{

	switch (::GetOrderTypeByTile(destination)) {

		case OT_GOTO_STATION:

					/* Test the different mutual exclusive flags. */

		case OT_GOTO_DEPOT:

		case OT_GOTO_WAYPOINT: return (order_flags & ~(AIOF_NON_STOP_FLAGS)) == 0;

		default:               return false;

	int num = 0;

	const Station *st;

	FOR_ALL_STATIONS(st) {

	}

	return max(0, 2 - num);

}

		const AirportFTAClass *afc = st->Airport();

		if (afc->nof_depots == 0 || (

					/* don't crash the plane if we know it can't land at the airport */

			continue;

		}

	FOR_VEHICLE_ORDERS(v, order) {

		const Station *st = Station::Get(order->station);

			/* If an airport doesn't have a hangar, skip it */

			if (st->Airport()->nof_depots != 0)

				return true;

		GetNewVehiclePosResult gp;

			/* move vehicle one pixel towards target */

			gp.x = (v->x_pos != (x + amd->x)) ?

					v->x_pos + ((x + amd->x > v->x_pos) ? 1 : -1) :

	/* FIXME -- MaybeCrashAirplane -> increase crashing chances of very modern airplanes on smaller than AT_METROPOLITAN airports */

	uint16 prob = 0x10000 / 1500;

			!_cheats.no_jetcrash.value) {

		prob = 0x10000 / 20;

	}

	Station *st = Station::Get(v->targetairport);

	/* runway busy or not allowed to use this airstation, circle */

			st->airport_tile != INVALID_TILE &&

			(st->owner == OWNER_NONE || st->owner == v->owner)) {

		/* {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41},

	for (Vehicle *v = front_v; v != NULL; v = v->Next()) {

		/* No cargo to unload */

		/* All cargo has already been paid for, no need to pay again */

		if (!v->cargo.UnpaidCargo()) {

			 * they were loaded, but to not force unload the vehicle when the

			 * station is still accepting the cargo in the vehicle. It doesn't

			 * accept cargo that was loaded at the same station. */

				remaining = v->cargo.MoveTo(&ge->cargo, amount_unloaded);

				SetBit(ge->acceptance_pickup, GoodsEntry::PICKUP);

		Engine *e;

		FOR_ALL_ENGINES(e) {

			/* Age the vehicle */

				e->age++;

				CalcEngineReliability(e);

			}

		Slope t = ComplementSlope(current);

	}

	return false;

		if (ind == NULL) return CMD_ERROR;

	}

		SetDParam(0, indspec->name);

		if (indspec->new_industry_text > STR_LAST_STRINGID) {

			SetDParam(1, STR_TOWN);

	const IndustrySpec *indspec = GetIndustrySpec(type);

	/* oil wells (or the industries with that flag set) are always allowed to closedown */

	return (indspec->behaviour & INDUSTRYBEH_CANCLOSE_LASTINSTANCE) == 0 && GetIndustryTypeCount(type) <= 1;

}

		}

	}

		if ( (byte)(_cur_year - i->last_prod_year) >= 5 && Chance16(1, smooth_economy ? 180 : 2)) {

			closeit = true;

		}

			strecpy(r.ifr_name, req->ifr_name, lastof(r.ifr_name));

			if (ioctl(sock, SIOCGIFFLAGS, &r) != -1 &&

					ioctl(sock, SIOCGIFBRDADDR, &r) != -1) {

				NetworkAddress addr(&r.ifr_broadaddr, sizeof(sockaddr));

				if (!broadcast->Contains(addr)) *broadcast->Append() = addr;

	}

	/* When the client was PRE_ACTIVE, the server was in pause mode, so unpause */

		DoCommandP(0, PM_PAUSED_JOIN, 0, CMD_PAUSE);

		NetworkServerSendChat(NETWORK_ACTION_SERVER_MESSAGE, DESTTYPE_BROADCAST, 0, "", CLIENT_ID_SERVER, NETWORK_SERVER_MESSAGE_GAME_UNPAUSED_CONNECT_FAIL);

	}

		/* The default colour for a message is company colour. Replace this with

		 * white for any additional lines */

		cmsg->end_date = _date + duration;

		bufp += strlen(bufp) + 1; // jump to 'next line' in the formatted string

	}

		SEND_COMMAND(PACKET_SERVER_ERROR)(cs, NETWORK_ERROR_KICKED);

		return;

	}

			InvalidateVehicleOrder(u, 0);

			/* If the vehicle already got the current depot set as current order, then update current order as well */

				u->current_order.SetRefit(cargo, subtype);

			}

		}

	if (v->vehstatus & VS_CRASHED) return;

	/* Do nothing for stopped vehicles if setting is '1' */

		return;

	/* do nothing we we're not the first vehicle in a share-chain */

	}

	/* Let's see if we may build this */

		/* If we are not allowed to overlap (flag is on for ai companies or we have

		 * signals on the tile), check that */

		return future == TRACK_BIT_HORZ || future == TRACK_BIT_VERT;

	/* Get a bitmask of which neighbouring roads has a tile */

	RoadBits n = ROAD_NONE;

	RoadBits present = GetAnyRoadBits(tile, rt);

	int rating_decrease = RATING_ROAD_DOWN_STEP_EDGE;

	/* If 0 or 1 bits are set in n, or if no bits that match the bits to remove,

							if (!EnsureNoVehicleOnGround(tile)) return CMD_ERROR;

							/* Ignore half built tiles */

								SetDisallowedRoadDirections(tile, GetDisallowedRoadDirections(tile) ^ toggle_drd);

								MarkTileDirtyByTile(tile);

							}

	RoadVehicle *v = RoadVehicle::GetIfValid(p1);

	if (v == NULL || !CheckOwnership(v->owner)) return CMD_ERROR;

			v->breakdown_ctr != 0 ||

			v->overtaking != 0 ||

			v->state == RVSB_WORMHOLE ||

	od.tile = v->tile + TileOffsByDiagDir(DirToDiagDir(v->direction));

	if (CheckRoadBlockedForOvertaking(&od)) return;

		v->overtaking_ctr = 0x11;

		v->overtaking = 0x10;

	} else {

					 * pretend we are heading for the tile in front, we'll

					 * see from there */

					desttile += TileOffsByDiagDir(dir);

						/* If we are already in front of the

						 * station/depot and we can get in from here,

						 * we enter */

	byte *base_ptr = (byte*)base;

	for (const OldChunks *chunk = chunks; chunk->type != OC_END; chunk++) {

			/* TTD(P)-only chunk, but TTO savegame || TTO-only chunk, but TTD/TTDP savegame */

			continue;

		}

		 * skip those */

		if (IsNormalAircraft(a)) {

			/* airplane in terminal stopped doesn't hurt anyone, so goto next */

				a->state = HANGAR;

				continue;

			}

				}

				for (DiagDirection dir = DIAGDIR_BEGIN; dir < DIAGDIR_END; dir++) { // test all possible exit directions

						TileIndex newtile = tile + TileOffsByDiagDir(dir);  // new tile to check

						DiagDirection newdir = ReverseDiagDir(dir); // direction we are entering from

						if (!MaybeAddToTodoSet(newtile, newdir, tile, dir)) return flags | SF_FULL;

			/* is it a bidir combo? - then do not count its other signal direction as exit */

			if (sig == SIGTYPE_COMBO && HasSignalOnTrackdir(tile, ReverseTrackdir(trackdir))) {

				/* at least one more exit */

						/* no green exit */

						(!(flags & SF_GREEN) ||

						/* only one green exit, and it is this one - so all other exits are red */

					newstate = SIGNAL_STATE_RED;

				}

			} else { // entry, at least one exit, no green exit

			}

		}

			/* SIGSEG_FREE is set by default */

			if (flags & SF_PBS) {

				state = SIGSEG_PBS;

				state = SIGSEG_FULL;

			}

		}

	Point pt = RemapCoords2(TileX(st->xy) * TILE_SIZE, TileY(st->xy) * TILE_SIZE);

	pt.y -= 32;

	SetDParam(0, st->index);

	SetDParam(1, st->facilities);

		uint num = 0;

		const Station *st;

		FOR_ALL_STATIONS(st) {

		}

		if (num >= 2) {

			authority_refuse_message = STR_ERROR_LOCAL_AUTHORITY_REFUSES_AIRPORT;

	_current_company = OWNER_TOWN;

			HasBit(t->flags12, TOWN_IS_FUNDED) &&

			CanDeleteHouse(tile) &&

			GetHouseAge(tile) >= hs->minimum_life &&

			}

			/* 3. If it is still a valid train after selling, update its acceleration and cached values */

				NormaliseTrainConsist(first);

				TrainConsistChanged(first, false);

				UpdateTrainGroupID(first);

static Vehicle *TrainApproachingCrossingEnum(Vehicle *v, void *data)

{

	/* not a train || not front engine || crashed */

	TileIndex tile = *(TileIndex*)data;

		}

	} else {

		/* turn the whole train around */

		if (flags & DC_EXEC) {

			/* Properly leave the station if we are loading and won't be loading anymore */

{

	bool sound = false;

		return;

	}

	if (_settings_game.pf.path_backoff_interval == 255) return;

	/* Exit if we reached our destination depot or are inside a depot. */

	/* Exit if we are on a station tile and are going to stop. */

	if (IsRailwayStationTile(v->tile) && v->current_order.ShouldStopAtStation(v, GetStationIndex(v->tile))) return;

	/* Exit if the current order doesn't have a destination, but the train has orders. */

{

	uint accel;

		switch (_settings_game.vehicle.train_acceleration_model) {

			default: NOT_REACHED();

			case TAM_ORIGINAL:  accel = v->acceleration * -4; break;

					assert(chosen_track & (bits | GetReservedTrackbits(gp.new_tile)));

					/* Check if it's a red signal and that force proceed is not clicked. */

						/* In front of a red signal */

						Trackdir i = FindFirstTrackdir(trackdirbits);

	}

	/* exit if train is stopped */

	bool valid_order = !v->current_order.IsType(OT_NOTHING) && v->current_order.GetType() != OT_CONDITIONAL;

	if (ProcessOrders(v) && CheckReverseTrain(v)) {

	int j = UpdateTrainSpeed(v);

	/* we need to invalidate the widget if we are stopping from 'Stopping 0 km/h' to 'Stopped' */

		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, VVW_WIDGET_START_STOP_VEH);

	}

		}

	}

		Track track = AxisToTrack(direction);

		AddSideToSignalBuffer(tile_start, INVALID_DIAGDIR, _current_company);

		YapfNotifyTrackLayoutChange(tile_start, track);

	}

	/* checks if you're allowed to remove unmovable things */

		return_cmd_error(flags & DC_AUTO ? STR_ERROR_OBJECT_IN_THE_WAY : INVALID_STRING_ID);

	if (IsStatue(tile)) {

	v->reliability = rel = max((rel_old = v->reliability) - v->reliability_spd_dec, 0);

	if ((rel_old >> 8) != (rel >> 8)) InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

			_settings_game.difficulty.vehicle_breakdowns < 1 ||

			v->cur_speed < 5 || _game_mode == GM_MENU) {

		return;

	switch (v->type) {

		case VEH_TRAIN:

			break;

		case VEH_SHIP:

		}

	} while (v->type == VEH_TRAIN && (v = GetNextVehicle((Train *)v)) != NULL);

		/* for trains this needs to be the front engine due to the callback function */

		_new_vehicle_id = w_front->index;

	}

			ClrBit(diff, button);

			if (HasBit(mouse_b, button)) {

				/* Pressed mouse button */

					button = RIGHT_BUTTON;

					ClrBit(diff, RIGHT_BUTTON);

				}

	if (mouse_action) HandleMouseEvents();

	poll_keyboard();

		ToggleFullScreen(!_fullscreen);

	} else if (keypressed()) {

		HandleKeypress(ConvertAllegroKeyIntoMy());

 */

int GetWidgetFromPos(const Window *w, int x, int y)

{

	int found_index = -1;

		const Widget *wi = &w->widget[index];

		if (wi->type == WWT_EMPTY || wi->type == WWT_FRAME) continue;

			}

		}

			/* When the resize widget is on the left size of the window

			 * we assume that that button is used to resize to the left. */

			StartWindowSizing(w, wi->left < (w->width / 2));

			return;

		}

			w->flags4 ^= WF_STICKY;

			w->InvalidateWidget(widget_index);

			return;

	}

	FOR_ALL_WINDOWS_FROM_FRONT(w) {

			w->OnTimeout();

			if (w->desc_flags & WDF_UNCLICK_BUTTONS) w->RaiseButtons();

		}

			/* Now find the new cursor pos.. this is NOT _cursor, because we move in steps. */

			_drag_delta.y += y;

				_drag_delta.x -= x; // x > 0 -> window gets longer -> left-edge moves to left -> subtract x to get new position.

				w->SetDirty();

				w->left -= x;  // If dragging left edge, move left window edge in opposite direction by the same amount.