1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "debug.h"

     6

#include "functions.h"

     7

#include "table/strings.h"

     8

#include "engine.h"

     9

#include "gfx.h"

    10

#include "player.h"

    11

#include "command.h"

    12

#include "vehicle.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 "date.h"

    20

#include "table/engines.h"

    21

    22

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    23

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    24

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    25

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    26

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    27

    28

enum {

    29

	ENGINE_AVAILABLE   = 1,

    30

	ENGINE_INTRODUCING = 2,

    31

	ENGINE_PREVIEWING  = 4,

    32

};

    33

    34

enum {

    35

	YEAR_ENGINE_AGING_STOPS = 2050,

    36

};

    37

    38

    39

void ShowEnginePreviewWindow(EngineID engine);

    40

    41

void DeleteCustomEngineNames(void)

    42

{

    43

	uint i;

    44

	StringID old;

    45

    46

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

    47

		old = _engine_name_strings[i];

    48

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    49

		DeleteName(old);

    50

	}

    51

    52

	_vehicle_design_names &= ~1;

    53

}

    54

    55

void LoadCustomEngineNames(void)

    56

{

    57

	/* XXX: not done */

    58

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

    59

}

    60

    61

static void SetupEngineNames(void)

    62

{

    63

	StringID *name;

    64

    65

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

    66

		*name = STR_SV_EMPTY;

    67

    68

	DeleteCustomEngineNames();

    69

	LoadCustomEngineNames();

    70

}

    71

    72

    73

static void CalcEngineReliability(Engine *e)

    74

{

    75

	uint age = e->age;

    76

    77

	if (age < e->duration_phase_1) {

    78

		uint start = e->reliability_start;

    79

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

    80

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

    81

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

    82

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

    83

		e->reliability = e->reliability_max;

    84

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

    85

		uint max = e->reliability_max;

    86

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

    87

	} else {

    88

		/* time's up for this engine.

    89

		 * We will now completely retire this design */

    90

		e->player_avail = 0;

    91

		e->reliability = e->reliability_final;

    92

		/* Kick this engine out of the lists */

    93

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

    94

	}

    95

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

    96

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

    97

}

    98

    99

void AddTypeToEngines(void)

   100

{

   101

	Engine* e = _engines;

   102

   103

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

   104

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

   105

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

   106

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

   107

}

   108

   109

void StartupEngines(void)

   110

{

   111

	Engine *e;

   112

	const EngineInfo *ei;

   113

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

   114

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

   115

   116

	SetupEngineNames();

   117

   118

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

   119

		uint32 r;

   120

   121

		e->age = 0;

   122

		e->flags = 0;

   123

		e->player_avail = 0;

   124

   125

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

   126

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

   127

		// added.

   128

		r = Random();

   129

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

   130

		if (e->intro_date <= _date) {

   131

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

   132

			e->player_avail = (byte)-1;

   133

			e->flags |= ENGINE_AVAILABLE;

   134

		}

   135

   136

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

   137

		r = Random();

   138

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

   139

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

   140

   141

		r = Random();

   142

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

   143

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

   144

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

   145

   146

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

   147

   148

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

   149

		if (ei->unk2 & 0x80) {

   150

			e->age = 0xFFFF;

   151

		} else {

   152

			CalcEngineReliability(e);

   153

		}

   154

   155

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

   156

   157

		// prevent certain engines from ever appearing.

   158

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

   159

			e->flags |= ENGINE_AVAILABLE;

   160

			e->player_avail = 0;

   161

		}

   162

   163

		/* This sets up type for the engine

   164

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

   165

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

   166

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

   167

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

   168

	}

   169

}

   170

   171

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   172

{

   173

	Engine *e = GetEngine(eid);

   174

   175

	SETBIT(e->player_avail, player);

   176

	if (e->type == VEH_Train) {

   177

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   178

		Player *p = GetPlayer(player);

   179

   180

		assert(rvi->railtype < RAILTYPE_END);

   181

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

   182

	}

   183

   184

	e->preview_player = INVALID_PLAYER;

   185

	if (player == _local_player) {

   186

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   187

	}

   188

}

   189

   190

static PlayerID GetBestPlayer(PlayerID pp)

   191

{

   192

	const Player *p;

   193

	int32 best_hist;

   194

	PlayerID best_player;

   195

	uint mask = 0;

   196

   197

	do {

   198

		best_hist = -1;

   199

		best_player = PLAYER_SPECTATOR;

   200

		FOR_ALL_PLAYERS(p) {

   201

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

   202

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

   203

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

   204

				best_player = p->index;

   205

			}

   206

		}

   207

   208

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   209

   210

		SETBIT(mask, best_player);

   211

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

   212

   213

	return best_player;

   214

}

   215

   216

void EnginesDailyLoop(void)

   217

{

   218

	EngineID i;

   219

   220

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   221

   222

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

   223

		Engine *e = &_engines[i];

   224

   225

		if (e->flags & ENGINE_INTRODUCING) {

   226

			if (e->flags & ENGINE_PREVIEWING) {

   227

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

   228

					e->flags &= ~ENGINE_PREVIEWING;

   229

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   230

					e->preview_player++;

   231

				}

   232

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

   233

				PlayerID best_player = GetBestPlayer(e->preview_player);

   234

   235

				if (best_player == PLAYER_SPECTATOR) {

   236

					e->preview_player = INVALID_PLAYER;

   237

					continue;

   238

				}

   239

   240

				if (!IsHumanPlayer(best_player)) {

   241

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

   242

					AcceptEnginePreview(i, best_player);

   243

				} else {

   244

					e->flags |= ENGINE_PREVIEWING;

   245

					e->preview_wait = 20;

   246

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

   247

				}

   248

			}

   249

		}

   250

	}

   251

}

   252

   253

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

   254

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

   255

 * @param tile unused

   256

 * @param p1 engine-prototype offered

   257

 * @param p2 unused

   258

 */

   259

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

   260

{

   261

	Engine *e;

   262

   263

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   264

	e = GetEngine(p1);

   265

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

   266

   267

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

   268

   269

	return 0;

   270

}

   271

   272

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

   273

static bool IsWagon(EngineID index)

   274

{

   275

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

   276

}

   277

   278

static void NewVehicleAvailable(Engine *e)

   279

{

   280

	Vehicle *v;

   281

	Player *p;

   282

	EngineID index = e - _engines;

   283

   284

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

   285

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

   286

	if (e->flags & ENGINE_INTRODUCING) {

   287

		FOR_ALL_PLAYERS(p) {

   288

			uint block_preview = p->block_preview;

   289

   290

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

   291

   292

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

   293

			p->block_preview = 20;

   294

   295

			FOR_ALL_VEHICLES(v) {

   296

				if (v->type == VEH_Train || v->type == VEH_Road || v->type == VEH_Ship ||

   297

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

   298

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

   299

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

   300

						p->block_preview = block_preview;

   301

						break;

   302

					}

   303

				}

   304

			}

   305

		}

   306

	}

   307

   308

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

   309

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   310

   311

	// Now available for all players

   312

	e->player_avail = (byte)-1;

   313

   314

	// Do not introduce new rail wagons

   315

	if (IsWagon(index)) return;

   316

   317

	if (index < NUM_TRAIN_ENGINES) {

   318

		// maybe make another rail type available

   319

		RailType railtype = RailVehInfo(index)->railtype;

   320

		assert(railtype < RAILTYPE_END);

   321

		FOR_ALL_PLAYERS(p) {

   322

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

   323

		}

   324

   325

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

   326

	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES) {

   327

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

   328

	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES + NUM_SHIP_ENGINES) {

   329

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

   330

	} else {

   331

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

   332

	}

   333

}

   334

   335

void EnginesMonthlyLoop(void)

   336

{

   337

	Engine *e;

   338

   339

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   340

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

   341

			// Age the vehicle

   342

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

   343

				e->age++;

   344

				CalcEngineReliability(e);

   345

			}

   346

   347

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

   348

				// Introduce it to all players

   349

				NewVehicleAvailable(e);

   350

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

   351

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

   352

				e->flags |= ENGINE_INTRODUCING;

   353

   354

				// Do not introduce new rail wagons

   355

				if (!IsWagon(e - _engines))

   356

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

   357

			}

   358

		}

   359

	}

   360

}

   361

   362

/** Rename an engine.

   363

 * @param tile unused

   364

 * @param p1 engine ID to rename

   365

 * @param p2 unused

   366

 */

   367

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

   368

{

   369

	StringID str;

   370

   371

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

   372

   373

	str = AllocateNameUnique(_cmd_text, 0);

   374

	if (str == 0) return CMD_ERROR;

   375

   376

	if (flags & DC_EXEC) {

   377

		StringID old_str = _engine_name_strings[p1];

   378

		_engine_name_strings[p1] = str;

   379

		DeleteName(old_str);

   380

		_vehicle_design_names |= 3;

   381

		MarkWholeScreenDirty();

   382

	} else {

   383

		DeleteName(str);

   384

	}

   385

   386

	return 0;

   387

}

   388

   389

   390

/*

   391

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

   392

 * the given player, false otherwise

   393

 *

   394

 * engine = index of the engine to check

   395

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

   396

 * player = index of the player

   397

 */

   398

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

   399

{

   400

	const Engine *e;

   401

   402

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

   403

	if (!IsEngineIndex(engine)) return false;

   404

   405

	e = GetEngine(engine);

   406

   407

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

   408

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

   409

   410

	// check if it's available

   411

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

   412

   413

	return true;

   414

}

   415

   416

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

   417

 * Engine Replacement stuff

   418

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

   419

   420

static void EngineRenewPoolNewBlock(uint start_item);

   421

   422

DEFINE_OLD_POOL(EngineRenew, EngineRenew, EngineRenewPoolNewBlock, NULL)

   423

   424

static void EngineRenewPoolNewBlock(uint start_item)

   425

{

   426

	EngineRenew *er;

   427

   428

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

   429

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

   430

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

   431

		er->index = start_item++;

   432

		er->from = INVALID_ENGINE;

   433

	}

   434

}

   435

   436

   437

static EngineRenew *AllocateEngineRenew(void)

   438

{

   439

	EngineRenew *er;

   440

   441

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

   442

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

   443

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

   444

		if (IsValidEngineRenew(er)) continue;

   445

   446

		er->to = INVALID_ENGINE;

   447

		er->next = NULL;

   448

		return er;

   449

	}

   450

   451

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

   452

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

   453

   454

	return NULL;

   455

}

   456

   457

/**

   458

 * Retrieves the EngineRenew that specifies the replacement of the given

   459

 * engine type from the given renewlist */

   460

static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine)

   461

{

   462

	EngineRenew *er = (EngineRenew *)erl;

   463

   464

	while (er) {

   465

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

   466

		er = er->next;

   467

	}

   468

	return NULL;

   469

}

   470

   471

void RemoveAllEngineReplacement(EngineRenewList *erl)

   472

{

   473

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

   474

	EngineRenew *next;

   475

   476

	while (er) {

   477

		next = er->next;

   478

		DeleteEngineRenew(er);

   479

		er = next;

   480

	}

   481

	*erl = NULL; // Empty list

   482

}

   483

   484

EngineID EngineReplacement(EngineRenewList erl, EngineID engine)

   485

{

   486

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

   487

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

   488

}

   489

   490

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

   491

{

   492

	EngineRenew *er;

   493