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 "player_base.h"

     9

#include "player_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_base.h"

    25

#include "autoreplace_gui.h"

    26

#include "string_func.h"

    27

#include "settings_type.h"

    28

#include "oldpool_func.h"

    29

#include "core/alloc_func.hpp"

    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

		return;

    76

	}

    77

    78

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

    79

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

    80

    81

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

    82

	switch (type) {

    83

		default: NOT_REACHED();

    84

    85

		case VEH_TRAIN:

    86

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

    87

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

    88

			this->info.string_id = STR_8000_KIRBY_PAUL_TANK_STEAM + base;

    89

			break;

    90

    91

		case VEH_ROAD:

    92

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

    93

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

    94

			this->info.string_id = STR_8074_MPS_REGAL_BUS + base;

    95

			break;

    96

    97

		case VEH_SHIP:

    98

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

    99

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

   100

			this->info.string_id = STR_80CC_MPS_OIL_TANKER + base;

   101

			break;

   102

   103

		case VEH_AIRCRAFT:

   104

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

   105

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

   106

			this->info.string_id = STR_80D7_SAMPSON_U52 + base;

   107

			break;

   108

	}

   109

}

   110

   111

Engine::~Engine()

   112

{

   113

	UnloadWagonOverrides(this);

   114

	free(this->name);

   115

}

   116

   117

void SetupEngines()

   118

{

   119

	_Engine_pool.CleanPool();

   120

	_Engine_pool.AddBlockToPool();

   121

   122

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

   123

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

   124

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

   125

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

   126

}

   127

   128

   129

void ShowEnginePreviewWindow(EngineID engine);

   130

   131

void DeleteCustomEngineNames()

   132

{

   133

	Engine *e;

   134

	FOR_ALL_ENGINES(e) {

   135

		free(e->name);

   136

		e->name = NULL;

   137

	}

   138

   139

	_vehicle_design_names &= ~1;

   140

}

   141

   142

void LoadCustomEngineNames()

   143

{

   144

	/* XXX: not done */

   145

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

   146

}

   147

   148

static void CalcEngineReliability(Engine *e)

   149

{

   150

	uint age = e->age;

   151

   152

	/* Check for early retirement */

   153

	if (e->player_avail != 0 && !_patches.never_expire_vehicles) {

   154

		int retire_early = e->info.retire_early;

   155

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

   156

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

   157

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

   158

			e->player_avail = 0;

   159

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   160

		}

   161

	}

   162

   163

	if (age < e->duration_phase_1) {

   164

		uint start = e->reliability_start;

   165

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

   166

	} else if ((age -= e->duration_phase_1) < e->duration_phase_2 || _patches.never_expire_vehicles) {

   167

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

   168

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

   169

		e->reliability = e->reliability_max;

   170

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

   171

		uint max = e->reliability_max;

   172

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

   173

	} else {

   174

		/* time's up for this engine.

   175

		 * We will now completely retire this design */

   176

		e->player_avail = 0;

   177

		e->reliability = e->reliability_final;

   178

		/* Kick this engine out of the lists */

   179

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   180

	}

   181

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

   182

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   183

}

   184

   185

void StartupEngines()

   186

{

   187

	Engine *e;

   188

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

   189

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

   190

   191

	FOR_ALL_ENGINES(e) {

   192

		const EngineInfo *ei = &e->info;

   193

		uint32 r;

   194

   195

		e->age = 0;

   196

		e->flags = 0;

   197

		e->player_avail = 0;

   198

   199

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

   200

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

   201

		 * added. */

   202

		r = Random();

   203

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

   204

		if (e->intro_date <= _date) {

   205

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

   206

			e->player_avail = (byte)-1;

   207

			e->flags |= ENGINE_AVAILABLE;

   208

		}

   209

   210

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

   211

		r = Random();

   212

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

   213

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

   214

   215

		r = Random();

   216

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

   217

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

   218

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

   219

   220

		e->reliability_spd_dec = (ei->unk2&0x7F) << 2;

   221

   222

		/* my invented flag for something that is a wagon */

   223

		if (ei->unk2 & 0x80) {

   224

			e->age = 0xFFFF;

   225

		} else {

   226

			CalcEngineReliability(e);

   227

		}

   228

   229

		e->lifelength = ei->lifelength + _patches.extend_vehicle_life;

   230

   231

		/* prevent certain engines from ever appearing. */

   232

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

   233

			e->flags |= ENGINE_AVAILABLE;

   234

			e->player_avail = 0;

   235

		}

   236

	}

   237

}

   238

   239

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   240

{

   241

	Engine *e = GetEngine(eid);

   242

	Player *p = GetPlayer(player);

   243

   244

	SetBit(e->player_avail, player);

   245

	if (e->type == VEH_TRAIN) {

   246

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   247

   248

		assert(rvi->railtype < RAILTYPE_END);

   249

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

   250

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

   251

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

   252

	}

   253

   254

	e->preview_player_rank = 0xFF;

   255

	if (player == _local_player) {

   256

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   257

	}

   258

}

   259

   260

static PlayerID GetBestPlayer(uint8 pp)

   261

{

   262

	const Player *p;

   263

	int32 best_hist;

   264

	PlayerID best_player;

   265

	uint mask = 0;

   266

   267

	do {

   268

		best_hist = -1;

   269

		best_player = PLAYER_SPECTATOR;

   270

		FOR_ALL_PLAYERS(p) {

   271

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

   272

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

   273

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

   274

				best_player = p->index;

   275

			}

   276

		}

   277

   278

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   279

   280

		SetBit(mask, best_player);

   281

	} while (--pp != 0);

   282

   283

	return best_player;

   284

}

   285

   286

void EnginesDailyLoop()

   287

{

   288

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   289

   290

	Engine *e;

   291

	FOR_ALL_ENGINES(e) {

   292

		EngineID i = e->index;

   293

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   294

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   295

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

   296

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   297

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   298

					e->preview_player_rank++;

   299

				}

   300

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

   301

				PlayerID best_player = GetBestPlayer(e->preview_player_rank);

   302

   303

				if (best_player == PLAYER_SPECTATOR) {

   304

					e->preview_player_rank = 0xFF;

   305

					continue;

   306

				}

   307

   308

				if (!IsHumanPlayer(best_player)) {

   309

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

   310

					AcceptEnginePreview(i, best_player);

   311

				} else {

   312

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   313

					e->preview_wait = 20;

   314

					if (IsInteractivePlayer(best_player)) ShowEnginePreviewWindow(i);

   315

				}

   316

			}

   317

		}

   318

	}

   319

}

   320

   321

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

   322

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

   323

 * @param tile unused

   324

 * @param flags operation to perfom

   325

 * @param p1 engine-prototype offered

   326

 * @param p2 unused

   327

 */

   328

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

   329

{

   330

	Engine *e;

   331

   332

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   333

	e = GetEngine(p1);

   334

	if (GetBestPlayer(e->preview_player_rank) != _current_player) return CMD_ERROR;

   335

   336

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

   337

   338

	return CommandCost();

   339

}

   340

   341

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

   342

static bool IsWagon(EngineID index)

   343

{

   344

	const Engine *e = GetEngine(index);

   345

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

   346

}

   347

   348

static void NewVehicleAvailable(Engine *e)

   349

{

   350

	Vehicle *v;

   351

	Player *p;

   352

	EngineID index = e->index;

   353

   354

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

   355

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

   356

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   357

		FOR_ALL_PLAYERS(p) {

   358

			uint block_preview = p->block_preview;

   359

   360

			if (!HasBit(e->player_avail, p->index)) continue;

   361

   362

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

   363

			p->block_preview = 20;

   364

   365

			FOR_ALL_VEHICLES(v) {

   366

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

   367

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

   368

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

   369

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

   370

						p->block_preview = block_preview;

   371

						break;

   372

					}

   373

				}

   374

			}

   375

		}

   376

	}

   377

   378

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

   379

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   380

   381

	/* Now available for all players */

   382

	e->player_avail = (byte)-1;

   383

   384

	/* Do not introduce new rail wagons */

   385

	if (IsWagon(index)) return;

   386

   387

	if (e->type == VEH_TRAIN) {

   388

		/* maybe make another rail type available */

   389

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

   390

		assert(railtype < RAILTYPE_END);

   391

		FOR_ALL_PLAYERS(p) {

   392

			if (p->is_active) SetBit(p->avail_railtypes, railtype);

   393

		}

   394

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

   395

		/* maybe make another road type available */

   396

		FOR_ALL_PLAYERS(p) {

   397

			if (p->is_active) SetBit(p->avail_roadtypes, HasBit(e->info.misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);

   398

		}

   399

	}

   400

	AddNewsItem(index, NM_CALLBACK, NF_NONE, NT_NEW_VEHICLES, DNC_VEHICLEAVAIL, 0, 0);

   401

}

   402

   403

void EnginesMonthlyLoop()

   404

{

   405

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   406

		Engine *e;

   407

		FOR_ALL_ENGINES(e) {

   408

			/* Age the vehicle */

   409

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

   410

				e->age++;

   411

				CalcEngineReliability(e);

   412

			}

   413

   414

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

   415

				/* Introduce it to all players */

   416

				NewVehicleAvailable(e);

   417

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

   418

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

   419

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   420

   421

				/* Do not introduce new rail wagons */

   422

				if (!IsWagon(e->index))

   423

					e->preview_player_rank = 1; // Give to the player with the highest rating.

   424

			}

   425

		}

   426

	}

   427

}

   428

   429

static bool IsUniqueEngineName(const char *name)

   430

{

   431

	char buf[512];

   432

   433

	const Engine *e;

   434

	FOR_ALL_ENGINES(e) {

   435

		SetDParam(0, e->index);

   436

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

   437

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

   438

	}

   439

   440

	return true;

   441

}

   442

   443

/** Rename an engine.

   444

 * @param tile unused

   445

 * @param flags operation to perfom

   446

 * @param p1 engine ID to rename

   447

 * @param p2 unused

   448

 */

   449

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

   450

{

   451

	if (!IsEngineIndex(p1) || StrEmpty(_cmd_text)) return CMD_ERROR;

   452

   453

	if (!IsUniqueEngineName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);

   454

   455

	if (flags & DC_EXEC) {

   456

		Engine *e = GetEngine(p1);

   457

		free(e->name);

   458

		e->name = strdup(_cmd_text);

   459

		_vehicle_design_names |= 3;

   460

		MarkWholeScreenDirty();

   461

	}

   462

   463

	return CommandCost();

   464

}

   465

   466

   467

/** Check if an engine is buildable.

   468

 * @param engine index of the engine to check.

   469

 * @param type   the type the engine should be.

   470

 * @param player index of the player.

   471

 * @return True if an engine is valid, of the specified type, and buildable by

   472

 *              the given player.

   473

 */

   474

bool IsEngineBuildable(EngineID engine, VehicleType type, PlayerID player)

   475

{

   476

	/* check if it's an engine that is in the engine array */

   477

	if (!IsEngineIndex(engine)) return false;

   478

   479

	const Engine *e = GetEngine(engine);

   480

   481

	/* check if it's an engine of specified type */

   482

	if (e->type != type) return false;

   483

   484

	/* check if it's available */

   485

	if (!HasBit(e->player_avail, player)) return false;

   486

   487

	if (type == VEH_TRAIN) {

   488

		/* Check if the rail type is available to this player */