1

/* $Id$ */

     2

     3

/** @file engine.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "table/strings.h"

     9

#include "engine.h"

    10

#include "player.h"

    11

#include "command_func.h"

    12

#include "news.h"

    13

#include "saveload.h"

    14

#include "variables.h"

    15

#include "train.h"

    16

#include "aircraft.h"

    17

#include "newgrf_cargo.h"

    18

#include "table/engines.h"

    19

#include "group.h"

    20

#include "misc/autoptr.hpp"

    21

#include "strings_func.h"

    22

#include "viewport.h"

    23

#include "functions.h"

    24

#include "window_func.h"

    25

#include "date_func.h"

    26

#include "autoreplace_base.h"

    27

#include "autoreplace_gui.h"

    28

#include "string_func.h"

    29

    30

EngineInfo _engine_info[TOTAL_NUM_ENGINES];

    31

RailVehicleInfo _rail_vehicle_info[NUM_TRAIN_ENGINES];

    32

ShipVehicleInfo _ship_vehicle_info[NUM_SHIP_ENGINES];

    33

AircraftVehicleInfo _aircraft_vehicle_info[NUM_AIRCRAFT_ENGINES];

    34

RoadVehicleInfo _road_vehicle_info[NUM_ROAD_ENGINES];

    35

    36

enum {

    37

	YEAR_ENGINE_AGING_STOPS = 2050,

    38

};

    39

    40

    59

void ShowEnginePreviewWindow(EngineID engine);

    60

    61

void DeleteCustomEngineNames()

    62

{

    63

	uint i;

    64

	StringID old;

    65

    66

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

    67

		old = _engine_name_strings[i];

    68

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    69

		DeleteName(old);

    70

	}

    71

    72

	_vehicle_design_names &= ~1;

    73

}

    74

    75

void LoadCustomEngineNames()

    76

{

    77

	/* XXX: not done */

    78

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

    79

}

    80

    81

static void SetupEngineNames()

    82

{

    83

	StringID *name;

    84

    85

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

    86

		*name = STR_SV_EMPTY;

    87

    88

	DeleteCustomEngineNames();

    89

	LoadCustomEngineNames();

    90

}

    91

    92

    93

static void CalcEngineReliability(Engine *e)

    94

{

    95

	uint age = e->age;

    96

    97

	/* Check for early retirement */

    98

	if (e->player_avail != 0 && !_patches.never_expire_vehicles) {

    99

		uint retire_early = EngInfo(e - _engines)->retire_early;

   100

		if (retire_early > 0 && age >= e->duration_phase_1 + e->duration_phase_2 - retire_early * 12) {

   101

			/* Early retirement is enabled and we're past the date... */

   102

			e->player_avail = 0;

   103

			AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   104

		}

   105

	}

   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 || _patches.never_expire_vehicles) {

   111

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

   112

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

   113

		e->reliability = e->reliability_max;

   114

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

   115

		uint max = e->reliability_max;

   116

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

   117

	} else {

   118

		/* time's up for this engine.

   119

		 * We will now completely retire this design */

   120

		e->player_avail = 0;

   121

		e->reliability = e->reliability_final;

   122

		/* Kick this engine out of the lists */

   123

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   124

	}

   125

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

   126

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   127

}

   128

   129

void StartupEngines()

   130

{

   131

	Engine *e;

   132

	const EngineInfo *ei;

   133

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

   134

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

   135

   136

	SetupEngineNames();

   137

   138

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

   139

		uint32 r;

   140

   141

		e->age = 0;

   142

		e->flags = 0;

   143

		e->player_avail = 0;

   144

   145

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

   146

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

   147

		 * added. */

   148

		r = Random();

   149

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

   150

		if (e->intro_date <= _date) {

   151

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

   152

			e->player_avail = (byte)-1;

   153

			e->flags |= ENGINE_AVAILABLE;

   154

		}

   155

   156

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

   157

		r = Random();

   158

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

   159

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

   160

   161

		r = Random();

   162

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

   163

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

   164

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

   165

   166

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

   167

   168

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

   169

		if (ei->unk2 & 0x80) {

   170

			e->age = 0xFFFF;

   171

		} else {

   172

			CalcEngineReliability(e);

   173

		}

   174

   175

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

   176

   177

		/* prevent certain engines from ever appearing. */

   178

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

   179

			e->flags |= ENGINE_AVAILABLE;

   180

			e->player_avail = 0;

   181

		}

   182

   183

		/* This sets up type for the engine

   184

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

   185

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

   186

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

   187

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

   188

	}

   189

}

   190

   191

static void AcceptEnginePreview(EngineID eid, PlayerID player)

   192

{

   193

	Engine *e = GetEngine(eid);

   194

	Player *p = GetPlayer(player);

   195

   196

	SetBit(e->player_avail, player);

   197

	if (e->type == VEH_TRAIN) {

   198

		const RailVehicleInfo *rvi = RailVehInfo(eid);

   199

   200

		assert(rvi->railtype < RAILTYPE_END);

   201

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

   202

	} else if (e->type == VEH_ROAD) {

   203

		SetBit(p->avail_roadtypes, HasBit(EngInfo(eid)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);

   204

	}

   205

   206

	e->preview_player = INVALID_PLAYER;

   207

	if (player == _local_player) {

   208

		AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   209

	}

   210

}

   211

   212

static PlayerID GetBestPlayer(PlayerID pp)

   213

{

   214

	const Player *p;

   215

	int32 best_hist;

   216

	PlayerID best_player;

   217

	uint mask = 0;

   218

   219

	do {

   220

		best_hist = -1;

   221

		best_player = PLAYER_SPECTATOR;

   222

		FOR_ALL_PLAYERS(p) {

   223

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

   224

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

   225

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

   226

				best_player = p->index;

   227

			}

   228

		}

   229

   230

		if (best_player == PLAYER_SPECTATOR) return PLAYER_SPECTATOR;

   231

   232

		SetBit(mask, best_player);

   233

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

   234

   235

	return best_player;

   236

}

   237

   238

void EnginesDailyLoop()

   239

{

   240

	EngineID i;

   241

   242

	if (_cur_year >= YEAR_ENGINE_AGING_STOPS) return;

   243

   244

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

   245

		Engine *e = &_engines[i];

   246

   247

		if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   248

			if (e->flags & ENGINE_OFFER_WINDOW_OPEN) {

   249

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

   250

					e->flags &= ~ENGINE_OFFER_WINDOW_OPEN;

   251

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   252

					e->preview_player++;

   253

				}

   254

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

   255

				PlayerID best_player = GetBestPlayer(e->preview_player);

   256

   257

				if (best_player == PLAYER_SPECTATOR) {

   258

					e->preview_player = INVALID_PLAYER;

   259

					continue;

   260

				}

   261

   262

				if (!IsHumanPlayer(best_player)) {

   263

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

   264

					AcceptEnginePreview(i, best_player);

   265

				} else {

   266

					e->flags |= ENGINE_OFFER_WINDOW_OPEN;

   267

					e->preview_wait = 20;

   268

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

   269

				}

   270

			}

   271

		}

   272

	}

   273

}

   274

   275

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

   276

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

   277

 * @param tile unused

   278

 * @param flags operation to perfom

   279

 * @param p1 engine-prototype offered

   280

 * @param p2 unused

   281

 */

   282

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

   283

{

   284

	Engine *e;

   285

   286

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   287

	e = GetEngine(p1);

   288

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

   289

   290

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

   291

   292

	return CommandCost();

   293

}

   294

   295

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

   296

static bool IsWagon(EngineID index)

   297

{

   298

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

   299

}

   300

   301

static void NewVehicleAvailable(Engine *e)

   302

{

   303

	Vehicle *v;

   304

	Player *p;

   305

	EngineID index = e - _engines;

   306

   307

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

   308

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

   309

	if (e->flags & ENGINE_EXCLUSIVE_PREVIEW) {

   310

		FOR_ALL_PLAYERS(p) {

   311

			uint block_preview = p->block_preview;

   312

   313

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

   314

   315

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

   316

			p->block_preview = 20;

   317

   318

			FOR_ALL_VEHICLES(v) {

   319

				if (v->type == VEH_TRAIN || v->type == VEH_ROAD || v->type == VEH_SHIP ||

   320

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

   321

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

   322

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

   323

						p->block_preview = block_preview;

   324

						break;

   325

					}

   326

				}

   327

			}

   328

		}

   329

	}

   330

   331

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

   332

	AddRemoveEngineFromAutoreplaceAndBuildWindows(e->type);

   333

   334

	/* Now available for all players */

   335

	e->player_avail = (byte)-1;

   336

   337

	/* Do not introduce new rail wagons */

   338

	if (IsWagon(index)) return;

   339

   340

	if (e->type == VEH_TRAIN) {

   341

		/* maybe make another rail type available */

   342

		RailType railtype = RailVehInfo(index)->railtype;

   343

		assert(railtype < RAILTYPE_END);

   344

		FOR_ALL_PLAYERS(p) {

   345

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

   346

		}

   347

	} else if (e->type == VEH_ROAD) {

   348

		/* maybe make another road type available */

   349

		FOR_ALL_PLAYERS(p) {

   350

			if (p->is_active) SetBit(p->avail_roadtypes, HasBit(EngInfo(index)->misc_flags, EF_ROAD_TRAM) ? ROADTYPE_TRAM : ROADTYPE_ROAD);

   351

		}

   352

	}

   353

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

   354

}

   355

   356

void EnginesMonthlyLoop()

   357

{

   358

	Engine *e;

   359

   360

	if (_cur_year < YEAR_ENGINE_AGING_STOPS) {

   361

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

   362

			/* Age the vehicle */

   363

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

   364

				e->age++;

   365

				CalcEngineReliability(e);

   366

			}

   367

   368

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

   369

				/* Introduce it to all players */

   370

				NewVehicleAvailable(e);

   371

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

   372

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

   373

				e->flags |= ENGINE_EXCLUSIVE_PREVIEW;

   374

   375

				/* Do not introduce new rail wagons */

   376

				if (!IsWagon(e - _engines))

   377

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

   378

			}

   379

		}

   380

	}

   381

}

   382

   383

static bool IsUniqueEngineName(const char *name)

   384

{

   385

	char buf[512];

   386

   387

	for (EngineID i = 0; i < TOTAL_NUM_ENGINES; i++) {

   388

		SetDParam(0, i);

   389

		GetString(buf, STR_ENGINE_NAME, lastof(buf));

   390

		if (strcmp(buf, name) == 0) return false;

   391

	}

   392

   393

	return true;

   394

}

   395

   396

/** Rename an engine.

   397

 * @param tile unused

   398

 * @param flags operation to perfom

   399

 * @param p1 engine ID to rename

   400

 * @param p2 unused

   401

 */

   402

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

   403

{

   404

	StringID str;

   405

   406

	if (!IsEngineIndex(p1) || StrEmpty(_cmd_text)) return CMD_ERROR;

   407

   408

	if (!IsUniqueEngineName(_cmd_text)) return_cmd_error(STR_NAME_MUST_BE_UNIQUE);

   409

   410

	str = AllocateName(_cmd_text, 0);

   411

	if (str == 0) return CMD_ERROR;

   412

   413

	if (flags & DC_EXEC) {

   414

		StringID old_str = _engine_name_strings[p1];

   415

		_engine_name_strings[p1] = str;

   416

		DeleteName(old_str);

   417

		_vehicle_design_names |= 3;

   418

		MarkWholeScreenDirty();

   419

	} else {

   420

		DeleteName(str);

   421

	}

   422

   423

	return CommandCost();

   424

}

   425

   426

   427

/*

   428

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

   429

 * the given player, false otherwise

   430

 *

   431

 * engine = index of the engine to check

   432

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

   433

 * player = index of the player

   434

 */

   435

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

   436

{

   437

	const Engine *e;

   438

   439

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

   440

	if (!IsEngineIndex(engine)) return false;

   441

   442

	e = GetEngine(engine);

   443

   444

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

   445

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

   446

   447

	/* check if it's available */

   448

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

   449

   450

	if (type == VEH_TRAIN) {

   451

		/* Check if the rail type is available to this player */

   452

		const Player *p = GetPlayer(player);

   453

		if (!HasBit(p->avail_railtypes, RailVehInfo(engine)->railtype)) return false;

   454

	}

   455

   456

	return true;

   457

}

   458

   459

/** Get the default cargo type for a certain engine type

   460

 * @param engine The ID to get the cargo for

   461

 * @return The cargo type. CT_INVALID means no cargo capacity

   462

 */

   463

CargoID GetEngineCargoType(EngineID engine)

   464

{

   465

	assert(IsEngineIndex(engine));

   466

   467

	switch (GetEngine(engine)->type) {

   468

		case VEH_TRAIN:

   469

			if (RailVehInfo(engine)->capacity == 0) return CT_INVALID;

   470

			return RailVehInfo(engine)->cargo_type;

   471

   472

		case VEH_ROAD:

   473

			if (RoadVehInfo(engine)->capacity == 0) return CT_INVALID;

   474

			return RoadVehInfo(engine)->cargo_type;

   475

   476

		case VEH_SHIP:

   477

			if (ShipVehInfo(engine)->capacity == 0) return CT_INVALID;

   478

			return ShipVehInfo(engine)->cargo_type;

   479

   480

		case VEH_AIRCRAFT:

   481

			/* all aircraft starts as passenger planes with cargo capacity */

   482

			return CT_PASSENGERS;

   483

   484

		default: NOT_REACHED(); return CT_INVALID;

   485

	}

   486

}

   487

   488

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

   489

 * Engine Replacement stuff

   490

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