OpenTTD
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_class_func.h"
16 #include "newgrf_object.h"
17 #include "newgrf_sound.h"
18 #include "object_base.h"
19 #include "object_map.h"
20 #include "tile_cmd.h"
21 #include "town.h"
22 #include "water.h"
23 #include "newgrf_animation_base.h"
24 
25 #include "safeguards.h"
26 
29 
33 
39 /* static */ const ObjectSpec *ObjectSpec::Get(ObjectType index)
40 {
41  assert(index < NUM_OBJECTS);
42  return &_object_specs[index];
43 }
44 
50 /* static */ const ObjectSpec *ObjectSpec::GetByTile(TileIndex tile)
51 {
52  return ObjectSpec::Get(GetObjectType(tile));
53 }
54 
60 {
61  return this->enabled && HasBit(this->climate, _settings_game.game_creation.landscape) &&
62  (this->flags & ((_game_mode != GM_EDITOR && !_generating_world) ? OBJECT_FLAG_ONLY_IN_SCENEDIT : OBJECT_FLAG_ONLY_IN_GAME)) == 0;
63 }
64 
70 {
71  return this->IsEverAvailable() && _date > this->introduction_date;
72 }
73 
79 {
80  return this->WasEverAvailable() &&
81  (_date < this->end_of_life_date || this->end_of_life_date < this->introduction_date + 365);
82 }
83 
88 uint ObjectSpec::Index() const
89 {
90  return this - _object_specs;
91 }
92 
95 {
96  /* Clean the pool. */
97  for (uint16 i = 0; i < NUM_OBJECTS; i++) {
98  _object_specs[i] = {};
99  }
100 
101  /* And add our originals. */
102  MemCpyT(_object_specs, _original_objects, lengthof(_original_objects));
103 
104  for (uint16 i = 0; i < lengthof(_original_objects); i++) {
105  _object_specs[i].grf_prop.local_id = i;
106  }
107 }
108 
109 template <typename Tspec, typename Tid, Tid Tmax>
111 {
112  ObjectClassID cls = ObjectClass::Allocate('LTHS');
113  ObjectClass::Get(cls)->name = STR_OBJECT_CLASS_LTHS;
114  _object_specs[OBJECT_LIGHTHOUSE].cls_id = cls;
115  ObjectClass::Assign(&_object_specs[OBJECT_LIGHTHOUSE]);
116 
117  cls = ObjectClass::Allocate('TRNS');
118  ObjectClass::Get(cls)->name = STR_OBJECT_CLASS_TRNS;
119  _object_specs[OBJECT_TRANSMITTER].cls_id = cls;
120  ObjectClass::Assign(&_object_specs[OBJECT_TRANSMITTER]);
121 }
122 
123 template <typename Tspec, typename Tid, Tid Tmax>
125 {
126  return this->GetSpec(index)->IsEverAvailable();
127 }
128 
130 
131 /* virtual */ uint32 ObjectScopeResolver::GetRandomBits() const
132 {
133  return IsValidTile(this->tile) && IsTileType(this->tile, MP_OBJECT) ? GetObjectRandomBits(this->tile) : 0;
134 }
135 
142 static uint32 GetObjectIDAtOffset(TileIndex tile, uint32 cur_grfid)
143 {
144  if (!IsTileType(tile, MP_OBJECT)) {
145  return 0xFFFF;
146  }
147 
148  const Object *o = Object::GetByTile(tile);
149  const ObjectSpec *spec = ObjectSpec::Get(o->type);
150 
151  /* Default objects have no associated NewGRF file */
152  if (spec->grf_prop.grffile == nullptr) {
153  return 0xFFFE; // Defined in another grf file
154  }
155 
156  if (spec->grf_prop.grffile->grfid == cur_grfid) { // same object, same grf ?
157  return spec->grf_prop.local_id | o->view << 16;
158  }
159 
160  return 0xFFFE; // Defined in another grf file
161 }
162 
171 static uint32 GetNearbyObjectTileInformation(byte parameter, TileIndex tile, ObjectID index, bool grf_version8)
172 {
173  if (parameter != 0) tile = GetNearbyTile(parameter, tile); // only perform if it is required
174  bool is_same_object = (IsTileType(tile, MP_OBJECT) && GetObjectIndex(tile) == index);
175 
176  return GetNearbyTileInformation(tile, grf_version8) | (is_same_object ? 1 : 0) << 8;
177 }
178 
186 static uint32 GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
187 {
188  uint32 best_dist = UINT32_MAX;
189  for (const Object *o : Object::Iterate()) {
190  if (o->type != type || o == current) continue;
191 
192  best_dist = min(best_dist, DistanceManhattan(tile, o->location.tile));
193  }
194 
195  return best_dist;
196 }
197 
206 static uint32 GetCountAndDistanceOfClosestInstance(byte local_id, uint32 grfid, TileIndex tile, const Object *current)
207 {
208  uint32 grf_id = GetRegister(0x100); // Get the GRFID of the definition to look for in register 100h
209  uint32 idx;
210 
211  /* Determine what will be the object type to look for */
212  switch (grf_id) {
213  case 0: // this is a default object type
214  idx = local_id;
215  break;
216 
217  case 0xFFFFFFFF: // current grf
218  grf_id = grfid;
219  FALLTHROUGH;
220 
221  default: // use the grfid specified in register 100h
222  idx = _object_mngr.GetID(local_id, grf_id);
223  break;
224  }
225 
226  /* If the object type is invalid, there is none and the closest is far away. */
227  if (idx >= NUM_OBJECTS) return 0 | 0xFFFF;
228 
229  return Object::GetTypeCount(idx) << 16 | min(GetClosestObject(tile, idx, current), 0xFFFF);
230 }
231 
233 /* virtual */ uint32 ObjectScopeResolver::GetVariable(byte variable, uint32 parameter, bool *available) const
234 {
235  /* We get the town from the object, or we calculate the closest
236  * town if we need to when there's no object. */
237  const Town *t = nullptr;
238 
239  if (this->obj == nullptr) {
240  switch (variable) {
241  /* Allow these when there's no object. */
242  case 0x41:
243  case 0x60:
244  case 0x61:
245  case 0x62:
246  case 0x64:
247  break;
248 
249  /* Allow these, but find the closest town. */
250  case 0x45:
251  case 0x46:
252  if (!IsValidTile(this->tile)) goto unhandled;
253  t = ClosestTownFromTile(this->tile, UINT_MAX);
254  break;
255 
256  /* Construction date */
257  case 0x42: return _date;
258 
259  /* Object founder information */
260  case 0x44: return _current_company;
261 
262  /* Object view */
263  case 0x48: return this->view;
264 
265  /*
266  * Disallow the rest:
267  * 0x40: Relative position is passed as parameter during construction.
268  * 0x43: Animation counter is only for actual tiles.
269  * 0x47: Object colour is only valid when its built.
270  * 0x63: Animation counter of nearby tile, see above.
271  */
272  default:
273  goto unhandled;
274  }
275 
276  /* If there's an invalid tile, then we don't have enough information at all. */
277  if (!IsValidTile(this->tile)) goto unhandled;
278  } else {
279  t = this->obj->town;
280  }
281 
282  switch (variable) {
283  /* Relative position. */
284  case 0x40: {
285  uint offset = this->tile - this->obj->location.tile;
286  uint offset_x = TileX(offset);
287  uint offset_y = TileY(offset);
288  return offset_y << 20 | offset_x << 16 | offset_y << 8 | offset_x;
289  }
290 
291  /* Tile information. */
292  case 0x41: return GetTileSlope(this->tile) << 8 | GetTerrainType(this->tile);
293 
294  /* Construction date */
295  case 0x42: return this->obj->build_date;
296 
297  /* Animation counter */
298  case 0x43: return GetAnimationFrame(this->tile);
299 
300  /* Object founder information */
301  case 0x44: return GetTileOwner(this->tile);
302 
303  /* Get town zone and Manhattan distance of closest town */
304  case 0x45: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceManhattan(this->tile, t->xy), 0xFFFF);
305 
306  /* Get square of Euclidian distance of closes town */
307  case 0x46: return GetTownRadiusGroup(t, this->tile) << 16 | min(DistanceSquare(this->tile, t->xy), 0xFFFF);
308 
309  /* Object colour */
310  case 0x47: return this->obj->colour;
311 
312  /* Object view */
313  case 0x48: return this->obj->view;
314 
315  /* Get object ID at offset param */
316  case 0x60: return GetObjectIDAtOffset(GetNearbyTile(parameter, this->tile), this->ro.grffile->grfid);
317 
318  /* Get random tile bits at offset param */
319  case 0x61: {
320  TileIndex tile = GetNearbyTile(parameter, this->tile);
321  return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetObjectRandomBits(tile) : 0;
322  }
323 
324  /* Land info of nearby tiles */
325  case 0x62: return GetNearbyObjectTileInformation(parameter, this->tile, this->obj == nullptr ? INVALID_OBJECT : this->obj->index, this->ro.grffile->grf_version >= 8);
326 
327  /* Animation counter of nearby tile */
328  case 0x63: {
329  TileIndex tile = GetNearbyTile(parameter, this->tile);
330  return (IsTileType(tile, MP_OBJECT) && Object::GetByTile(tile) == this->obj) ? GetAnimationFrame(tile) : 0;
331  }
332 
333  /* Count of object, distance of closest instance */
334  case 0x64: return GetCountAndDistanceOfClosestInstance(parameter, this->ro.grffile->grfid, this->tile, this->obj);
335  }
336 
337 unhandled:
338  DEBUG(grf, 1, "Unhandled object variable 0x%X", variable);
339 
340  *available = false;
341  return UINT_MAX;
342 }
343 
354  CallbackID callback, uint32 param1, uint32 param2)
355  : ResolverObject(spec->grf_prop.grffile, callback, param1, param2), object_scope(*this, obj, tile, view)
356 {
357  this->town_scope = nullptr;
358  this->root_spritegroup = (obj == nullptr && spec->grf_prop.spritegroup[CT_PURCHASE_OBJECT] != nullptr) ?
360 }
361 
362 ObjectResolverObject::~ObjectResolverObject()
363 {
364  delete this->town_scope;
365 }
366 
373 {
374  if (this->town_scope == nullptr) {
375  Town *t;
376  if (this->object_scope.obj != nullptr) {
377  t = this->object_scope.obj->town;
378  } else {
379  t = ClosestTownFromTile(this->object_scope.tile, UINT_MAX);
380  }
381  if (t == nullptr) return nullptr;
382  this->town_scope = new TownScopeResolver(*this, t, this->object_scope.obj == nullptr);
383  }
384  return this->town_scope;
385 }
386 
398 uint16 GetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, uint8 view)
399 {
400  ObjectResolverObject object(spec, o, tile, view, callback, param1, param2);
401  return object.ResolveCallback();
402 }
403 
410 static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
411 {
412  const DrawTileSprites *dts = group->ProcessRegisters(nullptr);
413  PaletteID palette = ((spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START) + Object::GetByTile(ti->tile)->colour;
414 
415  SpriteID image = dts->ground.sprite;
416  PaletteID pal = dts->ground.pal;
417 
418  if (GB(image, 0, SPRITE_WIDTH) != 0) {
419  /* If the ground sprite is the default flat water sprite, draw also canal/river borders
420  * Do not do this if the tile's WaterClass is 'land'. */
421  if ((image == SPR_FLAT_WATER_TILE || spec->flags & OBJECT_FLAG_DRAW_WATER) && IsTileOnWater(ti->tile)) {
422  DrawWaterClassGround(ti);
423  } else {
424  DrawGroundSprite(image, GroundSpritePaletteTransform(image, pal, palette));
425  }
426  }
427 
428  DrawNewGRFTileSeq(ti, dts, TO_STRUCTURES, 0, palette);
429 }
430 
436 void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
437 {
438  Object *o = Object::GetByTile(ti->tile);
439  ObjectResolverObject object(spec, o, ti->tile);
440 
441  const SpriteGroup *group = object.Resolve();
442  if (group == nullptr || group->type != SGT_TILELAYOUT) return;
443 
444  DrawTileLayout(ti, (const TileLayoutSpriteGroup *)group, spec);
445 }
446 
454 void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8 view)
455 {
456  ObjectResolverObject object(spec, nullptr, INVALID_TILE, view);
457  const SpriteGroup *group = object.Resolve();
458  if (group == nullptr || group->type != SGT_TILELAYOUT) return;
459 
460  const DrawTileSprites *dts = ((const TileLayoutSpriteGroup *)group)->ProcessRegisters(nullptr);
461 
462  PaletteID palette;
464  /* Get the colours of our company! */
465  if (spec->flags & OBJECT_FLAG_2CC_COLOUR) {
466  const Livery *l = Company::Get(_local_company)->livery;
467  palette = SPR_2CCMAP_BASE + l->colour1 + l->colour2 * 16;
468  } else {
469  palette = COMPANY_SPRITE_COLOUR(_local_company);
470  }
471  } else {
472  /* There's no company, so just take the base palette. */
473  palette = (spec->flags & OBJECT_FLAG_2CC_COLOUR) ? SPR_2CCMAP_BASE : PALETTE_RECOLOUR_START;
474  }
475 
476  SpriteID image = dts->ground.sprite;
477  PaletteID pal = dts->ground.pal;
478 
479  if (GB(image, 0, SPRITE_WIDTH) != 0) {
480  DrawSprite(image, GroundSpritePaletteTransform(image, pal, palette), x, y);
481  }
482 
483  DrawNewGRFTileSeqInGUI(x, y, dts, 0, palette);
484 }
485 
497 uint16 StubGetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, int extra_data)
498 {
499  return GetObjectCallback(callback, param1, param2, spec, o, tile);
500 }
501 
503 struct ObjectAnimationBase : public AnimationBase<ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback> {
504  static const CallbackID cb_animation_speed = CBID_OBJECT_ANIMATION_SPEED;
505  static const CallbackID cb_animation_next_frame = CBID_OBJECT_ANIMATION_NEXT_FRAME;
506 
507  static const ObjectCallbackMask cbm_animation_speed = CBM_OBJ_ANIMATION_SPEED;
508  static const ObjectCallbackMask cbm_animation_next_frame = CBM_OBJ_ANIMATION_NEXT_FRAME;
509 };
510 
516 {
517  const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
518  if (spec == nullptr || !(spec->flags & OBJECT_FLAG_ANIMATION)) return;
519 
521 }
522 
531 {
532  if (!HasBit(spec->animation.triggers, trigger)) return;
533 
535 }
536 
544 {
545  if (!HasBit(spec->animation.triggers, trigger)) return;
546 
547  TILE_AREA_LOOP(tile, o->location) {
548  TriggerObjectTileAnimation(o, tile, trigger, spec);
549  }
550 }
Implementation of the NewGRF class&#39; functions.
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:79
Definition of stuff that is very close to a company, like the company struct itself.
Maximum number of classes.
Definition: newgrf_object.h:48
Object wants 2CC colour mapping.
Definition: newgrf_object.h:34
ObjectFlags flags
Flags/settings related to the object.
Definition: newgrf_object.h:70
void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
Draw an object on the map.
static const ObjectType NUM_OBJECTS
Number of supported objects overall.
Definition: object_type.h:25
Tile information, used while rendering the tile.
Definition: tile_cmd.h:42
static const ObjectType OBJECT_TRANSMITTER
The large antenna.
Definition: object_type.h:16
bool IsAvailable() const
Check whether the object is available at this time.
byte landscape
the landscape we&#39;re currently in
decides next animation frame
uint16 triggers
The triggers that trigger animation.
decides animation speed
void TriggerObjectTileAnimation(Object *o, TileIndex tile, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
Trigger the update of animation on a single tile.
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:291
Town * town
Town the object is built in.
Definition: object_base.h:25
static byte GetAnimationFrame(TileIndex t)
Get the current animation frame.
Definition: tile_map.h:250
Functions related to debugging.
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 ...
TownScopeResolver * GetTown()
Get the town resolver scope that belongs to this object resolver.
GRFFilePropsBase< 2 > grf_prop
Properties related the the grf file.
Definition: newgrf_object.h:60
static byte GetObjectRandomBits(TileIndex t)
Get the random bits of this tile.
Definition: object_map.h:59
bool IsEverAvailable() const
Check whether the object might be available at some point in this game with the current game mode...
static void DrawNewGRFTileSeqInGUI(int x, int y, const DrawTileSprites *dts, uint32 stage, PaletteID default_palette)
Draw NewGRF object in GUI.
Definition: sprite.h:133
static uint32 GetCountAndDistanceOfClosestInstance(byte local_id, uint32 grfid, TileIndex tile, const Object *current)
Implementation of var 65.
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
byte colour
Colour of the object, for display purpose.
Definition: object_base.h:28
Object wants to be drawn on water.
Definition: newgrf_object.h:36
#define INSTANTIATE_NEWGRF_CLASS_METHODS(name, Tspec, Tid, Tmax)
Force instantiation of the methods so we don&#39;t get linker errors.
Determine the next animation frame for a house.
Allow incrementing of ObjectClassID variables.
Definition: newgrf_object.h:58
Date end_of_life_date
When can&#39;t this object be built anymore.
Definition: newgrf_object.h:69
static const CargoID CT_PURCHASE_OBJECT
Mapping of purchase for objects.
static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
Draw an group of sprites on the map.
bool WasEverAvailable() const
Check whether the object was available at some point in the past or present in this game with the cur...
Functions related to world/map generation.
Contains objects such as transmitters and owned land.
Definition: tile_type.h:51
Date introduction_date
From when can this object be built.
Definition: newgrf_object.h:68
static void ChangeAnimationFrame(CallbackID cb, const ObjectSpec *spec, Object *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.
bool IsUIAvailable(uint index) const
Check whether the spec will be available to the user at some point in time.
uint32 GetVariable(byte variable, uint32 parameter, bool *available) const override
Used by the resolver to get values for feature 0F deterministic spritegroups.
static const ObjectID INVALID_OBJECT
An invalid object.
Definition: object_type.h:34
static void AnimateTile(const ObjectSpec *spec, Object *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
Object scope resolver.
static const ObjectSpec * Get(ObjectType index)
Get the specification associated with a specific ObjectType.
ObjectSpec _object_specs[NUM_OBJECTS]
All the object specifications.
Functions related to NewGRF objects.
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
ObjectCallbackMask
Callback masks for objects.
static bool IsValidTile(TileIndex tile)
Checks if a tile is valid.
Definition: tile_map.h:161
virtual uint16 GetID(uint8 grf_local_id, uint32 grfid) const
Return the ID (if ever available) of a previously inserted entity.
Base for all objects.
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
void ResetObjects()
This function initialize the spec arrays of objects.
ObjectScopeResolver object_scope
The object scope resolver.
Struct containing information relating to NewGRF classes for stations and airports.
Definition: newgrf_class.h:19
static uint32 GetRegister(uint i)
Gets the value of a so-called newgrf "register".
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
bool enabled
Is this spec enabled?
Definition: newgrf_object.h:76
TileIndex xy
town center tile
Definition: town.h:54
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.
void AnimateNewObjectTile(TileIndex tile)
Handle the animation of the object tile.
TileIndex tile
Tile index.
Definition: tile_cmd.h:46
Object can only be built in game.
Definition: newgrf_object.h:33
struct Object * obj
The object the callback is ran for.
Ground palette sprite of a tile, together with its sprite layout.
Definition: sprite.h:58
void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8 view)
Draw representation of an object (tile) for GUI purposes.
TileIndex tile
The tile related to the object.
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
Object can only be constructed in the scenario editor.
Definition: newgrf_object.h:26
AnimationInfo animation
Information about the animation.
Definition: newgrf_object.h:71
uint Index() const
Gets the index of this spec.
#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.
Function implementations related to NewGRF animation.
Map accessors for object tiles.
Called to indicate how long the current animation frame should last.
A number of safeguards to prevent using unsafe methods.
Scope resolver for a town.
Definition: newgrf_town.h:22
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
uint16 GetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, uint8 view)
Perform a callback for an object.
ObjectOverrideManager _object_mngr(NEW_OBJECT_OFFSET, NUM_OBJECTS, INVALID_OBJECT_TYPE)
The override manager for our objects.
An object, such as transmitter, on the map.
Definition: object_base.h:23
static const ObjectType NEW_OBJECT_OFFSET
Offset for new objects.
Definition: object_type.h:24
Information about a particular livery.
Definition: livery.h:78
static uint32 GetObjectIDAtOffset(TileIndex tile, uint32 cur_grfid)
Make an analysis of a tile and get the object type.
void TriggerObjectAnimation(Object *o, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
Trigger the update of animation on a whole object.
static uint32 GetNearbyObjectTileInformation(byte parameter, TileIndex tile, ObjectID index, bool grf_version8)
Based on newhouses equivalent, but adapted for newobjects.
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:40
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
uint16 ObjectType
Types of objects.
Definition: object_type.h:14
Object wants random bits in "next animation frame" callback.
Definition: newgrf_object.h:38
ObjectResolverObject(const ObjectSpec *spec, Object *o, TileIndex tile, uint8 view=0, CallbackID callback=CBID_NO_CALLBACK, uint32 param1=0, uint32 param2=0)
Constructor of the object resolver.
static uint32 GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
Get the closest object of a given type.
byte colour2
Second colour, for vehicles with 2CC support.
Definition: livery.h:81
const struct SpriteGroup * spritegroup[Tcnt]
pointer to the different sprites of the entity
Object has animated tiles.
Definition: newgrf_object.h:32
uint16 StubGetObjectCallback(CallbackID callback, uint32 param1, uint32 param2, const ObjectSpec *spec, Object *o, TileIndex tile, int extra_data)
Perform a callback for an object.
static void MemCpyT(T *destination, const T *source, size_t num=1)
Type-safe version of memcpy().
Definition: mem_func.hpp:23
#define DEBUG(name, level,...)
Output a line of debugging information.
Definition: debug.h:35
const ObjectSpec _original_objects[]
Specification of the original object structures.
Functions related to companies.
PalSpriteID ground
Palette and sprite for the ground.
Definition: sprite.h:59
static const PaletteID PALETTE_RECOLOUR_START
First recolour sprite for company colours.
Definition: sprites.h:1556
bool _generating_world
Whether we are generating the map or not.
Definition: genworld.cpp:60
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition: pool_type.hpp:340
uint32 ObjectID
Unique identifier for an object.
Definition: object_type.h:29
static uint16 GetTypeCount(ObjectType type)
Get the count of objects for this type.
Definition: object_base.h:65
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
TownScopeResolver * town_scope
The town scope resolver (created on the first call).
Helper class for a unified approach to NewGRF animation.
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition: map.cpp:157
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
TileArea location
Location of the object.
Definition: object_base.h:26
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.
ObjectType type
Type of the object.
Definition: object_base.h:24
Town data structure.
Definition: town.h:53
static NewGRFClass * Get(Tid cls_id)
Get a particular class.
static ObjectID GetObjectIndex(TileIndex t)
Get the index of which object this tile is attached to.
Definition: object_map.h:47
other objects such as transmitters and lighthouses
Definition: transparency.h:29
ObjectAnimationTrigger
Animation triggers for objects.
Helper class for animation control.
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:45
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 bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:280
uint16 local_id
id defined by the grf file for this entity
static Object * GetByTile(TileIndex tile)
Get the object associated with a tile.
Definition: object_cmd.cpp:50
static void InsertDefaults()
Initialise the defaults.
A resolver object to be used with feature 0F spritegroups.
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.
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
Base of the town class.
byte colour1
First colour, for all vehicles.
Definition: livery.h:80
GameCreationSettings game_creation
settings used during the creation of a game (map)
static const ObjectSpec * GetByTile(TileIndex tile)
Get the specification associated with a tile.
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the &#39;Square&#39; distance between the two given tiles.
Definition: map.cpp:174
byte view
The view setting for this object.
Definition: object_base.h:29
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
ObjectClassID cls_id
The class to which this spec belongs.
Definition: newgrf_object.h:61
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
Date _date
Current date in days (day counter)
Definition: date.cpp:26
uint8 climate
In which climates is this object available?
Definition: newgrf_object.h:64
static const ObjectType INVALID_OBJECT_TYPE
An invalid object.
Definition: object_type.h:26
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:44
static const ObjectType OBJECT_LIGHTHOUSE
The nice lighthouse.
Definition: object_type.h:17
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:835
Generic &#39;commands&#39; that can be performed on all tiles.
ObjectType GetObjectType(TileIndex t)
Gets the ObjectType of the given object tile.
Definition: object_cmd.cpp:61
Called for periodically starting or stopping the animation.
ObjectClassID
Class IDs for objects.
Definition: newgrf_object.h:46
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24
StringID name
Name of this class.
Definition: newgrf_class.h:39