1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "table/strings.h"

     5

#include "engine.h"

     6

#include "table/engines.h"

     7

#include "gfx.h"

     8

#include "player.h"

     9

#include "command.h"

    10

#include "vehicle.h"

    11

#include "news.h"

    12

#include "saveload.h"

    13

#include "sprite.h"

    14

    15

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

    16

    17

enum {

    18

	ENGINE_AVAILABLE = 1,

    19

	ENGINE_INTRODUCING = 2,

    20

	ENGINE_PREVIEWING = 4,

    21

};

    22

    23

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

    24

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

    25

 * TTDPatch's newgrf.txt. */

    26

byte _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO] = {

    27

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

    28

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

    29

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

    30

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

    31

	// 27 is paper in temperate climate in TTDPatch

    32

	// Following can be renumbered:

    33

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

    34

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

    35

};

    36

    37

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

    38

byte _local_cargo_id_ctype[NUM_CID] = {

    39

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

    40

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

    41

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

    42

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

    43

};

    44

    45

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

    46

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

    47

byte _local_cargo_id_landscape[NUM_CID] = {

    48

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

    49

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

    50

};

    51

    52

void ShowEnginePreviewWindow(int engine);

    53

    54

void DeleteCustomEngineNames(void)

    55

{

    56

	uint i;

    57

	StringID old;

    58

    59

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

    60

		old = _engine_name_strings[i];

    61

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

    62

		DeleteName(old);

    63

	}

    64

    65

	_vehicle_design_names &= ~1;

    66

}

    67

    68

void LoadCustomEngineNames(void)

    69

{

    70

	// XXX: not done */

    71

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

    72

}

    73

    74

static void SetupEngineNames(void)

    75

{

    76

	uint i;

    77

    78

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

    79

		_engine_name_strings[i] = STR_SV_EMPTY;

    80

    81

	DeleteCustomEngineNames();

    82

	LoadCustomEngineNames();

    83

}

    84

    85

static void AdjustAvailAircraft(void)

    86

{

    87

	uint16 date = _date;

    88

	byte avail = 0;

    89

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

    90

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

    91

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

    92

    93

	if (avail != _avail_aircraft) {

    94

		_avail_aircraft = avail;

    95

		InvalidateWindow(WC_BUILD_STATION, 0);

    96

	}

    97

}

    98

    99

static void CalcEngineReliability(Engine *e)

   100

{

   101

	uint age = e->age;

   102

   103

	if (age < e->duration_phase_1) {

   104

		uint start = e->reliability_start;

   105

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

   106

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

   107

		e->reliability = e->reliability_max;

   108

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

   109

		uint max = e->reliability_max;

   110

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

   111

	} else {

   112

		// time's up for this engine

   113

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

   114

		// or disable this engine completely

   115

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

   116

		e->reliability = e->reliability_final;

   117

	}

   118

}

   119

   120

void AddTypeToEngines(void)

   121

{

   122

	Engine *e;

   123

	uint32 counter = 0;

   124

   125

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

   126

   127

		e->type = VEH_Train;

   128

		if 	(counter >= ROAD_ENGINES_INDEX) {

   129

			e->type = VEH_Road;

   130

			if 	(counter >= SHIP_ENGINES_INDEX) {

   131

				e->type = VEH_Ship;

   132

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   133

					e->type = VEH_Aircraft;

   134

					if 	(counter >= TOTAL_NUM_ENGINES) {

   135

						e->type = VEH_Special;

   136

					}

   137

				}

   138

			}

   139

		}

   140

	}

   141

}

   142

   143

void StartupEngines(void)

   144

{

   145

	Engine *e;

   146

	const EngineInfo *ei;

   147

	uint32 r, counter = 0;

   148

   149

	SetupEngineNames();

   150

   151

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

   152

   153

		e->age = 0;

   154

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

   155

		e->flags = 0;

   156

		e->player_avail = 0;

   157

   158

		r = Random();

   159

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

   160

		if (e->intro_date <= _date) {

   161

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

   162

			e->player_avail = (byte)-1;

   163

			e->flags |= ENGINE_AVAILABLE;

   164

		}

   165

   166

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

   167

		r = Random();

   168

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

   169

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

   170

   171

		r = Random();

   172

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

   173

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

   174

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

   175

   176

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

   177

   178

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

   179

		if (ei->unk2 & 0x80) {

   180

			e->age = 0xFFFF;

   181

		} else {

   182

			CalcEngineReliability(e);

   183

		}

   184

   185

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

   186

   187

		// prevent certain engines from ever appearing.

   188

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

   189

			e->flags |= ENGINE_AVAILABLE;

   190

			e->player_avail = 0;

   191

		}

   192

   193

		/* This sets up type for the engine

   194

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

   195

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

   196

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

   197

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

   198

	}

   199

   200

	AdjustAvailAircraft();

   201

}

   202

   203

uint32 _engine_refit_masks[256];

   204

   205

   206

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

   207

   208

struct WagonOverride {

   209

	byte *train_id;

   210

	int trains;

   211

	struct SpriteGroup group;

   212

};

   213

   214

static struct WagonOverrides {

   215

	int overrides_count;

   216

	struct WagonOverride *overrides;

   217

} _engine_wagon_overrides[256];

   218

   219

void SetWagonOverrideSprites(byte engine, struct SpriteGroup *group,

   220

                             byte *train_id, int trains)

   221

{

   222

	struct WagonOverrides *wos;

   223

	struct WagonOverride *wo;

   224

   225

	wos = &_engine_wagon_overrides[engine];

   226

	wos->overrides_count++;

   227

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

   228

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

   229

   230

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

   231

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

   232

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

   233

	 * --pasky */

   234

	wo->group = *group;

   235

	wo->trains = trains;

   236

	wo->train_id = malloc(trains);

   237

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

   238

}

   239

   240

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

   241

{

   242

	struct WagonOverrides *wos = &_engine_wagon_overrides[engine];

   243

	int i;

   244

   245

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

   246

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

   247

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

   248

	// that. --pasky

   249

   250

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

   251

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

   252

		int j;

   253

   254

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

   255

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

   256

				return &wo->group;

   257

		}

   258

	}

   259

	return NULL;

   260

}

   261

   262

   263

byte _engine_original_sprites[256];

   264

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

   265

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

   266

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

   267

// memory. --pasky)

   268

static struct SpriteGroup _engine_custom_sprites[256][NUM_CID];

   269

   270

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

   271

{

   272

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

   273

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

   274

	 * --pasky */

   275

	_engine_custom_sprites[engine][cargo] = *group;

   276

}

   277

   278

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

   279

                                                    struct Vehicle *veh,

   280

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

   281

   282

static struct RealSpriteGroup *

   283

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

   284

			  resolve_callback callback)

   285

{

   286

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

   287

	switch (spritegroup->type) {

   288

		case SGT_REAL:

   289

			return &spritegroup->g.real;

   290

   291

		case SGT_DETERMINISTIC: {

   292

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

   293

			struct SpriteGroup *target;

   294

			int value = -1;

   295

   296

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

   297

   298

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

   299

				/* General property */

   300

				value = GetDeterministicSpriteValue(dsg->variable);

   301

   302

			} else {

   303

				/* Vehicle-specific property. */

   304

   305

				if (veh == NULL) {

   306

					/* We are in a purchase list of something,

   307

					 * and we are checking for something undefined.

   308

					 * That means we should get the first target

   309

					 * (NOT the default one). */

   310

					if (dsg->num_ranges > 0) {

   311

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

   312

					} else {

   313

						target = dsg->default_group;

   314

					}

   315

					return callback(target, NULL, callback);

   316

				}

   317

   318

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   319

					/* First engine in the vehicle chain */

   320

					if (veh->type == VEH_Train)

   321

						veh = GetFirstVehicleInChain(veh);

   322

				}

   323

   324

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

   325

					if (veh->type == VEH_Train) {

   326

						Vehicle *u = GetFirstVehicleInChain(veh);

   327

						byte chain_before = 0, chain_after = 0;

   328

   329

						while (u != veh) {

   330

							u = u->next;

   331

							chain_before++;

   332

						}

   333

						while (u->next != NULL) {

   334

							u = u->next;

   335

							chain_after++;

   336

						};

   337

   338

						value = chain_before << 16 | chain_after << 8

   339

						        | (chain_before + chain_after + 1);

   340

					} else {

   341

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

   342

					}

   343

   344

				} else {

   345

					// TTDPatch runs on little-endian arch;

   346

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

   347

					switch (dsg->variable - 0x80) {

   348

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

   349

						veh_prop(0x00, veh->type);

   350

						veh_prop(0x01, veh->subtype);

   351

						veh_prop(0x04, veh->index);

   352

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

   353

						/* XXX? Is THIS right? */

   354

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

   355

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

   356

						veh_prop(0x0C, veh->num_orders);

   357

						veh_prop(0x0D, veh->cur_order_index);

   358

						veh_prop(0x10, veh->load_unload_time_rem);

   359

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

   360

						veh_prop(0x12, veh->date_of_last_service);

   361

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

   362

						veh_prop(0x14, veh->service_interval);

   363

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

   364

						veh_prop(0x16, veh->last_station_visited);

   365

						veh_prop(0x17, veh->tick_counter);

   366

						veh_prop(0x18, veh->max_speed);

   367

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

   368

						veh_prop(0x1F, veh->direction);

   369

						veh_prop(0x28, veh->cur_image);

   370

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

   371

						veh_prop(0x32, veh->vehstatus);

   372

						veh_prop(0x33, veh->vehstatus);

   373

						veh_prop(0x34, veh->cur_speed);

   374

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

   375

						veh_prop(0x36, veh->subspeed);

   376

						veh_prop(0x37, veh->acceleration);

   377

						veh_prop(0x39, veh->cargo_type);

   378

						veh_prop(0x3A, veh->cargo_cap);

   379

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

   380

						veh_prop(0x3C, veh->cargo_count);

   381

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

   382

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

   383

						veh_prop(0x3F, veh->cargo_days);

   384

						veh_prop(0x40, veh->age);

   385

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

   386

						veh_prop(0x42, veh->max_age);

   387

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

   388

						veh_prop(0x44, veh->build_year);

   389

						veh_prop(0x45, veh->unitnumber);

   390

						veh_prop(0x46, veh->engine_type);

   391

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

   392

						veh_prop(0x48, veh->spritenum);

   393

						veh_prop(0x49, veh->day_counter);

   394

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   395

						veh_prop(0x4B, veh->breakdown_ctr);

   396

						veh_prop(0x4C, veh->breakdown_delay);

   397

						veh_prop(0x4D, veh->breakdown_chance);

   398

						veh_prop(0x4E, veh->reliability);

   399

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

   400

						veh_prop(0x50, veh->reliability_spd_dec);

   401

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

   402

						veh_prop(0x52, veh->profit_this_year);

   403

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

   404

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

   405

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

   406

						veh_prop(0x56, veh->profit_last_year);

   407

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

   408

						veh_prop(0x58, veh->profit_last_year);

   409

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

   410

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

   411

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

   412

						veh_prop(0x5C, veh->value);

   413

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

   414

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

   415

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

   416

						veh_prop(0x60, veh->string_id);

   417

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

   418

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

   419

						 * aircraft: >=13h when in flight

   420

						 * train, ship: 80h=in depot

   421

						 * rv: 0feh=in depot */

   422

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

   423

   424

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

   425

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

   426

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

   427

   428

#undef veh_prop

   429

					}

   430

				}

   431

			}

   432

   433

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

   434

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

   435

			return callback(target, veh, callback);

   436

		}

   437

   438

		case SGT_RANDOMIZED: {

   439

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

   440

   441

			if (veh == NULL) {

   442

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

   443

				assert(rsg->num_groups > 0);

   444

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

   445

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

   446

			}

   447

   448

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   449

				/* First engine in the vehicle chain */

   450

				if (veh->type == VEH_Train)

   451

					veh = GetFirstVehicleInChain(veh);

   452

			}

   453

   454

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

   455

		}

   456

   457

		default:

   458

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

   459

			return NULL;

   460

	}

   461

}

   462

   463

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

   464

{

   465

	struct SpriteGroup *group;

   466

	uint16 overriding_engine = -1;

   467

	byte cargo = CID_PURCHASE;

   468

   469

	if (v != NULL) {

   470

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

   471

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

   472

	}

   473

   474

	group = &_engine_custom_sprites[engine][cargo];

   475

   476

	if (overriding_engine != 0xffff) {

   477

		struct SpriteGroup *overset;

   478

   479

		overset = GetWagonOverrideSpriteSet(engine, overriding_engine);

   480

		if (overset) group = overset;

   481

	}

   482

   483

	return group;

   484

}

   485

   486

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

   487

{

   488

	struct SpriteGroup *group;

   489

	struct RealSpriteGroup *rsg;

   490

	byte cargo = CID_PURCHASE;

   491

	byte loaded = 0;

   492

	bool in_motion = 0;

   493

	int totalsets, spriteset;

   494

	int r;

   495

   496

	if (v != NULL) {

   497

		int capacity = v->cargo_cap;

   498

   499

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

   500

		if (capacity == 0) capacity = 1;

   501

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

   502

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

   503

	}

   504