OpenTTD
terraform_cmd.cpp
Go to the documentation of this file.
1 /* $Id: terraform_cmd.cpp 27381 2015-08-10 20:24:13Z michi_cc $ */
2 
3 /*
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/>.
8  */
9 
12 #include "stdafx.h"
13 #include "command_func.h"
14 #include "tunnel_map.h"
15 #include "bridge_map.h"
16 #include "viewport_func.h"
17 #include "genworld.h"
18 #include "object_base.h"
19 #include "company_base.h"
20 #include "company_func.h"
21 
22 #include "table/strings.h"
23 
24 #include <map>
25 #include <set>
26 
27 #include "safeguards.h"
28 
30 typedef std::set<TileIndex> TileIndexSet;
32 typedef std::map<TileIndex, int> TileIndexToHeightMap;
33 
38 };
39 
41 
50 {
51  TileIndexToHeightMap::const_iterator it = ts->tile_to_new_height.find(tile);
52  return it != ts->tile_to_new_height.end() ? it->second : TileHeight(tile);
53 }
54 
62 static void TerraformSetHeightOfTile(TerraformerState *ts, TileIndex tile, int height)
63 {
64  ts->tile_to_new_height[tile] = height;
65 }
66 
75 {
76  ts->dirty_tiles.insert(tile);
77 }
78 
87 {
88  /* Make sure all tiles passed to TerraformAddDirtyTile are within [0, MapSize()] */
89  if (TileY(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY( 0, -1));
90  if (TileY(tile) >= 1 && TileX(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY(-1, -1));
91  if (TileX(tile) >= 1) TerraformAddDirtyTile(ts, tile + TileDiffXY(-1, 0));
92  TerraformAddDirtyTile(ts, tile);
93 }
94 
104 {
105  assert(tile < MapSize());
106 
107  /* Check range of destination height */
108  if (height < 0) return_cmd_error(STR_ERROR_ALREADY_AT_SEA_LEVEL);
109  if (height > _settings_game.construction.max_heightlevel) return_cmd_error(STR_ERROR_TOO_HIGH);
110 
111  /*
112  * Check if the terraforming has any effect.
113  * This can only be true, if multiple corners of the start-tile are terraformed (i.e. the terraforming is done by towns/industries etc.).
114  * In this case the terraforming should fail. (Don't know why.)
115  */
116  if (height == TerraformGetHeightOfTile(ts, tile)) return CMD_ERROR;
117 
118  /* Check "too close to edge of map". Only possible when freeform-edges is off. */
119  uint x = TileX(tile);
120  uint y = TileY(tile);
121  if (!_settings_game.construction.freeform_edges && ((x <= 1) || (y <= 1) || (x >= MapMaxX() - 1) || (y >= MapMaxY() - 1))) {
122  /*
123  * Determine a sensible error tile
124  */
125  if (x == 1) x = 0;
126  if (y == 1) y = 0;
127  _terraform_err_tile = TileXY(x, y);
128  return_cmd_error(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP);
129  }
130 
131  /* Mark incident tiles that are involved in the terraforming. */
132  TerraformAddDirtyTileAround(ts, tile);
133 
134  /* Store the height modification */
135  TerraformSetHeightOfTile(ts, tile, height);
136 
138 
139  /* Increment cost */
140  total_cost.AddCost(_price[PR_TERRAFORM]);
141 
142  /* Recurse to neighboured corners if height difference is larger than 1 */
143  {
144  const TileIndexDiffC *ttm;
145 
146  TileIndex orig_tile = tile;
147  static const TileIndexDiffC _terraform_tilepos[] = {
148  { 1, 0}, // move to tile in SE
149  {-2, 0}, // undo last move, and move to tile in NW
150  { 1, 1}, // undo last move, and move to tile in SW
151  { 0, -2} // undo last move, and move to tile in NE
152  };
153 
154  for (ttm = _terraform_tilepos; ttm != endof(_terraform_tilepos); ttm++) {
155  tile += ToTileIndexDiff(*ttm);
156 
157  if (tile >= MapSize()) continue;
158  /* Make sure we don't wrap around the map */
159  if (Delta(TileX(orig_tile), TileX(tile)) == MapSizeX() - 1) continue;
160  if (Delta(TileY(orig_tile), TileY(tile)) == MapSizeY() - 1) continue;
161 
162  /* Get TileHeight of neighboured tile as of current terraform progress */
163  int r = TerraformGetHeightOfTile(ts, tile);
164  int height_diff = height - r;
165 
166  /* Is the height difference to the neighboured corner greater than 1? */
167  if (abs(height_diff) > 1) {
168  /* Terraform the neighboured corner. The resulting height difference should be 1. */
169  height_diff += (height_diff < 0 ? 1 : -1);
170  CommandCost cost = TerraformTileHeight(ts, tile, r + height_diff);
171  if (cost.Failed()) return cost;
172  total_cost.AddCost(cost);
173  }
174  }
175  }
176 
177  return total_cost;
178 }
179 
189 CommandCost CmdTerraformLand(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
190 {
192 
194  int direction = (p2 != 0 ? 1 : -1);
195  TerraformerState ts;
196 
197  /* Compute the costs and the terraforming result in a model of the landscape */
198  if ((p1 & SLOPE_W) != 0 && tile + TileDiffXY(1, 0) < MapSize()) {
199  TileIndex t = tile + TileDiffXY(1, 0);
200  CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
201  if (cost.Failed()) return cost;
202  total_cost.AddCost(cost);
203  }
204 
205  if ((p1 & SLOPE_S) != 0 && tile + TileDiffXY(1, 1) < MapSize()) {
206  TileIndex t = tile + TileDiffXY(1, 1);
207  CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
208  if (cost.Failed()) return cost;
209  total_cost.AddCost(cost);
210  }
211 
212  if ((p1 & SLOPE_E) != 0 && tile + TileDiffXY(0, 1) < MapSize()) {
213  TileIndex t = tile + TileDiffXY(0, 1);
214  CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
215  if (cost.Failed()) return cost;
216  total_cost.AddCost(cost);
217  }
218 
219  if ((p1 & SLOPE_N) != 0) {
220  TileIndex t = tile + TileDiffXY(0, 0);
221  CommandCost cost = TerraformTileHeight(&ts, t, TileHeight(t) + direction);
222  if (cost.Failed()) return cost;
223  total_cost.AddCost(cost);
224  }
225 
226  /* Check if the terraforming is valid wrt. tunnels, bridges and objects on the surface
227  * Pass == 0: Collect tileareas which are caused to be auto-cleared.
228  * Pass == 1: Collect the actual cost. */
229  for (int pass = 0; pass < 2; pass++) {
230  for (TileIndexSet::const_iterator it = ts.dirty_tiles.begin(); it != ts.dirty_tiles.end(); it++) {
231  TileIndex tile = *it;
232 
233  assert(tile < MapSize());
234  /* MP_VOID tiles can be terraformed but as tunnels and bridges
235  * cannot go under / over these tiles they don't need checking. */
236  if (IsTileType(tile, MP_VOID)) continue;
237 
238  /* Find new heights of tile corners */
239  int z_N = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(0, 0));
240  int z_W = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(1, 0));
241  int z_S = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(1, 1));
242  int z_E = TerraformGetHeightOfTile(&ts, tile + TileDiffXY(0, 1));
243 
244  /* Find min and max height of tile */
245  int z_min = min(min(z_N, z_W), min(z_S, z_E));
246  int z_max = max(max(z_N, z_W), max(z_S, z_E));
247 
248  /* Compute tile slope */
249  Slope tileh = (z_max > z_min + 1 ? SLOPE_STEEP : SLOPE_FLAT);
250  if (z_W > z_min) tileh |= SLOPE_W;
251  if (z_S > z_min) tileh |= SLOPE_S;
252  if (z_E > z_min) tileh |= SLOPE_E;
253  if (z_N > z_min) tileh |= SLOPE_N;
254 
255  if (pass == 0) {
256  /* Check if bridge would take damage */
257  if (IsBridgeAbove(tile)) {
258  int bridge_height = GetBridgeHeight(GetSouthernBridgeEnd(tile));
259 
260  /* Check if bridge would take damage. */
261  if (direction == 1 && bridge_height <= z_max) {
262  _terraform_err_tile = tile; // highlight the tile under the bridge
263  return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
264  }
265 
266  /* Is the bridge above not too high afterwards? */
267  if (direction == -1 && bridge_height > (z_min + _settings_game.construction.max_bridge_height)) {
268  _terraform_err_tile = tile;
269  return_cmd_error(STR_ERROR_BRIDGE_TOO_HIGH_AFTER_LOWER_LAND);
270  }
271  }
272  /* Check if tunnel would take damage */
273  if (direction == -1 && IsTunnelInWay(tile, z_min)) {
274  _terraform_err_tile = tile; // highlight the tile above the tunnel
275  return_cmd_error(STR_ERROR_EXCAVATION_WOULD_DAMAGE);
276  }
277  }
278 
279  /* Is the tile already cleared? */
280  const ClearedObjectArea *coa = FindClearedObject(tile);
281  bool indirectly_cleared = coa != NULL && coa->first_tile != tile;
282 
283  /* Check tiletype-specific things, and add extra-cost */
284  const bool curr_gen = _generating_world;
285  if (_game_mode == GM_EDITOR) _generating_world = true; // used to create green terraformed land
286  DoCommandFlag tile_flags = flags | DC_AUTO | DC_FORCE_CLEAR_TILE;
287  if (pass == 0) {
288  tile_flags &= ~DC_EXEC;
289  tile_flags |= DC_NO_MODIFY_TOWN_RATING;
290  }
291  CommandCost cost;
292  if (indirectly_cleared) {
293  cost = DoCommand(tile, 0, 0, tile_flags, CMD_LANDSCAPE_CLEAR);
294  } else {
295  cost = _tile_type_procs[GetTileType(tile)]->terraform_tile_proc(tile, tile_flags, z_min, tileh);
296  }
297  _generating_world = curr_gen;
298  if (cost.Failed()) {
299  _terraform_err_tile = tile;
300  return cost;
301  }
302  if (pass == 1) total_cost.AddCost(cost);
303  }
304  }
305 
307  if (c != NULL && GB(c->terraform_limit, 16, 16) < ts.tile_to_new_height.size()) {
308  return_cmd_error(STR_ERROR_TERRAFORM_LIMIT_REACHED);
309  }
310 
311  if (flags & DC_EXEC) {
312  /* change the height */
313  for (TileIndexToHeightMap::const_iterator it = ts.tile_to_new_height.begin();
314  it != ts.tile_to_new_height.end(); it++) {
315  TileIndex tile = it->first;
316  int height = it->second;
317 
318  SetTileHeight(tile, (uint)height);
319  }
320 
321  /* Finally mark the dirty tiles dirty */
322  for (TileIndexSet::const_iterator it = ts.dirty_tiles.begin(); it != ts.dirty_tiles.end(); it++) {
323  MarkTileDirtyByTile(*it);
324 
325  int height = TerraformGetHeightOfTile(&ts, *it);
326 
327  /* Now, if we alter the height of the map edge, we need to take care
328  * about repainting the affected areas outside map as well.
329  * Remember:
330  * Outside map, we assume that our landscape descends to
331  * height zero as fast as possible.
332  * Those simulated tiles (they don't exist as datastructure,
333  * only as concept in code) need to be repainted properly,
334  * otherwise we will get ugly glitches.
335  *
336  * Furthermore, note that we have to take care about the possibility,
337  * that landscape was higher before the change,
338  * so also tiles a bit outside need to be repainted.
339  */
340  int x = TileX(*it);
341  int y = TileY(*it);
342  if (x == 0) {
343  if (y == 0) {
344  /* Height of the northern corner is altered. */
345  for (int cx = 0; cx >= -height - 1; cx--) {
346  for (int cy = 0; cy >= -height - 1; cy--) {
347  /* This means, tiles in the sector north of that
348  * corner need to be repainted.
349  */
350  if (cx + cy >= -height - 2) {
351  /* But only tiles that actually might have changed. */
353  }
354  }
355  }
356  } else if (y < (int)MapMaxY()) {
357  for (int cx = 0; cx >= -height - 1; cx--) {
359  }
360  } else {
361  for (int cx = 0; cx >= -height - 1; cx--) {
362  for (int cy = (int)MapMaxY(); cy <= (int)MapMaxY() + height + 1; cy++) {
363  if (cx + ((int)MapMaxY() - cy) >= -height - 2) {
365  }
366  }
367  }
368  }
369  } else if (x < (int)MapMaxX()) {
370  if (y == 0) {
371  for (int cy = 0; cy >= -height - 1; cy--) {
373  }
374  } else if (y < (int)MapMaxY()) {
375  /* Nothing to be done here, we are inside the map. */
376  } else {
377  for (int cy = (int)MapMaxY(); cy <= (int)MapMaxY() + height + 1; cy++) {
379  }
380  }
381  } else {
382  if (y == 0) {
383  for (int cx = (int)MapMaxX(); cx <= (int)MapMaxX() + height + 1; cx++) {
384  for (int cy = 0; cy >= -height - 1; cy--) {
385  if (((int)MapMaxX() - cx) + cy >= -height - 2) {
387  }
388  }
389  }
390  } else if (y < (int)MapMaxY()) {
391  for (int cx = (int)MapMaxX(); cx <= (int)MapMaxX() + height + 1; cx++) {
393  }
394  } else {
395  for (int cx = (int)MapMaxX(); cx <= (int)MapMaxX() + height + 1; cx++) {
396  for (int cy = (int)MapMaxY(); cy <= (int)MapMaxY() + height + 1; cy++) {
397  if (((int)MapMaxX() - cx) + ((int)MapMaxY() - cy) >= -height - 2) {
399  }
400  }
401  }
402  }
403  }
404  }
405 
406  if (c != NULL) c->terraform_limit -= (uint32)ts.tile_to_new_height.size() << 16;
407  }
408  return total_cost;
409 }
410 
411 
423 CommandCost CmdLevelLand(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
424 {
425  if (p1 >= MapSize()) return CMD_ERROR;
426 
428 
429  /* remember level height */
430  uint oldh = TileHeight(p1);
431 
432  /* compute new height */
433  uint h = oldh;
434  LevelMode lm = (LevelMode)GB(p2, 1, 2);
435  switch (lm) {
436  case LM_LEVEL: break;
437  case LM_RAISE: h++; break;
438  case LM_LOWER: h--; break;
439  default: return CMD_ERROR;
440  }
441 
442  /* Check range of destination height */
443  if (h > _settings_game.construction.max_heightlevel) return_cmd_error((oldh == 0) ? STR_ERROR_ALREADY_AT_SEA_LEVEL : STR_ERROR_TOO_HIGH);
444 
447  CommandCost last_error(lm == LM_LEVEL ? STR_ERROR_ALREADY_LEVELLED : INVALID_STRING_ID);
448  bool had_success = false;
449 
451  int limit = (c == NULL ? INT32_MAX : GB(c->terraform_limit, 16, 16));
452  if (limit == 0) return_cmd_error(STR_ERROR_TERRAFORM_LIMIT_REACHED);
453 
454  TileIterator *iter = HasBit(p2, 0) ? (TileIterator *)new DiagonalTileIterator(tile, p1) : new OrthogonalTileIterator(tile, p1);
455  for (; *iter != INVALID_TILE; ++(*iter)) {
456  TileIndex t = *iter;
457  uint curh = TileHeight(t);
458  while (curh != h) {
459  CommandCost ret = DoCommand(t, SLOPE_N, (curh > h) ? 0 : 1, flags & ~DC_EXEC, CMD_TERRAFORM_LAND);
460  if (ret.Failed()) {
461  last_error = ret;
462 
463  /* Did we reach the limit? */
464  if (ret.GetErrorMessage() == STR_ERROR_TERRAFORM_LIMIT_REACHED) limit = 0;
465  break;
466  }
467 
468  if (flags & DC_EXEC) {
469  money -= ret.GetCost();
470  if (money < 0) {
471  _additional_cash_required = ret.GetCost();
472  delete iter;
473  return cost;
474  }
475  DoCommand(t, SLOPE_N, (curh > h) ? 0 : 1, flags, CMD_TERRAFORM_LAND);
476  } else {
477  /* When we're at the terraform limit we better bail (unneeded) testing as well.
478  * This will probably cause the terraforming cost to be underestimated, but only
479  * when it's near the terraforming limit. Even then, the estimation is
480  * completely off due to it basically counting terraforming double, so it being
481  * cut off earlier might even give a better estimate in some cases. */
482  if (--limit <= 0) {
483  had_success = true;
484  break;
485  }
486  }
487 
488  cost.AddCost(ret);
489  curh += (curh > h) ? -1 : 1;
490  had_success = true;
491  }
492 
493  if (limit <= 0) break;
494  }
495 
496  delete iter;
497  return had_success ? cost : last_error;
498 }