tron@2186: /* $Id$ */ tron@2186: rubidium@10429: /** @file engine.cpp Base for all engine handling. */ belugas@6451: truelight@0: #include "stdafx.h" Darkvater@1891: #include "openttd.h" tron@1299: #include "debug.h" rubidium@8750: #include "player_base.h" rubidium@8750: #include "player_func.h" rubidium@8612: #include "command_func.h" rubidium@9259: #include "news_func.h" truelight@0: #include "saveload.h" tron@2159: #include "variables.h" peter1138@2708: #include "train.h" Darkvater@6105: #include "aircraft.h" belugas@3866: #include "newgrf_cargo.h" peter1138@10382: #include "newgrf_engine.h" rubidium@7139: #include "group.h" rubidium@8610: #include "strings_func.h" rubidium@8721: #include "gfx_func.h" rubidium@8627: #include "functions.h" rubidium@8627: #include "window_func.h" rubidium@8636: #include "date_func.h" rubidium@8708: #include "autoreplace_base.h" rubidium@8708: #include "autoreplace_gui.h" rubidium@8710: #include "string_func.h" rubidium@8766: #include "settings_type.h" smatz@9343: #include "oldpool_func.h" peter1138@10382: #include "core/alloc_func.hpp" smatz@10533: #include "vehicle_func.h" peter1138@10781: #include truelight@0: rubidium@8760: #include "table/strings.h" rubidium@8760: #include "table/engines.h" rubidium@8760: peter1138@10382: DEFINE_OLD_POOL_GENERIC(Engine, Engine) tron@2763: truelight@0: enum { truelight@4300: YEAR_ENGINE_AGING_STOPS = 2050, truelight@4300: }; truelight@4300: truelight@0: peter1138@10382: /** Number of engines of each vehicle type in original engine data */ peter1138@10382: const uint8 _engine_counts[4] = { peter1138@10382: lengthof(_orig_rail_vehicle_info), peter1138@10382: lengthof(_orig_road_vehicle_info), peter1138@10382: lengthof(_orig_ship_vehicle_info), peter1138@10382: lengthof(_orig_aircraft_vehicle_info), peter1138@10382: }; peter1138@10382: peter1138@10382: /** Offset of the first engine of each vehicle type in original engine data */ peter1138@10382: const uint8 _engine_offsets[4] = { peter1138@10382: 0, peter1138@10382: lengthof(_orig_rail_vehicle_info), peter1138@10382: lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info), peter1138@10382: lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info) + lengthof(_orig_ship_vehicle_info), peter1138@10382: }; peter1138@10382: peter1138@10382: Engine::Engine() : peter1138@10382: name(NULL), peter1138@10382: overrides_count(0), peter1138@10382: overrides(NULL) peter1138@10382: { peter1138@10382: } peter1138@10382: peter1138@10382: Engine::Engine(VehicleType type, EngineID base) peter1138@10382: { peter1138@10382: this->type = type; peter1138@10382: this->internal_id = base; peter1138@10382: this->list_position = base; peter1138@10382: peter1138@10382: /* Check if this base engine is within the original engine data range */ peter1138@10382: if (base >= _engine_counts[type]) { peter1138@10382: /* Mark engine as valid anyway */ peter1138@10382: this->info.climates = 0x80; peter1138@10382: return; peter1138@10382: } peter1138@10382: peter1138@10382: /* Copy the original engine info for this slot */ peter1138@10382: this->info = _orig_engine_info[_engine_offsets[type] + base]; peter1138@10382: peter1138@10382: /* Copy the original engine data for this slot */ peter1138@10382: switch (type) { peter1138@10382: default: NOT_REACHED(); peter1138@10382: peter1138@10382: case VEH_TRAIN: peter1138@10382: this->u.rail = _orig_rail_vehicle_info[base]; peter1138@10382: this->image_index = this->u.rail.image_index; peter1138@10382: this->info.string_id = STR_8000_KIRBY_PAUL_TANK_STEAM + base; peter1138@10382: break; peter1138@10382: peter1138@10382: case VEH_ROAD: peter1138@10382: this->u.road = _orig_road_vehicle_info[base]; peter1138@10382: this->image_index = this->u.road.image_index; peter1138@10382: this->info.string_id = STR_8074_MPS_REGAL_BUS + base; peter1138@10382: break; peter1138@10382: peter1138@10382: case VEH_SHIP: peter1138@10382: this->u.ship = _orig_ship_vehicle_info[base]; peter1138@10382: this->image_index = this->u.ship.image_index; peter1138@10382: this->info.string_id = STR_80CC_MPS_OIL_TANKER + base; peter1138@10382: break; peter1138@10382: peter1138@10382: case VEH_AIRCRAFT: peter1138@10382: this->u.air = _orig_aircraft_vehicle_info[base]; peter1138@10382: this->image_index = this->u.air.image_index; peter1138@10382: this->info.string_id = STR_80D7_SAMPSON_U52 + base; peter1138@10382: break; peter1138@10382: } peter1138@10382: } peter1138@10382: peter1138@10382: Engine::~Engine() peter1138@10382: { peter1138@10382: UnloadWagonOverrides(this); peter1138@10382: free(this->name); peter1138@10382: } peter1138@10382: smatz@10542: /** Sets cached values in Player::num_vehicles and Group::num_vehicles smatz@10542: */ smatz@10533: void SetCachedEngineCounts() smatz@10533: { smatz@10533: uint engines = GetEnginePoolSize(); smatz@10533: smatz@10533: /* Set up the engine count for all players */ smatz@10533: Player *p; smatz@10533: FOR_ALL_PLAYERS(p) { smatz@10533: free(p->num_engines); smatz@10533: p->num_engines = CallocT(engines); smatz@10533: } smatz@10533: smatz@10533: /* Recalculate */ smatz@10533: Group *g; smatz@10533: FOR_ALL_GROUPS(g) { smatz@10533: free(g->num_engines); smatz@10533: g->num_engines = CallocT(engines); smatz@10533: } smatz@10533: smatz@10533: const Vehicle *v; smatz@10533: FOR_ALL_VEHICLES(v) { smatz@10533: if (!IsEngineCountable(v)) continue; smatz@10533: smatz@10533: assert(v->engine_type < engines); smatz@10533: smatz@10533: GetPlayer(v->owner)->num_engines[v->engine_type]++; smatz@10533: smatz@10533: if (v->group_id == DEFAULT_GROUP) continue; smatz@10533: smatz@10533: g = GetGroup(v->group_id); smatz@10533: assert(v->type == g->vehicle_type); smatz@10533: assert(v->owner == g->owner); smatz@10533: smatz@10533: g->num_engines[v->engine_type]++; smatz@10533: } smatz@10533: } smatz@10533: peter1138@8717: void SetupEngines() peter1138@8717: { peter1138@10382: _Engine_pool.CleanPool(); peter1138@10382: _Engine_pool.AddBlockToPool(); peter1138@8717: peter1138@10382: for (uint i = 0; i < lengthof(_orig_rail_vehicle_info); i++) new Engine(VEH_TRAIN, i); peter1138@10382: for (uint i = 0; i < lengthof(_orig_road_vehicle_info); i++) new Engine(VEH_ROAD, i); peter1138@10382: for (uint i = 0; i < lengthof(_orig_ship_vehicle_info); i++) new Engine(VEH_SHIP, i); peter1138@10382: for (uint i = 0; i < lengthof(_orig_aircraft_vehicle_info); i++) new Engine(VEH_AIRCRAFT, i); peter1138@8717: } peter1138@8717: peter1138@8717: tron@2477: void ShowEnginePreviewWindow(EngineID engine); truelight@0: rubidium@6573: void DeleteCustomEngineNames() truelight@0: { peter1138@8754: Engine *e; peter1138@8754: FOR_ALL_ENGINES(e) { peter1138@8754: free(e->name); peter1138@8754: e->name = NULL; truelight@0: } truelight@0: truelight@0: _vehicle_design_names &= ~1; truelight@0: } truelight@0: rubidium@6573: void LoadCustomEngineNames() truelight@0: { rubidium@4432: /* XXX: not done */ Darkvater@5568: DEBUG(misc, 1, "LoadCustomEngineNames: not done"); truelight@0: } truelight@0: peter1138@10837: /* Determine if an engine type is a wagon (and not a loco) */ peter1138@10837: static bool IsWagon(EngineID index) peter1138@10837: { peter1138@10837: const Engine *e = GetEngine(index); peter1138@10837: return e->type == VEH_TRAIN && e->u.rail.railveh_type == RAILVEH_WAGON; peter1138@10837: } peter1138@10837: truelight@0: static void CalcEngineReliability(Engine *e) truelight@0: { truelight@0: uint age = e->age; truelight@0: peter1138@7102: /* Check for early retirement */ rubidium@10775: if (e->player_avail != 0 && !_settings_game.vehicle.never_expire_vehicles) { peter1138@10382: int retire_early = e->info.retire_early; frosch@9005: uint retire_early_max_age = max(0, e->duration_phase_1 + e->duration_phase_2 - retire_early * 12); frosch@9005: if (retire_early != 0 && age >= retire_early_max_age) { peter1138@7102: /* Early retirement is enabled and we're past the date... */ peter1138@7102: e->player_avail = 0; peter1138@7102: AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type); peter1138@7102: } peter1138@7102: } peter1138@7102: 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; rubidium@10775: } else if ((age -= e->duration_phase_1) < e->duration_phase_2 || _settings_game.vehicle.never_expire_vehicles) { bjarni@4767: /* We are at the peak of this engines life. It will have max reliability. bjarni@4767: * This is also true if the engines never expire. They will not go bad over time */ 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 { bjarni@4767: /* time's up for this engine. bjarni@4767: * We will now completely retire this design */ bjarni@4767: e->player_avail = 0; truelight@0: e->reliability = e->reliability_final; bjarni@6195: /* Kick this engine out of the lists */ bjarni@6195: AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type); truelight@0: } bjarni@4767: InvalidateWindowClasses(WC_BUILD_VEHICLE); // Update to show the new reliability bjarni@6195: InvalidateWindowClasses(WC_REPLACE_VEHICLE); truelight@0: } truelight@0: rubidium@6573: void StartupEngines() truelight@0: { truelight@0: Engine *e; truelight@4300: /* Aging of vehicles stops, so account for that when starting late */ rubidium@4322: const Date aging_date = min(_date, ConvertYMDToDate(YEAR_ENGINE_AGING_STOPS, 0, 1)); truelight@0: peter1138@10382: FOR_ALL_ENGINES(e) { peter1138@10382: const EngineInfo *ei = &e->info; tron@2242: uint32 r; truelight@0: truelight@0: e->age = 0; truelight@0: e->flags = 0; truelight@0: e->player_avail = 0; truelight@193: belugas@6451: /* The magic value of 729 days below comes from the NewGRF spec. If the belugas@6451: * base intro date is before 1922 then the random number of days is not belugas@6451: * added. */ truelight@0: r = Random(); rubidium@4297: e->intro_date = ei->base_intro <= ConvertYMDToDate(1922, 0, 1) ? ei->base_intro : (Date)GB(r, 0, 9) + ei->base_intro; truelight@0: if (e->intro_date <= _date) { truelight@4300: e->age = (aging_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: peter1138@10837: e->reliability_spd_dec = ei->decay_speed << 2; truelight@0: peter1138@10837: if (IsWagon(e->index)) { truelight@0: e->age = 0xFFFF; truelight@0: } else { truelight@0: CalcEngineReliability(e); truelight@0: } truelight@0: rubidium@10775: e->lifelength = ei->lifelength + _settings_game.vehicle.extend_vehicle_life; truelight@0: belugas@6451: /* prevent certain engines from ever appearing. */ rubidium@10775: if (!HasBit(ei->climates, _settings_game.game_creation.landscape)) { truelight@0: e->flags |= ENGINE_AVAILABLE; truelight@0: e->player_avail = 0; truelight@0: } truelight@0: } truelight@0: } truelight@0: tron@6074: static void AcceptEnginePreview(EngineID eid, PlayerID player) truelight@0: { tron@6074: Engine *e = GetEngine(eid); rubidium@7181: Player *p = GetPlayer(player); truelight@0: skidd13@8427: SetBit(e->player_avail, player); rubidium@6585: if (e->type == VEH_TRAIN) { tron@6074: const RailVehicleInfo *rvi = RailVehInfo(eid); tron@6074: tron@6074: assert(rvi->railtype < RAILTYPE_END); skidd13@8427: SetBit(p->avail_railtypes, rvi->railtype); rubidium@7181: } else if (e->type == VEH_ROAD) { skidd13@8427: SetBit(p->avail_roadtypes, HasBit(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD); tron@6074: } truelight@0: peter1138@9061: e->preview_player_rank = 0xFF; bjarni@4766: if (player == _local_player) { bjarni@6195: AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type); bjarni@4766: } truelight@0: } truelight@0: peter1138@9061: static PlayerID GetBestPlayer(uint8 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: smatz@9068: do { Darkvater@1786: best_hist = -1; Darkvater@4848: best_player = PLAYER_SPECTATOR; Darkvater@1786: FOR_ALL_PLAYERS(p) { skidd13@8424: 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: Darkvater@4848: if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR; Darkvater@1786: skidd13@8427: SetBit(mask, best_player); smatz@9129: } while (--pp != 0); Darkvater@1786: Darkvater@1786: return best_player; Darkvater@1786: } Darkvater@1786: rubidium@6573: void EnginesDailyLoop() truelight@0: { truelight@4300: if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return; truelight@0: peter1138@10382: Engine *e; peter1138@10382: FOR_ALL_ENGINES(e) { peter1138@10382: EngineID i = e->index; maedhros@6500: if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) { maedhros@6500: if (e->flags & ENGINE_OFFER_WINDOW_OPEN) { peter1138@9061: if (e->preview_player_rank != 0xFF && !--e->preview_wait) { maedhros@6500: e->flags &= ~ENGINE_OFFER_WINDOW_OPEN; truelight@0: DeleteWindowById(WC_ENGINE_PREVIEW, i); peter1138@9061: e->preview_player_rank++; truelight@193: } peter1138@9061: } else if (e->preview_player_rank != 0xFF) { peter1138@9061: PlayerID best_player = GetBestPlayer(e->preview_player_rank); Darkvater@1786: Darkvater@4848: if (best_player == PLAYER_SPECTATOR) { peter1138@9061: e->preview_player_rank = 0xFF; Darkvater@1786: continue; Darkvater@1786: } truelight@193: Darkvater@4845: if (!IsHumanPlayer(best_player)) { Darkvater@1786: /* XXX - TTDBUG: TTD has a bug here ???? */ tron@6074: AcceptEnginePreview(i, best_player); truelight@0: } else { maedhros@6500: e->flags |= ENGINE_OFFER_WINDOW_OPEN; truelight@0: e->preview_wait = 20; Darkvater@4845: if (IsInteractivePlayer(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 tron@3491: * @param tile unused belugas@6977: * @param flags operation to perfom Darkvater@1786: * @param p1 engine-prototype offered Darkvater@1786: * @param p2 unused Darkvater@1786: */ rubidium@7439: CommandCost CmdWantEnginePreview(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) truelight@0: { Darkvater@1786: Engine *e; tron@2951: Darkvater@1786: if (!IsEngineIndex(p1)) return CMD_ERROR; tron@1926: e = GetEngine(p1); peter1138@9061: if (GetBestPlayer(e->preview_player_rank) != _current_player) return CMD_ERROR; Darkvater@1786: tron@6074: if (flags & DC_EXEC) AcceptEnginePreview(p1, _current_player); Darkvater@1786: rubidium@7446: return CommandCost(); truelight@0: } truelight@0: rubidium@10521: StringID GetEngineCategoryName(EngineID engine); rubidium@10521: tron@410: static void NewVehicleAvailable(Engine *e) truelight@0: { truelight@0: Vehicle *v; truelight@0: Player *p; peter1138@10382: EngineID index = e->index; truelight@0: belugas@6451: /* In case the player didn't build the vehicle during the intro period, belugas@6451: * prevent that player from getting future intro periods for a while. */ maedhros@6500: if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) { truelight@0: FOR_ALL_PLAYERS(p) { truelight@919: uint block_preview = p->block_preview; truelight@919: skidd13@8424: 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) { rubidium@6585: if (v->type == VEH_TRAIN || v->type == VEH_ROAD || v->type == VEH_SHIP || rubidium@6585: (v->type == VEH_AIRCRAFT && IsNormalAircraft(v))) { 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: maedhros@6500: e->flags = (e->flags & ~ENGINE_EXCLUSIVE_PREVIEW) | ENGINE_AVAILABLE; bjarni@6195: AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type); dominik@114: belugas@6451: /* Now available for all players */ truelight@0: e->player_avail = (byte)-1; dominik@114: belugas@6451: /* Do not introduce new rail wagons */ tron@2639: if (IsWagon(index)) return; dominik@114: peter1138@8716: if (e->type == VEH_TRAIN) { belugas@6451: /* maybe make another rail type available */ peter1138@10382: RailType railtype = e->u.rail.railtype; tron@6074: assert(railtype < RAILTYPE_END); tron@6074: FOR_ALL_PLAYERS(p) { skidd13@8427: if (p->is_active) SetBit(p->avail_railtypes, railtype); celestar@2147: } peter1138@8716: } else if (e->type == VEH_ROAD) { rubidium@7182: /* maybe make another road type available */ rubidium@7182: FOR_ALL_PLAYERS(p) { peter1138@10382: if (p->is_active) SetBit(p->avail_roadtypes, HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD); rubidium@7182: } rubidium@7182: } rubidium@10521: rubidium@10521: SetDParam(0, GetEngineCategoryName(index)); rubidium@10521: SetDParam(1, index); rubidium@10556: AddNewsItem(STR_NEW_VEHICLE_NOW_AVAILABLE_WITH_TYPE, NS_NEW_VEHICLES, index, 0); truelight@0: } truelight@0: rubidium@6573: void EnginesMonthlyLoop() truelight@0: { truelight@4300: if (_cur_year < YEAR_ENGINE_AGING_STOPS) { peter1138@8897: Engine *e; peter1138@8897: FOR_ALL_ENGINES(e) { belugas@6451: /* 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: peter1138@2990: if (!(e->flags & ENGINE_AVAILABLE) && _date >= (e->intro_date + 365)) { belugas@6451: /* Introduce it to all players */ truelight@0: NewVehicleAvailable(e); maedhros@6500: } else if (!(e->flags & (ENGINE_AVAILABLE|ENGINE_EXCLUSIVE_PREVIEW)) && _date >= e->intro_date) { belugas@6451: /* Introduction date has passed.. show introducing dialog to one player. */ maedhros@6500: e->flags |= ENGINE_EXCLUSIVE_PREVIEW; dominik@257: belugas@6451: /* Do not introduce new rail wagons */ peter1138@10382: if (!IsWagon(e->index)) peter1138@9061: e->preview_player_rank = 1; // Give to the player with the highest rating. truelight@0: } truelight@0: } truelight@0: } truelight@0: } truelight@0: peter1138@7593: static bool IsUniqueEngineName(const char *name) peter1138@7593: { peter1138@7593: char buf[512]; peter1138@7593: peter1138@10382: const Engine *e; peter1138@10382: FOR_ALL_ENGINES(e) { peter1138@10382: SetDParam(0, e->index); peter1138@7593: GetString(buf, STR_ENGINE_NAME, lastof(buf)); peter1138@7593: if (strcmp(buf, name) == 0) return false; peter1138@7593: } peter1138@7593: peter1138@7593: return true; peter1138@7593: } peter1138@7593: Darkvater@1786: /** Rename an engine. tron@3491: * @param tile unused belugas@6977: * @param flags operation to perfom Darkvater@1786: * @param p1 engine ID to rename Darkvater@1786: * @param p2 unused Darkvater@1786: */ rubidium@7439: CommandCost CmdRenameEngine(TileIndex tile, uint32 flags, uint32 p1, uint32 p2) truelight@0: { peter1138@7593: if (!IsEngineIndex(p1) || StrEmpty(_cmd_text)) return CMD_ERROR; Darkvater@1786: peter1138@7593: if (!IsUniqueEngineName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE); peter1138@7593: truelight@0: if (flags & DC_EXEC) { peter1138@8754: Engine *e = GetEngine(p1); peter1138@8754: free(e->name); peter1138@8754: e->name = strdup(_cmd_text); truelight@0: _vehicle_design_names |= 3; truelight@0: MarkWholeScreenDirty(); truelight@0: } truelight@0: rubidium@7446: return CommandCost(); truelight@0: } truelight@0: truelight@0: peter1138@8975: /** Check if an engine is buildable. peter1138@8975: * @param engine index of the engine to check. peter1138@8975: * @param type the type the engine should be. peter1138@8975: * @param player index of the player. peter1138@8975: * @return True if an engine is valid, of the specified type, and buildable by peter1138@8975: * the given player. peter1138@2848: */ peter1138@8975: bool IsEngineBuildable(EngineID engine, VehicleType type, PlayerID player) peter1138@2848: { belugas@6451: /* check if it's an engine that is in the engine array */ peter1138@2848: if (!IsEngineIndex(engine)) return false; peter1138@2848: peter1138@8975: const Engine *e = GetEngine(engine); peter1138@2848: belugas@6451: /* check if it's an engine of specified type */ peter1138@2848: if (e->type != type) return false; peter1138@2848: belugas@6451: /* check if it's available */ skidd13@8424: if (!HasBit(e->player_avail, player)) return false; peter1138@2848: peter1138@7026: if (type == VEH_TRAIN) { peter1138@7026: /* Check if the rail type is available to this player */ peter1138@7026: const Player *p = GetPlayer(player); skidd13@8424: if (!HasBit(p->avail_railtypes, RailVehInfo(engine)->railtype)) return false; peter1138@7026: } peter1138@7026: peter1138@2848: return true; peter1138@2848: } peter1138@2848: bjarni@7001: /** Get the default cargo type for a certain engine type bjarni@7001: * @param engine The ID to get the cargo for bjarni@7001: * @return The cargo type. CT_INVALID means no cargo capacity bjarni@7001: */ bjarni@7001: CargoID GetEngineCargoType(EngineID engine) bjarni@7001: { bjarni@7001: assert(IsEngineIndex(engine)); bjarni@7001: bjarni@7001: switch (GetEngine(engine)->type) { bjarni@7001: case VEH_TRAIN: bjarni@7001: if (RailVehInfo(engine)->capacity == 0) return CT_INVALID; bjarni@7001: return RailVehInfo(engine)->cargo_type; bjarni@7001: bjarni@7001: case VEH_ROAD: bjarni@7001: if (RoadVehInfo(engine)->capacity == 0) return CT_INVALID; bjarni@7001: return RoadVehInfo(engine)->cargo_type; bjarni@7001: bjarni@7001: case VEH_SHIP: bjarni@7001: if (ShipVehInfo(engine)->capacity == 0) return CT_INVALID; bjarni@7001: return ShipVehInfo(engine)->cargo_type; bjarni@7001: bjarni@7001: case VEH_AIRCRAFT: bjarni@7001: /* all aircraft starts as passenger planes with cargo capacity */ bjarni@7001: return CT_PASSENGERS; bjarni@7001: bjarni@7001: default: NOT_REACHED(); return CT_INVALID; bjarni@7001: } bjarni@7001: } bjarni@7001: peter1138@2848: /************************************************************************ peter1138@2848: * Engine Replacement stuff peter1138@2848: ************************************************************************/ peter1138@2848: rubidium@7884: DEFINE_OLD_POOL_GENERIC(EngineRenew, EngineRenew) peter1138@2848: peter1138@2848: /** peter1138@2848: * Retrieves the EngineRenew that specifies the replacement of the given peter1138@2848: * engine type from the given renewlist */ rubidium@7139: static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine, GroupID group) peter1138@2848: { truelight@4348: EngineRenew *er = (EngineRenew *)erl; truelight@4348: peter1138@2848: while (er) { rubidium@7139: if (er->from == engine && er->group_id == group) return er; peter1138@2848: er = er->next; peter1138@2848: } peter1138@2848: return NULL; peter1138@2848: } peter1138@2848: belugas@4171: void RemoveAllEngineReplacement(EngineRenewList *erl) peter1138@2848: { truelight@4348: EngineRenew *er = (EngineRenew *)(*erl); truelight@4384: EngineRenew *next; truelight@4348: rubidium@7884: while (er != NULL) { truelight@4384: next = er->next; rubidium@7884: delete er; truelight@4384: er = next; peter1138@2848: } truelight@4348: *erl = NULL; // Empty list peter1138@2848: } peter1138@2848: rubidium@7139: EngineID EngineReplacement(EngineRenewList erl, EngineID engine, GroupID group) peter1138@2848: { rubidium@7139: const EngineRenew *er = GetEngineReplacement(erl, engine, group); bjarni@8803: if (er == NULL && (group == DEFAULT_GROUP || (IsValidGroupID(group) && !GetGroup(group)->replace_protection))) { bjarni@8803: /* We didn't find anything useful in the vehicle's own group so we will try ALL_GROUP */ bjarni@8803: er = GetEngineReplacement(erl, engine, ALL_GROUP); bjarni@8803: } peter1138@2848: return er == NULL ? INVALID_ENGINE : er->to; peter1138@2848: } peter1138@2848: rubidium@7439: CommandCost AddEngineReplacement(EngineRenewList *erl, EngineID old_engine, EngineID new_engine, GroupID group, uint32 flags) peter1138@2848: { peter1138@2848: EngineRenew *er; peter1138@2848: truelight@4348: /* Check if the old vehicle is already in the list */ rubidium@7139: er = GetEngineReplacement(*erl, old_engine, group); peter1138@2848: if (er != NULL) { peter1138@2848: if (flags & DC_EXEC) er->to = new_engine; rubidium@7446: return CommandCost(); peter1138@2848: } peter1138@2848: rubidium@10314: if (!EngineRenew::CanAllocateItem()) return CMD_ERROR; peter1138@2848: peter1138@2848: if (flags & DC_EXEC) { rubidium@10314: er = new EngineRenew(old_engine, new_engine); rubidium@7139: er->group_id = group; peter1138@2848: truelight@4348: /* Insert before the first element */ truelight@4348: er->next = (EngineRenew *)(*erl); truelight@4348: *erl = (EngineRenewList)er; peter1138@2848: } peter1138@2848: rubidium@7446: return CommandCost(); peter1138@2848: } peter1138@2848: rubidium@7439: CommandCost RemoveEngineReplacement(EngineRenewList *erl, EngineID engine, GroupID group, uint32 flags) peter1138@2848: { truelight@4348: EngineRenew *er = (EngineRenew *)(*erl); belugas@4171: EngineRenew *prev = NULL; peter1138@2848: peter1138@2848: while (er) peter1138@2848: { rubidium@7139: if (er->from == engine && er->group_id == group) { peter1138@2848: if (flags & DC_EXEC) { truelight@4348: if (prev == NULL) { // First element truelight@4348: /* The second becomes the new first element */ truelight@4348: *erl = (EngineRenewList)er->next; peter1138@2848: } else { truelight@4348: /* Cut this element out */ truelight@4348: prev->next = er->next; peter1138@2848: } rubidium@7884: delete er; peter1138@2848: } rubidium@7446: return CommandCost(); peter1138@2848: } peter1138@2848: prev = er; truelight@4348: er = er->next; peter1138@2848: } peter1138@2848: truelight@4348: return CMD_ERROR; peter1138@2848: } peter1138@2848: peter1138@2848: static const SaveLoad _engine_renew_desc[] = { rubidium@7139: SLE_VAR(EngineRenew, from, SLE_UINT16), rubidium@7139: SLE_VAR(EngineRenew, to, SLE_UINT16), peter1138@2848: rubidium@7139: SLE_REF(EngineRenew, next, REF_ENGINE_RENEWS), rubidium@7139: SLE_CONDVAR(EngineRenew, group_id, SLE_UINT16, 60, SL_MAX_VERSION), peter1138@2848: SLE_END() peter1138@2848: }; peter1138@2848: rubidium@6573: static void Save_ERNW() peter1138@2848: { peter1138@2848: EngineRenew *er; peter1138@2848: peter1138@2848: FOR_ALL_ENGINE_RENEWS(er) { truelight@4348: SlSetArrayIndex(er->index); truelight@4348: SlObject(er, _engine_renew_desc); peter1138@2848: } peter1138@2848: } peter1138@2848: rubidium@6573: static void Load_ERNW() peter1138@2848: { peter1138@2848: int index; peter1138@2848: peter1138@2848: while ((index = SlIterateArray()) != -1) { rubidium@7884: EngineRenew *er = new (index) EngineRenew(); peter1138@2848: SlObject(er, _engine_renew_desc); rubidium@7139: rubidium@7754: /* Advanced vehicle lists, ungrouped vehicles got added */ rubidium@7754: if (CheckSavegameVersion(60)) { rubidium@7754: er->group_id = ALL_GROUP; rubidium@7754: } else if (CheckSavegameVersion(71)) { rubidium@7754: if (er->group_id == DEFAULT_GROUP) er->group_id = ALL_GROUP; rubidium@7754: } peter1138@2848: } peter1138@2848: } peter1138@2848: Darkvater@1881: static const SaveLoad _engine_desc[] = { rubidium@4344: SLE_CONDVAR(Engine, intro_date, SLE_FILE_U16 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Engine, intro_date, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: SLE_CONDVAR(Engine, age, SLE_FILE_U16 | SLE_VAR_I32, 0, 30), rubidium@4344: SLE_CONDVAR(Engine, age, SLE_INT32, 31, SL_MAX_VERSION), rubidium@4344: SLE_VAR(Engine, reliability, SLE_UINT16), rubidium@4344: SLE_VAR(Engine, reliability_spd_dec, SLE_UINT16), rubidium@4344: SLE_VAR(Engine, reliability_start, SLE_UINT16), rubidium@4344: SLE_VAR(Engine, reliability_max, SLE_UINT16), rubidium@4344: SLE_VAR(Engine, reliability_final, SLE_UINT16), rubidium@4344: SLE_VAR(Engine, duration_phase_1, SLE_UINT16), rubidium@4344: SLE_VAR(Engine, duration_phase_2, SLE_UINT16), rubidium@4344: SLE_VAR(Engine, duration_phase_3, SLE_UINT16), truelight@0: rubidium@4344: SLE_VAR(Engine, lifelength, SLE_UINT8), rubidium@4344: SLE_VAR(Engine, flags, SLE_UINT8), peter1138@9061: SLE_VAR(Engine, preview_player_rank, SLE_UINT8), rubidium@4344: SLE_VAR(Engine, preview_wait, SLE_UINT8), tron@6074: SLE_CONDNULL(1, 0, 44), rubidium@4344: SLE_VAR(Engine, player_avail, SLE_UINT8), peter1138@8754: SLE_CONDSTR(Engine, name, SLE_STR, 0, 84, SL_MAX_VERSION), truelight@0: belugas@6451: /* reserve extra space in savegame here. (currently 16 bytes) */ Darkvater@3222: SLE_CONDNULL(16, 2, SL_MAX_VERSION), truelight@0: truelight@0: SLE_END() truelight@0: }; truelight@0: peter1138@10382: static std::map _temp_engine; peter1138@10382: peter1138@10382: Engine *GetTempDataEngine(EngineID index) peter1138@10382: { peter1138@10382: return &_temp_engine[index]; peter1138@10382: } peter1138@10382: rubidium@6573: static void Save_ENGN() truelight@0: { peter1138@10382: Engine *e; peter1138@10382: FOR_ALL_ENGINES(e) { peter1138@10382: SlSetArrayIndex(e->index); peter1138@10382: SlObject(e, _engine_desc); truelight@0: } truelight@0: } truelight@0: rubidium@6573: static void Load_ENGN() truelight@0: { peter1138@10382: /* As engine data is loaded before engines are initialized we need to load peter1138@10382: * this information into a temporary array. This is then copied into the peter1138@10382: * engine pool after processing NewGRFs by CopyTempEngineData(). */ truelight@0: int index; truelight@0: while ((index = SlIterateArray()) != -1) { peter1138@10382: Engine *e = GetTempDataEngine(index); peter1138@10382: SlObject(e, _engine_desc); truelight@0: } truelight@0: } truelight@0: peter1138@10382: /** peter1138@10382: * Copy data from temporary engine array into the real engine pool. peter1138@10382: */ peter1138@10382: void CopyTempEngineData() peter1138@10382: { peter1138@10382: Engine *e; peter1138@10382: FOR_ALL_ENGINES(e) { peter1138@10382: if (e->index >= _temp_engine.size()) break; peter1138@10382: peter1138@10382: const Engine *se = GetTempDataEngine(e->index); peter1138@10382: e->intro_date = se->intro_date; peter1138@10382: e->age = se->age; peter1138@10382: e->reliability = se->reliability; peter1138@10382: e->reliability_spd_dec = se->reliability_spd_dec; peter1138@10382: e->reliability_start = se->reliability_start; peter1138@10382: e->reliability_max = se->reliability_max; peter1138@10382: e->reliability_final = se->reliability_final; peter1138@10382: e->duration_phase_1 = se->duration_phase_1; peter1138@10382: e->duration_phase_2 = se->duration_phase_2; peter1138@10382: e->duration_phase_3 = se->duration_phase_3; peter1138@10382: e->lifelength = se->lifelength; peter1138@10382: e->flags = se->flags; peter1138@10382: e->preview_player_rank = se->preview_player_rank; peter1138@10382: e->preview_wait = se->preview_wait; peter1138@10382: e->player_avail = se->player_avail; peter1138@10382: if (se->name != NULL) e->name = strdup(se->name); peter1138@10382: } peter1138@10382: peter1138@10382: /* Get rid of temporary data */ peter1138@10382: _temp_engine.clear(); peter1138@10382: } peter1138@10382: peter1138@8754: static void Load_ENGS() truelight@0: { peter1138@10382: /* Load old separate String ID list into a temporary array. This peter1138@10382: * was always 256 entries. */ peter1138@10382: StringID names[256]; peter1138@8754: peter1138@8754: SlArray(names, lengthof(names), SLE_STRINGID); peter1138@8754: peter1138@10382: /* Copy each string into the temporary engine array. */ peter1138@8754: for (EngineID engine = 0; engine < lengthof(names); engine++) { peter1138@10382: Engine *e = GetTempDataEngine(engine); peter1138@8754: e->name = CopyFromOldName(names[engine]); peter1138@8754: } truelight@0: } truelight@0: rubidium@5838: extern const ChunkHandler _engine_chunk_handlers[] = { peter1138@2848: { 'ENGN', Save_ENGN, Load_ENGN, CH_ARRAY }, peter1138@8754: { 'ENGS', NULL, Load_ENGS, CH_RIFF }, peter1138@2848: { 'ERNW', Save_ERNW, Load_ERNW, CH_ARRAY | CH_LAST}, truelight@0: }; truelight@0: rubidium@6573: void InitializeEngines() tron@1197: { peter1138@2848: /* Clean the engine renew pool and create 1 block in it */ rubidium@7884: _EngineRenew_pool.CleanPool(); rubidium@7884: _EngineRenew_pool.AddBlockToPool(); bjarni@1196: }