tron@2186: /* $Id$ */
tron@2186: 
truelight@0: #include "stdafx.h"
Darkvater@1891: #include "openttd.h"
tron@1299: #include "debug.h"
tron@2163: #include "functions.h"
tron@2201: #include "string.h"
tron@2201: #include "strings.h"
tron@507: #include "table/strings.h"
truelight@0: #include "engine.h"
truelight@0: #include "table/engines.h"
tron@1009: #include "gfx.h"
truelight@0: #include "player.h"
truelight@0: #include "command.h"
truelight@0: #include "vehicle.h"
truelight@0: #include "news.h"
truelight@0: #include "saveload.h"
darkvater@405: #include "sprite.h"
tron@2159: #include "variables.h"
peter1138@2708: #include "train.h"
truelight@0: 
tron@2763: EngineInfo _engine_info[TOTAL_NUM_ENGINES];
tron@2763: RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];
tron@2763: ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];
tron@2763: AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];
tron@2763: RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];
tron@2763: 
truelight@0: enum {
truelight@0: 	ENGINE_AVAILABLE = 1,
truelight@0: 	ENGINE_INTRODUCING = 2,
truelight@0: 	ENGINE_PREVIEWING = 4,
truelight@0: };
truelight@0: 
Darkvater@1802: /** TRANSLATE FROM LOCAL CARGO TO GLOBAL CARGO ID'S.
Darkvater@1802:  * This maps the per-landscape cargo ID's to globally unique cargo ID's usable ie. in
Darkvater@1802:  * the custom GRF  files. It is basically just a transcribed table from TTDPatch's newgrf.txt.
Darkvater@1802:  */
Darkvater@1802: const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {
Darkvater@1802: 	/* LT_NORMAL */ {GC_PASSENGERS, GC_COAL,  GC_MAIL, GC_OIL, GC_LIVESTOCK, GC_GOODS, GC_GRAIN, GC_WOOD, GC_IRON_ORE,    GC_STEEL,  GC_VALUABLES, GC_PAPER_TEMP},
Darkvater@1802: 	/* LT_HILLY */  {GC_PASSENGERS, GC_COAL,  GC_MAIL, GC_OIL, GC_LIVESTOCK, GC_GOODS, GC_GRAIN, GC_WOOD, GC_INVALID,     GC_PAPER,  GC_VALUABLES, GC_FOOD },
Darkvater@1802: 	/* LT_DESERT */ {GC_PASSENGERS, GC_RUBBER,GC_MAIL, GC_OIL, GC_FRUIT,     GC_GOODS, GC_GRAIN, GC_WOOD, GC_COPPER_ORE,  GC_WATER,  GC_VALUABLES, GC_FOOD },
Darkvater@1802: 	/* LT_CANDY */  {GC_PASSENGERS, GC_SUGAR, GC_MAIL, GC_TOYS,GC_BATTERIES, GC_CANDY, GC_TOFFEE,GC_COLA, GC_COTTON_CANDY,GC_BUBBLES,GC_PLASTIC,   GC_FIZZY_DRINKS },
Darkvater@1802: 	/**
Darkvater@1802: 	 * - GC_INVALID (255) means that  cargo is not available for that climate
Darkvater@1802: 	 * - GC_PAPER_TEMP (27) is paper in  temperate climate in TTDPatch
Darkvater@1802: 	 * Following can  be renumbered:
Darkvater@1802: 	 * - GC_DEFAULT (29) is the defa ult cargo for the purpose of spritesets
Darkvater@1802: 	 * - GC_PURCHASE (30) is the purchase list image (the equivalent of 0xff) for the purpose of spritesets
Darkvater@1802: 	 */
truelight@0: };
truelight@0: 
Darkvater@1802: /** BEGIN --- TRANSLATE FROM GLOBAL CARGO TO LOCAL CARGO ID'S **/
Darkvater@1802: /** Map global cargo ID's to local-cargo ID's */
Darkvater@1802: const CargoID _local_cargo_id_ctype[NUM_GLOBAL_CID] = {
Darkvater@1802: 	CT_PASSENGERS,CT_COAL,   CT_MAIL,        CT_OIL,      CT_LIVESTOCK,CT_GOODS,  CT_GRAIN,      CT_WOOD,         /*  0- 7 */
Darkvater@1802: 	CT_IRON_ORE,  CT_STEEL,  CT_VALUABLES,   CT_PAPER,    CT_FOOD,     CT_FRUIT,  CT_COPPER_ORE, CT_WATER,        /*  8-15 */
Darkvater@1802: 	CT_RUBBER,    CT_SUGAR,  CT_TOYS,        CT_BATTERIES,CT_CANDY,    CT_TOFFEE, CT_COLA,       CT_COTTON_CANDY, /* 16-23 */
Darkvater@1802: 	CT_BUBBLES,   CT_PLASTIC,CT_FIZZY_DRINKS,CT_PAPER     /* unsup. */,CT_HILLY_UNUSED,                           /* 24-28 */
Darkvater@1802: 	CT_INVALID,   CT_INVALID                                                                                      /* 29-30 */
truelight@0: };
truelight@0: 
Darkvater@1802: #define MC(cargo) (1 << cargo)
Darkvater@1802: /** Bitmasked value where the global cargo ID is available in landscape
Darkvater@1802:  * 0: LT_NORMAL, 1: LT_HILLY, 2: LT_DESERT, 3: LT_CANDY */
Darkvater@1802: const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE] =
Darkvater@1802: { /* LT_NORMAL: temperate */
Darkvater@1802: 	MC(GC_PASSENGERS)|MC(GC_COAL)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|
peter1138@2611: 	MC(GC_IRON_ORE)|MC(GC_STEEL)|MC(GC_VALUABLES),
Darkvater@1802: 	/* LT_HILLY: arctic */
Darkvater@1802: 	MC(GC_PASSENGERS)|MC(GC_COAL)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|
peter1138@2611: 	MC(GC_GRAIN)|MC(GC_WOOD)|MC(GC_VALUABLES)|MC(GC_PAPER)|MC(GC_FOOD),
Darkvater@1802: 	/* LT_DESERT: rainforest/desert */
Darkvater@1802: 	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|
Darkvater@1802: 	MC(GC_VALUABLES)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_COPPER_ORE)|MC(GC_WATER)|MC(GC_RUBBER),
Darkvater@1802: 	/* LT_CANDY: toyland */
Darkvater@1802: 	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_SUGAR)|MC(GC_TOYS)|MC(GC_BATTERIES)|MC(GC_CANDY)|
Darkvater@1802: 	MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS)
truelight@0: };
Darkvater@1802: /** END   --- TRANSLATE FROM GLOBAL CARGO TO LOCAL CARGO ID'S **/
Darkvater@1802: 
Darkvater@1802: /** Bitmasked values of what type of cargo is refittable for the given vehicle-type.
Darkvater@1802:  * This coupled with the landscape information (_landscape_global_cargo_mask) gives
Darkvater@1802:  * us exactly what is refittable and what is not */
Darkvater@1802: const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {
Darkvater@1802: 	/* Trains */
Darkvater@1802: 	MC(GC_PASSENGERS)|MC(GC_COAL)|MC(GC_MAIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|MC(GC_IRON_ORE)|
Darkvater@1802: 	MC(GC_STEEL)|MC(GC_VALUABLES)|MC(GC_PAPER)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_COPPER_ORE)|MC(GC_WATER)|MC(GC_SUGAR)|
Darkvater@1802: 	MC(GC_TOYS)|MC(GC_CANDY)|MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS),
Darkvater@1802: 	/* Road vehicles (not refittable by default) */
Darkvater@1802: 	0,
Darkvater@1802: 	/* Ships */
Darkvater@1802: 	MC(GC_COAL)|MC(GC_MAIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|MC(GC_IRON_ORE)|MC(GC_STEEL)|MC(GC_VALUABLES)|
Darkvater@1802: 	MC(GC_PAPER)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_COPPER_ORE)|MC(GC_WATER)|MC(GC_RUBBER)|MC(GC_SUGAR)|MC(GC_TOYS)|MC(GC_BATTERIES)|
Darkvater@1802: 	MC(GC_CANDY)|MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS),
Darkvater@1802: 	/* Aircraft */
Darkvater@1802: 	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_GOODS)|MC(GC_VALUABLES)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_SUGAR)|MC(GC_TOYS)|
Darkvater@1802: 	MC(GC_BATTERIES)|MC(GC_CANDY)|MC(GC_TOFFEE)|MC(GC_COLA)|MC(GC_COTTON_CANDY)|MC(GC_BUBBLES)|MC(GC_PLASTIC)|MC(GC_FIZZY_DRINKS),
Darkvater@1802: 	/* Special/Disaster */
Darkvater@1802: 	0,0
Darkvater@1802: };
peter1138@2611: 
peter1138@2611: /**
peter1138@2611:  * Bitmask of classes for cargo types.
peter1138@2611:  */
peter1138@2611: const uint32 cargo_classes[16] = {
peter1138@2611: 	/* Passengers */ MC(GC_PASSENGERS),
peter1138@2611: 	/* Mail       */ MC(GC_MAIL),
peter1138@2611: 	/* Express    */ MC(GC_GOODS)|MC(GC_FOOD)|MC(GC_CANDY),
peter1138@2611: 	/* Armoured   */ MC(GC_VALUABLES),
peter1138@2611: 	/* Bulk       */ MC(GC_COAL)|MC(GC_GRAIN)|MC(GC_IRON_ORE)|MC(GC_COPPER_ORE)|MC(GC_FRUIT)|MC(GC_SUGAR)|MC(GC_TOFFEE)|MC(GC_COTTON_CANDY),
peter1138@2611: 	/* Piece      */ MC(GC_LIVESTOCK)|MC(GC_WOOD)|MC(GC_STEEL)|MC(GC_PAPER)|MC(GC_TOYS)|MC(GC_BATTERIES)|MC(GC_BUBBLES)|MC(GC_FIZZY_DRINKS),
peter1138@2611: 	/* Liquids    */ MC(GC_OIL)|MC(GC_WATER)|MC(GC_RUBBER)|MC(GC_COLA)|MC(GC_PLASTIC),
peter1138@2611: 	/* Chilled    */ MC(GC_FOOD)|MC(GC_FRUIT),
peter1138@2611: 	/* Undefined  */ 0, 0, 0, 0, 0, 0, 0, 0
peter1138@2611: };
Darkvater@1802: #undef MC
truelight@0: 
tron@2477: void ShowEnginePreviewWindow(EngineID engine);
truelight@0: 
tron@1093: void DeleteCustomEngineNames(void)
truelight@0: {
truelight@0: 	uint i;
truelight@0: 	StringID old;
truelight@0: 
Darkvater@1474: 	for (i = 0; i != TOTAL_NUM_ENGINES; i++) {
truelight@0: 		old = _engine_name_strings[i];
truelight@0: 		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;
truelight@0: 		DeleteName(old);
truelight@0: 	}
truelight@0: 
truelight@0: 	_vehicle_design_names &= ~1;
truelight@0: }
truelight@0: 
tron@1093: void LoadCustomEngineNames(void)
truelight@0: {
truelight@0: 	// XXX: not done */
truelight@0: 	DEBUG(misc, 1) ("LoadCustomEngineNames: not done");
truelight@0: }
truelight@0: 
tron@1093: static void SetupEngineNames(void)
truelight@0: {
Darkvater@1474: 	StringID *name;
truelight@0: 
Darkvater@1474: 	for (name = _engine_name_strings; name != endof(_engine_name_strings); name++)
Darkvater@1474: 		*name = STR_SV_EMPTY;
truelight@0: 
truelight@0: 	DeleteCustomEngineNames();
truelight@0: 	LoadCustomEngineNames();
truelight@0: }
truelight@0: 
tron@1093: static void AdjustAvailAircraft(void)
truelight@0: {
truelight@0: 	uint16 date = _date;
truelight@0: 	byte avail = 0;
truelight@0: 	if (date >= 12784) avail |= 2; // big airport
truelight@0: 	if (date < 14610 || _patches.always_small_airport) avail |= 1;  // small airport
truelight@0: 	if (date >= 15706) avail |= 4; // enable heliport
truelight@0: 
truelight@0: 	if (avail != _avail_aircraft) {
truelight@0: 		_avail_aircraft = avail;
truelight@0: 		InvalidateWindow(WC_BUILD_STATION, 0);
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static void CalcEngineReliability(Engine *e)
truelight@0: {
truelight@0: 	uint age = e->age;
truelight@0: 
truelight@0: 	if (age < e->duration_phase_1) {
truelight@0: 		uint start = e->reliability_start;
truelight@0: 		e->reliability = age * (e->reliability_max - start) / e->duration_phase_1 + start;
truelight@0: 	} else if ((age -= e->duration_phase_1) < e->duration_phase_2) {
truelight@0: 		e->reliability = e->reliability_max;
truelight@0: 	} else if ((age -= e->duration_phase_2) < e->duration_phase_3) {
truelight@0: 		uint max = e->reliability_max;
truelight@0: 		e->reliability = (int)age * (int)(e->reliability_final - max) / e->duration_phase_3 + max;
truelight@0: 	} else {
dominik@292: 		// time's up for this engine
dominik@292: 		// make it either available to all players (if never_expire_vehicles is enabled and if it was available earlier)
dominik@292: 		// or disable this engine completely
dominik@292: 		e->player_avail = (_patches.never_expire_vehicles && e->player_avail)? -1 : 0;
truelight@0: 		e->reliability = e->reliability_final;
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@1093: void AddTypeToEngines(void)
bjarni@842: {
tron@2242: 	Engine* e = _engines;
bjarni@842: 
tron@2242: 	do e->type = VEH_Train;    while (++e < &_engines[ROAD_ENGINES_INDEX]);
tron@2242: 	do e->type = VEH_Road;     while (++e < &_engines[SHIP_ENGINES_INDEX]);
tron@2242: 	do e->type = VEH_Ship;     while (++e < &_engines[AIRCRAFT_ENGINES_INDEX]);
tron@2242: 	do e->type = VEH_Aircraft; while (++e < &_engines[TOTAL_NUM_ENGINES]);
tron@2242: 	do e->type = VEH_Special;  while (++e < endof(_engines));
bjarni@842: }
bjarni@842: 
tron@1093: void StartupEngines(void)
truelight@0: {
truelight@0: 	Engine *e;
truelight@0: 	const EngineInfo *ei;
truelight@0: 
truelight@0: 	SetupEngineNames();
truelight@0: 
tron@2242: 	for (e = _engines, ei = _engine_info; e != endof(_engines); e++, ei++) {
tron@2242: 		uint32 r;
truelight@0: 
truelight@0: 		e->age = 0;
tron@2530: 		e->railtype = ei->railtype;
truelight@0: 		e->flags = 0;
truelight@0: 		e->player_avail = 0;
truelight@193: 
peter1138@2875: 		// The magic value of 729 days below comes from the NewGRF spec. If the
peter1138@2875: 		// base intro date is before 1922 then the random number of days is not
peter1138@2875: 		// added.
truelight@0: 		r = Random();
peter1138@2875: 		e->intro_date = ei->base_intro <= 729 ? ei->base_intro : GB(r, 0, 9) + ei->base_intro;
truelight@0: 		if (e->intro_date <= _date) {
truelight@0: 			e->age = (_date - e->intro_date) >> 5;
truelight@0: 			e->player_avail = (byte)-1;
truelight@0: 			e->flags |= ENGINE_AVAILABLE;
truelight@0: 		}
truelight@0: 
tron@2140: 		e->reliability_start = GB(r, 16, 14) + 0x7AE0;
truelight@0: 		r = Random();
tron@2140: 		e->reliability_max   = GB(r,  0, 14) + 0xBFFF;
tron@2140: 		e->reliability_final = GB(r, 16, 14) + 0x3FFF;
truelight@0: 
truelight@0: 		r = Random();
tron@2140: 		e->duration_phase_1 = GB(r, 0, 5) + 7;
tron@2140: 		e->duration_phase_2 = GB(r, 5, 4) + ei->base_life * 12 - 96;
tron@2140: 		e->duration_phase_3 = GB(r, 9, 7) + 120;
truelight@0: 
truelight@0: 		e->reliability_spd_dec = (ei->unk2&0x7F) << 2;
truelight@0: 
truelight@0: 		/* my invented flag for something that is a wagon */
truelight@0: 		if (ei->unk2 & 0x80) {
truelight@0: 			e->age = 0xFFFF;
truelight@0: 		} else {
truelight@0: 			CalcEngineReliability(e);
truelight@0: 		}
truelight@0: 
truelight@0: 		e->lifelength = ei->lifelength + _patches.extend_vehicle_life;
truelight@0: 
truelight@0: 		// prevent certain engines from ever appearing.
tron@2530: 		if (!HASBIT(ei->climates, _opt.landscape)) {
truelight@0: 			e->flags |= ENGINE_AVAILABLE;
truelight@0: 			e->player_avail = 0;
truelight@0: 		}
tron@915: 
bjarni@819: 		/* This sets up type for the engine
bjarni@819: 		   It is needed if you want to ask the engine what type it is
bjarni@819: 		   It should hopefully be the same as when you ask a vehicle what it is
bjarni@819: 		   but using this, you can ask what type an engine number is
bjarni@819: 		   even if it is not a vehicle (yet)*/
truelight@0: 	}
truelight@0: 
truelight@0: 	AdjustAvailAircraft();
truelight@0: }
truelight@0: 
truelight@0: // TODO: We don't support cargo-specific wagon overrides. Pretty exotic... ;-) --pasky
truelight@0: 
tron@1477: typedef struct WagonOverride {
truelight@0: 	byte *train_id;
truelight@0: 	int trains;
peter1138@2488: 	SpriteGroup *group;
tron@1477: } WagonOverride;
truelight@0: 
tron@1477: typedef struct WagonOverrides {
truelight@0: 	int overrides_count;
tron@1477: 	WagonOverride *overrides;
tron@1477: } WagonOverrides;
truelight@0: 
tron@1477: static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];
tron@1477: 
tron@2477: void SetWagonOverrideSprites(EngineID engine, SpriteGroup *group, byte *train_id,
tron@1477: 	int trains)
truelight@0: {
tron@1477: 	WagonOverrides *wos;
tron@1477: 	WagonOverride *wo;
truelight@0: 
truelight@0: 	wos = &_engine_wagon_overrides[engine];
truelight@0: 	wos->overrides_count++;
truelight@0: 	wos->overrides = realloc(wos->overrides,
tron@1477: 		wos->overrides_count * sizeof(*wos->overrides));
truelight@193: 
truelight@0: 	wo = &wos->overrides[wos->overrides_count - 1];
darkvater@408: 	/* FIXME: If we are replacing an override, release original SpriteGroup
darkvater@408: 	 * to prevent leaks. But first we need to refcount the SpriteGroup.
darkvater@408: 	 * --pasky */
peter1138@2488: 	wo->group = group;
peter1138@2490: 	group->ref_count++;
truelight@0: 	wo->trains = trains;
truelight@0: 	wo->train_id = malloc(trains);
truelight@0: 	memcpy(wo->train_id, train_id, trains);
truelight@0: }
truelight@0: 
tron@2477: static const SpriteGroup *GetWagonOverrideSpriteSet(EngineID engine, byte overriding_engine)
truelight@0: {
tron@2242: 	const WagonOverrides *wos = &_engine_wagon_overrides[engine];
truelight@0: 	int i;
truelight@0: 
darkvater@408: 	// XXX: This could turn out to be a timesink on profiles. We could
darkvater@408: 	// always just dedicate 65535 bytes for an [engine][train] trampoline
darkvater@408: 	// for O(1). Or O(logMlogN) and searching binary tree or smt. like
darkvater@408: 	// that. --pasky
truelight@0: 
truelight@0: 	for (i = 0; i < wos->overrides_count; i++) {
tron@2242: 		const WagonOverride *wo = &wos->overrides[i];
truelight@0: 		int j;
truelight@0: 
truelight@0: 		for (j = 0; j < wo->trains; j++) {
truelight@0: 			if (wo->train_id[j] == overriding_engine)
peter1138@2488: 				return wo->group;
truelight@0: 		}
truelight@0: 	}
truelight@0: 	return NULL;
truelight@0: }
truelight@0: 
peter1138@2491: /**
peter1138@2491:  * Unload all wagon override sprite groups.
peter1138@2491:  */
peter1138@2491: void UnloadWagonOverrides(void)
peter1138@2491: {
peter1138@2491: 	WagonOverrides *wos;
peter1138@2491: 	WagonOverride *wo;
peter1138@2491: 	EngineID engine;
peter1138@2491: 	int i;
peter1138@2491: 
peter1138@2491: 	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {
peter1138@2491: 		wos = &_engine_wagon_overrides[engine];
peter1138@2491: 		for (i = 0; i < wos->overrides_count; i++) {
peter1138@2491: 			wo = &wos->overrides[i];
peter1138@2491: 			UnloadSpriteGroup(&wo->group);
peter1138@2491: 			free(wo->train_id);
peter1138@2491: 		}
peter1138@2491: 		free(wos->overrides);
peter1138@2491: 		wos->overrides_count = 0;
peter1138@2491: 		wos->overrides = NULL;
peter1138@2491: 	}
peter1138@2491: }
truelight@0: 
truelight@0: // 0 - 28 are cargos, 29 is default, 30 is the advert (purchase list)
truelight@0: // (It isn't and shouldn't be like this in the GRF files since new cargo types
truelight@0: // may appear in future - however it's more convenient to store it like this in
truelight@0: // memory. --pasky)
peter1138@2488: static SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];
truelight@0: 
tron@2477: void SetCustomEngineSprites(EngineID engine, byte cargo, SpriteGroup *group)
truelight@0: {
peter1138@2491: 	if (engine_custom_sprites[engine][cargo] != NULL) {
peter1138@2491: 		DEBUG(grf, 6)("SetCustomEngineSprites: engine `%d' cargo `%d' already has group -- removing.", engine, cargo);
peter1138@2491: 		UnloadSpriteGroup(&engine_custom_sprites[engine][cargo]);
peter1138@2491: 	}
peter1138@2488: 	engine_custom_sprites[engine][cargo] = group;
peter1138@2490: 	group->ref_count++;
truelight@0: }
truelight@0: 
peter1138@2491: /**
peter1138@2491:  * Unload all engine sprite groups.
peter1138@2491:  */
peter1138@2491: void UnloadCustomEngineSprites(void)
peter1138@2491: {
peter1138@2491: 	EngineID engine;
peter1138@2491: 	CargoID cargo;
peter1138@2491: 
peter1138@2491: 	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {
peter1138@2491: 		for (cargo = 0; cargo < NUM_GLOBAL_CID; cargo++) {
peter1138@2491: 			if (engine_custom_sprites[engine][cargo] != NULL) {
peter1138@2491: 				DEBUG(grf, 6)("UnloadCustomEngineSprites: Unloading group for engine `%d' cargo `%d'.", engine, cargo);
peter1138@2491: 				UnloadSpriteGroup(&engine_custom_sprites[engine][cargo]);
peter1138@2491: 			}
peter1138@2491: 		}
peter1138@2491: 	}
peter1138@2491: }
peter1138@2491: 
peter1138@2708: static int MapOldSubType(const Vehicle *v)
peter1138@2708: {
peter1138@2708: 	if (v->type != VEH_Train) return v->subtype;
peter1138@2708: 	if (IsTrainEngine(v)) return 0;
peter1138@2708: 	if (IsFreeWagon(v)) return 4;
peter1138@2708: 	return 2;
peter1138@2708: }
peter1138@2708: 
tron@2242: typedef SpriteGroup *(*resolve_callback)(const SpriteGroup *spritegroup,
hackykid@1883: 	const Vehicle *veh, uint16 callback_info, void *resolve_func); /* XXX data pointer used as function pointer */
tron@445: 
tron@2242: static const SpriteGroup* ResolveVehicleSpriteGroup(const SpriteGroup *spritegroup,
hackykid@1883: 	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)
tron@426: {
peter1138@2488: 	if (spritegroup == NULL)
peter1138@2488: 		return NULL;
peter1138@2488: 
tron@445: 	//debug("spgt %d", spritegroup->type);
tron@426: 	switch (spritegroup->type) {
tron@426: 		case SGT_REAL:
hackykid@1883: 		case SGT_CALLBACK:
hackykid@1883: 			return spritegroup;
tron@426: 
tron@426: 		case SGT_DETERMINISTIC: {
tron@2242: 			const DeterministicSpriteGroup *dsg = &spritegroup->g.determ;
tron@2242: 			const SpriteGroup *target;
tron@426: 			int value = -1;
tron@426: 
tron@433: 			//debug("[%p] Having fun resolving variable %x", veh, dsg->variable);
hackykid@1883: 			if (dsg->variable == 0x0C) {
hackykid@1883: 				/* Callback ID */
hackykid@1883: 				value = callback_info & 0xFF;
peter1138@2602: 			} else if (dsg->variable == 0x10) {
peter1138@2602: 				value = (callback_info >> 8) & 0xFF;
hackykid@1883: 			} else if ((dsg->variable >> 6) == 0) {
tron@426: 				/* General property */
tron@426: 				value = GetDeterministicSpriteValue(dsg->variable);
tron@426: 			} else {
tron@433: 				/* Vehicle-specific property. */
tron@433: 
tron@433: 				if (veh == NULL) {
tron@433: 					/* We are in a purchase list of something,
tron@433: 					 * and we are checking for something undefined.
tron@433: 					 * That means we should get the first target
tron@433: 					 * (NOT the default one). */
tron@433: 					if (dsg->num_ranges > 0) {
peter1138@2488: 						target = dsg->ranges[0].group;
tron@433: 					} else {
tron@433: 						target = dsg->default_group;
tron@433: 					}
hackykid@1883: 					return resolve_func(target, NULL, callback_info, resolve_func);
tron@433: 				}
tron@433: 
tron@426: 				if (dsg->var_scope == VSG_SCOPE_PARENT) {
tron@426: 					/* First engine in the vehicle chain */
tron@433: 					if (veh->type == VEH_Train)
tron@426: 						veh = GetFirstVehicleInChain(veh);
tron@426: 				}
tron@426: 
hackykid@1855: 				if (dsg->variable == 0x40 || dsg->variable == 0x41) {
tron@433: 					if (veh->type == VEH_Train) {
tron@2242: 						const Vehicle *u = GetFirstVehicleInChain(veh);
tron@426: 						byte chain_before = 0, chain_after = 0;
tron@426: 
tron@426: 						while (u != veh) {
hackykid@1855: 							chain_before++;
hackykid@1855: 							if (dsg->variable == 0x41 && u->engine_type != veh->engine_type)
hackykid@1855: 								chain_before = 0;
tron@426: 							u = u->next;
tron@426: 						}
hackykid@1855: 						while (u->next != NULL && (dsg->variable == 0x40 || u->next->engine_type == veh->engine_type)) {
hackykid@1855: 							chain_after++;
tron@426: 							u = u->next;
tron@426: 						};
tron@426: 
pasky@1559: 						value = chain_before | chain_after << 8
pasky@1559: 						        | (chain_before + chain_after) << 16;
tron@426: 					} else {
tron@426: 						value = 1; /* 1 vehicle in the chain */
tron@426: 					}
tron@426: 
tron@426: 				} else {
tron@426: 					// TTDPatch runs on little-endian arch;
tron@426: 					// Variable is 0x80 + offset in TTD's vehicle structure
tron@426: 					switch (dsg->variable - 0x80) {
tron@555: #define veh_prop(id_, value_) case (id_): value = (value_); break
tron@426: 						veh_prop(0x00, veh->type);
peter1138@2708: 						veh_prop(0x01, MapOldSubType(veh));
tron@426: 						veh_prop(0x04, veh->index);
tron@426: 						veh_prop(0x05, veh->index & 0xFF);
tron@426: 						/* XXX? Is THIS right? */
tron@555: 						veh_prop(0x0A, PackOrder(&veh->current_order));
tron@555: 						veh_prop(0x0B, PackOrder(&veh->current_order) & 0xff);
tron@426: 						veh_prop(0x0C, veh->num_orders);
tron@426: 						veh_prop(0x0D, veh->cur_order_index);
tron@426: 						veh_prop(0x10, veh->load_unload_time_rem);
tron@426: 						veh_prop(0x11, veh->load_unload_time_rem & 0xFF);
tron@426: 						veh_prop(0x12, veh->date_of_last_service);
tron@426: 						veh_prop(0x13, veh->date_of_last_service & 0xFF);
tron@426: 						veh_prop(0x14, veh->service_interval);
tron@426: 						veh_prop(0x15, veh->service_interval & 0xFF);
tron@426: 						veh_prop(0x16, veh->last_station_visited);
tron@426: 						veh_prop(0x17, veh->tick_counter);
tron@426: 						veh_prop(0x18, veh->max_speed);
tron@426: 						veh_prop(0x19, veh->max_speed & 0xFF);
tron@426: 						veh_prop(0x1F, veh->direction);
tron@426: 						veh_prop(0x28, veh->cur_image);
tron@426: 						veh_prop(0x29, veh->cur_image & 0xFF);
tron@426: 						veh_prop(0x32, veh->vehstatus);
tron@426: 						veh_prop(0x33, veh->vehstatus);
tron@426: 						veh_prop(0x34, veh->cur_speed);
tron@426: 						veh_prop(0x35, veh->cur_speed & 0xFF);
tron@426: 						veh_prop(0x36, veh->subspeed);
tron@426: 						veh_prop(0x37, veh->acceleration);
tron@426: 						veh_prop(0x39, veh->cargo_type);
tron@426: 						veh_prop(0x3A, veh->cargo_cap);
tron@426: 						veh_prop(0x3B, veh->cargo_cap & 0xFF);
tron@426: 						veh_prop(0x3C, veh->cargo_count);
tron@426: 						veh_prop(0x3D, veh->cargo_count & 0xFF);
tron@426: 						veh_prop(0x3E, veh->cargo_source); // Probably useless; so what
tron@426: 						veh_prop(0x3F, veh->cargo_days);
tron@426: 						veh_prop(0x40, veh->age);
tron@426: 						veh_prop(0x41, veh->age & 0xFF);
tron@426: 						veh_prop(0x42, veh->max_age);
tron@426: 						veh_prop(0x43, veh->max_age & 0xFF);
tron@426: 						veh_prop(0x44, veh->build_year);
tron@426: 						veh_prop(0x45, veh->unitnumber);
tron@426: 						veh_prop(0x46, veh->engine_type);
tron@426: 						veh_prop(0x47, veh->engine_type & 0xFF);
tron@426: 						veh_prop(0x48, veh->spritenum);
tron@426: 						veh_prop(0x49, veh->day_counter);
tron@426: 						veh_prop(0x4A, veh->breakdowns_since_last_service);
tron@426: 						veh_prop(0x4B, veh->breakdown_ctr);
tron@426: 						veh_prop(0x4C, veh->breakdown_delay);
tron@426: 						veh_prop(0x4D, veh->breakdown_chance);
tron@426: 						veh_prop(0x4E, veh->reliability);
tron@426: 						veh_prop(0x4F, veh->reliability & 0xFF);
tron@426: 						veh_prop(0x50, veh->reliability_spd_dec);
tron@426: 						veh_prop(0x51, veh->reliability_spd_dec & 0xFF);
tron@426: 						veh_prop(0x52, veh->profit_this_year);
tron@426: 						veh_prop(0x53, veh->profit_this_year & 0xFFFFFF);
tron@426: 						veh_prop(0x54, veh->profit_this_year & 0xFFFF);
tron@426: 						veh_prop(0x55, veh->profit_this_year & 0xFF);
tron@426: 						veh_prop(0x56, veh->profit_last_year);
tron@426: 						veh_prop(0x57, veh->profit_last_year & 0xFF);
tron@426: 						veh_prop(0x58, veh->profit_last_year);
tron@426: 						veh_prop(0x59, veh->profit_last_year & 0xFF);
hackykid@1855: 						veh_prop(0x5A, veh->next == NULL ? INVALID_VEHICLE : veh->next->index);
tron@426: 						veh_prop(0x5C, veh->value);
tron@426: 						veh_prop(0x5D, veh->value & 0xFFFFFF);
tron@426: 						veh_prop(0x5E, veh->value & 0xFFFF);
tron@426: 						veh_prop(0x5F, veh->value & 0xFF);
tron@426: 						veh_prop(0x60, veh->string_id);
tron@426: 						veh_prop(0x61, veh->string_id & 0xFF);
tron@426: 						/* 00h..07h=sub image? 40h=in tunnel; actually some kind of status
tron@426: 						 * aircraft: >=13h when in flight
tron@426: 						 * train, ship: 80h=in depot
tron@426: 						 * rv: 0feh=in depot */
tron@426: 						/* TODO veh_prop(0x62, veh->???); */
tron@426: 
tron@426: 						/* TODO: The rest is per-vehicle, I hope no GRF file looks so far.
tron@426: 						 * But they won't let us have an easy ride so surely *some* GRF
tron@426: 						 * file does. So someone needs to do this too. --pasky */
tron@426: 
tron@426: #undef veh_prop
tron@426: 					}
tron@426: 				}
tron@426: 			}
tron@426: 
tron@426: 			target = value != -1 ? EvalDeterministicSpriteGroup(dsg, value) : dsg->default_group;
tron@445: 			//debug("Resolved variable %x: %d, %p", dsg->variable, value, callback);
hackykid@1883: 			return resolve_func(target, veh, callback_info, resolve_func);
tron@445: 		}
tron@445: 
tron@445: 		case SGT_RANDOMIZED: {
tron@2242: 			const RandomizedSpriteGroup *rsg = &spritegroup->g.random;
tron@445: 
tron@445: 			if (veh == NULL) {
tron@445: 				/* Purchase list of something. Show the first one. */
tron@445: 				assert(rsg->num_groups > 0);
tron@445: 				//debug("going for %p: %d", rsg->groups[0], rsg->groups[0].type);
peter1138@2488: 				return resolve_func(rsg->groups[0], NULL, callback_info, resolve_func);
tron@445: 			}
tron@445: 
tron@445: 			if (rsg->var_scope == VSG_SCOPE_PARENT) {
tron@445: 				/* First engine in the vehicle chain */
tron@445: 				if (veh->type == VEH_Train)
tron@445: 					veh = GetFirstVehicleInChain(veh);
tron@445: 			}
tron@445: 
hackykid@1883: 			return resolve_func(EvalRandomizedSpriteGroup(rsg, veh->random_bits), veh, callback_info, resolve_func);
tron@426: 		}
tron@426: 
tron@426: 		default:
tron@445: 			error("I don't know how to handle such a spritegroup %d!", spritegroup->type);
tron@426: 			return NULL;
tron@426: 	}
tron@426: }
tron@426: 
tron@2477: static const SpriteGroup *GetVehicleSpriteGroup(EngineID engine, const Vehicle *v)
truelight@0: {
tron@2242: 	const SpriteGroup *group;
Darkvater@1802: 	byte cargo = GC_PURCHASE;
truelight@0: 
darkvater@414: 	if (v != NULL) {
darkvater@414: 		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];
Darkvater@1802: 		assert(cargo != GC_INVALID);
darkvater@414: 	}
darkvater@414: 
peter1138@2488: 	group = engine_custom_sprites[engine][cargo];
darkvater@414: 
pasky@1560: 	if (v != NULL && v->type == VEH_Train) {
tron@2242: 		const SpriteGroup *overset = GetWagonOverrideSpriteSet(engine, v->u.rail.first_engine);
truelight@0: 
tron@1477: 		if (overset != NULL) group = overset;
truelight@0: 	}
truelight@193: 
tron@445: 	return group;
tron@445: }
tron@445: 
tron@2477: int GetCustomEngineSprite(EngineID engine, const Vehicle *v, byte direction)
tron@445: {
tron@2242: 	const SpriteGroup *group;
tron@2242: 	const RealSpriteGroup *rsg;
Darkvater@1802: 	byte cargo = GC_PURCHASE;
tron@445: 	byte loaded = 0;
tron@445: 	bool in_motion = 0;
tron@445: 	int totalsets, spriteset;
tron@445: 	int r;
tron@445: 
tron@445: 	if (v != NULL) {
tron@445: 		int capacity = v->cargo_cap;
tron@445: 
tron@445: 		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];
Darkvater@1802: 		assert(cargo != GC_INVALID);
Darkvater@1802: 
tron@445: 		if (capacity == 0) capacity = 1;
tron@445: 		loaded = (v->cargo_count * 100) / capacity;
peter1138@2830: 
peter1138@2830: 		if (v->type == VEH_Train) {
peter1138@2830: 			in_motion = GetFirstVehicleInChain(v)->current_order.type != OT_LOADING;
peter1138@2830: 		} else {
peter1138@2830: 			in_motion = v->current_order.type != OT_LOADING;
peter1138@2830: 		}
tron@445: 	}
tron@445: 
tron@445: 	group = GetVehicleSpriteGroup(engine, v);
hackykid@1883: 	group = ResolveVehicleSpriteGroup(group, v, 0, (resolve_callback) ResolveVehicleSpriteGroup);
darkvater@408: 
peter1138@2488: 	if (group == NULL && cargo != GC_DEFAULT) {
darkvater@369: 		// This group is empty but perhaps there'll be a default one.
peter1138@2488: 		group = ResolveVehicleSpriteGroup(engine_custom_sprites[engine][GC_DEFAULT], v, 0,
tron@445: 		                                (resolve_callback) ResolveVehicleSpriteGroup);
truelight@0: 	}
truelight@0: 
peter1138@2488: 	if (group == NULL)
peter1138@2488: 		return 0;
peter1138@2488: 
hackykid@1883: 	assert(group->type == SGT_REAL);
hackykid@1883: 	rsg = &group->g.real;
hackykid@1883: 
darkvater@408: 	if (!rsg->sprites_per_set) {
darkvater@369: 		// This group is empty. This function users should therefore
truelight@0: 		// look up the sprite number in _engine_original_sprites.
truelight@0: 		return 0;
truelight@0: 	}
truelight@0: 
hackykid@1988: 	assert(rsg->sprites_per_set <= 8);
hackykid@1988: 	direction %= rsg->sprites_per_set;
truelight@0: 
darkvater@408: 	totalsets = in_motion ? rsg->loaded_count : rsg->loading_count;
truelight@0: 
truelight@0: 	// My aim here is to make it possible to visually determine absolutely
truelight@0: 	// empty and totally full vehicles. --pasky
truelight@0: 	if (loaded == 100 || totalsets == 1) { // full
truelight@0: 		spriteset = totalsets - 1;
truelight@0: 	} else if (loaded == 0 || totalsets == 2) { // empty
truelight@0: 		spriteset = 0;
truelight@0: 	} else { // something inbetween
truelight@0: 		spriteset = loaded * (totalsets - 2) / 100 + 1;
truelight@0: 		// correct possible rounding errors
truelight@0: 		if (!spriteset)
truelight@0: 			spriteset = 1;
truelight@0: 		else if (spriteset == totalsets - 1)
truelight@0: 			spriteset--;
truelight@0: 	}
truelight@0: 
peter1138@2489: 	r = (in_motion ? rsg->loaded[spriteset]->g.result.result : rsg->loading[spriteset]->g.result.result) + direction;
truelight@0: 	return r;
truelight@0: }
truelight@0: 
hackykid@1883: /**
hackykid@1908:  * Check if a wagon is currently using a wagon override
hackykid@1908:  * @param v The wagon to check
hackykid@1908:  * @return true if it is using an override, false otherwise
hackykid@1908:  */
tron@2548: bool UsesWagonOverride(const Vehicle* v)
tron@2548: {
hackykid@1908: 	assert(v->type == VEH_Train);
tron@2242: 	return GetWagonOverrideSpriteSet(v->engine_type, v->u.rail.first_engine) != NULL;
hackykid@1908: }
hackykid@1908: 
hackykid@1908: /**
hackykid@1883:  * Evaluates a newgrf callback
hackykid@1883:  * @param callback_info info about which callback to evaluate
hackykid@1883:  *  (bit 0-7)  = CallBack id of the callback to use, see CallBackId enum
hackykid@1883:  *  (bit 8-15) = Other info some callbacks need to have, callback specific, see CallBackId enum, not used yet
hackykid@1883:  * @param engine Engine type of the vehicle to evaluate the callback for
hackykid@1883:  * @param vehicle The vehicle to evaluate the callback for, NULL if it doesnt exist (yet)
hackykid@1883:  * @return The value the callback returned, or CALLBACK_FAILED if it failed
hackykid@1883:  */
tron@2477: uint16 GetCallBackResult(uint16 callback_info, EngineID engine, const Vehicle *v)
hackykid@1883: {
tron@2242: 	const SpriteGroup *group;
hackykid@1883: 	byte cargo = GC_DEFAULT;
hackykid@1883: 
hackykid@1883: 	if (v != NULL)
hackykid@1883: 		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];
hackykid@1883: 
peter1138@2488: 	group = engine_custom_sprites[engine][cargo];
hackykid@1904: 
hackykid@1904: 	if (v != NULL && v->type == VEH_Train) {
tron@2242: 		const SpriteGroup *overset = GetWagonOverrideSpriteSet(engine, v->u.rail.first_engine);
hackykid@1904: 
hackykid@1904: 		if (overset != NULL) group = overset;
hackykid@1904: 	}
hackykid@1904: 
hackykid@1883: 	group = ResolveVehicleSpriteGroup(group, v, callback_info, (resolve_callback) ResolveVehicleSpriteGroup);
hackykid@1883: 
peter1138@2488: 	if (group == NULL && cargo != GC_DEFAULT) {
hackykid@1883: 		// This group is empty but perhaps there'll be a default one.
peter1138@2488: 		group = ResolveVehicleSpriteGroup(engine_custom_sprites[engine][GC_DEFAULT], v, callback_info,
hackykid@1883: 		                                (resolve_callback) ResolveVehicleSpriteGroup);
hackykid@1883: 	}
hackykid@1883: 
peter1138@2488: 	if (group == NULL || group->type != SGT_CALLBACK)
hackykid@1883: 		return CALLBACK_FAILED;
hackykid@1883: 
hackykid@1883: 	return group->g.callback.result;
hackykid@1883: }
hackykid@1883: 
hackykid@1883: 
truelight@0: 
tron@445: // Global variables are evil, yes, but we would end up with horribly overblown
tron@445: // calling convention otherwise and this should be 100% reentrant.
tron@445: static byte _vsg_random_triggers;
tron@445: static byte _vsg_bits_to_reseed;
tron@445: 
tron@2242: static const SpriteGroup *TriggerVehicleSpriteGroup(const SpriteGroup *spritegroup,
hackykid@1883: 	Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)
tron@445: {
peter1138@2488: 	if (spritegroup == NULL)
peter1138@2488: 		return NULL;
peter1138@2488: 
tron@1477: 	if (spritegroup->type == SGT_RANDOMIZED) {
tron@1477: 		_vsg_bits_to_reseed |= RandomizedSpriteGroupTriggeredBits(
tron@1477: 			&spritegroup->g.random,
tron@1477: 			_vsg_random_triggers,
tron@1477: 			&veh->waiting_triggers
tron@1477: 		);
tron@1477: 	}
tron@445: 
hackykid@1883: 	return ResolveVehicleSpriteGroup(spritegroup, veh, callback_info, resolve_func);
tron@445: }
tron@445: 
tron@1477: static void DoTriggerVehicle(Vehicle *veh, VehicleTrigger trigger, byte base_random_bits, bool first)
tron@445: {
tron@2242: 	const SpriteGroup *group;
tron@2242: 	const RealSpriteGroup *rsg;
tron@445: 	byte new_random_bits;
tron@445: 
tron@445: 	_vsg_random_triggers = trigger;
tron@445: 	_vsg_bits_to_reseed = 0;
hackykid@1883: 	group = TriggerVehicleSpriteGroup(GetVehicleSpriteGroup(veh->engine_type, veh), veh, 0,
hackykid@1883: 	                                  (resolve_callback) TriggerVehicleSpriteGroup);
hackykid@1883: 
peter1138@2488: 	if (group == NULL && veh->cargo_type != GC_DEFAULT) {
tron@445: 		// This group turned out to be empty but perhaps there'll be a default one.
peter1138@2488: 		group = TriggerVehicleSpriteGroup(engine_custom_sprites[veh->engine_type][GC_DEFAULT], veh, 0,
hackykid@1883: 		                                  (resolve_callback) TriggerVehicleSpriteGroup);
tron@445: 	}
hackykid@1883: 
peter1138@2488: 	if (group == NULL)
peter1138@2488: 		return;
peter1138@2488: 
hackykid@1883: 	assert(group->type == SGT_REAL);
hackykid@1883: 	rsg = &group->g.real;
hackykid@1883: 
truelight@542: 	new_random_bits = Random();
tron@445: 	veh->random_bits &= ~_vsg_bits_to_reseed;
truelight@542: 	veh->random_bits |= (first ? new_random_bits : base_random_bits) & _vsg_bits_to_reseed;
tron@445: 
tron@445: 	switch (trigger) {
tron@445: 		case VEHICLE_TRIGGER_NEW_CARGO:
tron@445: 			/* All vehicles in chain get ANY_NEW_CARGO trigger now.
tron@445: 			 * So we call it for the first one and they will recurse. */
tron@445: 			/* Indexing part of vehicle random bits needs to be
tron@445: 			 * same for all triggered vehicles in the chain (to get
tron@445: 			 * all the random-cargo wagons carry the same cargo,
tron@445: 			 * i.e.), so we give them all the NEW_CARGO triggered
tron@445: 			 * vehicle's portion of random bits. */
tron@445: 			assert(first);
tron@445: 			DoTriggerVehicle(GetFirstVehicleInChain(veh), VEHICLE_TRIGGER_ANY_NEW_CARGO, new_random_bits, false);
tron@445: 			break;
tron@445: 		case VEHICLE_TRIGGER_DEPOT:
tron@445: 			/* We now trigger the next vehicle in chain recursively.
tron@445: 			 * The random bits portions may be different for each
tron@445: 			 * vehicle in chain. */
tron@445: 			if (veh->next != NULL)
tron@445: 				DoTriggerVehicle(veh->next, trigger, 0, true);
tron@445: 			break;
tron@445: 		case VEHICLE_TRIGGER_EMPTY:
tron@445: 			/* We now trigger the next vehicle in chain
tron@445: 			 * recursively.  The random bits portions must be same
tron@445: 			 * for each vehicle in chain, so we give them all
tron@445: 			 * first chained vehicle's portion of random bits. */
tron@445: 			if (veh->next != NULL)
tron@445: 				DoTriggerVehicle(veh->next, trigger, first ? new_random_bits : base_random_bits, false);
tron@445: 			break;
tron@445: 		case VEHICLE_TRIGGER_ANY_NEW_CARGO:
tron@445: 			/* Now pass the trigger recursively to the next vehicle
tron@445: 			 * in chain. */
tron@445: 			assert(!first);
tron@445: 			if (veh->next != NULL)
tron@445: 				DoTriggerVehicle(veh->next, VEHICLE_TRIGGER_ANY_NEW_CARGO, base_random_bits, false);
tron@445: 			break;
tron@445: 	}
tron@445: }
tron@445: 
tron@1477: void TriggerVehicle(Vehicle *veh, VehicleTrigger trigger)
tron@445: {
peter1138@2589: 	if (trigger == VEHICLE_TRIGGER_DEPOT) {
peter1138@2589: 		// store that the vehicle entered a depot this tick
peter1138@2589: 		VehicleEnteredDepotThisTick(veh);
peter1138@2589: 	}
peter1138@2589: 
tron@445: 	DoTriggerVehicle(veh, trigger, 0, true);
tron@445: }
tron@445: 
Darkvater@1474: static char *_engine_custom_names[TOTAL_NUM_ENGINES];
truelight@0: 
tron@2477: void SetCustomEngineName(EngineID engine, const char *name)
truelight@0: {
truelight@0: 	_engine_custom_names[engine] = strdup(name);
truelight@0: }
truelight@0: 
peter1138@2769: void UnloadCustomEngineNames(void)
Darkvater@1474: {
Darkvater@1474: 	char **i;
Darkvater@1474: 	for (i = _engine_custom_names; i != endof(_engine_custom_names); i++) {
Darkvater@1474: 		free(*i);
Darkvater@1474: 		*i = NULL;
Darkvater@1474: 	}
Darkvater@1474: }
Darkvater@1474: 
tron@2477: StringID GetCustomEngineName(EngineID engine)
truelight@0: {
truelight@0: 	if (!_engine_custom_names[engine])
truelight@0: 		return _engine_name_strings[engine];
tron@2201: 	ttd_strlcpy(_userstring, _engine_custom_names[engine], lengthof(_userstring));
truelight@0: 	return STR_SPEC_USERSTRING;
truelight@0: }
truelight@0: 
truelight@0: 
tron@2817: static void AcceptEnginePreview(Engine *e, PlayerID player)
truelight@0: {
celestar@1962: 	Player *p = GetPlayer(player);
truelight@0: 
celestar@2147: 	assert(e->railtype < RAILTYPE_END);
truelight@0: 	SETBIT(e->player_avail, player);
celestar@2147: 	SETBIT(p->avail_railtypes, e->railtype);
truelight@0: 
truelight@0: 	e->preview_player = 0xFF;
truelight@0: 	InvalidateWindowClasses(WC_BUILD_VEHICLE);
bjarni@1096: 	InvalidateWindowClasses(WC_REPLACE_VEHICLE);
truelight@0: }
truelight@0: 
Darkvater@1786: static PlayerID GetBestPlayer(PlayerID pp)
Darkvater@1786: {
Darkvater@1786: 	const Player *p;
Darkvater@1786: 	int32 best_hist;
Darkvater@1786: 	PlayerID best_player;
Darkvater@1786: 	uint mask = 0;
Darkvater@1786: 
Darkvater@1786: 	do {
Darkvater@1786: 		best_hist = -1;
tron@2469: 		best_player = OWNER_SPECTATOR;
Darkvater@1786: 		FOR_ALL_PLAYERS(p) {
Darkvater@1786: 			if (p->is_active && p->block_preview == 0 && !HASBIT(mask, p->index) &&
Darkvater@1786: 					p->old_economy[0].performance_history > best_hist) {
Darkvater@1786: 				best_hist = p->old_economy[0].performance_history;
Darkvater@1786: 				best_player = p->index;
Darkvater@1786: 			}
Darkvater@1786: 		}
Darkvater@1786: 
tron@2469: 		if (best_player == OWNER_SPECTATOR) return OWNER_SPECTATOR;
Darkvater@1786: 
Darkvater@1786: 		SETBIT(mask, best_player);
Darkvater@1786: 	} while (--pp != 0);
Darkvater@1786: 
Darkvater@1786: 	return best_player;
Darkvater@1786: }
Darkvater@1786: 
tron@1093: void EnginesDailyLoop(void)
truelight@0: {
tron@2477: 	EngineID i;
truelight@0: 
Darkvater@1786: 	if (_cur_year >= 130) return;
truelight@0: 
tron@2242: 	for (i = 0; i != lengthof(_engines); i++) {
tron@2242: 		Engine* e = &_engines[i];
tron@2242: 
truelight@0: 		if (e->flags & ENGINE_INTRODUCING) {
truelight@0: 			if (e->flags & ENGINE_PREVIEWING) {
truelight@740: 				if (e->preview_player != 0xFF && !--e->preview_wait) {
truelight@0: 					e->flags &= ~ENGINE_PREVIEWING;
truelight@0: 					DeleteWindowById(WC_ENGINE_PREVIEW, i);
truelight@0: 					e->preview_player++;
truelight@193: 				}
Darkvater@1786:  			} else if (e->preview_player != 0xFF) {
Darkvater@1786: 				PlayerID best_player = GetBestPlayer(e->preview_player);
Darkvater@1786: 
tron@2469: 				if (best_player == OWNER_SPECTATOR) {
Darkvater@1786: 					e->preview_player = 0xFF;
Darkvater@1786: 					continue;
Darkvater@1786: 				}
truelight@193: 
truelight@0: 				if (!IS_HUMAN_PLAYER(best_player)) {
Darkvater@1786: 					/* XXX - TTDBUG: TTD has a bug here ???? */
truelight@0: 					AcceptEnginePreview(e, best_player);
truelight@0: 				} else {
truelight@0: 					e->flags |= ENGINE_PREVIEWING;
truelight@0: 					e->preview_wait = 20;
tron@2639: 					if (IS_INTERACTIVE_PLAYER(best_player)) ShowEnginePreviewWindow(i);
truelight@0: 				}
truelight@0: 			}
truelight@0: 		}
truelight@0: 	}
truelight@0: }
truelight@0: 
Darkvater@1786: /** Accept an engine prototype. XXX - it is possible that the top-player
Darkvater@1786:  * changes while you are waiting to accept the offer? Then it becomes invalid
Darkvater@1786:  * @param x,y unused
Darkvater@1786:  * @param p1 engine-prototype offered
Darkvater@1786:  * @param p2 unused
Darkvater@1786:  */
truelight@0: int32 CmdWantEnginePreview(int x, int y, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
Darkvater@1786: 	Engine *e;
Darkvater@1786: 	if (!IsEngineIndex(p1)) return CMD_ERROR;
Darkvater@1786: 
tron@1926: 	e = GetEngine(p1);
Darkvater@1786: 	if (GetBestPlayer(e->preview_player) != _current_player) return CMD_ERROR;
Darkvater@1786: 
Darkvater@1786: 	if (flags & DC_EXEC)
Darkvater@1786: 		AcceptEnginePreview(e, _current_player);
Darkvater@1786: 
truelight@0: 	return 0;
truelight@0: }
truelight@0: 
dominik@257: // Determine if an engine type is a wagon (and not a loco)
tron@2477: static bool IsWagon(EngineID index)
dominik@257: {
tron@964: 	return index < NUM_TRAIN_ENGINES && RailVehInfo(index)->flags & RVI_WAGON;
dominik@257: }
dominik@257: 
tron@410: static void NewVehicleAvailable(Engine *e)
truelight@0: {
truelight@0: 	Vehicle *v;
truelight@0: 	Player *p;
tron@2477: 	EngineID index = e - _engines;
truelight@0: 
truelight@0: 	// In case the player didn't build the vehicle during the intro period,
truelight@0: 	// prevent that player from getting future intro periods for a while.
tron@2639: 	if (e->flags & ENGINE_INTRODUCING) {
truelight@0: 		FOR_ALL_PLAYERS(p) {
truelight@919: 			uint block_preview = p->block_preview;
truelight@919: 
tron@2639: 			if (!HASBIT(e->player_avail, p->index)) continue;
truelight@193: 
truelight@919: 			/* We assume the user did NOT build it.. prove me wrong ;) */
truelight@919: 			p->block_preview = 20;
truelight@919: 
truelight@919: 			FOR_ALL_VEHICLES(v) {
truelight@0: 				if (v->type == VEH_Train || v->type == VEH_Road || v->type == VEH_Ship ||
truelight@0: 						(v->type == VEH_Aircraft && v->subtype <= 2)) {
truelight@919: 					if (v->owner == p->index && v->engine_type == index) {
truelight@919: 						/* The user did prove me wrong, so restore old value */
truelight@919: 						p->block_preview = block_preview;
truelight@919: 						break;
truelight@919: 					}
truelight@0: 				}
truelight@0: 			}
truelight@0: 		}
truelight@0: 	}
truelight@0: 
dominik@114: 	e->flags = (e->flags & ~ENGINE_INTRODUCING) | ENGINE_AVAILABLE;
dominik@114: 	InvalidateWindowClasses(WC_BUILD_VEHICLE);
bjarni@1096: 	InvalidateWindowClasses(WC_REPLACE_VEHICLE);
dominik@114: 
truelight@0: 	// Now available for all players
truelight@0: 	e->player_avail = (byte)-1;
dominik@114: 
dominik@114: 	// Do not introduce new rail wagons
tron@2639: 	if (IsWagon(index)) return;
dominik@114: 
dominik@114: 	// make maglev / monorail available
truelight@0: 	FOR_ALL_PLAYERS(p) {
celestar@2147: 		if (p->is_active) {
celestar@2147: 			assert(e->railtype < RAILTYPE_END);
celestar@2147: 			SETBIT(p->avail_railtypes, e->railtype);
celestar@2147: 		}
truelight@0: 	}
truelight@0: 
tron@2477: 	if (index < NUM_TRAIN_ENGINES) {
truelight@0: 		AddNewsItem(index, NEWS_FLAGS(NM_CALLBACK, 0, NT_NEW_VEHICLES, DNC_TRAINAVAIL), 0, 0);
tron@2477: 	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES) {
truelight@0: 		AddNewsItem(index, NEWS_FLAGS(NM_CALLBACK, 0, NT_NEW_VEHICLES, DNC_ROADAVAIL), 0, 0);
tron@2477: 	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES + NUM_SHIP_ENGINES) {
truelight@0: 		AddNewsItem(index, NEWS_FLAGS(NM_CALLBACK, 0, NT_NEW_VEHICLES, DNC_SHIPAVAIL), 0, 0);
truelight@0: 	} else {
truelight@0: 		AddNewsItem(index, NEWS_FLAGS(NM_CALLBACK, 0, NT_NEW_VEHICLES, DNC_AIRCRAFTAVAIL), 0, 0);
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@1093: void EnginesMonthlyLoop(void)
truelight@0: {
truelight@0: 	Engine *e;
truelight@0: 
truelight@0: 	if (_cur_year < 130) {
tron@2242: 		for (e = _engines; e != endof(_engines); e++) {
truelight@0: 			// Age the vehicle
tron@2242: 			if (e->flags & ENGINE_AVAILABLE && e->age != 0xFFFF) {
truelight@0: 				e->age++;
truelight@0: 				CalcEngineReliability(e);
truelight@0: 			}
truelight@0: 
Darkvater@9922: 			if (!(e->flags & ENGINE_AVAILABLE) && _date >= (e->intro_date + 365)) {
truelight@0: 				// Introduce it to all players
truelight@0: 				NewVehicleAvailable(e);
truelight@0: 			} else if (!(e->flags & (ENGINE_AVAILABLE|ENGINE_INTRODUCING)) && _date >= e->intro_date) {
truelight@0: 				// Introduction date has passed.. show introducing dialog to one player.
truelight@0: 				e->flags |= ENGINE_INTRODUCING;
dominik@257: 
dominik@257: 				// Do not introduce new rail wagons
tron@964: 				if (!IsWagon(e - _engines))
dominik@257: 					e->preview_player = 1; // Give to the player with the highest rating.
truelight@0: 			}
truelight@0: 		}
truelight@0: 	}
truelight@0: 	AdjustAvailAircraft();
truelight@0: }
truelight@0: 
Darkvater@1786: /** Rename an engine.
Darkvater@1786:  * @param x,y unused
Darkvater@1786:  * @param p1 engine ID to rename
Darkvater@1786:  * @param p2 unused
Darkvater@1786:  */
truelight@0: int32 CmdRenameEngine(int x, int y, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
truelight@0: 	StringID str;
truelight@0: 
Darkvater@1840: 	if (!IsEngineIndex(p1) || _cmd_text[0] == '\0') return CMD_ERROR;
Darkvater@1786: 
tron@1820: 	str = AllocateNameUnique(_cmd_text, 0);
Darkvater@1786: 	if (str == 0) return CMD_ERROR;
truelight@193: 
truelight@0: 	if (flags & DC_EXEC) {
truelight@0: 		StringID old_str = _engine_name_strings[p1];
truelight@0: 		_engine_name_strings[p1] = str;
truelight@0: 		DeleteName(old_str);
truelight@0: 		_vehicle_design_names |= 3;
truelight@0: 		MarkWholeScreenDirty();
truelight@0: 	} else {
truelight@0: 		DeleteName(str);
truelight@0: 	}
truelight@0: 
truelight@0: 	return 0;
truelight@0: }
truelight@0: 
truelight@0: 
peter1138@2848: /*
peter1138@2848:  * returns true if an engine is valid, of the specified type, and buildable by
peter1138@2848:  * the current player, false otherwise
peter1138@2848:  *
peter1138@2848:  * engine = index of the engine to check
peter1138@2848:  * type   = the type the engine should be of (VEH_xxx)
peter1138@2848:  */
peter1138@2848: bool IsEngineBuildable(uint engine, byte type)
peter1138@2848: {
peter1138@2848: 	const Engine *e;
peter1138@2848: 
peter1138@2848: 	// check if it's an engine that is in the engine array
peter1138@2848: 	if (!IsEngineIndex(engine)) return false;
peter1138@2848: 
peter1138@2848: 	e = GetEngine(engine);
peter1138@2848: 
peter1138@2848: 	// check if it's an engine of specified type
peter1138@2848: 	if (e->type != type) return false;
peter1138@2848: 
peter1138@2848: 	// check if it's available
peter1138@2848: 	if (!HASBIT(e->player_avail, _current_player)) return false;
peter1138@2848: 
peter1138@2848: 	return true;
peter1138@2848: }
peter1138@2848: 
peter1138@2848: /************************************************************************
peter1138@2848:  * Engine Replacement stuff
peter1138@2848:  ************************************************************************/
peter1138@2848: 
peter1138@2848: static void EngineRenewPoolNewBlock(uint start_item); /* Forward declare for initializer of _engine_renew_pool */
peter1138@2848: enum {
peter1138@2848: 	ENGINE_RENEW_POOL_BLOCK_SIZE_BITS = 3,
peter1138@2848: 	ENGINE_RENEW_POOL_MAX_BLOCKS      = 8000,
peter1138@2848: };
peter1138@2848: 
peter1138@2848: MemoryPool _engine_renew_pool = { "EngineRe", ENGINE_RENEW_POOL_MAX_BLOCKS, ENGINE_RENEW_POOL_BLOCK_SIZE_BITS, sizeof(EngineRenew), &EngineRenewPoolNewBlock, 0, 0, NULL };
peter1138@2848: 
peter1138@2848: static inline uint16 GetEngineRenewPoolSize(void)
peter1138@2848: {
peter1138@2848: 	return _engine_renew_pool.total_items;
peter1138@2848: }
peter1138@2848: 
peter1138@2848: #define FOR_ALL_ENGINE_RENEWS_FROM(er, start) for (er = GetEngineRenew(start); er != NULL; er = (er->index + 1 < GetEngineRenewPoolSize()) ? GetEngineRenew(er->index + 1) : NULL)
peter1138@2848: #define FOR_ALL_ENGINE_RENEWS(er) FOR_ALL_ENGINE_RENEWS_FROM(er, 0)
peter1138@2848: 
peter1138@2848: static void EngineRenewPoolNewBlock(uint start_item)
peter1138@2848: {
peter1138@2848: 	EngineRenew *er;
peter1138@2848: 
peter1138@2848: 	FOR_ALL_ENGINE_RENEWS_FROM(er, start_item) {
peter1138@2848: 		er->index = start_item++;
peter1138@2848: 		er->from = INVALID_ENGINE;
peter1138@2848: 	}
peter1138@2848: }
peter1138@2848: 
peter1138@2848: 
peter1138@2848: static EngineRenew *AllocateEngineRenew(void)
peter1138@2848: {
peter1138@2848: 	EngineRenew *er;
peter1138@2848: 
peter1138@2848: 	FOR_ALL_ENGINE_RENEWS(er) {
peter1138@2848: 		if (er->from == INVALID_ENGINE) {
peter1138@2848: 			er->to = INVALID_ENGINE;
peter1138@2848: 			er->next = NULL;
peter1138@2848: 			return er;
peter1138@2848: 		}
peter1138@2848: 	}
peter1138@2848: 
peter1138@2848: 	/* Check if we can add a block to the pool */
peter1138@2848: 	if (AddBlockToPool(&_engine_renew_pool)) return AllocateEngineRenew();
peter1138@2848: 
peter1138@2848: 	return NULL;
peter1138@2848: }
peter1138@2848: 
peter1138@2848: /**
peter1138@2848:  * Retrieves the EngineRenew that specifies the replacement of the given
peter1138@2848:  * engine type from the given renewlist */
peter1138@2848: static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine)
peter1138@2848: {
peter1138@2848: 	EngineRenew* er = (EngineRenew*)erl; /* Fetch first element */
peter1138@2848: 	while (er) {
peter1138@2848: 		if (er->from == engine) return er;
peter1138@2848: 		er = er->next;
peter1138@2848: 	}
peter1138@2848: 	return NULL;
peter1138@2848: }
peter1138@2848: 
peter1138@2848: void RemoveAllEngineReplacement(EngineRenewList* erl)
peter1138@2848: {
peter1138@2848: 	EngineRenew* er = (EngineRenew*)(*erl); /* Fetch first element */
peter1138@2848: 	while (er) {
peter1138@2848: 		er->from = INVALID_ENGINE; /* "Deallocate" all elements */
peter1138@2848: 		er = er->next;
peter1138@2848: 	}
peter1138@2848: 	*erl = NULL; /* Empty list */
peter1138@2848: }
peter1138@2848: 
peter1138@2848: EngineID EngineReplacement(EngineRenewList erl, EngineID engine)
peter1138@2848: {
peter1138@2848: 	const EngineRenew *er = GetEngineReplacement(erl, engine);
peter1138@2848: 	return er == NULL ? INVALID_ENGINE : er->to;
peter1138@2848: }
peter1138@2848: 
peter1138@2848: int32 AddEngineReplacement(EngineRenewList* erl, EngineID old_engine, EngineID new_engine, uint32 flags)
peter1138@2848: {
peter1138@2848: 	EngineRenew *er;
peter1138@2848: 
peter1138@2848: 	// Check if the old vehicle is already in the list
peter1138@2848: 	er = GetEngineReplacement(*erl, old_engine);
peter1138@2848: 	if (er != NULL) {
peter1138@2848: 		if (flags & DC_EXEC) er->to = new_engine;
peter1138@2848: 		return 0;
peter1138@2848: 	}
peter1138@2848: 
peter1138@2848: 	er = AllocateEngineRenew();
peter1138@2848: 	if (er == NULL) return CMD_ERROR;
peter1138@2848: 
peter1138@2848: 	if (flags & DC_EXEC) {
peter1138@2848: 		er->from = old_engine;
peter1138@2848: 		er->to = new_engine;
peter1138@2848: 		er->next = (EngineRenew*)(*erl); /* Resolve the first element in the list */
peter1138@2848: 
peter1138@2848: 		*erl = (EngineRenewList)er; /* Insert before the first element */
peter1138@2848: 	}
peter1138@2848: 
peter1138@2848: 	return 0;
peter1138@2848: }
peter1138@2848: 
peter1138@2848: int32 RemoveEngineReplacement(EngineRenewList* erl, EngineID engine, uint32 flags)
peter1138@2848: {
peter1138@2848: 	EngineRenew* er = (EngineRenew*)(*erl); /* Start at the first element */
peter1138@2848: 	EngineRenew* prev = NULL;
peter1138@2848: 
peter1138@2848: 	while (er)
peter1138@2848: 	{
peter1138@2848: 		if (er->from == engine) {
peter1138@2848: 			if (flags & DC_EXEC) {
peter1138@2848: 				if (prev == NULL) { /* First element */
peter1138@2848: 					(*erl) = (EngineRenewList)er->next; /* The second becomes the new first element */
peter1138@2848: 				} else {
peter1138@2848: 					prev->next = er->next; /* Cut this element out */
peter1138@2848: 				}
peter1138@2848: 				er->from = INVALID_ENGINE; /* Deallocate */
peter1138@2848: 			}
peter1138@2848: 			return 0;
peter1138@2848: 		}
peter1138@2848: 		prev = er;
peter1138@2848: 		er = er->next; /* Look at next element */
peter1138@2848: 	}
peter1138@2848: 
peter1138@2848: 	return CMD_ERROR; /* Not found? */
peter1138@2848: }
peter1138@2848: 
peter1138@2848: static const SaveLoad _engine_renew_desc[] = {
peter1138@2848: 	SLE_VAR(EngineRenew, from, SLE_UINT16),
peter1138@2848: 	SLE_VAR(EngineRenew, to,   SLE_UINT16),
peter1138@2848: 
peter1138@2848: 	SLE_REF(EngineRenew, next, REF_ENGINE_RENEWS),
peter1138@2848: 
peter1138@2848: 	SLE_END()
peter1138@2848: };
peter1138@2848: 
peter1138@2848: static void Save_ERNW(void)
peter1138@2848: {
peter1138@2848: 	EngineRenew *er;
peter1138@2848: 
peter1138@2848: 	FOR_ALL_ENGINE_RENEWS(er) {
peter1138@2848: 		if (er->from != INVALID_ENGINE) {
peter1138@2848: 			SlSetArrayIndex(er->index);
peter1138@2848: 			SlObject(er, _engine_renew_desc);
peter1138@2848: 		}
peter1138@2848: 	}
peter1138@2848: }
peter1138@2848: 
peter1138@2848: static void Load_ERNW(void)
peter1138@2848: {
peter1138@2848: 	int index;
peter1138@2848: 
peter1138@2848: 	while ((index = SlIterateArray()) != -1) {
peter1138@2848: 		EngineRenew *er;
peter1138@2848: 
peter1138@2848: 		if (!AddBlockIfNeeded(&_engine_renew_pool, index))
peter1138@2848: 			error("EngineRenews: failed loading savegame: too many EngineRenews");
peter1138@2848: 
peter1138@2848: 		er = GetEngineRenew(index);
peter1138@2848: 		SlObject(er, _engine_renew_desc);
peter1138@2848: 	}
peter1138@2848: }
peter1138@2848: 
Darkvater@1881: static const SaveLoad _engine_desc[] = {
truelight@0: 	SLE_VAR(Engine,intro_date,						SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,age,										SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,reliability,						SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,reliability_spd_dec,		SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,reliability_start,			SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,reliability_max,				SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,reliability_final,			SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,duration_phase_1,			SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,duration_phase_2,			SLE_UINT16),
truelight@0: 	SLE_VAR(Engine,duration_phase_3,			SLE_UINT16),
truelight@0: 
truelight@0: 	SLE_VAR(Engine,lifelength,						SLE_UINT8),
truelight@0: 	SLE_VAR(Engine,flags,									SLE_UINT8),
truelight@0: 	SLE_VAR(Engine,preview_player,				SLE_UINT8),
truelight@0: 	SLE_VAR(Engine,preview_wait,					SLE_UINT8),
truelight@0: 	SLE_VAR(Engine,railtype,							SLE_UINT8),
truelight@0: 	SLE_VAR(Engine,player_avail,					SLE_UINT8),
truelight@0: 
truelight@0: 	// reserve extra space in savegame here. (currently 16 bytes)
truelight@0: 	SLE_CONDARR(NullStruct,null,SLE_FILE_U64 | SLE_VAR_NULL, 2, 2, 255),
truelight@0: 
truelight@0: 	SLE_END()
truelight@0: };
truelight@0: 
tron@1093: static void Save_ENGN(void)
truelight@0: {
tron@2242: 	uint i;
tron@2242: 
tron@2242: 	for (i = 0; i != lengthof(_engines); i++) {
truelight@0: 		SlSetArrayIndex(i);
tron@2242: 		SlObject(&_engines[i], _engine_desc);
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@1093: static void Load_ENGN(void)
truelight@0: {
truelight@0: 	int index;
truelight@0: 	while ((index = SlIterateArray()) != -1) {
tron@1926: 		SlObject(GetEngine(index), _engine_desc);
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@1093: static void LoadSave_ENGS(void)
truelight@0: {
truelight@0: 	SlArray(_engine_name_strings, lengthof(_engine_name_strings), SLE_STRINGID);
truelight@0: }
truelight@0: 
truelight@0: const ChunkHandler _engine_chunk_handlers[] = {
peter1138@2848: 	{ 'ENGN', Save_ENGN,     Load_ENGN,     CH_ARRAY          },
peter1138@2848: 	{ 'ENGS', LoadSave_ENGS, LoadSave_ENGS, CH_RIFF           },
peter1138@2848: 	{ 'ERNW', Save_ERNW,     Load_ERNW,     CH_ARRAY | CH_LAST},
truelight@0: };
truelight@0: 
peter1138@2848: void InitializeEngines(void)
tron@1197: {
peter1138@2848: 	/* Clean the engine renew pool and create 1 block in it */
peter1138@2848: 	CleanPool(&_engine_renew_pool);
peter1138@2848: 	AddBlockToPool(&_engine_renew_pool);
bjarni@1196: }