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

{

    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) {

   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

		// make it either available to all players (if never_expire_vehicles is enabled and if it was available earlier)

   121

		// or disable this engine completely

   122

		e->player_avail = (_patches.never_expire_vehicles && e->player_avail)? -1 : 0;

   123

		e->reliability = e->reliability_final;

   124

	}

   125

}

   126

   127

void AddTypeToEngines(void)

   128

{

   129

	Engine* e = _engines;

   130

   131

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

   132

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

   133

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

   134

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

   135

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

   136

}

   137

   138

void StartupEngines(void)

   139

{

   140

	Engine *e;

   141

	const EngineInfo *ei;

   142

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

   143

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

   144

   145

	SetupEngineNames();

   146

   147

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

   148

		uint32 r;

   149

   150

		e->age = 0;

   151

		e->railtype = ei->railtype;

   152

		e->flags = 0;

   153

		e->player_avail = 0;

   154

   155

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

   156

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

   157

		// added.

   158

		r = Random();

   159

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

   160

		if (e->intro_date <= _date) {

   161

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

   162

			e->player_avail = (byte)-1;

   163

			e->flags |= ENGINE_AVAILABLE;

   164

		}

   165

   166

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

   167

		r = Random();

   168

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

   169

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

   170

   171

		r = Random();

   172

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

   173

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

   174

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

   175

   176

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

   177

   178

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

   179

		if (ei->unk2 & 0x80) {

   180

			e->age = 0xFFFF;

   181

		} else {

   182

			CalcEngineReliability(e);

   183

		}

   184

   185

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

   186

   187

		// prevent certain engines from ever appearing.

   188

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

   189

			e->flags |= ENGINE_AVAILABLE;

   190

			e->player_avail = 0;

   191

		}

   192

   193

		/* This sets up type for the engine

   194

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

   195

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

   196

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

   197

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

   198

	}

   199

   200

	AdjustAvailAircraft();

   201

}

   202

   203

static void AcceptEnginePreview(Engine *e, PlayerID player)

   204

{

   205

	Player *p = GetPlayer(player);

   206

   207

	assert(e->railtype < RAILTYPE_END);

   208

	SETBIT(e->player_avail, player);

   209

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

   210

   211

	e->preview_player = 0xFF;

   212

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   213

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   214

}

   215

   216

static PlayerID GetBestPlayer(PlayerID pp)

   217

{

   218

	const Player *p;

   219

	int32 best_hist;

   220

	PlayerID best_player;

   221

	uint mask = 0;

   222

   223

	do {

   224

		best_hist = -1;

   225

		best_player = OWNER_SPECTATOR;

   226

		FOR_ALL_PLAYERS(p) {

   227

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

   228

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

   229

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

   230

				best_player = p->index;

   231

			}

   232

		}

   233

   234

		if (best_player == OWNER_SPECTATOR) return OWNER_SPECTATOR;

   235

   236

		SETBIT(mask, best_player);

   237

	} while (--pp != 0);

   238

   239

	return best_player;

   240

}

   241

   242

void EnginesDailyLoop(void)

   243

{

   244

	EngineID i;

   245

   246

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   247

   248

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

   249

		Engine *e = &_engines[i];

   250

   251

		if (e->flags & ENGINE_INTRODUCING) {

   252

			if (e->flags & ENGINE_PREVIEWING) {

   253

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

   254

					e->flags &= ~ENGINE_PREVIEWING;

   255

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   256

					e->preview_player++;

   257

				}

   258

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

   259

				PlayerID best_player = GetBestPlayer(e->preview_player);

   260

   261

				if (best_player == OWNER_SPECTATOR) {

   262

					e->preview_player = 0xFF;

   263

					continue;

   264

				}

   265

   266

				if (!IS_HUMAN_PLAYER(best_player)) {

   267

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

   268

					AcceptEnginePreview(e, best_player);

   269

				} else {

   270

					e->flags |= ENGINE_PREVIEWING;

   271

					e->preview_wait = 20;

   272

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

   273

				}

   274

			}

   275

		}

   276

	}

   277

}

   278

   279

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

   280

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

   281

 * @param tile unused

   282

 * @param p1 engine-prototype offered

   283

 * @param p2 unused

   284

 */

   285

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

   286

{

   287

	Engine *e;

   288

   289

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   290

	e = GetEngine(p1);

   291

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

   292

   293

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

   294

   295

	return 0;

   296

}

   297

   298

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

   299

static bool IsWagon(EngineID index)

   300

{

   301

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

   302

}

   303

   304

static void NewVehicleAvailable(Engine *e)

   305

{

   306

	Vehicle *v;

   307

	Player *p;

   308

	EngineID index = e - _engines;

   309

   310

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

   311

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

   312

	if (e->flags & ENGINE_INTRODUCING) {

   313

		FOR_ALL_PLAYERS(p) {

   314

			uint block_preview = p->block_preview;

   315

   316

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

   317

   318

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

   319

			p->block_preview = 20;

   320

   321

			FOR_ALL_VEHICLES(v) {

   322

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

   323

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

   324

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

   325

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

   326

						p->block_preview = block_preview;

   327

						break;

   328

					}

   329

				}

   330

			}

   331

		}

   332

	}

   333

   334

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

   335

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   336

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   337

   338

	// Now available for all players

   339

	e->player_avail = (byte)-1;

   340

   341

	// Do not introduce new rail wagons

   342

	if (IsWagon(index)) return;

   343

   344

	// make maglev / monorail available

   345

	FOR_ALL_PLAYERS(p) {

   346

		if (p->is_active) {

   347

			assert(e->railtype < RAILTYPE_END);

   348

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

   349

		}

   350

	}

   351

   352

	if (index < NUM_TRAIN_ENGINES) {

   353

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

   354

	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES) {

   355

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

   356

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

   357

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

   358

	} else {

   359

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

   360

	}

   361

}

   362

   363

void EnginesMonthlyLoop(void)

   364

{

   365

	Engine *e;

   366

   367

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   368

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

   369

			// Age the vehicle

   370

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

   371

				e->age++;

   372

				CalcEngineReliability(e);

   373

			}

   374

   375

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

   376

				// Introduce it to all players

   377

				NewVehicleAvailable(e);

   378

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

   379

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

   380

				e->flags |= ENGINE_INTRODUCING;

   381

   382

				// Do not introduce new rail wagons

   383

				if (!IsWagon(e - _engines))

   384

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

   385

			}

   386

		}

   387

	}

   388

	AdjustAvailAircraft();

   389

}

   390

   391

/** Rename an engine.

   392

 * @param tile unused

   393

 * @param p1 engine ID to rename

   394

 * @param p2 unused

   395

 */

   396

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

   397

{

   398

	StringID str;

   399

   400

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

   401

   402

	str = AllocateNameUnique(_cmd_text, 0);

   403

	if (str == 0) return CMD_ERROR;

   404

   405

	if (flags & DC_EXEC) {

   406

		StringID old_str = _engine_name_strings[p1];

   407

		_engine_name_strings[p1] = str;

   408

		DeleteName(old_str);

   409

		_vehicle_design_names |= 3;

   410

		MarkWholeScreenDirty();

   411

	} else {

   412

		DeleteName(str);

   413

	}

   414

   415

	return 0;

   416

}

   417

   418

   419

/*

   420

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

   421

 * the current player, false otherwise

   422

 *

   423

 * engine = index of the engine to check

   424

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

   425

 */

   426

bool IsEngineBuildable(uint engine, byte type)

   427

{

   428

	const Engine *e;

   429

   430

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

   431

	if (!IsEngineIndex(engine)) return false;

   432

   433

	e = GetEngine(engine);

   434

   435

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

   436

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

   437

   438

	// check if it's available

   439

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

   440

   441

	return true;

   442

}

   443

   444

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

   445

 * Engine Replacement stuff

   446

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

   447

   448

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

   449

enum {

   450

	ENGINE_RENEW_POOL_BLOCK_SIZE_BITS = 3,

   451

	ENGINE_RENEW_POOL_MAX_BLOCKS      = 8000,

   452

};

   453

   454

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

   455

   456

static void EngineRenewPoolNewBlock(uint start_item)

   457

{

   458

	EngineRenew *er;

   459

   460

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

   461

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

   462

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

   463

		er->index = start_item++;

   464

		er->from = INVALID_ENGINE;

   465

	}

   466

}

   467

   468

   469

static EngineRenew *AllocateEngineRenew(void)

   470

{

   471

	EngineRenew *er;

   472

   473

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

   474

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

   475

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

   476

		if (IsValidEngineRenew(er)) continue;

   477

   478

		er->to = INVALID_ENGINE;

   479

		er->next = NULL;

   480

		return er;

   481

	}

   482

   483

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

   484

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

   485

   486

	return NULL;

   487

}

   488

   489

/**

   490

 * Retrieves the EngineRenew that specifies the replacement of the given

   491

 * engine type from the given renewlist */

   492

static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine)

   493

{

   494

	EngineRenew *er = (EngineRenew *)erl;

   495

   496

	while (er) {