OpenTTD Source  12.0-beta2
water_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 "cmd_helper.h"
12 #include "landscape.h"
13 #include "viewport_func.h"
14 #include "command_func.h"
15 #include "town.h"
16 #include "news_func.h"
17 #include "depot_base.h"
18 #include "depot_func.h"
19 #include "water.h"
20 #include "industry_map.h"
21 #include "newgrf_canal.h"
22 #include "strings_func.h"
23 #include "vehicle_func.h"
24 #include "sound_func.h"
25 #include "company_func.h"
26 #include "clear_map.h"
27 #include "tree_map.h"
28 #include "aircraft.h"
29 #include "effectvehicle_func.h"
30 #include "tunnelbridge_map.h"
31 #include "station_base.h"
32 #include "ai/ai.hpp"
33 #include "game/game.hpp"
34 #include "core/random_func.hpp"
35 #include "core/backup_type.hpp"
36 #include "date_func.h"
37 #include "company_base.h"
38 #include "company_gui.h"
39 #include "newgrf_generic.h"
40 #include "industry.h"
41 
42 #include "table/strings.h"
43 
44 #include "safeguards.h"
45 
49 static const uint8 _flood_from_dirs[] = {
50  (1 << DIR_NW) | (1 << DIR_SW) | (1 << DIR_SE) | (1 << DIR_NE), // SLOPE_FLAT
51  (1 << DIR_NE) | (1 << DIR_SE), // SLOPE_W
52  (1 << DIR_NW) | (1 << DIR_NE), // SLOPE_S
53  (1 << DIR_NE), // SLOPE_SW
54  (1 << DIR_NW) | (1 << DIR_SW), // SLOPE_E
55  0, // SLOPE_EW
56  (1 << DIR_NW), // SLOPE_SE
57  (1 << DIR_N ) | (1 << DIR_NW) | (1 << DIR_NE), // SLOPE_WSE, SLOPE_STEEP_S
58  (1 << DIR_SW) | (1 << DIR_SE), // SLOPE_N
59  (1 << DIR_SE), // SLOPE_NW
60  0, // SLOPE_NS
61  (1 << DIR_E ) | (1 << DIR_NE) | (1 << DIR_SE), // SLOPE_NWS, SLOPE_STEEP_W
62  (1 << DIR_SW), // SLOPE_NE
63  (1 << DIR_S ) | (1 << DIR_SW) | (1 << DIR_SE), // SLOPE_ENW, SLOPE_STEEP_N
64  (1 << DIR_W ) | (1 << DIR_SW) | (1 << DIR_NW), // SLOPE_SEN, SLOPE_STEEP_E
65 };
66 
73 static inline void MarkTileDirtyIfCanalOrRiver(TileIndex tile)
74 {
75  if (IsValidTile(tile) && IsTileType(tile, MP_WATER) && (IsCanal(tile) || IsRiver(tile))) MarkTileDirtyByTile(tile);
76 }
77 
85 {
86  for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
88  }
89 }
90 
91 
101 CommandCost CmdBuildShipDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const std::string &text)
102 {
103  Axis axis = Extract<Axis, 0, 1>(p1);
104 
105  TileIndex tile2 = tile + (axis == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
106 
107  if (!HasTileWaterGround(tile) || !HasTileWaterGround(tile2)) {
108  return_cmd_error(STR_ERROR_MUST_BE_BUILT_ON_WATER);
109  }
110 
111  if (IsBridgeAbove(tile) || IsBridgeAbove(tile2)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
112 
113  if (!IsTileFlat(tile) || !IsTileFlat(tile2)) {
114  /* Prevent depots on rapids */
115  return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
116  }
117 
118  if (!Depot::CanAllocateItem()) return CMD_ERROR;
119 
120  WaterClass wc1 = GetWaterClass(tile);
121  WaterClass wc2 = GetWaterClass(tile2);
122  CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_DEPOT_SHIP]);
123 
124  bool add_cost = !IsWaterTile(tile);
125  CommandCost ret = DoCommand(tile, 0, 0, flags | DC_AUTO, CMD_LANDSCAPE_CLEAR);
126  if (ret.Failed()) return ret;
127  if (add_cost) {
128  cost.AddCost(ret);
129  }
130  add_cost = !IsWaterTile(tile2);
131  ret = DoCommand(tile2, 0, 0, flags | DC_AUTO, CMD_LANDSCAPE_CLEAR);
132  if (ret.Failed()) return ret;
133  if (add_cost) {
134  cost.AddCost(ret);
135  }
136 
137  if (flags & DC_EXEC) {
138  Depot *depot = new Depot(tile);
139  depot->build_date = _date;
140 
141  if (wc1 == WATER_CLASS_CANAL || wc2 == WATER_CLASS_CANAL) {
142  /* Update infrastructure counts after the unconditional clear earlier. */
143  Company::Get(_current_company)->infrastructure.water += wc1 == WATER_CLASS_CANAL && wc2 == WATER_CLASS_CANAL ? 2 : 1;
144  }
145  Company::Get(_current_company)->infrastructure.water += 2 * LOCK_DEPOT_TILE_FACTOR;
147 
148  MakeShipDepot(tile, _current_company, depot->index, DEPOT_PART_NORTH, axis, wc1);
149  MakeShipDepot(tile2, _current_company, depot->index, DEPOT_PART_SOUTH, axis, wc2);
150  CheckForDockingTile(tile);
151  CheckForDockingTile(tile2);
152  MarkTileDirtyByTile(tile);
153  MarkTileDirtyByTile(tile2);
154  MakeDefaultName(depot);
155  }
156 
157  return cost;
158 }
159 
160 bool IsPossibleDockingTile(TileIndex t)
161 {
162  assert(IsValidTile(t));
163  switch (GetTileType(t)) {
164  case MP_WATER:
165  if (IsLock(t) && GetLockPart(t) == LOCK_PART_MIDDLE) return false;
166  FALLTHROUGH;
167  case MP_RAILWAY:
168  case MP_STATION:
169  case MP_TUNNELBRIDGE:
171 
172  default:
173  return false;
174  }
175 }
176 
183 {
184  for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
185  TileIndex tile = t + TileOffsByDiagDir(d);
186  if (!IsValidTile(tile)) continue;
187 
188  if (IsDockTile(tile) && IsValidDockingDirectionForDock(tile, d)) {
190  SetDockingTile(t, true);
191  }
192  if (IsTileType(tile, MP_INDUSTRY)) {
194  if (st != nullptr) {
195  st->docking_station.Add(t);
196  SetDockingTile(t, true);
197  }
198  }
199  if (IsTileType(tile, MP_STATION) && IsOilRig(tile)) {
201  SetDockingTile(t, true);
202  }
203  }
204 }
205 
206 void MakeWaterKeepingClass(TileIndex tile, Owner o)
207 {
208  WaterClass wc = GetWaterClass(tile);
209 
210  /* Autoslope might turn an originally canal or river tile into land */
211  int z;
212  Slope slope = GetTileSlope(tile, &z);
213 
214  if (slope != SLOPE_FLAT) {
215  if (wc == WATER_CLASS_CANAL) {
216  /* If we clear the canal, we have to remove it from the infrastructure count as well. */
218  if (c != nullptr) {
219  c->infrastructure.water--;
221  }
222  /* Sloped canals are locks and no natural water remains whatever the slope direction */
223  wc = WATER_CLASS_INVALID;
224  }
225 
226  /* Only river water should be restored on appropriate slopes. Other water would be invalid on slopes */
228  wc = WATER_CLASS_INVALID;
229  }
230  }
231 
232  if (wc == WATER_CLASS_SEA && z > 0) {
233  /* Update company infrastructure count. */
235  if (c != nullptr) {
236  c->infrastructure.water++;
238  }
239 
240  wc = WATER_CLASS_CANAL;
241  }
242 
243  /* Zero map array and terminate animation */
244  DoClearSquare(tile);
245 
246  /* Maybe change to water */
247  switch (wc) {
248  case WATER_CLASS_SEA: MakeSea(tile); break;
249  case WATER_CLASS_CANAL: MakeCanal(tile, o, Random()); break;
250  case WATER_CLASS_RIVER: MakeRiver(tile, Random()); break;
251  default: break;
252  }
253 
254  if (wc != WATER_CLASS_INVALID) CheckForDockingTile(tile);
255  MarkTileDirtyByTile(tile);
256 }
257 
258 static CommandCost RemoveShipDepot(TileIndex tile, DoCommandFlag flags)
259 {
260  if (!IsShipDepot(tile)) return CMD_ERROR;
261 
262  CommandCost ret = CheckTileOwnership(tile);
263  if (ret.Failed()) return ret;
264 
265  TileIndex tile2 = GetOtherShipDepotTile(tile);
266 
267  /* do not check for ship on tile when company goes bankrupt */
268  if (!(flags & DC_BANKRUPT)) {
270  if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile2);
271  if (ret.Failed()) return ret;
272  }
273 
274  if (flags & DC_EXEC) {
275  delete Depot::GetByTile(tile);
276 
278  if (c != nullptr) {
281  }
282 
283  MakeWaterKeepingClass(tile, GetTileOwner(tile));
284  MakeWaterKeepingClass(tile2, GetTileOwner(tile2));
285  }
286 
287  return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_DEPOT_SHIP]);
288 }
289 
298 {
300 
301  int delta = TileOffsByDiagDir(dir);
303  if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
304  if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
305  if (ret.Failed()) return ret;
306 
307  /* middle tile */
308  WaterClass wc_middle = HasTileWaterGround(tile) ? GetWaterClass(tile) : WATER_CLASS_CANAL;
309  ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
310  if (ret.Failed()) return ret;
311  cost.AddCost(ret);
312 
313  /* lower tile */
314  if (!IsWaterTile(tile - delta)) {
315  ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
316  if (ret.Failed()) return ret;
317  cost.AddCost(ret);
318  cost.AddCost(_price[PR_BUILD_CANAL]);
319  }
320  if (!IsTileFlat(tile - delta)) {
321  return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
322  }
323  WaterClass wc_lower = IsWaterTile(tile - delta) ? GetWaterClass(tile - delta) : WATER_CLASS_CANAL;
324 
325  /* upper tile */
326  if (!IsWaterTile(tile + delta)) {
327  ret = DoCommand(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
328  if (ret.Failed()) return ret;
329  cost.AddCost(ret);
330  cost.AddCost(_price[PR_BUILD_CANAL]);
331  }
332  if (!IsTileFlat(tile + delta)) {
333  return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
334  }
335  WaterClass wc_upper = IsWaterTile(tile + delta) ? GetWaterClass(tile + delta) : WATER_CLASS_CANAL;
336 
337  if (IsBridgeAbove(tile) || IsBridgeAbove(tile - delta) || IsBridgeAbove(tile + delta)) {
338  return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
339  }
340 
341  if (flags & DC_EXEC) {
342  /* Update company infrastructure counts. */
344  if (c != nullptr) {
345  /* Counts for the water. */
346  if (!IsWaterTile(tile - delta)) c->infrastructure.water++;
347  if (!IsWaterTile(tile + delta)) c->infrastructure.water++;
348  /* Count for the lock itself. */
349  c->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // Lock is three tiles.
351  }
352 
353  MakeLock(tile, _current_company, dir, wc_lower, wc_upper, wc_middle);
354  CheckForDockingTile(tile - delta);
355  CheckForDockingTile(tile + delta);
356  MarkTileDirtyByTile(tile);
357  MarkTileDirtyByTile(tile - delta);
358  MarkTileDirtyByTile(tile + delta);
359  MarkCanalsAndRiversAroundDirty(tile - delta);
360  MarkCanalsAndRiversAroundDirty(tile + delta);
361  }
362  cost.AddCost(_price[PR_BUILD_LOCK]);
363 
364  return cost;
365 }
366 
374 {
375  if (GetTileOwner(tile) != OWNER_NONE) {
376  CommandCost ret = CheckTileOwnership(tile);
377  if (ret.Failed()) return ret;
378  }
379 
381 
382  /* make sure no vehicle is on the tile. */
384  if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
385  if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
386  if (ret.Failed()) return ret;
387 
388  if (flags & DC_EXEC) {
389  /* Remove middle part from company infrastructure count. */
391  if (c != nullptr) {
392  c->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // three parts of the lock.
394  }
395 
396  if (GetWaterClass(tile) == WATER_CLASS_RIVER) {
397  MakeRiver(tile, Random());
398  } else {
399  DoClearSquare(tile);
400  }
401  MakeWaterKeepingClass(tile + delta, GetTileOwner(tile + delta));
402  MakeWaterKeepingClass(tile - delta, GetTileOwner(tile - delta));
404  MarkCanalsAndRiversAroundDirty(tile - delta);
405  MarkCanalsAndRiversAroundDirty(tile + delta);
406  }
407 
408  return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_LOCK]);
409 }
410 
420 CommandCost CmdBuildLock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const std::string &text)
421 {
423  if (dir == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
424 
425  return DoBuildLock(tile, dir, flags);
426 }
427 
430 {
432  return false;
433 }
434 
446 CommandCost CmdBuildCanal(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const std::string &text)
447 {
448  WaterClass wc = Extract<WaterClass, 0, 2>(p2);
449  if (p1 >= MapSize() || wc == WATER_CLASS_INVALID) return CMD_ERROR;
450 
451  /* Outside of the editor you can only build canals, not oceans */
452  if (wc != WATER_CLASS_CANAL && _game_mode != GM_EDITOR) return CMD_ERROR;
453 
454  /* Outside the editor you can only drag canals, and not areas */
455  if (_game_mode != GM_EDITOR) {
456  TileArea ta(tile, p1);
457  if (ta.w != 1 && ta.h != 1) return CMD_ERROR;
458  }
459 
461 
462  std::unique_ptr<TileIterator> iter;
463  if (HasBit(p2, 2)) {
464  iter = std::make_unique<DiagonalTileIterator>(tile, p1);
465  } else {
466  iter = std::make_unique<OrthogonalTileIterator>(tile, p1);
467  }
468 
469  for (; *iter != INVALID_TILE; ++(*iter)) {
470  TileIndex current_tile = *iter;
471  CommandCost ret;
472 
473  Slope slope = GetTileSlope(current_tile);
474  if (slope != SLOPE_FLAT && (wc != WATER_CLASS_RIVER || !IsInclinedSlope(slope))) {
475  return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
476  }
477 
478  /* can't make water of water! */
479  if (IsTileType(current_tile, MP_WATER) && (!IsTileOwner(current_tile, OWNER_WATER) || wc == WATER_CLASS_SEA)) continue;
480 
481  bool water = IsWaterTile(current_tile);
482  ret = DoCommand(current_tile, 0, 0, flags | DC_FORCE_CLEAR_TILE, CMD_LANDSCAPE_CLEAR);
483  if (ret.Failed()) return ret;
484 
485  if (!water) cost.AddCost(ret);
486 
487  if (flags & DC_EXEC) {
488  switch (wc) {
489  case WATER_CLASS_RIVER:
490  MakeRiver(current_tile, Random());
491  if (_game_mode == GM_EDITOR) {
492  TileIndex tile2 = current_tile;
494  }
495  break;
496 
497  case WATER_CLASS_SEA:
498  if (TileHeight(current_tile) == 0) {
499  MakeSea(current_tile);
500  break;
501  }
502  FALLTHROUGH;
503 
504  default:
505  MakeCanal(current_tile, _current_company, Random());
507  Company::Get(_current_company)->infrastructure.water++;
509  }
510  break;
511  }
512  MarkTileDirtyByTile(current_tile);
513  MarkCanalsAndRiversAroundDirty(current_tile);
514  CheckForDockingTile(current_tile);
515  }
516 
517  cost.AddCost(_price[PR_BUILD_CANAL]);
518  }
519 
520  if (cost.GetCost() == 0) {
521  return_cmd_error(STR_ERROR_ALREADY_BUILT);
522  } else {
523  return cost;
524  }
525 }
526 
527 static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlag flags)
528 {
529  switch (GetWaterTileType(tile)) {
530  case WATER_TILE_CLEAR: {
531  if (flags & DC_NO_WATER) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);
532 
533  Money base_cost = IsCanal(tile) ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER];
534  /* Make sure freeform edges are allowed or it's not an edge tile. */
535  if (!_settings_game.construction.freeform_edges && (!IsInsideMM(TileX(tile), 1, MapMaxX() - 1) ||
536  !IsInsideMM(TileY(tile), 1, MapMaxY() - 1))) {
537  return_cmd_error(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP);
538  }
539 
540  /* Make sure no vehicle is on the tile */
542  if (ret.Failed()) return ret;
543 
544  Owner owner = GetTileOwner(tile);
545  if (owner != OWNER_WATER && owner != OWNER_NONE) {
546  CommandCost ret = CheckTileOwnership(tile);
547  if (ret.Failed()) return ret;
548  }
549 
550  if (flags & DC_EXEC) {
551  if (IsCanal(tile) && Company::IsValidID(owner)) {
552  Company::Get(owner)->infrastructure.water--;
554  }
555  bool remove = IsDockingTile(tile);
556  DoClearSquare(tile);
558  if (remove) RemoveDockingTile(tile);
559  }
560 
561  return CommandCost(EXPENSES_CONSTRUCTION, base_cost);
562  }
563 
564  case WATER_TILE_COAST: {
565  Slope slope = GetTileSlope(tile);
566 
567  /* Make sure no vehicle is on the tile */
569  if (ret.Failed()) return ret;
570 
571  if (flags & DC_EXEC) {
572  bool remove = IsDockingTile(tile);
573  DoClearSquare(tile);
575  if (remove) RemoveDockingTile(tile);
576  }
577  if (IsSlopeWithOneCornerRaised(slope)) {
578  return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_WATER]);
579  } else {
580  return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_ROUGH]);
581  }
582  }
583 
584  case WATER_TILE_LOCK: {
585  static const TileIndexDiffC _lock_tomiddle_offs[][DIAGDIR_END] = {
586  /* NE SE SW NW */
587  { { 0, 0}, {0, 0}, { 0, 0}, {0, 0} }, // LOCK_PART_MIDDLE
588  { {-1, 0}, {0, 1}, { 1, 0}, {0, -1} }, // LOCK_PART_LOWER
589  { { 1, 0}, {0, -1}, {-1, 0}, {0, 1} }, // LOCK_PART_UPPER
590  };
591 
592  if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
593  if (_current_company == OWNER_WATER) return CMD_ERROR;
594  /* move to the middle tile.. */
595  return RemoveLock(tile + ToTileIndexDiff(_lock_tomiddle_offs[GetLockPart(tile)][GetLockDirection(tile)]), flags);
596  }
597 
598  case WATER_TILE_DEPOT:
599  if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
600  return RemoveShipDepot(tile, flags);
601 
602  default:
603  NOT_REACHED();
604  }
605 }
606 
616 {
617  switch (GetTileType(tile)) {
618  case MP_WATER:
619  switch (GetWaterTileType(tile)) {
620  default: NOT_REACHED();
621  case WATER_TILE_DEPOT: case WATER_TILE_CLEAR: return true;
623 
624  case WATER_TILE_COAST:
625  switch (GetTileSlope(tile)) {
626  case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
627  case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
628  case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
629  case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);
630  default: return false;
631  }
632  }
633 
634  case MP_RAILWAY:
635  if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
636  assert(IsPlainRail(tile));
637  switch (GetTileSlope(tile)) {
638  case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
639  case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
640  case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
641  case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);
642  default: return false;
643  }
644  }
645  return false;
646 
647  case MP_STATION:
648  if (IsOilRig(tile)) {
649  /* Do not draw waterborders inside of industries.
650  * Note: There is no easy way to detect the industry of an oilrig tile. */
651  TileIndex src_tile = tile + TileOffsByDir(from);
652  if ((IsTileType(src_tile, MP_STATION) && IsOilRig(src_tile)) ||
653  (IsTileType(src_tile, MP_INDUSTRY))) return true;
654 
655  return IsTileOnWater(tile);
656  }
657  return (IsDock(tile) && IsTileFlat(tile)) || IsBuoy(tile);
658 
659  case MP_INDUSTRY: {
660  /* Do not draw waterborders inside of industries.
661  * Note: There is no easy way to detect the industry of an oilrig tile. */
662  TileIndex src_tile = tile + TileOffsByDir(from);
663  if ((IsTileType(src_tile, MP_STATION) && IsOilRig(src_tile)) ||
664  (IsTileType(src_tile, MP_INDUSTRY) && GetIndustryIndex(src_tile) == GetIndustryIndex(tile))) return true;
665 
666  return IsTileOnWater(tile);
667  }
668 
669  case MP_OBJECT: return IsTileOnWater(tile);
670 
672 
673  case MP_VOID: return true; // consider map border as water, esp. for rivers
674 
675  default: return false;
676  }
677 }
678 
686 static void DrawWaterSprite(SpriteID base, uint offset, CanalFeature feature, TileIndex tile)
687 {
688  if (base != SPR_FLAT_WATER_TILE) {
689  /* Only call offset callback if the sprite is NewGRF-provided. */
690  offset = GetCanalSpriteOffset(feature, tile, offset);
691  }
692  DrawGroundSprite(base + offset, PAL_NONE);
693 }
694 
701 static void DrawWaterEdges(bool canal, uint offset, TileIndex tile)
702 {
703  CanalFeature feature;
704  SpriteID base = 0;
705  if (canal) {
706  feature = CF_DIKES;
707  base = GetCanalSprite(CF_DIKES, tile);
708  if (base == 0) base = SPR_CANAL_DIKES_BASE;
709  } else {
710  feature = CF_RIVER_EDGE;
711  base = GetCanalSprite(CF_RIVER_EDGE, tile);
712  if (base == 0) return; // Don't draw if no sprites provided.
713  }
714 
715  uint wa;
716 
717  /* determine the edges around with water. */
718  wa = IsWateredTile(TILE_ADDXY(tile, -1, 0), DIR_SW) << 0;
719  wa += IsWateredTile(TILE_ADDXY(tile, 0, 1), DIR_NW) << 1;
720  wa += IsWateredTile(TILE_ADDXY(tile, 1, 0), DIR_NE) << 2;
721  wa += IsWateredTile(TILE_ADDXY(tile, 0, -1), DIR_SE) << 3;
722 
723  if (!(wa & 1)) DrawWaterSprite(base, offset, feature, tile);
724  if (!(wa & 2)) DrawWaterSprite(base, offset + 1, feature, tile);
725  if (!(wa & 4)) DrawWaterSprite(base, offset + 2, feature, tile);
726  if (!(wa & 8)) DrawWaterSprite(base, offset + 3, feature, tile);
727 
728  /* right corner */
729  switch (wa & 0x03) {
730  case 0: DrawWaterSprite(base, offset + 4, feature, tile); break;
731  case 3: if (!IsWateredTile(TILE_ADDXY(tile, -1, 1), DIR_W)) DrawWaterSprite(base, offset + 8, feature, tile); break;
732  }
733 
734  /* bottom corner */
735  switch (wa & 0x06) {
736  case 0: DrawWaterSprite(base, offset + 5, feature, tile); break;
737  case 6: if (!IsWateredTile(TILE_ADDXY(tile, 1, 1), DIR_N)) DrawWaterSprite(base, offset + 9, feature, tile); break;
738  }
739 
740  /* left corner */
741  switch (wa & 0x0C) {
742  case 0: DrawWaterSprite(base, offset + 6, feature, tile); break;
743  case 12: if (!IsWateredTile(TILE_ADDXY(tile, 1, -1), DIR_E)) DrawWaterSprite(base, offset + 10, feature, tile); break;
744  }
745 
746  /* upper corner */
747  switch (wa & 0x09) {
748  case 0: DrawWaterSprite(base, offset + 7, feature, tile); break;
749  case 9: if (!IsWateredTile(TILE_ADDXY(tile, -1, -1), DIR_S)) DrawWaterSprite(base, offset + 11, feature, tile); break;
750  }
751 }
752 
754 static void DrawSeaWater(TileIndex tile)
755 {
756  DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
757 }
758 
760 static void DrawCanalWater(TileIndex tile)
761 {
762  SpriteID image = SPR_FLAT_WATER_TILE;
763  if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
764  /* First water slope sprite is flat water. */
765  image = GetCanalSprite(CF_WATERSLOPE, tile);
766  if (image == 0) image = SPR_FLAT_WATER_TILE;
767  }
768  DrawWaterSprite(image, 0, CF_WATERSLOPE, tile);
769 
770  DrawWaterEdges(true, 0, tile);
771 }
772 
773 #include "table/water_land.h"
774 
784 static void DrawWaterTileStruct(const TileInfo *ti, const DrawTileSeqStruct *dtss, SpriteID base, uint offset, PaletteID palette, CanalFeature feature)
785 {
786  /* Don't draw if buildings are invisible. */
787  if (IsInvisibilitySet(TO_BUILDINGS)) return;
788 
789  for (; !dtss->IsTerminator(); dtss++) {
790  uint tile_offs = offset + dtss->image.sprite;
791  if (feature < CF_END) tile_offs = GetCanalSpriteOffset(feature, ti->tile, tile_offs);
792  AddSortableSpriteToDraw(base + tile_offs, palette,
793  ti->x + dtss->delta_x, ti->y + dtss->delta_y,
794  dtss->size_x, dtss->size_y,
795  dtss->size_z, ti->z + dtss->delta_z,
797  }
798 }
799 
801 static void DrawWaterLock(const TileInfo *ti)
802 {
803  int part = GetLockPart(ti->tile);
804  const DrawTileSprites &dts = _lock_display_data[part][GetLockDirection(ti->tile)];
805 
806  /* Draw ground sprite. */
807  SpriteID image = dts.ground.sprite;
808 
809  SpriteID water_base = GetCanalSprite(CF_WATERSLOPE, ti->tile);
810  if (water_base == 0) {
811  /* Use default sprites. */
812  water_base = SPR_CANALS_BASE;
813  } else if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
814  /* NewGRF supplies a flat sprite as first sprite. */
815  if (image == SPR_FLAT_WATER_TILE) {
816  image = water_base;
817  } else {
818  image++;
819  }
820  }
821 
822  if (image < 5) image += water_base;
823  DrawGroundSprite(image, PAL_NONE);
824 
825  /* Draw structures. */
826  uint zoffs = 0;
827  SpriteID base = GetCanalSprite(CF_LOCKS, ti->tile);
828 
829  if (base == 0) {
830  /* If no custom graphics, use defaults. */
831  base = SPR_LOCK_BASE;
832  uint8 z_threshold = part == LOCK_PART_UPPER ? 8 : 0;
833  zoffs = ti->z > z_threshold ? 24 : 0;
834  }
835 
836  DrawWaterTileStruct(ti, dts.seq, base, zoffs, PAL_NONE, CF_LOCKS);
837 }
838 
840 static void DrawWaterDepot(const TileInfo *ti)
841 {
842  DrawWaterClassGround(ti);
843  DrawWaterTileStruct(ti, _shipdepot_display_data[GetShipDepotAxis(ti->tile)][GetShipDepotPart(ti->tile)].seq, 0, 0, COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile)), CF_END);
844 }
845 
846 static void DrawRiverWater(const TileInfo *ti)
847 {
848  SpriteID image = SPR_FLAT_WATER_TILE;
849  uint offset = 0;
850  uint edges_offset = 0;
851 
852  if (ti->tileh != SLOPE_FLAT || HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
853  image = GetCanalSprite(CF_RIVER_SLOPE, ti->tile);
854  if (image == 0) {
855  switch (ti->tileh) {
856  case SLOPE_NW: image = SPR_WATER_SLOPE_Y_DOWN; break;
857  case SLOPE_SW: image = SPR_WATER_SLOPE_X_UP; break;
858  case SLOPE_SE: image = SPR_WATER_SLOPE_Y_UP; break;
859  case SLOPE_NE: image = SPR_WATER_SLOPE_X_DOWN; break;
860  default: image = SPR_FLAT_WATER_TILE; break;
861  }
862  } else {
863  /* Flag bit 0 indicates that the first sprite is flat water. */
864  offset = HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE) ? 1 : 0;
865 
866  switch (ti->tileh) {
867  case SLOPE_SE: edges_offset += 12; break;
868  case SLOPE_NE: offset += 1; edges_offset += 24; break;
869  case SLOPE_SW: offset += 2; edges_offset += 36; break;
870  case SLOPE_NW: offset += 3; edges_offset += 48; break;
871  default: offset = 0; break;
872  }
873 
874  offset = GetCanalSpriteOffset(CF_RIVER_SLOPE, ti->tile, offset);
875  }
876  }
877 
878  DrawGroundSprite(image + offset, PAL_NONE);
879 
880  /* Draw river edges if available. */
881  DrawWaterEdges(false, edges_offset, ti->tile);
882 }
883 
884 void DrawShoreTile(Slope tileh)
885 {
886  /* Converts the enum Slope into an offset based on SPR_SHORE_BASE.
887  * This allows to calculate the proper sprite to display for this Slope */
888  static const byte tileh_to_shoresprite[32] = {
889  0, 1, 2, 3, 4, 16, 6, 7, 8, 9, 17, 11, 12, 13, 14, 0,
890  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 10, 15, 0,
891  };
892 
893  assert(!IsHalftileSlope(tileh)); // Halftile slopes need to get handled earlier.
894  assert(tileh != SLOPE_FLAT); // Shore is never flat
895 
896  assert((tileh != SLOPE_EW) && (tileh != SLOPE_NS)); // No suitable sprites for current flooding behaviour
897 
898  DrawGroundSprite(SPR_SHORE_BASE + tileh_to_shoresprite[tileh], PAL_NONE);
899 }
900 
901 void DrawWaterClassGround(const TileInfo *ti)
902 {
903  switch (GetWaterClass(ti->tile)) {
904  case WATER_CLASS_SEA: DrawSeaWater(ti->tile); break;
905  case WATER_CLASS_CANAL: DrawCanalWater(ti->tile); break;
906  case WATER_CLASS_RIVER: DrawRiverWater(ti); break;
907  default: NOT_REACHED();
908  }
909 }
910 
911 static void DrawTile_Water(TileInfo *ti)
912 {
913  switch (GetWaterTileType(ti->tile)) {
914  case WATER_TILE_CLEAR:
915  DrawWaterClassGround(ti);
916  DrawBridgeMiddle(ti);
917  break;
918 
919  case WATER_TILE_COAST: {
920  DrawShoreTile(ti->tileh);
921  DrawBridgeMiddle(ti);
922  break;
923  }
924 
925  case WATER_TILE_LOCK:
926  DrawWaterLock(ti);
927  break;
928 
929  case WATER_TILE_DEPOT:
930  DrawWaterDepot(ti);
931  break;
932  }
933 }
934 
935 void DrawShipDepotSprite(int x, int y, Axis axis, DepotPart part)
936 {
937  const DrawTileSprites &dts = _shipdepot_display_data[axis][part];
938 
939  DrawSprite(dts.ground.sprite, dts.ground.pal, x, y);
940  DrawOrigTileSeqInGUI(x, y, &dts, COMPANY_SPRITE_COLOUR(_local_company));
941 }
942 
943 
944 static int GetSlopePixelZ_Water(TileIndex tile, uint x, uint y)
945 {
946  int z;
947  Slope tileh = GetTilePixelSlope(tile, &z);
948 
949  return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
950 }
951 
952 static Foundation GetFoundation_Water(TileIndex tile, Slope tileh)
953 {
954  return FOUNDATION_NONE;
955 }
956 
957 static void GetTileDesc_Water(TileIndex tile, TileDesc *td)
958 {
959  switch (GetWaterTileType(tile)) {
960  case WATER_TILE_CLEAR:
961  switch (GetWaterClass(tile)) {
962  case WATER_CLASS_SEA: td->str = STR_LAI_WATER_DESCRIPTION_WATER; break;
963  case WATER_CLASS_CANAL: td->str = STR_LAI_WATER_DESCRIPTION_CANAL; break;
964  case WATER_CLASS_RIVER: td->str = STR_LAI_WATER_DESCRIPTION_RIVER; break;
965  default: NOT_REACHED();
966  }
967  break;
968  case WATER_TILE_COAST: td->str = STR_LAI_WATER_DESCRIPTION_COAST_OR_RIVERBANK; break;
969  case WATER_TILE_LOCK : td->str = STR_LAI_WATER_DESCRIPTION_LOCK; break;
970  case WATER_TILE_DEPOT:
971  td->str = STR_LAI_WATER_DESCRIPTION_SHIP_DEPOT;
972  td->build_date = Depot::GetByTile(tile)->build_date;
973  break;
974  default: NOT_REACHED();
975  }
976 
977  td->owner[0] = GetTileOwner(tile);
978 }
979 
985 static void FloodVehicle(Vehicle *v)
986 {
987  uint pass = v->Crash(true);
988 
989  AI::NewEvent(v->owner, new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_FLOODED));
990  Game::NewEvent(new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_FLOODED));
991  SetDParam(0, pass);
992  AddTileNewsItem(STR_NEWS_DISASTER_FLOOD_VEHICLE, NT_ACCIDENT, v->tile);
994  if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
995 }
996 
1003 static Vehicle *FloodVehicleProc(Vehicle *v, void *data)
1004 {
1005  if ((v->vehstatus & VS_CRASHED) != 0) return nullptr;
1006 
1007  switch (v->type) {
1008  default: break;
1009 
1010  case VEH_AIRCRAFT: {
1011  if (!IsAirportTile(v->tile) || GetTileMaxZ(v->tile) != 0) break;
1012  if (v->subtype == AIR_SHADOW) break;
1013 
1014  /* We compare v->z_pos against delta_z + 1 because the shadow
1015  * is at delta_z and the actual aircraft at delta_z + 1. */
1016  const Station *st = Station::GetByTile(v->tile);
1017  const AirportFTAClass *airport = st->airport.GetFTA();
1018  if (v->z_pos != airport->delta_z + 1) break;
1019 
1020  FloodVehicle(v);
1021  break;
1022  }
1023 
1024  case VEH_TRAIN:
1025  case VEH_ROAD: {
1026  int z = *(int*)data;
1027  if (v->z_pos > z) break;
1028  FloodVehicle(v->First());
1029  break;
1030  }
1031  }
1032 
1033  return nullptr;
1034 }
1035 
1041 static void FloodVehicles(TileIndex tile)
1042 {
1043  int z = 0;
1044 
1045  if (IsAirportTile(tile)) {
1046  const Station *st = Station::GetByTile(tile);
1047  for (TileIndex airport_tile : st->airport) {
1048  if (st->TileBelongsToAirport(airport_tile)) FindVehicleOnPos(airport_tile, &z, &FloodVehicleProc);
1049  }
1050 
1051  /* No vehicle could be flooded on this airport anymore */
1052  return;
1053  }
1054 
1055  if (!IsBridgeTile(tile)) {
1056  FindVehicleOnPos(tile, &z, &FloodVehicleProc);
1057  return;
1058  }
1059 
1060  TileIndex end = GetOtherBridgeEnd(tile);
1061  z = GetBridgePixelHeight(tile);
1062 
1063  FindVehicleOnPos(tile, &z, &FloodVehicleProc);
1065 }
1066 
1073 {
1074  /* FLOOD_ACTIVE: 'single-corner-raised'-coast, sea, sea-shipdepots, sea-buoys, sea-docks (water part), rail with flooded halftile, sea-water-industries, sea-oilrigs
1075  * FLOOD_DRYUP: coast with more than one corner raised, coast with rail-track, coast with trees
1076  * FLOOD_PASSIVE: (not used)
1077  * FLOOD_NONE: canals, rivers, everything else
1078  */
1079  switch (GetTileType(tile)) {
1080  case MP_WATER:
1081  if (IsCoast(tile)) {
1082  Slope tileh = GetTileSlope(tile);
1084  }
1085  FALLTHROUGH;
1086  case MP_STATION:
1087  case MP_INDUSTRY:
1088  case MP_OBJECT:
1089  return (GetWaterClass(tile) == WATER_CLASS_SEA) ? FLOOD_ACTIVE : FLOOD_NONE;
1090 
1091  case MP_RAILWAY:
1092  if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
1094  }
1095  return FLOOD_NONE;
1096 
1097  case MP_TREES:
1098  return (GetTreeGround(tile) == TREE_GROUND_SHORE ? FLOOD_DRYUP : FLOOD_NONE);
1099 
1100  default:
1101  return FLOOD_NONE;
1102  }
1103 }
1104 
1109 {
1110  assert(!IsTileType(target, MP_WATER));
1111 
1112  bool flooded = false; // Will be set to true if something is changed.
1113 
1114  Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
1115 
1116  Slope tileh = GetTileSlope(target);
1117  if (tileh != SLOPE_FLAT) {
1118  /* make coast.. */
1119  switch (GetTileType(target)) {
1120  case MP_RAILWAY: {
1121  if (!IsPlainRail(target)) break;
1122  FloodVehicles(target);
1123  flooded = FloodHalftile(target);
1124  break;
1125  }
1126 
1127  case MP_TREES:
1128  if (!IsSlopeWithOneCornerRaised(tileh)) {
1130  MarkTileDirtyByTile(target);
1131  flooded = true;
1132  break;
1133  }
1134  FALLTHROUGH;
1135 
1136  case MP_CLEAR:
1137  if (DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
1138  MakeShore(target);
1139  MarkTileDirtyByTile(target);
1140  flooded = true;
1141  }
1142  break;
1143 
1144  default:
1145  break;
1146  }
1147  } else {
1148  /* Flood vehicles */
1149  FloodVehicles(target);
1150 
1151  /* flood flat tile */
1152  if (DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
1153  MakeSea(target);
1154  MarkTileDirtyByTile(target);
1155  flooded = true;
1156  }
1157  }
1158 
1159  if (flooded) {
1160  /* Mark surrounding canal tiles dirty too to avoid glitches */
1162 
1163  /* update signals if needed */
1165 
1166  if (IsPossibleDockingTile(target)) CheckForDockingTile(target);
1167  }
1168 
1169  cur_company.Restore();
1170 }
1171 
1175 static void DoDryUp(TileIndex tile)
1176 {
1177  Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
1178 
1179  switch (GetTileType(tile)) {
1180  case MP_RAILWAY:
1181  assert(IsPlainRail(tile));
1182  assert(GetRailGroundType(tile) == RAIL_GROUND_WATER);
1183 
1184  RailGroundType new_ground;
1185  switch (GetTrackBits(tile)) {
1186  case TRACK_BIT_UPPER: new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
1187  case TRACK_BIT_LOWER: new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
1188  case TRACK_BIT_LEFT: new_ground = RAIL_GROUND_FENCE_VERT1; break;
1189  case TRACK_BIT_RIGHT: new_ground = RAIL_GROUND_FENCE_VERT2; break;
1190  default: NOT_REACHED();
1191  }
1192  SetRailGroundType(tile, new_ground);
1193  MarkTileDirtyByTile(tile);
1194  break;
1195 
1196  case MP_TREES:
1198  MarkTileDirtyByTile(tile);
1199  break;
1200 
1201  case MP_WATER:
1202  assert(IsCoast(tile));
1203 
1204  if (DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
1205  MakeClear(tile, CLEAR_GRASS, 3);
1206  MarkTileDirtyByTile(tile);
1207  }
1208  break;
1209 
1210  default: NOT_REACHED();
1211  }
1212 
1213  cur_company.Restore();
1214 }
1215 
1223 {
1224  if (IsTileType(tile, MP_WATER)) AmbientSoundEffect(tile);
1225 
1226  switch (GetFloodingBehaviour(tile)) {
1227  case FLOOD_ACTIVE:
1228  for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
1229  TileIndex dest = tile + TileOffsByDir(dir);
1230  if (!IsValidTile(dest)) continue;
1231  /* do not try to flood water tiles - increases performance a lot */
1232  if (IsTileType(dest, MP_WATER)) continue;
1233 
1234  /* TREE_GROUND_SHORE is the sign of a previous flood. */
1235  if (IsTileType(dest, MP_TREES) && GetTreeGround(dest) == TREE_GROUND_SHORE) continue;
1236 
1237  int z_dest;
1238  Slope slope_dest = GetFoundationSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
1239  if (z_dest > 0) continue;
1240 
1241  if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue;
1242 
1243  DoFloodTile(dest);
1244  }
1245  break;
1246 
1247  case FLOOD_DRYUP: {
1248  Slope slope_here = GetFoundationSlope(tile) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
1249  for (uint dir : SetBitIterator(_flood_from_dirs[slope_here])) {
1250  TileIndex dest = tile + TileOffsByDir((Direction)dir);
1251  if (!IsValidTile(dest)) continue;
1252 
1253  FloodingBehaviour dest_behaviour = GetFloodingBehaviour(dest);
1254  if ((dest_behaviour == FLOOD_ACTIVE) || (dest_behaviour == FLOOD_PASSIVE)) return;
1255  }
1256  DoDryUp(tile);
1257  break;
1258  }
1259 
1260  default: return;
1261  }
1262 }
1263 
1264 void ConvertGroundTilesIntoWaterTiles()
1265 {
1266  int z;
1267 
1268  for (TileIndex tile = 0; tile < MapSize(); ++tile) {
1269  Slope slope = GetTileSlope(tile, &z);
1270  if (IsTileType(tile, MP_CLEAR) && z == 0) {
1271  /* Make both water for tiles at level 0
1272  * and make shore, as that looks much better
1273  * during the generation. */
1274  switch (slope) {
1275  case SLOPE_FLAT:
1276  MakeSea(tile);
1277  break;
1278 
1279  case SLOPE_N:
1280  case SLOPE_E:
1281  case SLOPE_S:
1282  case SLOPE_W:
1283  MakeShore(tile);
1284  break;
1285 
1286  default:
1287  for (uint dir : SetBitIterator(_flood_from_dirs[slope & ~SLOPE_STEEP])) {
1288  TileIndex dest = TileAddByDir(tile, (Direction)dir);
1289  Slope slope_dest = GetTileSlope(dest) & ~SLOPE_STEEP;
1290  if (slope_dest == SLOPE_FLAT || IsSlopeWithOneCornerRaised(slope_dest)) {
1291  MakeShore(tile);
1292  break;
1293  }
1294  }
1295  break;
1296  }
1297  }
1298  }
1299 }
1300 
1301 static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
1302 {
1305 
1306  TrackBits ts;
1307 
1308  if (mode != TRANSPORT_WATER) return 0;
1309 
1310  switch (GetWaterTileType(tile)) {
1311  case WATER_TILE_CLEAR: ts = IsTileFlat(tile) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break;
1312  case WATER_TILE_COAST: ts = coast_tracks[GetTileSlope(tile) & 0xF]; break;
1313  case WATER_TILE_LOCK: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break;
1314  case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
1315  default: return 0;
1316  }
1317  if (TileX(tile) == 0) {
1318  /* NE border: remove tracks that connects NE tile edge */
1320  }
1321  if (TileY(tile) == 0) {
1322  /* NW border: remove tracks that connects NW tile edge */
1324  }
1326 }
1327 
1328 static bool ClickTile_Water(TileIndex tile)
1329 {
1330  if (GetWaterTileType(tile) == WATER_TILE_DEPOT) {
1332  return true;
1333  }
1334  return false;
1335 }
1336 
1337 static void ChangeTileOwner_Water(TileIndex tile, Owner old_owner, Owner new_owner)
1338 {
1339  if (!IsTileOwner(tile, old_owner)) return;
1340 
1341  bool is_lock_middle = IsLock(tile) && GetLockPart(tile) == LOCK_PART_MIDDLE;
1342 
1343  /* No need to dirty company windows here, we'll redraw the whole screen anyway. */
1344  if (is_lock_middle) Company::Get(old_owner)->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
1345  if (new_owner != INVALID_OWNER) {
1346  if (is_lock_middle) Company::Get(new_owner)->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
1347  /* Only subtract from the old owner here if the new owner is valid,
1348  * otherwise we clear ship depots and canal water below. */
1349  if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) {
1350  Company::Get(old_owner)->infrastructure.water--;
1351  Company::Get(new_owner)->infrastructure.water++;
1352  }
1353  if (IsShipDepot(tile)) {
1354  Company::Get(old_owner)->infrastructure.water -= LOCK_DEPOT_TILE_FACTOR;
1355  Company::Get(new_owner)->infrastructure.water += LOCK_DEPOT_TILE_FACTOR;
1356  }
1357 
1358  SetTileOwner(tile, new_owner);
1359  return;
1360  }
1361 
1362  /* Remove depot */
1363  if (IsShipDepot(tile)) DoCommand(tile, 0, 0, DC_EXEC | DC_BANKRUPT, CMD_LANDSCAPE_CLEAR);
1364 
1365  /* Set owner of canals and locks ... and also canal under dock there was before.
1366  * Check if the new owner after removing depot isn't OWNER_WATER. */
1367  if (IsTileOwner(tile, old_owner)) {
1368  if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) Company::Get(old_owner)->infrastructure.water--;
1369  SetTileOwner(tile, OWNER_NONE);
1370  }
1371 }
1372 
1373 static VehicleEnterTileStatus VehicleEnter_Water(Vehicle *v, TileIndex tile, int x, int y)
1374 {
1375  return VETSB_CONTINUE;
1376 }
1377 
1378 static CommandCost TerraformTile_Water(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
1379 {
1380  /* Canals can't be terraformed */
1381  if (IsWaterTile(tile) && IsCanal(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);
1382 
1383  return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
1384 }
1385 
1386 
1387 extern const TileTypeProcs _tile_type_water_procs = {
1388  DrawTile_Water, // draw_tile_proc
1389  GetSlopePixelZ_Water, // get_slope_z_proc
1390  ClearTile_Water, // clear_tile_proc
1391  nullptr, // add_accepted_cargo_proc
1392  GetTileDesc_Water, // get_tile_desc_proc
1393  GetTileTrackStatus_Water, // get_tile_track_status_proc
1394  ClickTile_Water, // click_tile_proc
1395  nullptr, // animate_tile_proc
1396  TileLoop_Water, // tile_loop_proc
1397  ChangeTileOwner_Water, // change_tile_owner_proc
1398  nullptr, // add_produced_cargo_proc
1399  VehicleEnter_Water, // vehicle_enter_tile_proc
1400  GetFoundation_Water, // get_foundation_proc
1401  TerraformTile_Water, // terraform_tile_proc
1402 };
VEH_AIRCRAFT
@ VEH_AIRCRAFT
Aircraft vehicle type.
Definition: vehicle_type.h:27
game.hpp
TileInfo::z
int z
Height.
Definition: tile_cmd.h:47
MP_CLEAR
@ MP_CLEAR
A tile without any structures, i.e. grass, rocks, farm fields etc.
Definition: tile_type.h:46
IsTileFlat
bool IsTileFlat(TileIndex tile, int *h)
Check if a given tile is flat.
Definition: tile_map.cpp:100
FLOOD_DRYUP
@ FLOOD_DRYUP
The tile drys up if it is not constantly flooded from neighboured tiles.
Definition: water.h:23
LOCK_PART_UPPER
@ LOCK_PART_UPPER
Upper part of a lock.
Definition: water_map.h:67
TileIndex
uint32 TileIndex
The index/ID of a Tile.
Definition: tile_type.h:83
TROPICZONE_DESERT
@ TROPICZONE_DESERT
Tile is desert.
Definition: tile_type.h:76
Station::docking_station
TileArea docking_station
Tile area the docking tiles cover.
Definition: station_base.h:463
DIR_SW
@ DIR_SW
Southwest.
Definition: direction_type.h:31
sound_func.h
TRACK_BIT_NONE
@ TRACK_BIT_NONE
No track.
Definition: track_type.h:39
DoCommand
CommandCost DoCommand(const CommandContainer *container, DoCommandFlag flags)
Shorthand for calling the long DoCommand with a container.
Definition: command.cpp:450
Pool::PoolItem<&_company_pool >::Get
static Titem * Get(size_t index)
Returns Titem with given index.
Definition: pool_type.hpp:337
GetOtherBridgeEnd
TileIndex GetOtherBridgeEnd(TileIndex tile)
Starting at one bridge end finds the other bridge end.
Definition: bridge_map.cpp:59
TileOffsByDiagDir
static TileIndexDiff TileOffsByDiagDir(DiagDirection dir)
Convert a DiagDirection to a TileIndexDiff.
Definition: map_func.h:341
Direction
Direction
Defines the 8 directions on the map.
Definition: direction_type.h:24
IsCanal
static bool IsCanal(TileIndex t)
Is it a canal tile?
Definition: water_map.h:163
GetOtherShipDepotTile
static TileIndex GetOtherShipDepotTile(TileIndex t)
Get the other tile of the ship depot.
Definition: water_map.h:272
DIR_BEGIN
@ DIR_BEGIN
Used to iterate.
Definition: direction_type.h:25
water.h
GetTileMaxZ
int GetTileMaxZ(TileIndex t)
Get top height of the tile inside the map.
Definition: tile_map.cpp:141
SPR_SHORE_BASE
static const SpriteID SPR_SHORE_BASE
shore tiles - action 05-0D
Definition: sprites.h:224
DrawOrigTileSeqInGUI
static void DrawOrigTileSeqInGUI(int x, int y, const DrawTileSprites *dts, PaletteID default_palette)
Draw TTD sprite sequence in GUI.
Definition: sprite.h:115
UpdateSignalsInBuffer
static SigSegState UpdateSignalsInBuffer(Owner owner)
Updates blocks in _globset buffer.
Definition: signal.cpp:468
command_func.h
DIR_SE
@ DIR_SE
Southeast.
Definition: direction_type.h:29
TileInfo::x
uint x
X position of the tile in unit coordinates.
Definition: tile_cmd.h:43
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
TO_BUILDINGS
@ TO_BUILDINGS
company buildings - depots, stations, HQ, ...
Definition: transparency.h:27
TileInfo
Tile information, used while rendering the tile.
Definition: tile_cmd.h:42
Backup
Class to backup a specific variable and restore it later.
Definition: backup_type.hpp:21
CmdBuildShipDepot
CommandCost CmdBuildShipDepot(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const std::string &text)
Build a ship depot.
Definition: water_cmd.cpp:101
company_base.h
IsTransparencySet
static bool IsTransparencySet(TransparencyOption to)
Check if the transparency option bit is set and if we aren't in the game menu (there's never transpar...
Definition: transparency.h:48
tunnelbridge_map.h
GetLockDirection
static DiagDirection GetLockDirection(TileIndex t)
Get the direction of the water lock.
Definition: water_map.h:308
DrawWaterLock
static void DrawWaterLock(const TileInfo *ti)
Draw a lock tile.
Definition: water_cmd.cpp:801
TileDesc::owner
Owner owner[4]
Name of the owner(s)
Definition: tile_cmd.h:53
Station
Station data structure.
Definition: station_base.h:447
company_gui.h
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:282
AmbientSoundEffect
static void AmbientSoundEffect(TileIndex tile)
Play an ambient sound effect for an empty tile.
Definition: newgrf_generic.h:53
FloodVehicles
static void FloodVehicles(TileIndex tile)
Finds a vehicle to flood.
Definition: water_cmd.cpp:1041
IsAirportTile
static bool IsAirportTile(TileIndex t)
Is this tile a station tile and an airport tile?
Definition: station_map.h:167
IsWateredTile
bool IsWateredTile(TileIndex tile, Direction from)
return true if a tile is a water tile wrt.
Definition: water_cmd.cpp:615
DIR_NW
@ DIR_NW
Northwest.
Definition: direction_type.h:33
SLOPE_HALFTILE_MASK
@ SLOPE_HALFTILE_MASK
three bits used for halftile slopes
Definition: slope_type.h:72
DiagDirToAxis
static Axis DiagDirToAxis(DiagDirection d)
Convert a DiagDirection to the axis.
Definition: direction_func.h:214
MakeSea
static void MakeSea(TileIndex t)
Make a sea tile.
Definition: water_map.h:414
TileAddByDir
static TileIndex TileAddByDir(TileIndex tile, Direction dir)
Adds a Direction to a tile.
Definition: map_func.h:370
Vehicle::vehstatus
byte vehstatus
Status.
Definition: vehicle_base.h:328
DIAGDIR_END
@ DIAGDIR_END
Used for iterations.
Definition: direction_type.h:83
MakeClear
static void MakeClear(TileIndex t, ClearGround g, uint density)
Make a clear tile.
Definition: clear_map.h:259
CompanyInfrastructure::water
uint32 water
Count of company owned track bits for canals.
Definition: company_base.h:34
depot_func.h
TREE_GROUND_SHORE
@ TREE_GROUND_SHORE
shore
Definition: tree_map.h:56
Pool::PoolItem::index
Tindex index
Index of this pool item.
Definition: pool_type.hpp:235
Vehicle::Crash
virtual uint Crash(bool flooded=false)
Crash the (whole) vehicle chain.
Definition: vehicle.cpp:260
AxisToTrackBits
static TrackBits AxisToTrackBits(Axis a)
Maps an Axis to the corresponding TrackBits value.
Definition: track_func.h:87
FloodHalftile
bool FloodHalftile(TileIndex t)
Called from water_cmd if a non-flat rail-tile gets flooded and should be converted to shore.
Definition: rail_cmd.cpp:771
PalSpriteID::sprite
SpriteID sprite
The 'real' sprite.
Definition: gfx_type.h:23
DoBuildLock
static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlag flags)
Builds a lock.
Definition: water_cmd.cpp:297
HasBit
static bool HasBit(const T x, const uint8 y)
Checks if a bit in a value is set.
Definition: bitmath_func.hpp:103
IsHalftileSlope
static bool IsHalftileSlope(Slope s)
Checks for non-continuous slope on halftile foundations.
Definition: slope_func.h:47
CLEAR_GRASS
@ CLEAR_GRASS
0-3
Definition: clear_map.h:20
SND_12_EXPLOSION
@ SND_12_EXPLOSION
16 == 0x10 Destruction, crashes, disasters, ...
Definition: sound_type.h:55
RAIL_GROUND_FENCE_VERT1
@ RAIL_GROUND_FENCE_VERT1
Grass with a fence at the eastern side.
Definition: rail_map.h:494
GetCanalSpriteOffset
uint GetCanalSpriteOffset(CanalFeature feature, TileIndex tile, uint cur_offset)
Get the new sprite offset for a water tile.
Definition: newgrf_canal.cpp:171
VETSB_CONTINUE
@ VETSB_CONTINUE
Bit sets of the above specified bits.
Definition: tile_cmd.h:34
MP_RAILWAY
@ MP_RAILWAY
A railway.
Definition: tile_type.h:47
WaterClass
WaterClass
classes of water (for WATER_TILE_CLEAR water tile type).
Definition: water_map.h:47
DrawWaterTileStruct
static void DrawWaterTileStruct(const TileInfo *ti, const DrawTileSeqStruct *dtss, SpriteID base, uint offset, PaletteID palette, CanalFeature feature)
Draw a build sprite sequence for water tiles.
Definition: water_cmd.cpp:784
GetPartialPixelZ
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
Definition: landscape.cpp:216
aircraft.h
DrawBridgeMiddle
void DrawBridgeMiddle(const TileInfo *ti)
Draw the middle bits of a bridge.
Definition: tunnelbridge_cmd.cpp:1540
water_land.h
GetTrackBits
static TrackBits GetTrackBits(TileIndex tile)
Gets the track bits of the given tile.
Definition: rail_map.h:136
TileInfo::y
uint y
Y position of the tile in unit coordinates.
Definition: tile_cmd.h:44
_settings_client
ClientSettings _settings_client
The current settings for this game.
Definition: settings.cpp:52
RAIL_GROUND_FENCE_VERT2
@ RAIL_GROUND_FENCE_VERT2
Grass with a fence at the western side.
Definition: rail_map.h:495
IsCoast
static bool IsCoast(TileIndex t)
Is it a coast tile?
Definition: water_map.h:195
DC_NO_WATER
@ DC_NO_WATER
don't allow building on water
Definition: command_type.h:351
CFF_HAS_FLAT_SPRITE
@ CFF_HAS_FLAT_SPRITE
Additional flat ground sprite in the beginning.
Definition: newgrf_canal.h:18
MP_INDUSTRY
@ MP_INDUSTRY
Part of an industry.
Definition: tile_type.h:54
town.h
TileY
static uint TileY(TileIndex tile)
Get the Y component of a tile.
Definition: map_func.h:215
OrthogonalTileArea::Add
void Add(TileIndex to_add)
Add a single tile to a tile area; enlarge if needed.
Definition: tilearea.cpp:43
Company::infrastructure
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
Definition: company_base.h:128
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
SLOPE_EW
@ SLOPE_EW
east and west corner are raised
Definition: slope_type.h:59
WATER_CLASS_RIVER
@ WATER_CLASS_RIVER
River.
Definition: water_map.h:50
TransportType
TransportType
Available types of transport.
Definition: transport_type.h:19
clear_map.h
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:221
WATER_TILE_DEPOT
@ WATER_TILE_DEPOT
Water Depot.
Definition: water_map.h:43
Vehicle::owner
Owner owner
Which company owns the vehicle?
Definition: vehicle_base.h:285
Owner
Owner
Enum for all companies/owners.
Definition: company_type.h:18
EV_EXPLOSION_LARGE
@ EV_EXPLOSION_LARGE
Various explosions.
Definition: effectvehicle_func.h:22
DC_EXEC
@ DC_EXEC
execute the given command
Definition: command_type.h:348
DIR_N
@ DIR_N
North.
Definition: direction_type.h:26
TileDesc
Tile description for the 'land area information' tool.
Definition: tile_cmd.h:51
SetDParam
static void SetDParam(uint n, uint64 v)
Set a string parameter v at index n in the global string parameter array.
Definition: strings_func.h:196
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:346
Foundation
Foundation
Enumeration for Foundations.
Definition: slope_type.h:93
EnsureNoVehicleOnGround
CommandCost EnsureNoVehicleOnGround(TileIndex tile)
Ensure there is no vehicle at the ground at the given position.
Definition: vehicle.cpp:539
newgrf_generic.h
AIR_SHADOW
@ AIR_SHADOW
shadow of the aircraft
Definition: aircraft.h:33
Industry::neutral_station
Station * neutral_station
Associated neutral station.
Definition: industry.h:69
CmdBuildLock
CommandCost CmdBuildLock(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const std::string &text)
Builds a lock.
Definition: water_cmd.cpp:420
TRACK_BIT_UPPER
@ TRACK_BIT_UPPER
Upper track.
Definition: track_type.h:42
CommandCost::Succeeded
bool Succeeded() const
Did this command succeed?
Definition: command_type.h:150
TileX
static uint TileX(TileIndex tile)
Get the X component of a tile.
Definition: map_func.h:205
industry_map.h
GetLockPart
static byte GetLockPart(TileIndex t)
Get the part of a lock.
Definition: water_map.h:320
DEPOT_PART_NORTH
@ DEPOT_PART_NORTH
Northern part of a depot.
Definition: water_map.h:58
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:590
effectvehicle_func.h
TRACK_BIT_RIGHT
@ TRACK_BIT_RIGHT
Right track.
Definition: track_type.h:45
Airport::GetFTA
const AirportFTAClass * GetFTA() const
Get the finite-state machine for this airport or the finite-state machine for the dummy airport in ca...
Definition: station_base.h:329
ai.hpp
IsInsideMM
static bool IsInsideMM(const T x, const size_t min, const size_t max)
Checks if a value is in an interval.
Definition: math_func.hpp:204
SLOPE_NW
@ SLOPE_NW
north and west corner are raised
Definition: slope_type.h:55
TileInfo::tileh
Slope tileh
Slope of the tile.
Definition: tile_cmd.h:45
SpriteID
uint32 SpriteID
The number of a sprite, without mapping bits and colourtables.
Definition: gfx_type.h:17
IsTileOnWater
static bool IsTileOnWater(TileIndex t)
Tests if the tile was built on water.
Definition: water_map.h:130
SLOPE_FLAT
@ SLOPE_FLAT
a flat tile
Definition: slope_type.h:49
GetShipDepotNorthTile
static TileIndex GetShipDepotNorthTile(TileIndex t)
Get the most northern tile of a ship depot.
Definition: water_map.h:283
TileDesc::build_date
Date build_date
Date of construction of tile contents.
Definition: tile_cmd.h:55
DrawTileSprites::ground
PalSpriteID ground
Palette and sprite for the ground.
Definition: sprite.h:59
ToTileIndexDiff
static TileIndexDiff ToTileIndexDiff(TileIndexDiffC tidc)
Return the offset between to tiles from a TileIndexDiffC struct.
Definition: map_func.h:230
WATER_TILE_COAST
@ WATER_TILE_COAST
Coast.
Definition: water_map.h:41
WATER_CLASS_INVALID
@ WATER_CLASS_INVALID
Used for industry tiles on land (also for oilrig if newgrf says so).
Definition: water_map.h:51
DrawTileSeqStruct::delta_x
int8 delta_x
0x80 is sequence terminator
Definition: sprite.h:26
depot_base.h
DirToDiagDir
static DiagDirection DirToDiagDir(Direction dir)
Convert a Direction to a DiagDirection.
Definition: direction_func.h:166
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
AI::NewEvent
static void NewEvent(CompanyID company, ScriptEvent *event)
Queue a new event for an AI.
Definition: ai_core.cpp:234
IsBridgeTile
static bool IsBridgeTile(TileIndex t)
checks if there is a bridge on this tile
Definition: bridge_map.h:35
CommandCost
Common return value for all commands.
Definition: command_type.h:23
HasTileWaterGround
static bool HasTileWaterGround(TileIndex t)
Checks whether the tile has water at the ground.
Definition: water_map.h:344
SetBitIterator
Iterable ensemble of each set bit in a value.
Definition: bitmath_func.hpp:329
cmd_helper.h
_date
Date _date
Current date in days (day counter)
Definition: date.cpp:28
SetTropicZone
static void SetTropicZone(TileIndex tile, TropicZone type)
Set the tropic zone.
Definition: tile_map.h:225
TileHeight
static uint TileHeight(TileIndex tile)
Returns the height of a tile.
Definition: tile_map.h:29
ClientSettings::sound
SoundSettings sound
sound effect settings
Definition: settings_type.h:596
CircularTileSearch
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
FloodVehicleProc
static Vehicle * FloodVehicleProc(Vehicle *v, void *data)
Flood a vehicle if we are allowed to flood it, i.e.
Definition: water_cmd.cpp:1003
DrawTileSeqStruct::delta_z
int8 delta_z
0x80 identifies child sprites
Definition: sprite.h:28
Industry::GetByTile
static Industry * GetByTile(TileIndex tile)
Get the industry of the given tile.
Definition: industry.h:144
WATER_TILE_CLEAR
@ WATER_TILE_CLEAR
Plain water.
Definition: water_map.h:40
MakeLock
static void MakeLock(TileIndex t, Owner o, DiagDirection d, WaterClass wc_lower, WaterClass wc_upper, WaterClass wc_middle)
Make a water lock.
Definition: water_map.h:496
DirtyCompanyInfrastructureWindows
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
Definition: company_gui.cpp:2709
DIR_E
@ DIR_E
East.
Definition: direction_type.h:28
TrackBitsToTrackdirBits
static TrackdirBits TrackBitsToTrackdirBits(TrackBits bits)
Converts TrackBits to TrackdirBits while allowing both directions.
Definition: track_func.h:318
TileIndexDiff
int32 TileIndexDiff
An offset value between to tiles.
Definition: map_func.h:154
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:242
TrackStatusToTrackBits
static TrackBits TrackStatusToTrackBits(TrackStatus ts)
Returns the present-track-information of a TrackStatus.
Definition: track_func.h:362
DrawCanalWater
static void DrawCanalWater(TileIndex tile)
draw a canal styled water tile with dikes around
Definition: water_cmd.cpp:760
MP_OBJECT
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition: tile_type.h:56
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:38
IsBuoy
static bool IsBuoy(TileIndex t)
Is tile t a buoy tile?
Definition: station_map.h:306
INVALID_OWNER
@ INVALID_OWNER
An invalid owner.
Definition: company_type.h:29
OrthogonalTileArea::w
uint16 w
The width of the area.
Definition: tilearea_type.h:20
MP_WATER
@ MP_WATER
Water tile.
Definition: tile_type.h:52
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:159
IsInvisibilitySet
static bool IsInvisibilitySet(TransparencyOption to)
Check if the invisibility option bit is set and if we aren't in the game menu (there's never transpar...
Definition: transparency.h:59
RiverModifyDesertZone
bool RiverModifyDesertZone(TileIndex tile, void *)
Callback to create non-desert around a river tile.
Definition: water_cmd.cpp:429
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:461
OrthogonalTileArea
Represents the covered area of e.g.
Definition: tilearea_type.h:18
IsShipDepot
static bool IsShipDepot(TileIndex t)
Is it a water tile with a ship depot on it?
Definition: water_map.h:216
DIR_NE
@ DIR_NE
Northeast.
Definition: direction_type.h:27
LOCK_PART_MIDDLE
@ LOCK_PART_MIDDLE
Middle part of a lock.
Definition: water_map.h:65
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:53
GetTropicZone
static TropicZone GetTropicZone(TileIndex tile)
Get the tropic zone.
Definition: tile_map.h:238
_water_feature
WaterFeature _water_feature[CF_END]
Table of canal 'feature' sprite groups.
Definition: newgrf_canal.cpp:21
Game::NewEvent
static void NewEvent(class ScriptEvent *event)
Queue a new event for a Game Script.
Definition: game_core.cpp:141
DrawTileSeqStruct::IsTerminator
bool IsTerminator() const
Check whether this is a sequence terminator.
Definition: sprite.h:41
_local_company
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
Definition: company_cmd.cpp:46
TRACK_BIT_X
@ TRACK_BIT_X
X-axis track.
Definition: track_type.h:40
TileOffsByDir
static TileIndexDiff TileOffsByDir(Direction dir)
Convert a Direction to a TileIndexDiff.
Definition: map_func.h:355
industry.h
safeguards.h
CombineTrackStatus
static TrackStatus CombineTrackStatus(TrackdirBits trackdirbits, TrackdirBits red_signals)
Builds a TrackStatus.
Definition: track_func.h:387
SetDockingTile
static void SetDockingTile(TileIndex t, bool b)
Set the docking tile state of a tile.
Definition: water_map.h:355
SLOPE_STEEP
@ SLOPE_STEEP
indicates the slope is steep
Definition: slope_type.h:54
IsValidTile
static bool IsValidTile(TileIndex tile)
Checks if a tile is valid.
Definition: tile_map.h:161
ConstructionSettings::freeform_edges
bool freeform_edges
allow terraforming the tiles at the map edges
Definition: settings_type.h:345
GetCanalSprite
SpriteID GetCanalSprite(CanalFeature feature, TileIndex tile)
Lookup the base sprite to use for a canal.
Definition: newgrf_canal.cpp:140
CommandCost::GetCost
Money GetCost() const
The costs as made up to this moment.
Definition: command_type.h:82
ReverseDiagDir
static DiagDirection ReverseDiagDir(DiagDirection d)
Returns the reverse direction of the given DiagDirection.
Definition: direction_func.h:118
GetTileSlope
Slope GetTileSlope(TileIndex tile, int *h)
Return the slope of a given tile inside the map.
Definition: tile_map.cpp:59
DIR_S
@ DIR_S
South.
Definition: direction_type.h:30
IsTileOwner
static bool IsTileOwner(TileIndex tile, Owner owner)
Checks if a tile belongs to the given owner.
Definition: tile_map.h:214
DrawTileSprites
Ground palette sprite of a tile, together with its sprite layout.
Definition: sprite.h:58
INVALID_DIAGDIR
@ INVALID_DIAGDIR
Flag for an invalid DiagDirection.
Definition: direction_type.h:84
DrawSprite
void DrawSprite(SpriteID img, PaletteID pal, int x, int y, const SubSprite *sub, ZoomLevel zoom)
Draw a sprite, not in a viewport.
Definition: gfx.cpp:1041
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:55
AirportFTAClass
Finite sTate mAchine (FTA) of an airport.
Definition: airport.h:143
SoundSettings::disaster
bool disaster
Play disaster and accident sounds.
Definition: settings_type.h:210
FOUNDATION_NONE
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Definition: slope_type.h:94
SLOPE_SW
@ SLOPE_SW
south and west corner are raised
Definition: slope_type.h:56
Slope
Slope
Enumeration for the slope-type.
Definition: slope_type.h:48
DiagDirection
DiagDirection
Enumeration for diagonal directions.
Definition: direction_type.h:77
MarkCanalsAndRiversAroundDirty
static void MarkCanalsAndRiversAroundDirty(TileIndex tile)
Marks the tiles around a tile as dirty, if they are canals or rivers.
Definition: water_cmd.cpp:84
GetFoundationSlope
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,...
Definition: landscape.cpp:423
TRACK_BIT_ALL
@ TRACK_BIT_ALL
All possible tracks.
Definition: track_type.h:53
CreateEffectVehicleRel
EffectVehicle * CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicleType type)
Create an effect vehicle above a particular vehicle.
Definition: effectvehicle.cpp:638
date_func.h
CommandCost::AddCost
void AddCost(const Money &cost)
Adds the given cost to the cost of the command.
Definition: command_type.h:62
TRACK_BIT_LOWER
@ TRACK_BIT_LOWER
Lower track.
Definition: track_type.h:43
WATER_CLASS_CANAL
@ WATER_CLASS_CANAL
Canal.
Definition: water_map.h:49
GetShipDepotPart
static DepotPart GetShipDepotPart(TileIndex t)
Get the part of a ship depot.
Definition: water_map.h:249
stdafx.h
landscape.h
TileTypeProcs
Set of callback functions for performing tile operations of a given tile type.
Definition: tile_cmd.h:145
DC_BANKRUPT
@ DC_BANKRUPT
company bankrupts, skip money check, skip vehicle on tile check in some cases
Definition: command_type.h:354
IsValidDockingDirectionForDock
bool IsValidDockingDirectionForDock(TileIndex t, DiagDirection d)
Check if a dock tile can be docked from the given direction.
Definition: station_cmd.cpp:2641
TileLoop_Water
void TileLoop_Water(TileIndex tile)
Let a water tile floods its diagonal adjoining tiles called from tunnelbridge_cmd,...
Definition: water_cmd.cpp:1222
viewport_func.h
IsTileType
static bool IsTileType(TileIndex tile, TileType type)
Checks if a tile is a given tiletype.
Definition: tile_map.h:150
RailGroundType
RailGroundType
The ground 'under' the rail.
Definition: rail_map.h:485
GetTunnelBridgeDirection
static DiagDirection GetTunnelBridgeDirection(TileIndex t)
Get the direction pointing to the other end.
Definition: tunnelbridge_map.h:26
GetTileOwner
static Owner GetTileOwner(TileIndex tile)
Returns the owner of a tile.
Definition: tile_map.h:178
AddSortableSpriteToDraw
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:665
TREE_GROUND_GRASS
@ TREE_GROUND_GRASS
normal grass
Definition: tree_map.h:53
RAIL_GROUND_WATER
@ RAIL_GROUND_WATER
Grass with a fence and shore or water on the free halftile.
Definition: rail_map.h:499
OrthogonalTileArea::h
uint16 h
The height of the area.
Definition: tilearea_type.h:21
MP_TREES
@ MP_TREES
Tile got trees.
Definition: tile_type.h:50
TileIndexDiffC
A pair-construct of a TileIndexDiff.
Definition: map_type.h:57
CheckForDockingTile
void CheckForDockingTile(TileIndex t)
Mark the supplied tile as a docking tile if it is suitable for docking.
Definition: water_cmd.cpp:182
AirportFTAClass::delta_z
byte delta_z
Z adjustment for helicopter pads.
Definition: airport.h:183
DEPOT_PART_SOUTH
@ DEPOT_PART_SOUTH
Southern part of a depot.
Definition: water_map.h:59
ReverseDir
static Direction ReverseDir(Direction d)
Return the reverse of a direction.
Definition: direction_func.h:54
MakeDefaultName
void MakeDefaultName(T *obj)
Set the default name for a depot/waypoint.
Definition: town.h:239
IsDockTile
static bool IsDockTile(TileIndex t)
Is tile t a dock tile?
Definition: station_map.h:295
TRACKDIR_BIT_NONE
@ TRACKDIR_BIT_NONE
No track build.
Definition: track_type.h:102
_current_company
CompanyID _current_company
Company currently doing an action.
Definition: company_cmd.cpp:47
vehicle_func.h
SLOPE_N
@ SLOPE_N
the north corner of the tile is raised
Definition: slope_type.h:53
FloodVehicle
static void FloodVehicle(Vehicle *v)
Handle the flooding of a vehicle.
Definition: water_cmd.cpp:985
FLOOD_PASSIVE
@ FLOOD_PASSIVE
The tile does not actively flood neighboured tiles, but it prevents them from drying up.
Definition: water.h:22
station_base.h
strings_func.h
Vehicle::First
Vehicle * First() const
Get the first vehicle of this vehicle chain.
Definition: vehicle_base.h:607
GetWaterClass
static WaterClass GetWaterClass(TileIndex t)
Get the water class at a tile.
Definition: water_map.h:106
RAIL_GROUND_FENCE_HORIZ1
@ RAIL_GROUND_FENCE_HORIZ1
Grass with a fence at the southern side.
Definition: rail_map.h:496
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
DoFloodTile
void DoFloodTile(TileIndex target)
Floods a tile.
Definition: water_cmd.cpp:1108
TRACK_BIT_LEFT
@ TRACK_BIT_LEFT
Left track.
Definition: track_type.h:44
DrawSeaWater
static void DrawSeaWater(TileIndex tile)
Draw a plain sea water tile with no edges.
Definition: water_cmd.cpp:754
MP_VOID
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition: tile_type.h:53
IsPlainRail
static bool IsPlainRail(TileIndex t)
Returns whether this is plain rails, with or without signals.
Definition: rail_map.h:49
Backup::Restore
void Restore()
Restore the variable.
Definition: backup_type.hpp:112
GetWaterTileType
static WaterTileType GetWaterTileType(TileIndex t)
Get the water tile type at a tile.
Definition: water_map.h:77
IsSlopeWithOneCornerRaised
static bool IsSlopeWithOneCornerRaised(Slope s)
Tests if a specific slope has exactly one corner raised.
Definition: slope_func.h:88
MakeShipDepot
static void MakeShipDepot(TileIndex t, Owner o, DepotID did, DepotPart part, Axis a, WaterClass original_water_class)
Make a ship depot section.
Definition: water_map.h:450
DIR_END
@ DIR_END
Used to iterate.
Definition: direction_type.h:34
IsWaterTile
static bool IsWaterTile(TileIndex t)
Is it a water tile with plain water?
Definition: water_map.h:184
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
GetIndustryIndex
static IndustryID GetIndustryIndex(TileIndex t)
Get the industry ID of the given tile.
Definition: industry_map.h:63
tree_map.h
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
TRANSPORT_WATER
@ TRANSPORT_WATER
Transport over water.
Definition: transport_type.h:29
OWNER_NONE
@ OWNER_NONE
The tile has no ownership.
Definition: company_type.h:25
MakeShore
static void MakeShore(TileIndex t)
Helper function to make a coast tile.
Definition: water_map.h:375
TileDiffXY
static TileIndexDiff TileDiffXY(int x, int y)
Calculates an offset for the given coordinate(-offset).
Definition: map_func.h:179
MP_STATION
@ MP_STATION
A tile of a station.
Definition: tile_type.h:51
FloodingBehaviour
FloodingBehaviour
Describes the behaviour of a tile during flooding.
Definition: water.h:19
SpecializedStation< Station, false >::GetByTile
static Station * GetByTile(TileIndex tile)
Get the station belonging to a specific tile.
Definition: base_station_base.h:238
RIVER_OFFSET_DESERT_DISTANCE
static const uint RIVER_OFFSET_DESERT_DISTANCE
Circular tile search radius to create non-desert around a river tile.
Definition: water.h:42
FindVehicleOnPos
void FindVehicleOnPos(TileIndex tile, void *data, VehicleFromPosProc *proc)
Find a vehicle from a specific location.
Definition: vehicle.cpp:498
FLOOD_NONE
@ FLOOD_NONE
The tile does not flood neighboured tiles.
Definition: water.h:20
Pool::PoolItem<&_depot_pool >::CanAllocateItem
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
Definition: pool_type.hpp:307
NT_ACCIDENT
@ NT_ACCIDENT
An accident or disaster has occurred.
Definition: news_type.h:24
IsLock
static bool IsLock(TileIndex t)
Is there a lock on a given water tile?
Definition: water_map.h:297
DIAGDIR_BEGIN
@ DIAGDIR_BEGIN
Used for iterations.
Definition: direction_type.h:78
GetShipDepotAxis
static Axis GetShipDepotAxis(TileIndex t)
Get the axis of the ship depot.
Definition: water_map.h:237
CmdBuildCanal
CommandCost CmdBuildCanal(TileIndex tile, DoCommandFlag flags, uint32 p1, uint32 p2, const std::string &text)
Build a piece of canal.
Definition: water_cmd.cpp:446
TileDesc::str
StringID str
Description of the tile.
Definition: tile_cmd.h:52
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
company_func.h
IsRiver
static bool IsRiver(TileIndex t)
Is it a river water tile?
Definition: water_map.h:174
MapMaxX
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:102
GetTreeGround
static TreeGround GetTreeGround(TileIndex t)
Returns the groundtype for tree tiles.
Definition: tree_map.h:88
TILE_ADDXY
#define TILE_ADDXY(tile, x, y)
Adds a given offset to a tile.
Definition: map_func.h:258
_flood_from_dirs
static const uint8 _flood_from_dirs[]
Describes from which directions a specific slope can be flooded (if the tile is floodable at all).
Definition: water_cmd.cpp:49
LOCK_DEPOT_TILE_FACTOR
static const uint LOCK_DEPOT_TILE_FACTOR
Multiplier for how many regular tiles a lock counts.
Definition: economy_type.h:230
DrawWaterDepot
static void DrawWaterDepot(const TileInfo *ti)
Draw a ship depot tile.
Definition: water_cmd.cpp:840
SLOPE_W
@ SLOPE_W
the west corner of the tile is raised
Definition: slope_type.h:50
TrackBits
TrackBits
Bitfield corresponding to Track.
Definition: track_type.h:38
Vehicle::subtype
byte subtype
subtype (Filled with values from AircraftSubType/DisasterSubType/EffectVehicleType/GroundVehicleSubty...
Definition: vehicle_base.h:338
IsDockingTile
static bool IsDockingTile(TileIndex t)
Checks whether the tile is marked as a dockling tile.
Definition: water_map.h:365
CheckTileOwnership
CommandCost CheckTileOwnership(TileIndex tile)
Check whether the current owner owns the stuff on the given tile.
Definition: company_cmd.cpp:329
DrawTileSprites::seq
const DrawTileSeqStruct * seq
Array of child sprites. Terminated with a terminator entry.
Definition: sprite.h:60
Depot::build_date
Date build_date
Date of construction.
Definition: depot_base.h:25
FLOOD_ACTIVE
@ FLOOD_ACTIVE
The tile floods neighboured tiles.
Definition: water.h:21
Depot
Definition: depot_base.h:19
MakeCanal
static void MakeCanal(TileIndex t, Owner o, uint8 random_bits)
Make a canal tile.
Definition: water_map.h:435
DiagDirToDiagTrackBits
static TrackBits DiagDirToDiagTrackBits(DiagDirection diagdir)
Maps a (4-way) direction to the diagonal track bits incidating with that diagdir.
Definition: track_func.h:523
GetBridgePixelHeight
static int GetBridgePixelHeight(TileIndex tile)
Get the height ('z') of a bridge in pixels.
Definition: bridge_map.h:84
IsDock
static bool IsDock(TileIndex t)
Is tile t a dock tile?
Definition: station_map.h:285
random_func.hpp
newgrf_canal.h
OverflowSafeInt< int64 >
IsOilRig
static bool IsOilRig(TileIndex t)
Is tile t part of an oilrig?
Definition: station_map.h:274
INVALID_TILE
static const TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:88
Axis
Axis
Allow incrementing of DiagDirDiff variables.
Definition: direction_type.h:123
RemoveLock
static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
Remove a lock.
Definition: water_cmd.cpp:373
GetFloodingBehaviour
FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
Returns the behaviour of a tile during flooding.
Definition: water_cmd.cpp:1072
SetTileOwner
static void SetTileOwner(TileIndex tile, Owner owner)
Sets the owner of a tile.
Definition: tile_map.h:198
RAIL_GROUND_FENCE_HORIZ2
@ RAIL_GROUND_FENCE_HORIZ2
Grass with a fence at the northern side.
Definition: rail_map.h:497
PalSpriteID::pal
PaletteID pal
The palette (use PAL_NONE) if not needed)
Definition: gfx_type.h:24
TRACK_BIT_Y
@ TRACK_BIT_Y
Y-axis track.
Definition: track_type.h:41
TileInfo::tile
TileIndex tile
Tile index.
Definition: tile_cmd.h:46
GameSettings::construction
ConstructionSettings construction
construction of things in-game
Definition: settings_type.h:577
IsInclinedSlope
static bool IsInclinedSlope(Slope s)
Tests if a specific slope is an inclined slope.
Definition: slope_func.h:228
SLOPE_NS
@ SLOPE_NS
north and south corner are raised
Definition: slope_type.h:60
GetTileType
static TileType GetTileType(TileIndex tile)
Get the tiletype of a given tile.
Definition: tile_map.h:96
VEH_TRAIN
@ VEH_TRAIN
Train vehicle type.
Definition: vehicle_type.h:24
Pool::PoolItem<&_company_pool >::IsValidID
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
Definition: pool_type.hpp:326
BaseVehicle::type
VehicleType type
Type of vehicle.
Definition: vehicle_type.h:52
WATER_CLASS_SEA
@ WATER_CLASS_SEA
Sea.
Definition: water_map.h:48
TROPICZONE_NORMAL
@ TROPICZONE_NORMAL
Normal tropiczone.
Definition: tile_type.h:75
WATER_TILE_LOCK
@ WATER_TILE_LOCK
Water lock.
Definition: water_map.h:42
GetTilePixelSlope
static Slope GetTilePixelSlope(TileIndex tile, int *h)
Return the slope of a given tile.
Definition: tile_map.h:280
ShowDepotWindow
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
Definition: depot_gui.cpp:1103
GetTunnelBridgeTransportType
static TransportType GetTunnelBridgeTransportType(TileIndex t)
Tunnel: Get the transport type of the tunnel (road or rail) Bridge: Get the transport type of the bri...
Definition: tunnelbridge_map.h:39
VEH_SHIP
@ VEH_SHIP
Ship vehicle type.
Definition: vehicle_type.h:26
Company
Definition: company_base.h:115
SLOPE_SE
@ SLOPE_SE
south and east corner are raised
Definition: slope_type.h:57
DepotPart
DepotPart
Sections of the water depot.
Definition: water_map.h:57
OWNER_WATER
@ OWNER_WATER
The tile/execution is done by "water".
Definition: company_type.h:26
DrawWaterSprite
static void DrawWaterSprite(SpriteID base, uint offset, CanalFeature feature, TileIndex tile)
Draw a water sprite, potentially with a NewGRF-modified sprite offset.
Definition: water_cmd.cpp:686
SLOPE_NE
@ SLOPE_NE
north and east corner are raised
Definition: slope_type.h:58
SLOPE_E
@ SLOPE_E
the east corner of the tile is raised
Definition: slope_type.h:52
VehicleEnterTileStatus
VehicleEnterTileStatus
The returned bits of VehicleEnterTile.
Definition: tile_cmd.h:20
CMD_LANDSCAPE_CLEAR
@ CMD_LANDSCAPE_CLEAR
demolish a tile
Definition: command_type.h:180
DrawWaterEdges
static void DrawWaterEdges(bool canal, uint offset, TileIndex tile)
Draw canal or river edges.
Definition: water_cmd.cpp:701
DrawGroundSprite
void DrawGroundSprite(SpriteID image, PaletteID pal, const SubSprite *sub, int extra_offs_x, int extra_offs_y)
Draws a ground sprite for the current tile.
Definition: viewport.cpp:581
MakeRiver
static void MakeRiver(TileIndex t, uint8 random_bits)
Make a river tile.
Definition: water_map.h:424
SetTreeGroundDensity
static void SetTreeGroundDensity(TileIndex t, TreeGround g, uint d)
Set the density and ground type of a tile with trees.
Definition: tree_map.h:130
GetInclinedSlopeDirection
static DiagDirection GetInclinedSlopeDirection(Slope s)
Returns the direction of an inclined slope.
Definition: slope_func.h:239
MarkTileDirtyIfCanalOrRiver
static void MarkTileDirtyIfCanalOrRiver(TileIndex tile)
Marks tile dirty if it is a canal or river tile.
Definition: water_cmd.cpp:73
news_func.h
IsBridgeAbove
static bool IsBridgeAbove(TileIndex t)
checks if a bridge is set above the ground of this tile
Definition: bridge_map.h:45
DrawTileSeqStruct
A tile child sprite and palette to draw for stations etc, with 3D bounding box.
Definition: sprite.h:25
DoDryUp
static void DoDryUp(TileIndex tile)
Drys a tile up.
Definition: water_cmd.cpp:1175
backup_type.hpp
CanalFeature
CanalFeature
List of different canal 'features'.
Definition: newgrf.h:25
AXIS_X
@ AXIS_X
The X axis.
Definition: direction_type.h:124