1

/* $Id$ */

     2

     3

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

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "debug.h"

     8

#include "sprite.h"

     9

#include "table/strings.h"

    10

#include "station.h"

    11

#include "station_map.h"

    12

#include "newgrf_station.h"

    13

    14

static StationClass station_classes[STAT_CLASS_MAX];

    15

    16

/**

    17

 * Reset station classes to their default state.

    18

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

    19

 * entry, for standard stations and waypoints.

    20

 */

    21

void ResetStationClasses(void)

    22

{

    23

	StationClassID i;

    24

	for (i = 0; i < STAT_CLASS_MAX; i++) {

    25

		station_classes[i].id = 0;

    26

		station_classes[i].name = STR_EMPTY;

    27

		station_classes[i].stations = 0;

    28

    29

		free(station_classes[i].spec);

    30

		station_classes[i].spec = NULL;

    31

	}

    32

    33

	// Set up initial data

    34

	station_classes[0].id = 'DFLT';

    35

	station_classes[0].name = STR_STAT_CLASS_DFLT;

    36

	station_classes[0].stations = 1;

    37

	station_classes[0].spec = malloc(sizeof(*station_classes[0].spec));

    38

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

    39

    40

	station_classes[1].id = 'WAYP';

    41

	station_classes[1].name = STR_STAT_CLASS_WAYP;

    42

	station_classes[1].stations = 1;

    43

	station_classes[1].spec = malloc(sizeof(*station_classes[1].spec));

    44

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

    45

}

    46

    47

/**

    48

 * Allocate a station class for the given class id.

    49

 * @param classid A 32 bit value identifying the class.

    50

 * @return Index into station_classes of allocated class.

    51

 */

    52

StationClassID AllocateStationClass(uint32 class)

    53

{

    54

	StationClassID i;

    55

    56

	for (i = 0; i < STAT_CLASS_MAX; i++) {

    57

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

    58

			// ClassID is already allocated, so reuse it.

    59

			return i;

    60

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

    61

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

    62

			station_classes[i].id = class;

    63

			return i;

    64

		}

    65

	}

    66

    67

	DEBUG(grf, 2)("StationClassAllocate: Already allocated %d classes, using default.", STAT_CLASS_MAX);

    68

	return STAT_CLASS_DFLT;

    69

}

    70

    71

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

    72

void SetStationClassName(StationClassID sclass, StringID name)

    73

{

    74

	assert(sclass < STAT_CLASS_MAX);

    75

	station_classes[sclass].name = name;

    76

}

    77

    78

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

    79

StringID GetStationClassName(StationClassID sclass)

    80

{

    81

	assert(sclass < STAT_CLASS_MAX);

    82

	return station_classes[sclass].name;

    83

}

    84

    85

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

    86

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

    87

 */

    88

StringID *BuildStationClassDropdown(void)

    89

{

    90

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

    91

	static StringID names[STAT_CLASS_MAX + 1];

    92

	uint i;

    93

    94

	/* Add each name */

    95

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

    96

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

    97

	}

    98

	/* Terminate the list */

    99

	names[i] = INVALID_STRING_ID;

   100

   101

	return names;

   102

}

   103

   104

/**

   105

 * Get the number of station classes in use.

   106

 * @return Number of station classes.

   107

 */

   108

uint GetNumStationClasses(void)

   109

{

   110

	uint i;

   111

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

   112

	return i;

   113

}

   114

   115

/**

   116

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

   117

 * @param sclass Index of the station class.

   118

 * @return Number of stations in the class.

   119

 */

   120

uint GetNumCustomStations(StationClassID sclass)

   121

{

   122

	assert(sclass < STAT_CLASS_MAX);

   123

	return station_classes[sclass].stations;

   124

}

   125

   126

/**

   127

 * Tie a station spec to its station class.

   128

 * @param spec The station spec.

   129

 */

   130

void SetCustomStationSpec(StationSpec *statspec)

   131

{

   132

	StationClass *station_class;

   133

	int i;

   134

   135

	assert(statspec->sclass < STAT_CLASS_MAX);

   136

	station_class = &station_classes[statspec->sclass];

   137

   138

	i = station_class->stations++;

   139

	station_class->spec = realloc(station_class->spec, station_class->stations * sizeof(*station_class->spec));

   140

   141

	station_class->spec[i] = statspec;

   142

}

   143

   144

/**

   145

 * Retrieve a station spec from a class.

   146

 * @param sclass Index of the station class.

   147

 * @param station The station index with the class.

   148

 * @return The station spec.

   149

 */

   150

const StationSpec *GetCustomStationSpec(StationClassID sclass, uint station)

   151

{

   152

	assert(sclass < STAT_CLASS_MAX);

   153

	if (station < station_classes[sclass].stations)

   154

		return station_classes[sclass].spec[station];

   155

   156

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

   157

	// probably was not loaded.

   158

	return NULL;

   159

}

   160

   161

static const RealSpriteGroup *ResolveStationSpriteGroup(const SpriteGroup *spg, const Station *st)

   162

{

   163

	if (spg == NULL) return NULL;

   164

	switch (spg->type) {

   165

		case SGT_REAL:

   166

			return &spg->g.real;

   167

   168

		case SGT_DETERMINISTIC: {

   169

			const DeterministicSpriteGroup *dsg = &spg->g.determ;

   170

			SpriteGroup *target;

   171

			int value = -1;

   172

			byte variable = dsg->adjusts[0].variable;

   173

   174

			if ((variable >> 6) == 0) {

   175

				/* General property */

   176

				value = GetDeterministicSpriteValue(variable);

   177

			} else {

   178

				if (st == NULL) {

   179

					/* We are in a build dialog of something,

   180

					 * and we are checking for something undefined.

   181

					 * That means we should get the first target

   182

					 * (NOT the default one). */

   183

					if (dsg->num_ranges > 0) {

   184

						target = dsg->ranges[0].group;

   185

					} else {

   186

						target = dsg->default_group;

   187

					}

   188

					return ResolveStationSpriteGroup(target, NULL);

   189

				}

   190

   191

				/* Station-specific property. */

   192

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   193

					/* TODO: Town structure. */

   194

   195

				} else /* VSG_SELF */ {

   196

					if (variable == 0x40 || variable == 0x41) {

   197

						/* FIXME: This is ad hoc only

   198

						 * for waypoints. */

   199

						value = 0x01010000;

   200

					} else {

   201

						/* TODO: Only small fraction done. */

   202

						// TTDPatch runs on little-endian arch;

   203

						// Variable is 0x70 + offset in the TTD's station structure

   204

						switch (variable - 0x70) {

   205

							case 0x80: value = st->facilities;             break;

   206

							case 0x81: value = st->airport_type;           break;

   207

							case 0x82: value = st->truck_stops->status;    break;

   208

							case 0x83: value = st->bus_stops->status;      break;

   209

							case 0x86: value = st->airport_flags & 0xFFFF; break;

   210

							case 0x87: value = st->airport_flags & 0xFF;   break;

   211

							case 0x8A: value = st->build_date;             break;

   212

						}

   213

					}

   214

				}

   215

			}

   216

   217

			target = value != -1 ? EvalDeterministicSpriteGroup(dsg, value) : dsg->default_group;

   218

			return ResolveStationSpriteGroup(target, st);

   219

		}

   220

   221

		default:

   222

		case SGT_RANDOMIZED:

   223

			DEBUG(grf, 6)("I don't know how to handle random spritegroups yet!");

   224

			return NULL;

   225

	}

   226

}

   227

   228

uint32 GetCustomStationRelocation(const StationSpec *statspec, const Station *st, byte ctype)

   229

{

   230

	const RealSpriteGroup *rsg = ResolveStationSpriteGroup(statspec->spritegroup[ctype], st);

   231

	if (rsg == NULL) return 0;

   232

   233

	if (rsg->num_loading != 0) return rsg->loading[0]->g.result.sprite;

   234

	if (rsg->num_loaded  != 0) return rsg->loaded[0]->g.result.sprite;

   235

   236

	DEBUG(grf, 6)("Custom station 0x%08x::0x%02x has no sprites associated.",

   237

		statspec->grfid, statspec->localidx);

   238

	/* This is what gets subscribed of dtss->image in newgrf.c,

   239

	 * so it's probably kinda "default offset". Try to use it as

   240

	 * emergency measure. */

   241

	return 0;

   242

}

   243

   244

   245

/**

   246

 * Allocate a StationSpec to a Station. This is called once per build operation.

   247

 * @param spec StationSpec to allocate.

   248

 * @param st Station to allocate it to.

   249

 * @param exec Whether to actually allocate the spec.

   250

 * @return Index within the Station's spec list, or -1 if the allocation failed.

   251

 */

   252

int AllocateSpecToStation(const StationSpec *statspec, Station *st, bool exec)

   253

{

   254

	uint i;

   255

   256

	if (statspec == NULL) return 0;

   257

   258

	/* Check if this spec has already been allocated */

   259

	for (i = 1; i < st->num_specs && i < 256; i++) {

   260

		if (st->speclist[i].spec == statspec) return i;

   261

	}

   262

   263

	for (i = 1; i < st->num_specs && i < 256; i++) {

   264

		if (st->speclist[i].spec == NULL && st->speclist[i].grfid == 0) break;

   265

	}

   266

   267

	if (i < 256) {

   268

		if (exec) {

   269

			if (i >= st->num_specs) {

   270

				st->num_specs = i + 1;

   271

				st->speclist = realloc(st->speclist, st->num_specs * sizeof(*st->speclist));

   272

   273

				if (st->num_specs == 2) {

   274

					/* Initial allocation */

   275

					st->speclist[0].spec     = NULL;

   276

					st->speclist[0].grfid    = 0;

   277

					st->speclist[0].localidx = 0;

   278

				}

   279

			}

   280

   281

			st->speclist[i].spec     = statspec;

   282

			st->speclist[i].grfid    = statspec->grfid;

   283

			st->speclist[i].localidx = statspec->localidx;

   284

		}

   285

		return i;

   286

	}

   287

   288

	return -1;

   289

}

   290

   291

   292

/** Deallocate a StationSpec from a Station. Called when removing a single station tile.

   293

 * @param st Station to work with.

   294

 * @param specindex Index of the custom station within the Station's spec list.

   295

 * @return Indicates whether the StationSpec was deallocated.

   296

 */

   297

bool DeallocateSpecFromStation(Station *st, byte specindex)

   298

{

   299

	bool freeable = true;

   300

   301

	/* specindex of 0 (default) is never freeable */

   302

	if (specindex == 0) return false;

   303

   304

	/* Check all tiles over the station to check if the specindex is still in use */

   305

	BEGIN_TILE_LOOP(tile, st->trainst_w, st->trainst_h, st->train_tile) {

   306

		if (IsTileType(tile, MP_STATION) && GetStationIndex(tile) == st->index && IsRailwayStation(tile) && GetCustomStationSpecIndex(tile) == specindex) {

   307

			freeable = false;

   308

			break;

   309

		}

   310

	} END_TILE_LOOP(tile, st->trainst_w, st->trainst_h, st->train_tile)

   311

   312

	if (freeable) {

   313

		/* This specindex is no longer in use, so deallocate it */

   314

		st->speclist[specindex].spec     = NULL;

   315

		st->speclist[specindex].grfid    = 0;

   316

		st->speclist[specindex].localidx = 0;

   317

   318

		/* If this was the highest spec index, reallocate */

   319

		if (specindex == st->num_specs - 1) {

   320

			for (; st->speclist[st->num_specs - 1].grfid == 0 && st->num_specs > 1; st->num_specs--);

   321

   322

			if (st->num_specs > 1) {

   323

				st->speclist = realloc(st->speclist, st->num_specs * sizeof(*st->speclist));

   324

			} else {

   325

				free(st->speclist);

   326

				st->num_specs = 0;

   327

				st->speclist  = NULL;

   328

			}

   329

		}

   330

	}

   331

   332

	return freeable;

   333

}