1

/* $Id$ */

     2

     3

/** @file newgrf_engine.cpp */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "debug.h"

     9

#include "functions.h"

    10

#include "engine.h"

    11

#include "train.h"

    12

#include "player.h"

    13

#include "station.h"

    14

#include "airport.h"

    15

#include "newgrf.h"

    16

#include "newgrf_callbacks.h"

    17

#include "newgrf_engine.h"

    18

#include "newgrf_station.h"

    19

#include "newgrf_spritegroup.h"

    20

#include "newgrf_cargo.h"

    21

#include "date.h"

    22

#include "helpers.hpp"

    23

#include "cargotype.h"

    24

    25

    26

int _traininfo_vehicle_pitch = 0;

    27

int _traininfo_vehicle_width = 29;

    28

    29

struct WagonOverride {

    30

	byte *train_id;

    31

	int trains;

    32

	CargoID cargo;

    33

	const SpriteGroup *group;

    34

};

    35

    36

struct WagonOverrides {

    37

	int overrides_count;

    38

	WagonOverride *overrides;

    39

};

    40

    41

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    42

    43

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

    44

{

    45

	WagonOverrides *wos;

    46

	WagonOverride *wo;

    47

    48

	assert(engine < TOTAL_NUM_ENGINES);

    49

	assert(cargo < NUM_CARGO + 2); // Include CT_DEFAULT and CT_PURCHASE pseudo cargos.

    50

    51

	wos = &_engine_wagon_overrides[engine];

    52

	wos->overrides_count++;

    53

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

    54

    55

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

    56

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

    57

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

    58

	 * --pasky */

    59

	wo->group = group;

    60

	wo->cargo = cargo;

    61

	wo->trains = trains;

    62

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

    63

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

    64

}

    65

    66

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

    67

{

    68

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    69

    70

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

    71

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

    72

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

    73

	 * that. --pasky */

    74

    75

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

    76

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

    77

    78

		if (wo->cargo != cargo && wo->cargo != CT_DEFAULT) continue;

    79

    80

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

    81

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

    82

		}

    83

	}

    84

	return NULL;

    85

}

    86

    87

/**

    88

 * Unload all wagon override sprite groups.

    89

 */

    90

void UnloadWagonOverrides()

    91

{

    92

	WagonOverrides *wos;

    93

	WagonOverride *wo;

    94

	EngineID engine;

    95

	int i;

    96

    97

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

    98

		wos = &_engine_wagon_overrides[engine];

    99

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

   100

			wo = &wos->overrides[i];

   101

			wo->group = NULL;

   102

			free(wo->train_id);

   103

		}

   104

		free(wos->overrides);

   105

		wos->overrides_count = 0;

   106

		wos->overrides = NULL;

   107

	}

   108

}

   109

   110

/* Space for NUM_CARGO real cargos and 2 pseudo cargos, CT_DEFAULT and CT_PURCHASE */

   111

static const SpriteGroup *_engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_CARGO + 2];

   112

static const GRFFile *_engine_grf[TOTAL_NUM_ENGINES];

   113

   114

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

   115

{

   116

	assert(engine < lengthof(_engine_custom_sprites));

   117

	assert(cargo < lengthof(*_engine_custom_sprites));

   118

   119

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

   120

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

   121

	}

   122

	_engine_custom_sprites[engine][cargo] = group;

   123

}

   124

   125

/**

   126

 * Unload all engine sprite groups.

   127

 */

   128

void UnloadCustomEngineSprites()

   129

{

   130

	memset(_engine_custom_sprites, 0, sizeof(_engine_custom_sprites));

   131

	memset(_engine_grf, 0, sizeof(_engine_grf));

   132

}

   133

   134

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   135

   136

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

   137

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   138

{

   139

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   140

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   141

   142

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

   143

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

   144

	}

   145

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   146

}

   147

   148

/** Unload all rotor override sprite groups */

   149

void UnloadRotorOverrideSprites()

   150

{

   151

	EngineID engine;

   152

   153

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

   154

	 * the context of EngineID is correct */

   155

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

   156

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   157

	}

   158

}

   159

   160

   161

/**

   162

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

   163

 * etc during a game.

   164

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

   165

 * @param file   Pointer of GRFFile to tie.

   166

 */

   167

void SetEngineGRF(EngineID engine, const GRFFile *file)

   168

{

   169

	assert(engine < TOTAL_NUM_ENGINES);

   170

	_engine_grf[engine] = file;

   171

}

   172

   173

   174

/**

   175

 * Retrieve the GRFFile tied to an engine

   176

 * @param engine Engine ID to retrieve.

   177

 * @return Pointer to GRFFile.

   178

 */

   179

const GRFFile *GetEngineGRF(EngineID engine)

   180

{

   181

	assert(engine < TOTAL_NUM_ENGINES);

   182

	return _engine_grf[engine];

   183

}

   184

   185

   186

/**

   187

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

   188

 * @param engine Engine ID to retrieve.

   189

 * @return 32 bit GRFID value.

   190

 */

   191

uint32 GetEngineGRFID(EngineID engine)

   192

{

   193

	assert(engine < TOTAL_NUM_ENGINES);

   194

	return _engine_grf[engine]->grfid;

   195

}

   196

   197

   198

static int MapOldSubType(const Vehicle *v)

   199

{

   200

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

   201

	if (IsTrainEngine(v)) return 0;

   202

	if (IsFreeWagon(v)) return 4;

   203

	return 2;

   204

}

   205

   206

   207

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

   208

enum {

   209

	AMS_TTDP_HANGAR,

   210

	AMS_TTDP_TO_HANGAR,

   211

	AMS_TTDP_TO_PAD1,

   212

	AMS_TTDP_TO_PAD2,

   213

	AMS_TTDP_TO_PAD3,

   214

	AMS_TTDP_TO_ENTRY_2_AND_3,

   215

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   216

	AMS_TTDP_TO_JUNCTION,

   217

	AMS_TTDP_LEAVE_RUNWAY,

   218

	AMS_TTDP_TO_INWAY,

   219

	AMS_TTDP_TO_RUNWAY,

   220

	AMS_TTDP_TO_OUTWAY,

   221

	AMS_TTDP_WAITING,

   222

	AMS_TTDP_TAKEOFF,

   223

	AMS_TTDP_TO_TAKEOFF,

   224

	AMS_TTDP_CLIMBING,

   225

	AMS_TTDP_FLIGHT_APPROACH,

   226

	AMS_TTDP_UNUSED_0x11,

   227

	AMS_TTDP_FLIGHT_TO_TOWER,

   228

	AMS_TTDP_UNUSED_0x13,

   229

	AMS_TTDP_FLIGHT_FINAL,

   230

	AMS_TTDP_FLIGHT_DESCENT,

   231

	AMS_TTDP_BRAKING,

   232

	AMS_TTDP_HELI_TAKEOFF_AIRPORT,

   233

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,

   234

	AMS_TTDP_HELI_LAND_AIRPORT,

   235

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   236

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   237

	AMS_TTDP_HELI_LAND_HELIPORT,

   238

};

   239

   240

   241

/**

   242

 * Map OTTD aircraft movement states to TTDPatch style movement states

   243

 * (VarAction 2 Variable 0xE2)

   244

 */

   245

static byte MapAircraftMovementState(const Vehicle *v)

   246

{

   247

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

   250

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

   251

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

   252

   253

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

   254

		case HANGAR:

   255

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

   256

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

   257

			 * AMED_HELI_LOWER some time before actually descending. */

   258

   259

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

   260

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

   261

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT;

   262

   263

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

   264

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

   265

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   266

   267

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

   268

			 * Has reached hanger? */

   269

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGAR;

   270

   271

			/* Still moving towards hanger. */

   272

			return AMS_TTDP_TO_HANGAR;

   273

   274

		case TERM1:

   275

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   276

			return AMS_TTDP_TO_JUNCTION;

   277

   278

		case TERM2:

   279

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   280

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   281

   282

		case TERM3:

   283

		case TERM4:

   284

		case TERM5:

   285

		case TERM6:

   286

		case TERM7:

   287

		case TERM8:

   288

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

   289

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   290

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   291

   292

		case HELIPAD1:

   293

		case HELIPAD2:

   294

		case HELIPAD3:

   295

		case HELIPAD4: // Will only occur for helicopters.

   296

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

   297

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

   298

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   299

   300

		case TAKEOFF: // Moving to takeoff position.

   301

			return AMS_TTDP_TO_OUTWAY;

   302

   303

		case STARTTAKEOFF: // Accelerating down runway.

   304

			return AMS_TTDP_TAKEOFF;

   305

   306

		case ENDTAKEOFF: // Ascent

   307

			return AMS_TTDP_CLIMBING;

   308

   309

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

   310

			if (afc->delta_z == 0) {

   311

				return amdflag & AMED_HELI_RAISE ?

   312

					AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;

   313

			} else {

   314

				return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   315

			}

   316

   317

		case FLYING:

   318

			return amdflag & AMED_HOLD ? AMS_TTDP_FLIGHT_APPROACH : AMS_TTDP_FLIGHT_TO_TOWER;

   319

   320

		case LANDING: // Descent

   321

			return AMS_TTDP_FLIGHT_DESCENT;

   322

   323

		case ENDLANDING: // On the runway braking

   324

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   325

			/* Landed - moving off runway */

   326

			return AMS_TTDP_TO_INWAY;

   327

   328

		case HELILANDING:

   329

		case HELIENDLANDING: // Helicoptor is decending.

   330

			if (amdflag & AMED_HELI_LOWER) {

   331

				return afc->delta_z == 0 ?

   332

					AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;

   333

			} else {

   334

				return AMS_TTDP_FLIGHT_TO_TOWER;

   335

			}

   336

   337

		default:

   338

			return AMS_TTDP_HANGAR;

   339

	}

   340

}

   341

   342

   343

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

   344

enum {

   345

	AMA_TTDP_IN_HANGAR,

   346

	AMA_TTDP_ON_PAD1,

   347

	AMA_TTDP_ON_PAD2,

   348

	AMA_TTDP_ON_PAD3,

   349

	AMA_TTDP_HANGAR_TO_PAD1,

   350

	AMA_TTDP_HANGAR_TO_PAD2,

   351

	AMA_TTDP_HANGAR_TO_PAD3,

   352

	AMA_TTDP_LANDING_TO_PAD1,

   353

	AMA_TTDP_LANDING_TO_PAD2,

   354

	AMA_TTDP_LANDING_TO_PAD3,

   355

	AMA_TTDP_PAD1_TO_HANGAR,

   356

	AMA_TTDP_PAD2_TO_HANGAR,

   357

	AMA_TTDP_PAD3_TO_HANGAR,

   358

	AMA_TTDP_PAD1_TO_TAKEOFF,

   359

	AMA_TTDP_PAD2_TO_TAKEOFF,

   360

	AMA_TTDP_PAD3_TO_TAKEOFF,

   361

	AMA_TTDP_HANGAR_TO_TAKOFF,

   362

	AMA_TTDP_LANDING_TO_HANGAR,

   363

	AMA_TTDP_IN_FLIGHT,

   364

};

   365

   366

   367

/**

   368

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   369

 * (VarAction 2 Variable 0xE6)

   370

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

   371

 */

   372

static byte MapAircraftMovementAction(const Vehicle *v)

   373

{

   374

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

   375

		case HANGAR:

   376

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

   377

   378

		case TERM1:

   379

		case HELIPAD1:

   380

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

   381

   382

		case TERM2:

   383

		case HELIPAD2:

   384

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

   385

   386

		case TERM3:

   387

		case TERM4:

   388

		case TERM5:

   389

		case TERM6:

   390

		case TERM7:

   391

		case TERM8:

   392

		case HELIPAD3:

   393

		case HELIPAD4:

   394

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

   395

   396

		case TAKEOFF:      // Moving to takeoff position

   397

		case STARTTAKEOFF: // Accelerating down runway

   398

		case ENDTAKEOFF:   // Ascent

   399

		case HELITAKEOFF:

   400

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

   401

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   402

   403

		case FLYING:

   404

			return AMA_TTDP_IN_FLIGHT;

   405

   406

		case LANDING:    // Descent

   407

		case ENDLANDING: // On the runway braking

   408

		case HELILANDING:

   409

		case HELIENDLANDING:

   410

			/* @todo Need to check terminal we're landing to. Is it known yet? */

   411

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

   412

				AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;

   413

   414

		default:

   415

			return AMA_TTDP_IN_HANGAR;

   416

	}

   417

}

   418

   419

   420

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

   421

enum {

   422

	ATP_TTDP_SMALL,

   423

	ATP_TTDP_LARGE,

   424

	ATP_TTDP_HELIPORT,

   425

	ATP_TTDP_OILRIG,

   426

};

   427

   428

   429

/* Vehicle Resolver Functions */

   430

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

   431

{

   432

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

   433

}

   434

   435

   436

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   437

{

   438

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

   439

}

   440

   441

   442

static uint32 VehicleGetTriggers(const ResolverObject *object)

   443

{

   444

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

   445

}

   446

   447

   448

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

   449

{

   450

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

   451

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

   452

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

   453

	 */

   454

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

   455

   456

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

   457

	 * other time is an error. */

   458

	assert(object->trigger != 0);

   459

   460

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

   461

}

   462

   463

   464

static uint32 GetGRFParameter(EngineID engine_type, byte parameter)

   465

{

   466

	const GRFFile *file = GetEngineGRF(engine_type);

   467

   468

	if (parameter >= file->param_end) return 0;

   469

	return file->param[parameter];

   470

}

   471

   472

   473

static uint8 LiveryHelper(EngineID engine, const Vehicle *v)

   474

{

   475

	const Livery *l;

   476

   477

	if (v == NULL) {

   478

		l = GetEngineLivery(engine, _current_player, INVALID_ENGINE, NULL);

   479

	} else if (v->type == VEH_TRAIN) {

   480

		l = GetEngineLivery((v->u.rail.first_engine != INVALID_ENGINE && (IsArticulatedPart(v) || UsesWagonOverride(v))) ? v->u.rail.first_engine : v->engine_type, v->owner, v->u.rail.first_engine, v);

   481

	} else {

   482

		l = GetEngineLivery(v->engine_type, v->owner, INVALID_ENGINE, v);

   483

	}

   484

   485

	return l->colour1 + l->colour2 * 16;

   486

}

   487

   488