count = _cargoc.ai_roadveh_count[p->ainew.cargo];

		// Let's check it backwards.. we simply want to best engine available..

			// Is it availiable?

			// Also, check if the reliability of the vehicle is above the AI_VEHICLE_MIN_RELIABILTY

			if (!HASBIT(GetEngine(i)->player_avail, _current_player) || GetEngine(i)->reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;

			if (!CmdFailed(ret)) break;

		}

		// We did not find a vehicle :(

		return i;

	}

}

		}

	}

}

/*

 *

 *

 *  -- TrueLight :: 2005-09-01

 */

	if (spd == 0) {

		img = SPR_ROTOR_STOPPED;

	} else if (tick >= spd) {

		u->tick_counter = 0;

		img = u->cur_image + 1;

		if (img > SPR_ROTOR_MOVING_3) img = SPR_ROTOR_MOVING_1;

		return;

	BeginVehicleMove(u);

	VehiclePositionChanged(u);

	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

}

{

	SndPlayVehicleFx(AircraftVehInfo(v->engine_type)->sfx, v);

}

{

	Station *st;

	uint16 prob;

	st = GetStation(v->u.air.targetairport);

	if (GB(Random(), 0, 16) > prob) return;

	// Crash the airplane. Remove all goods stored at the station.

		st->goods[i].rating = 1;

		SB(st->goods[i].waiting_acceptance, 0, 12, 0);

	}

		return;

	// if the block of the next position is busy, stay put

	// We are already at the target airport, we need to find a terminal

	if (v->current_order.station == v->u.air.targetairport) {

		// FindFreeTerminal:

		// 1. Find a free terminal, 2. Occupy it, 3. Set the vehicle's state to that terminal

		// airplane goto state takeoff, helicopter to helitakeoff

		v->u.air.state = (v->subtype != 0) ? TAKEOFF : HELITAKEOFF;

	}

static void AircraftEventHandler_EndLanding(Vehicle *v, const AirportFTAClass *Airport)

{

	// next block busy, don't do a thing, just wait

	// if going to terminal (OT_GOTO_STATION) choose one

	// 1. in case all terminals are busy AirportFindFreeTerminal() returns false or

	// 2. not going for terminal (but depot, no order),

	// --> get out of the way to the hangar.

	if (v->current_order.type == OT_GOTO_STATION) {

	}

	v->u.air.state = HANGAR;

static void AircraftEventHandler_HeliEndLanding(Vehicle *v, const AirportFTAClass *Airport)

{

	// next block busy, don't do a thing, just wait

	// if going to helipad (OT_GOTO_STATION) choose one. If airport doesn't have helipads, choose terminal

	// 1. in case all terminals/helipads are busy (AirportFindFreeHelipad() returns false) or

	// the reason behind this is that if an airport has a terminal, it also has a hangar. Airplanes

	// must go to a hangar.

	if (v->current_order.type == OT_GOTO_STATION) {

	}

	v->u.air.state = (Airport->terminals != NULL) ? HANGAR : HELITAKEOFF;

}

static void AirportGoToNextPosition(Vehicle *v, const AirportFTAClass *Airport)

{

	// if aircraft is not in position, wait until it is

	AirportClearBlock(v, Airport);

	AirportMove(v, Airport); // move aircraft to next position

	if (current->heading == v->u.air.state) {

		prev_pos = v->u.air.pos; // location could be changed in state, so save it before-hand

		_aircraft_state_handlers[v->u.air.state](v, Airport);

		return true;

	}

		//search for all all elements in the list with the same state, and blocks != N

		// this means more blocks should be checked/set

		current = current_pos;

		while (current != NULL) {

			if (current->heading == current_pos->heading && current->block != 0) {

				airport_flags |= current->block;

		// if the block to be checked is in the next position, then exclude that from

		// checking, because it has been set by the airplane before

		if (HASBITS(st->airport_flags, airport_flags)) {

			v->cur_speed = 0;

					//at what terminal does the group start?

					//that means, sum up all terminals of

					//groups with lower number

						group_start += Airport->terminals[i];

					group_end = group_start + Airport->terminals[target_group];

				}

			}

			temp = temp->next_in_chain;

		}

	}

  AirportFTA *temp;

	// if an airport doesn't have helipads, use terminals

	// if there are more helicoptergroups, pick one, just as in AirportFindFreeTerminal()

	if (Airport->helipads[0] > 1) {

						group_start += Airport->helipads[i];

					group_end = group_start + Airport->helipads[target_group];

				}

			}

			temp = temp->next_in_chain;

		}

	}

	return false;	// it shouldn't get here anytime, but just to be sure

}

	FOR_ALL_STATIONS(st) {

		st->airport_flags = 0; // reset airport

		// type of oilrig has been moved, update it (3-5)

	}

	FOR_ALL_VEHICLES(v_oldstyle) {

			v_oldstyle->tile = 0; // aircraft in air is tile=0

			// correct speed of helicopter-rotors

			// set new position x,y,z

			SetAircraftPosition(v_oldstyle, gp.x, gp.y, GetAircraftFlyingAltitude(v_oldstyle));

					GetNewVehiclePos(v, &gp);

					// set new position x,y,z

					SetAircraftPosition(v, gp.x, gp.y, GetAircraftFlyingAltitude(v));

					assert(v->u.air.state == ENDTAKEOFF || v->u.air.state == HELITAKEOFF);

					takeofftype = (v->subtype == 0) ? HELITAKEOFF : ENDTAKEOFF;

					// search in airportdata for that heading

			DrawVehicleProfitButton(v, x, y + 13);

			SetDParam(0, v->unitnumber);

				str = STR_021F;

				str = v->age > v->max_age - 366 ? STR_00E3 : STR_00E2;

			DrawString(x, y + 2, str, 0);

			SetDParam(0, v->profit_this_year);

		case 7: { /* Matrix to show vehicles */

			uint32 id_v = (e->click.pt.y - PLY_WND_PRC__OFFSET_TOP_WIDGET) / PLY_WND_PRC__SIZE_OF_ROW_BIG;

			id_v += w->vscroll.pos;

	// build the state machine

	AirportBuildAutomata(Airport, FA);

	{

	}

	// print out full information

	// true  -- full info including heading, block, etc

	int i;

	uint16 nofelements = 0;

	int temp = FA[0].position;

	for (i = 0; i < MAX_ELEMENTS; i++) {

		if (temp != FA[i].position) {

			nofelements++;

			temp = FA[i].position;

		}

	}

	return nofelements;

}

	AirportFTA *FAutomata;

	AirportFTA *current;

	uint16 internalcounter, i;

	Airport->layout = FAutomata;

	internalcounter = 0;

		current->next_position = FA[internalcounter].next_in_chain;

		// outgoing nodes from the same position, create linked list

			// create link

			current->next_in_chain = newNode;

			current = current->next_in_chain;

	for (i = 0; i < Airport->nofelements; i++) {

		position = Airport->layout[i].position;

		temp = &Airport->layout[i];

		do {

			temp = temp->next_in_chain;

		} while (temp != NULL);

		next_element++;

	return MAX_ELEMENTS;

}

	"TO_ALL",

	"HANGAR",

	"TERM1",

	"DUMMY"	// extra heading for 255

};

static void AirportPrintOut(const AirportFTAClass *Airport, const bool full_report)

{

	AirportFTA *temp;

			heading = (temp->heading == 255) ? MAX_HEADINGS+1 : temp->heading;

			printf("Pos:%2d NPos:%2d Heading:%15s Block:%2d\n", temp->position, temp->next_position,

						 _airport_heading_strings[heading], AirportBlockToString(temp->block));

		}

		while (temp->next_in_chain != NULL) {

			temp = temp->next_in_chain;

			if (full_report) {

				heading = (temp->heading == 255) ? MAX_HEADINGS+1 : temp->heading;

				printf("Pos:%2d NPos:%2d Heading:%15s Block:%2d\n", temp->position, temp->next_position,

							_airport_heading_strings[heading], AirportBlockToString(temp->block));

			}

		}

		printf("\n");

	}

	if (block & 0x0000000c) { block >>= 2;  i += 2; }

	if (block & 0x00000002) { i += 1; }

	return i;

const AirportFTAClass* GetAirport(const byte airport_type)

{

		if (e->click.widget - 3 >= 0 && e->click.widget != 5) _build_docks_button_proc[e->click.widget - 3](w);

		break;

			case '1': BuildDocksClick_Canal(w); break;

			case '2': BuildDocksClick_Lock(w); break;

			case '3': BuildDocksClick_Demolish(w); break;

			case '5': BuildDocksClick_Dock(w); break;

			case '6': BuildDocksClick_Buoy(w); break;

			case 'l': BuildDocksClick_Landscaping(w); break;

		}

	case WE_PLACE_OBJ:

		_place_proc(e->place.tile);

		if (e->click.pt.x != -1) {

			if ((e->place.userdata & 0xF) == VPM_X_AND_Y) { // dragged actions

				GUIPlaceProcDragXY(e);

				DoCommandP(e->place.tile, e->place.starttile, 0, CcBuildCanal, CMD_BUILD_CANAL | CMD_AUTO | CMD_MSG(STR_CANT_BUILD_CANALS));

		}

		break;

		SetWindowDirty(w);

		w = FindWindowById(WC_BUILD_STATION, 0);

		w = FindWindowById(WC_BUILD_DEPOT, 0);

		break;

	case WE_PLACE_PRESIZE: {

static void BuildDocksDepotWndProc(Window *w, WindowEvent *e)

{

	case WE_PAINT:

		w->click_state = (1<<3) << _ship_depot_direction;

		DrawWindowWidgets(w);

		return;

	case WE_CLICK: {

		case 3:

		case 4:

			_ship_depot_direction = e->click.widget - 3;

static void DrawTrainEngineInfo(EngineID engine, int x, int y, int maxw)

{

	const RailVehicleInfo *rvi = RailVehInfo(engine);

	uint multihead = (rvi->flags & RVI_MULTIHEAD) ? 1 : 0;

	SetDParam(0, (_price.build_railvehicle >> 3) * rvi->base_cost >> 5);

	SetDParam(4, rvi->running_cost_base * _price.running_rail[rvi->engclass] >> 8 << multihead);

		SetDParam(5, _cargoc.names_long[rvi->cargo_type]);

	}

	DrawStringMultiCenter(x, y, STR_885B_COST_WEIGHT_T_SPEED_POWER, maxw);

}

void ShowPlayerTrains(PlayerID player, StationID station);

void ShowTrainViewWindow(Vehicle *v);

void ShowTrainDetailsWindow(Vehicle *v);

void ShowRoadVehViewWindow(Vehicle *v);

void ShowErrorMessage(StringID msg_1, StringID msg_2, int x, int y);

void DrawStationCoverageAreaText(int sx, int sy, uint mask,int rad);

void ShowSmallMap(void);

void ShowExtraViewPortWindow(void);

static void MaybePlantFarmField(const Industry* i)

{

	}

}

static bool CheckNewIndustry_BubbleGen(TileIndex tile, int type)

{

}

typedef bool CheckNewIndustryProc(TileIndex tile, int type);

	}

	/* Check if we can add a block to the pool */

}

static void DoCreateNewIndustry(Industry *i, TileIndex tile, int type, const IndustryTileTable *it, Town *t, byte owner)

static void ToolbarPauseClick(Window *w)

{

	if (DoCommandP(0, _pause ? 0 : 1, 0, NULL, CMD_PAUSE))

		SndPlayFx(SND_15_BEEP);

		// update the toolbar button too

		CLRBIT(wt->disabled_state, button);

		CLRBIT(wt->disabled_state, button + 1);

		SetWindowDirty(wt);

	}

	}

}

{

		SetWindowDirty(w);

	}

}

	int i = 0;

	w->click_state ^= x;

	do {

}

void UnclickWindowButtons(Window *w)

{

	bool sticky = false;

	UnclickSomeWindowButtons(w, (uint32)-1);

{

	_fios_path_changed = true;

	FiosFreeSavegameList();

}

static void DrawFiosTexts(uint maxw)

			item = _fios_list + pos;

			DoDrawStringTruncated(item->title, 4, y, _fios_colors[item->type], w->width - 18);

			pos++;

		}

		if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) {

		pos = w->vscroll.pos;

		while (pos < _fios_num) {

			item = _fios_list + pos;

			pos++;

		}

	}

		break;

				file = _fios_list + y;