Changeset - r2293:b55e49a164c0
[Not reviewed]
master
0 14 0
bjarni - 19 years ago 2005-08-06 16:07:22
bjarni@openttd.org
(svn r2817) -Codechange: [autoreplace]: moved autoreplace and autorenew to serverside
-This means that one company can only have one setting for renew and replacing
more clients will not fight due to different settings anymore
-This is a needed step in the line to fix autoreplacing dualheaded locomotives
NOTE: savegame revision bump (peter1138 + me in coop)
14 files changed with 234 insertions and 75 deletions:
0 comments (0 inline, 0 general)
aircraft_cmd.c
Show inline comments
 
@@ -1502,56 +1502,57 @@ static void AircraftEventHandler_General
 
	DEBUG(misc, 0) ("OK, you shouldn't be here, check your Airport Scheme!");
 
	assert(0);
 
}
 

	
 
static void AircraftEventHandler_TakeOff(Vehicle *v, const AirportFTAClass *Airport) {
 
	PlayAircraftSound(v); // play takeoffsound for airplanes
 
	v->u.air.state = STARTTAKEOFF;
 
}
 

	
 
static void AircraftEventHandler_StartTakeOff(Vehicle *v, const AirportFTAClass *Airport)
 
{
 
	v->sprite_width = v->sprite_height = 24; // ??? no idea what this is
 
	v->u.air.state = ENDTAKEOFF;
 
}
 

	
 
static void AircraftEventHandler_EndTakeOff(Vehicle *v, const AirportFTAClass *Airport)
 
{
 
	v->u.air.state = FLYING;
 
	// get the next position to go to, differs per airport
 
	AircraftNextAirportPos_and_Order(v);
 
}
 

	
 
static void AircraftEventHandler_HeliTakeOff(Vehicle *v, const AirportFTAClass *Airport)
 
{
 
	Player *p = GetPlayer(v->owner);
 
	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
 
	if ((v->owner == _local_player && _autoreplace_array[v->engine_type] != v->engine_type) ||
 
		(v->owner == _local_player && _patches.autorenew && v->age - v->max_age > (_patches.autorenew_months * 30))) {
 
	if ((v->owner == _local_player && p->engine_replacement[v->engine_type] != v->engine_type) ||
 
		(v->owner == _local_player && p->engine_renew && v->age - v->max_age > (p->engine_renew_months * 30))) {
 
		_current_player = _local_player;
 
		DoCommandP(v->tile, v->index, 1, NULL, CMD_SEND_AIRCRAFT_TO_HANGAR | CMD_SHOW_NO_ERROR);
 
		_current_player = OWNER_NONE;
 
	}
 
}
 

	
 
static void AircraftEventHandler_Flying(Vehicle *v, const AirportFTAClass *Airport)
 
{
 
	Station *st;
 
	byte landingtype;
 
	AirportFTA *current;
 
	uint16 tcur_speed, tsubspeed;
 

	
 
	st = GetStation(v->u.air.targetairport);
 
	// flying device is accepted at this station
 
	// small airport --> no helicopters (AIRCRAFT_ONLY)
 
	// all other airports --> all types of flying devices (ALL)
 
	// heliport/oilrig, etc --> no airplanes (HELICOPTERS_ONLY)
 
	// runway busy or not allowed to use this airstation, circle
 
	if (! (v->subtype == Airport->acc_planes ||
 
			st->airport_tile == 0 || (st->owner != OWNER_NONE && st->owner != v->owner) )) {
 

	
 
		// {32,FLYING,NOTHING_block,37}, {32,LANDING,N,33}, {32,HELILANDING,N,41},
 
		// if it is an airplane, look for LANDING, for helicopter HELILANDING
 
@@ -1565,55 +1566,56 @@ static void AircraftEventHandler_Flying(
 
				// hack for speed thingie
 
				tcur_speed = v->cur_speed;
 
				tsubspeed = v->subspeed;
 
				if (!AirportHasBlock(v, current, Airport)) {
 
					v->u.air.state = landingtype; // LANDING / HELILANDING
 
					// it's a bit dirty, but I need to set position to next position, otherwise
 
					// if there are multiple runways, plane won't know which one it took (because
 
					// they all have heading LANDING). And also occupy that block!
 
					v->u.air.pos = current->next_position;
 
					SETBITS(st->airport_flags, Airport->layout[v->u.air.pos].block);
 
					return;
 
				}
 
				v->cur_speed = tcur_speed;
 
				v->subspeed = tsubspeed;
 
			}
 
			current = current->next_in_chain;
 
		}
 
	}
 
	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)
 
{
 
	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)
 
		if ((_autoreplace_array[v->engine_type] != v->engine_type) ||
 
			(_patches.autorenew && v->age - v->max_age > (_patches.autorenew_months * 30))) {
 
		if ((p->engine_replacement[v->engine_type] != 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 (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;
 
		}
 
	}
 
}
 

	
 
static void AircraftEventHandler_HeliLanding(Vehicle *v, const AirportFTAClass *Airport)
 
{
 
	AircraftLand(v); // helicopters don't crash
 
	v->u.air.state = HELIENDLANDING;
 
}
 

	
 
static void AircraftEventHandler_EndLanding(Vehicle *v, const AirportFTAClass *Airport)
 
{
 
	// next block busy, don't do a thing, just wait
 
	if(AirportHasBlock(v, &Airport->layout[v->u.air.pos], Airport)) {return;}
 

	
 
	// 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) {
misc.c
Show inline comments
 
@@ -101,56 +101,50 @@ void InitializeLandscape(void);
 
void InitializeTowns(void);
 
void InitializeTrees(void);
 
void InitializeSigns(void);
 
void InitializeStations(void);
 
static void InitializeNameMgr(void);
 
void InitializePlayers(void);
 
static void InitializeCheats(void);
 
void InitializeNPF(void);
 

	
 
void GenerateLandscape(void);
 
void GenerateClearTile(void);
 

	
 
void GenerateIndustries(void);
 
void GenerateUnmovables(void);
 
void GenerateTowns(void);
 

	
 
void StartupPlayers(void);
 
void StartupDisasters(void);
 
void GenerateTrees(void);
 

	
 
void ConvertGroundTilesIntoWaterTiles(void);
 

	
 
void InitializeGame(uint size_x, uint size_y)
 
{
 
	uint i;
 

	
 
	AllocateMap(size_x, size_y);
 

	
 
	// Initialize the autoreplace array. Needs to be cleared between each game
 
	for (i = 0; i < lengthof(_autoreplace_array); i++)
 
		_autoreplace_array[i] = i;
 

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

	
 
	SetObjectToPlace(SPR_CURSOR_ZZZ, 0, 0, 0);
 

	
 
	_pause = 0;
 
	_fast_forward = 0;
 
	_tick_counter = 0;
 
	_date_fract = 0;
 
	_cur_tileloop_tile = 0;
 

	
 
	{
 
		uint starting = ConvertIntDate(_patches.starting_date);
 
		if ( starting == (uint)-1) starting = 10958;
 
		SetDate(starting);
 
	}
 

	
 
	InitializeVehicles();
 
	InitializeWaypoints();
 
	InitializeDepot();
 
	InitializeOrders();
 

	
 
	InitNewsItemStructs();
 
	InitializeLandscape();
 
	InitializeClearLand();
network_client.c
Show inline comments
 
@@ -506,48 +506,51 @@ DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER
 
		}
 

	
 
		_opt_ptr = &_opt; // during a network game you are always in-game
 

	
 
		// Say we received the map and loaded it correctly!
 
		SEND_COMMAND(PACKET_CLIENT_MAP_OK)();
 

	
 
		if (_network_playas == 0 || _network_playas > MAX_PLAYERS ||
 
				!GetPlayer(_network_playas - 1)->is_active) {
 

	
 
			if (_network_playas == OWNER_SPECTATOR) {
 
				// The client wants to be a spectator..
 
				_local_player = OWNER_SPECTATOR;
 
				DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
 
			} else {
 
				/* We have arrived and ready to start playing; send a command to make a new player;
 
				 * the server will give us a client-id and let us in */
 
				_local_player = 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;
 
			_patches.autorenew = GetPlayer(_local_player)->engine_renew;
 
			_patches.autorenew_months = GetPlayer(_local_player)->engine_renew_months;
 
			_patches.autorenew_money = GetPlayer(_local_player)->engine_renew_money;
 
			DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
 
		}
 
	}
 

	
 
	return NETWORK_RECV_STATUS_OKAY;
 
}
 

	
 
DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_FRAME)
 
{
 
	_frame_counter_server = NetworkRecv_uint32(MY_CLIENT, p);
 
	_frame_counter_max = NetworkRecv_uint32(MY_CLIENT, p);
 
#ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME
 
	// Test if the server supports this option
 
	//  and if we are at the frame the server is
 
	if (p->pos < p->size) {
 
		_sync_frame = _frame_counter_server;
 
		_sync_seed_1 = NetworkRecv_uint32(MY_CLIENT, p);
 
#ifdef NETWORK_SEND_DOUBLE_SEED
 
		_sync_seed_2 = NetworkRecv_uint32(MY_CLIENT, p);
 
#endif
 
	}
 
#endif
 
	DEBUG(net, 7)("[NET] Received FRAME %d",_frame_counter_server);
 

	
openttd.c
Show inline comments
 
@@ -558,48 +558,50 @@ static void MakeNewGame(void)
 

	
 
	// Copy in game options
 
	_opt_ptr = &_opt;
 
	memcpy(_opt_ptr, &_opt_newgame, sizeof(GameOptions));
 

	
 
	GfxLoadSprites();
 

	
 
	// Reinitialize windows
 
	ResetWindowSystem();
 
	LoadStringWidthTable();
 

	
 
	SetupColorsAndInitialWindow();
 

	
 
	// Randomize world
 
	GenerateWorld(0, 1<<_patches.map_x, 1<<_patches.map_y);
 

	
 
	// In a dedicated server, the server does not play
 
	if (_network_dedicated) {
 
		_local_player = OWNER_SPECTATOR;
 
	} else {
 
		// Create a single player
 
		DoStartupNewPlayer(false);
 

	
 
		_local_player = 0;
 
		_current_player = _local_player;
 
		DoCommandP(0, (_patches.autorenew << 15 ) | (_patches.autorenew_months << 16) | 4, _patches.autorenew_money, NULL, CMD_REPLACE_VEHICLE);
 
	}
 

	
 
	MarkWholeScreenDirty();
 
}
 

	
 
static void MakeNewEditorWorld(void)
 
{
 
	_game_mode = GM_EDITOR;
 

	
 
	// Copy in game options
 
	_opt_ptr = &_opt;
 
	memcpy(_opt_ptr, &_opt_newgame, sizeof(GameOptions));
 

	
 
	GfxLoadSprites();
 

	
 
	// Re-init the windowing system
 
	ResetWindowSystem();
 

	
 
	// Create toolbars
 
	SetupColorsAndInitialWindow();
 

	
 
	// Startup the game system
 
	GenerateWorld(1, 1<<_patches.map_x, 1<<_patches.map_y);
 

	
 
@@ -630,48 +632,50 @@ static void StartScenario(void)
 
	GfxLoadSprites();
 

	
 
	// Reinitialize windows
 
	ResetWindowSystem();
 
	LoadStringWidthTable();
 

	
 
	SetupColorsAndInitialWindow();
 

	
 
	// Load game
 
	if (SaveOrLoad(_file_to_saveload.name, _file_to_saveload.mode) != SL_OK) {
 
		LoadIntroGame();
 
		ShowErrorMessage(_error_message, STR_4009_GAME_LOAD_FAILED, 0, 0);
 
	}
 

	
 
	_opt_ptr = &_opt;
 
	memcpy(&_opt_ptr->diff, &_opt_newgame.diff, sizeof(GameDifficulty));
 
	_opt.diff_level = _opt_newgame.diff_level;
 

	
 
	// Inititalize data
 
	StartupPlayers();
 
	StartupEngines();
 
	StartupDisasters();
 

	
 
	_local_player = 0;
 
	_current_player = _local_player;
 
	DoCommandP(0, (_patches.autorenew << 15 ) | (_patches.autorenew_months << 16) | 4, _patches.autorenew_money, NULL, CMD_REPLACE_VEHICLE);
 

	
 
	MarkWholeScreenDirty();
 
}
 

	
 
bool SafeSaveOrLoad(const char *filename, int mode, int newgm)
 
{
 
	byte ogm = _game_mode;
 
	int r;
 

	
 
	_game_mode = newgm;
 
	r = SaveOrLoad(filename, mode);
 
	if (r == SL_REINIT) {
 
		if (ogm == GM_MENU)
 
			LoadIntroGame();
 
		else if (ogm == GM_EDITOR)
 
			MakeNewEditorWorld();
 
		else
 
			MakeNewGame();
 
		return false;
 
	} else if (r != SL_OK) {
 
		_game_mode = ogm;
 
		return false;
 
	} else
 
		return true;
 
@@ -1221,30 +1225,47 @@ bool AfterLoadGame(uint version)
 
					SetTileType(tile, MP_STREET);
 
				} else {
 
					_m[tile].m2 = 0;
 
				}
 
			}
 
		} END_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0);
 
	}
 

	
 
	if (version < 0x900) {
 
		Town *t;
 
		FOR_ALL_TOWNS(t) {
 
			UpdateTownMaxPass(t);
 
		}
 
	}
 

	
 
	if (version < 0xF00) {
 
		BEGIN_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0) {
 
			if (IsTileType(tile, MP_RAILWAY) && HasSignals(tile) && HASBIT(_m[tile].m4, 2)) {
 
				CLRBIT(_m[tile].m4, 2);
 
				SETBIT(_m[tile].m4, 3);
 
			}
 
		} END_TILE_LOOP(tile, MapSizeX(), MapSizeY(), 0);
 
	}
 

	
 
	if (version < 0x1000) {
 
		int i;
 
		FOR_ALL_PLAYERS(p) {
 
			for (i = 0; i < 256; i++) {
 
				p->engine_replacement[i] = INVALID_ENGINE;
 
			}
 
			p->engine_renew = false;
 
			p->engine_renew_months = -6;
 
			p->engine_renew_money = 100000;
 
		}
 
		// Set the human controlled player to the patch settings
 
		p = GetPlayer(_local_player);
 
		p->engine_renew = _patches.autorenew;
 
		p->engine_renew_months = _patches.autorenew_months;
 
		p->engine_renew_money = _patches.autorenew_money;
 
	}
 

	
 
	FOR_ALL_PLAYERS(p) {
 
		p->avail_railtypes = GetPlayerRailtypes(p->index);
 
	}
 

	
 
	return true;
 
}
player.h
Show inline comments
 
@@ -166,48 +166,52 @@ typedef struct Player {
 

	
 
	uint16 cargo_types; /* which cargo types were transported the last year */
 

	
 
	TileIndex location_of_house;
 
	TileIndex last_build_coordinate;
 

	
 
	byte share_owners[4];
 

	
 
	byte inaugurated_year;
 
	byte num_valid_stat_ent;
 

	
 
	byte quarters_of_bankrupcy;
 
	byte bankrupt_asked; // which players were asked about buying it?
 
	int16 bankrupt_timeout;
 
	int32 bankrupt_value;
 

	
 
	bool is_active;
 
	byte is_ai;
 
	PlayerAI ai;
 
	PlayerAiNew ainew;
 

	
 
	int64 yearly_expenses[3][13];
 
	PlayerEconomyEntry cur_economy;
 
	PlayerEconomyEntry old_economy[24];
 
	EngineID engine_replacement[256];
 
	bool engine_renew;
 
	int16 engine_renew_months;
 
	uint32 engine_renew_money;
 
} Player;
 

	
 
void ChangeOwnershipOfPlayerItems(byte old_player, byte new_player);
 
void GetNameOfOwner(byte owner, TileIndex tile);
 
int64 CalculateCompanyValue(Player *p);
 
void InvalidatePlayerWindows(Player *p);
 
void AiDoGameLoop(Player *p);
 
void UpdatePlayerMoney32(Player *p);
 
#define FOR_ALL_PLAYERS(p) for(p=_players; p != endof(_players); p++)
 

	
 
extern PlayerID _current_player;
 

	
 
#define MAX_PLAYERS 8
 
VARDEF Player _players[MAX_PLAYERS];
 
// NOSAVE: can be determined from player structs
 
VARDEF byte _player_colors[MAX_PLAYERS];
 

	
 
static inline Player* GetPlayer(uint i)
 
{
 
  assert(i < lengthof(_players));
 
  return &_players[i];
 
}
 

	
 
/** Returns the number of rail types the player can build
players.c
Show inline comments
 
@@ -453,71 +453,79 @@ restart:;
 
			}
 
		}
 
		return;
 
	}
 
}
 

	
 
static Player *AllocatePlayer(void)
 
{
 
	Player *p;
 
	// Find a free slot
 
	FOR_ALL_PLAYERS(p) {
 
		if (!p->is_active) {
 
			int i = p->index;
 
			memset(p, 0, sizeof(Player));
 
			p->index = i;
 
			return p;
 
		}
 
	}
 
	return NULL;
 
}
 

	
 
Player *DoStartupNewPlayer(bool is_ai)
 
{
 
	Player *p;
 
	int index;
 
	int index, i;
 

	
 
	p = AllocatePlayer();
 
	if (p == NULL) return NULL;
 

	
 
	index = p->index;
 

	
 
	// Make a color
 
	p->player_color = GeneratePlayerColor();
 
	_player_colors[index] = p->player_color;
 
	p->name_1 = STR_SV_UNNAMED;
 
	p->is_active = true;
 

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

	
 
	p->is_ai = is_ai;
 
	p->ai.state = 5; /* AIS_WANT_NEW_ROUTE */
 
	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();
 

	
 
	/* Engine renewal settings */
 
	for (i = 0; i < 256; i++)
 
		p->engine_replacement[i] = INVALID_ENGINE;
 

	
 
	p->engine_renew = false;
 
	p->engine_renew_months = -6;
 
	p->engine_renew_money = 100000;
 

	
 
	GeneratePresidentName(p);
 

	
 
	InvalidateWindow(WC_GRAPH_LEGEND, 0);
 
	InvalidateWindow(WC_TOOLBAR_MENU, 0);
 
	InvalidateWindow(WC_CLIENT_LIST, 0);
 

	
 
	return p;
 
}
 

	
 
void StartupPlayers(void)
 
{
 
	// The AI starts like in the setting with +2 month max
 
	_next_competitor_start = _opt.diff.competitor_start_time * 90 * DAY_TICKS + RandomRange(60 * DAY_TICKS) + 1;
 
}
 

	
 
static void MaybeStartNewPlayer(void)
 
{
 
	uint n;
 
	Player *p;
 

	
 
	// count number of competitors
 
	n = 0;
 
	for(p=_players; p!=endof(_players); p++)
 
		if (p->is_active && p->is_ai)
 
@@ -640,93 +648,208 @@ byte GetPlayerRailtypes(int p)
 

	
 
		/* Skip all wagons */
 
		if ((i >= 27 && i < 54) || (i >= 57 && i < 84) || (i >= 89 && i < 116))
 
			continue;
 

	
 
		assert(e->railtype < RAILTYPE_END);
 
		SETBIT(rt, e->railtype);
 
	}
 

	
 
	return rt;
 
}
 

	
 
static void DeletePlayerStuff(int pi)
 
{
 
	Player *p;
 

	
 
	DeletePlayerWindows(pi);
 
	p = GetPlayer(pi);
 
	DeleteName(p->name_1);
 
	DeleteName(p->president_name_1);
 
	p->name_1 = 0;
 
	p->president_name_1 = 0;
 
}
 

	
 
/** Change engine renewal parameters
 
 * @param x,y unused
 
 * @param p1 bits 0-3 command
 
 * - p1 = 0 - change auto renew bool
 
 * - p1 = 1 - change auto renew months
 
 * - p1 = 2 - change auto renew money
 
 * - p1 = 3 - change auto renew array
 
 * - p1 = 4 - change bool, months & money all together
 
 * @param p2 value to set
 
 * if p1 = 0, then:
 
 * - p2 = enable engine renewal
 
 * if p1 = 1, then:
 
 * - p2 = months left before engine expires to replace it
 
 * if p1 = 2, then
 
 * - p2 = minimum amount of money available
 
 * if p1 = 3, then:
 
 * - p2 bits  0-15 = old engine type
 
 * - p2 bits 16-31 = new engine type
 
 * if p1 = 4, then:
 
 * - p1 bit     15 = enable engine renewal
 
 * - p1 bits 16-31 = months left before engine expires to replace it
 
 * - p2 bits  0-31 = minimum amount of money available
 
 */
 
int32 CmdReplaceVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 
{
 
	Player *p;
 
	if (!(_current_player < MAX_PLAYERS))
 
		return CMD_ERROR;
 

	
 
	p = GetPlayer(_current_player);
 
	switch (GB(p1, 0, 3)) {
 
		case 0:
 
			if (p->engine_renew == (bool)GB(p2, 0, 1))
 
				return CMD_ERROR;
 

	
 
			if (flags & DC_EXEC) {
 
				p->engine_renew = (bool)GB(p2, 0, 1);
 
				if (_current_player == _local_player) {
 
					_patches.autorenew = p->engine_renew;
 
					InvalidateWindow(WC_GAME_OPTIONS, 0);
 
				}
 
			}
 
			break;
 
		case 1:
 
			if (p->engine_renew_months == (int16)p2)
 
				return CMD_ERROR;
 

	
 
			if (flags & DC_EXEC) {
 
				p->engine_renew_months = (int16)p2;
 
				if (_current_player == _local_player) {
 
					_patches.autorenew_months = p->engine_renew_months;
 
					InvalidateWindow(WC_GAME_OPTIONS, 0);
 
				}
 
			}
 
			break;
 
		case 2:
 
			if (p->engine_renew_money == (uint32)p2)
 
				return CMD_ERROR;
 

	
 
			if (flags & DC_EXEC) {
 
				p->engine_renew_money = (uint32)p2;
 
				if (_current_player == _local_player) {
 
					_patches.autorenew_money = p->engine_renew_money;
 
					InvalidateWindow(WC_GAME_OPTIONS, 0);
 
				}
 
			}
 
			break;
 
		case 3: {
 
			EngineID old_engine_type = GB(p2, 0, 16);
 
			EngineID new_engine_type = GB(p2, 16, 16);
 

	
 
			if (new_engine_type != INVALID_ENGINE) {
 
				/* 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
 
				if (GetEngine(old_engine_type)->type != GetEngine(new_engine_type)->type)
 
					return CMD_ERROR;
 

	
 
				// make sure that we do not replace a plane with a helicopter or vise versa
 
				if (GetEngine(new_engine_type)->type == VEH_Aircraft && HASBIT(AircraftVehInfo(old_engine_type)->subtype, 0) != HASBIT(AircraftVehInfo(new_engine_type)->subtype, 0))
 
					return CMD_ERROR;
 

	
 
				// make sure that the player can actually buy the new engine
 
				if (!HASBIT(GetEngine(new_engine_type)->player_avail, _current_player))
 
					return CMD_ERROR;
 
			}
 

	
 
			if (flags & DC_EXEC) {
 
				p->engine_replacement[old_engine_type] = new_engine_type;
 
			}
 
		} break;
 
		case 4:
 
			if (flags & DC_EXEC) {
 
				p->engine_renew = (bool)GB(p1, 15, 1);
 
				p->engine_renew_months = (int16)GB(p1, 16, 16);
 
				p->engine_renew_money = (uint32)p2;
 

	
 
				if (_current_player == _local_player) {
 
					_patches.autorenew = p->engine_renew;
 
					_patches.autorenew_months = p->engine_renew_months;
 
					_patches.autorenew_money = p->engine_renew_money;
 
					InvalidateWindow(WC_GAME_OPTIONS, 0);
 
				}
 
			}
 
			break;
 
	}
 

	
 
	return 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
 
 * - p1 = 3 - merge two companies together. Player to merge #1 with player #2. Identified by p2
 
 * @param p2 various functionality, dictated by p1
 
 * - p1 = 0 - ClientID of the newly created player
 
 * - p1 = 2 - PlayerID of the that is getting deleted
 
 * - p1 = 3 - #1 p2 = (bit  0-15) - player to merge (p2 & 0xFFFF)
 
 *          - #2 p2 = (bit 16-31) - player to be merged into ((p2>>16)&0xFFFF)
 
 * @todo In the case of p1=0, create new player, the clientID of the new player is in parameter
 
 * p2. This parameter is passed in at function DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND)
 
 * on the server itself. First of all this is unbelievably ugly; second of all, well,
 
 * it IS ugly! <b>Someone fix this up :)</b> So where to fix?@n
 
 * @arg - network_server.c:838 DEF_SERVER_RECEIVE_COMMAND(PACKET_CLIENT_COMMAND)@n
 
 * @arg - network_client.c:536 DEF_CLIENT_RECEIVE_COMMAND(PACKET_SERVER_MAP) from where the map has been received
 
 */
 
int32 CmdPlayerCtrl(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 
{
 
	if (flags & DC_EXEC) _current_player = OWNER_NONE;
 

	
 
	switch (p1) {
 
	case 0: { /* Create a new player */
 
		Player *p;
 
		PlayerID pid = p2;
 

	
 
		if (!(flags & DC_EXEC) || pid >= MAX_PLAYERS) return 0;
 

	
 
		p = DoStartupNewPlayer(false);
 

	
 
#ifdef ENABLE_NETWORK
 
		if (_networking && !_network_server && _local_player == OWNER_SPECTATOR)
 
			/* In case we are a client joining a server... */
 
			DeleteWindowById(WC_NETWORK_STATUS_WINDOW, 0);
 
#endif /* ENABLE_NETWORK */
 

	
 
		if (p != NULL) {
 
			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();
 
				}
 
			} else if (p->index == _local_player) {
 
				DoCommandP(0, (_patches.autorenew << 15 ) | (_patches.autorenew_months << 16) | 4, _patches.autorenew_money, NULL, CMD_REPLACE_VEHICLE);
 
			}
 
#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];
 
				ci->client_playas = p->index + 1;
 
				NetworkUpdateClientInfo(ci->client_index);
 

	
 
				if (ci->client_playas != 0 && ci->client_playas <= MAX_PLAYERS) {
 
					PlayerID player_backup = _local_player;
 
					_network_player_info[p->index].months_empty = 0;
 

	
 
					/* XXX - When a client joins, we automatically set its name to the
 
					 * player's name (for some reason). As it stands now only the server
 
					 * knows the client's name, so it needs to send out a "broadcast" to
 
					 * do this. To achieve this we send a network command. However, it
 
					 * uses _local_player to execute the command as.  To prevent abuse
 
					 * (eg. only yourself can change your name/company), we 'cheat' by
 
					 * impersonation _local_player as the server. Not the best solution;
 
					 * but it works.
 
					 * TODO: Perhaps this could be improved by when the client is ready
 
					 * with joining to let it send itself the command, and not the server?
 
					 * For example in network_client.c:534? */
 
@@ -1001,48 +1124,54 @@ static const SaveLoad _player_desc[] = {
 

	
 
	SLE_VAR(Player,cargo_types,			SLE_UINT16),
 
	SLE_CONDVAR(Player, location_of_house,     SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
 
	SLE_CONDVAR(Player, location_of_house,     SLE_UINT32, 6, 255),
 
	SLE_CONDVAR(Player, last_build_coordinate, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),
 
	SLE_CONDVAR(Player, last_build_coordinate, SLE_UINT32, 6, 255),
 
	SLE_VAR(Player,inaugurated_year,SLE_UINT8),
 

	
 
	SLE_ARR(Player,share_owners,		SLE_UINT8, 4),
 

	
 
	SLE_VAR(Player,num_valid_stat_ent,SLE_UINT8),
 

	
 
	SLE_VAR(Player,quarters_of_bankrupcy,SLE_UINT8),
 
	SLE_VAR(Player,bankrupt_asked,	SLE_UINT8),
 
	SLE_VAR(Player,bankrupt_timeout,SLE_INT16),
 
	SLE_VAR(Player,bankrupt_value,	SLE_INT32),
 

	
 
	// yearly expenses was changed to 64-bit in savegame version 2.
 
	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),
 

	
 
	// Engine renewal settings
 
	SLE_CONDARR(Player,engine_replacement,  SLE_UINT16, 256, 16, 255),
 
	SLE_CONDVAR(Player,engine_renew,         SLE_UINT8,      16, 255),
 
	SLE_CONDVAR(Player,engine_renew_months,  SLE_INT16,      16, 255),
 
	SLE_CONDVAR(Player,engine_renew_money,  SLE_UINT32,      16, 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()
 
};
 

	
 
static const SaveLoad _player_economy_desc[] = {
 
	// these were changed to 64-bit in savegame format 2
 
	SLE_CONDVAR(PlayerEconomyEntry,income,							SLE_INT32, 0, 1),
 
	SLE_CONDVAR(PlayerEconomyEntry,expenses,						SLE_INT32, 0, 1),
 
	SLE_CONDVAR(PlayerEconomyEntry,company_value, SLE_FILE_I32 | SLE_VAR_I64, 0, 1),
 
	SLE_CONDVAR(PlayerEconomyEntry,income,	SLE_FILE_I64 | SLE_VAR_I32, 2, 255),
 
	SLE_CONDVAR(PlayerEconomyEntry,expenses,SLE_FILE_I64 | SLE_VAR_I32, 2, 255),
 
	SLE_CONDVAR(PlayerEconomyEntry,company_value, SLE_INT64, 2, 255),
 

	
 
	SLE_VAR(PlayerEconomyEntry,delivered_cargo,			SLE_INT32),
 
	SLE_VAR(PlayerEconomyEntry,performance_history,	SLE_INT32),
 

	
 
	SLE_END()
 
};
 

	
 
static const SaveLoad _player_ai_desc[] = {
 
	SLE_VAR(PlayerAI,state,							SLE_UINT8),
 
	SLE_VAR(PlayerAI,tick,							SLE_UINT8),
railtypes.h
Show inline comments
 
@@ -3,49 +3,49 @@
 
/** @file railtypes.h
 
 * All the railtype-specific information is stored here.
 
 */
 

	
 
/** Global Railtype definition
 
 */
 
const RailtypeInfo _railtypes[RAILTYPE_END] = {
 
	/** Railway */
 
	{ /* Main Sprites */
 
		{ SPR_RAIL_TRACK_Y, SPR_RAIL_TRACK_N_S, SPR_RAIL_TRACK_BASE, SPR_RAIL_SINGLE_Y, SPR_RAIL_SINGLE_X,
 
			SPR_RAIL_SINGLE_NORTH, SPR_RAIL_SINGLE_SOUTH, SPR_RAIL_SINGLE_EAST, SPR_RAIL_SINGLE_WEST },
 

	
 
		/* GUI sprites */
 
		{ 0x4E3, 0x4E4, 0x4E5, 0x4E6,
 
			SPR_OPENTTD_BASE + 0, 0x50E, 0x97E, SPR_OPENTTD_BASE + 25 },
 

	
 
		/* strings */
 
		{ STR_100A_RAILROAD_CONSTRUCTION },
 

	
 
		/* Offset of snow tiles */
 
		SPR_RAIL_SNOW_OFFSET,
 

	
 
		/* Compatible railtypes */
 
		(1 << RAILTYPE_RAIL),
 
	
 

	
 
		/* main offset */
 
		0,
 
	},
 

	
 
	/** Monorail */
 
	{ /* Main Sprites */
 
		{ SPR_MONO_TRACK_Y, SPR_MONO_TRACK_N_S, SPR_MONO_TRACK_BASE, SPR_MONO_SINGLE_Y, SPR_MONO_SINGLE_X,
 
			SPR_MONO_SINGLE_NORTH, SPR_MONO_SINGLE_SOUTH, SPR_MONO_SINGLE_EAST, SPR_MONO_SINGLE_WEST },
 

	
 
		/* GUI sprites */
 
		{ 0x4E7, 0x4E8, 0x4E9, 0x4EA,
 
			SPR_OPENTTD_BASE + 1, SPR_OPENTTD_BASE + 12, 0x97F, SPR_OPENTTD_BASE + 27 },
 

	
 
		/* strings */
 
		{ STR_100B_MONORAIL_CONSTRUCTION },
 

	
 
		/* Offset of snow tiles */
 
		SPR_MONO_SNOW_OFFSET,
 

	
 
		/* Compatible Railtypes */
 
		(1 << RAILTYPE_MONO),
 

	
 
		/* main offset */
 
		82,
saveload.c
Show inline comments
 
@@ -7,49 +7,49 @@
 
 * <li>initialize the writer by creating a temporary memory-buffer for it
 
 * <li>go through all to-be saved elements, each 'chunk' (ChunkHandler) prefixed by a label
 
 * <li>use their description array (SaveLoad) to know what elements to save and in what version
 
 *    of the game it was active (used when loading)
 
 * <li>write all data byte-by-byte to the temporary buffer so it is endian-safe
 
 * <li>when the buffer is full; flush it to the output (eg save to file) (_sl.buf, _sl.bufp, _sl.bufe)
 
 * <li>repeat this until everything is done, and flush any remaining output to file
 
 * </ol>
 
 * @see ChunkHandler
 
 * @see SaveLoad
 
 */
 
#include "stdafx.h"
 
#include "openttd.h"
 
#include "debug.h"
 
#include "functions.h"
 
#include "vehicle.h"
 
#include "station.h"
 
#include "thread.h"
 
#include "town.h"
 
#include "player.h"
 
#include "saveload.h"
 
#include "variables.h"
 

	
 
enum {
 
	SAVEGAME_MAJOR_VERSION = 15,
 
	SAVEGAME_MAJOR_VERSION = 16,
 
	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};
 

	
 
SaverLoader _sl;
 

	
 
/**
 
 * Fill the input buffer by reading from the file with the given reader
 
 */
 
static void SlReadFill(void)
 
{
 
	uint len = _sl.read_bytes();
 
	assert(len != 0);
 

	
 
	_sl.bufp = _sl.buf;
 
	_sl.bufe = _sl.buf + len;
 
	_sl.offs_base += len;
 
}
 

	
 
static inline uint32 SlGetOffs(void) {return _sl.offs_base - (_sl.bufe - _sl.bufp);}
 

	
settings_gui.c
Show inline comments
 
@@ -597,48 +597,66 @@ static int32 InvalidateStationBuildWindo
 
}
 

	
 
/* Check service intervals of vehicles, p1 is value of % or day based servicing */
 
static int32 CheckInterval(int32 p1)
 
{
 
	bool warning;
 
	if (p1) {
 
		warning = ( (IS_INT_INSIDE(_patches.servint_trains,   5, 90+1) || _patches.servint_trains   == 0) &&
 
								(IS_INT_INSIDE(_patches.servint_roadveh,  5, 90+1) || _patches.servint_roadveh  == 0) &&
 
								(IS_INT_INSIDE(_patches.servint_aircraft, 5, 90+1) || _patches.servint_aircraft == 0) &&
 
								(IS_INT_INSIDE(_patches.servint_ships,    5, 90+1) || _patches.servint_ships    == 0) );
 
	} else {
 
		warning = ( (IS_INT_INSIDE(_patches.servint_trains,   30, 800+1) || _patches.servint_trains   == 0) &&
 
								(IS_INT_INSIDE(_patches.servint_roadveh,  30, 800+1) || _patches.servint_roadveh  == 0) &&
 
								(IS_INT_INSIDE(_patches.servint_aircraft, 30, 800+1) || _patches.servint_aircraft == 0) &&
 
								(IS_INT_INSIDE(_patches.servint_ships,    30, 800+1) || _patches.servint_ships    == 0) );
 
	}
 

	
 
	if (!warning)
 
		ShowErrorMessage(-1, STR_CONFIG_PATCHES_SERVICE_INTERVAL_INCOMPATIBLE, 0, 0);
 

	
 
	return InValidateDetailsWindow(0);
 
}
 

	
 
static int32 EngineRenewUpdate(int32 p1)
 
{
 
	DoCommandP(0, 0, _patches.autorenew, NULL, CMD_REPLACE_VEHICLE);
 
	return 0;
 
}
 

	
 
static int32 EngineRenewMonthsUpdate(int32 p1)
 
{
 
	DoCommandP(0, 1, _patches.autorenew_months, NULL, CMD_REPLACE_VEHICLE);
 
	return 0;
 
}
 

	
 
static int32 EngineRenewMoneyUpdate(int32 p1)
 
{
 
	DoCommandP(0, 2, _patches.autorenew_money, NULL, CMD_REPLACE_VEHICLE);
 
	return 0;
 
}
 

	
 
typedef int32 PatchButtonClick(int32);
 

	
 
typedef struct PatchEntry {
 
  byte type;                    // type of selector
 
  byte flags;                   // selector flags
 
  StringID str;                 // string with descriptive text
 
  char console_name[40];        // the name this patch has in console
 
  void *variable;               // pointer to the variable
 
  int32 min, max;               // range for spinbox setting
 
  uint32 step;                  // step for spinbox
 
  PatchButtonClick *click_proc; // callback procedure
 
} PatchEntry;
 

	
 
enum {
 
	PE_BOOL			= 0,
 
	PE_UINT8		= 1,
 
	PE_INT16		= 2,
 
	PE_UINT16		= 3,
 
	PE_INT32		= 4,
 
	PE_CURRENCY	= 5,
 
	// selector flags
 
	PF_0ISDIS				= 1 << 0,
 
	PF_NOCOMMA			= 1 << 1,
 
	PF_MULTISTRING	= 1 << 2,
 
@@ -667,51 +685,51 @@ static const PatchEntry _patches_constru
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_BUILDONSLOPES,		"build_on_slopes",	&_patches.build_on_slopes,					0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_EXTRADYNAMITE,		"extra_dynamite",		&_patches.extra_dynamite,						0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_LONGBRIDGES,			"long_bridges",			&_patches.longbridges,							0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_SIGNALSIDE,				"signal_side",			&_patches.signal_side,							0,  0,  0, NULL},
 

	
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_SMALL_AIRPORTS,		"always_small_airport", &_patches.always_small_airport,			0,  0,  0, NULL},
 
	{PE_UINT8,	PF_PLAYERBASED, STR_CONFIG_PATCHES_DRAG_SIGNALS_DENSITY, "drag_signals_density", &_patches.drag_signals_density, 1, 20,  1, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_AUTO_PBS_PLACEMENT, "auto_pbs_placement", &_patches.auto_pbs_placement, 1, 20,  1, NULL},
 

	
 
};
 

	
 
static const PatchEntry _patches_vehicles[] = {
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_REALISTICACCEL,		"realistic_acceleration", &_patches.realistic_acceleration,		0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_FORBID_90_DEG,		"forbid_90_deg", 		&_patches.forbid_90_deg,						0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_MAMMOTHTRAINS,		"mammoth_trains", 	&_patches.mammoth_trains,						0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_GOTODEPOT,				"goto_depot", 			&_patches.gotodepot,								0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_ROADVEH_QUEUE,		"roadveh_queue", 		&_patches.roadveh_queue,						0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_NEW_PATHFINDING_ALL, "new_pathfinding_all", &_patches.new_pathfinding_all,		0,  0,  0, NULL},
 

	
 
	{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_BOOL,		PF_PLAYERBASED, STR_CONFIG_PATCHES_AUTORENEW_VEHICLE,"autorenew", &_patches.autorenew,								0,  0,  0, NULL},
 
	{PE_INT16,	PF_PLAYERBASED, STR_CONFIG_PATCHES_AUTORENEW_MONTHS, "autorenew_months", &_patches.autorenew_months,				-12, 12,  1, NULL},
 
	{PE_CURRENCY, PF_PLAYERBASED, STR_CONFIG_PATCHES_AUTORENEW_MONEY,"autorenew_money", &_patches.autorenew_money,					0, 2000000, 100000, NULL},
 
	{PE_BOOL,     PF_PLAYERBASED, STR_CONFIG_PATCHES_AUTORENEW_VEHICLE, "autorenew",        &_patches.autorenew,                   0, 0, 0, &EngineRenewUpdate},
 
	{PE_INT16,	  PF_PLAYERBASED, STR_CONFIG_PATCHES_AUTORENEW_MONTHS,  "autorenew_months", &_patches.autorenew_months,         -12, 12, 1, &EngineRenewMonthsUpdate},
 
	{PE_CURRENCY, PF_PLAYERBASED, STR_CONFIG_PATCHES_AUTORENEW_MONEY,   "autorenew_money",  &_patches.autorenew_money,  0, 2000000, 100000, &EngineRenewMoneyUpdate},
 

	
 
	{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},
 

	
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_SERVINT_ISPERCENT,"servint_isperfect",&_patches.servint_ispercent,				0,  0,  0, &CheckInterval},
 
	{PE_UINT16, PF_0ISDIS, STR_CONFIG_PATCHES_SERVINT_TRAINS,		"servint_trains",   &_patches.servint_trains,		5,800,  5, &InValidateDetailsWindow},
 
	{PE_UINT16, PF_0ISDIS, STR_CONFIG_PATCHES_SERVINT_ROADVEH,	"servint_roadveh",  &_patches.servint_roadveh,	5,800,  5, &InValidateDetailsWindow},
 
	{PE_UINT16, PF_0ISDIS, STR_CONFIG_PATCHES_SERVINT_AIRCRAFT, "servint_aircraft", &_patches.servint_aircraft, 5,800,  5, &InValidateDetailsWindow},
 
	{PE_UINT16, PF_0ISDIS, STR_CONFIG_PATCHES_SERVINT_SHIPS,		"servint_ships",    &_patches.servint_ships,		5,800,  5, &InValidateDetailsWindow},
 
	{PE_BOOL,   0,         STR_CONFIG_PATCHES_NOSERVICE,        "no_servicing_if_no_breakdowns", &_patches.no_servicing_if_no_breakdowns, 0, 0, 0, NULL},
 
};
 

	
 
static const PatchEntry _patches_stations[] = {
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_JOINSTATIONS,			"join_stations", &_patches.join_stations,						0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_FULLLOADANY,			"full_load_any", &_patches.full_load_any,						0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_IMPROVEDLOAD,			"improved_load", &_patches.improved_load,						0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_SELECTGOODS,			"select_goods",  &_patches.selectgoods,							0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_NEW_NONSTOP,			"new_nonstop", &_patches.new_nonstop,							0,  0,  0, NULL},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_NONUNIFORM_STATIONS, "nonuniform_stations", &_patches.nonuniform_stations,		0,  0,  0, NULL},
 
	{PE_UINT8,	0, STR_CONFIG_PATCHES_STATION_SPREAD,		"station_spread", &_patches.station_spread,						4, 64,  1, &InvalidateStationBuildWindow},
 
	{PE_BOOL,		0, STR_CONFIG_PATCHES_SERVICEATHELIPAD, "service_at_helipad", &_patches.serviceathelipad,					0,  0,  0, NULL},
 
	{PE_BOOL, 0, STR_CONFIG_PATCHES_CATCHMENT, "modified_catchment", &_patches.modified_catchment, 0, 0, 0, NULL},
tunnelbridge_cmd.c
Show inline comments
 
@@ -12,49 +12,49 @@
 
#include "functions.h"
 
#include "map.h"
 
#include "tile.h"
 
#include "vehicle.h"
 
#include "viewport.h"
 
#include "command.h"
 
#include "player.h"
 
#include "town.h"
 
#include "sound.h"
 
#include "pbs.h"
 
#include "debug.h"
 
#include "variables.h"
 
#include "bridge.h"
 

	
 
#include "table/bridge_land.h"
 
#include "table/tunnel_land.h"
 

	
 
extern const byte _track_sloped_sprites[14];
 
extern const SpriteID _water_shore_sprites[15];
 

	
 
extern void DrawCanalWater(TileIndex tile);
 

	
 
const Bridge _bridge[] = {
 
/*
 
	   year of availablity 
 
	   year of availablity
 
	   |  minimum length
 
	   |  |   maximum length
 
	   |  |   |    price
 
	   |  |   |    |    maximum speed
 
	   |  |   |    |    |  sprite to use in GUI                string with description
 
	   |  |   |    |    |  |                                   |                            */
 
	{  0, 0, 16,  80,  32, 0xA24                             , STR_5012_WOODEN              },
 
	{  0, 0,  2, 112,  48, 0xA26 | PALETTE_TO_STRUCT_RED     , STR_5013_CONCRETE            },
 
	{ 10, 0,  5, 144,  64, 0xA25                             , STR_500F_GIRDER_STEEL        },
 
	{  0, 2, 10, 168,  80, 0xA22 | PALETTE_TO_STRUCT_CONCRETE, STR_5011_SUSPENSION_CONCRETE },
 
	{ 10, 3, 16, 185,  96, 0xA22                             , STR_500E_SUSPENSION_STEEL    },
 
	{ 10, 3, 16, 192, 112, 0xA22 | PALETTE_TO_STRUCT_YELLOW  , STR_500E_SUSPENSION_STEEL	},
 
	{ 10, 3,  7, 224, 160, 0xA23                             , STR_5010_CANTILEVER_STEEL    },
 
	{ 10, 3,  8, 232, 208, 0xA23 | PALETTE_TO_STRUCT_BROWN   , STR_5010_CANTILEVER_STEEL    },
 
	{ 10, 3,  9, 248, 240, 0xA23 | PALETTE_TO_STRUCT_RED     , STR_5010_CANTILEVER_STEEL    },
 
	{ 10, 0,  2, 240, 256, 0xA27                             , STR_500F_GIRDER_STEEL        },
 
	{ 75, 2, 16, 255, 320, 0xA28                             , STR_5014_TUBULAR_STEEL       },
 
	{ 85, 2, 32, 380, 512, 0xA28 | PALETTE_TO_STRUCT_YELLOW  , STR_5014_TUBULAR_STEEL       },
 
	{ 90, 2, 32, 510, 608, 0xA28 | PALETTE_TO_STRUCT_GREY    , STR_BRIDGE_TUBULAR_SILICON   }
 
};
 

	
 
// calculate the price factor for building a long bridge.
 
// basically the cost delta is 1,1, 1, 2,2, 3,3,3, 4,4,4,4, 5,5,5,5,5, 6,6,6,6,6,6,  7,7,7,7,7,7,7,  8,8,8,8,8,8,8,8,
 
int CalcBridgeLenCostFactor(int x)
variables.h
Show inline comments
 
@@ -413,31 +413,28 @@ StringID BindCString(const char *str);
 

	
 
/* landscape.c */
 
extern const byte _tileh_to_sprite[32];
 
extern const byte _inclined_tileh[8];
 

	
 
extern const TileTypeProcs * const _tile_type_procs[16];
 

	
 
/* station_cmd.c */
 
// there are 5 types of airport (Country (3x4) , City(6x6), Metropolitan(6x6), International(7x7), Heliport(1x1)
 
// will become obsolete once airports are loaded from seperate file
 
extern const byte _airport_size_x[];
 
extern const byte _airport_size_y[];
 

	
 
/* misc */
 
VARDEF char _screenshot_name[128];
 
VARDEF byte _vehicle_design_names;
 

	
 
/* tunnelbridge */
 
#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
 

	
 
/* Autoreplace vehicle stuff*/
 
VARDEF byte _autoreplace_array[256];
 

	
 
/* Forking stuff */
 
VARDEF bool _dedicated_forks;
 

	
 
#endif /* VARIABLES_H */
vehicle.c
Show inline comments
 
@@ -1301,112 +1301,105 @@ void CheckVehicleBreakdown(Vehicle *v)
 
	/* reduced breakdowns? */
 
	if (_opt.diff.vehicle_breakdowns == 1) rel += 0x6666;
 

	
 
	/* check if to break down */
 
	if (_breakdown_chance[(uint)min(rel, 0xffff) >> 10] <= v->breakdown_chance) {
 
		v->breakdown_ctr    = GB(r, 16, 6) + 0x3F;
 
		v->breakdown_delay  = GB(r, 24, 7) + 0x80;
 
		v->breakdown_chance = 0;
 
	}
 
}
 

	
 
static const StringID _vehicle_type_names[4] = {
 
	STR_019F_TRAIN,
 
	STR_019C_ROAD_VEHICLE,
 
	STR_019E_SHIP,
 
	STR_019D_AIRCRAFT,
 
};
 

	
 
static void ShowVehicleGettingOld(Vehicle *v, StringID msg)
 
{
 
	if (v->owner != _local_player)
 
		return;
 

	
 
	// Do not show getting-old message if autorenew is active
 
	if (_patches.autorenew)
 
	if (GetPlayer(v->owner)->engine_renew)
 
		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);
 
}
 

	
 
void AgeVehicle(Vehicle *v)
 
{
 
	int age;
 

	
 
	if (v->age < 65535)
 
		v->age++;
 

	
 
	age = v->age - v->max_age;
 
	if (age == 366*0 || age == 366*1 || age == 366*2 || age == 366*3 || age == 366*4)
 
		v->reliability_spd_dec <<= 1;
 

	
 
	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 

	
 
	if (age == -366) {
 
		ShowVehicleGettingOld(v, STR_01A0_IS_GETTING_OLD);
 
	} else if (age == 0) {
 
		ShowVehicleGettingOld(v, STR_01A1_IS_GETTING_VERY_OLD);
 
	} else if (age == 366*1 || age == 366*2 || age == 366*3 || age == 366*4 || age == 366*5) {
 
		ShowVehicleGettingOld(v, STR_01A2_IS_GETTING_VERY_OLD_AND);
 
	}
 
}
 

	
 
extern int32 EstimateTrainCost(const RailVehicleInfo *rvi);
 
extern int32 EstimateRoadVehCost(EngineID engine_type);
 
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).
 
 * @param x,y unused
 
 * @param p1 index of vehicle being replaced
 
 * @param p2 various bitstuffed elements
 
 * - p2 = (bit  0-15) - new engine type for the vehicle (p2 & 0xFFFF)
 
 * - p2 = (bit 16-31) - money the player wants to have left after replacement counted in 100.000 (100K) (p2 >> 16)
 
 * Must be called with _current_player set to the owner of the vehicle
 
 * @param v Vehicle to replace
 
 */
 
int32 CmdReplaceVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2)
 
int32 ReplaceVehicle(Vehicle *v)
 
{
 
	/* makesvariables to inform about how much money the player wants to have left after replacing
 
	 and which engine to replace with out of p2.
 
	 the first 16 bit is the money. The last 5 digits (all 0) were removed when sent, so we add them again.
 
	 This way the max is 6553 millions and it is more than the 32 bit that is stored in _patches
 
	 This is a nice way to send 32 bit and only use 16 bit
 
	 the last 8 bit is the engine. The 8 bits in front of the engine is free so it have room for 16 bit engine entries */
 
	EngineID new_engine_type = (p2 & 0xFFFF);
 
	uint32 autorefit_money = (p2 >> 16) * 100000;
 
	Vehicle *v, *u, *first;
 
	Player *p = GetPlayer(v->owner);
 
	EngineID old_engine_type = v->engine_type;
 
	EngineID new_engine_type = p->engine_replacement[old_engine_type];
 
	Vehicle *u, *first;
 
	int cost, build_cost, rear_engine_cost = 0;
 
	EngineID old_engine_type;
 

	
 
	if (!IsVehicleIndex(p1)) return CMD_ERROR;
 

	
 
	v = u = GetVehicle(p1);
 
	// If replacing due to age only, use the same type :-)
 
	if (new_engine_type == INVALID_ENGINE)
 
		new_engine_type = old_engine_type;
 

	
 
	old_engine_type = v->engine_type;
 
	u = v;
 

	
 
	/* 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
 
	if (v->type != GetEngine(new_engine_type)->type) return CMD_ERROR;
 

	
 
	// check that it's the vehicle's owner that requested the replace
 
	if (!CheckOwnership(v->owner)) return CMD_ERROR;
 

	
 
	// makes sure that we do not replace a plane with a helicopter or vise versa
 
	if (v->type == VEH_Aircraft) {
 
		if (HASBIT(AircraftVehInfo(old_engine_type)->subtype, 0) != HASBIT(AircraftVehInfo(new_engine_type)->subtype, 0)) return CMD_ERROR;
 
	}
 

	
 
	// makes sure that the player can actually buy the new engine. Renewing is still allowed to outdated engines
 
	if (!HASBIT(GetEngine(new_engine_type)->player_avail, v->owner) && old_engine_type != new_engine_type) return CMD_ERROR;
 

	
 
	switch (v->type) {
 
		case VEH_Train:    build_cost = EstimateTrainCost(RailVehInfo(new_engine_type)); break;
 
		case VEH_Road:     build_cost = EstimateRoadVehCost(new_engine_type);            break;
 
		case VEH_Ship:     build_cost = EstimateShipCost(new_engine_type);               break;
 
		case VEH_Aircraft: build_cost = EstimateAircraftCost(new_engine_type);           break;
 
@@ -1428,70 +1421,69 @@ int32 CmdReplaceVehicle(int x, int y, ui
 
			// prevent that the rear engine can get replaced to something else than the front engine
 
			if ( v->u.rail.first_engine != INVALID_VEHICLE && RailVehInfo(old_engine_type)->flags & RVI_MULTIHEAD && RailVehInfo(old_engine_type)->flags ) {
 
				if ( first->engine_type != new_engine_type ) return CMD_ERROR;
 
			}
 

	
 
			// checks if the engine is the first one
 
			if ( v->u.rail.first_engine == INVALID_VEHICLE ) {
 
				if ( RailVehInfo(new_engine_type)->flags & RVI_MULTIHEAD ) {
 
					if ( u->engine_type == old_engine_type && v->next != NULL) {
 
						rear_engine_cost = build_cost - u->value;
 
					} else {
 
						rear_engine_cost = build_cost;
 
					}
 
				} else {
 
					if ( u->engine_type == old_engine_type && RailVehInfo(old_engine_type)->flags & RVI_MULTIHEAD) {
 
						if (v->next != NULL) rear_engine_cost = -(int32)u->value;
 
					}
 
				}
 
			 }
 
		}
 
	}
 

	
 
	/* 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 ( GetPlayer(v->owner)->money64 < (int32)(autorefit_money + build_cost + rear_engine_cost - v->value)) {
 
	if ( p->money64 < (p->engine_renew_money + build_cost + rear_engine_cost - v->value)) {
 
		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;
 
				case VEH_Ship:     message = STR_SHIP_AUTORENEW_FAILED;        break;
 
				case VEH_Aircraft: message = STR_AIRCRAFT_AUTORENEW_FAILED;    break;
 
				// This should never happen
 
				default: message = 0; break;
 
			}
 

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

	
 
		return CMD_ERROR;
 
	}
 
	cost = build_cost - v->value + rear_engine_cost;
 

	
 

	
 
	if (flags & DC_EXEC) {
 
	if (old_engine_type != new_engine_type) {
 
		/* 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;
 

	
 
		v->date_of_last_service = _date;
 
		v->build_year = _cur_year;
 

	
 
		v->value = build_cost;
 

	
 
		if (v->engine_type != new_engine_type) {
 
			byte sprite = v->spritenum;
 
			byte cargo_type = v->cargo_type;
 
			v->engine_type = new_engine_type;
 
			v->max_age = e->lifelength * 366;
 

	
 
			/* Update limits of the vehicle (for when upgraded) */
 
			switch (v->type) {
 
			case VEH_Train:
 
				{
 
				const RailVehicleInfo *rvi = RailVehInfo(new_engine_type);
 
				const RailVehicleInfo *rvi2 = RailVehInfo(old_engine_type);
 
@@ -1594,97 +1586,91 @@ int32 CmdReplaceVehicle(int x, int y, ui
 
				v->spritenum = avi->image_index;
 

	
 
					if ( cargo_type == CT_PASSENGERS ) {
 
						v->cargo_cap = avi->passenger_capacity;
 
						u = v->next;
 
						u->cargo_cap = avi->mail_capacity;
 
					} else {
 
						// 0x0100 means that we skip the check for being stopped inside the hangar
 
						// since we do not stop it for autorefitting
 
						CmdRefitAircraft(v->x_pos, v->y_pos, DC_EXEC, v->index , cargo_type + 0x0100 );
 
					}
 
				InvalidateWindowClasses(WC_AIRCRAFT_LIST);
 
				break;
 
				}
 
			default: return CMD_ERROR;
 
			}
 
			// makes sure that the cargo is still valid compared to new capacity
 
			if (v->cargo_count != 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;
 
			}
 
		}
 
		InvalidateWindow(WC_REPLACE_VEHICLE, v->type);
 
		ResortVehicleLists();
 
		InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 
	}
 

	
 
	// A replaced vehicle should be classed as new
 
	v->age = 0;
 

	
 
	InvalidateWindow(WC_REPLACE_VEHICLE, v->type);
 
	ResortVehicleLists();
 
	InvalidateWindow(WC_VEHICLE_DETAILS, v->index);
 

	
 
	//needs to be down here because refitting will change SET_EXPENSES_TYPE if called
 
	SET_EXPENSES_TYPE(EXPENSES_NEW_VEHICLES);
 
	SubtractMoneyFromPlayer(cost);
 
	if (_current_player == _local_player)
 
		ShowCostOrIncomeAnimation(v->x_pos, v->y_pos, v->z_pos, cost);
 

	
 
	return cost;
 
}
 

	
 
void MaybeReplaceVehicle(Vehicle *v)
 
{
 
	uint32 new_engine_and_autoreplace_money;
 

	
 
	if (v->owner != _local_player)
 
		return;
 
	Player *p = GetPlayer(v->owner);
 
	// 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
 
	if (!_patches.autorenew || v->age - v->max_age < (_patches.autorenew_months * 30)) {  //replace if engine is too old
 
		if (_autoreplace_array[v->engine_type] == v->engine_type && v->type != VEH_Train) //updates to a new model
 
	if (!p->engine_renew || v->age - v->max_age < (p->engine_renew_months * 30)) {  //replace if engine is too old
 
		if (p->engine_replacement[v->engine_type] == INVALID_ENGINE && v->type != VEH_Train) // updates to a new model
 
			return;
 
	}
 
	/* Now replace the vehicle */
 
	_current_player = v->owner;
 

	
 
	/* makes the variable to inform about how much money the player wants to have left after replacing
 
	 and which engine to replace with
 
	 the first 16 bit is the money. Since we know the last 5 digits is 0, they are thrown away.
 
	 This way the max is 6553 millions and it is more than the 32 bit that is stored in _patches
 
	 This is a nice way to send 32 bit and only use 16 bit
 
	 the last 8 bit is the engine. The 8 bits in front of the engine is free so it have room for 16 bit engine entries */
 
	new_engine_and_autoreplace_money = ((_patches.autorenew_money / 100000) << 16) + _autoreplace_array[v->engine_type];
 

	
 
	assert(v->type == GetEngine(_autoreplace_array[v->engine_type])->type);
 

	
 
	if ( v->type != VEH_Train ) {
 
		DoCommandP(v->tile, v->index, new_engine_and_autoreplace_money, NULL, CMD_REPLACE_VEHICLE | CMD_SHOW_NO_ERROR);
 
		ReplaceVehicle(v);
 
	} else {
 
	// checks if any of the engines in the train are either old or listed for replacement
 
		do {
 
			if ( v->engine_type != _autoreplace_array[v->engine_type] || (_patches.autorenew && (v->age - v->max_age) > (_patches.autorenew_months * 30))) {
 
				new_engine_and_autoreplace_money = (new_engine_and_autoreplace_money & 0xFFFF0000) + _autoreplace_array[v->engine_type]; // sets the new engine replacement type
 
				DoCommandP(v->tile, v->index, new_engine_and_autoreplace_money, NULL, CMD_REPLACE_VEHICLE | CMD_SHOW_NO_ERROR);
 
			if (p->engine_replacement[v->engine_type] != INVALID_ENGINE || (p->engine_renew && (v->age - v->max_age) > (p->engine_renew_months * 30))) {
 
				ReplaceVehicle(v);
 
			}
 
		} while ((v=v->next) != NULL);
 
	}
 
	_current_player = OWNER_NONE;
 
}
 

	
 
int32 CmdCloneOrder(int x, int y, uint32 flags, uint32 veh1_veh2, uint32 mode);
 
int32 CmdMoveRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2);
 
int32 CmdBuildRailVehicle(int x, int y, uint32 flags, uint32 p1, uint32 p2);
 
int32 CmdBuildRoadVeh(int x, int y, uint32 flags, uint32 p1, uint32 p2);
 
int32 CmdBuildShip(int x, int y, uint32 flags, uint32 p1, uint32 p2);
 
int32 CmdBuildAircraft(int x, int y, uint32 flags, uint32 p1, uint32 p2);
 

	
 

	
 
typedef int32 VehBuildProc(int x, int y, uint32 flags, uint32 p1, uint32 p2);
 

	
 
static VehBuildProc * const _veh_build_proc_table[] = {
 
	CmdBuildRailVehicle,
 
	CmdBuildRoadVeh,
 
	CmdBuildShip,
 
	CmdBuildAircraft,
 
};
 

	
 
static VehicleID * _new_vehicle_id_proc_table[] = {
vehicle.h
Show inline comments
 
@@ -432,30 +432,31 @@ static inline Vehicle *GetFirstVehicleFr
 
	Vehicle *u = v;
 
	while (u->prev_shared != NULL)
 
		u = u->prev_shared;
 

	
 
	return u;
 
}
 

	
 
// NOSAVE: Can be regenerated by inspecting the vehicles.
 
VARDEF VehicleID _vehicle_position_hash[0x1000];
 

	
 
// NOSAVE: Return values from various commands.
 
VARDEF VehicleID _new_train_id;
 
VARDEF VehicleID _new_wagon_id;
 
VARDEF VehicleID _new_aircraft_id;
 
VARDEF VehicleID _new_ship_id;
 
VARDEF VehicleID _new_roadveh_id;
 
VARDEF uint16 _aircraft_refit_capacity;
 
VARDEF byte _cmd_build_rail_veh_score;
 
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
 
#define INVALID_ENGINE 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 */
vehicle_gui.c
Show inline comments
 
@@ -723,48 +723,49 @@ static void DrawEngineArrayInReplaceWind
 
					}
 
					if ( (HASBIT(subtype, 0) == HASBIT(AircraftVehInfo(engine_id)->subtype, 0))
 
						&& HASBIT(e->player_avail, _local_player) ) {
 
						if (sel[1]==0) selected_id[1] = engine_id;
 
						if (IS_INT_INSIDE(--pos2, -w->vscroll.cap, 0)) {
 
							DrawString(x2+62, y2+7, GetCustomEngineName(engine_id), sel[1]==0 ? 0xC : 0x10);
 
							DrawAircraftEngine(x2+29, y2+10, engine_id, SPRITE_PALETTE(PLAYER_SPRITE_COLOR(_local_player)));
 
							y2 += 24;
 
						}
 
						sel[1]--;
 
					}
 
				} while (++engine_id, ++e,--num);
 
			}
 
			break;
 
		}   // end of aircraft
 
	}
 

	
 
}
 
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;
 
	Player *p = GetPlayer(_local_player);
 

	
 
	switch(e->event) {
 
		case WE_PAINT:
 
			{
 
				int pos = w->vscroll.pos;
 
				int selected_id[2] = {-1,-1};
 
				int x = 1;
 
				int y = 15;
 
				int pos2 = w->vscroll2.pos;
 
				int x2 = 1 + 228;
 
				int y2 = 15;
 
				int sel[2];
 
				sel[0] = WP(w,replaceveh_d).sel_index[0];
 
				sel[1] = WP(w,replaceveh_d).sel_index[1];
 

	
 
				{
 
					uint i;
 
					const Vehicle *vehicle;
 

	
 
					for (i = 0; i < lengthof(_player_num_engines); i++) {
 
						_player_num_engines[i] = 0;
 
					}
 
					FOR_ALL_VEHICLES(vehicle) {
 
						if ( vehicle->owner == _local_player ) {
 
@@ -792,70 +793,70 @@ static void ReplaceVehicleWndProc(Window
 
						sel[0] = 0;
 
						WP(w,replaceveh_d).sel_index[0] = 0;
 
						w->vscroll.pos = 0;
 
						// now we go back to set selected_id[1] properly
 
						SetWindowDirty(w);
 
						return;
 
					} else { //there are no vehicles in the left window
 
						selected_id[1] = -1;
 
					}
 
				}
 

	
 
				if ( WP(w,replaceveh_d).count[1] <= sel[1] ) {
 
					if (WP(w,replaceveh_d).count[1]) {
 
						sel[1] = 0;
 
						WP(w,replaceveh_d).sel_index[1] = 0;
 
						w->vscroll2.pos = 0;
 
						// now we go back to set selected_id[1] properly
 
						SetWindowDirty(w);
 
						return;
 
					} else { //there are no vehicles in the right window
 
						selected_id[1] = -1;
 
					}
 
				}
 

	
 
				if ( selected_id[0] == selected_id[1] || _autoreplace_array[selected_id[0]] == selected_id[1]
 
				if ( selected_id[0] == selected_id[1] || p->engine_replacement[selected_id[0]] == selected_id[1]
 
					|| selected_id[0] == -1 || selected_id[1] == -1 )
 
					SETBIT(w->disabled_state, 4);
 
				else
 
					CLRBIT(w->disabled_state, 4);
 

	
 
				if ( _autoreplace_array[selected_id[0]] == selected_id[0] || selected_id[0] == -1 )
 
				if (p->engine_replacement[selected_id[0]] == INVALID_ENGINE || selected_id[0] == -1)
 
					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 ) {
 
					if ( selected_id[0] == _autoreplace_array[selected_id[0]] )
 
					if (p->engine_replacement[selected_id[0]] == INVALID_ENGINE)
 
						SetDParam(0, STR_NOT_REPLACING);
 
					else
 
						SetDParam(0, GetCustomEngineName(_autoreplace_array[selected_id[0]]));
 
						SetDParam(0, GetCustomEngineName(p->engine_replacement[selected_id[0]]));
 
				} 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);
 

	
 

	
 
				/*	now we draw the two arrays according to what we just counted */
 
				DrawEngineArrayInReplaceWindow(w, x, y, x2, y2, pos, pos2, sel[0], sel[1], selected_id[0], selected_id[1]);
 

	
 
				WP(w,replaceveh_d).sel_engine[0] = selected_id[0];
 
				WP(w,replaceveh_d).sel_engine[1] = selected_id[1];
 
				/* now we draw the info about the vehicles we selected */
 
				switch (WP(w,replaceveh_d).vehicletype) {
 
					case VEH_Train: {
 
						byte i = 0;
 
						int offset = 0;
 

	
 
						for ( i = 0 ; i < 2 ; i++) {
 
							if ( i )
 
							offset = 228;
 
							if (selected_id[i] != -1) {
 
								if (!(RailVehInfo(selected_id[i])->flags & RVI_WAGON)) {
 
@@ -887,56 +888,59 @@ static void ReplaceVehicleWndProc(Window
 
								DrawShipPurchaseInfo(2 + 228, 15 + (24 * w->vscroll.cap), selected_id[1]);
 
							}
 
						}
 
						break;
 
					}   // end of VEH_Ship
 

	
 
					case VEH_Aircraft: {
 
						if (selected_id[0] != -1) {
 
							DrawAircraftPurchaseInfo(2, 15 + (24 * w->vscroll.cap), selected_id[0]);
 
							if (selected_id[1] != -1) {
 
								DrawAircraftPurchaseInfo(2 + 228, 15 + (24 * w->vscroll.cap), selected_id[1]);
 
							}
 
						}
 
						break;
 
					}   // end of VEH_Aircraft
 
				}
 
			} break;   // end of paint
 

	
 
		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);
 
					break;
 
				}
 
				case 4: {
 
					_autoreplace_array[WP(w,replaceveh_d).sel_engine[0]] = WP(w,replaceveh_d).sel_engine[1];
 
				case 4: { /* Start replacing */
 
					EngineID veh_from = WP(w, replaceveh_d).sel_engine[0];
 
					EngineID veh_to = WP(w, replaceveh_d).sel_engine[1];
 
					DoCommandP(0, 3, veh_from + (veh_to << 16), NULL, CMD_REPLACE_VEHICLE);
 
					SetWindowDirty(w);
 
					break;
 
				}
 

	
 
				case 6: {
 
					_autoreplace_array[WP(w,replaceveh_d).sel_engine[0]] = WP(w,replaceveh_d).sel_engine[0];
 
				case 6: { /* Stop replacing */
 
					EngineID veh_from = WP(w, replaceveh_d).sel_engine[0];
 
					DoCommandP(0, 3, veh_from + (INVALID_ENGINE << 16), NULL, CMD_REPLACE_VEHICLE);
 
					SetWindowDirty(w);
 
					break;
 
				}
 

	
 
				case 7:
 
					// sets up that the left one was clicked. The default values are for the right one (9)
 
					// this way, the code for 9 handles both sides
 
					click_scroll_pos = w->vscroll.pos;
 
					click_scroll_cap = w->vscroll.cap;
 
					click_side = 0;
 
				case 9: {
 
					uint i = (e->click.pt.y - 14) / w->resize.step_height;
 
					if (i < click_scroll_cap) {
 
						WP(w,replaceveh_d).sel_index[click_side] = i + click_scroll_pos;
 
						SetWindowDirty(w);
 
					}
 
				} break;
 
			}
 

	
 
		} break;
 

	
 
		case WE_DROPDOWN_SELECT: { /* we have selected a dropdown item in the list */
 
			_railtype_selected_in_replace_gui = e->dropdown.index;
 
			SetWindowDirty(w);
0 comments (0 inline, 0 general)