};

struct CargoSpec {

	uint8 bitnum;

	CargoLabel label;

	uint8 legend_colour;

	uint8 rating_colour;

	uint8 weight;

	uint16 initial_payment;

	uint8 transit_days[2];

	StringID quantifier;

	StringID abbrev;

	SpriteID sprite;

	uint16 classes;

	const struct SpriteGroup *group;

	bool IsValid() const;

};

		CargoSpec *cs = &_cargo[cid + i];

		switch (prop) {

			case 0x08: /* Bit number of cargo */

				cs->bitnum = grf_load_byte(&buf);

				if (cs->IsValid()) {

					SetBit(_cargo_mask, cid + i);

				} else {

					ClrBit(_cargo_mask, cid + i);

				}

				break;

		if (cf >= CF_END) {

			grfmsg(1, "CanalMapSpriteGroup: Canal subset %d out of range, skipping", cf);

			continue;

		}

		_water_feature[cf].group = _cur_grffile->spritegroups[groupid];

	}

}

static void StationMapSpriteGroup(byte *buf, uint8 idcount)

		if (cid >= NUM_CARGO) {

			grfmsg(1, "CargoMapSpriteGroup: Cargo ID %d out of range, skipping", cid);

			continue;

		}

		CargoSpec *cs = &_cargo[cid];

		cs->group = _cur_grffile->spritegroups[groupid];

	}

}

/* Action 0x03 */

	if (group->g.real.num_loaded == 0) return NULL;

	return group->g.real.loaded[0];

}

{

	res->GetRandomBits = &CanalGetRandomBits;

	res->GetTriggers   = &CanalGetTriggers;

	res->SetTriggers   = &CanalSetTriggers;

	res->GetVariable   = &CanalGetVariable;

	res->ResolveReal   = &CanalResolveReal;

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

SpriteID GetCanalSprite(CanalFeature feature, TileIndex tile)

{

	ResolverObject object;

	const SpriteGroup *group;

	group = Resolve(_water_feature[feature].group, &object);

	if (group == NULL || group->type != SGT_RESULT) return 0;

	return group->g.result.sprite;

}

	CF_END,

};

struct WaterFeature {

	const SpriteGroup *group;

	uint8 callbackmask;

	uint8 flags;

};

/** Table of canal 'feature' sprite groups */

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

SpriteID GetCustomCargoSprite(const CargoSpec *cs)

{

	const SpriteGroup *group;

	assert(object->trigger != 0);

	if (v != NULL) v->waiting_triggers = triggers;

}

static uint8 LiveryHelper(EngineID engine, const Vehicle *v)

{

	const Livery *l;

	if (v == NULL) {

		if (!IsValidPlayerID(_current_player)) return 0;

			case 0x43: return _current_player | (LiveryHelper(object->u.vehicle.self_type, NULL) << 24); // Owner information

			case 0x46: return 0;               // Motion counter

			case 0x48: return GetEngine(object->u.vehicle.self_type)->flags; // Vehicle Type Info

			case 0x49: return _cur_year; // 'Long' format build year

			case 0xC4: return Clamp(_cur_year, ORIGINAL_BASE_YEAR, ORIGINAL_MAX_YEAR) - ORIGINAL_BASE_YEAR; // Build year

			case 0xDA: return INVALID_VEHICLE; // Next vehicle

		}

		*available = false;

		return UINT_MAX;

	}

				for (; v != NULL; v = v->Next()) {

					if (GetEngine(v->engine_type)->internal_id == parameter) count++;

				}

				return count;

			}

		case 0xFE:

		case 0xFF: {

			uint16 modflags = 0;

			if (v->type == VEH_TRAIN) {

				const Vehicle *u = IsTrainWagon(v) && HasBit(v->vehicle_flags, VRF_POWEREDWAGON) ? v->First() : v;

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

/** Retrieve the SpriteGroup for the specified vehicle.

 * If the vehicle is not specified, the purchase list group for the engine is

 * chosen. For trains, an additional engine override lookup is performed.

	if (group->g.real.num_loaded == 0) return NULL;

	return group->g.real.loaded[0];

}

{

	res->GetRandomBits = &GenericCallbackGetRandomBits;

	res->GetTriggers   = &GenericCallbackGetTriggers;

	res->SetTriggers   = &GenericCallbackSetTriggers;

	res->GetVariable   = &GenericCallbackGetVariable;

	res->ResolveReal   = &GenericCallbackResolveReal;

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

/** Follow a generic feature callback list and return the first successful

 * answer

 * @param feature GRF Feature of callback

 * 'Execute' an AI purchase selection callback

 */

uint16 GetAiPurchaseCallbackResult(uint8 feature, CargoID cargo_type, uint8 default_selection, IndustryType src_industry, IndustryType dst_industry, uint8 distance, AIConstructionEvent event, uint8 count, uint8 station_size, const GRFFile **file)

{

	ResolverObject object;

	object.callback = CBID_GENERIC_AI_PURCHASE_SELECTION;

	object.u.generic.cargo_type        = cargo_type;

	object.u.generic.default_selection = default_selection;

	object.u.generic.src_industry      = src_industry;

	object.u.generic.dst_industry      = dst_industry;

	town_id_count    = town->building_counts.id_count[house_id];

	town_class_count = town->building_counts.class_count[class_id];

	return map_class_count << 24 | town_class_count << 16 | map_id_count << 8 | town_id_count;

}

uint32 GetNearbyTileInformation(byte parameter, TileIndex tile)

{

	tile = GetNearbyTile(parameter, tile);

	return GetNearbyTileInformation(tile);

}

		/* Cargo acceptance history of nearby stations */

		/*case 0x64: not implemented yet */

		/* Distance test for some house types */

		case 0x65: return GetDistanceFromNearbyHouse(parameter, tile, object->u.house.house_id);

	}

	DEBUG(grf, 1, "Unhandled house property 0x%X", variable);

	*available = false;

	return UINT_MAX;

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

uint16 GetHouseCallback(CallbackID callback, uint32 param1, uint32 param2, HouseID house_id, Town *town, TileIndex tile)

{

	ResolverObject object;

	const SpriteGroup *group;

	if (grf_type == IT_INVALID) return IT_INVALID;

	if (!HasBit(grf_type, 7)) return GB(grf_type, 0, 6);

	return _industry_mngr.GetID(GB(grf_type, 0, 6), grf_id);

}

/**

 * Finds the distance for the closest tile with water/land given a tile

 * @param tile  the tile to find the distance too

 * @param water whether to find water or land

 * @note FAILS when an industry should be seen as water

 */

		return TownGetVariable(variable, parameter, available, t);

	}

	if (industry == NULL) {

		/* industry does not exist, only use those variables that are "safe" */

		switch (variable) {

			/* Manhattan distance of closes dry/water tile */

			case 0x43: return GetClosestWaterDistance(tile, (indspec->behaviour & INDUSTRYBEH_BUILT_ONWATER) == 0);

		}

		DEBUG(grf, 1, "Unhandled property 0x%X (no available industry) in callback 0x%x", variable, object->callback);

		case 0x67:

		case 0x68: return GetCountAndDistanceOfClosestInstance(parameter, variable == 0x68 ? GB(GetRegister(0x101), 0, 8) : 0, industry);

		/* Get a variable from the persistent storage */

		case 0x7C: return industry->psa.Get(parameter);

		/* Industry structure access*/

		case 0x80: return industry->xy;

		case 0x81: return GB(industry->xy, 8, 8);

		/* Pointer to the town the industry is associated with */

		case 0x82: return industry->town->index;

		case 0x83:

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

uint16 GetIndustryCallback(CallbackID callback, uint32 param1, uint32 param2, Industry *industry, IndustryType type, TileIndex tile)

{

	ResolverObject object;

	const SpriteGroup *group;

#include "animated_tile_func.h"

#include "water.h"

#include "table/sprites.h"

#include "table/strings.h"

/**

 * Based on newhouses equivalent, but adapted for newindustries

 * @param parameter from callback.  It's in fact a pair of coordinates

 * @param tile TileIndex from which the callback was initiated

 * @param index of the industry been queried for

 * @return a construction of bits obeying the newgrf format

			}

			return 0xFFFFFFFF;

		}

		/* Get industry tile ID at offset */

		case 0x62 : return GetIndustryIDAtOffset(GetNearbyTile(parameter, tile), inds);

	}

	DEBUG(grf, 1, "Unhandled industry tile property 0x%X", variable);

	*available = false;

	return (uint32)-1;

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

void IndustryDrawTileLayout(const TileInfo *ti, const SpriteGroup *group, byte rnd_color, byte stage, IndustryGfx gfx)

{

	const DrawTileSprites *dts = group->g.layout.dts;

	const DrawTileSeqStruct *dtss;

		case 0x1C: return object->last_value;

		case 0x5F: return (object->GetRandomBits(object) << 8) | object->GetTriggers(object);

		case 0x7D: return _temp_store.Get(parameter);

		/* Not a common variable, so evalute the feature specific variables */

		default: return object->GetVariable(object, variable, parameter, available);

	}

}

	VarSpriteGroupScope scope;

	bool info_view; ///< Indicates if the item is being drawn in an info window

	BaseStorageArray *psa; ///< The persistent storage array of this resolved object.

	union {

		struct {

			const struct Vehicle *self;

			const struct Vehicle *parent;

			EngineID self_type;

		} vehicle;

	res->callback_param1 = 0;

	res->callback_param2 = 0;

	res->last_value      = 0;

	res->trigger         = 0;

	res->reseed          = 0;

	res->count           = 0;

}

static const SpriteGroup *ResolveStation(ResolverObject *object)

{

	const SpriteGroup *group;

	CargoID ctype = CT_DEFAULT_NA;

/* $Id$ */

/** @file cargo_const.h Table of all default cargo types */

#define MK(bt, label, c, e, f, g, h, fr, te, ks1, ks2, ks3, ks4, ks5, l, m) \

static const CargoSpec _default_cargo[] = {

	MK(  0, 'PASS', 152,  1, 3185,  0,  24, false, TE_PASSENGERS,

		STR_000F_PASSENGERS,     STR_002F_PASSENGER,      STR_PASSENGERS, STR_QUANTITY_PASSENGERS,   STR_ABBREV_PASSENGERS,

		SPR_CARGO_PASSENGER,     CC_PASSENGERS  ),

	MK(  1, 'COAL',  32, 16, 5916,  7, 255, true,  TE_NONE,