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

#include "helpers.hpp"

    21

    22

    23

    24

/* Default cargo classes */

    25

static const uint16 _cargo_classes[NUM_GLOBAL_CID] = {

    26

	CC_PASSENGERS,

    27

	CC_BULK,

    28

	CC_MAIL,

    29

	CC_LIQUID,

    30

	CC_PIECE_GOODS,

    31

	CC_EXPRESS,

    32

	CC_BULK,

    33

	CC_PIECE_GOODS,

    34

	CC_BULK,

    35

	CC_PIECE_GOODS,

    36

	CC_ARMOURED,

    37

	CC_PIECE_GOODS,

    38

	CC_REFRIGERATED | CC_EXPRESS,

    39

	CC_REFRIGERATED | CC_EXPRESS,

    40

	CC_BULK,

    41

	CC_LIQUID,

    42

	CC_LIQUID,

    43

	CC_BULK,

    44

	CC_PIECE_GOODS,

    45

	CC_PIECE_GOODS,

    46

	CC_EXPRESS,

    47

	CC_BULK,

    48

	CC_LIQUID,

    49

	CC_BULK,

    50

	CC_PIECE_GOODS,

    51

	CC_LIQUID,

    52

	CC_PIECE_GOODS,

    53

	CC_PIECE_GOODS,

    54

	CC_NOAVAILABLE,

    55

	CC_NOAVAILABLE,

    56

	CC_NOAVAILABLE,

    57

};

    58

    59

int _traininfo_vehicle_pitch = 0;

    60

int _traininfo_vehicle_width = 29;

    61

    62

typedef struct WagonOverride {

    63

	byte *train_id;

    64

	int trains;

    65

	CargoID cargo;

    66

	const SpriteGroup *group;

    67

} WagonOverride;

    68

    69

typedef struct WagonOverrides {

    70

	int overrides_count;

    71

	WagonOverride *overrides;

    72

} WagonOverrides;

    73

    74

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    75

    76

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

    77

{

    78

	WagonOverrides *wos;

    79

	WagonOverride *wo;

    80

    81

	assert(engine < TOTAL_NUM_ENGINES);

    82

	assert(cargo < NUM_GLOBAL_CID);

    83

    84

	wos = &_engine_wagon_overrides[engine];

    85

	wos->overrides_count++;

    86

	wos->overrides = ReallocT(wos->overrides, wos->overrides_count);

    87

    88

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

    89

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

    90

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

    91

	 * --pasky */

    92

	wo->group = group;

    93

	wo->cargo = cargo;

    94

	wo->trains = trains;

    95

	wo->train_id = MallocT<byte>(trains);

    96

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

    97

}

    98

    99

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

   100

{

   101

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

   102

	int i;

   103

   104

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

   105

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

   106

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

   107

	// that. --pasky

   108

   109

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

   110

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

   111

		int j;

   112

   113

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

   114

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

   115

		}

   116

	}

   117

	return NULL;

   118

}

   119

   120

/**

   121

 * Unload all wagon override sprite groups.

   122

 */

   123

void UnloadWagonOverrides(void)

   124

{

   125

	WagonOverrides *wos;

   126

	WagonOverride *wo;

   127

	EngineID engine;

   128

	int i;

   129

   130

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

   131

		wos = &_engine_wagon_overrides[engine];

   132

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

   133

			wo = &wos->overrides[i];

   134

			wo->group = NULL;

   135

			free(wo->train_id);

   136

		}

   137

		free(wos->overrides);

   138

		wos->overrides_count = 0;

   139

		wos->overrides = NULL;

   140

	}

   141

}

   142

   143

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

   144

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

   145

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

   146

// memory. --pasky)

   147

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

   148

static const GRFFile *_engine_grf[TOTAL_NUM_ENGINES];

   149

   150

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

   151

{

   152

	assert(engine < TOTAL_NUM_ENGINES);

   153

	assert(cargo < NUM_GLOBAL_CID);

   154

   155

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

   156

		grfmsg(6, "SetCustomEngineSprites: engine %d cargo %d already has group -- replacing", engine, cargo);

   157

	}

   158

	engine_custom_sprites[engine][cargo] = group;

   159

}

   160

   161

/**

   162

 * Unload all engine sprite groups.

   163

 */

   164

void UnloadCustomEngineSprites(void)

   165

{

   166

	EngineID engine;

   167

	CargoID cargo;

   168

   169

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

   170

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

   171

			engine_custom_sprites[engine][cargo] = NULL;

   172

		}

   173

		_engine_grf[engine] = 0;

   174

	}

   175

}

   176

   177

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   178

   179

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

   180

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   181

{

   182

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   183

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   184

   185

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

   186

		grfmsg(6, "SetRotorOverrideSprites: engine %d already has group -- replacing.", engine);

   187

	}

   188

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   189

}

   190

   191

/** Unload all rotor override sprite groups */

   192

void UnloadRotorOverrideSprites(void)

   193

{

   194

	EngineID engine;

   195

   196

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

   197

	 * the context of EngineID is correct */

   198

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

   199

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   200

	}

   201

}

   202

   203

   204

/**

   205

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

   206

 * etc during a game.

   207

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

   208

 * @param file   Pointer of GRFFile to tie.

   209

 */

   210

void SetEngineGRF(EngineID engine, const GRFFile *file)

   211

{

   212

	assert(engine < TOTAL_NUM_ENGINES);

   213

	_engine_grf[engine] = file;

   214

}

   215

   216

   217

/**

   218

 * Retrieve the GRFFile tied to an engine

   219

 * @param engine Engine ID to retrieve.

   220

 * @return Pointer to GRFFile.

   221

 */

   222

const GRFFile *GetEngineGRF(EngineID engine)

   223

{

   224

	assert(engine < TOTAL_NUM_ENGINES);

   225

	return _engine_grf[engine];

   226

}

   227

   228

   229

/**

   230

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

   231

 * @param engine Engine ID to retrieve.

   232

 * @return 32 bit GRFID value.

   233

 */

   234

uint32 GetEngineGRFID(EngineID engine)

   235

{

   236

	assert(engine < TOTAL_NUM_ENGINES);

   237

	return _engine_grf[engine]->grfid;

   238

}

   239

   240

   241

static int MapOldSubType(const Vehicle *v)

   242

{

   243

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

   244

	if (IsTrainEngine(v)) return 0;

   245

	if (IsFreeWagon(v)) return 4;

   246

	return 2;

   247

}

   248

   249

   250

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

   251

enum {

   252

	AMS_TTDP_HANGAR,

   253

	AMS_TTDP_TO_HANGAR,

   254

	AMS_TTDP_TO_PAD1,

   255

	AMS_TTDP_TO_PAD2,

   256

	AMS_TTDP_TO_PAD3,

   257

	AMS_TTDP_TO_ENTRY_2_AND_3,

   258

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   259

	AMS_TTDP_TO_JUNCTION,

   260

	AMS_TTDP_LEAVE_RUNWAY,

   261

	AMS_TTDP_TO_INWAY,

   262

	AMS_TTDP_TO_RUNWAY,

   263

	AMS_TTDP_TO_OUTWAY,

   264

	AMS_TTDP_WAITING,

   265

	AMS_TTDP_TAKEOFF,

   266

	AMS_TTDP_TO_TAKEOFF,

   267

	AMS_TTDP_CLIMBING,

   268

	AMS_TTDP_FLIGHT_APPROACH,

   269

	AMS_TTDP_UNUSED_0x11,

   270

	AMS_TTDP_FLIGHT_TO_TOWER,

   271

	AMS_TTDP_UNUSED_0x13,

   272

	AMS_TTDP_FLIGHT_FINAL,

   273

	AMS_TTDP_FLIGHT_DESCENT,

   274

	AMS_TTDP_BRAKING,

   275

	AMS_TTDP_HELI_TAKEOFF_AIRPORT,

   276

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,

   277

	AMS_TTDP_HELI_LAND_AIRPORT,

   278

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   279

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   280

	AMS_TTDP_HELI_LAND_HELIPORT,

   281

};

   282

   283

   284

/**

   285

 * Map OTTD aircraft movement states to TTDPatch style movement states

   286

 * (VarAction 2 Variable 0xE2)

   287

 */

   288

static byte MapAircraftMovementState(const Vehicle *v)

   289

{

   290

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

   291

	const AirportFTAClass *afc = st->Airport();

   292

	byte amdflag = afc->MovingData(v->u.air.pos)->flag;

   293

   294

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

   295

		case HANGAR:

   296

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

   297

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

   298

			 * AMED_HELI_LOWER some time before actually descending. */

   299

   300

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

   301

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

   302

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT;

   303

   304

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

   305

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

   306

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   307

   308

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

   309

			/* Has reached hanger? */

   310

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGAR;

   311

   312

			// Still moving towards hanger.

   313

			return AMS_TTDP_TO_HANGAR;

   314

   315

		case TERM1:

   316

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   317

			return AMS_TTDP_TO_JUNCTION;

   318

   319

		case TERM2:

   320

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   321

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   322

   323

		case TERM3:

   324

		case TERM4:

   325

		case TERM5:

   326

		case TERM6:

   327

		case TERM7:

   328

		case TERM8:

   329

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

   330

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   331

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   332

   333

		case HELIPAD1:

   334

		case HELIPAD2:

   335

		case HELIPAD3:

   336

		case HELIPAD4: // Will only occur for helicopters.

   337

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

   338

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

   339

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   340

   341

		case TAKEOFF: // Moving to takeoff position.

   342

			return AMS_TTDP_TO_OUTWAY;

   343

   344

		case STARTTAKEOFF: // Accelerating down runway.

   345

			return AMS_TTDP_TAKEOFF;

   346

   347

		case ENDTAKEOFF: // Ascent

   348

			return AMS_TTDP_CLIMBING;

   349

   350

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

   351

			if (afc->delta_z == 0) {

   352

				return amdflag & AMED_HELI_RAISE ?

   353

					AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;

   354

			} else {

   355

				return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   356

			}

   357

   358

		case FLYING:

   359

			return AMS_TTDP_FLIGHT_TO_TOWER;

   360

   361

		case LANDING: // Descent

   362

			return AMS_TTDP_FLIGHT_DESCENT;

   363

   364

		case ENDLANDING: // On the runway braking

   365

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   366

			// Landed - moving off runway

   367

			return AMS_TTDP_TO_INWAY;

   368

   369

		case HELILANDING:

   370

		case HELIENDLANDING: // Helicoptor is decending.

   371

			if (amdflag & AMED_HELI_LOWER) {

   372

				return afc->delta_z == 0 ?

   373

					AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;

   374

			} else {

   375

				return AMS_TTDP_FLIGHT_TO_TOWER;

   376

			}

   377

   378

		default:

   379

			return AMS_TTDP_HANGAR;

   380

	}

   381

}

   382

   383

   384

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

   385

enum {

   386

	AMA_TTDP_IN_HANGAR,

   387

	AMA_TTDP_ON_PAD1,

   388

	AMA_TTDP_ON_PAD2,

   389

	AMA_TTDP_ON_PAD3,

   390

	AMA_TTDP_HANGAR_TO_PAD1,

   391

	AMA_TTDP_HANGAR_TO_PAD2,

   392

	AMA_TTDP_HANGAR_TO_PAD3,

   393

	AMA_TTDP_LANDING_TO_PAD1,

   394

	AMA_TTDP_LANDING_TO_PAD2,

   395

	AMA_TTDP_LANDING_TO_PAD3,

   396

	AMA_TTDP_PAD1_TO_HANGAR,

   397

	AMA_TTDP_PAD2_TO_HANGAR,

   398

	AMA_TTDP_PAD3_TO_HANGAR,

   399

	AMA_TTDP_PAD1_TO_TAKEOFF,

   400

	AMA_TTDP_PAD2_TO_TAKEOFF,

   401

	AMA_TTDP_PAD3_TO_TAKEOFF,

   402

	AMA_TTDP_HANGAR_TO_TAKOFF,

   403

	AMA_TTDP_LANDING_TO_HANGAR,

   404

	AMA_TTDP_IN_FLIGHT,

   405

};

   406

   407

   408

/**

   409

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   410

 * (VarAction 2 Variable 0xE6)

   411

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

   412

 */

   413

static byte MapAircraftMovementAction(const Vehicle *v)

   414

{

   415

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

   416

		case HANGAR:

   417

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

   418

   419

		case TERM1:

   420

		case HELIPAD1:

   421

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

   422

   423

		case TERM2:

   424

		case HELIPAD2:

   425

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

   426

   427

		case TERM3:

   428

		case TERM4:

   429

		case TERM5:

   430

		case TERM6:

   431

		case TERM7:

   432

		case TERM8:

   433

		case HELIPAD3:

   434

		case HELIPAD4:

   435

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

   436

   437

		case TAKEOFF:      // Moving to takeoff position

   438

		case STARTTAKEOFF: // Accelerating down runway

   439

		case ENDTAKEOFF:   // Ascent

   440

		case HELITAKEOFF:

   441

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

   442

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   443

   444

		case FLYING:

   445

			return AMA_TTDP_IN_FLIGHT;

   446

   447

		case LANDING:    // Descent

   448

		case ENDLANDING: // On the runway braking

   449

		case HELILANDING:

   450

		case HELIENDLANDING:

   451

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

   452

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

   453

				AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;

   454

   455

		default:

   456

			return AMA_TTDP_IN_HANGAR;

   457

	}

   458

}

   459

   460

   461

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

   462

enum {

   463

	ATP_TTDP_SMALL,

   464

	ATP_TTDP_LARGE,

   465

	ATP_TTDP_HELIPORT,

   466

	ATP_TTDP_OILRIG,

   467

};

   468

   469

   470

/* Vehicle Resolver Functions */

   471

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

   472

{

   473

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

   474

}

   475

   476

   477

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   478

{

   479

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

   480

}

   481

   482

   483

static uint32 VehicleGetTriggers(const ResolverObject *object)

   484

{

   485

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

   486

}

   487

   488

   489

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

   490

{