e->reliability = e->reliability_final;

	}

}

void AddTypeToEngines(void)

{

}

void StartupEngines(void)

{

	Engine *e;

	const EngineInfo *ei;

	SetupEngineNames();

		e->age = 0;

		e->railtype = ei->railtype_climates >> 4;

		e->flags = 0;

		e->player_avail = 0;

	wo->group = *group;

	wo->trains = trains;

	wo->train_id = malloc(trains);

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

}

{

	int i;

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

	// always just dedicate 65535 bytes for an [engine][train] trampoline

	// for O(1). Or O(logMlogN) and searching binary tree or smt. like

	// that. --pasky

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

		int j;

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

			if (wo->train_id[j] == overriding_engine)

				return &wo->group;

		}

	}

	return NULL;

}

// 0 - 28 are cargos, 29 is default, 30 is the advert (purchase list)

// (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)

static SpriteGroup _engine_custom_sprites[TOTAL_NUM_ENGINES][NUM_GLOBAL_CID];

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

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

	 * --pasky */

	_engine_custom_sprites[engine][cargo] = *group;

}

	const Vehicle *veh, uint16 callback_info, void *resolve_func); /* XXX data pointer used as function pointer */

	const Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

{

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

	switch (spritegroup->type) {

		case SGT_REAL:

		case SGT_CALLBACK:

			return spritegroup;

		case SGT_DETERMINISTIC: {

			int value = -1;

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

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

				/* Callback ID */

				value = callback_info & 0xFF;

					if (veh->type == VEH_Train)

						veh = GetFirstVehicleInChain(veh);

				}

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

					if (veh->type == VEH_Train) {

						byte chain_before = 0, chain_after = 0;

						while (u != veh) {

							chain_before++;

							if (dsg->variable == 0x41 && u->engine_type != veh->engine_type)

								chain_before = 0;

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

			//debug("Resolved variable %x: %d, %p", dsg->variable, value, callback);

			return resolve_func(target, veh, callback_info, resolve_func);

		}

		case SGT_RANDOMIZED: {

			if (veh == NULL) {

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

				assert(rsg->num_groups > 0);

				//debug("going for %p: %d", rsg->groups[0], rsg->groups[0].type);

				return resolve_func(&rsg->groups[0], NULL, callback_info, resolve_func);

		default:

			error("I don't know how to handle such a spritegroup %d!", spritegroup->type);

			return NULL;

	}

}

{

	byte cargo = GC_PURCHASE;

	if (v != NULL) {

		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];

		assert(cargo != GC_INVALID);

	}

	group = &_engine_custom_sprites[engine][cargo];

	if (v != NULL && v->type == VEH_Train) {

		if (overset != NULL) group = overset;

	}

	return group;

}

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

{

	byte cargo = GC_PURCHASE;

	byte loaded = 0;

	bool in_motion = 0;

	int totalsets, spriteset;

	int r;

 * Check if a wagon is currently using a wagon override

 * @param v The wagon to check

 * @return true if it is using an override, false otherwise

 */

bool UsesWagonOverride(const Vehicle *v) {

	assert(v->type == VEH_Train);

}

/**

 * Evaluates a newgrf callback

 * @param callback_info info about which callback to evaluate

 *  (bit 0-7)  = CallBack id of the callback to use, see CallBackId enum

 * @param engine Engine type of the vehicle to evaluate the callback for

 * @param vehicle The vehicle to evaluate the callback for, NULL if it doesnt exist (yet)

 * @return The value the callback returned, or CALLBACK_FAILED if it failed

 */

uint16 GetCallBackResult(uint16 callback_info, byte engine, const Vehicle *v)

{

	byte cargo = GC_DEFAULT;

	if (v != NULL)

		cargo = _global_cargo_id[_opt.landscape][v->cargo_type];

	group = &_engine_custom_sprites[engine][cargo];

	if (v != NULL && v->type == VEH_Train) {

		if (overset != NULL) group = overset;

	}

	group = ResolveVehicleSpriteGroup(group, v, callback_info, (resolve_callback) ResolveVehicleSpriteGroup);

// Global variables are evil, yes, but we would end up with horribly overblown

// calling convention otherwise and this should be 100% reentrant.

static byte _vsg_random_triggers;

static byte _vsg_bits_to_reseed;

	Vehicle *veh, uint16 callback_info, resolve_callback resolve_func)

{

	if (spritegroup->type == SGT_RANDOMIZED) {

		_vsg_bits_to_reseed |= RandomizedSpriteGroupTriggeredBits(

			&spritegroup->g.random,

			_vsg_random_triggers,

	return ResolveVehicleSpriteGroup(spritegroup, veh, callback_info, resolve_func);

}

static void DoTriggerVehicle(Vehicle *veh, VehicleTrigger trigger, byte base_random_bits, bool first)

{

	byte new_random_bits;

	_vsg_random_triggers = trigger;

	_vsg_bits_to_reseed = 0;

	group = TriggerVehicleSpriteGroup(GetVehicleSpriteGroup(veh->engine_type, veh), veh, 0,

	                                  (resolve_callback) TriggerVehicleSpriteGroup);

	return best_player;

}

void EnginesDailyLoop(void)

{

	if (_cur_year >= 130) return;

		if (e->flags & ENGINE_INTRODUCING) {

			if (e->flags & ENGINE_PREVIEWING) {

				if (e->preview_player != 0xFF && !--e->preview_wait) {

					e->flags &= ~ENGINE_PREVIEWING;

					DeleteWindowById(WC_ENGINE_PREVIEW, i);

					e->preview_player++;

void EnginesMonthlyLoop(void)

{

	Engine *e;

	if (_cur_year < 130) {

			// Age the vehicle

				e->age++;

				CalcEngineReliability(e);

			}

			if (!(e->flags & ENGINE_AVAILABLE) && (uint16)(_date - min(_date, 365)) >= e->intro_date) {

				// Introduce it to all players

	SLE_END()

};

static void Save_ENGN(void)

{

		SlSetArrayIndex(i);

	}

}

static void Load_ENGN(void)

{

	int index;

#include "openttd.h"

#include "sprite.h"

#include "variables.h"

{

	int i;

	value >>= dsg->shift_num; // This should bring us to the byte range.

	value &= dsg->and_mask;

			return 0;

		default:

			return -1;

	}

}

{

	byte mask;

	byte index;

	/* Noone likes mangling with bits, but you don't get around it here.

	 * Sorry. --pasky */

	mask = (rsg->num_groups - 1) << rsg->lowest_randbit;

	index = (random_bits & mask) >> rsg->lowest_randbit;

	assert(index < rsg->num_groups);

	return &rsg->groups[index];

}

	byte triggers, byte *waiting_triggers)

{

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

	bool res;

	if (rsg->cmp_mode == RSG_CMP_ANY) {

	byte high;

};

/* This takes value (probably of the variable specified in the group) and

 * chooses corresponding SpriteGroup accordingly to the given

 * DeterministicSpriteGroup. */

/* Get value of a common deterministic SpriteGroup variable. */

int GetDeterministicSpriteValue(byte var);

/* 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