static void AiHandleTakeover(Player *p)

{

	if (p->bankrupt_timeout != 0) {

		p->bankrupt_timeout -= 8;

		if (p->bankrupt_timeout > 0) return;

		p->bankrupt_timeout = 0;

		DeleteWindowById(WC_BUY_COMPANY, _current_player);

		if (IsLocalPlayer()) {

			AskExitToGameMenu();

			return;

		}

	}

	if (p->bankrupt_asked == 255) return;

	{

		uint asked = p->bankrupt_asked;

		Player *pp, *best_pl = NULL;

		int32 best_val = -1;

		uint old_p;

		// Ask the guy with the highest performance hist.

		FOR_ALL_PLAYERS(pp) {

		if (best_val == -1) {

			p->bankrupt_asked = 255;

			return;

		}

		SETBIT(p->bankrupt_asked, best_pl->index);

		if (best_pl->index == _local_player) {

			p->bankrupt_timeout = 4440;

			ShowBuyCompanyDialog(_current_player);

			return;

		}

		// Too little money for computer to buy it?

		if (best_pl->player_money >> 1 >= p->bankrupt_value) {

			// Computer wants to buy it.

			old_p = _current_player;

			_current_player = p->index;

			DoCommand(0, old_p, 0, DC_EXEC, CMD_BUY_COMPANY);

			_current_player = old_p;

		}

	}

}

{

	if (p->bankrupt_asked != 0) {

		AiHandleTakeover(p);

		return;

	}

	// Ugly hack to make sure the service interval of the AI is good, not looking

	//  to the patch-setting

	// Also, it takes into account the setting if the service-interval is in days

	//  or in %

	_ai_service_interval = _patches.servint_ispercent?80:180;

	AiAdjustLoan(p);

	AiBuildCompanyHQ(p);

#if 0

	{

		static byte old_state = 99;

		static bool hasdots = false;

		char *_ai_state_names[]={

			"AiCase0",

			"AiCase1",

			"AiStateVehLoop",

	}

	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);

	} else {

		pass = callback;

	}

	_returned_refit_capacity = pass;

	cost = 0;

		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;

		u->cargo_cap = mail;

		if (v->cargo_type == new_cid) {

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

#include "airport.h"

#include "sound.h"

#include "variables.h"

#include "table/sprites.h"

#include "date.h"

static void DisasterClearSquare(TileIndex tile)

{

	if (!EnsureNoVehicle(tile)) return;

	switch (GetTileType(tile)) {

		case MP_RAILWAY:

				PlayerID p = _current_player;

				_current_player = OWNER_WATER;

				DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);

				_current_player = p;

			}

			break;

		case MP_HOUSE: {

			PlayerID p = _current_player;

			_current_player = OWNER_NONE;

			DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);

			_current_player = p;

				v->age = 0;

			}

			if ((v->tick_counter&7)==0) {

				CreateEffectVehicleRel(v, 0, -17, 2, EV_SMOKE);

			}

		} else if (v->current_order.dest == 0) {

			tile = v->tile; /**/

			if (IsValidTile(tile) &&

					IsTileType(tile, MP_STATION) &&

					IsAirport(tile) &&

				v->current_order.dest = 1;

				v->age = 0;

				SetDParam(0, GetStationIndex(tile));

				AddNewsItem(STR_B000_ZEPPELIN_DISASTER_AT,

					NEWS_FLAGS(NM_THIN, NF_VIEWPORT|NF_VEHICLE, NT_ACCIDENT, 0),

					v->index,

					0);

			}

		}

		if (v->y_pos >= ((int)MapSizeY() + 9) * TILE_SIZE - 1)

			DeleteDisasterVeh(v);

		return;

	}

	if (v->current_order.dest > 2) {

		if (++v->age <= 13320)

			return;

		tile = v->tile; /**/

		if (IsValidTile(tile) &&

				IsTileType(tile, MP_STATION) &&

				IsAirport(tile) &&

			st = GetStationByTile(tile);

			CLRBITS(st->airport_flags, RUNWAY_IN_block);

		}

		SetDisasterVehiclePos(v, v->x_pos, v->y_pos, v->z_pos);

		DeleteDisasterVeh(v);

		return;

	}

	x = v->x_pos;

	y = v->y_pos;

	z = GetSlopeZ(x,y);

				GB(r, 8, 3) + 5,

				EV_EXPLOSION_SMALL);

		}

	} else if (v->age == 350) {

		v->current_order.dest = 3;

		v->age = 0;

	}

	tile = v->tile;/**/

	if (IsValidTile(tile) &&

			IsTileType(tile, MP_STATION) &&

			IsAirport(tile) &&

		st = GetStationByTile(tile);

		SETBITS(st->airport_flags, RUNWAY_IN_block);

	}

}

// UFO starts in the middle, and flies around a bit until it locates

// a road vehicle which it targets.

static void DisasterTick_UFO(Vehicle *v)

{

	GetNewVehiclePosResult gp;

	Vehicle *u;

	uint dist;

			v->direction = GetDirectionTowards(v, x, y);

			GetNewVehiclePos(v, &gp);

			SetDisasterVehiclePos(v, gp.x, gp.y, v->z_pos);

			return;

		}

		if (++v->age < 6) {

			v->dest_tile = RandomTile();

			return;

		}

		v->current_order.dest = 1;

		FOR_ALL_VEHICLES(u) {

				v->dest_tile = u->index;

				v->age = 0;

				return;

			}

		}

		DeleteDisasterVeh(v);

	} else {

// target a vehicle

		u = GetVehicle(v->dest_tile);

		if (u->type != VEH_Road) {

			DeleteDisasterVeh(v);

		}

		if (++v->age < 6) {

			v->dest_tile = RandomTile();

			return;

		}

		v->current_order.dest = 1;

		tile_org = tile = RandomTile();

		do {

			if (IsTileType(tile, MP_RAILWAY) &&

					IsPlainRailTile(tile) &&

				break;

			}

			tile = TILE_MASK(tile+1);

		} while (tile != tile_org);

		v->dest_tile = tile;

		v->age = 0;

	} else {

		return;

	}

}

// The plane which will shoot down the UFO

	Vehicle *v = ForceAllocateSpecialVehicle(), *u;

	Station *st;

	int x;

	if (v == NULL) return;

	/* Pick a random place, unless we find a small airport */

	x = TileX(Random()) * TILE_SIZE + TILE_SIZE / 2;

	FOR_ALL_STATIONS(st) {

		if (st->airport_tile != 0 &&

				st->airport_type <= 1 &&

			x = (TileX(st->xy) + 2) * TILE_SIZE;

			break;

		}

	}

	InitializeDisasterVehicle(v, x, 0, 135, DIR_SE, 0);

	// Allocate shadow too?

	u = ForceAllocateSpecialVehicle();

	if (u != NULL) {

		v->next = u;

		InitializeDisasterVehicle(u, x, 0, 0, DIR_SE, 1);

	p->quarters_of_bankrupcy++;

	owner = p->index;

	switch (p->quarters_of_bankrupcy) {

		case 2:

			AddNewsItem( (StringID)(owner + 16),

				NEWS_FLAGS(NM_CALLBACK, 0, NT_COMPANY_INFO, DNC_BANKRUPCY),0,0);

			break;

		case 3: {

			/* XXX - In multiplayer, should we ask other players if it wants to take

		          over when it is a human company? -- TrueLight */

				AddNewsItem( (StringID)(owner + 16),

					NEWS_FLAGS(NM_CALLBACK, 0, NT_COMPANY_INFO, DNC_BANKRUPCY),0,0);

				break;

			}

			// Check if the company has any value.. if not, declare it bankrupt

			//  right now

			val = CalculateCompanyValue(p);

			if (val > 0) {

				p->bankrupt_value = val;

				p->bankrupt_asked = 1 << owner; // Don't ask the owner

				p->bankrupt_timeout = 0;

			// Else, falltrue to case 4...

		}

		case 4: {

			// Close everything the owner has open

			DeletePlayerWindows(owner);

//		Show bankrupt news

			SetDParam(0, p->name_1);

			SetDParam(1, p->name_2);

			AddNewsItem( (StringID)(owner + 16*3), NEWS_FLAGS(NM_CALLBACK, 0, NT_COMPANY_INFO, DNC_BANKRUPCY),0,0);

			// If the player is human, and it is no network play, leave the player playing

				p->bankrupt_asked = 255;

				p->bankrupt_timeout = 0x456;

			} else {

#ifdef ENABLE_NETWORK

					// If we are the server, make sure it is clear that his player is no

					//  longer with us!

					NetworkClientInfo *ci;

					NetworkClientState *cs;

					/* Find all clients that were in control of this company */

					FOR_ALL_CLIENTS(cs) {

						ci = DEREF_CLIENT_INFO(cs);

						if ((ci->client_playas-1) == owner) {

							ci->client_playas = OWNER_SPECTATOR;

							// Send the new info to all the clients

							NetworkUpdateClientInfo(_network_own_client_index);

						}

					}

				}

				// Make sure the player no longer controls the company

					// Switch the player to spectator..

					_local_player = OWNER_SPECTATOR;

				}

#endif /* ENABLE_NETWORK */

				/* Remove the player */

				ChangeOwnershipOfPlayerItems(owner, OWNER_SPECTATOR);

				// Register the player as not-active

				p->is_active = false;

					AI_PlayerDied(owner);

					AI_PlayerDied(owner);

			}

		}

	}

}

void DrawNewsBankrupcy(Window *w)

{

	Player *p;

	DrawNewsBorder(w);

					e->flags &= ~ENGINE_PREVIEWING;

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

					e->preview_player++;

				}

			} else if (e->preview_player != 0xFF) {

				PlayerID best_player = GetBestPlayer(e->preview_player);

				if (best_player == OWNER_SPECTATOR) {

					e->preview_player = 0xFF;

					continue;

				}

					/* XXX - TTDBUG: TTD has a bug here ???? */

					AcceptEnginePreview(e, best_player);

				} else {

					e->flags |= ENGINE_PREVIEWING;

					e->preview_wait = 20;

				}

			}

		}

	}

}

/** Accept an engine prototype. XXX - it is possible that the top-player

 * changes while you are waiting to accept the offer? Then it becomes invalid

 * @param tile unused

 * @param p1 engine-prototype offered

 * @param p2 unused

 */

{

	Player *p;

	p = GetPlayer(_current_player);

	if (p->current_loan >= _economy.max_loan) {

		SetDParam(0, _economy.max_loan);

		return_cmd_error(STR_702B_MAXIMUM_PERMITTED_LOAN);

	}

	if (flags & DC_EXEC) {

		/* Loan the maximum amount or not? */

		p->money64 += loan;

		p->current_loan += loan;

		UpdatePlayerMoney32(p);

		InvalidatePlayerWindows(p);

	}

	return 0;

}

/** Decrease the loan of your company.

 * @param tile unused

	if (p->current_loan == 0) return_cmd_error(STR_702D_LOAN_ALREADY_REPAYED);

	loan = p->current_loan;

	/* p2 is true while CTRL is pressed (repay all possible loan, or max money you have)

	 * Repay any loan in chunks of 10.000 pounds */

	if (p2) {

		loan = min(loan, p->player_money);

		loan = max(loan, 10000);

		loan -= loan % 10000;

	} else {

	}

	if (p->player_money < loan) {

		SetDParam(0, loan);

		return_cmd_error(STR_702E_REQUIRED);

	}

	if (flags & DC_EXEC) {

		p->money64 -= loan;

		p->current_loan -= loan;

		UpdatePlayerMoney32(p);

		InvalidatePlayerWindows(p);

	if (p->player_money == 893288)

		p->money64 = p->player_money = p->current_loan = 100000;

	_player_colors[num] = p->player_color;

	p->inaugurated_year = _old_inaugurated_year;

	if (p->location_of_house == 0xFFFF)

		p->location_of_house = 0;

	/* State 20 for AI players is sell vehicle. Since the AI struct is not

	 * really figured out as of now, p->ai.cur_veh; needed for 'sell vehicle'

	 * is NULL and the function will crash. To fix this, just change the state

	 * to some harmless state, like 'loop vehicle'; 1 */

	if (p->is_ai && (!_networking || _network_server) && _ai.enabled)

		AI_StartNewAI(p->index);

	return true;

}

static uint32 _old_order_ptr;

static uint16 _old_next_ptr;

static uint32 _current_vehicle_id;

static const OldChunks vehicle_train_chunk[] = {

	}

	if (sel_ord > v->num_orders) return CMD_ERROR;

	if (IsOrderPoolFull()) return_cmd_error(STR_8831_NO_MORE_SPACE_FOR_ORDERS);

	/* XXX - This limit is only here because the backuppedorders can't

	 * handle any more then this.. */

	if (v->num_orders >= MAX_BACKUP_ORDER_COUNT) return_cmd_error(STR_8832_TOO_MANY_ORDERS);

	/* For ships, make sure that the station is not too far away from the

	 * previous destination, for human players with new pathfinding disabled */

		sel_ord != 0 && GetVehicleOrder(v, sel_ord - 1)->type == OT_GOTO_STATION

		&& !_patches.new_pathfinding_all) {

		int dist = DistanceManhattan(

			GetStation(GetVehicleOrder(v, sel_ord - 1)->dest)->xy,

			GetStation(new_order.dest)->xy // XXX type != OT_GOTO_STATION?

		);

		if (dist >= 130)

			return_cmd_error(STR_0210_TOO_FAR_FROM_PREVIOUS_DESTINATIO);

	}

	if (flags & DC_EXEC) {

	return _local_player == _current_player;

}

void DeletePlayerWindows(PlayerID pi);

byte GetPlayerRailtypes(PlayerID p);

/** Finds out if a Player has a certain railtype available */

static inline bool HasRailtypeAvail(const Player *p, RailType Railtype)

{

	return HASBIT(p->avail_railtypes, Railtype);

}

/* Validate functions for rail building */

static inline bool ValParamRailtype(uint32 rail) { return HASBIT(GetPlayer(_current_player)->avail_railtypes, rail);}

/** Returns the "best" railtype a player can build.

 * As the AI doesn't know what the BEST one is, we have our own priority list

 * here. When adding new railtypes, modify this function

 * @param p the player "in action"

 * @return The "best" railtype a player has available

 */

static inline RailType GetBestRailtype(const Player* p)

{

	if (HasRailtypeAvail(p, RAILTYPE_MAGLEV)) return RAILTYPE_MAGLEV;

	if (HasRailtypeAvail(p, RAILTYPE_MONO)) return RAILTYPE_MONO;

	if (HasRailtypeAvail(p, RAILTYPE_ELECTRIC)) return RAILTYPE_ELECTRIC;

	return RAILTYPE_RAIL;

}

typedef struct HighScore {

	char company[100];

	StringID title; // NO_SAVE, has troubles with changing string-numbers.

	uint16 score;   // do NOT change type, will break hs.dat

} HighScore;

VARDEF HighScore _highscore_table[5][5]; // 4 difficulty-settings (+ network); top 5

void SaveToHighScore(void);

void LoadFromHighScore(void);

int8 SaveHighScoreValue(const Player *p);

int8 SaveHighScoreValueNetwork(void);

		}

		GetString(buffer, str);

		if (strlen(buffer) >= 32 || GetStringBoundingBox(buffer).width >= 150)

			goto bad_town_name;

set_name:;

		p->name_1 = str;

		p->name_2 = strp;

		MarkWholeScreenDirty();

			SetDParam(0, t->index);

			AddNewsItem(p->index + (4 << 4), NEWS_FLAGS(NM_CALLBACK, NF_TILE, NT_COMPANY_INFO, DNC_BANKRUPCY), p->last_build_coordinate, 0);

		}

		return;

	}

bad_town_name:;

	if (p->president_name_1 == SPECSTR_PRESIDENT_NAME) {

		str = SPECSTR_ANDCO_NAME;

		strp = p->president_name_2;

		goto set_name;

	} else {

	p = GetPlayer(_cur_player_tick_index);

	_cur_player_tick_index = (_cur_player_tick_index + 1) % MAX_PLAYERS;

	if (p->name_1 != 0) GenerateCompanyName(p);

	if (AI_AllowNewAI() && _game_mode != GM_MENU && !--_next_competitor_start)

		MaybeStartNewPlayer();

}

// index is the next parameter in _decode_parameters to set up

StringID GetPlayerNameString(PlayerID player, uint index)

{

		SetDParam(index, player+1);

		return STR_7002_PLAYER;

	}

	return STR_EMPTY;

}

extern void ShowPlayerFinances(int player);

void PlayersYearlyLoop(void)

{

	Player *p;

		break;

	case 2: { /* Delete a player */

		Player *p;

		if (p2 >= MAX_PLAYERS) return CMD_ERROR;

		if (!(flags & DC_EXEC)) return 0;

		p = GetPlayer(p2);

		/* Only allow removal of HUMAN companies */

			/* Delete any open window of the company */

			DeletePlayerWindows(p->index);

			/* Show the bankrupt news */

			SetDParam(0, p->name_1);

			SetDParam(1, p->name_2);

			AddNewsItem( (StringID)(p->index + 16*3), NEWS_FLAGS(NM_CALLBACK, 0, NT_COMPANY_INFO, DNC_BANKRUPCY),0,0);

			/* Remove the company */

			ChangeOwnershipOfPlayerItems(p->index, OWNER_SPECTATOR);

			p->is_active = false;

		}

	SLE_CONDVAR(Livery, colour1, SLE_UINT8, 34, SL_MAX_VERSION),

	SLE_CONDVAR(Livery, colour2, SLE_UINT8, 34, SL_MAX_VERSION),

	SLE_END()

};

static void SaveLoad_PLYR(Player* p)

{

	int i;

	SlObject(p, _player_desc);

	// Write AI?

		SlObject(&p->ai, _player_ai_desc);

		for (i = 0; i != p->ai.num_build_rec; i++) {

			SlObject(&p->ai.src + i, _player_ai_build_rec_desc);

		}

	}

	// Write economy

	SlObject(&p->cur_economy, _player_economy_desc);

	// Write old economy entries.

	for (i = 0; i < p->num_valid_stat_ent; i++) {

		SlObject(&p->old_economy[i], _player_economy_desc);

			default:       capacity *= 4; break;

		}

		switch (new_cid) {

			case CT_PASSENGERS: break;

			case CT_MAIL:

			case CT_GOODS: capacity /= 2; break;

			default:       capacity /= 4; break;

		}

	}

	_returned_refit_capacity = capacity;

	cost = 0;

		cost = GetRefitCost(v->engine_type);