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 "ai/ai.h"

    30

#include "core/alloc_func.hpp"

    31

#include "vehicle_func.h"

    33

    34

#include "table/strings.h"

    35

#include "table/engines.h"

    36

    37

DEFINE_OLD_POOL_GENERIC(Engine, Engine)

    38

    39

enum {

    40

	YEAR_ENGINE_AGING_STOPS = 2050,

    41

};

    42

    43

    44

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

    45

const uint8 _engine_counts[4] = {

    46

	lengthof(_orig_rail_vehicle_info),

    47

	lengthof(_orig_road_vehicle_info),

    48

	lengthof(_orig_ship_vehicle_info),

    49

	lengthof(_orig_aircraft_vehicle_info),

    50

};

    51

    52

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

    53

const uint8 _engine_offsets[4] = {

    54

	0,

    55

	lengthof(_orig_rail_vehicle_info),

    56

	lengthof(_orig_rail_vehicle_info) + lengthof(_orig_road_vehicle_info),

    57

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

    58

};

    59

    60

Engine::Engine() :

    61

	name(NULL),

    62

	overrides_count(0),

    63

	overrides(NULL)

    64

{

    65

}

    66

    67

Engine::Engine(VehicleType type, EngineID base)

    68

{

    69

	this->type = type;

    70

	this->internal_id = base;

    71

	this->list_position = base;

    72

    73

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

    74

	if (base >= _engine_counts[type]) {

    75

		/* Mark engine as valid anyway */

    76

		this->info.climates = 0x80;

    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

			break;

    92

    93

		case VEH_ROAD:

    94

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

    95

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

    96

			this->info.string_id = STR_8074_MPS_REGAL_BUS + base;

    97

			break;

    98

    99

		case VEH_SHIP:

   100

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

   101

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

   102

			this->info.string_id = STR_80CC_MPS_OIL_TANKER + base;

   103

			break;

   104

   105

		case VEH_AIRCRAFT:

   106

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

   107

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

   108

			this->info.string_id = STR_80D7_SAMPSON_U52 + base;

   109

			break;

   110

	}

   111

}

   112

   113

Engine::~Engine()

   114

{

   115

	UnloadWagonOverrides(this);

   116

	free(this->name);

   117

}

   118

   119

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

   120

 */

   121

void SetCachedEngineCounts()

   122

{

   123

	uint engines = GetEnginePoolSize();

   124

   125

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

   126

	Player *p;

   127

	FOR_ALL_PLAYERS(p) {

   128

		free(p->num_engines);

   129

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

   130

	}

   131

   132

	/* Recalculate */

   133

	Group *g;

   134

	FOR_ALL_GROUPS(g) {

   135

		free(g->num_engines);

   136

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

   137

	}

   138

   139

	const Vehicle *v;

   140

	FOR_ALL_VEHICLES(v) {

   141

		if (!IsEngineCountable(v)) continue;

   142

   143

		assert(v->engine_type < engines);

   144

   145

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

   146

   147

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

   148

   149

		g = GetGroup(v->group_id);

   150

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

   151

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

   152

   153

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

   154

	}

   155

}

   156

   157

void SetupEngines()

   158

{

   159

	_Engine_pool.CleanPool();

   160

	_Engine_pool.AddBlockToPool();

   161

   162

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

   163

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

   164

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

   165

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

   166

}

   167

   168

   169

void ShowEnginePreviewWindow(EngineID engine);

   170

   171

void DeleteCustomEngineNames()

   172

{

   173

	Engine *e;

   174

	FOR_ALL_ENGINES(e) {

   175

		free(e->name);

   176

		e->name = NULL;

   177

	}

   178

   179

	_vehicle_design_names &= ~1;

   180

}

   181

   182

void LoadCustomEngineNames()

   183

{

   184

	/* XXX: not done */

   185

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

   186

}

   187

   188

static void CalcEngineReliability(Engine *e)

   189

{

   190

	uint age = e->age;

   191

   192

	/* Check for early retirement */

   193

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

   194

		int retire_early = e->info.retire_early;

   195

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

   196

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

   197

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

   198

			e->player_avail = 0;

   199

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   200

		}

   201

	}

   202

   203

	if (age < e->duration_phase_1) {

   204

		uint start = e->reliability_start;

   205

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

   206

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

   207

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

   208

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

   209

		e->reliability = e->reliability_max;

   210

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

   211

		uint max = e->reliability_max;

   212

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

   213

	} else {

   214

		/* time's up for this engine.

   215

		 * We will now completely retire this design */

   216

		e->player_avail = 0;

   217

		e->reliability = e->reliability_final;

   218

		/* Kick this engine out of the lists */

   219

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   220

	}

   221

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

   222

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   223

}

   224

   225

void StartupEngines()

   226

{

   227

	Engine *e;

   228

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

   229

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

   230

   231

	FOR_ALL_ENGINES(e) {

   232

		const EngineInfo *ei = &e->info;

   233

		uint32 r;

   234

   235

		e->age = 0;

   236

		e->flags = 0;

   237

		e->player_avail = 0;

   238

   239

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

   240

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

   241

		 * added. */

   242

		r = Random();

   243

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

   244

		if (e->intro_date <= _date) {

   245

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

   246

			e->player_avail = (byte)-1;

   247

			e->flags |= ENGINE_AVAILABLE;

   248

		}

   249

   250

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

   251

		r = Random();

   252

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

   253

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

   254

   255

		r = Random();

   256

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

   257

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

   258

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

   259

   260

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

   261

   262

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

   263

		if (ei->unk2 & 0x80) {

   264

			e->age = 0xFFFF;

   265

		} else {

   266

			CalcEngineReliability(e);

   267

		}

   268

   269

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

   270

   271

		/* prevent certain engines from ever appearing. */

   272

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

   273

			e->flags |= ENGINE_AVAILABLE;

   274

			e->player_avail = 0;

   275

		}

   276

	}

   277

}

   278

   279

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   280

{

   281

	Engine *e = GetEngine(eid);

   282

	Player *p = GetPlayer(player);

   283

   284

	SetBit(e->player_avail, player);

   285

	if (e->type == VEH_TRAIN) {

   286

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   287

   288

		assert(rvi->railtype < RAILTYPE_END);

   289

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

   290

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

   291

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

   292

	}

   293

   294

	e->preview_player_rank = 0xFF;

   295

	if (player == _local_player) {

   296

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   297

	}

   298

}

   299

   300

static PlayerID GetBestPlayer(uint8 pp)

   301

{

   302

	const Player *p;

   303

	int32 best_hist;

   304

	PlayerID best_player;

   305

	uint mask = 0;

   306

   307

	do {

   308

		best_hist = -1;

   309

		best_player = PLAYER_SPECTATOR;

   310

		FOR_ALL_PLAYERS(p) {

   311

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

   312

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

   313

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

   314

				best_player = p->index;

   315

			}

   316

		}

   317

   318

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   319

   320

		SetBit(mask, best_player);

   321

	} while (--pp != 0);

   322

   323

	return best_player;

   324

}

   325

   326

void EnginesDailyLoop()

   327

{

   328

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   329

   330

	Engine *e;

   331

	FOR_ALL_ENGINES(e) {

   332

		EngineID i = e->index;

   333

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   334

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   335

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

   336

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   337

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   338

					e->preview_player_rank++;

   339

				}

   340

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

   341

				PlayerID best_player = GetBestPlayer(e->preview_player_rank);

   342

   343

				if (best_player == PLAYER_SPECTATOR) {

   344

					e->preview_player_rank = 0xFF;

   345

					continue;

   346

				}

   347

   348

				e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   349

				e->preview_wait = 20;

   350

				AI_Event(best_player, new AIEventEnginePreview(i));

   351

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

   352

			}

   353

		}

   354

	}

   355

}

   356

   357

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

   358

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

   359

 * @param tile unused

   360

 * @param flags operation to perfom

   361

 * @param p1 engine-prototype offered

   362

 * @param p2 unused

   363

 */

   364

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

   365

{

   366

	Engine *e;

   367

   368

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   369

	e = GetEngine(p1);

   370

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

   371

   372

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

   373

   374

	return CommandCost();

   375

}

   376

   377

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

   378

static bool IsWagon(EngineID index)

   379

{

   380

	const Engine *e = GetEngine(index);

   381

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

   382

}

   383

   384

StringID GetEngineCategoryName(EngineID engine);

   385

   386

static void NewVehicleAvailable(Engine *e)

   387

{

   388

	Vehicle *v;

   389

	Player *p;

   390

	EngineID index = e->index;

   391

   392

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

   393

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

   394

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   395

		FOR_ALL_PLAYERS(p) {

   396

			uint block_preview = p->block_preview;

   397

   398

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

   399

   400

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

   401

			p->block_preview = 20;

   402

   403

			FOR_ALL_VEHICLES(v) {

   404

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

   405

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

   406

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

   407

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

   408

						p->block_preview = block_preview;

   409

						break;

   410

					}

   411

				}

   412

			}

   413

		}

   414

	}

   415

   416

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

   417

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   418

   419

	/* Now available for all players */

   420

	e->player_avail = (byte)-1;

   421

   422

	/* Do not introduce new rail wagons */

   423

	if (IsWagon(index)) return;

   424

   425

	if (e->type == VEH_TRAIN) {

   426

		/* maybe make another rail type available */

   427

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

   428

		assert(railtype < RAILTYPE_END);

   429

		FOR_ALL_PLAYERS(p) {

   430

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

   431

		}

   432

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

   433

		/* maybe make another road type available */

   434

		FOR_ALL_PLAYERS(p) {

   435

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

   436

		}

   437

	}

   438

   439

	SetDParam(0, GetEngineCategoryName(index));

   440

	SetDParam(1, index);

   441

	AddNewsItem(STR_NEW_VEHICLE_NOW_AVAILABLE_WITH_TYPE, NS_NEW_VEHICLES, index, 0);

   442

}

   443

   444

void EnginesMonthlyLoop()

   445

{

   446

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   447

		Engine *e;

   448

		FOR_ALL_ENGINES(e) {

   449

			/* Age the vehicle */

   450

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

   451

				e->age++;

   452

				CalcEngineReliability(e);

   453

			}

   454

   455

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

   456

				/* Introduce it to all players */

   457

				NewVehicleAvailable(e);

   458

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

   459

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

   460

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   461

   462

				/* Do not introduce new rail wagons */

   463

				if (!IsWagon(e->index))

   464

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

   465

			}

   466

		}

   467

	}

   468

}

   469

   470

static bool IsUniqueEngineName(const char *name)

   471

{

   472

	char buf[512];

   473

   474

	const Engine *e;

   475

	FOR_ALL_ENGINES(e) {

   476

		SetDParam(0, e->index);

   477

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

   478

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

   479

	}

   480

   481

	return true;

   482

}

   483

   484

/** Rename an engine.

   485

 * @param tile unused

   486

 * @param flags operation to perfom

   487

 * @param p1 engine ID to rename

   488

 * @param p2 unused

   489

 */