C_SOURCES += station_newgrf.c

				stat->sclass = AllocateStationClass(classid);

				stat->tiles = grf_load_extended(&buf);

				stat->renderdata = calloc(stat->tiles, sizeof(*stat->renderdata));

					PalSpriteID ground_sprite;

					ground_sprite = grf_load_dword(&buf);

					if (ground_sprite == 0) {

					if (HASBIT(ground_sprite, 31)) {

						// Bit 31 indicates that we should use a custom sprite.

						dts->ground_sprite = GB(ground_sprite, 0, 15) - 0x42D;

						dts->ground_sprite += _cur_grffile->first_spriteset;

					} else {

						dts->ground_sprite = ground_sprite;

					}

				stat->renderdata = calloc(stat->tiles, sizeof(*stat->renderdata));

	if (_cur_grffile->first_spriteset == 0)

		_cur_grffile->first_spriteset = _cur_grffile->spriteset_start;

				stat->localidx = stid;

				SetCustomStation(stat);

static void ResetCustomStations(void)

{

	GRFFile *file;

	int i;

	CargoID c;

	for (file = _first_grffile; file != NULL; file = file->next) {

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

			if (file->stations[i].grfid != file->grfid)

				continue;

			// TODO: Release renderdata, platforms and layouts

			// Release this stations sprite groups.

			for (c = 0; c < NUM_GLOBAL_CID; c++) {

				if (file->stations[i].spritegroup[c] != NULL)

					UnloadSpriteGroup(&file->stations[i].spritegroup[c]);

			}

		}

	}

}

	// Reset station classes

	ResetStationClasses();

	ResetCustomStations();

	SpriteID first_spriteset; ///< Holds the first spriteset's sprite offset.

		DoCommandP(tile, _cur_waypoint_type, 0, CcPlaySound1E, CMD_BUILD_TRAIN_WAYPOINT | CMD_MSG(STR_CANT_BUILD_TRAIN_WAYPOINT));

	_waypoint_count = GetNumCustomStations(STAT_CLASS_WAYP);

			&& _waypoint_count > 1)

		int i;

		for (i = 0; i < 5; i++)

			if(w->hscroll.pos + i < _waypoint_count)

				DrawWaypointSprite(2 + i * 68, 25, w->hscroll.pos + i, _cur_railtype);

	w->hscroll.count = _waypoint_count;

#include "station_newgrf.h"

/* $Id$ */

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

#include "stdafx.h"

#include "openttd.h"

#include "debug.h"

#include "sprite.h"

#include "station_newgrf.h"

static StationClass station_classes[STAT_CLASS_MAX];

/**

 * Reset station classes to their default state.

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

 * entry, for standard stations and waypoints.

 */

void ResetStationClasses(void)

{

	StationClassID i;

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

		station_classes[i].id = 0;

		free(station_classes[i].name);

		station_classes[i].name = NULL;

		station_classes[i].stations = 0;

		free(station_classes[i].spec);

		station_classes[i].spec = NULL;

	}

	// Set up initial data

	station_classes[0].id = 'DFLT';

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

	station_classes[0].stations = 1;

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

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

	station_classes[1].id = 'WAYP';

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

	station_classes[1].stations = 1;

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

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

}

/**

 * Allocate a station class for the given class id.

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

 * @return Index into station_classes of allocated class.

 */

StationClassID AllocateStationClass(uint32 class)

{

	StationClassID i;

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

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

			// ClassID is already allocated, so reuse it.

			return i;

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

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

			station_classes[i].id = class;

			return i;

		}

	}

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

	return STAT_CLASS_DFLT;

}

/**

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

 * @param sclass Index of the station class.

 * @return Number of stations in the class.

 */

uint GetNumCustomStations(StationClassID sclass)

{

	assert(sclass < STAT_CLASS_MAX);

	return station_classes[sclass].stations;

}

/**

 * Tie a station spec to its station class.

 * @param spec The station spec.

 */

void SetCustomStation(StationSpec *spec)

{

	StationClass *station_class;

	int i;

	assert(spec->sclass < STAT_CLASS_MAX);

	station_class = &station_classes[spec->sclass];

	i = station_class->stations++;

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

	station_class->spec[i] = spec;

}

/**

 * Retrieve a station spec from a class.

 * @param sclass Index of the station class.

 * @param station The station index with the class.

 * @return The station spec.

 */

const StationSpec *GetCustomStation(StationClassID sclass, uint station)

{

	assert(sclass < STAT_CLASS_MAX);

	if (station < station_classes[sclass].stations)

		return station_classes[sclass].spec[station];

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

	// probably was not loaded.

	return NULL;

}

/* $Id$ */

/** @file station_newgrf.h Header file for NewGRF stations */

#ifndef STATION_NEWGRF_H

#define STATION_NEWGRF_H

#include "engine.h"

typedef enum {

	STAT_CLASS_DFLT,     ///< Default station class.

	STAT_CLASS_WAYP,     ///< Waypoint class.

	STAT_CLASS_MAX = 16, ///< Maximum number of classes.

} StationClassID;

/* Station layout for given dimensions - it is a two-dimensional array

 * where index is computed as (x * platforms) + platform. */

typedef byte *StationLayout;

typedef struct stationspec {

	uint32 grfid; ///< ID of GRF file station belongs to.

	int localidx; ///< Index within GRF file of station.

	StationClassID sclass; ///< The class to which this spec belongs.

	/**

	 * Bitmask of number of platforms available for the station.

	 * 0..6 correpsond to 1..7, while bit 7 corresponds to >7 platforms.

	 */

	byte allowed_platforms;

	/**

	 * Bitmask of platform lengths available for the station.

	 * 0..6 correpsond to 1..7, while bit 7 corresponds to >7 tiles long.

	 */

	byte allowed_lengths;

	/** Number of tile layouts.

	 * A minimum of 8 is required is required for stations.

	 * 0-1 = plain platform

	 * 2-3 = platform with building

	 * 4-5 = platform with roof, left side

	 * 6-7 = platform with roof, right side

	 */

	int tiles;

	DrawTileSprites *renderdata; ///< Array of tile layouts.

	byte lengths;

	byte *platforms;

	StationLayout **layouts;

	/**

	 * NUM_GLOBAL_CID sprite groups.

	 * Used for obtaining the sprite offset of custom sprites, and for

	 * evaluating callbacks.

	 */

	SpriteGroup *spritegroup[NUM_GLOBAL_CID];

} StationSpec;

/**

 * Struct containing information relating to station classes.

 */

typedef struct stationclass {

	uint32 id;          ///< ID of this class, e.g. 'DFLT', 'WAYP', etc.

	char *name;         ///< Name of this class.

	uint stations;      ///< Number of stations in this class.

	StationSpec **spec; ///< Array of station specifications.

} StationClass;

void ResetStationClasses(void);

StationClassID AllocateStationClass(uint32 class);

void SetStationClassName(StationClassID sclass, const char *name);

uint GetNumCustomStations(StationClassID sclass);

void SetCustomStation(StationSpec *spec);

const StationSpec *GetCustomStation(StationClassID sclass, uint station);

#endif /* STATION_NEWGRF_H */

 * @param p1 graphics for waypoint type, 0 indicates standard graphics

	if (p1 >= GetNumCustomStations(STAT_CLASS_WAYP)) return CMD_ERROR;

		if (p1 > 0) { // waypoint type 0 uses default graphics

			_m[tile].m4 = (p1 - 1) & 0xff;

	stat = GetCustomStation(STAT_CLASS_WAYP, stat_id);

	if (stat == NULL) {

		// stat is NULL for default waypoints and when waypoint graphics are

		// not loaded.

	uint32 grfid;