Changeset - r6087:a13ab75a089f
Parent rev.
Child rev.
[Not reviewed]
master
0 5 0
tron - 18 years ago 2007-02-20 06:39:09
tron@openttd.org
(svn r8822) -Fix

Variable scope, const
5 files changed with 117 insertions and 201 deletions:
src/aircraft.h
3
1
src/aircraft_cmd.cpp
106
184
src/airport.cpp
6
12
src/build_vehicle_gui.cpp
1
1
src/station_cmd.cpp
1
3
0 comments (0 inline, 0 general)
src/aircraft.h
➞
Show inline comments
 
@@ -40,11 +40,13 @@ static inline bool IsAircraftInHangarSto
 
	return IsAircraftInHangar(v) && v->vehstatus & VS_STOPPED;
 
}
 

			




	
	
	
		
 
uint16 AircraftDefaultCargoCapacity(CargoID cid, EngineID engine_type);

			




	
	
	
		
 
uint16 AircraftDefaultCargoCapacity(CargoID cid, const AircraftVehicleInfo*);

			




	
	
	
		
 

			




	
	
	
		
 
void CcBuildAircraft(bool success, TileIndex tile, uint32 p1, uint32 p2);

			




	
	
	
		
 
void CcCloneAircraft(bool success, TileIndex tile, uint32 p1, uint32 p2);

			




	
	
	
		
 
void HandleAircraftEnterHangar(Vehicle *v);

			




	
	
	
		
 
void GetAircraftSpriteSize(EngineID engine, uint &width, uint &height);

			




	
	
	
		
 

			




	
	
	
		
 
void UpdateAirplanesOnNewStation(const Station *st);

			




	
	
	
		
 

			




	
	
	
		
 
#endif /* AIRCRAFT_H */

			




        

    


    
    

    

        

                

                    src/aircraft_cmd.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -34,7 +34,7 @@ static const byte _airport_terminal_stat

			




	
	
	
		
 
static const byte _airport_terminal_flag[] =  {0, 1, 2, 3, 4, 5, 22, 23, 0, 0, 6, 7, 24, 25};

			




	
	
	
		
 

			




	
	
	
		
 
static bool AirportMove(Vehicle *v, const AirportFTAClass *apc);

			




	
	
	
		
 
static bool AirportSetBlocks(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *apc);

			




	
	
	
		
 
static bool AirportSetBlocks(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc);

			




	
	
	
		
 
static bool AirportHasBlock(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc);

			




	
	
	
		
 
static bool AirportFindFreeTerminal(Vehicle *v, const AirportFTAClass *apc);

			




	
	
	
		
 
static bool AirportFindFreeHelipad(Vehicle *v, const AirportFTAClass *apc);

			




	
	
		
 
@@ -130,11 +130,9 @@ int GetAircraftImage(const Vehicle* v, D

			




	
	
	
		
 

			




	
	
	
		
 
SpriteID GetRotorImage(const Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	const Vehicle *w;

			




	
	
	
		
 

			




	
	
	
		
 
	assert(v->subtype == AIR_HELICOPTER);

			




	
	
	
		
 

			




	
	
	
		
 
	w = v->next->next;

			




	
	
	
		
 
	const Vehicle *w = v->next->next;

			




	
	
	
		
 
	if (is_custom_sprite(v->spritenum)) {

			




	
	
	
		
 
		SpriteID spritenum = GetCustomRotorSprite(v, false);

			




	
	
	
		
 
		if (spritenum != 0) return spritenum;

			




	
	
		
 
@@ -205,10 +203,8 @@ static int32 EstimateAircraftCost(const 

			




	
	
	
		
 
 * @param engine Which engine to find a cargo capacity for.

			




	
	
	
		
 
 * @return New cargo capacity value.

			




	
	
	
		
 
 */

			




	
	
	
		
 
uint16 AircraftDefaultCargoCapacity(CargoID cid, EngineID engine_type)

			




	
	
	
		
 
uint16 AircraftDefaultCargoCapacity(CargoID cid, const AircraftVehicleInfo *avi)

			




	
	
	
		
 
{

			




	
	
	
		
 
	const AircraftVehicleInfo *avi = AircraftVehInfo(engine_type);

			




	
	
	
		
 

			




	
	
	
		
 
	assert(cid != CT_INVALID);

			




	
	
	
		
 

			




	
	
	
		
 
	/* An aircraft can carry twice as much goods as normal cargo,

			




	
	
		
 
@@ -233,9 +229,6 @@ uint16 AircraftDefaultCargoCapacity(Carg

			




	
	
	
		
 
 */

			




	
	
	
		
 
int32 CmdBuildAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *vl[3];

			




	
	
	
		
 
	UnitID unit_num;

			




	
	
	
		
 

			




	
	
	
		
 
	if (!IsEngineBuildable(p1, VEH_Aircraft, _current_player)) return_cmd_error(STR_ENGINE_NOT_BUILDABLE);

			




	
	
	
		
 

			




	
	
	
		
 
	const AircraftVehicleInfo *avi = AircraftVehInfo(p1);

			




	
	
		
 
@@ -257,19 +250,16 @@ int32 CmdBuildAircraft(TileIndex tile, u

			




	
	
	
		
 

			




	
	
	
		
 
	/* Allocate 2 or 3 vehicle structs, depending on type

			




	
	
	
		
 
	 * vl[0] = aircraft, vl[1] = shadow, [vl[2] = rotor] */

			




	
	
	
		
 
	Vehicle *vl[3];

			




	
	
	
		
 
	if (!AllocateVehicles(vl, avi->subtype & AIR_CTOL ? 2 : 3)) {

			




	
	
	
		
 
		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_Aircraft);

			




	
	
	
		
 
	UnitID unit_num = HASBIT(p2, 0) ? 0 : GetFreeUnitNumber(VEH_Aircraft);

			




	
	
	
		
 
	if (unit_num > _patches.max_aircraft)

			




	
	
	
		
 
		return_cmd_error(STR_00E1_TOO_MANY_VEHICLES_IN_GAME);

			




	
	
	
		
 

			




	
	
	
		
 
	if (flags & DC_EXEC) {

			




	
	
	
		
 
		CargoID cargo;

			




	
	
	
		
 
		uint x;

			




	
	
	
		
 
		uint y;

			




	
	
	
		
 

			




	
	
	
		
 
		Vehicle *v = vl[0]; // aircraft

			




	
	
	
		
 
		Vehicle *u = vl[1]; // shadow

			




	
	
	
		
 

			




	
	
		
 
@@ -282,8 +272,8 @@ int32 CmdBuildAircraft(TileIndex tile, u

			




	
	
	
		
 
		v->tile = tile;

			




	
	
	
		
 
//		u->tile = 0;

			




	
	
	
		
 

			




	
	
	
		
 
		x = TileX(tile) * TILE_SIZE + 5;

			




	
	
	
		
 
		y = TileY(tile) * TILE_SIZE + 3;

			




	
	
	
		
 
		uint x = TileX(tile) * TILE_SIZE + 5;

			




	
	
	
		
 
		uint y = TileY(tile) * TILE_SIZE + 3;

			




	
	
	
		
 

			




	
	
	
		
 
		v->x_pos = u->x_pos = x;

			




	
	
	
		
 
		v->y_pos = u->y_pos = y;

			




	
	
		
 
@@ -336,7 +326,7 @@ int32 CmdBuildAircraft(TileIndex tile, u

			




	
	
	
		
 
		 * passengers, we select the cargo type from the refit mask.

			




	
	
	
		
 
		 * This is a fairly nasty hack to get around the fact that TTD

			




	
	
	
		
 
		 * has no default cargo type specifier for planes... */

			




	
	
	
		
 
		cargo = FindFirstRefittableCargo(p1);

			




	
	
	
		
 
		CargoID cargo = FindFirstRefittableCargo(p1);

			




	
	
	
		
 
		if (cargo != CT_INVALID && cargo != CT_PASSENGERS) {

			




	
	
	
		
 
			uint16 callback = CALLBACK_FAILED;

			




	
	
	
		
 

			




	
	
		
 
@@ -348,7 +338,7 @@ int32 CmdBuildAircraft(TileIndex tile, u

			




	
	
	
		
 

			




	
	
	
		
 
			if (callback == CALLBACK_FAILED) {

			




	
	
	
		
 
				/* Callback failed, or not executed; use the default cargo capacity */

			




	
	
	
		
 
				v->cargo_cap = AircraftDefaultCargoCapacity(v->cargo_type, v->engine_type);

			




	
	
	
		
 
				v->cargo_cap = AircraftDefaultCargoCapacity(v->cargo_type, avi);

			




	
	
	
		
 
			} else {

			




	
	
	
		
 
				v->cargo_cap = callback;

			




	
	
	
		
 
			}

			




	
	
		
 
@@ -450,11 +440,9 @@ static void DoDeleteAircraft(Vehicle *v)

			




	
	
	
		
 
 */

			




	
	
	
		
 
int32 CmdSellAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *v;

			




	
	
	
		
 

			




	
	
	
		
 
	if (!IsValidVehicleID(p1)) return CMD_ERROR;

			




	
	
	
		
 

			




	
	
	
		
 
	v = GetVehicle(p1);

			




	
	
	
		
 
	Vehicle *v = GetVehicle(p1);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!IsAircraftInHangarStopped(v)) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED);

			




	
	
		
 
@@ -477,12 +465,9 @@ int32 CmdSellAircraft(TileIndex tile, ui

			




	
	
	
		
 
 */

			




	
	
	
		
 
int32 CmdStartStopAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *v;

			




	
	
	
		
 
	uint16 callback;

			




	
	
	
		
 

			




	
	
	
		
 
	if (!IsValidVehicleID(p1)) return CMD_ERROR;

			




	
	
	
		
 

			




	
	
	
		
 
	v = GetVehicle(p1);

			




	
	
	
		
 
	Vehicle *v = GetVehicle(p1);

			




	
	
	
		
 

			




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

			




	
	
	
		
 

			




	
	
		
 
@@ -492,7 +477,7 @@ int32 CmdStartStopAircraft(TileIndex til

			




	
	
	
		
 

			




	
	
	
		
 
	/* Check if this aircraft can be started/stopped. The callback will fail or

			




	
	
	
		
 
	 * return 0xFF if it can. */

			




	
	
	
		
 
	callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v);

			




	
	
	
		
 
	uint16 callback = GetVehicleCallback(CBID_VEHICLE_START_STOP_CHECK, 0, 0, v->engine_type, v);

			




	
	
	
		
 
	if (callback != CALLBACK_FAILED && callback != 0xFF) {

			




	
	
	
		
 
		StringID error = GetGRFStringID(GetEngineGRFID(v->engine_type), 0xD000 + callback);

			




	
	
	
		
 
		return_cmd_error(error);

			




	
	
		
 
@@ -521,8 +506,6 @@ int32 CmdStartStopAircraft(TileIndex til

			




	
	
	
		
 
 */

			




	
	
	
		
 
int32 CmdSendAircraftToHangar(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *v;

			




	
	
	
		
 

			




	
	
	
		
 
	if (p2 & DEPOT_MASS_SEND) {

			




	
	
	
		
 
		/* Mass goto depot requested */

			




	
	
	
		
 
		if (!ValidVLWFlags(p2 & VLW_MASK)) return CMD_ERROR;

			




	
	
		
 
@@ -531,7 +514,7 @@ int32 CmdSendAircraftToHangar(TileIndex 

			




	
	
	
		
 

			




	
	
	
		
 
	if (!IsValidVehicleID(p1)) return CMD_ERROR;

			




	
	
	
		
 

			




	
	
	
		
 
	v = GetVehicle(p1);

			




	
	
	
		
 
	Vehicle *v = GetVehicle(p1);

			




	
	
	
		
 

			




	
	
	
		
 
	if (v->type != VEH_Aircraft || !CheckOwnership(v->owner) || IsAircraftInHangar(v)) return CMD_ERROR;

			




	
	
	
		
 

			




	
	
		
 
@@ -560,16 +543,13 @@ int32 CmdSendAircraftToHangar(TileIndex 

			




	
	
	
		
 
		const Station *st = GetStation(next_airport_index);

			




	
	
	
		
 
		/* If the station is not a valid airport or if it has no hangars */

			




	
	
	
		
 
		if (!st->IsValid() || st->airport_tile == 0 || st->Airport()->nof_depots == 0) {

			




	
	
	
		
 
			StationID station;

			




	
	
	
		
 

			




	
	
	
		
 
			// the aircraft has to search for a hangar on its own

			




	
	
	
		
 
			station = FindNearestHangar(v);

			




	
	
	
		
 
			StationID station = FindNearestHangar(v);

			




	
	
	
		
 

			




	
	
	
		
 
			next_airport_has_hangar = false;

			




	
	
	
		
 
			if (station == INVALID_STATION) return CMD_ERROR;

			




	
	
	
		
 
			st = GetStation(station);

			




	
	
	
		
 
			next_airport_index = station;

			




	
	
	
		
 

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		if (flags & DC_EXEC) {

			




	
	
		
 
@@ -599,29 +579,23 @@ int32 CmdSendAircraftToHangar(TileIndex 

			




	
	
	
		
 
 */

			




	
	
	
		
 
int32 CmdRefitAircraft(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *v;

			




	
	
	
		
 
	int pass, mail;

			




	
	
	
		
 
	int32 cost;

			




	
	
	
		
 
	CargoID new_cid = GB(p2, 0, 8);

			




	
	
	
		
 
	byte new_subtype = GB(p2, 8, 8);

			




	
	
	
		
 
	const AircraftVehicleInfo *avi;

			




	
	
	
		
 
	uint16 callback = CALLBACK_FAILED;

			




	
	
	
		
 

			




	
	
	
		
 
	if (!IsValidVehicleID(p1)) return CMD_ERROR;

			




	
	
	
		
 

			




	
	
	
		
 
	v = GetVehicle(p1);

			




	
	
	
		
 
	Vehicle *v = GetVehicle(p1);

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	if (!IsAircraftInHangarStopped(v)) return_cmd_error(STR_A01B_AIRCRAFT_MUST_BE_STOPPED);

			




	
	
	
		
 

			




	
	
	
		
 
	avi = AircraftVehInfo(v->engine_type);

			




	
	
	
		
 

			




	
	
	
		
 
	/* Check cargo */

			




	
	
	
		
 
	CargoID new_cid = GB(p2, 0, 8);

			




	
	
	
		
 
	if (new_cid > NUM_CARGO || !CanRefitTo(v->engine_type, new_cid)) return CMD_ERROR;

			




	
	
	
		
 

			




	
	
	
		
 
	SET_EXPENSES_TYPE(EXPENSES_AIRCRAFT_RUN);

			




	
	
	
		
 

			




	
	
	
		
 
	/* Check the refit capacity callback */

			




	
	
	
		
 
	uint16 callback = CALLBACK_FAILED;

			




	
	
	
		
 
	if (HASBIT(EngInfo(v->engine_type)->callbackmask, CBM_REFIT_CAPACITY)) {

			




	
	
	
		
 
		/* Back up the existing cargo type */

			




	
	
	
		
 
		CargoID temp_cid = v->cargo_type;

			




	
	
		
 
@@ -636,26 +610,28 @@ int32 CmdRefitAircraft(TileIndex tile, u

			




	
	
	
		
 
		v->cargo_subtype = temp_subtype;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	const AircraftVehicleInfo *avi = AircraftVehInfo(v->engine_type);

			




	
	
	
		
 

			




	
	
	
		
 
	uint pass;

			




	
	
	
		
 
	if (callback == CALLBACK_FAILED) {

			




	
	
	
		
 
		/* If the callback failed, or wasn't executed, use the aircraft's

			




	
	
	
		
 
		 * default cargo capacity */

			




	
	
	
		
 
		pass = AircraftDefaultCargoCapacity(new_cid, v->engine_type);

			




	
	
	
		
 
		pass = AircraftDefaultCargoCapacity(new_cid, avi);

			




	
	
	
		
 
	} else {

			




	
	
	
		
 
		pass = callback;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	_returned_refit_capacity = pass;

			




	
	
	
		
 

			




	
	
	
		
 
	cost = 0;

			




	
	
	
		
 
	int32 cost = 0;

			




	
	
	
		
 
	if (IsHumanPlayer(v->owner) && new_cid != v->cargo_type) {

			




	
	
	
		
 
		cost = GetRefitCost(v->engine_type);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (flags & DC_EXEC) {

			




	
	
	
		
 
		Vehicle *u;

			




	
	
	
		
 
		v->cargo_cap = pass;

			




	
	
	
		
 

			




	
	
	
		
 
		u = v->next;

			




	
	
	
		
 
		mail = (new_cid != CT_PASSENGERS) ? 0 : avi->mail_capacity;

			




	
	
	
		
 
		Vehicle *u = v->next;

			




	
	
	
		
 
		uint mail = new_cid != CT_PASSENGERS ? 0 : avi->mail_capacity;

			




	
	
	
		
 
		u->cargo_cap = mail;

			




	
	
	
		
 
		if (v->cargo_type == new_cid) {

			




	
	
	
		
 
			v->cargo_count = min(pass, v->cargo_count);

			




	
	
		
 
@@ -677,8 +653,6 @@ int32 CmdRefitAircraft(TileIndex tile, u

			




	
	
	
		
 

			




	
	
	
		
 
static void CheckIfAircraftNeedsService(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	const Station* st;

			




	
	
	
		
 

			




	
	
	
		
 
	if (_patches.servint_aircraft == 0) return;

			




	
	
	
		
 
	if (!VehicleNeedsService(v)) return;

			




	
	
	
		
 
	if (v->vehstatus & VS_STOPPED) return;

			




	
	
		
 
@@ -694,7 +668,7 @@ static void CheckIfAircraftNeedsService(

			




	
	
	
		
 
		return;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	st = GetStation(v->current_order.dest);

			




	
	
	
		
 
	const Station *st = GetStation(v->current_order.dest);

			




	
	
	
		
 
	// only goto depot if the target airport has terminals (eg. it is airport)

			




	
	
	
		
 
	if (st->IsValid() && st->airport_tile != 0 && st->Airport()->terminals != NULL) {

			




	
	
	
		
 
//		printf("targetairport = %d, st->index = %d\n", v->u.air.targetairport, st->index);

			




	
	
		
 
@@ -711,8 +685,6 @@ static void CheckIfAircraftNeedsService(

			




	
	
	
		
 

			




	
	
	
		
 
void OnNewDay_Aircraft(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	int32 cost;

			




	
	
	
		
 

			




	
	
	
		
 
	if (!IsNormalAircraft(v)) return;

			




	
	
	
		
 

			




	
	
	
		
 
	if ((++v->day_counter & 7) == 0) DecreaseVehicleValue(v);

			




	
	
		
 
@@ -725,7 +697,7 @@ void OnNewDay_Aircraft(Vehicle *v)

			




	
	
	
		
 

			




	
	
	
		
 
	if (v->vehstatus & VS_STOPPED) return;

			




	
	
	
		
 

			




	
	
	
		
 
	cost = AircraftVehInfo(v->engine_type)->running_cost * _price.aircraft_running / 364;

			




	
	
	
		
 
	int32 cost = AircraftVehInfo(v->engine_type)->running_cost * _price.aircraft_running / 364;

			




	
	
	
		
 

			




	
	
	
		
 
	v->profit_this_year -= cost >> 8;

			




	
	
	
		
 

			




	
	
		
 
@@ -761,11 +733,7 @@ static void AgeAircraftCargo(Vehicle *v)

			




	
	
	
		
 

			




	
	
	
		
 
static void HelicopterTickHandler(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *u;

			




	
	
	
		
 
	int tick,spd;

			




	
	
	
		
 
	SpriteID img;

			




	
	
	
		
 

			




	
	
	
		
 
	u = v->next->next;

			




	
	
	
		
 
	Vehicle *u = v->next->next;

			




	
	
	
		
 

			




	
	
	
		
 
	if (u->vehstatus & VS_HIDDEN) return;

			




	
	
	
		
 

			




	
	
		
 
@@ -786,9 +754,10 @@ static void HelicopterTickHandler(Vehicl

			




	
	
	
		
 
			u->cur_speed--;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	tick = ++u->tick_counter;

			




	
	
	
		
 
	spd = u->cur_speed >> 4;

			




	
	
	
		
 
	int tick = ++u->tick_counter;

			




	
	
	
		
 
	int spd = u->cur_speed >> 4;

			




	
	
	
		
 

			




	
	
	
		
 
	SpriteID img;

			




	
	
	
		
 
	if (spd == 0) {

			




	
	
	
		
 
		u->u.air.state = HRS_ROTOR_STOPPED;

			




	
	
	
		
 
		img = GetRotorImage(v);

			




	
	
		
 
@@ -811,10 +780,6 @@ static void HelicopterTickHandler(Vehicl

			




	
	
	
		
 

			




	
	
	
		
 
static void SetAircraftPosition(Vehicle *v, int x, int y, int z)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *u;

			




	
	
	
		
 
	int safe_x;

			




	
	
	
		
 
	int safe_y;

			




	
	
	
		
 

			




	
	
	
		
 
	v->x_pos = x;

			




	
	
	
		
 
	v->y_pos = y;

			




	
	
	
		
 
	v->z_pos = z;

			




	
	
		
 
@@ -826,10 +791,10 @@ static void SetAircraftPosition(Vehicle 

			




	
	
	
		
 
	VehiclePositionChanged(v);

			




	
	
	
		
 
	EndVehicleMove(v);

			




	
	
	
		
 

			




	
	
	
		
 
	u = v->next;

			




	
	
	
		
 
	Vehicle *u = v->next;

			




	
	
	
		
 

			




	
	
	
		
 
	safe_x = clamp(x, 0, MapMaxX() * TILE_SIZE);

			




	
	
	
		
 
	safe_y = clamp(y - 1, 0, MapMaxY() * TILE_SIZE);

			




	
	
	
		
 
	int safe_x = clamp(x, 0, MapMaxX() * TILE_SIZE);

			




	
	
	
		
 
	int safe_y = clamp(y - 1, 0, MapMaxY() * TILE_SIZE);

			




	
	
	
		
 
	u->x_pos = x;

			




	
	
	
		
 
	u->y_pos = y - ((v->z_pos-GetSlopeZ(safe_x, safe_y)) >> 3);;

			




	
	
	
		
 

			




	
	
		
 
@@ -858,12 +823,10 @@ static void SetAircraftPosition(Vehicle 

			




	
	
	
		
 
 */

			




	
	
	
		
 
void HandleAircraftEnterHangar(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Vehicle *u;

			




	
	
	
		
 

			




	
	
	
		
 
	v->subspeed = 0;

			




	
	
	
		
 
	v->progress = 0;

			




	
	
	
		
 

			




	
	
	
		
 
	u = v->next;

			




	
	
	
		
 
	Vehicle *u = v->next;

			




	
	
	
		
 
	u->vehstatus |= VS_HIDDEN;

			




	
	
	
		
 
	u = u->next;

			




	
	
	
		
 
	if (u != NULL) {

			




	
	
		
 
@@ -937,7 +900,13 @@ static byte GetAircraftFlyingAltitude(co

			




	
	
	
		
 
	 * other by providing them with vertical seperation

			




	
	
	
		
 
	 */

			




	
	
	
		
 
	switch (v->direction) {

			




	
	
	
		
 
		case DIR_N: case DIR_NE: case DIR_E: case DIR_SE: base_altitude += 15; break;

			




	
	
	
		
 
		case DIR_N:

			




	
	
	
		
 
		case DIR_NE:

			




	
	
	
		
 
		case DIR_E:

			




	
	
	
		
 
		case DIR_SE:

			




	
	
	
		
 
			base_altitude += 15;

			




	
	
	
		
 
			break;

			




	
	
	
		
 

			




	
	
	
		
 
		default: break;

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
		
 
@@ -949,25 +918,13 @@ static byte GetAircraftFlyingAltitude(co

			




	
	
	
		
 

			




	
	
	
		
 
static bool AircraftController(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Station *st;

			




	
	
	
		
 
	Vehicle *u;

			




	
	
	
		
 
	byte z, maxz, curz;

			




	
	
	
		
 
	Direction newdir;

			




	
	
	
		
 
	GetNewVehiclePosResult gp;

			




	
	
	
		
 
	uint dist;

			




	
	
	
		
 
	int x,y;

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
	// prevent going to 0,0 if airport is deleted.

			




	
	
	
		
 
	{

			




	
	
	
		
 
		TileIndex tile = st->airport_tile;

			




	
	
	
		
 

			




	
	
	
		
 
		if (tile == 0) tile = st->xy;

			




	
	
	
		
 
		// xy of destination

			




	
	
	
		
 
		x = TileX(tile) * TILE_SIZE;

			




	
	
	
		
 
		y = TileY(tile) * TILE_SIZE;

			




	
	
	
		
 
	}

			




	
	
	
		
 
	int x = TileX(tile) * TILE_SIZE;

			




	
	
	
		
 
	int y = TileY(tile) * TILE_SIZE;

			




	
	
	
		
 

			




	
	
	
		
 
	// get airport moving data

			




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

			




	
	
		
 
@@ -975,7 +932,7 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 

			




	
	
	
		
 
	// Helicopter raise

			




	
	
	
		
 
	if (amd->flag & AMED_HELI_RAISE) {

			




	
	
	
		
 
		u = v->next->next;

			




	
	
	
		
 
		Vehicle *u = v->next->next;

			




	
	
	
		
 

			




	
	
	
		
 
		// Make sure the rotors don't rotate too fast

			




	
	
	
		
 
		if (u->cur_speed > 32) {

			




	
	
		
 
@@ -1013,10 +970,10 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 
			v->tile = st->airport_tile;

			




	
	
	
		
 

			




	
	
	
		
 
			// Find altitude of landing position.

			




	
	
	
		
 
			z = GetSlopeZ(x, y) + 1 + afc->delta_z;

			




	
	
	
		
 
			uint z = GetSlopeZ(x, y) + 1 + afc->delta_z;

			




	
	
	
		
 

			




	
	
	
		
 
			if (z == v->z_pos) {

			




	
	
	
		
 
				u = v->next->next;

			




	
	
	
		
 
				Vehicle *u = v->next->next;

			




	
	
	
		
 

			




	
	
	
		
 
				// Increase speed of rotors. When speed is 80, we've landed.

			




	
	
	
		
 
				if (u->cur_speed >= 80) return true;

			




	
	
		
 
@@ -1031,7 +988,7 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	// Get distance from destination pos to current pos.

			




	
	
	
		
 
	dist = myabs(x + amd->x - v->x_pos) +  myabs(y + amd->y - v->y_pos);

			




	
	
	
		
 
	uint dist = myabs(x + amd->x - v->x_pos) +  myabs(y + amd->y - v->y_pos);

			




	
	
	
		
 

			




	
	
	
		
 
	// Need exact position?

			




	
	
	
		
 
	if (!(amd->flag & AMED_EXACTPOS) && dist <= (amd->flag & AMED_SLOWTURN ? 8U : 4U))

			




	
	
		
 
@@ -1039,10 +996,8 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 

			




	
	
	
		
 
	// At final pos?

			




	
	
	
		
 
	if (dist == 0) {

			




	
	
	
		
 
		DirDiff dirdiff;

			




	
	
	
		
 

			




	
	
	
		
 
		// Change direction smoothly to final direction.

			




	
	
	
		
 
		dirdiff = DirDifference(amd->direction, v->direction);

			




	
	
	
		
 
		DirDiff dirdiff = DirDifference(amd->direction, v->direction);

			




	
	
	
		
 
		// if distance is 0, and plane points in right direction, no point in calling

			




	
	
	
		
 
		// UpdateAircraftSpeed(). So do it only afterwards

			




	
	
	
		
 
		if (dirdiff == DIRDIFF_SAME) {

			




	
	
		
 
@@ -1064,7 +1019,7 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 
	if (v->load_unload_time_rem != 0) v->load_unload_time_rem--;

			




	
	
	
		
 

			




	
	
	
		
 
	// Turn. Do it slowly if in the air.

			




	
	
	
		
 
	newdir = GetDirectionTowards(v, x + amd->x, y + amd->y);

			




	
	
	
		
 
	Direction newdir = GetDirectionTowards(v, x + amd->x, y + amd->y);

			




	
	
	
		
 
	if (newdir != v->direction) {

			




	
	
	
		
 
		if (amd->flag & AMED_SLOWTURN) {

			




	
	
	
		
 
			if (v->load_unload_time_rem == 0) v->load_unload_time_rem = 8;

			




	
	
		
 
@@ -1076,6 +1031,7 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	// Move vehicle.

			




	
	
	
		
 
	GetNewVehiclePosResult gp;

			




	
	
	
		
 
	GetNewVehiclePos(v, &gp);

			




	
	
	
		
 
	v->tile = gp.new_tile;

			




	
	
	
		
 

			




	
	
		
 
@@ -1083,12 +1039,10 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 
	if (amd->flag & (AMED_TAKEOFF | AMED_SLOWTURN | AMED_LAND)) v->tile = 0;

			




	
	
	
		
 

			




	
	
	
		
 
	// Adjust Z for land or takeoff?

			




	
	
	
		
 
	z = v->z_pos;

			




	
	
	
		
 
	uint z = v->z_pos;

			




	
	
	
		
 

			




	
	
	
		
 
	if (amd->flag & AMED_TAKEOFF) {

			




	
	
	
		
 
		z += 2;

			




	
	
	
		
 
		maxz = GetAircraftFlyingAltitude(v);

			




	
	
	
		
 
		if (z > maxz) z = maxz;

			




	
	
	
		
 
		z = min(z + 2, GetAircraftFlyingAltitude(v));

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (amd->flag & AMED_LAND) {

			




	
	
		
 
@@ -1100,7 +1054,7 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 
			return false;

			




	
	
	
		
 
		}

			




	
	
	
		
 

			




	
	
	
		
 
		curz = GetSlopeZ(x, y) + 1;

			




	
	
	
		
 
		uint curz = GetSlopeZ(x, y) + 1;

			




	
	
	
		
 

			




	
	
	
		
 
		if (curz > z) {

			




	
	
	
		
 
			z++;

			




	
	
		
 
@@ -1114,7 +1068,7 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 

			




	
	
	
		
 
	// We've landed. Decrase speed when we're reaching end of runway.

			




	
	
	
		
 
	if (amd->flag & AMED_BRAKE) {

			




	
	
	
		
 
		curz = GetSlopeZ(x, y) + 1;

			




	
	
	
		
 
		uint curz = GetSlopeZ(x, y) + 1;

			




	
	
	
		
 

			




	
	
	
		
 
		if (z > curz) {

			




	
	
	
		
 
			z--;

			




	
	
		
 
@@ -1132,17 +1086,13 @@ static bool AircraftController(Vehicle *

			




	
	
	
		
 

			




	
	
	
		
 
static void HandleCrashedAircraft(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	uint32 r;

			




	
	
	
		
 
	Station *st;

			




	
	
	
		
 
	int z;

			




	
	
	
		
 

			




	
	
	
		
 
	v->u.air.crashed_counter++;

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




	
	
	
		
 
	// make aircraft crash down to the ground

			




	
	
	
		
 
	if (v->u.air.crashed_counter < 500 && st->airport_tile==0 && ((v->u.air.crashed_counter % 3) == 0) ) {

			




	
	
	
		
 
		z = GetSlopeZ(v->x_pos, v->y_pos);

			




	
	
	
		
 
		uint z = GetSlopeZ(v->x_pos, v->y_pos);

			




	
	
	
		
 
		v->z_pos -= 1;

			




	
	
	
		
 
		if (v->z_pos == z) {

			




	
	
	
		
 
			v->u.air.crashed_counter = 500;

			




	
	
		
 
@@ -1151,6 +1101,7 @@ static void HandleCrashedAircraft(Vehicl

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	if (v->u.air.crashed_counter < 650) {

			




	
	
	
		
 
		uint32 r;

			




	
	
	
		
 
		if (CHANCE16R(1,32,r)) {

			




	
	
	
		
 
			static const DirDiff delta[] = {

			




	
	
	
		
 
				DIRDIFF_45LEFT, DIRDIFF_SAME, DIRDIFF_SAME, DIRDIFF_45RIGHT

			




	
	
		
 
@@ -1232,8 +1183,6 @@ static void HandleAircraftSmoke(Vehicle 

			




	
	
	
		
 

			




	
	
	
		
 
static void ProcessAircraftOrder(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	const Order *order;

			




	
	
	
		
 

			




	
	
	
		
 
	switch (v->current_order.type) {

			




	
	
	
		
 
		case OT_GOTO_DEPOT:

			




	
	
	
		
 
			if (!(v->current_order.flags & OF_PART_OF_ORDERS)) return;

			




	
	
		
 
@@ -1250,7 +1199,7 @@ static void ProcessAircraftOrder(Vehicle

			




	
	
	
		
 

			




	
	
	
		
 
	if (v->cur_order_index >= v->num_orders) v->cur_order_index = 0;

			




	
	
	
		
 

			




	
	
	
		
 
	order = GetVehicleOrder(v, v->cur_order_index);

			




	
	
	
		
 
	const Order *order = GetVehicleOrder(v, v->cur_order_index);

			




	
	
	
		
 

			




	
	
	
		
 
	if (order == NULL) {

			




	
	
	
		
 
		v->current_order.type = OT_NOTHING;

			




	
	
		
 
@@ -1325,10 +1274,6 @@ static void HandleAircraftLoading(Vehicl

			




	
	
	
		
 

			




	
	
	
		
 
static void CrashAirplane(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	uint16 amt;

			




	
	
	
		
 
	Station *st;

			




	
	
	
		
 
	StringID newsitem;

			




	
	
	
		
 

			




	
	
	
		
 
	v->vehstatus |= VS_CRASHED;

			




	
	
	
		
 
	v->u.air.crashed_counter = 0;

			




	
	
	
		
 

			




	
	
		
 
@@ -1336,13 +1281,14 @@ static void CrashAirplane(Vehicle *v)

			




	
	
	
		
 

			




	
	
	
		
 
	InvalidateWindow(WC_VEHICLE_VIEW, v->index);

			




	
	
	
		
 

			




	
	
	
		
 
	amt = 2;

			




	
	
	
		
 
	uint amt = 2;

			




	
	
	
		
 
	if (v->cargo_type == CT_PASSENGERS) amt += v->cargo_count;

			




	
	
	
		
 
	SetDParam(0, amt);

			




	
	
	
		
 

			




	
	
	
		
 
	v->cargo_count = 0;

			




	
	
	
		
 
	v->next->cargo_count = 0;

			




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

			




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

			




	
	
	
		
 
	StringID newsitem;

			




	
	
	
		
 
	if (st->airport_tile == 0) {

			




	
	
	
		
 
		newsitem = STR_PLANE_CRASH_OUT_OF_FUEL;

			




	
	
	
		
 
	} else {

			




	
	
		
 
@@ -1361,14 +1307,10 @@ static void CrashAirplane(Vehicle *v)

			




	
	
	
		
 

			




	
	
	
		
 
static void MaybeCrashAirplane(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Station *st;

			




	
	
	
		
 
	uint16 prob;

			




	
	
	
		
 
	uint i;

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	prob = 0x10000 / 1500;

			




	
	
	
		
 
	uint16 prob = 0x10000 / 1500;

			




	
	
	
		
 
	if (st->Airport()->flags & AirportFTAClass::SHORT_STRIP &&

			




	
	
	
		
 
			AircraftVehInfo(v->engine_type)->subtype & AIR_FAST &&

			




	
	
	
		
 
			!_cheats.no_jetcrash.value) {

			




	
	
		
 
@@ -1378,7 +1320,7 @@ static void MaybeCrashAirplane(Vehicle *

			




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

			




	
	
	
		
 

			




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

			




	
	
	
		
 
	for (i = 0; i != NUM_CARGO; i++) {

			




	
	
	
		
 
	for (uint i = 0; i != NUM_CARGO; i++) {

			




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

			




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

			




	
	
	
		
 
	}

			




	
	
		
 
@@ -1389,12 +1331,9 @@ static void MaybeCrashAirplane(Vehicle *

			




	
	
	
		
 
// we've landed and just arrived at a terminal

			




	
	
	
		
 
static void AircraftEntersTerminal(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Station *st;

			




	
	
	
		
 
	Order old_order;

			




	
	
	
		
 

			




	
	
	
		
 
	if (v->current_order.type == OT_GOTO_DEPOT) return;

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
	v->last_station_visited = v->u.air.targetairport;

			




	
	
	
		
 

			




	
	
	
		
 
	/* Check if station was ever visited before */

			




	
	
		
 
@@ -1412,7 +1351,7 @@ static void AircraftEntersTerminal(Vehic

			




	
	
	
		
 
			0);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	old_order = v->current_order;

			




	
	
	
		
 
	Order old_order = v->current_order;

			




	
	
	
		
 
	v->BeginLoading();

			




	
	
	
		
 
	v->current_order.flags = 0;

			




	
	
	
		
 

			




	
	
		
 
@@ -1625,7 +1564,8 @@ static void AircraftEventHandler_General

			




	
	
	
		
 
	assert("OK, you shouldn't be here, check your Airport Scheme!" && 0);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
static void AircraftEventHandler_TakeOff(Vehicle *v, const AirportFTAClass *apc) {

			




	
	
	
		
 
static void AircraftEventHandler_TakeOff(Vehicle *v, const AirportFTAClass *apc)

			




	
	
	
		
 
{

			




	
	
	
		
 
	PlayAircraftSound(v); // play takeoffsound for airplanes

			




	
	
	
		
 
	v->u.air.state = STARTTAKEOFF;

			




	
	
	
		
 
}

			




	
	
		
 
@@ -1666,12 +1606,8 @@ static void AircraftEventHandler_HeliTak

			




	
	
	
		
 

			




	
	
	
		
 
static void AircraftEventHandler_Flying(Vehicle *v, const AirportFTAClass *apc)

			




	
	
	
		
 
{

			




	
	
	
		
 
	Station *st;

			




	
	
	
		
 
	byte landingtype;

			




	
	
	
		
 
	AirportFTA *current;

			




	
	
	
		
 
	uint16 tcur_speed, tsubspeed;

			




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

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
	if (apc->flags & (v->subtype == AIR_HELICOPTER ? AirportFTAClass::HELICOPTERS : AirportFTAClass::AIRPLANES) &&

			




	
	
	
		
 
			st->airport_tile != 0 &&

			




	
	
		
 
@@ -1679,15 +1615,15 @@ static void AircraftEventHandler_Flying(

			




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

			




	
	
	
		
 
		// if it is an airplane, look for LANDING, for helicopter HELILANDING

			




	
	
	
		
 
		// it is possible to choose from multiple landing runways, so loop until a free one is found

			




	
	
	
		
 
		landingtype = (v->subtype == AIR_HELICOPTER) ? HELILANDING : LANDING;

			




	
	
	
		
 
		current = apc->layout[v->u.air.pos].next;

			




	
	
	
		
 
		byte landingtype = (v->subtype == AIR_HELICOPTER) ? HELILANDING : LANDING;

			




	
	
	
		
 
		const AirportFTA *current = apc->layout[v->u.air.pos].next;

			




	
	
	
		
 
		while (current != NULL) {

			




	
	
	
		
 
			if (current->heading == landingtype) {

			




	
	
	
		
 
				// save speed before, since if AirportHasBlock is false, it resets them to 0

			




	
	
	
		
 
				// we don't want that for plane in air

			




	
	
	
		
 
				// hack for speed thingie

			




	
	
	
		
 
				tcur_speed = v->cur_speed;

			




	
	
	
		
 
				tsubspeed = v->subspeed;

			




	
	
	
		
 
				uint16 tcur_speed = v->cur_speed;

			




	
	
	
		
 
				uint16 tsubspeed = v->subspeed;

			




	
	
	
		
 
				if (!AirportHasBlock(v, current, apc)) {

			




	
	
	
		
 
					v->u.air.state = landingtype; // LANDING / HELILANDING

			




	
	
	
		
 
					// it's a bit dirty, but I need to set position to next position, otherwise

			




	
	
		
 
@@ -1709,12 +1645,12 @@ static void AircraftEventHandler_Flying(

			




	
	
	
		
 

			




	
	
	
		
 
static void AircraftEventHandler_Landing(Vehicle *v, const AirportFTAClass *apc)

			




	
	
	
		
 
{

			




	
	
	
		
 
	const Player* p = GetPlayer(v->owner);

			




	
	
	
		
 
	AircraftLandAirplane(v);  // maybe crash airplane

			




	
	
	
		
 
	v->u.air.state = ENDLANDING;

			




	
	
	
		
 
	// check if the aircraft needs to be replaced or renewed and send it to a hangar if needed

			




	
	
	
		
 
	if (v->current_order.type != OT_GOTO_DEPOT && v->owner == _local_player) {

			




	
	
	
		
 
		// only the vehicle owner needs to calculate the rest (locally)

			




	
	
	
		
 
		const Player* p = GetPlayer(v->owner);

			




	
	
	
		
 
		if (EngineHasReplacementForPlayer(p, v->engine_type) ||

			




	
	
	
		
 
			(p->engine_renew && v->age - v->max_age > (p->engine_renew_months * 30))) {

			




	
	
	
		
 
			// send the aircraft to the hangar at next airport

			




	
	
		
 
@@ -1814,19 +1750,16 @@ static void AirportGoToNextPosition(Vehi

			




	
	
	
		
 
// gets pos from vehicle and next orders

			




	
	
	
		
 
static bool AirportMove(Vehicle *v, const AirportFTAClass *apc)

			




	
	
	
		
 
{

			




	
	
	
		
 
	AirportFTA *current;

			




	
	
	
		
 
	byte prev_pos;

			




	
	
	
		
 

			




	
	
	
		
 
	// error handling

			




	
	
	
		
 
	if (v->u.air.pos >= apc->nofelements) {

			




	
	
	
		
 
		DEBUG(misc, 0, "[Ap] position %d is not valid for current airport. Max position is %d", v->u.air.pos, apc->nofelements-1);

			




	
	
	
		
 
		assert(v->u.air.pos < apc->nofelements);

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	current = &apc->layout[v->u.air.pos];

			




	
	
	
		
 
	const AirportFTA *current = &apc->layout[v->u.air.pos];

			




	
	
	
		
 
	// we have arrived in an important state (eg terminal, hangar, etc.)

			




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

			




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

			




	
	
	
		
 
		byte 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, apc);

			




	
	
	
		
 
		if (v->u.air.state != FLYING) v->u.air.previous_pos = prev_pos;

			




	
	
	
		
 
		return true;

			




	
	
		
 
@@ -1885,18 +1818,17 @@ static bool AirportHasBlock(Vehicle *v, 

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// returns true on success. Eg, next block was free and we have occupied it

			




	
	
	
		
 
static bool AirportSetBlocks(Vehicle *v, AirportFTA *current_pos, const AirportFTAClass *apc)

			




	
	
	
		
 
static bool AirportSetBlocks(Vehicle *v, const AirportFTA *current_pos, const AirportFTAClass *apc)

			




	
	
	
		
 
{

			




	
	
	
		
 
	AirportFTA *next = &apc->layout[current_pos->next_position];

			




	
	
	
		
 
	AirportFTA *reference = &apc->layout[v->u.air.pos];

			




	
	
	
		
 
	const AirportFTA *next = &apc->layout[current_pos->next_position];

			




	
	
	
		
 
	const AirportFTA *reference = &apc->layout[v->u.air.pos];

			




	
	
	
		
 

			




	
	
	
		
 
	// if the next position is in another block, check it and wait until it is free

			




	
	
	
		
 
	if ((apc->layout[current_pos->position].block & next->block) != next->block) {

			




	
	
	
		
 
		uint64 airport_flags = next->block;

			




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

			




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

			




	
	
	
		
 
		// this means more blocks should be checked/set

			




	
	
	
		
 
			AirportFTA *current = current_pos;

			




	
	
	
		
 
		const AirportFTA *current = current_pos;

			




	
	
	
		
 
		if (current == reference) current = current->next;

			




	
	
	
		
 
		while (current != NULL) {

			




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

			




	
	
		
 
@@ -1910,6 +1842,7 @@ static bool AirportSetBlocks(Vehicle *v,

			




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

			




	
	
	
		
 
		if (current_pos->block == next->block) airport_flags ^= next->block;

			




	
	
	
		
 

			




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

			




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

			




	
	
	
		
 
			v->cur_speed = 0;

			




	
	
	
		
 
			v->subspeed = 0;

			




	
	
		
 
@@ -1940,9 +1873,8 @@ static bool FreeTerminal(Vehicle *v, byt

			




	
	
	
		
 
static uint GetNumTerminals(const AirportFTAClass *apc)

			




	
	
	
		
 
{

			




	
	
	
		
 
	uint num = 0;

			




	
	
	
		
 
	uint i;

			




	
	
	
		
 

			




	
	
	
		
 
	for (i = apc->terminals[0]; i > 0; i--) num += apc->terminals[i];

			




	
	
	
		
 
	for (uint i = apc->terminals[0]; i > 0; i--) num += apc->terminals[i];

			




	
	
	
		
 

			




	
	
	
		
 
	return num;

			




	
	
	
		
 
}

			




	
	
		
 
@@ -1960,28 +1892,25 @@ static bool AirportFindFreeTerminal(Vehi

			




	
	
	
		
 
	 * fails, then attempt fails and plane waits

			




	
	
	
		
 
	 */

			




	
	
	
		
 
	if (apc->terminals[0] > 1) {

			




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

			




	
	
	
		
 
		AirportFTA *temp = apc->layout[v->u.air.pos].next;

			




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

			




	
	
	
		
 
		const AirportFTA *temp = apc->layout[v->u.air.pos].next;

			




	
	
	
		
 

			




	
	
	
		
 
		while (temp != NULL) {

			




	
	
	
		
 
			if (temp->heading == 255) {

			




	
	
	
		
 
				if (!HASBITS(st->airport_flags, temp->block)) {

			




	
	
	
		
 
					int target_group;

			




	
	
	
		
 
					int i;

			




	
	
	
		
 
					int group_start = 0;

			




	
	
	
		
 
					int group_end;

			




	
	
	
		
 

			




	
	
	
		
 
					//read which group do we want to go to?

			




	
	
	
		
 
					//(the first free group)

			




	
	
	
		
 
					target_group = temp->next_position + 1;

			




	
	
	
		
 
					uint target_group = temp->next_position + 1;

			




	
	
	
		
 

			




	
	
	
		
 
					//at what terminal does the group start?

			




	
	
	
		
 
					//that means, sum up all terminals of

			




	
	
	
		
 
					//groups with lower number

			




	
	
	
		
 
					for (i = 1; i < target_group; i++)

			




	
	
	
		
 
					uint group_start = 0;

			




	
	
	
		
 
					for (uint i = 1; i < target_group; i++) {

			




	
	
	
		
 
						group_start += apc->terminals[i];

			




	
	
	
		
 
					}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
					uint group_end = group_start + apc->terminals[target_group];

			




	
	
	
		
 
					if (FreeTerminal(v, group_start, group_end)) return true;

			




	
	
	
		
 
				}

			




	
	
	
		
 
			} else {

			




	
	
		
 
@@ -2000,9 +1929,8 @@ static bool AirportFindFreeTerminal(Vehi

			




	
	
	
		
 
static uint GetNumHelipads(const AirportFTAClass *apc)

			




	
	
	
		
 
{

			




	
	
	
		
 
	uint num = 0;

			




	
	
	
		
 
	uint i;

			




	
	
	
		
 

			




	
	
	
		
 
	for (i = apc->helipads[0]; i > 0; i--) num += apc->helipads[i];

			




	
	
	
		
 
	for (uint i = apc->helipads[0]; i > 0; i--) num += apc->helipads[i];

			




	
	
	
		
 

			




	
	
	
		
 
	return num;

			




	
	
	
		
 
}

			




	
	
		
 
@@ -2021,22 +1949,20 @@ static bool AirportFindFreeHelipad(Vehic

			




	
	
	
		
 
		while (temp != NULL) {

			




	
	
	
		
 
			if (temp->heading == 255) {

			




	
	
	
		
 
				if (!HASBITS(st->airport_flags, temp->block)) {

			




	
	
	
		
 
					int target_group;

			




	
	
	
		
 
					int i;

			




	
	
	
		
 
					int group_start = 0;

			




	
	
	
		
 
					int group_end;

			




	
	
	
		
 

			




	
	
	
		
 
					//read which group do we want to go to?

			




	
	
	
		
 
					//(the first free group)

			




	
	
	
		
 
					target_group = temp->next_position + 1;

			




	
	
	
		
 
					uint target_group = temp->next_position + 1;

			




	
	
	
		
 

			




	
	
	
		
 
					//at what terminal does the group start?

			




	
	
	
		
 
					//that means, sum up all terminals of

			




	
	
	
		
 
					//groups with lower number

			




	
	
	
		
 
					for (i = 1; i < target_group; i++)

			




	
	
	
		
 
					uint group_start = 0;

			




	
	
	
		
 
					for (uint i = 1; i < target_group; i++) {

			




	
	
	
		
 
						group_start += apc->helipads[i];

			




	
	
	
		
 
					}

			




	
	
	
		
 

			




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

			




	
	
	
		
 
					uint group_end = group_start + apc->helipads[target_group];

			




	
	
	
		
 
					if (FreeTerminal(v, group_start, group_end)) return true;

			




	
	
	
		
 
				}

			




	
	
	
		
 
			} else {

			




	
	
		
 
@@ -2085,15 +2011,13 @@ static void AircraftEventHandler(Vehicle

			




	
	
	
		
 

			




	
	
	
		
 
void Aircraft_Tick(Vehicle *v)

			




	
	
	
		
 
{

			




	
	
	
		
 
	int i;

			




	
	
	
		
 

			




	
	
	
		
 
	if (!IsNormalAircraft(v)) return;

			




	
	
	
		
 

			




	
	
	
		
 
	if (v->subtype == AIR_HELICOPTER) HelicopterTickHandler(v);

			




	
	
	
		
 

			




	
	
	
		
 
	AgeAircraftCargo(v);

			




	
	
	
		
 

			




	
	
	
		
 
	for (i = 0; i != 6; i++) {

			




	
	
	
		
 
	for (uint i = 0; i != 6; i++) {

			




	
	
	
		
 
		AircraftEventHandler(v, i);

			




	
	
	
		
 
		if (v->type != VEH_Aircraft) // In case it was deleted

			




	
	
	
		
 
			break;

			




	
	
		
 
@@ -2104,15 +2028,13 @@ void Aircraft_Tick(Vehicle *v)

			




	
	
	
		
 
// need to be called to load aircraft from old version

			




	
	
	
		
 
void UpdateOldAircraft(void)

			




	
	
	
		
 
{

			




	
	
	
		
 
	// set airport_flags to 0 for all airports just to be sure

			




	
	
	
		
 
	Station *st;

			




	
	
	
		
 
	Vehicle *v_oldstyle;

			




	
	
	
		
 
	GetNewVehiclePosResult gp;

			




	
	
	
		
 

			




	
	
	
		
 
	// set airport_flags to 0 for all airports just to be sure

			




	
	
	
		
 
	FOR_ALL_STATIONS(st) {

			




	
	
	
		
 
		st->airport_flags = 0; // reset airport

			




	
	
	
		
 
	}

			




	
	
	
		
 

			




	
	
	
		
 
	Vehicle *v_oldstyle;

			




	
	
	
		
 
	FOR_ALL_VEHICLES(v_oldstyle) {

			




	
	
	
		
 
	// airplane has another vehicle with subtype 4 (shadow), helicopter also has 3 (rotor)

			




	
	
	
		
 
	// skip those

			




	
	
		
 
@@ -2127,6 +2049,7 @@ void UpdateOldAircraft(void)

			




	
	
	
		
 
			v_oldstyle->vehstatus &= ~VS_STOPPED; // make airplane moving

			




	
	
	
		
 
			v_oldstyle->u.air.state = FLYING;

			




	
	
	
		
 
			AircraftNextAirportPos_and_Order(v_oldstyle); // move it to the entry point of the airport

			




	
	
	
		
 
			GetNewVehiclePosResult gp;

			




	
	
	
		
 
			GetNewVehiclePos(v_oldstyle, &gp); // get the position of the plane (to be used for setting)

			




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

			




	
	
	
		
 

			




	
	
		
 
@@ -2139,14 +2062,12 @@ void UpdateOldAircraft(void)

			




	
	
	
		
 
	}

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void UpdateAirplanesOnNewStation(Station *st)

			




	
	
	
		
 
void UpdateAirplanesOnNewStation(const Station *st)

			




	
	
	
		
 
{

			




	
	
	
		
 
	GetNewVehiclePosResult gp;

			




	
	
	
		
 
	Vehicle *v;

			




	
	
	
		
 
	byte takeofftype;

			




	
	
	
		
 
	uint16 cnt;

			




	
	
	
		
 
	// only 1 station is updated per function call, so it is enough to get entry_point once

			




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

			




	
	
	
		
 

			




	
	
	
		
 
	Vehicle *v;

			




	
	
	
		
 
	FOR_ALL_VEHICLES(v) {

			




	
	
	
		
 
		if (v->type == VEH_Aircraft && IsNormalAircraft(v)) {

			




	
	
	
		
 
			if (v->u.air.targetairport == st->index) { // if heading to this airport

			




	
	
		
 
@@ -2158,15 +2079,16 @@ void UpdateAirplanesOnNewStation(Station

			




	
	
	
		
 
					v->u.air.state = FLYING;

			




	
	
	
		
 
					// landing plane needs to be reset to flying height (only if in pause mode upgrade,

			




	
	
	
		
 
					// in normal mode, plane is reset in AircraftController. It doesn't hurt for FLYING

			




	
	
	
		
 
					GetNewVehiclePosResult gp;

			




	
	
	
		
 
					GetNewVehiclePos(v, &gp);

			




	
	
	
		
 
					// set new position x,y,z

			




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

			




	
	
	
		
 
				} else {

			




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

			




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

			




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

			




	
	
	
		
 
					// search in airportdata for that heading

			




	
	
	
		
 
					// easiest to do, since this doesn't happen a lot

			




	
	
	
		
 
					for (cnt = 0; cnt < ap->nofelements; cnt++) {

			




	
	
	
		
 
					for (uint cnt = 0; cnt < ap->nofelements; cnt++) {

			




	
	
	
		
 
						if (ap->layout[cnt].heading == takeofftype) {

			




	
	
	
		
 
							v->u.air.pos = ap->layout[cnt].position;

			




	
	
	
		
 
							break;

			




        

    


    
    

    

        

                

                    src/airport.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -288,11 +288,10 @@ AirportFTAClass::~AirportFTAClass()

			




	
	
	
		
 
 * know one element from the other by differing 'position' identifiers */

			




	
	
	
		
 
static uint16 AirportGetNofElements(const AirportFTAbuildup *apFA)

			




	
	
	
		
 
{

			




	
	
	
		
 
	int i;

			




	
	
	
		
 
	uint16 nofelements = 0;

			




	
	
	
		
 
	int temp = apFA[0].position;

			




	
	
	
		
 

			




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

			




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

			




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

			




	
	
	
		
 
			nofelements++;

			




	
	
	
		
 
			temp = apFA[i].position;

			




	
	
		
 
@@ -307,12 +306,11 @@ static uint16 AirportGetNofElements(cons

			




	
	
	
		
 
 * groups there are, and then the number of terminals for each group */

			




	
	
	
		
 
static byte AirportGetTerminalCount(const byte *terminals, byte *groups)

			




	
	
	
		
 
{

			




	
	
	
		
 
	byte i;

			




	
	
	
		
 
	byte nof_terminals = 0;

			




	
	
	
		
 
	*groups = 0;

			




	
	
	
		
 

			




	
	
	
		
 
	if (terminals != NULL) {

			




	
	
	
		
 
		i = terminals[0];

			




	
	
	
		
 
		uint i = terminals[0];

			




	
	
	
		
 
		*groups = i;

			




	
	
	
		
 
		while (i-- > 0) {

			




	
	
	
		
 
			terminals++;

			




	
	
		
 
@@ -326,12 +324,11 @@ static byte AirportGetTerminalCount(cons

			




	
	
	
		
 

			




	
	
	
		
 
static AirportFTA* AirportBuildAutomata(uint nofelements, const AirportFTAbuildup *apFA)

			




	
	
	
		
 
{

			




	
	
	
		
 
	AirportFTA *current;

			




	
	
	
		
 
	AirportFTA *FAutomata = MallocT<AirportFTA>(nofelements);

			




	
	
	
		
 
	uint16 internalcounter = 0;

			




	
	
	
		
 

			




	
	
	
		
 
	for (uint i = 0; i < nofelements; i++) {

			




	
	
	
		
 
		current = &FAutomata[i];

			




	
	
	
		
 
		AirportFTA *current = &FAutomata[i];

			




	
	
	
		
 
		current->position      = apFA[internalcounter].position;

			




	
	
	
		
 
		current->heading       = apFA[internalcounter].heading;

			




	
	
	
		
 
		current->block         = apFA[internalcounter].block;

			




	
	
		
 
@@ -349,7 +346,7 @@ static AirportFTA* AirportBuildAutomata(

			




	
	
	
		
 
			current->next = newNode;

			




	
	
	
		
 
			current = current->next;

			




	
	
	
		
 
			internalcounter++;

			




	
	
	
		
 
		} // while

			




	
	
	
		
 
		}

			




	
	
	
		
 
		current->next = NULL;

			




	
	
	
		
 
		internalcounter++;

			




	
	
	
		
 
	}

			




	
	
		
 
@@ -365,9 +362,8 @@ static byte AirportTestFTA(uint nofeleme

			




	
	
	
		
 
		uint position = layout[i].position;

			




	
	
	
		
 
		if (position != next_position) return i;

			




	
	
	
		
 
		const AirportFTA *first = &layout[i];

			




	
	
	
		
 
		const AirportFTA *current = first;

			




	
	
	
		
 

			




	
	
	
		
 
		for (; current != NULL; current = current->next) {

			




	
	
	
		
 
		for (const AirportFTA *current = first; current != NULL; current = current->next) {

			




	
	
	
		
 
			/* A heading must always be valid. The only exceptions are

			




	
	
	
		
 
			 * - multiple choices as start, identified by a special value of 255

			




	
	
	
		
 
			 * - terminal group which is identified by a special value of 255 */

			




	
	
		
 
@@ -434,9 +430,7 @@ static void AirportPrintOut(uint nofelem

			




	
	
	
		
 
	if (!full_report) printf("(P = Current Position; NP = Next Position)\n");

			




	
	
	
		
 

			




	
	
	
		
 
	for (uint i = 0; i < nofelements; i++) {

			




	
	
	
		
 
		const AirportFTA *current = &layout[i];

			




	
	
	
		
 

			




	
	
	
		
 
		for (; current != NULL; current = current->next) {

			




	
	
	
		
 
		for (const AirportFTA *current = &layout[i]; current != NULL; current = current->next) {

			




	
	
	
		
 
			if (full_report) {

			




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

			




	
	
	
		
 
				printf("\tPos:%2d NPos:%2d Heading:%15s Block:%2d\n", current->position,

			




        

    


    
    

    

        

                

                    src/build_vehicle_gui.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -505,7 +505,7 @@ static int DrawAircraftPurchaseInfo(int 

			




	
	
	
		
 
		/* Note, if the default capacity is selected by the refit capacity

			




	
	
	
		
 
		* callback, then the capacity shown is likely to be incorrect. */

			




	
	
	
		
 
		SetDParam(0, cargo);

			




	
	
	
		
 
		SetDParam(1, AircraftDefaultCargoCapacity(cargo, engine_number));

			




	
	
	
		
 
		SetDParam(1, AircraftDefaultCargoCapacity(cargo, avi));

			




	
	
	
		
 
		SetDParam(2, STR_9842_REFITTABLE);

			




	
	
	
		
 
		DrawString(x, y, STR_PURCHASE_INFO_CAPACITY, 0);

			




	
	
	
		
 
	}

			




        

    


    
    

    

        

                

                    src/station_cmd.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -4,6 +4,7 @@

			




	
	
	
		
 

			




	
	
	
		
 
#include "stdafx.h"

			




	
	
	
		
 
#include "openttd.h"

			




	
	
	
		
 
#include "aircraft.h"

			




	
	
	
		
 
#include "bridge_map.h"

			




	
	
	
		
 
#include "debug.h"

			




	
	
	
		
 
#include "functions.h"

			




	
	
		
 
@@ -72,9 +73,6 @@ DEFINE_OLD_POOL(Station, Station, Statio

			




	
	
	
		
 
DEFINE_OLD_POOL(RoadStop, RoadStop, RoadStopPoolNewBlock, NULL)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
extern void UpdateAirplanesOnNewStation(Station *st);

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
RoadStop* GetRoadStopByTile(TileIndex tile, RoadStop::Type type)

			




	
	
	
		
 
{

			




	
	
	
		
 
	const Station* st = GetStationByTile(tile);

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: code.theleruby.com-48
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2022 by various authors & licensed under GPLv3.
            – Support