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

    11

#include "newgrf_station.h"

    12

    13

static StationClass station_classes[STAT_CLASS_MAX];

    14

    15

/**

    16

 * Reset station classes to their default state.

    17

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

    18

 * entry, for standard stations and waypoints.

    19

 */

    20

void ResetStationClasses(void)

    21

{

    22

	StationClassID i;

    23

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

    24

		station_classes[i].id = 0;

    25

    26

		free(station_classes[i].name);

    27

		station_classes[i].name = NULL;

    28

    29

		station_classes[i].stations = 0;

    30

    31

		free(station_classes[i].spec);

    32

		station_classes[i].spec = NULL;

    33

	}

    34

    35

	// Set up initial data

    36

	station_classes[0].id = 'DFLT';

    37

	station_classes[0].name = strdup("Default");

    38

	station_classes[0].stations = 1;

    39

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

    40

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

    41

    42

	station_classes[1].id = 'WAYP';

    43

	station_classes[1].name = strdup("Waypoints");

    44

	station_classes[1].stations = 1;

    45

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

    46

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

    47

}

    48

    49

/**

    50

 * Allocate a station class for the given class id.

    51

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

    52

 * @return Index into station_classes of allocated class.

    53

 */

    54

StationClassID AllocateStationClass(uint32 class)

    55

{

    56

	StationClassID i;

    57

    58

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

    59

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

    60

			// ClassID is already allocated, so reuse it.

    61

			return i;

    62

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

    63

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

    64

			station_classes[i].id = class;

    65

			return i;

    66

		}

    67

	}

    68

    69

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

    70

	return STAT_CLASS_DFLT;

    71

}

    72

    73

/**

    85

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

    86

 * @param sclass Index of the station class.

    87

 * @return Number of stations in the class.

    88

 */

    89

uint GetNumCustomStations(StationClassID sclass)

    90

{

    91

	assert(sclass < STAT_CLASS_MAX);

    92

	return station_classes[sclass].stations;

    93

}

    94

    95

/**

    96

 * Tie a station spec to its station class.

    97

 * @param spec The station spec.

    98

 */

    99

void SetCustomStation(StationSpec *spec)

   100

{

   101

	StationClass *station_class;

   102

	int i;

   103

   104

	assert(spec->sclass < STAT_CLASS_MAX);

   105

	station_class = &station_classes[spec->sclass];

   106

   107

	i = station_class->stations++;

   108

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

   109

   110

	station_class->spec[i] = spec;

   111

}

   112

   113

/**

   114

 * Retrieve a station spec from a class.

   115

 * @param sclass Index of the station class.

   116

 * @param station The station index with the class.

   117

 * @return The station spec.

   118

 */

   119

const StationSpec *GetCustomStation(StationClassID sclass, uint station)

   120

{

   121

	assert(sclass < STAT_CLASS_MAX);

   122

	if (station < station_classes[sclass].stations)

   123

		return station_classes[sclass].spec[station];

   124

   125

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

   126

	// probably was not loaded.

   127

	return NULL;

   128

}

   129

   130

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

   131

{

   132

	if (spg == NULL) return NULL;

   133

	switch (spg->type) {

   134

		case SGT_REAL:

   135

			return &spg->g.real;

   136

   137

		case SGT_DETERMINISTIC: {

   138

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

   139

			SpriteGroup *target;

   140

			int value = -1;

   141

   142

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

   143

				/* General property */

   144

				value = GetDeterministicSpriteValue(dsg->variable);

   145

			} else {

   146

				if (st == NULL) {

   147

					/* We are in a build dialog of something,

   148

					 * and we are checking for something undefined.

   149

					 * That means we should get the first target

   150

					 * (NOT the default one). */

   151

					if (dsg->num_ranges > 0) {

   152

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

   153

					} else {

   154

						target = dsg->default_group;

   155

					}

   156

					return ResolveStationSpriteGroup(target, NULL);

   157

				}

   158

   159

				/* Station-specific property. */

   160

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   161

					/* TODO: Town structure. */

   162

   163

				} else /* VSG_SELF */ {

   164

					if (dsg->variable == 0x40 || dsg->variable == 0x41) {

   165

						/* FIXME: This is ad hoc only

   166

						 * for waypoints. */

   167

						value = 0x01010000;

   168

					} else {

   169

						/* TODO: Only small fraction done. */

   170

						// TTDPatch runs on little-endian arch;

   171

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

   172

						switch (dsg->variable - 0x70) {

   173

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

   174

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

   175

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

   176

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

   177

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

   178

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

   179

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

   180

						}

   181

					}

   182

				}

   183

			}

   184

   185

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

   186

			return ResolveStationSpriteGroup(target, st);

   187

		}

   188

   189

		default:

   190

		case SGT_RANDOMIZED:

   191

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

   192

			return NULL;

   193

	}

   194

}

   195

   196

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

   197

{

   198

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

   199

	if (rsg == NULL) return 0;

   200

   201

	if (rsg->sprites_per_set != 0) {

   202

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

   203

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

   204

	}

   205

   206

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

   207

		spec->grfid, spec->localidx);

   208

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

   209

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

   210

	 * emergency measure. */

   211

	return 0;

   212

}