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"

    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

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

    34

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    35

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

    36

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

    37

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    38

	/* Trains */

    39

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

    40

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

    41

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

    42

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

    43

	0,

    44

	/* Ships */

    45

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

    46

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

    47

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

    48

	/* Aircraft */

    49

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

    50

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

    51

	/* Special/Disaster */

    52

	0,0

    53

};

    54

#undef MC

    55

    56

void ShowEnginePreviewWindow(EngineID engine);

    57

    58

void DeleteCustomEngineNames(void)

    59

{

    60

	uint i;

    61

	StringID old;

    62

    63

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

    64

		old = _engine_name_strings[i];

    65

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    66

		DeleteName(old);

    67

	}

    68

    69

	_vehicle_design_names &= ~1;

    70

}

    71

    72

void LoadCustomEngineNames(void)

    73

{

    74

	// XXX: not done */

    75

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

    76

}

    77

    78

static void SetupEngineNames(void)

    79

{

    80

	StringID *name;

    81

    82

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

    83

		*name = STR_SV_EMPTY;

    84

    85

	DeleteCustomEngineNames();

    86

	LoadCustomEngineNames();

    87

}

    88

    89

static void AdjustAvailAircraft(void)

    90

{

    91

	uint16 date = _date;

    92

	byte avail = 0;

    93

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

    94

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

    95

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

    96

    97

	if (avail != _avail_aircraft) {

    98

		_avail_aircraft = avail;

    99

		InvalidateWindow(WC_BUILD_STATION, 0);

   100

	}

   101

}

   102

   103

static void CalcEngineReliability(Engine *e)

   104

{

   105

	uint age = e->age;

   106

   107

	if (age < e->duration_phase_1) {

   108

		uint start = e->reliability_start;

   109

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

   110

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

   111

		e->reliability = e->reliability_max;

   112

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

   113

		uint max = e->reliability_max;

   114

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

   115

	} else {

   116

		// time's up for this engine

   117

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

   118

		// or disable this engine completely

   119

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

   120

		e->reliability = e->reliability_final;

   121

	}

   122

}

   123

   124

void AddTypeToEngines(void)

   125

{

   126

	Engine* e = _engines;

   127

   128

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

   129

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

   130

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

   131

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

   132

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

   133

}

   134

   135

void StartupEngines(void)

   136

{

   137

	Engine *e;

   138

	const EngineInfo *ei;

   139

   140

	SetupEngineNames();

   141

   142

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

   143

		uint32 r;

   144

   145

		e->age = 0;

   146

		e->railtype = ei->railtype;

   147

		e->flags = 0;

   148

		e->player_avail = 0;

   149

   150

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

   151

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

   152

		// added.

   153

		r = Random();

   154

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

   155

		if (e->intro_date <= _date) {

   156

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

   157

			e->player_avail = (byte)-1;

   158

			e->flags |= ENGINE_AVAILABLE;

   159

		}

   160

   161

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

   162

		r = Random();

   163

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

   164

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

   165

   166

		r = Random();

   167

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

   168

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

   169

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

   170

   171

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

   172

   173

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

   174

		if (ei->unk2 & 0x80) {

   175

			e->age = 0xFFFF;

   176

		} else {

   177

			CalcEngineReliability(e);

   178

		}

   179

   180

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

   181

   182

		// prevent certain engines from ever appearing.

   183

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

   184

			e->flags |= ENGINE_AVAILABLE;

   185

			e->player_avail = 0;

   186

		}

   187

   188

		/* This sets up type for the engine

   189

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

   190

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

   191

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

   192

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

   193

	}

   194

   195

	AdjustAvailAircraft();

   196

}

   197

   198

static void AcceptEnginePreview(Engine *e, PlayerID player)

   199

{

   200

	Player *p = GetPlayer(player);

   201

   202

	assert(e->railtype < RAILTYPE_END);

   203

	SETBIT(e->player_avail, player);

   204

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

   205

   206

	e->preview_player = 0xFF;

   207

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   208

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   209

}

   210

   211

static PlayerID GetBestPlayer(PlayerID pp)

   212

{

   213

	const Player *p;

   214

	int32 best_hist;

   215

	PlayerID best_player;

   216

	uint mask = 0;

   217

   218

	do {

   219

		best_hist = -1;

   220

		best_player = OWNER_SPECTATOR;

   221

		FOR_ALL_PLAYERS(p) {

   222

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

   223

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

   224

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

   225

				best_player = p->index;

   226

			}

   227

		}

   228

   229

		if (best_player == OWNER_SPECTATOR) return OWNER_SPECTATOR;

   230

   231

		SETBIT(mask, best_player);

   232

	} while (--pp != 0);

   233

   234

	return best_player;

   235

}

   236

   237

void EnginesDailyLoop(void)

   238

{

   239

	EngineID i;

   240

   241

	if (_cur_year >= 130) return;

   242

   243

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

   244

		Engine *e = &_engines[i];

   245

   246

		if (e->flags & ENGINE_INTRODUCING) {

   247

			if (e->flags & ENGINE_PREVIEWING) {

   248

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

   249

					e->flags &= ~ENGINE_PREVIEWING;

   250

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   251

					e->preview_player++;

   252

				}

   253

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

   254

				PlayerID best_player = GetBestPlayer(e->preview_player);

   255

   256

				if (best_player == OWNER_SPECTATOR) {

   257

					e->preview_player = 0xFF;

   258

					continue;

   259

				}

   260

   261

				if (!IS_HUMAN_PLAYER(best_player)) {

   262

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

   263

					AcceptEnginePreview(e, best_player);

   264

				} else {

   265

					e->flags |= ENGINE_PREVIEWING;

   266

					e->preview_wait = 20;

   267

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

   268

				}

   269

			}

   270

		}

   271

	}

   272

}

   273

   274

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

   275

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

   276

 * @param tile unused

   277

 * @param p1 engine-prototype offered

   278

 * @param p2 unused

   279

 */

   280

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

   281

{

   282

	Engine *e;

   283

   284

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   285

	e = GetEngine(p1);

   286

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

   287

   288

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

   289

   290

	return 0;

   291

}

   292

   293

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

   294

static bool IsWagon(EngineID index)

   295

{

   296

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

   297

}

   298

   299

static void NewVehicleAvailable(Engine *e)

   300

{

   301

	Vehicle *v;

   302

	Player *p;

   303

	EngineID index = e - _engines;

   304

   305

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

   306

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

   307

	if (e->flags & ENGINE_INTRODUCING) {

   308

		FOR_ALL_PLAYERS(p) {

   309

			uint block_preview = p->block_preview;

   310

   311

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

   312

   313

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

   314

			p->block_preview = 20;

   315

   316

			FOR_ALL_VEHICLES(v) {

   317

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

   318

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

   319

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

   320

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

   321

						p->block_preview = block_preview;

   322

						break;

   323

					}

   324

				}

   325

			}

   326

		}

   327

	}

   328

   329

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

   330

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   331

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   332

   333

	// Now available for all players

   334

	e->player_avail = (byte)-1;

   335

   336

	// Do not introduce new rail wagons

   337

	if (IsWagon(index)) return;

   338

   339

	// make maglev / monorail available

   340

	FOR_ALL_PLAYERS(p) {

   341

		if (p->is_active) {

   342

			assert(e->railtype < RAILTYPE_END);

   343

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

   344

		}

   345

	}

   346

   347

	if (index < NUM_TRAIN_ENGINES) {

   348

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

   349

	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES) {

   350

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

   351

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

   352

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

   353

	} else {

   354

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

   355

	}

   356

}

   357

   358

void EnginesMonthlyLoop(void)

   359

{

   360

	Engine *e;

   361

   362

	if (_cur_year < 130) {

   363

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

   364

			// Age the vehicle

   365

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

   366

				e->age++;

   367

				CalcEngineReliability(e);

   368

			}

   369

   370

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

   371

				// Introduce it to all players

   372

				NewVehicleAvailable(e);

   373

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

   374

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

   375

				e->flags |= ENGINE_INTRODUCING;

   376

   377

				// Do not introduce new rail wagons

   378

				if (!IsWagon(e - _engines))

   379

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

   380

			}

   381

		}

   382

	}

   383

	AdjustAvailAircraft();

   384

}

   385

   386

/** Rename an engine.

   387

 * @param tile unused

   388

 * @param p1 engine ID to rename

   389

 * @param p2 unused

   390

 */

   391

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

   392

{

   393

	StringID str;

   394

   395

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

   396

   397

	str = AllocateNameUnique(_cmd_text, 0);

   398

	if (str == 0) return CMD_ERROR;

   399

   400

	if (flags & DC_EXEC) {

   401

		StringID old_str = _engine_name_strings[p1];

   402

		_engine_name_strings[p1] = str;

   403

		DeleteName(old_str);

   404

		_vehicle_design_names |= 3;

   405

		MarkWholeScreenDirty();

   406

	} else {

   407

		DeleteName(str);

   408

	}

   409

   410

	return 0;

   411

}

   412

   413

   414

/*

   415

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

   416

 * the current player, false otherwise

   417

 *

   418

 * engine = index of the engine to check

   419

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

   420

 */

   421

bool IsEngineBuildable(uint engine, byte type)

   422

{

   423

	const Engine *e;

   424

   425

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

   426

	if (!IsEngineIndex(engine)) return false;

   427

   428

	e = GetEngine(engine);

   429

   430

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

   431

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

   432

   433

	// check if it's available

   434

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

   435

   436

	return true;

   437

}

   438

   439

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

   440

 * Engine Replacement stuff

   441

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

   442

   443

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

   444

enum {

   445

	ENGINE_RENEW_POOL_BLOCK_SIZE_BITS = 3,

   446

	ENGINE_RENEW_POOL_MAX_BLOCKS      = 8000,

   447

};

   448

   449

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

   450

   451

static inline uint16 GetEngineRenewPoolSize(void)

   452

{

   453

	return _engine_renew_pool.total_items;

   454

}

   455

   456

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

   457

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

   458

   459

static void EngineRenewPoolNewBlock(uint start_item)

   460

{

   461

	EngineRenew *er;

   462

   463

	FOR_ALL_ENGINE_RENEWS_FROM(er, start_item) {

   464

		er->index = start_item++;

   465

		er->from = INVALID_ENGINE;

   466

	}

   467

}

   468

   469

   470

static EngineRenew *AllocateEngineRenew(void)

   471

{

   472

	EngineRenew *er;

   473

   474

	FOR_ALL_ENGINE_RENEWS(er) {

   475

		if (er->from == INVALID_ENGINE) {

   476

			er->to = INVALID_ENGINE;

   477

			er->next = NULL;

   478

			return er;

   479

		}

   480

	}

   481

   482

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

   483

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

   484

   485

	return NULL;

   486

}

   487

   488

/**

   489

 * Retrieves the EngineRenew that specifies the replacement of the given

   490

 * engine type from the given renewlist */

   491

static EngineRenew *GetEngineReplacement(EngineRenewList erl, EngineID engine)

   492

{

   493

	EngineRenew *er = (EngineRenew*)erl; /* Fetch first element */

   494

	while (er) {

   495

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

   496

		er = er->next;

   497

	}

   498

	return NULL;