src/engine.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file engine.cpp Base for all engine handling. */
  11
  12 #include "stdafx.h"
  13 #include "company_func.h"
  14 #include "command_func.h"
  15 #include "news_func.h"
  16 #include "aircraft.h"
  17 #include "newgrf.h"
  18 #include "newgrf_engine.h"
  19 #include "strings_func.h"
  20 #include "core/random_func.hpp"
  21 #include "window_func.h"
  22 #include "date_func.h"
  23 #include "autoreplace_gui.h"
  24 #include "string_func.h"
  25 #include "ai/ai.hpp"
  26 #include "core/pool_func.hpp"
  27 #include "engine_gui.h"
  28 #include "engine_func.h"
  29 #include "engine_base.h"
  30 #include "company_base.h"
  31 #include "vehicle_func.h"
  32 #include "articulated_vehicles.h"
  33 #include "error.h"
  34
  35 #include "table/strings.h"
  36 #include "table/engines.h"
  37
  38 template<> Engine::Pool Engine::PoolItem::pool ("Engine");
  39 INSTANTIATE_POOL_METHODS(Engine)
  40
  41 EngineOverrideManager _engine_mngr;
  42
  43 /**
  44  * Year that engine aging stops. Engines will not reduce in reliability
  45  * and no more engines will be introduced
  46  */
  47 static Year _year_engine_aging_stops;
  48
  49 /**
  50  * The railtypes that have been or never will be introduced, or
  51  * an inverse bitmap of rail types that have to be introduced. */
  52 static uint16 _introduced_railtypes;
  53
  54 /** Number of engines of each vehicle type in original engine data */
  55 const uint8 _engine_counts[4] = {
  56         lengthof(_orig_rail_vehicle_info),
  57         lengthof(_orig_road_vehicle_info),
  58         lengthof(_orig_ship_vehicle_info),
  59         lengthof(_orig_aircraft_vehicle_info),
  60 };
  61
  62 /** Offset of the first engine of each vehicle type in original engine data */
  63 const uint8 _engine_offsets[4] = {
  64         0,
  65         lengthof(_orig_rail_vehicle_info),
  66         lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info),
  67         lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info) + lengthof(_orig_ship_vehicle_info),
  68 };
  69
  70 assert_compile(lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info) + lengthof(_orig_ship_vehicle_info) + lengthof(_orig_aircraft_vehicle_info) == lengthof(_orig_engine_info));
  71
  72 const uint EngineOverrideManager::NUM_DEFAULT_ENGINES = _engine_counts[VEH_TRAIN] + _engine_counts[VEH_ROAD] + _engine_counts[VEH_SHIP] + _engine_counts[VEH_AIRCRAFT];
  73
  74 Engine::Engine() :
  75         name(NULL),
  76         overrides_count(0),
  77         overrides(NULL)
  78 {
  79 }
  80
  81 Engine::Engine(VehicleType type, EngineID base)
  82 {
  83         this->type = type;
  84         this->grf_prop.local_id = base;
  85         this->list_position = base;
  86
  87         /* Check if this base engine is within the original engine data range */
  88         if (base >= _engine_counts[type]) {
  89                 /* Set model life to maximum to make wagons available */
  90                 this->info.base_life = 0xFF;
  91                 /* Set road vehicle tractive effort to the default value */
  92                 if (type == VEH_ROAD) this->u.road.tractive_effort = 0x4C;
  93                 /* Aircraft must have CT_INVALID as default, as there is no property */
  94                 if (type == VEH_AIRCRAFT) this->info.cargo_type = CT_INVALID;
  95                 /* Set visual effect to the default value */
  96                 switch (type) {
  97                         case VEH_TRAIN: this->u.rail.visual_effect = VE_DEFAULT; break;
  98                         case VEH_ROAD:  this->u.road.visual_effect = VE_DEFAULT; break;
  99                         case VEH_SHIP:  this->u.ship.visual_effect = VE_DEFAULT; break;
 100                         default: break; // The aircraft, disasters and especially visual effects have no NewGRF configured visual effects
 101                 }
 102                 /* Set cargo aging period to the default value. */
 103                 this->info.cargo_age_period = CARGO_AGING_TICKS;
 104                 return;
 105         }
 106
 107         /* Copy the original engine info for this slot */
 108         this->info = _orig_engine_info[_engine_offsets[type] + base];
 109
 110         /* Copy the original engine data for this slot */
 111         switch (type) {
 112                 default: NOT_REACHED();
 113
 114                 case VEH_TRAIN:
 115                         this->u.rail = _orig_rail_vehicle_info[base];
 116                         this->original_image_index = this->u.rail.image_index;
 117                         this->info.string_id = STR_VEHICLE_NAME_TRAIN_ENGINE_RAIL_KIRBY_PAUL_TANK_STEAM + base;
 118
 119                         /* Set the default model life of original wagons to "infinite" */
 120                         if (this->u.rail.railveh_type == RAILVEH_WAGON) this->info.base_life = 0xFF;
 121
 122                         break;
 123
 124                 case VEH_ROAD:
 125                         this->u.road = _orig_road_vehicle_info[base];
 126                         this->original_image_index = this->u.road.image_index;
 127                         this->info.string_id = STR_VEHICLE_NAME_ROAD_VEHICLE_MPS_REGAL_BUS + base;
 128                         break;
 129
 130                 case VEH_SHIP:
 131                         this->u.ship = _orig_ship_vehicle_info[base];
 132                         this->original_image_index = this->u.ship.image_index;
 133                         this->info.string_id = STR_VEHICLE_NAME_SHIP_MPS_OIL_TANKER + base;
 134                         break;
 135
 136                 case VEH_AIRCRAFT:
 137                         this->u.air = _orig_aircraft_vehicle_info[base];
 138                         this->original_image_index = this->u.air.image_index;
 139                         this->info.string_id = STR_VEHICLE_NAME_AIRCRAFT_SAMPSON_U52 + base;
 140                         break;
 141         }
 142 }
 143
 144 Engine::~Engine()
 145 {
 146         UnloadWagonOverrides(this);
 147         free(this->name);
 148 }
 149
 150 /**
 151  * Checks whether the engine is a valid (non-articulated part of an) engine.
 152  * @return true if enabled
 153  */
 154 bool Engine::IsEnabled() const
 155 {
 156         return this->info.string_id != STR_NEWGRF_INVALID_ENGINE && HasBit(this->info.climates, _settings_game.game_creation.landscape);
 157 }
 158
 159 /**
 160  * Retrieve the GRF ID of the NewGRF the engine is tied to.
 161  * This is the GRF providing the Action 3.
 162  * @return GRF ID of the associated NewGRF.
 163  */
 164 uint32 Engine::GetGRFID() const
 165 {
 166         const GRFFile *file = this->GetGRF();
 167         return file == NULL ? 0 : file->grfid;
 168 }
 169
 170 /**
 171  * Determines whether an engine can carry something.
 172  * A vehicle cannot carry anything if its capacity is zero, or none of the possible cargoes is available in the climate.
 173  * @return true if the vehicle can carry something.
 174  */
 175 bool Engine::CanCarryCargo() const
 176 {
 177         /* For engines that can appear in a consist (i.e. rail vehicles and (articulated) road vehicles), a capacity
 178          * of zero is a special case, to define the vehicle to not carry anything. The default cargotype is still used
 179          * for livery selection etc.
 180          * Note: Only the property is tested. A capacity callback returning 0 does not have the same effect.
 181          */
 182         switch (this->type) {
 183                 case VEH_TRAIN:
 184                         if (this->u.rail.capacity == 0) return false;
 185                         break;
 186
 187                 case VEH_ROAD:
 188                         if (this->u.road.capacity == 0) return false;
 189                         break;
 190
 191                 case VEH_SHIP:
 192                 case VEH_AIRCRAFT:
 193                         break;
 194
 195                 default: NOT_REACHED();
 196         }
 197         return this->GetDefaultCargoType() != CT_INVALID;
 198 }
 199
 200
 201 /**
 202  * Determines capacity of a given vehicle from scratch.
 203  * For aircraft the main capacity is determined. Mail might be present as well.
 204  * @param v Vehicle of interest; NULL in purchase list
 205  * @param mail_capacity returns secondary cargo (mail) capacity of aircraft
 206  * @return Capacity
 207  */
 208 uint Engine::DetermineCapacity(const Vehicle *v, uint16 *mail_capacity) const
 209 {
 210         assert(v == NULL || this->index == v->engine_type);
 211         if (mail_capacity != NULL) *mail_capacity = 0;
 212
 213         if (!this->CanCarryCargo()) return 0;
 214
 215         bool new_multipliers = HasBit(this->info.misc_flags, EF_NO_DEFAULT_CARGO_MULTIPLIER);
 216         CargoID default_cargo = this->GetDefaultCargoType();
 217         CargoID cargo_type = (v != NULL) ? v->cargo_type : default_cargo;
 218
 219         if (mail_capacity != NULL && this->type == VEH_AIRCRAFT && IsCargoInClass(cargo_type, CC_PASSENGERS)) {
 220                 *mail_capacity = GetEngineProperty(this->index, PROP_AIRCRAFT_MAIL_CAPACITY, this->u.air.mail_capacity, v);
 221         }
 222
 223         /* Check the refit capacity callback if we are not in the default configuration, or if we are using the new multiplier algorithm. */
 224         if (HasBit(this->info.callback_mask, CBM_VEHICLE_REFIT_CAPACITY) &&
 225                         (new_multipliers || default_cargo != cargo_type || (v != NULL && v->cargo_subtype != 0))) {
 226                 uint16 callback = GetVehicleCallback(CBID_VEHICLE_REFIT_CAPACITY, 0, 0, this->index, v);
 227                 if (callback != CALLBACK_FAILED) return callback;
 228         }
 229
 230         /* Get capacity according to property resp. CB */
 231         uint capacity;
 232         uint extra_mail_cap = 0;
 233         switch (this->type) {
 234                 case VEH_TRAIN:
 235                         capacity = GetEngineProperty(this->index, PROP_TRAIN_CARGO_CAPACITY,        this->u.rail.capacity, v);
 236
 237                         /* In purchase list add the capacity of the second head. Always use the plain property for this. */
 238                         if (v == NULL && this->u.rail.railveh_type == RAILVEH_MULTIHEAD) capacity += this->u.rail.capacity;
 239                         break;
 240
 241                 case VEH_ROAD:
 242                         capacity = GetEngineProperty(this->index, PROP_ROADVEH_CARGO_CAPACITY,      this->u.road.capacity, v);
 243                         break;
 244
 245                 case VEH_SHIP:
 246                         capacity = GetEngineProperty(this->index, PROP_SHIP_CARGO_CAPACITY,         this->u.ship.capacity, v);
 247                         break;
 248
 249                 case VEH_AIRCRAFT:
 250                         capacity = GetEngineProperty(this->index, PROP_AIRCRAFT_PASSENGER_CAPACITY, this->u.air.passenger_capacity, v);
 251                         if (!IsCargoInClass(cargo_type, CC_PASSENGERS)) {
 252                                 extra_mail_cap = GetEngineProperty(this->index, PROP_AIRCRAFT_MAIL_CAPACITY, this->u.air.mail_capacity, v);
 253                         }
 254                         if (!new_multipliers && cargo_type == CT_MAIL) return capacity + extra_mail_cap;
 255                         default_cargo = CT_PASSENGERS; // Always use 'passengers' wrt. cargo multipliers
 256                         break;
 257
 258                 default: NOT_REACHED();
 259         }
 260
 261         if (!new_multipliers) {
 262                 /* Use the passenger multiplier for mail as well */
 263                 capacity += extra_mail_cap;
 264                 extra_mail_cap = 0;
 265         }
 266
 267         /* Apply multipliers depending on cargo- and vehicletype. */
 268         if (new_multipliers || (this->type != VEH_SHIP && default_cargo != cargo_type)) {
 269                 uint16 default_multiplier = new_multipliers ? 0x100 : CargoSpec::Get(default_cargo)->multiplier;
 270                 uint16 cargo_multiplier = CargoSpec::Get(cargo_type)->multiplier;
 271                 capacity *= cargo_multiplier;
 272                 if (extra_mail_cap > 0) {
 273                         uint mail_multiplier = CargoSpec::Get(CT_MAIL)->multiplier;
 274                         capacity += (default_multiplier * extra_mail_cap * cargo_multiplier + mail_multiplier / 2) / mail_multiplier;
 275                 }
 276                 capacity = (capacity + default_multiplier / 2) / default_multiplier;
 277         }
 278
 279         return capacity;
 280 }
 281
 282 /**
 283  * Return how much the running costs of this engine are.
 284  * @return Yearly running cost of the engine.
 285  */
 286 Money Engine::GetRunningCost() const
 287 {
 288         Price base_price;
 289         uint cost_factor;
 290         switch (this->type) {
 291                 case VEH_ROAD:
 292                         base_price = this->u.road.running_cost_class;
 293                         if (base_price == INVALID_PRICE) return 0;
 294                         cost_factor = GetEngineProperty(this->index, PROP_ROADVEH_RUNNING_COST_FACTOR, this->u.road.running_cost);
 295                         break;
 296
 297                 case VEH_TRAIN:
 298                         base_price = this->u.rail.running_cost_class;
 299                         if (base_price == INVALID_PRICE) return 0;
 300                         cost_factor = GetEngineProperty(this->index, PROP_TRAIN_RUNNING_COST_FACTOR, this->u.rail.running_cost);
 301                         break;
 302
 303                 case VEH_SHIP:
 304                         base_price = PR_RUNNING_SHIP;
 305                         cost_factor = GetEngineProperty(this->index, PROP_SHIP_RUNNING_COST_FACTOR, this->u.ship.running_cost);
 306                         break;
 307
 308                 case VEH_AIRCRAFT:
 309                         base_price = PR_RUNNING_AIRCRAFT;
 310                         cost_factor = GetEngineProperty(this->index, PROP_AIRCRAFT_RUNNING_COST_FACTOR, this->u.air.running_cost);
 311                         break;
 312
 313                 default: NOT_REACHED();
 314         }
 315
 316         return GetPrice(base_price, cost_factor, this->GetGRF(), -8);
 317 }
 318
 319 /**
 320  * Return how much a new engine costs.
 321  * @return Cost of the engine.
 322  */
 323 Money Engine::GetCost() const
 324 {
 325         Price base_price;
 326         uint cost_factor;
 327         switch (this->type) {
 328                 case VEH_ROAD:
 329                         base_price = PR_BUILD_VEHICLE_ROAD;
 330                         cost_factor = GetEngineProperty(this->index, PROP_ROADVEH_COST_FACTOR, this->u.road.cost_factor);
 331                         break;
 332
 333                 case VEH_TRAIN:
 334                         if (this->u.rail.railveh_type == RAILVEH_WAGON) {
 335                                 base_price = PR_BUILD_VEHICLE_WAGON;
 336                                 cost_factor = GetEngineProperty(this->index, PROP_TRAIN_COST_FACTOR, this->u.rail.cost_factor);
 337                         } else {
 338                                 base_price = PR_BUILD_VEHICLE_TRAIN;
 339                                 cost_factor = GetEngineProperty(this->index, PROP_TRAIN_COST_FACTOR, this->u.rail.cost_factor);
 340                         }
 341                         break;
 342
 343                 case VEH_SHIP:
 344                         base_price = PR_BUILD_VEHICLE_SHIP;
 345                         cost_factor = GetEngineProperty(this->index, PROP_SHIP_COST_FACTOR, this->u.ship.cost_factor);
 346                         break;
 347
 348                 case VEH_AIRCRAFT:
 349                         base_price = PR_BUILD_VEHICLE_AIRCRAFT;
 350                         cost_factor = GetEngineProperty(this->index, PROP_AIRCRAFT_COST_FACTOR, this->u.air.cost_factor);
 351                         break;
 352
 353                 default: NOT_REACHED();
 354         }
 355
 356         return GetPrice(base_price, cost_factor, this->GetGRF(), -8);
 357 }
 358
 359 /**
 360  * Returns max speed of the engine for display purposes
 361  * @return max speed in km-ish/h
 362  */
 363 uint Engine::GetDisplayMaxSpeed() const
 364 {
 365         switch (this->type) {
 366                 case VEH_TRAIN:
 367                         return GetEngineProperty(this->index, PROP_TRAIN_SPEED, this->u.rail.max_speed);
 368
 369                 case VEH_ROAD: {
 370                         uint max_speed = GetEngineProperty(this->index, PROP_ROADVEH_SPEED, 0);
 371                         return (max_speed != 0) ? max_speed * 2 : this->u.road.max_speed / 2;
 372                 }
 373
 374                 case VEH_SHIP:
 375                         return GetEngineProperty(this->index, PROP_SHIP_SPEED, this->u.ship.max_speed) / 2;
 376
 377                 case VEH_AIRCRAFT: {
 378                         uint max_speed = GetEngineProperty(this->index, PROP_AIRCRAFT_SPEED, 0);
 379                         if (max_speed != 0) {
 380                                 return (max_speed * 128) / 10;
 381                         }
 382                         return this->u.air.max_speed;
 383                 }
 384
 385                 default: NOT_REACHED();
 386         }
 387 }
 388
 389 /**
 390  * Returns the power of the engine for display
 391  * and sorting purposes.
 392  * Only trains and road vehicles have power
 393  * @return power in display units hp
 394  */
 395 uint Engine::GetPower() const
 396 {
 397         /* Only trains and road vehicles have 'power'. */
 398         switch (this->type) {
 399                 case VEH_TRAIN:
 400                         return GetEngineProperty(this->index, PROP_TRAIN_POWER, this->u.rail.power);
 401                 case VEH_ROAD:
 402                         return GetEngineProperty(this->index, PROP_ROADVEH_POWER, this->u.road.power) * 10;
 403
 404                 default: NOT_REACHED();
 405         }
 406 }
 407
 408 /**
 409  * Returns the weight of the engine for display purposes.
 410  * For dual-headed train-engines this is the weight of both heads
 411  * @return weight in display units metric tons
 412  */
 413 uint Engine::GetDisplayWeight() const
 414 {
 415         /* Only trains and road vehicles have 'weight'. */
 416         switch (this->type) {
 417                 case VEH_TRAIN:
 418                         return GetEngineProperty(this->index, PROP_TRAIN_WEIGHT, this->u.rail.weight) << (this->u.rail.railveh_type == RAILVEH_MULTIHEAD ? 1 : 0);
 419                 case VEH_ROAD:
 420                         return GetEngineProperty(this->index, PROP_ROADVEH_WEIGHT, this->u.road.weight) / 4;
 421
 422                 default: NOT_REACHED();
 423         }
 424 }
 425
 426 /**
 427  * Returns the tractive effort of the engine for display purposes.
 428  * For dual-headed train-engines this is the tractive effort of both heads
 429  * @return tractive effort in display units kN
 430  */
 431 uint Engine::GetDisplayMaxTractiveEffort() const
 432 {
 433         /* Only trains and road vehicles have 'tractive effort'. */
 434         switch (this->type) {
 435                 case VEH_TRAIN:
 436                         return (10 * this->GetDisplayWeight() * GetEngineProperty(this->index, PROP_TRAIN_TRACTIVE_EFFORT, this->u.rail.tractive_effort)) / 256;
 437                 case VEH_ROAD:
 438                         return (10 * this->GetDisplayWeight() * GetEngineProperty(this->index, PROP_ROADVEH_TRACTIVE_EFFORT, this->u.road.tractive_effort)) / 256;
 439
 440                 default: NOT_REACHED();
 441         }
 442 }
 443
 444 /**
 445  * Returns the vehicle's (not model's!) life length in days.
 446  * @return the life length
 447  */
 448 Date Engine::GetLifeLengthInDays() const
 449 {
 450         /* Assume leap years; this gives the player a bit more than the given amount of years, but never less. */
 451         return (this->info.lifelength + _settings_game.vehicle.extend_vehicle_life) * DAYS_IN_LEAP_YEAR;
 452 }
 453
 454 /**
 455  * Get the range of an aircraft type.
 456  * @return Range of the aircraft type in tiles or 0 if unlimited range.
 457  */
 458 uint16 Engine::GetRange() const
 459 {
 460         switch (this->type) {
 461                 case VEH_AIRCRAFT:
 462                         return GetEngineProperty(this->index, PROP_AIRCRAFT_RANGE, this->u.air.max_range);
 463
 464                 default: NOT_REACHED();
 465         }
 466 }
 467
 468 /**
 469  * Initializes the EngineOverrideManager with the default engines.
 470  */
 471 void EngineOverrideManager::ResetToDefaultMapping()
 472 {
 473         this->Clear();
 474         for (VehicleType type = VEH_TRAIN; type <= VEH_AIRCRAFT; type++) {
 475                 for (uint internal_id = 0; internal_id < _engine_counts[type]; internal_id++) {
 476                         EngineIDMapping *eid = this->Append();
 477                         eid->type            = type;
 478                         eid->grfid           = INVALID_GRFID;
 479                         eid->internal_id     = internal_id;
 480                         eid->substitute_id   = internal_id;
 481                 }
 482         }
 483 }
 484
 485 /**
 486  * Looks up an EngineID in the EngineOverrideManager
 487  * @param type Vehicle type
 488  * @param grf_local_id The local id in the newgrf
 489  * @param grfid The GrfID that defines the scope of grf_local_id.
 490  *              If a newgrf overrides the engines of another newgrf, the "scope grfid" is the ID of the overridden newgrf.
 491  *              If dynnamic_engines is disabled, all newgrf share the same ID scope identified by INVALID_GRFID.
 492  * @return The engine ID if present, or INVALID_ENGINE if not.
 493  */
 494 EngineID EngineOverrideManager::GetID(VehicleType type, uint16 grf_local_id, uint32 grfid)
 495 {
 496         const EngineIDMapping *end = this->End();
 497         EngineID index = 0;
 498         for (const EngineIDMapping *eid = this->Begin(); eid != end; eid++, index++) {
 499                 if (eid->type == type && eid->grfid == grfid && eid->internal_id == grf_local_id) {
 500                         return index;
 501                 }
 502         }
 503         return INVALID_ENGINE;
 504 }
 505
 506 /**
 507  * Tries to reset the engine mapping to match the current NewGRF configuration.
 508  * This is only possible when there are currently no vehicles in the game.
 509  * @return false if resetting failed due to present vehicles.
 510  */
 511 bool EngineOverrideManager::ResetToCurrentNewGRFConfig()
 512 {
 513         const Vehicle *v;
 514         FOR_ALL_VEHICLES(v) {
 515                 if (IsCompanyBuildableVehicleType(v)) return false;
 516         }
 517
 518         /* Reset the engines, they will get new EngineIDs */
 519         _engine_mngr.ResetToDefaultMapping();
 520         ReloadNewGRFData();
 521
 522         return true;
 523 }
 524
 525 /**
 526  * Initialise the engine pool with the data from the original vehicles.
 527  */
 528 void SetupEngines()
 529 {
 530         DeleteWindowByClass(WC_ENGINE_PREVIEW);
 531         Engine::pool.CleanPool();
 532
 533         assert(_engine_mngr.Length() >= _engine_mngr.NUM_DEFAULT_ENGINES);
 534         const EngineIDMapping *end = _engine_mngr.End();
 535         uint index = 0;
 536         for (const EngineIDMapping *eid = _engine_mngr.Begin(); eid != end; eid++, index++) {
 537                 /* Assert is safe; there won't be more than 256 original vehicles
 538                  * in any case, and we just cleaned the pool. */
 539                 assert(Engine::CanAllocateItem());
 540                 const Engine *e = new Engine(eid->type, eid->internal_id);
 541                 assert(e->index == index);
 542         }
 543
 544         _introduced_railtypes = 0;
 545 }
 546
 547 /**
 548  * Check whether the railtypes should be introduced.
 549  */
 550 static void CheckRailIntroduction()
 551 {
 552         /* All railtypes have been introduced. */
 553         if (_introduced_railtypes == UINT16_MAX || Company::GetPoolSize() == 0) return;
 554
 555         /* We need to find the railtypes that are known to all companies. */
 556         RailTypes rts = (RailTypes)UINT16_MAX;
 557
 558         /* We are at, or past the introduction date of the rail. */
 559         Company *c;
 560         FOR_ALL_COMPANIES(c) {
 561                 c->avail_railtypes = AddDateIntroducedRailTypes(c->avail_railtypes, _date);
 562                 rts &= c->avail_railtypes;
 563         }
 564
 565         _introduced_railtypes |= rts;
 566 }
 567
 568 void ShowEnginePreviewWindow(EngineID engine);
 569
 570 /**
 571  * Determine whether an engine type is a wagon (and not a loco).
 572  * @param index %Engine getting queried.
 573  * @return Whether the queried engine is a wagon.
 574  */
 575 static bool IsWagon(EngineID index)
 576 {
 577         const Engine *e = Engine::Get(index);
 578         return e->type == VEH_TRAIN && e->u.rail.railveh_type == RAILVEH_WAGON;
 579 }
 580
 581 /**
 582  * Update #reliability of engine \a e, (if needed) update the engine GUIs.
 583  * @param e %Engine to update.
 584  */
 585 static void CalcEngineReliability(Engine *e)
 586 {
 587         uint age = e->age;
 588
 589         /* Check for early retirement */
 590         if (e->company_avail != 0 && !_settings_game.vehicle.never_expire_vehicles && e->info.base_life != 0xFF) {
 591                 int retire_early = e->info.retire_early;
 592                 uint retire_early_max_age = max(0, e->duration_phase_1 + e->duration_phase_2 - retire_early * 12);
 593                 if (retire_early != 0 && age >= retire_early_max_age) {
 594                         /* Early retirement is enabled and we're past the date... */
 595                         e->company_avail = 0;
 596                         AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
 597                 }
 598         }
 599
 600         if (age < e->duration_phase_1) {
 601                 uint start = e->reliability_start;
 602                 e->reliability = age * (e->reliability_max - start) / e->duration_phase_1 + start;
 603         } else if ((age -= e->duration_phase_1) < e->duration_phase_2 || _settings_game.vehicle.never_expire_vehicles || e->info.base_life == 0xFF) {
 604                 /* We are at the peak of this engines life. It will have max reliability.
 605                  * This is also true if the engines never expire. They will not go bad over time */
 606                 e->reliability = e->reliability_max;
 607         } else if ((age -= e->duration_phase_2) < e->duration_phase_3) {
 608                 uint max = e->reliability_max;
 609                 e->reliability = (int)age * (int)(e->reliability_final - max) / e->duration_phase_3 + max;
 610         } else {
 611                 /* time's up for this engine.
 612                  * We will now completely retire this design */
 613                 e->company_avail = 0;
 614                 e->reliability = e->reliability_final;
 615                 /* Kick this engine out of the lists */
 616                 AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
 617         }
 618         SetWindowClassesDirty(WC_BUILD_VEHICLE); // Update to show the new reliability
 619         SetWindowClassesDirty(WC_REPLACE_VEHICLE);
 620 }
 621
 622 /** Compute the value for #_year_engine_aging_stops. */
 623 void SetYearEngineAgingStops()
 624 {
 625         /* Determine last engine aging year, default to 2050 as previously. */
 626         _year_engine_aging_stops = 2050;
 627
 628         const Engine *e;
 629         FOR_ALL_ENGINES(e) {
 630                 const EngineInfo *ei = &e->info;
 631
 632                 /* Exclude certain engines */
 633                 if (!HasBit(ei->climates, _settings_game.game_creation.landscape)) continue;
 634                 if (e->type == VEH_TRAIN && e->u.rail.railveh_type == RAILVEH_WAGON) continue;
 635
 636                 /* Base year ending date on half the model life */
 637                 YearMonthDay ymd;
 638                 ConvertDateToYMD(ei->base_intro + (ei->lifelength * DAYS_IN_LEAP_YEAR) / 2, &ymd);
 639
 640                 _year_engine_aging_stops = max(_year_engine_aging_stops, ymd.year);
 641         }
 642 }
 643
 644 /**
 645  * Start/initialise one engine.
 646  * @param e The engine to initialise.
 647  * @param aging_date The date used for age calculations.
 648  */
 649 void StartupOneEngine(Engine *e, Date aging_date)
 650 {
 651         const EngineInfo *ei = &e->info;
 652
 653         e->age = 0;
 654         e->flags = 0;
 655         e->company_avail = 0;
 656
 657         /* Don't randomise the start-date in the first two years after gamestart to ensure availability
 658          * of engines in early starting games.
 659          * Note: TTDP uses fixed 1922 */
 660         uint32 r = Random();
 661         e->intro_date = ei->base_intro <= ConvertYMDToDate(_settings_game.game_creation.starting_year + 2, 0, 1) ? ei->base_intro : (Date)GB(r, 0, 9) + ei->base_intro;
 662         if (e->intro_date <= _date) {
 663                 e->age = (aging_date - e->intro_date) >> 5;
 664                 e->company_avail = (CompanyMask)-1;
 665                 e->flags |= ENGINE_AVAILABLE;
 666         }
 667
 668         e->reliability_start = GB(r, 16, 14) + 0x7AE0;
 669         r = Random();
 670         e->reliability_max   = GB(r,  0, 14) + 0xBFFF;
 671         e->reliability_final = GB(r, 16, 14) + 0x3FFF;
 672
 673         r = Random();
 674         e->duration_phase_1 = GB(r, 0, 5) + 7;
 675         e->duration_phase_2 = GB(r, 5, 4) + ei->base_life * 12 - 96;
 676         e->duration_phase_3 = GB(r, 9, 7) + 120;
 677
 678         e->reliability_spd_dec = ei->decay_speed << 2;
 679
 680         CalcEngineReliability(e);
 681
 682         /* prevent certain engines from ever appearing. */
 683         if (!HasBit(ei->climates, _settings_game.game_creation.landscape)) {
 684                 e->flags |= ENGINE_AVAILABLE;
 685                 e->company_avail = 0;
 686         }
 687 }
 688
 689 /**
 690  * Start/initialise all our engines. Must be called whenever there are changes
 691  * to the NewGRF config.
 692  */
 693 void StartupEngines()
 694 {
 695         Engine *e;
 696         /* Aging of vehicles stops, so account for that when starting late */
 697         const Date aging_date = min(_date, ConvertYMDToDate(_year_engine_aging_stops, 0, 1));
 698
 699         FOR_ALL_ENGINES(e) {
 700                 StartupOneEngine(e, aging_date);
 701         }
 702
 703         /* Update the bitmasks for the vehicle lists */
 704         Company *c;
 705         FOR_ALL_COMPANIES(c) {
 706                 c->avail_railtypes = GetCompanyRailtypes(c->index);
 707                 c->avail_roadtypes = GetCompanyRoadtypes(c->index);
 708         }
 709
 710         /* Rail types that are invalid or never introduced are marked as
 711          * being introduced upon start. That way we can easily check whether
 712          * there is any date related introduction that is still going to
 713          * happen somewhere in the future. */
 714         for (RailType rt = RAILTYPE_BEGIN; rt != RAILTYPE_END; rt++) {
 715                 const RailtypeInfo *rti = GetRailTypeInfo(rt);
 716                 if (rti->label != 0 && IsInsideMM(rti->introduction_date, 0, MAX_DAY)) continue;
 717
 718                 SetBit(_introduced_railtypes, rt);
 719         }
 720
 721         CheckRailIntroduction();
 722
 723         /* Invalidate any open purchase lists */
 724         InvalidateWindowClassesData(WC_BUILD_VEHICLE);
 725 }
 726
 727 /**
 728  * Company \a company accepts engine \a eid for preview.
 729  * @param eid Engine being accepted (is under preview).
 730  * @param company Current company previewing the engine.
 731  */
 732 static void AcceptEnginePreview(EngineID eid, CompanyID company)
 733 {
 734         Engine *e = Engine::Get(eid);
 735         Company *c = Company::Get(company);
 736
 737         SetBit(e->company_avail, company);
 738         if (e->type == VEH_TRAIN) {
 739                 assert(e->u.rail.railtype < RAILTYPE_END);
 740                 c->avail_railtypes = AddDateIntroducedRailTypes(c->avail_railtypes | GetRailTypeInfo(e->u.rail.railtype)->introduces_railtypes, _date);
 741         } else if (e->type == VEH_ROAD) {
 742                 SetBit(c->avail_roadtypes, HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);
 743         }
 744
 745         e->preview_company = INVALID_COMPANY;
 746         e->preview_asked = (CompanyMask)-1;
 747         if (company == _local_company) {
 748                 AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
 749         }
 750
 751         /* Update the toolbar. */
 752         if (e->type == VEH_ROAD) InvalidateWindowData(WC_BUILD_TOOLBAR, TRANSPORT_ROAD);
 753         if (e->type == VEH_SHIP) InvalidateWindowData(WC_BUILD_TOOLBAR, TRANSPORT_WATER);
 754
 755         /* Notify preview window, that it might want to close.
 756          * Note: We cannot directly close the window.
 757          *       In singleplayer this function is called from the preview window, so
 758          *       we have to use the GUI-scope scheduling of InvalidateWindowData.
 759          */
 760         InvalidateWindowData(WC_ENGINE_PREVIEW, eid);
 761 }
 762
 763 /**
 764  * Get the best company for an engine preview.
 765  * @param e Engine to preview.
 766  * @return Best company if it exists, #INVALID_COMPANY otherwise.
 767  */
 768 static CompanyID GetPreviewCompany(Engine *e)
 769 {
 770         CompanyID best_company = INVALID_COMPANY;
 771
 772         /* For trains the cargomask has no useful meaning, since you can attach other wagons */
 773         uint32 cargomask = e->type != VEH_TRAIN ? GetUnionOfArticulatedRefitMasks(e->index, true) : (uint32)-1;
 774
 775         int32 best_hist = -1;
 776         const Company *c;
 777         FOR_ALL_COMPANIES(c) {
 778                 if (c->block_preview == 0 && !HasBit(e->preview_asked, c->index) &&
 779                                 c->old_economy[0].performance_history > best_hist) {
 780
 781                         /* Check whether the company uses similar vehicles */
 782                         Vehicle *v;
 783                         FOR_ALL_VEHICLES(v) {
 784                                 if (v->owner != c->index || v->type != e->type) continue;
 785                                 if (!v->GetEngine()->CanCarryCargo() || !HasBit(cargomask, v->cargo_type)) continue;
 786
 787                                 best_hist = c->old_economy[0].performance_history;
 788                                 best_company = c->index;
 789                                 break;
 790                         }
 791                 }
 792         }
 793
 794         return best_company;
 795 }
 796
 797 /**
 798  * Checks if a vehicle type is disabled for all/ai companies.
 799  * @param type The vehicle type which shall be checked.
 800  * @param ai If true, check if the type is disabled for AI companies, otherwise check if
 801  *           the vehicle type is disabled for human companies.
 802  * @return Whether or not a vehicle type is disabled.
 803  */
 804 static bool IsVehicleTypeDisabled(VehicleType type, bool ai)
 805 {
 806         switch (type) {
 807                 case VEH_TRAIN:    return _settings_game.vehicle.max_trains == 0   || (ai && _settings_game.ai.ai_disable_veh_train);
 808                 case VEH_ROAD:     return _settings_game.vehicle.max_roadveh == 0  || (ai && _settings_game.ai.ai_disable_veh_roadveh);
 809                 case VEH_SHIP:     return _settings_game.vehicle.max_ships == 0    || (ai && _settings_game.ai.ai_disable_veh_ship);
 810                 case VEH_AIRCRAFT: return _settings_game.vehicle.max_aircraft == 0 || (ai && _settings_game.ai.ai_disable_veh_aircraft);
 811
 812                 default: NOT_REACHED();
 813         }
 814 }
 815
 816 /** Daily check to offer an exclusive engine preview to the companies. */
 817 void EnginesDailyLoop()
 818 {
 819         CheckRailIntroduction();
 820
 821         if (_cur_year >= _year_engine_aging_stops) return;
 822
 823         Engine *e;
 824         FOR_ALL_ENGINES(e) {
 825                 EngineID i = e->index;
 826                 if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {
 827                         if (e->preview_company != INVALID_COMPANY) {
 828                                 if (!--e->preview_wait) {
 829                                         DeleteWindowById(WC_ENGINE_PREVIEW, i);
 830                                         e->preview_company = INVALID_COMPANY;
 831                                 }
 832                         } else if (CountBits(e->preview_asked) < MAX_COMPANIES) {
 833                                 e->preview_company = GetPreviewCompany(e);
 834
 835                                 if (e->preview_company == INVALID_COMPANY) {
 836                                         e->preview_asked = (CompanyMask)-1;
 837                                         continue;
 838                                 }
 839
 840                                 SetBit(e->preview_asked, e->preview_company);
 841                                 e->preview_wait = 20;
 842                                 /* AIs are intentionally not skipped for preview even if they cannot build a certain
 843                                  * vehicle type. This is done to not give poor performing human companies an "unfair"
 844                                  * boost that they wouldn't have gotten against other human companies. The check on
 845                                  * the line below is just to make AIs not notice that they have a preview if they
 846                                  * cannot build the vehicle. */
 847                                 if (!IsVehicleTypeDisabled(e->type, true)) AI::NewEvent(e->preview_company, new ScriptEventEnginePreview(i));
 848                                 if (IsInteractiveCompany(e->preview_company)) ShowEnginePreviewWindow(i);
 849                         }
 850                 }
 851         }
 852 }
 853
 854 /**
 855  * Accept an engine prototype. XXX - it is possible that the top-company
 856  * changes while you are waiting to accept the offer? Then it becomes invalid
 857  * @param tile unused
 858  * @param flags operation to perform
 859  * @param p1 engine-prototype offered
 860  * @param p2 unused
 861  * @param text unused
 862  * @return the cost of this operation or an error
 863  */
 864 CommandCost CmdWantEnginePreview(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
 865 {
 866         Engine *e = Engine::GetIfValid(p1);
 867         if (e == NULL || e->preview_company != _current_company) return CMD_ERROR;
 868
 869         if (flags & DC_EXEC) AcceptEnginePreview(p1, _current_company);
 870
 871         return CommandCost();
 872 }
 873
 874 /**
 875  * An engine has become available for general use.
 876  * Also handle the exclusive engine preview contract.
 877  * @param e Engine generally available as of now.
 878  */
 879 static void NewVehicleAvailable(Engine *e)
 880 {
 881         Vehicle *v;
 882         Company *c;
 883         EngineID index = e->index;
 884
 885         /* In case the company didn't build the vehicle during the intro period,
 886          * prevent that company from getting future intro periods for a while. */
 887         if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {
 888                 FOR_ALL_COMPANIES(c) {
 889                         uint block_preview = c->block_preview;
 890
 891                         if (!HasBit(e->company_avail, c->index)) continue;
 892
 893                         /* We assume the user did NOT build it.. prove me wrong ;) */
 894                         c->block_preview = 20;
 895
 896                         FOR_ALL_VEHICLES(v) {
 897                                 if (v->type == VEH_TRAIN || v->type == VEH_ROAD || v->type == VEH_SHIP ||
 898                                                 (v->type == VEH_AIRCRAFT && Aircraft::From(v)->IsNormalAircraft())) {
 899                                         if (v->owner == c->index && v->engine_type == index) {
 900                                                 /* The user did prove me wrong, so restore old value */
 901                                                 c->block_preview = block_preview;
 902                                                 break;
 903                                         }
 904                                 }
 905                         }
 906                 }
 907         }
 908
 909         e->flags = (e->flags & ~ENGINE_EXCLUSIVE_PREVIEW) | ENGINE_AVAILABLE;
 910         AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);
 911
 912         /* Now available for all companies */
 913         e->company_avail = (CompanyMask)-1;
 914
 915         /* Do not introduce new rail wagons */
 916         if (IsWagon(index)) return;
 917
 918         if (e->type == VEH_TRAIN) {
 919                 /* maybe make another rail type available */
 920                 RailType railtype = e->u.rail.railtype;
 921                 assert(railtype < RAILTYPE_END);
 922                 FOR_ALL_COMPANIES(c) c->avail_railtypes = AddDateIntroducedRailTypes(c->avail_railtypes | GetRailTypeInfo(e->u.rail.railtype)->introduces_railtypes, _date);
 923         } else if (e->type == VEH_ROAD) {
 924                 /* maybe make another road type available */
 925                 FOR_ALL_COMPANIES(c) SetBit(c->avail_roadtypes, HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);
 926         }
 927
 928         /* Only broadcast event if AIs are able to build this vehicle type. */
 929         if (!IsVehicleTypeDisabled(e->type, true)) AI::BroadcastNewEvent(new ScriptEventEngineAvailable(index));
 930
 931         /* Only provide the "New Vehicle available" news paper entry, if engine can be built. */
 932         if (!IsVehicleTypeDisabled(e->type, false)) {
 933                 SetDParam(0, GetEngineCategoryName(index));
 934                 SetDParam(1, index);
 935                 AddNewsItem(STR_NEWS_NEW_VEHICLE_NOW_AVAILABLE_WITH_TYPE, NT_NEW_VEHICLES, NF_VEHICLE, NR_ENGINE, index);
 936         }
 937
 938         /* Update the toolbar. */
 939         if (e->type == VEH_ROAD) InvalidateWindowData(WC_BUILD_TOOLBAR, TRANSPORT_ROAD);
 940         if (e->type == VEH_SHIP) InvalidateWindowData(WC_BUILD_TOOLBAR, TRANSPORT_WATER);
 941
 942         /* Close pending preview windows */
 943         DeleteWindowById(WC_ENGINE_PREVIEW, index);
 944 }
 945
 946 /** Monthly update of the availability, reliability, and preview offers of the engines. */
 947 void EnginesMonthlyLoop()
 948 {
 949         if (_cur_year < _year_engine_aging_stops) {
 950                 Engine *e;
 951                 FOR_ALL_ENGINES(e) {
 952                         /* Age the vehicle */
 953                         if ((e->flags & ENGINE_AVAILABLE) && e->age != MAX_DAY) {
 954                                 e->age++;
 955                                 CalcEngineReliability(e);
 956                         }
 957
 958                         /* Do not introduce invalid engines */
 959                         if (!e->IsEnabled()) continue;
 960
 961                         if (!(e->flags & ENGINE_AVAILABLE) && _date >= (e->intro_date + DAYS_IN_YEAR)) {
 962                                 /* Introduce it to all companies */
 963                                 NewVehicleAvailable(e);
 964                         } else if (!(e->flags & (ENGINE_AVAILABLE | ENGINE_EXCLUSIVE_PREVIEW)) && _date >= e->intro_date) {
 965                                 /* Introduction date has passed...
 966                                  * Check if it is allowed to build this vehicle type at all
 967                                  * based on the current game settings. If not, it does not
 968                                  * make sense to show the preview dialog to any company. */
 969                                 if (IsVehicleTypeDisabled(e->type, false)) continue;
 970
 971                                 /* Do not introduce new rail wagons */
 972                                 if (IsWagon(e->index)) continue;
 973
 974                                 /* Show preview dialog to one of the companies. */
 975                                 e->flags |= ENGINE_EXCLUSIVE_PREVIEW;
 976                                 e->preview_company = INVALID_COMPANY;
 977                                 e->preview_asked = 0;
 978                         }
 979                 }
 980
 981                 InvalidateWindowClassesData(WC_BUILD_VEHICLE); // rebuild the purchase list (esp. when sorted by reliability)
 982         }
 983 }
 984
 985 /**
 986  * Is \a name still free as name for an engine?
 987  * @param name New name of an engine.
 988  * @return \c false if the name is being used already, else \c true.
 989  */
 990 static bool IsUniqueEngineName(const char *name)
 991 {
 992         const Engine *e;
 993
 994         FOR_ALL_ENGINES(e) {
 995                 if (e->name != NULL && strcmp(e->name, name) == 0) return false;
 996         }
 997
 998         return true;
 999 }
1000
1001 /**
1002  * Rename an engine.
1003  * @param tile unused
1004  * @param flags operation to perform
1005  * @param p1 engine ID to rename
1006  * @param p2 unused
1007  * @param text the new name or an empty string when resetting to the default
1008  * @return the cost of this operation or an error
1009  */
1010 CommandCost CmdRenameEngine(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
1011 {
1012         Engine *e = Engine::GetIfValid(p1);
1013         if (e == NULL) return CMD_ERROR;
1014
1015         bool reset = StrEmpty(text);
1016
1017         if (!reset) {
1018                 if (Utf8StringLength(text) >= MAX_LENGTH_ENGINE_NAME_CHARS) return CMD_ERROR;
1019                 if (!IsUniqueEngineName(text)) return_cmd_error(STR_ERROR_NAME_MUST_BE_UNIQUE);
1020         }
1021
1022         if (flags & DC_EXEC) {
1023                 free(e->name);
1024
1025                 if (reset) {
1026                         e->name = NULL;
1027                 } else {
1028                         e->name = strdup(text);
1029                 }
1030
1031                 MarkWholeScreenDirty();
1032         }
1033
1034         return CommandCost();
1035 }
1036
1037
1038 /**
1039  * Check if an engine is buildable.
1040  * @param engine  index of the engine to check.
1041  * @param type    the type the engine should be.
1042  * @param company index of the company.
1043  * @return True if an engine is valid, of the specified type, and buildable by
1044  *              the given company.
1045  */
1046 bool IsEngineBuildable(EngineID engine, VehicleType type, CompanyID company)
1047 {
1048         const Engine *e = Engine::GetIfValid(engine);
1049
1050         /* check if it's an engine that is in the engine array */
1051         if (e == NULL) return false;
1052
1053         /* check if it's an engine of specified type */
1054         if (e->type != type) return false;
1055
1056         /* check if it's available ... */
1057         if (company == OWNER_DEITY) {
1058                 /* ... for any company (preview does not count) */
1059                 if (!(e->flags & ENGINE_AVAILABLE) || e->company_avail == 0) return false;
1060         } else {
1061                 /* ... for this company */
1062                 if (!HasBit(e->company_avail, company)) return false;
1063         }
1064
1065         if (!e->IsEnabled()) return false;
1066
1067         if (type == VEH_TRAIN && company != OWNER_DEITY) {
1068                 /* Check if the rail type is available to this company */
1069                 const Company *c = Company::Get(company);
1070                 if (((GetRailTypeInfo(e->u.rail.railtype))->compatible_railtypes & c->avail_railtypes) == 0) return false;
1071         }
1072
1073         return true;
1074 }
1075
1076 /**
1077  * Check if an engine is refittable.
1078  * Note: Likely you want to use IsArticulatedVehicleRefittable().
1079  * @param engine index of the engine to check.
1080  * @return true if the engine is refittable.
1081  */
1082 bool IsEngineRefittable(EngineID engine)
1083 {
1084         const Engine *e = Engine::GetIfValid(engine);
1085
1086         /* check if it's an engine that is in the engine array */
1087         if (e == NULL) return false;
1088
1089         if (!e->CanCarryCargo()) return false;
1090
1091         const EngineInfo *ei = &e->info;
1092         if (ei->refit_mask == 0) return false;
1093
1094         /* Are there suffixes?
1095          * Note: This does not mean the suffixes are actually available for every consist at any time. */
1096         if (HasBit(ei->callback_mask, CBM_VEHICLE_CARGO_SUFFIX)) return true;
1097
1098         /* Is there any cargo except the default cargo? */
1099         CargoID default_cargo = e->GetDefaultCargoType();
1100         return default_cargo != CT_INVALID && ei->refit_mask != 1U << default_cargo;
1101 }
1102
1103 /**
1104  * Check for engines that have an appropriate availability.
1105  */
1106 void CheckEngines()
1107 {
1108         const Engine *e;
1109         Date min_date = INT32_MAX;
1110
1111         FOR_ALL_ENGINES(e) {
1112                 if (!e->IsEnabled()) continue;
1113
1114                 /* We have an available engine... yay! */
1115                 if ((e->flags & ENGINE_AVAILABLE) != 0 && e->company_avail != 0) return;
1116
1117                 /* Okay, try to find the earliest date. */
1118                 min_date = min(min_date, e->info.base_intro);
1119         }
1120
1121         if (min_date < INT32_MAX) {
1122                 SetDParam(0, min_date);
1123                 ShowErrorMessage(STR_ERROR_NO_VEHICLES_AVAILABLE_YET, STR_ERROR_NO_VEHICLES_AVAILABLE_YET_EXPLANATION, WL_WARNING);
1124         } else {
1125                 ShowErrorMessage(STR_ERROR_NO_VEHICLES_AVAILABLE_AT_ALL, STR_ERROR_NO_VEHICLES_AVAILABLE_AT_ALL_EXPLANATION, WL_WARNING);
1126         }
1127 }