OpenTTD Source: src/terraform_cmd.cpp Source File

OpenTTD Source 14.0-beta3

terraform_cmd.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 "command_func.h"
12 #include "tunnel_map.h"
13 #include "bridge_map.h"
14 #include "viewport_func.h"
15 #include "genworld.h"
16 #include "object_base.h"
17 #include "company_base.h"
18 #include "company_func.h"
19 #include "core/backup_type.hpp"
20 #include "terraform_cmd.h"
21 #include "landscape_cmd.h"
22
23 #include "table/strings.h"
24
25 #include "safeguards.h"
26
28 typedef std::set<TileIndex> TileIndexSet;
30 typedef std::map<TileIndex, int> TileIndexToHeightMap;
31
33 struct TerraformerState {
34 TileIndexSet dirty_tiles;
35 TileIndexToHeightMap tile_to_new_height;
36 };
37
45 static int TerraformGetHeightOfTile(const TerraformerState *ts, TileIndex tile)
46 {
47 TileIndexToHeightMap::const_iterator it = ts->tile_to_new_height.find(tile);
48 return it != ts->tile_to_new_height.end() ? it->second : TileHeight(tile);
49 }
50
58 static void TerraformSetHeightOfTile(TerraformerState *ts, TileIndex tile, int height)
59 {
60 ts->tile_to_new_height[tile] = height;
61 }
62
70 static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)
71 {
72 ts->dirty_tiles.insert(tile);
73 }
74
82 static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)
83 {
84 /* Make sure all tiles passed to TerraformAddDirtyTile are within [0, Map::Size()] */
85 if (TileY(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY( 0, -1));
86 if (TileY(tile) >= 1 && TileX(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY(-1, -1));
87 if (TileX(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY(-1, 0));
88 TerraformAddDirtyTile(ts, tile);
89 }
90
99 static std::tuple<CommandCost, TileIndex> TerraformTileHeight(TerraformerState *ts, TileIndex tile, int height)
100 {
101 assert(tile < Map::Size());
102
103 /* Check range of destination height */
104 if (height < 0) return { CommandCost(STR_ERROR_ALREADY_AT_SEA_LEVEL), INVALID_TILE };
105 if (height > _settings_game.construction.map_height_limit) return { CommandCost(STR_ERROR_TOO_HIGH), INVALID_TILE };
106
107 /*
108 * Check if the terraforming has any effect.
109 * This can only be true, if multiple corners of the start-tile are terraformed (i.e. the terraforming is done by towns/industries etc.).
110 * In this case the terraforming should fail. (Don't know why.)
111 */
112 if (height == TerraformGetHeightOfTile(ts, tile)) return { CMD_ERROR, INVALID_TILE };
113
114 /* Check "too close to edge of map". Only possible when freeform-edges is off. */
115 uint x = TileX(tile);
116 uint y = TileY(tile);
117 if (!_settings_game.construction.freeform_edges && ((x <= 1) || (y <= 1) || (x >= Map::MaxX() - 1) || (y >= Map::MaxY() - 1))) {
118 /*
119 * Determine a sensible error tile
120 */
121 if (x == 1) x = 0;
122 if (y == 1) y = 0;
123 return { CommandCost(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP), TileXY(x, y) };
124 }
125
126 /* Mark incident tiles that are involved in the terraforming. */
127 TerraformAddDirtyTileAround(ts, tile);
128
129 /* Store the height modification */
130 TerraformSetHeightOfTile(ts, tile, height);
131
132 CommandCost total_cost(EXPENSES_CONSTRUCTION);
133
134 /* Increment cost */
135 total_cost.AddCost(_price[PR_TERRAFORM]);
136
137 /* Recurse to neighboured corners if height difference is larger than 1 */
138 {
139 const TileIndexDiffC *ttm;
140
141 TileIndex orig_tile = tile;
142 static const TileIndexDiffC _terraform_tilepos[] = {
143 { 1, 0}, // move to tile in SE
144 {-2, 0}, // undo last move, and move to tile in NW
145 { 1, 1}, // undo last move, and move to tile in SW
146 { 0, -2} // undo last move, and move to tile in NE
147 };
148
149 for (ttm = _terraform_tilepos; ttm != endof(_terraform_tilepos); ttm++) {
150 tile += ToTileIndexDiff(*ttm);
151
152 if (tile >= Map::Size()) continue;
153 /* Make sure we don't wrap around the map */
154 if (Delta(TileX(orig_tile), TileX(tile)) == Map::SizeX() - 1) continue;
155 if (Delta(TileY(orig_tile), TileY(tile)) == Map::SizeY() - 1) continue;
156
157 /* Get TileHeight of neighboured tile as of current terraform progress */
158 int r = TerraformGetHeightOfTile(ts, tile);
159 int height_diff = height - r;
160
161 /* Is the height difference to the neighboured corner greater than 1? */
162 if (abs(height_diff) > 1) {
163 /* Terraform the neighboured corner. The resulting height difference should be 1. */
164 height_diff += (height_diff < 0 ? 1 : -1);
165 auto [cost, err_tile] = TerraformTileHeight(ts, tile, r + height_diff);
166 if (cost.Failed()) return { cost, err_tile };
167 total_cost.AddCost(cost);
168 }
169 }
170 }
171
172 return { total_cost, INVALID_TILE };
173 }
174
183 std::tuple<CommandCost, Money, TileIndex> CmdTerraformLand(DoCommandFlag flags, TileIndex tile, Slope slope, bool dir_up)
184 {
185 CommandCost total_cost(EXPENSES_CONSTRUCTION);
186 int direction = (dir_up ? 1 : -1);
187 TerraformerState ts;
188
189 /* Compute the costs and the terraforming result in a model of the landscape */
190 if ((slope & SLOPE_W) != 0 && tile + TileDiffXY(1, 0) < Map::Size()) {
191 TileIndex t = tile + TileDiffXY(1, 0);
192 auto [cost, err_tile] = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
193 if (cost.Failed()) return { cost, 0, err_tile };
194 total_cost.AddCost(cost);
195 }
196
197 if ((slope & SLOPE_S) != 0 && tile + TileDiffXY(1, 1) < Map::Size()) {
198 TileIndex t = tile + TileDiffXY(1, 1);
199 auto [cost, err_tile] = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
200 if (cost.Failed()) return { cost, 0, err_tile };
201 total_cost.AddCost(cost);
202 }
203
204 if ((slope & SLOPE_E) != 0 && tile + TileDiffXY(0, 1) < Map::Size()) {
205 TileIndex t = tile + TileDiffXY(0, 1);
206 auto [cost, err_tile] = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
207 if (cost.Failed()) return { cost, 0, err_tile };
208 total_cost.AddCost(cost);
209 }
210
211 if ((slope & SLOPE_N) != 0) {
212 TileIndex t = tile + TileDiffXY(0, 0);
213 auto [cost, err_tile] = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
214 if (cost.Failed()) return { cost, 0, err_tile };
215 total_cost.AddCost(cost);
216 }
217
218 /* Check if the terraforming is valid wrt. tunnels, bridges and objects on the surface
219 * Pass == 0: Collect tileareas which are caused to be auto-cleared.
220 * Pass == 1: Collect the actual cost. */
221 for (int pass = 0; pass < 2; pass++) {
222 for (const auto &t : ts.dirty_tiles) {
223 assert(t < Map::Size());
224 /* MP_VOID tiles can be terraformed but as tunnels and bridges
225 * cannot go under / over these tiles they don't need checking. */
226 if (IsTileType(t, MP_VOID)) continue;
227
228 /* Find new heights of tile corners */
229 int z_N = TerraformGetHeightOfTile(&ts, t + TileDiffXY(0, 0));
230 int z_W = TerraformGetHeightOfTile(&ts, t + TileDiffXY(1, 0));
231 int z_S = TerraformGetHeightOfTile(&ts, t + TileDiffXY(1, 1));
232 int z_E = TerraformGetHeightOfTile(&ts, t + TileDiffXY(0, 1));
233
234 /* Find min and max height of tile */
235 int z_min = std::min({z_N, z_W, z_S, z_E});
236 int z_max = std::max({z_N, z_W, z_S, z_E});
237
238 /* Compute tile slope */
239 Slope tileh = (z_max > z_min + 1 ? SLOPE_STEEP : SLOPE_FLAT);
240 if (z_W > z_min) tileh |= SLOPE_W;
241 if (z_S > z_min) tileh |= SLOPE_S;
242 if (z_E > z_min) tileh |= SLOPE_E;
243 if (z_N > z_min) tileh |= SLOPE_N;
244
245 if (pass == 0) {
246 /* Check if bridge would take damage */
247 if (IsBridgeAbove(t)) {
248 int bridge_height = GetBridgeHeight(GetSouthernBridgeEnd(t));
249
250 /* Check if bridge would take damage. */
251 if (direction == 1 && bridge_height <= z_max) {
252 return { CommandCost(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST), 0, t }; // highlight the tile under the bridge
253 }
254
255 /* Is the bridge above not too high afterwards? */
256 if (direction == -1 && bridge_height > (z_min + _settings_game.construction.max_bridge_height)) {
257 return { CommandCost(STR_ERROR_BRIDGE_TOO_HIGH_AFTER_LOWER_LAND), 0, t };
258 }
259 }
260 /* Check if tunnel would take damage */
261 if (direction == -1 && IsTunnelInWay(t, z_min)) {
262 return { CommandCost(STR_ERROR_EXCAVATION_WOULD_DAMAGE), 0, t }; // highlight the tile above the tunnel
263 }
264 }
265
266 /* Is the tile already cleared? */
267 const ClearedObjectArea *coa = FindClearedObject(t);
268 bool indirectly_cleared = coa != nullptr && coa->first_tile != t;
269
270 /* Check tiletype-specific things, and add extra-cost */
271 Backup<bool> old_generating_world(_generating_world, FILE_LINE);
272 if (_game_mode == GM_EDITOR) old_generating_world.Change(true); // used to create green terraformed land
273 DoCommandFlag tile_flags = flags | DC_AUTO | DC_FORCE_CLEAR_TILE;
274 if (pass == 0) {
275 tile_flags &= ~DC_EXEC;
276 tile_flags |= DC_NO_MODIFY_TOWN_RATING;
277 }
278 CommandCost cost;
279 if (indirectly_cleared) {
280 cost = Command<CMD_LANDSCAPE_CLEAR>::Do(tile_flags, t);
281 } else {
282 cost = _tile_type_procs[GetTileType(t)]->terraform_tile_proc(t, tile_flags, z_min, tileh);
283 }
284 old_generating_world.Restore();
285 if (cost.Failed()) {
286 return { cost, 0, t };
287 }
288 if (pass == 1) total_cost.AddCost(cost);
289 }
290 }
291
292 Company *c = Company::GetIfValid(_current_company);
293 if (c != nullptr && GB(c->terraform_limit, 16, 16) < ts.tile_to_new_height.size()) {
294 return { CommandCost(STR_ERROR_TERRAFORM_LIMIT_REACHED), 0, INVALID_TILE };
295 }
296
297 if (flags & DC_EXEC) {
298 /* Mark affected areas dirty. */
299 for (const auto &t : ts.dirty_tiles) {
300 MarkTileDirtyByTile(t);
301 TileIndexToHeightMap::const_iterator new_height = ts.tile_to_new_height.find(t);
302 if (new_height == ts.tile_to_new_height.end()) continue;
303 MarkTileDirtyByTile(t, 0, new_height->second);
304 }
305
306 /* change the height */
307 for (const auto &it : ts.tile_to_new_height) {
308 TileIndex t = it.first;
309 int height = it.second;
310
311 SetTileHeight(t, (uint)height);
312 }
313
314 if (c != nullptr) c->terraform_limit -= (uint32_t)ts.tile_to_new_height.size() << 16;
315 }
316 return { total_cost, 0, total_cost.Succeeded() ? tile : INVALID_TILE };
317 }
318
319
329 std::tuple<CommandCost, Money, TileIndex> CmdLevelLand(DoCommandFlag flags, TileIndex tile, TileIndex start_tile, bool diagonal, LevelMode lm)
330 {
331 if (start_tile >= Map::Size()) return { CMD_ERROR, 0, INVALID_TILE };
332
333 /* remember level height */
334 uint oldh = TileHeight(start_tile);
335
336 /* compute new height */
337 uint h = oldh;
338 switch (lm) {
339 case LM_LEVEL: break;
340 case LM_RAISE: h++; break;
341 case LM_LOWER: h--; break;
342 default: return { CMD_ERROR, 0, INVALID_TILE };
343 }
344
345 /* Check range of destination height */
346 if (h > _settings_game.construction.map_height_limit) return { CommandCost(oldh == 0 ? STR_ERROR_ALREADY_AT_SEA_LEVEL : STR_ERROR_TOO_HIGH), 0, INVALID_TILE };
347
348 Money money = GetAvailableMoneyForCommand();
349 CommandCost cost(EXPENSES_CONSTRUCTION);
350 CommandCost last_error(lm == LM_LEVEL ? STR_ERROR_ALREADY_LEVELLED : INVALID_STRING_ID);
351 bool had_success = false;
352
353 const Company *c = Company::GetIfValid(_current_company);
354 int limit = (c == nullptr ? INT32_MAX : GB(c->terraform_limit, 16, 16));
355 if (limit == 0) return { CommandCost(STR_ERROR_TERRAFORM_LIMIT_REACHED), 0, INVALID_TILE };
356
357 TileIndex error_tile = INVALID_TILE;
358 std::unique_ptr<TileIterator> iter = TileIterator::Create(tile, start_tile, diagonal);
359 for (; *iter != INVALID_TILE; ++(*iter)) {
360 TileIndex t = *iter;
361 uint curh = TileHeight(t);
362 while (curh != h) {
363 CommandCost ret;
364 std::tie(ret, std::ignore, error_tile) = Command<CMD_TERRAFORM_LAND>::Do(flags & ~DC_EXEC, t, SLOPE_N, curh <= h);
365 if (ret.Failed()) {
366 last_error = ret;
367
368 /* Did we reach the limit? */
369 if (ret.GetErrorMessage() == STR_ERROR_TERRAFORM_LIMIT_REACHED) limit = 0;
370 break;
371 }
372
373 if (flags & DC_EXEC) {
374 money -= ret.GetCost();
375 if (money < 0) {
376 return { cost, ret.GetCost(), error_tile };
377 }
378 Command<CMD_TERRAFORM_LAND>::Do(flags, t, SLOPE_N, curh <= h);
379 } else {
380 /* When we're at the terraform limit we better bail (unneeded) testing as well.
381 * This will probably cause the terraforming cost to be underestimated, but only
382 * when it's near the terraforming limit. Even then, the estimation is
383 * completely off due to it basically counting terraforming double, so it being
384 * cut off earlier might even give a better estimate in some cases. */
385 if (--limit <= 0) {
386 had_success = true;
387 break;
388 }
389 }
390
391 cost.AddCost(ret);
392 curh += (curh > h) ? -1 : 1;
393 had_success = true;
394 }
395
396 if (limit <= 0) break;
397 }
398
399 CommandCost cc_ret = had_success ? cost : last_error;
400 return { cc_ret, 0, cc_ret.Succeeded() ? tile : error_tile };
401 }
Backup::Change
void Change(const U &new_value)
Change the value of the variable.
Definition: backup_type.hpp:84
TileY
static debug_inline uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:437
TerraformerState::dirty_tiles
TileIndexSet dirty_tiles
The tiles that need to be redrawn.
Definition: terraform_cmd.cpp:34
tunnel_map.h
command_func.h
_tile_type_procs
const TileTypeProcs *const _tile_type_procs[16]
Tile callback functions for each type of tile.
Definition: landscape.cpp:64
TerraformTileHeight
static std::tuple< CommandCost, TileIndex > TerraformTileHeight(TerraformerState *ts, TileIndex tile, int height)
Terraform the north corner of a tile to a specific height.
Definition: terraform_cmd.cpp:99
Pool::PoolItem<&_company_pool >::GetIfValid
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:346
CMD_ERROR
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:28
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
LM_LOWER
@ LM_LOWER
Lower the land.
Definition: map_type.h:57
Map::MaxX
static debug_inline uint MaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:297
terraform_cmd.h
company_base.h
GB
constexpr static debug_inline 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
SetTileHeight
void SetTileHeight(Tile tile, uint height)
Sets the height of a tile.
Definition: tile_map.h:57
GetBridgeHeight
int GetBridgeHeight(TileIndex t)
Get the height ('z') of a bridge.
Definition: bridge_map.cpp:70
INVALID_TILE
constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:95
TileIterator::Create
static std::unique_ptr< TileIterator > Create(TileIndex corner1, TileIndex corner2, bool diagonal)
Create either an OrthogonalTileIterator or DiagonalTileIterator given the diagonal parameter.
Definition: tilearea.cpp:291
TerraformAddDirtyTile
static void TerraformAddDirtyTile(TerraformerState *ts, TileIndex tile)
Adds a tile to the "tile_table" in a TerraformerState.
Definition: terraform_cmd.cpp:70
StrongType::Typedef< uint32_t, struct TileIndexTag, StrongType::Compare, StrongType::Integer, StrongType::Compatible< int32_t >, StrongType::Compatible< int64_t > >
SLOPE_S
@ SLOPE_S
the south corner of the tile is raised
Definition: slope_type.h:51
TerraformGetHeightOfTile
static int TerraformGetHeightOfTile(const TerraformerState *ts, TileIndex tile)
Gets the TileHeight (height of north corner) of a tile as of current terraforming progress.
Definition: terraform_cmd.cpp:45
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:371
CmdLevelLand
std::tuple< CommandCost, Money, TileIndex > CmdLevelLand(DoCommandFlag flags, TileIndex tile, TileIndex start_tile, bool diagonal, LevelMode lm)
Levels a selected (rectangle) area of land.
Definition: terraform_cmd.cpp:329
CommandCost::GetErrorMessage
StringID GetErrorMessage() const
Returns the error message of a command.
Definition: command_type.h:142
SLOPE_E
@ SLOPE_E
the east corner of the tile is raised
Definition: slope_type.h:52
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:369
genworld.h
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:162
object_base.h
TerraformerState
State of the terraforming.
Definition: terraform_cmd.cpp:33
GetTileType
static debug_inline TileType GetTileType(Tile tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
Slope
Slope
Enumeration for the slope-type.
Definition: slope_type.h:48
landscape_cmd.h
ToTileIndexDiff
TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between two tiles from a TileIndexDiffC struct.
Definition: map_func.h:452
GetAvailableMoneyForCommand
Money GetAvailableMoneyForCommand()
This functions returns the money which can be used to execute a command.
Definition: company_cmd.cpp:227
EXPENSES_CONSTRUCTION
@ EXPENSES_CONSTRUCTION
Construction costs.
Definition: economy_type.h:173
CommandCost
Common return value for all commands.
Definition: command_type.h:23
ConstructionSettings::map_height_limit
uint8_t map_height_limit
the maximum allowed heightlevel
Definition: settings_type.h:370
ClearedObjectArea::first_tile
TileIndex first_tile
The first tile being cleared, which then causes the whole object to be cleared.
Definition: object_base.h:85
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:171
IsTunnelInWay
bool IsTunnelInWay(TileIndex tile, int z)
Is there a tunnel in the way in any direction?
Definition: tunnel_map.cpp:68
ConstructionSettings::max_bridge_height
byte max_bridge_height
maximum height of bridges
Definition: settings_type.h:374
TileDiffXY
TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition: map_func.h:401
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:55
TerraformAddDirtyTileAround
static void TerraformAddDirtyTileAround(TerraformerState *ts, TileIndex tile)
Adds all tiles that incident with the north corner of a specific tile to the "tile_table" in a Terraf...
Definition: terraform_cmd.cpp:82
safeguards.h
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition: settings_type.h:383
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:83
GetSouthernBridgeEnd
TileIndex GetSouthernBridgeEnd(TileIndex t)
Finds the southern end of a bridge starting at a middle tile.
Definition: bridge_map.cpp:49
LM_LEVEL
@ LM_LEVEL
Level the land.
Definition: map_type.h:56
CommandCost::AddCost
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Definition: command_type.h:63
stdafx.h
viewport_func.h
bridge_map.h
TileTypeProcs::terraform_tile_proc
TerraformTileProc * terraform_tile_proc
Called when a terraforming operation is about to take place.
Definition: tile_cmd.h:172
TileIndexSet
std::set< TileIndex > TileIndexSet
Set of tiles.
Definition: terraform_cmd.cpp:28
SLOPE_W
@ SLOPE_W
the west corner of the tile is raised
Definition: slope_type.h:50
TileIndexDiffC
A pair-construct of a TileIndexDiff.
Definition: map_type.h:31
Map::SizeX
static debug_inline uint SizeX()
Get the size of the map along the X.
Definition: map_func.h:270
_generating_world
bool _generating_world
Whether we are generating the map or not.
Definition: genworld.cpp:62
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:50
Map::MaxY
static uint MaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:306
TerraformerState::tile_to_new_height
TileIndexToHeightMap tile_to_new_height
The tiles for which the height has changed.
Definition: terraform_cmd.cpp:35
DC_FORCE_CLEAR_TILE
@ DC_FORCE_CLEAR_TILE
do not only remove the object on the tile, but also clear any water left on it
Definition: command_type.h:382
FindClearedObject
ClearedObjectArea * FindClearedObject(TileIndex tile)
Find the entry in _cleared_object_areas which occupies a certain tile.
Definition: object_cmd.cpp:531
MP_VOID
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition: tile_type.h:55
TerraformSetHeightOfTile
static void TerraformSetHeightOfTile(TerraformerState *ts, TileIndex tile, int height)
Stores the TileHeight (height of north corner) of a tile in a TerraformerState.
Definition: terraform_cmd.cpp:58
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
SLOPE_N
@ SLOPE_N
the north corner of the tile is raised
Definition: slope_type.h:53
abs
constexpr T abs(const T a)
Returns the absolute value of (scalar) variable.
Definition: math_func.hpp:23
Map::Size
static debug_inline uint Size()
Get the size of the map.
Definition: map_func.h:288
endof
#define endof(x)
Get the end element of an fixed size array.
Definition: stdafx.h:308
CompanyProperties::terraform_limit
uint32_t terraform_limit
Amount of tileheights we can (still) terraform (times 65536).
Definition: company_base.h:86
MarkTileDirtyByTile
void MarkTileDirtyByTile(TileIndex tile, int bridge_level_offset, int tile_height_override)
Mark a tile given by its index dirty for repaint.
Definition: viewport.cpp:2051
IsBridgeAbove
bool IsBridgeAbove(Tile t)
checks if a bridge is set above the ground of this tile
Definition: bridge_map.h:45
DC_AUTO
@ DC_AUTO
don't allow building on structures
Definition: command_type.h:372
DC_NO_MODIFY_TOWN_RATING
@ DC_NO_MODIFY_TOWN_RATING
do not change town rating
Definition: command_type.h:381
company_func.h
LevelMode
LevelMode
Argument for CmdLevelLand describing what to do.
Definition: map_type.h:55
CommandHelper
Definition: command_func.h:93
Delta
constexpr T Delta(const T a, const T b)
Returns the (absolute) difference between two (scalar) variables.
Definition: math_func.hpp:234
TileXY
static debug_inline TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:385
TileHeight
static debug_inline uint TileHeight(Tile tile)
Returns the height of a tile.
Definition: tile_map.h:29
OverflowSafeInt< int64_t >
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:620
TileIndexToHeightMap
std::map< TileIndex, int > TileIndexToHeightMap
Mapping of tiles to their height.
Definition: terraform_cmd.cpp:30
IsTileType
static debug_inline bool IsTileType(Tile tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
TileX
static debug_inline uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:427
LM_RAISE
@ LM_RAISE
Raise the land.
Definition: map_type.h:58
SLOPE_FLAT
@ SLOPE_FLAT
a flat tile
Definition: slope_type.h:49
ClearedObjectArea
Keeps track of removed objects during execution/testruns of commands.
Definition: object_base.h:84
Company
Definition: company_base.h:116
SLOPE_STEEP
@ SLOPE_STEEP
indicates the slope is steep
Definition: slope_type.h:54
INVALID_STRING_ID
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Definition: strings_type.h:17
Map::SizeY
static uint SizeY()
Get the size of the map along the Y.
Definition: map_func.h:279
CmdTerraformLand
std::tuple< CommandCost, Money, TileIndex > CmdTerraformLand(DoCommandFlag flags, TileIndex tile, Slope slope, bool dir_up)
Terraform land.
Definition: terraform_cmd.cpp:183
backup_type.hpp