1

/* $Id$ */

     2

     3

/** @file engine.cpp */

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

    18

#include "misc/autoptr.hpp"

    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

    30

#include "table/strings.h"

    31

#include "table/engines.h"

    32

    33

Engine _engines[TOTAL_NUM_ENGINES];

    34

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    35

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    36

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    37

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    38

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    39

    40

enum {

    41

	YEAR_ENGINE_AGING_STOPS = 2050,

    42

};

    43

    44

    45

void SetupEngines()

    46

{

    47

	/* Copy original static engine data */

    48

	memcpy(&_engine_info, &_orig_engine_info, sizeof(_orig_engine_info));

    49

	memcpy(&_rail_vehicle_info, &_orig_rail_vehicle_info, sizeof(_orig_rail_vehicle_info));

    50

	memcpy(&_ship_vehicle_info, &_orig_ship_vehicle_info, sizeof(_orig_ship_vehicle_info));

    51

	memcpy(&_aircraft_vehicle_info, &_orig_aircraft_vehicle_info, sizeof(_orig_aircraft_vehicle_info));

    52

	memcpy(&_road_vehicle_info, &_orig_road_vehicle_info, sizeof(_orig_road_vehicle_info));

    53

    54

	/* Add type to engines */

    55

	Engine* e = _engines;

    56

	do e->type = VEH_TRAIN;    while (++e < &_engines[ROAD_ENGINES_INDEX]);

    57

	do e->type = VEH_ROAD;     while (++e < &_engines[SHIP_ENGINES_INDEX]);

    58

	do e->type = VEH_SHIP;     while (++e < &_engines[AIRCRAFT_ENGINES_INDEX]);

    59

	do e->type = VEH_AIRCRAFT; while (++e < &_engines[TOTAL_NUM_ENGINES]);

    60

    61

	/* Set up default engine names */

    62

	for (EngineID engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {

    63

		EngineInfo *ei = &_engine_info[engine];

    64

		ei->string_id = STR_8000_KIRBY_PAUL_TANK_STEAM + engine;

    65

	}

    66

}

    67

    68

    69

void ShowEnginePreviewWindow(EngineID engine);

    70

    71

void DeleteCustomEngineNames()

    72

{

    73

	Engine *e;

    74

	FOR_ALL_ENGINES(e) {

    75

		free(e->name);

    76

		e->name = NULL;

    77

	}

    78

    79

	_vehicle_design_names &= ~1;

    80

}

    81

    82

void LoadCustomEngineNames()

    83

{

    84

	/* XXX: not done */

    85

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

    86

}

    87

    88

static void CalcEngineReliability(Engine *e)

    89

{

    90

	uint age = e->age;

    91

    92

	/* Check for early retirement */

    93

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

    94

		int retire_early = EngInfo(e - _engines)->retire_early;

    95

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

    96

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

    97

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

    98

			e->player_avail = 0;

    99

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   100

		}

   101

	}

   102

   103

	if (age < e->duration_phase_1) {

   104

		uint start = e->reliability_start;

   105

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

   106

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

   107

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

   108

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

   109

		e->reliability = e->reliability_max;

   110

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

   111

		uint max = e->reliability_max;

   112

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

   113

	} else {

   114

		/* time's up for this engine.

   115

		 * We will now completely retire this design */

   116

		e->player_avail = 0;

   117

		e->reliability = e->reliability_final;

   118

		/* Kick this engine out of the lists */

   119

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   120

	}

   121

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

   122

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   123

}

   124

   125

void StartupEngines()

   126

{

   127

	Engine *e;

   128

	const EngineInfo *ei;

   129

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

   130

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

   131

   132

	for (e = _engines, ei = _engine_info; e != endof(_engines); e++, ei++) {

   133

		uint32 r;

   134

   135

		e->age = 0;

   136

		e->flags = 0;

   137

		e->player_avail = 0;

   138

   139

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

   140

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

   141

		 * added. */

   142

		r = Random();

   143

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

   144

		if (e->intro_date <= _date) {

   145

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

   146

			e->player_avail = (byte)-1;

   147

			e->flags |= ENGINE_AVAILABLE;

   148

		}

   149

   150

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

   151

		r = Random();

   152

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

   153

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

   154

   155

		r = Random();

   156

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

   157

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

   158

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

   159

   160

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

   161

   162

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

   163

		if (ei->unk2 & 0x80) {

   164

			e->age = 0xFFFF;

   165

		} else {

   166

			CalcEngineReliability(e);

   167

		}

   168

   169

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

   170

   171

		/* prevent certain engines from ever appearing. */

   172

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

   173

			e->flags |= ENGINE_AVAILABLE;

   174

			e->player_avail = 0;

   175

		}

   176

	}

   177

}

   178

   179

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   180

{

   181

	Engine *e = GetEngine(eid);

   182

	Player *p = GetPlayer(player);

   183

   184

	SetBit(e->player_avail, player);

   185

	if (e->type == VEH_TRAIN) {

   186

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   187

   188

		assert(rvi->railtype < RAILTYPE_END);

   189

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

   190

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

   191

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

   192

	}

   193

   194

	e->preview_player_rank = 0xFF;

   195

	if (player == _local_player) {

   196

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   197

	}

   198

}

   199

   200

static PlayerID GetBestPlayer(uint8 pp)

   201

{

   202

	const Player *p;

   203

	int32 best_hist;

   204

	PlayerID best_player;

   205

	uint mask = 0;

   206

   207

	do {

   208

		best_hist = -1;

   209

		best_player = PLAYER_SPECTATOR;

   210

		FOR_ALL_PLAYERS(p) {

   211

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

   212

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

   213

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

   214

				best_player = p->index;

   215

			}

   216

		}

   217

   218

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   219

   220

		SetBit(mask, best_player);

   221

	} while (--pp != 0);

   222

   223

	return best_player;

   224

}

   225

   226

void EnginesDailyLoop()

   227

{

   228

	EngineID i;

   229

   230

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   231

   232

	for (i = 0; i != lengthof(_engines); i++) {

   233

		Engine *e = &_engines[i];

   234

   235

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   236

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   237

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

   238

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   239

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   240

					e->preview_player_rank++;

   241

				}

   242

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

   243

				PlayerID best_player = GetBestPlayer(e->preview_player_rank);

   244

   245

				if (best_player == PLAYER_SPECTATOR) {

   246

					e->preview_player_rank = 0xFF;

   247

					continue;

   248

				}

   249

   250

				if (!IsHumanPlayer(best_player)) {

   251

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

   252

					AcceptEnginePreview(i, best_player);

   253

				} else {

   254

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   255

					e->preview_wait = 20;

   256

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

   257

				}

   258

			}

   259

		}

   260

	}

   261

}

   262

   263

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

   264

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

   265

 * @param tile unused

   266

 * @param flags operation to perfom

   267

 * @param p1 engine-prototype offered

   268

 * @param p2 unused

   269

 */

   270

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

   271

{

   272

	Engine *e;

   273

   274

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   275

	e = GetEngine(p1);

   276

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

   277

   278

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

   279

   280

	return CommandCost();

   281

}

   282

   283

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

   284

static bool IsWagon(EngineID index)

   285

{

   286

	return index < NUM_TRAIN_ENGINES && RailVehInfo(index)->railveh_type == RAILVEH_WAGON;

   287

}

   288

   289

static void NewVehicleAvailable(Engine *e)

   290

{

   291

	Vehicle *v;

   292

	Player *p;

   293

	EngineID index = e - _engines;

   294

   295

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

   296

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

   297

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   298

		FOR_ALL_PLAYERS(p) {

   299

			uint block_preview = p->block_preview;

   300

   301

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

   302

   303

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

   304

			p->block_preview = 20;

   305

   306

			FOR_ALL_VEHICLES(v) {

   307

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

   308

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

   309

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

   310

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

   311

						p->block_preview = block_preview;

   312

						break;

   313

					}

   314

				}

   315

			}

   316

		}

   317

	}

   318

   319

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

   320

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   321

   322

	/* Now available for all players */

   323

	e->player_avail = (byte)-1;

   324

   325

	/* Do not introduce new rail wagons */

   326

	if (IsWagon(index)) return;

   327

   328

	if (e->type == VEH_TRAIN) {

   329

		/* maybe make another rail type available */

   330

		RailType railtype = RailVehInfo(index)->railtype;

   331

		assert(railtype < RAILTYPE_END);

   332

		FOR_ALL_PLAYERS(p) {

   333

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

   334

		}

   335

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

   336

		/* maybe make another road type available */

   337

		FOR_ALL_PLAYERS(p) {

   338

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

   339

		}

   340

	}

   341

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

   342

}

   343

   344

void EnginesMonthlyLoop()

   345

{

   346

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   347

		Engine *e;

   348

		FOR_ALL_ENGINES(e) {

   349

			/* Age the vehicle */

   350

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

   351

				e->age++;

   352

				CalcEngineReliability(e);

   353

			}

   354

   355

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

   356

				/* Introduce it to all players */

   357

				NewVehicleAvailable(e);

   358

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

   359

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

   360

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   361

   362

				/* Do not introduce new rail wagons */

   363

				if (!IsWagon(e - _engines))

   364

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

   365

			}

   366

		}

   367

	}

   368

}

   369

   370

static bool IsUniqueEngineName(const char *name)

   371

{

   372

	char buf[512];

   373

   374

	for (EngineID i = 0; i < TOTAL_NUM_ENGINES; i++) {

   375

		SetDParam(0, i);

   376

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

   377

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

   378

	}

   379

   380

	return true;

   381

}

   382

   383

/** Rename an engine.

   384

 * @param tile unused

   385

 * @param flags operation to perfom

   386

 * @param p1 engine ID to rename

   387

 * @param p2 unused

   388

 */

   389

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

   390

{

   391

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

   392

   393

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

   394

   395

	if (flags & DC_EXEC) {

   396

		Engine *e = GetEngine(p1);

   397

		free(e->name);

   398

		e->name = strdup(_cmd_text);

   399

		_vehicle_design_names |= 3;

   400

		MarkWholeScreenDirty();

   401

	}

   402

   403

	return CommandCost();

   404

}

   405

   406

   407

/** Check if an engine is buildable.

   408

 * @param engine index of the engine to check.

   409

 * @param type   the type the engine should be.

   410

 * @param player index of the player.

   411

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

   412

 *              the given player.

   413

 */

   414

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

   415

{

   416

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

   417

	if (!IsEngineIndex(engine)) return false;

   418

   419

	const Engine *e = GetEngine(engine);

   420

   421

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

   422

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

   423

   424

	/* check if it's available */

   425

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

   426

   427

	if (type == VEH_TRAIN) {

   428

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

   429

		const Player *p = GetPlayer(player);

   430

		if (!HasBit(p->avail_railtypes, RailVehInfo(engine)->railtype)) return false;

   431

	}

   432

   433

	return true;

   434

}

   435

   436

/** Get the default cargo type for a certain engine type

   437

 * @param engine The ID to get the cargo for

   438

 * @return The cargo type. CT_INVALID means no cargo capacity

   439

 */

   440

CargoID GetEngineCargoType(EngineID engine)

   441

{

   442

	assert(IsEngineIndex(engine));

   443

   444

	switch (GetEngine(engine)->type) {

   445

		case VEH_TRAIN:

   446

			if (RailVehInfo(engine)->capacity == 0) return CT_INVALID;

   447

			return RailVehInfo(engine)->cargo_type;

   448

   449

		case VEH_ROAD:

   450

			if (RoadVehInfo(engine)->capacity == 0) return CT_INVALID;

   451

			return RoadVehInfo(engine)->cargo_type;

   452

   453

		case VEH_SHIP:

   454

			if (ShipVehInfo(engine)->capacity == 0) return CT_INVALID;

   455

			return ShipVehInfo(engine)->cargo_type;

   456

   457

		case VEH_AIRCRAFT:

   458

			/* all aircraft starts as passenger planes with cargo capacity */

   459

			return CT_PASSENGERS;

   460

   461

		default: NOT_REACHED(); return CT_INVALID;

   462

	}

   463

}

   464

   465

/************************************************************************

   466

 * Engine Replacement stuff

   467

 ************************************************************************/

   468

   469

DEFINE_OLD_POOL_GENERIC(EngineRenew, EngineRenew)

   470

   471

/**

   472

 * Retrieves the EngineRenew that specifies the replacement of the given

   473

 * engine type from the given renewlist */

   474

static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine, GroupID group)

   475

{

   476

	EngineRenew *er = (EngineRenew *)erl;

   477

   478

	while (er) {

   479

		if (er->from == engine && er->group_id == group) return er;

   480

		er = er->next;

   481

	}

   482

	return NULL;

   483

}

   484

   485

void RemoveAllEngineReplacement(EngineRenewList *erl)

   486

{

   487

	EngineRenew *er = (EngineRenew *)(*erl);

   488