1

/* $Id$ */

     2

     3

/** @file engine.cpp Base for all engine handling. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "company_base.h"

     9

#include "company_func.h"

    10

#include "command_func.h"

    11

#include "news_func.h"

    12

#include "saveload.h"

    13

#include "variables.h"

    14

#include "train.h"

    15

#include "aircraft.h"

    16

#include "newgrf_cargo.h"

    17

#include "newgrf_engine.h"

    18

#include "group.h"

    19

#include "strings_func.h"

    20

#include "gfx_func.h"

    21

#include "functions.h"

    22

#include "window_func.h"

    23

#include "date_func.h"

    24

#include "autoreplace_gui.h"

    25

#include "string_func.h"

    26

#include "settings_type.h"

    27

#include "oldpool_func.h"

    28

#include "core/alloc_func.hpp"

    29

#include "vehicle_func.h"

    30

#include <map>

    31

    32

#include "table/strings.h"

    33

#include "table/engines.h"

    34

    35

DEFINE_OLD_POOL_GENERIC(Engine, Engine)

    36

    37

enum {

    38

	YEAR_ENGINE_AGING_STOPS = 2050,

    39

};

    40

    41

    42

/** Number of engines of each vehicle type in original engine data */

    43

const uint8 _engine_counts[4] = {

    44

	lengthof(_orig_rail_vehicle_info),

    45

	lengthof(_orig_road_vehicle_info),

    46

	lengthof(_orig_ship_vehicle_info),

    47

	lengthof(_orig_aircraft_vehicle_info),

    48

};

    49

    50

/** Offset of the first engine of each vehicle type in original engine data */

    51

const uint8 _engine_offsets[4] = {

    52

	0,

    53

	lengthof(_orig_rail_vehicle_info),

    54

	lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info),

    55

	lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info) + lengthof(_orig_ship_vehicle_info),

    56

};

    57

    58

Engine::Engine() :

    59

	name(NULL),

    60

	overrides_count(0),

    61

	overrides(NULL)

    62

{

    63

}

    64

    65

Engine::Engine(VehicleType type, EngineID base)

    66

{

    67

	this->type = type;

    68

	this->internal_id = base;

    69

	this->list_position = base;

    70

    71

	/* Check if this base engine is within the original engine data range */

    72

	if (base >= _engine_counts[type]) {

    73

		/* Mark engine as valid anyway */

    74

		this->info.climates = 0x80;

    75

		/* Set model life to maximum to make wagons available */

    76

		this->info.base_life = 0xFF;

    77

		return;

    78

	}

    79

    80

	/* Copy the original engine info for this slot */

    81

	this->info = _orig_engine_info[_engine_offsets[type] + base];

    82

    83

	/* Copy the original engine data for this slot */

    84

	switch (type) {

    85

		default: NOT_REACHED();

    86

    87

		case VEH_TRAIN:

    88

			this->u.rail = _orig_rail_vehicle_info[base];

    89

			this->image_index = this->u.rail.image_index;

    90

			this->info.string_id = STR_8000_KIRBY_PAUL_TANK_STEAM + base;

    91

    92

			/* Set the default model life of original wagons to "infinite" */

    93

			if (this->u.rail.railveh_type == RAILVEH_WAGON) this->info.base_life = 0xFF;

    94

    95

			break;

    96

    97

		case VEH_ROAD:

    98

			this->u.road = _orig_road_vehicle_info[base];

    99

			this->image_index = this->u.road.image_index;

   100

			this->info.string_id = STR_8074_MPS_REGAL_BUS + base;

   101

			break;

   102

   103

		case VEH_SHIP:

   104

			this->u.ship = _orig_ship_vehicle_info[base];

   105

			this->image_index = this->u.ship.image_index;

   106

			this->info.string_id = STR_80CC_MPS_OIL_TANKER + base;

   107

			break;

   108

   109

		case VEH_AIRCRAFT:

   110

			this->u.air = _orig_aircraft_vehicle_info[base];

   111

			this->image_index = this->u.air.image_index;

   112

			this->info.string_id = STR_80D7_SAMPSON_U52 + base;

   113

			break;

   114

	}

   115

}

   116

   117

Engine::~Engine()

   118

{

   119

	UnloadWagonOverrides(this);

   120

	free(this->name);

   121

}

   122

   123

/** Sets cached values in Company::num_vehicles and Group::num_vehicles

   124

 */

   125

void SetCachedEngineCounts()

   126

{

   127

	uint engines = GetEnginePoolSize();

   128

   129

	/* Set up the engine count for all companies */

   130

	Company *c;

   131

	FOR_ALL_COMPANIES(c) {

   132

		free(c->num_engines);

   133

		c->num_engines = CallocT<EngineID>(engines);

   134

	}

   135

   136

	/* Recalculate */

   137

	Group *g;

   138

	FOR_ALL_GROUPS(g) {

   139

		free(g->num_engines);

   140

		g->num_engines = CallocT<EngineID>(engines);

   141

	}

   142

   143

	const Vehicle *v;

   144

	FOR_ALL_VEHICLES(v) {

   145

		if (!IsEngineCountable(v)) continue;

   146

   147

		assert(v->engine_type < engines);

   148

   149

		GetCompany(v->owner)->num_engines[v->engine_type]++;

   150

   151

		if (v->group_id == DEFAULT_GROUP) continue;

   152

   153

		g = GetGroup(v->group_id);

   154

		assert(v->type == g->vehicle_type);

   155

		assert(v->owner == g->owner);

   156

   157

		g->num_engines[v->engine_type]++;

   158

	}

   159

}

   160

   161

void SetupEngines()

   162

{

   163

	_Engine_pool.CleanPool();

   164

	_Engine_pool.AddBlockToPool();

   165

   166

	for (uint i = 0; i < lengthof(_orig_rail_vehicle_info); i++) new Engine(VEH_TRAIN, i);

   167

	for (uint i = 0; i < lengthof(_orig_road_vehicle_info); i++) new Engine(VEH_ROAD, i);

   168

	for (uint i = 0; i < lengthof(_orig_ship_vehicle_info); i++) new Engine(VEH_SHIP, i);

   169

	for (uint i = 0; i < lengthof(_orig_aircraft_vehicle_info); i++) new Engine(VEH_AIRCRAFT, i);

   170

}

   171

   172

   173

void ShowEnginePreviewWindow(EngineID engine);

   174

   175

void DeleteCustomEngineNames()

   176

{

   177

	Engine *e;

   178

	FOR_ALL_ENGINES(e) {

   179

		free(e->name);

   180

		e->name = NULL;

   181

	}

   182

   183

	_vehicle_design_names &= ~1;

   184

}

   185

   186

void LoadCustomEngineNames()

   187

{

   188

	/* XXX: not done */

   189

	DEBUG(misc, 1, "LoadCustomEngineNames: not done");

   190

}

   191

   192

/* Determine if an engine type is a wagon (and not a loco) */

   193

static bool IsWagon(EngineID index)

   194

{

   195

	const Engine *e = GetEngine(index);

   196

	return e->type == VEH_TRAIN && e->u.rail.railveh_type == RAILVEH_WAGON;

   197

}

   198

   199

static void CalcEngineReliability(Engine *e)

   200

{

   201

	uint age = e->age;

   202

   203

	/* Check for early retirement */

   204

	if (e->company_avail != 0 && !_settings_game.vehicle.never_expire_vehicles && e->info.base_life != 0xFF) {

   205

		int retire_early = e->info.retire_early;

   206

		uint retire_early_max_age = max(0, e->duration_phase_1 + e->duration_phase_2 - retire_early * 12);

   207

		if (retire_early != 0 && age >= retire_early_max_age) {

   208

			/* Early retirement is enabled and we're past the date... */

   209

			e->company_avail = 0;

   210

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   211

		}

   212

	}

   213

   214

	if (age < e->duration_phase_1) {

   215

		uint start = e->reliability_start;

   216

		e->reliability = age * (e->reliability_max - start) / e->duration_phase_1 + start;

   217

	} else if ((age -= e->duration_phase_1) < e->duration_phase_2 || _settings_game.vehicle.never_expire_vehicles || e->info.base_life == 0xFF) {

   218

		/* We are at the peak of this engines life. It will have max reliability.

   219

		 * This is also true if the engines never expire. They will not go bad over time */

   220

		e->reliability = e->reliability_max;

   221

	} else if ((age -= e->duration_phase_2) < e->duration_phase_3) {

   222

		uint max = e->reliability_max;

   223

		e->reliability = (int)age * (int)(e->reliability_final - max) / e->duration_phase_3 + max;

   224

	} else {

   225

		/* time's up for this engine.

   226

		 * We will now completely retire this design */

   227

		e->company_avail = 0;

   228

		e->reliability = e->reliability_final;

   229

		/* Kick this engine out of the lists */

   230

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   231

	}

   232

	InvalidateWindowClasses(WC_BUILD_VEHICLE); // Update to show the new reliability

   233

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   234

}

   235

   236

void StartupEngines()

   237

{

   238

	Engine *e;

   239

	/* Aging of vehicles stops, so account for that when starting late */

   240

	const Date aging_date = min(_date, ConvertYMDToDate(YEAR_ENGINE_AGING_STOPS, 0, 1));

   241

   242

	FOR_ALL_ENGINES(e) {

   243

		const EngineInfo *ei = &e->info;

   244

		uint32 r;

   245

   246

		e->age = 0;

   247

		e->flags = 0;

   248

		e->company_avail = 0;

   249

   250

		/* The magic value of 729 days below comes from the NewGRF spec. If the

   251

		 * base intro date is before 1922 then the random number of days is not

   252

		 * added. */

   253

		r = Random();

   254

		e->intro_date = ei->base_intro <= ConvertYMDToDate(1922, 0, 1) ? ei->base_intro : (Date)GB(r, 0, 9) + ei->base_intro;

   255

		if (e->intro_date <= _date) {

   256

			e->age = (aging_date - e->intro_date) >> 5;

   257

			e->company_avail = (CompanyMask)-1;

   258

			e->flags |= ENGINE_AVAILABLE;

   259

		}

   260

   261

		e->reliability_start = GB(r, 16, 14) + 0x7AE0;

   262

		r = Random();

   263

		e->reliability_max   = GB(r,  0, 14) + 0xBFFF;

   264

		e->reliability_final = GB(r, 16, 14) + 0x3FFF;

   265

   266

		r = Random();

   267

		e->duration_phase_1 = GB(r, 0, 5) + 7;

   268

		e->duration_phase_2 = GB(r, 5, 4) + ei->base_life * 12 - 96;

   269

		e->duration_phase_3 = GB(r, 9, 7) + 120;

   270

   271

		e->reliability_spd_dec = ei->decay_speed << 2;

   272

   273

		CalcEngineReliability(e);

   274

   275

		e->lifelength = ei->lifelength + _settings_game.vehicle.extend_vehicle_life;

   276

   277

		/* prevent certain engines from ever appearing. */

   278

		if (!HasBit(ei->climates, _settings_game.game_creation.landscape)) {

   279

			e->flags |= ENGINE_AVAILABLE;

   280

			e->company_avail = 0;

   281

		}

   282

	}

   283

   284

	/* Update the bitmasks for the vehicle lists */

   285

	Company *c;

   286

	FOR_ALL_COMPANIES(c) {

   287

		c->avail_railtypes = GetCompanyRailtypes(c->index);

   288

		c->avail_roadtypes = GetCompanyRoadtypes(c->index);

   289

	}

   290

}

   291

   292

static void AcceptEnginePreview(EngineID eid, CompanyID company)

   293

{

   294

	Engine *e = GetEngine(eid);

   295

	Company *c = GetCompany(company);

   296

   297

	SetBit(e->company_avail, company);

   298

	if (e->type == VEH_TRAIN) {

   299

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   300

   301

		assert(rvi->railtype < RAILTYPE_END);

   302

		SetBit(c->avail_railtypes, rvi->railtype);

   303

	} else if (e->type == VEH_ROAD) {

   304

		SetBit(c->avail_roadtypes, HasBit(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);

   305

	}

   306

   307

	e->preview_company_rank = 0xFF;

   308

	if (company == _local_company) {

   309

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   310

	}

   311

}

   312

   313

static CompanyID GetBestCompany(uint8 pp)

   314

{

   315

	const Company *c;

   316

	int32 best_hist;

   317

	CompanyID best_company;

   318

	uint mask = 0;

   319

   320

	do {

   321

		best_hist = -1;

   322

		best_company = INVALID_COMPANY;

   323

		FOR_ALL_COMPANIES(c) {

   324

			if (c->block_preview == 0 && !HasBit(mask, c->index) &&

   325

					c->old_economy[0].performance_history > best_hist) {

   326

				best_hist = c->old_economy[0].performance_history;

   327

				best_company = c->index;

   328

			}

   329

		}

   330

   331

		if (best_company == INVALID_COMPANY) return INVALID_COMPANY;

   332

   333

		SetBit(mask, best_company);

   334

	} while (--pp != 0);

   335

   336

	return best_company;

   337

}

   338

   339

void EnginesDailyLoop()

   340

{

   341

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   342

   343

	Engine *e;

   344

	FOR_ALL_ENGINES(e) {

   345

		EngineID i = e->index;

   346

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   347

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   348

				if (e->preview_company_rank != 0xFF && !--e->preview_wait) {

   349

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   350

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   351

					e->preview_company_rank++;

   352

				}

   353

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

   354

				CompanyID best_company = GetBestCompany(e->preview_company_rank);

   355

   356

				if (best_company == INVALID_COMPANY) {

   357

					e->preview_company_rank = 0xFF;

   358

					continue;

   359

				}

   360

   361

				if (!IsHumanCompany(best_company)) {

   362

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

   363

					AcceptEnginePreview(i, best_company);

   364

				} else {

   365

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   366

					e->preview_wait = 20;

   367

					if (IsInteractiveCompany(best_company)) ShowEnginePreviewWindow(i);

   368

				}

   369

			}

   370

		}

   371

	}

   372

}

   373

   374

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

   375

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

   376

 * @param tile unused

   377

 * @param flags operation to perfom

   378

 * @param p1 engine-prototype offered

   379

 * @param p2 unused

   380

 */

   381

CommandCost CmdWantEnginePreview(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)

   382

{

   383

	Engine *e;

   384

   385

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   386

	e = GetEngine(p1);

   387

	if (GetBestCompany(e->preview_company_rank) != _current_company) return CMD_ERROR;

   388

   389

	if (flags & DC_EXEC) AcceptEnginePreview(p1, _current_company);

   390

   391

	return CommandCost();

   392

}

   393

   394

StringID GetEngineCategoryName(EngineID engine);

   395

   396

static void NewVehicleAvailable(Engine *e)

   397

{

   398

	Vehicle *v;

   399

	Company *c;

   400

	EngineID index = e->index;

   401

   402

	/* In case the company didn't build the vehicle during the intro period,

   403

	 * prevent that company from getting future intro periods for a while. */

   404

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   405

		FOR_ALL_COMPANIES(c) {

   406

			uint block_preview = c->block_preview;

   407

   408

			if (!HasBit(e->company_avail, c->index)) continue;

   409

   410

			/* We assume the user did NOT build it.. prove me wrong ;) */

   411

			c->block_preview = 20;

   412

   413

			FOR_ALL_VEHICLES(v) {

   414

				if (v->type == VEH_TRAIN || v->type == VEH_ROAD || v->type == VEH_SHIP ||

   415

						(v->type == VEH_AIRCRAFT && IsNormalAircraft(v))) {

   416

					if (v->owner == c->index && v->engine_type == index) {

   417

						/* The user did prove me wrong, so restore old value */

   418

						c->block_preview = block_preview;

   419

						break;

   420

					}

   421

				}

   422

			}

   423

		}

   424

	}

   425

   426

	e->flags = (e->flags & ~ENGINE_EXCLUSIVE_PREVIEW) | ENGINE_AVAILABLE;

   427

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   428

   429

	/* Now available for all companies */

   430

	e->company_avail = (CompanyMask)-1;

   431

   432

	/* Do not introduce new rail wagons */

   433

	if (IsWagon(index)) return;

   434

   435

	if (e->type == VEH_TRAIN) {

   436

		/* maybe make another rail type available */

   437

		RailType railtype = e->u.rail.railtype;

   438

		assert(railtype < RAILTYPE_END);

   439

		FOR_ALL_COMPANIES(c) SetBit(c->avail_railtypes, railtype);

   440

	} else if (e->type == VEH_ROAD) {

   441

		/* maybe make another road type available */

   442

		FOR_ALL_COMPANIES(c) SetBit(c->avail_roadtypes, HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);

   443

	}

   444

   445

	SetDParam(0, GetEngineCategoryName(index));

   446

	SetDParam(1, index);

   447

	AddNewsItem(STR_NEW_VEHICLE_NOW_AVAILABLE_WITH_TYPE, NS_NEW_VEHICLES, index, 0);

   448

}

   449

   450

void EnginesMonthlyLoop()

   451

{

   452

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   453

		Engine *e;

   454

		FOR_ALL_ENGINES(e) {

   455

			/* Age the vehicle */

   456

			if (e->flags & ENGINE_AVAILABLE && e->age != 0xFFFF) {

   457

				e->age++;

   458

				CalcEngineReliability(e);

   459

			}

   460

   461

			if (!(e->flags & ENGINE_AVAILABLE) && _date >= (e->intro_date + 365)) {

   462

				/* Introduce it to all companies */

   463

				NewVehicleAvailable(e);

   464

			} else if (!(e->flags & (ENGINE_AVAILABLE|ENGINE_EXCLUSIVE_PREVIEW)) && _date >= e->intro_date) {

   465

				/* Introduction date has passed.. show introducing dialog to one companies. */

   466

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   467

   468

				/* Do not introduce new rail wagons */

   469

				if (!IsWagon(e->index))

   470

					e->preview_company_rank = 1; // Give to the company with the highest rating.

   471

			}

   472

		}

   473

	}

   474

}

   475

   476

static bool IsUniqueEngineName(const char *name)

   477

{

   478

	char buf[512];

   479

   480

	const Engine *e;

   481

	FOR_ALL_ENGINES(e) {

   482

		SetDParam(0, e->index);

   483

		GetString(buf, STR_ENGINE_NAME, lastof(buf));

   484

		if (strcmp(buf, name) == 0) return false;

   485

	}

   486