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

    39

};

    40

    49

};

    50

    67

};

    91

    92

void ShowEnginePreviewWindow(int engine);

    93

    94

void DeleteCustomEngineNames(void)

    95

{

    96

	uint i;

    97

	StringID old;

    98

    99

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

   100

		old = _engine_name_strings[i];

   101

		_engine_name_strings[i] = i + STR_8000_KIRBY_PAUL_TANK_STEAM;

   102

		DeleteName(old);

   103

	}

   104

   105

	_vehicle_design_names &= ~1;

   106

}

   107

   108

void LoadCustomEngineNames(void)

   109

{

   110

	// XXX: not done */

   111

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

   112

}

   113

   114

static void SetupEngineNames(void)

   115

{

   116

	StringID *name;

   117

   118

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

   119

		*name = STR_SV_EMPTY;

   120

   121

	DeleteCustomEngineNames();

   122

	LoadCustomEngineNames();

   123

}

   124

   125

static void AdjustAvailAircraft(void)

   126

{

   127

	uint16 date = _date;

   128

	byte avail = 0;

   129

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

   130

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

   131

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

   132

   133

	if (avail != _avail_aircraft) {

   134

		_avail_aircraft = avail;

   135

		InvalidateWindow(WC_BUILD_STATION, 0);

   136

	}

   137

}

   138

   139

static void CalcEngineReliability(Engine *e)

   140

{

   141

	uint age = e->age;

   142

   143

	if (age < e->duration_phase_1) {

   144

		uint start = e->reliability_start;

   145

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

   146

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

   147

		e->reliability = e->reliability_max;

   148

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

   149

		uint max = e->reliability_max;

   150

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

   151

	} else {

   152

		// time's up for this engine

   153

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

   154

		// or disable this engine completely

   155

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

   156

		e->reliability = e->reliability_final;

   157

	}

   158

}

   159

   160

void AddTypeToEngines(void)

   161

{

   162

	Engine *e;

   163

	uint32 counter = 0;

   164

   165

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

   166

   167

		e->type = VEH_Train;

   168

		if 	(counter >= ROAD_ENGINES_INDEX) {

   169

			e->type = VEH_Road;

   170

			if 	(counter >= SHIP_ENGINES_INDEX) {

   171

				e->type = VEH_Ship;

   172

				if 	(counter >= AIRCRAFT_ENGINES_INDEX) {

   173

					e->type = VEH_Aircraft;

   174

					if 	(counter >= TOTAL_NUM_ENGINES) {

   175

						e->type = VEH_Special;

   176

					}

   177

				}

   178

			}

   179

		}

   180

	}

   181

}

   182

   183

void StartupEngines(void)

   184

{

   185

	Engine *e;

   186

	const EngineInfo *ei;

   187

	uint32 r, counter = 0;

   188

   189

	SetupEngineNames();

   190

   191

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

   192

   193

		e->age = 0;

   194

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

   195

		e->flags = 0;

   196

		e->player_avail = 0;

   197

   198

		r = Random();

   199

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

   200

		if (e->intro_date <= _date) {

   201

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

   202

			e->player_avail = (byte)-1;

   203

			e->flags |= ENGINE_AVAILABLE;

   204

		}

   205

   206

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

   207

		r = Random();

   208

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

   209

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

   210

   211

		r = Random();

   212

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

   213

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

   214

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

   215

   216

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

   217

   218

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

   219

		if (ei->unk2 & 0x80) {

   220

			e->age = 0xFFFF;

   221

		} else {

   222

			CalcEngineReliability(e);

   223

		}

   224

   225

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

   226

   227

		// prevent certain engines from ever appearing.

   228

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

   229

			e->flags |= ENGINE_AVAILABLE;

   230

			e->player_avail = 0;

   231

		}

   232

   233

		/* This sets up type for the engine

   234

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

   235

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

   236

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

   237

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

   238

	}

   239

   240

	AdjustAvailAircraft();

   241

}

   242

   243

uint32 _engine_refit_masks[TOTAL_NUM_ENGINES];

   244

   245

   246

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

   247

   248

typedef struct WagonOverride {

   249

	byte *train_id;

   250

	int trains;

   251

	SpriteGroup group;

   252

} WagonOverride;

   253

   254

typedef struct WagonOverrides {

   255

	int overrides_count;

   256

	WagonOverride *overrides;

   257

} WagonOverrides;

   258

   259

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

   260

   261

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

   262

	int trains)

   263

{

   264

	WagonOverrides *wos;

   265

	WagonOverride *wo;

   266

   267

	wos = &_engine_wagon_overrides[engine];

   268

	wos->overrides_count++;

   269

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

   270

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

   271

   272

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

   273

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

   274

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

   275

	 * --pasky */

   276

	wo->group = *group;

   277

	wo->trains = trains;

   278

	wo->train_id = malloc(trains);

   279

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

   280

}

   281

   282

static SpriteGroup *GetWagonOverrideSpriteSet(byte engine, byte overriding_engine)

   283

{

   284

	WagonOverrides *wos = &_engine_wagon_overrides[engine];

   285

	int i;

   286

   287

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

   288

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

   289

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

   290

	// that. --pasky

   291

   292

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

   293

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

   294

		int j;

   295

   296

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

   297

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

   298

				return &wo->group;

   299

		}

   300

	}

   301

	return NULL;

   302

}

   303

   304

   305

byte _engine_original_sprites[TOTAL_NUM_ENGINES];

   306

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

   307

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

   308

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

   309

// memory. --pasky)

   311

   312

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

   313

{

   314

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

   315

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

   316

	 * --pasky */

   317

	_engine_custom_sprites[engine][cargo] = *group;

   318

}

   319

   320

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

   321

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

   322

   323

static RealSpriteGroup* ResolveVehicleSpriteGroup(SpriteGroup *spritegroup,

   324

	const Vehicle *veh, resolve_callback callback)

   325

{

   326

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

   327

	switch (spritegroup->type) {

   328

		case SGT_REAL:

   329

			return &spritegroup->g.real;

   330

   331

		case SGT_DETERMINISTIC: {

   332

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

   333

			SpriteGroup *target;

   334

			int value = -1;

   335

   336

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

   337

   338

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

   339

				/* General property */

   340

				value = GetDeterministicSpriteValue(dsg->variable);

   341

			} else {

   342

				/* Vehicle-specific property. */

   343

   344

				if (veh == NULL) {

   345

					/* We are in a purchase list of something,

   346

					 * and we are checking for something undefined.

   347

					 * That means we should get the first target

   348

					 * (NOT the default one). */

   349

					if (dsg->num_ranges > 0) {

   350

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

   351

					} else {

   352

						target = dsg->default_group;

   353

					}

   354

					return callback(target, NULL, callback);

   355

				}

   356

   357

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   358

					/* First engine in the vehicle chain */

   359

					if (veh->type == VEH_Train)

   360

						veh = GetFirstVehicleInChain(veh);

   361

				}

   362

   363

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

   364

					if (veh->type == VEH_Train) {

   365

						Vehicle *u = GetFirstVehicleInChain(veh);

   366

						byte chain_before = 0, chain_after = 0;

   367

   368

						while (u != veh) {

   369

							u = u->next;

   370

							chain_before++;

   371

						}

   372

						while (u->next != NULL) {

   373

							u = u->next;

   374

							chain_after++;

   375

						};

   376

   377

						value = chain_before | chain_after << 8

   378

						        | (chain_before + chain_after) << 16;

   379

					} else {

   380

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

   381

					}

   382

   383

				} else {

   384

					// TTDPatch runs on little-endian arch;

   385

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

   386

					switch (dsg->variable - 0x80) {

   387

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

   388

						veh_prop(0x00, veh->type);

   389

						veh_prop(0x01, veh->subtype);

   390

						veh_prop(0x04, veh->index);

   391

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

   392

						/* XXX? Is THIS right? */

   393

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

   394

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

   395

						veh_prop(0x0C, veh->num_orders);

   396

						veh_prop(0x0D, veh->cur_order_index);

   397

						veh_prop(0x10, veh->load_unload_time_rem);

   398

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

   399

						veh_prop(0x12, veh->date_of_last_service);

   400

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

   401

						veh_prop(0x14, veh->service_interval);

   402

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

   403

						veh_prop(0x16, veh->last_station_visited);

   404

						veh_prop(0x17, veh->tick_counter);

   405

						veh_prop(0x18, veh->max_speed);

   406

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

   407

						veh_prop(0x1F, veh->direction);

   408

						veh_prop(0x28, veh->cur_image);

   409

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

   410

						veh_prop(0x32, veh->vehstatus);

   411

						veh_prop(0x33, veh->vehstatus);

   412

						veh_prop(0x34, veh->cur_speed);

   413

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

   414

						veh_prop(0x36, veh->subspeed);

   415

						veh_prop(0x37, veh->acceleration);

   416

						veh_prop(0x39, veh->cargo_type);

   417

						veh_prop(0x3A, veh->cargo_cap);

   418

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

   419

						veh_prop(0x3C, veh->cargo_count);

   420

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

   421

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

   422

						veh_prop(0x3F, veh->cargo_days);

   423

						veh_prop(0x40, veh->age);

   424

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

   425

						veh_prop(0x42, veh->max_age);

   426

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

   427

						veh_prop(0x44, veh->build_year);

   428

						veh_prop(0x45, veh->unitnumber);

   429

						veh_prop(0x46, veh->engine_type);

   430

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

   431

						veh_prop(0x48, veh->spritenum);

   432

						veh_prop(0x49, veh->day_counter);

   433

						veh_prop(0x4A, veh->breakdowns_since_last_service);

   434

						veh_prop(0x4B, veh->breakdown_ctr);

   435

						veh_prop(0x4C, veh->breakdown_delay);

   436

						veh_prop(0x4D, veh->breakdown_chance);

   437

						veh_prop(0x4E, veh->reliability);

   438

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

   439

						veh_prop(0x50, veh->reliability_spd_dec);

   440

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

   441

						veh_prop(0x52, veh->profit_this_year);

   442

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

   443

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

   444

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

   445

						veh_prop(0x56, veh->profit_last_year);

   446

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

   447

						veh_prop(0x58, veh->profit_last_year);

   448

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

   449

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

   450

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

   451

						veh_prop(0x5C, veh->value);

   452

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

   453

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

   454

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

   455

						veh_prop(0x60, veh->string_id);

   456

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

   457

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

   458

						 * aircraft: >=13h when in flight

   459

						 * train, ship: 80h=in depot

   460

						 * rv: 0feh=in depot */

   461

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

   462

   463

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

   464

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

   465

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

   466

   467

#undef veh_prop

   468

					}

   469

				}

   470

			}

   471

   472

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

   473

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

   474

			return callback(target, veh, callback);

   475

		}

   476

   477

		case SGT_RANDOMIZED: {

   478

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

   479

   480

			if (veh == NULL) {

   481

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

   482

				assert(rsg->num_groups > 0);

   483

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

   484

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

   485

			}

   486

   487

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

   488

				/* First engine in the vehicle chain */

   489

				if (veh->type == VEH_Train)

   490

					veh = GetFirstVehicleInChain(veh);

   491

			}

   492

   493

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

   494

		}

   495

   496

		default:

   497

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

   498

			return NULL;

   499

	}

   500

}