1

#include "stdafx.h"

     2

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

   123

   124

	SetupEngineNames();

   125

   126

   127

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

   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

   169

	AdjustAvailAircraft();

   170

}

   171

   172

uint32 _engine_refit_masks[256];

   173

   174

   175

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

   176

   177

struct WagonOverride {

   178

	byte *train_id;

   179

	int trains;

   180

	struct SpriteGroup group;

   181

};

   182

   183

static struct WagonOverrides {

   184

	int overrides_count;

   185

	struct WagonOverride *overrides;

   186

} _engine_wagon_overrides[256];

   187

   188

void SetWagonOverrideSprites(byte engine, struct SpriteGroup *group,

   189

                             byte *train_id, int trains)

   190

{

   191

	struct WagonOverrides *wos;

   192

	struct WagonOverride *wo;

   193

   194

	wos = &_engine_wagon_overrides[engine];

   195

	wos->overrides_count++;

   196

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

   197

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

   198

   199

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

   200

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

   201

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

   202

	 * --pasky */

   203

	wo->group = *group;

   204

	wo->trains = trains;

   205

	wo->train_id = malloc(trains);

   206

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

   207

}

   208

   209

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

   210

{

   211

	struct WagonOverrides *wos = &_engine_wagon_overrides[engine];

   212

	int i;

   213

   214

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

   215

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

   216

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

   217

	// that. --pasky

   218

   219

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

   220

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

   221

		int j;

   222

   223

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

   224

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

   225

				return &wo->group;

   226

		}

   227

	}

   228

	return NULL;

   229

}

   230

   231

   232

byte _engine_original_sprites[256];

   233

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

   234

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

   235

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

   236

// memory. --pasky)

   237

static struct SpriteGroup _engine_custom_sprites[256][NUM_CID];

   238

   239

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

   240

{

   241

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

   242

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

   243

	 * --pasky */

   244

	_engine_custom_sprites[engine][cargo] = *group;

   245

}

   246

   247

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

   248

                                                    struct Vehicle *veh,

   249

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

   250

   251

static struct RealSpriteGroup *

   252

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

   253

			  resolve_callback callback)

   254

{

   255

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

   256

	switch (spritegroup->type) {

   257

		case SGT_REAL:

   258

			return &spritegroup->g.real;

   259

   260

		case SGT_DETERMINISTIC: {

   261

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

   262

			struct SpriteGroup *target;

   263

			int value = -1;

   264

   265

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

   266

   267

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

   268

				/* General property */

   269

				value = GetDeterministicSpriteValue(dsg->variable);

   270

   271

			} else {

   272

				/* Vehicle-specific property. */

   273

   274

				if (veh == NULL) {

   275

					/* We are in a purchase list of something,

   276

					 * and we are checking for something undefined.

   277

					 * That means we should get the first target

   278

					 * (NOT the default one). */

   279

					if (dsg->num_ranges > 0) {

   280

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

   281

					} else {

   282

						target = dsg->default_group;

   283

					}

   284

					return callback(target, NULL, callback);

   285

				}

   286

   287

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   288

					/* First engine in the vehicle chain */

   289

					if (veh->type == VEH_Train)

   290

						veh = GetFirstVehicleInChain(veh);

   291

				}

   292

   293

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

   294

					if (veh->type == VEH_Train) {

   295

						Vehicle *u = GetFirstVehicleInChain(veh);

   296

						byte chain_before = 0, chain_after = 0;

   297

   298

						while (u != veh) {

   299

							u = u->next;

   300

							chain_before++;

   301

						}

   302

						while (u->next != NULL) {

   303

							u = u->next;

   304

							chain_after++;

   305

						};

   306

   307

						value = chain_before << 16 | chain_after << 8

   308

						        | (chain_before + chain_after + 1);

   309

					} else {

   310

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

   311

					}

   312

   313

				} else {

   314

					// TTDPatch runs on little-endian arch;

   315

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

   316

					switch (dsg->variable - 0x80) {

   317

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

   318

						veh_prop(0x00, veh->type);

   319

						veh_prop(0x01, veh->subtype);

   320

						veh_prop(0x04, veh->index);

   321

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

   322

						/* XXX? Is THIS right? */

   323

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

   324

						veh_prop(0x0B, veh->next_order);

   325

						veh_prop(0x0C, veh->num_orders);

   326

						veh_prop(0x0D, veh->cur_order_index);

   327

						veh_prop(0x10, veh->load_unload_time_rem);

   328

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

   329

						veh_prop(0x12, veh->date_of_last_service);

   330

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

   331

						veh_prop(0x14, veh->service_interval);

   332

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

   333

						veh_prop(0x16, veh->last_station_visited);

   334

						veh_prop(0x17, veh->tick_counter);

   335

						veh_prop(0x18, veh->max_speed);

   336

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

   337

						veh_prop(0x1F, veh->direction);

   338

						veh_prop(0x28, veh->cur_image);

   339

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

   340

						veh_prop(0x32, veh->vehstatus);

   341

						veh_prop(0x33, veh->vehstatus);

   342

						veh_prop(0x34, veh->cur_speed);

   343

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

   344

						veh_prop(0x36, veh->subspeed);

   345

						veh_prop(0x37, veh->acceleration);

   346

						veh_prop(0x39, veh->cargo_type);

   347

						veh_prop(0x3A, veh->cargo_cap);

   348

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

   349

						veh_prop(0x3C, veh->cargo_count);

   350

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

   351

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

   352

						veh_prop(0x3F, veh->cargo_days);

   353

						veh_prop(0x40, veh->age);

   354

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

   355

						veh_prop(0x42, veh->max_age);

   356

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

   357

						veh_prop(0x44, veh->build_year);

   358

						veh_prop(0x45, veh->unitnumber);

   359

						veh_prop(0x46, veh->engine_type);

   360

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

   361

						veh_prop(0x48, veh->spritenum);

   362

						veh_prop(0x49, veh->day_counter);

   363

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   364

						veh_prop(0x4B, veh->breakdown_ctr);

   365

						veh_prop(0x4C, veh->breakdown_delay);

   366

						veh_prop(0x4D, veh->breakdown_chance);

   367

						veh_prop(0x4E, veh->reliability);

   368

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

   369

						veh_prop(0x50, veh->reliability_spd_dec);

   370

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

   371

						veh_prop(0x52, veh->profit_this_year);

   372

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

   373

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

   374

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

   375

						veh_prop(0x56, veh->profit_last_year);

   376

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

   377

						veh_prop(0x58, veh->profit_last_year);

   378

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

   379

						veh_prop(0x5A, veh->next_in_chain_old);

   380

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

   381

						veh_prop(0x5C, veh->value);

   382

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

   383

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

   384

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

   385

						veh_prop(0x60, veh->string_id);

   386

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

   387

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

   388

						 * aircraft: >=13h when in flight

   389

						 * train, ship: 80h=in depot

   390

						 * rv: 0feh=in depot */

   391

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

   392

   393

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

   394

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

   395

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

   396

   397

#undef veh_prop

   398

					}

   399

				}

   400

			}

   401

   402

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

   403

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

   404

			return callback(target, veh, callback);

   405

		}

   406

   407

		case SGT_RANDOMIZED: {

   408

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

   409

   410

			if (veh == NULL) {

   411

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

   412

				assert(rsg->num_groups > 0);

   413

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

   414

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

   415

			}

   416

   417

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   418

				/* First engine in the vehicle chain */

   419

				if (veh->type == VEH_Train)

   420

					veh = GetFirstVehicleInChain(veh);

   421

			}

   422

   423

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

   424

		}

   425

   426

		default:

   427

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

   428

			return NULL;

   429

	}

   430

}

   431

   432

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

   433

{

   434

	struct SpriteGroup *group;

   435

	uint16 overriding_engine = -1;

   436

	byte cargo = CID_PURCHASE;

   437

   438

	if (v != NULL) {

   439

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

   440

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

   441

	}

   442

   443

	group = &_engine_custom_sprites[engine][cargo];

   444

   445

	if (overriding_engine != 0xffff) {

   446

		struct SpriteGroup *overset;

   447

   448

		overset = GetWagonOverrideSpriteSet(engine, overriding_engine);

   449

		if (overset) group = overset;

   450

	}

   451

   452

	return group;

   453

}

   454

   455

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

   456

{

   457

	struct SpriteGroup *group;

   458

	struct RealSpriteGroup *rsg;

   459

	byte cargo = CID_PURCHASE;

   460

	byte loaded = 0;

   461

	bool in_motion = 0;

   462

	int totalsets, spriteset;

   463

	int r;

   464

   465

	if (v != NULL) {

   466

		int capacity = v->cargo_cap;

   467

   468

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

   469

		if (capacity == 0) capacity = 1;

   470

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

   471

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

   472

	}

   473

   474

	group = GetVehicleSpriteGroup(engine, v);

   475

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

   476

   477

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

   478

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

   479

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

   480

		                                (resolve_callback) ResolveVehicleSpriteGroup);

   481

	}

   482

   483

	if (!rsg->sprites_per_set) {

   484

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

   485

		// look up the sprite number in _engine_original_sprites.

   486

		return 0;

   487

	}

   488

   489

	direction %= 8;

   490

	if (rsg->sprites_per_set == 4)

   491

		direction %= 4;

   492

   493

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

   494

   495

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

   496

	// empty and totally full vehicles. --pasky

   497

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

   498

		spriteset = totalsets - 1;

   499

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

   500

		spriteset = 0;

   501

	} else { // something inbetween

   502

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

   503

		// correct possible rounding errors

   504

		if (!spriteset)

   505

			spriteset = 1;

   506

		else if (spriteset == totalsets - 1)

   507

			spriteset--;