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