1

/* $Id$ */

     2

     3

/** @file engine.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "functions.h"

     9

#include "table/strings.h"

    10

#include "engine.h"

    11

#include "gfx.h"

    12

#include "player.h"

    13

#include "command.h"

    14

#include "vehicle.h"

    15

#include "news.h"

    16

#include "saveload.h"

    17

#include "variables.h"

    18

#include "train.h"

    19

#include "aircraft.h"

    20

#include "newgrf_cargo.h"

    21

#include "date.h"

    22

#include "table/engines.h"

    23

#include "group.h"

    24

#include "string.h"

    25

#include "strings.h"

    26

    27

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    28

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    29

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    30

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    31

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    32

    33

enum {

    34

	YEAR_ENGINE_AGING_STOPS = 2050,

    35

};

    36

    37

    38

void ShowEnginePreviewWindow(EngineID engine);

    39

    40

void DeleteCustomEngineNames()

    41

{

    42

	uint i;

    43

	StringID old;

    44

    45

	for (i = 0; i != TOTAL_NUM_ENGINES; i++) {

    46

		old = _engine_name_strings[i];

    47

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    48

		DeleteName(old);

    49

	}

    50

    51

	_vehicle_design_names &= ~1;

    52

}

    53

    54

void LoadCustomEngineNames()

    55

{

    56

	/* XXX: not done */

    57

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

    58

}

    59

    60

static void SetupEngineNames()

    61

{

    62

	StringID *name;

    63

    64

	for (name = _engine_name_strings; name != endof(_engine_name_strings); name++)

    65

		*name = STR_SV_EMPTY;

    66

    67

	DeleteCustomEngineNames();

    68

	LoadCustomEngineNames();

    69

}

    70

    71

    72

static void CalcEngineReliability(Engine *e)

    73

{

    74

	uint age = e->age;

    75

    76

	/* Check for early retirement */

    77

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

    78

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

    79

		if (retire_early > 0 && age >= e->duration_phase_1 + e->duration_phase_2 - retire_early * 12) {

    80

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

    81

			e->player_avail = 0;

    82

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

    83

		}

    84

	}

    85

    86

	if (age < e->duration_phase_1) {

    87

		uint start = e->reliability_start;

    88

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

    89

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

    90

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

    91

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

    92

		e->reliability = e->reliability_max;

    93

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

    94

		uint max = e->reliability_max;

    95

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

    96

	} else {

    97

		/* time's up for this engine.

    98

		 * We will now completely retire this design */

    99

		e->player_avail = 0;

   100

		e->reliability = e->reliability_final;

   101

		/* Kick this engine out of the lists */

   102

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   103

	}

   104

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

   105

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   106

}

   107

   108

void AddTypeToEngines()

   109

{

   110

	Engine* e = _engines;

   111

   112

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

   113

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

   114

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

   115

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

   116

}

   117

   118

void StartupEngines()

   119

{

   120

	Engine *e;

   121

	const EngineInfo *ei;

   122

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

   123

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

   124

   125

	SetupEngineNames();

   126

   127

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

   128

		uint32 r;

   129

   130

		e->age = 0;

   131

		e->flags = 0;

   132

		e->player_avail = 0;

   133

   134

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

   135

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

   136

		 * added. */

   137

		r = Random();

   138

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

   139

		if (e->intro_date <= _date) {

   140

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

   141

			e->player_avail = (byte)-1;

   142

			e->flags |= ENGINE_AVAILABLE;

   143

		}

   144

   145

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

   146

		r = Random();

   147

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

   148

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

   149

   150

		r = Random();

   151

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

   152

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

   153

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

   154

   155

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

   156

   157

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

   158

		if (ei->unk2 & 0x80) {

   159

			e->age = 0xFFFF;

   160

		} else {

   161

			CalcEngineReliability(e);

   162

		}

   163

   164

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

   165

   166

		/* prevent certain engines from ever appearing. */

   167

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

   168

			e->flags |= ENGINE_AVAILABLE;

   169

			e->player_avail = 0;

   170

		}

   171

   172

		/* This sets up type for the engine

   173

		 * It is needed if you want to ask the engine what type it is

   174

		 * It should hopefully be the same as when you ask a vehicle what it is

   175

		 * but using this, you can ask what type an engine number is

   176

		 * even if it is not a vehicle (yet)*/

   177

	}

   178

}

   179

   180

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   181

{

   182

	Engine *e = GetEngine(eid);

   183

	Player *p = GetPlayer(player);

   184

   185

	SETBIT(e->player_avail, player);

   186

	if (e->type == VEH_TRAIN) {

   187

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   188

   189

		assert(rvi->railtype < RAILTYPE_END);

   190

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

   191

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

   192

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

   193

	}

   194

   195

	e->preview_player = INVALID_PLAYER;

   196

	if (player == _local_player) {

   197

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   198

	}

   199

}

   200

   201

static PlayerID GetBestPlayer(PlayerID pp)

   202

{

   203

	const Player *p;

   204

	int32 best_hist;

   205

	PlayerID best_player;

   206

	uint mask = 0;

   207

   208

	do {

   209

		best_hist = -1;

   210

		best_player = PLAYER_SPECTATOR;

   211

		FOR_ALL_PLAYERS(p) {

   212

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

   213

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

   214

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

   215

				best_player = p->index;

   216

			}

   217

		}

   218

   219

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   220

   221

		SETBIT(mask, best_player);

   222

	} while (pp--, pp != 0);

   223

   224

	return best_player;

   225

}

   226

   227

void EnginesDailyLoop()

   228

{

   229

	EngineID i;

   230

   231

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   232

   233

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

   234

		Engine *e = &_engines[i];

   235

   236

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   237

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   238

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

   239

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   240

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   241

					e->preview_player++;

   242

				}

   243

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

   244

				PlayerID best_player = GetBestPlayer(e->preview_player);

   245

   246

				if (best_player == PLAYER_SPECTATOR) {

   247

					e->preview_player = INVALID_PLAYER;

   248

					continue;

   249

				}

   250

   251

				if (!IsHumanPlayer(best_player)) {

   252

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

   253

					AcceptEnginePreview(i, best_player);

   254

				} else {

   255

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   256

					e->preview_wait = 20;

   257

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

   258

				}

   259

			}

   260

		}

   261

	}

   262

}

   263

   264

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

   265

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

   266

 * @param tile unused

   267

 * @param flags operation to perfom

   268

 * @param p1 engine-prototype offered

   269

 * @param p2 unused

   270

 */

   271

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

   272

{

   273

	Engine *e;

   274

   275

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   276

	e = GetEngine(p1);

   277

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

   278

   279

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

   280

   281

	return CommandCost();

   282

}

   283

   284

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

   285

static bool IsWagon(EngineID index)

   286

{

   287

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

   288

}

   289

   290

static void NewVehicleAvailable(Engine *e)

   291

{

   292

	Vehicle *v;

   293

	Player *p;

   294

	EngineID index = e - _engines;

   295

   296

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

   297

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

   298

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   299

		FOR_ALL_PLAYERS(p) {

   300

			uint block_preview = p->block_preview;

   301

   302

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

   303

   304

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

   305

			p->block_preview = 20;

   306

   307

			FOR_ALL_VEHICLES(v) {

   308

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

   309

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

   310

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

   311

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

   312

						p->block_preview = block_preview;

   313

						break;

   314

					}

   315

				}

   316

			}

   317

		}

   318

	}

   319

   320

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

   321

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   322

   323

	/* Now available for all players */

   324

	e->player_avail = (byte)-1;

   325

   326

	/* Do not introduce new rail wagons */

   327

	if (IsWagon(index)) return;

   328

   329

	if (index < NUM_TRAIN_ENGINES) {

   330

		/* maybe make another rail type available */

   331

		RailType railtype = RailVehInfo(index)->railtype;

   332

		assert(railtype < RAILTYPE_END);

   333

		FOR_ALL_PLAYERS(p) {

   334

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

   335

		}

   336

	}

   337

	if ((index - NUM_TRAIN_ENGINES) < NUM_ROAD_ENGINES) {

   338

		/* maybe make another road type available */

   339

		FOR_ALL_PLAYERS(p) {

   340

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

   341

		}

   342

	}

   343

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

   344

}

   345

   346

void EnginesMonthlyLoop()

   347

{

   348

	Engine *e;

   349

   350

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   351

		for (e = _engines; e != endof(_engines); e++) {

   352

			/* Age the vehicle */

   353

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

   354

				e->age++;

   355

				CalcEngineReliability(e);

   356

			}

   357

   358

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

   359

				/* Introduce it to all players */

   360

				NewVehicleAvailable(e);

   361

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

   362

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

   363

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   364

   365

				/* Do not introduce new rail wagons */

   366

				if (!IsWagon(e - _engines))

   367

					e->preview_player = (PlayerID)1; // Give to the player with the highest rating.

   368

			}

   369

		}

   370

	}

   371

}

   372

   373

static bool IsUniqueEngineName(const char *name)

   374

{

   375

	char buf[512];

   376

   377

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

   378

		SetDParam(0, i);

   379

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

   380

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

   381

	}

   382

   383

	return true;

   384

}

   385

   386

/** Rename an engine.

   387

 * @param tile unused

   388

 * @param flags operation to perfom

   389

 * @param p1 engine ID to rename

   390

 * @param p2 unused

   391

 */

   392

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

   393

{

   394

	StringID str;

   395

   396

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

   397

   398

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

   399

   400

	str = AllocateName(_cmd_text, 0);

   401

	if (str == 0) return CMD_ERROR;

   402

   403

	if (flags & DC_EXEC) {

   404

		StringID old_str = _engine_name_strings[p1];

   405

		_engine_name_strings[p1] = str;

   406

		DeleteName(old_str);

   407

		_vehicle_design_names |= 3;

   408

		MarkWholeScreenDirty();

   409

	} else {

   410

		DeleteName(str);

   411

	}

   412

   413

	return CommandCost();

   414

}

   415

   416

   417

/*

   418

 * returns true if an engine is valid, of the specified type, and buildable by

   419

 * the given player, false otherwise

   420

 *

   421

 * engine = index of the engine to check

   422

 * type   = the type the engine should be of (VEH_xxx)

   423

 * player = index of the player

   424

 */

   425

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

   426

{

   427

	const Engine *e;

   428

   429

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

   430

	if (!IsEngineIndex(engine)) return false;

   431

   432

	e = GetEngine(engine);

   433

   434

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

   435

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

   436

   437

	/* check if it's available */

   438

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

   439

   440

	if (type == VEH_TRAIN) {

   441

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

   442

		const Player *p = GetPlayer(player);

   443

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

   444

	}

   445

   446

	return true;

   447

}

   448

   449

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

   450

 * @param engine The ID to get the cargo for

   451

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

   452

 */

   453

CargoID GetEngineCargoType(EngineID engine)

   454

{

   455

	assert(IsEngineIndex(engine));

   456

   457

	switch (GetEngine(engine)->type) {

   458

		case VEH_TRAIN:

   459

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

   460

			return RailVehInfo(engine)->cargo_type;

   461

   462

		case VEH_ROAD:

   463

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

   464

			return RoadVehInfo(engine)->cargo_type;

   465

   466

		case VEH_SHIP:

   467

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

   468

			return ShipVehInfo(engine)->cargo_type;

   469

   470

		case VEH_AIRCRAFT:

   471

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

   472

			return CT_PASSENGERS;

   473

   474

		default: NOT_REACHED(); return CT_INVALID;

   475

	}

   476

}

   477

   478

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

   479

 * Engine Replacement stuff

   480

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

   481

   482

static void EngineRenewPoolNewBlock(uint start_item);

   483

   484

DEFINE_OLD_POOL(EngineRenew, EngineRenew, EngineRenewPoolNewBlock, NULL)

   485

   486

static void EngineRenewPoolNewBlock(uint start_item)

   487

{

   488

	EngineRenew *er;

   489

   490

	/* We don't use FOR_ALL here, because FOR_ALL skips invalid items.

   491

	 *  TODO - This is just a temporary stage, this will be removed. */