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

	StringID *name;

    77

    78

	for (name = _engine_name_strings; name != endof(_engine_name_strings); name++)

    79

		*name = 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[TOTAL_NUM_ENGINES];

   204

   205

   206

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

   207

   208

typedef struct WagonOverride {

   209

	byte *train_id;

   210

	int trains;

   211

	SpriteGroup group;

   212

} WagonOverride;

   213

   214

typedef struct WagonOverrides {

   215

	int overrides_count;

   216

	WagonOverride *overrides;

   217

} WagonOverrides;

   218

   219

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   220

   221

void SetWagonOverrideSprites(byte engine, SpriteGroup *group, byte *train_id,

   222

	int trains)

   223

{

   224

	WagonOverrides *wos;

   225

	WagonOverride *wo;

   226

   227

	wos = &_engine_wagon_overrides[engine];

   228

	wos->overrides_count++;

   229

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

   230

		wos->overrides_count * sizeof(*wos->overrides));

   231

   232

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

   233

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

   234

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

   235

	 * --pasky */

   236

	wo->group = *group;

   237

	wo->trains = trains;

   238

	wo->train_id = malloc(trains);

   239

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

   240

}

   241

   242

static SpriteGroup *GetWagonOverrideSpriteSet(byte engine, byte overriding_engine)

   243

{

   244

	WagonOverrides *wos = &_engine_wagon_overrides[engine];

   245

	int i;

   246

   247

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

   248

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

   249

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

   250

	// that. --pasky

   251

   252

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

   253

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

   254

		int j;

   255

   256

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

   257

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

   258

				return &wo->group;

   259

		}

   260

	}

   261

	return NULL;

   262

}

   263

   264

   265

byte _engine_original_sprites[TOTAL_NUM_ENGINES];

   266

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

   267

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

   268

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

   269

// memory. --pasky)

   270

static SpriteGroup _engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_CID];

   271

   272

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

   273

{

   274

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

   275

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

   276

	 * --pasky */

   277

	_engine_custom_sprites[engine][cargo] = *group;

   278

}

   279

   280

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

   281

	const Vehicle *veh, void *callback); /* XXX data pointer used as function pointer */

   282

   283

static RealSpriteGroup* ResolveVehicleSpriteGroup(SpriteGroup *spritegroup,

   284

	const Vehicle *veh, 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

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

   293

			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

			} else {

   302

				/* Vehicle-specific property. */

   303

   304

				if (veh == NULL) {

   305

					/* We are in a purchase list of something,

   306

					 * and we are checking for something undefined.

   307

					 * That means we should get the first target

   308

					 * (NOT the default one). */

   309

					if (dsg->num_ranges > 0) {

   310

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

   311

					} else {

   312

						target = dsg->default_group;

   313

					}

   314

					return callback(target, NULL, callback);

   315

				}

   316

   317

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   318

					/* First engine in the vehicle chain */

   319

					if (veh->type == VEH_Train)

   320

						veh = GetFirstVehicleInChain(veh);

   321

				}

   322

   323

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

   324

					if (veh->type == VEH_Train) {

   325

						Vehicle *u = GetFirstVehicleInChain(veh);

   326

						byte chain_before = 0, chain_after = 0;

   327

   328

						while (u != veh) {

   329

							u = u->next;

   330

							chain_before++;

   331

						}

   332

						while (u->next != NULL) {

   333

							u = u->next;

   334

							chain_after++;

   335

						};

   336

   337

						value = chain_before | chain_after << 8

   338

						        | (chain_before + chain_after) << 16;

   339

					} else {

   340

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

   341

					}

   342

   343

				} else {

   344

					// TTDPatch runs on little-endian arch;

   345

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

   346

					switch (dsg->variable - 0x80) {

   347

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

   348

						veh_prop(0x00, veh->type);

   349

						veh_prop(0x01, veh->subtype);

   350

						veh_prop(0x04, veh->index);

   351

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

   352

						/* XXX? Is THIS right? */

   353

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

   354

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

   355

						veh_prop(0x0C, veh->num_orders);

   356

						veh_prop(0x0D, veh->cur_order_index);

   357

						veh_prop(0x10, veh->load_unload_time_rem);

   358

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

   359

						veh_prop(0x12, veh->date_of_last_service);

   360

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

   361

						veh_prop(0x14, veh->service_interval);

   362

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

   363

						veh_prop(0x16, veh->last_station_visited);

   364

						veh_prop(0x17, veh->tick_counter);

   365

						veh_prop(0x18, veh->max_speed);

   366

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

   367

						veh_prop(0x1F, veh->direction);

   368

						veh_prop(0x28, veh->cur_image);

   369

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

   370

						veh_prop(0x32, veh->vehstatus);

   371

						veh_prop(0x33, veh->vehstatus);

   372

						veh_prop(0x34, veh->cur_speed);

   373

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

   374

						veh_prop(0x36, veh->subspeed);

   375

						veh_prop(0x37, veh->acceleration);

   376

						veh_prop(0x39, veh->cargo_type);

   377

						veh_prop(0x3A, veh->cargo_cap);

   378

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

   379

						veh_prop(0x3C, veh->cargo_count);

   380

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

   381

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

   382

						veh_prop(0x3F, veh->cargo_days);

   383

						veh_prop(0x40, veh->age);

   384

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

   385

						veh_prop(0x42, veh->max_age);

   386

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

   387

						veh_prop(0x44, veh->build_year);

   388

						veh_prop(0x45, veh->unitnumber);

   389

						veh_prop(0x46, veh->engine_type);

   390

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

   391

						veh_prop(0x48, veh->spritenum);

   392

						veh_prop(0x49, veh->day_counter);

   393

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   394

						veh_prop(0x4B, veh->breakdown_ctr);

   395

						veh_prop(0x4C, veh->breakdown_delay);

   396

						veh_prop(0x4D, veh->breakdown_chance);

   397

						veh_prop(0x4E, veh->reliability);

   398

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

   399

						veh_prop(0x50, veh->reliability_spd_dec);

   400

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

   401

						veh_prop(0x52, veh->profit_this_year);

   402

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

   403

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

   404

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

   405

						veh_prop(0x56, veh->profit_last_year);

   406

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

   407

						veh_prop(0x58, veh->profit_last_year);

   408

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

   409

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

   410

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

   411

						veh_prop(0x5C, veh->value);

   412

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

   413

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

   414

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

   415

						veh_prop(0x60, veh->string_id);

   416

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

   417

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

   418

						 * aircraft: >=13h when in flight

   419

						 * train, ship: 80h=in depot

   420

						 * rv: 0feh=in depot */

   421

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

   422

   423

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

   424

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

   425

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

   426

   427

#undef veh_prop

   428

					}

   429

				}

   430

			}

   431

   432

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

   433

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

   434

			return callback(target, veh, callback);

   435

		}

   436

   437

		case SGT_RANDOMIZED: {

   438

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

   439

   440

			if (veh == NULL) {

   441

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

   442

				assert(rsg->num_groups > 0);

   443

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

   444

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

   445

			}

   446

   447

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   448

				/* First engine in the vehicle chain */

   449

				if (veh->type == VEH_Train)

   450

					veh = GetFirstVehicleInChain(veh);

   451

			}

   452

   453

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

   454

		}

   455

   456

		default:

   457

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

   458

			return NULL;

   459

	}

   460

}

   461

   462

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

   463

{

   464

	SpriteGroup *group;

   465

	byte cargo = CID_PURCHASE;

   466

   467

	if (v != NULL) {

   468

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

   469

	}

   470

   471

	group = &_engine_custom_sprites[engine][cargo];

   472

   475

   476

		if (overset != NULL) group = overset;

   477

	}

   478

   479

	return group;

   480

}

   481

   482

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

   483

{

   484

	SpriteGroup *group;

   485

	RealSpriteGroup *rsg;

   486

	byte cargo = CID_PURCHASE;

   487

	byte loaded = 0;

   488

	bool in_motion = 0;

   489

	int totalsets, spriteset;

   490

	int r;

   491

   492

	if (v != NULL) {

   493

		int capacity = v->cargo_cap;

   494

   495

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

   496

		if (capacity == 0) capacity = 1;

   497

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

   498

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

   499

	}

   500

   501

	group = GetVehicleSpriteGroup(engine, v);