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_industrytiles.cpp NewGRF handling of industry tiles. */
14 #include "landscape.h"
15 #include "newgrf_industrytiles.h"
16 #include "newgrf_sound.h"
19 #include "command_func.h"
21 #include "newgrf_animation_base.h"
22 #include "map/slope.h"
24 #include "table/strings.h"
27 * Based on newhouses equivalent, but adapted for newindustries
28 * @param parameter from callback. It's in fact a pair of coordinates
29 * @param tile TileIndex from which the callback was initiated
30 * @param index of the industry been queried for
31 * @param signed_offsets Are the x and y offset encoded in parameter signed?
32 * @param grf_version8 True, if we are dealing with a new NewGRF which uses GRF version >= 8.
33 * @return a construction of bits obeying the newgrf format
35 uint32
GetNearbyIndustryTileInformation(byte parameter
, TileIndex tile
, IndustryID index
, bool signed_offsets
, bool grf_version8
)
37 if (parameter
!= 0) tile
= GetNearbyTile(parameter
, tile
, signed_offsets
); // only perform if it is required
38 bool is_same_industry
= (IsIndustryTile(tile
) && GetIndustryIndex(tile
) == index
);
40 return GetNearbyTileInformation(tile
, grf_version8
) | (is_same_industry
? 1 : 0) << 8;
44 * This is the position of the tile relative to the northernmost tile of the industry.
47 * x the x offset from the northernmost tile
48 * XX same, but stored in a byte instead of a nibble
49 * y the y offset from the northernmost tile
50 * YY same, but stored in a byte instead of a nibble
51 * @param tile TileIndex of the tile to evaluate
52 * @param ind_tile northernmost tile of the industry
54 uint32
GetRelativePosition(TileIndex tile
, TileIndex ind_tile
)
56 byte x
= TileX(tile
) - TileX(ind_tile
);
57 byte y
= TileY(tile
) - TileY(ind_tile
);
59 return ((y
& 0xF) << 20) | ((x
& 0xF) << 16) | (y
<< 8) | x
;
62 /* virtual */ uint32
IndustryTileScopeResolver::GetVariable(byte variable
, uint32 parameter
, bool *available
) const
65 /* Construction state of the tile: a value between 0 and 3 */
66 case 0x40: return (IsIndustryTile(this->tile
)) ? GetIndustryConstructionStage(this->tile
) : 0;
69 case 0x41: return GetTerrainType(this->tile
);
71 /* Current town zone of the tile in the nearest town */
72 case 0x42: return GetTownRadiusGroup(ClosestTownFromTile(this->tile
), this->tile
);
74 /* Relative position */
75 case 0x43: return GetRelativePosition(this->tile
, this->industry
->location
.tile
);
77 /* Animation frame. Like house variable 46 but can contain anything 0..FF. */
78 case 0x44: return IsIndustryTile(this->tile
) ? GetAnimationFrame(this->tile
) : 0;
80 /* Land info of nearby tiles */
81 case 0x60: return GetNearbyIndustryTileInformation(parameter
, this->tile
,
82 this->industry
== NULL
? (IndustryID
)INVALID_INDUSTRY
: this->industry
->index
, true, this->grffile
->grf_version
>= 8);
84 /* Animation stage of nearby tiles */
86 TileIndex tile
= GetNearbyTile(parameter
, this->tile
);
87 if (IsIndustryTile(tile
) && Industry::GetByTile(tile
) == this->industry
) {
88 return GetAnimationFrame(tile
);
93 /* Get industry tile ID at offset */
94 case 0x62: return GetIndustryIDAtOffset(GetNearbyTile(parameter
, this->tile
), this->industry
, this->grffile
->grfid
);
97 DEBUG(grf
, 1, "Unhandled industry tile variable 0x%X", variable
);
103 /* virtual */ uint32
IndustryTileScopeResolver::GetRandomBits() const
105 assert(this->industry
!= NULL
&& IsValidTile(this->tile
));
106 assert(this->industry
->index
== INVALID_INDUSTRY
|| IsIndustryTile(this->tile
));
108 return (this->industry
->index
!= INVALID_INDUSTRY
) ? GetIndustryRandomBits(this->tile
) : 0;
111 /* virtual */ uint32
IndustryTileScopeResolver::GetTriggers() const
113 assert(this->industry
!= NULL
&& IsValidTile(this->tile
));
114 assert(this->industry
->index
== INVALID_INDUSTRY
|| IsIndustryTile(this->tile
));
115 if (this->industry
->index
== INVALID_INDUSTRY
) return 0;
116 return GetIndustryTriggers(this->tile
);
119 /* virtual */ void IndustryTileScopeResolver::SetTriggers(int triggers
) const
121 assert(this->industry
!= NULL
&& this->industry
->index
!= INVALID_INDUSTRY
&& IsValidTile(this->tile
) && IsIndustryTile(this->tile
));
122 SetIndustryTriggers(this->tile
, triggers
);
126 * Get the associated NewGRF file from the industry graphics.
127 * @param gfx Graphics to query.
128 * @return Grf file associated with the graphics, if any.
130 static const GRFFile
*GetIndTileGrffile(IndustryGfx gfx
)
132 const IndustryTileSpec
*its
= GetIndustryTileSpec(gfx
);
133 return (its
!= NULL
) ? its
->grf_prop
.grffile
: NULL
;
137 * Constructor of the industry tiles scope resolver.
138 * @param gfx Graphics of the industry.
139 * @param tile %Tile of the industry.
140 * @param indus %Industry owning the tile.
141 * @param callback Callback ID.
142 * @param callback_param1 First parameter (var 10) of the callback.
143 * @param callback_param2 Second parameter (var 18) of the callback.
145 IndustryTileResolverObject::IndustryTileResolverObject(IndustryGfx gfx
, TileIndex tile
, Industry
*indus
,
146 CallbackID callback
, uint32 callback_param1
, uint32 callback_param2
)
147 : ResolverObject(GetIndTileGrffile(gfx
), callback
, callback_param1
, callback_param2
),
148 indtile_scope(this->grffile
, indus
, tile
),
149 ind_scope(*this, tile
, indus
, indus
->type
)
151 this->root_spritegroup
= GetIndustryTileSpec(gfx
)->grf_prop
.spritegroup
;
155 * Constructor of the scope resolver for the industry tile.
156 * @param grffile GRFFile the resolved SpriteGroup belongs to.
157 * @param industry %Industry owning the tile.
158 * @param tile %Tile of the industry.
160 IndustryTileScopeResolver::IndustryTileScopeResolver (const GRFFile
*grffile
, Industry
*industry
, TileIndex tile
)
161 : ScopeResolver(), grffile(grffile
)
163 this->industry
= industry
;
167 static void IndustryDrawTileLayout(const TileInfo
*ti
, const TileLayoutSpriteGroup
*group
, byte rnd_colour
, byte stage
, IndustryGfx gfx
)
169 TileLayoutSpriteGroup::Result
result (group
, stage
);
171 SpriteID image
= result
.ground
.sprite
;
172 PaletteID pal
= result
.ground
.pal
;
174 if (HasBit(image
, SPRITE_MODIFIER_CUSTOM_SPRITE
)) image
+= result
.stage
;
175 if (HasBit(pal
, SPRITE_MODIFIER_CUSTOM_SPRITE
)) pal
+= result
.stage
;
177 if (GB(image
, 0, SPRITE_WIDTH
) != 0) {
178 /* If the ground sprite is the default flat water sprite, draw also canal/river borders
179 * Do not do this if the tile's WaterClass is 'land'. */
180 if (image
== SPR_FLAT_WATER_TILE
&& IsTileOnWater(ti
->tile
)) {
181 DrawWaterClassGround(ti
);
183 DrawGroundSprite (ti
, image
, GroundSpritePaletteTransform(image
, pal
, GENERAL_SPRITE_COLOUR(rnd_colour
)));
187 DrawNewGRFTileSeq (ti
, result
.seq
, TO_INDUSTRIES
, result
.stage
, GENERAL_SPRITE_COLOUR(rnd_colour
));
190 uint16
GetIndustryTileCallback(CallbackID callback
, uint32 param1
, uint32 param2
, IndustryGfx gfx_id
, Industry
*industry
, TileIndex tile
)
192 assert(industry
!= NULL
&& IsValidTile(tile
));
193 assert(industry
->index
== INVALID_INDUSTRY
|| IsIndustryTile(tile
));
195 IndustryTileResolverObject
object(gfx_id
, tile
, industry
, callback
, param1
, param2
);
196 return SpriteGroup::CallbackResult (object
.Resolve());
199 bool DrawNewIndustryTile(TileInfo
*ti
, Industry
*i
, IndustryGfx gfx
, const IndustryTileSpec
*inds
)
201 if (ti
->tileh
!= SLOPE_FLAT
) {
202 bool draw_old_one
= true;
203 if (HasBit(inds
->callback_mask
, CBM_INDT_DRAW_FOUNDATIONS
)) {
204 /* Called to determine the type (if any) of foundation to draw for industry tile */
205 uint32 callback_res
= GetIndustryTileCallback(CBID_INDTILE_DRAW_FOUNDATIONS
, 0, 0, gfx
, i
, ti
->tile
);
206 if (callback_res
!= CALLBACK_FAILED
) draw_old_one
= ConvertBooleanCallback(inds
->grf_prop
.grffile
, CBID_INDTILE_DRAW_FOUNDATIONS
, callback_res
);
209 if (draw_old_one
) DrawFoundation(ti
, FOUNDATION_LEVELED
);
212 IndustryTileResolverObject
object(gfx
, ti
->tile
, i
);
214 const SpriteGroup
*group
= object
.Resolve();
215 if (group
== NULL
|| !group
->IsType (SGT_TILELAYOUT
)) return false;
217 /* Limit the building stage to the number of stages supplied. */
218 const TileLayoutSpriteGroup
*tlgroup
= (const TileLayoutSpriteGroup
*)group
;
219 byte stage
= GetIndustryConstructionStage(ti
->tile
);
220 IndustryDrawTileLayout(ti
, tlgroup
, i
->random_colour
, stage
, gfx
);
224 extern bool IsSlopeRefused(Slope current
, Slope refused
);
227 * Check the slope of a tile of a new industry.
228 * @param ind_base_tile Base tile of the industry.
229 * @param ind_tile Tile to check.
230 * @param its Tile specification.
231 * @param type Industry type.
232 * @param gfx Gfx of the tile.
233 * @param itspec_index Layout.
234 * @param initial_random_bits Random bits of industry after construction
235 * @param founder Industry founder
236 * @param creation_type The circumstances the industry is created under.
237 * @return Succeeded or failed command.
239 CommandCost
PerformIndustryTileSlopeCheck(TileIndex ind_base_tile
, TileIndex ind_tile
, const IndustryTileSpec
*its
, IndustryType type
, IndustryGfx gfx
, uint itspec_index
, uint16 initial_random_bits
, Owner founder
, IndustryAvailabilityCallType creation_type
)
242 ind
.index
= INVALID_INDUSTRY
;
243 ind
.location
.tile
= ind_base_tile
;
246 ind
.random
= initial_random_bits
;
247 ind
.founder
= founder
;
249 uint16 callback_res
= GetIndustryTileCallback(CBID_INDTILE_SHAPE_CHECK
, 0, creation_type
<< 8 | itspec_index
, gfx
, &ind
, ind_tile
);
250 if (callback_res
== CALLBACK_FAILED
) {
251 if (!IsSlopeRefused(GetTileSlope(ind_tile
), its
->slopes_refused
)) return CommandCost();
252 return_cmd_error(STR_ERROR_SITE_UNSUITABLE
);
254 if (its
->grf_prop
.grffile
->grf_version
< 7) {
255 if (callback_res
!= 0) return CommandCost();
256 return_cmd_error(STR_ERROR_SITE_UNSUITABLE
);
259 return GetErrorMessageFromLocationCallbackResult(callback_res
, its
->grf_prop
.grffile
, STR_ERROR_SITE_UNSUITABLE
);
262 /** Helper class for animation control. */
263 struct IndustryAnimationBase
{
264 static const CallbackID cb_animation_speed
= CBID_INDTILE_ANIMATION_SPEED
;
265 static const CallbackID cb_animation_next_frame
= CBID_INDTILE_ANIM_NEXT_FRAME
;
267 static const IndustryTileCallbackMask cbm_animation_speed
= CBM_INDT_ANIM_SPEED
;
268 static const IndustryTileCallbackMask cbm_animation_next_frame
= CBM_INDT_ANIM_NEXT_FRAME
;
270 /** Callback wrapper for animation control. */
271 static uint16
get_callback (CallbackID callback
, uint32 param1
, uint32 param2
, const IndustryTileSpec
*spec
, Industry
*ind
, TileIndex tile
)
273 return GetIndustryTileCallback (callback
, param1
, param2
, spec
- GetIndustryTileSpec(0), ind
, tile
);
277 void AnimateNewIndustryTile(TileIndex tile
)
279 const IndustryTileSpec
*itspec
= GetIndustryTileSpec(GetIndustryGfx(tile
));
280 if (itspec
== NULL
) return;
282 AnimationBase::AnimateTile
<IndustryAnimationBase
> (itspec
, Industry::GetByTile(tile
), tile
, (itspec
->special_flags
& INDTILE_SPECIAL_NEXTFRAME_RANDOMBITS
) != 0);
285 bool StartStopIndustryTileAnimation(TileIndex tile
, IndustryAnimationTrigger iat
, uint32 random
)
287 IndustryGfx gfx
= GetIndustryGfx (tile
);
288 const IndustryTileSpec
*itspec
= GetIndustryTileSpec (gfx
);
290 if (!HasBit(itspec
->animation
.triggers
, iat
)) return false;
292 uint16 callback
= GetIndustryTileCallback (CBID_INDTILE_ANIM_START_STOP
,
293 random
, iat
, gfx
, Industry::GetByTile(tile
), tile
);
294 AnimationBase::ChangeAnimationFrame (itspec
, tile
, callback
);
298 bool StartStopIndustryTileAnimation(const Industry
*ind
, IndustryAnimationTrigger iat
)
301 uint32 random
= Random();
302 TILE_AREA_LOOP(tile
, ind
->location
) {
303 if (ind
->TileBelongsToIndustry(tile
)) {
304 if (StartStopIndustryTileAnimation(tile
, iat
, random
)) {
305 SB(random
, 0, 16, Random());
316 * Trigger random triggers for an industry tile and reseed its random bits.
317 * @param tile Industry tile to trigger.
318 * @param trigger Trigger to trigger.
319 * @param ind Industry of the tile.
320 * @param [in,out] reseed_industry Collects bits to reseed for the industry.
322 static void DoTriggerIndustryTile(TileIndex tile
, IndustryTileTrigger trigger
, Industry
*ind
, uint32
&reseed_industry
)
324 assert(IsValidTile(tile
) && IsIndustryTile(tile
));
326 IndustryGfx gfx
= GetIndustryGfx(tile
);
327 const IndustryTileSpec
*itspec
= GetIndustryTileSpec(gfx
);
329 if (itspec
->grf_prop
.spritegroup
== NULL
) return;
331 IndustryTileResolverObject
object(gfx
, tile
, ind
, CBID_RANDOM_TRIGGER
);
332 object
.trigger
= trigger
;
334 const SpriteGroup
*group
= object
.Resolve();
335 if (group
== NULL
) return;
337 byte new_random_bits
= Random();
338 byte random_bits
= GetIndustryRandomBits(tile
);
339 random_bits
&= ~object
.reseed
[VSG_SCOPE_SELF
];
340 random_bits
|= new_random_bits
& object
.reseed
[VSG_SCOPE_SELF
];
341 SetIndustryRandomBits(tile
, random_bits
);
342 MarkTileDirtyByTile(tile
);
344 reseed_industry
|= object
.reseed
[VSG_SCOPE_PARENT
];
348 * Reseeds the random bits of an industry.
349 * @param ind Industry.
350 * @param reseed Bits to reseed.
352 static void DoReseedIndustry(Industry
*ind
, uint32 reseed
)
354 if (reseed
== 0 || ind
== NULL
) return;
356 uint16 random_bits
= Random();
357 ind
->random
&= reseed
;
358 ind
->random
|= random_bits
& reseed
;
362 * Trigger a random trigger for a single industry tile.
363 * @param tile Industry tile to trigger.
364 * @param trigger Trigger to trigger.
366 void TriggerIndustryTile(TileIndex tile
, IndustryTileTrigger trigger
)
368 uint32 reseed_industry
= 0;
369 Industry
*ind
= Industry::GetByTile(tile
);
370 DoTriggerIndustryTile(tile
, trigger
, ind
, reseed_industry
);
371 DoReseedIndustry(ind
, reseed_industry
);
375 * Trigger a random trigger for all industry tiles.
376 * @param ind Industry to trigger.
377 * @param trigger Trigger to trigger.
379 void TriggerIndustry(Industry
*ind
, IndustryTileTrigger trigger
)
381 uint32 reseed_industry
= 0;
382 TILE_AREA_LOOP(tile
, ind
->location
) {
383 if (ind
->TileBelongsToIndustry(tile
)) {
384 DoTriggerIndustryTile(tile
, trigger
, ind
, reseed_industry
);
387 DoReseedIndustry(ind
, reseed_industry
);