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

    24

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    25

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    26

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    27

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    28

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    29

    30

enum {

    31

	YEAR_ENGINE_AGING_STOPS = 2050,

    32

};

    33

    34

    35

void ShowEnginePreviewWindow(EngineID engine);

    36

    37

void DeleteCustomEngineNames()

    38

{

    39

	uint i;

    40

	StringID old;

    41

    42

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

    43

		old = _engine_name_strings[i];

    44

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    45

		DeleteName(old);

    46

	}

    47

    48

	_vehicle_design_names &= ~1;

    49

}

    50

    51

void LoadCustomEngineNames()

    52

{

    53

	/* XXX: not done */

    54

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

    55

}

    56

    57

static void SetupEngineNames()

    58

{

    59

	StringID *name;

    60

    61

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

    62

		*name = STR_SV_EMPTY;

    63

    64

	DeleteCustomEngineNames();

    65

	LoadCustomEngineNames();

    66

}

    67

    68

    69

static void CalcEngineReliability(Engine *e)

    70

{

    71

	uint age = e->age;

    72

    73

	if (age < e->duration_phase_1) {

    74

		uint start = e->reliability_start;

    75

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

    76

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

    77

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

    78

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

    79

		e->reliability = e->reliability_max;

    80

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

    81

		uint max = e->reliability_max;

    82

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

    83

	} else {

    84

		/* time's up for this engine.

    85

		 * We will now completely retire this design */

    86

		e->player_avail = 0;

    87

		e->reliability = e->reliability_final;

    88

		/* Kick this engine out of the lists */

    89

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

    90

	}

    91

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

    92

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

    93

}

    94

    95

void AddTypeToEngines()

    96

{

    97

	Engine* e = _engines;

    98

    99

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

   100

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

   101

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

   102

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

   103

}

   104

   105

void StartupEngines()

   106

{

   107

	Engine *e;

   108

	const EngineInfo *ei;

   109

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

   110

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

   111

   112

	SetupEngineNames();

   113

   114

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

   115

		uint32 r;

   116

   117

		e->age = 0;

   118

		e->flags = 0;

   119

		e->player_avail = 0;

   120

   121

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

   122

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

   123

		 * added. */

   124

		r = Random();

   125

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

   126

		if (e->intro_date <= _date) {

   127

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

   128

			e->player_avail = (byte)-1;

   129

			e->flags |= ENGINE_AVAILABLE;

   130

		}

   131

   132

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

   133

		r = Random();

   134

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

   135

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

   136

   137

		r = Random();

   138

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

   139

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

   140

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

   141

   142

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

   143

   144

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

   145

		if (ei->unk2 & 0x80) {

   146

			e->age = 0xFFFF;

   147

		} else {

   148

			CalcEngineReliability(e);

   149

		}

   150

   151

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

   152

   153

		/* prevent certain engines from ever appearing. */

   154

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

   155

			e->flags |= ENGINE_AVAILABLE;

   156

			e->player_avail = 0;

   157

		}

   158

   159

		/* This sets up type for the engine

   160

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

   161

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

   162

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

   163

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

   164

	}

   165

}

   166

   167

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   168

{

   169

	Engine *e = GetEngine(eid);

   170

   171

	SETBIT(e->player_avail, player);

   172

	if (e->type == VEH_TRAIN) {

   173

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   174

		Player *p = GetPlayer(player);

   175

   176

		assert(rvi->railtype < RAILTYPE_END);

   177

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

   178

	}

   179

   180

	e->preview_player = INVALID_PLAYER;

   181

	if (player == _local_player) {

   182

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   183

	}

   184

}

   185

   186

static PlayerID GetBestPlayer(PlayerID pp)

   187

{

   188

	const Player *p;

   189

	int32 best_hist;

   190

	PlayerID best_player;

   191

	uint mask = 0;

   192

   193

	do {

   194

		best_hist = -1;

   195

		best_player = PLAYER_SPECTATOR;

   196

		FOR_ALL_PLAYERS(p) {

   197

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

   198

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

   199

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

   200

				best_player = p->index;

   201

			}

   202

		}

   203

   204

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   205

   206

		SETBIT(mask, best_player);

   207

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

   208

   209

	return best_player;

   210

}

   211

   212

void EnginesDailyLoop()

   213

{

   214

	EngineID i;

   215

   216

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   217

   218

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

   219

		Engine *e = &_engines[i];

   220

   221

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   222

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   223

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

   224

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   225

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   226

					e->preview_player++;

   227

				}

   228

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

   229

				PlayerID best_player = GetBestPlayer(e->preview_player);

   230

   231

				if (best_player == PLAYER_SPECTATOR) {

   232

					e->preview_player = INVALID_PLAYER;

   233

					continue;

   234

				}

   235

   236

				if (!IsHumanPlayer(best_player)) {

   237

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

   238

					AcceptEnginePreview(i, best_player);

   239

				} else {

   240

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   241

					e->preview_wait = 20;

   242

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

   243

				}

   244

			}

   245

		}

   246

	}

   247

}

   248

   249

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

   250

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

   251

 * @param tile unused

   252

 * @param p1 engine-prototype offered

   253

 * @param p2 unused

   254

 */

   255

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

   256

{

   257

	Engine *e;

   258

   259

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   260

	e = GetEngine(p1);

   261

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

   262

   263

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

   264

   265

	return 0;

   266

}

   267

   268

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

   269

static bool IsWagon(EngineID index)

   270

{

   271

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

   272

}

   273

   274

static void NewVehicleAvailable(Engine *e)

   275

{

   276

	Vehicle *v;

   277

	Player *p;

   278

	EngineID index = e - _engines;

   279

   280

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

   281

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

   282

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   283

		FOR_ALL_PLAYERS(p) {

   284

			uint block_preview = p->block_preview;

   285

   286

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

   287

   288

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

   289

			p->block_preview = 20;

   290

   291

			FOR_ALL_VEHICLES(v) {

   292

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

   293

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

   294

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

   295

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

   296

						p->block_preview = block_preview;

   297

						break;

   298

					}

   299

				}

   300

			}

   301

		}

   302

	}

   303

   304

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

   305

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   306

   307

	/* Now available for all players */

   308

	e->player_avail = (byte)-1;

   309

   310

	/* Do not introduce new rail wagons */

   311

	if (IsWagon(index)) return;

   312

   313

	if (index < NUM_TRAIN_ENGINES) {

   314

		/* maybe make another rail type available */

   315

		RailType railtype = RailVehInfo(index)->railtype;

   316

		assert(railtype < RAILTYPE_END);

   317

		FOR_ALL_PLAYERS(p) {

   318

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

   319

		}

   320

	}

   321

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

   322

}

   323

   324

void EnginesMonthlyLoop()

   325

{

   326

	Engine *e;

   327

   328

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   329

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

   330

			/* Age the vehicle */

   331

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

   332

				e->age++;

   333

				CalcEngineReliability(e);

   334

			}

   335

   336

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

   337

				/* Introduce it to all players */

   338

				NewVehicleAvailable(e);

   339

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

   340

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

   341

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   342

   343

				/* Do not introduce new rail wagons */

   344

				if (!IsWagon(e - _engines))

   345

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

   346

			}

   347

		}

   348

	}

   349

}

   350

   351

/** Rename an engine.

   352

 * @param tile unused

   353

 * @param p1 engine ID to rename

   354

 * @param p2 unused

   355

 */

   356

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

   357

{

   358

	StringID str;

   359

   360

	if (!IsEngineIndex(p1) || _cmd_text[0] == '\0') return CMD_ERROR;

   361

   362

	str = AllocateNameUnique(_cmd_text, 0);

   363

	if (str == 0) return CMD_ERROR;

   364

   365

	if (flags & DC_EXEC) {

   366

		StringID old_str = _engine_name_strings[p1];

   367

		_engine_name_strings[p1] = str;

   368

		DeleteName(old_str);

   369

		_vehicle_design_names |= 3;

   370

		MarkWholeScreenDirty();

   371

	} else {

   372

		DeleteName(str);

   373

	}

   374

   375

	return 0;

   376

}

   377

   378

   379

/*

   380

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

   381

 * the given player, false otherwise

   382

 *

   383

 * engine = index of the engine to check

   384

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

   385

 * player = index of the player

   386

 */

   387

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

   388

{

   389

	const Engine *e;

   390

   391

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

   392

	if (!IsEngineIndex(engine)) return false;

   393

   394

	e = GetEngine(engine);

   395

   396

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

   397

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

   398

   399

	/* check if it's available */

   400

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

   401

   402

	return true;

   403

}

   404

   405

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

   406

 * Engine Replacement stuff

   407

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

   408

   409

static void EngineRenewPoolNewBlock(uint start_item);

   410

   411

DEFINE_OLD_POOL(EngineRenew, EngineRenew, EngineRenewPoolNewBlock, NULL)

   412

   413

static void EngineRenewPoolNewBlock(uint start_item)

   414

{

   415

	EngineRenew *er;

   416

   417

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

   418

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

   419

	for (er = GetEngineRenew(start_item); er != NULL; er = (er->index + 1U < GetEngineRenewPoolSize()) ? GetEngineRenew(er->index + 1U) : NULL) {

   420

		er->index = start_item++;

   421

		er->from = INVALID_ENGINE;

   422

	}

   423

}

   424

   425

   426

static EngineRenew *AllocateEngineRenew()

   427

{

   428

	EngineRenew *er;

   429

   430

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

   431

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

   432

	for (er = GetEngineRenew(0); er != NULL; er = (er->index + 1U < GetEngineRenewPoolSize()) ? GetEngineRenew(er->index + 1U) : NULL) {

   433

		if (IsValidEngineRenew(er)) continue;

   434

   435

		er->to = INVALID_ENGINE;

   436

		er->next = NULL;

   437

		return er;

   438

	}

   439

   440

	/* Check if we can add a block to the pool */

   441

	if (AddBlockToPool(&_EngineRenew_pool)) return AllocateEngineRenew();

   442

   443

	return NULL;

   444

}

   445

   446

/**

   447

 * Retrieves the EngineRenew that specifies the replacement of the given

   448

 * engine type from the given renewlist */

   449

static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine)

   450

{

   451

	EngineRenew *er = (EngineRenew *)erl;

   452

   453

	while (er) {

   454

		if (er->from == engine) return er;

   455

		er = er->next;

   456

	}

   457

	return NULL;

   458

}

   459

   460

void RemoveAllEngineReplacement(EngineRenewList *erl)

   461

{

   462

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

   463

	EngineRenew *next;

   464

   465

	while (er) {

   466

		next = er->next;

   467

		DeleteEngineRenew(er);

   468

		er = next;

   469

	}

   470

	*erl = NULL; // Empty list

   471

}

   472

   473

EngineID EngineReplacement(EngineRenewList erl, EngineID engine)

   474

{

   475

	const EngineRenew *er = GetEngineReplacement(erl, engine);

   476

	return er == NULL ? INVALID_ENGINE : er->to;

   477

}

   478

   479

int32 AddEngineReplacement(EngineRenewList *erl, EngineID old_engine, EngineID new_engine, uint32 flags)

   480

{

   481

	EngineRenew *er;

   482

   483

	/* Check if the old vehicle is already in the list */

   484

	er = GetEngineReplacement(*erl, old_engine);

   485

	if (er != NULL) {

   486

		if (flags & DC_EXEC) er->to = new_engine;

   487

		return 0;

   488

	}

   489

   490

	er = AllocateEngineRenew();

   491