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

#include "cargotype.h"

    22

    23

    24

int _traininfo_vehicle_pitch = 0;

    25

int _traininfo_vehicle_width = 29;

    26

    27

typedef struct WagonOverride {

    28

	byte *train_id;

    29

	int trains;

    30

	CargoID cargo;

    31

	const SpriteGroup *group;

    32

} WagonOverride;

    33

    34

typedef struct WagonOverrides {

    35

	int overrides_count;

    36

	WagonOverride *overrides;

    37

} WagonOverrides;

    38

    39

static WagonOverrides _engine_wagon_overrides[TOTAL_NUM_ENGINES];

    40

    41

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

    42

{

    43

	WagonOverrides *wos;

    44

	WagonOverride *wo;

    45

    46

	assert(engine < TOTAL_NUM_ENGINES);

    48

    49

	wos = &_engine_wagon_overrides[engine];

    50

	wos->overrides_count++;

    51

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

    52

    53

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

    54

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

    55

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

    56

	 * --pasky */

    57

	wo->group = group;

    58

	wo->cargo = cargo;

    59

	wo->trains = trains;

    60

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

    61

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

    62

}

    63

    64

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

    65

{

    66

	const WagonOverrides *wos = &_engine_wagon_overrides[engine];

    67

	int i;

    68

    69

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

    70

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

    71

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

    72

	// that. --pasky

    73

    74

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

    75

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

    76

		int j;

    77

    78

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

    79

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

    80

		}

    81

	}

    82

	return NULL;

    83

}

    84

    85

/**

    86

 * Unload all wagon override sprite groups.

    87

 */

    88

void UnloadWagonOverrides(void)

    89

{

    90

	WagonOverrides *wos;

    91

	WagonOverride *wo;

    92

	EngineID engine;

    93

	int i;

    94

    95

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

    96

		wos = &_engine_wagon_overrides[engine];

    97

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

    98

			wo = &wos->overrides[i];

    99

			wo->group = NULL;

   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(void)

   127

{

   128

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

   129

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

   130

}

   131

   132

static const SpriteGroup *heli_rotor_custom_sprites[NUM_AIRCRAFT_ENGINES];

   133

   134

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

   135

void SetRotorOverrideSprites(EngineID engine, const SpriteGroup *group)

   136

{

   137

	assert(engine >= AIRCRAFT_ENGINES_INDEX);

   138

	assert(engine < AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES);

   139

   140

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

   141

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

   142

	}

   143

	heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = group;

   144

}

   145

   146

/** Unload all rotor override sprite groups */

   147

void UnloadRotorOverrideSprites(void)

   148

{

   149

	EngineID engine;

   150

   151

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

   152

	 * the context of EngineID is correct */

   153

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

   154

		heli_rotor_custom_sprites[engine - AIRCRAFT_ENGINES_INDEX] = NULL;

   155

	}

   156

}

   157

   158

   159

/**

   160

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

   161

 * etc during a game.

   162

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

   163

 * @param file   Pointer of GRFFile to tie.

   164

 */

   165

void SetEngineGRF(EngineID engine, const GRFFile *file)

   166

{

   167

	assert(engine < TOTAL_NUM_ENGINES);

   168

	_engine_grf[engine] = file;

   169

}

   170

   171

   172

/**

   173

 * Retrieve the GRFFile tied to an engine

   174

 * @param engine Engine ID to retrieve.

   175

 * @return Pointer to GRFFile.

   176

 */

   177

const GRFFile *GetEngineGRF(EngineID engine)

   178

{

   179

	assert(engine < TOTAL_NUM_ENGINES);

   180

	return _engine_grf[engine];

   181

}

   182

   183

   184

/**

   185

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

   186

 * @param engine Engine ID to retrieve.

   187

 * @return 32 bit GRFID value.

   188

 */

   189

uint32 GetEngineGRFID(EngineID engine)

   190

{

   191

	assert(engine < TOTAL_NUM_ENGINES);

   192

	return _engine_grf[engine]->grfid;

   193

}

   194

   195

   196

static int MapOldSubType(const Vehicle *v)

   197

{

   198

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

   199

	if (IsTrainEngine(v)) return 0;

   200

	if (IsFreeWagon(v)) return 4;

   201

	return 2;

   202

}

   203

   204

   205

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

   206

enum {

   207

	AMS_TTDP_HANGAR,

   208

	AMS_TTDP_TO_HANGAR,

   209

	AMS_TTDP_TO_PAD1,

   210

	AMS_TTDP_TO_PAD2,

   211

	AMS_TTDP_TO_PAD3,

   212

	AMS_TTDP_TO_ENTRY_2_AND_3,

   213

	AMS_TTDP_TO_ENTRY_2_AND_3_AND_H,

   214

	AMS_TTDP_TO_JUNCTION,

   215

	AMS_TTDP_LEAVE_RUNWAY,

   216

	AMS_TTDP_TO_INWAY,

   217

	AMS_TTDP_TO_RUNWAY,

   218

	AMS_TTDP_TO_OUTWAY,

   219

	AMS_TTDP_WAITING,

   220

	AMS_TTDP_TAKEOFF,

   221

	AMS_TTDP_TO_TAKEOFF,

   222

	AMS_TTDP_CLIMBING,

   223

	AMS_TTDP_FLIGHT_APPROACH,

   224

	AMS_TTDP_UNUSED_0x11,

   225

	AMS_TTDP_FLIGHT_TO_TOWER,

   226

	AMS_TTDP_UNUSED_0x13,

   227

	AMS_TTDP_FLIGHT_FINAL,

   228

	AMS_TTDP_FLIGHT_DESCENT,

   229

	AMS_TTDP_BRAKING,

   230

	AMS_TTDP_HELI_TAKEOFF_AIRPORT,

   231

	AMS_TTDP_HELI_TO_TAKEOFF_AIRPORT,

   232

	AMS_TTDP_HELI_LAND_AIRPORT,

   233

	AMS_TTDP_HELI_TAKEOFF_HELIPORT,

   234

	AMS_TTDP_HELI_TO_TAKEOFF_HELIPORT,

   235

	AMS_TTDP_HELI_LAND_HELIPORT,

   236

};

   237

   238

   239

/**

   240

 * Map OTTD aircraft movement states to TTDPatch style movement states

   241

 * (VarAction 2 Variable 0xE2)

   242

 */

   243

static byte MapAircraftMovementState(const Vehicle *v)

   244

{

   245

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

   246

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

   247

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

   248

   249

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

   250

		case HANGAR:

   251

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

   252

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

   253

			 * AMED_HELI_LOWER some time before actually descending. */

   254

   255

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

   256

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

   257

			if (amdflag & AMED_HELI_LOWER) return AMS_TTDP_HELI_LAND_AIRPORT;

   258

   259

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

   260

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

   261

			if (amdflag & AMED_SLOWTURN) return AMS_TTDP_FLIGHT_TO_TOWER;

   262

   263

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

   264

			/* Has reached hanger? */

   265

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_HANGAR;

   266

   267

			// Still moving towards hanger.

   268

			return AMS_TTDP_TO_HANGAR;

   269

   270

		case TERM1:

   271

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD1;

   272

			return AMS_TTDP_TO_JUNCTION;

   273

   274

		case TERM2:

   275

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD2;

   276

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   277

   278

		case TERM3:

   279

		case TERM4:

   280

		case TERM5:

   281

		case TERM6:

   282

		case TERM7:

   283

		case TERM8:

   284

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

   285

			if (amdflag & AMED_EXACTPOS) return AMS_TTDP_TO_PAD3;

   286

			return AMS_TTDP_TO_ENTRY_2_AND_3_AND_H;

   287

   288

		case HELIPAD1:

   289

		case HELIPAD2:

   290

		case HELIPAD3:

   291

		case HELIPAD4: // Will only occur for helicopters.

   292

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

   293

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

   294

			return AMS_TTDP_TO_JUNCTION; // On the ground.

   295

   296

		case TAKEOFF: // Moving to takeoff position.

   297

			return AMS_TTDP_TO_OUTWAY;

   298

   299

		case STARTTAKEOFF: // Accelerating down runway.

   300

			return AMS_TTDP_TAKEOFF;

   301

   302

		case ENDTAKEOFF: // Ascent

   303

			return AMS_TTDP_CLIMBING;

   304

   305

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

   306

			if (afc->delta_z == 0) {

   307

				return amdflag & AMED_HELI_RAISE ?

   308

					AMS_TTDP_HELI_TAKEOFF_AIRPORT : AMS_TTDP_TO_JUNCTION;

   309

			} else {

   310

				return AMS_TTDP_HELI_TAKEOFF_HELIPORT;

   311

			}

   312

   313

		case FLYING:

   314

			return AMS_TTDP_FLIGHT_TO_TOWER;

   315

   316

		case LANDING: // Descent

   317

			return AMS_TTDP_FLIGHT_DESCENT;

   318

   319

		case ENDLANDING: // On the runway braking

   320

			if (amdflag & AMED_BRAKE) return AMS_TTDP_BRAKING;

   321

			// Landed - moving off runway

   322

			return AMS_TTDP_TO_INWAY;

   323

   324

		case HELILANDING:

   325

		case HELIENDLANDING: // Helicoptor is decending.

   326

			if (amdflag & AMED_HELI_LOWER) {

   327

				return afc->delta_z == 0 ?

   328

					AMS_TTDP_HELI_LAND_AIRPORT : AMS_TTDP_HELI_LAND_HELIPORT;

   329

			} else {

   330

				return AMS_TTDP_FLIGHT_TO_TOWER;

   331

			}

   332

   333

		default:

   334

			return AMS_TTDP_HANGAR;

   335

	}

   336

}

   337

   338

   339

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

   340

enum {

   341

	AMA_TTDP_IN_HANGAR,

   342

	AMA_TTDP_ON_PAD1,

   343

	AMA_TTDP_ON_PAD2,

   344

	AMA_TTDP_ON_PAD3,

   345

	AMA_TTDP_HANGAR_TO_PAD1,

   346

	AMA_TTDP_HANGAR_TO_PAD2,

   347

	AMA_TTDP_HANGAR_TO_PAD3,

   348

	AMA_TTDP_LANDING_TO_PAD1,

   349

	AMA_TTDP_LANDING_TO_PAD2,

   350

	AMA_TTDP_LANDING_TO_PAD3,

   351

	AMA_TTDP_PAD1_TO_HANGAR,

   352

	AMA_TTDP_PAD2_TO_HANGAR,

   353

	AMA_TTDP_PAD3_TO_HANGAR,

   354

	AMA_TTDP_PAD1_TO_TAKEOFF,

   355

	AMA_TTDP_PAD2_TO_TAKEOFF,

   356

	AMA_TTDP_PAD3_TO_TAKEOFF,

   357

	AMA_TTDP_HANGAR_TO_TAKOFF,

   358

	AMA_TTDP_LANDING_TO_HANGAR,

   359

	AMA_TTDP_IN_FLIGHT,

   360

};

   361

   362

   363

/**

   364

 * Map OTTD aircraft movement states to TTDPatch style movement actions

   365

 * (VarAction 2 Variable 0xE6)

   366

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

   367

 */

   368

static byte MapAircraftMovementAction(const Vehicle *v)

   369

{

   370

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

   371

		case HANGAR:

   372

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

   373

   374

		case TERM1:

   375

		case HELIPAD1:

   376

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

   377

   378

		case TERM2:

   379

		case HELIPAD2:

   380

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

   381

   382

		case TERM3:

   383

		case TERM4:

   384

		case TERM5:

   385

		case TERM6:

   386

		case TERM7:

   387

		case TERM8:

   388

		case HELIPAD3:

   389

		case HELIPAD4:

   390

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

   391

   392

		case TAKEOFF:      // Moving to takeoff position

   393

		case STARTTAKEOFF: // Accelerating down runway

   394

		case ENDTAKEOFF:   // Ascent

   395

		case HELITAKEOFF:

   396

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

   397

			return AMA_TTDP_PAD1_TO_TAKEOFF;

   398

   399

		case FLYING:

   400

			return AMA_TTDP_IN_FLIGHT;

   401

   402

		case LANDING:    // Descent

   403

		case ENDLANDING: // On the runway braking

   404

		case HELILANDING:

   405

		case HELIENDLANDING:

   406

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

   407

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

   408

				AMA_TTDP_LANDING_TO_HANGAR : AMA_TTDP_LANDING_TO_PAD1;

   409

   410

		default:

   411

			return AMA_TTDP_IN_HANGAR;

   412

	}

   413

}

   414

   415

   416

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

   417

enum {

   418

	ATP_TTDP_SMALL,

   419

	ATP_TTDP_LARGE,

   420

	ATP_TTDP_HELIPORT,

   421

	ATP_TTDP_OILRIG,

   422

};

   423

   424

   425

/* Vehicle Resolver Functions */

   426

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

   427

{

   428

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

   429

}

   430

   431

   432

static uint32 VehicleGetRandomBits(const ResolverObject *object)

   433

{

   434

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

   435

}

   436

   437

   438

static uint32 VehicleGetTriggers(const ResolverObject *object)

   439

{

   440

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

   441

}

   442

   443

   444

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

   445

{

   446

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

   447

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

   448

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

   449

	 */

   450

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

   451

   452

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

   453

	 * other time is an error. */

   454

	assert(object->trigger != 0);

   455

   456

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

   457

}

   458

   459

   460

static uint32 GetVehicleTypeInfo(EngineID engine_type)

   461

{

   462

	/* Bit 0  Vehicle type is available on the market

   463

	 * Bit 1  Vehicle type is in the testing phase

   464

	 * Bit 2  Exclusive testing offer for a human player active */

   465

	const Engine *e = GetEngine(engine_type);

   466

	uint32 var = 0;

   467

   468

	if (e->player_avail == 0xFF) SETBIT(var, 0);

   469

	if (e->age < e->duration_phase_1) SETBIT(var, 1);

   470

	if (e->player_avail > 0 && e->player_avail != 0xFF) SETBIT(var, 2);

   471

	return var;

   472

}

   473

   474

   475

static uint32 GetGRFParameter(EngineID engine_type, byte parameter)

   476

{

   477

	const GRFFile *file = GetEngineGRF(engine_type);

   478

   479

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

   480

	return file->param[parameter];

   481

}

   482

   483

   484

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

   485

{

   486

	const Vehicle *v = GRV(object);

   487

   488

	if (v == NULL) {

   489

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

   490

		switch (variable) {