// get the next position to go to, differs per airport

	AircraftNextAirportPos_and_Order(v);

}

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

{

	v->sprite_width = v->sprite_height = 24; // ??? no idea what this is

	v->u.air.state = FLYING;

	// get the next position to go to, differs per airport

	AircraftNextAirportPos_and_Order(v);

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

		_current_player = _local_player;

		DoCommandP(v->tile, v->index, 1, NULL, CMD_SEND_AIRCRAFT_TO_HANGAR | CMD_SHOW_NO_ERROR);

		_current_player = OWNER_NONE;

	}

}

	v->u.air.state = FLYING;

	v->u.air.pos = Airport->layout[v->u.air.pos].next_position;

}

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

{

	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)

			// send the aircraft to the hangar at next airport (bit 17 set)

			_current_player = _local_player;

			DoCommandP(v->tile, v->index, 1 << 16, NULL, CMD_SEND_AIRCRAFT_TO_HANGAR | CMD_SHOW_NO_ERROR);

			_current_player = OWNER_NONE;

		}

	}

void GenerateTrees(void);

void ConvertGroundTilesIntoWaterTiles(void);

void InitializeGame(uint size_x, uint size_y)

{

	AllocateMap(size_x, size_y);

	AddTypeToEngines(); // make sure all engines have a type

	SetObjectToPlace(SPR_CURSOR_ZZZ, 0, 0, 0);

	_pause = 0;

	_fast_forward = 0;

				NetworkSend_Command(0, 0, 0, CMD_PLAYER_CTRL, NULL);

				_local_player = OWNER_SPECTATOR;

			}

		} else {

			// take control over an existing company

			_local_player = _network_playas - 1;

			DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);

		}

	}

	return NETWORK_RECV_STATUS_OKAY;

}

		_local_player = OWNER_SPECTATOR;

	} else {

		// Create a single player

		DoStartupNewPlayer(false);

		_local_player = 0;

	}

	MarkWholeScreenDirty();

}

static void MakeNewEditorWorld(void)

	// Inititalize data

	StartupPlayers();

	StartupEngines();

	StartupDisasters();

	_local_player = 0;

	MarkWholeScreenDirty();

}

bool SafeSaveOrLoad(const char *filename, int mode, int newgm)

{

				CLRBIT(_m[tile].m4, 2);

				SETBIT(_m[tile].m4, 3);

			}

		} END_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0);

	}

	FOR_ALL_PLAYERS(p) {

		p->avail_railtypes = GetPlayerRailtypes(p->index);

	}

	return true;

}

	PlayerAI ai;

	PlayerAiNew ainew;

	int64 yearly_expenses[3][13];

	PlayerEconomyEntry cur_economy;

	PlayerEconomyEntry old_economy[24];

} Player;

void ChangeOwnershipOfPlayerItems(byte old_player, byte new_player);

void GetNameOfOwner(byte owner, TileIndex tile);

int64 CalculateCompanyValue(Player *p);

void InvalidatePlayerWindows(Player *p);

	return NULL;

}

Player *DoStartupNewPlayer(bool is_ai)

{

	Player *p;

	p = AllocatePlayer();

	if (p == NULL) return NULL;

	index = p->index;

	p->share_owners[0] = p->share_owners[1] = p->share_owners[2] = p->share_owners[3] = 0xFF;

	p->avail_railtypes = GetPlayerRailtypes(index);

	p->inaugurated_year = _cur_year;

	p->face = Random();

	GeneratePresidentName(p);

	InvalidateWindow(WC_GRAPH_LEGEND, 0);

	InvalidateWindow(WC_TOOLBAR_MENU, 0);

	InvalidateWindow(WC_CLIENT_LIST, 0);

	DeleteName(p->name_1);

	DeleteName(p->president_name_1);

	p->name_1 = 0;

	p->president_name_1 = 0;

}

/** Control the players: add, delete, etc.

 * @param x,y unused

 * @param p1 various functionality

 * - p1 = 0 - create a new player, Which player (network) it will be is in p2

 * - p1 = 1 - create a new AI player

 * - p1 = 2 - delete a player. Player is identified by p2

			if (_local_player == OWNER_SPECTATOR) {

				/* Check if we do not want to be a spectator in network */

				if (!_networking ||  (_network_server && !_network_dedicated) || _network_playas != OWNER_SPECTATOR) {

					_local_player = p->index;

					MarkWholeScreenDirty();

				}

			}

#ifdef ENABLE_NETWORK

			if (_network_server) {

				/* XXX - UGLY! p2 (pid) is mis-used to fetch the client-id, done at server-side

				 * in network_server.c:838, function DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND) */

				NetworkClientInfo *ci = &_network_client_info[pid];

	SLE_CONDARR(Player,yearly_expenses,	SLE_FILE_I32|SLE_VAR_I64, 3*13, 0, 1),

	SLE_CONDARR(Player,yearly_expenses,	SLE_INT64, 3*13, 2, 255),

	SLE_CONDVAR(Player,is_ai,			SLE_UINT8, 2, 255),

	SLE_CONDVAR(Player,is_active,	SLE_UINT8, 4, 255),

	// reserve extra space in savegame here. (currently 64 bytes)

	SLE_CONDARR(NullStruct,null,SLE_FILE_U64 | SLE_VAR_NULL, 8, 2, 255),

	SLE_END()

};

		/* Offset of snow tiles */

		SPR_RAIL_SNOW_OFFSET,

		/* Compatible railtypes */

		(1 << RAILTYPE_RAIL),

		/* main offset */

		0,

	},

	/** Monorail */

	{ /* Main Sprites */

#include "town.h"

#include "player.h"

#include "saveload.h"

#include "variables.h"

enum {

	SAVEGAME_MINOR_VERSION = 0,

	SAVEGAME_LOADABLE_VERSION = (SAVEGAME_MAJOR_VERSION << 8) + SAVEGAME_MINOR_VERSION

};

enum NeedLengthValues {NL_NONE = 0, NL_WANTLENGTH = 1, NL_CALCLENGTH = 2};

	if (!warning)

		ShowErrorMessage(-1, STR_CONFIG_PATCHES_SERVICE_INTERVAL_INCOMPATIBLE, 0, 0);

	return InValidateDetailsWindow(0);

}

typedef int32 PatchButtonClick(int32);

typedef struct PatchEntry {

  byte type;                    // type of selector

  byte flags;                   // selector flags

  StringID str;                 // string with descriptive text

	{PE_BOOL,		PF_PLAYERBASED, STR_CONFIG_PATCHES_WARN_INCOME_LESS, "train_income_warn", &_patches.train_income_warn,				0,  0,  0, NULL},

	{PE_UINT8,	PF_MULTISTRING | PF_PLAYERBASED, STR_CONFIG_PATCHES_ORDER_REVIEW, "order_review_system", &_patches.order_review_system,0,2,  1, NULL},

	{PE_BOOL,		0, STR_CONFIG_PATCHES_NEVER_EXPIRE_VEHICLES, "never_expire_vehicles", &_patches.never_expire_vehicles,0,0,0, NULL},

	{PE_UINT16, PF_0ISDIS | PF_PLAYERBASED, STR_CONFIG_PATCHES_LOST_TRAIN_DAYS, "lost_train_days", &_patches.lost_train_days,	180,720, 60, NULL},

	{PE_UINT16,	0, STR_CONFIG_PATCHES_MAX_TRAINS,				"max_trains", &_patches.max_trains,								0,5000, 50, NULL},

	{PE_UINT16,	0, STR_CONFIG_PATCHES_MAX_ROADVEH,			"max_roadveh", &_patches.max_roadveh,							0,5000, 50, NULL},

	{PE_UINT16,	0, STR_CONFIG_PATCHES_MAX_AIRCRAFT,			"max_aircraft", &_patches.max_aircraft,						0,5000, 50, NULL},

	{PE_UINT16,	0, STR_CONFIG_PATCHES_MAX_SHIPS,				"max_ships", &_patches.max_ships,									0,5000, 50, NULL},

extern const SpriteID _water_shore_sprites[15];

extern void DrawCanalWater(TileIndex tile);

const Bridge _bridge[] = {

/*

	   |  minimum length

	   |  |   maximum length

	   |  |   |    price

	   |  |   |    |    maximum speed

	   |  |   |    |    |  sprite to use in GUI                string with description

	   |  |   |    |    |  |                                   |                            */

#define MAX_BRIDGES 13

/* For new pathfinding. Define here so it is globally available without having

 * to include npf.h */

#define NPF_TILE_LENGTH 100

/* Forking stuff */

VARDEF bool _dedicated_forks;

#endif /* VARIABLES_H */

static void ShowVehicleGettingOld(Vehicle *v, StringID msg)

{

	if (v->owner != _local_player)

		return;

	// Do not show getting-old message if autorenew is active

		return;

	SetDParam(0, _vehicle_type_names[v->type - 0x10]);

	SetDParam(1, v->unitnumber);

	AddNewsItem(msg, NEWS_FLAGS(NM_SMALL, NF_VIEWPORT|NF_VEHICLE, NT_ADVICE, 0), v->index, 0);

}

extern int32 EstimateShipCost(EngineID engine_type);

extern int32 EstimateAircraftCost(EngineID engine_type);

extern int32 CmdRefitRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2);

extern int32 CmdRefitShip(int x, int y, uint32 flags, uint32 p1, uint32 p2);

extern int32 CmdRefitAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2);

/** Replaces a vehicle (used to be called autorenew).

 */

{

	int cost, build_cost, rear_engine_cost = 0;

	/* First we make sure that it's a valid type the user requested

	 * check that it's an engine that is in the engine array */

	if (!IsEngineIndex(new_engine_type)) return CMD_ERROR;

	// check that the new vehicle type is the same as the original one

			 }

		}

	}

	/* Check if there is money for the upgrade.. if not, give a nice news-item

	    (that is needed, because this CMD is called automaticly) */

		if (( _local_player == v->owner ) && ( v->unitnumber != 0 )) {  //v->unitnumber = 0 for train cars

			int message;

			SetDParam(0, v->unitnumber);

			switch (v->type) {

				case VEH_Train:    message = STR_TRAIN_AUTORENEW_FAILED;       break;

				case VEH_Road:     message = STR_ROADVEHICLE_AUTORENEW_FAILED; break;

		}

		return CMD_ERROR;

	}

	cost = build_cost - v->value + rear_engine_cost;

		/* We do not really buy a new vehicle, we upgrade the old one */

		const Engine* e = GetEngine(new_engine_type);

		v->reliability = e->reliability;

		v->reliability_spd_dec = e->reliability_spd_dec;

		v->age = 0;

				if ( v->cargo_type != cargo_type )

					v->cargo_count = 0;

				else if ( v->cargo_count > v->cargo_cap )

					v->cargo_count = v->cargo_cap;

			}

		}

	}

	//needs to be down here because refitting will change SET_EXPENSES_TYPE if called

	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);

	return cost;

}

void MaybeReplaceVehicle(Vehicle *v)

{

	// uncomment next line if you want to see what engine type just entered a depot

	//printf("engine type: %d\n", v->engine_type);

	// A vehicle is autorenewed when it it gets the amount of months

	//  give by _patches.autorenew_months away for his max age.

	//  Standard is -6, meaning 6 months before his max age

	//  It can be any value between -12 and 12.

	//  Here it also checks if the vehicles is listed for replacement

			return;

	}

	/* Now replace the vehicle */

	_current_player = v->owner;

	if ( v->type != VEH_Train ) {

	} else {

	// checks if any of the engines in the train are either old or listed for replacement

		do {

			}

		} while ((v=v->next) != NULL);

	}

	_current_player = OWNER_NONE;

}

VARDEF byte _cmd_build_rail_veh_var1;

// for each player, for each vehicle type, keep a list of the vehicles.

//VARDEF Vehicle *_vehicle_arr[8][4];

#define INVALID_VEHICLE 0xFFFF

/* A lot of code calls for the invalidation of the status bar, which is widget 5.

 * Best is to have a virtual value for it when it needs to change again */

#define STATUS_BAR 5

#endif /* VEHICLE_H */

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

{

	// these 3 variables is used if any of the lists is clicked

	uint16 click_scroll_pos = w->vscroll2.pos;

	uint16 click_scroll_cap = w->vscroll2.cap;

	byte click_side = 1;

	switch(e->event) {

		case WE_PAINT:

			{

				int pos = w->vscroll.pos;

				int selected_id[2] = {-1,-1};

						return;

					} else { //there are no vehicles in the right window

						selected_id[1] = -1;

					}

				}

					|| selected_id[0] == -1 || selected_id[1] == -1 )

					SETBIT(w->disabled_state, 4);

				else

					CLRBIT(w->disabled_state, 4);

					SETBIT(w->disabled_state, 6);

				else

					CLRBIT(w->disabled_state, 6);

				// now the actual drawing of the window itself takes place

				DrawWindowWidgets(w);

				// sets up the string for the vehicle that is being replaced to

				if ( selected_id[0] != -1 ) {

						SetDParam(0, STR_NOT_REPLACING);

					else

				} else {

					SetDParam(0, STR_NOT_REPLACING_VEHICLE_SELECTED);

				}

				DrawString(145, (w->resize.step_height == 24 ? 77 : 87 ) + ( w->resize.step_height * w->vscroll.cap), STR_02BD, 0x10);

		case WE_CLICK: {

			switch(e->click.widget) {

				case 14: case 15: { /* Select sorting criteria dropdown menu */

					ShowDropDownMenu(w, _rail_types_list, _railtype_selected_in_replace_gui, 15, ~GetPlayer(_local_player)->avail_railtypes, 1);