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

    10

#include "train.h"

    11

#include "player_func.h"

    12

#include "player_base.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 "cargotype.h"

    22

#include "date_func.h"

    23

#include "vehicle_func.h"

    24

#include "core/random_func.hpp"

    25

#include "direction_func.h"

    28

    29

    30

int _traininfo_vehicle_pitch = 0;

    31

int _traininfo_vehicle_width = 29;

    32

    33

struct WagonOverride {

    34

	EngineID *train_id;

    35

	uint trains;

    36

	CargoID cargo;

    37

	const SpriteGroup *group;

    38

};

    39

    40

struct WagonOverrides {

    41

	uint overrides_count;

    42

	WagonOverride *overrides;

    43

};

    44

    45

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    46

    47

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

    48

{

    49

	WagonOverrides *wos;

    50

	WagonOverride *wo;

    51

    52

	assert(engine < TOTAL_NUM_ENGINES);

    53

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

    54

    55

	wos = &_engine_wagon_overrides[engine];

    56

	wos->overrides_count++;

    57

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

    58

    59

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

    60

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

    61

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

    62

	 * --pasky */

    63

	wo->group = group;

    64

	wo->cargo = cargo;

    65

	wo->trains = trains;

    66

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

    67

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

    68

}

    69

    70

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

    71

{

    72

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    73

    74

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

    75

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

    76

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

    77

	 * that. --pasky */

    78

    79

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

    80

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

    81

    82

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

    83

    84

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

    85

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

    86

		}

    87

	}

    88

	return NULL;

    89

}

    90

    91

/**

    92

 * Unload all wagon override sprite groups.

    93

 */

    94

void UnloadWagonOverrides()

    95

{

    96

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

    97

		WagonOverrides *wos = &_engine_wagon_overrides[engine];

    98

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

    99

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

   100

			free(wo->train_id);

   101

		}

   102

		free(wos->overrides);

   103

		wos->overrides_count = 0;

   104

		wos->overrides = NULL;

   105

	}

   106

}

   107

   108

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

   109

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

   110

static const GRFFile *_engine_grf[TOTAL_NUM_ENGINES];

   111

   112

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

   113

{

   114

	assert(engine < lengthof(_engine_custom_sprites));

   115

	assert(cargo < lengthof(*_engine_custom_sprites));

   116

   117

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

   118

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

   119

	}

   120

	_engine_custom_sprites[engine][cargo] = group;

   121

}

   122

   123

/**

   124

 * Unload all engine sprite groups.

   125

 */

   126

void UnloadCustomEngineSprites()

   127

{

   128

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

   129

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

   130

}

   131

   132

/**

   133

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

   134

 * etc during a game.

   135

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

   136

 * @param file   Pointer of GRFFile to tie.

   137

 */

   138

void SetEngineGRF(EngineID engine, const GRFFile *file)

   139

{

   140

	assert(engine < TOTAL_NUM_ENGINES);

   141

	_engine_grf[engine] = file;

   142

}

   143

   144

   145

/**

   146

 * Retrieve the GRFFile tied to an engine

   147

 * @param engine Engine ID to retrieve.

   148

 * @return Pointer to GRFFile.

   149

 */

   150

const GRFFile *GetEngineGRF(EngineID engine)

   151

{

   152

	assert(engine < TOTAL_NUM_ENGINES);

   153

	return _engine_grf[engine];

   154

}

   155

   156

   157

/**

   158

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

   159

 * @param engine Engine ID to retrieve.

   160

 * @return 32 bit GRFID value.

   161

 */

   162

uint32 GetEngineGRFID(EngineID engine)

   163

{

   164

	assert(engine < TOTAL_NUM_ENGINES);

   165

	return _engine_grf[engine]->grfid;

   166

}

   167

   168

   169

static int MapOldSubType(const Vehicle *v)

   170

{

   171

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

   172

	if (IsTrainEngine(v)) return 0;

   173

	if (IsFreeWagon(v)) return 4;

   174

	return 2;

   175

}

   176

   177

   178

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

   179

enum {

   180

	AMS_TTDP_HANGAR,

   181

	AMS_TTDP_TO_HANGAR,

   182

	AMS_TTDP_TO_PAD1,

   183

	AMS_TTDP_TO_PAD2,

   184

	AMS_TTDP_TO_PAD3,

   185

	AMS_TTDP_TO_ENTRY_2_AND_3,

   186

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   187

	AMS_TTDP_TO_JUNCTION,

   188

	AMS_TTDP_LEAVE_RUNWAY,

   189

	AMS_TTDP_TO_INWAY,

   190

	AMS_TTDP_TO_RUNWAY,

   191

	AMS_TTDP_TO_OUTWAY,

   192

	AMS_TTDP_WAITING,

   193

	AMS_TTDP_TAKEOFF,

   194

	AMS_TTDP_TO_TAKEOFF,

   195

	AMS_TTDP_CLIMBING,

   196

	AMS_TTDP_FLIGHT_APPROACH,

   197

	AMS_TTDP_UNUSED_0x11,

   198

	AMS_TTDP_FLIGHT_TO_TOWER,

   199

	AMS_TTDP_UNUSED_0x13,

   200

	AMS_TTDP_FLIGHT_FINAL,

   201

	AMS_TTDP_FLIGHT_DESCENT,

   202

	AMS_TTDP_BRAKING,

   203

	AMS_TTDP_HELI_TAKEOFF_AIRPORT,

   204

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,

   205

	AMS_TTDP_HELI_LAND_AIRPORT,

   206

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   207

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   208

	AMS_TTDP_HELI_LAND_HELIPORT,

   209

};

   210

   211

   212

/**

   213

 * Map OTTD aircraft movement states to TTDPatch style movement states

   214

 * (VarAction 2 Variable 0xE2)

   215

 */

   216

static byte MapAircraftMovementState(const Vehicle *v)

   217

{

   218

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

   219

	if (st->airport_tile == 0) return AMS_TTDP_FLIGHT_TO_TOWER;

   220

   221

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

   222

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

   223

   224

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

   225

		case HANGAR:

   226

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

   227

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

   228

			 * AMED_HELI_LOWER some time before actually descending. */

   229

   230

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

   231

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

   232

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT;

   233

   234

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

   235

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

   236

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   237

   238

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

   239

			 * Has reached hanger? */

   240

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGAR;

   241

   242

			/* Still moving towards hanger. */

   243

			return AMS_TTDP_TO_HANGAR;

   244

   245

		case FIRST_TERMINAL: // TERM 1

   246

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   247

			return AMS_TTDP_TO_JUNCTION;

   248

   249

		case FIRST_TERMINAL + 1: // TERM 2

   250

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   251

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   252

   253

		case TAKEOFF: // Moving to takeoff position.

   254

			return AMS_TTDP_TO_OUTWAY;

   255

   256

		case STARTTAKEOFF: // Accelerating down runway.

   257

			return AMS_TTDP_TAKEOFF;

   258

   259

		case ENDTAKEOFF: // Ascent

   260

			return AMS_TTDP_CLIMBING;

   261

   262

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

   263

			//TODO: airport->delta_z no longer used. need to get actual height of individual tile in layout

   264

			//TODO: AMED_HELI_RAISE no longer used. decide based on height differences from v->zpos to target layout height

   265

			if (afc->MovingData(v->u.air.pos)->z == 0) {

   266

				return amdflag & AMED_HELI_RAISE ?

   267

					AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;

   268

			} else {

   269

				return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   270

			}

   271

   272

		case FLYING:

   273

			return amdflag & AMED_HOLD ? AMS_TTDP_FLIGHT_APPROACH : AMS_TTDP_FLIGHT_TO_TOWER;

   274

   275

		case LANDING: // Descent

   276

			return AMS_TTDP_FLIGHT_DESCENT;

   277

   278

		case ENDLANDING: // On the runway braking

   279

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   280

			/* Landed - moving off runway */

   281

			return AMS_TTDP_TO_INWAY;

   282

   283

		case HELILANDING:

   284

		case HELIENDLANDING: // Helicoptor is decending.

   285

			if (amdflag & AMED_HELI_LOWER) {

   286

				//TODO: airport->delta_z no longer used. need to get actual height of individual tile in layout

   287

				//return afc->delta_z == 0 ?

   288

				//	AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;

   289

				return AMS_TTDP_HELI_LAND_AIRPORT;

   290

			} else {

   291

				return AMS_TTDP_FLIGHT_TO_TOWER;

   292

			}

   293

   294

		default:

   295

			if (FIRST_TERMINAL <= v->u.air.state && v->u.air.state <= LAST_TERMINAL) {

   296

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

   297

				return (amdflag & AMED_EXACTPOS) ? AMS_TTDP_TO_PAD3 : AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   298

			}

   299

			if (FIRST_HELIPAD <= v->u.air.state && v->u.air.state <= LAST_HELIPAD) {

   300

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

   301

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

   302

				return AMS_TTDP_TO_JUNCTION; // On the ground.

   303

			}

   304

   305

			return AMS_TTDP_HANGAR;

   306

	}

   307

}

   308

   309

   310

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

   311

enum {

   312

	AMA_TTDP_IN_HANGAR,

   313

	AMA_TTDP_ON_PAD1,

   314

	AMA_TTDP_ON_PAD2,

   315

	AMA_TTDP_ON_PAD3,

   316

	AMA_TTDP_HANGAR_TO_PAD1,

   317

	AMA_TTDP_HANGAR_TO_PAD2,

   318

	AMA_TTDP_HANGAR_TO_PAD3,

   319

	AMA_TTDP_LANDING_TO_PAD1,

   320

	AMA_TTDP_LANDING_TO_PAD2,

   321

	AMA_TTDP_LANDING_TO_PAD3,

   322

	AMA_TTDP_PAD1_TO_HANGAR,

   323

	AMA_TTDP_PAD2_TO_HANGAR,

   324

	AMA_TTDP_PAD3_TO_HANGAR,

   325

	AMA_TTDP_PAD1_TO_TAKEOFF,

   326

	AMA_TTDP_PAD2_TO_TAKEOFF,

   327

	AMA_TTDP_PAD3_TO_TAKEOFF,

   328

	AMA_TTDP_HANGAR_TO_TAKOFF,

   329

	AMA_TTDP_LANDING_TO_HANGAR,

   330

	AMA_TTDP_IN_FLIGHT,

   331

};

   332

   333

   334

/**

   335

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   336

 * (VarAction 2 Variable 0xE6)

   337

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

   338

 */

   339

static byte MapAircraftMovementAction(const Vehicle *v)

   340

{

   341

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

   342

		case HANGAR:

   343

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

   344

   345

		case FIRST_TERMINAL:

   346

		case FIRST_HELIPAD:

   347

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

   348

   349

		case FIRST_TERMINAL + 1:

   350

		case FIRST_HELIPAD + 1:

   351

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

   352

   353

		case TAKEOFF:      // Moving to takeoff position

   354

		case STARTTAKEOFF: // Accelerating down runway

   355

		case ENDTAKEOFF:   // Ascent

   356

		case HELITAKEOFF:

   357

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

   358

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   359

   360

		case FLYING:

   361

			return AMA_TTDP_IN_FLIGHT;

   362

   363

		case LANDING:    // Descent

   364

		case ENDLANDING: // On the runway braking

   365

		case HELILANDING:

   366

		case HELIENDLANDING:

   367

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

   368

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

   369

				AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;

   370

   371

		default:

   372

			if (FIRST_TERMINAL <= v->u.air.state && v->u.air.state <= LAST_HELIPAD) {

   373

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

   374

			}

   375

   376

			return AMA_TTDP_IN_HANGAR;

   377

	}

   378

}

   379

   380

   381

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

   382

enum {

   383

	ATP_TTDP_SMALL,

   384

	ATP_TTDP_LARGE,

   385

	ATP_TTDP_HELIPORT,

   386

	ATP_TTDP_OILRIG,

   387

};

   388

   389

   390

/* Vehicle Resolver Functions */

   391

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

   392

{

   393

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

   394

}

   395

   396

   397

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   398

{

   399

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

   400

}

   401

   402

   403

static uint32 VehicleGetTriggers(const ResolverObject *object)

   404

{

   405

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

   406

}

   407

   408

   409

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

   410

{

   411

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

   412

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

   413

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

   414

	 */

   415

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

   416

   417

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

   418

	 * other time is an error. */

   419

	assert(object->trigger != 0);

   420

   421

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

   422

}

   423

   424

   425

static uint32 GetGRFParameter(EngineID engine_type, byte parameter)

   426

{

   427

	const GRFFile *file = GetEngineGRF(engine_type);

   428

   429

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

   430

	return file->param[parameter];

   431

}

   432

   433

   434

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

   435

{

   436

	const Livery *l;

   437

   438

	if (v == NULL) {

   439

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

   440

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

   441

		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);

   442

	} else {

   443

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

   444

	}

   445

   446

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

   447

}

   448

   449

   450

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

   451

{

   452

	const Vehicle *v = GRV(object);

   453

   454

	if (v == NULL) {

   455

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

   456

		switch (variable) {

   457

			case 0x43: return _current_player | (LiveryHelper(object->u.vehicle.self_type, NULL) << 24); // Owner information

   458

			case 0x46: return 0;               // Motion counter

   459

			case 0x48: return GetEngine(object->u.vehicle.self_type)->flags; // Vehicle Type Info

   460

			case 0xC4: return Clamp(_cur_year, ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR; // Build year

   461

			case 0xDA: return INVALID_VEHICLE; // Next vehicle

   462

			case 0x7F: return GetGRFParameter(object->u.vehicle.self_type, parameter); // Read GRF parameter

   463

		}

   464

   465

		*available = false;

   466

		return UINT_MAX;

   467

	}

   468

   469

	/* Calculated vehicle parameters */

   470

	switch (variable) {

   471

		case 0x40: // Get length of consist

   472

		case 0x41: // Get length of same consecutive wagons

   473

			{

   474

				const Vehicle* u;

   475

				byte chain_before = 0;

   476

				byte chain_after  = 0;

   477

   478

				for (u = v->First(); u != v; u = u->Next()) {

   479

					chain_before++;

   480

					if (variable == 0x41 && u->engine_type != v->engine_type) chain_before = 0;

   481

				}

   482

   483

				while (u->Next() != NULL && (variable == 0x40 || u->Next()->engine_type == v->engine_type)) {

   484

					chain_after++;

   485

					u = u->Next();

   486

				}

   487