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

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

    19

    20

typedef struct WagonOverride {

    21

	byte *train_id;

    22

	int trains;

    23

	const SpriteGroup *group;

    24

} WagonOverride;

    25

    26

typedef struct WagonOverrides {

    27

	int overrides_count;

    28

	WagonOverride *overrides;

    29

} WagonOverrides;

    30

    31

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    32

    33

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

    34

{

    35

	WagonOverrides *wos;

    36

	WagonOverride *wo;

    37

    38

	wos = &_engine_wagon_overrides[engine];

    39

	wos->overrides_count++;

    40

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

    41

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

    42

    43

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

    44

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

    45

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

    46

	 * --pasky */

    47

	wo->group = group;

    48

	wo->trains = trains;

    49

	wo->train_id = malloc(trains);

    50

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

    51

}

    52

    53

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

    54

{

    55

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    56

	int i;

    57

    58

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

    59

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

    60

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

    61

	// that. --pasky

    62

    63

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

    64

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

    65

		int j;

    66

    67

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

    68

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

    69

				return wo->group;

    70

		}

    71

	}

    72

	return NULL;

    73

}

    74

    75

/**

    76

 * Unload all wagon override sprite groups.

    77

 */

    78

void UnloadWagonOverrides(void)

    79

{

    80

	WagonOverrides *wos;

    81

	WagonOverride *wo;

    82

	EngineID engine;

    83

	int i;

    84

    85

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

    86

		wos = &_engine_wagon_overrides[engine];

    87

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

    88

			wo = &wos->overrides[i];

    89

			wo->group = NULL;

    90

			free(wo->train_id);

    91

		}

    92

		free(wos->overrides);

    93

		wos->overrides_count = 0;

    94

		wos->overrides = NULL;

    95

	}

    96

}

    97

    98

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

    99

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

   100

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

   101

// memory. --pasky)

   102

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

   103

static uint32 _engine_grf[TOTAL_NUM_ENGINES];

   104

   105

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

   106

{

   107

	assert(engine < TOTAL_NUM_ENGINES);

   108

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

   109

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

   110

	}

   111

	engine_custom_sprites[engine][cargo] = group;

   112

}

   113

   114

/**

   115

 * Unload all engine sprite groups.

   116

 */

   117

void UnloadCustomEngineSprites(void)

   118

{

   119

	EngineID engine;

   120

	CargoID cargo;

   121

   122

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

   123

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

   124

			engine_custom_sprites[engine][cargo] = NULL;

   125

		}

   126

		_engine_grf[engine] = 0;

   127

	}

   128

}

   129

   130

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   131

   132

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

   133

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   134

{

   135

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   136

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   137

   138

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

   139

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

   140

	}

   141

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   142

}

   143

   144

/** Unload all rotor override sprite groups */

   145

void UnloadRotorOverrideSprites(void)

   146

{

   147

	EngineID engine;

   148

   149

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

   150

	 * the context of EngineID is correct */

   151

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

   152

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   153

	}

   154

}

   155

   156

void SetEngineGRF(EngineID engine, uint32 grfid)

   157

{

   158

	assert(engine < TOTAL_NUM_ENGINES);

   159

	_engine_grf[engine] = grfid;

   160

}

   161

   162

uint32 GetEngineGRFID(EngineID engine)

   163

{

   164

	assert(engine < TOTAL_NUM_ENGINES);

   165

	return _engine_grf[engine];

   166

}

   167

   168

   169

static int MapOldSubType(const Vehicle *v)

   170

{

   171

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

   172

	if (IsTrainEngine(v)) return 0;

   173

	if (IsFreeWagon(v)) return 4;

   174

	return 2;

   175

}

   176

   177

   178

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

   179

enum {

   180

	AMS_TTDP_HANGER,

   181

	AMS_TTDP_TO_HANGER,

   182

	AMS_TTDP_TO_PAD1,

   183

	AMS_TTDP_TO_PAD2,

   184

	AMS_TTDP_TO_PAD3,

   185

	AMS_TTDP_TO_ENTRY_2_AND_3,

   186

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   187

	AMS_TTDP_TO_JUNCTION,

   188

	AMS_TTDP_LEAVE_RUNWAY,

   189

	AMS_TTDP_TO_INWAY,

   190

	AMS_TTDP_TO_RUNWAY,

   191

	AMS_TTDP_TO_OUTWAY,

   192

	AMS_TTDP_WAITING,

   193

	AMS_TTDP_TAKEOFF,

   194

	AMS_TTDP_TO_TAKEOFF,

   195

	AMS_TTDP_CLIMBING,

   196

	AMS_TTDP_FLIGHT_APPROACH,

   197

	AMS_TTDP_UNUSED_0x11,

   198

	AMS_TTDP_FLIGHT_TO_TOWER,

   199

	AMS_TTDP_UNUSED_0x13,

   200

	AMS_TTDP_FLIGHT_FINAL,

   201

	AMS_TTDP_FLIGHT_DESCENT,

   202

	AMS_TTDP_BRAKING,

   203

	AMS_TTDP_HELI_TAKEOFF_AIRPOPT,

   204

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPOPT,

   205

	AMS_TTDP_HELI_LAND_AIRPOPT,

   206

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   207

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   208

	AMS_TTDP_HELI_LAND_HELIPORT,

   209

};

   210

   211

   212

/**

   213

 * Map OTTD aircraft movement states to TTDPatch style movement states

   214

 * (VarAction 2 Variable 0xE2)

   215

 */

   216

static byte MapAircraftMovementState(const Vehicle *v)

   217

{

   218

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

   219

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

   220

   221

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

   222

		case HANGAR:

   223

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

   224

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

   225

			 * AMED_HELI_LOWER some time before actually descending. */

   226

   227

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

   228

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

   229

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPOPT;

   230

   231

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

   232

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

   233

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   234

   235

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

   236

			/* Has reached hanger? */

   237

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGER;

   238

   239

			// Still moving towards hanger.

   240

			return AMS_TTDP_TO_HANGER;

   241

   242

		case TERM1:

   243

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   244

			return AMS_TTDP_TO_JUNCTION;

   245

   246

		case TERM2:

   247

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   248

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   249

   250

		case TERM3:

   251

		case TERM4:

   252

		case TERM5:

   253

		case TERM6:

   254

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

   255

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   256

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   257

   258

		case HELIPAD1:

   259

		case HELIPAD2: // Will only occur for helicopters.

   260

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

   261

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

   262

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   263

   264

		case TAKEOFF: // Moving to takeoff position.

   265

			return AMS_TTDP_TO_OUTWAY;

   266

   267

		case STARTTAKEOFF: // Accelerating down runway.

   268

			return AMS_TTDP_TAKEOFF;

   269

   270

		case ENDTAKEOFF: // Ascent

   271

			return AMS_TTDP_CLIMBING;

   272

   273

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

   274

			switch (st->airport_type) {

   275

				case AT_SMALL:

   276

				case AT_LARGE:

   277

				case AT_METROPOLITAN:

   278

				case AT_INTERNATIONAL:

   279

					if (amdflag & AMED_HELI_RAISE) return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   280

					return AMS_TTDP_TO_JUNCTION;

   281

   282

				case AT_HELIPORT:

   283

				case AT_OILRIG:

   284

					return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   285

   286

				default:

   287

					return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   288

			}

   289

   290

		case FLYING:

   291

			return AMS_TTDP_FLIGHT_TO_TOWER;

   292

   293

		case LANDING: // Descent

   294

			return AMS_TTDP_FLIGHT_DESCENT;

   295

   296

		case ENDLANDING: // On the runway braking

   297

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   298

			// Landed - moving off runway

   299

			return AMS_TTDP_TO_INWAY;

   300

   301

		case HELILANDING:

   302

		case HELIENDLANDING: // Helicoptor is decending.

   303

			if (amdflag & AMED_HELI_LOWER) {

   304

				switch (st->airport_type) {

   305

					case AT_HELIPORT:

   306

					case AT_OILRIG:

   307

						return AMS_TTDP_HELI_LAND_HELIPORT;

   308

   309

					default:

   310

						return AMS_TTDP_HELI_LAND_AIRPOPT;

   311

				}

   312

			}

   313

			return AMS_TTDP_FLIGHT_TO_TOWER;

   314

   315

		default:

   316

			return AMS_TTDP_HANGER;

   317

	}

   318

}

   319

   320

   321

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

   322

enum {

   323

	AMA_TTDP_IN_HANGER,

   324

	AMA_TTDP_ON_PAD1,

   325

	AMA_TTDP_ON_PAD2,

   326

	AMA_TTDP_ON_PAD3,

   327

	AMA_TTDP_HANGER_TO_PAD1,

   328

	AMA_TTDP_HANGER_TO_PAD2,

   329

	AMA_TTDP_HANGER_TO_PAD3,

   330

	AMA_TTDP_LANDING_TO_PAD1,

   331

	AMA_TTDP_LANDING_TO_PAD2,

   332

	AMA_TTDP_LANDING_TO_PAD3,

   333

	AMA_TTDP_PAD1_TO_HANGER,

   334

	AMA_TTDP_PAD2_TO_HANGER,

   335

	AMA_TTDP_PAD3_TO_HANGER,

   336

	AMA_TTDP_PAD1_TO_TAKEOFF,

   337

	AMA_TTDP_PAD2_TO_TAKEOFF,

   338

	AMA_TTDP_PAD3_TO_TAKEOFF,

   339

	AMA_TTDP_HANGER_TO_TAKOFF,

   340

	AMA_TTDP_LANDING_TO_HANGER,

   341

	AMA_TTDP_IN_FLIGHT,

   342

};

   343

   344

   345

/**

   346

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   347

 * (VarAction 2 Variable 0xE6)

   348

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

   349

 */

   350

static byte MapAircraftMovementAction(const Vehicle *v)

   351

{

   352

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

   353

		case HANGAR:

   354

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

   355

   356

		case TERM1:

   357

		case HELIPAD1:

   358

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

   359

   360

		case TERM2:

   361

		case HELIPAD2:

   362

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

   363

   364

		case TERM3:

   365

		case TERM4:

   366

		case TERM5:

   367

		case TERM6:

   368

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

   369

   370

		case TAKEOFF:      // Moving to takeoff position

   371

		case STARTTAKEOFF: // Accelerating down runway

   372

		case ENDTAKEOFF:   // Ascent

   373

		case HELITAKEOFF:

   374

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

   375

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   376

   377

		case FLYING:

   378

			return AMA_TTDP_IN_FLIGHT;

   379

   380

		case LANDING:    // Descent

   381

		case ENDLANDING: // On the runway braking

   382

		case HELILANDING:

   383

		case HELIENDLANDING:

   384

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

   385

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

   386

				AMA_TTDP_LANDING_TO_HANGER : AMA_TTDP_LANDING_TO_PAD1;

   387

   388

		default:

   389

			return AMA_TTDP_IN_HANGER;

   390

	}

   391

}

   392

   393

   394

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

   395

enum {

   396

	ATP_TTDP_SMALL,

   397

	ATP_TTDP_LARGE,

   398

	ATP_TTDP_HELIPORT,

   399

	ATP_TTDP_OILRIG,

   400

};

   401

   402

   403

/* Vehicle Resolver Functions */

   404

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

   405

{

   406

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

   407

}

   408

   409

   410

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   411

{

   412

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

   413

}

   414

   415

   416

static uint32 VehicleGetTriggers(const ResolverObject *object)

   417

{

   418

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

   419

}

   420

   421

   422

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

   423

{

   424

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

   425

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

   426

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

   427

	 */

   428

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

   429

   430

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

   431

	 * other time is an error. */

   432

	assert(object->trigger != 0);

   433

   434

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

   435

}

   436

   437

   438

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

   439

{

   440

	const Vehicle *v = GRV(object);

   441

   442

	if (v == NULL) {

   443

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

   444

		switch (variable) {

   445

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

   446

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

   447

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

   448

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

   449

			default:   return -1;

   450

		}

   451

	}

   452

   453

	/* Calculated vehicle parameters */

   454

	switch (variable) {

   455

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

   456

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

   457

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

   458

   459

			{

   460

				const Vehicle* u;

   461

				byte chain_before = 0;

   462

				byte chain_after  = 0;

   463

   464

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

   465

					chain_before++;

   466

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

   467

				}

   468

   469

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

   470

					chain_after++;

   471

					u = u->next;

   472

				}

   473

   474

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

   475

			}

   476

   477

		case 0x43: /* Player information */

   478

			return v->owner;

   479

   480

		case 0x44: /* Aircraft information */

   481

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

   482

   483

			{

   484

				const Vehicle *w = v->next;

   485

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

   486

				byte airporttype;

   487

   488

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

   489

					case AT_SMALL: airporttype = ATP_TTDP_SMALL; break;

   490

					case AT_METROPOLITAN:

   491

					case AT_INTERNATIONAL:

   492

					case AT_LARGE: airporttype = ATP_TTDP_LARGE; break;

   493

					case AT_HELIPORT: airporttype = ATP_TTDP_HELIPORT; break;

   494

					case AT_OILRIG: airporttype = ATP_TTDP_OILRIG; break;

   495