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"

    10

#include "newgrf_station.h"

    11

    12

static StationClass station_classes[STAT_CLASS_MAX];

    13

    14

/**

    15

 * Reset station classes to their default state.

    16

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

    17

 * entry, for standard stations and waypoints.

    18

 */

    19

void ResetStationClasses(void)

    20

{

    21

	StationClassID i;

    22

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

    23

		station_classes[i].id = 0;

    24

    25

		free(station_classes[i].name);

    26

		station_classes[i].name = NULL;

    27

    28

		station_classes[i].stations = 0;

    29

    30

		free(station_classes[i].spec);

    31

		station_classes[i].spec = NULL;

    32

	}

    33

    34

	// Set up initial data

    35

	station_classes[0].id = 'DFLT';

    36

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

    37

	station_classes[0].stations = 1;

    38

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

    39

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

    40

    41

	station_classes[1].id = 'WAYP';

    42

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

    43

	station_classes[1].stations = 1;

    44

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

    45

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

    46

}

    47

    48

/**

    49

 * Allocate a station class for the given class id.

    50

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

    51

 * @return Index into station_classes of allocated class.

    52

 */

    53

StationClassID AllocateStationClass(uint32 class)

    54

{

    55

	StationClassID i;

    56

    57

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

    58

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

    59

			// ClassID is already allocated, so reuse it.

    60

			return i;

    61

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

    62

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

    63

			station_classes[i].id = class;

    64

			return i;

    65

		}

    66

	}

    67

    68

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

    69

	return STAT_CLASS_DFLT;

    70

}

    71

    72

/**

    73

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

    74

 * @param sclass Index of the station class.

    75

 * @return Number of stations in the class.

    76

 */

    77

uint GetNumCustomStations(StationClassID sclass)

    78

{

    79

	assert(sclass < STAT_CLASS_MAX);

    80

	return station_classes[sclass].stations;

    81

}

    82

    83

/**

    84

 * Tie a station spec to its station class.

    85

 * @param spec The station spec.

    86

 */

    87

void SetCustomStation(StationSpec *spec)

    88

{

    89

	StationClass *station_class;

    90

	int i;

    91

    92

	assert(spec->sclass < STAT_CLASS_MAX);

    93

	station_class = &station_classes[spec->sclass];

    94

    95

	i = station_class->stations++;

    96

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

    97

    98

	station_class->spec[i] = spec;

    99

}

   100

   101

/**

   102

 * Retrieve a station spec from a class.

   103

 * @param sclass Index of the station class.

   104

 * @param station The station index with the class.

   105

 * @return The station spec.

   106

 */

   107

const StationSpec *GetCustomStation(StationClassID sclass, uint station)

   108

{

   109

	assert(sclass < STAT_CLASS_MAX);

   110

	if (station < station_classes[sclass].stations)

   111

		return station_classes[sclass].spec[station];

   112

   113

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

   114

	// probably was not loaded.

   115

	return NULL;

   116

}

   117

   118

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

   119

{

   120

	switch (spg->type) {

   121

		case SGT_REAL:

   122

			return &spg->g.real;

   123

   124

		case SGT_DETERMINISTIC: {

   125

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

   126

			SpriteGroup *target;

   127

			int value = -1;

   128

   129

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

   130

				/* General property */

   131

				value = GetDeterministicSpriteValue(dsg->variable);

   132

			} else {

   133

				if (st == NULL) {

   134

					/* We are in a build dialog of something,

   135

					 * and we are checking for something undefined.

   136

					 * That means we should get the first target

   137

					 * (NOT the default one). */

   138

					if (dsg->num_ranges > 0) {

   139

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

   140

					} else {

   141

						target = dsg->default_group;

   142

					}

   143

					return ResolveStationSpriteGroup(target, NULL);

   144

				}

   145

   146

				/* Station-specific property. */

   147

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

   148

					/* TODO: Town structure. */

   149

   150

				} else /* VSG_SELF */ {

   151

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

   152

						/* FIXME: This is ad hoc only

   153

						 * for waypoints. */

   154

						value = 0x01010000;

   155

					} else {

   156

						/* TODO: Only small fraction done. */

   157

						// TTDPatch runs on little-endian arch;

   158

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

   159

						switch (dsg->variable - 0x70) {

   160

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

   161

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

   162

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

   163

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

   164

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

   165

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

   166

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

   167

						}

   168

					}

   169

				}

   170

			}

   171

   172

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

   173

			return ResolveStationSpriteGroup(target, st);

   174

		}

   175

   176

		default:

   177

		case SGT_RANDOMIZED:

   178

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

   179

			return NULL;

   180

	}

   181

}

   182

   183

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

   184

{

   185

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

   186

   187

	if (rsg->sprites_per_set != 0) {

   188

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

   189

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

   190

	}

   191

   192

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

   193

		spec->grfid, spec->localidx);

   194

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

   195

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

   196

	 * emergency measure. */

   197

	return 0;

   198

}