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"

    31

#include "map"

    32

    33

#include "table/strings.h"

    34

#include "table/engines.h"

    35

    36

DEFINE_OLD_POOL_GENERIC(Engine, Engine)

    37

    38

enum {

    39

	YEAR_ENGINE_AGING_STOPS = 2050,

    40

};

    41

    42

    43

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

    44

const uint8 _engine_counts[4] = {

    45

	lengthof(_orig_rail_vehicle_info),

    46

	lengthof(_orig_road_vehicle_info),

    47

	lengthof(_orig_ship_vehicle_info),

    48

	lengthof(_orig_aircraft_vehicle_info),

    49

};

    50

    51

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

    52

const uint8 _engine_offsets[4] = {

    53

	0,

    54

	lengthof(_orig_rail_vehicle_info),

    55

	lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info),

    56

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

    57

};

    58

    59

Engine::Engine() :

    60

	name(NULL),

    61

	overrides_count(0),

    62

	overrides(NULL)

    63

{

    64

}

    65

    66

Engine::Engine(VehicleType type, EngineID base)

    67

{

    68

	this->type = type;

    69

	this->internal_id = base;

    70

	this->list_position = base;

    71

    72

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

    73

	if (base >= _engine_counts[type]) {

    74

		/* Mark engine as valid anyway */

    75

		this->info.climates = 0x80;

    76

		return;

    77

	}

    78

    79

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

    80

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

    81

    82

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

    83

	switch (type) {

    84

		default: NOT_REACHED();

    85

    86

		case VEH_TRAIN:

    87

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

    88

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

    89

			this->info.string_id = STR_8000_KIRBY_PAUL_TANK_STEAM + base;

    90

			break;

    91

    92

		case VEH_ROAD:

    93

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

    94

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

    95

			this->info.string_id = STR_8074_MPS_REGAL_BUS + base;

    96

			break;

    97

    98

		case VEH_SHIP:

    99

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

   100

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

   101

			this->info.string_id = STR_80CC_MPS_OIL_TANKER + base;

   102

			break;

   103

   104

		case VEH_AIRCRAFT:

   105

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

   106

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

   107

			this->info.string_id = STR_80D7_SAMPSON_U52 + base;

   108

			break;

   109

	}

   110

}

   111

   112

Engine::~Engine()

   113

{

   114

	UnloadWagonOverrides(this);

   115

	free(this->name);

   116

}

   117

   118

/** Sort all items using qsort() and given 'CompareItems' function

   119

 * @param el list to be sorted

   120

 * @param compare function for evaluation of the quicksort

   121

 */

   122

void EngList_Sort(EngineList *el, EngList_SortTypeFunction compare)

   123

{

   124

	size_t size = el->size();

   125

	/* out-of-bounds access at the next line for size == 0 (even with operator[] at some systems)

   126

	 * generally, do not sort if there are less than 2 items */

   127

	if (size < 2) return;

   128

	qsort(&(el->at(0)), size, sizeof(EngineID), compare);

   129

}

   130

   131

/** Sort selected range of items (on indices @ <begin, begin+num_items-1>)

   132

 * @param el list to be sorted

   133

 * @param compare function for evaluation of the quicksort

   134

 * @param begin start of sorting

   135

 * @param num_items count of items to be sorted

   136

 */

   137

void EngList_SortPartial(EngineList *el, EngList_SortTypeFunction compare, uint begin, uint num_items)

   138

{

   139

	assert(begin <= (uint)el->size());

   140

	assert(begin + num_items <= (uint)el->size());

   141

	qsort(&((*el)[begin]), num_items, sizeof(EngineID), compare);

   142

}

   143

   180

void SetupEngines()

   181

{

   182

	_Engine_pool.CleanPool();

   183

	_Engine_pool.AddBlockToPool();

   184

   185

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

   186

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

   187

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

   188

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

   189

}

   190

   191

   192

void ShowEnginePreviewWindow(EngineID engine);

   193

   194

void DeleteCustomEngineNames()

   195

{

   196

	Engine *e;

   197

	FOR_ALL_ENGINES(e) {

   198

		free(e->name);

   199

		e->name = NULL;

   200

	}

   201

   202

	_vehicle_design_names &= ~1;

   203

}

   204

   205

void LoadCustomEngineNames()

   206

{

   207

	/* XXX: not done */

   208

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

   209

}

   210

   211

static void CalcEngineReliability(Engine *e)

   212

{

   213

	uint age = e->age;

   214

   215

	/* Check for early retirement */

   216

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

   217

		int retire_early = e->info.retire_early;

   218

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

   219

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

   220

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

   221

			e->player_avail = 0;

   222

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   223

		}

   224

	}

   225

   226

	if (age < e->duration_phase_1) {

   227

		uint start = e->reliability_start;

   228

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

   229

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

   230

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

   231

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

   232

		e->reliability = e->reliability_max;

   233

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

   234

		uint max = e->reliability_max;

   235

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

   236

	} else {

   237

		/* time's up for this engine.

   238

		 * We will now completely retire this design */

   239

		e->player_avail = 0;

   240

		e->reliability = e->reliability_final;

   241

		/* Kick this engine out of the lists */

   242

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   243

	}

   244

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

   245

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   246

}

   247

   248

void StartupEngines()

   249

{

   250

	Engine *e;

   251

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

   252

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

   253

   254

	FOR_ALL_ENGINES(e) {

   255

		const EngineInfo *ei = &e->info;

   256

		uint32 r;

   257

   258

		e->age = 0;

   259

		e->flags = 0;

   260

		e->player_avail = 0;

   261

   262

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

   263

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

   264

		 * added. */

   265

		r = Random();

   266

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

   267

		if (e->intro_date <= _date) {

   268

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

   269

			e->player_avail = (byte)-1;

   270

			e->flags |= ENGINE_AVAILABLE;

   271

		}

   272

   273

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

   274

		r = Random();

   275

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

   276

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

   277

   278

		r = Random();

   279

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

   280

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

   281

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

   282

   283

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

   284

   285

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

   286

		if (ei->unk2 & 0x80) {

   287

			e->age = 0xFFFF;

   288

		} else {

   289

			CalcEngineReliability(e);

   290

		}

   291

   292

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

   293

   294

		/* prevent certain engines from ever appearing. */

   295

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

   296

			e->flags |= ENGINE_AVAILABLE;

   297

			e->player_avail = 0;

   298

		}

   299

	}

   300

}

   301

   302

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   303

{

   304

	Engine *e = GetEngine(eid);

   305

	Player *p = GetPlayer(player);

   306

   307

	SetBit(e->player_avail, player);

   308

	if (e->type == VEH_TRAIN) {

   309

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   310

   311

		assert(rvi->railtype < RAILTYPE_END);

   312

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

   313

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

   314

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

   315

	}

   316

   317

	e->preview_player_rank = 0xFF;

   318

	if (player == _local_player) {

   319

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   320

	}

   321

}

   322

   323

static PlayerID GetBestPlayer(uint8 pp)

   324

{

   325

	const Player *p;

   326

	int32 best_hist;

   327

	PlayerID best_player;

   328

	uint mask = 0;

   329

   330

	do {

   331

		best_hist = -1;

   332

		best_player = PLAYER_SPECTATOR;

   333

		FOR_ALL_PLAYERS(p) {

   334

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

   335

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

   336

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

   337

				best_player = p->index;

   338

			}

   339

		}

   340

   341

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   342

   343

		SetBit(mask, best_player);

   344

	} while (--pp != 0);

   345

   346

	return best_player;

   347

}

   348

   349

void EnginesDailyLoop()

   350

{

   351

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   352

   353

	Engine *e;

   354

	FOR_ALL_ENGINES(e) {

   355

		EngineID i = e->index;

   356

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   357

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   358

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

   359

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   360

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   361

					e->preview_player_rank++;

   362

				}

   363

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

   364

				PlayerID best_player = GetBestPlayer(e->preview_player_rank);

   365

   366

				if (best_player == PLAYER_SPECTATOR) {

   367

					e->preview_player_rank = 0xFF;

   368

					continue;

   369

				}

   370

   371

				if (!IsHumanPlayer(best_player)) {

   372

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

   373

					AcceptEnginePreview(i, best_player);

   374

				} else {

   375

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   376

					e->preview_wait = 20;

   377

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

   378

				}

   379

			}

   380

		}

   381

	}

   382

}

   383

   384

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

   385

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

   386

 * @param tile unused

   387

 * @param flags operation to perfom

   388

 * @param p1 engine-prototype offered

   389

 * @param p2 unused

   390

 */

   391

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

   392

{

   393

	Engine *e;

   394

   395

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   396

	e = GetEngine(p1);

   397

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

   398

   399

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

   400

   401

	return CommandCost();

   402

}

   403

   404

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

   405

static bool IsWagon(EngineID index)

   406

{

   407

	const Engine *e = GetEngine(index);

   408

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

   409

}

   410

   411

StringID GetEngineCategoryName(EngineID engine);

   412

   413

static void NewVehicleAvailable(Engine *e)

   414

{

   415

	Vehicle *v;

   416

	Player *p;

   417

	EngineID index = e->index;

   418

   419

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

   420

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

   421

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   422

		FOR_ALL_PLAYERS(p) {

   423

			uint block_preview = p->block_preview;

   424

   425

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

   426

   427

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

   428

			p->block_preview = 20;

   429

   430

			FOR_ALL_VEHICLES(v) {

   431

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

   432

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

   433

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

   434

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

   435

						p->block_preview = block_preview;

   436

						break;

   437

					}

   438

				}

   439

			}

   440

		}

   441

	}

   442

   443

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

   444

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   445

   446

	/* Now available for all players */

   447

	e->player_avail = (byte)-1;

   448

   449

	/* Do not introduce new rail wagons */

   450

	if (IsWagon(index)) return;

   451

   452

	if (e->type == VEH_TRAIN) {

   453

		/* maybe make another rail type available */

   454

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

   455

		assert(railtype < RAILTYPE_END);

   456

		FOR_ALL_PLAYERS(p) {

   457

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

   458

		}

   459

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

   460

		/* maybe make another road type available */

   461

		FOR_ALL_PLAYERS(p) {

   462

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

   463

		}

   464

	}

   465

   466

	SetDParam(0, GetEngineCategoryName(index));

   467

	SetDParam(1, index);

   468

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

   469

}

   470

   471

void EnginesMonthlyLoop()

   472

{

   473

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   474

		Engine *e;

   475

		FOR_ALL_ENGINES(e) {

   476

			/* Age the vehicle */

   477

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

   478

				e->age++;

   479

				CalcEngineReliability(e);

   480

			}

   481

   482

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

   483

				/* Introduce it to all players */

   484

				NewVehicleAvailable(e);

   485

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

   486

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

   487

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   488

   489

				/* Do not introduce new rail wagons */