OpenTTD Source 20250613-master-ga1786fa1f4
newgrf_industrytiles.cpp
Go to the documentation of this file.
1/*
2 * This file is part of OpenTTD.
3 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
4 * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
5 * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
6 */
7
10#include "stdafx.h"
11#include "debug.h"
12#include "landscape.h"
13#include "newgrf_badge.h"
15#include "newgrf_sound.h"
16#include "industry.h"
17#include "town.h"
18#include "command_func.h"
19#include "water.h"
21
22#include "table/strings.h"
23
24#include "safeguards.h"
25
35uint32_t GetNearbyIndustryTileInformation(uint8_t parameter, TileIndex tile, IndustryID index, bool signed_offsets, bool grf_version8)
36{
37 if (parameter != 0) tile = GetNearbyTile(parameter, tile, signed_offsets); // only perform if it is required
38 bool is_same_industry = (IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == index);
39
40 return GetNearbyTileInformation(tile, grf_version8) | (is_same_industry ? 1 : 0) << 8;
41}
42
54uint32_t GetRelativePosition(TileIndex tile, TileIndex ind_tile)
55{
56 uint8_t x = TileX(tile) - TileX(ind_tile);
57 uint8_t y = TileY(tile) - TileY(ind_tile);
58
59 return ((y & 0xF) << 20) | ((x & 0xF) << 16) | (y << 8) | x;
60}
61
62/* virtual */ uint32_t IndustryTileScopeResolver::GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const
63{
64 switch (variable) {
65 /* Construction state of the tile: a value between 0 and 3 */
66 case 0x40: return (IsTileType(this->tile, MP_INDUSTRY)) ? GetIndustryConstructionStage(this->tile) : 0;
67
68 /* Terrain type */
69 case 0x41: return GetTerrainType(this->tile);
70
71 /* Current town zone of the tile in the nearest town */
72 case 0x42: return to_underlying(GetTownRadiusGroup(ClosestTownFromTile(this->tile, UINT_MAX), this->tile));
73
74 /* Relative position */
75 case 0x43: return GetRelativePosition(this->tile, this->industry->location.tile);
76
77 /* Animation frame. Like house variable 46 but can contain anything 0..FF. */
78 case 0x44: return IsTileType(this->tile, MP_INDUSTRY) ? GetAnimationFrame(this->tile) : 0;
79
80 /* Land info of nearby tiles */
81 case 0x60: return GetNearbyIndustryTileInformation(parameter, this->tile,
82 this->industry == nullptr ? (IndustryID)IndustryID::Invalid() : this->industry->index, true, this->ro.grffile->grf_version >= 8);
83
84 /* Animation stage of nearby tiles */
85 case 0x61: {
86 TileIndex tile = GetNearbyTile(parameter, this->tile);
88 return GetAnimationFrame(tile);
89 }
90 return UINT_MAX;
91 }
92
93 /* Get industry tile ID at offset */
94 case 0x62: return GetIndustryIDAtOffset(GetNearbyTile(parameter, this->tile), this->industry, this->ro.grffile->grfid);
95
96 case 0x7A: return GetBadgeVariableResult(*this->ro.grffile, GetIndustryTileSpec(GetIndustryGfx(this->tile))->badges, parameter);
97 }
98
99 Debug(grf, 1, "Unhandled industry tile variable 0x{:X}", variable);
100
101 available = false;
102 return UINT_MAX;
103}
104
105/* virtual */ uint32_t IndustryTileScopeResolver::GetRandomBits() const
106{
107 assert(this->industry != nullptr && IsValidTile(this->tile));
108 assert(this->industry->index == IndustryID::Invalid() || IsTileType(this->tile, MP_INDUSTRY));
109
110 return (this->industry->index != IndustryID::Invalid()) ? GetIndustryRandomBits(this->tile) : 0;
111}
112
114{
115 assert(this->industry != nullptr && IsValidTile(this->tile));
116 assert(this->industry->index == IndustryID::Invalid() || IsTileType(this->tile, MP_INDUSTRY));
117 if (this->industry->index == IndustryID::Invalid()) return 0;
118 return GetIndustryRandomTriggers(this->tile).base();
119}
120
126static const GRFFile *GetIndTileGrffile(IndustryGfx gfx)
127{
128 const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
129 return (its != nullptr) ? its->grf_prop.grffile : nullptr;
130}
131
142 CallbackID callback, uint32_t callback_param1, uint32_t callback_param2)
143 : SpecializedResolverObject<IndustryRandomTriggers>(GetIndTileGrffile(gfx), callback, callback_param1, callback_param2),
144 indtile_scope(*this, indus, tile),
145 ind_scope(*this, tile, indus, indus->type),
146 gfx(gfx)
147{
148 this->root_spritegroup = GetIndustryTileSpec(gfx)->grf_prop.GetSpriteGroup(indus->index != IndustryID::Invalid());
149}
150
152{
153 return GSF_INDUSTRYTILES;
154}
155
160
161static void IndustryDrawTileLayout(const TileInfo *ti, const DrawTileSpriteSpan &dts, Colours rnd_colour, uint8_t stage)
162{
163 SpriteID image = dts.ground.sprite;
164 PaletteID pal = dts.ground.pal;
165
166 if (HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE)) image += stage;
167 if (HasBit(pal, SPRITE_MODIFIER_CUSTOM_SPRITE)) pal += stage;
168
169 if (GB(image, 0, SPRITE_WIDTH) != 0) {
170 /* If the ground sprite is the default flat water sprite, draw also canal/river borders
171 * Do not do this if the tile's WaterClass is 'land'. */
172 if (image == SPR_FLAT_WATER_TILE && IsTileOnWater(ti->tile)) {
173 DrawWaterClassGround(ti);
174 } else {
175 DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, GetColourPalette(rnd_colour)));
176 }
177 }
178
179 DrawNewGRFTileSeq(ti, &dts, TO_INDUSTRIES, stage, GetColourPalette(rnd_colour));
180}
181
182uint16_t GetIndustryTileCallback(CallbackID callback, uint32_t param1, uint32_t param2, IndustryGfx gfx_id, Industry *industry, TileIndex tile, std::span<int32_t> regs100)
183{
184 assert(industry != nullptr && IsValidTile(tile));
185 assert(industry->index == IndustryID::Invalid() || IsTileType(tile, MP_INDUSTRY));
186
187 IndustryTileResolverObject object(gfx_id, tile, industry, callback, param1, param2);
188 return object.ResolveCallback(regs100);
189}
190
191bool DrawNewIndustryTile(TileInfo *ti, Industry *i, IndustryGfx gfx, const IndustryTileSpec *inds)
192{
193 if (ti->tileh != SLOPE_FLAT) {
194 bool draw_old_one = true;
196 /* Called to determine the type (if any) of foundation to draw for industry tile */
197 uint32_t callback_res = GetIndustryTileCallback(CBID_INDTILE_DRAW_FOUNDATIONS, 0, 0, gfx, i, ti->tile);
198 if (callback_res != CALLBACK_FAILED) draw_old_one = ConvertBooleanCallback(inds->grf_prop.grffile, CBID_INDTILE_DRAW_FOUNDATIONS, callback_res);
199 }
200
201 if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED);
202 }
203
204 IndustryTileResolverObject object(gfx, ti->tile, i);
205
206 const auto *group = object.Resolve<TileLayoutSpriteGroup>();
207 if (group == nullptr) return false;
208
209 /* Limit the building stage to the number of stages supplied. */
210 uint8_t stage = GetIndustryConstructionStage(ti->tile);
211 auto processor = group->ProcessRegisters(object, &stage);
212 auto dts = processor.GetLayout();
213 IndustryDrawTileLayout(ti, dts, i->random_colour, stage);
214 return true;
215}
216
217extern bool IsSlopeRefused(Slope current, Slope refused);
218
232CommandCost PerformIndustryTileSlopeCheck(TileIndex ind_base_tile, TileIndex ind_tile, const IndustryTileSpec *its, IndustryType type, IndustryGfx gfx, size_t layout_index, uint16_t initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type)
233{
234 Industry ind;
235 ind.index = IndustryID::Invalid();
236 ind.location.tile = ind_base_tile;
237 ind.location.w = 0;
238 ind.type = type;
239 ind.random = initial_random_bits;
240 ind.founder = founder;
241
242 std::array<int32_t, 16> regs100;
243 uint16_t callback_res = GetIndustryTileCallback(CBID_INDTILE_SHAPE_CHECK, 0, creation_type << 8 | static_cast<uint32_t>(layout_index), gfx, &ind, ind_tile, regs100);
244 if (callback_res == CALLBACK_FAILED) {
245 if (!IsSlopeRefused(GetTileSlope(ind_tile), its->slopes_refused)) return CommandCost();
246 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
247 }
248 if (its->grf_prop.grffile->grf_version < 7) {
249 if (callback_res != 0) return CommandCost();
250 return CommandCost(STR_ERROR_SITE_UNSUITABLE);
251 }
252
253 return GetErrorMessageFromLocationCallbackResult(callback_res, regs100, its->grf_prop.grffile, STR_ERROR_SITE_UNSUITABLE);
254}
255
256/* Simple wrapper for GetHouseCallback to keep the animation unified. */
257uint16_t GetSimpleIndustryCallback(CallbackID callback, uint32_t param1, uint32_t param2, const IndustryTileSpec *spec, Industry *ind, TileIndex tile, int)
258{
259 return GetIndustryTileCallback(callback, param1, param2, spec - GetIndustryTileSpec(0), ind, tile);
260}
261
263struct IndustryAnimationBase : public AnimationBase<IndustryAnimationBase, IndustryTileSpec, Industry, int, GetSimpleIndustryCallback, TileAnimationFrameAnimationHelper<Industry> > {
264 static constexpr CallbackID cb_animation_speed = CBID_INDTILE_ANIMATION_SPEED;
265 static constexpr CallbackID cb_animation_next_frame = CBID_INDTILE_ANIMATION_NEXT_FRAME;
266
267 static constexpr IndustryTileCallbackMask cbm_animation_speed = IndustryTileCallbackMask::AnimationSpeed;
268 static constexpr IndustryTileCallbackMask cbm_animation_next_frame = IndustryTileCallbackMask::AnimationNextFrame;
269};
270
271void AnimateNewIndustryTile(TileIndex tile)
272{
274 if (itspec == nullptr) return;
275
277}
278
279static bool DoTriggerIndustryTileAnimation(TileIndex tile, IndustryAnimationTrigger iat, uint32_t random, uint32_t var18_extra = 0)
280{
282 if (!itspec->animation.triggers.Test(iat)) return false;
283
285 return true;
286}
287
288bool TriggerIndustryTileAnimation_ConstructionStageChanged(TileIndex tile, bool first_call)
289{
291 return DoTriggerIndustryTileAnimation(tile, iat, Random(), first_call ? 0x100 : 0);
292}
293
294bool TriggerIndustryTileAnimation(TileIndex tile, IndustryAnimationTrigger iat)
295{
297 return DoTriggerIndustryTileAnimation(tile, iat, Random());
298}
299
300bool TriggerIndustryAnimation(const Industry *ind, IndustryAnimationTrigger iat)
301{
302 bool ret = true;
303 uint32_t random = Random();
304 for (TileIndex tile : ind->location) {
305 if (ind->TileBelongsToIndustry(tile)) {
306 if (DoTriggerIndustryTileAnimation(tile, iat, random)) {
307 SB(random, 0, 16, Random());
308 } else {
309 ret = false;
310 }
311 }
312 }
313
314 return ret;
315}
316
324static void DoTriggerIndustryTileRandomisation(TileIndex tile, IndustryRandomTrigger trigger, Industry *ind, uint32_t &reseed_industry)
325{
326 assert(IsValidTile(tile) && IsTileType(tile, MP_INDUSTRY));
327
328 IndustryGfx gfx = GetIndustryGfx(tile);
329 const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
330
331 if (!itspec->grf_prop.HasSpriteGroups()) return;
332
333 IndustryTileResolverObject object(gfx, tile, ind, CBID_RANDOM_TRIGGER);
334 auto waiting_random_triggers = GetIndustryRandomTriggers(tile);
335 waiting_random_triggers.Set(trigger);
336 SetIndustryRandomTriggers(tile, waiting_random_triggers); // store now for var 5F
337 object.SetWaitingRandomTriggers(waiting_random_triggers);
338
339 object.ResolveRerandomisation();
340
341 /* Store remaining triggers. */
342 waiting_random_triggers.Reset(object.GetUsedRandomTriggers());
343 SetIndustryRandomTriggers(tile, waiting_random_triggers);
344
345 /* Rerandomise tile bits */
346 uint8_t new_random_bits = Random();
347 uint8_t random_bits = GetIndustryRandomBits(tile);
348 random_bits &= ~object.reseed[VSG_SCOPE_SELF];
349 random_bits |= new_random_bits & object.reseed[VSG_SCOPE_SELF];
350 SetIndustryRandomBits(tile, random_bits);
352
353 reseed_industry |= object.reseed[VSG_SCOPE_PARENT];
354}
355
361static void DoReseedIndustry(Industry *ind, uint32_t reseed)
362{
363 if (reseed == 0 || ind == nullptr) return;
364
365 uint16_t random_bits = Random();
366 ind->random &= reseed;
367 ind->random |= random_bits & reseed;
368}
369
376{
377 uint32_t reseed_industry = 0;
378 Industry *ind = Industry::GetByTile(tile);
379 DoTriggerIndustryTileRandomisation(tile, trigger, ind, reseed_industry);
380 DoReseedIndustry(ind, reseed_industry);
381}
382
389{
390 uint32_t reseed_industry = 0;
391 for (TileIndex tile : ind->location) {
392 if (ind->TileBelongsToIndustry(tile)) {
393 DoTriggerIndustryTileRandomisation(tile, trigger, ind, reseed_industry);
394 }
395 }
396 DoReseedIndustry(ind, reseed_industry);
397}
398
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr T SB(T &x, const uint8_t s, const uint8_t n, const U d)
Set n bits in x starting at bit s to d.
debug_inline static constexpr uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr Tstorage base() const noexcept
Retrieve the raw value behind this bit set.
Common return value for all commands.
Enum-as-bit-set wrapper.
Functions related to commands.
Functions related to debugging.
#define Debug(category, level, format_string,...)
Output a line of debugging information.
Definition debug.h:37
constexpr std::underlying_type_t< enum_type > to_underlying(enum_type e)
Implementation of std::to_underlying (from C++23)
Definition enum_type.hpp:17
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:17
uint32_t PaletteID
The number of the palette.
Definition gfx_type.h:18
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Base of all industries.
const IndustryTileSpec * GetIndustryTileSpec(IndustryGfx gfx)
Accessor for array _industry_tile_specs.
uint8_t GetIndustryRandomBits(Tile tile)
Get the random bits for this tile.
IndustryGfx GetIndustryGfx(Tile t)
Get the industry graphics ID for the given industry tile.
IndustryID GetIndustryIndex(Tile t)
Get the industry ID of the given tile.
void SetIndustryRandomBits(Tile tile, uint8_t bits)
Set the random bits for this tile.
void SetIndustryRandomTriggers(Tile tile, IndustryRandomTriggers triggers)
Set the activated triggers bits for this industry tile Used for grf callbacks.
IndustryRandomTriggers GetIndustryRandomTriggers(Tile tile)
Get the activated triggers bits for this industry tile Used for grf callbacks.
uint8_t GetIndustryConstructionStage(Tile tile)
Returns the industry construction stage of the specified tile.
IndustryRandomTrigger
Available industry random triggers.
IndustryAnimationTrigger
Animation triggers of the industries.
@ ConstructionStageChanged
Trigger whenever the construction stage changes.
@ NextFrameRandomBits
Callback 0x26 needs random bits.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
Functions related to OTTD's landscape.
@ Random
Randomise borders.
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:424
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:414
GrfSpecFeature
Definition newgrf.h:69
uint32_t GetRelativePosition(TileIndex tile, TileIndex ind_tile)
This is the position of the tile relative to the northernmost tile of the industry.
Function implementations related to NewGRF animation.
uint32_t GetBadgeVariableResult(const GRFFile &grffile, std::span< const BadgeID > badges, uint32_t parameter)
Test for a matching badge in a list of badges, returning the number of matching bits.
Functions related to NewGRF badges.
CallbackID
List of implemented NewGRF callbacks.
@ CBID_INDTILE_ANIMATION_SPEED
Called to indicate how long the current animation frame should last.
@ CBID_INDTILE_SHAPE_CHECK
Called to determine if the given industry tile can be built on specific tile.
@ CBID_INDTILE_DRAW_FOUNDATIONS
Called to determine the type (if any) of foundation to draw for industry tile.
@ CBID_RANDOM_TRIGGER
Set when calling a randomizing trigger (almost undocumented).
@ CBID_INDTILE_ANIMATION_TRIGGER
Called for periodically starting or stopping the animation.
@ CBID_INDTILE_ANIMATION_NEXT_FRAME
Called to determine industry tile next animation frame.
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
IndustryTileCallbackMask
Callback masks for industry tiles.
@ DrawFoundations
decides if default foundations need to be drawn
@ AnimationNextFrame
decides next animation frame
@ AnimationSpeed
decides animation speed
CommandCost GetErrorMessageFromLocationCallbackResult(uint16_t cb_res, std::span< const int32_t > textstack, const GRFFile *grffile, StringID default_error)
Get the error message from a shape/location/slope check callback result.
uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8)
Common part of station var 0x67, house var 0x62, indtile var 0x60, industry var 0x62.
bool ConvertBooleanCallback(const GRFFile *grffile, uint16_t cbid, uint16_t cb_res)
Converts a callback result into a boolean.
uint32_t GetTerrainType(TileIndex tile, TileContext context)
Function used by houses (and soon industries) to get information on type of "terrain" the tile it is ...
TileIndex GetNearbyTile(uint8_t parameter, TileIndex tile, bool signed_offsets, Axis axis)
Get the tile at the given offset.
uint32_t GetIndustryIDAtOffset(TileIndex tile, const Industry *i, uint32_t cur_grfid)
Make an analysis of a tile and check for its belonging to the same industry, and/or the same grf file...
IndustryAvailabilityCallType
From where has callback CBID_INDUSTRY_PROBABILITY been called.
uint32_t GetNearbyIndustryTileInformation(uint8_t parameter, TileIndex tile, IndustryID index, bool signed_offsets, bool grf_version8)
Based on newhouses equivalent, but adapted for newindustries.
void TriggerIndustryTileRandomisation(TileIndex tile, IndustryRandomTrigger trigger)
Trigger a random trigger for a single industry tile.
static void DoTriggerIndustryTileRandomisation(TileIndex tile, IndustryRandomTrigger trigger, Industry *ind, uint32_t &reseed_industry)
Trigger random triggers for an industry tile and reseed its random bits.
uint32_t GetRelativePosition(TileIndex tile, TileIndex ind_tile)
This is the position of the tile relative to the northernmost tile of the industry.
CommandCost PerformIndustryTileSlopeCheck(TileIndex ind_base_tile, TileIndex ind_tile, const IndustryTileSpec *its, IndustryType type, IndustryGfx gfx, size_t layout_index, uint16_t initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type)
Check the slope of a tile of a new industry.
static const GRFFile * GetIndTileGrffile(IndustryGfx gfx)
Get the associated NewGRF file from the industry graphics.
void TriggerIndustryRandomisation(Industry *ind, IndustryRandomTrigger trigger)
Trigger a random trigger for all industry tiles.
static void DoReseedIndustry(Industry *ind, uint32_t reseed)
Reseeds the random bits of an industry.
uint32_t GetNearbyIndustryTileInformation(uint8_t parameter, TileIndex tile, IndustryID index, bool signed_offsets, bool grf_version8)
Based on newhouses equivalent, but adapted for newindustries.
NewGRF handling of industry tiles.
Functions related to NewGRF provided sounds.
@ VSG_SCOPE_SELF
Resolved object itself.
@ VSG_SCOPE_PARENT
Related object of the resolved one.
A number of safeguards to prevent using unsafe methods.
Slope
Enumeration for the slope-type.
Definition slope_type.h:48
@ SLOPE_FLAT
a flat tile
Definition slope_type.h:49
@ FOUNDATION_LEVELED
The tile is leveled up to a flat slope.
Definition slope_type.h:95
static PaletteID GetColourPalette(Colours colour)
Get recolour palette for a colour.
Definition sprite.h:184
void DrawNewGRFTileSeq(const struct TileInfo *ti, const DrawTileSprites *dts, TransparencyOption to, uint32_t stage, PaletteID default_palette)
Draw NewGRF industrytile or house sprite layout.
Definition sprite.h:126
PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition sprite.h:170
static constexpr uint8_t SPRITE_MODIFIER_CUSTOM_SPRITE
these masks change the colours of the palette for a sprite.
Definition sprites.h:1551
static constexpr uint8_t SPRITE_WIDTH
number of bits for the sprite number
Definition sprites.h:1541
Definition of base types and functions in a cross-platform compatible way.
Helper class for a unified approach to NewGRF animation.
static void AnimateTile(const IndustryTileSpec *spec, Industry *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
static void ChangeAnimationFrame(CallbackID cb, const IndustryTileSpec *spec, Industry *obj, TileIndex tile, uint32_t random_bits, uint32_t trigger, int extra_data=0)
Check a callback to determine what the next animation step is and execute that step.
Ground palette sprite of a tile, together with its sprite layout.
Definition sprite.h:58
PalSpriteID ground
Palette and sprite for the ground.
Definition sprite.h:44
const struct GRFFile * grffile
grf file that introduced this entity
uint16_t local_id
id defined by the grf file for this entity
Dynamic data of a loaded NewGRF.
Definition newgrf.h:115
Helper class for animation control.
Resolver for industry tiles.
GrfSpecFeature GetFeature() const override
Get the feature number being resolved for.
uint32_t GetDebugID() const override
Get an identifier for the item being resolved.
IndustryTileResolverObject(IndustryGfx gfx, TileIndex tile, Industry *indus, CallbackID callback=CBID_NO_CALLBACK, uint32_t callback_param1=0, uint32_t callback_param2=0)
Constructor of the industry tiles scope resolver.
uint32_t GetRandomBits() const override
Get a few random bits.
Industry * industry
Industry owning the tiles.
uint32_t GetVariable(uint8_t variable, uint32_t parameter, bool &available) const override
Get a variable value.
TileIndex tile
Tile being resolved.
uint32_t GetRandomTriggers() const override
Get the triggers.
Defines the data structure of each individual tile of an industry.
IndustryTileSpecialFlags special_flags
Bitmask of extra flags used by the tile.
Slope slopes_refused
slope pattern on which this tile cannot be built
AnimationInfo< IndustryAnimationTriggers > animation
Information about the animation (is it looping, how many loops etc)
SubstituteGRFFileProps grf_prop
properties related to the grf file
IndustryTileCallbackMasks callback_mask
Bitmask of industry tile callbacks that have to be called.
Defines the internal data of a functional industry.
Definition industry.h:64
IndustryType type
type of industry.
Definition industry.h:100
Colours random_colour
randomized colour of the industry, for display purpose
Definition industry.h:102
uint16_t random
Random value used for randomisation of all kinds of things.
Definition industry.h:119
Owner founder
Founder of the industry.
Definition industry.h:111
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition industry.h:236
TileArea location
Location of the industry.
Definition industry.h:92
bool TileBelongsToIndustry(TileIndex tile) const
Check if a given tile belongs to this industry.
Definition industry.h:133
uint16_t w
The width of the area.
TileIndex tile
The base tile of the area.
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:23
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition gfx_type.h:24
Templated helper to make a PoolID a single POD value.
Definition pool_type.hpp:43
Tindex index
Index of this pool item.
const GRFFile * grffile
GRFFile the resolved SpriteGroup belongs to.
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
ResolverObject & ro
Surrounding resolver object.
Specialization of ResolverObject with type-safe access to RandomTriggers.
const struct SpriteGroup * GetSpriteGroup(bool entity_exists) const
Get the standard sprite group.
bool HasSpriteGroups() const
Check whether the entity has sprite groups.
Tile information, used while rendering the tile.
Definition tile_cmd.h:29
Slope tileh
Slope of the tile.
Definition tile_cmd.h:32
TileIndex tile
Tile index.
Definition tile_cmd.h:33
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
uint8_t GetAnimationFrame(Tile t)
Get the current animation frame.
Definition tile_map.h:250
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition tile_map.h:161
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
@ MP_INDUSTRY
Part of an industry.
Definition tile_type.h:56
Base of the town class.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold.
HouseZone GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
@ TO_INDUSTRIES
industries
void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite for the current tile.
Definition viewport.cpp:579
Functions related to water (management)
bool IsTileOnWater(Tile t)
Tests if the tile was built on water.
Definition water_map.h:136