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 object_cmd.cpp Handling of object tiles. */
13 #include "landscape.h"
14 #include "command_func.h"
15 #include "viewport_func.h"
16 #include "company_base.h"
20 #include "autoslope.h"
21 #include "clear_func.h"
23 #include "window_func.h"
24 #include "company_gui.h"
25 #include "cheat_type.h"
27 #include "cargopacket.h"
28 #include "core/random_func.hpp"
29 #include "core/pool_func.hpp"
30 #include "map/object.h"
31 #include "map/bridge.h"
32 #include "object_base.h"
33 #include "newgrf_config.h"
34 #include "newgrf_object.h"
35 #include "date_func.h"
36 #include "newgrf_debug.h"
37 #include "vehicle_func.h"
39 #include "table/strings.h"
40 #include "table/object_land.h"
42 template<> Object::Pool
Object::PoolItem::pool ("Object");
43 INSTANTIATE_POOL_METHODS(Object
)
44 uint16
Object::counts
[NUM_OBJECTS
];
47 * Get the object associated with a tile.
48 * @param tile The tile to fetch the object for.
51 /* static */ Object
*Object::GetByTile(TileIndex tile
)
53 return Object::Get(GetObjectIndex(tile
));
57 * Gets the ObjectType of the given object tile
58 * @param t the tile to get the type from.
59 * @pre IsObjectTile(t)
62 ObjectType
GetObjectType(TileIndex t
)
64 assert(IsObjectTile(t
));
65 return Object::GetByTile(t
)->type
;
68 /** Initialize/reset the objects. */
69 void InitializeObjects()
71 Object::ResetTypeCounts();
75 * Actually build the object.
76 * @param type The type of object to build.
77 * @param tile The tile to build the northern tile of the object on.
78 * @param owner The owner of the object.
79 * @param town Town the tile is related with.
80 * @param view The view for the object.
81 * @pre All preconditions for building the object at that location
82 * are met, e.g. slope and clearness of tiles are checked.
84 void BuildObject(ObjectType type
, TileIndex tile
, CompanyID owner
, Town
*town
, uint8 view
)
86 const ObjectSpec
*spec
= ObjectSpec::Get(type
);
88 TileArea
ta(tile
, GB(spec
->size
, HasBit(view
, 0) ? 4 : 0, 4), GB(spec
->size
, HasBit(view
, 0) ? 0 : 4, 4));
89 Object
*o
= new Object();
92 o
->town
= town
== NULL
? CalcClosestTownFromTile(tile
) : town
;
93 o
->build_date
= _date
;
96 /* If nothing owns the object, the colour will be random. Otherwise
97 * get the colour from the company's livery settings. */
98 if (owner
== OWNER_NONE
) {
101 const Livery
*l
= Company::Get(owner
)->livery
;
102 o
->colour
= l
->colour1
+ l
->colour2
* 16;
105 /* If the object wants only one colour, then give it that colour. */
106 if ((spec
->flags
& OBJECT_FLAG_2CC_COLOUR
) == 0) o
->colour
&= 0xF;
108 if (HasBit(spec
->callback_mask
, CBM_OBJ_COLOUR
)) {
109 uint16 res
= GetObjectCallback(CBID_OBJECT_COLOUR
, o
->colour
, 0, spec
, o
, tile
);
110 if (res
!= CALLBACK_FAILED
) {
111 if (res
>= 0x100) ErrorUnknownCallbackResult(spec
->grf_prop
.grffile
->grfid
, CBID_OBJECT_COLOUR
, res
);
112 o
->colour
= GB(res
, 0, 8);
116 assert(o
->town
!= NULL
);
118 TILE_AREA_LOOP(t
, ta
) {
119 WaterClass wc
= (IsPlainWaterTile(t
) ? GetWaterClass(t
) : WATER_CLASS_INVALID
);
120 /* Update company infrastructure counts for objects build on canals owned by nobody. */
121 if (wc
== WATER_CLASS_CANAL
&& owner
!= OWNER_NONE
&& (IsTileOwner(tile
, OWNER_NONE
) || IsTileOwner(tile
, OWNER_WATER
))) {
122 Company::Get(owner
)->infrastructure
.water
++;
123 DirtyCompanyInfrastructureWindows(owner
);
125 MakeObject(t
, owner
, o
->index
, wc
, Random());
126 MarkTileDirtyByTile(t
);
129 Object::IncTypeCount(type
);
130 if (spec
->flags
& OBJECT_FLAG_ANIMATION
) TriggerObjectAnimation(o
, OAT_BUILT
, spec
);
134 * Increase the animation stage of a whole structure.
135 * @param tile The tile of the structure.
137 static void IncreaseAnimationStage(TileIndex tile
)
139 TileArea ta
= Object::GetByTile(tile
)->location
;
140 TILE_AREA_LOOP(t
, ta
) {
141 SetAnimationFrame(t
, GetAnimationFrame(t
) + 1);
142 MarkTileDirtyByTile(t
);
146 /** We encode the company HQ size in the animation stage. */
147 #define GetCompanyHQSize GetAnimationFrame
148 /** We encode the company HQ size in the animation stage. */
149 #define IncreaseCompanyHQSize IncreaseAnimationStage
152 * Update the CompanyHQ to the state associated with the given score
153 * @param tile The (northern) tile of the company HQ, or INVALID_TILE.
154 * @param score The current (performance) score of the company.
156 void UpdateCompanyHQ(TileIndex tile
, uint score
)
158 if (tile
== INVALID_TILE
) return;
161 (val
= 0, score
< 170) ||
162 (val
++, score
< 350) ||
163 (val
++, score
< 520) ||
164 (val
++, score
< 720) ||
167 while (GetCompanyHQSize(tile
) < val
) {
168 IncreaseCompanyHQSize(tile
);
173 * Updates the colour of the object whenever a company changes.
174 * @param c The company the company colour changed of.
176 void UpdateObjectColours(const Company
*c
)
179 FOR_ALL_OBJECTS(obj
) {
180 Owner owner
= GetTileOwner(obj
->location
.tile
);
181 /* Not the current owner, so colour doesn't change. */
182 if (owner
!= c
->index
) continue;
184 const ObjectSpec
*spec
= ObjectSpec::GetByTile(obj
->location
.tile
);
185 /* Using the object colour callback, so not using company colour. */
186 if (HasBit(spec
->callback_mask
, CBM_OBJ_COLOUR
)) continue;
188 const Livery
*l
= c
->livery
;
189 obj
->colour
= ((spec
->flags
& OBJECT_FLAG_2CC_COLOUR
) ? (l
->colour2
* 16) : 0) + l
->colour1
;
193 extern CommandCost
CheckBuildableTile (TileIndex tile
, uint invalid_dirs
,
194 int &allowed_z
, bool allow_steep
, int check_bridge
);
195 static CommandCost
ClearTile_Object(TileIndex tile
, DoCommandFlag flags
);
198 * Build an object object
199 * @param tile tile where the object will be located
200 * @param flags type of operation
201 * @param p1 the object type to build
202 * @param p2 the view for the object
204 * @return the cost of this operation or an error
206 CommandCost
CmdBuildObject(TileIndex tile
, DoCommandFlag flags
, uint32 p1
, uint32 p2
, const char *text
)
208 CommandCost
cost(EXPENSES_PROPERTY
);
210 ObjectType type
= (ObjectType
)GB(p1
, 0, 16);
211 if (type
>= NUM_OBJECTS
) return CMD_ERROR
;
212 uint8 view
= GB(p2
, 0, 2);
213 const ObjectSpec
*spec
= ObjectSpec::Get(type
);
214 if (_game_mode
== GM_NORMAL
&& !spec
->IsAvailable() && !_generating_world
) return CMD_ERROR
;
215 if ((_game_mode
== GM_EDITOR
|| _generating_world
) && !spec
->WasEverAvailable()) return CMD_ERROR
;
217 if ((spec
->flags
& OBJECT_FLAG_ONLY_IN_SCENEDIT
) != 0 && ((!_generating_world
&& _game_mode
!= GM_EDITOR
) || _current_company
!= OWNER_NONE
)) return CMD_ERROR
;
218 if ((spec
->flags
& OBJECT_FLAG_ONLY_IN_GAME
) != 0 && (_generating_world
|| _game_mode
!= GM_NORMAL
|| _current_company
> MAX_COMPANIES
)) return CMD_ERROR
;
219 if (view
>= spec
->views
) return CMD_ERROR
;
221 if (!Object::CanAllocateItem()) return_cmd_error(STR_ERROR_TOO_MANY_OBJECTS
);
222 if (Town::GetNumItems() == 0) return_cmd_error(STR_ERROR_MUST_FOUND_TOWN_FIRST
);
224 int size_x
= GB(spec
->size
, HasBit(view
, 0) ? 4 : 0, 4);
225 int size_y
= GB(spec
->size
, HasBit(view
, 0) ? 0 : 4, 4);
226 TileArea
ta(tile
, size_x
, size_y
);
228 if (type
== OBJECT_OWNED_LAND
) {
229 /* Owned land is special as it can be placed on any slope. */
230 cost
.AddCost(DoCommand(tile
, 0, 0, flags
, CMD_LANDSCAPE_CLEAR
));
232 /* Check the surface to build on. At this time we can't actually execute the
233 * the CLEAR_TILE commands since the newgrf callback later on can check
234 * some information about the tiles. */
235 bool allow_water
= (spec
->flags
& (OBJECT_FLAG_BUILT_ON_WATER
| OBJECT_FLAG_NOT_ON_LAND
)) != 0;
236 bool allow_ground
= (spec
->flags
& OBJECT_FLAG_NOT_ON_LAND
) == 0;
237 TILE_AREA_LOOP(t
, ta
) {
238 if (HasTileWaterGround(t
)) {
239 if (!allow_water
) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER
);
240 if (!IsPlainWaterTile(t
)) {
241 /* Normal water tiles don't have to be cleared. For all other tile types clear
242 * the tile but leave the water. */
243 cost
.AddCost(DoCommand(t
, 0, 0, flags
& ~DC_NO_WATER
& ~DC_EXEC
, CMD_LANDSCAPE_CLEAR
));
245 /* Can't build on water owned by another company. */
246 Owner o
= GetTileOwner(t
);
247 if (o
!= OWNER_NONE
&& o
!= OWNER_WATER
) cost
.AddCost(CheckOwnership(o
, t
));
249 /* However, the tile has to be clear of vehicles. */
250 StringID str
= CheckVehicleOnGround (t
);
251 if (str
!= STR_NULL
) {
252 cost
.AddCost (CommandCost (str
));
256 if (!allow_ground
) return_cmd_error(STR_ERROR_MUST_BE_BUILT_ON_WATER
);
257 /* For non-water tiles, we'll have to clear it before building. */
258 cost
.AddCost(DoCommand(t
, 0, 0, flags
& ~DC_EXEC
, CMD_LANDSCAPE_CLEAR
));
262 /* So, now the surface is checked... check the slope of said surface. */
264 if (GetTileSlope(tile
, &allowed_z
) != SLOPE_FLAT
) allowed_z
++;
266 TILE_AREA_LOOP(t
, ta
) {
267 uint16 callback
= CALLBACK_FAILED
;
268 if (HasBit(spec
->callback_mask
, CBM_OBJ_SLOPE_CHECK
)) {
269 TileIndex diff
= t
- tile
;
270 callback
= GetObjectCallback(CBID_OBJECT_LAND_SLOPE_CHECK
, GetTileSlope(t
), TileY(diff
) << 4 | TileX(diff
), spec
, NULL
, t
, view
);
273 if (callback
== CALLBACK_FAILED
) {
274 cost
.AddCost (CheckBuildableTile (t
, 0, allowed_z
, false, 1));
276 /* The meaning of bit 10 is inverted for a grf version < 8. */
277 if (spec
->grf_prop
.grffile
->grf_version
< 8) ToggleBit(callback
, 10);
278 CommandCost ret
= GetErrorMessageFromLocationCallbackResult(callback
, spec
->grf_prop
.grffile
, STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION
);
279 if (ret
.Failed()) return ret
;
283 if (flags
& DC_EXEC
) {
284 /* This is basically a copy of the loop above with the exception that we now
285 * execute the commands and don't check for errors, since that's already done. */
286 TILE_AREA_LOOP(t
, ta
) {
287 if (HasTileWaterGround(t
)) {
288 if (!IsPlainWaterTile(t
)) {
289 DoCommand(t
, 0, 0, (flags
& ~DC_NO_WATER
) | DC_NO_MODIFY_TOWN_RATING
, CMD_LANDSCAPE_CLEAR
);
292 DoCommand(t
, 0, 0, flags
| DC_NO_MODIFY_TOWN_RATING
, CMD_LANDSCAPE_CLEAR
);
297 if (cost
.Failed()) return cost
;
299 /* Finally do a check for bridges. */
300 TILE_AREA_LOOP(t
, ta
) {
301 if (HasBridgeAbove(t
) && (
302 !(spec
->flags
& OBJECT_FLAG_ALLOW_UNDER_BRIDGE
) ||
303 (GetTileMaxZ(t
) + spec
->height
>= GetBridgeHeight(GetSouthernBridgeEnd(t
))))) {
304 return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST
);
310 case OBJECT_TRANSMITTER
:
311 case OBJECT_LIGHTHOUSE
:
312 if (!IsTileFlat(tile
)) return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED
);
315 case OBJECT_OWNED_LAND
:
316 if (IsObjectTile(tile
) &&
317 IsTileOwner(tile
, _current_company
) &&
318 IsObjectType(tile
, OBJECT_OWNED_LAND
)) {
319 return_cmd_error(STR_ERROR_YOU_ALREADY_OWN_IT
);
324 Company
*c
= Company::Get(_current_company
);
325 if (c
->location_of_HQ
!= INVALID_TILE
) {
326 /* We need to persuade a bit harder to remove the old HQ. */
327 _current_company
= OWNER_WATER
;
328 cost
.AddCost(ClearTile_Object(c
->location_of_HQ
, flags
));
329 _current_company
= c
->index
;
332 if (flags
& DC_EXEC
) {
333 hq_score
= UpdateCompanyRatingAndValue(c
, false);
334 c
->location_of_HQ
= tile
;
335 SetWindowDirty(WC_COMPANY
, c
->index
);
341 /* This may never be constructed using this method. */
344 default: // i.e. NewGRF provided.
348 if (flags
& DC_EXEC
) {
349 BuildObject(type
, tile
, _current_company
, NULL
, view
);
351 /* Make sure the HQ starts at the right size. */
352 if (type
== OBJECT_HQ
) UpdateCompanyHQ(tile
, hq_score
);
355 cost
.AddCost(ObjectSpec::Get(type
)->GetBuildCost() * size_x
* size_y
);
360 static Foundation
GetFoundation_Object(TileIndex tile
, Slope tileh
);
362 static void DrawTile_Object(TileInfo
*ti
)
364 ObjectType type
= GetObjectType(ti
->tile
);
365 const ObjectSpec
*spec
= ObjectSpec::Get(type
);
367 /* Fall back for when the object doesn't exist anymore. */
368 if (!spec
->enabled
) type
= OBJECT_TRANSMITTER
;
370 if ((spec
->flags
& OBJECT_FLAG_HAS_NO_FOUNDATION
) == 0) DrawFoundation(ti
, GetFoundation_Object(ti
->tile
, ti
->tileh
));
372 if (type
< NEW_OBJECT_OFFSET
) {
373 const DrawTileSprites
*dts
= NULL
;
374 Owner to
= GetTileOwner(ti
->tile
);
375 PaletteID palette
= to
== OWNER_NONE
? PAL_NONE
: COMPANY_SPRITE_COLOUR(to
);
377 if (type
== OBJECT_HQ
) {
378 TileIndex diff
= ti
->tile
- Object::GetByTile(ti
->tile
)->location
.tile
;
379 dts
= &_object_hq
[GetCompanyHQSize(ti
->tile
) << 2 | TileY(diff
) << 1 | TileX(diff
)];
381 dts
= &_objects
[type
];
384 if (spec
->flags
& OBJECT_FLAG_HAS_NO_FOUNDATION
) {
385 /* If an object has no foundation, but tries to draw a (flat) ground
386 * type... we have to be nice and convert that for them. */
387 switch (dts
->ground
.sprite
) {
388 case SPR_FLAT_BARE_LAND
: DrawClearLandTile(ti
, 0); break;
389 case SPR_FLAT_1_THIRD_GRASS_TILE
: DrawClearLandTile(ti
, 1); break;
390 case SPR_FLAT_2_THIRD_GRASS_TILE
: DrawClearLandTile(ti
, 2); break;
391 case SPR_FLAT_GRASS_TILE
: DrawClearLandTile(ti
, 3); break;
392 default: DrawGroundSprite (ti
, dts
->ground
.sprite
, palette
); break;
395 DrawGroundSprite (ti
, dts
->ground
.sprite
, palette
);
398 if (!IsInvisibilitySet(TO_STRUCTURES
)) {
399 const DrawTileSeqStruct
*dtss
;
400 foreach_draw_tile_seq(dtss
, dts
->seq
) {
401 AddSortableSpriteToDraw (ti
->vd
,
402 dtss
->image
.sprite
, palette
,
403 ti
->x
+ dtss
->delta_x
, ti
->y
+ dtss
->delta_y
,
404 dtss
->size_x
, dtss
->size_y
,
405 dtss
->size_z
, ti
->z
+ dtss
->delta_z
,
406 IsTransparencySet(TO_STRUCTURES
)
411 DrawNewObjectTile(ti
, spec
);
414 DrawBridgeMiddle(ti
);
417 static int GetSlopePixelZ_Object(TileIndex tile
, uint x
, uint y
)
419 if (IsObjectType(tile
, OBJECT_OWNED_LAND
)) {
421 Slope tileh
= GetTilePixelSlope(tile
, &z
);
423 return z
+ GetPartialPixelZ(x
& 0xF, y
& 0xF, tileh
);
425 return GetTileMaxPixelZ(tile
);
429 static Foundation
GetFoundation_Object(TileIndex tile
, Slope tileh
)
431 return IsObjectType(tile
, OBJECT_OWNED_LAND
) ? FOUNDATION_NONE
: FlatteningFoundation(tileh
);
435 * Perform the actual removal of the object from the map.
436 * @param o The object to really clear.
438 static void ReallyClearObjectTile(Object
*o
)
440 Object::DecTypeCount(o
->type
);
441 TILE_AREA_LOOP(tile_cur
, o
->location
) {
442 DeleteNewGRFInspectWindow(GSF_OBJECTS
, tile_cur
);
444 MakeWaterKeepingClass(tile_cur
, GetTileOwner(tile_cur
));
449 SmallVector
<ClearedObjectArea
, 4> _cleared_object_areas
;
452 * Find the entry in _cleared_object_areas which occupies a certain tile.
453 * @param tile Tile of interest
454 * @return Occupying entry, or NULL if none
456 ClearedObjectArea
*FindClearedObject(TileIndex tile
)
458 TileArea ta
= TileArea(tile
, 1, 1);
460 const ClearedObjectArea
*end
= _cleared_object_areas
.End();
461 for (ClearedObjectArea
*coa
= _cleared_object_areas
.Begin(); coa
!= end
; coa
++) {
462 if (coa
->area
.Intersects(ta
)) return coa
;
468 static CommandCost
ClearTile_Object(TileIndex tile
, DoCommandFlag flags
)
470 /* Get to the northern most tile. */
471 Object
*o
= Object::GetByTile(tile
);
472 TileArea ta
= o
->location
;
474 ObjectType type
= o
->type
;
475 const ObjectSpec
*spec
= ObjectSpec::Get(type
);
477 CommandCost
cost(EXPENSES_CONSTRUCTION
, spec
->GetClearCost() * ta
.w
* ta
.h
/ 5);
478 if (spec
->flags
& OBJECT_FLAG_CLEAR_INCOME
) cost
.MultiplyCost(-1); // They get an income!
480 /* Towns can't remove any objects. */
481 if (_current_company
== OWNER_TOWN
) return CMD_ERROR
;
483 /* Water can remove everything! */
484 if (_current_company
!= OWNER_WATER
) {
485 if ((flags
& DC_NO_WATER
) && IsTileOnWater(tile
)) {
486 /* There is water under the object, treat it as water tile. */
487 return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER
);
488 } else if (!(spec
->flags
& OBJECT_FLAG_AUTOREMOVE
) && (flags
& DC_AUTO
)) {
489 /* No automatic removal by overbuilding stuff. */
490 return_cmd_error(type
== OBJECT_HQ
? STR_ERROR_COMPANY_HEADQUARTERS_IN
: STR_ERROR_OBJECT_IN_THE_WAY
);
491 } else if (_game_mode
== GM_EDITOR
) {
492 /* No further limitations for the editor. */
493 } else if (GetTileOwner(tile
) == OWNER_NONE
) {
494 /* Owned by nobody and unremovable, so we can only remove it with brute force! */
495 if (!_cheats
.magic_bulldozer
.value
&& (spec
->flags
& OBJECT_FLAG_CANNOT_REMOVE
) != 0) return CMD_ERROR
;
496 } else if (CheckTileOwnership(tile
).Failed()) {
497 /* We don't own it!. */
498 return_cmd_error(STR_ERROR_OWNED_BY
);
499 } else if ((spec
->flags
& OBJECT_FLAG_CANNOT_REMOVE
) != 0 && (spec
->flags
& OBJECT_FLAG_AUTOREMOVE
) == 0) {
500 /* In the game editor or with cheats we can remove, otherwise we can't. */
501 if (!_cheats
.magic_bulldozer
.value
) return CMD_ERROR
;
503 /* Removing with the cheat costs more in TTDPatch / the specs. */
504 cost
.MultiplyCost(25);
506 } else if ((spec
->flags
& (OBJECT_FLAG_BUILT_ON_WATER
| OBJECT_FLAG_NOT_ON_LAND
)) != 0) {
507 /* Water can't remove objects that are buildable on water. */
513 Company
*c
= Company::Get(GetTileOwner(tile
));
514 if (flags
& DC_EXEC
) {
515 c
->location_of_HQ
= INVALID_TILE
; // reset HQ position
516 SetWindowDirty(WC_COMPANY
, c
->index
);
517 CargoPacket::InvalidateAllFrom(ST_HEADQUARTERS
, c
->index
);
520 /* cost of relocating company is 1% of company value */
521 cost
= CommandCost(EXPENSES_PROPERTY
, CalculateCompanyValue(c
) / 100);
526 if (flags
& DC_EXEC
) {
527 Town
*town
= o
->town
;
528 ClrBit(town
->statues
, GetTileOwner(tile
));
529 SetWindowDirty(WC_TOWN_AUTHORITY
, town
->index
);
537 ClearedObjectArea
*cleared_area
= _cleared_object_areas
.Append();
538 cleared_area
->first_tile
= tile
;
539 cleared_area
->area
= ta
;
541 if (flags
& DC_EXEC
) ReallyClearObjectTile(o
);
546 static void AddAcceptedCargo_Object(TileIndex tile
, CargoArray
&acceptance
, uint32
*always_accepted
)
548 if (!IsObjectType(tile
, OBJECT_HQ
)) return;
550 /* HQ accepts passenger and mail; but we have to divide the values
551 * between 4 tiles it occupies! */
553 /* HQ level (depends on company performance) in the range 1..5. */
554 uint level
= GetCompanyHQSize(tile
) + 1;
556 /* Top town building generates 10, so to make HQ interesting, the top
558 acceptance
[CT_PASSENGERS
] += max(1U, level
);
559 SetBit(*always_accepted
, CT_PASSENGERS
);
561 /* Top town building generates 4, HQ can make up to 8. The
562 * proportion passengers:mail is different because such a huge
563 * commercial building generates unusually high amount of mail
564 * correspondence per physical visitor. */
565 acceptance
[CT_MAIL
] += max(1U, level
/ 2);
566 SetBit(*always_accepted
, CT_MAIL
);
570 static void GetTileDesc_Object(TileIndex tile
, TileDesc
*td
)
572 const ObjectSpec
*spec
= ObjectSpec::GetByTile(tile
);
573 td
->str
= spec
->name
;
574 td
->owner
[0] = GetTileOwner(tile
);
575 td
->build_date
= Object::GetByTile(tile
)->build_date
;
577 if (spec
->grf_prop
.grffile
!= NULL
) {
578 td
->grf
= GetGRFConfig(spec
->grf_prop
.grffile
->grfid
)->GetName();
582 static void TileLoop_Object(TileIndex tile
)
584 const ObjectSpec
*spec
= ObjectSpec::GetByTile(tile
);
585 if (spec
->flags
& OBJECT_FLAG_ANIMATION
) {
586 Object
*o
= Object::GetByTile(tile
);
587 TriggerObjectTileAnimation(o
, tile
, OAT_TILELOOP
, spec
);
588 if (o
->location
.tile
== tile
) TriggerObjectAnimation(o
, OAT_256_TICKS
, spec
);
591 if (IsTileOnWater(tile
)) TileLoop_Water(tile
);
593 if (!IsObjectType(tile
, OBJECT_HQ
)) return;
595 /* HQ accepts passenger and mail; but we have to divide the values
596 * between 4 tiles it occupies! */
598 /* HQ level (depends on company performance) in the range 1..5. */
599 uint level
= GetCompanyHQSize(tile
) + 1;
602 StationFinder
stations(TileArea(tile
, 2, 2));
605 /* Top town buildings generate 250, so the top HQ type makes 256. */
606 if (GB(r
, 0, 8) < (256 / 4 / (6 - level
))) {
607 uint amt
= GB(r
, 0, 8) / 8 / 4 + 1;
608 if (EconomyIsInRecession()) amt
= (amt
+ 1) >> 1;
609 MoveGoodsToStation(CT_PASSENGERS
, amt
, ST_HEADQUARTERS
, GetTileOwner(tile
), stations
.GetStations());
612 /* Top town building generates 90, HQ can make up to 196. The
613 * proportion passengers:mail is about the same as in the acceptance
615 if (GB(r
, 8, 8) < (196 / 4 / (6 - level
))) {
616 uint amt
= GB(r
, 8, 8) / 8 / 4 + 1;
617 if (EconomyIsInRecession()) amt
= (amt
+ 1) >> 1;
618 MoveGoodsToStation(CT_MAIL
, amt
, ST_HEADQUARTERS
, GetTileOwner(tile
), stations
.GetStations());
623 static bool ClickTile_Object(TileIndex tile
)
625 if (!IsObjectType(tile
, OBJECT_HQ
)) return false;
627 ShowCompany(GetTileOwner(tile
));
631 static void AnimateTile_Object(TileIndex tile
)
633 AnimateNewObjectTile(tile
);
637 * Try to build a lighthouse.
638 * @return True iff building a lighthouse succeeded.
640 static bool TryBuildLightHouse()
642 uint maxx
= MapMaxX();
643 uint maxy
= MapMaxY();
646 /* Scatter the lighthouses more evenly around the perimeter */
647 int perimeter
= (GB(r
, 16, 16) % (2 * (maxx
+ maxy
))) - maxy
;
649 for (dir
= DIAGDIR_NE
; perimeter
> 0; dir
++) {
650 perimeter
-= (DiagDirToAxis(dir
) == AXIS_X
) ? maxx
: maxy
;
656 case DIAGDIR_NE
: tile
= TileXY(maxx
- 1, r
% maxy
); break;
657 case DIAGDIR_SE
: tile
= TileXY(r
% maxx
, 1); break;
658 case DIAGDIR_SW
: tile
= TileXY(1, r
% maxy
); break;
659 case DIAGDIR_NW
: tile
= TileXY(r
% maxx
, maxy
- 1); break;
662 /* Only build lighthouses at tiles where the border is sea. */
663 if (!IsWaterTile(tile
)) return false;
665 for (int j
= 0; j
< 19; j
++) {
667 if (IsGroundTile(tile
) && IsTileFlat(tile
, &h
) && h
<= 2 && !HasBridgeAbove(tile
)) {
668 BuildObject(OBJECT_LIGHTHOUSE
, tile
);
669 assert(tile
< MapSize());
672 tile
+= TileOffsByDiagDir(dir
);
673 if (!IsValidTile(tile
)) return false;
679 * Try to build a transmitter.
680 * @return True iff a transmitter was built.
682 static bool TryBuildTransmitter()
684 TileIndex tile
= RandomTile();
686 if (IsGroundTile(tile
) && IsTileFlat(tile
, &h
) && h
>= 4 && !HasBridgeAbove(tile
)) {
690 TILE_AREA_LOOP(t
, ta
) {
691 if (IsObjectTypeTile (t
, OBJECT_TRANSMITTER
)) return false;
694 BuildObject(OBJECT_TRANSMITTER
, tile
);
700 void GenerateObjects()
702 /* Set a guestimate on how much we progress */
703 SetGeneratingWorldProgress(GWP_OBJECT
, NUM_OBJECTS
);
705 /* Determine number of water tiles at map border needed for freeform_edges */
706 uint num_water_tiles
= 0;
707 if (_settings_game
.construction
.freeform_edges
) {
708 for (uint x
= 0; x
< MapMaxX(); x
++) {
709 if (IsWaterTile(TileXY(x
, 1))) num_water_tiles
++;
710 if (IsWaterTile(TileXY(x
, MapMaxY() - 1))) num_water_tiles
++;
712 for (uint y
= 1; y
< MapMaxY() - 1; y
++) {
713 if (IsWaterTile(TileXY(1, y
))) num_water_tiles
++;
714 if (IsWaterTile(TileXY(MapMaxX() - 1, y
))) num_water_tiles
++;
718 /* Iterate over all possible object types */
719 for (uint i
= 0; i
< NUM_OBJECTS
; i
++) {
720 const ObjectSpec
*spec
= ObjectSpec::Get(i
);
722 /* Continue, if the object was never available till now or shall not be placed */
723 if (!spec
->WasEverAvailable() || spec
->generate_amount
== 0) continue;
725 uint16 amount
= spec
->generate_amount
;
727 /* Scale by map size */
728 if ((spec
->flags
& OBJECT_FLAG_SCALE_BY_WATER
) && _settings_game
.construction
.freeform_edges
) {
729 /* Scale the amount of lighthouses with the amount of land at the borders.
730 * The -6 is because the top borders are void (-2) and all corners
731 * are counted twice (-4). */
732 amount
= ScaleByMapPerimeter(amount
* num_water_tiles
) / (2 * MapMaxY() + 2 * MapMaxX() - 6);
733 } else if (spec
->flags
& OBJECT_FLAG_SCALE_BY_WATER
) {
734 amount
= ScaleByMapPerimeter(amount
);
736 amount
= ScaleByMapSize(amount
);
739 /* Now try to place the requested amount of this object */
740 for (uint j
= ScaleByMapSize(1000); j
!= 0 && amount
!= 0 && Object::CanAllocateItem(); j
--) {
742 case OBJECT_TRANSMITTER
:
743 if (TryBuildTransmitter()) amount
--;
746 case OBJECT_LIGHTHOUSE
:
747 if (TryBuildLightHouse()) amount
--;
751 uint8 view
= RandomRange(spec
->views
);
752 if (CmdBuildObject(RandomTile(), DC_EXEC
| DC_AUTO
| DC_NO_TEST_TOWN_RATING
| DC_NO_MODIFY_TOWN_RATING
, i
, view
, NULL
).Succeeded()) amount
--;
756 IncreaseGeneratingWorldProgress(GWP_OBJECT
);
760 static void ChangeTileOwner_Object(TileIndex tile
, Owner old_owner
, Owner new_owner
)
762 if (!IsTileOwner(tile
, old_owner
)) return;
764 bool do_clear
= false;
766 if (IsObjectType(tile
, OBJECT_OWNED_LAND
) && new_owner
!= INVALID_OWNER
) {
767 SetTileOwner(tile
, new_owner
);
768 } else if (IsObjectType(tile
, OBJECT_STATUE
)) {
769 Town
*t
= Object::GetByTile(tile
)->town
;
770 ClrBit(t
->statues
, old_owner
);
771 if (new_owner
!= INVALID_OWNER
&& !HasBit(t
->statues
, new_owner
)) {
772 /* Transfer ownership to the new company */
773 SetBit(t
->statues
, new_owner
);
774 SetTileOwner(tile
, new_owner
);
779 SetWindowDirty(WC_TOWN_AUTHORITY
, t
->index
);
785 ReallyClearObjectTile(Object::GetByTile(tile
));
786 /* When clearing objects, they may turn into canal, which may require transfering ownership. */
787 ChangeTileOwner(tile
, old_owner
, new_owner
);
791 static CommandCost
TerraformTile_Object(TileIndex tile
, DoCommandFlag flags
, int z_new
, Slope tileh_new
)
793 ObjectType type
= GetObjectType(tile
);
795 if (type
== OBJECT_OWNED_LAND
) {
796 /* Owned land remains unsold */
797 CommandCost ret
= CheckTileOwnership(tile
);
798 if (ret
.Succeeded()) return CommandCost();
799 } else if (AutoslopeEnabled() && type
!= OBJECT_TRANSMITTER
&& type
!= OBJECT_LIGHTHOUSE
) {
801 * - Both new and old slope must not be steep.
802 * - TileMaxZ must not be changed.
803 * - Allow autoslope by default.
804 * - Disallow autoslope if callback succeeds and returns non-zero.
806 Slope tileh_old
= GetTileSlope(tile
);
807 /* TileMaxZ must not be changed. Slopes must not be steep. */
808 if (!IsSteepSlope(tileh_old
) && !IsSteepSlope(tileh_new
) && (GetTileMaxZ(tile
) == z_new
+ GetSlopeMaxZ(tileh_new
))) {
809 const ObjectSpec
*spec
= ObjectSpec::Get(type
);
811 /* Call callback 'disable autosloping for objects'. */
812 if (HasBit(spec
->callback_mask
, CBM_OBJ_AUTOSLOPE
)) {
813 /* If the callback fails, allow autoslope. */
814 uint16 res
= GetObjectCallback(CBID_OBJECT_AUTOSLOPE
, 0, 0, spec
, Object::GetByTile(tile
), tile
);
815 if (res
== CALLBACK_FAILED
|| !ConvertBooleanCallback(spec
->grf_prop
.grffile
, CBID_OBJECT_AUTOSLOPE
, res
)) return CommandCost(EXPENSES_CONSTRUCTION
, _price
[PR_BUILD_FOUNDATION
]);
816 } else if (spec
->enabled
) {
817 /* allow autoslope */
818 return CommandCost(EXPENSES_CONSTRUCTION
, _price
[PR_BUILD_FOUNDATION
]);
823 return DoCommand(tile
, 0, 0, flags
, CMD_LANDSCAPE_CLEAR
);
826 extern const TileTypeProcs _tile_type_object_procs
= {
827 DrawTile_Object
, // draw_tile_proc
828 GetSlopePixelZ_Object
, // get_slope_z_proc
829 ClearTile_Object
, // clear_tile_proc
830 AddAcceptedCargo_Object
, // add_accepted_cargo_proc
831 GetTileDesc_Object
, // get_tile_desc_proc
832 NULL
, // get_tile_railway_status_proc
833 NULL
, // get_tile_road_status_proc
834 NULL
, // get_tile_waterway_status_proc
835 ClickTile_Object
, // click_tile_proc
836 AnimateTile_Object
, // animate_tile_proc
837 TileLoop_Object
, // tile_loop_proc
838 ChangeTileOwner_Object
, // change_tile_owner_proc
839 NULL
, // add_produced_cargo_proc
840 GetFoundation_Object
, // get_foundation_proc
841 TerraformTile_Object
, // terraform_tile_proc