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 "table/engines.h"

    10

#include "gfx.h"

    11

#include "player.h"

    12

#include "command.h"

    13

#include "vehicle.h"

    14

#include "news.h"

    15

#include "saveload.h"

    16

#include "variables.h"

    17

#include "train.h"

    18

#include "newgrf_cargo.h"

    19

    20

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    21

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    22

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    23

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    24

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    25

    26

enum {

    27

	ENGINE_AVAILABLE = 1,

    28

	ENGINE_INTRODUCING = 2,

    29

	ENGINE_PREVIEWING = 4,

    30

};

    31

    32

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

    33

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    34

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

    35

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

    36

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    37

	/* Trains */

    38

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

    39

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

    40

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

    41

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

    42

	0,

    43

	/* Ships */

    44

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

    45

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

    46

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

    47

	/* Aircraft */

    48

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

    49

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

    50

	/* Special/Disaster */

    51

	0,0

    52

};

    53

#undef MC

    54

    55

void ShowEnginePreviewWindow(EngineID engine);

    56

    57

void DeleteCustomEngineNames(void)

    58

{

    59

	uint i;

    60

	StringID old;

    61

    62

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

    63

		old = _engine_name_strings[i];

    64

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    65

		DeleteName(old);

    66

	}

    67

    68

	_vehicle_design_names &= ~1;

    69

}

    70

    71

void LoadCustomEngineNames(void)

    72

{

    73

	// XXX: not done */

    74

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

    75

}

    76

    77

static void SetupEngineNames(void)

    78

{

    79

	StringID *name;

    80

    81

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

    82

		*name = STR_SV_EMPTY;

    83

    84

	DeleteCustomEngineNames();

    85

	LoadCustomEngineNames();

    86

}

    87

    88

static void AdjustAvailAircraft(void)

    89

{

    90

	uint16 date = _date;

    91

	byte avail = 0;

    92

	if (date >= 12784) avail |= 2; // big airport

    93

	if (date < 14610 || _patches.always_small_airport) avail |= 1;  // small airport

    94

	if (date >= 15706) avail |= 4; // enable heliport

    95

    96

	if (avail != _avail_aircraft) {

    97

		_avail_aircraft = avail;

    98

		InvalidateWindow(WC_BUILD_STATION, 0);

    99

	}

   100

}

   101

   102

static void CalcEngineReliability(Engine *e)

   103

{

   104

	uint age = e->age;

   105

   106

	if (age < e->duration_phase_1) {

   107

		uint start = e->reliability_start;

   108

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

   109

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

   110

		e->reliability = e->reliability_max;

   111

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

   112

		uint max = e->reliability_max;

   113

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

   114

	} else {

   115

		// time's up for this engine

   116

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

   117

		// or disable this engine completely

   118

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

   119

		e->reliability = e->reliability_final;

   120

	}

   121

}

   122

   123

void AddTypeToEngines(void)

   124

{

   125

	Engine* e = _engines;

   126

   127

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

   128

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

   129

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

   130

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

   131

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

   132

}

   133

   134

void StartupEngines(void)

   135

{

   136

	Engine *e;

   137

	const EngineInfo *ei;

   138

   139

	SetupEngineNames();

   140

   141

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

   142

		uint32 r;

   143

   144

		e->age = 0;

   145

		e->railtype = ei->railtype;

   146

		e->flags = 0;

   147

		e->player_avail = 0;

   148

   149

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

   150

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

   151

		// added.

   152

		r = Random();

   153

		e->intro_date = ei->base_intro <= 729 ? ei->base_intro : GB(r, 0, 9) + ei->base_intro;

   154

		if (e->intro_date <= _date) {

   155

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

   156

			e->player_avail = (byte)-1;

   157

			e->flags |= ENGINE_AVAILABLE;

   158

		}

   159

   160

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

   161

		r = Random();

   162

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

   163

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

   164

   165

		r = Random();

   166

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

   167

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

   168

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

   169

   170

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

   171

   172

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

   173

		if (ei->unk2 & 0x80) {

   174

			e->age = 0xFFFF;

   175

		} else {

   176

			CalcEngineReliability(e);

   177

		}

   178

   179

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

   180

   181

		// prevent certain engines from ever appearing.

   182

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

   183

			e->flags |= ENGINE_AVAILABLE;

   184

			e->player_avail = 0;

   185

		}

   186

   187

		/* This sets up type for the engine

   188

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

   189

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

   190

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

   191

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

   192

	}

   193

   194

	AdjustAvailAircraft();

   195

}

   196

   197

static void AcceptEnginePreview(Engine *e, PlayerID player)

   198

{

   199

	Player *p = GetPlayer(player);

   200

   201

	assert(e->railtype < RAILTYPE_END);

   202

	SETBIT(e->player_avail, player);

   203

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

   204

   205

	e->preview_player = 0xFF;

   206

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   207

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   208

}

   209

   210

static PlayerID GetBestPlayer(PlayerID pp)

   211

{

   212

	const Player *p;

   213

	int32 best_hist;

   214

	PlayerID best_player;

   215

	uint mask = 0;

   216

   217

	do {

   218

		best_hist = -1;

   219

		best_player = OWNER_SPECTATOR;

   220

		FOR_ALL_PLAYERS(p) {

   221

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

   222

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

   223

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

   224

				best_player = p->index;

   225

			}

   226

		}

   227

   228

		if (best_player == OWNER_SPECTATOR) return OWNER_SPECTATOR;

   229

   230

		SETBIT(mask, best_player);

   231

	} while (--pp != 0);

   232

   233

	return best_player;

   234

}

   235

   236

void EnginesDailyLoop(void)

   237

{

   238

	EngineID i;

   239

   240

	if (_cur_year >= 130) return;

   241

   242

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

   244

   245

		if (e->flags & ENGINE_INTRODUCING) {

   246

			if (e->flags & ENGINE_PREVIEWING) {

   247

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

   248

					e->flags &= ~ENGINE_PREVIEWING;

   249

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   250

					e->preview_player++;

   251

				}

   252

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

   253

				PlayerID best_player = GetBestPlayer(e->preview_player);

   254

   255

				if (best_player == OWNER_SPECTATOR) {

   256

					e->preview_player = 0xFF;

   257

					continue;

   258

				}

   259

   260

				if (!IS_HUMAN_PLAYER(best_player)) {

   261

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

   262

					AcceptEnginePreview(e, best_player);

   263

				} else {

   264

					e->flags |= ENGINE_PREVIEWING;

   265

					e->preview_wait = 20;

   266

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

   267

				}

   268

			}

   269

		}

   270

	}

   271

}

   272

   273

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

   274

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

   275

 * @param tile unused

   276

 * @param p1 engine-prototype offered

   277

 * @param p2 unused

   278

 */

   279

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

   280

{

   281

	Engine *e;

   282

   283

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   284

	e = GetEngine(p1);

   285

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

   286

   287

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

   288

   289

	return 0;

   290

}

   291

   292

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

   293

static bool IsWagon(EngineID index)

   294

{

   295

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

   296

}

   297

   298

static void NewVehicleAvailable(Engine *e)

   299

{

   300

	Vehicle *v;

   301

	Player *p;

   302

	EngineID index = e - _engines;

   303

   304

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

   305

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

   306

	if (e->flags & ENGINE_INTRODUCING) {

   307

		FOR_ALL_PLAYERS(p) {

   308

			uint block_preview = p->block_preview;

   309

   310

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

   311

   312

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

   313

			p->block_preview = 20;

   314

   315

			FOR_ALL_VEHICLES(v) {

   316

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

   317

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

   318

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

   319

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

   320

						p->block_preview = block_preview;

   321

						break;

   322

					}

   323

				}

   324

			}

   325

		}

   326

	}

   327

   328

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

   329

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   330

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   331

   332

	// Now available for all players

   333

	e->player_avail = (byte)-1;

   334

   335

	// Do not introduce new rail wagons

   336

	if (IsWagon(index)) return;

   337

   338

	// make maglev / monorail available

   339

	FOR_ALL_PLAYERS(p) {

   340

		if (p->is_active) {

   341

			assert(e->railtype < RAILTYPE_END);

   342

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

   343

		}

   344

	}

   345

   346

	if (index < NUM_TRAIN_ENGINES) {

   347

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

   348

	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES) {

   349

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

   350

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

   351

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

   352

	} else {

   353

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

   354

	}

   355

}

   356

   357

void EnginesMonthlyLoop(void)

   358

{

   359

	Engine *e;

   360

   361

	if (_cur_year < 130) {

   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_INTRODUCING)) && _date >= e->intro_date) {

   373

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

   374

				e->flags |= ENGINE_INTRODUCING;

   375

   376

				// Do not introduce new rail wagons

   377

				if (!IsWagon(e - _engines))

   378

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

   379

			}

   380

		}

   381

	}

   382

	AdjustAvailAircraft();

   383

}

   384

   385

/** Rename an engine.

   386

 * @param tile unused

   387

 * @param p1 engine ID to rename

   388

 * @param p2 unused

   389

 */

   390

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

   391

{

   392

	StringID str;

   393

   394

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

   395

   396

	str = AllocateNameUnique(_cmd_text, 0);

   397

	if (str == 0) return CMD_ERROR;

   398

   399

	if (flags & DC_EXEC) {

   400

		StringID old_str = _engine_name_strings[p1];

   401

		_engine_name_strings[p1] = str;

   402

		DeleteName(old_str);

   403

		_vehicle_design_names |= 3;

   404

		MarkWholeScreenDirty();

   405

	} else {

   406

		DeleteName(str);

   407

	}

   408

   409

	return 0;

   410

}

   411

   412

   413

/*

   414

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

   415

 * the current player, false otherwise

   416

 *

   417

 * engine = index of the engine to check

   418

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

   419

 */

   420

bool IsEngineBuildable(uint engine, byte type)

   421

{

   422

	const Engine *e;

   423

   424

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

   425

	if (!IsEngineIndex(engine)) return false;

   426

   427

	e = GetEngine(engine);

   428

   429

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

   430

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

   431

   432

	// check if it's available

   433

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

   434

   435

	return true;

   436

}

   437

   438

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

   439

 * Engine Replacement stuff

   440

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

   441

   442

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

   443

enum {

   444

	ENGINE_RENEW_POOL_BLOCK_SIZE_BITS = 3,

   445

	ENGINE_RENEW_POOL_MAX_BLOCKS      = 8000,

   446

};

   447

   448

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

   449

   450

static inline uint16 GetEngineRenewPoolSize(void)

   451

{

   452

	return _engine_renew_pool.total_items;

   453

}

   454

   455

#define FOR_ALL_ENGINE_RENEWS_FROM(er, start) for (er = GetEngineRenew(start); er != NULL; er = (er->index + 1 < GetEngineRenewPoolSize()) ? GetEngineRenew(er->index + 1) : NULL)

   456

#define FOR_ALL_ENGINE_RENEWS(er) FOR_ALL_ENGINE_RENEWS_FROM(er, 0)

   457

   458

static void EngineRenewPoolNewBlock(uint start_item)

   459

{

   460

	EngineRenew *er;

   461

   462

	FOR_ALL_ENGINE_RENEWS_FROM(er, start_item) {

   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

	FOR_ALL_ENGINE_RENEWS(er) {

   474

		if (er->from == INVALID_ENGINE) {

   475

			er->to = INVALID_ENGINE;

   476

			er->next = NULL;

   477

			return er;

   478

		}

   479

	}

   480

   481

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

   482

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

   483

   484

	return NULL;

   485

}

   486

   487

/**

   488

 * Retrieves the EngineRenew that specifies the replacement of the given

   489

 * engine type from the given renewlist */

   490

static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine)

   491

{

   493

	while (er) {

   494

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

   495

		er = er->next;

   496

	}

   497

	return NULL;

   498

}