mirror
/
OpenTTD
mirror of https://github.com/OpenTTD/OpenTTD
1
0
Fork 0
Code Issues

(svn r24682) -Codechange: Add resolver classes for houses.

release/1.3
alberth 2012-11-10 20:40:05 +00:00
parent 0885a2370a
commit d7b62da87b
4 changed files with 126 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

199
src/newgrf_house.cpp
View File

@ -29,6 +29,39 @@ static HouseClassMapping _class_mapping[HOUSE_CLASS_MAX];
HouseOverrideManager _house_mngr(NEW_HOUSE_OFFSET, HOUSE_MAX, INVALID_HOUSE_ID); HouseOverrideManager _house_mngr(NEW_HOUSE_OFFSET, HOUSE_MAX, INVALID_HOUSE_ID);
HouseScopeResolver::HouseScopeResolver(ResolverObject *ro, HouseID house_id, TileIndex tile, Town *town,
bool not_yet_constructed, uint8 initial_random_bits, uint32 watched_cargo_triggers)
: ScopeResolver(ro)
{
this->house_id = house_id;
this->tile = tile;
this->town = town;
this->not_yet_constructed = not_yet_constructed;
this->initial_random_bits = initial_random_bits;
this->watched_cargo_triggers = watched_cargo_triggers;
}
/**
* Retrieve the grf file associated with a house.
* @param house_id House to query.
* @return The associated GRF file (may be \c NULL).
*/
static const GRFFile *GetHouseSpecGrf(HouseID house_id)
{
const HouseSpec *hs = HouseSpec::Get(house_id);
return (hs != NULL) ? hs->grf_prop.grffile : NULL;
}
HouseResolverObject::HouseResolverObject(HouseID house_id, TileIndex tile, Town *town,
CallbackID callback, uint32 param1, uint32 param2,
bool not_yet_constructed, uint8 initial_random_bits, uint32 watched_cargo_triggers)
: ResolverObject(GetHouseSpecGrf(house_id), callback, param1, param2),
house_scope(this, house_id, tile, town, not_yet_constructed, initial_random_bits, watched_cargo_triggers),
town_scope(this, town, not_yet_constructed) // Don't access StorePSA if house is not yet constructed.
{
}
HouseClassID AllocateHouseClassID(byte grf_class_id, uint32 grfid) HouseClassID AllocateHouseClassID(byte grf_class_id, uint32 grfid)
{ {
/* Start from 1 because 0 means that no class has been assigned. */ /* Start from 1 because 0 means that no class has been assigned. */
@ -98,27 +131,24 @@ void DecreaseBuildingCount(Town *t, HouseID house_id)
if (_building_counts.class_count[class_id] > 0) _building_counts.class_count[class_id]--; if (_building_counts.class_count[class_id] > 0) _building_counts.class_count[class_id]--;
} }
static uint32 HouseGetRandomBits(const ResolverObject *object) /* virtual */ uint32 HouseScopeResolver::GetRandomBits() const
{ {
/* Note: Towns build houses over houses. So during construction checks 'tile' may be a valid but unrelated house. */ /* Note: Towns build houses over houses. So during construction checks 'tile' may be a valid but unrelated house. */
TileIndex tile = object->u.house.tile; assert(IsValidTile(this->tile) && (this->not_yet_constructed || IsTileType(this->tile, MP_HOUSE)));
assert(IsValidTile(tile) && (object->u.house.not_yet_constructed || IsTileType(tile, MP_HOUSE))); return this->not_yet_constructed ? this->initial_random_bits : GetHouseRandomBits(this->tile);
return object->u.house.not_yet_constructed ? object->u.house.initial_random_bits : GetHouseRandomBits(tile);
} }
static uint32 HouseGetTriggers(const ResolverObject *object) /* virtual */ uint32 HouseScopeResolver::GetTriggers() const
{ {
/* Note: Towns build houses over houses. So during construction checks 'tile' may be a valid but unrelated house. */ /* Note: Towns build houses over houses. So during construction checks 'tile' may be a valid but unrelated house. */
TileIndex tile = object->u.house.tile; assert(IsValidTile(this->tile) && (this->not_yet_constructed || IsTileType(this->tile, MP_HOUSE)));
assert(IsValidTile(tile) && (object->u.house.not_yet_constructed || IsTileType(tile, MP_HOUSE))); return this->not_yet_constructed ? 0 : GetHouseTriggers(this->tile);
return object->u.house.not_yet_constructed ? 0 : GetHouseTriggers(tile);
} }
static void HouseSetTriggers(const ResolverObject *object, int triggers) /* virtual */ void HouseScopeResolver::SetTriggers(int triggers) const
{ {
TileIndex tile = object->u.house.tile; assert(!this->not_yet_constructed && IsValidTile(this->tile) && IsTileType(this->tile, MP_HOUSE));
assert(!object->u.house.not_yet_constructed && IsValidTile(tile) && IsTileType(tile, MP_HOUSE)); SetHouseTriggers(this->tile, triggers);
SetHouseTriggers(tile, triggers);
} }
static uint32 GetNumHouses(HouseID house_id, const Town *town) static uint32 GetNumHouses(HouseID house_id, const Town *town)
@ -259,75 +289,65 @@ static uint32 GetDistanceFromNearbyHouse(uint8 parameter, TileIndex tile, HouseI
} }
/** /**
* HouseGetVariable(): * @note Used by the resolver to get values for feature 07 deterministic spritegroups.
*
* Used by the resolver to get values for feature 07 deterministic spritegroups.
*/ */
static uint32 HouseGetVariable(const ResolverObject *object, byte variable, uint32 parameter, bool *available) /* virtual */ uint32 HouseScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
{ {
Town *town = object->u.house.town;
TileIndex tile = object->u.house.tile;
HouseID house_id = object->u.house.house_id;
if (object->scope == VSG_SCOPE_PARENT) {
return TownGetVariable(variable, parameter, available, town, object->grffile);
}
switch (variable) { switch (variable) {
/* Construction stage. */ /* Construction stage. */
case 0x40: return (IsTileType(tile, MP_HOUSE) ? GetHouseBuildingStage(tile) : 0) | TileHash2Bit(TileX(tile), TileY(tile)) << 2; case 0x40: return (IsTileType(this->tile, MP_HOUSE) ? GetHouseBuildingStage(this->tile) : 0) | TileHash2Bit(TileX(this->tile), TileY(this->tile)) << 2;
/* Building age. */ /* Building age. */
case 0x41: return IsTileType(tile, MP_HOUSE) ? GetHouseAge(tile) : 0; case 0x41: return IsTileType(this->tile, MP_HOUSE) ? GetHouseAge(this->tile) : 0;
/* Town zone */ /* Town zone */
case 0x42: return GetTownRadiusGroup(town, tile); case 0x42: return GetTownRadiusGroup(this->town, this->tile);
/* Terrain type */ /* Terrain type */
case 0x43: return GetTerrainType(tile); case 0x43: return GetTerrainType(this->tile);
/* Number of this type of building on the map. */ /* Number of this type of building on the map. */
case 0x44: return GetNumHouses(house_id, town); case 0x44: return GetNumHouses(this->house_id, this->town);
/* Whether the town is being created or just expanded. */ /* Whether the town is being created or just expanded. */
case 0x45: return _generating_world ? 1 : 0; case 0x45: return _generating_world ? 1 : 0;
/* Current animation frame. */ /* Current animation frame. */
case 0x46: return IsTileType(tile, MP_HOUSE) ? GetAnimationFrame(tile) : 0; case 0x46: return IsTileType(this->tile, MP_HOUSE) ? GetAnimationFrame(this->tile) : 0;
/* Position of the house */ /* Position of the house */
case 0x47: return TileY(tile) << 16 | TileX(tile); case 0x47: return TileY(this->tile) << 16 | TileX(this->tile);
/* Building counts for old houses with id = parameter. */ /* Building counts for old houses with id = parameter. */
case 0x60: return parameter < NEW_HOUSE_OFFSET ? GetNumHouses(parameter, town) : 0; case 0x60: return parameter < NEW_HOUSE_OFFSET ? GetNumHouses(parameter, this->town) : 0;
/* Building counts for new houses with id = parameter. */ /* Building counts for new houses with id = parameter. */
case 0x61: { case 0x61: {
const HouseSpec *hs = HouseSpec::Get(house_id); const HouseSpec *hs = HouseSpec::Get(this->house_id);
if (hs->grf_prop.grffile == NULL) return 0; if (hs->grf_prop.grffile == NULL) return 0;
HouseID new_house = _house_mngr.GetID(parameter, hs->grf_prop.grffile->grfid); HouseID new_house = _house_mngr.GetID(parameter, hs->grf_prop.grffile->grfid);
return new_house == INVALID_HOUSE_ID ? 0 : GetNumHouses(new_house, town); return new_house == INVALID_HOUSE_ID ? 0 : GetNumHouses(new_house, this->town);
} }
/* Land info for nearby tiles. */ /* Land info for nearby tiles. */
case 0x62: return GetNearbyTileInformation(parameter, tile, object->grffile->grf_version >= 8); case 0x62: return GetNearbyTileInformation(parameter, this->tile, this->ro->grffile->grf_version >= 8);
/* Current animation frame of nearby house tiles */ /* Current animation frame of nearby house tiles */
case 0x63: { case 0x63: {
TileIndex testtile = GetNearbyTile(parameter, tile); TileIndex testtile = GetNearbyTile(parameter, this->tile);
return IsTileType(testtile, MP_HOUSE) ? GetAnimationFrame(testtile) : 0; return IsTileType(testtile, MP_HOUSE) ? GetAnimationFrame(testtile) : 0;
} }
/* Cargo acceptance history of nearby stations */ /* Cargo acceptance history of nearby stations */
case 0x64: { case 0x64: {
CargoID cid = GetCargoTranslation(parameter, object->grffile); CargoID cid = GetCargoTranslation(parameter, this->ro->grffile);
if (cid == CT_INVALID) return 0; if (cid == CT_INVALID) return 0;
/* Extract tile offset. */ /* Extract tile offset. */
int8 x_offs = GB(GetRegister(0x100), 0, 8); int8 x_offs = GB(GetRegister(0x100), 0, 8);
int8 y_offs = GB(GetRegister(0x100), 8, 8); int8 y_offs = GB(GetRegister(0x100), 8, 8);
TileIndex testtile = TILE_MASK(tile + TileDiffXY(x_offs, y_offs)); TileIndex testtile = TILE_MASK(this->tile + TileDiffXY(x_offs, y_offs));
StationFinder stations(TileArea(testtile, 1, 1)); StationFinder stations(TileArea(testtile, 1, 1));
const StationList *sl = stations.GetStations(); const StationList *sl = stations.GetStations();
@ -343,31 +363,31 @@ static uint32 HouseGetVariable(const ResolverObject *object, byte variable, uint
} }
/* Cargo triggered CB 148? */ /* Cargo triggered CB 148? */
if (HasBit(object->u.house.watched_cargo_triggers, cid)) SetBit(res, 4); if (HasBit(this->watched_cargo_triggers, cid)) SetBit(res, 4);
return res; return res;
} }
/* Distance test for some house types */ /* Distance test for some house types */
case 0x65: return GetDistanceFromNearbyHouse(parameter, tile, object->u.house.house_id); case 0x65: return GetDistanceFromNearbyHouse(parameter, this->tile, this->house_id);
/* Class and ID of nearby house tile */ /* Class and ID of nearby house tile */
case 0x66: { case 0x66: {
TileIndex testtile = GetNearbyTile(parameter, tile); TileIndex testtile = GetNearbyTile(parameter, this->tile);
if (!IsTileType(testtile, MP_HOUSE)) return 0xFFFFFFFF; if (!IsTileType(testtile, MP_HOUSE)) return 0xFFFFFFFF;
HouseSpec *hs = HouseSpec::Get(GetHouseType(testtile)); HouseSpec *hs = HouseSpec::Get(GetHouseType(testtile));
/* Information about the grf local classid if the house has a class */ /* Information about the grf local classid if the house has a class */
uint houseclass = 0; uint houseclass = 0;
if (hs->class_id != HOUSE_NO_CLASS) { if (hs->class_id != HOUSE_NO_CLASS) {
houseclass = (hs->grf_prop.grffile == object->grffile ? 1 : 2) << 8; houseclass = (hs->grf_prop.grffile == this->ro->grffile ? 1 : 2) << 8;
houseclass |= _class_mapping[hs->class_id].class_id; houseclass |= _class_mapping[hs->class_id].class_id;
} }
/* old house type or grf-local houseid */ /* old house type or grf-local houseid */
uint local_houseid = 0; uint local_houseid = 0;
if (house_id < NEW_HOUSE_OFFSET) { if (this->house_id < NEW_HOUSE_OFFSET) {
local_houseid = house_id; local_houseid = this->house_id;
} else { } else {
local_houseid = (hs->grf_prop.grffile == object->grffile ? 1 : 2) << 8; local_houseid = (hs->grf_prop.grffile == this->ro->grffile ? 1 : 2) << 8;
local_houseid |= hs->grf_prop.local_id; local_houseid |= hs->grf_prop.local_id;
} }
return houseclass << 16 | local_houseid; return houseclass << 16 | local_houseid;
@ -375,7 +395,7 @@ static uint32 HouseGetVariable(const ResolverObject *object, byte variable, uint
/* GRFID of nearby house tile */ /* GRFID of nearby house tile */
case 0x67: { case 0x67: {
TileIndex testtile = GetNearbyTile(parameter, tile); TileIndex testtile = GetNearbyTile(parameter, this->tile);
if (!IsTileType(testtile, MP_HOUSE)) return 0xFFFFFFFF; if (!IsTileType(testtile, MP_HOUSE)) return 0xFFFFFFFF;
HouseID house_id = GetHouseType(testtile); HouseID house_id = GetHouseType(testtile);
if (house_id < NEW_HOUSE_OFFSET) return 0; if (house_id < NEW_HOUSE_OFFSET) return 0;
@ -391,71 +411,21 @@ static uint32 HouseGetVariable(const ResolverObject *object, byte variable, uint
return UINT_MAX; return UINT_MAX;
} }
static const SpriteGroup *HouseResolveReal(const ResolverObject *object, const RealSpriteGroup *group) /* virtual */ const SpriteGroup *HouseResolverObject::ResolveReal(const RealSpriteGroup *group) const
{ {
/* Houses do not have 'real' groups */ /* Houses do not have 'real' groups */
return NULL; return NULL;
} }
/** uint16 GetHouseCallback(CallbackID callback, uint32 param1, uint32 param2, HouseID house_id, Town *town, TileIndex tile,
* Store a value into the persistent storage of the object's parent. bool not_yet_constructed, uint8 initial_random_bits, uint32 watched_cargo_triggers)
* @param object Object that we want to query.
* @param pos Position in the persistent storage to use.
* @param value Value to store.
*/
void HouseStorePSA(ResolverObject *object, uint pos, int32 value)
{ {
/* Houses have no persistent storage. */
if (object->scope != VSG_SCOPE_PARENT || object->u.house.not_yet_constructed) return;
/* Pass the request on to the town of the house */
TownStorePSA(object->u.house.town, object->grffile, pos, value);
}
/**
* NewHouseResolver():
*
* Returns a resolver object to be used with feature 07 spritegroups.
*/
static void NewHouseResolver(ResolverObject *res, HouseID house_id, TileIndex tile, Town *town)
{
res->GetRandomBits = HouseGetRandomBits;
res->GetTriggers = HouseGetTriggers;
res->SetTriggers = HouseSetTriggers;
res->GetVariable = HouseGetVariable;
res->ResolveRealMethod = HouseResolveReal;
res->StorePSA = HouseStorePSA;
res->u.house.tile = tile;
res->u.house.town = town;
res->u.house.house_id = house_id;
res->u.house.not_yet_constructed = false;
res->callback = CBID_NO_CALLBACK;
res->callback_param1 = 0;
res->callback_param2 = 0;
res->ResetState();
const HouseSpec *hs = HouseSpec::Get(house_id);
res->grffile = (hs != NULL ? hs->grf_prop.grffile : NULL);
}
uint16 GetHouseCallback(CallbackID callback, uint32 param1, uint32 param2, HouseID house_id, Town *town, TileIndex tile, bool not_yet_constructed, uint8 initial_random_bits, uint32 watched_cargo_triggers)
{
ResolverObject object;
const SpriteGroup *group;
assert(IsValidTile(tile) && (not_yet_constructed || IsTileType(tile, MP_HOUSE))); assert(IsValidTile(tile) && (not_yet_constructed || IsTileType(tile, MP_HOUSE)));
NewHouseResolver(&object, house_id, tile, town); HouseResolverObject object(house_id, tile, town, callback, param1, param2,
object.callback = callback; not_yet_constructed, initial_random_bits, watched_cargo_triggers);
object.callback_param1 = param1;
object.callback_param2 = param2;
object.u.house.not_yet_constructed = not_yet_constructed;
object.u.house.initial_random_bits = initial_random_bits;
object.u.house.watched_cargo_triggers = watched_cargo_triggers;
group = SpriteGroup::Resolve(HouseSpec::Get(house_id)->grf_prop.spritegroup[0], &object); const SpriteGroup *group = SpriteGroup::Resolve(HouseSpec::Get(house_id)->grf_prop.spritegroup[0], &object);
if (group == NULL) return CALLBACK_FAILED; if (group == NULL) return CALLBACK_FAILED;
return group->GetCallbackResult(); return group->GetCallbackResult();
@ -491,8 +461,6 @@ static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *grou
void DrawNewHouseTile(TileInfo *ti, HouseID house_id) void DrawNewHouseTile(TileInfo *ti, HouseID house_id)
{ {
const HouseSpec *hs = HouseSpec::Get(house_id); const HouseSpec *hs = HouseSpec::Get(house_id);
const SpriteGroup *group;
ResolverObject object;
if (ti->tileh != SLOPE_FLAT) { if (ti->tileh != SLOPE_FLAT) {
bool draw_old_one = true; bool draw_old_one = true;
@ -505,12 +473,10 @@ void DrawNewHouseTile(TileInfo *ti, HouseID house_id)
if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED); if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED);
} }
NewHouseResolver(&object, house_id, ti->tile, Town::GetByTile(ti->tile)); HouseResolverObject object(house_id, ti->tile, Town::GetByTile(ti->tile));
group = SpriteGroup::Resolve(hs->grf_prop.spritegroup[0], &object); const SpriteGroup *group = SpriteGroup::Resolve(hs->grf_prop.spritegroup[0], &object);
if (group == NULL || group->type != SGT_TILELAYOUT) { if (group != NULL && group->type == SGT_TILELAYOUT) {
return;
} else {
/* Limit the building stage to the number of stages supplied. */ /* Limit the building stage to the number of stages supplied. */
const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group; const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group;
byte stage = GetHouseBuildingStage(ti->tile); byte stage = GetHouseBuildingStage(ti->tile);
@ -623,8 +589,6 @@ bool NewHouseTileLoop(TileIndex tile)
static void DoTriggerHouse(TileIndex tile, HouseTrigger trigger, byte base_random, bool first) static void DoTriggerHouse(TileIndex tile, HouseTrigger trigger, byte base_random, bool first)
{ {
ResolverObject object;
/* We can't trigger a non-existent building... */ /* We can't trigger a non-existent building... */
assert(IsTileType(tile, MP_HOUSE)); assert(IsTileType(tile, MP_HOUSE));
@ -633,9 +597,7 @@ static void DoTriggerHouse(TileIndex tile, HouseTrigger trigger, byte base_rando
if (hs->grf_prop.spritegroup == NULL) return; if (hs->grf_prop.spritegroup == NULL) return;
NewHouseResolver(&object, hid, tile, Town::GetByTile(tile)); HouseResolverObject object(hid, tile, Town::GetByTile(tile), CBID_RANDOM_TRIGGER);
object.callback = CBID_RANDOM_TRIGGER;
object.trigger = trigger; object.trigger = trigger;
const SpriteGroup *group = SpriteGroup::Resolve(hs->grf_prop.spritegroup[0], &object); const SpriteGroup *group = SpriteGroup::Resolve(hs->grf_prop.spritegroup[0], &object);
@ -715,12 +677,3 @@ void WatchedCargoCallback(TileIndex tile, uint32 trigger_cargoes)
if (hs->building_flags & BUILDING_HAS_4_TILES) DoWatchedCargoCallback(TILE_ADDXY(north, 1, 1), tile, trigger_cargoes, r); if (hs->building_flags & BUILDING_HAS_4_TILES) DoWatchedCargoCallback(TILE_ADDXY(north, 1, 1), tile, trigger_cargoes, r);
} }
/**
* Resolve a house's spec and such so we can get a variable.
* @param ro The resolver object to fill.
* @param index The house tile to get the data from.
*/
void GetHouseResolver(ResolverObject *ro, uint index)
{
NewHouseResolver(ro, GetHouseType(index), index, Town::GetByTile(index));
}

43
src/newgrf_house.h
View File

@ -15,6 +15,46 @@
#include "newgrf_callbacks.h" #include "newgrf_callbacks.h"
#include "tile_cmd.h" #include "tile_cmd.h"
#include "house_type.h" #include "house_type.h"
#include "newgrf_spritegroup.h"
#include "newgrf_town.h"
struct HouseScopeResolver : public ScopeResolver {
HouseID house_id;
TileIndex tile;
Town *town; ///< Town of this house.
bool not_yet_constructed; ///< True for construction check.
uint16 initial_random_bits; ///< Random bits during construction checks.
uint32 watched_cargo_triggers; ///< Cargo types that triggered the watched cargo callback.
HouseScopeResolver(ResolverObject *ro, HouseID house_id, TileIndex tile, Town *town,
bool not_yet_constructed, uint8 initial_random_bits, uint32 watched_cargo_triggers);
/* virtual */ uint32 GetRandomBits() const;
/* virtual */ uint32 GetVariable(byte variable, uint32 parameter, bool *available) const;
/* virtual */ uint32 GetTriggers() const;
/* virtual */ void SetTriggers(int triggers) const;
};
/** Resolver object to be used for houses (feature 07 spritegroups). */
struct HouseResolverObject : public ResolverObject {
HouseScopeResolver house_scope;
TownScopeResolver town_scope;
HouseResolverObject(HouseID house_id, TileIndex tile, Town *town,
CallbackID callback = CBID_NO_CALLBACK, uint32 param1 = 0, uint32 param2 = 0,
bool not_yet_constructed = false, uint8 initial_random_bits = 0, uint32 watched_cargo_triggers = 0);
/* virtual */ ScopeResolver *GetScope(VarSpriteGroupScope scope = VSG_SCOPE_SELF, byte relative = 0)
{
switch (scope) {
case VSG_SCOPE_SELF: return &this->house_scope;
case VSG_SCOPE_PARENT: return &this->town_scope;
default: return &this->default_scope; // XXX ResolverObject::GetScope(scope, relative);
}
}
/* virtual */ const SpriteGroup *ResolveReal(const RealSpriteGroup *group) const;
};
/** /**
* Makes class IDs unique to each GRF file. * Makes class IDs unique to each GRF file.
@ -44,7 +84,8 @@ void DrawNewHouseTile(TileInfo *ti, HouseID house_id);
void AnimateNewHouseTile(TileIndex tile); void AnimateNewHouseTile(TileIndex tile);
void AnimateNewHouseConstruction(TileIndex tile); void AnimateNewHouseConstruction(TileIndex tile);
uint16 GetHouseCallback(CallbackID callback, uint32 param1, uint32 param2, HouseID house_id, Town *town, TileIndex tile, bool not_yet_constructed = false, uint8 initial_random_bits = 0, uint32 watched_cargo_triggers = 0); uint16 GetHouseCallback(CallbackID callback, uint32 param1, uint32 param2, HouseID house_id, Town *town, TileIndex tile,
bool not_yet_constructed = false, uint8 initial_random_bits = 0, uint32 watched_cargo_triggers = 0);
void WatchedCargoCallback(TileIndex tile, uint32 trigger_cargoes); void WatchedCargoCallback(TileIndex tile, uint32 trigger_cargoes);
bool CanDeleteHouse(TileIndex tile); bool CanDeleteHouse(TileIndex tile);

8
src/newgrf_spritegroup.h
View File

@ -364,14 +364,6 @@ struct ResolverObject {
CargoID cargo_type; CargoID cargo_type;
Axis axis; ///< Station axis, used only for the slope check callback. Axis axis; ///< Station axis, used only for the slope check callback.
} station; } station;
struct {
TileIndex tile;
Town *town; ///< Town of this house
HouseID house_id;
uint16 initial_random_bits; ///< Random bits during construction checks
bool not_yet_constructed; ///< True for construction check
uint32 watched_cargo_triggers; ///< Cargo types that triggered the watched cargo callback.
} house;
struct { struct {
TileIndex tile; TileIndex tile;
Industry *ind; Industry *ind;

9
src/table/newgrf_debug_data.h
View File

@ -9,6 +9,8 @@
/** @file newgrf_debug_data.h Data 'tables' for NewGRF debugging. */ /** @file newgrf_debug_data.h Data 'tables' for NewGRF debugging. */
#include "../newgrf_house.h"
/* Helper for filling property tables */ /* Helper for filling property tables */
#define NIP(prop, base, variable, type, name) { name, cpp_offsetof(base, variable), cpp_sizeof(base, variable), prop, type } #define NIP(prop, base, variable, type, name) { name, cpp_offsetof(base, variable), cpp_sizeof(base, variable), prop, type }
#define NIP_END() { NULL, 0, 0, 0, 0 } #define NIP_END() { NULL, 0, 0, 0, 0 }
@ -184,7 +186,12 @@ class NIHHouse : public NIHelper {
const void *GetSpec(uint index) const { return HouseSpec::Get(GetHouseType(index)); } const void *GetSpec(uint index) const { return HouseSpec::Get(GetHouseType(index)); }
void SetStringParameters(uint index) const { this->SetObjectAtStringParameters(STR_TOWN_NAME, GetTownIndex(index), index); } void SetStringParameters(uint index) const { this->SetObjectAtStringParameters(STR_TOWN_NAME, GetTownIndex(index), index); }
uint32 GetGRFID(uint index) const { return (this->IsInspectable(index)) ? HouseSpec::Get(GetHouseType(index))->grf_prop.grffile->grfid : 0; } uint32 GetGRFID(uint index) const { return (this->IsInspectable(index)) ? HouseSpec::Get(GetHouseType(index))->grf_prop.grffile->grfid : 0; }
void Resolve(ResolverObject *ro, uint32 index) const { extern void GetHouseResolver(ResolverObject *ro, uint index); GetHouseResolver(ro, index); }
/* virtual */ uint Resolve(uint index, uint var, uint param, bool *avail) const
{
HouseResolverObject ro(GetHouseType(index), index, Town::GetByTile(index));
return ro.GetScope(ro.scope)->GetVariable(var, param, avail);
}
}; };
static const NIFeature _nif_house = { static const NIFeature _nif_house = {