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

#include "newgrf_cargo.h"

    18

    19

    20

    21

/* Default cargo classes */

    22

static const uint16 _cargo_classes[NUM_GLOBAL_CID] = {

    23

	CC_PASSENGERS,

    24

	CC_BULK,

    25

	CC_MAIL,

    26

	CC_LIQUID,

    27

	CC_PIECE_GOODS,

    28

	CC_EXPRESS,

    29

	CC_BULK,

    30

	CC_PIECE_GOODS,

    31

	CC_BULK,

    32

	CC_PIECE_GOODS,

    33

	CC_ARMOURED,

    34

	CC_PIECE_GOODS,

    35

	CC_REFRIGERATED | CC_EXPRESS,

    36

	CC_REFRIGERATED | CC_EXPRESS,

    37

	CC_BULK,

    38

	CC_LIQUID,

    39

	CC_LIQUID,

    40

	CC_BULK,

    41

	CC_PIECE_GOODS,

    42

	CC_PIECE_GOODS,

    43

	CC_EXPRESS,

    44

	CC_BULK,

    45

	CC_LIQUID,

    46

	CC_BULK,

    47

	CC_PIECE_GOODS,

    48

	CC_LIQUID,

    49

	CC_PIECE_GOODS,

    50

	CC_PIECE_GOODS,

    51

	CC_NOAVAILABLE,

    52

	CC_NOAVAILABLE,

    53

	CC_NOAVAILABLE,

    54

};

    55

    56

int _traininfo_vehicle_pitch = 0;

    57

int _traininfo_vehicle_width = 29;

    58

    59

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

    60

    61

typedef struct WagonOverride {

    62

	byte *train_id;

    63

	int trains;

    64

	const SpriteGroup *group;

    65

} WagonOverride;

    66

    67

typedef struct WagonOverrides {

    68

	int overrides_count;

    69

	WagonOverride *overrides;

    70

} WagonOverrides;

    71

    72

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    73

    74

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

    75

{

    76

	WagonOverrides *wos;

    77

	WagonOverride *wo;

    78

    79

	wos = &_engine_wagon_overrides[engine];

    80

	wos->overrides_count++;

    81

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

    82

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

    83

    84

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

    85

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

    86

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

    87

	 * --pasky */

    88

	wo->group = group;

    89

	wo->trains = trains;

    90

	wo->train_id = malloc(trains);

    91

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

    92

}

    93

    94

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

    95

{

    96

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    97

	int i;

    98

    99

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

   100

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

   101

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

   102

	// that. --pasky

   103

   104

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

   105

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

   106

		int j;

   107

   108

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

   109

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

   110

				return wo->group;

   111

		}

   112

	}

   113

	return NULL;

   114

}

   115

   116

/**

   117

 * Unload all wagon override sprite groups.

   118

 */

   119

void UnloadWagonOverrides(void)

   120

{

   121

	WagonOverrides *wos;

   122

	WagonOverride *wo;

   123

	EngineID engine;

   124

	int i;

   125

   126

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

   127

		wos = &_engine_wagon_overrides[engine];

   128

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

   129

			wo = &wos->overrides[i];

   130

			wo->group = NULL;

   131

			free(wo->train_id);

   132

		}

   133

		free(wos->overrides);

   134

		wos->overrides_count = 0;

   135

		wos->overrides = NULL;

   136

	}

   137

}

   138

   139

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

   140

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

   141

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

   142

// memory. --pasky)

   143

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

   144

static uint32 _engine_grf[TOTAL_NUM_ENGINES];

   145

   146

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

   147

{

   148

	assert(engine < TOTAL_NUM_ENGINES);

   149

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

   150

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

   151

	}

   152

	engine_custom_sprites[engine][cargo] = group;

   153

}

   154

   155

/**

   156

 * Unload all engine sprite groups.

   157

 */

   158

void UnloadCustomEngineSprites(void)

   159

{

   160

	EngineID engine;

   161

	CargoID cargo;

   162

   163

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

   164

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

   165

			engine_custom_sprites[engine][cargo] = NULL;

   166

		}

   167

		_engine_grf[engine] = 0;

   168

	}

   169

}

   170

   171

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   172

   173

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

   174

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   175

{

   176

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   177

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   178

   179

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

   180

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

   181

	}

   182

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   183

}

   184

   185

/** Unload all rotor override sprite groups */

   186

void UnloadRotorOverrideSprites(void)

   187

{

   188

	EngineID engine;

   189

   190

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

   191

	 * the context of EngineID is correct */

   192

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

   193

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   194

	}

   195

}

   196

   197

void SetEngineGRF(EngineID engine, uint32 grfid)

   198

{

   199

	assert(engine < TOTAL_NUM_ENGINES);

   200

	_engine_grf[engine] = grfid;

   201

}

   202

   203

uint32 GetEngineGRFID(EngineID engine)

   204

{

   205

	assert(engine < TOTAL_NUM_ENGINES);

   206

	return _engine_grf[engine];

   207

}

   208

   209

   210

static int MapOldSubType(const Vehicle *v)

   211

{

   212

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

   213

	if (IsTrainEngine(v)) return 0;

   214

	if (IsFreeWagon(v)) return 4;

   215

	return 2;

   216

}

   217

   218

   219

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

   220

enum {

   221

	AMS_TTDP_HANGER,

   222

	AMS_TTDP_TO_HANGER,

   223

	AMS_TTDP_TO_PAD1,

   224

	AMS_TTDP_TO_PAD2,

   225

	AMS_TTDP_TO_PAD3,

   226

	AMS_TTDP_TO_ENTRY_2_AND_3,

   227

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   228

	AMS_TTDP_TO_JUNCTION,

   229

	AMS_TTDP_LEAVE_RUNWAY,

   230

	AMS_TTDP_TO_INWAY,

   231

	AMS_TTDP_TO_RUNWAY,

   232

	AMS_TTDP_TO_OUTWAY,

   233

	AMS_TTDP_WAITING,

   234

	AMS_TTDP_TAKEOFF,

   235

	AMS_TTDP_TO_TAKEOFF,

   236

	AMS_TTDP_CLIMBING,

   237

	AMS_TTDP_FLIGHT_APPROACH,

   238

	AMS_TTDP_UNUSED_0x11,

   239

	AMS_TTDP_FLIGHT_TO_TOWER,

   240

	AMS_TTDP_UNUSED_0x13,

   241

	AMS_TTDP_FLIGHT_FINAL,

   242

	AMS_TTDP_FLIGHT_DESCENT,

   243

	AMS_TTDP_BRAKING,

   244

	AMS_TTDP_HELI_TAKEOFF_AIRPOPT,

   245

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPOPT,

   246

	AMS_TTDP_HELI_LAND_AIRPOPT,

   247

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   248

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   249

	AMS_TTDP_HELI_LAND_HELIPORT,

   250

};

   251

   252

   253

/**

   254

 * Map OTTD aircraft movement states to TTDPatch style movement states

   255

 * (VarAction 2 Variable 0xE2)

   256

 */

   257

static byte MapAircraftMovementState(const Vehicle *v)

   258

{

   259

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

   260

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

   261

   262

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

   263

		case HANGAR:

   264

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

   265

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

   266

			 * AMED_HELI_LOWER some time before actually descending. */

   267

   268

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

   269

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

   270

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPOPT;

   271

   272

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

   273

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

   274

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   275

   276

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

   277

			/* Has reached hanger? */

   278

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGER;

   279

   280

			// Still moving towards hanger.

   281

			return AMS_TTDP_TO_HANGER;

   282

   283

		case TERM1:

   284

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   285

			return AMS_TTDP_TO_JUNCTION;

   286

   287

		case TERM2:

   288

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   289

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   290

   291

		case TERM3:

   292

		case TERM4:

   293

		case TERM5:

   294

		case TERM6:

   295

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

   296

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   297

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   298

   299

		case HELIPAD1:

   300

		case HELIPAD2: // Will only occur for helicopters.

   301

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

   302

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

   303

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   304

   305

		case TAKEOFF: // Moving to takeoff position.

   306

			return AMS_TTDP_TO_OUTWAY;

   307

   308

		case STARTTAKEOFF: // Accelerating down runway.

   309

			return AMS_TTDP_TAKEOFF;

   310

   311

		case ENDTAKEOFF: // Ascent

   312

			return AMS_TTDP_CLIMBING;

   313

   314

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

   315

			switch (st->airport_type) {

   316

				case AT_SMALL:

   317

				case AT_LARGE:

   318

				case AT_METROPOLITAN:

   319

				case AT_INTERNATIONAL:

   320

					if (amdflag & AMED_HELI_RAISE) return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   321

					return AMS_TTDP_TO_JUNCTION;

   322

   323

				case AT_HELIPORT:

   324

				case AT_OILRIG:

   325

					return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   326

   327

				default:

   328

					return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   329

			}

   330

   331

		case FLYING:

   332

			return AMS_TTDP_FLIGHT_TO_TOWER;

   333

   334

		case LANDING: // Descent

   335

			return AMS_TTDP_FLIGHT_DESCENT;

   336

   337

		case ENDLANDING: // On the runway braking

   338

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   339

			// Landed - moving off runway

   340

			return AMS_TTDP_TO_INWAY;

   341

   342

		case HELILANDING:

   343

		case HELIENDLANDING: // Helicoptor is decending.

   344

			if (amdflag & AMED_HELI_LOWER) {

   345

				switch (st->airport_type) {

   346

					case AT_HELIPORT:

   347

					case AT_OILRIG:

   348

						return AMS_TTDP_HELI_LAND_HELIPORT;

   349

   350

					default:

   351

						return AMS_TTDP_HELI_LAND_AIRPOPT;

   352

				}

   353

			}

   354

			return AMS_TTDP_FLIGHT_TO_TOWER;

   355

   356

		default:

   357

			return AMS_TTDP_HANGER;

   358

	}

   359

}

   360

   361

   362

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

   363

enum {

   364

	AMA_TTDP_IN_HANGER,

   365

	AMA_TTDP_ON_PAD1,

   366

	AMA_TTDP_ON_PAD2,

   367

	AMA_TTDP_ON_PAD3,

   368

	AMA_TTDP_HANGER_TO_PAD1,

   369

	AMA_TTDP_HANGER_TO_PAD2,

   370

	AMA_TTDP_HANGER_TO_PAD3,

   371

	AMA_TTDP_LANDING_TO_PAD1,

   372

	AMA_TTDP_LANDING_TO_PAD2,

   373

	AMA_TTDP_LANDING_TO_PAD3,

   374

	AMA_TTDP_PAD1_TO_HANGER,

   375

	AMA_TTDP_PAD2_TO_HANGER,

   376

	AMA_TTDP_PAD3_TO_HANGER,

   377

	AMA_TTDP_PAD1_TO_TAKEOFF,

   378

	AMA_TTDP_PAD2_TO_TAKEOFF,

   379

	AMA_TTDP_PAD3_TO_TAKEOFF,

   380

	AMA_TTDP_HANGER_TO_TAKOFF,

   381

	AMA_TTDP_LANDING_TO_HANGER,

   382

	AMA_TTDP_IN_FLIGHT,

   383

};

   384

   385

   386

/**

   387

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   388

 * (VarAction 2 Variable 0xE6)

   389

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

   390

 */

   391

static byte MapAircraftMovementAction(const Vehicle *v)

   392

{

   393

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

   394

		case HANGAR:

   395

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

   396

   397

		case TERM1:

   398

		case HELIPAD1:

   399

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

   400

   401

		case TERM2:

   402

		case HELIPAD2:

   403

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

   404

   405

		case TERM3:

   406

		case TERM4:

   407

		case TERM5:

   408

		case TERM6:

   409

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

   410

   411

		case TAKEOFF:      // Moving to takeoff position

   412

		case STARTTAKEOFF: // Accelerating down runway

   413

		case ENDTAKEOFF:   // Ascent

   414

		case HELITAKEOFF:

   415

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

   416

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   417

   418

		case FLYING:

   419

			return AMA_TTDP_IN_FLIGHT;

   420

   421

		case LANDING:    // Descent

   422

		case ENDLANDING: // On the runway braking

   423

		case HELILANDING:

   424

		case HELIENDLANDING:

   425

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

   426

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

   427

				AMA_TTDP_LANDING_TO_HANGER : AMA_TTDP_LANDING_TO_PAD1;

   428

   429

		default:

   430

			return AMA_TTDP_IN_HANGER;

   431

	}

   432

}

   433

   434

   435

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

   436

enum {

   437

	ATP_TTDP_SMALL,

   438

	ATP_TTDP_LARGE,

   439

	ATP_TTDP_HELIPORT,

   440

	ATP_TTDP_OILRIG,

   441

};

   442

   443

   444

/* Vehicle Resolver Functions */

   445

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

   446

{

   447

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

   448

}

   449

   450

   451

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   452

{

   453

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

   454

}

   455

   456

   457

static uint32 VehicleGetTriggers(const ResolverObject *object)

   458

{

   459

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

   460

}

   461

   462

   463

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

   464

{

   465

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

   466

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

   467

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

   468

	 */

   469

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

   470

   471

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

   472

	 * other time is an error. */

   473

	assert(object->trigger != 0);

   474

   475

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

   476

}

   477

   478

   479

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

   480

{

   481

	const Vehicle *v = GRV(object);

   482

   483

	if (v == NULL) {

   484

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

   485

		switch (variable) {

   486

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

   487

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

   488

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

   489

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

   490

			default:   return -1;

   491

		}

   492

	}

   493

   494

	/* Calculated vehicle parameters */