4 * This file is part of OpenTTD.
5 * 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.
6 * 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.
7 * 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/>.
10 /** @file newgrf_object.cpp Handling of object NewGRFs. */
13 #include "company_base.h"
14 #include "company_func.h"
17 #include "newgrf_class_func.h"
18 #include "newgrf_object.h"
19 #include "newgrf_sound.h"
20 #include "object_base.h"
22 #include "map/object.h"
23 #include "map/slope.h"
27 #include "newgrf_animation_base.h"
29 /** The override manager for our objects. */
30 ObjectOverrideManager
_object_mngr(NEW_OBJECT_OFFSET
, NUM_OBJECTS
, INVALID_OBJECT_TYPE
);
32 extern const ObjectSpec _original_objects
[NEW_OBJECT_OFFSET
];
33 /** All the object specifications. */
34 ObjectSpec _object_specs
[NUM_OBJECTS
];
37 * Get the specification associated with a specific ObjectType.
38 * @param index The object type to fetch.
39 * @return The specification.
41 /* static */ const ObjectSpec
*ObjectSpec::Get(ObjectType index
)
43 assert(index
< NUM_OBJECTS
);
44 return &_object_specs
[index
];
48 * Get the specification associated with a tile.
49 * @param tile The tile to fetch the data for.
50 * @return The specification.
52 /* static */ const ObjectSpec
*ObjectSpec::GetByTile(TileIndex tile
)
54 return ObjectSpec::Get(GetObjectType(tile
));
58 * Check whether the object might be available at some point in this game with the current game mode.
59 * @return true if it might be available.
61 bool ObjectSpec::IsEverAvailable() const
63 return this->enabled
&& HasBit(this->climate
, _settings_game
.game_creation
.landscape
) &&
64 (this->flags
& ((_game_mode
!= GM_EDITOR
&& !_generating_world
) ? OBJECT_FLAG_ONLY_IN_SCENEDIT
: OBJECT_FLAG_ONLY_IN_GAME
)) == 0;
68 * Check whether the object was available at some point in the past or present in this game with the current game mode.
69 * @return true if it was ever or is available.
71 bool ObjectSpec::WasEverAvailable() const
73 return this->IsEverAvailable() && _date
> this->introduction_date
;
77 * Check whether the object is available at this time.
78 * @return true if it is available.
80 bool ObjectSpec::IsAvailable() const
82 return this->WasEverAvailable() &&
83 (_date
< this->end_of_life_date
|| this->end_of_life_date
< this->introduction_date
+ 365);
87 * Gets the index of this spec.
90 uint
ObjectSpec::Index() const
92 return this - _object_specs
;
95 /** This function initialize the spec arrays of objects. */
99 MemSetT(_object_specs
, 0, lengthof(_object_specs
));
101 /* And add our originals. */
102 MemCpyT(_object_specs
, _original_objects
, lengthof(_original_objects
));
104 for (uint16 i
= 0; i
< lengthof(_original_objects
); i
++) {
105 _object_specs
[i
].grf_prop
.local_id
= i
;
109 template <typename Tspec
, typename Tid
, Tid Tmax
>
110 /* static */ void NewGRFClass
<Tspec
, Tid
, Tmax
>::InsertDefaults()
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
]);
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
]);
123 template <typename Tspec
, typename Tid
, Tid Tmax
>
124 bool NewGRFClass
<Tspec
, Tid
, Tmax
>::IsUIAvailable(uint index
) const
126 return this->GetSpec(index
)->IsEverAvailable();
129 INSTANTIATE_NEWGRF_CLASS_METHODS(ObjectClass
, ObjectSpec
, ObjectClassID
, OBJECT_CLASS_MAX
)
132 * Constructor of an object scope resolver.
133 * @param ro Surrounding resolver.
134 * @param obj Object being resolved.
135 * @param tile %Tile of the object.
136 * @param view View of the object.
138 ObjectScopeResolver::ObjectScopeResolver(ResolverObject
&ro
, Object
*obj
, TileIndex tile
, uint8 view
)
146 /* virtual */ uint32
ObjectScopeResolver::GetRandomBits() const
148 return IsValidTile(this->tile
) && IsObjectTile(this->tile
) ? GetObjectRandomBits(this->tile
) : 0;
152 * Make an analysis of a tile and get the object type.
153 * @param tile TileIndex of the tile to query
154 * @param cur_grfid GRFID of the current callback chain
155 * @return value encoded as per NFO specs
157 static uint32
GetObjectIDAtOffset(TileIndex tile
, uint32 cur_grfid
)
159 if (!IsObjectTile(tile
)) {
163 const ObjectSpec
*spec
= ObjectSpec::GetByTile(tile
);
165 /* Default objects have no associated NewGRF file */
166 if (spec
->grf_prop
.grffile
== NULL
) {
167 return 0xFFFE; // Defined in another grf file
170 if (spec
->grf_prop
.grffile
->grfid
== cur_grfid
) { // same object, same grf ?
171 return spec
->grf_prop
.local_id
;
174 return 0xFFFE; // Defined in another grf file
178 * Based on newhouses equivalent, but adapted for newobjects
179 * @param parameter from callback. It's in fact a pair of coordinates
180 * @param tile TileIndex from which the callback was initiated
181 * @param index of the object been queried for
182 * @param grf_version8 True, if we are dealing with a new NewGRF which uses GRF version >= 8.
183 * @return a construction of bits obeying the newgrf format
185 static uint32
GetNearbyObjectTileInformation(byte parameter
, TileIndex tile
, ObjectID index
, bool grf_version8
)
187 if (parameter
!= 0) tile
= GetNearbyTile(parameter
, tile
); // only perform if it is required
188 bool is_same_object
= (IsObjectTile(tile
) && GetObjectIndex(tile
) == index
);
190 return GetNearbyTileInformation(tile
, grf_version8
) | (is_same_object
? 1 : 0) << 8;
194 * Get the closest object of a given type.
195 * @param tile The tile to start searching from.
196 * @param type The type of the object to search for.
197 * @param current The current object (to ignore).
198 * @return The distance to the closest object.
200 static uint32
GetClosestObject(TileIndex tile
, ObjectType type
, const Object
*current
)
202 uint32 best_dist
= UINT32_MAX
;
205 if (o
->type
!= type
|| o
== current
) continue;
207 best_dist
= min(best_dist
, DistanceManhattan(tile
, o
->location
.tile
));
214 * Implementation of var 65
215 * @param local_id Parameter given to the callback, which is the set id, or the local id, in our terminology.
216 * @param grfid The object's GRFID.
217 * @param tile The tile to look from.
218 * @param current Object for which the inquiry is made
219 * @return The formatted answer to the callback : rr(reserved) cc(count) dddd(manhattan distance of closest sister)
221 static uint32
GetCountAndDistanceOfClosestInstance(byte local_id
, uint32 grfid
, TileIndex tile
, const Object
*current
)
223 uint32 grf_id
= GetRegister(0x100); // Get the GRFID of the definition to look for in register 100h
226 /* Determine what will be the object type to look for */
228 case 0: // this is a default object type
232 case 0xFFFFFFFF: // current grf
236 default: // use the grfid specified in register 100h
237 idx
= _object_mngr
.GetID(local_id
, grf_id
);
241 /* If the object type is invalid, there is none and the closest is far away. */
242 if (idx
>= NUM_OBJECTS
) return 0 | 0xFFFF;
244 return Object::GetTypeCount(idx
) << 16 | min(GetClosestObject(tile
, idx
, current
), 0xFFFF);
247 /** Used by the resolver to get values for feature 0F deterministic spritegroups. */
248 /* virtual */ uint32
ObjectScopeResolver::GetVariable(byte variable
, uint32 parameter
, bool *available
) const
250 /* We get the town from the object, or we calculate the closest
251 * town if we need to when there's no object. */
252 const Town
*t
= NULL
;
254 if (this->obj
== NULL
) {
256 /* Allow these when there's no object. */
264 /* Allow these, but find the closest town. */
267 if (!IsValidTile(this->tile
)) goto unhandled
;
268 t
= ClosestTownFromTile(this->tile
, UINT_MAX
);
271 /* Construction date */
272 case 0x42: return _date
;
274 /* Object founder information */
275 case 0x44: return _current_company
;
278 case 0x48: return this->view
;
282 * 0x40: Relative position is passed as parameter during construction.
283 * 0x43: Animation counter is only for actual tiles.
284 * 0x47: Object colour is only valid when its built.
285 * 0x63: Animation counter of nearby tile, see above.
291 /* If there's an invalid tile, then we don't have enough information at all. */
292 if (!IsValidTile(this->tile
)) goto unhandled
;
298 /* Relative position. */
300 uint offset
= this->tile
- this->obj
->location
.tile
;
301 uint offset_x
= TileX(offset
);
302 uint offset_y
= TileY(offset
);
303 return offset_y
<< 20 | offset_x
<< 16 | offset_y
<< 8 | offset_x
;
306 /* Tile information. */
307 case 0x41: return GetTileSlope(this->tile
) << 8 | GetTerrainType(this->tile
);
309 /* Construction date */
310 case 0x42: return this->obj
->build_date
;
312 /* Animation counter */
313 case 0x43: return GetAnimationFrame(this->tile
);
315 /* Object founder information */
316 case 0x44: return GetTileOwner(this->tile
);
318 /* Get town zone and Manhattan distance of closest town */
319 case 0x45: return GetTownRadiusGroup(t
, this->tile
) << 16 | min(DistanceManhattan(this->tile
, t
->xy
), 0xFFFF);
321 /* Get square of Euclidian distance of closes town */
322 case 0x46: return GetTownRadiusGroup(t
, this->tile
) << 16 | min(DistanceSquare(this->tile
, t
->xy
), 0xFFFF);
325 case 0x47: return this->obj
->colour
;
328 case 0x48: return this->obj
->view
;
330 /* Get object ID at offset param */
331 case 0x60: return GetObjectIDAtOffset(GetNearbyTile(parameter
, this->tile
), this->ro
.grffile
->grfid
);
333 /* Get random tile bits at offset param */
335 TileIndex tile
= GetNearbyTile(parameter
, this->tile
);
336 return (IsObjectTile(tile
) && Object::GetByTile(tile
) == this->obj
) ? GetObjectRandomBits(tile
) : 0;
339 /* Land info of nearby tiles */
340 case 0x62: return GetNearbyObjectTileInformation(parameter
, this->tile
, this->obj
== NULL
? INVALID_OBJECT
: this->obj
->index
, this->ro
.grffile
->grf_version
>= 8);
342 /* Animation counter of nearby tile */
344 TileIndex tile
= GetNearbyTile(parameter
, this->tile
);
345 return (IsObjectTile(tile
) && Object::GetByTile(tile
) == this->obj
) ? GetAnimationFrame(tile
) : 0;
348 /* Count of object, distance of closest instance */
349 case 0x64: return GetCountAndDistanceOfClosestInstance(parameter
, this->ro
.grffile
->grfid
, this->tile
, this->obj
);
353 DEBUG(grf
, 1, "Unhandled object variable 0x%X", variable
);
360 * Get the object's sprite group.
361 * @param spec The specification to get the sprite group from.
362 * @param o The object to get he sprite group for.
363 * @return The resolved sprite group.
365 static const SpriteGroup
*GetObjectSpriteGroup(const ObjectSpec
*spec
, const Object
*o
)
367 const SpriteGroup
*group
= NULL
;
369 if (o
== NULL
) group
= spec
->grf_prop
.spritegroup
[CT_PURCHASE_OBJECT
];
370 if (group
!= NULL
) return group
;
372 /* Fall back to the default set if the selected cargo type is not defined */
373 return spec
->grf_prop
.spritegroup
[0];
378 * Constructor of the object resolver.
379 * @param obj Object being resolved.
380 * @param tile %Tile of the object.
381 * @param view View of the object.
382 * @param callback Callback ID.
383 * @param callback_param1 First parameter (var 10) of the callback.
384 * @param callback_param2 Second parameter (var 18) of the callback.
386 ObjectResolverObject::ObjectResolverObject(const ObjectSpec
*spec
, Object
*obj
, TileIndex tile
, uint8 view
,
387 CallbackID callback
, uint32 param1
, uint32 param2
)
388 : ResolverObject(spec
->grf_prop
.grffile
, callback
, param1
, param2
), object_scope(*this, obj
, tile
, view
)
390 this->town_scope
= NULL
;
393 ObjectResolverObject::~ObjectResolverObject()
395 delete this->town_scope
;
399 * Get the town resolver scope that belongs to this object resolver.
400 * On the first call, the town scope is created (if possible).
401 * @return Town scope, if available.
403 TownScopeResolver
*ObjectResolverObject::GetTown()
405 if (this->town_scope
== NULL
) {
407 if (this->object_scope
.obj
!= NULL
) {
408 t
= this->object_scope
.obj
->town
;
410 t
= ClosestTownFromTile(this->object_scope
.tile
, UINT_MAX
);
412 if (t
== NULL
) return NULL
;
413 this->town_scope
= new TownScopeResolver(*this, t
, this->object_scope
.obj
== NULL
);
415 return this->town_scope
;
419 * Perform a callback for an object.
420 * @param callback The callback to perform.
421 * @param param1 The first parameter to pass to the NewGRF.
422 * @param param2 The second parameter to pass to the NewGRF.
423 * @param spec The specification of the object / the entry point.
424 * @param o The object to call the callback for.
425 * @param tile The tile the callback is called for.
426 * @param view The view of the object (only used when o == NULL).
427 * @return The result of the callback.
429 uint16
GetObjectCallback(CallbackID callback
, uint32 param1
, uint32 param2
, const ObjectSpec
*spec
, Object
*o
, TileIndex tile
, uint8 view
)
431 ObjectResolverObject
object(spec
, o
, tile
, view
, callback
, param1
, param2
);
432 const SpriteGroup
*group
= SpriteGroup::Resolve(GetObjectSpriteGroup(spec
, o
), object
);
433 if (group
== NULL
) return CALLBACK_FAILED
;
435 return group
->GetCallbackResult();
439 * Draw an group of sprites on the map.
440 * @param ti Information about the tile to draw on.
441 * @param group The group of sprites to draw.
442 * @param spec Object spec to draw.
444 static void DrawTileLayout(const TileInfo
*ti
, const TileLayoutSpriteGroup
*group
, const ObjectSpec
*spec
)
446 const DrawTileSprites
*dts
= group
->ProcessRegisters(NULL
);
447 PaletteID palette
= ((spec
->flags
& OBJECT_FLAG_2CC_COLOUR
) ? SPR_2CCMAP_BASE
: PALETTE_RECOLOUR_START
) + Object::GetByTile(ti
->tile
)->colour
;
449 SpriteID image
= dts
->ground
.sprite
;
450 PaletteID pal
= dts
->ground
.pal
;
452 if (GB(image
, 0, SPRITE_WIDTH
) != 0) {
453 /* If the ground sprite is the default flat water sprite, draw also canal/river borders
454 * Do not do this if the tile's WaterClass is 'land'. */
455 if ((image
== SPR_FLAT_WATER_TILE
|| spec
->flags
& OBJECT_FLAG_DRAW_WATER
) && IsTileOnWater(ti
->tile
)) {
456 DrawWaterClassGround(ti
);
458 DrawGroundSprite(image
, GroundSpritePaletteTransform(image
, pal
, palette
));
462 DrawNewGRFTileSeq(ti
, dts
, TO_STRUCTURES
, 0, palette
);
466 * Draw an object on the map.
467 * @param ti Information about the tile to draw on.
468 * @param spec Object spec to draw.
470 void DrawNewObjectTile(TileInfo
*ti
, const ObjectSpec
*spec
)
472 Object
*o
= Object::GetByTile(ti
->tile
);
473 ObjectResolverObject
object(spec
, o
, ti
->tile
);
475 const SpriteGroup
*group
= SpriteGroup::Resolve(GetObjectSpriteGroup(spec
, o
), object
);
476 if (group
== NULL
|| group
->type
!= SGT_TILELAYOUT
) return;
478 DrawTileLayout(ti
, (const TileLayoutSpriteGroup
*)group
, spec
);
482 * Draw representation of an object (tile) for GUI purposes.
483 * @param x Position x of image.
484 * @param y Position y of image.
485 * @param spec Object spec to draw.
486 * @param view The object's view.
488 void DrawNewObjectTileInGUI(int x
, int y
, const ObjectSpec
*spec
, uint8 view
)
490 ObjectResolverObject
object(spec
, NULL
, INVALID_TILE
, view
);
491 const SpriteGroup
*group
= SpriteGroup::Resolve(GetObjectSpriteGroup(spec
, NULL
), object
);
492 if (group
== NULL
|| group
->type
!= SGT_TILELAYOUT
) return;
494 const DrawTileSprites
*dts
= ((const TileLayoutSpriteGroup
*)group
)->ProcessRegisters(NULL
);
497 if (Company::IsValidID(_local_company
)) {
498 /* Get the colours of our company! */
499 if (spec
->flags
& OBJECT_FLAG_2CC_COLOUR
) {
500 const Livery
*l
= Company::Get(_local_company
)->livery
;
501 palette
= SPR_2CCMAP_BASE
+ l
->colour1
+ l
->colour2
* 16;
503 palette
= COMPANY_SPRITE_COLOUR(_local_company
);
506 /* There's no company, so just take the base palette. */
507 palette
= (spec
->flags
& OBJECT_FLAG_2CC_COLOUR
) ? SPR_2CCMAP_BASE
: PALETTE_RECOLOUR_START
;
510 SpriteID image
= dts
->ground
.sprite
;
511 PaletteID pal
= dts
->ground
.pal
;
513 if (GB(image
, 0, SPRITE_WIDTH
) != 0) {
514 DrawSprite(image
, GroundSpritePaletteTransform(image
, pal
, palette
), x
, y
);
517 DrawNewGRFTileSeqInGUI(x
, y
, dts
, 0, palette
);
521 * Perform a callback for an object.
522 * @param callback The callback to perform.
523 * @param param1 The first parameter to pass to the NewGRF.
524 * @param param2 The second parameter to pass to the NewGRF.
525 * @param spec The specification of the object / the entry point.
526 * @param o The object to call the callback for.
527 * @param tile The tile the callback is called for.
528 * @param extra_data Ignored.
529 * @return The result of the callback.
531 uint16
StubGetObjectCallback(CallbackID callback
, uint32 param1
, uint32 param2
, const ObjectSpec
*spec
, Object
*o
, TileIndex tile
, int extra_data
)
533 return GetObjectCallback(callback
, param1
, param2
, spec
, o
, tile
);
536 /** Helper class for animation control. */
537 struct ObjectAnimationBase
: public AnimationBase
<ObjectAnimationBase
, ObjectSpec
, Object
, int, StubGetObjectCallback
> {
538 static const CallbackID cb_animation_speed
= CBID_OBJECT_ANIMATION_SPEED
;
539 static const CallbackID cb_animation_next_frame
= CBID_OBJECT_ANIMATION_NEXT_FRAME
;
541 static const ObjectCallbackMask cbm_animation_speed
= CBM_OBJ_ANIMATION_SPEED
;
542 static const ObjectCallbackMask cbm_animation_next_frame
= CBM_OBJ_ANIMATION_NEXT_FRAME
;
546 * Handle the animation of the object tile.
547 * @param tile The tile to animate.
549 void AnimateNewObjectTile(TileIndex tile
)
551 const ObjectSpec
*spec
= ObjectSpec::GetByTile(tile
);
552 if (spec
== NULL
|| !(spec
->flags
& OBJECT_FLAG_ANIMATION
)) return;
554 ObjectAnimationBase::AnimateTile(spec
, Object::GetByTile(tile
), tile
, (spec
->flags
& OBJECT_FLAG_ANIM_RANDOM_BITS
) != 0);
558 * Trigger the update of animation on a single tile.
559 * @param o The object that got triggered.
560 * @param tile The location of the triggered tile.
561 * @param trigger The trigger that is triggered.
562 * @param spec The spec associated with the object.
564 void TriggerObjectTileAnimation(Object
*o
, TileIndex tile
, ObjectAnimationTrigger trigger
, const ObjectSpec
*spec
)
566 if (!HasBit(spec
->animation
.triggers
, trigger
)) return;
568 ObjectAnimationBase::ChangeAnimationFrame(CBID_OBJECT_ANIMATION_START_STOP
, spec
, o
, tile
, Random(), trigger
);
572 * Trigger the update of animation on a whole object.
573 * @param o The object that got triggered.
574 * @param trigger The trigger that is triggered.
575 * @param spec The spec associated with the object.
577 void TriggerObjectAnimation(Object
*o
, ObjectAnimationTrigger trigger
, const ObjectSpec
*spec
)
579 if (!HasBit(spec
->animation
.triggers
, trigger
)) return;
581 TILE_AREA_LOOP(tile
, o
->location
) {
582 TriggerObjectTileAnimation(o
, tile
, trigger
, spec
);