1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "table/strings.h"

     4

#include "engine.h"

     5

#include "table/engines.h"

     6

#include "player.h"

     7

#include "command.h"

     8

#include "vehicle.h"

     9

#include "news.h"

    10

#include "saveload.h"

    11

#include "sprite.h"

    12

    13

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

    14

    15

enum {

    16

	ENGINE_AVAILABLE = 1,

    17

	ENGINE_INTRODUCING = 2,

    18

	ENGINE_PREVIEWING = 4,

    19

};

    20

    21

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

    22

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

    23

 * TTDPatch's newgrf.txt. */

    24

byte _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    25

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

    26

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

    27

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

    28

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

    29

	// 27 is paper in temperate climate in TTDPatch

    30

	// Following can be renumbered:

    31

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

    32

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

    33

};

    34

    35

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

    36

byte _local_cargo_id_ctype[NUM_CID] = {

    37

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

    38

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

    39

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

    40

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

    41

};

    42

    43

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

    44

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

    45

byte _local_cargo_id_landscape[NUM_CID] = {

    46

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

    47

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

    48

};

    49

    50

void ShowEnginePreviewWindow(int engine);

    51

    52

void DeleteCustomEngineNames()

    53

{

    54

	uint i;

    55

	StringID old;

    56

    57

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

    58

		old = _engine_name_strings[i];

    59

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    60

		DeleteName(old);

    61

	}

    62

    63

	_vehicle_design_names &= ~1;

    64

}

    65

    66

void LoadCustomEngineNames()

    67

{

    68

	// XXX: not done */

    69

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

    70

}

    71

    72

static void SetupEngineNames()

    73

{

    74

	uint i;

    75

    76

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

    77

		_engine_name_strings[i] = STR_SV_EMPTY;

    78

    79

	DeleteCustomEngineNames();

    80

	LoadCustomEngineNames();

    81

}

    82

    83

static void AdjustAvailAircraft()

    84

{

    85

	uint16 date = _date;

    86

	byte avail = 0;

    87

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

    88

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

    89

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

    90

    91

	if (avail != _avail_aircraft) {

    92

		_avail_aircraft = avail;

    93

		InvalidateWindow(WC_BUILD_STATION, 0);

    94

	}

    95

}

    96

    97

static void CalcEngineReliability(Engine *e)

    98

{

    99

	uint age = e->age;

   100

   101

	if (age < e->duration_phase_1) {

   102

		uint start = e->reliability_start;

   103

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

   104

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

   105

		e->reliability = e->reliability_max;

   106

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

   107

		uint max = e->reliability_max;

   108

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

   109

	} else {

   110

		// time's up for this engine

   111

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

   112

		// or disable this engine completely

   113

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

   114

		e->reliability = e->reliability_final;

   115

	}

   116

}

   117

   118

void StartupEngines()

   119

{

   120

	Engine *e;

   121

	const EngineInfo *ei;

   122

	uint32 r, counter = 0;

   123

   124

	SetupEngineNames();

   125

   126

   127

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

   128

		e->age = 0;

   129

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

   130

		e->flags = 0;

   131

		e->player_avail = 0;

   132

   133

		r = Random();

   134

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

   135

		if (e->intro_date <= _date) {

   136

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

   137

			e->player_avail = (byte)-1;

   138

			e->flags |= ENGINE_AVAILABLE;

   139

		}

   140

   141

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

   142

		r = Random();

   143

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

   144

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

   145

   146

		r = Random();

   147

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

   148

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

   149

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

   150

   151

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

   152

   153

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

   154

		if (ei->unk2 & 0x80) {

   155

			e->age = 0xFFFF;

   156

		} else {

   157

			CalcEngineReliability(e);

   158

		}

   159

   160

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

   161

   162

		// prevent certain engines from ever appearing.

   163

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

   164

			e->flags |= ENGINE_AVAILABLE;

   165

			e->player_avail = 0;

   166

		}

   167

   168

		/* This sets up type for the engine

   169

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

   170

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

   171

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

   172

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

   173

		e->type = VEH_Train;

   174

		if 	(counter >= ROAD_ENGINES_INDEX) {

   175

			e->type = VEH_Road;

   176

			if 	(counter >= SHIP_ENGINES_INDEX) {

   177

				e->type = VEH_Ship;

   178

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   179

					e->type = VEH_Aircraft;

   180

					if 	(counter >= TOTAL_NUM_ENGINES) {

   181

						e->type = VEH_Special;

   182

					}

   183

				}

   184

			}

   185

		}

   186

	}

   187

   188

	AdjustAvailAircraft();

   189

}

   190

   191

uint32 _engine_refit_masks[256];

   192

   193

   194

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

   195

   196

struct WagonOverride {

   197

	byte *train_id;

   198

	int trains;

   199

	struct SpriteGroup group;

   200

};

   201

   202

static struct WagonOverrides {

   203

	int overrides_count;

   204

	struct WagonOverride *overrides;

   205

} _engine_wagon_overrides[256];

   206

   207

void SetWagonOverrideSprites(byte engine, struct SpriteGroup *group,

   208

                             byte *train_id, int trains)

   209

{

   210

	struct WagonOverrides *wos;

   211

	struct WagonOverride *wo;

   212

   213

	wos = &_engine_wagon_overrides[engine];

   214

	wos->overrides_count++;

   215

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

   216

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

   217

   218

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

   219

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

   220

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

   221

	 * --pasky */

   222

	wo->group = *group;

   223

	wo->trains = trains;

   224

	wo->train_id = malloc(trains);

   225

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

   226

}

   227

   228

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

   229

{

   230

	struct WagonOverrides *wos = &_engine_wagon_overrides[engine];

   231

	int i;

   232

   233

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

   234

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

   235

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

   236

	// that. --pasky

   237

   238

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

   239

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

   240

		int j;

   241

   242

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

   243

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

   244

				return &wo->group;

   245

		}

   246

	}

   247

	return NULL;

   248

}

   249

   250

   251

byte _engine_original_sprites[256];

   252

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

   253

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

   254

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

   255

// memory. --pasky)

   256

static struct SpriteGroup _engine_custom_sprites[256][NUM_CID];

   257

   258

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

   259

{

   260

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

   261

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

   262

	 * --pasky */

   263

	_engine_custom_sprites[engine][cargo] = *group;

   264

}

   265

   266

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

   267

                                                    struct Vehicle *veh,

   268

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

   269

   270

static struct RealSpriteGroup *

   271

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

   272

			  resolve_callback callback)

   273

{

   274

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

   275

	switch (spritegroup->type) {

   276

		case SGT_REAL:

   277

			return &spritegroup->g.real;

   278

   279

		case SGT_DETERMINISTIC: {

   280

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

   281

			struct SpriteGroup *target;

   282

			int value = -1;

   283

   284

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

   285

   286

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

   287

				/* General property */

   288

				value = GetDeterministicSpriteValue(dsg->variable);

   289

   290

			} else {

   291

				/* Vehicle-specific property. */

   292

   293

				if (veh == NULL) {

   294

					/* We are in a purchase list of something,

   295

					 * and we are checking for something undefined.

   296

					 * That means we should get the first target

   297

					 * (NOT the default one). */

   298

					if (dsg->num_ranges > 0) {

   299

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

   300

					} else {

   301

						target = dsg->default_group;

   302

					}

   303

					return callback(target, NULL, callback);

   304

				}

   305

   306

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   307

					/* First engine in the vehicle chain */

   308

					if (veh->type == VEH_Train)

   309

						veh = GetFirstVehicleInChain(veh);

   310

				}

   311

   312

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

   313

					if (veh->type == VEH_Train) {

   314

						Vehicle *u = GetFirstVehicleInChain(veh);

   315

						byte chain_before = 0, chain_after = 0;

   316

   317

						while (u != veh) {

   318

							u = u->next;

   319

							chain_before++;

   320

						}

   321

						while (u->next != NULL) {

   322

							u = u->next;

   323

							chain_after++;

   324

						};

   325

   326

						value = chain_before << 16 | chain_after << 8

   327

						        | (chain_before + chain_after + 1);

   328

					} else {

   329

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

   330

					}

   331

   332

				} else {

   333

					// TTDPatch runs on little-endian arch;

   334

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

   335

					switch (dsg->variable - 0x80) {

   336

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

   337

						veh_prop(0x00, veh->type);

   338

						veh_prop(0x01, veh->subtype);

   339

						veh_prop(0x04, veh->index);

   340

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

   341

						/* XXX? Is THIS right? */

   342

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

   343

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

   344

						veh_prop(0x0C, veh->num_orders);

   345

						veh_prop(0x0D, veh->cur_order_index);

   346

						veh_prop(0x10, veh->load_unload_time_rem);

   347

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

   348

						veh_prop(0x12, veh->date_of_last_service);

   349

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

   350

						veh_prop(0x14, veh->service_interval);

   351

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

   352

						veh_prop(0x16, veh->last_station_visited);

   353

						veh_prop(0x17, veh->tick_counter);

   354

						veh_prop(0x18, veh->max_speed);

   355

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

   356

						veh_prop(0x1F, veh->direction);

   357

						veh_prop(0x28, veh->cur_image);

   358

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

   359

						veh_prop(0x32, veh->vehstatus);

   360

						veh_prop(0x33, veh->vehstatus);

   361

						veh_prop(0x34, veh->cur_speed);

   362

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

   363

						veh_prop(0x36, veh->subspeed);

   364

						veh_prop(0x37, veh->acceleration);

   365

						veh_prop(0x39, veh->cargo_type);

   366

						veh_prop(0x3A, veh->cargo_cap);

   367

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

   368

						veh_prop(0x3C, veh->cargo_count);

   369

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

   370

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

   371

						veh_prop(0x3F, veh->cargo_days);

   372

						veh_prop(0x40, veh->age);

   373

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

   374

						veh_prop(0x42, veh->max_age);

   375

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

   376

						veh_prop(0x44, veh->build_year);

   377

						veh_prop(0x45, veh->unitnumber);

   378

						veh_prop(0x46, veh->engine_type);

   379

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

   380

						veh_prop(0x48, veh->spritenum);

   381

						veh_prop(0x49, veh->day_counter);

   382

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   383

						veh_prop(0x4B, veh->breakdown_ctr);

   384

						veh_prop(0x4C, veh->breakdown_delay);

   385

						veh_prop(0x4D, veh->breakdown_chance);

   386

						veh_prop(0x4E, veh->reliability);

   387

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

   388

						veh_prop(0x50, veh->reliability_spd_dec);

   389

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

   390

						veh_prop(0x52, veh->profit_this_year);

   391

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

   392

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

   393

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

   394

						veh_prop(0x56, veh->profit_last_year);

   395

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

   396

						veh_prop(0x58, veh->profit_last_year);

   397

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

   398

						veh_prop(0x5A, veh->next_in_chain_old);

   399

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

   400

						veh_prop(0x5C, veh->value);

   401

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

   402

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

   403

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

   404

						veh_prop(0x60, veh->string_id);

   405

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

   406

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

   407

						 * aircraft: >=13h when in flight

   408

						 * train, ship: 80h=in depot

   409

						 * rv: 0feh=in depot */

   410

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

   411

   412

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

   413

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

   414

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

   415

   416

#undef veh_prop

   417

					}

   418

				}

   419

			}

   420

   421

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

   422

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

   423

			return callback(target, veh, callback);

   424

		}

   425

   426

		case SGT_RANDOMIZED: {

   427

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

   428

   429

			if (veh == NULL) {

   430

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

   431

				assert(rsg->num_groups > 0);

   432

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

   433

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

   434

			}

   435

   436

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   437

				/* First engine in the vehicle chain */

   438

				if (veh->type == VEH_Train)

   439

					veh = GetFirstVehicleInChain(veh);

   440

			}

   441

   442

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

   443

		}

   444

   445

		default:

   446

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

   447

			return NULL;

   448

	}

   449

}

   450

   451

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

   452

{

   453

	struct SpriteGroup *group;

   454

	uint16 overriding_engine = -1;

   455

	byte cargo = CID_PURCHASE;

   456

   457

	if (v != NULL) {

   458

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

   459

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

   460

	}

   461

   462

	group = &_engine_custom_sprites[engine][cargo];

   463

   464

	if (overriding_engine != 0xffff) {

   465

		struct SpriteGroup *overset;

   466

   467

		overset = GetWagonOverrideSpriteSet(engine, overriding_engine);

   468

		if (overset) group = overset;

   469

	}

   470

   471

	return group;

   472

}

   473

   474

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

   475

{

   476

	struct SpriteGroup *group;

   477

	struct RealSpriteGroup *rsg;

   478

	byte cargo = CID_PURCHASE;

   479

	byte loaded = 0;

   480

	bool in_motion = 0;

   481

	int totalsets, spriteset;

   482

	int r;

   483

   484

	if (v != NULL) {

   485

		int capacity = v->cargo_cap;

   486

   487

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

   488

		if (capacity == 0) capacity = 1;

   489

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

   490

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

   491

	}

   492

   493

	group = GetVehicleSpriteGroup(engine, v);

   494

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

   495

   496

	if (rsg->sprites_per_set == 0 && cargo != 29) { /* XXX magic number */

   497

		// This group is empty but perhaps there'll be a default one.

   498

		rsg = ResolveVehicleSpriteGroup(&_engine_custom_sprites[engine][29], v,

   499

		                                (resolve_callback) ResolveVehicleSpriteGroup);

   500

	}

   501

   502

	if (!rsg->sprites_per_set) {

   503

		// This group is empty. This function users should therefore

   504

		// look up the sprite number in _engine_original_sprites.

   505

		return 0;

   506