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

    18

#include "date.h"

    19

#include "table/engines.h"

    20

    21

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    22

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    23

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    24

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    25

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    26

    27

enum {

    28

	ENGINE_AVAILABLE   = 1,

    29

	ENGINE_INTRODUCING = 2,

    30

	ENGINE_PREVIEWING  = 4,

    31

};

    32

    33

enum {

    34

	YEAR_ENGINE_AGING_STOPS = 2050,

    35

};

    36

    37

/** Bitmasked values of what type of cargo is refittable for the given vehicle-type.

    38

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    39

 * us exactly what is refittable and what is not */

    40

#define MC(cargo) (1 << cargo)

    41

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    42

	/* Trains */

    43

	MC(GC_PASSENGERS) | MC(GC_COAL)      | MC(GC_MAIL)   | MC(GC_LIVESTOCK) | MC(GC_GOODS)        | MC(GC_GRAIN)      | MC(GC_WOOD)    | MC(GC_IRON_ORE)    |

    44

	MC(GC_STEEL)      | MC(GC_VALUABLES) | MC(GC_PAPER)  | MC(GC_FOOD)      | MC(GC_FRUIT)        | MC(GC_COPPER_ORE) | MC(GC_WATER)   | MC(GC_SUGAR)       |

    45

	MC(GC_TOYS)       | MC(GC_CANDY)     | MC(GC_TOFFEE) | MC(GC_COLA)      | MC(GC_COTTON_CANDY) | MC(GC_BUBBLES)    | MC(GC_PLASTIC) | MC(GC_FIZZY_DRINKS),

    46

	/* Road vehicles (not refittable by default) */

    47

	0,

    48

	/* Ships */

    49

	MC(GC_COAL)  | MC(GC_MAIL)   | MC(GC_LIVESTOCK) | MC(GC_GOODS)        | MC(GC_GRAIN)   | MC(GC_WOOD)    | MC(GC_IRON_ORE) | MC(GC_STEEL) | MC(GC_VALUABLES) |

    50

	MC(GC_PAPER) | MC(GC_FOOD)   | MC(GC_FRUIT)     | MC(GC_COPPER_ORE)   | MC(GC_WATER)   | MC(GC_RUBBER)  | MC(GC_SUGAR)    | MC(GC_TOYS)  | MC(GC_BATTERIES) |

    51

	MC(GC_CANDY) | MC(GC_TOFFEE) | MC(GC_COLA)      | MC(GC_COTTON_CANDY) | MC(GC_BUBBLES) | MC(GC_PLASTIC) | MC(GC_FIZZY_DRINKS),

    52

	/* Aircraft */

    53

	MC(GC_PASSENGERS) | MC(GC_MAIL)  | MC(GC_GOODS)  | MC(GC_VALUABLES) | MC(GC_FOOD)         | MC(GC_FRUIT)   | MC(GC_SUGAR)   | MC(GC_TOYS) |

    54

	MC(GC_BATTERIES)  | MC(GC_CANDY) | MC(GC_TOFFEE) | MC(GC_COLA)      | MC(GC_COTTON_CANDY) | MC(GC_BUBBLES) | MC(GC_PLASTIC) | MC(GC_FIZZY_DRINKS),

    55

	/* Special/Disaster */

    56

	0,0

    57

};

    58

#undef MC

    59

    60

void ShowEnginePreviewWindow(EngineID engine);

    61

    62

void DeleteCustomEngineNames(void)

    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(void)

    77

{

    78

	/* XXX: not done */

    79

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

    80

}

    81

    82

static void SetupEngineNames(void)

    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

static void AdjustAvailAircraft(void)

    94

{

    95

	byte avail = 0;

    96

	if (_cur_year >= 1955) avail |= 2; // big airport

    97

	if (_cur_year <  1960 || _patches.always_small_airport) avail |= 1;  // small airport

    98

	if (_cur_year >= 1963) avail |= 4; // enable heliport

    99

   100

	if (avail != _avail_aircraft) {

   101

		_avail_aircraft = avail;

   102

		InvalidateWindow(WC_BUILD_STATION, 0);

   103

	}

   104

}

   105

   106

static void CalcEngineReliability(Engine *e)

   107

{

   108

	uint age = e->age;

   109

   110

	if (age < e->duration_phase_1) {

   111

		uint start = e->reliability_start;

   112

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

   113

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

   114

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

   115

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

   116

		e->reliability = e->reliability_max;

   117

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

   118

		uint max = e->reliability_max;

   119

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

   120

	} else {

   121

		/* time's up for this engine.

   122

		 * We will now completely retire this design */

   123

		e->player_avail = 0;

   124

		e->reliability = e->reliability_final;

   125

		InvalidateWindowClassesData(WC_BUILD_VEHICLE); // Kick this engine out of the lists

   126

	}

   127

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

   128

}

   129

   130

void AddTypeToEngines(void)

   131

{

   132

	Engine* e = _engines;

   133

   134

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

   135

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

   136

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

   137

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

   138

	do e->type = VEH_Special;  while (++e < endof(_engines));

   139

}

   140

   141

void StartupEngines(void)

   142

{

   143

	Engine *e;

   144

	const EngineInfo *ei;

   145

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

   146

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

   147

   148

	SetupEngineNames();

   149

   150

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

   151

		uint32 r;

   152

   153

		e->age = 0;

   154

		e->railtype = ei->railtype;

   155

		e->flags = 0;

   156

		e->player_avail = 0;

   157

   158

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

   159

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

   160

		// added.

   161

		r = Random();

   162

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

   163

		if (e->intro_date <= _date) {

   164

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

   165

			e->player_avail = (byte)-1;

   166

			e->flags |= ENGINE_AVAILABLE;

   167

		}

   168

   169

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

   170

		r = Random();

   171

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

   172

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

   173

   174

		r = Random();

   175

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

   176

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

   177

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

   178

   179

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

   180

   181

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

   182

		if (ei->unk2 & 0x80) {

   183

			e->age = 0xFFFF;

   184

		} else {

   185

			CalcEngineReliability(e);

   186

		}

   187

   188

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

   189

   190

		// prevent certain engines from ever appearing.

   191

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

   192

			e->flags |= ENGINE_AVAILABLE;

   193

			e->player_avail = 0;

   194

		}

   195

   196

		/* This sets up type for the engine

   197

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

   198

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

   199

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

   200

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

   201

	}

   202

   203

	AdjustAvailAircraft();

   204

}

   205

   206

static void AcceptEnginePreview(Engine *e, PlayerID player)

   207

{

   208

	Player *p = GetPlayer(player);

   209

   210

	assert(e->railtype < RAILTYPE_END);

   211

	SETBIT(e->player_avail, player);

   212

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

   213

   214

	e->preview_player = 0xFF;

   215

	if (player == _local_player) {

   216

		InvalidateWindowClassesData(WC_BUILD_VEHICLE);

   217

		InvalidateWindowClasses(WC_BUILD_VEHICLE);

   218

		InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   219

	}

   220

}

   221

   222

static PlayerID GetBestPlayer(PlayerID pp)

   223

{

   224

	const Player *p;

   225

	int32 best_hist;

   226

	PlayerID best_player;

   227

	uint mask = 0;

   228

   229

	do {

   230

		best_hist = -1;

   231

		best_player = OWNER_SPECTATOR;

   232

		FOR_ALL_PLAYERS(p) {

   233

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

   234

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

   235

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

   236

				best_player = p->index;

   237

			}

   238

		}

   239

   240

		if (best_player == OWNER_SPECTATOR) return OWNER_SPECTATOR;

   241

   242

		SETBIT(mask, best_player);

   243

	} while (--pp != 0);

   244

   245

	return best_player;

   246

}

   247

   248

void EnginesDailyLoop(void)

   249

{

   250

	EngineID i;

   251

   252

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   253

   254

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

   255

		Engine *e = &_engines[i];

   256

   257

		if (e->flags & ENGINE_INTRODUCING) {

   258

			if (e->flags & ENGINE_PREVIEWING) {

   259

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

   260

					e->flags &= ~ENGINE_PREVIEWING;

   261

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   262

					e->preview_player++;

   263

				}

   264

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

   265

				PlayerID best_player = GetBestPlayer(e->preview_player);

   266

   267

				if (best_player == OWNER_SPECTATOR) {

   268

					e->preview_player = 0xFF;

   269

					continue;

   270

				}

   271

   272

				if (!IS_HUMAN_PLAYER(best_player)) {

   273

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

   274

					AcceptEnginePreview(e, best_player);

   275

				} else {

   276

					e->flags |= ENGINE_PREVIEWING;

   277

					e->preview_wait = 20;

   278

					if (IS_INTERACTIVE_PLAYER(best_player)) ShowEnginePreviewWindow(i);

   279

				}

   280

			}

   281

		}

   282

	}

   283

}

   284

   285

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

   286

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

   287

 * @param tile unused

   288

 * @param p1 engine-prototype offered

   289

 * @param p2 unused

   290

 */

   291

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

   292

{

   293

	Engine *e;

   294

   295

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   296

	e = GetEngine(p1);

   297

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

   298

   299

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

   300

   301

	return 0;

   302

}

   303

   304

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

   305

static bool IsWagon(EngineID index)

   306

{

   307

	return index < NUM_TRAIN_ENGINES && RailVehInfo(index)->flags & RVI_WAGON;

   308

}

   309

   310

static void NewVehicleAvailable(Engine *e)

   311

{

   312

	Vehicle *v;

   313

	Player *p;

   314

	EngineID index = e - _engines;

   315

   316

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

   317

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

   318

	if (e->flags & ENGINE_INTRODUCING) {

   319

		FOR_ALL_PLAYERS(p) {

   320

			uint block_preview = p->block_preview;

   321

   322

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

   323

   324

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

   325

			p->block_preview = 20;

   326

   327

			FOR_ALL_VEHICLES(v) {

   328

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

   329

						(v->type == VEH_Aircraft && v->subtype <= 2)) {

   330

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

   331

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

   332

						p->block_preview = block_preview;

   333

						break;

   334

					}

   335

				}

   336

			}

   337

		}

   338

	}

   339

   340

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

   341

	InvalidateWindowClassesData(WC_BUILD_VEHICLE);

   342

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   343

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   344

   345

	// Now available for all players

   346

	e->player_avail = (byte)-1;

   347

   348

	// Do not introduce new rail wagons

   349

	if (IsWagon(index)) return;

   350

   351

	// make maglev / monorail available

   352

	FOR_ALL_PLAYERS(p) {

   353

		if (p->is_active) {

   354

			assert(e->railtype < RAILTYPE_END);

   355

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

   356

		}

   357

	}

   358

   359

	if (index < NUM_TRAIN_ENGINES) {

   360

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

   361

	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES) {

   362

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

   363

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

   364

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

   365

	} else {

   366

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

   367

	}

   368

}

   369

   370

void EnginesMonthlyLoop(void)

   371

{

   372

	Engine *e;

   373

   374

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   375

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

   376

			// Age the vehicle

   377

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

   378

				e->age++;

   379

				CalcEngineReliability(e);

   380

			}

   381

   382

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

   383

				// Introduce it to all players

   384

				NewVehicleAvailable(e);

   385

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

   386

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

   387

				e->flags |= ENGINE_INTRODUCING;

   388

   389

				// Do not introduce new rail wagons

   390

				if (!IsWagon(e - _engines))

   391

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

   392

			}

   393

		}

   394

	}

   395

	AdjustAvailAircraft();

   396

}

   397

   398

/** Rename an engine.

   399

 * @param tile unused

   400

 * @param p1 engine ID to rename

   401

 * @param p2 unused

   402

 */

   403

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

   404

{

   405

	StringID str;

   406

   407

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

   408

   409

	str = AllocateNameUnique(_cmd_text, 0);

   410

	if (str == 0) return CMD_ERROR;

   411

   412

	if (flags & DC_EXEC) {

   413

		StringID old_str = _engine_name_strings[p1];

   414

		_engine_name_strings[p1] = str;

   415

		DeleteName(old_str);

   416

		_vehicle_design_names |= 3;

   417

		MarkWholeScreenDirty();

   418

	} else {

   419

		DeleteName(str);

   420

	}

   421

   422

	return 0;

   423

}

   424

   425

   426

/*

   427

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

   428

 * the current player, false otherwise

   429

 *

   430

 * engine = index of the engine to check

   431

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

   432

 */

   433

bool IsEngineBuildable(uint engine, byte type)

   434

{

   435

	const Engine *e;

   436

   437

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

   438

	if (!IsEngineIndex(engine)) return false;

   439

   440

	e = GetEngine(engine);

   441

   442

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

   443

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

   444

   445

	// check if it's available

   446

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

   447

   448

	return true;

   449

}

   450

   451

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

   452

 * Engine Replacement stuff

   453

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

   454

   455

static void EngineRenewPoolNewBlock(uint start_item); /* Forward declare for initializer of _engine_renew_pool */

   456

enum {

   457

	ENGINE_RENEW_POOL_BLOCK_SIZE_BITS = 3,

   458

	ENGINE_RENEW_POOL_MAX_BLOCKS      = 8000,

   459

};

   460

   461

MemoryPool _engine_renew_pool = { "EngineRe", ENGINE_RENEW_POOL_MAX_BLOCKS, ENGINE_RENEW_POOL_BLOCK_SIZE_BITS, sizeof(EngineRenew), &EngineRenewPoolNewBlock, NULL, 0, 0, NULL };

   462

   463

static void EngineRenewPoolNewBlock(uint start_item)

   464

{

   465

	EngineRenew *er;

   466

   467

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

   468

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

   469

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

   470

		er->index = start_item++;

   471

		er->from = INVALID_ENGINE;

   472

	}

   473

}

   474

   475

   476

static EngineRenew *AllocateEngineRenew(void)

   477

{

   478

	EngineRenew *er;

   479

   480

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

   481

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

   482

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

   483

		if (IsValidEngineRenew(er)) continue;

   484

   485

		er->to = INVALID_ENGINE;

   486

		er->next = NULL;

   487

		return er;

   488

	}

   489

   490

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

   491

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

   492

   493

	return NULL;

   494

}

   495