OpenTTD Source  20241108-master-g80f628063a
newgrf_object.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 "company_base.h"
12 #include "company_func.h"
13 #include "debug.h"
14 #include "genworld.h"
15 #include "newgrf_object.h"
16 #include "newgrf_class_func.h"
17 #include "newgrf_sound.h"
18 #include "object_base.h"
19 #include "object_map.h"
21 #include "tile_cmd.h"
22 #include "town.h"
23 #include "water.h"
24 #include "newgrf_animation_base.h"
25 
26 #include "safeguards.h"
27 
30 
33 std::vector<ObjectSpec> _object_specs;
34 
35 const std::vector<ObjectSpec> &ObjectSpec::Specs()
36 {
37  return _object_specs;
38 }
39 
40 size_t ObjectSpec::Count()
41 {
42  return _object_specs.size();
43 }
44 
50 /* static */ const ObjectSpec *ObjectSpec::Get(ObjectType index)
51 {
52  /* Empty object if index is out of range -- this might happen if NewGRFs are changed. */
53  static ObjectSpec empty = {};
54 
55  assert(index < NUM_OBJECTS);
56  if (index >= _object_specs.size()) return &empty;
57  return &_object_specs[index];
58 }
59 
65 /* static */ const ObjectSpec *ObjectSpec::GetByTile(TileIndex tile)
66 {
67  return ObjectSpec::Get(GetObjectType(tile));
68 }
69 
75 {
76  return this->IsEnabled() && HasBit(this->climate, _settings_game.game_creation.landscape) &&
77  (this->flags & ((_game_mode != GM_EDITOR && !_generating_world) ? OBJECT_FLAG_ONLY_IN_SCENEDIT : OBJECT_FLAG_ONLY_IN_GAME)) == 0;
78 }
79 
85 {
87 }
88 
94 {
95  return this->WasEverAvailable() &&
97 }
98 
103 uint ObjectSpec::Index() const
104 {
105  return this - _object_specs.data();
106 }
107 
111 /* static */ void ObjectSpec::BindToClasses()
112 {
113  for (auto &spec : _object_specs) {
114  if (spec.IsEnabled() && spec.class_index != INVALID_OBJECT_CLASS) {
115  ObjectClass::Assign(&spec);
116  }
117  }
118 }
119 
122 {
123  /* Clean the pool. */
124  _object_specs.clear();
125 
126  /* And add our originals. */
128 
129  for (uint16_t i = 0; i < lengthof(_original_objects); i++) {
130  ObjectSpec &spec = _object_specs.emplace_back(_original_objects[i]);
131  spec.grf_prop.local_id = i;
132  }
133 
134  /* Set class for originals. */
137 }
138 
139 template <>
140 /* static */ void ObjectClass::InsertDefaults()
141 {
142  ObjectClass::Get(ObjectClass::Allocate('LTHS'))->name = STR_OBJECT_CLASS_LTHS;
143  ObjectClass::Get(ObjectClass::Allocate('TRNS'))->name = STR_OBJECT_CLASS_TRNS;
144 }
145 
146 template <>
147 bool ObjectClass::IsUIAvailable(uint index) const
148 {
149  return this->GetSpec(index)->IsEverAvailable();
150 }
151 
152 /* Instantiate ObjectClass. */
154 
155 /* virtual */ uint32_t ObjectScopeResolver::GetRandomBits() const
156 {
157  return IsValidTile(this->tile) && IsTileType(this->tile, MP_OBJECT) ? GetObjectRandomBits(this->tile) : 0;
158 }
159 
166 static uint32_t GetObjectIDAtOffset(TileIndex tile, uint32_t cur_grfid)
167 {
168  if (!IsTileType(tile, MP_OBJECT)) {
169  return 0xFFFF;
170  }
171 
172  const Object *o = Object::GetByTile(tile);
173  const ObjectSpec *spec = ObjectSpec::Get(o->type);
174 
175  /* Default objects have no associated NewGRF file */
176  if (spec->grf_prop.grffile == nullptr) {
177  return 0xFFFE; // Defined in another grf file
178  }
179 
180  if (spec->grf_prop.grffile->grfid == cur_grfid) { // same object, same grf ?
181  return spec->grf_prop.local_id | o->view << 16;
182  }
183 
184  return 0xFFFE; // Defined in another grf file
185 }
186 
195 static uint32_t GetNearbyObjectTileInformation(uint8_t parameter, TileIndex tile, ObjectID index, bool grf_version8)
196 {
197  if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required
198  bool is_same_object = (IsTileType(tile, MP_OBJECT) && GetObjectIndex(tile) == index);
199 
200  return GetNearbyTileInformation(tile, grf_version8) | (is_same_object ? 1 : 0) << 8;
201 }
202 
210 static uint32_t GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
211 {
212  uint32_t best_dist = UINT32_MAX;
213  for (const Object *o : Object::Iterate()) {
214  if (o->type != type || o == current) continue;
215 
216  best_dist = std::min(best_dist, DistanceManhattan(tile, o->location.tile));
217  }
218 
219  return best_dist;
220 }
221 
230 static uint32_t GetCountAndDistanceOfClosestInstance(uint8_t local_id, uint32_t grfid, TileIndex tile, const Object *current)
231 {
232  uint32_t grf_id = GetRegister(0x100); // Get the GRFID of the definition to look for in register 100h
233  uint32_t idx;
234 
235  /* Determine what will be the object type to look for */
236  switch (grf_id) {
237  case 0: // this is a default object type
238  idx = local_id;
239  break;
240 
241  case 0xFFFFFFFF: // current grf
242  grf_id = grfid;
243  [[fallthrough]];
244 
245  default: // use the grfid specified in register 100h
246  idx = _object_mngr.GetID(local_id, grf_id);
247  break;
248  }
249 
250  /* If the object type is invalid, there is none and the closest is far away. */
251  if (idx >= NUM_OBJECTS) return 0 | 0xFFFF;
252 
253  return Object::GetTypeCount(idx) << 16 | ClampTo<uint16_t>(GetClosestObject(tile, idx, current));
254 }
255 
257 /* virtual */ uint32_t ObjectScopeResolver::GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const
258 {
259  /* We get the town from the object, or we calculate the closest
260  * town if we need to when there's no object. */
261  const Town *t = nullptr;
262 
263  if (this->obj == nullptr) {
264  switch (variable) {
265  /* Allow these when there's no object. */
266  case 0x41:
267  case 0x60:
268  case 0x61:
269  case 0x62:
270  case 0x64:
271  break;
272 
273  /* Allow these, but find the closest town. */
274  case 0x45:
275  case 0x46:
276  if (!IsValidTile(this->tile)) goto unhandled;
277  t = ClosestTownFromTile(this->tile, UINT_MAX);
278  break;
279 
280  /* Construction date */
281  case 0x42: return TimerGameCalendar::date.base();
282 
283  /* Object founder information */
284  case 0x44: return _current_company;
285 
286  /* Object view */
287  case 0x48: return this->view;
288 
289  /*
290  * Disallow the rest:
291  * 0x40: Relative position is passed as parameter during construction.
292  * 0x43: Animation counter is only for actual tiles.
293  * 0x47: Object colour is only valid when its built.
294  * 0x63: Animation counter of nearby tile, see above.
295  */
296  default:
297  goto unhandled;
298  }
299 
300  /* If there's an invalid tile, then we don't have enough information at all. */
301  if (!IsValidTile(this->tile)) goto unhandled;
302  } else {
303  t = this->obj->town;
304  }
305 
306  switch (variable) {
307  /* Relative position. */
308  case 0x40: {
309  TileIndex offset = this->tile - this->obj->location.tile;
310  uint offset_x = TileX(offset);
311  uint offset_y = TileY(offset);
312  return offset_y << 20 | offset_x << 16 | offset_y << 8 | offset_x;
313  }
314 
315  /* Tile information. */
316  case 0x41: return GetTileSlope(this->tile) << 8 | GetTerrainType(this->tile);
317 
318  /* Construction date */
319  case 0x42: return this->obj->build_date.base();
320 
321  /* Animation counter */
322  case 0x43: return GetAnimationFrame(this->tile);
323 
324  /* Object founder information */
325  case 0x44: return GetTileOwner(this->tile);
326 
327  /* Get town zone and Manhattan distance of closest town */
328  case 0x45: return GetTownRadiusGroup(t, this->tile) << 16 | ClampTo<uint16_t>(DistanceManhattan(this->tile, t->xy));
329 
330  /* Get square of Euclidian distance of closest town */
331  case 0x46: return DistanceSquare(this->tile, t->xy);
332 
333  /* Object colour */
334  case 0x47: return this->obj->colour;
335 
336  /* Object view */
337  case 0x48: return this->obj->view;
338 
339  /* Get object ID at offset param */
340  case 0x60: return GetObjectIDAtOffset(GetNearbyTile(parameter, this->tile), this->ro.grffile->grfid);
341 
342  /* Get random tile bits at offset param */
343  case 0x61: {
344  TileIndex tile = GetNearbyTile(parameter, this->tile);
345  return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetObjectRandomBits(tile) : 0;
346  }
347 
348  /* Land info of nearby tiles */
349  case 0x62: return GetNearbyObjectTileInformation(parameter, this->tile, this->obj == nullptr ? INVALID_OBJECT : this->obj->index, this->ro.grffile->grf_version >= 8);
350 
351  /* Animation counter of nearby tile */
352  case 0x63: {
353  TileIndex tile = GetNearbyTile(parameter, this->tile);
354  return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetAnimationFrame(tile) : 0;
355  }
356 
357  /* Count of object, distance of closest instance */
358  case 0x64: return GetCountAndDistanceOfClosestInstance(parameter, this->ro.grffile->grfid, this->tile, this->obj);
359  }
360 
361 unhandled:
362  Debug(grf, 1, "Unhandled object variable 0x{:X}", variable);
363 
364  available = false;
365  return UINT_MAX;
366 }
367 
378  CallbackID callback, uint32_t param1, uint32_t param2)
379  : ResolverObject(spec->grf_prop.grffile, callback, param1, param2), object_scope(*this, obj, spec, tile, view)
380 {
381  this->root_spritegroup = (obj == nullptr && spec->grf_prop.spritegroup[OBJECT_SPRITE_GROUP_PURCHASE] != nullptr) ?
382  spec->grf_prop.spritegroup[OBJECT_SPRITE_GROUP_PURCHASE] : spec->grf_prop.spritegroup[OBJECT_SPRITE_GROUP_DEFAULT];
383 }
384 
391 {
392  if (!this->town_scope.has_value()) {
393  Town *t;
394  if (this->object_scope.obj != nullptr) {
395  t = this->object_scope.obj->town;
396  } else {
397  t = ClosestTownFromTile(this->object_scope.tile, UINT_MAX);
398  }
399  if (t == nullptr) return nullptr;
400  this->town_scope.emplace(*this, t, this->object_scope.obj == nullptr);
401  }
402  return &*this->town_scope;
403 }
404 
406 {
407  return GSF_OBJECTS;
408 }
409 
411 {
412  return this->object_scope.spec->grf_prop.local_id;
413 }
414 
426 uint16_t GetObjectCallback(CallbackID callback, uint32_t param1, uint32_t param2, const ObjectSpec *spec, Object *o, TileIndex tile, uint8_t view)
427 {
428  ObjectResolverObject object(spec, o, tile, view, callback, param1, param2);
429  return object.ResolveCallback();
430 }
431 
438 static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
439 {
440  const DrawTileSprites *dts = group->ProcessRegisters(nullptr);
441  PaletteID palette = ((spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START) + Object::GetByTile(ti->tile)->colour;
442 
443  SpriteID image = dts->ground.sprite;
444  PaletteID pal = dts->ground.pal;
445 
446  if (GB(image, 0, SPRITE_WIDTH) != 0) {
447  /* If the ground sprite is the default flat water sprite, draw also canal/river borders
448  * Do not do this if the tile's WaterClass is 'land'. */
449  if ((image == SPR_FLAT_WATER_TILE || spec->flags & OBJECT_FLAG_DRAW_WATER) && IsTileOnWater(ti->tile)) {
450  DrawWaterClassGround(ti);
451  } else {
452  DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette));
453  }
454  }
455 
456  DrawNewGRFTileSeq(ti, dts, TO_STRUCTURES, 0, palette);
457 }
458 
464 void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
465 {
466  Object *o = Object::GetByTile(ti->tile);
467  ObjectResolverObject object(spec, o, ti->tile);
468 
469  const SpriteGroup *group = object.Resolve();
470  if (group == nullptr || group->type != SGT_TILELAYOUT) return;
471 
472  DrawTileLayout(ti, (const TileLayoutSpriteGroup *)group, spec);
473 }
474 
482 void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8_t view)
483 {
484  ObjectResolverObject object(spec, nullptr, INVALID_TILE, view);
485  const SpriteGroup *group = object.Resolve();
486  if (group == nullptr || group->type != SGT_TILELAYOUT) return;
487 
488  const DrawTileSprites *dts = ((const TileLayoutSpriteGroup *)group)->ProcessRegisters(nullptr);
489 
490  PaletteID palette;
492  /* Get the colours of our company! */
493  if (spec->flags & OBJECT_FLAG_2CC_COLOUR) {
494  const Livery *l = Company::Get(_local_company)->livery;
495  palette = SPR_2CCMAP_BASE + l->colour1 + l->colour2 * 16;
496  } else {
497  palette = COMPANY_SPRITE_COLOUR(_local_company);
498  }
499  } else {
500  /* There's no company, so just take the base palette. */
501  palette = (spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START;
502  }
503 
504  SpriteID image = dts->ground.sprite;
505  PaletteID pal = dts->ground.pal;
506 
507  if (GB(image, 0, SPRITE_WIDTH) != 0) {
508  DrawSprite(image, GroundSpritePaletteTransform(image, pal, palette), x, y);
509  }
510 
511  DrawNewGRFTileSeqInGUI(x, y, dts, 0, palette);
512 }
513 
524 uint16_t StubGetObjectCallback(CallbackID callback, uint32_t param1, uint32_t param2, const ObjectSpec *spec, Object *o, TileIndex tile, int)
525 {
526  return GetObjectCallback(callback, param1, param2, spec, o, tile);
527 }
528 
531  static const CallbackID cb_animation_speed = CBID_OBJECT_ANIMATION_SPEED;
532  static const CallbackID cb_animation_next_frame = CBID_OBJECT_ANIMATION_NEXT_FRAME;
533 
534  static const ObjectCallbackMask cbm_animation_speed = CBM_OBJ_ANIMATION_SPEED;
535  static const ObjectCallbackMask cbm_animation_next_frame = CBM_OBJ_ANIMATION_NEXT_FRAME;
536 };
537 
543 {
544  const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
545  if (spec == nullptr || !(spec->flags & OBJECT_FLAG_ANIMATION)) return;
546 
548 }
549 
558 {
559  if (!HasBit(spec->animation.triggers, trigger)) return;
560 
562 }
563 
571 {
572  if (!HasBit(spec->animation.triggers, trigger)) return;
573 
574  for (TileIndex tile : o->location) {
575  TriggerObjectTileAnimation(o, tile, trigger, spec);
576  }
577 }
constexpr debug_inline bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
constexpr static debug_inline uint GB(const T x, const uint8_t s, const uint8_t n)
Fetch n bits from x, started at bit s.
Struct containing information relating to NewGRF classes for stations and airports.
Definition: newgrf_class.h:26
static void Assign(Tspec *spec)
Assign a spec to one of the classes.
StringID name
Name of this class.
Definition: newgrf_class.h:49
bool IsUIAvailable(uint index) const
Check whether the spec will be available to the user at some point in time.
static NewGRFClass * Get(Tindex class_index)
Get a particular class.
static Tindex Allocate(uint32_t global_id)
Allocate a class with a given global class ID.
static void InsertDefaults()
Initialise the defaults.
const Tspec * GetSpec(uint index) const
Get a spec from the class at a given index.
virtual uint16_t GetID(uint16_t grf_local_id, uint32_t grfid) const
Return the ID (if ever available) of a previously inserted entity.
static Date date
Current date in days (day counter).
Definition of stuff that is very close to a company, like the company struct itself.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:52
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:53
Functions related to companies.
Functions related to debugging.
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition: debug.h:37
bool _generating_world
Whether we are generating the map or not.
Definition: genworld.cpp:67
Functions related to world/map generation.
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:988
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:18
uint32_t PaletteID
The number of the palette.
Definition: gfx_type.h:19
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition: map.cpp:163
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition: map.cpp:146
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:425
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:415
GrfSpecFeature
Definition: newgrf.h:67
Function implementations related to NewGRF animation.
ObjectAnimationTrigger
Animation triggers for objects.
CallbackID
List of implemented NewGRF callbacks.
@ CBID_OBJECT_ANIMATION_START_STOP
Called for periodically starting or stopping the animation.
@ CBID_OBJECT_ANIMATION_NEXT_FRAME
Determine the next animation frame for a house.
@ CBID_OBJECT_ANIMATION_SPEED
Called to indicate how long the current animation frame should last.
ObjectCallbackMask
Callback masks for objects.
@ CBM_OBJ_ANIMATION_NEXT_FRAME
decides next animation frame
@ CBM_OBJ_ANIMATION_SPEED
decides animation speed
Implementation of the NewGRF class' functions.
uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8)
Common part of station var 0x67, house var 0x62, indtile var 0x60, industry var 0x62.
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.
std::vector< ObjectSpec > _object_specs
All the object specifications.
void ResetObjects()
This function initialize the spec arrays of objects.
void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8_t view)
Draw representation of an object (tile) for GUI purposes.
void TriggerObjectAnimation(Object *o, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
Trigger the update of animation on a whole object.
ObjectOverrideManager _object_mngr(NEW_OBJECT_OFFSET, NUM_OBJECTS, INVALID_OBJECT_TYPE)
The override manager for our objects.
void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
Draw an object on the map.
static uint32_t GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
Get the closest object of a given type.
static uint32_t GetObjectIDAtOffset(TileIndex tile, uint32_t cur_grfid)
Make an analysis of a tile and get the object type.
uint16_t StubGetObjectCallback(CallbackID callback, uint32_t param1, uint32_t param2, const ObjectSpec *spec, Object *o, TileIndex tile, int)
Perform a callback for an object.
uint16_t GetObjectCallback(CallbackID callback, uint32_t param1, uint32_t param2, const ObjectSpec *spec, Object *o, TileIndex tile, uint8_t view)
Perform a callback for an object.
static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
Draw an group of sprites on the map.
static uint32_t GetCountAndDistanceOfClosestInstance(uint8_t local_id, uint32_t grfid, TileIndex tile, const Object *current)
Implementation of var 65.
static uint32_t GetNearbyObjectTileInformation(uint8_t parameter, TileIndex tile, ObjectID index, bool grf_version8)
Based on newhouses equivalent, but adapted for newobjects.
void TriggerObjectTileAnimation(Object *o, TileIndex tile, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
Trigger the update of animation on a single tile.
void AnimateNewObjectTile(TileIndex tile)
Handle the animation of the object tile.
Functions related to NewGRF objects.
@ OBJECT_FLAG_2CC_COLOUR
Object wants 2CC colour mapping.
Definition: newgrf_object.h:34
@ OBJECT_FLAG_ANIMATION
Object has animated tiles.
Definition: newgrf_object.h:32
@ OBJECT_FLAG_ANIM_RANDOM_BITS
Object wants random bits in "next animation frame" callback.
Definition: newgrf_object.h:38
@ OBJECT_FLAG_ONLY_IN_GAME
Object can only be built in game.
Definition: newgrf_object.h:33
@ OBJECT_FLAG_DRAW_WATER
Object wants to be drawn on water.
Definition: newgrf_object.h:36
@ OBJECT_FLAG_ONLY_IN_SCENEDIT
Object can only be constructed in the scenario editor.
Definition: newgrf_object.h:26
@ INVALID_OBJECT_CLASS
Class for the less fortunate.
Definition: newgrf_object.h:51
Functions related to NewGRF provided sounds.
uint32_t GetRegister(uint i)
Gets the value of a so-called newgrf "register".
Base for all objects.
ObjectType GetObjectType(Tile t)
Gets the ObjectType of the given object tile.
Definition: object_cmd.cpp:66
const ObjectSpec _original_objects[]
Specification of the original object structures.
Map accessors for object tiles.
uint8_t GetObjectRandomBits(Tile t)
Get the random bits of this tile.
Definition: object_map.h:59
ObjectID GetObjectIndex(Tile t)
Get the index of which object this tile is attached to.
Definition: object_map.h:47
static const ObjectType OBJECT_LIGHTHOUSE
The nice lighthouse.
Definition: object_type.h:17
uint16_t ObjectType
Types of objects.
Definition: object_type.h:14
uint32_t ObjectID
Unique identifier for an object.
Definition: object_type.h:28
static const ObjectType INVALID_OBJECT_TYPE
An invalid object.
Definition: object_type.h:25
static const ObjectType NUM_OBJECTS
Number of supported objects overall.
Definition: object_type.h:23
static const ObjectType OBJECT_TRANSMITTER
The large antenna.
Definition: object_type.h:16
static const ObjectID INVALID_OBJECT
An invalid object.
Definition: object_type.h:33
static const ObjectType NEW_OBJECT_OFFSET
Offset for new objects.
Definition: object_type.h:22
A number of safeguards to prevent using unsafe methods.
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:57
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:124
void DrawNewGRFTileSeqInGUI(int x, int y, const DrawTileSprites *dts, uint32_t stage, PaletteID default_palette)
Draw NewGRF object in GUI.
Definition: sprite.h:133
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
static const PaletteID PALETTE_RECOLOUR_START
First recolour sprite for company colours.
Definition: sprites.h:1574
static constexpr uint8_t SPRITE_WIDTH
number of bits for the sprite number
Definition: sprites.h:1535
Definition of base types and functions in a cross-platform compatible way.
#define lengthof(array)
Return the length of an fixed size array.
Definition: stdafx.h:280
Helper class for a unified approach to NewGRF animation.
static void AnimateTile(const ObjectSpec *spec, Object *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
static void ChangeAnimationFrame(CallbackID cb, const ObjectSpec *spec, Object *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.
uint16_t triggers
The triggers that trigger animation.
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:59
uint16_t local_id
id defined by the grf file for this entity
const struct GRFFile * grffile
grf file that introduced this entity
std::array< const struct SpriteGroup *, Tcnt > spritegroup
pointers to the different sprites of the entity
uint8_t landscape
the landscape we're currently in
GameCreationSettings game_creation
settings used during the creation of a game (map)
Information about a particular livery.
Definition: livery.h:78
Colours colour2
Second colour, for vehicles with 2CC support.
Definition: livery.h:81
Colours colour1
First colour, for all vehicles.
Definition: livery.h:80
uint16_t index
Index within class of this spec, invalid until inserted into class.
Definition: newgrf_class.h:19
Helper class for animation control.
A resolver object to be used with feature 0F spritegroups.
ObjectScopeResolver object_scope
The object scope resolver.
std::optional< TownScopeResolver > town_scope
The town scope resolver (created on the first call).
TownScopeResolver * GetTown()
Get the town resolver scope that belongs to this object resolver.
GrfSpecFeature GetFeature() const override
Get the feature number being resolved for.
ObjectResolverObject(const ObjectSpec *spec, Object *o, TileIndex tile, uint8_t view=0, CallbackID callback=CBID_NO_CALLBACK, uint32_t param1=0, uint32_t param2=0)
Constructor of the object resolver.
uint32_t GetDebugID() const override
Get an identifier for the item being resolved.
uint32_t GetVariable(uint8_t variable, [[maybe_unused]] uint32_t parameter, bool &available) const override
Used by the resolver to get values for feature 0F deterministic spritegroups.
TileIndex tile
The tile related to the object.
uint8_t view
The view of the object.
uint32_t GetRandomBits() const override
Get a few random bits.
const ObjectSpec * spec
Specification of the object type.
struct Object * obj
The object the callback is ran for.
Allow incrementing of ObjectClassID variables.
Definition: newgrf_object.h:60
AnimationInfo animation
Information about the animation.
Definition: newgrf_object.h:63
bool IsEnabled() const
Test if this object is enabled.
Definition: newgrf_object.h:82
TimerGameCalendar::Date introduction_date
From when can this object be built.
Definition: newgrf_object.h:70
bool IsEverAvailable() const
Check whether the object might be available at some point in this game with the current game mode.
static const ObjectSpec * GetByTile(TileIndex tile)
Get the specification associated with a tile.
static const ObjectSpec * Get(ObjectType index)
Get the specification associated with a specific ObjectType.
GRFFilePropsBase< 2 > grf_prop
Properties related the the grf file.
Definition: newgrf_object.h:62
bool IsAvailable() const
Check whether the object is available at this time.
uint Index() const
Gets the index of this spec.
static void BindToClasses()
Tie all ObjectSpecs to their class.
uint8_t climate
In which climates is this object available?
Definition: newgrf_object.h:66
ObjectFlags flags
Flags/settings related to the object.
Definition: newgrf_object.h:72
bool WasEverAvailable() const
Check whether the object was available at some point in the past or present in this game with the cur...
TimerGameCalendar::Date end_of_life_date
When can't this object be built anymore.
Definition: newgrf_object.h:71
An object, such as transmitter, on the map.
Definition: object_base.h:23
ObjectType type
Type of the object.
Definition: object_base.h:24
Town * town
Town the object is built in.
Definition: object_base.h:25
static uint16_t GetTypeCount(ObjectType type)
Get the count of objects for this type.
Definition: object_base.h:65
static Object * GetByTile(TileIndex tile)
Get the object associated with a tile.
Definition: object_cmd.cpp:55
TimerGameCalendar::Date build_date
Date of construction.
Definition: object_base.h:27
uint8_t view
The view setting for this object.
Definition: object_base.h:29
TileArea location
Location of the object.
Definition: object_base.h:26
uint8_t colour
Colour of the object, for display purpose.
Definition: object_base.h:28
TileIndex tile
The base tile of the area.
Definition: tilearea_type.h:19
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:24
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:25
Tindex index
Index of this pool item.
Definition: pool_type.hpp:238
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:339
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:328
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:388
Interface for SpriteGroup-s to access the gamestate.
const GRFFile * grffile
GRFFile the resolved SpriteGroup belongs to.
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
ResolverObject & ro
Surrounding resolver object.
virtual const SpriteGroup * Resolve([[maybe_unused]] ResolverObject &object) const
Base sprite group resolver.
Tile information, used while rendering the tile.
Definition: tile_cmd.h:43
TileIndex tile
Tile index.
Definition: tile_cmd.h:47
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
const DrawTileSprites * ProcessRegisters(uint8_t *stage) const
Process registers and the construction stage into the sprite layout.
Scope resolver for a town.
Definition: newgrf_town.h:22
Town data structure.
Definition: town.h:54
TileIndex xy
town center tile
Definition: town.h:55
Generic 'commands' that can be performed on all tiles.
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition: tile_map.h:178
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
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition: tile_type.h:58
Definition of the game-calendar-timer.
Base of the town class.
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
Definition: town_cmd.cpp:2447
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:3870
@ TO_STRUCTURES
other objects such as transmitters and lighthouses
Definition: transparency.h:29
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:587
Functions related to water (management)
bool IsTileOnWater(Tile t)
Tests if the tile was built on water.
Definition: water_map.h:136