OpenTTD Source: src/water_cmd.cpp Source File

OpenTTD Source 13.1

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 "landscape.h"
12 #include "viewport_func.h"
13 #include "command_func.h"
14 #include "town.h"
15 #include "news_func.h"
16 #include "depot_base.h"
17 #include "depot_func.h"
18 #include "water.h"
19 #include "industry_map.h"
20 #include "newgrf_canal.h"
21 #include "strings_func.h"
22 #include "vehicle_func.h"
23 #include "sound_func.h"
24 #include "company_func.h"
25 #include "clear_map.h"
26 #include "tree_map.h"
27 #include "aircraft.h"
28 #include "effectvehicle_func.h"
29 #include "tunnelbridge_map.h"
30 #include "station_base.h"
31 #include "ai/ai.hpp"
32 #include "game/game.hpp"
33 #include "core/random_func.hpp"
34 #include "core/backup_type.hpp"
35 #include "date_func.h"
36 #include "company_base.h"
37 #include "company_gui.h"
38 #include "newgrf_generic.h"
39 #include "industry.h"
40 #include "water_cmd.h"
41 #include "landscape_cmd.h"
42
43 #include "table/strings.h"
44
45 #include "safeguards.h"
46
50 static const uint8 _flood_from_dirs[] = {
51 (1 << DIR_NW) | (1 << DIR_SW) | (1 << DIR_SE) | (1 << DIR_NE), // SLOPE_FLAT
52 (1 << DIR_NE) | (1 << DIR_SE), // SLOPE_W
53 (1 << DIR_NW) | (1 << DIR_NE), // SLOPE_S
54 (1 << DIR_NE), // SLOPE_SW
55 (1 << DIR_NW) | (1 << DIR_SW), // SLOPE_E
56 0, // SLOPE_EW
57 (1 << DIR_NW), // SLOPE_SE
58 (1 << DIR_N ) | (1 << DIR_NW) | (1 << DIR_NE), // SLOPE_WSE, SLOPE_STEEP_S
59 (1 << DIR_SW) | (1 << DIR_SE), // SLOPE_N
60 (1 << DIR_SE), // SLOPE_NW
61 0, // SLOPE_NS
62 (1 << DIR_E ) | (1 << DIR_NE) | (1 << DIR_SE), // SLOPE_NWS, SLOPE_STEEP_W
63 (1 << DIR_SW), // SLOPE_NE
64 (1 << DIR_S ) | (1 << DIR_SW) | (1 << DIR_SE), // SLOPE_ENW, SLOPE_STEEP_N
65 (1 << DIR_W ) | (1 << DIR_SW) | (1 << DIR_NW), // SLOPE_SEN, SLOPE_STEEP_E
66 };
67
74 static inline void MarkTileDirtyIfCanalOrRiver(TileIndex tile)
75 {
76 if (IsValidTile(tile) && IsTileType(tile, MP_WATER) && (IsCanal(tile) || IsRiver(tile))) MarkTileDirtyByTile(tile);
77 }
78
85 static void MarkCanalsAndRiversAroundDirty(TileIndex tile)
86 {
87 for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
88 MarkTileDirtyIfCanalOrRiver(tile + TileOffsByDir(dir));
89 }
90 }
91
92
100 CommandCost CmdBuildShipDepot(DoCommandFlag flags, TileIndex tile, Axis axis)
101 {
102 if (!IsValidAxis(axis)) return CMD_ERROR;
103 TileIndex tile2 = tile + (axis == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
104
105 if (!HasTileWaterGround(tile) || !HasTileWaterGround(tile2)) {
106 return_cmd_error(STR_ERROR_MUST_BE_BUILT_ON_WATER);
107 }
108
109 if (IsBridgeAbove(tile) || IsBridgeAbove(tile2)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
110
111 if (!IsTileFlat(tile) || !IsTileFlat(tile2)) {
112 /* Prevent depots on rapids */
113 return_cmd_error(STR_ERROR_SITE_UNSUITABLE);
114 }
115
116 if (!Depot::CanAllocateItem()) return CMD_ERROR;
117
118 WaterClass wc1 = GetWaterClass(tile);
119 WaterClass wc2 = GetWaterClass(tile2);
120 CommandCost cost = CommandCost(EXPENSES_CONSTRUCTION, _price[PR_BUILD_DEPOT_SHIP]);
121
122 bool add_cost = !IsWaterTile(tile);
123 CommandCost ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags | DC_AUTO, tile);
124 if (ret.Failed()) return ret;
125 if (add_cost) {
126 cost.AddCost(ret);
127 }
128 add_cost = !IsWaterTile(tile2);
129 ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags | DC_AUTO, tile2);
130 if (ret.Failed()) return ret;
131 if (add_cost) {
132 cost.AddCost(ret);
133 }
134
135 if (flags & DC_EXEC) {
136 Depot *depot = new Depot(tile);
137 depot->build_date = _date;
138
139 uint new_water_infra = 2 * LOCK_DEPOT_TILE_FACTOR;
140 /* Update infrastructure counts after the tile clears earlier.
141 * Clearing object tiles may result in water tiles which are already accounted for in the water infrastructure total.
142 * See: MakeWaterKeepingClass() */
143 if (wc1 == WATER_CLASS_CANAL && !(HasTileWaterClass(tile) && GetWaterClass(tile) == WATER_CLASS_CANAL && IsTileOwner(tile, _current_company))) new_water_infra++;
144 if (wc2 == WATER_CLASS_CANAL && !(HasTileWaterClass(tile2) && GetWaterClass(tile2) == WATER_CLASS_CANAL && IsTileOwner(tile2, _current_company))) new_water_infra++;
145
146 Company::Get(_current_company)->infrastructure.water += new_water_infra;
147 DirtyCompanyInfrastructureWindows(_current_company);
148
149 MakeShipDepot(tile, _current_company, depot->index, DEPOT_PART_NORTH, axis, wc1);
150 MakeShipDepot(tile2, _current_company, depot->index, DEPOT_PART_SOUTH, axis, wc2);
151 CheckForDockingTile(tile);
152 CheckForDockingTile(tile2);
153 MarkTileDirtyByTile(tile);
154 MarkTileDirtyByTile(tile2);
155 MakeDefaultName(depot);
156 }
157
158 return cost;
159 }
160
161 bool IsPossibleDockingTile(TileIndex t)
162 {
163 assert(IsValidTile(t));
164 switch (GetTileType(t)) {
165 case MP_WATER:
166 if (IsLock(t) && GetLockPart(t) == LOCK_PART_MIDDLE) return false;
167 FALLTHROUGH;
168 case MP_RAILWAY:
169 case MP_STATION:
170 case MP_TUNNELBRIDGE:
171 return TrackStatusToTrackBits(GetTileTrackStatus(t, TRANSPORT_WATER, 0)) != TRACK_BIT_NONE;
172
173 default:
174 return false;
175 }
176 }
177
183 void CheckForDockingTile(TileIndex t)
184 {
185 for (DiagDirection d = DIAGDIR_BEGIN; d != DIAGDIR_END; d++) {
186 TileIndex tile = t + TileOffsByDiagDir(d);
187 if (!IsValidTile(tile)) continue;
188
189 if (IsDockTile(tile) && IsValidDockingDirectionForDock(tile, d)) {
190 Station::GetByTile(tile)->docking_station.Add(t);
191 SetDockingTile(t, true);
192 }
193 if (IsTileType(tile, MP_INDUSTRY)) {
194 Station *st = Industry::GetByTile(tile)->neutral_station;
195 if (st != nullptr) {
196 st->docking_station.Add(t);
197 SetDockingTile(t, true);
198 }
199 }
200 if (IsTileType(tile, MP_STATION) && IsOilRig(tile)) {
201 Station::GetByTile(tile)->docking_station.Add(t);
202 SetDockingTile(t, true);
203 }
204 }
205 }
206
207 void MakeWaterKeepingClass(TileIndex tile, Owner o)
208 {
209 WaterClass wc = GetWaterClass(tile);
210
211 /* Autoslope might turn an originally canal or river tile into land */
212 int z;
213 Slope slope = GetTileSlope(tile, &z);
214
215 if (slope != SLOPE_FLAT) {
216 if (wc == WATER_CLASS_CANAL) {
217 /* If we clear the canal, we have to remove it from the infrastructure count as well. */
218 Company *c = Company::GetIfValid(o);
219 if (c != nullptr) {
220 c->infrastructure.water--;
221 DirtyCompanyInfrastructureWindows(c->index);
222 }
223 /* Sloped canals are locks and no natural water remains whatever the slope direction */
224 wc = WATER_CLASS_INVALID;
225 }
226
227 /* Only river water should be restored on appropriate slopes. Other water would be invalid on slopes */
228 if (wc != WATER_CLASS_RIVER || GetInclinedSlopeDirection(slope) == INVALID_DIAGDIR) {
229 wc = WATER_CLASS_INVALID;
230 }
231 }
232
233 if (wc == WATER_CLASS_SEA && z > 0) {
234 /* Update company infrastructure count. */
235 Company *c = Company::GetIfValid(o);
236 if (c != nullptr) {
237 c->infrastructure.water++;
238 DirtyCompanyInfrastructureWindows(c->index);
239 }
240
241 wc = WATER_CLASS_CANAL;
242 }
243
244 /* Zero map array and terminate animation */
245 DoClearSquare(tile);
246
247 /* Maybe change to water */
248 switch (wc) {
249 case WATER_CLASS_SEA: MakeSea(tile); break;
250 case WATER_CLASS_CANAL: MakeCanal(tile, o, Random()); break;
251 case WATER_CLASS_RIVER: MakeRiver(tile, Random()); break;
252 default: break;
253 }
254
255 if (wc != WATER_CLASS_INVALID) CheckForDockingTile(tile);
256 MarkTileDirtyByTile(tile);
257 }
258
259 static CommandCost RemoveShipDepot(TileIndex tile, DoCommandFlag flags)
260 {
261 if (!IsShipDepot(tile)) return CMD_ERROR;
262
263 CommandCost ret = CheckTileOwnership(tile);
264 if (ret.Failed()) return ret;
265
266 TileIndex tile2 = GetOtherShipDepotTile(tile);
267
268 /* do not check for ship on tile when company goes bankrupt */
269 if (!(flags & DC_BANKRUPT)) {
270 CommandCost ret = EnsureNoVehicleOnGround(tile);
271 if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile2);
272 if (ret.Failed()) return ret;
273 }
274
275 if (flags & DC_EXEC) {
276 delete Depot::GetByTile(tile);
277
278 Company *c = Company::GetIfValid(GetTileOwner(tile));
279 if (c != nullptr) {
280 c->infrastructure.water -= 2 * LOCK_DEPOT_TILE_FACTOR;
281 DirtyCompanyInfrastructureWindows(c->index);
282 }
283
284 MakeWaterKeepingClass(tile, GetTileOwner(tile));
285 MakeWaterKeepingClass(tile2, GetTileOwner(tile2));
286 }
287
288 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_DEPOT_SHIP]);
289 }
290
298 static CommandCost DoBuildLock(TileIndex tile, DiagDirection dir, DoCommandFlag flags)
299 {
300 CommandCost cost(EXPENSES_CONSTRUCTION);
301
302 int delta = TileOffsByDiagDir(dir);
303 CommandCost ret = EnsureNoVehicleOnGround(tile);
304 if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
305 if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
306 if (ret.Failed()) return ret;
307
308 /* middle tile */
309 WaterClass wc_middle = HasTileWaterGround(tile) ? GetWaterClass(tile) : WATER_CLASS_CANAL;
310 ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
311 if (ret.Failed()) return ret;
312 cost.AddCost(ret);
313
314 /* lower tile */
315 if (!IsWaterTile(tile - delta)) {
316 ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile - delta);
317 if (ret.Failed()) return ret;
318 cost.AddCost(ret);
319 cost.AddCost(_price[PR_BUILD_CANAL]);
320 }
321 if (!IsTileFlat(tile - delta)) {
322 return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
323 }
324 WaterClass wc_lower = IsWaterTile(tile - delta) ? GetWaterClass(tile - delta) : WATER_CLASS_CANAL;
325
326 /* upper tile */
327 if (!IsWaterTile(tile + delta)) {
328 ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile + delta);
329 if (ret.Failed()) return ret;
330 cost.AddCost(ret);
331 cost.AddCost(_price[PR_BUILD_CANAL]);
332 }
333 if (!IsTileFlat(tile + delta)) {
334 return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
335 }
336 WaterClass wc_upper = IsWaterTile(tile + delta) ? GetWaterClass(tile + delta) : WATER_CLASS_CANAL;
337
338 if (IsBridgeAbove(tile) || IsBridgeAbove(tile - delta) || IsBridgeAbove(tile + delta)) {
339 return_cmd_error(STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST);
340 }
341
342 if (flags & DC_EXEC) {
343 /* Update company infrastructure counts. */
344 Company *c = Company::GetIfValid(_current_company);
345 if (c != nullptr) {
346 /* Counts for the water. */
347 if (!IsWaterTile(tile - delta)) c->infrastructure.water++;
348 if (!IsWaterTile(tile + delta)) c->infrastructure.water++;
349 /* Count for the lock itself. */
350 c->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // Lock is three tiles.
351 DirtyCompanyInfrastructureWindows(_current_company);
352 }
353
354 MakeLock(tile, _current_company, dir, wc_lower, wc_upper, wc_middle);
355 CheckForDockingTile(tile - delta);
356 CheckForDockingTile(tile + delta);
357 MarkTileDirtyByTile(tile);
358 MarkTileDirtyByTile(tile - delta);
359 MarkTileDirtyByTile(tile + delta);
360 MarkCanalsAndRiversAroundDirty(tile - delta);
361 MarkCanalsAndRiversAroundDirty(tile + delta);
362 }
363 cost.AddCost(_price[PR_BUILD_LOCK]);
364
365 return cost;
366 }
367
374 static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
375 {
376 if (GetTileOwner(tile) != OWNER_NONE) {
377 CommandCost ret = CheckTileOwnership(tile);
378 if (ret.Failed()) return ret;
379 }
380
381 TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));
382
383 /* make sure no vehicle is on the tile. */
384 CommandCost ret = EnsureNoVehicleOnGround(tile);
385 if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile + delta);
386 if (ret.Succeeded()) ret = EnsureNoVehicleOnGround(tile - delta);
387 if (ret.Failed()) return ret;
388
389 if (flags & DC_EXEC) {
390 /* Remove middle part from company infrastructure count. */
391 Company *c = Company::GetIfValid(GetTileOwner(tile));
392 if (c != nullptr) {
393 c->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // three parts of the lock.
394 DirtyCompanyInfrastructureWindows(c->index);
395 }
396
397 if (GetWaterClass(tile) == WATER_CLASS_RIVER) {
398 MakeRiver(tile, Random());
399 } else {
400 DoClearSquare(tile);
401 }
402 MakeWaterKeepingClass(tile + delta, GetTileOwner(tile + delta));
403 MakeWaterKeepingClass(tile - delta, GetTileOwner(tile - delta));
404 MarkCanalsAndRiversAroundDirty(tile);
405 MarkCanalsAndRiversAroundDirty(tile - delta);
406 MarkCanalsAndRiversAroundDirty(tile + delta);
407 }
408
409 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_LOCK]);
410 }
411
418 CommandCost CmdBuildLock(DoCommandFlag flags, TileIndex tile)
419 {
420 DiagDirection dir = GetInclinedSlopeDirection(GetTileSlope(tile));
421 if (dir == INVALID_DIAGDIR) return_cmd_error(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION);
422
423 return DoBuildLock(tile, dir, flags);
424 }
425
427 bool RiverModifyDesertZone(TileIndex tile, void *)
428 {
429 if (GetTropicZone(tile) == TROPICZONE_DESERT) SetTropicZone(tile, TROPICZONE_NORMAL);
430 return false;
431 }
432
442 CommandCost CmdBuildCanal(DoCommandFlag flags, TileIndex tile, TileIndex start_tile, WaterClass wc, bool diagonal)
443 {
444 if (start_tile >= MapSize() || !IsValidWaterClass(wc)) return CMD_ERROR;
445
446 /* Outside of the editor you can only build canals, not oceans */
447 if (wc != WATER_CLASS_CANAL && _game_mode != GM_EDITOR) return CMD_ERROR;
448
449 CommandCost cost(EXPENSES_CONSTRUCTION);
450
451 std::unique_ptr<TileIterator> iter;
452 if (diagonal) {
453 iter = std::make_unique<DiagonalTileIterator>(tile, start_tile);
454 } else {
455 iter = std::make_unique<OrthogonalTileIterator>(tile, start_tile);
456 }
457
458 for (; *iter != INVALID_TILE; ++(*iter)) {
459 TileIndex current_tile = *iter;
460 CommandCost ret;
461
462 Slope slope = GetTileSlope(current_tile);
463 if (slope != SLOPE_FLAT && (wc != WATER_CLASS_RIVER || !IsInclinedSlope(slope))) {
464 return_cmd_error(STR_ERROR_FLAT_LAND_REQUIRED);
465 }
466
467 bool water = IsWaterTile(current_tile);
468
469 /* Outside the editor, prevent building canals over your own or OWNER_NONE owned canals */
470 if (water && IsCanal(current_tile) && _game_mode != GM_EDITOR && (IsTileOwner(current_tile, _current_company) || IsTileOwner(current_tile, OWNER_NONE))) continue;
471
472 ret = Command<CMD_LANDSCAPE_CLEAR>::Do(flags, current_tile);
473 if (ret.Failed()) return ret;
474
475 if (!water) cost.AddCost(ret);
476
477 if (flags & DC_EXEC) {
478 switch (wc) {
479 case WATER_CLASS_RIVER:
480 MakeRiver(current_tile, Random());
481 if (_game_mode == GM_EDITOR) {
482 TileIndex tile2 = current_tile;
483 CircularTileSearch(&tile2, RIVER_OFFSET_DESERT_DISTANCE, RiverModifyDesertZone, nullptr);
484 }
485 break;
486
487 case WATER_CLASS_SEA:
488 if (TileHeight(current_tile) == 0) {
489 MakeSea(current_tile);
490 break;
491 }
492 FALLTHROUGH;
493
494 default:
495 /* If we overbuild a water object with a canal, don't update the infrastructure total. */
496 bool is_existing_canal = IsTileType(current_tile, MP_WATER) && IsCanal(current_tile);
497 if (Company::IsValidID(_current_company) && !is_existing_canal) {
498 Company::Get(_current_company)->infrastructure.water++;
499 DirtyCompanyInfrastructureWindows(_current_company);
500 }
501
502 MakeCanal(current_tile, _current_company, Random());
503 break;
504 }
505 MarkTileDirtyByTile(current_tile);
506 MarkCanalsAndRiversAroundDirty(current_tile);
507 CheckForDockingTile(current_tile);
508 }
509
510 cost.AddCost(_price[PR_BUILD_CANAL]);
511 }
512
513 if (cost.GetCost() == 0) {
514 return_cmd_error(STR_ERROR_ALREADY_BUILT);
515 } else {
516 return cost;
517 }
518 }
519
520 static CommandCost ClearTile_Water(TileIndex tile, DoCommandFlag flags)
521 {
522 switch (GetWaterTileType(tile)) {
523 case WATER_TILE_CLEAR: {
524 if (flags & DC_NO_WATER) return_cmd_error(STR_ERROR_CAN_T_BUILD_ON_WATER);
525
526 Money base_cost = IsCanal(tile) ? _price[PR_CLEAR_CANAL] : _price[PR_CLEAR_WATER];
527 /* Make sure freeform edges are allowed or it's not an edge tile. */
528 if (!_settings_game.construction.freeform_edges && (!IsInsideMM(TileX(tile), 1, MapMaxX() - 1) ||
529 !IsInsideMM(TileY(tile), 1, MapMaxY() - 1))) {
530 return_cmd_error(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP);
531 }
532
533 /* Make sure no vehicle is on the tile */
534 CommandCost ret = EnsureNoVehicleOnGround(tile);
535 if (ret.Failed()) return ret;
536
537 Owner owner = GetTileOwner(tile);
538 if (owner != OWNER_WATER && owner != OWNER_NONE) {
539 CommandCost ret = CheckTileOwnership(tile);
540 if (ret.Failed()) return ret;
541 }
542
543 if (flags & DC_EXEC) {
544 if (IsCanal(tile) && Company::IsValidID(owner)) {
545 Company::Get(owner)->infrastructure.water--;
546 DirtyCompanyInfrastructureWindows(owner);
547 }
548 DoClearSquare(tile);
549 MarkCanalsAndRiversAroundDirty(tile);
550 }
551
552 return CommandCost(EXPENSES_CONSTRUCTION, base_cost);
553 }
554
555 case WATER_TILE_COAST: {
556 Slope slope = GetTileSlope(tile);
557
558 /* Make sure no vehicle is on the tile */
559 CommandCost ret = EnsureNoVehicleOnGround(tile);
560 if (ret.Failed()) return ret;
561
562 if (flags & DC_EXEC) {
563 DoClearSquare(tile);
564 MarkCanalsAndRiversAroundDirty(tile);
565 }
566 if (IsSlopeWithOneCornerRaised(slope)) {
567 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_WATER]);
568 } else {
569 return CommandCost(EXPENSES_CONSTRUCTION, _price[PR_CLEAR_ROUGH]);
570 }
571 }
572
573 case WATER_TILE_LOCK: {
574 static const TileIndexDiffC _lock_tomiddle_offs[][DIAGDIR_END] = {
575 /* NE SE SW NW */
576 { { 0, 0}, {0, 0}, { 0, 0}, {0, 0} }, // LOCK_PART_MIDDLE
577 { {-1, 0}, {0, 1}, { 1, 0}, {0, -1} }, // LOCK_PART_LOWER
578 { { 1, 0}, {0, -1}, {-1, 0}, {0, 1} }, // LOCK_PART_UPPER
579 };
580
581 if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
582 if (_current_company == OWNER_WATER) return CMD_ERROR;
583 /* move to the middle tile.. */
584 return RemoveLock(tile + ToTileIndexDiff(_lock_tomiddle_offs[GetLockPart(tile)][GetLockDirection(tile)]), flags);
585 }
586
587 case WATER_TILE_DEPOT:
588 if (flags & DC_AUTO) return_cmd_error(STR_ERROR_BUILDING_MUST_BE_DEMOLISHED);
589 return RemoveShipDepot(tile, flags);
590
591 default:
592 NOT_REACHED();
593 }
594 }
595
604 bool IsWateredTile(TileIndex tile, Direction from)
605 {
606 switch (GetTileType(tile)) {
607 case MP_WATER:
608 switch (GetWaterTileType(tile)) {
609 default: NOT_REACHED();
610 case WATER_TILE_DEPOT: case WATER_TILE_CLEAR: return true;
611 case WATER_TILE_LOCK: return DiagDirToAxis(GetLockDirection(tile)) == DiagDirToAxis(DirToDiagDir(from));
612
613 case WATER_TILE_COAST:
614 switch (GetTileSlope(tile)) {
615 case SLOPE_W: return (from == DIR_SE) || (from == DIR_E) || (from == DIR_NE);
616 case SLOPE_S: return (from == DIR_NE) || (from == DIR_N) || (from == DIR_NW);
617 case SLOPE_E: return (from == DIR_NW) || (from == DIR_W) || (from == DIR_SW);
618 case SLOPE_N: return (from == DIR_SW) || (from == DIR_S) || (from == DIR_SE);
619 default: return false;
620 }
621 }
622
623 case MP_RAILWAY:
624 if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
625 assert(IsPlainRail(tile));
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 return false;
635
636 case MP_STATION:
637 if (IsOilRig(tile)) {
638 /* Do not draw waterborders inside of industries.
639 * Note: There is no easy way to detect the industry of an oilrig tile. */
640 TileIndex src_tile = tile + TileOffsByDir(from);
641 if ((IsTileType(src_tile, MP_STATION) && IsOilRig(src_tile)) ||
642 (IsTileType(src_tile, MP_INDUSTRY))) return true;
643
644 return IsTileOnWater(tile);
645 }
646 return (IsDock(tile) && IsTileFlat(tile)) || IsBuoy(tile);
647
648 case MP_INDUSTRY: {
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) && GetIndustryIndex(src_tile) == GetIndustryIndex(tile))) return true;
654
655 return IsTileOnWater(tile);
656 }
657
658 case MP_OBJECT: return IsTileOnWater(tile);
659
660 case MP_TUNNELBRIDGE: return GetTunnelBridgeTransportType(tile) == TRANSPORT_WATER && ReverseDiagDir(GetTunnelBridgeDirection(tile)) == DirToDiagDir(from);
661
662 case MP_VOID: return true; // consider map border as water, esp. for rivers
663
664 default: return false;
665 }
666 }
667
675 static void DrawWaterSprite(SpriteID base, uint offset, CanalFeature feature, TileIndex tile)
676 {
677 if (base != SPR_FLAT_WATER_TILE) {
678 /* Only call offset callback if the sprite is NewGRF-provided. */
679 offset = GetCanalSpriteOffset(feature, tile, offset);
680 }
681 DrawGroundSprite(base + offset, PAL_NONE);
682 }
683
690 static void DrawWaterEdges(bool canal, uint offset, TileIndex tile)
691 {
692 CanalFeature feature;
693 SpriteID base = 0;
694 if (canal) {
695 feature = CF_DIKES;
696 base = GetCanalSprite(CF_DIKES, tile);
697 if (base == 0) base = SPR_CANAL_DIKES_BASE;
698 } else {
699 feature = CF_RIVER_EDGE;
700 base = GetCanalSprite(CF_RIVER_EDGE, tile);
701 if (base == 0) return; // Don't draw if no sprites provided.
702 }
703
704 uint wa;
705
706 /* determine the edges around with water. */
707 wa = IsWateredTile(TILE_ADDXY(tile, -1, 0), DIR_SW) << 0;
708 wa += IsWateredTile(TILE_ADDXY(tile, 0, 1), DIR_NW) << 1;
709 wa += IsWateredTile(TILE_ADDXY(tile, 1, 0), DIR_NE) << 2;
710 wa += IsWateredTile(TILE_ADDXY(tile, 0, -1), DIR_SE) << 3;
711
712 if (!(wa & 1)) DrawWaterSprite(base, offset, feature, tile);
713 if (!(wa & 2)) DrawWaterSprite(base, offset + 1, feature, tile);
714 if (!(wa & 4)) DrawWaterSprite(base, offset + 2, feature, tile);
715 if (!(wa & 8)) DrawWaterSprite(base, offset + 3, feature, tile);
716
717 /* right corner */
718 switch (wa & 0x03) {
719 case 0: DrawWaterSprite(base, offset + 4, feature, tile); break;
720 case 3: if (!IsWateredTile(TILE_ADDXY(tile, -1, 1), DIR_W)) DrawWaterSprite(base, offset + 8, feature, tile); break;
721 }
722
723 /* bottom corner */
724 switch (wa & 0x06) {
725 case 0: DrawWaterSprite(base, offset + 5, feature, tile); break;
726 case 6: if (!IsWateredTile(TILE_ADDXY(tile, 1, 1), DIR_N)) DrawWaterSprite(base, offset + 9, feature, tile); break;
727 }
728
729 /* left corner */
730 switch (wa & 0x0C) {
731 case 0: DrawWaterSprite(base, offset + 6, feature, tile); break;
732 case 12: if (!IsWateredTile(TILE_ADDXY(tile, 1, -1), DIR_E)) DrawWaterSprite(base, offset + 10, feature, tile); break;
733 }
734
735 /* upper corner */
736 switch (wa & 0x09) {
737 case 0: DrawWaterSprite(base, offset + 7, feature, tile); break;
738 case 9: if (!IsWateredTile(TILE_ADDXY(tile, -1, -1), DIR_S)) DrawWaterSprite(base, offset + 11, feature, tile); break;
739 }
740 }
741
743 static void DrawSeaWater(TileIndex tile)
744 {
745 DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
746 }
747
749 static void DrawCanalWater(TileIndex tile)
750 {
751 SpriteID image = SPR_FLAT_WATER_TILE;
752 if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
753 /* First water slope sprite is flat water. */
754 image = GetCanalSprite(CF_WATERSLOPE, tile);
755 if (image == 0) image = SPR_FLAT_WATER_TILE;
756 }
757 DrawWaterSprite(image, 0, CF_WATERSLOPE, tile);
758
759 DrawWaterEdges(true, 0, tile);
760 }
761
762 #include "table/water_land.h"
763
773 static void DrawWaterTileStruct(const TileInfo *ti, const DrawTileSeqStruct *dtss, SpriteID base, uint offset, PaletteID palette, CanalFeature feature)
774 {
775 /* Don't draw if buildings are invisible. */
776 if (IsInvisibilitySet(TO_BUILDINGS)) return;
777
778 for (; !dtss->IsTerminator(); dtss++) {
779 uint tile_offs = offset + dtss->image.sprite;
780 if (feature < CF_END) tile_offs = GetCanalSpriteOffset(feature, ti->tile, tile_offs);
781 AddSortableSpriteToDraw(base + tile_offs, palette,
782 ti->x + dtss->delta_x, ti->y + dtss->delta_y,
783 dtss->size_x, dtss->size_y,
784 dtss->size_z, ti->z + dtss->delta_z,
785 IsTransparencySet(TO_BUILDINGS));
786 }
787 }
788
790 static void DrawWaterLock(const TileInfo *ti)
791 {
792 int part = GetLockPart(ti->tile);
793 const DrawTileSprites &dts = _lock_display_data[part][GetLockDirection(ti->tile)];
794
795 /* Draw ground sprite. */
796 SpriteID image = dts.ground.sprite;
797
798 SpriteID water_base = GetCanalSprite(CF_WATERSLOPE, ti->tile);
799 if (water_base == 0) {
800 /* Use default sprites. */
801 water_base = SPR_CANALS_BASE;
802 } else if (HasBit(_water_feature[CF_WATERSLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
803 /* NewGRF supplies a flat sprite as first sprite. */
804 if (image == SPR_FLAT_WATER_TILE) {
805 image = water_base;
806 } else {
807 image++;
808 }
809 }
810
811 if (image < 5) image += water_base;
812 DrawGroundSprite(image, PAL_NONE);
813
814 /* Draw structures. */
815 uint zoffs = 0;
816 SpriteID base = GetCanalSprite(CF_LOCKS, ti->tile);
817
818 if (base == 0) {
819 /* If no custom graphics, use defaults. */
820 base = SPR_LOCK_BASE;
821 uint8 z_threshold = part == LOCK_PART_UPPER ? 8 : 0;
822 zoffs = ti->z > z_threshold ? 24 : 0;
823 }
824
825 DrawWaterTileStruct(ti, dts.seq, base, zoffs, PAL_NONE, CF_LOCKS);
826 }
827
829 static void DrawWaterDepot(const TileInfo *ti)
830 {
831 DrawWaterClassGround(ti);
832 DrawWaterTileStruct(ti, _shipdepot_display_data[GetShipDepotAxis(ti->tile)][GetShipDepotPart(ti->tile)].seq, 0, 0, COMPANY_SPRITE_COLOUR(GetTileOwner(ti->tile)), CF_END);
833 }
834
835 static void DrawRiverWater(const TileInfo *ti)
836 {
837 SpriteID image = SPR_FLAT_WATER_TILE;
838 uint offset = 0;
839 uint edges_offset = 0;
840
841 if (ti->tileh != SLOPE_FLAT || HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE)) {
842 image = GetCanalSprite(CF_RIVER_SLOPE, ti->tile);
843 if (image == 0) {
844 switch (ti->tileh) {
845 case SLOPE_NW: image = SPR_WATER_SLOPE_Y_DOWN; break;
846 case SLOPE_SW: image = SPR_WATER_SLOPE_X_UP; break;
847 case SLOPE_SE: image = SPR_WATER_SLOPE_Y_UP; break;
848 case SLOPE_NE: image = SPR_WATER_SLOPE_X_DOWN; break;
849 default: image = SPR_FLAT_WATER_TILE; break;
850 }
851 } else {
852 /* Flag bit 0 indicates that the first sprite is flat water. */
853 offset = HasBit(_water_feature[CF_RIVER_SLOPE].flags, CFF_HAS_FLAT_SPRITE) ? 1 : 0;
854
855 switch (ti->tileh) {
856 case SLOPE_SE: edges_offset += 12; break;
857 case SLOPE_NE: offset += 1; edges_offset += 24; break;
858 case SLOPE_SW: offset += 2; edges_offset += 36; break;
859 case SLOPE_NW: offset += 3; edges_offset += 48; break;
860 default: offset = 0; break;
861 }
862
863 offset = GetCanalSpriteOffset(CF_RIVER_SLOPE, ti->tile, offset);
864 }
865 }
866
867 DrawGroundSprite(image + offset, PAL_NONE);
868
869 /* Draw river edges if available. */
870 DrawWaterEdges(false, edges_offset, ti->tile);
871 }
872
873 void DrawShoreTile(Slope tileh)
874 {
875 /* Converts the enum Slope into an offset based on SPR_SHORE_BASE.
876 * This allows to calculate the proper sprite to display for this Slope */
877 static const byte tileh_to_shoresprite[32] = {
878 0, 1, 2, 3, 4, 16, 6, 7, 8, 9, 17, 11, 12, 13, 14, 0,
879 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 10, 15, 0,
880 };
881
882 assert(!IsHalftileSlope(tileh)); // Halftile slopes need to get handled earlier.
883 assert(tileh != SLOPE_FLAT); // Shore is never flat
884
885 assert((tileh != SLOPE_EW) && (tileh != SLOPE_NS)); // No suitable sprites for current flooding behaviour
886
887 DrawGroundSprite(SPR_SHORE_BASE + tileh_to_shoresprite[tileh], PAL_NONE);
888 }
889
890 void DrawWaterClassGround(const TileInfo *ti)
891 {
892 switch (GetWaterClass(ti->tile)) {
893 case WATER_CLASS_SEA: DrawSeaWater(ti->tile); break;
894 case WATER_CLASS_CANAL: DrawCanalWater(ti->tile); break;
895 case WATER_CLASS_RIVER: DrawRiverWater(ti); break;
896 default: NOT_REACHED();
897 }
898 }
899
900 static void DrawTile_Water(TileInfo *ti)
901 {
902 switch (GetWaterTileType(ti->tile)) {
903 case WATER_TILE_CLEAR:
904 DrawWaterClassGround(ti);
905 DrawBridgeMiddle(ti);
906 break;
907
908 case WATER_TILE_COAST: {
909 DrawShoreTile(ti->tileh);
910 DrawBridgeMiddle(ti);
911 break;
912 }
913
914 case WATER_TILE_LOCK:
915 DrawWaterLock(ti);
916 break;
917
918 case WATER_TILE_DEPOT:
919 DrawWaterDepot(ti);
920 break;
921 }
922 }
923
924 void DrawShipDepotSprite(int x, int y, Axis axis, DepotPart part)
925 {
926 const DrawTileSprites &dts = _shipdepot_display_data[axis][part];
927
928 DrawSprite(dts.ground.sprite, dts.ground.pal, x, y);
929 DrawOrigTileSeqInGUI(x, y, &dts, COMPANY_SPRITE_COLOUR(_local_company));
930 }
931
932
933 static int GetSlopePixelZ_Water(TileIndex tile, uint x, uint y)
934 {
935 int z;
936 Slope tileh = GetTilePixelSlope(tile, &z);
937
938 return z + GetPartialPixelZ(x & 0xF, y & 0xF, tileh);
939 }
940
941 static Foundation GetFoundation_Water(TileIndex tile, Slope tileh)
942 {
943 return FOUNDATION_NONE;
944 }
945
946 static void GetTileDesc_Water(TileIndex tile, TileDesc *td)
947 {
948 switch (GetWaterTileType(tile)) {
949 case WATER_TILE_CLEAR:
950 switch (GetWaterClass(tile)) {
951 case WATER_CLASS_SEA: td->str = STR_LAI_WATER_DESCRIPTION_WATER; break;
952 case WATER_CLASS_CANAL: td->str = STR_LAI_WATER_DESCRIPTION_CANAL; break;
953 case WATER_CLASS_RIVER: td->str = STR_LAI_WATER_DESCRIPTION_RIVER; break;
954 default: NOT_REACHED();
955 }
956 break;
957 case WATER_TILE_COAST: td->str = STR_LAI_WATER_DESCRIPTION_COAST_OR_RIVERBANK; break;
958 case WATER_TILE_LOCK : td->str = STR_LAI_WATER_DESCRIPTION_LOCK; break;
959 case WATER_TILE_DEPOT:
960 td->str = STR_LAI_WATER_DESCRIPTION_SHIP_DEPOT;
961 td->build_date = Depot::GetByTile(tile)->build_date;
962 break;
963 default: NOT_REACHED();
964 }
965
966 td->owner[0] = GetTileOwner(tile);
967 }
968
974 static void FloodVehicle(Vehicle *v)
975 {
976 uint pass = v->Crash(true);
977
978 AI::NewEvent(v->owner, new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_FLOODED));
979 Game::NewEvent(new ScriptEventVehicleCrashed(v->index, v->tile, ScriptEventVehicleCrashed::CRASH_FLOODED));
980 SetDParam(0, pass);
981 AddTileNewsItem(STR_NEWS_DISASTER_FLOOD_VEHICLE, NT_ACCIDENT, v->tile);
982 CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
983 if (_settings_client.sound.disaster) SndPlayVehicleFx(SND_12_EXPLOSION, v);
984 }
985
992 static Vehicle *FloodVehicleProc(Vehicle *v, void *data)
993 {
994 if ((v->vehstatus & VS_CRASHED) != 0) return nullptr;
995
996 switch (v->type) {
997 default: break;
998
999 case VEH_AIRCRAFT: {
1000 if (!IsAirportTile(v->tile) || GetTileMaxZ(v->tile) != 0) break;
1001 if (v->subtype == AIR_SHADOW) break;
1002
1003 /* We compare v->z_pos against delta_z + 1 because the shadow
1004 * is at delta_z and the actual aircraft at delta_z + 1. */
1005 const Station *st = Station::GetByTile(v->tile);
1006 const AirportFTAClass *airport = st->airport.GetFTA();
1007 if (v->z_pos != airport->delta_z + 1) break;
1008
1009 FloodVehicle(v);
1010 break;
1011 }
1012
1013 case VEH_TRAIN:
1014 case VEH_ROAD: {
1015 int z = *(int*)data;
1016 if (v->z_pos > z) break;
1017 FloodVehicle(v->First());
1018 break;
1019 }
1020 }
1021
1022 return nullptr;
1023 }
1024
1030 static void FloodVehicles(TileIndex tile)
1031 {
1032 int z = 0;
1033
1034 if (IsAirportTile(tile)) {
1035 const Station *st = Station::GetByTile(tile);
1036 for (TileIndex airport_tile : st->airport) {
1037 if (st->TileBelongsToAirport(airport_tile)) FindVehicleOnPos(airport_tile, &z, &FloodVehicleProc);
1038 }
1039
1040 /* No vehicle could be flooded on this airport anymore */
1041 return;
1042 }
1043
1044 if (!IsBridgeTile(tile)) {
1045 FindVehicleOnPos(tile, &z, &FloodVehicleProc);
1046 return;
1047 }
1048
1049 TileIndex end = GetOtherBridgeEnd(tile);
1050 z = GetBridgePixelHeight(tile);
1051
1052 FindVehicleOnPos(tile, &z, &FloodVehicleProc);
1053 FindVehicleOnPos(end, &z, &FloodVehicleProc);
1054 }
1055
1061 FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
1062 {
1063 /* FLOOD_ACTIVE: 'single-corner-raised'-coast, sea, sea-shipdepots, sea-buoys, sea-docks (water part), rail with flooded halftile, sea-water-industries, sea-oilrigs
1064 * FLOOD_DRYUP: coast with more than one corner raised, coast with rail-track, coast with trees
1065 * FLOOD_PASSIVE: (not used)
1066 * FLOOD_NONE: canals, rivers, everything else
1067 */
1068 switch (GetTileType(tile)) {
1069 case MP_WATER:
1070 if (IsCoast(tile)) {
1071 Slope tileh = GetTileSlope(tile);
1072 return (IsSlopeWithOneCornerRaised(tileh) ? FLOOD_ACTIVE : FLOOD_DRYUP);
1073 }
1074 FALLTHROUGH;
1075 case MP_STATION:
1076 case MP_INDUSTRY:
1077 case MP_OBJECT:
1078 return (GetWaterClass(tile) == WATER_CLASS_SEA) ? FLOOD_ACTIVE : FLOOD_NONE;
1079
1080 case MP_RAILWAY:
1081 if (GetRailGroundType(tile) == RAIL_GROUND_WATER) {
1082 return (IsSlopeWithOneCornerRaised(GetTileSlope(tile)) ? FLOOD_ACTIVE : FLOOD_DRYUP);
1083 }
1084 return FLOOD_NONE;
1085
1086 case MP_TREES:
1087 return (GetTreeGround(tile) == TREE_GROUND_SHORE ? FLOOD_DRYUP : FLOOD_NONE);
1088
1089 default:
1090 return FLOOD_NONE;
1091 }
1092 }
1093
1097 void DoFloodTile(TileIndex target)
1098 {
1099 assert(!IsTileType(target, MP_WATER));
1100
1101 bool flooded = false; // Will be set to true if something is changed.
1102
1103 Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
1104
1105 Slope tileh = GetTileSlope(target);
1106 if (tileh != SLOPE_FLAT) {
1107 /* make coast.. */
1108 switch (GetTileType(target)) {
1109 case MP_RAILWAY: {
1110 if (!IsPlainRail(target)) break;
1111 FloodVehicles(target);
1112 flooded = FloodHalftile(target);
1113 break;
1114 }
1115
1116 case MP_TREES:
1117 if (!IsSlopeWithOneCornerRaised(tileh)) {
1118 SetTreeGroundDensity(target, TREE_GROUND_SHORE, 3);
1119 MarkTileDirtyByTile(target);
1120 flooded = true;
1121 break;
1122 }
1123 FALLTHROUGH;
1124
1125 case MP_CLEAR:
1126 if (Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC, target).Succeeded()) {
1127 MakeShore(target);
1128 MarkTileDirtyByTile(target);
1129 flooded = true;
1130 }
1131 break;
1132
1133 default:
1134 break;
1135 }
1136 } else {
1137 /* Flood vehicles */
1138 FloodVehicles(target);
1139
1140 /* flood flat tile */
1141 if (Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC, target).Succeeded()) {
1142 MakeSea(target);
1143 MarkTileDirtyByTile(target);
1144 flooded = true;
1145 }
1146 }
1147
1148 if (flooded) {
1149 /* Mark surrounding canal tiles dirty too to avoid glitches */
1150 MarkCanalsAndRiversAroundDirty(target);
1151
1152 /* update signals if needed */
1153 UpdateSignalsInBuffer();
1154
1155 if (IsPossibleDockingTile(target)) CheckForDockingTile(target);
1156 }
1157
1158 cur_company.Restore();
1159 }
1160
1164 static void DoDryUp(TileIndex tile)
1165 {
1166 Backup<CompanyID> cur_company(_current_company, OWNER_WATER, FILE_LINE);
1167
1168 switch (GetTileType(tile)) {
1169 case MP_RAILWAY:
1170 assert(IsPlainRail(tile));
1171 assert(GetRailGroundType(tile) == RAIL_GROUND_WATER);
1172
1173 RailGroundType new_ground;
1174 switch (GetTrackBits(tile)) {
1175 case TRACK_BIT_UPPER: new_ground = RAIL_GROUND_FENCE_HORIZ1; break;
1176 case TRACK_BIT_LOWER: new_ground = RAIL_GROUND_FENCE_HORIZ2; break;
1177 case TRACK_BIT_LEFT: new_ground = RAIL_GROUND_FENCE_VERT1; break;
1178 case TRACK_BIT_RIGHT: new_ground = RAIL_GROUND_FENCE_VERT2; break;
1179 default: NOT_REACHED();
1180 }
1181 SetRailGroundType(tile, new_ground);
1182 MarkTileDirtyByTile(tile);
1183 break;
1184
1185 case MP_TREES:
1186 SetTreeGroundDensity(tile, TREE_GROUND_GRASS, 3);
1187 MarkTileDirtyByTile(tile);
1188 break;
1189
1190 case MP_WATER:
1191 assert(IsCoast(tile));
1192
1193 if (Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC, tile).Succeeded()) {
1194 MakeClear(tile, CLEAR_GRASS, 3);
1195 MarkTileDirtyByTile(tile);
1196 }
1197 break;
1198
1199 default: NOT_REACHED();
1200 }
1201
1202 cur_company.Restore();
1203 }
1204
1211 void TileLoop_Water(TileIndex tile)
1212 {
1213 if (IsTileType(tile, MP_WATER)) AmbientSoundEffect(tile);
1214
1215 switch (GetFloodingBehaviour(tile)) {
1216 case FLOOD_ACTIVE:
1217 for (Direction dir = DIR_BEGIN; dir < DIR_END; dir++) {
1218 TileIndex dest = tile + TileOffsByDir(dir);
1219 if (!IsValidTile(dest)) continue;
1220 /* do not try to flood water tiles - increases performance a lot */
1221 if (IsTileType(dest, MP_WATER)) continue;
1222
1223 /* TREE_GROUND_SHORE is the sign of a previous flood. */
1224 if (IsTileType(dest, MP_TREES) && GetTreeGround(dest) == TREE_GROUND_SHORE) continue;
1225
1226 int z_dest;
1227 Slope slope_dest = GetFoundationSlope(dest, &z_dest) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
1228 if (z_dest > 0) continue;
1229
1230 if (!HasBit(_flood_from_dirs[slope_dest], ReverseDir(dir))) continue;
1231
1232 DoFloodTile(dest);
1233 }
1234 break;
1235
1236 case FLOOD_DRYUP: {
1237 Slope slope_here = GetFoundationSlope(tile) & ~SLOPE_HALFTILE_MASK & ~SLOPE_STEEP;
1238 for (uint dir : SetBitIterator(_flood_from_dirs[slope_here])) {
1239 TileIndex dest = tile + TileOffsByDir((Direction)dir);
1240 if (!IsValidTile(dest)) continue;
1241
1242 FloodingBehaviour dest_behaviour = GetFloodingBehaviour(dest);
1243 if ((dest_behaviour == FLOOD_ACTIVE) || (dest_behaviour == FLOOD_PASSIVE)) return;
1244 }
1245 DoDryUp(tile);
1246 break;
1247 }
1248
1249 default: return;
1250 }
1251 }
1252
1253 void ConvertGroundTilesIntoWaterTiles()
1254 {
1255 int z;
1256
1257 for (TileIndex tile = 0; tile < MapSize(); ++tile) {
1258 Slope slope = GetTileSlope(tile, &z);
1259 if (IsTileType(tile, MP_CLEAR) && z == 0) {
1260 /* Make both water for tiles at level 0
1261 * and make shore, as that looks much better
1262 * during the generation. */
1263 switch (slope) {
1264 case SLOPE_FLAT:
1265 MakeSea(tile);
1266 break;
1267
1268 case SLOPE_N:
1269 case SLOPE_E:
1270 case SLOPE_S:
1271 case SLOPE_W:
1272 MakeShore(tile);
1273 break;
1274
1275 default:
1276 for (uint dir : SetBitIterator(_flood_from_dirs[slope & ~SLOPE_STEEP])) {
1277 TileIndex dest = TileAddByDir(tile, (Direction)dir);
1278 Slope slope_dest = GetTileSlope(dest) & ~SLOPE_STEEP;
1279 if (slope_dest == SLOPE_FLAT || IsSlopeWithOneCornerRaised(slope_dest)) {
1280 MakeShore(tile);
1281 break;
1282 }
1283 }
1284 break;
1285 }
1286 }
1287 }
1288 }
1289
1290 static TrackStatus GetTileTrackStatus_Water(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
1291 {
1292 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,
1293 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};
1294
1295 TrackBits ts;
1296
1297 if (mode != TRANSPORT_WATER) return 0;
1298
1299 switch (GetWaterTileType(tile)) {
1300 case WATER_TILE_CLEAR: ts = IsTileFlat(tile) ? TRACK_BIT_ALL : TRACK_BIT_NONE; break;
1301 case WATER_TILE_COAST: ts = coast_tracks[GetTileSlope(tile) & 0xF]; break;
1302 case WATER_TILE_LOCK: ts = DiagDirToDiagTrackBits(GetLockDirection(tile)); break;
1303 case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
1304 default: return 0;
1305 }
1306 if (TileX(tile) == 0) {
1307 /* NE border: remove tracks that connects NE tile edge */
1308 ts &= ~(TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT);
1309 }
1310 if (TileY(tile) == 0) {
1311 /* NW border: remove tracks that connects NW tile edge */
1312 ts &= ~(TRACK_BIT_Y | TRACK_BIT_LEFT | TRACK_BIT_UPPER);
1313 }
1314 return CombineTrackStatus(TrackBitsToTrackdirBits(ts), TRACKDIR_BIT_NONE);
1315 }
1316
1317 static bool ClickTile_Water(TileIndex tile)
1318 {
1319 if (GetWaterTileType(tile) == WATER_TILE_DEPOT) {
1320 ShowDepotWindow(GetShipDepotNorthTile(tile), VEH_SHIP);
1321 return true;
1322 }
1323 return false;
1324 }
1325
1326 static void ChangeTileOwner_Water(TileIndex tile, Owner old_owner, Owner new_owner)
1327 {
1328 if (!IsTileOwner(tile, old_owner)) return;
1329
1330 bool is_lock_middle = IsLock(tile) && GetLockPart(tile) == LOCK_PART_MIDDLE;
1331
1332 /* No need to dirty company windows here, we'll redraw the whole screen anyway. */
1333 if (is_lock_middle) Company::Get(old_owner)->infrastructure.water -= 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
1334 if (new_owner != INVALID_OWNER) {
1335 if (is_lock_middle) Company::Get(new_owner)->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // Lock has three parts.
1336 /* Only subtract from the old owner here if the new owner is valid,
1337 * otherwise we clear ship depots and canal water below. */
1338 if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) {
1339 Company::Get(old_owner)->infrastructure.water--;
1340 Company::Get(new_owner)->infrastructure.water++;
1341 }
1342 if (IsShipDepot(tile)) {
1343 Company::Get(old_owner)->infrastructure.water -= LOCK_DEPOT_TILE_FACTOR;
1344 Company::Get(new_owner)->infrastructure.water += LOCK_DEPOT_TILE_FACTOR;
1345 }
1346
1347 SetTileOwner(tile, new_owner);
1348 return;
1349 }
1350
1351 /* Remove depot */
1352 if (IsShipDepot(tile)) Command<CMD_LANDSCAPE_CLEAR>::Do(DC_EXEC | DC_BANKRUPT, tile);
1353
1354 /* Set owner of canals and locks ... and also canal under dock there was before.
1355 * Check if the new owner after removing depot isn't OWNER_WATER. */
1356 if (IsTileOwner(tile, old_owner)) {
1357 if (GetWaterClass(tile) == WATER_CLASS_CANAL && !is_lock_middle) Company::Get(old_owner)->infrastructure.water--;
1358 SetTileOwner(tile, OWNER_NONE);
1359 }
1360 }
1361
1362 static VehicleEnterTileStatus VehicleEnter_Water(Vehicle *v, TileIndex tile, int x, int y)
1363 {
1364 return VETSB_CONTINUE;
1365 }
1366
1367 static CommandCost TerraformTile_Water(TileIndex tile, DoCommandFlag flags, int z_new, Slope tileh_new)
1368 {
1369 /* Canals can't be terraformed */
1370 if (IsWaterTile(tile) && IsCanal(tile)) return_cmd_error(STR_ERROR_MUST_DEMOLISH_CANAL_FIRST);
1371
1372 return Command<CMD_LANDSCAPE_CLEAR>::Do(flags, tile);
1373 }
1374
1375
1376 extern const TileTypeProcs _tile_type_water_procs = {
1377 DrawTile_Water, // draw_tile_proc
1378 GetSlopePixelZ_Water, // get_slope_z_proc
1379 ClearTile_Water, // clear_tile_proc
1380 nullptr, // add_accepted_cargo_proc
1381 GetTileDesc_Water, // get_tile_desc_proc
1382 GetTileTrackStatus_Water, // get_tile_track_status_proc
1383 ClickTile_Water, // click_tile_proc
1384 nullptr, // animate_tile_proc
1385 TileLoop_Water, // tile_loop_proc
1386 ChangeTileOwner_Water, // change_tile_owner_proc
1387 nullptr, // add_produced_cargo_proc
1388 VehicleEnter_Water, // vehicle_enter_tile_proc
1389 GetFoundation_Water, // get_foundation_proc
1390 TerraformTile_Water, // terraform_tile_proc
1391 };
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:48
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
SLOPE_SE
@ SLOPE_SE
south and east corner are raised
Definition: slope_type.h:57
LOCK_PART_UPPER
@ LOCK_PART_UPPER
Upper part of a lock.
Definition: water_map.h:78
TROPICZONE_DESERT
@ TROPICZONE_DESERT
Tile is desert.
Definition: tile_type.h:78
Station::docking_station
TileArea docking_station
Tile area the docking tiles cover.
Definition: station_base.h:470
DIR_SW
@ DIR_SW
Southwest.
Definition: direction_type.h:31
IsInsideMM
static constexpr bool IsInsideMM(const T x, const size_t min, const size_t max) noexcept
Checks if a value is in an interval.
Definition: math_func.hpp:204
sound_func.h
TRACK_BIT_NONE
@ TRACK_BIT_NONE
No track.
Definition: track_type.h:39
IsValidAxis
static bool IsValidAxis(Axis d)
Checks if an integer value is a valid Axis.
Definition: direction_func.h:43
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:174
GetOtherShipDepotTile
static TileIndex GetOtherShipDepotTile(TileIndex t)
Get the other tile of the ship depot.
Definition: water_map.h:283
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
HasTileWaterClass
static bool HasTileWaterClass(TileIndex t)
Checks whether the tile has an waterclass associated.
Definition: water_map.h:106
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:28
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
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:319
DrawWaterLock
static void DrawWaterLock(const TileInfo *ti)
Draw a lock tile.
Definition: water_cmd.cpp:790
TileDesc::owner
Owner owner[4]
Name of the owner(s)
Definition: tile_cmd.h:53
Axis
Axis
Allow incrementing of DiagDirDiff variables.
Definition: direction_type.h:125
SLOPE_NW
@ SLOPE_NW
north and west corner are raised
Definition: slope_type.h:55
Station
Station data structure.
Definition: station_base.h:454
company_gui.h
Vehicle::z_pos
int32 z_pos
z coordinate.
Definition: vehicle_base.h:285
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:1030
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:604
DIR_NW
@ DIR_NW
Northwest.
Definition: direction_type.h:33
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:425
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:332
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:35
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:767
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:298
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
INVALID_TILE
static constexpr TileIndex INVALID_TILE
The very nice invalid tile marker.
Definition: tile_type.h:108
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
TileIndex
The index/ID of a Tile.
Definition: tile_type.h:85
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:49
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:773
GetPartialPixelZ
uint GetPartialPixelZ(int x, int y, Slope corners)
Determines height at given coordinate of a slope.
Definition: landscape.cpp:219
aircraft.h
DrawBridgeMiddle
void DrawBridgeMiddle(const TileInfo *ti)
Draw the middle bits of a bridge.
Definition: tunnelbridge_cmd.cpp:1543
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:53
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:206
DC_NO_WATER
@ DC_NO_WATER
don't allow building on water
Definition: command_type.h:360
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:56
TRANSPORT_WATER
@ TRANSPORT_WATER
Transport over water.
Definition: transport_type.h:29
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
SLOPE_S
@ SLOPE_S
the south corner of the tile is raised
Definition: slope_type.h:51
Company::infrastructure
CompanyInfrastructure infrastructure
NOSAVE: Counts of company owned infrastructure.
Definition: company_base.h:130
DIR_W
@ DIR_W
West.
Definition: direction_type.h:32
clear_map.h
VEH_ROAD
@ VEH_ROAD
Road vehicle type.
Definition: vehicle_type.h:25
Vehicle
Vehicle data structure.
Definition: vehicle_base.h:224
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:288
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:357
DIR_N
@ DIR_N
North.
Definition: direction_type.h:26
WATER_CLASS_INVALID
@ WATER_CLASS_INVALID
Used for industry tiles on land (also for oilrig if newgrf says so).
Definition: water_map.h:51
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
SLOPE_E
@ SLOPE_E
the east corner of the tile is raised
Definition: slope_type.h:52
DoCommandFlag
DoCommandFlag
List of flags for a command.
Definition: command_type.h:355
Foundation
Foundation
Enumeration for Foundations.
Definition: slope_type.h:93
CmdBuildLock
CommandCost CmdBuildLock(DoCommandFlag flags, TileIndex tile)
Builds a lock.
Definition: water_cmd.cpp:418
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
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:151
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:331
DEPOT_PART_NORTH
@ DEPOT_PART_NORTH
Northern part of a depot.
Definition: water_map.h:69
GetTileTrackStatus
TrackStatus GetTileTrackStatus(TileIndex tile, TransportType mode, uint sub_mode, DiagDirection side)
Returns information about trackdirs and signal states.
Definition: landscape.cpp:601
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
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:141
GetShipDepotNorthTile
static TileIndex GetShipDepotNorthTile(TileIndex t)
Get the most northern tile of a ship depot.
Definition: water_map.h:294
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 two tiles from a TileIndexDiffC struct.
Definition: map_func.h:230
Slope
Slope
Enumeration for the slope-type.
Definition: slope_type.h:48
WATER_TILE_COAST
@ WATER_TILE_COAST
Coast.
Definition: water_map.h:41
DrawTileSeqStruct::delta_x
int8 delta_x
0x80 is sequence terminator
Definition: sprite.h:26
depot_base.h
landscape_cmd.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:38
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:236
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:24
HasTileWaterGround
static bool HasTileWaterGround(TileIndex t)
Checks whether the tile has water at the ground.
Definition: water_map.h:355
WaterClass
WaterClass
classes of water (for WATER_TILE_CLEAR water tile type).
Definition: water_map.h:47
SetBitIterator
Iterable ensemble of each set bit in a value.
Definition: bitmath_func.hpp:329
_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:607
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:992
SLOPE_NE
@ SLOPE_NE
north and east corner are raised
Definition: slope_type.h:58
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:507
DirtyCompanyInfrastructureWindows
void DirtyCompanyInfrastructureWindows(CompanyID company)
Redraw all windows with company infrastructure counts.
Definition: company_gui.cpp:2772
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 two tiles.
Definition: map_func.h:154
Vehicle::tile
TileIndex tile
Current tile index.
Definition: vehicle_base.h:245
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:749
MP_OBJECT
@ MP_OBJECT
Contains objects such as transmitters and owned land.
Definition: tile_type.h:58
TransportType
TransportType
Available types of transport.
Definition: transport_type.h:19
VS_CRASHED
@ VS_CRASHED
Vehicle is crashed.
Definition: vehicle_base.h:41
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
MP_WATER
@ MP_WATER
Water tile.
Definition: tile_type.h:54
CommandCost::Failed
bool Failed() const
Did this command fail?
Definition: command_type.h:160
WATER_CLASS_CANAL
@ WATER_CLASS_CANAL
Canal.
Definition: water_map.h:49
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:427
Station::airport
Airport airport
Tile area the airport covers.
Definition: station_base.h:468
IsShipDepot
static bool IsShipDepot(TileIndex t)
Is it a water tile with a ship depot on it?
Definition: water_map.h:227
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:76
IsValidWaterClass
static bool IsValidWaterClass(WaterClass wc)
Checks if a water class is valid.
Definition: water_map.h:62
_settings_game
GameSettings _settings_game
Game settings of a running game or the scenario editor.
Definition: settings.cpp:54
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:146
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:366
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:354
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:83
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:1058
MP_TUNNELBRIDGE
@ MP_TUNNELBRIDGE
Tunnel entry/exit and bridge heads.
Definition: tile_type.h:57
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:218
FOUNDATION_NONE
@ FOUNDATION_NONE
The tile has no foundation, the slope remains unchanged.
Definition: slope_type.h:94
SLOPE_NS
@ SLOPE_NS
north and south corner are raised
Definition: slope_type.h:60
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:85
WATER_CLASS_RIVER
@ WATER_CLASS_RIVER
River.
Definition: water_map.h:50
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:426
TRACK_BIT_ALL
@ TRACK_BIT_ALL
All possible tracks.
Definition: track_type.h:53
SLOPE_HALFTILE_MASK
@ SLOPE_HALFTILE_MASK
three bits used for halftile slopes
Definition: slope_type.h:72
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:63
TRACK_BIT_LOWER
@ TRACK_BIT_LOWER
Lower track.
Definition: track_type.h:43
GetShipDepotPart
static DepotPart GetShipDepotPart(TileIndex t)
Get the part of a ship depot.
Definition: water_map.h:260
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:363
IsValidDockingDirectionForDock
bool IsValidDockingDirectionForDock(TileIndex t, DiagDirection d)
Check if a dock tile can be docked from the given direction.
Definition: station_cmd.cpp:2605
WATER_CLASS_SEA
@ WATER_CLASS_SEA
Sea.
Definition: water_map.h:48
TileLoop_Water
void TileLoop_Water(TileIndex tile)
Let a water tile floods its diagonal adjoining tiles called from tunnelbridge_cmd,...
Definition: water_cmd.cpp:1211
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:667
TREE_GROUND_GRASS
@ TREE_GROUND_GRASS
normal grass
Definition: tree_map.h:53
SLOPE_W
@ SLOPE_W
the west corner of the tile is raised
Definition: slope_type.h:50
RAIL_GROUND_WATER
@ RAIL_GROUND_WATER
Grass with a fence and shore or water on the free halftile.
Definition: rail_map.h:499
MP_TREES
@ MP_TREES
Tile got trees.
Definition: tile_type.h:52
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:183
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:70
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:245
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
NT_ACCIDENT
@ NT_ACCIDENT
An accident or disaster has occurred.
Definition: news_type.h:24
FloodVehicle
static void FloodVehicle(Vehicle *v)
Handle the flooding of a vehicle.
Definition: water_cmd.cpp:974
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:623
GetWaterClass
static WaterClass GetWaterClass(TileIndex t)
Get the water class at a tile.
Definition: water_map.h:117
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:1097
SLOPE_EW
@ SLOPE_EW
east and west corner are raised
Definition: slope_type.h:59
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:743
MP_VOID
@ MP_VOID
Invisible tiles at the SW and SE border.
Definition: tile_type.h:55
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:88
SLOPE_N
@ SLOPE_N
the north corner of the tile is raised
Definition: slope_type.h:53
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:461
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:195
PaletteID
uint32 PaletteID
The number of the palette.
Definition: gfx_type.h:18
SLOPE_SW
@ SLOPE_SW
south and west corner are raised
Definition: slope_type.h:56
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:1998
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:386
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:53
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:237
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
IsLock
static bool IsLock(TileIndex t)
Is there a lock on a given water tile?
Definition: water_map.h:308
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:248
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:358
company_func.h
IsRiver
static bool IsRiver(TileIndex t)
Is it a river water tile?
Definition: water_map.h:185
MapMaxX
static uint MapMaxX()
Gets the maximum X coordinate within the map, including MP_VOID.
Definition: map_func.h:102
AXIS_X
@ AXIS_X
The X axis.
Definition: direction_type.h:126
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:50
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:829
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:342
CheckTileOwnership
CommandCost CheckTileOwnership(TileIndex tile)
Check whether the current owner owns the stuff on the given tile.
Definition: company_cmd.cpp:334
CommandHelper
Definition: command_func.h:94
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:446
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
RemoveLock
static CommandCost RemoveLock(TileIndex tile, DoCommandFlag flags)
Remove a lock.
Definition: water_cmd.cpp:374
GetFloodingBehaviour
FloodingBehaviour GetFloodingBehaviour(TileIndex tile)
Returns the behaviour of a tile during flooding.
Definition: water_cmd.cpp:1061
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:588
IsInclinedSlope
static bool IsInclinedSlope(Slope s)
Tests if a specific slope is an inclined slope.
Definition: slope_func.h:228
CmdBuildShipDepot
CommandCost CmdBuildShipDepot(DoCommandFlag flags, TileIndex tile, Axis axis)
Build a ship depot.
Definition: water_cmd.cpp:100
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
TROPICZONE_NORMAL
@ TROPICZONE_NORMAL
Normal tropiczone.
Definition: tile_type.h:77
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
CmdBuildCanal
CommandCost CmdBuildCanal(DoCommandFlag flags, TileIndex tile, TileIndex start_tile, WaterClass wc, bool diagonal)
Build a piece of canal.
Definition: water_cmd.cpp:442
SLOPE_FLAT
@ SLOPE_FLAT
a flat tile
Definition: slope_type.h:49
ShowDepotWindow
void ShowDepotWindow(TileIndex tile, VehicleType type)
Opens a depot window.
Definition: depot_gui.cpp:1149
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:117
DepotPart
DepotPart
Sections of the water depot.
Definition: water_map.h:68
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:675
SLOPE_STEEP
@ SLOPE_STEEP
indicates the slope is steep
Definition: slope_type.h:54
VehicleEnterTileStatus
VehicleEnterTileStatus
The returned bits of VehicleEnterTile.
Definition: tile_cmd.h:20
DrawWaterEdges
static void DrawWaterEdges(bool canal, uint offset, TileIndex tile)
Draw canal or river edges.
Definition: water_cmd.cpp:690
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:583
MakeRiver
static void MakeRiver(TileIndex t, uint8 random_bits)
Make a river tile.
Definition: water_map.h:435
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:74
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
water_cmd.h
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:1164
backup_type.hpp
CanalFeature
CanalFeature
List of different canal 'features'.
Definition: newgrf.h:25