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

    19

/* XXX These tables should be moved / ripped out when newcargos is implemented. */

    20

    21

/* Cargo classes */

    22

enum {

    23

	CC_NONE         = 0,

    24

	CC_PASSENGERS   = 1 << 0,

    25

	CC_MAIL         = 1 << 1,

    26

	CC_EXPRESS      = 1 << 2,

    27

	CC_ARMOURED     = 1 << 3,

    28

	CC_BULK         = 1 << 4,

    29

	CC_PIECE_GOODS  = 1 << 5,

    30

	CC_LIQUID       = 1 << 6,

    31

	CC_REFRIGERATED = 1 << 7,

    32

};

    33

    34

/* Default cargo classes */

    35

static const uint16 _cargo_classes[NUM_GLOBAL_CID] = {

    36

	CC_PASSENGERS,

    37

	CC_BULK,

    38

	CC_MAIL,

    39

	CC_LIQUID,

    40

	CC_PIECE_GOODS,

    41

	CC_EXPRESS,

    42

	CC_BULK,

    43

	CC_PIECE_GOODS,

    44

	CC_BULK,

    45

	CC_PIECE_GOODS,

    46

	CC_ARMOURED,

    47

	CC_PIECE_GOODS,

    48

	CC_REFRIGERATED | CC_EXPRESS,

    49

	CC_REFRIGERATED | CC_EXPRESS,

    50

	CC_BULK,

    51

	CC_LIQUID,

    52

	CC_LIQUID,

    53

	CC_BULK,

    54

	CC_PIECE_GOODS,

    55

	CC_PIECE_GOODS,

    56

	CC_EXPRESS,

    57

	CC_BULK,

    58

	CC_LIQUID,

    59

	CC_BULK,

    60

	CC_PIECE_GOODS,

    61

	CC_LIQUID,

    62

	CC_PIECE_GOODS,

    63

	CC_PIECE_GOODS,

    64

	CC_NONE,

    65

	CC_NONE,

    66

	CC_NONE,

    67

};

    68

    69

int _traininfo_vehicle_pitch = 0;

    70

int _traininfo_vehicle_width = 29;

    71

    72

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

    73

    74

typedef struct WagonOverride {

    75

	byte *train_id;

    76

	int trains;

    77

	const SpriteGroup *group;

    78

} WagonOverride;

    79

    80

typedef struct WagonOverrides {

    81

	int overrides_count;

    82

	WagonOverride *overrides;

    83

} WagonOverrides;

    84

    85

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    86

    87

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

    88

{

    89

	WagonOverrides *wos;

    90

	WagonOverride *wo;

    91

    92

	wos = &_engine_wagon_overrides[engine];

    93

	wos->overrides_count++;

    94

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

    95

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

    96

    97

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

    98

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

    99

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

   100

	 * --pasky */

   101

	wo->group = group;

   102

	wo->trains = trains;

   103

	wo->train_id = malloc(trains);

   104

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

   105

}

   106

   107

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

   108

{

   109

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   110

	int i;

   111

   112

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

   113

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

   114

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

   115

	// that. --pasky

   116

   117

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

   118

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

   119

		int j;

   120

   121

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

   122

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

   123

				return wo->group;

   124

		}

   125

	}

   126

	return NULL;

   127

}

   128

   129

/**

   130

 * Unload all wagon override sprite groups.

   131

 */

   132

void UnloadWagonOverrides(void)

   133

{

   134

	WagonOverrides *wos;

   135

	WagonOverride *wo;

   136

	EngineID engine;

   137

	int i;

   138

   139

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

   140

		wos = &_engine_wagon_overrides[engine];

   141

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

   142

			wo = &wos->overrides[i];

   143

			wo->group = NULL;

   144

			free(wo->train_id);

   145

		}

   146

		free(wos->overrides);

   147

		wos->overrides_count = 0;

   148

		wos->overrides = NULL;

   149

	}

   150

}

   151

   152

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

   153

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

   154

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

   155

// memory. --pasky)

   156

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

   157

static uint32 _engine_grf[TOTAL_NUM_ENGINES];

   158

   159

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

   160

{

   161

	assert(engine < TOTAL_NUM_ENGINES);

   162

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

   163

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

   164

	}

   165

	engine_custom_sprites[engine][cargo] = group;

   166

}

   167

   168

/**

   169

 * Unload all engine sprite groups.

   170

 */

   171

void UnloadCustomEngineSprites(void)

   172

{

   173

	EngineID engine;

   174

	CargoID cargo;

   175

   176

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

   177

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

   178

			engine_custom_sprites[engine][cargo] = NULL;

   179

		}

   180

		_engine_grf[engine] = 0;

   181

	}

   182

}

   183

   184

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   185

   186

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

   187

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   188

{

   189

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   190

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   191

   192

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

   193

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

   194

	}

   195

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   196

}

   197

   198

/** Unload all rotor override sprite groups */

   199

void UnloadRotorOverrideSprites(void)

   200

{

   201

	EngineID engine;

   202

   203

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

   204

	 * the context of EngineID is correct */

   205

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

   206

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   207

	}

   208

}

   209

   210

void SetEngineGRF(EngineID engine, uint32 grfid)

   211

{

   212

	assert(engine < TOTAL_NUM_ENGINES);

   213

	_engine_grf[engine] = grfid;

   214

}

   215

   216

uint32 GetEngineGRFID(EngineID engine)

   217

{

   218

	assert(engine < TOTAL_NUM_ENGINES);

   219

	return _engine_grf[engine];

   220

}

   221

   222

   223

static int MapOldSubType(const Vehicle *v)

   224

{

   225

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

   226

	if (IsTrainEngine(v)) return 0;

   227

	if (IsFreeWagon(v)) return 4;

   228

	return 2;

   229

}

   230

   231

   232

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

   233

enum {

   234

	AMS_TTDP_HANGER,

   235

	AMS_TTDP_TO_HANGER,

   236

	AMS_TTDP_TO_PAD1,

   237

	AMS_TTDP_TO_PAD2,

   238

	AMS_TTDP_TO_PAD3,

   239

	AMS_TTDP_TO_ENTRY_2_AND_3,

   240

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   241

	AMS_TTDP_TO_JUNCTION,

   242

	AMS_TTDP_LEAVE_RUNWAY,

   243

	AMS_TTDP_TO_INWAY,

   244

	AMS_TTDP_TO_RUNWAY,

   245

	AMS_TTDP_TO_OUTWAY,

   246

	AMS_TTDP_WAITING,

   247

	AMS_TTDP_TAKEOFF,

   248

	AMS_TTDP_TO_TAKEOFF,

   249

	AMS_TTDP_CLIMBING,

   250

	AMS_TTDP_FLIGHT_APPROACH,

   251

	AMS_TTDP_UNUSED_0x11,

   252

	AMS_TTDP_FLIGHT_TO_TOWER,

   253

	AMS_TTDP_UNUSED_0x13,

   254

	AMS_TTDP_FLIGHT_FINAL,

   255

	AMS_TTDP_FLIGHT_DESCENT,

   256

	AMS_TTDP_BRAKING,

   257

	AMS_TTDP_HELI_TAKEOFF_AIRPOPT,

   258

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPOPT,

   259

	AMS_TTDP_HELI_LAND_AIRPOPT,

   260

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   261

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   262

	AMS_TTDP_HELI_LAND_HELIPORT,

   263

};

   264

   265

   266

/**

   267

 * Map OTTD aircraft movement states to TTDPatch style movement states

   268

 * (VarAction 2 Variable 0xE2)

   269

 */

   270

static byte MapAircraftMovementState(const Vehicle *v)

   271

{

   272

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

   273

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

   274

   275

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

   276

		case HANGAR:

   277

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

   278

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

   279

			 * AMED_HELI_LOWER some time before actually descending. */

   280

   281

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

   282

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

   283

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPOPT;

   284

   285

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

   286

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

   287

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   288

   289

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

   290

			/* Has reached hanger? */

   291

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGER;

   292

   293

			// Still moving towards hanger.

   294

			return AMS_TTDP_TO_HANGER;

   295

   296

		case TERM1:

   297

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   298

			return AMS_TTDP_TO_JUNCTION;

   299

   300

		case TERM2:

   301

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   302

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   303

   304

		case TERM3:

   305

		case TERM4:

   306

		case TERM5:

   307

		case TERM6:

   308

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

   309

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   310

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   311

   312

		case HELIPAD1:

   313

		case HELIPAD2: // Will only occur for helicopters.

   314

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

   315

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

   316

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   317

   318

		case TAKEOFF: // Moving to takeoff position.

   319

			return AMS_TTDP_TO_OUTWAY;

   320

   321

		case STARTTAKEOFF: // Accelerating down runway.

   322

			return AMS_TTDP_TAKEOFF;

   323

   324

		case ENDTAKEOFF: // Ascent

   325

			return AMS_TTDP_CLIMBING;

   326

   327

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

   328

			switch (st->airport_type) {

   329

				case AT_SMALL:

   330

				case AT_LARGE:

   331

				case AT_METROPOLITAN:

   332

				case AT_INTERNATIONAL:

   333

					if (amdflag & AMED_HELI_RAISE) return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   334

					return AMS_TTDP_TO_JUNCTION;

   335

   336

				case AT_HELIPORT:

   337

				case AT_OILRIG:

   338

					return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   339

   340

				default:

   341

					return AMS_TTDP_HELI_TAKEOFF_AIRPOPT;

   342

			}

   343

   344

		case FLYING:

   345

			return AMS_TTDP_FLIGHT_TO_TOWER;

   346

   347

		case LANDING: // Descent

   348

			return AMS_TTDP_FLIGHT_DESCENT;

   349

   350

		case ENDLANDING: // On the runway braking

   351

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   352

			// Landed - moving off runway

   353

			return AMS_TTDP_TO_INWAY;

   354

   355

		case HELILANDING:

   356

		case HELIENDLANDING: // Helicoptor is decending.

   357

			if (amdflag & AMED_HELI_LOWER) {

   358

				switch (st->airport_type) {

   359

					case AT_HELIPORT:

   360

					case AT_OILRIG:

   361

						return AMS_TTDP_HELI_LAND_HELIPORT;

   362

   363

					default:

   364

						return AMS_TTDP_HELI_LAND_AIRPOPT;

   365

				}

   366

			}

   367

			return AMS_TTDP_FLIGHT_TO_TOWER;

   368

   369

		default:

   370

			return AMS_TTDP_HANGER;

   371

	}

   372

}

   373

   374

   375

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

   376

enum {

   377

	AMA_TTDP_IN_HANGER,

   378

	AMA_TTDP_ON_PAD1,

   379

	AMA_TTDP_ON_PAD2,

   380

	AMA_TTDP_ON_PAD3,

   381

	AMA_TTDP_HANGER_TO_PAD1,

   382

	AMA_TTDP_HANGER_TO_PAD2,

   383

	AMA_TTDP_HANGER_TO_PAD3,

   384

	AMA_TTDP_LANDING_TO_PAD1,

   385

	AMA_TTDP_LANDING_TO_PAD2,

   386

	AMA_TTDP_LANDING_TO_PAD3,

   387

	AMA_TTDP_PAD1_TO_HANGER,

   388

	AMA_TTDP_PAD2_TO_HANGER,

   389

	AMA_TTDP_PAD3_TO_HANGER,

   390

	AMA_TTDP_PAD1_TO_TAKEOFF,

   391

	AMA_TTDP_PAD2_TO_TAKEOFF,

   392

	AMA_TTDP_PAD3_TO_TAKEOFF,

   393

	AMA_TTDP_HANGER_TO_TAKOFF,

   394

	AMA_TTDP_LANDING_TO_HANGER,

   395

	AMA_TTDP_IN_FLIGHT,

   396

};

   397

   398

   399

/**

   400

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   401

 * (VarAction 2 Variable 0xE6)

   402

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

   403

 */

   404

static byte MapAircraftMovementAction(const Vehicle *v)

   405

{

   406

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

   407

		case HANGAR:

   408

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

   409

   410

		case TERM1:

   411

		case HELIPAD1:

   412

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

   413

   414

		case TERM2:

   415

		case HELIPAD2:

   416

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

   417

   418

		case TERM3:

   419

		case TERM4:

   420

		case TERM5:

   421

		case TERM6:

   422

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

   423

   424

		case TAKEOFF:      // Moving to takeoff position

   425

		case STARTTAKEOFF: // Accelerating down runway

   426

		case ENDTAKEOFF:   // Ascent

   427

		case HELITAKEOFF:

   428

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

   429

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   430

   431

		case FLYING:

   432

			return AMA_TTDP_IN_FLIGHT;

   433

   434

		case LANDING:    // Descent

   435

		case ENDLANDING: // On the runway braking

   436

		case HELILANDING:

   437

		case HELIENDLANDING:

   438

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

   439

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

   440

				AMA_TTDP_LANDING_TO_HANGER : AMA_TTDP_LANDING_TO_PAD1;

   441

   442

		default:

   443

			return AMA_TTDP_IN_HANGER;

   444

	}

   445

}

   446

   447

   448

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

   449

enum {

   450

	ATP_TTDP_SMALL,

   451

	ATP_TTDP_LARGE,

   452

	ATP_TTDP_HELIPORT,

   453

	ATP_TTDP_OILRIG,

   454

};

   455

   456

   457

/* Vehicle Resolver Functions */

   458

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

   459

{

   460

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

   461

}

   462

   463

   464

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   465

{

   466

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

   467

}

   468

   469

   470

static uint32 VehicleGetTriggers(const ResolverObject *object)

   471

{

   472

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

   473

}

   474

   475

   476

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

   477

{

   478

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

   479

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

   480

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

   481

	 */

   482

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

   483

   484

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

   485

	 * other time is an error. */

   486

	assert(object->trigger != 0);

   487

   488

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

   489

}

   490

   491

   492

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

   493

{

   494

	const Vehicle *v = GRV(object);