1

/* $Id$ */

     2

     3

/** @file newgrf_station.cpp Functions for dealing with station classes and custom stations. */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "variables.h"

     8

#include "functions.h"

     9

#include "landscape.h"

    10

#include "debug.h"

    11

#include "sprite.h"

    12

#include "table/sprites.h"

    13

#include "table/strings.h"

    14

#include "station.h"

    15

#include "station_map.h"

    16

#include "newgrf.h"

    17

#include "newgrf_callbacks.h"

    18

#include "newgrf_station.h"

    19

#include "newgrf_spritegroup.h"

    20

#include "date.h"

    21

#include "helpers.hpp"

    22

#include "cargotype.h"

    23

#include "town_map.h"

    24

#include "newgrf_town.h"

    25

    26

static StationClass station_classes[STAT_CLASS_MAX];

    27

    28

enum {

    29

	MAX_SPECLIST = 255,

    30

};

    31

    32

/**

    33

 * Reset station classes to their default state.

    34

 * This includes initialising the Default and Waypoint classes with an empty

    35

 * entry, for standard stations and waypoints.

    36

 */

    37

void ResetStationClasses()

    38

{

    39

	for (StationClassID i = STAT_CLASS_BEGIN; i < STAT_CLASS_MAX; i++) {

    40

		station_classes[i].id = 0;

    41

		station_classes[i].name = STR_EMPTY;

    42

		station_classes[i].stations = 0;

    43

    44

		free(station_classes[i].spec);

    45

		station_classes[i].spec = NULL;

    46

	}

    47

    48

	/* Set up initial data */

    49

	station_classes[0].id = 'DFLT';

    50

	station_classes[0].name = STR_STAT_CLASS_DFLT;

    51

	station_classes[0].stations = 1;

    52

	station_classes[0].spec = MallocT<StationSpec*>(1);

    53

	station_classes[0].spec[0] = NULL;

    54

    55

	station_classes[1].id = 'WAYP';

    56

	station_classes[1].name = STR_STAT_CLASS_WAYP;

    57

	station_classes[1].stations = 1;

    58

	station_classes[1].spec = MallocT<StationSpec*>(1);

    59

	station_classes[1].spec[0] = NULL;

    60

}

    61

    62

/**

    63

 * Allocate a station class for the given class id.

    65

 * @return Index into station_classes of allocated class.

    66

 */

    67

StationClassID AllocateStationClass(uint32 cls)

    68

{

    69

	for (StationClassID i = STAT_CLASS_BEGIN; i < STAT_CLASS_MAX; i++) {

    70

		if (station_classes[i].id == cls) {

    71

			/* ClassID is already allocated, so reuse it. */

    72

			return i;

    73

		} else if (station_classes[i].id == 0) {

    74

			/* This class is empty, so allocate it to the ClassID. */

    75

			station_classes[i].id = cls;

    76

			return i;

    77

		}

    78

	}

    79

    80

	grfmsg(2, "StationClassAllocate: already allocated %d classes, using default", STAT_CLASS_MAX);

    81

	return STAT_CLASS_DFLT;

    82

}

    83

    84

/** Set the name of a custom station class */

    85

void SetStationClassName(StationClassID sclass, StringID name)

    86

{

    87

	assert(sclass < STAT_CLASS_MAX);

    88

	station_classes[sclass].name = name;

    89

}

    90

    91

/** Retrieve the name of a custom station class */

    92

StringID GetStationClassName(StationClassID sclass)

    93

{

    94

	assert(sclass < STAT_CLASS_MAX);

    95

	return station_classes[sclass].name;

    96

}

    97

    98

/** Build a list of station class name StringIDs to use in a dropdown list

    99

 * @return Pointer to a (static) array of StringIDs

   100

 */

   101

StringID *BuildStationClassDropdown()

   102

{

   103

	/* Allow room for all station classes, plus a terminator entry */

   104

	static StringID names[STAT_CLASS_MAX + 1];

   105

	uint i;

   106

   107

	/* Add each name */

   108

	for (i = 0; i < STAT_CLASS_MAX && station_classes[i].id != 0; i++) {

   109

		names[i] = station_classes[i].name;

   110

	}

   111

	/* Terminate the list */

   112

	names[i] = INVALID_STRING_ID;

   113

   114

	return names;

   115

}

   116

   117

/**

   118

 * Get the number of station classes in use.

   119

 * @return Number of station classes.

   120

 */

   121

uint GetNumStationClasses()

   122

{

   123

	uint i;

   124

	for (i = 0; i < STAT_CLASS_MAX && station_classes[i].id != 0; i++);

   125

	return i;

   126

}

   127

   128

/**

   129

 * Return the number of stations for the given station class.

   130

 * @param sclass Index of the station class.

   131

 * @return Number of stations in the class.

   132

 */

   133

uint GetNumCustomStations(StationClassID sclass)

   134

{

   135

	assert(sclass < STAT_CLASS_MAX);

   136

	return station_classes[sclass].stations;

   137

}

   138

   139

/**

   140

 * Tie a station spec to its station class.

   142

 */

   143

void SetCustomStationSpec(StationSpec *statspec)

   144

{

   145

	StationClass *station_class;

   146

	int i;

   147

   148

	/* If the station has already been allocated, don't reallocate it. */

   149

	if (statspec->allocated) return;

   150

   151

	assert(statspec->sclass < STAT_CLASS_MAX);

   152

	station_class = &station_classes[statspec->sclass];

   153

   154

	i = station_class->stations++;

   155

	station_class->spec = ReallocT(station_class->spec, station_class->stations);

   156

   157

	station_class->spec[i] = statspec;

   158

	statspec->allocated = true;

   159

}

   160

   161

/**

   162

 * Retrieve a station spec from a class.

   163

 * @param sclass Index of the station class.

   164

 * @param station The station index with the class.

   165

 * @return The station spec.

   166

 */

   167

const StationSpec *GetCustomStationSpec(StationClassID sclass, uint station)

   168

{

   169

	assert(sclass < STAT_CLASS_MAX);

   170

	if (station < station_classes[sclass].stations)

   171

		return station_classes[sclass].spec[station];

   172

   173

	/* If the custom station isn't defined any more, then the GRF file

   174

	 * probably was not loaded. */

   175

	return NULL;

   176

}

   177

   178

   179

const StationSpec *GetCustomStationSpecByGrf(uint32 grfid, byte localidx)

   180

{

   181

	uint j;

   182

   183

	for (StationClassID i = STAT_CLASS_BEGIN; i < STAT_CLASS_MAX; i++) {

   184

		for (j = 0; j < station_classes[i].stations; j++) {

   185

			const StationSpec *statspec = station_classes[i].spec[j];

   186

			if (statspec == NULL) continue;

   187

			if (statspec->grffile->grfid == grfid && statspec->localidx == localidx) return statspec;

   188

		}

   189

	}

   190

   191

	return NULL;

   192

}

   193

   194

   195

/* Evaluate a tile's position within a station, and return the result a bitstuffed format.

   196

 * if not centred: .TNLcCpP, if centred: .TNL..CP

   197

 * T = Tile layout number (GetStationGfx), N = Number of platforms, L = Length of platforms

   198

 * C = Current platform number from start, c = from end

   199

 * P = Position along platform from start, p = from end

   200

 * if centred, C/P start from the centre and c/p are not available.

   201

 */

   202

uint32 GetPlatformInfo(Axis axis, byte tile, int platforms, int length, int x, int y, bool centred)

   203

{

   204

	uint32 retval = 0;

   205

   206

	if (axis == AXIS_X) {

   207

		Swap(platforms, length);

   208

		Swap(x, y);

   209

	}

   210

   211

	/* Limit our sizes to 4 bits */

   212

	platforms = min(15, platforms);

   213

	length    = min(15, length);

   214

	x = min(15, x);

   215

	y = min(15, y);

   216

	if (centred) {

   217

		x -= platforms / 2;

   218

		y -= length / 2;

   219

		SB(retval,  0, 4, y & 0xF);

   220

		SB(retval,  4, 4, x & 0xF);

   221

	} else {

   222

		SB(retval,  0, 4, y);

   223

		SB(retval,  4, 4, length - y - 1);

   224

		SB(retval,  8, 4, x);

   225

		SB(retval, 12, 4, platforms - x - 1);

   226

	}

   227

	SB(retval, 16, 4, length);

   228

	SB(retval, 20, 4, platforms);

   229

	SB(retval, 24, 4, tile);

   230

   231

	return retval;

   232

}

   233

   234

   235

/* Find the end of a railway station, from the tile, in the direction of delta.

   236

 * If check_type is set, we stop if the custom station type changes.

   237

 * If check_axis is set, we stop if the station direction changes.

   238

 */

   239

static TileIndex FindRailStationEnd(TileIndex tile, TileIndexDiff delta, bool check_type, bool check_axis)

   240

{

   241

	bool waypoint;

   242

	byte orig_type = 0;

   243

	Axis orig_axis = AXIS_X;

   244

   245

	waypoint = IsTileType(tile, MP_RAILWAY);

   246

   247

	if (waypoint) {

   248

		if (check_axis) orig_axis = GetWaypointAxis(tile);

   249

	} else {

   250

		if (check_type) orig_type = GetCustomStationSpecIndex(tile);

   251

		if (check_axis) orig_axis = GetRailStationAxis(tile);

   252

	}

   253

   254

	while (true) {

   255

		TileIndex new_tile = TILE_ADD(tile, delta);

   256

   257

		if (waypoint) {

   258

			if (!IsTileType(new_tile, MP_RAILWAY)) break;

   259

			if (!IsRailWaypoint(new_tile)) break;

   260

			if (check_axis && GetWaypointAxis(new_tile) != orig_axis) break;

   261

		} else {

   262

			if (!IsRailwayStationTile(new_tile)) break;

   263

			if (check_type && GetCustomStationSpecIndex(new_tile) != orig_type) break;

   264

			if (check_axis && GetRailStationAxis(new_tile) != orig_axis) break;

   265

		}

   266

   267

		tile = new_tile;

   268

	}

   269

	return tile;

   270

}

   271

   272

   273

static uint32 GetPlatformInfoHelper(TileIndex tile, bool check_type, bool check_axis, bool centred)

   274

{

   275

	int tx = TileX(tile);

   276

	int ty = TileY(tile);

   277

	int sx = TileX(FindRailStationEnd(tile, TileDiffXY(-1,  0), check_type, check_axis));

   278

	int sy = TileY(FindRailStationEnd(tile, TileDiffXY( 0, -1), check_type, check_axis));

   279

	int ex = TileX(FindRailStationEnd(tile, TileDiffXY( 1,  0), check_type, check_axis)) + 1;

   280

	int ey = TileY(FindRailStationEnd(tile, TileDiffXY( 0,  1), check_type, check_axis)) + 1;

   281

	Axis axis = IsTileType(tile, MP_RAILWAY) ? GetWaypointAxis(tile) : GetRailStationAxis(tile);

   282

   283

	tx -= sx; ex -= sx;

   284

	ty -= sy; ey -= sy;

   285

   286

	return GetPlatformInfo(axis, IsTileType(tile, MP_RAILWAY) ? 2 : GetStationGfx(tile), ex, ey, tx, ty, centred);

   287

}

   288

   289

   290

static uint32 GetRailContinuationInfo(TileIndex tile)

   291

{

   292

	/* Tile offsets and exit dirs for X axis */

   293

	static Direction x_dir[8] = { DIR_SW, DIR_NE, DIR_SE, DIR_NW, DIR_S, DIR_E, DIR_W, DIR_N };

   294

	static DiagDirection x_exits[8] = { DIAGDIR_SW, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NE, DIAGDIR_SW, DIAGDIR_NE };

   295

   296

	/* Tile offsets and exit dirs for Y axis */

   297

	static Direction y_dir[8] = { DIR_SE, DIR_NW, DIR_SW, DIR_NE, DIR_S, DIR_W, DIR_E, DIR_N };

   298

	static DiagDirection y_exits[8] = { DIAGDIR_SE, DIAGDIR_NW, DIAGDIR_SW, DIAGDIR_NE, DIAGDIR_SE, DIAGDIR_NW, DIAGDIR_SE, DIAGDIR_NW };

   299

   300

	Axis axis = IsTileType(tile, MP_RAILWAY) ? GetWaypointAxis(tile) : GetRailStationAxis(tile);

   301

   302

	/* Choose appropriate lookup table to use */

   303

	Direction *dir = axis == AXIS_X ? x_dir : y_dir;

   304

	DiagDirection *diagdir = axis == AXIS_X ? x_exits : y_exits;

   305

   306

	uint32 res = 0;

   307

	uint i;

   308

   309

	for (i = 0; i < lengthof(x_dir); i++, dir++, diagdir++) {

   310

		uint32 ts = GetTileTrackStatus(tile + TileOffsByDir(*dir), TRANSPORT_RAIL);

   311

		if (ts != 0) {

   312

			/* If there is any track on the tile, set the bit in the second byte */

   313

			SETBIT(res, i + 8);

   314

   315

			/* If any track reaches our exit direction, set the bit in the lower byte */

   316

			if (ts & DiagdirReachesTracks(*diagdir)) SETBIT(res, i);

   317

		}

   318

	}

   319

   320

	return res;

   321

}

   322

   323

   324

/* Station Resolver Functions */

   325

static uint32 StationGetRandomBits(const ResolverObject *object)

   326

{

   327

	const Station *st = object->u.station.st;

   328

	const TileIndex tile = object->u.station.tile;

   329

	return (st == NULL ? 0 : st->random_bits) | (tile == INVALID_TILE ? 0 : GetStationTileRandomBits(tile) << 16);

   330

}

   331

   332

   333

static uint32 StationGetTriggers(const ResolverObject *object)

   334

{

   335

	const Station *st = object->u.station.st;

   336

	return st == NULL ? 0 : st->waiting_triggers;

   337

}

   338

   339

   340

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

   341

{

   342

	Station *st = (Station*)object->u.station.st;

   343

	assert(st != NULL);

   344

	st->waiting_triggers = triggers;

   345

}

   346

   347

   348

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

   349

{

   350

	const Station *st = object->u.station.st;

   351

	TileIndex tile = object->u.station.tile;

   352

   353

	if (object->scope == VSG_SCOPE_PARENT) {

   354

		/* Pass the request on to the town of the station */

   355

		Town *t;

   356

   357

		if (st != NULL) {

   358

			t = st->town;

   359

		} else if (tile != INVALID_TILE) {

   360

			t = GetTownByTile(tile);

   361

		} else {

   362

			*available = false;

   363

			return UINT_MAX;

   364

		}

   365

   366

		return TownGetVariable(variable, parameter, available, t);

   367

	}

   368

   369

	if (st == NULL) {

   370

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

   371

		switch (variable) {

   372

			case 0x40:

   373

			case 0x41:

   374

			case 0x46:

   375

			case 0x47:

   376

			case 0x49: return 0x2110000;       // Platforms, tracks & position

   377

			case 0x42: return 0;               // Rail type (XXX Get current type from GUI?)

   378

			case 0x43: return _current_player; // Station owner

   379

			case 0x44: return 2;               // PBS status

   380

			case 0xFA: return max(_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0); // Build date

   381

		}

   382

   383

		*available = false;

   384

		return UINT_MAX;

   385

	}

   386

   387

	switch (variable) {

   388

		/* Calculated station variables */

   389

		case 0x40: return GetPlatformInfoHelper(tile, false, false, false);

   390

		case 0x41: return GetPlatformInfoHelper(tile, true,  false, false);

   391

		case 0x42: // Terrain and rail type

   392

			return ((_opt.landscape == LT_ARCTIC && GetTileZ(tile) > GetSnowLine()) ? 4 : 0) |

   393

			       (_opt.landscape == LT_TROPIC ? GetTropicZone(tile) : 0) |

   394

			       (GetRailType(tile) << 8);

   395

		case 0x43: return st->owner; // Station owner

   396

		case 0x44: return 2;         // PBS status

   397

		case 0x45: return GetRailContinuationInfo(tile);

   398

		case 0x46: return GetPlatformInfoHelper(tile, false, false, true);

   399

		case 0x47: return GetPlatformInfoHelper(tile, true,  false, true);

   400

		case 0x48: { // Accepted cargo types

   401

			CargoID cargo_type;

   402

			uint32 value = 0;

   403

   404

			for (cargo_type = 0; cargo_type < NUM_CARGO; cargo_type++) {

   405

				if (HASBIT(st->goods[cargo_type].waiting_acceptance, 15)) SETBIT(value, cargo_type);

   406

			}

   407

			return value;

   408

		}

   409

		case 0x49: return GetPlatformInfoHelper(tile, false, true, false);

   410

   411

		/* Variables which use the parameter */

   412

		/* Variables 0x60 to 0x65 are handled separately below */

   413

   414

		/* General station properties */

   415

		case 0x82: return 50;

   416

		case 0x84: return st->string_id;

   417

		case 0x86: return 0;

   418

		case 0x8A: return st->had_vehicle_of_type;

   419

		case 0xF0: return st->facilities;

   420

		case 0xF1: return st->airport_type;

   421

		case 0xF2: return st->truck_stops->status;

   422

		case 0xF3: return st->bus_stops->status;

   423

		case 0xF6: return st->airport_flags;

   424

		case 0xF7: return GB(st->airport_flags, 8, 8);

   425

		case 0xFA: return max(st->build_date - DAYS_TILL_ORIGINAL_BASE_YEAR, 0);

   426

	}

   427

   428

	/* Handle cargo variables with parameter, 0x60 to 0x65 */

   429

	if (variable >= 0x60 && variable <= 0x65) {

   430

		CargoID c = GetCargoTranslation(parameter, object->u.station.statspec->grffile);

   431

   432

		if (c == CT_INVALID) return 0;

   433

		const GoodsEntry *ge = &st->goods[c];

   434

   435

		switch (variable) {

   436

			case 0x60: return GB(ge->waiting_acceptance, 0, 12);

   437

			case 0x61: return ge->days_since_pickup;

   438

			case 0x62: return ge->rating;

   439

			case 0x63: return ge->enroute_time;

   440

			case 0x64: return ge->last_speed | (ge->last_age << 8);

   441

			case 0x65: return GB(ge->waiting_acceptance, 12, 4);

   442

		}

   443

	}

   444

   445

	/* Handle cargo variables (deprecated) */

   446

	if (variable >= 0x8C && variable <= 0xEC) {

   447

		const GoodsEntry *g = &st->goods[GB(variable - 0x8C, 3, 4)];

   448

		switch (GB(variable - 0x8C, 0, 3)) {

   449

			case 0: return g->waiting_acceptance;

   450

			case 1: return GB(g->waiting_acceptance, 8, 8);

   451

			case 2: return g->days_since_pickup;

   452

			case 3: return g->rating;

   453

			case 4: return g->enroute_from;

   454

			case 5: return g->enroute_time;

   455

			case 6: return g->last_speed;

   456

			case 7: return g->last_age;

   457

		}

   458

	}

   459

   460

	DEBUG(grf, 1, "Unhandled station property 0x%X", variable);

   461

   462

	*available = false;

   463

	return UINT_MAX;

   464

}

   465

   466

   467

static const SpriteGroup *StationResolveReal(const ResolverObject *object, const SpriteGroup *group)

   468

{

   469

	const Station *st = object->u.station.st;

   470

	const StationSpec *statspec = object->u.station.statspec;

   471

	uint set;

   472

   473

	uint cargo = 0;

   474

	CargoID cargo_type = object->u.station.cargo_type;

   475

   476

	if (st == NULL || statspec->sclass == STAT_CLASS_WAYP) {

   477

		return group->g.real.loading[0];

   478

	}

   479

   480

	switch (cargo_type) {

   481

		case CT_INVALID:

   482

		case CT_DEFAULT_NA:

   483

		case CT_PURCHASE:

   484

			cargo = 0;

   485

			break;

   486

   487

		case CT_DEFAULT:

   488

			for (cargo_type = 0; cargo_type < NUM_CARGO; cargo_type++) {

   489

				cargo += GB(st->goods[cargo_type].waiting_acceptance, 0, 12);

   490

			}

   491

			break;

   492