1

/* $Id$ */

     2

     3

/** @file newgrf_engine.cpp NewGRF handling of engines. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "debug.h"

     9

#include "engine_func.h"

    10

#include "engine_base.h"

    11

#include "train.h"

    12

#include "player_func.h"

    13

#include "player_base.h"

    14

#include "station_base.h"

    15

#include "airport.h"

    16

#include "newgrf.h"

    17

#include "newgrf_callbacks.h"

    18

#include "newgrf_engine.h"

    19

#include "newgrf_station.h"

    20

#include "newgrf_spritegroup.h"

    21

#include "newgrf_cargo.h"

    22

#include "cargotype.h"

    23

#include "date_func.h"

    24

#include "vehicle_func.h"

    25

#include "core/random_func.hpp"

    26

#include "direction_func.h"

    27

#include "rail_map.h"

    28

#include "rail.h"

    29

#include "settings_type.h"

    30

#include <map>

    31

    32

    33

int _traininfo_vehicle_pitch = 0;

    34

int _traininfo_vehicle_width = 29;

    35

    36

struct WagonOverride {

    37

	EngineID *train_id;

    38

	uint trains;

    39

	CargoID cargo;

    40

	const SpriteGroup *group;

    41

};

    42

    43

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

    44

{

    45

	Engine *e = GetEngine(engine);

    46

	WagonOverride *wo;

    47

    48

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

    49

    50

	e->overrides_count++;

    51

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

    52

    53

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

    54

	wo->group = group;

    55

	wo->cargo = cargo;

    56

	wo->trains = trains;

    57

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

    58

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

    59

}

    60

    61

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

    62

{

    63

	const Engine *e = GetEngine(engine);

    64

    65

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

    66

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

    67

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

    68

	 * that. --pasky */

    69

    70

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

    71

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

    72

    73

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

    74

    75

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

    76

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

    77

		}

    78

	}

    79

	return NULL;

    80

}

    81

    82

/**

    83

 * Unload all wagon override sprite groups.

    84

 */

    85

void UnloadWagonOverrides(Engine *e)

    86

{

    87

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

    88

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

    89

		free(wo->train_id);

    90

	}

    91

	free(e->overrides);

    92

	e->overrides_count = 0;

    93

	e->overrides = NULL;

    94

}

    95

    96

    97

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

    98

{

    99

	Engine *e = GetEngine(engine);

   100

	assert(cargo < lengthof(e->group));

   101

   102

	if (e->group[cargo] != NULL) {

   103

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

   104

	}

   105

	e->group[cargo] = group;

   106

}

   107

   108

   109

/**

   110

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

   111

 * etc during a game.

   112

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

   113

 * @param file   Pointer of GRFFile to tie.

   114

 */

   115

void SetEngineGRF(EngineID engine, const GRFFile *file)

   116

{

   117

	Engine *e = GetEngine(engine);

   118

	e->grffile = file;

   119

}

   120

   121

   122

/**

   123

 * Retrieve the GRFFile tied to an engine

   124

 * @param engine Engine ID to retrieve.

   125

 * @return Pointer to GRFFile.

   126

 */

   127

const GRFFile *GetEngineGRF(EngineID engine)

   128

{

   129

	return GetEngine(engine)->grffile;

   130

}

   131

   132

   133

/**

   134

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

   135

 * @param engine Engine ID to retrieve.

   136

 * @return 32 bit GRFID value.

   137

 */

   138

uint32 GetEngineGRFID(EngineID engine)

   139

{

   140

	return GetEngineGRF(engine)->grfid;

   141

}

   142

   143

   144

static int MapOldSubType(const Vehicle *v)

   145

{

   146

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

   147

	if (IsTrainEngine(v)) return 0;

   148

	if (IsFreeWagon(v)) return 4;

   149

	return 2;

   150

}

   151

   152

   153

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

   154

enum {

   155

	AMS_TTDP_HANGAR,

   156

	AMS_TTDP_TO_HANGAR,

   157

	AMS_TTDP_TO_PAD1,

   158

	AMS_TTDP_TO_PAD2,

   159

	AMS_TTDP_TO_PAD3,

   160

	AMS_TTDP_TO_ENTRY_2_AND_3,

   161

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   162

	AMS_TTDP_TO_JUNCTION,

   163

	AMS_TTDP_LEAVE_RUNWAY,

   164

	AMS_TTDP_TO_INWAY,

   165

	AMS_TTDP_TO_RUNWAY,

   166

	AMS_TTDP_TO_OUTWAY,

   167

	AMS_TTDP_WAITING,

   168

	AMS_TTDP_TAKEOFF,

   169

	AMS_TTDP_TO_TAKEOFF,

   170

	AMS_TTDP_CLIMBING,

   171

	AMS_TTDP_FLIGHT_APPROACH,

   172

	AMS_TTDP_UNUSED_0x11,

   173

	AMS_TTDP_FLIGHT_TO_TOWER,

   174

	AMS_TTDP_UNUSED_0x13,

   175

	AMS_TTDP_FLIGHT_FINAL,

   176

	AMS_TTDP_FLIGHT_DESCENT,

   177

	AMS_TTDP_BRAKING,

   178

	AMS_TTDP_HELI_TAKEOFF_AIRPORT,

   179

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,

   180

	AMS_TTDP_HELI_LAND_AIRPORT,

   181

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   182

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   183

	AMS_TTDP_HELI_LAND_HELIPORT,

   184

};

   185

   186

   187

/**

   188

 * Map OTTD aircraft movement states to TTDPatch style movement states

   189

 * (VarAction 2 Variable 0xE2)

   190

 */

   191

static byte MapAircraftMovementState(const Vehicle *v)

   192

{

   193

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

   194

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

   195

   196

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

   197

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

   198

   199

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

   200

		case HANGAR:

   201

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

   202

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

   203

			 * AMED_HELI_LOWER some time before actually descending. */

   204

   205

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

   206

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

   207

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT;

   208

   209

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

   210

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

   211

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   212

   213

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

   214

			 * Has reached hanger? */

   215

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGAR;

   216

   217

			/* Still moving towards hanger. */

   218

			return AMS_TTDP_TO_HANGAR;

   219

   220

		case FIRST_TERMINAL: // TERM 1

   221

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   222

			return AMS_TTDP_TO_JUNCTION;

   223

   224

		case FIRST_TERMINAL + 1: // TERM 2

   225

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   226

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   227

   228

		case TAKEOFF: // Moving to takeoff position.

   229

			return AMS_TTDP_TO_OUTWAY;

   230

   231

		case STARTTAKEOFF: // Accelerating down runway.

   232

			return AMS_TTDP_TAKEOFF;

   233

   234

		case ENDTAKEOFF: // Ascent

   235

			return AMS_TTDP_CLIMBING;

   236

   237

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

   238

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

   239

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

   240

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

   241

				return amdflag & AMED_HELI_RAISE ?

   242

					AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;

   243

			} else {

   244

				return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   245

			}

   246

   247

		case FLYING:

   248

			return amdflag & AMED_HOLD ? AMS_TTDP_FLIGHT_APPROACH : AMS_TTDP_FLIGHT_TO_TOWER;

   249

   250

		case LANDING: // Descent

   251

			return AMS_TTDP_FLIGHT_DESCENT;

   252

   253

		case ENDLANDING: // On the runway braking

   254

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   255

			/* Landed - moving off runway */

   256

			return AMS_TTDP_TO_INWAY;

   257

   258

		case HELILANDING:

   259

		case HELIENDLANDING: // Helicoptor is decending.

   260

			if (amdflag & AMED_HELI_LOWER) {

   261

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

   262

				//return afc->delta_z == 0 ?

   263

				//	AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;

   264

				return AMS_TTDP_HELI_LAND_AIRPORT;

   265

			} else {

   266

				return AMS_TTDP_FLIGHT_TO_TOWER;

   267

			}

   268

   269

		default:

   270

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

   271

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

   272

				return (amdflag & AMED_EXACTPOS) ? AMS_TTDP_TO_PAD3 : AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   273

			}

   274

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

   275

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

   276

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

   277

				return AMS_TTDP_TO_JUNCTION; // On the ground.

   278

			}

   279

   280

			return AMS_TTDP_HANGAR;

   281

	}

   282

}

   283

   284

   285

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

   286

enum {

   287

	AMA_TTDP_IN_HANGAR,

   288

	AMA_TTDP_ON_PAD1,

   289

	AMA_TTDP_ON_PAD2,

   290

	AMA_TTDP_ON_PAD3,

   291

	AMA_TTDP_HANGAR_TO_PAD1,

   292

	AMA_TTDP_HANGAR_TO_PAD2,

   293

	AMA_TTDP_HANGAR_TO_PAD3,

   294

	AMA_TTDP_LANDING_TO_PAD1,

   295

	AMA_TTDP_LANDING_TO_PAD2,

   296

	AMA_TTDP_LANDING_TO_PAD3,

   297

	AMA_TTDP_PAD1_TO_HANGAR,

   298

	AMA_TTDP_PAD2_TO_HANGAR,

   299

	AMA_TTDP_PAD3_TO_HANGAR,

   300

	AMA_TTDP_PAD1_TO_TAKEOFF,

   301

	AMA_TTDP_PAD2_TO_TAKEOFF,

   302

	AMA_TTDP_PAD3_TO_TAKEOFF,

   303

	AMA_TTDP_HANGAR_TO_TAKOFF,

   304

	AMA_TTDP_LANDING_TO_HANGAR,

   305

	AMA_TTDP_IN_FLIGHT,

   306

};

   307

   308

   309

/**

   310

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   311

 * (VarAction 2 Variable 0xE6)

   312

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

   313

 */

   314

static byte MapAircraftMovementAction(const Vehicle *v)

   315

{

   316

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

   317

		case HANGAR:

   318

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

   319

   320

		case FIRST_TERMINAL:

   321

		case FIRST_HELIPAD:

   322

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

   323

   324

		case FIRST_TERMINAL + 1:

   325

		case FIRST_HELIPAD + 1:

   326

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

   327

   328

		case TAKEOFF:      // Moving to takeoff position

   329

		case STARTTAKEOFF: // Accelerating down runway

   330

		case ENDTAKEOFF:   // Ascent

   331

		case HELITAKEOFF:

   332

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

   333

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   334

   335

		case FLYING:

   336

			return AMA_TTDP_IN_FLIGHT;

   337

   338

		case LANDING:    // Descent

   339

		case ENDLANDING: // On the runway braking

   340

		case HELILANDING:

   341

		case HELIENDLANDING:

   342

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

   343

			return (v->current_order.IsType(OT_GOTO_DEPOT)) ?

   344

				AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;

   345

   346

		default:

   347

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

   348

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

   349

			}

   350

   351

			return AMA_TTDP_IN_HANGAR;

   352

	}

   353

}

   354

   355

   356

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

   357

enum {

   358

	ATP_TTDP_SMALL,

   359

	ATP_TTDP_LARGE,

   360

	ATP_TTDP_HELIPORT,

   361

	ATP_TTDP_OILRIG,

   362

};

   363

   364

   365

/* Vehicle Resolver Functions */

   366

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

   367

{

   368

	switch (object->scope) {

   369

		default: NOT_REACHED();

   370

		case VSG_SCOPE_SELF: return object->u.vehicle.self;

   371

		case VSG_SCOPE_PARENT: return object->u.vehicle.parent;

   372

		case VSG_SCOPE_RELATIVE: {

   373

			const Vehicle *v = NULL;

   374

			switch (GB(object->count, 6, 2)) {

   375

				default: NOT_REACHED();

   376

				case 0x00: // count back (away from the engine), starting at this vehicle

   377

				case 0x01: // count forward (toward the engine), starting at this vehicle

   378

					v = object->u.vehicle.self;

   379

					break;

   380

				case 0x02: // count back, starting at the engine

   381

					v = object->u.vehicle.parent;

   382

					break;

   383

				case 0x03: { // count back, starting at the first vehicle in this chain of vehicles with the same ID, as for vehicle variable 41

   384

					const Vehicle *self = object->u.vehicle.self;

   385

					for (const Vehicle *u = self->First(); u != self; u = u->Next()) {

   386

						if (u->engine_type != self->engine_type) {

   387

							v = NULL;

   388

						} else {

   389

							if (v == NULL) v = u;

   390

						}

   391

					}

   392

					if (v == NULL) v = self;

   393

				} break;

   394

			}

   395

			uint32 count = GB(object->count, 0, 4);

   396

			if (count == 0) count = GetRegister(0x100);

   397

			while (v != NULL && count-- != 0) v = (GB(object->count, 6, 2) == 0x01) ? v->Previous() : v->Next();

   398

			return v;

   399

		}

   400

	}

   401

}

   402

   403

   404

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   405

{

   406

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

   407

}

   408

   409

   410

static uint32 VehicleGetTriggers(const ResolverObject *object)

   411

{

   412

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

   413

}

   414

   415

   416

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

   417

{

   418

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

   419

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

   420

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

   421

	 */

   422

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

   423

   424

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

   425

	 * other time is an error. */

   426

	assert(object->trigger != 0);

   427

   428

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

   429

}

   430

   431

   432

static uint32 GetGRFParameter(EngineID engine_type, byte parameter)

   433

{

   434

	const GRFFile *file = GetEngineGRF(engine_type);

   435

   436

	if (file == NULL) return 0;

   437

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

   438

	return file->param[parameter];

   439

}

   440

   441

   442

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

   443

{

   444

	const Livery *l;

   445

   446

	if (v == NULL) {

   447

		if (!IsValidPlayer(_current_player)) return 0;

   448

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

   449

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

   450

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

   451

	} else {

   452

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

   453

	}

   454

   455

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

   456

}

   457

   458

   459

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

   460

{

   461

	const Vehicle *v = GRV(object);

   462

   463

	if (v == NULL) {

   464

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

   465

		switch (variable) {

   466

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

   467

			case 0x46: return 0;               // Motion counter

   468

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

   469

			case 0x49: return _cur_year; // 'Long' format build year

   470

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

   471

			case 0xDA: return INVALID_VEHICLE; // Next vehicle

   472

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

   473

		}

   474

   475

		*available = false;

   476

		return UINT_MAX;

   477

	}

   478

   479

	/* Calculated vehicle parameters */

   480

	switch (variable) {

   481

		case 0x40: // Get length of consist

   482

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

   483

			{

   484

				const Vehicle* u;

   485

				byte chain_before = 0;

   486

				byte chain_after  = 0;

   487