OpenTTD
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_industrytiles.h"
14 #include "newgrf_sound.h"
15 #include "industry.h"
16 #include "town.h"
17 #include "command_func.h"
18 #include "water.h"
19 #include "newgrf_animation_base.h"
20 
21 #include "table/strings.h"
22 
23 #include "safeguards.h"
24 
34 uint32 GetNearbyIndustryTileInformation(byte parameter, TileIndex tile, IndustryID index, bool signed_offsets, bool grf_version8)
35 {
36  if (parameter != 0) tile = GetNearbyTile(parameter, tile, signed_offsets); // only perform if it is required
37  bool is_same_industry = (IsTileType(tile, MP_INDUSTRY) && GetIndustryIndex(tile) == index);
38 
39  return GetNearbyTileInformation(tile, grf_version8) | (is_same_industry ? 1 : 0) << 8;
40 }
41 
53 uint32 GetRelativePosition(TileIndex tile, TileIndex ind_tile)
54 {
55  byte x = TileX(tile) - TileX(ind_tile);
56  byte y = TileY(tile) - TileY(ind_tile);
57 
58  return ((y & 0xF) << 20) | ((x & 0xF) << 16) | (y << 8) | x;
59 }
60 
61 /* virtual */ uint32 IndustryTileScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
62 {
63  switch (variable) {
64  /* Construction state of the tile: a value between 0 and 3 */
65  case 0x40: return (IsTileType(this->tile, MP_INDUSTRY)) ? GetIndustryConstructionStage(this->tile) : 0;
66 
67  /* Terrain type */
68  case 0x41: return GetTerrainType(this->tile);
69 
70  /* Current town zone of the tile in the nearest town */
71  case 0x42: return GetTownRadiusGroup(ClosestTownFromTile(this->tile, UINT_MAX), this->tile);
72 
73  /* Relative position */
74  case 0x43: return GetRelativePosition(this->tile, this->industry->location.tile);
75 
76  /* Animation frame. Like house variable 46 but can contain anything 0..FF. */
77  case 0x44: return IsTileType(this->tile, MP_INDUSTRY) ? GetAnimationFrame(this->tile) : 0;
78 
79  /* Land info of nearby tiles */
80  case 0x60: return GetNearbyIndustryTileInformation(parameter, this->tile,
81  this->industry == nullptr ? (IndustryID)INVALID_INDUSTRY : this->industry->index, true, this->ro.grffile->grf_version >= 8);
82 
83  /* Animation stage of nearby tiles */
84  case 0x61: {
85  TileIndex tile = GetNearbyTile(parameter, this->tile);
86  if (IsTileType(tile, MP_INDUSTRY) && Industry::GetByTile(tile) == this->industry) {
87  return GetAnimationFrame(tile);
88  }
89  return UINT_MAX;
90  }
91 
92  /* Get industry tile ID at offset */
93  case 0x62: return GetIndustryIDAtOffset(GetNearbyTile(parameter, this->tile), this->industry, this->ro.grffile->grfid);
94  }
95 
96  DEBUG(grf, 1, "Unhandled industry tile variable 0x%X", variable);
97 
98  *available = false;
99  return UINT_MAX;
100 }
101 
102 /* virtual */ uint32 IndustryTileScopeResolver::GetRandomBits() const
103 {
104  assert(this->industry != nullptr && IsValidTile(this->tile));
105  assert(this->industry->index == INVALID_INDUSTRY || IsTileType(this->tile, MP_INDUSTRY));
106 
107  return (this->industry->index != INVALID_INDUSTRY) ? GetIndustryRandomBits(this->tile) : 0;
108 }
109 
110 /* virtual */ uint32 IndustryTileScopeResolver::GetTriggers() const
111 {
112  assert(this->industry != nullptr && IsValidTile(this->tile));
113  assert(this->industry->index == INVALID_INDUSTRY || IsTileType(this->tile, MP_INDUSTRY));
114  if (this->industry->index == INVALID_INDUSTRY) return 0;
115  return GetIndustryTriggers(this->tile);
116 }
117 
123 static const GRFFile *GetIndTileGrffile(IndustryGfx gfx)
124 {
125  const IndustryTileSpec *its = GetIndustryTileSpec(gfx);
126  return (its != nullptr) ? its->grf_prop.grffile : nullptr;
127 }
128 
139  CallbackID callback, uint32 callback_param1, uint32 callback_param2)
140  : ResolverObject(GetIndTileGrffile(gfx), callback, callback_param1, callback_param2),
141  indtile_scope(*this, indus, tile),
142  ind_scope(*this, tile, indus, indus->type)
143 {
145 }
146 
147 static void IndustryDrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, byte rnd_colour, byte stage, IndustryGfx gfx)
148 {
149  const DrawTileSprites *dts = group->ProcessRegisters(&stage);
150 
151  SpriteID image = dts->ground.sprite;
152  PaletteID pal = dts->ground.pal;
153 
154  if (HasBit(image, SPRITE_MODIFIER_CUSTOM_SPRITE)) image += stage;
155  if (HasBit(pal, SPRITE_MODIFIER_CUSTOM_SPRITE)) pal += stage;
156 
157  if (GB(image, 0, SPRITE_WIDTH) != 0) {
158  /* If the ground sprite is the default flat water sprite, draw also canal/river borders
159  * Do not do this if the tile's WaterClass is 'land'. */
160  if (image == SPR_FLAT_WATER_TILE && IsTileOnWater(ti->tile)) {
161  DrawWaterClassGround(ti);
162  } else {
163  DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, GENERAL_SPRITE_COLOUR(rnd_colour)));
164  }
165  }
166 
167  DrawNewGRFTileSeq(ti, dts, TO_INDUSTRIES, stage, GENERAL_SPRITE_COLOUR(rnd_colour));
168 }
169 
170 uint16 GetIndustryTileCallback(CallbackID callback, uint32 param1, uint32 param2, IndustryGfx gfx_id, Industry *industry, TileIndex tile)
171 {
172  assert(industry != nullptr && IsValidTile(tile));
173  assert(industry->index == INVALID_INDUSTRY || IsTileType(tile, MP_INDUSTRY));
174 
175  IndustryTileResolverObject object(gfx_id, tile, industry, callback, param1, param2);
176  return object.ResolveCallback();
177 }
178 
179 bool DrawNewIndustryTile(TileInfo *ti, Industry *i, IndustryGfx gfx, const IndustryTileSpec *inds)
180 {
181  if (ti->tileh != SLOPE_FLAT) {
182  bool draw_old_one = true;
184  /* Called to determine the type (if any) of foundation to draw for industry tile */
185  uint32 callback_res = GetIndustryTileCallback(CBID_INDTILE_DRAW_FOUNDATIONS, 0, 0, gfx, i, ti->tile);
186  if (callback_res != CALLBACK_FAILED) draw_old_one = ConvertBooleanCallback(inds->grf_prop.grffile, CBID_INDTILE_DRAW_FOUNDATIONS, callback_res);
187  }
188 
189  if (draw_old_one) DrawFoundation(ti, FOUNDATION_LEVELED);
190  }
191 
192  IndustryTileResolverObject object(gfx, ti->tile, i);
193 
194  const SpriteGroup *group = object.Resolve();
195  if (group == nullptr || group->type != SGT_TILELAYOUT) return false;
196 
197  /* Limit the building stage to the number of stages supplied. */
198  const TileLayoutSpriteGroup *tlgroup = (const TileLayoutSpriteGroup *)group;
199  byte stage = GetIndustryConstructionStage(ti->tile);
200  IndustryDrawTileLayout(ti, tlgroup, i->random_colour, stage, gfx);
201  return true;
202 }
203 
204 extern bool IsSlopeRefused(Slope current, Slope refused);
205 
219 CommandCost PerformIndustryTileSlopeCheck(TileIndex ind_base_tile, TileIndex ind_tile, const IndustryTileSpec *its, IndustryType type, IndustryGfx gfx, size_t layout_index, uint16 initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type)
220 {
221  Industry ind;
222  ind.index = INVALID_INDUSTRY;
223  ind.location.tile = ind_base_tile;
224  ind.location.w = 0;
225  ind.type = type;
226  ind.random = initial_random_bits;
227  ind.founder = founder;
228 
229  uint16 callback_res = GetIndustryTileCallback(CBID_INDTILE_SHAPE_CHECK, 0, creation_type << 8 | (uint32)layout_index, gfx, &ind, ind_tile);
230  if (callback_res == CALLBACK_FAILED) {
231  if (!IsSlopeRefused(GetTileSlope(ind_tile), its->slopes_refused)) return CommandCost();
232  return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
233  }
234  if (its->grf_prop.grffile->grf_version < 7) {
235  if (callback_res != 0) return CommandCost();
236  return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
237  }
238 
239  return GetErrorMessageFromLocationCallbackResult(callback_res, its->grf_prop.grffile, STR_ERROR_SITE_UNSUITABLE);
240 }
241 
242 /* Simple wrapper for GetHouseCallback to keep the animation unified. */
243 uint16 GetSimpleIndustryCallback(CallbackID callback, uint32 param1, uint32 param2, const IndustryTileSpec *spec, Industry *ind, TileIndex tile, int extra_data)
244 {
245  return GetIndustryTileCallback(callback, param1, param2, spec - GetIndustryTileSpec(0), ind, tile);
246 }
247 
249 struct IndustryAnimationBase : public AnimationBase<IndustryAnimationBase, IndustryTileSpec, Industry, int, GetSimpleIndustryCallback> {
250  static const CallbackID cb_animation_speed = CBID_INDTILE_ANIMATION_SPEED;
251  static const CallbackID cb_animation_next_frame = CBID_INDTILE_ANIM_NEXT_FRAME;
252 
253  static const IndustryTileCallbackMask cbm_animation_speed = CBM_INDT_ANIM_SPEED;
254  static const IndustryTileCallbackMask cbm_animation_next_frame = CBM_INDT_ANIM_NEXT_FRAME;
255 };
256 
257 void AnimateNewIndustryTile(TileIndex tile)
258 {
259  const IndustryTileSpec *itspec = GetIndustryTileSpec(GetIndustryGfx(tile));
260  if (itspec == nullptr) return;
261 
263 }
264 
265 bool StartStopIndustryTileAnimation(TileIndex tile, IndustryAnimationTrigger iat, uint32 random)
266 {
267  const IndustryTileSpec *itspec = GetIndustryTileSpec(GetIndustryGfx(tile));
268 
269  if (!HasBit(itspec->animation.triggers, iat)) return false;
270 
272  return true;
273 }
274 
275 bool StartStopIndustryTileAnimation(const Industry *ind, IndustryAnimationTrigger iat)
276 {
277  bool ret = true;
278  uint32 random = Random();
279  TILE_AREA_LOOP(tile, ind->location) {
280  if (ind->TileBelongsToIndustry(tile)) {
281  if (StartStopIndustryTileAnimation(tile, iat, random)) {
282  SB(random, 0, 16, Random());
283  } else {
284  ret = false;
285  }
286  }
287  }
288 
289  return ret;
290 }
291 
299 static void DoTriggerIndustryTile(TileIndex tile, IndustryTileTrigger trigger, Industry *ind, uint32 &reseed_industry)
300 {
301  assert(IsValidTile(tile) && IsTileType(tile, MP_INDUSTRY));
302 
303  IndustryGfx gfx = GetIndustryGfx(tile);
304  const IndustryTileSpec *itspec = GetIndustryTileSpec(gfx);
305 
306  if (itspec->grf_prop.spritegroup[0] == nullptr) return;
307 
308  IndustryTileResolverObject object(gfx, tile, ind, CBID_RANDOM_TRIGGER);
309  object.waiting_triggers = GetIndustryTriggers(tile) | trigger;
310  SetIndustryTriggers(tile, object.waiting_triggers); // store now for var 5F
311 
312  const SpriteGroup *group = object.Resolve();
313  if (group == nullptr) return;
314 
315  /* Store remaining triggers. */
317 
318  /* Rerandomise tile bits */
319  byte new_random_bits = Random();
320  byte random_bits = GetIndustryRandomBits(tile);
321  random_bits &= ~object.reseed[VSG_SCOPE_SELF];
322  random_bits |= new_random_bits & object.reseed[VSG_SCOPE_SELF];
323  SetIndustryRandomBits(tile, random_bits);
324  MarkTileDirtyByTile(tile);
325 
326  reseed_industry |= object.reseed[VSG_SCOPE_PARENT];
327 }
328 
334 static void DoReseedIndustry(Industry *ind, uint32 reseed)
335 {
336  if (reseed == 0 || ind == nullptr) return;
337 
338  uint16 random_bits = Random();
339  ind->random &= reseed;
340  ind->random |= random_bits & reseed;
341 }
342 
349 {
350  uint32 reseed_industry = 0;
351  Industry *ind = Industry::GetByTile(tile);
352  DoTriggerIndustryTile(tile, trigger, ind, reseed_industry);
353  DoReseedIndustry(ind, reseed_industry);
354 }
355 
362 {
363  uint32 reseed_industry = 0;
364  TILE_AREA_LOOP(tile, ind->location) {
365  if (ind->TileBelongsToIndustry(tile)) {
366  DoTriggerIndustryTile(tile, trigger, ind, reseed_industry);
367  }
368  }
369  DoReseedIndustry(ind, reseed_industry);
370 }
371 
Owner
Enum for all companies/owners.
Definition: company_type.h:18
IndustryTileResolverObject(IndustryGfx gfx, TileIndex tile, Industry *indus, CallbackID callback=CBID_NO_CALLBACK, uint32 callback_param1=0, uint32 callback_param2=0)
Constructor of the industry tiles scope resolver.
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
static const uint CALLBACK_FAILED
Different values for Callback result evaluations.
Tile information, used while rendering the tile.
Definition: tile_cmd.h:42
IndustryAnimationTrigger
Animation triggers of the industries.
uint32 GetRelativePosition(TileIndex tile, TileIndex ind_tile)
This is the position of the tile relative to the northernmost tile of the industry.
uint16 triggers
The triggers that trigger animation.
ResolverObject & ro
Surrounding resolver object.
Part of an industry.
Definition: tile_type.h:49
static byte GetAnimationFrame(TileIndex t)
Get the current animation frame.
Definition: tile_map.h:250
Functions related to debugging.
Called to determine if the given industry tile can be built on specific tile.
static void DrawNewGRFTileSeq(const struct TileInfo *ti, const DrawTileSprites *dts, TransparencyOption to, uint32 stage, PaletteID default_palette)
Draw NewGRF industrytile or house sprite layout.
Definition: sprite.h:124
Interface for SpriteGroup-s to access the gamestate.
uint32 GetTerrainType(TileIndex tile, TileContext context)
Function used by houses (and soon industries) to get information on type of "terrain" the tile it is ...
Slope tileh
Slope of the tile.
Definition: tile_cmd.h:45
static IndustryGfx GetIndustryGfx(TileIndex t)
Get the industry graphics ID for the given industry tile.
Definition: industry_map.h:137
static void DoTriggerIndustryTile(TileIndex tile, IndustryTileTrigger trigger, Industry *ind, uint32 &reseed_industry)
Trigger random triggers for an industry tile and reseed its random bits.
Called for periodically starting or stopping the animation.
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
Defines the internal data of a functional industry.
Definition: industry.h:40
Tindex index
Index of this pool item.
Definition: pool_type.hpp:189
uint16 random
Random value used for randomisation of all kinds of things.
Definition: industry.h:72
Common return value for all commands.
Definition: command_type.h:23
Called to indicate how long the current animation frame should last.
uint32 reseed[VSG_END]
Collects bits to rerandomise while triggering triggers.
static void ChangeAnimationFrame(CallbackID cb, const IndustryTileSpec *spec, Industry *obj, TileIndex tile, uint32 random_bits, uint32 trigger, int extra_data=0)
Check a callback to determine what the next animation step is and execute that step.
uint16 w
The width of the area.
Definition: tilearea_type.h:18
a flat tile
Definition: slope_type.h:49
CommandCost GetErrorMessageFromLocationCallbackResult(uint16 cb_res, const GRFFile *grffile, StringID default_error)
Get the error message from a shape/location/slope check callback result.
byte random_colour
randomized colour of the industry, for display purpose
Definition: industry.h:59
static void AnimateTile(const IndustryTileSpec *spec, Industry *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
Definition: landscape.cpp:470
static void SetIndustryRandomBits(TileIndex tile, byte bits)
Set the random bits for this tile.
Definition: industry_map.h:237
static T SB(T &x, const uint8 s, const uint8 n, const U d)
Set n bits in x starting at bit s to d.
IndustryTileSpecialFlags special_flags
Bitmask of extra flags used by the tile.
Definition: industrytype.h:169
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
Slope GetTileSlope(TileIndex tile, int *h)
Return the slope of a given tile inside the map.
Definition: tile_map.cpp:59
static bool IsValidTile(TileIndex tile)
Checks if a tile is valid.
Definition: tile_map.h:161
Slope slopes_refused
slope pattern on which this tile cannot be built
Definition: industrytype.h:158
uint32 GetRandomBits() const override
Get a few random bits.
Town * ClosestTownFromTile(TileIndex tile, uint threshold)
Return the town closest (in distance or ownership) to a given tile, within a given threshold...
Definition: town_cmd.cpp:3488
Resolver for industry tiles.
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
TileIndex GetNearbyTile(byte parameter, TileIndex tile, bool signed_offsets, Axis axis)
Get the tile at the given offset.
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
const DrawTileSprites * ProcessRegisters(uint8 *stage) const
Process registers and the construction stage into the sprite layout.
uint32 GetTriggers() const override
Get the triggers.
TileIndex tile
Tile index.
Definition: tile_cmd.h:46
The tile is leveled up to a flat slope.
Definition: slope_type.h:95
Ground palette sprite of a tile, together with its sprite layout.
Definition: sprite.h:58
IndustryTileTrigger
Available industry tile triggers.
static byte GetIndustryConstructionStage(TileIndex tile)
Returns the industry construction stage of the specified tile.
Definition: industry_map.h:100
decides if default foundations need to be drawn
bool ConvertBooleanCallback(const GRFFile *grffile, uint16 cbid, uint16 cb_res)
Converts a callback result into a boolean.
Called to determine the type (if any) of foundation to draw for industry tile.
IndustryTileCallbackMask
Callback masks for industry tiles.
uint32 GetNearbyIndustryTileInformation(byte parameter, TileIndex tile, IndustryID index, bool signed_offsets, bool grf_version8)
Based on newhouses equivalent, but adapted for newindustries.
#define TILE_AREA_LOOP(var, ta)
A loop which iterates over the tiles of a TileArea.
Definition of base types and functions in a cross-platform compatible way.
uint32 GetVariable(byte variable, uint32 parameter, bool *available) const override
Get a variable value.
Function implementations related to NewGRF animation.
void TriggerIndustryTile(TileIndex tile, IndustryTileTrigger trigger)
Trigger a random trigger for a single industry tile.
A number of safeguards to prevent using unsafe methods.
IndustryType type
type of industry.
Definition: industry.h:57
uint32 waiting_triggers
Waiting triggers to be used by any rerandomisation. (scope independent)
static PaletteID GroundSpritePaletteTransform(SpriteID image, PaletteID pal, PaletteID default_pal)
Applies PALETTE_MODIFIER_COLOUR to a palette entry of a ground sprite.
Definition: sprite.h:168
CommandCost PerformIndustryTileSlopeCheck(TileIndex ind_base_tile, TileIndex ind_tile, const IndustryTileSpec *its, IndustryType type, IndustryGfx gfx, size_t layout_index, uint16 initial_random_bits, Owner founder, IndustryAvailabilityCallType creation_type)
Check the slope of a tile of a new industry.
TileArea location
Location of the industry.
Definition: industry.h:41
static void DoReseedIndustry(Industry *ind, uint32 reseed)
Reseeds the random bits of an industry.
Set when a sprite originates from an Action 1.
Definition: sprites.h:1524
uint32 GetIndustryIDAtOffset(TileIndex tile, const Industry *i, uint32 cur_grfid)
Make an analysis of a tile and check for its belonging to the same industry, and/or the same grf file...
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition: viewport.cpp:1938
GRFFileProps grf_prop
properties related to the grf file
Definition: industrytype.h:171
const IndustryTileSpec * GetIndustryTileSpec(IndustryGfx gfx)
Accessor for array _industry_tile_specs.
decides animation speed
IndustryAvailabilityCallType
From where has callback CBID_INDUSTRY_PROBABILITY been called.
Industry * industry
Industry owning the tiles.
number of bits for the sprite number
Definition: sprites.h:1512
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
Definition: town_cmd.cpp:2181
Resolved object itself.
NewGRF handling of industry tiles.
const struct SpriteGroup * spritegroup[Tcnt]
pointer to the different sprites of the entity
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:33
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
uint8 callback_mask
Bitmask of industry tile callbacks that have to be called.
Definition: industrytype.h:167
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:17
const GRFFile * grffile
GRFFile the resolved SpriteGroup belongs to.
void TriggerIndustry(Industry *ind, IndustryTileTrigger trigger)
Trigger a random trigger for all industry tiles.
Helper class for animation control.
PalSpriteID ground
Palette and sprite for the ground.
Definition: sprite.h:59
TileIndex tile
Tile being resolved.
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
uint32 GetNearbyTileInformation(TileIndex tile, bool grf_version8)
Common part of station var 0x67, house var 0x62, indtile var 0x60, industry var 0x62.
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
Helper class for a unified approach to NewGRF animation.
AnimationInfo animation
Information about the animation (is it looping, how many loops etc)
Definition: industrytype.h:168
Called to determine industry tile next animation frame.
uint32 GetRemainingTriggers() const
Returns the waiting triggers that did not trigger any rerandomisation.
static IndustryID GetIndustryIndex(TileIndex t)
Get the industry ID of the given tile.
Definition: industry_map.h:63
Related object of the resolved one.
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
decides next animation frame
CallbackID callback
Callback being resolved.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
Slope
Enumeration for the slope-type.
Definition: slope_type.h:48
static byte GetIndustryRandomBits(TileIndex tile)
Get the random bits for this tile.
Definition: industry_map.h:224
Functions related to OTTD&#39;s landscape.
Functions related to commands.
Callback 0x26 needs random bits.
Definition: industrytype.h:89
static void SetIndustryTriggers(TileIndex tile, byte triggers)
Set the activated triggers bits for this industry tile Used for grf callbacks.
Definition: industry_map.h:264
Owner founder
Founder of the industry.
Definition: industry.h:66
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:575
static const GRFFile * GetIndTileGrffile(IndustryGfx gfx)
Get the associated NewGRF file from the industry graphics.
Base of all industries.
const struct GRFFile * grffile
grf file that introduced this entity
CallbackID
List of implemented NewGRF callbacks.
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Functions related to NewGRF provided sounds.
Set when calling a randomizing trigger (almost undocumented).
Base of the town class.
bool TileBelongsToIndustry(TileIndex tile) const
Check if a given tile belongs to this industry.
Definition: industry.h:86
Defines the data structure of each individual tile of an industry.
Definition: industrytype.h:155
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition: industry.h:113
static byte GetIndustryTriggers(TileIndex tile)
Get the activated triggers bits for this industry tile Used for grf callbacks.
Definition: industry_map.h:250
Functions related to water (management)
static bool IsTileOnWater(TileIndex t)
Tests if the tile was built on water.
Definition: water_map.h:130
SpriteID sprite
The &#39;real&#39; sprite.
Definition: gfx_type.h:23
industries
Definition: transparency.h:26
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
Dynamic data of a loaded NewGRF.
Definition: newgrf.h:105
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24