// TODO: We don't support cargo-specific wagon overrides. Pretty exotic... ;-) --pasky

	byte *train_id;

	int trains;

	int overrides_count;

{

	wos = &_engine_wagon_overrides[engine];

	wos->overrides_count++;

	wos->overrides = realloc(wos->overrides,

	wo = &wos->overrides[wos->overrides_count - 1];

	/* FIXME: If we are replacing an override, release original SpriteGroup

	memcpy(wo->train_id, train_id, trains);

}

{

	int i;

	// XXX: This could turn out to be a timesink on profiles. We could

	// that. --pasky

	for (i = 0; i < wos->overrides_count; i++) {

		int j;

		for (j = 0; j < wo->trains; j++) {

// (It isn't and shouldn't be like this in the GRF files since new cargo types

// may appear in future - however it's more convenient to store it like this in

// memory. --pasky)

{

	/* FIXME: If we are replacing an override, release original SpriteGroup

	 * to prevent leaks. But first we need to refcount the SpriteGroup.

	_engine_custom_sprites[engine][cargo] = *group;

}

{

	//debug("spgt %d", spritegroup->type);

	switch (spritegroup->type) {

			return &spritegroup->g.real;

		case SGT_DETERMINISTIC: {

			int value = -1;

			//debug("[%p] Having fun resolving variable %x", veh, dsg->variable);

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

				/* General property */

				value = GetDeterministicSpriteValue(dsg->variable);

			} else {

				/* Vehicle-specific property. */

		}

		case SGT_RANDOMIZED: {

			if (veh == NULL) {

				/* Purchase list of something. Show the first one. */

	}

}

{

	uint16 overriding_engine = -1;

	byte cargo = CID_PURCHASE;

	group = &_engine_custom_sprites[engine][cargo];

	if (overriding_engine != 0xffff) {

	}

	return group;

int GetCustomEngineSprite(byte engine, const Vehicle *v, byte direction)

{

	byte cargo = CID_PURCHASE;

	byte loaded = 0;

	bool in_motion = 0;

extern int _custom_sprites_base;

{

	return ResolveVehicleSpriteGroup(spritegroup, veh, callback);

}

{

	byte new_random_bits;

	_vsg_random_triggers = trigger;

	}

}

{

	DoTriggerVehicle(veh, trigger, 0, true);

}

#define GetCustomVehicleSprite(v, direction) GetCustomEngineSprite(v->engine_type, v, direction)

#define GetCustomVehicleIcon(et, direction) GetCustomEngineSprite(et, NULL, direction)

	VEHICLE_TRIGGER_NEW_CARGO = 1,

	// Externally triggered only for the first vehicle in chain

	VEHICLE_TRIGGER_DEPOT = 2,

	VEHICLE_TRIGGER_EMPTY = 4,

	// Not triggered externally (called for the whole chain if we got NEW_CARGO)

	VEHICLE_TRIGGER_ANY_NEW_CARGO = 8,

void SetCustomEngineName(int engine, const char *name);

StringID GetCustomEngineName(int engine);

extern int _replace_sprites_offset[16];

extern int _traininfo_vehicle_pitch;

int _grffile_count;

static int _cur_spriteid;

static int _cur_stage;

static uint32 _ttdpatch_flags[8];

	GSF_TRAIN,

	GSF_ROAD,

	GSF_SHIP,

	GSF_STATION,

	GSF_BRIDGE,

	GSF_TOWNHOUSE,

typedef void (*SpecialSpriteHandler)(byte *buf, int len);

 */

	GMS_NOTICE,

	GMS_WARN,

	GMS_ERROR,

	GMS_FATAL,

{

	int export_severity = 0;

	char buf[1024];

	va_list va;

	va_start(va, str);

	va_end(va);

	export_severity = 2 - (severity == GMS_FATAL ? 2 : severity);

}

{

	return file;

}

{

	return file;

}

		case 0x08:

		{	/* Class ID */

			FOR_EACH_OBJECT {

				uint32 classid;

				/* classid, for a change, is always little-endian */

		case 0x09:

		{	/* Define sprite layout */

			FOR_EACH_OBJECT {

				int t;

				stat->tiles = grf_load_byte(&buf);

		case 0x0a:

		{	/* Copy sprite layout */

			FOR_EACH_OBJECT {

				byte srcid = grf_load_byte(&buf);

				int t;

				stat->tiles = srcstat->tiles;

		case 0x0C:

		{	/* Platforms number */

			FOR_EACH_OBJECT {

				stat->allowed_platforms = ~grf_load_byte(&buf);

			}

		case 0x0D:

		{	/* Platforms length */

			FOR_EACH_OBJECT {

				stat->allowed_lengths = ~grf_load_byte(&buf);

			}

		case 0x0e:

		{	/* Define custom layout */

			FOR_EACH_OBJECT {

				while (buf < *bufp + len) {

					byte length = grf_load_byte(&buf);

	return ret;

}

/* Action 0x00 */

static void VehicleChangeInfo(byte *buf, int len)

		}

		}

	}

}

#undef FOR_EACH_OBJECT

	/* XXX: For stations, these two are "little cargo" and "lotsa cargo" sets. */

	uint8 numloaded;

	uint8 numloading;

	byte *loaded_ptr;

	byte *loading_ptr;

	int i;

	numloading = buf[4];

	if (numloaded == 0x81 || numloaded == 0x82) {

		uint16 groupid;

		int i;

		if (setid >= _cur_grffile->spritegroups_count) {

			_cur_grffile->spritegroups_count = setid + 1;

		}

		group = &_cur_grffile->spritegroups[setid];

		group->type = SGT_DETERMINISTIC;

		dg = &group->g.determ;

		return;

	} else if (numloaded == 0x80 || numloaded == 0x83) {

		int i;

		/* This stuff is getting actually evaluated in

		if (setid >= _cur_grffile->spritegroups_count) {

			_cur_grffile->spritegroups_count = setid + 1;

		}

		group = &_cur_grffile->spritegroups[setid];

	if (setid >= _cur_grffile->spritegroups_count) {

		_cur_grffile->spritegroups_count = setid + 1;

	}

	group = &_cur_grffile->spritegroups[setid];

	group->type = SGT_REAL;

	rg = &group->g.real;

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

			uint8 stid = buf[3 + i];

			byte *bp = &buf[4 + idcount];

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

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

				uint8 stid = buf[3 + i];

				stat->spritegroup[0] = _cur_grffile->spritegroups[groupid];

				stat->grfid = _cur_grffile->grfid;

			param_val = _opt.road_side << 4;

			break;

		case 0x88: {  /* see if specified GRFID is active */

			file = GetFileByGRFID(cond_val);

			param_val = (file != NULL);

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

		uint32 grfid = grf_load_dword(&buf);

		/* Unset activation flag */

		if (file != NULL) {

void InitNewGRFFile(const char *filename, int sprite_offset)

{

	newfile = GetFileByFilename(filename);

	if (newfile != NULL) {

		return;

	}

	if (newfile == NULL)

		error ("Out of memory");

#include "sprite.h"

#include "station.h"

struct GRFFile {

	char *filename;

	uint32 grfid;

	uint16 flags;

	uint16 sprite_offset;

	/* A sprite group contains all sprites of a given vehicle (or multiple

	 * vehicles) when carrying given cargo. It consists of several sprite

	int spriteset_feature;

	int spritegroups_count;

};

extern int _grffile_count;

void InitNewGRFFile(const char *filename, int sprite_offset);

void DecodeSpecialSprite(const char *filename, int num, int spriteid, int stage);

		if (!IS_RAIL_DEPOT(m5) && IS_RAIL_WAYPOINT(m5) && _map3_lo[ti->tile]&16) {

			// look for customization

			if (stat) {

				DrawTileSeqStruct const *seq;

void DrawWaypointSprite(int x, int y, int stat_id, int railtype)

{

	uint32 relocation;

	DrawTileSprites *cust;

	DrawTileSeqStruct const *seq;

	AllocateWindowDesc(&_patches_selection_desc);

}

enum {

	NEWGRF_WND_PROC_OFFSET_TOP_WIDGET = 14,

	case WE_PAINT: {

		int x, y = NEWGRF_WND_PROC_OFFSET_TOP_WIDGET;

		uint16 i = 0;

		DrawWindowWidgets(w);

	{ // little helper function to calculate _grffile_count

	  // should be REMOVED once _grffile_count is calculated at loading

		_grffile_count = 0;

		while (c != NULL) {

			_grffile_count++;

#include "sprite.h"

{

	int i;

	}

	for (i = 0; i < dsg->num_ranges; i++) {

		if (range->low <= value && value <= range->high)

			return &range->group;

	}

}

{

	byte mask;

	byte index;

	return &rsg->groups[index];

}

{

	byte match = rsg->triggers & (*waiting_triggers | triggers);

	bool res;

/* This is for custom sprites: */

	// XXX: Would anyone ever need more than 16 spritesets? Maybe we should

	// use even less, now we take whole 8kb for custom sprites table, oh my!

	byte sprites_per_set; // means number of directions - 4 or 8

	uint16 loaded[16]; // sprite ids

	byte loading_count;

	uint16 loading[16]; // sprite ids

/* Shared by deterministic and random groups. */

	VSG_SCOPE_SELF,

	// Engine of consists for vehicles, city for stations.

	VSG_SCOPE_PARENT,

	// Take this variable:

	byte variable;

	// Do this with it:

	byte and_mask;

	// Then do this with it:

	byte add_val;

	byte divmod_val;

	// And apply it to this:

	byte num_ranges;

	// Dynamically allocated, this is the sole owner

	// Take this object:

	// Check for these triggers:

	byte triggers;

	// Look for this in the per-object randomized bitmask:

	byte num_groups; // must be power of 2

	// Take the group with appropriate index:

struct SpriteGroup {

	union {

	} g;

};

struct DeterministicSpriteGroupRange {

	byte low;

	byte high;

};

/* This takes randomized bitmask (probably associated with

 * vehicle/station/whatever) and chooses corresponding SpriteGroup

 * accordingly to the given RandomizedSpriteGroup. */

/* Triggers given RandomizedSpriteGroup with given bitmask and returns and-mask

 * of random bits to be reseeded, or zero if there were no triggers matched

 * (then they are |ed to @waiting_triggers instead). */

#endif

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

typedef byte *StationLayout;