OpenTTD Source: src/newgrf_object.cpp Source File

OpenTTD Source 15.0-beta1

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"
20#include "timer/timer_game_calendar.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
29 ObjectOverrideManager _object_mngr(NEW_OBJECT_OFFSET, NUM_OBJECTS, INVALID_OBJECT_TYPE);
30
31extern const ObjectSpec _original_objects[NEW_OBJECT_OFFSET];
33std::vector<ObjectSpec> _object_specs;
34
35const std::vector<ObjectSpec> &ObjectSpec::Specs()
36{
37 return _object_specs;
38}
39
40size_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
74 bool ObjectSpec::IsEverAvailable() const
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
84 bool ObjectSpec::WasEverAvailable() const
85{
86 return this->IsEverAvailable() && TimerGameCalendar::date > this->introduction_date;
87}
88
93 bool ObjectSpec::IsAvailable() const
94{
95 return this->WasEverAvailable() &&
96 (TimerGameCalendar::date < this->end_of_life_date || this->end_of_life_date < this->introduction_date + 365);
97}
98
103uint 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
121 void ResetObjects()
122{
123 /* Clean the pool. */
124 _object_specs.clear();
125
126 /* And add our originals. */
127 _object_specs.reserve(lengthof(_original_objects));
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. */
135 _object_specs[OBJECT_LIGHTHOUSE].class_index = ObjectClass::Allocate('LTHS');
136 _object_specs[OBJECT_TRANSMITTER].class_index = ObjectClass::Allocate('TRNS');
137}
138
139template <>
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
146template <>
147bool ObjectClass::IsUIAvailable(uint index) const
148{
149 return this->GetSpec(index)->IsEverAvailable();
150}
151
152/* Instantiate ObjectClass. */
153template class NewGRFClass<ObjectSpec, ObjectClassID, OBJECT_CLASS_MAX>;
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.HasGrfFile()) {
177 return 0xFFFE; // Defined in another grf file
178 }
179
180 if (spec->grf_prop.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
361unhandled:
362 Debug(grf, 1, "Unhandled object variable 0x{:X}", variable);
363
364 available = false;
365 return UINT_MAX;
366}
367
377ObjectResolverObject::ObjectResolverObject(const ObjectSpec *spec, Object *obj, TileIndex tile, uint8_t view,
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
390 TownScopeResolver *ObjectResolverObject::GetTown()
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
405 GrfSpecFeature ObjectResolverObject::GetFeature() const
406{
407 return GSF_OBJECTS;
408}
409
410uint32_t ObjectResolverObject::GetDebugID() const
411{
412 return this->object_scope.spec->grf_prop.local_id;
413}
414
426uint16_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;
491 if (Company::IsValidID(_local_company)) {
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
524uint16_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
530 struct ObjectAnimationBase : public AnimationBase<ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback, TileAnimationFrameAnimationHelper<Object> > {
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
542 void AnimateNewObjectTile(TileIndex tile)
543{
544 const ObjectSpec *spec = ObjectSpec::GetByTile(tile);
545 if (spec == nullptr || !(spec->flags & OBJECT_FLAG_ANIMATION)) return;
546
547 ObjectAnimationBase::AnimateTile(spec, Object::GetByTile(tile), tile, (spec->flags & OBJECT_FLAG_ANIM_RANDOM_BITS) != 0);
548}
549
557 void TriggerObjectTileAnimation(Object *o, TileIndex tile, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
558{
559 if (!HasBit(spec->animation.triggers, trigger)) return;
560
561 ObjectAnimationBase::ChangeAnimationFrame(CBID_OBJECT_ANIMATION_START_STOP, spec, o, tile, Random(), trigger);
562}
563
570 void TriggerObjectAnimation(Object *o, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
571{
572 if (!HasBit(spec->animation.triggers, trigger)) return;
573
574 for (TileIndex tile : o->location) {
575 TriggerObjectTileAnimation(o, tile, trigger, spec);
576 }
577}
HasBit
debug_inline constexpr bool HasBit(const T x, const uint8_t y)
Checks if a bit in a value is set.
Definition bitmath_func.hpp:103
GB
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.
Definition bitmath_func.hpp:32
NewGRFClass
Struct containing information relating to NewGRF classes for stations and airports.
Definition newgrf_class.h:26
NewGRFClass::Assign
static void Assign(Tspec *spec)
Assign a spec to one of the classes.
Definition newgrf_class_func.h:70
NewGRFClass::name
StringID name
Name of this class.
Definition newgrf_class.h:49
NewGRFClass::IsUIAvailable
bool IsUIAvailable(uint index) const
Check whether the spec will be available to the user at some point in time.
Definition newgrf_airport.cpp:36
NewGRFClass::Get
static NewGRFClass * Get(Tindex class_index)
Get a particular class.
Definition newgrf_class_func.h:82
NewGRFClass::Allocate
static Tindex Allocate(uint32_t global_id)
Allocate a class with a given global class ID.
Definition newgrf_class_func.h:32
NewGRFClass::InsertDefaults
static void InsertDefaults()
Initialise the defaults.
Definition newgrf_airport.cpp:27
NewGRFClass::GetSpec
const Tspec * GetSpec(uint index) const
Get a spec from the class at a given index.
Definition newgrf_class_func.h:114
ObjectOverrideManager
Definition newgrf_commons.h:278
OverrideManagerBase::GetID
virtual uint16_t GetID(uint16_t grf_local_id, uint32_t grfid) const
Return the ID (if ever available) of a previously inserted entity.
Definition newgrf_commons.cpp:90
TimerGameCalendar::date
static Date date
Current date in days (day counter).
Definition timer_game_calendar.h:33
company_base.h
Definition of stuff that is very close to a company, like the company struct itself.
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition company_cmd.cpp:52
_current_company
CompanyID _current_company
Company currently doing an action.
Definition company_cmd.cpp:53
company_func.h
Functions related to companies.
debug.h
Functions related to debugging.
Debug
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
Definition debug.h:37
_generating_world
bool _generating_world
Whether we are generating the map or not.
Definition genworld.cpp:67
genworld.h
Functions related to world/map generation.
DrawSprite
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
SpriteID
uint32_t SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition gfx_type.h:18
PaletteID
uint32_t PaletteID
The number of the palette.
Definition gfx_type.h:19
DistanceSquare
uint DistanceSquare(TileIndex t0, TileIndex t1)
Gets the 'Square' distance between the two given tiles.
Definition map.cpp:163
DistanceManhattan
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition map.cpp:146
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition map_func.h:425
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition map_func.h:415
GrfSpecFeature
GrfSpecFeature
Definition newgrf.h:67
newgrf_animation_base.h
Function implementations related to NewGRF animation.
ObjectAnimationTrigger
ObjectAnimationTrigger
Animation triggers for objects.
Definition newgrf_animation_type.h:56
CallbackID
CallbackID
List of implemented NewGRF callbacks.
Definition newgrf_callbacks.h:20
CBID_OBJECT_ANIMATION_START_STOP
@ CBID_OBJECT_ANIMATION_START_STOP
Called for periodically starting or stopping the animation.
Definition newgrf_callbacks.h:260
CBID_OBJECT_ANIMATION_NEXT_FRAME
@ CBID_OBJECT_ANIMATION_NEXT_FRAME
Determine the next animation frame for a house.
Definition newgrf_callbacks.h:257
CBID_OBJECT_ANIMATION_SPEED
@ CBID_OBJECT_ANIMATION_SPEED
Called to indicate how long the current animation frame should last.
Definition newgrf_callbacks.h:263
ObjectCallbackMask
ObjectCallbackMask
Callback masks for objects.
Definition newgrf_callbacks.h:404
CBM_OBJ_ANIMATION_NEXT_FRAME
@ CBM_OBJ_ANIMATION_NEXT_FRAME
decides next animation frame
Definition newgrf_callbacks.h:406
CBM_OBJ_ANIMATION_SPEED
@ CBM_OBJ_ANIMATION_SPEED
decides animation speed
Definition newgrf_callbacks.h:407
newgrf_class_func.h
Implementation of the NewGRF class' functions.
GetNearbyTileInformation
uint32_t GetNearbyTileInformation(TileIndex tile, bool grf_version8)
Common part of station var 0x67, house var 0x62, indtile var 0x60, industry var 0x62.
Definition newgrf_commons.cpp:433
GetTerrainType
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 ...
Definition newgrf_commons.cpp:335
GetNearbyTile
TileIndex GetNearbyTile(uint8_t parameter, TileIndex tile, bool signed_offsets, Axis axis)
Get the tile at the given offset.
Definition newgrf_commons.cpp:410
GetCountAndDistanceOfClosestInstance
static uint32_t GetCountAndDistanceOfClosestInstance(uint8_t param_setID, uint8_t layout_filter, bool town_filter, const Industry *current)
Implementation of both var 67 and 68 since the mechanism is almost the same, it is easier to regroup ...
Definition newgrf_industries.cpp:115
_object_specs
std::vector< ObjectSpec > _object_specs
All the object specifications.
Definition newgrf_object.cpp:33
ResetObjects
void ResetObjects()
This function initialize the spec arrays of objects.
Definition newgrf_object.cpp:121
DrawNewObjectTileInGUI
void DrawNewObjectTileInGUI(int x, int y, const ObjectSpec *spec, uint8_t view)
Draw representation of an object (tile) for GUI purposes.
Definition newgrf_object.cpp:482
TriggerObjectAnimation
void TriggerObjectAnimation(Object *o, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
Trigger the update of animation on a whole object.
Definition newgrf_object.cpp:570
_object_mngr
ObjectOverrideManager _object_mngr(NEW_OBJECT_OFFSET, NUM_OBJECTS, INVALID_OBJECT_TYPE)
The override manager for our objects.
DrawNewObjectTile
void DrawNewObjectTile(TileInfo *ti, const ObjectSpec *spec)
Draw an object on the map.
Definition newgrf_object.cpp:464
GetClosestObject
static uint32_t GetClosestObject(TileIndex tile, ObjectType type, const Object *current)
Get the closest object of a given type.
Definition newgrf_object.cpp:210
GetObjectIDAtOffset
static uint32_t GetObjectIDAtOffset(TileIndex tile, uint32_t cur_grfid)
Make an analysis of a tile and get the object type.
Definition newgrf_object.cpp:166
StubGetObjectCallback
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.
Definition newgrf_object.cpp:524
GetObjectCallback
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.
Definition newgrf_object.cpp:426
DrawTileLayout
static void DrawTileLayout(const TileInfo *ti, const TileLayoutSpriteGroup *group, const ObjectSpec *spec)
Draw an group of sprites on the map.
Definition newgrf_object.cpp:438
GetCountAndDistanceOfClosestInstance
static uint32_t GetCountAndDistanceOfClosestInstance(uint8_t local_id, uint32_t grfid, TileIndex tile, const Object *current)
Implementation of var 65.
Definition newgrf_object.cpp:230
GetNearbyObjectTileInformation
static uint32_t GetNearbyObjectTileInformation(uint8_t parameter, TileIndex tile, ObjectID index, bool grf_version8)
Based on newhouses equivalent, but adapted for newobjects.
Definition newgrf_object.cpp:195
TriggerObjectTileAnimation
void TriggerObjectTileAnimation(Object *o, TileIndex tile, ObjectAnimationTrigger trigger, const ObjectSpec *spec)
Trigger the update of animation on a single tile.
Definition newgrf_object.cpp:557
AnimateNewObjectTile
void AnimateNewObjectTile(TileIndex tile)
Handle the animation of the object tile.
Definition newgrf_object.cpp:542
newgrf_object.h
Functions related to NewGRF objects.
OBJECT_FLAG_2CC_COLOUR
@ OBJECT_FLAG_2CC_COLOUR
Object wants 2CC colour mapping.
Definition newgrf_object.h:34
OBJECT_FLAG_ANIMATION
@ OBJECT_FLAG_ANIMATION
Object has animated tiles.
Definition newgrf_object.h:32
OBJECT_FLAG_ANIM_RANDOM_BITS
@ 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_FLAG_ONLY_IN_GAME
Object can only be built in game.
Definition newgrf_object.h:33
OBJECT_FLAG_DRAW_WATER
@ OBJECT_FLAG_DRAW_WATER
Object wants to be drawn on water.
Definition newgrf_object.h:36
OBJECT_FLAG_ONLY_IN_SCENEDIT
@ OBJECT_FLAG_ONLY_IN_SCENEDIT
Object can only be constructed in the scenario editor.
Definition newgrf_object.h:26
INVALID_OBJECT_CLASS
@ INVALID_OBJECT_CLASS
Class for the less fortunate.
Definition newgrf_object.h:51
newgrf_sound.h
Functions related to NewGRF provided sounds.
GetRegister
uint32_t GetRegister(uint i)
Gets the value of a so-called newgrf "register".
Definition newgrf_spritegroup.h:29
object_base.h
Base for all objects.
GetObjectType
ObjectType GetObjectType(Tile t)
Gets the ObjectType of the given object tile.
Definition object_cmd.cpp:66
object_map.h
Map accessors for object tiles.
GetObjectRandomBits
uint8_t GetObjectRandomBits(Tile t)
Get the random bits of this tile.
Definition object_map.h:59
GetObjectIndex
ObjectID GetObjectIndex(Tile t)
Get the index of which object this tile is attached to.
Definition object_map.h:47
OBJECT_LIGHTHOUSE
static const ObjectType OBJECT_LIGHTHOUSE
The nice lighthouse.
Definition object_type.h:17
ObjectType
uint16_t ObjectType
Types of objects.
Definition object_type.h:14
ObjectID
uint32_t ObjectID
Unique identifier for an object.
Definition object_type.h:28
INVALID_OBJECT_TYPE
static const ObjectType INVALID_OBJECT_TYPE
An invalid object.
Definition object_type.h:25
NUM_OBJECTS
static const ObjectType NUM_OBJECTS
Number of supported objects overall.
Definition object_type.h:23
OBJECT_TRANSMITTER
static const ObjectType OBJECT_TRANSMITTER
The large antenna.
Definition object_type.h:16
INVALID_OBJECT
static const ObjectID INVALID_OBJECT
An invalid object.
Definition object_type.h:33
NEW_OBJECT_OFFSET
static const ObjectType NEW_OBJECT_OFFSET
Offset for new objects.
Definition object_type.h:22
safeguards.h
A number of safeguards to prevent using unsafe methods.
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition settings.cpp:57
DrawNewGRFTileSeq
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
DrawNewGRFTileSeqInGUI
void DrawNewGRFTileSeqInGUI(int x, int y, const DrawTileSprites *dts, uint32_t stage, PaletteID default_palette)
Draw NewGRF object in GUI.
Definition sprite.h:133
GroundSpritePaletteTransform
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
PALETTE_RECOLOUR_START
static const PaletteID PALETTE_RECOLOUR_START
First recolour sprite for company colours.
Definition sprites.h:1574
SPRITE_WIDTH
static constexpr uint8_t SPRITE_WIDTH
number of bits for the sprite number
Definition sprites.h:1535
stdafx.h
Definition of base types and functions in a cross-platform compatible way.
lengthof
#define lengthof(array)
Return the length of an fixed size array.
Definition stdafx.h:280
AnimationBase
Helper class for a unified approach to NewGRF animation.
Definition newgrf_animation_base.h:43
AnimationBase< ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback, TileAnimationFrameAnimationHelper< Object > >::AnimateTile
static void AnimateTile(const ObjectSpec *spec, Object *obj, TileIndex tile, bool random_animation, int extra_data=0)
Animate a single tile.
Definition newgrf_animation_base.h:52
AnimationBase< ObjectAnimationBase, ObjectSpec, Object, int, StubGetObjectCallback, TileAnimationFrameAnimationHelper< Object > >::ChangeAnimationFrame
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.
Definition newgrf_animation_base.h:131
AnimationInfo::triggers
uint16_t triggers
The triggers that trigger animation.
Definition newgrf_animation_type.h:22
DrawTileSprites
Ground palette sprite of a tile, together with its sprite layout.
Definition sprite.h:58
DrawTileSprites::ground
PalSpriteID ground
Palette and sprite for the ground.
Definition sprite.h:59
GRFFilePropsBase::HasGrfFile
bool HasGrfFile() const
Test if this entity was introduced by NewGRF.
Definition newgrf_commons.h:320
GRFFilePropsBase::local_id
uint16_t local_id
id defined by the grf file for this entity
Definition newgrf_commons.h:311
GRFFilePropsBase::grfid
uint32_t grfid
grfid that introduced this entity.
Definition newgrf_commons.h:312
GRFFilePropsBase::spritegroup
std::array< const struct SpriteGroup *, Tcnt > spritegroup
pointers to the different sprites of the entity
Definition newgrf_commons.h:314
GameCreationSettings::landscape
uint8_t landscape
the landscape we're currently in
Definition settings_type.h:368
GameSettings::game_creation
GameCreationSettings game_creation
settings used during the creation of a game (map)
Definition settings_type.h:593
Livery
Information about a particular livery.
Definition livery.h:78
Livery::colour2
Colours colour2
Second colour, for vehicles with 2CC support.
Definition livery.h:81
Livery::colour1
Colours colour1
First colour, for all vehicles.
Definition livery.h:80
NewGRFSpecBase< ObjectClassID >::index
uint16_t index
Index within class of this spec, invalid until inserted into class.
Definition newgrf_class.h:19
ObjectAnimationBase
Helper class for animation control.
Definition newgrf_object.cpp:530
ObjectResolverObject
A resolver object to be used with feature 0F spritegroups.
Definition newgrf_object.h:133
ObjectResolverObject::object_scope
ObjectScopeResolver object_scope
The object scope resolver.
Definition newgrf_object.h:134
ObjectResolverObject::town_scope
std::optional< TownScopeResolver > town_scope
The town scope resolver (created on the first call).
Definition newgrf_object.h:135
ObjectResolverObject::GetTown
TownScopeResolver * GetTown()
Get the town resolver scope that belongs to this object resolver.
Definition newgrf_object.cpp:390
ObjectResolverObject::GetFeature
GrfSpecFeature GetFeature() const override
Get the feature number being resolved for.
Definition newgrf_object.cpp:405
ObjectResolverObject::ObjectResolverObject
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.
Definition newgrf_object.cpp:377
ObjectResolverObject::GetDebugID
uint32_t GetDebugID() const override
Get an identifier for the item being resolved.
Definition newgrf_object.cpp:410
ObjectScopeResolver::GetVariable
uint32_t GetVariable(uint8_t variable, uint32_t parameter, bool &available) const override
Used by the resolver to get values for feature 0F deterministic spritegroups.
Definition newgrf_object.cpp:257
ObjectScopeResolver::tile
TileIndex tile
The tile related to the object.
Definition newgrf_object.h:113
ObjectScopeResolver::view
uint8_t view
The view of the object.
Definition newgrf_object.h:114
ObjectScopeResolver::GetRandomBits
uint32_t GetRandomBits() const override
Get a few random bits.
Definition newgrf_object.cpp:155
ObjectScopeResolver::spec
const ObjectSpec * spec
Specification of the object type.
Definition newgrf_object.h:112
ObjectScopeResolver::obj
struct Object * obj
The object the callback is ran for.
Definition newgrf_object.h:111
ObjectSpec
Allow incrementing of ObjectClassID variables.
Definition newgrf_object.h:60
ObjectSpec::animation
AnimationInfo animation
Information about the animation.
Definition newgrf_object.h:63
ObjectSpec::IsEnabled
bool IsEnabled() const
Test if this object is enabled.
Definition newgrf_object.h:82
ObjectSpec::introduction_date
TimerGameCalendar::Date introduction_date
From when can this object be built.
Definition newgrf_object.h:70
ObjectSpec::IsEverAvailable
bool IsEverAvailable() const
Check whether the object might be available at some point in this game with the current game mode.
Definition newgrf_object.cpp:74
ObjectSpec::GetByTile
static const ObjectSpec * GetByTile(TileIndex tile)
Get the specification associated with a tile.
Definition newgrf_object.cpp:65
ObjectSpec::Get
static const ObjectSpec * Get(ObjectType index)
Get the specification associated with a specific ObjectType.
Definition newgrf_object.cpp:50
ObjectSpec::grf_prop
GRFFilePropsBase< 2 > grf_prop
Properties related the the grf file.
Definition newgrf_object.h:62
ObjectSpec::IsAvailable
bool IsAvailable() const
Check whether the object is available at this time.
Definition newgrf_object.cpp:93
ObjectSpec::Index
uint Index() const
Gets the index of this spec.
Definition newgrf_object.cpp:103
ObjectSpec::BindToClasses
static void BindToClasses()
Tie all ObjectSpecs to their class.
Definition newgrf_object.cpp:111
ObjectSpec::climate
uint8_t climate
In which climates is this object available?
Definition newgrf_object.h:66
ObjectSpec::flags
ObjectFlags flags
Flags/settings related to the object.
Definition newgrf_object.h:72
ObjectSpec::WasEverAvailable
bool WasEverAvailable() const
Check whether the object was available at some point in the past or present in this game with the cur...
Definition newgrf_object.cpp:84
ObjectSpec::end_of_life_date
TimerGameCalendar::Date end_of_life_date
When can't this object be built anymore.
Definition newgrf_object.h:71
Object
An object, such as transmitter, on the map.
Definition object_base.h:23
Object::type
ObjectType type
Type of the object.
Definition object_base.h:24
Object::town
Town * town
Town the object is built in.
Definition object_base.h:25
Object::GetTypeCount
static uint16_t GetTypeCount(ObjectType type)
Get the count of objects for this type.
Definition object_base.h:65
Object::GetByTile
static Object * GetByTile(TileIndex tile)
Get the object associated with a tile.
Definition object_cmd.cpp:55
Object::build_date
TimerGameCalendar::Date build_date
Date of construction.
Definition object_base.h:27
Object::view
uint8_t view
The view setting for this object.
Definition object_base.h:29
Object::location
TileArea location
Location of the object.
Definition object_base.h:26
Object::colour
uint8_t colour
Colour of the object, for display purpose.
Definition object_base.h:28
OrthogonalTileArea::tile
TileIndex tile
The base tile of the area.
Definition tilearea_type.h:19
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition gfx_type.h:24
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition gfx_type.h:25
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition pool_type.hpp:238
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition pool_type.hpp:328
Pool::PoolItem<&_object_pool >::Iterate
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Definition pool_type.hpp:388
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition pool_type.hpp:339
ResolverObject
Interface for SpriteGroup-s to access the gamestate.
Definition newgrf_spritegroup.h:296
ResolverObject::grffile
const GRFFile * grffile
GRFFile the resolved SpriteGroup belongs to.
Definition newgrf_spritegroup.h:324
ResolverObject::root_spritegroup
const SpriteGroup * root_spritegroup
Root SpriteGroup to use for resolving.
Definition newgrf_spritegroup.h:325
ScopeResolver::ro
ResolverObject & ro
Surrounding resolver object.
Definition newgrf_spritegroup.h:278
SpriteGroup
Definition newgrf_spritegroup.h:57
SpriteGroup::Resolve
virtual const SpriteGroup * Resolve(ResolverObject &object) const
Base sprite group resolver.
Definition newgrf_spritegroup.h:61
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
TileInfo
Tile information, used while rendering the tile.
Definition tile_cmd.h:43
TileInfo::tile
TileIndex tile
Tile index.
Definition tile_cmd.h:47
TileLayoutSpriteGroup
Action 2 sprite layout for houses, industry tiles, objects and airport tiles.
Definition newgrf_spritegroup.h:248
TileLayoutSpriteGroup::ProcessRegisters
const DrawTileSprites * ProcessRegisters(uint8_t *stage) const
Process registers and the construction stage into the sprite layout.
Definition newgrf_spritegroup.cpp:289
TownScopeResolver
Scope resolver for a town.
Definition newgrf_town.h:22
Town
Town data structure.
Definition town.h:54
Town::xy
TileIndex xy
town center tile
Definition town.h:55
tile_cmd.h
Generic 'commands' that can be performed on all tiles.
GetTileOwner
Owner GetTileOwner(Tile tile)
Returns the owner of a tile.
Definition tile_map.h:178
GetAnimationFrame
uint8_t GetAnimationFrame(Tile t)
Get the current animation frame.
Definition tile_map.h:250
IsValidTile
bool IsValidTile(Tile tile)
Checks if a tile is valid.
Definition tile_map.h:161
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition tile_map.h:150
GetTileSlope
Slope GetTileSlope(TileIndex tile)
Return the slope of a given tile inside the map.
Definition tile_map.h:279
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition tile_type.h:95
MP_OBJECT
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition tile_type.h:58
timer_game_calendar.h
Definition of the game-calendar-timer.
town.h
Base of the town class.
GetTownRadiusGroup
HouseZonesBits GetTownRadiusGroup(const Town *t, TileIndex tile)
Returns the bit corresponding to the town zone of the specified tile.
Definition town_cmd.cpp:2474
ClosestTownFromTile
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:3896
TO_STRUCTURES
@ TO_STRUCTURES
other objects such as transmitters and lighthouses
Definition transparency.h:29
DrawGroundSprite
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
water.h
Functions related to water (management)
IsTileOnWater
bool IsTileOnWater(Tile t)
Tests if the tile was built on water.
Definition water_map.h:136