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

   119

{

   120

	Engine *e;

   121

	uint32 counter = 0;

   122

   123

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

   124

   125

		e->type = VEH_Train;

   126

		if 	(counter >= ROAD_ENGINES_INDEX) {

   127

			e->type = VEH_Road;

   128

			if 	(counter >= SHIP_ENGINES_INDEX) {

   129

				e->type = VEH_Ship;

   130

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   131

					e->type = VEH_Aircraft;

   132

					if 	(counter >= TOTAL_NUM_ENGINES) {

   133

						e->type = VEH_Special;

   134

					}

   135

				}

   136

			}

   137

		}

   138

	}

   139

}

   140

   141

void StartupEngines()

   142

{

   143

	Engine *e;

   144

	const EngineInfo *ei;

   145

	uint32 r, counter = 0;

   146

   147

	SetupEngineNames();

   148

   149

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

   150

   151

		e->age = 0;

   152

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

   153

		e->flags = 0;

   154

		e->player_avail = 0;

   155

   156

		r = Random();

   157

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

   158

		if (e->intro_date <= _date) {

   159

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

   160

			e->player_avail = (byte)-1;

   161

			e->flags |= ENGINE_AVAILABLE;

   162

		}

   163

   164

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

   165

		r = Random();

   166

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

   167

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

   168

   169

		r = Random();

   170

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

   171

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

   172

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

   173

   174

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

   175

   176

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

   177

		if (ei->unk2 & 0x80) {

   178

			e->age = 0xFFFF;

   179

		} else {

   180

			CalcEngineReliability(e);

   181

		}

   182

   183

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

   184

   185

		// prevent certain engines from ever appearing.

   186

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

   187

			e->flags |= ENGINE_AVAILABLE;

   188

			e->player_avail = 0;

   189

		}

   190

   191

		/* This sets up type for the engine

   192

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

   193

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

   194

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

   195

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

   196

	}

   197

   198

	AdjustAvailAircraft();

   199

}

   200

   201

uint32 _engine_refit_masks[256];

   202

   203

   204

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

   205

   206

struct WagonOverride {

   207

	byte *train_id;

   208

	int trains;

   209

	struct SpriteGroup group;

   210

};

   211

   212

static struct WagonOverrides {

   213

	int overrides_count;

   214

	struct WagonOverride *overrides;

   215

} _engine_wagon_overrides[256];

   216

   217

void SetWagonOverrideSprites(byte engine, struct SpriteGroup *group,

   218

                             byte *train_id, int trains)

   219

{

   220

	struct WagonOverrides *wos;

   221

	struct WagonOverride *wo;

   222

   223

	wos = &_engine_wagon_overrides[engine];

   224

	wos->overrides_count++;

   225

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

   226

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

   227

   228

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

   229

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

   230

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

   231

	 * --pasky */

   232

	wo->group = *group;

   233

	wo->trains = trains;

   234

	wo->train_id = malloc(trains);

   235

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

   236

}

   237

   238

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

   239

{

   240

	struct WagonOverrides *wos = &_engine_wagon_overrides[engine];

   241

	int i;

   242

   243

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

   244

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

   245

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

   246

	// that. --pasky

   247

   248

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

   249

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

   250

		int j;

   251

   252

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

   253

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

   254

				return &wo->group;

   255

		}

   256

	}

   257

	return NULL;

   258

}

   259

   260

   261

byte _engine_original_sprites[256];

   262

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

   263

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

   264

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

   265

// memory. --pasky)

   266

static struct SpriteGroup _engine_custom_sprites[256][NUM_CID];

   267

   268

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

   269

{

   270

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

   271

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

   272

	 * --pasky */

   273

	_engine_custom_sprites[engine][cargo] = *group;

   274

}

   275

   276

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

   277

                                                    struct Vehicle *veh,

   278

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

   279

   280

static struct RealSpriteGroup *

   281

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

   282

			  resolve_callback callback)

   283

{

   284

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

   285

	switch (spritegroup->type) {

   286

		case SGT_REAL:

   287

			return &spritegroup->g.real;

   288

   289

		case SGT_DETERMINISTIC: {

   290

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

   291

			struct SpriteGroup *target;

   292

			int value = -1;

   293

   294

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

   295

   296

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

   297

				/* General property */

   298

				value = GetDeterministicSpriteValue(dsg->variable);

   299

   300

			} else {

   301

				/* Vehicle-specific property. */

   302

   303

				if (veh == NULL) {

   304

					/* We are in a purchase list of something,

   305

					 * and we are checking for something undefined.

   306

					 * That means we should get the first target

   307

					 * (NOT the default one). */

   308

					if (dsg->num_ranges > 0) {

   309

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

   310

					} else {

   311

						target = dsg->default_group;

   312

					}

   313

					return callback(target, NULL, callback);

   314

				}

   315

   316

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   317

					/* First engine in the vehicle chain */

   318

					if (veh->type == VEH_Train)

   319

						veh = GetFirstVehicleInChain(veh);

   320

				}

   321

   322

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

   323

					if (veh->type == VEH_Train) {

   324

						Vehicle *u = GetFirstVehicleInChain(veh);

   325

						byte chain_before = 0, chain_after = 0;

   326

   327

						while (u != veh) {

   328

							u = u->next;

   329

							chain_before++;

   330

						}

   331

						while (u->next != NULL) {

   332

							u = u->next;

   333

							chain_after++;

   334

						};

   335

   336

						value = chain_before << 16 | chain_after << 8

   337

						        | (chain_before + chain_after + 1);

   338

					} else {

   339

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

   340

					}

   341

   342

				} else {

   343

					// TTDPatch runs on little-endian arch;

   344

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

   345

					switch (dsg->variable - 0x80) {

   346

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

   347

						veh_prop(0x00, veh->type);

   348

						veh_prop(0x01, veh->subtype);

   349

						veh_prop(0x04, veh->index);

   350

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

   351

						/* XXX? Is THIS right? */

   352

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

   353

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

   354

						veh_prop(0x0C, veh->num_orders);

   355

						veh_prop(0x0D, veh->cur_order_index);

   356

						veh_prop(0x10, veh->load_unload_time_rem);

   357

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

   358

						veh_prop(0x12, veh->date_of_last_service);

   359

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

   360

						veh_prop(0x14, veh->service_interval);

   361

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

   362

						veh_prop(0x16, veh->last_station_visited);

   363

						veh_prop(0x17, veh->tick_counter);

   364

						veh_prop(0x18, veh->max_speed);

   365

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

   366

						veh_prop(0x1F, veh->direction);

   367

						veh_prop(0x28, veh->cur_image);

   368

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

   369

						veh_prop(0x32, veh->vehstatus);

   370

						veh_prop(0x33, veh->vehstatus);

   371

						veh_prop(0x34, veh->cur_speed);

   372

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

   373

						veh_prop(0x36, veh->subspeed);

   374

						veh_prop(0x37, veh->acceleration);

   375

						veh_prop(0x39, veh->cargo_type);

   376

						veh_prop(0x3A, veh->cargo_cap);

   377

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

   378

						veh_prop(0x3C, veh->cargo_count);

   379

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

   380

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

   381

						veh_prop(0x3F, veh->cargo_days);

   382

						veh_prop(0x40, veh->age);

   383

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

   384

						veh_prop(0x42, veh->max_age);

   385

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

   386

						veh_prop(0x44, veh->build_year);

   387

						veh_prop(0x45, veh->unitnumber);

   388

						veh_prop(0x46, veh->engine_type);

   389

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

   390

						veh_prop(0x48, veh->spritenum);

   391

						veh_prop(0x49, veh->day_counter);

   392

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   393

						veh_prop(0x4B, veh->breakdown_ctr);

   394

						veh_prop(0x4C, veh->breakdown_delay);

   395

						veh_prop(0x4D, veh->breakdown_chance);

   396

						veh_prop(0x4E, veh->reliability);

   397

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

   398

						veh_prop(0x50, veh->reliability_spd_dec);

   399

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

   400

						veh_prop(0x52, veh->profit_this_year);

   401

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

   402

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

   403

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

   404

						veh_prop(0x56, veh->profit_last_year);

   405

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

   406

						veh_prop(0x58, veh->profit_last_year);

   407

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

   408

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

   409

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

   410

						veh_prop(0x5C, veh->value);

   411

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

   412

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

   413

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

   414

						veh_prop(0x60, veh->string_id);

   415

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

   416

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

   417

						 * aircraft: >=13h when in flight

   418

						 * train, ship: 80h=in depot

   419

						 * rv: 0feh=in depot */

   420

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

   421

   422

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

   423

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

   424

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

   425

   426

#undef veh_prop

   427

					}

   428

				}

   429

			}

   430

   431

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

   432

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

   433

			return callback(target, veh, callback);

   434

		}

   435

   436

		case SGT_RANDOMIZED: {

   437

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

   438

   439

			if (veh == NULL) {

   440

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

   441

				assert(rsg->num_groups > 0);

   442

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

   443

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

   444

			}

   445

   446

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   447

				/* First engine in the vehicle chain */

   448

				if (veh->type == VEH_Train)

   449

					veh = GetFirstVehicleInChain(veh);

   450

			}

   451

   452

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

   453

		}

   454

   455

		default:

   456

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

   457

			return NULL;

   458

	}

   459

}

   460

   461

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

   462

{

   463

	struct SpriteGroup *group;

   464

	uint16 overriding_engine = -1;

   465

	byte cargo = CID_PURCHASE;

   466

   467

	if (v != NULL) {

   468

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

   469

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

   470

	}

   471

   472

	group = &_engine_custom_sprites[engine][cargo];

   473

   474

	if (overriding_engine != 0xffff) {

   475

		struct SpriteGroup *overset;

   476

   477

		overset = GetWagonOverrideSpriteSet(engine, overriding_engine);

   478

		if (overset) group = overset;

   479

	}

   480

   481

	return group;

   482

}

   483

   484

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

   485

{

   486

	struct SpriteGroup *group;

   487

	struct RealSpriteGroup *rsg;

   488

	byte cargo = CID_PURCHASE;

   489

	byte loaded = 0;

   490

	bool in_motion = 0;

   491

	int totalsets, spriteset;

   492

	int r;

   493

   494

	if (v != NULL) {

   495

		int capacity = v->cargo_cap;

   496

   497

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

   498

		if (capacity == 0) capacity = 1;

   499

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

   500

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

   501

	}

   502

   503

	group = GetVehicleSpriteGroup(engine, v);

   504

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

   505