1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "engine.h"

     5

#include "table/engines.h"

     7

#include "player.h"

     8

#include "command.h"

     9

#include "vehicle.h"

    10

#include "news.h"

    11

#include "saveload.h"

    12

#include "sprite.h"

    13

    14

#define UPDATE_PLAYER_RAILTYPE(e,p) if ((byte)(e->railtype + 1) > p->max_railtype) p->max_railtype = e->railtype + 1;

    15

    16

enum {

    17

	ENGINE_AVAILABLE = 1,

    18

	ENGINE_INTRODUCING = 2,

    19

	ENGINE_PREVIEWING = 4,

    20

};

    21

    22

/* This maps per-landscape cargo ids to globally unique cargo ids usable ie. in

    23

 * the custom GRF files. It is basically just a transcribed table from

    24

 * TTDPatch's newgrf.txt. */

    25

byte _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    26

	/* LT_NORMAL */ {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 12 },

    27

	/* LT_HILLY */  {  0,  1,  2,  3,  4,  5,  6,  7, 28, 11, 10, 12 },

    28

	/* LT_DESERT */ {  0, 16,  2,  3, 13,  5,  6,  7, 14, 15, 10, 12 },

    29

	/* LT_CANDY */  {  0, 17,  2, 18, 19, 20, 21, 22, 23, 24, 25, 26 },

    30

	// 27 is paper in temperate climate in TTDPatch

    31

	// Following can be renumbered:

    32

	// 29 is the default cargo for the purpose of spritesets

    33

	// 30 is the purchase list image (the equivalent of 0xff) for the purpose of spritesets

    34

};

    35

    36

/* These two arrays provide a reverse mapping. */

    37

byte _local_cargo_id_ctype[NUM_CID] = {

    38

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

    39

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

    40

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

    41

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

    42

};

    43

    44

/* LT'th bit is set of the particular landscape if cargo available there.

    45

 * 1: LT_NORMAL, 2: LT_HILLY, 4: LT_DESERT, 8: LT_CANDY */

    46

byte _local_cargo_id_landscape[NUM_CID] = {

    47

	15, 3, 15, 7, 3, 7, 7, 7, 1, 1, 7, 2, 7, // 0-12

    48

	4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 1, 2, // 13-28

    49

};

    50

    51

void ShowEnginePreviewWindow(int engine);

    52

    53

void DeleteCustomEngineNames()

    54

{

    55

	uint i;

    56

	StringID old;

    57

    58

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

    59

		old = _engine_name_strings[i];

    60

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    61

		DeleteName(old);

    62

	}

    63

    64

	_vehicle_design_names &= ~1;

    65

}

    66

    67

void LoadCustomEngineNames()

    68

{

    69

	// XXX: not done */

    70

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

    71

}

    72

    73

static void SetupEngineNames()

    74

{

    75

	uint i;

    76

    77

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

    78

		_engine_name_strings[i] = STR_SV_EMPTY;

    79

    80

	DeleteCustomEngineNames();

    81

	LoadCustomEngineNames();

    82

}

    83

    84

static void AdjustAvailAircraft()

    85

{

    86

	uint16 date = _date;

    87

	byte avail = 0;

    88

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

    89

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

    90

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

    91

    92

	if (avail != _avail_aircraft) {

    93

		_avail_aircraft = avail;

    94

		InvalidateWindow(WC_BUILD_STATION, 0);

    95

	}

    96

}

    97

    98

static void CalcEngineReliability(Engine *e)

    99

{

   100

	uint age = e->age;

   101

   102

	if (age < e->duration_phase_1) {

   103

		uint start = e->reliability_start;

   104

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

   105

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

   106

		e->reliability = e->reliability_max;

   107

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

   108

		uint max = e->reliability_max;

   109

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

   110

	} else {

   111

		// time's up for this engine

   112

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

   113

		// or disable this engine completely

   114

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

   115

		e->reliability = e->reliability_final;

   116

	}

   117

}

   118

   119

void AddTypeToEngines()

   120

{

   121

	Engine *e;

   122

	uint32 counter = 0;

   123

   124

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

   125

   126

		e->type = VEH_Train;

   127

		if 	(counter >= ROAD_ENGINES_INDEX) {

   128

			e->type = VEH_Road;

   129

			if 	(counter >= SHIP_ENGINES_INDEX) {

   130

				e->type = VEH_Ship;

   131

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   132

					e->type = VEH_Aircraft;

   133

					if 	(counter >= TOTAL_NUM_ENGINES) {

   134

						e->type = VEH_Special;

   135

					}

   136

				}

   137

			}

   138

		}

   139

	}

   140

}

   141

   142

void StartupEngines()

   143

{

   144

	Engine *e;

   145

	const EngineInfo *ei;

   146

	uint32 r, counter = 0;

   147

   148

	SetupEngineNames();

   149

   150

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

   151

   152

		e->age = 0;

   153

		e->railtype = ei->railtype_climates >> 4;

   154

		e->flags = 0;

   155

		e->player_avail = 0;

   156

   157

		r = Random();

   158

		e->intro_date = (uint16)((r & 0x1FF) + ei->base_intro);

   159

		if (e->intro_date <= _date) {

   160

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

   161

			e->player_avail = (byte)-1;

   162

			e->flags |= ENGINE_AVAILABLE;

   163

		}

   164

   165

		e->reliability_start = (uint16)(((r >> 16) & 0x3fff) + 0x7AE0);

   166

		r = Random();

   167

		e->reliability_max = (uint16)((r & 0x3fff) + 0xbfff);

   168

		e->reliability_final = (uint16)(((r>>16) & 0x3fff) + 0x3fff);

   169

   170

		r = Random();

   171

		e->duration_phase_1 = (uint16)((r & 0x1F) + 7);

   172

		e->duration_phase_2 = (uint16)(((r >> 5) & 0xF) + ei->base_life * 12 - 96);

   173

		e->duration_phase_3 = (uint16)(((r >> 9) & 0x7F) + 120);

   174

   175

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

   176

   177

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

   178

		if (ei->unk2 & 0x80) {

   179

			e->age = 0xFFFF;

   180

		} else {

   181

			CalcEngineReliability(e);

   182

		}

   183

   184

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

   185

   186

		// prevent certain engines from ever appearing.

   187

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

   188

			e->flags |= ENGINE_AVAILABLE;

   189

			e->player_avail = 0;

   190

		}

   191

   192

		/* This sets up type for the engine

   193

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

   194

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

   195

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

   196

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

   197

	}

   198

   199

	AdjustAvailAircraft();

   200

}

   201

   202

uint32 _engine_refit_masks[256];

   203

   204

   205

// TODO: We don't support cargo-specific wagon overrides. Pretty exotic... ;-) --pasky

   206

   207

struct WagonOverride {

   208

	byte *train_id;

   209

	int trains;

   210

	struct SpriteGroup group;

   211

};

   212

   213

static struct WagonOverrides {

   214

	int overrides_count;

   215

	struct WagonOverride *overrides;

   216

} _engine_wagon_overrides[256];

   217

   218

void SetWagonOverrideSprites(byte engine, struct SpriteGroup *group,

   219

                             byte *train_id, int trains)

   220

{

   221

	struct WagonOverrides *wos;

   222

	struct WagonOverride *wo;

   223

   224

	wos = &_engine_wagon_overrides[engine];

   225

	wos->overrides_count++;

   226

	wos->overrides = realloc(wos->overrides,

   227

	                         wos->overrides_count * sizeof(struct WagonOverride));

   228

   229

	wo = &wos->overrides[wos->overrides_count - 1];

   230

	/* FIXME: If we are replacing an override, release original SpriteGroup

   231

	 * to prevent leaks. But first we need to refcount the SpriteGroup.

   232

	 * --pasky */

   233

	wo->group = *group;

   234

	wo->trains = trains;

   235

	wo->train_id = malloc(trains);

   236

	memcpy(wo->train_id, train_id, trains);

   237

}

   238

   239

static struct SpriteGroup *GetWagonOverrideSpriteSet(byte engine, byte overriding_engine)

   240

{

   241

	struct WagonOverrides *wos = &_engine_wagon_overrides[engine];

   242

	int i;

   243

   244

	// XXX: This could turn out to be a timesink on profiles. We could

   245

	// always just dedicate 65535 bytes for an [engine][train] trampoline

   246

	// for O(1). Or O(logMlogN) and searching binary tree or smt. like

   247

	// that. --pasky

   248

   249

	for (i = 0; i < wos->overrides_count; i++) {

   250

		struct WagonOverride *wo = &wos->overrides[i];

   251

		int j;

   252

   253

		for (j = 0; j < wo->trains; j++) {

   254

			if (wo->train_id[j] == overriding_engine)

   255

				return &wo->group;

   256

		}

   257

	}

   258

	return NULL;

   259

}

   260

   261

   262

byte _engine_original_sprites[256];

   263

// 0 - 28 are cargos, 29 is default, 30 is the advert (purchase list)

   264

// (It isn't and shouldn't be like this in the GRF files since new cargo types

   265

// may appear in future - however it's more convenient to store it like this in

   266

// memory. --pasky)

   267

static struct SpriteGroup _engine_custom_sprites[256][NUM_CID];

   268

   269

void SetCustomEngineSprites(byte engine, byte cargo, struct SpriteGroup *group)

   270

{

   271

	/* FIXME: If we are replacing an override, release original SpriteGroup

   272

	 * to prevent leaks. But first we need to refcount the SpriteGroup.

   273

	 * --pasky */

   274

	_engine_custom_sprites[engine][cargo] = *group;

   275

}

   276

   277

typedef struct RealSpriteGroup *(*resolve_callback)(struct SpriteGroup *spritegroup,

   278

                                                    struct Vehicle *veh,

   279

                                                    void *callback); /* XXX data pointer used as function pointer */

   280

   281

static struct RealSpriteGroup *

   282

ResolveVehicleSpriteGroup(struct SpriteGroup *spritegroup, struct Vehicle *veh,

   283

			  resolve_callback callback)

   284

{

   285

	//debug("spgt %d", spritegroup->type);

   286

	switch (spritegroup->type) {

   287

		case SGT_REAL:

   288

			return &spritegroup->g.real;

   289

   290

		case SGT_DETERMINISTIC: {

   291

			struct DeterministicSpriteGroup *dsg = &spritegroup->g.determ;

   292

			struct SpriteGroup *target;

   293

			int value = -1;

   294

   295

			//debug("[%p] Having fun resolving variable %x", veh, dsg->variable);

   296

   297

			if ((dsg->variable >> 6) == 0) {

   298

				/* General property */

   299

				value = GetDeterministicSpriteValue(dsg->variable);

   300

   301

			} else {

   302

				/* Vehicle-specific property. */

   303

   304

				if (veh == NULL) {

   305

					/* We are in a purchase list of something,

   306

					 * and we are checking for something undefined.

   307

					 * That means we should get the first target

   308

					 * (NOT the default one). */

   309

					if (dsg->num_ranges > 0) {

   310

						target = &dsg->ranges[0].group;

   311

					} else {

   312

						target = dsg->default_group;

   313

					}

   314

					return callback(target, NULL, callback);

   315

				}

   316

   317

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   318

					/* First engine in the vehicle chain */

   319

					if (veh->type == VEH_Train)

   320

						veh = GetFirstVehicleInChain(veh);

   321

				}

   322

   323

				if (dsg->variable == 0x40) {

   324

					if (veh->type == VEH_Train) {

   325

						Vehicle *u = GetFirstVehicleInChain(veh);

   326

						byte chain_before = 0, chain_after = 0;

   327

   328

						while (u != veh) {

   329

							u = u->next;

   330

							chain_before++;

   331

						}

   332

						while (u->next != NULL) {

   333

							u = u->next;

   334

							chain_after++;

   335

						};

   336

   337

						value = chain_before << 16 | chain_after << 8

   338

						        | (chain_before + chain_after + 1);

   339

					} else {

   340

						value = 1; /* 1 vehicle in the chain */

   341

					}

   342

   343

				} else {

   344

					// TTDPatch runs on little-endian arch;

   345

					// Variable is 0x80 + offset in TTD's vehicle structure

   346

					switch (dsg->variable - 0x80) {

   347

#define veh_prop(id_, value_) case (id_): value = (value_); break

   348

						veh_prop(0x00, veh->type);

   349

						veh_prop(0x01, veh->subtype);

   350

						veh_prop(0x04, veh->index);

   351

						veh_prop(0x05, veh->index & 0xFF);

   352

						/* XXX? Is THIS right? */

   353

						veh_prop(0x0A, PackOrder(&veh->current_order));

   354

						veh_prop(0x0B, PackOrder(&veh->current_order) & 0xff);

   355

						veh_prop(0x0C, veh->num_orders);

   356

						veh_prop(0x0D, veh->cur_order_index);

   357

						veh_prop(0x10, veh->load_unload_time_rem);

   358

						veh_prop(0x11, veh->load_unload_time_rem & 0xFF);

   359

						veh_prop(0x12, veh->date_of_last_service);

   360

						veh_prop(0x13, veh->date_of_last_service & 0xFF);

   361

						veh_prop(0x14, veh->service_interval);

   362

						veh_prop(0x15, veh->service_interval & 0xFF);

   363

						veh_prop(0x16, veh->last_station_visited);

   364

						veh_prop(0x17, veh->tick_counter);

   365

						veh_prop(0x18, veh->max_speed);

   366

						veh_prop(0x19, veh->max_speed & 0xFF);

   367

						veh_prop(0x1F, veh->direction);

   368

						veh_prop(0x28, veh->cur_image);

   369

						veh_prop(0x29, veh->cur_image & 0xFF);

   370

						veh_prop(0x32, veh->vehstatus);

   371

						veh_prop(0x33, veh->vehstatus);

   372

						veh_prop(0x34, veh->cur_speed);

   373

						veh_prop(0x35, veh->cur_speed & 0xFF);

   374

						veh_prop(0x36, veh->subspeed);

   375

						veh_prop(0x37, veh->acceleration);

   376

						veh_prop(0x39, veh->cargo_type);

   377

						veh_prop(0x3A, veh->cargo_cap);

   378

						veh_prop(0x3B, veh->cargo_cap & 0xFF);

   379

						veh_prop(0x3C, veh->cargo_count);

   380

						veh_prop(0x3D, veh->cargo_count & 0xFF);

   381

						veh_prop(0x3E, veh->cargo_source); // Probably useless; so what

   382

						veh_prop(0x3F, veh->cargo_days);

   383

						veh_prop(0x40, veh->age);

   384

						veh_prop(0x41, veh->age & 0xFF);

   385

						veh_prop(0x42, veh->max_age);

   386

						veh_prop(0x43, veh->max_age & 0xFF);

   387

						veh_prop(0x44, veh->build_year);

   388

						veh_prop(0x45, veh->unitnumber);

   389

						veh_prop(0x46, veh->engine_type);

   390

						veh_prop(0x47, veh->engine_type & 0xFF);

   391

						veh_prop(0x48, veh->spritenum);

   392

						veh_prop(0x49, veh->day_counter);

   393

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   394

						veh_prop(0x4B, veh->breakdown_ctr);

   395

						veh_prop(0x4C, veh->breakdown_delay);

   396

						veh_prop(0x4D, veh->breakdown_chance);

   397

						veh_prop(0x4E, veh->reliability);

   398

						veh_prop(0x4F, veh->reliability & 0xFF);

   399

						veh_prop(0x50, veh->reliability_spd_dec);

   400

						veh_prop(0x51, veh->reliability_spd_dec & 0xFF);

   401

						veh_prop(0x52, veh->profit_this_year);

   402

						veh_prop(0x53, veh->profit_this_year & 0xFFFFFF);

   403

						veh_prop(0x54, veh->profit_this_year & 0xFFFF);

   404

						veh_prop(0x55, veh->profit_this_year & 0xFF);

   405

						veh_prop(0x56, veh->profit_last_year);

   406

						veh_prop(0x57, veh->profit_last_year & 0xFF);

   407

						veh_prop(0x58, veh->profit_last_year);

   408

						veh_prop(0x59, veh->profit_last_year & 0xFF);

   409

/*						veh_prop(0x5A, veh->next_in_chain_old);

   410

						veh_prop(0x5B, veh->next_in_chain_old & 0xFF);*/

   411

						veh_prop(0x5C, veh->value);

   412

						veh_prop(0x5D, veh->value & 0xFFFFFF);

   413

						veh_prop(0x5E, veh->value & 0xFFFF);

   414

						veh_prop(0x5F, veh->value & 0xFF);

   415

						veh_prop(0x60, veh->string_id);

   416

						veh_prop(0x61, veh->string_id & 0xFF);

   417

						/* 00h..07h=sub image? 40h=in tunnel; actually some kind of status

   418

						 * aircraft: >=13h when in flight

   419

						 * train, ship: 80h=in depot

   420

						 * rv: 0feh=in depot */

   421

						/* TODO veh_prop(0x62, veh->???); */

   422

   423

						/* TODO: The rest is per-vehicle, I hope no GRF file looks so far.

   424

						 * But they won't let us have an easy ride so surely *some* GRF

   425

						 * file does. So someone needs to do this too. --pasky */

   426

   427

#undef veh_prop

   428

					}

   429

				}

   430

			}

   431

   432

			target = value != -1 ? EvalDeterministicSpriteGroup(dsg, value) : dsg->default_group;

   433

			//debug("Resolved variable %x: %d, %p", dsg->variable, value, callback);

   434

			return callback(target, veh, callback);

   435

		}

   436

   437

		case SGT_RANDOMIZED: {

   438

			struct RandomizedSpriteGroup *rsg = &spritegroup->g.random;

   439

   440

			if (veh == NULL) {

   441

				/* Purchase list of something. Show the first one. */

   442

				assert(rsg->num_groups > 0);

   443

				//debug("going for %p: %d", rsg->groups[0], rsg->groups[0].type);

   444

				return callback(&rsg->groups[0], NULL, callback);

   445

			}

   446

   447

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   448

				/* First engine in the vehicle chain */

   449

				if (veh->type == VEH_Train)

   450

					veh = GetFirstVehicleInChain(veh);

   451

			}

   452

   453

			return callback(EvalRandomizedSpriteGroup(rsg, veh->random_bits), veh, callback);

   454

		}

   455

   456

		default:

   457

			error("I don't know how to handle such a spritegroup %d!", spritegroup->type);

   458

			return NULL;

   459

	}

   460

}

   461

   462

static struct SpriteGroup *GetVehicleSpriteGroup(byte engine, Vehicle *v)

   463

{

   464

	struct SpriteGroup *group;

   465

	uint16 overriding_engine = -1;

   466

	byte cargo = CID_PURCHASE;

   467

   468

	if (v != NULL) {

   469

		overriding_engine = v->type == VEH_Train ? v->u.rail.first_engine : -1;

   470

		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];

   471

	}

   472

   473

	group = &_engine_custom_sprites[engine][cargo];

   474

   475

	if (overriding_engine != 0xffff) {

   476

		struct SpriteGroup *overset;

   477

   478

		overset = GetWagonOverrideSpriteSet(engine, overriding_engine);

   479

		if (overset) group = overset;

   480

	}

   481

   482

	return group;

   483

}

   484

   485

int GetCustomEngineSprite(byte engine, Vehicle *v, byte direction)

   486

{

   487

	struct SpriteGroup *group;

   488

	struct RealSpriteGroup *rsg;

   489

	byte cargo = CID_PURCHASE;

   490

	byte loaded = 0;

   491

	bool in_motion = 0;

   492

	int totalsets, spriteset;

   493

	int r;

   494

   495

	if (v != NULL) {

   496

		int capacity = v->cargo_cap;

   497

   498

		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];

   499

		if (capacity == 0) capacity = 1;

   500

		loaded = (v->cargo_count * 100) / capacity;

   501

		in_motion = (v->cur_speed != 0);

   502

	}

   503

   504

	group = GetVehicleSpriteGroup(engine, v);

   505

	rsg = ResolveVehicleSpriteGroup(group, v, (resolve_callback) ResolveVehicleSpriteGroup);