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

    17

#include "variables.h"

    18

#include "train.h"

    19

#include "newgrf_engine.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

/** TRANSLATE FROM LOCAL CARGO TO GLOBAL CARGO ID'S.

    34

 * This maps the per-landscape cargo ID's to globally unique cargo ID's usable ie. in

    35

 * the custom GRF  files. It is basically just a transcribed table from TTDPatch's newgrf.txt.

    36

 */

    37

const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    38

	/* LT_NORMAL */ {GC_PASSENGERS, GC_COAL,  GC_MAIL, GC_OIL, GC_LIVESTOCK, GC_GOODS, GC_GRAIN, GC_WOOD, GC_IRON_ORE,    GC_STEEL,  GC_VALUABLES, GC_PAPER_TEMP},

    39

	/* LT_HILLY */  {GC_PASSENGERS, GC_COAL,  GC_MAIL, GC_OIL, GC_LIVESTOCK, GC_GOODS, GC_GRAIN, GC_WOOD, GC_INVALID,     GC_PAPER,  GC_VALUABLES, GC_FOOD },

    40

	/* LT_DESERT */ {GC_PASSENGERS, GC_RUBBER,GC_MAIL, GC_OIL, GC_FRUIT,     GC_GOODS, GC_GRAIN, GC_WOOD, GC_COPPER_ORE,  GC_WATER,  GC_VALUABLES, GC_FOOD },

    41

	/* LT_CANDY */  {GC_PASSENGERS, GC_SUGAR, GC_MAIL, GC_TOYS,GC_BATTERIES, GC_CANDY, GC_TOFFEE,GC_COLA, GC_COTTON_CANDY,GC_BUBBLES,GC_PLASTIC,   GC_FIZZY_DRINKS },

    42

	/**

    43

	 * - GC_INVALID (255) means that  cargo is not available for that climate

    44

	 * - GC_PAPER_TEMP (27) is paper in  temperate climate in TTDPatch

    45

	 * Following can  be renumbered:

    46

	 * - GC_DEFAULT (29) is the defa ult cargo for the purpose of spritesets

    47

	 * - GC_PURCHASE (30) is the purchase list image (the equivalent of 0xff) for the purpose of spritesets

    48

	 */

    49

};

    50

    51

/** BEGIN --- TRANSLATE FROM GLOBAL CARGO TO LOCAL CARGO ID'S **/

    52

/** Map global cargo ID's to local-cargo ID's */

    53

const CargoID _local_cargo_id_ctype[NUM_GLOBAL_CID] = {

    54

	CT_PASSENGERS,CT_COAL,   CT_MAIL,        CT_OIL,      CT_LIVESTOCK,CT_GOODS,  CT_GRAIN,      CT_WOOD,         /*  0- 7 */

    55

	CT_IRON_ORE,  CT_STEEL,  CT_VALUABLES,   CT_PAPER,    CT_FOOD,     CT_FRUIT,  CT_COPPER_ORE, CT_WATER,        /*  8-15 */

    56

	CT_RUBBER,    CT_SUGAR,  CT_TOYS,        CT_BATTERIES,CT_CANDY,    CT_TOFFEE, CT_COLA,       CT_COTTON_CANDY, /* 16-23 */

    57

	CT_BUBBLES,   CT_PLASTIC,CT_FIZZY_DRINKS,CT_PAPER     /* unsup. */,CT_HILLY_UNUSED,                           /* 24-28 */

    58

	CT_INVALID,   CT_INVALID                                                                                      /* 29-30 */

    59

};

    60

    61

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

    62

/** Bitmasked value where the global cargo ID is available in landscape

    63

 * 0: LT_NORMAL, 1: LT_HILLY, 2: LT_DESERT, 3: LT_CANDY */

    64

const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE] =

    65

{ /* LT_NORMAL: temperate */

    66

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

    67

	MC(GC_IRON_ORE)|MC(GC_STEEL)|MC(GC_VALUABLES),

    68

	/* LT_HILLY: arctic */

    69

	MC(GC_PASSENGERS)|MC(GC_COAL)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_LIVESTOCK)|MC(GC_GOODS)|

    70

	MC(GC_GRAIN)|MC(GC_WOOD)|MC(GC_VALUABLES)|MC(GC_PAPER)|MC(GC_FOOD),

    71

	/* LT_DESERT: rainforest/desert */

    72

	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_OIL)|MC(GC_GOODS)|MC(GC_GRAIN)|MC(GC_WOOD)|

    73

	MC(GC_VALUABLES)|MC(GC_FOOD)|MC(GC_FRUIT)|MC(GC_COPPER_ORE)|MC(GC_WATER)|MC(GC_RUBBER),

    74

	/* LT_CANDY: toyland */

    75

	MC(GC_PASSENGERS)|MC(GC_MAIL)|MC(GC_SUGAR)|MC(GC_TOYS)|MC(GC_BATTERIES)|MC(GC_CANDY)|

    76

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

    77

};

    78

/** END   --- TRANSLATE FROM GLOBAL CARGO TO LOCAL CARGO ID'S **/

    79

    80

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

    81

 * This coupled with the landscape information (_landscape_global_cargo_mask) gives

    82

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

    83

const uint32 _default_refitmasks[NUM_VEHICLE_TYPES] = {

    84

	/* Trains */

    85

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

    86

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

    87

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

    88

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

    89

	0,

    90

	/* Ships */

    91

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

    92

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

    93

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

    94

	/* Aircraft */

    95

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

    96

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

    97

	/* Special/Disaster */

    98

	0,0

    99

};

   100

   101

/**

   102

 * Bitmask of classes for cargo types.

   103

 */

   104

const uint32 cargo_classes[16] = {

   105

	/* Passengers */ MC(GC_PASSENGERS),

   106

	/* Mail       */ MC(GC_MAIL),

   107

	/* Express    */ MC(GC_GOODS)|MC(GC_FOOD)|MC(GC_CANDY),

   108

	/* Armoured   */ MC(GC_VALUABLES),

   109

	/* Bulk       */ MC(GC_COAL)|MC(GC_GRAIN)|MC(GC_IRON_ORE)|MC(GC_COPPER_ORE)|MC(GC_FRUIT)|MC(GC_SUGAR)|MC(GC_TOFFEE)|MC(GC_COTTON_CANDY),

   110

	/* Piece      */ MC(GC_LIVESTOCK)|MC(GC_WOOD)|MC(GC_STEEL)|MC(GC_PAPER)|MC(GC_TOYS)|MC(GC_BATTERIES)|MC(GC_BUBBLES)|MC(GC_FIZZY_DRINKS),

   111

	/* Liquids    */ MC(GC_OIL)|MC(GC_WATER)|MC(GC_RUBBER)|MC(GC_COLA)|MC(GC_PLASTIC),

   112

	/* Chilled    */ MC(GC_FOOD)|MC(GC_FRUIT),

   113

	/* Undefined  */ 0, 0, 0, 0, 0, 0, 0, 0

   114

};

   115

#undef MC

   116

   117

void ShowEnginePreviewWindow(EngineID engine);

   118

   119

void DeleteCustomEngineNames(void)

   120

{

   121

	uint i;

   122

	StringID old;

   123

   124

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

   125

		old = _engine_name_strings[i];

   126

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

   127

		DeleteName(old);

   128

	}

   129

   130

	_vehicle_design_names &= ~1;

   131

}

   132

   133

void LoadCustomEngineNames(void)

   134

{

   135

	// XXX: not done */

   136

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

   137

}

   138

   139

static void SetupEngineNames(void)

   140

{

   141

	StringID *name;

   142

   143

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

   144

		*name = STR_SV_EMPTY;

   145

   146

	DeleteCustomEngineNames();

   147

	LoadCustomEngineNames();

   148

}

   149

   150

static void AdjustAvailAircraft(void)

   151

{

   152

	uint16 date = _date;

   153

	byte avail = 0;

   154

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

   155

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

   156

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

   157

   158

	if (avail != _avail_aircraft) {

   159

		_avail_aircraft = avail;

   160

		InvalidateWindow(WC_BUILD_STATION, 0);

   161

	}

   162

}

   163

   164

static void CalcEngineReliability(Engine *e)

   165

{

   166

	uint age = e->age;

   167

   168

	if (age < e->duration_phase_1) {

   169

		uint start = e->reliability_start;

   170

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

   171

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

   172

		e->reliability = e->reliability_max;

   173

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

   174

		uint max = e->reliability_max;

   175

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

   176

	} else {

   177

		// time's up for this engine

   178

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

   179

		// or disable this engine completely

   180

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

   181

		e->reliability = e->reliability_final;

   182

	}

   183

}

   184

   185

void AddTypeToEngines(void)

   186

{

   187

	Engine* e = _engines;

   188

   189

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

   190

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

   191

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

   192

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

   193

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

   194

}

   195

   196

void StartupEngines(void)

   197

{

   198

	Engine *e;

   199

	const EngineInfo *ei;

   200

   201

	SetupEngineNames();

   202

   203

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

   204

		uint32 r;

   205

   206

		e->age = 0;

   207

		e->railtype = ei->railtype;

   208

		e->flags = 0;

   209

		e->player_avail = 0;

   210

   211

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

   212

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

   213

		// added.

   214

		r = Random();

   215

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

   216

		if (e->intro_date <= _date) {

   217

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

   218

			e->player_avail = (byte)-1;

   219

			e->flags |= ENGINE_AVAILABLE;

   220

		}

   221

   222

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

   223

		r = Random();

   224

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

   225

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

   226

   227

		r = Random();

   228

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

   229

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

   230

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

   231

   232

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

   233

   234

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

   235

		if (ei->unk2 & 0x80) {

   236

			e->age = 0xFFFF;

   237

		} else {

   238

			CalcEngineReliability(e);

   239

		}

   240

   241

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

   242

   243

		// prevent certain engines from ever appearing.

   244

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

   245

			e->flags |= ENGINE_AVAILABLE;

   246

			e->player_avail = 0;

   247

		}

   248

   249

		/* This sets up type for the engine

   250

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

   251

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

   252

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

   253

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

   254

	}

   255

   256

	AdjustAvailAircraft();

   257

}

   258

   259

static void AcceptEnginePreview(Engine *e, PlayerID player)

   260

{

   261

	Player *p = GetPlayer(player);

   262

   263

	assert(e->railtype < RAILTYPE_END);

   264

	SETBIT(e->player_avail, player);

   265

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

   266

   267

	e->preview_player = 0xFF;

   268

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   269

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   270

}

   271

   272

static PlayerID GetBestPlayer(PlayerID pp)

   273

{

   274

	const Player *p;

   275

	int32 best_hist;

   276

	PlayerID best_player;

   277

	uint mask = 0;

   278

   279

	do {

   280

		best_hist = -1;

   281

		best_player = OWNER_SPECTATOR;

   282

		FOR_ALL_PLAYERS(p) {

   283

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

   284

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

   285

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

   286

				best_player = p->index;

   287

			}

   288

		}

   289

   290

		if (best_player == OWNER_SPECTATOR) return OWNER_SPECTATOR;

   291

   292

		SETBIT(mask, best_player);

   293

	} while (--pp != 0);

   294

   295

	return best_player;

   296

}

   297

   298

void EnginesDailyLoop(void)

   299

{

   300

	EngineID i;

   301

   302

	if (_cur_year >= 130) return;

   303

   304

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

   305

		Engine* e = &_engines[i];

   306

   307

		if (e->flags & ENGINE_INTRODUCING) {

   308

			if (e->flags & ENGINE_PREVIEWING) {

   309

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

   310

					e->flags &= ~ENGINE_PREVIEWING;

   311

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

   312

					e->preview_player++;

   313

				}

   314

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

   315

				PlayerID best_player = GetBestPlayer(e->preview_player);

   316

   317

				if (best_player == OWNER_SPECTATOR) {

   318

					e->preview_player = 0xFF;

   319

					continue;

   320

				}

   321

   322

				if (!IS_HUMAN_PLAYER(best_player)) {

   323

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

   324

					AcceptEnginePreview(e, best_player);

   325

				} else {

   326

					e->flags |= ENGINE_PREVIEWING;

   327

					e->preview_wait = 20;

   328

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

   329

				}

   330

			}

   331

		}

   332

	}

   333

}

   334

   335

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

   336

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

   338

 * @param p1 engine-prototype offered

   339

 * @param p2 unused

   340

 */

   342

{

   343

	Engine *e;

   344

   345

	if (!IsEngineIndex(p1)) return CMD_ERROR;

   346

	e = GetEngine(p1);

   347

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

   348

   349

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

   350

   351

	return 0;

   352

}

   353

   354

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

   355

static bool IsWagon(EngineID index)

   356

{

   357

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

   358

}

   359

   360

static void NewVehicleAvailable(Engine *e)

   361

{

   362

	Vehicle *v;

   363

	Player *p;

   364

	EngineID index = e - _engines;

   365

   366

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

   367

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

   368

	if (e->flags & ENGINE_INTRODUCING) {

   369

		FOR_ALL_PLAYERS(p) {

   370

			uint block_preview = p->block_preview;

   371

   372

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

   373

   374

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

   375

			p->block_preview = 20;

   376

   377

			FOR_ALL_VEHICLES(v) {

   378

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

   379

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

   380

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

   381

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

   382

						p->block_preview = block_preview;

   383

						break;

   384

					}

   385

				}

   386

			}

   387

		}

   388

	}

   389

   390

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

   391

	InvalidateWindowClasses(WC_BUILD_VEHICLE);

   392

	InvalidateWindowClasses(WC_REPLACE_VEHICLE);

   393

   394

	// Now available for all players

   395

	e->player_avail = (byte)-1;

   396

   397

	// Do not introduce new rail wagons

   398

	if (IsWagon(index)) return;

   399

   400

	// make maglev / monorail available

   401

	FOR_ALL_PLAYERS(p) {

   402

		if (p->is_active) {

   403

			assert(e->railtype < RAILTYPE_END);

   404

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

   405

		}

   406

	}

   407

   408

	if (index < NUM_TRAIN_ENGINES) {

   409

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

   410

	} else if (index < NUM_TRAIN_ENGINES + NUM_ROAD_ENGINES) {

   411

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

   412

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

   413

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

   414

	} else {

   415

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

   416

	}

   417

}

   418

   419

void EnginesMonthlyLoop(void)

   420

{

   421

	Engine *e;

   422

   423

	if (_cur_year < 130) {

   424

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

   425

			// Age the vehicle

   426

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

   427

				e->age++;

   428

				CalcEngineReliability(e);

   429

			}

   430

   431

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

   432

				// Introduce it to all players

   433

				NewVehicleAvailable(e);

   434

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

   435

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

   436

				e->flags |= ENGINE_INTRODUCING;

   437

   438

				// Do not introduce new rail wagons

   439

				if (!IsWagon(e - _engines))

   440

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

   441

			}

   442

		}

   443

	}

   444

	AdjustAvailAircraft();

   445

}

   446

   447

/** Rename an engine.

   449

 * @param p1 engine ID to rename

   450

 * @param p2 unused

   451

 */

   453

{

   454

	StringID str;

   455

   456

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

   457

   458

	str = AllocateNameUnique(_cmd_text, 0);

   459

	if (str == 0) return CMD_ERROR;

   460

   461

	if (flags & DC_EXEC) {

   462

		StringID old_str = _engine_name_strings[p1];

   463

		_engine_name_strings[p1] = str;

   464

		DeleteName(old_str);

   465

		_vehicle_design_names |= 3;

   466

		MarkWholeScreenDirty();

   467

	} else {

   468

		DeleteName(str);

   469

	}

   470

   471

	return 0;

   472

}

   473

   474

   475

/*

   476

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

   477

 * the current player, false otherwise

   478

 *

   479

 * engine = index of the engine to check

   480

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

   481

 */

   482

bool IsEngineBuildable(uint engine, byte type)

   483

{

   484

	const Engine *e;

   485

   486

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

   487

	if (!IsEngineIndex(engine)) return false;

   488

   489

	e = GetEngine(engine);

   490

   491

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

   492

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

   493

   494

	// check if it's available

   495

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

   496

   497

	return true;

   498

}