OpenTTD
landscape.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 
12 #include "stdafx.h"
13 #include "heightmap.h"
14 #include "clear_map.h"
15 #include "spritecache.h"
16 #include "viewport_func.h"
17 #include "command_func.h"
18 #include "landscape.h"
19 #include "void_map.h"
20 #include "tgp.h"
21 #include "genworld.h"
22 #include "fios.h"
23 #include "date_func.h"
24 #include "water.h"
25 #include "effectvehicle_func.h"
26 #include "landscape_type.h"
27 #include "animated_tile_func.h"
28 #include "core/random_func.hpp"
29 #include "object_base.h"
30 #include "company_func.h"
31 #include "pathfinder/npf/aystar.h"
32 #include "saveload/saveload.h"
33 #include "framerate_type.h"
34 #include <list>
35 #include <set>
36 
37 #include "table/strings.h"
38 #include "table/sprites.h"
39 
40 #include "safeguards.h"
41 
42 extern const TileTypeProcs
43  _tile_type_clear_procs,
44  _tile_type_rail_procs,
47  _tile_type_trees_procs,
48  _tile_type_station_procs,
49  _tile_type_water_procs,
50  _tile_type_void_procs,
51  _tile_type_industry_procs,
52  _tile_type_tunnelbridge_procs,
53  _tile_type_object_procs;
54 
60 const TileTypeProcs * const _tile_type_procs[16] = {
61  &_tile_type_clear_procs,
62  &_tile_type_rail_procs,
65  &_tile_type_trees_procs,
66  &_tile_type_station_procs,
67  &_tile_type_water_procs,
68  &_tile_type_void_procs,
69  &_tile_type_industry_procs,
70  &_tile_type_tunnelbridge_procs,
71  &_tile_type_object_procs,
72 };
73 
75 extern const byte _slope_to_sprite_offset[32] = {
76  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0,
77  0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 17, 0, 15, 18, 0,
78 };
79 
88 static SnowLine *_snow_line = nullptr;
89 
103 Point InverseRemapCoords2(int x, int y, bool clamp_to_map, bool *clamped)
104 {
105  if (clamped != nullptr) *clamped = false; // Not clamping yet.
106 
107  /* Initial x/y world coordinate is like if the landscape
108  * was completely flat on height 0. */
109  Point pt = InverseRemapCoords(x, y);
110 
111  const uint min_coord = _settings_game.construction.freeform_edges ? TILE_SIZE : 0;
112  const uint max_x = MapMaxX() * TILE_SIZE - 1;
113  const uint max_y = MapMaxY() * TILE_SIZE - 1;
114 
115  if (clamp_to_map) {
116  /* Bring the coordinates near to a valid range. At the top we allow a number
117  * of extra tiles. This is mostly due to the tiles on the north side of
118  * the map possibly being drawn higher due to the extra height levels. */
120  Point old_pt = pt;
121  pt.x = Clamp(pt.x, -extra_tiles * TILE_SIZE, max_x);
122  pt.y = Clamp(pt.y, -extra_tiles * TILE_SIZE, max_y);
123  if (clamped != nullptr) *clamped = (pt.x != old_pt.x) || (pt.y != old_pt.y);
124  }
125 
126  /* Now find the Z-world coordinate by fix point iteration.
127  * This is a bit tricky because the tile height is non-continuous at foundations.
128  * The clicked point should be approached from the back, otherwise there are regions that are not clickable.
129  * (FOUNDATION_HALFTILE_LOWER on SLOPE_STEEP_S hides north halftile completely)
130  * So give it a z-malus of 4 in the first iterations. */
131  int z = 0;
132  if (clamp_to_map) {
133  for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(pt.x + max(z, 4) - 4, min_coord, max_x), Clamp(pt.y + max(z, 4) - 4, min_coord, max_y)) / 2;
134  for (int m = 3; m > 0; m--) z = GetSlopePixelZ(Clamp(pt.x + max(z, m) - m, min_coord, max_x), Clamp(pt.y + max(z, m) - m, min_coord, max_y)) / 2;
135  for (int i = 0; i < 5; i++) z = GetSlopePixelZ(Clamp(pt.x + z, min_coord, max_x), Clamp(pt.y + z, min_coord, max_y)) / 2;
136  } else {
137  for (int i = 0; i < 5; i++) z = GetSlopePixelZOutsideMap(pt.x + max(z, 4) - 4, pt.y + max(z, 4) - 4) / 2;
138  for (int m = 3; m > 0; m--) z = GetSlopePixelZOutsideMap(pt.x + max(z, m) - m, pt.y + max(z, m) - m) / 2;
139  for (int i = 0; i < 5; i++) z = GetSlopePixelZOutsideMap(pt.x + z, pt.y + z ) / 2;
140  }
141 
142  pt.x += z;
143  pt.y += z;
144  if (clamp_to_map) {
145  Point old_pt = pt;
146  pt.x = Clamp(pt.x, min_coord, max_x);
147  pt.y = Clamp(pt.y, min_coord, max_y);
148  if (clamped != nullptr) *clamped = *clamped || (pt.x != old_pt.x) || (pt.y != old_pt.y);
149  }
150 
151  return pt;
152 }
153 
163 {
164  if (!IsFoundation(f)) return 0;
165 
166  if (IsLeveledFoundation(f)) {
167  uint dz = 1 + (IsSteepSlope(*s) ? 1 : 0);
168  *s = SLOPE_FLAT;
169  return dz;
170  }
171 
174  return 0;
175  }
176 
177  if (IsSpecialRailFoundation(f)) {
179  return 0;
180  }
181 
182  uint dz = IsSteepSlope(*s) ? 1 : 0;
183  Corner highest_corner = GetHighestSlopeCorner(*s);
184 
185  switch (f) {
187  *s = (((highest_corner == CORNER_W) || (highest_corner == CORNER_S)) ? SLOPE_SW : SLOPE_NE);
188  break;
189 
191  *s = (((highest_corner == CORNER_S) || (highest_corner == CORNER_E)) ? SLOPE_SE : SLOPE_NW);
192  break;
193 
195  *s = SlopeWithOneCornerRaised(highest_corner);
196  break;
197 
199  *s = HalftileSlope(SlopeWithOneCornerRaised(highest_corner), highest_corner);
200  break;
201 
202  default: NOT_REACHED();
203  }
204  return dz;
205 }
206 
207 
215 uint GetPartialPixelZ(int x, int y, Slope corners)
216 {
217  if (IsHalftileSlope(corners)) {
218  switch (GetHalftileSlopeCorner(corners)) {
219  case CORNER_W:
220  if (x - y >= 0) return GetSlopeMaxPixelZ(corners);
221  break;
222 
223  case CORNER_S:
224  if (x - (y ^ 0xF) >= 0) return GetSlopeMaxPixelZ(corners);
225  break;
226 
227  case CORNER_E:
228  if (y - x >= 0) return GetSlopeMaxPixelZ(corners);
229  break;
230 
231  case CORNER_N:
232  if ((y ^ 0xF) - x >= 0) return GetSlopeMaxPixelZ(corners);
233  break;
234 
235  default: NOT_REACHED();
236  }
237  }
238 
239  int z = 0;
240 
241  switch (RemoveHalftileSlope(corners)) {
242  case SLOPE_W:
243  if (x - y >= 0) {
244  z = (x - y) >> 1;
245  }
246  break;
247 
248  case SLOPE_S:
249  y ^= 0xF;
250  if ((x - y) >= 0) {
251  z = (x - y) >> 1;
252  }
253  break;
254 
255  case SLOPE_SW:
256  z = (x >> 1) + 1;
257  break;
258 
259  case SLOPE_E:
260  if (y - x >= 0) {
261  z = (y - x) >> 1;
262  }
263  break;
264 
265  case SLOPE_EW:
266  case SLOPE_NS:
267  case SLOPE_ELEVATED:
268  z = 4;
269  break;
270 
271  case SLOPE_SE:
272  z = (y >> 1) + 1;
273  break;
274 
275  case SLOPE_WSE:
276  z = 8;
277  y ^= 0xF;
278  if (x - y < 0) {
279  z += (x - y) >> 1;
280  }
281  break;
282 
283  case SLOPE_N:
284  y ^= 0xF;
285  if (y - x >= 0) {
286  z = (y - x) >> 1;
287  }
288  break;
289 
290  case SLOPE_NW:
291  z = (y ^ 0xF) >> 1;
292  break;
293 
294  case SLOPE_NWS:
295  z = 8;
296  if (x - y < 0) {
297  z += (x - y) >> 1;
298  }
299  break;
300 
301  case SLOPE_NE:
302  z = (x ^ 0xF) >> 1;
303  break;
304 
305  case SLOPE_ENW:
306  z = 8;
307  y ^= 0xF;
308  if (y - x < 0) {
309  z += (y - x) >> 1;
310  }
311  break;
312 
313  case SLOPE_SEN:
314  z = 8;
315  if (y - x < 0) {
316  z += (y - x) >> 1;
317  }
318  break;
319 
320  case SLOPE_STEEP_S:
321  z = 1 + ((x + y) >> 1);
322  break;
323 
324  case SLOPE_STEEP_W:
325  z = 1 + ((x + (y ^ 0xF)) >> 1);
326  break;
327 
328  case SLOPE_STEEP_N:
329  z = 1 + (((x ^ 0xF) + (y ^ 0xF)) >> 1);
330  break;
331 
332  case SLOPE_STEEP_E:
333  z = 1 + (((x ^ 0xF) + y) >> 1);
334  break;
335 
336  default: break;
337  }
338 
339  return z;
340 }
341 
342 int GetSlopePixelZ(int x, int y)
343 {
344  TileIndex tile = TileVirtXY(x, y);
345 
346  return _tile_type_procs[GetTileType(tile)]->get_slope_z_proc(tile, x, y);
347 }
348 
357 int GetSlopePixelZOutsideMap(int x, int y)
358 {
359  if (IsInsideBS(x, 0, MapSizeX() * TILE_SIZE) && IsInsideBS(y, 0, MapSizeY() * TILE_SIZE)) {
360  return GetSlopePixelZ(x, y);
361  } else {
362  return _tile_type_procs[MP_VOID]->get_slope_z_proc(INVALID_TILE, x, y);
363  }
364 }
365 
375 int GetSlopeZInCorner(Slope tileh, Corner corner)
376 {
377  assert(!IsHalftileSlope(tileh));
378  return ((tileh & SlopeWithOneCornerRaised(corner)) != 0 ? 1 : 0) + (tileh == SteepSlope(corner) ? 1 : 0);
379 }
380 
393 void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2)
394 {
395  static const Slope corners[4][4] = {
396  /* corner | steep slope
397  * z1 z2 | z1 z2 */
398  {SLOPE_E, SLOPE_N, SLOPE_STEEP_E, SLOPE_STEEP_N}, // DIAGDIR_NE, z1 = E, z2 = N
399  {SLOPE_S, SLOPE_E, SLOPE_STEEP_S, SLOPE_STEEP_E}, // DIAGDIR_SE, z1 = S, z2 = E
400  {SLOPE_S, SLOPE_W, SLOPE_STEEP_S, SLOPE_STEEP_W}, // DIAGDIR_SW, z1 = S, z2 = W
401  {SLOPE_W, SLOPE_N, SLOPE_STEEP_W, SLOPE_STEEP_N}, // DIAGDIR_NW, z1 = W, z2 = N
402  };
403 
404  int halftile_test = (IsHalftileSlope(tileh) ? SlopeWithOneCornerRaised(GetHalftileSlopeCorner(tileh)) : 0);
405  if (halftile_test == corners[edge][0]) *z2 += TILE_HEIGHT; // The slope is non-continuous in z2. z2 is on the upper side.
406  if (halftile_test == corners[edge][1]) *z1 += TILE_HEIGHT; // The slope is non-continuous in z1. z1 is on the upper side.
407 
408  if ((tileh & corners[edge][0]) != 0) *z1 += TILE_HEIGHT; // z1 is raised
409  if ((tileh & corners[edge][1]) != 0) *z2 += TILE_HEIGHT; // z2 is raised
410  if (RemoveHalftileSlope(tileh) == corners[edge][2]) *z1 += TILE_HEIGHT; // z1 is highest corner of a steep slope
411  if (RemoveHalftileSlope(tileh) == corners[edge][3]) *z2 += TILE_HEIGHT; // z2 is highest corner of a steep slope
412 }
413 
423 {
424  Slope tileh = GetTileSlope(tile, z);
425  Foundation f = _tile_type_procs[GetTileType(tile)]->get_foundation_proc(tile, tileh);
426  uint z_inc = ApplyFoundationToSlope(f, &tileh);
427  if (z != nullptr) *z += z_inc;
428  return tileh;
429 }
430 
431 
432 bool HasFoundationNW(TileIndex tile, Slope slope_here, uint z_here)
433 {
434  int z;
435 
436  int z_W_here = z_here;
437  int z_N_here = z_here;
438  GetSlopePixelZOnEdge(slope_here, DIAGDIR_NW, &z_W_here, &z_N_here);
439 
440  Slope slope = GetFoundationPixelSlope(TILE_ADDXY(tile, 0, -1), &z);
441  int z_W = z;
442  int z_N = z;
443  GetSlopePixelZOnEdge(slope, DIAGDIR_SE, &z_W, &z_N);
444 
445  return (z_N_here > z_N) || (z_W_here > z_W);
446 }
447 
448 
449 bool HasFoundationNE(TileIndex tile, Slope slope_here, uint z_here)
450 {
451  int z;
452 
453  int z_E_here = z_here;
454  int z_N_here = z_here;
455  GetSlopePixelZOnEdge(slope_here, DIAGDIR_NE, &z_E_here, &z_N_here);
456 
457  Slope slope = GetFoundationPixelSlope(TILE_ADDXY(tile, -1, 0), &z);
458  int z_E = z;
459  int z_N = z;
460  GetSlopePixelZOnEdge(slope, DIAGDIR_SW, &z_E, &z_N);
461 
462  return (z_N_here > z_N) || (z_E_here > z_E);
463 }
464 
471 {
472  if (!IsFoundation(f)) return;
473 
474  /* Two part foundations must be drawn separately */
475  assert(f != FOUNDATION_STEEP_BOTH);
476 
477  uint sprite_block = 0;
478  int z;
479  Slope slope = GetFoundationPixelSlope(ti->tile, &z);
480 
481  /* Select the needed block of foundations sprites
482  * Block 0: Walls at NW and NE edge
483  * Block 1: Wall at NE edge
484  * Block 2: Wall at NW edge
485  * Block 3: No walls at NW or NE edge
486  */
487  if (!HasFoundationNW(ti->tile, slope, z)) sprite_block += 1;
488  if (!HasFoundationNE(ti->tile, slope, z)) sprite_block += 2;
489 
490  /* Use the original slope sprites if NW and NE borders should be visible */
491  SpriteID leveled_base = (sprite_block == 0 ? (int)SPR_FOUNDATION_BASE : (SPR_SLOPES_VIRTUAL_BASE + sprite_block * SPR_TRKFOUND_BLOCK_SIZE));
492  SpriteID inclined_base = SPR_SLOPES_VIRTUAL_BASE + SPR_SLOPES_INCLINED_OFFSET + sprite_block * SPR_TRKFOUND_BLOCK_SIZE;
493  SpriteID halftile_base = SPR_HALFTILE_FOUNDATION_BASE + sprite_block * SPR_HALFTILE_BLOCK_SIZE;
494 
495  if (IsSteepSlope(ti->tileh)) {
496  if (!IsNonContinuousFoundation(f)) {
497  /* Lower part of foundation */
499  leveled_base + (ti->tileh & ~SLOPE_STEEP), PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z
500  );
501  }
502 
503  Corner highest_corner = GetHighestSlopeCorner(ti->tileh);
504  ti->z += ApplyPixelFoundationToSlope(f, &ti->tileh);
505 
506  if (IsInclinedFoundation(f)) {
507  /* inclined foundation */
508  byte inclined = highest_corner * 2 + (f == FOUNDATION_INCLINED_Y ? 1 : 0);
509 
510  AddSortableSpriteToDraw(inclined_base + inclined, PAL_NONE, ti->x, ti->y,
511  f == FOUNDATION_INCLINED_X ? 16 : 1,
512  f == FOUNDATION_INCLINED_Y ? 16 : 1,
513  TILE_HEIGHT, ti->z
514  );
515  OffsetGroundSprite(31, 9);
516  } else if (IsLeveledFoundation(f)) {
517  AddSortableSpriteToDraw(leveled_base + SlopeWithOneCornerRaised(highest_corner), PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z - TILE_HEIGHT);
518  OffsetGroundSprite(31, 1);
519  } else if (f == FOUNDATION_STEEP_LOWER) {
520  /* one corner raised */
521  OffsetGroundSprite(31, 1);
522  } else {
523  /* halftile foundation */
524  int x_bb = (((highest_corner == CORNER_W) || (highest_corner == CORNER_S)) ? 8 : 0);
525  int y_bb = (((highest_corner == CORNER_S) || (highest_corner == CORNER_E)) ? 8 : 0);
526 
527  AddSortableSpriteToDraw(halftile_base + highest_corner, PAL_NONE, ti->x + x_bb, ti->y + y_bb, 8, 8, 7, ti->z + TILE_HEIGHT);
528  OffsetGroundSprite(31, 9);
529  }
530  } else {
531  if (IsLeveledFoundation(f)) {
532  /* leveled foundation */
533  AddSortableSpriteToDraw(leveled_base + ti->tileh, PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z);
534  OffsetGroundSprite(31, 1);
535  } else if (IsNonContinuousFoundation(f)) {
536  /* halftile foundation */
537  Corner halftile_corner = GetHalftileFoundationCorner(f);
538  int x_bb = (((halftile_corner == CORNER_W) || (halftile_corner == CORNER_S)) ? 8 : 0);
539  int y_bb = (((halftile_corner == CORNER_S) || (halftile_corner == CORNER_E)) ? 8 : 0);
540 
541  AddSortableSpriteToDraw(halftile_base + halftile_corner, PAL_NONE, ti->x + x_bb, ti->y + y_bb, 8, 8, 7, ti->z);
542  OffsetGroundSprite(31, 9);
543  } else if (IsSpecialRailFoundation(f)) {
544  /* anti-zig-zag foundation */
545  SpriteID spr;
546  if (ti->tileh == SLOPE_NS || ti->tileh == SLOPE_EW) {
547  /* half of leveled foundation under track corner */
548  spr = leveled_base + SlopeWithThreeCornersRaised(GetRailFoundationCorner(f));
549  } else {
550  /* tile-slope = sloped along X/Y, foundation-slope = three corners raised */
551  spr = inclined_base + 2 * GetRailFoundationCorner(f) + ((ti->tileh == SLOPE_SW || ti->tileh == SLOPE_NE) ? 1 : 0);
552  }
553  AddSortableSpriteToDraw(spr, PAL_NONE, ti->x, ti->y, 16, 16, 7, ti->z);
554  OffsetGroundSprite(31, 9);
555  } else {
556  /* inclined foundation */
557  byte inclined = GetHighestSlopeCorner(ti->tileh) * 2 + (f == FOUNDATION_INCLINED_Y ? 1 : 0);
558 
559  AddSortableSpriteToDraw(inclined_base + inclined, PAL_NONE, ti->x, ti->y,
560  f == FOUNDATION_INCLINED_X ? 16 : 1,
561  f == FOUNDATION_INCLINED_Y ? 16 : 1,
562  TILE_HEIGHT, ti->z
563  );
564  OffsetGroundSprite(31, 9);
565  }
566  ti->z += ApplyPixelFoundationToSlope(f, &ti->tileh);
567  }
568 }
569 
570 void DoClearSquare(TileIndex tile)
571 {
572  /* If the tile can have animation and we clear it, delete it from the animated tile list. */
573  if (_tile_type_procs[GetTileType(tile)]->animate_tile_proc != nullptr) DeleteAnimatedTile(tile);
574 
575  MakeClear(tile, CLEAR_GRASS, _generating_world ? 3 : 0);
576  MarkTileDirtyByTile(tile);
577 }
578 
589 TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
590 {
591  return _tile_type_procs[GetTileType(tile)]->get_tile_track_status_proc(tile, mode, sub_mode, side);
592 }
593 
600 void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
601 {
602  _tile_type_procs[GetTileType(tile)]->change_tile_owner_proc(tile, old_owner, new_owner);
603 }
604 
605 void GetTileDesc(TileIndex tile, TileDesc *td)
606 {
607  _tile_type_procs[GetTileType(tile)]->get_tile_desc_proc(tile, td);
608 }
609 
616 {
617  return _snow_line != nullptr;
618 }
619 
626 {
627  _snow_line = CallocT<SnowLine>(1);
628  _snow_line->lowest_value = 0xFF;
629  memcpy(_snow_line->table, table, sizeof(_snow_line->table));
630 
631  for (uint i = 0; i < SNOW_LINE_MONTHS; i++) {
632  for (uint j = 0; j < SNOW_LINE_DAYS; j++) {
633  _snow_line->highest_value = max(_snow_line->highest_value, table[i][j]);
634  _snow_line->lowest_value = min(_snow_line->lowest_value, table[i][j]);
635  }
636  }
637 }
638 
645 {
646  if (_snow_line == nullptr) return _settings_game.game_creation.snow_line_height;
647 
648  YearMonthDay ymd;
649  ConvertDateToYMD(_date, &ymd);
650  return _snow_line->table[ymd.month][ymd.day];
651 }
652 
659 {
660  return _snow_line == nullptr ? _settings_game.game_creation.snow_line_height : _snow_line->highest_value;
661 }
662 
669 {
670  return _snow_line == nullptr ? _settings_game.game_creation.snow_line_height : _snow_line->lowest_value;
671 }
672 
678 {
679  free(_snow_line);
680  _snow_line = nullptr;
681 }
682 
692 CommandCost CmdLandscapeClear(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
693 {
695  bool do_clear = false;
696  /* Test for stuff which results in water when cleared. Then add the cost to also clear the water. */
697  if ((flags & DC_FORCE_CLEAR_TILE) && HasTileWaterClass(tile) && IsTileOnWater(tile) && !IsWaterTile(tile) && !IsCoastTile(tile)) {
698  if ((flags & DC_AUTO) && GetWaterClass(tile) == WATER_CLASS_CANAL) return_cmd_error(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);
699  do_clear = true;
700  cost.AddCost(GetWaterClass(tile) == WATER_CLASS_CANAL ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER]);
701  }
702 
703  Company *c = (flags & (DC_AUTO | DC_BANKRUPT)) ? nullptr : Company::GetIfValid(_current_company);
704  if (c != nullptr && (int)GB(c->clear_limit, 16, 16) < 1) {
705  return_cmd_error(STR_ERROR_CLEARING_LIMIT_REACHED);
706  }
707 
708  const ClearedObjectArea *coa = FindClearedObject(tile);
709 
710  /* If this tile was the first tile which caused object destruction, always
711  * pass it on to the tile_type_proc. That way multiple test runs and the exec run stay consistent. */
712  if (coa != nullptr && coa->first_tile != tile) {
713  /* If this tile belongs to an object which was already cleared via another tile, pretend it has been
714  * already removed.
715  * However, we need to check stuff, which is not the same for all object tiles. (e.g. being on water or not) */
716 
717  /* If a object is removed, it leaves either bare land or water. */
718  if ((flags & DC_NO_WATER) && HasTileWaterClass(tile) && IsTileOnWater(tile)) {
719  return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);
720  }
721  } else {
722  cost.AddCost(_tile_type_procs[GetTileType(tile)]->clear_tile_proc(tile, flags));
723  }
724 
725  if (flags & DC_EXEC) {
726  if (c != nullptr) c->clear_limit -= 1 << 16;
727  if (do_clear) DoClearSquare(tile);
728  }
729  return cost;
730 }
731 
742 CommandCost CmdClearArea(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
743 {
744  if (p1 >= MapSize()) return CMD_ERROR;
745 
748  CommandCost last_error = CMD_ERROR;
749  bool had_success = false;
750 
751  const Company *c = (flags & (DC_AUTO | DC_BANKRUPT)) ? nullptr : Company::GetIfValid(_current_company);
752  int limit = (c == nullptr ? INT32_MAX : GB(c->clear_limit, 16, 16));
753 
754  TileIterator *iter = HasBit(p2, 0) ? (TileIterator *)new DiagonalTileIterator(tile, p1) : new OrthogonalTileIterator(tile, p1);
755  for (; *iter != INVALID_TILE; ++(*iter)) {
756  TileIndex t = *iter;
757  CommandCost ret = DoCommand(t, 0, 0, flags & ~DC_EXEC, CMD_LANDSCAPE_CLEAR);
758  if (ret.Failed()) {
759  last_error = ret;
760 
761  /* We may not clear more tiles. */
762  if (c != nullptr && GB(c->clear_limit, 16, 16) < 1) break;
763  continue;
764  }
765 
766  had_success = true;
767  if (flags & DC_EXEC) {
768  money -= ret.GetCost();
769  if (ret.GetCost() > 0 && money < 0) {
770  _additional_cash_required = ret.GetCost();
771  delete iter;
772  return cost;
773  }
774  DoCommand(t, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
775 
776  /* draw explosion animation...
777  * Disable explosions when game is paused. Looks silly and blocks the view. */
778  if ((t == tile || t == p1) && _pause_mode == PM_UNPAUSED) {
779  /* big explosion in two corners, or small explosion for single tiles */
781  TileX(tile) == TileX(p1) && TileY(tile) == TileY(p1) ? EV_EXPLOSION_SMALL : EV_EXPLOSION_LARGE
782  );
783  }
784  } else {
785  /* When we're at the clearing limit we better bail (unneed) testing as well. */
786  if (ret.GetCost() != 0 && --limit <= 0) break;
787  }
788  cost.AddCost(ret);
789  }
790 
791  delete iter;
792  return had_success ? cost : last_error;
793 }
794 
795 
796 TileIndex _cur_tileloop_tile;
797 
802 {
804 
805  /* The pseudorandom sequence of tiles is generated using a Galois linear feedback
806  * shift register (LFSR). This allows a deterministic pseudorandom ordering, but
807  * still with minimal state and fast iteration. */
808 
809  /* Maximal length LFSR feedback terms, from 12-bit (for 64x64 maps) to 24-bit (for 4096x4096 maps).
810  * Extracted from http://www.ece.cmu.edu/~koopman/lfsr/ */
811  static const uint32 feedbacks[] = {
812  0xD8F, 0x1296, 0x2496, 0x4357, 0x8679, 0x1030E, 0x206CD, 0x403FE, 0x807B8, 0x1004B2, 0x2006A8, 0x4004B2, 0x800B87
813  };
814  assert_compile(lengthof(feedbacks) == 2 * MAX_MAP_SIZE_BITS - 2 * MIN_MAP_SIZE_BITS + 1);
815  const uint32 feedback = feedbacks[MapLogX() + MapLogY() - 2 * MIN_MAP_SIZE_BITS];
816 
817  /* We update every tile every 256 ticks, so divide the map size by 2^8 = 256 */
818  uint count = 1 << (MapLogX() + MapLogY() - 8);
819 
820  TileIndex tile = _cur_tileloop_tile;
821  /* The LFSR cannot have a zeroed state. */
822  assert(tile != 0);
823 
824  /* Manually update tile 0 every 256 ticks - the LFSR never iterates over it itself. */
825  if (_tick_counter % 256 == 0) {
826  _tile_type_procs[GetTileType(0)]->tile_loop_proc(0);
827  count--;
828  }
829 
830  while (count--) {
831  _tile_type_procs[GetTileType(tile)]->tile_loop_proc(tile);
832 
833  /* Get the next tile in sequence using a Galois LFSR. */
834  tile = (tile >> 1) ^ (-(int32)(tile & 1) & feedback);
835  }
836 
837  _cur_tileloop_tile = tile;
838 }
839 
840 void InitializeLandscape()
841 {
842  for (uint y = _settings_game.construction.freeform_edges ? 1 : 0; y < MapMaxY(); y++) {
843  for (uint x = _settings_game.construction.freeform_edges ? 1 : 0; x < MapMaxX(); x++) {
844  MakeClear(TileXY(x, y), CLEAR_GRASS, 3);
845  SetTileHeight(TileXY(x, y), 0);
847  ClearBridgeMiddle(TileXY(x, y));
848  }
849  }
850 
851  for (uint x = 0; x < MapSizeX(); x++) MakeVoid(TileXY(x, MapMaxY()));
852  for (uint y = 0; y < MapSizeY(); y++) MakeVoid(TileXY(MapMaxX(), y));
853 }
854 
855 static const byte _genterrain_tbl_1[5] = { 10, 22, 33, 37, 4 };
856 static const byte _genterrain_tbl_2[5] = { 0, 0, 0, 0, 33 };
857 
858 static void GenerateTerrain(int type, uint flag)
859 {
860  uint32 r = Random();
861 
862  const Sprite *templ = GetSprite((((r >> 24) * _genterrain_tbl_1[type]) >> 8) + _genterrain_tbl_2[type] + 4845, ST_MAPGEN);
863  if (templ == nullptr) usererror("Map generator sprites could not be loaded");
864 
865  uint x = r & MapMaxX();
866  uint y = (r >> MapLogX()) & MapMaxY();
867 
868  if (x < 2 || y < 2) return;
869 
870  DiagDirection direction = (DiagDirection)GB(r, 22, 2);
871  uint w = templ->width;
872  uint h = templ->height;
873 
874  if (DiagDirToAxis(direction) == AXIS_Y) Swap(w, h);
875 
876  const byte *p = templ->data;
877 
878  if ((flag & 4) != 0) {
879  uint xw = x * MapSizeY();
880  uint yw = y * MapSizeX();
881  uint bias = (MapSizeX() + MapSizeY()) * 16;
882 
883  switch (flag & 3) {
884  default: NOT_REACHED();
885  case 0:
886  if (xw + yw > MapSize() - bias) return;
887  break;
888 
889  case 1:
890  if (yw < xw + bias) return;
891  break;
892 
893  case 2:
894  if (xw + yw < MapSize() + bias) return;
895  break;
896 
897  case 3:
898  if (xw < yw + bias) return;
899  break;
900  }
901  }
902 
903  if (x + w >= MapMaxX() - 1) return;
904  if (y + h >= MapMaxY() - 1) return;
905 
906  TileIndex tile = TileXY(x, y);
907 
908  switch (direction) {
909  default: NOT_REACHED();
910  case DIAGDIR_NE:
911  do {
912  TileIndex tile_cur = tile;
913 
914  for (uint w_cur = w; w_cur != 0; --w_cur) {
915  if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
916  p++;
917  tile_cur++;
918  }
919  tile += TileDiffXY(0, 1);
920  } while (--h != 0);
921  break;
922 
923  case DIAGDIR_SE:
924  do {
925  TileIndex tile_cur = tile;
926 
927  for (uint h_cur = h; h_cur != 0; --h_cur) {
928  if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
929  p++;
930  tile_cur += TileDiffXY(0, 1);
931  }
932  tile += TileDiffXY(1, 0);
933  } while (--w != 0);
934  break;
935 
936  case DIAGDIR_SW:
937  tile += TileDiffXY(w - 1, 0);
938  do {
939  TileIndex tile_cur = tile;
940 
941  for (uint w_cur = w; w_cur != 0; --w_cur) {
942  if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
943  p++;
944  tile_cur--;
945  }
946  tile += TileDiffXY(0, 1);
947  } while (--h != 0);
948  break;
949 
950  case DIAGDIR_NW:
951  tile += TileDiffXY(0, h - 1);
952  do {
953  TileIndex tile_cur = tile;
954 
955  for (uint h_cur = h; h_cur != 0; --h_cur) {
956  if (GB(*p, 0, 4) >= TileHeight(tile_cur)) SetTileHeight(tile_cur, GB(*p, 0, 4));
957  p++;
958  tile_cur -= TileDiffXY(0, 1);
959  }
960  tile += TileDiffXY(1, 0);
961  } while (--w != 0);
962  break;
963  }
964 }
965 
966 
967 #include "table/genland.h"
968 
969 static void CreateDesertOrRainForest()
970 {
971  TileIndex update_freq = MapSize() / 4;
972  const TileIndexDiffC *data;
973  uint max_desert_height = CeilDiv(_settings_game.construction.max_heightlevel, 4);
974 
975  for (TileIndex tile = 0; tile != MapSize(); ++tile) {
976  if ((tile % update_freq) == 0) IncreaseGeneratingWorldProgress(GWP_LANDSCAPE);
977 
978  if (!IsValidTile(tile)) continue;
979 
980  for (data = _make_desert_or_rainforest_data;
981  data != endof(_make_desert_or_rainforest_data); ++data) {
982  TileIndex t = AddTileIndexDiffCWrap(tile, *data);
983  if (t != INVALID_TILE && (TileHeight(t) >= max_desert_height || IsTileType(t, MP_WATER))) break;
984  }
985  if (data == endof(_make_desert_or_rainforest_data)) {
987  }
988  }
989 
990  for (uint i = 0; i != 256; i++) {
992 
993  RunTileLoop();
994  }
995 
996  for (TileIndex tile = 0; tile != MapSize(); ++tile) {
997  if ((tile % update_freq) == 0) IncreaseGeneratingWorldProgress(GWP_LANDSCAPE);
998 
999  if (!IsValidTile(tile)) continue;
1000 
1001  for (data = _make_desert_or_rainforest_data;
1002  data != endof(_make_desert_or_rainforest_data); ++data) {
1003  TileIndex t = AddTileIndexDiffCWrap(tile, *data);
1004  if (t != INVALID_TILE && IsTileType(t, MP_CLEAR) && IsClearGround(t, CLEAR_DESERT)) break;
1005  }
1006  if (data == endof(_make_desert_or_rainforest_data)) {
1008  }
1009  }
1010 }
1011 
1018 static bool FindSpring(TileIndex tile, void *user_data)
1019 {
1020  int referenceHeight;
1021  if (!IsTileFlat(tile, &referenceHeight) || IsWaterTile(tile)) return false;
1022 
1023  /* In the tropics rivers start in the rainforest. */
1024  if (_settings_game.game_creation.landscape == LT_TROPIC && GetTropicZone(tile) != TROPICZONE_RAINFOREST) return false;
1025 
1026  /* Are there enough higher tiles to warrant a 'spring'? */
1027  uint num = 0;
1028  for (int dx = -1; dx <= 1; dx++) {
1029  for (int dy = -1; dy <= 1; dy++) {
1030  TileIndex t = TileAddWrap(tile, dx, dy);
1031  if (t != INVALID_TILE && GetTileMaxZ(t) > referenceHeight) num++;
1032  }
1033  }
1034 
1035  if (num < 4) return false;
1036 
1037  /* Are we near the top of a hill? */
1038  for (int dx = -16; dx <= 16; dx++) {
1039  for (int dy = -16; dy <= 16; dy++) {
1040  TileIndex t = TileAddWrap(tile, dx, dy);
1041  if (t != INVALID_TILE && GetTileMaxZ(t) > referenceHeight + 2) return false;
1042  }
1043  }
1044 
1045  return true;
1046 }
1047 
1054 static bool MakeLake(TileIndex tile, void *user_data)
1055 {
1056  uint height = *(uint*)user_data;
1057  if (!IsValidTile(tile) || TileHeight(tile) != height || !IsTileFlat(tile)) return false;
1058  if (_settings_game.game_creation.landscape == LT_TROPIC && GetTropicZone(tile) == TROPICZONE_DESERT) return false;
1059 
1060  for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
1061  TileIndex t2 = tile + TileOffsByDiagDir(d);
1062  if (IsWaterTile(t2)) {
1063  MakeRiver(tile, Random());
1064  /* Remove desert directly around the river tile. */
1065  TileIndex t = tile;
1067  return false;
1068  }
1069  }
1070 
1071  return false;
1072 }
1073 
1080 static bool FlowsDown(TileIndex begin, TileIndex end)
1081 {
1082  assert(DistanceManhattan(begin, end) == 1);
1083 
1084  int heightBegin;
1085  int heightEnd;
1086  Slope slopeBegin = GetTileSlope(begin, &heightBegin);
1087  Slope slopeEnd = GetTileSlope(end, &heightEnd);
1088 
1089  return heightEnd <= heightBegin &&
1090  /* Slope either is inclined or flat; rivers don't support other slopes. */
1091  (slopeEnd == SLOPE_FLAT || IsInclinedSlope(slopeEnd)) &&
1092  /* Slope continues, then it must be lower... or either end must be flat. */
1093  ((slopeEnd == slopeBegin && heightEnd < heightBegin) || slopeEnd == SLOPE_FLAT || slopeBegin == SLOPE_FLAT);
1094 }
1095 
1096 /* AyStar callback for checking whether we reached our destination. */
1097 static int32 River_EndNodeCheck(const AyStar *aystar, const OpenListNode *current)
1098 {
1099  return current->path.node.tile == *(TileIndex*)aystar->user_target ? AYSTAR_FOUND_END_NODE : AYSTAR_DONE;
1100 }
1101 
1102 /* AyStar callback for getting the cost of the current node. */
1103 static int32 River_CalculateG(AyStar *aystar, AyStarNode *current, OpenListNode *parent)
1104 {
1106 }
1107 
1108 /* AyStar callback for getting the estimated cost to the destination. */
1109 static int32 River_CalculateH(AyStar *aystar, AyStarNode *current, OpenListNode *parent)
1110 {
1111  return DistanceManhattan(*(TileIndex*)aystar->user_target, current->tile);
1112 }
1113 
1114 /* AyStar callback for getting the neighbouring nodes of the given node. */
1115 static void River_GetNeighbours(AyStar *aystar, OpenListNode *current)
1116 {
1117  TileIndex tile = current->path.node.tile;
1118 
1119  aystar->num_neighbours = 0;
1120  for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
1121  TileIndex t2 = tile + TileOffsByDiagDir(d);
1122  if (IsValidTile(t2) && FlowsDown(tile, t2)) {
1123  aystar->neighbours[aystar->num_neighbours].tile = t2;
1124  aystar->neighbours[aystar->num_neighbours].direction = INVALID_TRACKDIR;
1125  aystar->num_neighbours++;
1126  }
1127  }
1128 }
1129 
1130 /* AyStar callback when an route has been found. */
1131 static void River_FoundEndNode(AyStar *aystar, OpenListNode *current)
1132 {
1133  for (PathNode *path = &current->path; path != nullptr; path = path->parent) {
1134  TileIndex tile = path->node.tile;
1135  if (!IsWaterTile(tile)) {
1136  MakeRiver(tile, Random());
1137  /* Remove desert directly around the river tile. */
1139  }
1140  }
1141 }
1142 
1143 static const uint RIVER_HASH_SIZE = 8;
1144 
1151 static uint River_Hash(uint tile, uint dir)
1152 {
1153  return GB(TileHash(TileX(tile), TileY(tile)), 0, RIVER_HASH_SIZE);
1154 }
1155 
1161 static void BuildRiver(TileIndex begin, TileIndex end)
1162 {
1163  AyStar finder = {};
1164  finder.CalculateG = River_CalculateG;
1165  finder.CalculateH = River_CalculateH;
1166  finder.GetNeighbours = River_GetNeighbours;
1167  finder.EndNodeCheck = River_EndNodeCheck;
1168  finder.FoundEndNode = River_FoundEndNode;
1169  finder.user_target = &end;
1170 
1171  finder.Init(River_Hash, 1 << RIVER_HASH_SIZE);
1172 
1173  AyStarNode start;
1174  start.tile = begin;
1175  start.direction = INVALID_TRACKDIR;
1176  finder.AddStartNode(&start, 0);
1177  finder.Main();
1178  finder.Free();
1179 }
1180 
1187 static bool FlowRiver(TileIndex spring, TileIndex begin)
1188 {
1189  #define SET_MARK(x) marks.insert(x)
1190  #define IS_MARKED(x) (marks.find(x) != marks.end())
1191 
1192  uint height = TileHeight(begin);
1193  if (IsWaterTile(begin)) return DistanceManhattan(spring, begin) > _settings_game.game_creation.min_river_length;
1194 
1195  std::set<TileIndex> marks;
1196  SET_MARK(begin);
1197 
1198  /* Breadth first search for the closest tile we can flow down to. */
1199  std::list<TileIndex> queue;
1200  queue.push_back(begin);
1201 
1202  bool found = false;
1203  uint count = 0; // Number of tiles considered; to be used for lake location guessing.
1204  TileIndex end;
1205  do {
1206  end = queue.front();
1207  queue.pop_front();
1208 
1209  uint height2 = TileHeight(end);
1210  if (IsTileFlat(end) && (height2 < height || (height2 == height && IsWaterTile(end)))) {
1211  found = true;
1212  break;
1213  }
1214 
1215  for (DiagDirection d = DIAGDIR_BEGIN; d < DIAGDIR_END; d++) {
1216  TileIndex t2 = end + TileOffsByDiagDir(d);
1217  if (IsValidTile(t2) && !IS_MARKED(t2) && FlowsDown(end, t2)) {
1218  SET_MARK(t2);
1219  count++;
1220  queue.push_back(t2);
1221  }
1222  }
1223  } while (!queue.empty());
1224 
1225  if (found) {
1226  /* Flow further down hill. */
1227  found = FlowRiver(spring, end);
1228  } else if (count > 32) {
1229  /* Maybe we can make a lake. Find the Nth of the considered tiles. */
1230  TileIndex lakeCenter = 0;
1231  int i = RandomRange(count - 1) + 1;
1232  std::set<TileIndex>::const_iterator cit = marks.begin();
1233  while (--i) cit++;
1234  lakeCenter = *cit;
1235 
1236  if (IsValidTile(lakeCenter) &&
1237  /* A river, or lake, can only be built on flat slopes. */
1238  IsTileFlat(lakeCenter) &&
1239  /* We want the lake to be built at the height of the river. */
1240  TileHeight(begin) == TileHeight(lakeCenter) &&
1241  /* We don't want the lake at the entry of the valley. */
1242  lakeCenter != begin &&
1243  /* We don't want lakes in the desert. */
1244  (_settings_game.game_creation.landscape != LT_TROPIC || GetTropicZone(lakeCenter) != TROPICZONE_DESERT) &&
1245  /* We only want a lake if the river is long enough. */
1247  end = lakeCenter;
1248  MakeRiver(lakeCenter, Random());
1249  /* Remove desert directly around the river tile. */
1251  lakeCenter = end;
1252  uint range = RandomRange(8) + 3;
1253  CircularTileSearch(&lakeCenter, range, MakeLake, &height);
1254  /* Call the search a second time so artefacts from going circular in one direction get (mostly) hidden. */
1255  lakeCenter = end;
1256  CircularTileSearch(&lakeCenter, range, MakeLake, &height);
1257  found = true;
1258  }
1259  }
1260 
1261  marks.clear();
1262  if (found) BuildRiver(begin, end);
1263  return found;
1264 }
1265 
1269 static void CreateRivers()
1270 {
1272  if (amount == 0) return;
1273 
1275  SetGeneratingWorldProgress(GWP_RIVER, wells + 256 / 64); // Include the tile loop calls below.
1276 
1277  for (; wells != 0; wells--) {
1279  for (int tries = 0; tries < 128; tries++) {
1280  TileIndex t = RandomTile();
1281  if (!CircularTileSearch(&t, 8, FindSpring, nullptr)) continue;
1282  if (FlowRiver(t, t)) break;
1283  }
1284  }
1285 
1286  /* Run tile loop to update the ground density. */
1287  for (uint i = 0; i != 256; i++) {
1288  if (i % 64 == 0) IncreaseGeneratingWorldProgress(GWP_RIVER);
1289  RunTileLoop();
1290  }
1291 }
1292 
1293 void GenerateLandscape(byte mode)
1294 {
1296  enum GenLandscapeSteps {
1297  GLS_HEIGHTMAP = 3,
1298  GLS_TERRAGENESIS = 5,
1299  GLS_ORIGINAL = 2,
1300  GLS_TROPIC = 12,
1301  GLS_OTHER = 0,
1302  };
1303  uint steps = (_settings_game.game_creation.landscape == LT_TROPIC) ? GLS_TROPIC : GLS_OTHER;
1304 
1305  if (mode == GWM_HEIGHTMAP) {
1306  SetGeneratingWorldProgress(GWP_LANDSCAPE, steps + GLS_HEIGHTMAP);
1310  SetGeneratingWorldProgress(GWP_LANDSCAPE, steps + GLS_TERRAGENESIS);
1312  } else {
1313  SetGeneratingWorldProgress(GWP_LANDSCAPE, steps + GLS_ORIGINAL);
1315  for (uint x = 0; x < MapSizeX(); x++) MakeVoid(TileXY(x, 0));
1316  for (uint y = 0; y < MapSizeY(); y++) MakeVoid(TileXY(0, y));
1317  }
1319  case LT_ARCTIC: {
1320  uint32 r = Random();
1321 
1322  for (uint i = ScaleByMapSize(GB(r, 0, 7) + 950); i != 0; --i) {
1323  GenerateTerrain(2, 0);
1324  }
1325 
1326  uint flag = GB(r, 7, 2) | 4;
1327  for (uint i = ScaleByMapSize(GB(r, 9, 7) + 450); i != 0; --i) {
1328  GenerateTerrain(4, flag);
1329  }
1330  break;
1331  }
1332 
1333  case LT_TROPIC: {
1334  uint32 r = Random();
1335 
1336  for (uint i = ScaleByMapSize(GB(r, 0, 7) + 170); i != 0; --i) {
1337  GenerateTerrain(0, 0);
1338  }
1339 
1340  uint flag = GB(r, 7, 2) | 4;
1341  for (uint i = ScaleByMapSize(GB(r, 9, 8) + 1700); i != 0; --i) {
1342  GenerateTerrain(0, flag);
1343  }
1344 
1345  flag ^= 2;
1346 
1347  for (uint i = ScaleByMapSize(GB(r, 17, 7) + 410); i != 0; --i) {
1348  GenerateTerrain(3, flag);
1349  }
1350  break;
1351  }
1352 
1353  default: {
1354  uint32 r = Random();
1355 
1357  uint i = ScaleByMapSize(GB(r, 0, 7) + (3 - _settings_game.difficulty.quantity_sea_lakes) * 256 + 100);
1358  for (; i != 0; --i) {
1359  /* Make sure we do not overflow. */
1360  GenerateTerrain(Clamp(_settings_game.difficulty.terrain_type, 0, 3), 0);
1361  }
1362  break;
1363  }
1364  }
1365  }
1366 
1367  /* Do not call IncreaseGeneratingWorldProgress() before FixSlopes(),
1368  * it allows screen redraw. Drawing of broken slopes crashes the game */
1369  FixSlopes();
1371  ConvertGroundTilesIntoWaterTiles();
1373 
1374  if (_settings_game.game_creation.landscape == LT_TROPIC) CreateDesertOrRainForest();
1375 
1376  CreateRivers();
1377 }
1378 
1379 void OnTick_Town();
1380 void OnTick_Trees();
1381 void OnTick_Station();
1382 void OnTick_Industry();
1383 
1384 void OnTick_Companies();
1385 void OnTick_LinkGraph();
1386 
1387 void CallLandscapeTick()
1388 {
1389  {
1391 
1392  OnTick_Town();
1393  OnTick_Trees();
1394  OnTick_Station();
1395  OnTick_Industry();
1396  }
1397 
1398  OnTick_Companies();
1399  OnTick_LinkGraph();
1400 }
static TileType GetTileType(TileIndex tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
Owner
Enum for all companies/owners.
Definition: company_type.h:18
don&#39;t allow building on structures
Definition: command_type.h:345
static bool IsHalftileSlope(Slope s)
Checks for non-continuous slope on halftile foundations.
Definition: slope_func.h:47
uint ApplyFoundationToSlope(Foundation f, Slope *s)
Applies a foundation to a slope.
Definition: landscape.cpp:162
void Init(Hash_HashProc hash, uint num_buckets)
Initialize an AyStar.
Definition: aystar.cpp:293
void ChangeTileOwner(TileIndex tile, Owner old_owner, Owner new_owner)
Change the owner of a tile.
Definition: landscape.cpp:600
static void Swap(T &a, T &b)
Type safe swap operation.
Definition: math_func.hpp:275
the north corner of the tile is raised
Definition: slope_type.h:53
Corner
Enumeration of tile corners.
Definition: slope_type.h:22
#define RandomTile()
Get a valid random tile.
Definition: map_func.h:435
TileIndex first_tile
The first tile being cleared, which then causes the whole object to be cleared.
Definition: object_base.h:85
static const uint TILE_PIXELS
Pixel distance between tile columns/rows in #ZOOM_LVL_BASE.
Definition: tile_type.h:15
uint8 max_heightlevel
maximum allowed heightlevel
static void ClearBridgeMiddle(TileIndex t)
Removes bridges from the given, that is bridges along the X and Y axis.
Definition: bridge_map.h:103
static uint MapSizeX()
Get the size of the map along the X.
Definition: map_func.h:72
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:79
static Titem * GetIfValid(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:302
byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS]
Height of the snow line each day of the year.
Definition: landscape.h:24
byte river_route_random
the amount of randomicity for the route finding
static TropicZone GetTropicZone(TileIndex tile)
Get the tropic zone.
Definition: tile_map.h:238
Rainforest tile.
Definition: tile_type.h:72
static const SpriteID SPR_HALFTILE_FOUNDATION_BASE
Halftile foundations.
Definition: sprites.h:202
static uint MapSizeY()
Get the size of the map along the Y.
Definition: map_func.h:82
Normal tropiczone.
Definition: tile_type.h:70
do not only remove the object on the tile, but also clear any water left on it
Definition: command_type.h:355
Tile information, used while rendering the tile.
Definition: tile_cmd.h:42
south and east corner are raised
Definition: slope_type.h:57
Internal node.
Definition: aystar.h:55
static void MakeVoid(TileIndex t)
Make a nice void tile ;)
Definition: void_map.h:19
the west corner of the tile is raised
Definition: slope_type.h:50
byte landscape
the landscape we&#39;re currently in
Tile is desert.
Definition: tile_type.h:71
byte LowestSnowLine()
Get the lowest possible snow line height, either variable or static.
Definition: landscape.cpp:668
byte land_generator
the landscape generator
static const uint RIVER_HASH_SIZE
The number of bits the hash for river finding should have.
Definition: landscape.cpp:1143
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
Definition: landscape.cpp:215
void LoadHeightmap(DetailedFileType dft, const char *filename)
Load a heightmap from file and change the map in his current dimensions to a landscape representing t...
Definition: heightmap.cpp:489
byte amount_of_rivers
the amount of rivers
Money GetAvailableMoneyForCommand()
Definition: command.cpp:519
static Corner GetHalftileFoundationCorner(Foundation f)
Returns the halftile corner of a halftile-foundation.
Definition: slope_func.h:333
Functions related to dates.
static WaterClass GetWaterClass(TileIndex t)
Get the water class at a tile.
Definition: water_map.h:106
Day day
Day (1..31)
Definition: date_type.h:104
Northwest.
Various explosions.
const byte _slope_to_sprite_offset[32]
landscape slope => sprite
static uint MapLogX()
Logarithm of the map size along the X side.
Definition: map_func.h:51
Used for iterations.
int GetSlopePixelZOutsideMap(int x, int y)
Return world z coordinate of a given point of a tile, also for tiles outside the map (virtual "black"...
Definition: landscape.cpp:357
north and south corner are raised
Definition: slope_type.h:60
static const CommandCost CMD_ERROR
Define a default return value for a failed command.
Definition: command_func.h:23
Data structure describing a sprite.
Definition: spritecache.h:16
Slope tileh
Slope of the tile.
Definition: tile_cmd.h:45
static uint ScaleByMapSize(uint n)
Scales the given value by the map size, where the given value is for a 256 by 256 map...
Definition: map_func.h:122
Types for recording game performance data.
static const uint CUSTOM_SEA_LEVEL_NUMBER_DIFFICULTY
Value for custom sea level in difficulty settings.
Definition: genworld.h:45
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
Definition: saveload.cpp:58
void FixSlopes()
This function takes care of the fact that land in OpenTTD can never differ more than 1 in height...
Definition: heightmap.cpp:388
Create the rivers.
Definition: genworld.h:70
void SetSnowLine(byte table[SNOW_LINE_MONTHS][SNOW_LINE_DAYS])
Set a variable snow line, as loaded from a newgrf file.
Definition: landscape.cpp:625
bool IsSnowLineSet()
Has a snow line table already been loaded.
Definition: landscape.cpp:615
CommandCost CmdClearArea(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Clear a big piece of landscape.
Definition: landscape.cpp:742
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
Not an end-tile, or wrong direction.
Definition: aystar.h:32
static bool IsFoundation(Foundation f)
Tests for FOUNDATION_NONE.
Definition: slope_func.h:287
Generate a newgame from a heightmap.
Definition: genworld.h:31
demolish a tile
Definition: command_type.h:180
Tile description for the &#39;land area information&#39; tool.
Definition: tile_cmd.h:51
DifficultySettings difficulty
settings related to the difficulty
the east corner of the tile is raised
Definition: slope_type.h:52
void OnTick_Companies()
Called every tick for updating some company info.
static const uint SNOW_LINE_MONTHS
Number of months in the snow line table.
Definition: landscape.h:16
static bool IsSteepSlope(Slope s)
Checks if a slope is steep.
Definition: slope_func.h:36
void OnTick_LinkGraph()
Spawn or join a link graph job or compress a link graph if any link graph is due to do so...
static bool FindSpring(TileIndex tile, void *user_data)
Find the spring of a river.
Definition: landscape.cpp:1018
static Corner GetHalftileSlopeCorner(Slope s)
Returns the leveled halftile of a halftile slope.
Definition: slope_func.h:148
Functions related to world/map generation.
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:82
north, west and south corner are raised
Definition: slope_type.h:62
static uint MapLogY()
Logarithm of the map size along the y side.
Definition: map_func.h:62
Construction costs.
Definition: economy_type.h:149
south and west corner are raised
Definition: slope_type.h:56
Common return value for all commands.
Definition: command_type.h:23
static Slope SlopeWithOneCornerRaised(Corner corner)
Returns the slope with a specific corner raised.
Definition: slope_func.h:99
static T max(const T a, const T b)
Returns the maximum of two values.
Definition: math_func.hpp:24
static bool IsInclinedSlope(Slope s)
Tests if a specific slope is an inclined slope.
Definition: slope_func.h:228
static bool IsClearGround(TileIndex t, ClearGround ct)
Set the type of clear tile.
Definition: clear_map.h:71
EffectVehicle * CreateEffectVehicleAbove(int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular location.
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition: tile_map.cpp:100
static Slope GetFoundationPixelSlope(TileIndex tile, int *z)
Get slope of a tile on top of a (possible) foundation If a tile does not have a foundation, the function returns the same as GetTilePixelSlope.
Definition: landscape.h:66
Functions for the Perlin noise enhanced map generator.
a flat tile
Definition: slope_type.h:49
int z
Height.
Definition: tile_cmd.h:47
static const uint TILE_SIZE
Tile size in world coordinates.
Definition: tile_type.h:13
static uint32 RandomRange(uint32 limit)
Pick a random number between 0 and limit - 1, inclusive.
Definition: random_func.hpp:81
This file has the header for AyStar.
void DrawFoundation(TileInfo *ti, Foundation f)
Draw foundation f at tile ti.
Definition: landscape.cpp:470
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Definition: command_type.h:62
static Corner GetHighestSlopeCorner(Slope s)
Returns the highest corner of a slope (one corner raised or a steep slope).
Definition: slope_func.h:126
Various explosions.
north and east corner are raised
Definition: slope_type.h:58
static bool IsInsideBS(const T x, const size_t base, const size_t size)
Checks if a value is between a window started at some base point.
Definition: math_func.hpp:248
company bankrupts, skip money check, skip vehicle on tile check in some cases
Definition: command_type.h:350
Functions related to (drawing on) viewports.
Pseudo random number generator.
static void SetTileHeight(TileIndex tile, uint height)
Sets the height of a tile.
Definition: tile_map.h:57
bool freeform_edges
allow terraforming the tiles at the map edges
GetTileTrackStatusProc * get_tile_track_status_proc
Get available tracks and status of a tile.
Definition: tile_cmd.h:151
Slope GetTileSlope(TileIndex tile, int *h)
Return the slope of a given tile inside the map.
Definition: tile_map.cpp:59
static bool IsValidTile(TileIndex tile)
Checks if a tile is valid.
Definition: tile_map.h:161
static Slope SteepSlope(Corner corner)
Returns a specific steep slope.
Definition: slope_func.h:217
east, north and west corner are raised
Definition: slope_type.h:65
Base for all objects.
AyStar search algorithm struct.
Definition: aystar.h:116
Tile animation!
indicates the slope is steep
Definition: slope_type.h:54
static bool FlowsDown(TileIndex begin, TileIndex end)
Check whether a river at begin could (logically) flow down to end.
Definition: landscape.cpp:1080
uint x
X position of the tile in unit coordinates.
Definition: tile_cmd.h:43
Create the landscape.
Definition: genworld.h:69
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:341
Functions/types related to saving and loading games.
Foundation
Enumeration for Foundations.
Definition: slope_type.h:93
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
Special sprite for the map generator.
Definition: gfx_type.h:298
bool RiverModifyDesertZone(TileIndex tile, void *data)
Callback to create non-desert around a river tile.
Definition: water_cmd.cpp:425
Southeast.
Iterator to iterate over a diagonal area of the map.
TileIndex tile
Tile index.
Definition: tile_cmd.h:46
static uint ApplyPixelFoundationToSlope(Foundation f, Slope *s)
Applies a foundation to a slope.
Definition: landscape.h:129
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:441
The y axis.
A normal unpaused game.
Definition: openttd.h:56
west, south and east corner are raised
Definition: slope_type.h:63
void AddStartNode(AyStarNode *start_node, uint g)
Adds a node from where to start an algorithm.
Definition: aystar.cpp:280
byte min_river_length
the minimum river length
static void CreateRivers()
Actually (try to) create some rivers.
Definition: landscape.cpp:1269
DoCommandFlag
List of flags for a command.
Definition: command_type.h:342
void ClearSnowLine()
Clear the variable snow line table and free the memory.
Definition: landscape.cpp:677
byte snow_line_height
the configured snow line height
Keeps track of removed objects during execution/testruns of commands.
Definition: object_base.h:84
const TileTypeProcs _tile_type_road_procs
Tile callback functions for road tiles.
void DeleteAnimatedTile(TileIndex tile)
Removes the given tile from the animated tile table.
Definition of base types and functions in a cross-platform compatible way.
A path of nodes.
Definition: aystar.h:45
Data structure to convert between Date and triplet (year, month, and day).
Definition: date_type.h:101
#define TILE_ADDXY(tile, x, y)
Adds a given offset to a tile.
Definition: map_func.h:258
void CDECL usererror(const char *s,...)
Error handling for fatal user errors.
Definition: openttd.cpp:92
A number of safeguards to prevent using unsafe methods.
Table used to generate deserts and/or rain forests.
bool CircularTileSearch(TileIndex *tile, uint size, TestTileOnSearchProc proc, void *user_data)
Function performing a search around a center tile and going outward, thus in circle.
Definition: map.cpp:258
Flag for an invalid trackdir.
Definition: track_type.h:89
uint32 clear_limit
Amount of tiles we can (still) clear (times 65536).
Definition: company_base.h:86
Structure describing the height of the snow line each day of the year.
Definition: landscape.h:23
Water tile.
Definition: tile_type.h:47
uint y
Y position of the tile in unit coordinates.
Definition: tile_cmd.h:44
static uint CeilDiv(uint a, uint b)
Computes ceil(a / b) for non-negative a and b.
Definition: math_func.hpp:314
The tile has an along Y-axis inclined foundation.
Definition: slope_type.h:97
static const uint TILE_HEIGHT
Height of a height level in world coordinate AND in pixels in #ZOOM_LVL_BASE.
Definition: tile_type.h:16
don&#39;t allow building on water
Definition: command_type.h:347
void GenerateTerrainPerlin()
The main new land generator using Perlin noise.
Definition: tgp.cpp:981
TerraGenesis Perlin landscape generator.
Definition: genworld.h:21
Base class for tile iterators.
Definition: tilearea_type.h:99
static Slope SlopeWithThreeCornersRaised(Corner corner)
Returns the slope with all except one corner raised.
Definition: slope_func.h:206
byte data[]
Sprite data.
Definition: spritecache.h:21
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:1938
byte lowest_value
Lowest snow line of the year.
Definition: landscape.h:26
Time spent processing other world features.
#define lengthof(x)
Return the length of an fixed size array.
Definition: depend.cpp:40
bit mask containing all &#39;simple&#39; slopes
Definition: slope_type.h:61
static uint TileHash(uint x, uint y)
Calculate a hash value from a tile position.
Definition: tile_map.h:316
static bool IsWaterTile(TileIndex t)
Is it a water tile with plain water?
Definition: water_map.h:184
static T min(const T a, const T b)
Returns the minimum of two values.
Definition: math_func.hpp:40
static void MakeRiver(TileIndex t, uint8 random_bits)
Make a river tile.
Definition: water_map.h:424
PauseMode _pause_mode
The current pause mode.
Definition: gfx.cpp:47
The tile has a steep slope. The lowest corner is raised by a foundation and the upper halftile is lev...
Definition: slope_type.h:101
ClearedObjectArea * FindClearedObject(TileIndex tile)
Find the entry in _cleared_object_areas which occupies a certain tile.
Definition: object_cmd.cpp:449
PathNode * parent
The parent of this item.
Definition: aystar.h:47
Functions to cache sprites in memory.
bool Failed() const
Did this command fail?
Definition: command_type.h:159
Month month
Month (0..11)
Definition: date_type.h:103
Node in the search.
Definition: aystar.h:38
CommandCost CmdLandscapeClear(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const char *text)
Clear a piece of landscape.
Definition: landscape.cpp:692
a steep slope falling to east (from west)
Definition: slope_type.h:66
east and west corner are raised
Definition: slope_type.h:59
void AddSortableSpriteToDraw(SpriteID image, PaletteID pal, int x, int y, int w, int h, int dz, int z, bool transparent, int bb_offset_x, int bb_offset_y, int bb_offset_z, const SubSprite *sub)
Draw a (transparent) sprite at given coordinates with a given bounding box.
Definition: viewport.cpp:659
static Slope RemoveHalftileSlope(Slope s)
Removes a halftile slope from a slope.
Definition: slope_func.h:60
#define return_cmd_error(errcode)
Returns from a function with a specific StringID as error.
Definition: command_func.h:33
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:589
uint16 height
Height of the sprite.
Definition: spritecache.h:17
static T Clamp(const T a, const T min, const T max)
Clamp a value between an interval.
Definition: math_func.hpp:137
TileIndex TileAddWrap(TileIndex tile, int addx, int addy)
This function checks if we add addx/addy to tile, if we do wrap around the edges. ...
Definition: map.cpp:114
uint16 _tick_counter
Ever incrementing (and sometimes wrapping) tick counter for setting off various events.
Definition: date.cpp:28
A pair-construct of a TileIndexDiff.
Definition: map_type.h:57
static Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
byte quantity_sea_lakes
the amount of seas/lakes
Definition: settings_type.h:65
execute the given command
Definition: command_type.h:344
static int GetSlopeMaxPixelZ(Slope s)
Returns the height of the highest corner of a slope relative to TileZ (= minimal height) ...
Definition: slope_func.h:173
Slope GetFoundationSlope(TileIndex tile, int *z)
Get slope of a tile on top of a (possible) foundation If a tile does not have a foundation, the function returns the same as GetTileSlope.
Definition: landscape.cpp:422
byte highest_value
Highest snow line of the year.
Definition: landscape.h:25
uint16 width
Width of the sprite.
Definition: spritecache.h:18
void GetSlopePixelZOnEdge(Slope tileh, DiagDirection edge, int *z1, int *z2)
Determine the Z height of the corners of a specific tile edge.
Definition: landscape.cpp:393
Functions related to companies.
static TileIndex TileVirtXY(uint x, uint y)
Get a tile from the virtual XY-coordinate.
Definition: map_func.h:194
static uint MapSize()
Get the size of the map.
Definition: map_func.h:92
bool _generating_world
Whether we are generating the map or not.
Definition: genworld.cpp:60
Invisible tiles at the SW and SE border.
Definition: tile_type.h:48
Point InverseRemapCoords2(int x, int y, bool clamp_to_map, bool *clamped)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
Definition: landscape.cpp:103
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition: tile_map.cpp:141
Declarations for savegames operations.
Types related to the landscape.
Set of callback functions for performing tile operations of a given tile type.
Definition: tile_cmd.h:145
Functions related to creating heightmaps from files.
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:78
Used for iterations.
Map accessors for &#39;clear&#39; tiles.
uint DistanceManhattan(TileIndex t0, TileIndex t1)
Gets the Manhattan distance between the two given tiles.
Definition: map.cpp:157
Map accessors for void tiles.
static Corner GetRailFoundationCorner(Foundation f)
Returns the track corner of a special rail foundation.
Definition: slope_func.h:356
north and west corner are raised
Definition: slope_type.h:55
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
int Main()
This is the function you call to run AyStar.
Definition: aystar.cpp:245
static void MakeClear(TileIndex t, ClearGround g, uint density)
Make a clear tile.
Definition: clear_map.h:259
The tile has an along X-axis inclined foundation.
Definition: slope_type.h:96
TransportType
Available types of transport.
static uint GB(const T x, const uint8 s, const uint8 n)
Fetch n bits from x, started at bit s.
static bool IsLeveledFoundation(Foundation f)
Tests if the foundation is a leveled foundation.
Definition: slope_func.h:298
static Point InverseRemapCoords(int x, int y)
Map 2D viewport or smallmap coordinate to 3D world or tile coordinate.
Definition: landscape.h:112
Slope
Enumeration for the slope-type.
Definition: slope_type.h:48
static uint River_Hash(uint tile, uint dir)
Simple hash function for river tiles to be used by AyStar.
Definition: landscape.cpp:1151
const TileTypeProcs *const _tile_type_procs[16]
Tile callback functions for each type of tile.
Definition: landscape.cpp:60
static uint MapMaxY()
Gets the maximum Y coordinate within the map, including MP_VOID.
Definition: map_func.h:111
RAII class for measuring multi-step elements of performance.
#define endof(x)
Get the end element of an fixed size array.
Definition: stdafx.h:384
Functions related to OTTD&#39;s landscape.
void OffsetGroundSprite(int x, int y)
Called when a foundation has been drawn for the current tile.
Definition: viewport.cpp:587
Functions related to commands.
char name[MAX_PATH]
Name of the file.
Definition: saveload.h:320
Coordinates of a point in 2D.
byte terrain_type
the mountainousness of the landscape
Definition: settings_type.h:64
a steep slope falling to south (from north)
Definition: slope_type.h:69
Iterator to iterate over a tile area (rectangle) of the map.
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:45
byte GetSnowLine()
Get the current snow line, either variable or static.
Definition: landscape.cpp:644
static uint TileHeight(TileIndex tile)
Returns the height of a tile.
Definition: tile_map.h:29
The tile has a steep slope. The lowest corner is raised by a foundation to allow building railroad on...
Definition: slope_type.h:98
ConstructionSettings construction
construction of things in-game
static const uint SNOW_LINE_DAYS
Number of days in each month in the snow line table.
Definition: landscape.h:17
static bool IsCoastTile(TileIndex t)
Is it a coast tile.
Definition: water_map.h:205
static TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition: map_func.h:179
static const uint RIVER_OFFSET_DESERT_DISTANCE
Circular tile search radius to create non-desert around a river tile.
Definition: water.h:42
static void free(const void *ptr)
Version of the standard free that accepts const pointers.
Definition: depend.cpp:129
int GetSlopeZInCorner(Slope tileh, Corner corner)
Determine the Z height of a corner relative to TileZ.
Definition: landscape.cpp:375
static const uint MAX_MAP_SIZE_BITS
Maximal size of map is equal to 2 ^ MAX_MAP_SIZE_BITS.
Definition: map_type.h:64
static bool FlowRiver(TileIndex spring, TileIndex begin)
Try to flow the river down from a given begin.
Definition: landscape.cpp:1187
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
static bool HasTileWaterClass(TileIndex t)
Checks whether the tile has an waterclass associated.
Definition: water_map.h:95
DiagDirection
Enumeration for diagonal directions.
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:83
Northeast, upper right on your monitor.
void RunTileLoop()
Gradually iterate over all tiles on the map, calling their TileLoopProcs once every 256 ticks...
Definition: landscape.cpp:801
static Slope HalftileSlope(Slope s, Corner corner)
Adds a halftile slope to a slope.
Definition: slope_func.h:274
GameCreationSettings game_creation
settings used during the creation of a game (map)
void Free()
This function frees the memory it allocated.
Definition: aystar.cpp:206
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition: tile_type.h:41
static bool IsInclinedFoundation(Foundation f)
Tests if the foundation is an inclined foundation.
Definition: slope_func.h:309
DetailedFileType detail_ftype
Concrete file type (PNG, BMP, old save, etc).
Definition: saveload.h:318
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:102
void SetGeneratingWorldProgress(GenWorldProgress cls, uint total)
Set the total of a stage of the world generation.
a steep slope falling to west (from east)
Definition: slope_type.h:68
Functions related to water (management)
static bool IsNonContinuousFoundation(Foundation f)
Tests if a foundation is a non-continuous foundation, i.e.
Definition: slope_func.h:320
static bool IsTileOnWater(TileIndex t)
Tests if the tile was built on water.
Definition: water_map.h:130
static TileIndex AddTileIndexDiffCWrap(TileIndex tile, TileIndexDiffC diff)
Add a TileIndexDiffC to a TileIndex and returns the new one.
Definition: map_func.h:300
void GenerateLandscape(byte mode)
Definition: landscape.cpp:1293
void IncreaseGeneratingWorldProgress(GenWorldProgress cls)
Increases the current stage of the world generation with one.
Date _date
Current date in days (day counter)
Definition: date.cpp:26
static bool MakeLake(TileIndex tile, void *user_data)
Make a connected lake; fill all tiles in the circular tile search that are connected.
Definition: landscape.cpp:1054
void ConvertDateToYMD(Date date, YearMonthDay *ymd)
Converts a Date to a Year, Month & Day.
Definition: date.cpp:92
the south corner of the tile is raised
Definition: slope_type.h:51
static SnowLine * _snow_line
Description of the snow line throughout the year.
Definition: landscape.cpp:88
static void BuildRiver(TileIndex begin, TileIndex end)
Actually build the river between the begin and end tiles using AyStar.
Definition: landscape.cpp:1161
static bool IsSpecialRailFoundation(Foundation f)
Tests if a foundation is a special rail foundation for single horizontal/vertical track...
Definition: slope_func.h:345
This file contains all sprite-related enums and defines.
Functions related to effect vehicles.
south, east and north corner are raised
Definition: slope_type.h:64
static TileIndex TileXY(uint x, uint y)
Returns the TileIndex of a coordinate.
Definition: map_func.h:163
static Corner OppositeCorner(Corner corner)
Returns the opposite corner.
Definition: slope_func.h:184
a steep slope falling to north (from south)
Definition: slope_type.h:67
const TileTypeProcs _tile_type_town_procs
Tile callback functions for a town.
static void SetTropicZone(TileIndex tile, TropicZone type)
Set the tropic zone.
Definition: tile_map.h:225
static const uint MIN_MAP_SIZE_BITS
Minimal and maximal map width and height.
Definition: map_type.h:63
byte HighestSnowLine()
Get the highest possible snow line height, either variable or static.
Definition: landscape.cpp:658
Southwest.
An end node was found.
Definition: aystar.h:27
GetTileDescProc * get_tile_desc_proc
Get a description of a tile (for the &#39;land area information&#39; tool)
Definition: tile_cmd.h:150