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.h"

    14

#include "newgrf_callbacks.h"

    15

#include "newgrf_engine.h"

    16

#include "newgrf_station.h"

    17

#include "newgrf_spritegroup.h"

    18

#include "newgrf_cargo.h"

    19

#include "date.h"

    20

    21

    22

    23

/* Default cargo classes */

    24

static const uint16 _cargo_classes[NUM_GLOBAL_CID] = {

    25

	CC_PASSENGERS,

    26

	CC_BULK,

    27

	CC_MAIL,

    28

	CC_LIQUID,

    29

	CC_PIECE_GOODS,

    30

	CC_EXPRESS,

    31

	CC_BULK,

    32

	CC_PIECE_GOODS,

    33

	CC_BULK,

    34

	CC_PIECE_GOODS,

    35

	CC_ARMOURED,

    36

	CC_PIECE_GOODS,

    37

	CC_REFRIGERATED | CC_EXPRESS,

    38

	CC_REFRIGERATED | CC_EXPRESS,

    39

	CC_BULK,

    40

	CC_LIQUID,

    41

	CC_LIQUID,

    42

	CC_BULK,

    43

	CC_PIECE_GOODS,

    44

	CC_PIECE_GOODS,

    45

	CC_EXPRESS,

    46

	CC_BULK,

    47

	CC_LIQUID,

    48

	CC_BULK,

    49

	CC_PIECE_GOODS,

    50

	CC_LIQUID,

    51

	CC_PIECE_GOODS,

    52

	CC_PIECE_GOODS,

    53

	CC_NOAVAILABLE,

    54

	CC_NOAVAILABLE,

    55

	CC_NOAVAILABLE,

    56

};

    57

    58

int _traininfo_vehicle_pitch = 0;

    59

int _traininfo_vehicle_width = 29;

    60

    61

typedef struct WagonOverride {

    62

	byte *train_id;

    63

	int trains;

    64

	CargoID cargo;

    65

	const SpriteGroup *group;

    66

} WagonOverride;

    67

    68

typedef struct WagonOverrides {

    69

	int overrides_count;

    70

	WagonOverride *overrides;

    71

} WagonOverrides;

    72

    73

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    74

    75

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

    76

{

    77

	WagonOverrides *wos;

    78

	WagonOverride *wo;

    79

    80

	wos = &_engine_wagon_overrides[engine];

    81

	wos->overrides_count++;

    82

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

    83

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

    84

    85

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

    86

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

    87

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

    88

	 * --pasky */

    89

	wo->group = group;

    90

	wo->cargo = cargo;

    91

	wo->trains = trains;

    92

	wo->train_id = malloc(trains);

    93

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

    94

}

    95

    96

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

    97

{

    98

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    99

	int i;

   100

   101

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

   102

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

   103

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

   104

	// that. --pasky

   105

   106

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

   107

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

   108

		int j;

   109

   110

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

   111

			if (wo->train_id[j] == overriding_engine && (wo->cargo == cargo || wo->cargo == GC_DEFAULT)) return wo->group;

   112

		}

   113

	}

   114

	return NULL;

   115

}

   116

   117

/**

   118

 * Unload all wagon override sprite groups.

   119

 */

   120

void UnloadWagonOverrides(void)

   121

{

   122

	WagonOverrides *wos;

   123

	WagonOverride *wo;

   124

	EngineID engine;

   125

	int i;

   126

   127

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

   128

		wos = &_engine_wagon_overrides[engine];

   129

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

   130

			wo = &wos->overrides[i];

   131

			wo->group = NULL;

   132

			free(wo->train_id);

   133

		}

   134

		free(wos->overrides);

   135

		wos->overrides_count = 0;

   136

		wos->overrides = NULL;

   137

	}

   138

}

   139

   140

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

   141

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

   142

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

   143

// memory. --pasky)

   144

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

   145

static const GRFFile *_engine_grf[TOTAL_NUM_ENGINES];

   146

   147

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

   148

{

   149

	assert(engine < TOTAL_NUM_ENGINES);

   150

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

   151

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

   152

	}

   153

	engine_custom_sprites[engine][cargo] = group;

   154

}

   155

   156

/**

   157

 * Unload all engine sprite groups.

   158

 */

   159

void UnloadCustomEngineSprites(void)

   160

{

   161

	EngineID engine;

   162

	CargoID cargo;

   163

   164

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

   165

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

   166

			engine_custom_sprites[engine][cargo] = NULL;

   167

		}

   168

		_engine_grf[engine] = 0;

   169

	}

   170

}

   171

   172

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   173

   174

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

   175

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   176

{

   177

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   178

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   179

   180

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

   181

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

   182

	}

   183

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   184

}

   185

   186

/** Unload all rotor override sprite groups */

   187

void UnloadRotorOverrideSprites(void)

   188

{

   189

	EngineID engine;

   190

   191

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

   192

	 * the context of EngineID is correct */

   193

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

   194

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   195

	}

   196

}

   197

   198

   199

/**

   200

 * Tie a GRFFile entry to an engine, to allow us to retrieve GRF parameters

   201

 * etc during a game.

   202

 * @param engine Engine ID to tie the GRFFile to.

   203

 * @param file   Pointer of GRFFile to tie.

   204

 */

   205

void SetEngineGRF(EngineID engine, const GRFFile *file)

   206

{

   207

	assert(engine < TOTAL_NUM_ENGINES);

   208

	_engine_grf[engine] = file;

   209

}

   210

   211

   212

/**

   213

 * Retrieve the GRFFile tied to an engine

   214

 * @param engine Engine ID to retrieve.

   215

 * @return Pointer to GRFFile.

   216

 */

   217

const GRFFile *GetEngineGRF(EngineID engine)

   218

{

   219

	assert(engine < TOTAL_NUM_ENGINES);

   220

	return _engine_grf[engine];

   221

}

   222

   223

   224

/**

   225

 * Retrieve the GRF ID of the GRFFile tied to an engine

   226

 * @param engine Engine ID to retrieve.

   227

 * @return 32 bit GRFID value.

   228

 */

   229

uint32 GetEngineGRFID(EngineID engine)

   230

{

   231

	assert(engine < TOTAL_NUM_ENGINES);

   232

	return _engine_grf[engine]->grfid;

   233

}

   234

   235

   236

static int MapOldSubType(const Vehicle *v)

   237

{

   238

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

   239

	if (IsTrainEngine(v)) return 0;

   240

	if (IsFreeWagon(v)) return 4;

   241

	return 2;

   242

}

   243

   244

   245

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

   246

enum {

   247

	AMS_TTDP_HANGAR,

   248

	AMS_TTDP_TO_HANGAR,

   249

	AMS_TTDP_TO_PAD1,

   250

	AMS_TTDP_TO_PAD2,

   251

	AMS_TTDP_TO_PAD3,

   252

	AMS_TTDP_TO_ENTRY_2_AND_3,

   253

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   254

	AMS_TTDP_TO_JUNCTION,

   255

	AMS_TTDP_LEAVE_RUNWAY,

   256

	AMS_TTDP_TO_INWAY,

   257

	AMS_TTDP_TO_RUNWAY,

   258

	AMS_TTDP_TO_OUTWAY,

   259

	AMS_TTDP_WAITING,

   260

	AMS_TTDP_TAKEOFF,

   261

	AMS_TTDP_TO_TAKEOFF,

   262

	AMS_TTDP_CLIMBING,

   263

	AMS_TTDP_FLIGHT_APPROACH,

   264

	AMS_TTDP_UNUSED_0x11,

   265

	AMS_TTDP_FLIGHT_TO_TOWER,

   266

	AMS_TTDP_UNUSED_0x13,

   267

	AMS_TTDP_FLIGHT_FINAL,

   268

	AMS_TTDP_FLIGHT_DESCENT,

   269

	AMS_TTDP_BRAKING,

   270

	AMS_TTDP_HELI_TAKEOFF_AIRPORT,

   271

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,

   272

	AMS_TTDP_HELI_LAND_AIRPORT,

   273

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   274

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   275

	AMS_TTDP_HELI_LAND_HELIPORT,

   276

};

   277

   278

   279

/**

   280

 * Map OTTD aircraft movement states to TTDPatch style movement states

   281

 * (VarAction 2 Variable 0xE2)

   282

 */

   283

static byte MapAircraftMovementState(const Vehicle *v)

   284

{

   285

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

   286

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

   287

   288

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

   289

		case HANGAR:

   290

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

   291

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

   292

			 * AMED_HELI_LOWER some time before actually descending. */

   293

   294

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

   295

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

   296

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT;

   297

   298

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

   299

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

   300

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   301

   302

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

   303

			/* Has reached hanger? */

   304

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGAR;

   305

   306

			// Still moving towards hanger.

   307

			return AMS_TTDP_TO_HANGAR;

   308

   309

		case TERM1:

   310

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   311

			return AMS_TTDP_TO_JUNCTION;

   312

   313

		case TERM2:

   314

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   315

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   316

   317

		case TERM3:

   318

		case TERM4:

   319

		case TERM5:

   320

		case TERM6:

   321

		case TERM7:

   322

		case TERM8:

   323

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

   324

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   325

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   326

   327

		case HELIPAD1:

   328

		case HELIPAD2:

   329

		case HELIPAD3:

   330

		case HELIPAD4: // Will only occur for helicopters.

   331

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

   332

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

   333

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   334

   335

		case TAKEOFF: // Moving to takeoff position.

   336

			return AMS_TTDP_TO_OUTWAY;

   337

   338

		case STARTTAKEOFF: // Accelerating down runway.

   339

			return AMS_TTDP_TAKEOFF;

   340

   341

		case ENDTAKEOFF: // Ascent

   342

			return AMS_TTDP_CLIMBING;

   343

   344

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

   345

			switch (st->airport_type) {

   346

				case AT_SMALL:

   347

				case AT_LARGE:

   348

				case AT_METROPOLITAN:

   349

				case AT_INTERNATIONAL:

   350

				case AT_COMMUTER:

   351

				case AT_INTERCON:

   352

				/* Note, Helidepot and Helistation are treated as airports as

   353

				 * helicopters are taking off from ground level. */

   354

				case AT_HELIDEPOT:

   355

				case AT_HELISTATION:

   356

					if (amdflag & AMED_HELI_RAISE) return AMS_TTDP_HELI_TAKEOFF_AIRPORT;

   357

					return AMS_TTDP_TO_JUNCTION;

   358

   359

				case AT_HELIPORT:

   360

				case AT_OILRIG:

   361

					return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   362

   363

				default:

   364

					return AMS_TTDP_HELI_TAKEOFF_AIRPORT;

   365

			}

   366

   367

		case FLYING:

   368

			return AMS_TTDP_FLIGHT_TO_TOWER;

   369

   370

		case LANDING: // Descent

   371

			return AMS_TTDP_FLIGHT_DESCENT;

   372

   373

		case ENDLANDING: // On the runway braking

   374

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   375

			// Landed - moving off runway

   376

			return AMS_TTDP_TO_INWAY;

   377

   378

		case HELILANDING:

   379

		case HELIENDLANDING: // Helicoptor is decending.

   380

			if (amdflag & AMED_HELI_LOWER) {

   381

				switch (st->airport_type) {

   382

					case AT_HELIPORT:

   383

					case AT_OILRIG:

   384

						return AMS_TTDP_HELI_LAND_HELIPORT;

   385

   386

					default:

   387

						/* Note, Helidepot and Helistation are treated as airports as

   388

						 * helicopters are landing at ground level. */

   389

						return AMS_TTDP_HELI_LAND_AIRPORT;

   390

				}

   391

			}

   392

			return AMS_TTDP_FLIGHT_TO_TOWER;

   393

   394

		default:

   395

			return AMS_TTDP_HANGAR;

   396

	}

   397

}

   398

   399

   400

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

   401

enum {

   402

	AMA_TTDP_IN_HANGAR,

   403

	AMA_TTDP_ON_PAD1,

   404

	AMA_TTDP_ON_PAD2,

   405

	AMA_TTDP_ON_PAD3,

   406

	AMA_TTDP_HANGAR_TO_PAD1,

   407

	AMA_TTDP_HANGAR_TO_PAD2,

   408

	AMA_TTDP_HANGAR_TO_PAD3,

   409

	AMA_TTDP_LANDING_TO_PAD1,

   410

	AMA_TTDP_LANDING_TO_PAD2,

   411

	AMA_TTDP_LANDING_TO_PAD3,

   412

	AMA_TTDP_PAD1_TO_HANGAR,

   413

	AMA_TTDP_PAD2_TO_HANGAR,

   414

	AMA_TTDP_PAD3_TO_HANGAR,

   415

	AMA_TTDP_PAD1_TO_TAKEOFF,

   416

	AMA_TTDP_PAD2_TO_TAKEOFF,

   417

	AMA_TTDP_PAD3_TO_TAKEOFF,

   418

	AMA_TTDP_HANGAR_TO_TAKOFF,

   419

	AMA_TTDP_LANDING_TO_HANGAR,

   420

	AMA_TTDP_IN_FLIGHT,

   421

};

   422

   423

   424

/**

   425

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   426

 * (VarAction 2 Variable 0xE6)

   427

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

   428

 */

   429

static byte MapAircraftMovementAction(const Vehicle *v)

   430

{

   431

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

   432

		case HANGAR:

   433

			return (v->cur_speed > 0) ? AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_IN_HANGAR;

   434

   435

		case TERM1:

   436

		case HELIPAD1:

   437

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

   438

   439

		case TERM2:

   440

		case HELIPAD2:

   441

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

   442

   443

		case TERM3:

   444

		case TERM4:

   445

		case TERM5:

   446

		case TERM6:

   447

		case TERM7:

   448

		case TERM8:

   449

		case HELIPAD3:

   450

		case HELIPAD4:

   451

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

   452

   453

		case TAKEOFF:      // Moving to takeoff position

   454

		case STARTTAKEOFF: // Accelerating down runway

   455

		case ENDTAKEOFF:   // Ascent

   456

		case HELITAKEOFF:

   457

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

   458

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   459

   460

		case FLYING:

   461

			return AMA_TTDP_IN_FLIGHT;

   462

   463

		case LANDING:    // Descent

   464

		case ENDLANDING: // On the runway braking

   465

		case HELILANDING:

   466

		case HELIENDLANDING:

   467

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

   468

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

   469

				AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;

   470

   471

		default:

   472

			return AMA_TTDP_IN_HANGAR;

   473

	}

   474

}

   475

   476

   477

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

   478

enum {

   479

	ATP_TTDP_SMALL,

   480

	ATP_TTDP_LARGE,

   481

	ATP_TTDP_HELIPORT,

   482

	ATP_TTDP_OILRIG,

   483

};

   484

   485

   486

/* Vehicle Resolver Functions */

   487

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

   488

{

   489

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

   490

}

   491