1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "engine.h"

     4

#include "table/engines.h"

     5

#include "player.h"

     6

#include "command.h"

     7

#include "vehicle.h"

     8

#include "news.h"

     9

#include "saveload.h"

    10

#include "sprite.h"

    11

    12

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

    13

    14

enum {

    15

	ENGINE_AVAILABLE = 1,

    16

	ENGINE_INTRODUCING = 2,

    17

	ENGINE_PREVIEWING = 4,

    18

};

    19

    20

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

    21

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

    22

 * TTDPatch's newgrf.txt. */

    23

byte _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    24

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

    25

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

    26

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

    27

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

    28

	// 27 is paper in temperate climate in TTDPatch

    29

	// Following can be renumbered:

    30

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

    31

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

    32

};

    33

    34

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

    35

byte _local_cargo_id_ctype[NUM_CID] = {

    36

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

    37

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

    38

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

    39

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

    40

};

    41

    42

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

    43

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

    44

byte _local_cargo_id_landscape[NUM_CID] = {

    45

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

    46

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

    47

};

    48

    49

void ShowEnginePreviewWindow(int engine);

    50

    51

void DeleteCustomEngineNames()

    52

{

    53

	uint i;

    54

	StringID old;

    55

    56

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

    57

		old = _engine_name_strings[i];

    58

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    59

		DeleteName(old);

    60

	}

    61

    62

	_vehicle_design_names &= ~1;

    63

}

    64

    65

void LoadCustomEngineNames()

    66

{

    67

	// XXX: not done */

    68

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

    69

}

    70

    71

static void SetupEngineNames()

    72

{

    73

	uint i;

    74

    75

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

    76

		_engine_name_strings[i] = STR_SV_EMPTY;

    77

    78

	DeleteCustomEngineNames();

    79

	LoadCustomEngineNames();

    80

}

    81

    82

static void AdjustAvailAircraft()

    83

{

    84

	uint16 date = _date;

    85

	byte avail = 0;

    86

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

    87

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

    88

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

    89

    90

	if (avail != _avail_aircraft) {

    91

		_avail_aircraft = avail;

    92

		InvalidateWindow(WC_BUILD_STATION, 0);

    93

	}

    94

}

    95

    96

static void CalcEngineReliability(Engine *e)

    97

{

    98

	uint age = e->age;

    99

   100

	if (age < e->duration_phase_1) {

   101

		uint start = e->reliability_start;

   102

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

   103

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

   104

		e->reliability = e->reliability_max;

   105

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

   106

		uint max = e->reliability_max;

   107

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

   108

	} else {

   109

		// time's up for this engine

   110

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

   111

		// or disable this engine completely

   112

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

   113

		e->reliability = e->reliability_final;

   114

	}

   115

}

   116

   117

void StartupEngines()

   118

{

   119

	Engine *e;

   120

	const EngineInfo *ei;

   121

	uint32 r;

   122

   123

	SetupEngineNames();

   124

   125

   126

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

   127

		e->age = 0;

   128

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

   129

		e->flags = 0;

   130

		e->player_avail = 0;

   131

   132

		r = Random();

   133

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

   134

		if (e->intro_date <= _date) {

   135

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

   136

			e->player_avail = (byte)-1;

   137

			e->flags |= ENGINE_AVAILABLE;

   138

		}

   139

   140

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

   141

		r = Random();

   142

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

   143

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

   144

   145

		r = Random();

   146

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

   147

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

   148

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

   149

   150

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

   151

   152

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

   153

		if (ei->unk2 & 0x80) {

   154

			e->age = 0xFFFF;

   155

		} else {

   156

			CalcEngineReliability(e);

   157

		}

   158

   159

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

   160

   161

		// prevent certain engines from ever appearing.

   162

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

   163

			e->flags |= ENGINE_AVAILABLE;

   164

			e->player_avail = 0;

   165

		}

   166

	}

   167

   168

	AdjustAvailAircraft();

   169

}

   170

   171

uint32 _engine_refit_masks[256];

   172

   173

   174

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

   175

   176

struct WagonOverride {

   177

	byte *train_id;

   178

	int trains;

   179

	struct SpriteGroup group;

   180

};

   181

   182

static struct WagonOverrides {

   183

	int overrides_count;

   184

	struct WagonOverride *overrides;

   185

} _engine_wagon_overrides[256];

   186

   187

void SetWagonOverrideSprites(byte engine, struct SpriteGroup *group,

   188

                             byte *train_id, int trains)

   189

{

   190

	struct WagonOverrides *wos;

   191

	struct WagonOverride *wo;

   192

   193

	wos = &_engine_wagon_overrides[engine];

   194

	wos->overrides_count++;

   195

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

   196

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

   197

   198

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

   199

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

   200

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

   201

	 * --pasky */

   202

	wo->group = *group;

   203

	wo->trains = trains;

   204

	wo->train_id = malloc(trains);

   205

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

   206

}

   207

   208

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

   209

{

   210

	struct WagonOverrides *wos = &_engine_wagon_overrides[engine];

   211

	int i;

   212

   213

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

   214

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

   215

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

   216

	// that. --pasky

   217

   218

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

   219

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

   220

		int j;

   221

   222

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

   223

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

   224

				return &wo->group;

   225

		}

   226

	}

   227

	return NULL;

   228

}

   229

   230

   231

byte _engine_original_sprites[256];

   232

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

   233

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

   234

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

   235

// memory. --pasky)

   236

static struct SpriteGroup _engine_custom_sprites[256][NUM_CID];

   237

   238

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

   239

{

   240

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

   241

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

   242

	 * --pasky */

   243

	_engine_custom_sprites[engine][cargo] = *group;

   244

}

   245

   246

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

   247

                                                    struct Vehicle *veh,

   248

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

   249

   250

static struct RealSpriteGroup *

   251

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

   252

			  resolve_callback callback)

   253

{

   254

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

   255

	switch (spritegroup->type) {

   256

		case SGT_REAL:

   257

			return &spritegroup->g.real;

   258

   259

		case SGT_DETERMINISTIC: {

   260

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

   261

			struct SpriteGroup *target;

   262

			int value = -1;

   263

   264

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

   265

   266

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

   267

				/* General property */

   268

				value = GetDeterministicSpriteValue(dsg->variable);

   269

   270

			} else {

   271

				/* Vehicle-specific property. */

   272

   273

				if (veh == NULL) {

   274

					/* We are in a purchase list of something,

   275

					 * and we are checking for something undefined.

   276

					 * That means we should get the first target

   277

					 * (NOT the default one). */

   278

					if (dsg->num_ranges > 0) {

   279

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

   280

					} else {

   281

						target = dsg->default_group;

   282

					}

   283

					return callback(target, NULL, callback);

   284

				}

   285

   286

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   287

					/* First engine in the vehicle chain */

   288

					if (veh->type == VEH_Train)

   289

						veh = GetFirstVehicleInChain(veh);

   290

				}

   291

   292

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

   293

					if (veh->type == VEH_Train) {

   294

						Vehicle *u = GetFirstVehicleInChain(veh);

   295

						byte chain_before = 0, chain_after = 0;

   296

   297

						while (u != veh) {

   298

							u = u->next;

   299

							chain_before++;

   300

						}

   301

						while (u->next != NULL) {

   302

							u = u->next;

   303

							chain_after++;

   304

						};

   305

   306

						value = chain_before << 16 | chain_after << 8

   307

						        | (chain_before + chain_after + 1);

   308

					} else {

   309

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

   310

					}

   311

   312

				} else {

   313

					// TTDPatch runs on little-endian arch;

   314

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

   315

					switch (dsg->variable - 0x80) {

   316

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

   317

						veh_prop(0x00, veh->type);

   318

						veh_prop(0x01, veh->subtype);

   319

						veh_prop(0x04, veh->index);

   320

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

   321

						/* XXX? Is THIS right? */

   322

						veh_prop(0x0A, veh->next_order_param << 8 | veh->next_order);

   323

						veh_prop(0x0B, veh->next_order);

   324

						veh_prop(0x0C, veh->num_orders);

   325

						veh_prop(0x0D, veh->cur_order_index);

   326

						veh_prop(0x10, veh->load_unload_time_rem);

   327

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

   328

						veh_prop(0x12, veh->date_of_last_service);

   329

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

   330

						veh_prop(0x14, veh->service_interval);

   331

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

   332

						veh_prop(0x16, veh->last_station_visited);

   333

						veh_prop(0x17, veh->tick_counter);

   334

						veh_prop(0x18, veh->max_speed);

   335

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

   336

						veh_prop(0x1F, veh->direction);

   337

						veh_prop(0x28, veh->cur_image);

   338

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

   339

						veh_prop(0x32, veh->vehstatus);

   340

						veh_prop(0x33, veh->vehstatus);

   341

						veh_prop(0x34, veh->cur_speed);

   342

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

   343

						veh_prop(0x36, veh->subspeed);

   344

						veh_prop(0x37, veh->acceleration);

   345

						veh_prop(0x39, veh->cargo_type);

   346

						veh_prop(0x3A, veh->cargo_cap);

   347

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

   348

						veh_prop(0x3C, veh->cargo_count);

   349

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

   350

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

   351

						veh_prop(0x3F, veh->cargo_days);

   352

						veh_prop(0x40, veh->age);

   353

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

   354

						veh_prop(0x42, veh->max_age);

   355

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

   356

						veh_prop(0x44, veh->build_year);

   357

						veh_prop(0x45, veh->unitnumber);

   358

						veh_prop(0x46, veh->engine_type);

   359

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

   360

						veh_prop(0x48, veh->spritenum);

   361

						veh_prop(0x49, veh->day_counter);

   362

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   363

						veh_prop(0x4B, veh->breakdown_ctr);

   364

						veh_prop(0x4C, veh->breakdown_delay);

   365

						veh_prop(0x4D, veh->breakdown_chance);

   366

						veh_prop(0x4E, veh->reliability);

   367

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

   368

						veh_prop(0x50, veh->reliability_spd_dec);

   369

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

   370

						veh_prop(0x52, veh->profit_this_year);

   371

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

   372

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

   373

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

   374

						veh_prop(0x56, veh->profit_last_year);

   375

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

   376

						veh_prop(0x58, veh->profit_last_year);

   377

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

   378

						veh_prop(0x5A, veh->next_in_chain_old);

   379

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

   380

						veh_prop(0x5C, veh->value);

   381

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

   382

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

   383

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

   384

						veh_prop(0x60, veh->string_id);

   385

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

   386

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

   387

						 * aircraft: >=13h when in flight

   388

						 * train, ship: 80h=in depot

   389

						 * rv: 0feh=in depot */

   390

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

   391

   392

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

   393

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

   394

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

   395

   396

#undef veh_prop

   397

					}

   398

				}

   399

			}

   400

   401

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

   402

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

   403

			return callback(target, veh, callback);

   404

		}

   405

   406

		case SGT_RANDOMIZED: {

   407

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

   408

   409

			if (veh == NULL) {

   410

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

   411

				assert(rsg->num_groups > 0);

   412

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

   413

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

   414

			}

   415

   416

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   417

				/* First engine in the vehicle chain */

   418

				if (veh->type == VEH_Train)

   419

					veh = GetFirstVehicleInChain(veh);

   420

			}

   421

   422

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

   423

		}

   424

   425

		default:

   426

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

   427

			return NULL;

   428

	}

   429

}

   430

   431

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

   432

{

   433

	struct SpriteGroup *group;

   434

	uint16 overriding_engine = -1;

   435

	byte cargo = CID_PURCHASE;

   436

   437

	if (v != NULL) {

   438

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

   439

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

   440

	}

   441

   442

	group = &_engine_custom_sprites[engine][cargo];

   443

   444

	if (overriding_engine != 0xffff) {

   445

		struct SpriteGroup *overset;

   446

   447

		overset = GetWagonOverrideSpriteSet(engine, overriding_engine);

   448

		if (overset) group = overset;

   449

	}

   450

   451

	return group;

   452

}

   453

   454

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

   455

{

   456

	struct SpriteGroup *group;

   457

	struct RealSpriteGroup *rsg;

   458

	byte cargo = CID_PURCHASE;

   459

	byte loaded = 0;

   460

	bool in_motion = 0;

   461

	int totalsets, spriteset;

   462

	int r;

   463

   464

	if (v != NULL) {

   465

		int capacity = v->cargo_cap;

   466

   467

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

   468

		if (capacity == 0) capacity = 1;

   469

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

   470

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

   471

	}

   472

   473

	group = GetVehicleSpriteGroup(engine, v);

   474

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

   475

   476

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

   477

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

   478

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

   479

		                                (resolve_callback) ResolveVehicleSpriteGroup);

   480

	}

   481

   482

	if (!rsg->sprites_per_set) {

   483

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

   484

		// look up the sprite number in _engine_original_sprites.

   485

		return 0;

   486

	}

   487

   488

	direction %= 8;

   489

	if (rsg->sprites_per_set == 4)

   490

		direction %= 4;

   491

   492

	totalsets = in_motion ? rsg->loaded_count : rsg->loading_count;

   493

   494

	// My aim here is to make it possible to visually determine absolutely

   495

	// empty and totally full vehicles. --pasky

   496

	if (loaded == 100 || totalsets == 1) { // full

   497

		spriteset = totalsets - 1;

   498

	} else if (loaded == 0 || totalsets == 2) { // empty

   499

		spriteset = 0;

   500

	} else { // something inbetween

   501

		spriteset = loaded * (totalsets - 2) / 100 + 1;

   502

		// correct possible rounding errors

   503

		if (!spriteset)

   504

			spriteset = 1;

   505

		else if (spriteset == totalsets - 1)

   506

			spriteset--;

   507

	}