1

/* $Id$ */

     2

     3

/** @file engine.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "table/strings.h"

     9

#include "engine.h"

    12

#include "command_func.h"

    13

#include "news.h"

    14

#include "saveload.h"

    15

#include "variables.h"

    16

#include "train.h"

    17

#include "aircraft.h"

    18

#include "newgrf_cargo.h"

    19

#include "table/engines.h"

    20

#include "group.h"

    21

#include "misc/autoptr.hpp"

    22

#include "strings_func.h"

    23

#include "gfx_func.h"

    24

#include "functions.h"

    25

#include "window_func.h"

    26

#include "date_func.h"

    27

#include "autoreplace_base.h"

    28

#include "autoreplace_gui.h"

    29

#include "string_func.h"

    30

    31

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    32

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    33

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    34

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    35

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    36

    37

enum {

    38

	YEAR_ENGINE_AGING_STOPS = 2050,

    39

};

    40

    41

    42

void SetupEngines()

    43

{

    44

	/* Copy original static engine data */

    45

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

    46

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

    47

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

    48

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

    49

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

    50

    51

	/* Add type to engines */

    52

	Engine* e = _engines;

    53

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

    54

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

    55

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

    56

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

    57

}

    58

    59

    60

void ShowEnginePreviewWindow(EngineID engine);

    61

    62

void DeleteCustomEngineNames()

    63

{

    64

	uint i;

    65

	StringID old;

    66

    67

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

    68

		old = _engine_name_strings[i];

    69

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    70

		DeleteName(old);

    71

	}

    72

    73

	_vehicle_design_names &= ~1;

    74

}

    75

    76

void LoadCustomEngineNames()

    77

{

    78

	/* XXX: not done */

    79

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

    80

}

    81

    82

static void SetupEngineNames()

    83

{

    84

	StringID *name;

    85

    86

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

    87

		*name = STR_SV_EMPTY;

    88

    89

	DeleteCustomEngineNames();

    90

	LoadCustomEngineNames();

    91

}

    92

    93

    94

static void CalcEngineReliability(Engine *e)

    95

{

    96

	uint age = e->age;

    97

    98

	/* Check for early retirement */

    99

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

   100

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

   101

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

   102

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

   103

			e->player_avail = 0;

   104

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   105

		}

   106

	}

   107

   108

	if (age < e->duration_phase_1) {

   109

		uint start = e->reliability_start;

   110

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

   111

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

   112

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

   113

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

   114

		e->reliability = e->reliability_max;

   115

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

   116

		uint max = e->reliability_max;

   117

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

   118

	} else {

   119

		/* time's up for this engine.

   120

		 * We will now completely retire this design */

   121

		e->player_avail = 0;

   122

		e->reliability = e->reliability_final;

   123

		/* Kick this engine out of the lists */

   124

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   125

	}

   126

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

   127

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   128

}

   129

   130

void StartupEngines()

   131

{

   132

	Engine *e;

   133

	const EngineInfo *ei;

   134

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

   135

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

   136

   137

	SetupEngineNames();

   138

   139

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

   140

		uint32 r;

   141

   142

		e->age = 0;

   143

		e->flags = 0;

   144

		e->player_avail = 0;

   145

   146

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

   147

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

   148

		 * added. */

   149

		r = Random();

   150

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

   151

		if (e->intro_date <= _date) {

   152

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

   153

			e->player_avail = (byte)-1;

   154

			e->flags |= ENGINE_AVAILABLE;

   155

		}

   156

   157

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

   158

		r = Random();

   159

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

   160

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

   161

   162

		r = Random();

   163

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

   164

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

   165

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

   166

   167

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

   168

   169

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

   170

		if (ei->unk2 & 0x80) {

   171

			e->age = 0xFFFF;

   172

		} else {

   173

			CalcEngineReliability(e);

   174

		}

   175

   176

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

   177

   178

		/* prevent certain engines from ever appearing. */

   179

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

   180

			e->flags |= ENGINE_AVAILABLE;

   181

			e->player_avail = 0;

   182

		}

   183

   184

		/* This sets up type for the engine

   185

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

   186

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

   187

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

   188

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

   189

	}

   190

}

   191

   192

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   193

{

   194

	Engine *e = GetEngine(eid);

   195

	Player *p = GetPlayer(player);

   196

   197

	SetBit(e->player_avail, player);

   198

	if (e->type == VEH_TRAIN) {

   199

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   200

   201

		assert(rvi->railtype < RAILTYPE_END);

   202

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

   203

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

   204

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

   205

	}

   206

   207

	e->preview_player = INVALID_PLAYER;

   208

	if (player == _local_player) {

   209

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   210

	}

   211

}

   212

   213

static PlayerID GetBestPlayer(PlayerID pp)

   214

{

   215

	const Player *p;

   216

	int32 best_hist;

   217

	PlayerID best_player;

   218

	uint mask = 0;

   219

   220

	do {

   221

		best_hist = -1;

   222

		best_player = PLAYER_SPECTATOR;

   223

		FOR_ALL_PLAYERS(p) {

   224

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

   225

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

   226

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

   227

				best_player = p->index;

   228

			}

   229

		}

   230

   231

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   232

   233

		SetBit(mask, best_player);

   234

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

   235

   236

	return best_player;

   237

}

   238

   239

void EnginesDailyLoop()

   240

{

   241

	EngineID i;

   242

   243

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   244

   245

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

   246

		Engine *e = &_engines[i];

   247

   248

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   249

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   250

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

   251

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   252

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   253

					e->preview_player++;

   254

				}

   255

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

   256

				PlayerID best_player = GetBestPlayer(e->preview_player);

   257

   258

				if (best_player == PLAYER_SPECTATOR) {

   259

					e->preview_player = INVALID_PLAYER;

   260

					continue;

   261

				}

   262

   263

				if (!IsHumanPlayer(best_player)) {

   264

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

   265

					AcceptEnginePreview(i, best_player);

   266

				} else {

   267

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   268

					e->preview_wait = 20;

   269

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

   270

				}

   271

			}

   272

		}

   273

	}

   274

}

   275

   276

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

   277

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

   278

 * @param tile unused

   279

 * @param flags operation to perfom

   280

 * @param p1 engine-prototype offered

   281

 * @param p2 unused

   282

 */

   283

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

   284

{

   285

	Engine *e;

   286

   287

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   288

	e = GetEngine(p1);

   289

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

   290

   291

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

   292

   293

	return CommandCost();

   294

}

   295

   296

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

   297

static bool IsWagon(EngineID index)

   298

{

   299

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

   300

}

   301

   302

static void NewVehicleAvailable(Engine *e)

   303

{

   304

	Vehicle *v;

   305

	Player *p;

   306

	EngineID index = e - _engines;

   307

   308

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

   309

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

   310

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   311

		FOR_ALL_PLAYERS(p) {

   312

			uint block_preview = p->block_preview;

   313

   314

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

   315

   316

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

   317

			p->block_preview = 20;

   318

   319

			FOR_ALL_VEHICLES(v) {

   320

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

   321

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

   322

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

   323

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

   324

						p->block_preview = block_preview;

   325

						break;

   326

					}

   327

				}

   328

			}

   329

		}

   330

	}

   331

   332

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

   333

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   334

   335

	/* Now available for all players */

   336

	e->player_avail = (byte)-1;

   337

   338

	/* Do not introduce new rail wagons */

   339

	if (IsWagon(index)) return;

   340

   341

	if (e->type == VEH_TRAIN) {

   342

		/* maybe make another rail type available */

   343

		RailType railtype = RailVehInfo(index)->railtype;

   344

		assert(railtype < RAILTYPE_END);

   345

		FOR_ALL_PLAYERS(p) {

   346

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

   347

		}

   348

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

   349

		/* maybe make another road type available */

   350

		FOR_ALL_PLAYERS(p) {

   351

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

   352

		}

   353

	}

   354

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

   355

}

   356

   357

void EnginesMonthlyLoop()

   358

{

   359

	Engine *e;

   360

   361

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   362

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

   363

			/* Age the vehicle */

   364

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

   365

				e->age++;

   366

				CalcEngineReliability(e);

   367

			}

   368

   369

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

   370

				/* Introduce it to all players */

   371

				NewVehicleAvailable(e);

   372

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

   373

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

   374

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   375

   376

				/* Do not introduce new rail wagons */

   377

				if (!IsWagon(e - _engines))

   378

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

   379

			}

   380

		}

   381

	}

   382

}

   383

   384

static bool IsUniqueEngineName(const char *name)

   385

{

   386

	char buf[512];

   387

   388

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

   389

		SetDParam(0, i);

   390

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

   391

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

   392

	}

   393

   394

	return true;

   395

}

   396

   397

/** Rename an engine.

   398

 * @param tile unused

   399

 * @param flags operation to perfom

   400

 * @param p1 engine ID to rename

   401

 * @param p2 unused

   402

 */

   403

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

   404

{

   405

	StringID str;

   406

   407

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

   408

   409

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

   410

   411

	str = AllocateName(_cmd_text, 0);

   412

	if (str == 0) return CMD_ERROR;

   413

   414

	if (flags & DC_EXEC) {

   415

		StringID old_str = _engine_name_strings[p1];

   416

		_engine_name_strings[p1] = str;

   417

		DeleteName(old_str);

   418

		_vehicle_design_names |= 3;

   419

		MarkWholeScreenDirty();

   420

	} else {

   421

		DeleteName(str);

   422

	}

   423

   424

	return CommandCost();

   425

}

   426

   427

   428

/*

   429

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

   430

 * the given player, false otherwise

   431

 *

   432

 * engine = index of the engine to check

   433

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

   434

 * player = index of the player

   435

 */

   436

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

   437

{

   438

	const Engine *e;

   439

   440

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

   441

	if (!IsEngineIndex(engine)) return false;

   442

   443

	e = GetEngine(engine);

   444

   445

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

   446

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

   447

   448

	/* check if it's available */

   449

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

   450

   451

	if (type == VEH_TRAIN) {

   452

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

   453

		const Player *p = GetPlayer(player);

   454

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

   455

	}

   456

   457

	return true;

   458

}

   459

   460

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

   461

 * @param engine The ID to get the cargo for

   462

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

   463

 */

   464

CargoID GetEngineCargoType(EngineID engine)

   465

{

   466

	assert(IsEngineIndex(engine));

   467

   468

	switch (GetEngine(engine)->type) {

   469

		case VEH_TRAIN:

   470

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

   471

			return RailVehInfo(engine)->cargo_type;

   472

   473

		case VEH_ROAD:

   474

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

   475

			return RoadVehInfo(engine)->cargo_type;

   476

   477

		case VEH_SHIP:

   478

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

   479

			return ShipVehInfo(engine)->cargo_type;

   480

   481

		case VEH_AIRCRAFT:

   482

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

   483

			return CT_PASSENGERS;

   484

   485

		default: NOT_REACHED(); return CT_INVALID;

   486

	}

   487

}

   488

   489

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

   490

 * Engine Replacement stuff