OpenTTD Source: src/water_cmd.cpp Source File

OpenTTD Source 12.2

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
84 static void MarkCanalsAndRiversAroundDirty(TileIndex tile)
85 {
86 for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
87 MarkTileDirtyIfCanalOrRiver(tile + TileOffsByDir(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;
146 DirtyCompanyInfrastructureWindows(_current_company);
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:
170 return TrackStatusToTrackBits(GetTileTrackStatus(t, TRANSPORT_WATER, 0)) != TRACK_BIT_NONE;
171
172 default:
173 return false;
174 }
175 }
176
182 void CheckForDockingTile(TileIndex t)
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)) {
189 Station::GetByTile(tile)->docking_station.Add(t);
190 SetDockingTile(t, true);
191 }
192 if (IsTileType(tile, MP_INDUSTRY)) {
193 Station *st = Industry::GetByTile(tile)->neutral_station;
194 if (st != nullptr) {
195 st->docking_station.Add(t);
196 SetDockingTile(t, true);
197 }
198 }
199 if (IsTileType(tile, MP_STATION) && IsOilRig(tile)) {
200 Station::GetByTile(tile)->docking_station.Add(t);
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. */
217 Company *c = Company::GetIfValid(o);
218 if (c != nullptr) {
219 c->infrastructure.water--;
220 DirtyCompanyInfrastructureWindows(c->index);
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 */
227 if (wc != WATER_CLASS_RIVER || GetInclinedSlopeDirection(slope) == INVALID_DIAGDIR) {
228 wc = WATER_CLASS_INVALID;
229 }
230 }
231
232 if (wc == WATER_CLASS_SEA && z > 0) {
233 /* Update company infrastructure count. */
234 Company *c = Company::GetIfValid(o);
235 if (c != nullptr) {
236 c->infrastructure.water++;
237 DirtyCompanyInfrastructureWindows(c->index);
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)) {
269 CommandCost ret = EnsureNoVehicleOnGround(tile);
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
277 Company *c = Company::GetIfValid(GetTileOwner(tile));
278 if (c != nullptr) {
279 c->infrastructure.water -= 2 * LOCK_DEPOT_TILE_FACTOR;
280 DirtyCompanyInfrastructureWindows(c->index);
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
297 static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlag flags)
298 {
299 CommandCost cost(EXPENSES_CONSTRUCTION);
300
301 int delta = TileOffsByDiagDir(dir);
302 CommandCost ret = EnsureNoVehicleOnGround(tile);
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. */
343 Company *c = Company::GetIfValid(_current_company);
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.
350 DirtyCompanyInfrastructureWindows(_current_company);
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
373 static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
374 {
375 if (GetTileOwner(tile) != OWNER_NONE) {
376 CommandCost ret = CheckTileOwnership(tile);
377 if (ret.Failed()) return ret;
378 }
379
380 TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));
381
382 /* make sure no vehicle is on the tile. */
383 CommandCost ret = EnsureNoVehicleOnGround(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. */
390 Company *c = Company::GetIfValid(GetTileOwner(tile));
391 if (c != nullptr) {
392 c->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // three parts of the lock.
393 DirtyCompanyInfrastructureWindows(c->index);
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));
403 MarkCanalsAndRiversAroundDirty(tile);
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 {
422 DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
423 if (dir == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
424
425 return DoBuildLock(tile, dir, flags);
426 }
427
429 bool RiverModifyDesertZone(TileIndex tile, void *)
430 {
431 if (GetTropicZone(tile) == TROPICZONE_DESERT) SetTropicZone(tile, TROPICZONE_NORMAL);
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
460 CommandCost cost(EXPENSES_CONSTRUCTION);
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 bool water = IsWaterTile(current_tile);
479
480 /* Outside the editor, prevent building canals over your own or OWNER_NONE owned canals */
481 if (water && IsCanal(current_tile) && _game_mode != GM_EDITOR && (IsTileOwner(current_tile, _current_company) || IsTileOwner(current_tile, OWNER_NONE))) continue;
482
483 ret = DoCommand(current_tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
484 if (ret.Failed()) return ret;
485
486 if (!water) cost.AddCost(ret);
487
488 if (flags & DC_EXEC) {
489 switch (wc) {
490 case WATER_CLASS_RIVER:
491 MakeRiver(current_tile, Random());
492 if (_game_mode == GM_EDITOR) {
493 TileIndex tile2 = current_tile;
494 CircularTileSearch(&tile2, RIVER_OFFSET_DESERT_DISTANCE, RiverModifyDesertZone, nullptr);
495 }
496 break;
497
498 case WATER_CLASS_SEA:
499 if (TileHeight(current_tile) == 0) {
500 MakeSea(current_tile);
501 break;
502 }
503 FALLTHROUGH;
504
505 default:
506 MakeCanal(current_tile, _current_company, Random());
507 if (Company::IsValidID(_current_company)) {
508 Company::Get(_current_company)->infrastructure.water++;
509 DirtyCompanyInfrastructureWindows(_current_company);
510 }
511 break;
512 }
513 MarkTileDirtyByTile(current_tile);
514 MarkCanalsAndRiversAroundDirty(current_tile);
515 CheckForDockingTile(current_tile);
516 }
517
518 cost.AddCost(_price[PR_BUILD_CANAL]);
519 }
520
521 if (cost.GetCost() == 0) {
522 return_cmd_error(STR_ERROR_ALREADY_BUILT);
523 } else {
524 return cost;
525 }
526 }
527
528 static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlag flags)
529 {
530 switch (GetWaterTileType(tile)) {
531 case WATER_TILE_CLEAR: {
532 if (flags & DC_NO_WATER) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);
533
534 Money base_cost = IsCanal(tile) ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER];
535 /* Make sure freeform edges are allowed or it's not an edge tile. */
536 if (!_settings_game.construction.freeform_edges && (!IsInsideMM(TileX(tile), 1, MapMaxX() - 1) ||
537 !IsInsideMM(TileY(tile), 1, MapMaxY() - 1))) {
538 return_cmd_error(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP);
539 }
540
541 /* Make sure no vehicle is on the tile */
542 CommandCost ret = EnsureNoVehicleOnGround(tile);
543 if (ret.Failed()) return ret;
544
545 Owner owner = GetTileOwner(tile);
546 if (owner != OWNER_WATER && owner != OWNER_NONE) {
547 CommandCost ret = CheckTileOwnership(tile);
548 if (ret.Failed()) return ret;
549 }
550
551 if (flags & DC_EXEC) {
552 if (IsCanal(tile) && Company::IsValidID(owner)) {
553 Company::Get(owner)->infrastructure.water--;
554 DirtyCompanyInfrastructureWindows(owner);
555 }
556 bool remove = IsDockingTile(tile);
557 DoClearSquare(tile);
558 MarkCanalsAndRiversAroundDirty(tile);
559 if (remove) RemoveDockingTile(tile);
560 }
561
562 return CommandCost(EXPENSES_CONSTRUCTION, base_cost);
563 }
564
565 case WATER_TILE_COAST: {
566 Slope slope = GetTileSlope(tile);
567
568 /* Make sure no vehicle is on the tile */
569 CommandCost ret = EnsureNoVehicleOnGround(tile);
570 if (ret.Failed()) return ret;
571
572 if (flags & DC_EXEC) {
573 bool remove = IsDockingTile(tile);
574 DoClearSquare(tile);
575 MarkCanalsAndRiversAroundDirty(tile);
576 if (remove) RemoveDockingTile(tile);
577 }
578 if (IsSlopeWithOneCornerRaised(slope)) {
579 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_WATER]);
580 } else {
581 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_ROUGH]);
582 }
583 }
584
585 case WATER_TILE_LOCK: {
586 static const TileIndexDiffC _lock_tomiddle_offs[][DIAGDIR_END] = {
587 /* NE SE SW NW */
588 { { 0, 0}, {0, 0}, { 0, 0}, {0, 0} }, // LOCK_PART_MIDDLE
589 { {-1, 0}, {0, 1}, { 1, 0}, {0, -1} }, // LOCK_PART_LOWER
590 { { 1, 0}, {0, -1}, {-1, 0}, {0, 1} }, // LOCK_PART_UPPER
591 };
592
593 if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
594 if (_current_company == OWNER_WATER) return CMD_ERROR;
595 /* move to the middle tile.. */
596 return RemoveLock(tile + ToTileIndexDiff(_lock_tomiddle_offs[GetLockPart(tile)][GetLockDirection(tile)]), flags);
597 }
598
599 case WATER_TILE_DEPOT:
600 if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
601 return RemoveShipDepot(tile, flags);
602
603 default:
604 NOT_REACHED();
605 }
606 }
607
616 bool IsWateredTile(TileIndex tile, Direction from)
617 {
618 switch (GetTileType(tile)) {
619 case MP_WATER:
620 switch (GetWaterTileType(tile)) {
621 default: NOT_REACHED();
622 case WATER_TILE_DEPOT: case WATER_TILE_CLEAR: return true;
623 case WATER_TILE_LOCK: return DiagDirToAxis(GetLockDirection(tile)) == DiagDirToAxis(DirToDiagDir(from));
624
625 case WATER_TILE_COAST:
626 switch (GetTileSlope(tile)) {
627 case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
628 case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
629 case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
630 case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);
631 default: return false;
632 }
633 }
634
635 case MP_RAILWAY:
636 if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
637 assert(IsPlainRail(tile));
638 switch (GetTileSlope(tile)) {
639 case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
640 case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
641 case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
642 case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);
643 default: return false;
644 }
645 }
646 return false;
647
648 case MP_STATION:
649 if (IsOilRig(tile)) {
650 /* Do not draw waterborders inside of industries.
651 * Note: There is no easy way to detect the industry of an oilrig tile. */
652 TileIndex src_tile = tile + TileOffsByDir(from);
653 if ((IsTileType(src_tile, MP_STATION) && IsOilRig(src_tile)) ||
654 (IsTileType(src_tile, MP_INDUSTRY))) return true;
655
656 return IsTileOnWater(tile);
657 }
658 return (IsDock(tile) && IsTileFlat(tile)) || IsBuoy(tile);
659
660 case MP_INDUSTRY: {
661 /* Do not draw waterborders inside of industries.
662 * Note: There is no easy way to detect the industry of an oilrig tile. */
663 TileIndex src_tile = tile + TileOffsByDir(from);
664 if ((IsTileType(src_tile, MP_STATION) && IsOilRig(src_tile)) ||
665 (IsTileType(src_tile, MP_INDUSTRY) && GetIndustryIndex(src_tile) == GetIndustryIndex(tile))) return true;
666
667 return IsTileOnWater(tile);
668 }
669
670 case MP_OBJECT: return IsTileOnWater(tile);
671
672 case MP_TUNNELBRIDGE: return GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER && ReverseDiagDir(GetTunnelBridgeDirection(tile)) == DirToDiagDir(from);
673
674 case MP_VOID: return true; // consider map border as water, esp. for rivers
675
676 default: return false;
677 }
678 }
679
687 static void DrawWaterSprite(SpriteID base, uint offset, CanalFeature feature, TileIndex tile)
688 {
689 if (base != SPR_FLAT_WATER_TILE) {
690 /* Only call offset callback if the sprite is NewGRF-provided. */
691 offset = GetCanalSpriteOffset(feature, tile, offset);
692 }
693 DrawGroundSprite(base + offset, PAL_NONE);
694 }
695
702 static void DrawWaterEdges(bool canal, uint offset, TileIndex tile)
703 {
704 CanalFeature feature;
705 SpriteID base = 0;
706 if (canal) {
707 feature = CF_DIKES;
708 base = GetCanalSprite(CF_DIKES, tile);
709 if (base == 0) base = SPR_CANAL_DIKES_BASE;
710 } else {
711 feature = CF_RIVER_EDGE;
712 base = GetCanalSprite(CF_RIVER_EDGE, tile);
713 if (base == 0) return; // Don't draw if no sprites provided.
714 }
715
716 uint wa;
717
718 /* determine the edges around with water. */
719 wa = IsWateredTile(TILE_ADDXY(tile, -1, 0), DIR_SW) << 0;
720 wa += IsWateredTile(TILE_ADDXY(tile, 0, 1), DIR_NW) << 1;
721 wa += IsWateredTile(TILE_ADDXY(tile, 1, 0), DIR_NE) << 2;
722 wa += IsWateredTile(TILE_ADDXY(tile, 0, -1), DIR_SE) << 3;
723
724 if (!(wa & 1)) DrawWaterSprite(base, offset, feature, tile);
725 if (!(wa & 2)) DrawWaterSprite(base, offset + 1, feature, tile);
726 if (!(wa & 4)) DrawWaterSprite(base, offset + 2, feature, tile);
727 if (!(wa & 8)) DrawWaterSprite(base, offset + 3, feature, tile);
728
729 /* right corner */
730 switch (wa & 0x03) {
731 case 0: DrawWaterSprite(base, offset + 4, feature, tile); break;
732 case 3: if (!IsWateredTile(TILE_ADDXY(tile, -1, 1), DIR_W)) DrawWaterSprite(base, offset + 8, feature, tile); break;
733 }
734
735 /* bottom corner */
736 switch (wa & 0x06) {
737 case 0: DrawWaterSprite(base, offset + 5, feature, tile); break;
738 case 6: if (!IsWateredTile(TILE_ADDXY(tile, 1, 1), DIR_N)) DrawWaterSprite(base, offset + 9, feature, tile); break;
739 }
740
741 /* left corner */
742 switch (wa & 0x0C) {
743 case 0: DrawWaterSprite(base, offset + 6, feature, tile); break;
744 case 12: if (!IsWateredTile(TILE_ADDXY(tile, 1, -1), DIR_E)) DrawWaterSprite(base, offset + 10, feature, tile); break;
745 }
746
747 /* upper corner */
748 switch (wa & 0x09) {
749 case 0: DrawWaterSprite(base, offset + 7, feature, tile); break;
750 case 9: if (!IsWateredTile(TILE_ADDXY(tile, -1, -1), DIR_S)) DrawWaterSprite(base, offset + 11, feature, tile); break;
751 }
752 }
753
755 static void DrawSeaWater(TileIndex tile)
756 {
757 DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
758 }
759
761 static void DrawCanalWater(TileIndex tile)
762 {
763 SpriteID image = SPR_FLAT_WATER_TILE;
764 if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
765 /* First water slope sprite is flat water. */
766 image = GetCanalSprite(CF_WATERSLOPE, tile);
767 if (image == 0) image = SPR_FLAT_WATER_TILE;
768 }
769 DrawWaterSprite(image, 0, CF_WATERSLOPE, tile);
770
771 DrawWaterEdges(true, 0, tile);
772 }
773
774 #include "table/water_land.h"
775
785 static void DrawWaterTileStruct(const TileInfo *ti, const DrawTileSeqStruct *dtss, SpriteID base, uint offset, PaletteID palette, CanalFeature feature)
786 {
787 /* Don't draw if buildings are invisible. */
788 if (IsInvisibilitySet(TO_BUILDINGS)) return;
789
790 for (; !dtss->IsTerminator(); dtss++) {
791 uint tile_offs = offset + dtss->image.sprite;
792 if (feature < CF_END) tile_offs = GetCanalSpriteOffset(feature, ti->tile, tile_offs);
793 AddSortableSpriteToDraw(base + tile_offs, palette,
794 ti->x + dtss->delta_x, ti->y + dtss->delta_y,
795 dtss->size_x, dtss->size_y,
796 dtss->size_z, ti->z + dtss->delta_z,
797 IsTransparencySet(TO_BUILDINGS));
798 }
799 }
800
802 static void DrawWaterLock(const TileInfo *ti)
803 {
804 int part = GetLockPart(ti->tile);
805 const DrawTileSprites &dts = _lock_display_data[part][GetLockDirection(ti->tile)];
806
807 /* Draw ground sprite. */
808 SpriteID image = dts.ground.sprite;
809
810 SpriteID water_base = GetCanalSprite(CF_WATERSLOPE, ti->tile);
811 if (water_base == 0) {
812 /* Use default sprites. */
813 water_base = SPR_CANALS_BASE;
814 } else if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
815 /* NewGRF supplies a flat sprite as first sprite. */
816 if (image == SPR_FLAT_WATER_TILE) {
817 image = water_base;
818 } else {
819 image++;
820 }
821 }
822
823 if (image < 5) image += water_base;
824 DrawGroundSprite(image, PAL_NONE);
825
826 /* Draw structures. */
827 uint zoffs = 0;
828 SpriteID base = GetCanalSprite(CF_LOCKS, ti->tile);
829
830 if (base == 0) {
831 /* If no custom graphics, use defaults. */
832 base = SPR_LOCK_BASE;
833 uint8 z_threshold = part == LOCK_PART_UPPER ? 8 : 0;
834 zoffs = ti->z > z_threshold ? 24 : 0;
835 }
836
837 DrawWaterTileStruct(ti, dts.seq, base, zoffs, PAL_NONE, CF_LOCKS);
838 }
839
841 static void DrawWaterDepot(const TileInfo *ti)
842 {
843 DrawWaterClassGround(ti);
844 DrawWaterTileStruct(ti, _shipdepot_display_data[GetShipDepotAxis(ti->tile)][GetShipDepotPart(ti->tile)].seq, 0, 0, COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile)), CF_END);
845 }
846
847 static void DrawRiverWater(const TileInfo *ti)
848 {
849 SpriteID image = SPR_FLAT_WATER_TILE;
850 uint offset = 0;
851 uint edges_offset = 0;
852
853 if (ti->tileh != SLOPE_FLAT || HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
854 image = GetCanalSprite(CF_RIVER_SLOPE, ti->tile);
855 if (image == 0) {
856 switch (ti->tileh) {
857 case SLOPE_NW: image = SPR_WATER_SLOPE_Y_DOWN; break;
858 case SLOPE_SW: image = SPR_WATER_SLOPE_X_UP; break;
859 case SLOPE_SE: image = SPR_WATER_SLOPE_Y_UP; break;
860 case SLOPE_NE: image = SPR_WATER_SLOPE_X_DOWN; break;
861 default: image = SPR_FLAT_WATER_TILE; break;
862 }
863 } else {
864 /* Flag bit 0 indicates that the first sprite is flat water. */
865 offset = HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE) ? 1 : 0;
866
867 switch (ti->tileh) {
868 case SLOPE_SE: edges_offset += 12; break;
869 case SLOPE_NE: offset += 1; edges_offset += 24; break;
870 case SLOPE_SW: offset += 2; edges_offset += 36; break;
871 case SLOPE_NW: offset += 3; edges_offset += 48; break;
872 default: offset = 0; break;
873 }
874
875 offset = GetCanalSpriteOffset(CF_RIVER_SLOPE, ti->tile, offset);
876 }
877 }
878
879 DrawGroundSprite(image + offset, PAL_NONE);
880
881 /* Draw river edges if available. */
882 DrawWaterEdges(false, edges_offset, ti->tile);
883 }
884
885 void DrawShoreTile(Slope tileh)
886 {
887 /* Converts the enum Slope into an offset based on SPR_SHORE_BASE.
888 * This allows to calculate the proper sprite to display for this Slope */
889 static const byte tileh_to_shoresprite[32] = {
890 0, 1, 2, 3, 4, 16, 6, 7, 8, 9, 17, 11, 12, 13, 14, 0,
891 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 10, 15, 0,
892 };
893
894 assert(!IsHalftileSlope(tileh)); // Halftile slopes need to get handled earlier.
895 assert(tileh != SLOPE_FLAT); // Shore is never flat
896
897 assert((tileh != SLOPE_EW) && (tileh != SLOPE_NS)); // No suitable sprites for current flooding behaviour
898
899 DrawGroundSprite(SPR_SHORE_BASE + tileh_to_shoresprite[tileh], PAL_NONE);
900 }
901
902 void DrawWaterClassGround(const TileInfo *ti)
903 {
904 switch (GetWaterClass(ti->tile)) {
905 case WATER_CLASS_SEA: DrawSeaWater(ti->tile); break;
906 case WATER_CLASS_CANAL: DrawCanalWater(ti->tile); break;
907 case WATER_CLASS_RIVER: DrawRiverWater(ti); break;
908 default: NOT_REACHED();
909 }
910 }
911
912 static void DrawTile_Water(TileInfo *ti)
913 {
914 switch (GetWaterTileType(ti->tile)) {
915 case WATER_TILE_CLEAR:
916 DrawWaterClassGround(ti);
917 DrawBridgeMiddle(ti);
918 break;
919
920 case WATER_TILE_COAST: {
921 DrawShoreTile(ti->tileh);
922 DrawBridgeMiddle(ti);
923 break;
924 }
925
926 case WATER_TILE_LOCK:
927 DrawWaterLock(ti);
928 break;
929
930 case WATER_TILE_DEPOT:
931 DrawWaterDepot(ti);
932 break;
933 }
934 }
935
936 void DrawShipDepotSprite(int x, int y, Axis axis, DepotPart part)
937 {
938 const DrawTileSprites &dts = _shipdepot_display_data[axis][part];
939
940 DrawSprite(dts.ground.sprite, dts.ground.pal, x, y);
941 DrawOrigTileSeqInGUI(x, y, &dts, COMPANY_SPRITE_COLOUR(_local_company));
942 }
943
944
945 static int GetSlopePixelZ_Water(TileIndex tile, uint x, uint y)
946 {
947 int z;
948 Slope tileh = GetTilePixelSlope(tile, &z);
949
950 return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
951 }
952
953 static Foundation GetFoundation_Water(TileIndex tile, Slope tileh)
954 {
955 return FOUNDATION_NONE;
956 }
957
958 static void GetTileDesc_Water(TileIndex tile, TileDesc *td)
959 {
960 switch (GetWaterTileType(tile)) {
961 case WATER_TILE_CLEAR:
962 switch (GetWaterClass(tile)) {
963 case WATER_CLASS_SEA: td->str = STR_LAI_WATER_DESCRIPTION_WATER; break;
964 case WATER_CLASS_CANAL: td->str = STR_LAI_WATER_DESCRIPTION_CANAL; break;
965 case WATER_CLASS_RIVER: td->str = STR_LAI_WATER_DESCRIPTION_RIVER; break;
966 default: NOT_REACHED();
967 }
968 break;
969 case WATER_TILE_COAST: td->str = STR_LAI_WATER_DESCRIPTION_COAST_OR_RIVERBANK; break;
970 case WATER_TILE_LOCK : td->str = STR_LAI_WATER_DESCRIPTION_LOCK; break;
971 case WATER_TILE_DEPOT:
972 td->str = STR_LAI_WATER_DESCRIPTION_SHIP_DEPOT;
973 td->build_date = Depot::GetByTile(tile)->build_date;
974 break;
975 default: NOT_REACHED();
976 }
977
978 td->owner[0] = GetTileOwner(tile);
979 }
980
986 static void FloodVehicle(Vehicle *v)
987 {
988 uint pass = v->Crash(true);
989
990 AI::NewEvent(v->owner, new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_FLOODED));
991 Game::NewEvent(new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_FLOODED));
992 SetDParam(0, pass);
993 AddTileNewsItem(STR_NEWS_DISASTER_FLOOD_VEHICLE, NT_ACCIDENT, v->tile);
994 CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
995 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
996 }
997
1004 static Vehicle *FloodVehicleProc(Vehicle *v, void *data)
1005 {
1006 if ((v->vehstatus & VS_CRASHED) != 0) return nullptr;
1007
1008 switch (v->type) {
1009 default: break;
1010
1011 case VEH_AIRCRAFT: {
1012 if (!IsAirportTile(v->tile) || GetTileMaxZ(v->tile) != 0) break;
1013 if (v->subtype == AIR_SHADOW) break;
1014
1015 /* We compare v->z_pos against delta_z + 1 because the shadow
1016 * is at delta_z and the actual aircraft at delta_z + 1. */
1017 const Station *st = Station::GetByTile(v->tile);
1018 const AirportFTAClass *airport = st->airport.GetFTA();
1019 if (v->z_pos != airport->delta_z + 1) break;
1020
1021 FloodVehicle(v);
1022 break;
1023 }
1024
1025 case VEH_TRAIN:
1026 case VEH_ROAD: {
1027 int z = *(int*)data;
1028 if (v->z_pos > z) break;
1029 FloodVehicle(v->First());
1030 break;
1031 }
1032 }
1033
1034 return nullptr;
1035 }
1036
1042 static void FloodVehicles(TileIndex tile)
1043 {
1044 int z = 0;
1045
1046 if (IsAirportTile(tile)) {
1047 const Station *st = Station::GetByTile(tile);
1048 for (TileIndex airport_tile : st->airport) {
1049 if (st->TileBelongsToAirport(airport_tile)) FindVehicleOnPos(airport_tile, &z, &FloodVehicleProc);
1050 }
1051
1052 /* No vehicle could be flooded on this airport anymore */
1053 return;
1054 }
1055
1056 if (!IsBridgeTile(tile)) {
1057 FindVehicleOnPos(tile, &z, &FloodVehicleProc);
1058 return;
1059 }
1060
1061 TileIndex end = GetOtherBridgeEnd(tile);
1062 z = GetBridgePixelHeight(tile);
1063
1064 FindVehicleOnPos(tile, &z, &FloodVehicleProc);
1065 FindVehicleOnPos(end, &z, &FloodVehicleProc);
1066 }
1067
1073 FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
1074 {
1075 /* FLOOD_ACTIVE: 'single-corner-raised'-coast, sea, sea-shipdepots, sea-buoys, sea-docks (water part), rail with flooded halftile, sea-water-industries, sea-oilrigs
1076 * FLOOD_DRYUP: coast with more than one corner raised, coast with rail-track, coast with trees
1077 * FLOOD_PASSIVE: (not used)
1078 * FLOOD_NONE: canals, rivers, everything else
1079 */
1080 switch (GetTileType(tile)) {
1081 case MP_WATER:
1082 if (IsCoast(tile)) {
1083 Slope tileh = GetTileSlope(tile);
1084 return (IsSlopeWithOneCornerRaised(tileh) ? FLOOD_ACTIVE : FLOOD_DRYUP);
1085 }
1086 FALLTHROUGH;
1087 case MP_STATION:
1088 case MP_INDUSTRY:
1089 case MP_OBJECT:
1090 return (GetWaterClass(tile) == WATER_CLASS_SEA) ? FLOOD_ACTIVE : FLOOD_NONE;
1091
1092 case MP_RAILWAY:
1093 if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
1094 return (IsSlopeWithOneCornerRaised(GetTileSlope(tile)) ? FLOOD_ACTIVE : FLOOD_DRYUP);
1095 }
1096 return FLOOD_NONE;
1097
1098 case MP_TREES:
1099 return (GetTreeGround(tile) == TREE_GROUND_SHORE ? FLOOD_DRYUP : FLOOD_NONE);
1100
1101 default:
1102 return FLOOD_NONE;
1103 }
1104 }
1105
1109 void DoFloodTile(TileIndex target)
1110 {
1111 assert(!IsTileType(target, MP_WATER));
1112
1113 bool flooded = false; // Will be set to true if something is changed.
1114
1115 Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
1116
1117 Slope tileh = GetTileSlope(target);
1118 if (tileh != SLOPE_FLAT) {
1119 /* make coast.. */
1120 switch (GetTileType(target)) {
1121 case MP_RAILWAY: {
1122 if (!IsPlainRail(target)) break;
1123 FloodVehicles(target);
1124 flooded = FloodHalftile(target);
1125 break;
1126 }
1127
1128 case MP_TREES:
1129 if (!IsSlopeWithOneCornerRaised(tileh)) {
1130 SetTreeGroundDensity(target, TREE_GROUND_SHORE, 3);
1131 MarkTileDirtyByTile(target);
1132 flooded = true;
1133 break;
1134 }
1135 FALLTHROUGH;
1136
1137 case MP_CLEAR:
1138 if (DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
1139 MakeShore(target);
1140 MarkTileDirtyByTile(target);
1141 flooded = true;
1142 }
1143 break;
1144
1145 default:
1146 break;
1147 }
1148 } else {
1149 /* Flood vehicles */
1150 FloodVehicles(target);
1151
1152 /* flood flat tile */
1153 if (DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
1154 MakeSea(target);
1155 MarkTileDirtyByTile(target);
1156 flooded = true;
1157 }
1158 }
1159
1160 if (flooded) {
1161 /* Mark surrounding canal tiles dirty too to avoid glitches */
1162 MarkCanalsAndRiversAroundDirty(target);
1163
1164 /* update signals if needed */
1165 UpdateSignalsInBuffer();
1166
1167 if (IsPossibleDockingTile(target)) CheckForDockingTile(target);
1168 }
1169
1170 cur_company.Restore();
1171 }
1172
1176 static void DoDryUp(TileIndex tile)
1177 {
1178 Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
1179
1180 switch (GetTileType(tile)) {
1181 case MP_RAILWAY:
1182 assert(IsPlainRail(tile));
1183 assert(GetRailGroundType(tile) == RAIL_GROUND_WATER);
1184
1185 RailGroundType new_ground;
1186 switch (GetTrackBits(tile)) {
1187 case TRACK_BIT_UPPER: new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
1188 case TRACK_BIT_LOWER: new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
1189 case TRACK_BIT_LEFT: new_ground = RAIL_GROUND_FENCE_VERT1; break;
1190 case TRACK_BIT_RIGHT: new_ground = RAIL_GROUND_FENCE_VERT2; break;
1191 default: NOT_REACHED();
1192 }
1193 SetRailGroundType(tile, new_ground);
1194 MarkTileDirtyByTile(tile);
1195 break;
1196
1197 case MP_TREES:
1198 SetTreeGroundDensity(tile, TREE_GROUND_GRASS, 3);
1199 MarkTileDirtyByTile(tile);
1200 break;
1201
1202 case MP_WATER:
1203 assert(IsCoast(tile));
1204
1205 if (DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR).Succeeded()) {
1206 MakeClear(tile, CLEAR_GRASS, 3);
1207 MarkTileDirtyByTile(tile);
1208 }
1209 break;
1210
1211 default: NOT_REACHED();
1212 }
1213
1214 cur_company.Restore();
1215 }
1216
1223 void TileLoop_Water(TileIndex tile)
1224 {
1225 if (IsTileType(tile, MP_WATER)) AmbientSoundEffect(tile);
1226
1227 switch (GetFloodingBehaviour(tile)) {
1228 case FLOOD_ACTIVE:
1229 for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
1230 TileIndex dest = tile + TileOffsByDir(dir);
1231 if (!IsValidTile(dest)) continue;
1232 /* do not try to flood water tiles - increases performance a lot */
1233 if (IsTileType(dest, MP_WATER)) continue;
1234
1235 /* TREE_GROUND_SHORE is the sign of a previous flood. */
1236 if (IsTileType(dest, MP_TREES) && GetTreeGround(dest) == TREE_GROUND_SHORE) continue;
1237
1238 int z_dest;
1239 Slope slope_dest = GetFoundationSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
1240 if (z_dest > 0) continue;
1241
1242 if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue;
1243
1244 DoFloodTile(dest);
1245 }
1246 break;
1247
1248 case FLOOD_DRYUP: {
1249 Slope slope_here = GetFoundationSlope(tile) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
1250 for (uint dir : SetBitIterator(_flood_from_dirs[slope_here])) {
1251 TileIndex dest = tile + TileOffsByDir((Direction)dir);
1252 if (!IsValidTile(dest)) continue;
1253
1254 FloodingBehaviour dest_behaviour = GetFloodingBehaviour(dest);
1255 if ((dest_behaviour == FLOOD_ACTIVE) || (dest_behaviour == FLOOD_PASSIVE)) return;
1256 }
1257 DoDryUp(tile);
1258 break;
1259 }
1260
1261 default: return;
1262 }
1263 }
1264
1265 void ConvertGroundTilesIntoWaterTiles()
1266 {
1267 int z;
1268
1269 for (TileIndex tile = 0; tile < MapSize(); ++tile) {
1270 Slope slope = GetTileSlope(tile, &z);
1271 if (IsTileType(tile, MP_CLEAR) && z == 0) {
1272 /* Make both water for tiles at level 0
1273 * and make shore, as that looks much better
1274 * during the generation. */
1275 switch (slope) {
1276 case SLOPE_FLAT:
1277 MakeSea(tile);
1278 break;
1279
1280 case SLOPE_N:
1281 case SLOPE_E:
1282 case SLOPE_S:
1283 case SLOPE_W:
1284 MakeShore(tile);
1285 break;
1286
1287 default:
1288 for (uint dir : SetBitIterator(_flood_from_dirs[slope & ~SLOPE_STEEP])) {
1289 TileIndex dest = TileAddByDir(tile, (Direction)dir);
1290 Slope slope_dest = GetTileSlope(dest) & ~SLOPE_STEEP;
1291 if (slope_dest == SLOPE_FLAT || IsSlopeWithOneCornerRaised(slope_dest)) {
1292 MakeShore(tile);
1293 break;
1294 }
1295 }
1296 break;
1297 }
1298 }
1299 }
1300 }
1301
1302 static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
1303 {
1304 static const TrackBits coast_tracks[] = {TRACK_BIT_NONE, TRACK_BIT_RIGHT, TRACK_BIT_UPPER, TRACK_BIT_NONE, TRACK_BIT_LEFT, TRACK_BIT_NONE, TRACK_BIT_NONE,
1305 TRACK_BIT_NONE, TRACK_BIT_LOWER, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE, TRACK_BIT_NONE};
1306
1307 TrackBits ts;
1308
1309 if (mode != TRANSPORT_WATER) return 0;
1310
1311 switch (GetWaterTileType(tile)) {
1312 case WATER_TILE_CLEAR: ts = IsTileFlat(tile) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break;
1313 case WATER_TILE_COAST: ts = coast_tracks[GetTileSlope(tile) & 0xF]; break;
1314 case WATER_TILE_LOCK: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break;
1315 case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
1316 default: return 0;
1317 }
1318 if (TileX(tile) == 0) {
1319 /* NE border: remove tracks that connects NE tile edge */
1320 ts &= ~(TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT);
1321 }
1322 if (TileY(tile) == 0) {
1323 /* NW border: remove tracks that connects NW tile edge */
1324 ts &= ~(TRACK_BIT_Y | TRACK_BIT_LEFT | TRACK_BIT_UPPER);
1325 }
1326 return CombineTrackStatus(TrackBitsToTrackdirBits(ts), TRACKDIR_BIT_NONE);
1327 }
1328
1329 static bool ClickTile_Water(TileIndex tile)
1330 {
1331 if (GetWaterTileType(tile) == WATER_TILE_DEPOT) {
1332 ShowDepotWindow(GetShipDepotNorthTile(tile), VEH_SHIP);
1333 return true;
1334 }
1335 return false;
1336 }
1337
1338 static void ChangeTileOwner_Water(TileIndex tile, Owner old_owner, Owner new_owner)
1339 {
1340 if (!IsTileOwner(tile, old_owner)) return;
1341
1342 bool is_lock_middle = IsLock(tile) && GetLockPart(tile) == LOCK_PART_MIDDLE;
1343
1344 /* No need to dirty company windows here, we'll redraw the whole screen anyway. */
1345 if (is_lock_middle) Company::Get(old_owner)->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
1346 if (new_owner != INVALID_OWNER) {
1347 if (is_lock_middle) Company::Get(new_owner)->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
1348 /* Only subtract from the old owner here if the new owner is valid,
1349 * otherwise we clear ship depots and canal water below. */
1350 if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) {
1351 Company::Get(old_owner)->infrastructure.water--;
1352 Company::Get(new_owner)->infrastructure.water++;
1353 }
1354 if (IsShipDepot(tile)) {
1355 Company::Get(old_owner)->infrastructure.water -= LOCK_DEPOT_TILE_FACTOR;
1356 Company::Get(new_owner)->infrastructure.water += LOCK_DEPOT_TILE_FACTOR;
1357 }
1358
1359 SetTileOwner(tile, new_owner);
1360 return;
1361 }
1362
1363 /* Remove depot */
1364 if (IsShipDepot(tile)) DoCommand(tile, 0, 0, DC_EXEC | DC_BANKRUPT, CMD_LANDSCAPE_CLEAR);
1365
1366 /* Set owner of canals and locks ... and also canal under dock there was before.
1367 * Check if the new owner after removing depot isn't OWNER_WATER. */
1368 if (IsTileOwner(tile, old_owner)) {
1369 if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) Company::Get(old_owner)->infrastructure.water--;
1370 SetTileOwner(tile, OWNER_NONE);
1371 }
1372 }
1373
1374 static VehicleEnterTileStatus VehicleEnter_Water(Vehicle *v, TileIndex tile, int x, int y)
1375 {
1376 return VETSB_CONTINUE;
1377 }
1378
1379 static CommandCost TerraformTile_Water(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
1380 {
1381 /* Canals can't be terraformed */
1382 if (IsWaterTile(tile) && IsCanal(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);
1383
1384 return DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
1385 }
1386
1387
1388 extern const TileTypeProcs _tile_type_water_procs = {
1389 DrawTile_Water, // draw_tile_proc
1390 GetSlopePixelZ_Water, // get_slope_z_proc
1391 ClearTile_Water, // clear_tile_proc
1392 nullptr, // add_accepted_cargo_proc
1393 GetTileDesc_Water, // get_tile_desc_proc
1394 GetTileTrackStatus_Water, // get_tile_track_status_proc
1395 ClickTile_Water, // click_tile_proc
1396 nullptr, // animate_tile_proc
1397 TileLoop_Water, // tile_loop_proc
1398 ChangeTileOwner_Water, // change_tile_owner_proc
1399 nullptr, // add_produced_cargo_proc
1400 VehicleEnter_Water, // vehicle_enter_tile_proc
1401 GetFoundation_Water, // get_foundation_proc
1402 TerraformTile_Water, // terraform_tile_proc
1403 };
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:802
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:1042
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:616
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:785
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:597
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:1004
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:761
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:346
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:1042
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:212
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:2650
TileLoop_Water
void TileLoop_Water(TileIndex tile)
Let a water tile floods its diagonal adjoining tiles called from tunnelbridge_cmd,...
Definition: water_cmd.cpp:1223
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:986
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:609
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
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:1109
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:755
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:841
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:1073
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:578
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:687
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:702
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:1176
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