_engine_custom_sprites[engine][cargo] = *group;

}

{

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

	switch (spritegroup->type) {

		case SGT_REAL:

		case SGT_DETERMINISTIC: {

			DeterministicSpriteGroup *dsg = &spritegroup->g.determ;

			int value = -1;

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

				/* General property */

				value = GetDeterministicSpriteValue(dsg->variable);

			} else {

					} else {

						target = dsg->default_group;

					}

				}

				if (dsg->var_scope == VSG_SCOPE_PARENT) {

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

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

		}

		case SGT_RANDOMIZED: {

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

			}

			if (rsg->var_scope == VSG_SCOPE_PARENT) {

					veh = GetFirstVehicleInChain(veh);

			}

		}

		default:

	}

	group = GetVehicleSpriteGroup(engine, v);

		// This group is empty but perhaps there'll be a default one.

		                                (resolve_callback) ResolveVehicleSpriteGroup);

	}

	if (!rsg->sprites_per_set) {

		// This group is empty. This function users should therefore

		// look up the sprite number in _engine_original_sprites.

	return r;

}

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

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

extern int _custom_sprites_base;

{

	if (spritegroup->type == SGT_RANDOMIZED) {

		_vsg_bits_to_reseed |= RandomizedSpriteGroupTriggeredBits(

		);

	}

}

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

{

	RealSpriteGroup *rsg;

	byte new_random_bits;

	_vsg_random_triggers = trigger;

	_vsg_bits_to_reseed = 0;

	                                (resolve_callback) TriggerVehicleSpriteGroup);

		// This group turned out to be empty but perhaps there'll be a default one.

						(resolve_callback) TriggerVehicleSpriteGroup);

	}

	new_random_bits = Random();

	veh->random_bits &= ~_vsg_bits_to_reseed;

	veh->random_bits |= (first ? new_random_bits : base_random_bits) & _vsg_bits_to_reseed;

	NUM_GLOBAL_CID  =  31

};

VARDEF const uint32 _default_refitmasks[NUM_VEHICLE_TYPES];

VARDEF const CargoID _global_cargo_id[NUM_LANDSCAPE][NUM_CARGO];

VARDEF const uint32 _landscape_global_cargo_mask[NUM_LANDSCAPE];

void SetCustomEngineSprites(byte engine, byte cargo, struct SpriteGroup *group);

// loaded is in percents, overriding_engine 0xffff is none

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

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

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

#undef FOR_EACH_OBJECT

/* Action 0x01 */

static void NewSpriteSet(byte *buf, int len)

			dg->divmod_val = grf_load_byte(&buf);

		}

		dg->num_ranges = grf_load_byte(&buf);

		dg->ranges = calloc(dg->num_ranges, sizeof(*dg->ranges));

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

			groupid = grf_load_word(&buf);

				/* This doesn't exist for us. */

				grf_load_word(&buf); // skip range

				i--; dg->num_ranges--;

				continue;

			/* XXX: If multiple surreal sets attach a surreal

			 * set this way, we are in trouble. */

			dg->ranges[i].group = _cur_grffile->spritegroups[groupid];

			dg->ranges[i].low = grf_load_byte(&buf);

			dg->ranges[i].high = grf_load_byte(&buf);

		}

		groupid = grf_load_word(&buf);

			/* This spritegroup stinks. */

			free(dg->ranges), dg->ranges = NULL;

			grfmsg(GMS_WARN, "NewSpriteGroup(%02x:0x%x): Default groupid %04x is cargo callback or unknown, ignoring spritegroup.", setid, numloaded, groupid);

			return;

		dg->default_group = malloc(sizeof(*dg->default_group));

		memcpy(dg->default_group, &_cur_grffile->spritegroups[groupid], sizeof(*dg->default_group));

		return;

	SpriteGroup *groups;

} RandomizedSpriteGroup;

typedef enum SpriteGroupType {

	SGT_REAL,

	SGT_DETERMINISTIC,

	SGT_RANDOMIZED,

} SpriteGroupType;

struct SpriteGroup {

		RealSpriteGroup real;

		DeterministicSpriteGroup determ;

		RandomizedSpriteGroup random;

	} g;

};

	cost = 0;

	num = 0;

	do {

		/* XXX: We also refit all the attached wagons en-masse if they

		 * can be refitted. This is how TTDPatch does it.  TODO: Have

		if (v->cargo_cap != 0) {

			RailVehicleInfo *rvi = RailVehInfo(v->engine_type);

			CargoID old_cid = rvi->cargo_type;

			 * can carry twice as much mail/goods as normal cargo,

			 * and four times as much passengers */

			(old_cid == CT_PASSENGERS) ||

			(amount <<= 1, old_cid == CT_MAIL || old_cid == CT_GOODS) ||

			(amount <<= 1, true);

			(new_cid == CT_PASSENGERS) ||

			(amount >>= 1, new_cid == CT_MAIL || new_cid == CT_GOODS) ||

			(amount >>= 1, true);

			if (new_cid != v->cargo_type)

				cost += (_price.build_railvehicle >> 8);

			num += amount;

				v->cargo_type = new_cid;

				v->cargo_cap = amount;

				InvalidateWindow(WC_VEHICLE_DETAILS, v->index);

			}

		}

	// SkipStoppedInDepotCheck is called by CmdReplace and it should only apply to the single car it is called for