1

/* $Id$ */

     2

     3

#include "stdafx.h"

     4

#include "openttd.h"

     5

#include "variables.h"

     6

#include "debug.h"

     7

#include "functions.h"

     8

#include "engine.h"

     9

#include "train.h"

    10

#include "player.h"

    11

#include "station.h"

    12

#include "airport.h"

    13

#include "newgrf_callbacks.h"

    14

#include "newgrf_engine.h"

    15

#include "newgrf_station.h"

    16

#include "newgrf_spritegroup.h"

    17

    18

int _traininfo_vehicle_pitch = 0;

    19

    20

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

    21

    22

typedef struct WagonOverride {

    23

	byte *train_id;

    24

	int trains;

    25

	const SpriteGroup *group;

    26

} WagonOverride;

    27

    28

typedef struct WagonOverrides {

    29

	int overrides_count;

    30

	WagonOverride *overrides;

    31

} WagonOverrides;

    32

    33

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    34

    35

void SetWagonOverrideSprites(EngineID engine, const SpriteGroup *group, byte *train_id, int trains)

    36

{

    37

	WagonOverrides *wos;

    38

	WagonOverride *wo;

    39

    40

	wos = &_engine_wagon_overrides[engine];

    41

	wos->overrides_count++;

    42

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

    43

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

    44

    45

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

    46

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

    47

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

    48

	 * --pasky */

    49

	wo->group = group;

    50

	wo->trains = trains;

    51

	wo->train_id = malloc(trains);

    52

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

    53

}

    54

    55

static const SpriteGroup *GetWagonOverrideSpriteSet(EngineID engine, byte overriding_engine)

    56

{

    57

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    58

	int i;

    59

    60

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

    61

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

    62

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

    63

	// that. --pasky

    64

    65

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

    66

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

    67

		int j;

    68

    69

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

    70

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

    71

				return wo->group;

    72

		}

    73

	}

    74

	return NULL;

    75

}

    76

    77

/**

    78

 * Unload all wagon override sprite groups.

    79

 */

    80

void UnloadWagonOverrides(void)

    81

{

    82

	WagonOverrides *wos;

    83

	WagonOverride *wo;

    84

	EngineID engine;

    85

	int i;

    86

    87

	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {

    88

		wos = &_engine_wagon_overrides[engine];

    89

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

    90

			wo = &wos->overrides[i];

    91

			wo->group = NULL;

    92

			free(wo->train_id);

    93

		}

    94

		free(wos->overrides);

    95

		wos->overrides_count = 0;

    96

		wos->overrides = NULL;

    97

	}

    98

}

    99

   100

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

   101

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

   102

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

   103

// memory. --pasky)

   104

static const SpriteGroup *engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

   105

static uint32 _engine_grf[TOTAL_NUM_ENGINES];

   106

   107

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

   108

{

   109

	assert(engine < TOTAL_NUM_ENGINES);

   110

	if (engine_custom_sprites[engine][cargo] != NULL) {

   111

		DEBUG(grf, 6)("SetCustomEngineSprites: engine `%d' cargo `%d' already has group -- replacing.", engine, cargo);

   112

	}

   113

	engine_custom_sprites[engine][cargo] = group;

   114

}

   115

   116

/**

   117

 * Unload all engine sprite groups.

   118

 */

   119

void UnloadCustomEngineSprites(void)

   120

{

   121

	EngineID engine;

   122

	CargoID cargo;

   123

   124

	for (engine = 0; engine < TOTAL_NUM_ENGINES; engine++) {

   125

		for (cargo = 0; cargo < NUM_GLOBAL_CID; cargo++) {

   126

			engine_custom_sprites[engine][cargo] = NULL;

   127

		}

   128

		_engine_grf[engine] = 0;

   129

	}

   130

}

   131

   132

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   133

   134

/** Load a rotor override sprite group for an aircraft */

   135

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   136

{

   137

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   138

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   139

   140

	if (heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] != NULL) {

   141

		DEBUG(grf, 6)("SetRotorOverrideSprites: engine `%d' already has group -- replacing.", engine);

   142

	}

   143

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   144

}

   145

   146

/** Unload all rotor override sprite groups */

   147

void UnloadRotorOverrideSprites(void)

   148

{

   149

	EngineID engine;

   150

   151

	/* Starting at AIRCRAFT_ENGINES_INDEX may seem pointless, but it means

   152

	 * the context of EngineID is correct */

   153

	for (engine = AIRCRAFT_ENGINES_INDEX; engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES; engine++) {

   154

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   155

	}

   156

}

   157

   158

void SetEngineGRF(EngineID engine, uint32 grfid)

   159

{

   160

	assert(engine < TOTAL_NUM_ENGINES);

   161

	_engine_grf[engine] = grfid;

   162

}

   163

   164

uint32 GetEngineGRFID(EngineID engine)

   165

{

   166

	assert(engine < TOTAL_NUM_ENGINES);

   167

	return _engine_grf[engine];

   168

}

   169

   170

   171

static int MapOldSubType(const Vehicle *v)

   172

{

   173

	if (v->type != VEH_Train) return v->subtype;

   174

	if (IsTrainEngine(v)) return 0;

   175

	if (IsFreeWagon(v)) return 4;

   176

	return 2;

   177

}

   178

   179

   180

/* TTDP style aircraft movement states for GRF Action 2 Var 0xE2 */

   181

enum {

   182

	AMS_TTDP_HANGER,

   183

	AMS_TTDP_TO_HANGER,

   184

	AMS_TTDP_TO_PAD1,

   185

	AMS_TTDP_TO_PAD2,

   186

	AMS_TTDP_TO_PAD3,

   187

	AMS_TTDP_TO_ENTRY_2_AND_3,

   188

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   189

	AMS_TTDP_TO_JUNCTION,

   190

	AMS_TTDP_LEAVE_RUNWAY,

   191

	AMS_TTDP_TO_INWAY,

   192

	AMS_TTDP_TO_RUNWAY,

   193

	AMS_TTDP_TO_OUTWAY,

   194

	AMS_TTDP_WAITING,

   195

	AMS_TTDP_TAKEOFF,

   196

	AMS_TTDP_TO_TAKEOFF,

   197

	AMS_TTDP_CLIMBING,

   198

	AMS_TTDP_FLIGHT_APPROACH,

   199

	AMS_TTDP_UNUSED_0x11,

   200

	AMS_TTDP_FLIGHT_TO_TOWER,

   201

	AMS_TTDP_UNUSED_0x13,

   202

	AMS_TTDP_FLIGHT_FINAL,

   203

	AMS_TTDP_FLIGHT_DESCENT,

   204

	AMS_TTDP_BRAKING,

   205

	AMS_TTDP_HELI_TAKEOFF_AIRPOPT,

   206

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPOPT,

   207

	AMS_TTDP_HELI_LAND_AIRPOPT,

   208

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   209

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   210

	AMS_TTDP_HELI_LAND_HELIPORT,

   211

};

   212

   213

   214

/**

   215

 * Map OTTD aircraft movement states to TTDPatch style movement states

   216

 * (VarAction 2 Variable 0xE2)

   217

 */

   218

static byte MapAircraftMovementState(const Vehicle *v)

   219

{

   220

	const Station *st = GetStation(v->u.air.targetairport);

   221

	byte amdflag = GetAirportMovingData(st->airport_type, v->u.air.pos)->flag;

   222

   223

	switch (v->u.air.state) {

   224

		case HANGAR:

   225

			/* The international airport is a special case as helicopters can land in

   226

			 * front of the hanger. Helicopters also change their air.state to

   227

			 * AMED_HELI_LOWER some time before actually descending. */

   228

   229

			/* This condition only occurs for helicopters, during descent,

   230

			 * to a landing by the hanger of an international airport. */

   231

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPOPT;

   232

   233

			/* This condition only occurs for helicopters, before starting descent,

   234

			 * to a landing by the hanger of an international airport. */

   235

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   236

   237

			// The final two conditions apply to helicopters or aircraft.

   238

			/* Has reached hanger? */

   239

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGER;

   240

   241

			// Still moving towards hanger.

   242

			return AMS_TTDP_TO_HANGER;

   243

   244

		case TERM1:

   245

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   246

			return AMS_TTDP_TO_JUNCTION;

   247

   248

		case TERM2:

   249

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   250

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   251

   252

		case TERM3:

   253

		case TERM4:

   254

		case TERM5:

   255

		case TERM6:

   256

			/* TTDPatch only has 3 terminals, so treat these states the same */

   257

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   258

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   259

   260

		case HELIPAD1:

   261

		case HELIPAD2: // Will only occur for helicopters.

   262

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPOPT; // Descending.

   263

			if (amdflag & AMED_SLOWTURN)   return AMS_TTDP_FLIGHT_TO_TOWER;   // Still hasn't started descent.

   264

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   265

   266

		case TAKEOFF: // Moving to takeoff position.

   267

			return AMS_TTDP_TO_OUTWAY;

   268

   269

		case STARTTAKEOFF: // Accelerating down runway.

   270

			return AMS_TTDP_TAKEOFF;

   271

   272

		case ENDTAKEOFF: // Ascent

   273

			return AMS_TTDP_CLIMBING;

   274

   275

		case HELITAKEOFF: // Helicopter is moving to take off position.

   276

			switch (st->airport_type) {

   277

				case AT_SMALL:

   278

				case AT_LARGE:

   279

				case AT_METROPOLITAN:

   280

				case AT_INTERNATIONAL:

   281

					if (amdflag & AMED_HELI_RAISE) return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   282

					return AMS_TTDP_TO_JUNCTION;

   283

   284

				case AT_HELIPORT:

   285

				case AT_OILRIG:

   286

					return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   287

   288

				default:

   289

					return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   290

			}

   291

   292

		case FLYING:

   293

			return AMS_TTDP_FLIGHT_TO_TOWER;

   294

   295

		case LANDING: // Descent

   296

			return AMS_TTDP_FLIGHT_DESCENT;

   297

   298

		case ENDLANDING: // On the runway braking

   299

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   300

			// Landed - moving off runway

   301

			return AMS_TTDP_TO_INWAY;

   302

   303

		case HELILANDING:

   304

		case HELIENDLANDING: // Helicoptor is decending.

   305

			if (amdflag & AMED_HELI_LOWER) {

   306

				switch (st->airport_type) {

   307

					case AT_HELIPORT:

   308

					case AT_OILRIG:

   309

						return AMS_TTDP_HELI_LAND_HELIPORT;

   310

   311

					default:

   312

						return AMS_TTDP_HELI_LAND_AIRPOPT;

   313

				}

   314

			}

   315

			return AMS_TTDP_FLIGHT_TO_TOWER;

   316

   317

		default:

   318

			return AMS_TTDP_HANGER;

   319

	}

   320

}

   321

   322

   323

/* TTDP style aircraft movement action for GRF Action 2 Var 0xE6 */

   324

enum {

   325

	AMA_TTDP_IN_HANGER,

   326

	AMA_TTDP_ON_PAD1,

   327

	AMA_TTDP_ON_PAD2,

   328

	AMA_TTDP_ON_PAD3,

   329

	AMA_TTDP_HANGER_TO_PAD1,

   330

	AMA_TTDP_HANGER_TO_PAD2,

   331

	AMA_TTDP_HANGER_TO_PAD3,

   332

	AMA_TTDP_LANDING_TO_PAD1,

   333

	AMA_TTDP_LANDING_TO_PAD2,

   334

	AMA_TTDP_LANDING_TO_PAD3,

   335

	AMA_TTDP_PAD1_TO_HANGER,

   336

	AMA_TTDP_PAD2_TO_HANGER,

   337

	AMA_TTDP_PAD3_TO_HANGER,

   338

	AMA_TTDP_PAD1_TO_TAKEOFF,

   339

	AMA_TTDP_PAD2_TO_TAKEOFF,

   340

	AMA_TTDP_PAD3_TO_TAKEOFF,

   341

	AMA_TTDP_HANGER_TO_TAKOFF,

   342

	AMA_TTDP_LANDING_TO_HANGER,

   343

	AMA_TTDP_IN_FLIGHT,

   344

};

   345

   346

   347

/**

   348

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   349

 * (VarAction 2 Variable 0xE6)

   350

 * This is not fully supported yet but it's enough for Planeset.

   351

 */

   352

static byte MapAircraftMovementAction(const Vehicle *v)

   353

{

   354

	switch (v->u.air.state) {

   355

		case HANGAR:

   356

			return (v->cur_speed > 0) ? AMA_TTDP_LANDING_TO_HANGER : AMA_TTDP_IN_HANGER;

   357

   358

		case TERM1:

   359

		case HELIPAD1:

   360

			return (v->current_order.type == OT_LOADING) ? AMA_TTDP_ON_PAD1 : AMA_TTDP_LANDING_TO_PAD1;

   361

   362

		case TERM2:

   363

		case HELIPAD2:

   364

			return (v->current_order.type == OT_LOADING) ? AMA_TTDP_ON_PAD2 : AMA_TTDP_LANDING_TO_PAD2;

   365

   366

		case TERM3:

   367

		case TERM4:

   368

		case TERM5:

   369

		case TERM6:

   370

			return (v->current_order.type == OT_LOADING) ? AMA_TTDP_ON_PAD3 : AMA_TTDP_LANDING_TO_PAD3;

   371

   372

		case TAKEOFF:      // Moving to takeoff position

   373

		case STARTTAKEOFF: // Accelerating down runway

   374

		case ENDTAKEOFF:   // Ascent

   375

		case HELITAKEOFF:

   376

			// TODO Need to find which terminal (or hanger) we've come from. How?

   377

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   378

   379

		case FLYING:

   380

			return AMA_TTDP_IN_FLIGHT;

   381

   382

		case LANDING:    // Descent

   383

		case ENDLANDING: // On the runway braking

   384

		case HELILANDING:

   385

		case HELIENDLANDING:

   386

			// TODO Need to check terminal we're landing to. Is it known yet?

   387

			return (v->current_order.type == OT_GOTO_DEPOT) ?

   388

				AMA_TTDP_LANDING_TO_HANGER : AMA_TTDP_LANDING_TO_PAD1;

   389

   390

		default:

   391

			return AMA_TTDP_IN_HANGER;

   392

	}

   393

}

   394

   395

   396

/* TTDP airport types. Used to map our types to TTDPatch's */

   397

enum {

   398

	ATP_TTDP_SMALL,

   399

	ATP_TTDP_LARGE,

   400

	ATP_TTDP_HELIPORT,

   401

	ATP_TTDP_OILRIG,

   402

};

   403

   404

   405

/* Vehicle Resolver Functions */

   406

static inline const Vehicle *GRV(const ResolverObject *object)

   407

{

   408

	return object->scope == VSG_SCOPE_SELF ? object->u.vehicle.self : object->u.vehicle.parent;

   409

}

   410

   411

   412

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   413

{

   414

	return GRV(object) == NULL ? 0 : GRV(object)->random_bits;

   415

}

   416

   417

   418

static uint32 VehicleGetTriggers(const ResolverObject *object)

   419

{

   420

	return GRV(object) == NULL ? 0 : GRV(object)->waiting_triggers;

   421

}

   422

   423

   424

static void VehicleSetTriggers(const ResolverObject *object, int triggers)

   425

{

   426

	/* Evil cast to get around const-ness. This used to be achieved by an

   427

	 * innocent looking function pointer cast... Currently I cannot see a

   428

	 * way of avoiding this without removing consts deep within gui code.

   429

	 */

   430

	Vehicle *v = (Vehicle*)GRV(object);

   431

   432

	/* This function must only be called when processing triggers -- any

   433

	 * other time is an error. */

   434

	assert(object->trigger != 0);

   435

   436

	if (v != NULL) v->waiting_triggers = triggers;

   437

}

   438

   439

   440

static uint32 VehicleGetVariable(const ResolverObject *object, byte variable, byte parameter)

   441

{

   442

	const Vehicle *v = GRV(object);

   443

   444

	if (v == NULL) {

   445

		/* Vehicle does not exist, so we're in a purchase list */

   446

		switch (variable) {

   447

			case 0x43: return _current_player; /* Owner information */

   448

			case 0x46: return 0;               /* Motion counter */

   449

			case 0xC4: return _cur_year;       /* Build year */

   450

			case 0xDA: return INVALID_VEHICLE; /* Next vehicle */

   451

			default:   return -1;

   452

		}

   453

	}

   454

   455

	/* Calculated vehicle parameters */

   456

	switch (variable) {

   457

		case 0x40: /* Get length of consist */

   458

		case 0x41: /* Get length of same consecutive wagons */

   459

			if (v->type != VEH_Train) return 1;

   460

   461

			{

   462

				const Vehicle* u;

   463

				byte chain_before = 0;

   464

				byte chain_after  = 0;

   465

   466

				for (u = GetFirstVehicleInChain(v); u != v; u = u->next) {

   467

					chain_before++;

   468

					if (variable == 0x41 && u->engine_type != v->engine_type) chain_before = 0;

   469

				}

   470

   471

				while (u->next != NULL && (variable == 0x40 || u->next->engine_type == v->engine_type)) {

   472

					chain_after++;

   473

					u = u->next;

   474

				}

   475

   476

				return chain_before | chain_after << 8 | (chain_before + chain_after) << 16;

   477

			}

   478

   479

		case 0x43: /* Player information */

   480

			return v->owner;

   481

   482

		case 0x44: /* Aircraft information */

   483

			if (v->type != VEH_Aircraft) return -1;

   484

   485

			{

   486

				const Vehicle *w = v->next;

   487

				uint16 altitude = v->z_pos - w->z_pos; /* Aircraft height - shadow height */

   488

				byte airporttype;

   489

   490

				switch (GetStation(v->u.air.targetairport)->airport_type) {

   491

					case AT_SMALL: airporttype = ATP_TTDP_SMALL; break;

   492

					case AT_METROPOLITAN:

   493

					case AT_INTERNATIONAL:

   494

					case AT_LARGE: airporttype = ATP_TTDP_LARGE; break;