tron@2186: /* $Id$ */
tron@2186: 
belugas@6928: /** @file water_cmd.cpp */
belugas@6928: 
truelight@0: #include "stdafx.h"
Darkvater@1891: #include "openttd.h"
tron@3189: #include "bridge_map.h"
rubidium@6486: #include "bridge.h"
tron@6460: #include "cmd_helper.h"
tron@3338: #include "station_map.h"
tron@1363: #include "table/sprites.h"
tron@507: #include "table/strings.h"
tron@2163: #include "functions.h"
maedhros@6949: #include "landscape.h"
tron@679: #include "map.h"
tron@1209: #include "tile.h"
truelight@0: #include "vehicle.h"
truelight@0: #include "viewport.h"
truelight@0: #include "command.h"
truelight@0: #include "town.h"
darkvater@149: #include "news.h"
tron@337: #include "sound.h"
truelight@1313: #include "depot.h"
matthijs@1752: #include "vehicle_gui.h"
bjarni@2676: #include "train.h"
maedhros@7353: #include "roadveh.h"
tron@3111: #include "water_map.h"
peter1138@5210: #include "newgrf.h"
peter1138@7079: #include "newgrf_canal.h"
darkvater@149: 
celestar@5573: static const SpriteID _water_shore_sprites[] = {
tron@2517: 	0,
tron@2517: 	SPR_SHORE_TILEH_1,
tron@2517: 	SPR_SHORE_TILEH_2,
tron@2517: 	SPR_SHORE_TILEH_3,
tron@2517: 	SPR_SHORE_TILEH_4,
tron@2517: 	0,
tron@2517: 	SPR_SHORE_TILEH_6,
tron@2517: 	0,
tron@2517: 	SPR_SHORE_TILEH_8,
tron@2517: 	SPR_SHORE_TILEH_9,
tron@2517: 	0,
tron@2517: 	0,
tron@2517: 	SPR_SHORE_TILEH_12,
tron@2517: 	0,
tron@2517: 	0
ludde@2261: };
ludde@2261: 
ludde@2261: 
rubidium@6191: static Vehicle *FindFloodableVehicleOnTile(TileIndex tile);
darkvater@149: static void FloodVehicle(Vehicle *v);
truelight@0: 
Darkvater@1784: /** Build a ship depot.
tron@3491:  * @param tile tile where ship depot is built
belugas@6928:  * @param flags type of operation
tron@6460:  * @param p1 bit 0 depot orientation (Axis)
Darkvater@1784:  * @param p2 unused
truelight@0:  */
rubidium@7439: CommandCost CmdBuildShipDepot(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
tron@3491: 	TileIndex tile2;
truelight@193: 
rubidium@7439: 	CommandCost cost, ret;
truelight@1313: 	Depot *depot;
truelight@0: 
truelight@0: 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
truelight@0: 
Darkvater@1784: 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
truelight@0: 
tron@6460: 	Axis axis = Extract<Axis, 0>(p1);
tron@6460: 
tron@6460: 	tile2 = tile + (axis == AXIS_X ? TileDiffXY(1, 0) : TileDiffXY(0, 1));
Darkvater@1784: 	if (!EnsureNoVehicle(tile2)) return CMD_ERROR;
truelight@0: 
truelight@0: 	if (!IsClearWaterTile(tile) || !IsClearWaterTile(tile2))
truelight@0: 		return_cmd_error(STR_3801_MUST_BE_BUILT_ON_WATER);
truelight@0: 
celestar@5573: 	if (IsBridgeAbove(tile) || IsBridgeAbove(tile2)) return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
celestar@5573: 
tron@3491: 	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
Darkvater@1784: 	if (CmdFailed(ret)) return CMD_ERROR;
tron@3491: 	ret = DoCommand(tile2, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
Darkvater@1784: 	if (CmdFailed(ret)) return CMD_ERROR;
truelight@193: 
truelight@1313: 	depot = AllocateDepot();
Darkvater@1784: 	if (depot == NULL) return CMD_ERROR;
truelight@0: 
truelight@0: 	if (flags & DC_EXEC) {
truelight@1313: 		depot->xy = tile;
truelight@1313: 		depot->town_index = ClosestTownFromTile(tile, (uint)-1)->index;
truelight@0: 
tron@6460: 		MakeShipDepot(tile,  _current_player, DEPOT_NORTH, axis);
tron@6460: 		MakeShipDepot(tile2, _current_player, DEPOT_SOUTH, axis);
celestar@3372: 		MarkTileDirtyByTile(tile);
celestar@3372: 		MarkTileDirtyByTile(tile2);
truelight@0: 	}
truelight@0: 
rubidium@7446: 	return cost.AddCost(_price.build_ship_depot);
truelight@0: }
truelight@0: 
rubidium@7439: static CommandCost RemoveShipDepot(TileIndex tile, uint32 flags)
truelight@0: {
tron@1977: 	TileIndex tile2;
truelight@0: 
celestar@3373: 	if (!IsShipDepot(tile)) return CMD_ERROR;
tron@2951: 	if (!CheckTileOwnership(tile)) return CMD_ERROR;
tron@2951: 	if (!EnsureNoVehicle(tile)) return CMD_ERROR;
truelight@0: 
celestar@3373: 	tile2 = GetOtherShipDepotTile(tile);
truelight@0: 
tron@2951: 	if (!EnsureNoVehicle(tile2)) return CMD_ERROR;
truelight@0: 
truelight@0: 	if (flags & DC_EXEC) {
celestar@3373: 		/* Kill the depot, which is registered at the northernmost tile. Use that one */
truelight@4388: 		DeleteDepot(GetDepotByTile(tile2 < tile ? tile2 : tile));
truelight@0: 
tron@3111: 		MakeWater(tile);
tron@3111: 		MakeWater(tile2);
tron@3111: 		MarkTileDirtyByTile(tile);
tron@3111: 		MarkTileDirtyByTile(tile2);
truelight@0: 	}
truelight@0: 
rubidium@7446: 	return CommandCost(_price.remove_ship_depot);
truelight@0: }
truelight@0: 
belugas@6928: /** build a shiplift */
rubidium@7439: static CommandCost DoBuildShiplift(TileIndex tile, DiagDirection dir, uint32 flags)
truelight@0: {
rubidium@7439: 	CommandCost ret;
truelight@0: 	int delta;
truelight@0: 
belugas@6928: 	/* middle tile */
tron@3491: 	ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
peter1138@2737: 	if (CmdFailed(ret)) return CMD_ERROR;
truelight@193: 
Darkvater@4559: 	delta = TileOffsByDiagDir(dir);
belugas@6928: 	/* lower tile */
tron@3491: 	ret = DoCommand(tile - delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
peter1138@2737: 	if (CmdFailed(ret)) return CMD_ERROR;
tron@3636: 	if (GetTileSlope(tile - delta, NULL) != SLOPE_FLAT) {
tron@3636: 		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
tron@3636: 	}
truelight@0: 
belugas@6928: 	/* upper tile */
tron@3491: 	ret = DoCommand(tile + delta, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
peter1138@2737: 	if (CmdFailed(ret)) return CMD_ERROR;
tron@3636: 	if (GetTileSlope(tile + delta, NULL) != SLOPE_FLAT) {
tron@3636: 		return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
tron@3636: 	}
truelight@0: 
celestar@5573: 	if ((MayHaveBridgeAbove(tile) && IsBridgeAbove(tile)) ||
celestar@5573: 	    (MayHaveBridgeAbove(tile - delta) && IsBridgeAbove(tile - delta)) ||
celestar@5573: 	    (MayHaveBridgeAbove(tile + delta) && IsBridgeAbove(tile + delta))) {
celestar@5573: 		return_cmd_error(STR_5007_MUST_DEMOLISH_BRIDGE_FIRST);
celestar@5573: 	}
celestar@5573: 
truelight@0: 	if (flags & DC_EXEC) {
peter1138@3940: 		MakeLock(tile, _current_player, dir);
celestar@3372: 		MarkTileDirtyByTile(tile);
celestar@3372: 		MarkTileDirtyByTile(tile - delta);
celestar@3372: 		MarkTileDirtyByTile(tile + delta);
truelight@0: 	}
truelight@0: 
rubidium@7446: 	return CommandCost(_price.clear_water * 22 >> 3);
truelight@0: }
truelight@0: 
rubidium@7439: static CommandCost RemoveShiplift(TileIndex tile, uint32 flags)
truelight@0: {
Darkvater@4559: 	TileIndexDiff delta = TileOffsByDiagDir(GetLockDirection(tile));
truelight@0: 
peter1138@3940: 	if (!CheckTileOwnership(tile)) return CMD_ERROR;
peter1138@3940: 
belugas@6928: 	/* make sure no vehicle is on the tile. */
truelight@0: 	if (!EnsureNoVehicle(tile) || !EnsureNoVehicle(tile + delta) || !EnsureNoVehicle(tile - delta))
truelight@0: 		return CMD_ERROR;
truelight@0: 
truelight@0: 	if (flags & DC_EXEC) {
truelight@0: 		DoClearSquare(tile);
truelight@0: 		DoClearSquare(tile + delta);
truelight@0: 		DoClearSquare(tile - delta);
truelight@0: 	}
truelight@193: 
rubidium@7446: 	return CommandCost(_price.clear_water * 2);
truelight@0: }
truelight@0: 
tron@1977: static void MarkTilesAroundDirty(TileIndex tile)
truelight@0: {
truelight@0: 	MarkTileDirtyByTile(TILE_ADDXY(tile, 0, 1));
truelight@0: 	MarkTileDirtyByTile(TILE_ADDXY(tile, 0, -1));
truelight@0: 	MarkTileDirtyByTile(TILE_ADDXY(tile, 1, 0));
truelight@0: 	MarkTileDirtyByTile(TILE_ADDXY(tile, -1, 0));
truelight@0: }
truelight@0: 
Darkvater@1796: /** Builds a lock (ship-lift)
tron@3491:  * @param tile tile where to place the lock
belugas@6928:  * @param flags type of operation
Darkvater@1796:  * @param p1 unused
Darkvater@1796:  * @param p2 unused
Darkvater@1796:  */
rubidium@7439: CommandCost CmdBuildLock(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
tron@3157: 	DiagDirection dir;
darkvater@889: 
darkvater@889: 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
truelight@0: 
tron@3157: 	switch (GetTileSlope(tile, NULL)) {
tron@3636: 		case SLOPE_SW: dir = DIAGDIR_SW; break;
tron@3636: 		case SLOPE_SE: dir = DIAGDIR_SE; break;
tron@3636: 		case SLOPE_NW: dir = DIAGDIR_NW; break;
tron@3636: 		case SLOPE_NE: dir = DIAGDIR_NE; break;
tron@3157: 		default: return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
Darkvater@1796: 	}
tron@3157: 	return DoBuildShiplift(tile, dir, flags);
truelight@0: }
truelight@0: 
Darkvater@1796: /** Build a piece of canal.
tron@3491:  * @param tile end tile of stretch-dragging
belugas@6928:  * @param flags type of operation
Darkvater@1796:  * @param p1 start tile of stretch-dragging
rubidium@6612:  * @param p2 ctrl pressed - toggles ocean / canals at sealevel (ocean only allowed in the scenario editor)
Darkvater@1796:  */
rubidium@7439: CommandCost CmdBuildCanal(TileIndex tile, uint32 flags, uint32 p1, uint32 p2)
truelight@0: {
rubidium@7439: 	CommandCost cost;
Darkvater@1632: 	int size_x, size_y;
tron@3491: 	int x;
tron@3491: 	int y;
Darkvater@1796: 	int sx, sy;
Darkvater@1796: 
tron@2934: 	if (p1 >= MapSize()) return CMD_ERROR;
rubidium@6612: 	/* Outside of the editor you can only build canals, not oceans */
rubidium@6612: 	if (HASBIT(p2, 0) && _game_mode != GM_EDITOR) return CMD_ERROR;
Darkvater@1796: 
tron@3491: 	x = TileX(tile);
tron@3491: 	y = TileY(tile);
Darkvater@1796: 	sx = TileX(p1);
Darkvater@1796: 	sy = TileY(p1);
Darkvater@1632: 
truelight@0: 	SET_EXPENSES_TYPE(EXPENSES_CONSTRUCTION);
truelight@0: 
tron@6432: 	if (x < sx) Swap(x, sx);
tron@6432: 	if (y < sy) Swap(y, sy);
Darkvater@1632: 	size_x = (x - sx) + 1;
Darkvater@1632: 	size_y = (y - sy) + 1;
truelight@193: 
Darkvater@1796: 	/* Outside the editor you can only drag canals, and not areas */
Darkvater@1796: 	if (_game_mode != GM_EDITOR && (sx != x && sy != y)) return CMD_ERROR;
Darkvater@1796: 
tron@1981: 	BEGIN_TILE_LOOP(tile, size_x, size_y, TileXY(sx, sy)) {
rubidium@7439: 		CommandCost ret;
celestar@5573: 
tron@3636: 		if (GetTileSlope(tile, NULL) != SLOPE_FLAT) {
tron@3636: 			return_cmd_error(STR_0007_FLAT_LAND_REQUIRED);
tron@3636: 		}
truelight@0: 
belugas@6928: 		/* can't make water of water! */
peter1138@4087: 		if (IsTileType(tile, MP_WATER) && (!IsTileOwner(tile, OWNER_WATER) || HASBIT(p2, 0))) continue;
Darkvater@1632: 
celestar@5573: 		ret = DoCommand(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
celestar@5573: 		if (CmdFailed(ret)) return ret;
rubidium@7446: 		cost.AddCost(ret);
tron@3183: 
tron@3189: 		if (flags & DC_EXEC) {
Darkvater@5767: 			if (TileHeight(tile) == 0 && HASBIT(p2, 0)) {
celestar@5573: 				MakeWater(tile);
celestar@5573: 			} else {
celestar@5573: 				MakeCanal(tile, _current_player);
celestar@5573: 			}
tron@3189: 			MarkTileDirtyByTile(tile);
tron@3189: 			MarkTilesAroundDirty(tile);
tron@3189: 		}
tron@3183: 
rubidium@7446: 		cost.AddCost(_price.clear_water);
Darkvater@1632: 	} END_TILE_LOOP(tile, size_x, size_y, 0);
truelight@0: 
rubidium@7446: 	if (cost.GetCost() == 0) {
tron@3183: 		return_cmd_error(STR_1007_ALREADY_BUILT);
tron@3183: 	} else {
tron@3183: 		return cost;
tron@3183: 	}
truelight@0: }
truelight@0: 
rubidium@7439: static CommandCost ClearTile_Water(TileIndex tile, byte flags)
tron@1977: {
celestar@3425: 	switch (GetWaterTileType(tile)) {
rubidium@6507: 		case WATER_TILE_CLEAR:
celestar@3425: 			if (flags & DC_NO_WATER) return_cmd_error(STR_3807_CAN_T_BUILD_ON_WATER);
truelight@0: 
belugas@6928: 			/* Make sure no vehicle is on the tile */
celestar@3425: 			if (!EnsureNoVehicle(tile)) return CMD_ERROR;
truelight@0: 
belugas@6928: 			/* Make sure it's not an edge tile. */
celestar@3425: 			if (!IS_INT_INSIDE(TileX(tile), 1, MapMaxX() - 1) ||
celestar@3425: 					!IS_INT_INSIDE(TileY(tile), 1, MapMaxY() - 1)) {
celestar@3425: 				return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);
celestar@3425: 			}
tron@3017: 
peter1138@3940: 			if (GetTileOwner(tile) != OWNER_WATER && !CheckTileOwnership(tile)) return CMD_ERROR;
peter1138@3940: 
tron@3017: 			if (flags & DC_EXEC) DoClearSquare(tile);
rubidium@7446: 			return CommandCost(_price.clear_water);
truelight@0: 
rubidium@6507: 		case WATER_TILE_COAST: {
tron@3636: 			Slope slope = GetTileSlope(tile, NULL);
tron@3439: 
belugas@6928: 			/* Make sure no vehicle is on the tile */
tron@3439: 			if (!EnsureNoVehicle(tile)) return CMD_ERROR;
tron@3439: 
belugas@6928: 			/* Make sure it's not an edge tile. */
tron@3439: 			if (!IS_INT_INSIDE(TileX(tile), 1, MapMaxX() - 1) ||
tron@3439: 					!IS_INT_INSIDE(TileY(tile), 1, MapMaxY() - 1)) {
tron@3439: 				return_cmd_error(STR_0002_TOO_CLOSE_TO_EDGE_OF_MAP);
celestar@3425: 			}
celestar@3425: 
tron@3439: 			if (flags & DC_EXEC) DoClearSquare(tile);
tron@3636: 			if (slope == SLOPE_N || slope == SLOPE_E || slope == SLOPE_S || slope == SLOPE_W) {
rubidium@7446: 				return CommandCost(_price.clear_water);
tron@3439: 			} else {
rubidium@7446: 				return CommandCost(_price.purchase_land);
celestar@3425: 			}
tron@3439: 		}
tron@3439: 
rubidium@6507: 		case WATER_TILE_LOCK: {
tron@3439: 			static const TileIndexDiffC _shiplift_tomiddle_offs[] = {
tron@3439: 				{ 0,  0}, {0,  0}, { 0, 0}, {0,  0}, // middle
tron@3439: 				{-1,  0}, {0,  1}, { 1, 0}, {0, -1}, // lower
tron@3439: 				{ 1,  0}, {0, -1}, {-1, 0}, {0,  1}, // upper
tron@3439: 			};
tron@3439: 
tron@3439: 			if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);
tron@3439: 			if (_current_player == OWNER_WATER) return CMD_ERROR;
belugas@6928: 			/* move to the middle tile.. */
tron@3439: 			return RemoveShiplift(tile + ToTileIndexDiff(_shiplift_tomiddle_offs[GetSection(tile)]), flags);
tron@3439: 		}
tron@3439: 
rubidium@6507: 		case WATER_TILE_DEPOT:
celestar@3425: 			if (flags & DC_AUTO) return_cmd_error(STR_2004_BUILDING_MUST_BE_DEMOLISHED);
celestar@3425: 			return RemoveShipDepot(tile, flags);
tron@3439: 
tron@3439: 		default:
tron@3439: 			NOT_REACHED();
truelight@0: 	}
truelight@0: }
truelight@0: 
belugas@6928: /** return true if a tile is a water tile. */
tron@1048: static bool IsWateredTile(TileIndex tile)
truelight@0: {
tron@1214: 	switch (GetTileType(tile)) {
tron@3977: 		case MP_WATER:
peter1138@4087: 			if (!IsCoast(tile)) return true;
peter1138@4087: 
peter1138@4087: 			switch (GetTileSlope(tile, NULL)) {
peter1138@4087: 				case SLOPE_W:
peter1138@4087: 				case SLOPE_S:
peter1138@4087: 				case SLOPE_E:
peter1138@4087: 				case SLOPE_N:
peter1138@4087: 					return true;
peter1138@4087: 
peter1138@4087: 				default:
peter1138@4087: 					return false;
peter1138@4087: 			}
tron@3977: 
celestar@6156: 		case MP_STATION: return IsOilRig(tile) || IsDock(tile) || IsBuoy(tile);
celestar@5573: 		default:         return false;
tron@1048: 	}
truelight@0: }
truelight@0: 
belugas@6928: /** draw a canal styled water tile with dikes around */
tron@1977: void DrawCanalWater(TileIndex tile)
truelight@0: {
truelight@0: 	uint wa;
truelight@193: 
peter1138@7079: 	/* Test for custom graphics, else use the default */
peter1138@7079: 	SpriteID dikes_base = GetCanalSprite(CF_DIKES, tile);
peter1138@7079: 	if (dikes_base == 0) dikes_base = SPR_CANALS_BASE + 57;
peter1138@7079: 
belugas@6928: 	/* determine the edges around with water. */
truelight@0: 	wa = IsWateredTile(TILE_ADDXY(tile, -1, 0)) << 0;
truelight@0: 	wa += IsWateredTile(TILE_ADDXY(tile, 0, 1)) << 1;
truelight@0: 	wa += IsWateredTile(TILE_ADDXY(tile, 1, 0)) << 2;
truelight@0: 	wa += IsWateredTile(TILE_ADDXY(tile, 0, -1)) << 3;
truelight@193: 
peter1138@7079: 	if (!(wa & 1)) DrawGroundSprite(dikes_base,     PAL_NONE);
peter1138@7079: 	if (!(wa & 2)) DrawGroundSprite(dikes_base + 1, PAL_NONE);
peter1138@7079: 	if (!(wa & 4)) DrawGroundSprite(dikes_base + 2, PAL_NONE);
peter1138@7079: 	if (!(wa & 8)) DrawGroundSprite(dikes_base + 3, PAL_NONE);
truelight@0: 
belugas@6928: 	/* right corner */
tron@2989: 	switch (wa & 0x03) {
peter1138@7079: 		case 0: DrawGroundSprite(dikes_base + 4, PAL_NONE); break;
peter1138@7079: 		case 3: if (!IsWateredTile(TILE_ADDXY(tile, -1, 1))) DrawGroundSprite(dikes_base + 8, PAL_NONE); break;
tron@2989: 	}
truelight@0: 
belugas@6928: 	/* bottom corner */
tron@2989: 	switch (wa & 0x06) {
peter1138@7079: 		case 0: DrawGroundSprite(dikes_base + 5, PAL_NONE); break;
peter1138@7079: 		case 6: if (!IsWateredTile(TILE_ADDXY(tile, 1, 1))) DrawGroundSprite(dikes_base + 9, PAL_NONE); break;
tron@2989: 	}
truelight@0: 
belugas@6928: 	/* left corner */
tron@2989: 	switch (wa & 0x0C) {
peter1138@7079: 		case  0: DrawGroundSprite(dikes_base + 6, PAL_NONE); break;
peter1138@7079: 		case 12: if (!IsWateredTile(TILE_ADDXY(tile, 1, -1))) DrawGroundSprite(dikes_base + 10, PAL_NONE); break;
tron@2989: 	}
truelight@0: 
belugas@6928: 	/* upper corner */
tron@2989: 	switch (wa & 0x09) {
peter1138@7079: 		case 0: DrawGroundSprite(dikes_base + 7, PAL_NONE); break;
peter1138@7079: 		case 9: if (!IsWateredTile(TILE_ADDXY(tile, -1, -1))) DrawGroundSprite(dikes_base + 11, PAL_NONE); break;
tron@2989: 	}
truelight@0: }
truelight@0: 
rubidium@6574: struct LocksDrawTileStruct {
truelight@0: 	int8 delta_x, delta_y, delta_z;
truelight@0: 	byte width, height, depth;
truelight@0: 	SpriteID image;
rubidium@6574: };
truelight@0: 
truelight@0: #include "table/water_land.h"
truelight@0: 
Darkvater@2436: static void DrawWaterStuff(const TileInfo *ti, const WaterDrawTileStruct *wdts,
peter1138@5919: 	SpriteID palette, uint base
tron@1399: )
truelight@0: {
peter1138@7079: 	SpriteID image;
peter1138@7079: 	SpriteID water_base = GetCanalSprite(CF_WATERSLOPE, ti->tile);
peter1138@7079: 	SpriteID locks_base = GetCanalSprite(CF_LOCKS, ti->tile);
peter1138@7079: 
peter1138@7079: 	/* If no custom graphics, use defaults */
peter1138@7079: 	if (water_base == 0) water_base = SPR_CANALS_BASE + 5;
peter1138@7079: 	if (locks_base == 0) {
peter1138@7079: 		locks_base = SPR_CANALS_BASE + 9;
peter1138@7079: 	} else {
peter1138@7079: 		/* If using custom graphics, ignore the variation on height */
peter1138@7079: 		base = 0;
peter1138@7079: 	}
peter1138@7079: 
peter1138@7079: 	image = wdts++->image;
peter1138@7079: 	if (image < 4) image += water_base;
peter1138@7079: 	DrawGroundSprite(image, PAL_NONE);
truelight@193: 
tron@1399: 	for (; wdts->delta_x != 0x80; wdts++) {
peter1138@7079: 		SpriteID image = wdts->image;
peter1138@5919: 		SpriteID pal;
peter1138@5919: 
peter1138@7079: 		if (image < 24) image += locks_base;
peter1138@7079: 		image += base;
peter1138@7079: 
peter1138@6923: 		if (HASBIT(_transparent_opt, TO_BUILDINGS)) {
peter1138@5919: 			SETBIT(image, PALETTE_MODIFIER_TRANSPARENT);
peter1138@5919: 			pal = PALETTE_TO_TRANSPARENT;
tron@497: 		} else {
peter1138@5919: 			pal = palette;
truelight@0: 		}
peter1138@5919: 
peter1138@5919: 		AddSortableSpriteToDraw(image, pal,
peter1138@5919: 			ti->x + wdts->delta_x, ti->y + wdts->delta_y,
peter1138@5919: 			wdts->width, wdts->height,
peter1138@5919: 			wdts->unk, ti->z + wdts->delta_z);
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: static void DrawTile_Water(TileInfo *ti)
truelight@0: {
celestar@3402: 	switch (GetWaterTileType(ti->tile)) {
rubidium@6507: 		case WATER_TILE_CLEAR:
peter1138@5919: 			DrawGroundSprite(SPR_FLAT_WATER_TILE, PAL_NONE);
peter1138@4087: 			if (ti->z != 0 || !IsTileOwner(ti->tile, OWNER_WATER)) DrawCanalWater(ti->tile);
celestar@5573: 			DrawBridgeMiddle(ti);
celestar@3402: 			break;
truelight@0: 
rubidium@6507: 		case WATER_TILE_COAST:
tron@3636: 			assert(!IsSteepSlope(ti->tileh));
peter1138@5210: 			if (_coast_base != 0) {
peter1138@5919: 				DrawGroundSprite(_coast_base + ti->tileh, PAL_NONE);
peter1138@5210: 			} else {
peter1138@5919: 				DrawGroundSprite(_water_shore_sprites[ti->tileh], PAL_NONE);
peter1138@5210: 			}
celestar@5573: 			DrawBridgeMiddle(ti);
celestar@3402: 			break;
truelight@0: 
rubidium@6507: 		case WATER_TILE_LOCK: {
celestar@3425: 			const WaterDrawTileStruct *t = _shiplift_display_seq[GetSection(ti->tile)];
celestar@3402: 			DrawWaterStuff(ti, t, 0, ti->z > t[3].delta_y ? 24 : 0);
celestar@3402: 		} break;
celestar@3402: 
rubidium@6507: 		case WATER_TILE_DEPOT:
celestar@3425: 			DrawWaterStuff(ti, _shipdepot_display_seq[GetSection(ti->tile)], PLAYER_SPRITE_COLOR(GetTileOwner(ti->tile)), 0);
celestar@3402: 			break;
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: void DrawShipDepotSprite(int x, int y, int image)
truelight@0: {
tron@1399: 	const WaterDrawTileStruct *wdts = _shipdepot_display_seq[image];
truelight@0: 
peter1138@5919: 	DrawSprite(wdts++->image, PAL_NONE, x, y);
truelight@193: 
tron@1399: 	for (; wdts->delta_x != 0x80; wdts++) {
truelight@0: 		Point pt = RemapCoords(wdts->delta_x, wdts->delta_y, wdts->delta_z);
peter1138@5919: 		DrawSprite(wdts->image, PLAYER_SPRITE_COLOR(_local_player), x + pt.x, y + pt.y);
truelight@0: 	}
truelight@0: }
truelight@0: 
truelight@0: 
tron@4231: static uint GetSlopeZ_Water(TileIndex tile, uint x, uint y)
truelight@193: {
tron@4231: 	uint z;
rubidium@5838: 	Slope tileh = GetTileSlope(tile, &z);
tron@4231: 
tron@4231: 	return z + GetPartialZ(x & 0xF, y & 0xF, tileh);
truelight@0: }
truelight@0: 
tron@3636: static Slope GetSlopeTileh_Water(TileIndex tile, Slope tileh)
truelight@193: {
tron@3418: 	return tileh;
dominik@39: }
dominik@39: 
tron@1977: static void GetAcceptedCargo_Water(TileIndex tile, AcceptedCargo ac)
truelight@0: {
truelight@0: 	/* not used */
truelight@0: }
truelight@0: 
tron@1977: static void GetTileDesc_Water(TileIndex tile, TileDesc *td)
truelight@0: {
celestar@3402: 	switch (GetWaterTileType(tile)) {
rubidium@6507: 		case WATER_TILE_CLEAR:
peter1138@4087: 			if (TilePixelHeight(tile) == 0 || IsTileOwner(tile, OWNER_WATER)) {
celestar@3402: 				td->str = STR_3804_WATER;
celestar@3402: 			} else {
celestar@3402: 				td->str = STR_LANDINFO_CANAL;
celestar@3402: 			}
celestar@3402: 			break;
rubidium@6507: 		case WATER_TILE_COAST: td->str = STR_3805_COAST_OR_RIVERBANK; break;
rubidium@6507: 		case WATER_TILE_LOCK : td->str = STR_LANDINFO_LOCK; break;
rubidium@6507: 		case WATER_TILE_DEPOT: td->str = STR_3806_SHIP_DEPOT; break;
celestar@3402: 		default: assert(0); break;
tron@2951: 	}
truelight@0: 
tron@1901: 	td->owner = GetTileOwner(tile);
truelight@0: }
truelight@0: 
tron@1977: static void AnimateTile_Water(TileIndex tile)
truelight@0: {
truelight@0: 	/* not used */
truelight@0: }
truelight@0: 
tron@1075: static void TileLoopWaterHelper(TileIndex tile, const TileIndexDiffC *offs)
truelight@0: {
tron@1075: 	TileIndex target = TILE_ADD(tile, ToTileIndexDiff(offs[0]));
truelight@0: 
belugas@6928: 	/* type of this tile mustn't be water already. */
tron@2639: 	if (IsTileType(target, MP_WATER)) return;
truelight@0: 
tron@1075: 	if (TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[1]))) != 0 ||
tron@2639: 			TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[2]))) != 0) {
tron@1075: 		return;
tron@2639: 	}
tron@1075: 
tron@1075: 	if (TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[3]))) != 0 ||
tron@1075: 			TileHeight(TILE_ADD(tile, ToTileIndexDiff(offs[4]))) != 0) {
belugas@6928: 		/* make coast.. */
tron@1214: 		switch (GetTileType(target)) {
tron@1076: 			case MP_RAILWAY: {
tron@3267: 				TrackBits tracks;
tron@3636: 				Slope slope;
tron@3267: 
tron@3275: 				if (!IsPlainRailTile(target)) break;
tron@3267: 
tron@3267: 				tracks = GetTrackBits(target);
tron@3267: 				slope = GetTileSlope(target, NULL);
tron@1076: 				if (!(
tron@3636: 							(slope == SLOPE_W && tracks == TRACK_BIT_RIGHT) ||
tron@3636: 							(slope == SLOPE_S && tracks == TRACK_BIT_UPPER) ||
tron@3636: 							(slope == SLOPE_E && tracks == TRACK_BIT_LEFT)  ||
tron@3636: 							(slope == SLOPE_N && tracks == TRACK_BIT_LOWER)
tron@3267: 						)) {
tron@1076: 					break;
tron@3267: 				}
tron@1076: 			}
tron@1076: 			/* FALLTHROUGH */
tron@1076: 
tron@1075: 			case MP_CLEAR:
tron@1075: 			case MP_TREES:
tron@1075: 				_current_player = OWNER_WATER;
rubidium@7442: 				if (CmdSucceeded(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
tron@3111: 					MakeShore(target);
tron@3111: 					MarkTileDirtyByTile(target);
tron@1075: 				}
tron@1075: 				break;
tron@1075: 
tron@1075: 			default:
tron@1075: 				break;
truelight@0: 		}
truelight@0: 	} else {
truelight@0: 		_current_player = OWNER_WATER;
rubidium@6191: 
rubidium@6191: 		Vehicle *v = FindFloodableVehicleOnTile(target);
rubidium@6191: 		if (v != NULL) FloodVehicle(v);
tron@1075: 
rubidium@7442: 		if (CmdSucceeded(DoCommand(target, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR))) {
tron@3111: 			MakeWater(target);
tron@3111: 			MarkTileDirtyByTile(target);
tron@1075: 		}
truelight@0: 	}
truelight@0: }
truelight@0: 
rubidium@6191: /**
rubidium@6191:  * Finds a vehicle to flood.
rubidium@6191:  * It does not find vehicles that are already crashed on bridges, i.e. flooded.
rubidium@6191:  * @param tile the tile where to find a vehicle to flood
rubidium@6191:  * @return a vehicle too flood or NULL when there is no vehicle too flood.
rubidium@6191:  */
rubidium@6191: static Vehicle *FindFloodableVehicleOnTile(TileIndex tile)
rubidium@6191: {
rubidium@7402: 	if (IsTileType(tile, MP_STATION) && IsAirport(tile)) {
rubidium@7402: 		const Station *st = GetStationByTile(tile);
rubidium@7402: 		const AirportFTAClass *airport = st->Airport();
rubidium@7402: 		for (uint x = 0; x < airport->size_x; x++) {
rubidium@7402: 			for (uint y = 0; y < airport->size_y; y++) {
rubidium@7402: 				tile = TILE_ADDXY(st->airport_tile, x, y);
rubidium@7402: 				Vehicle *v = FindVehicleOnTileZ(tile, 1 + airport->delta_z);
rubidium@7402: 				if (v != NULL && (v->vehstatus & VS_CRASHED) == 0) return v;
rubidium@7402: 			}
rubidium@7402: 		}
rubidium@7402: 
rubidium@7402: 		/* No vehicle could be flooded on this airport anymore */
rubidium@7402: 		return NULL;
rubidium@7402: 	}
rubidium@7402: 
rubidium@6191: 	if (!IsBridgeTile(tile)) return FindVehicleOnTileZ(tile, 0);
rubidium@6191: 
rubidium@6191: 	TileIndex end = GetOtherBridgeEnd(tile);
rubidium@6191: 	byte z = GetBridgeHeight(tile);
rubidium@6191: 	Vehicle *v;
rubidium@6191: 
rubidium@6191: 	/* check the start tile first since as this is closest to the water */
rubidium@6191: 	v = FindVehicleOnTileZ(tile, z);
rubidium@6191: 	if (v != NULL && (v->vehstatus & VS_CRASHED) == 0) return v;
rubidium@6191: 
rubidium@6191: 	/* check a vehicle in between both bridge heads */
rubidium@6191: 	v = FindVehicleBetween(tile, end, z, true);
rubidium@6191: 	if (v != NULL) return v;
rubidium@6191: 
rubidium@6191: 	/* check the end tile last to give fleeing vehicles a chance to escape */
rubidium@6191: 	v = FindVehicleOnTileZ(end, z);
rubidium@6191: 	return (v != NULL && (v->vehstatus & VS_CRASHED) == 0) ? v : NULL;
rubidium@6191: }
rubidium@6191: 
darkvater@149: static void FloodVehicle(Vehicle *v)
darkvater@149: {
darkvater@149: 	if (!(v->vehstatus & VS_CRASHED)) {
darkvater@168: 		uint16 pass = 0;
darkvater@149: 
rubidium@7402: 		if (v->type == VEH_TRAIN || v->type == VEH_ROAD || v->type == VEH_AIRCRAFT) {
rubidium@7402: 			if (v->type == VEH_AIRCRAFT) {
rubidium@7402: 				/* Crashing aircraft are always at z_pos == 1, never on z_pos == 0,
rubidium@7402: 				 * because that's always the shadow. Except for the heliport, because
rubidium@7402: 				 * that station has a big z_offset for the aircraft. */
rubidium@7402: 				if (!IsTileType(v->tile, MP_STATION) || !IsAirport(v->tile) || GetTileMaxZ(v->tile) != 0) return;
rubidium@7402: 				const Station *st = GetStationByTile(v->tile);
rubidium@7402: 				const AirportFTAClass *airport = st->Airport();
rubidium@7402: 
rubidium@7402: 				if (v->z_pos != airport->delta_z + 1) return;
rubidium@7402: 			}
belugas@4171: 			Vehicle *u;
truelight@193: 
rubidium@7402: 			if (v->type != VEH_AIRCRAFT) v = GetFirstVehicleInChain(v);
darkvater@149: 			u = v;
darkvater@149: 
maedhros@7353: 			/* crash all wagons, and count passengers */
darkvater@149: 			BEGIN_ENUM_WAGONS(v)
rubidium@7506: 				if (IsCargoInClass(v->cargo_type, CC_PASSENGERS)) pass += v->cargo.Count();
darkvater@149: 				v->vehstatus |= VS_CRASHED;
rubidium@6191: 				MarkAllViewportsDirty(v->left_coord, v->top_coord, v->right_coord + 1, v->bottom_coord + 1);
darkvater@149: 			END_ENUM_WAGONS(v)
darkvater@149: 
darkvater@149: 			v = u;
maedhros@7353: 
rubidium@7402: 			switch (v->type) {
rubidium@7402: 				default: NOT_REACHED();
rubidium@7402: 				case VEH_TRAIN:
rubidium@7402: 					if (IsFrontEngine(v)) pass += 4; // driver
rubidium@7402: 					v->u.rail.crash_anim_pos = 4000; // max 4440, disappear pretty fast
rubidium@7402: 					break;
rubidium@7402: 
rubidium@7402: 				case VEH_ROAD:
rubidium@7402: 					if (IsRoadVehFront(v)) pass += 1; // driver
rubidium@7402: 					v->u.road.crashed_ctr = 2000; // max 2220, disappear pretty fast
rubidium@7402: 					break;
rubidium@7402: 
rubidium@7402: 				case VEH_AIRCRAFT:
rubidium@7402: 					pass += 2; // driver
rubidium@7402: 					v->u.air.crashed_counter = 9000; // max 10000, disappear pretty fast
rubidium@7402: 					break;
maedhros@7353: 			}
maedhros@7353: 
tron@588: 			RebuildVehicleLists();
tron@2549: 		} else {
darkvater@168: 			return;
tron@2549: 		}
darkvater@149: 
darkvater@755: 		InvalidateWindowWidget(WC_VEHICLE_VIEW, v->index, STATUS_BAR);
darkvater@149: 		InvalidateWindow(WC_VEHICLE_DEPOT, v->tile);
truelight@193: 
tron@534: 		SetDParam(0, pass);
darkvater@149: 		AddNewsItem(STR_B006_FLOOD_VEHICLE_DESTROYED,
rubidium@6987: 			NEWS_FLAGS(NM_THIN, NF_VIEWPORT | NF_VEHICLE, NT_ACCIDENT, 0),
darkvater@149: 			v->index,
darkvater@149: 			0);
tron@2549: 		CreateEffectVehicleRel(v, 4, 4, 8, EV_EXPLOSION_LARGE);
tron@2549: 		SndPlayVehicleFx(SND_12_EXPLOSION, v);
dominik@714: 	}
darkvater@149: }
darkvater@149: 
belugas@6928: /** called from tunnelbridge_cmd, and by TileLoop_Industry() */
tron@1977: void TileLoop_Water(TileIndex tile)
truelight@0: {
tron@909: 	static const TileIndexDiffC _tile_loop_offs_array[][5] = {
rubidium@4344: 		// tile to mod              shore?    shore?
tron@909: 		{{-1,  0}, {0, 0}, {0, 1}, {-1,  0}, {-1,  1}},
tron@909: 		{{ 0,  1}, {0, 1}, {1, 1}, { 0,  2}, { 1,  2}},
tron@909: 		{{ 1,  0}, {1, 0}, {1, 1}, { 2,  0}, { 2,  1}},
tron@909: 		{{ 0, -1}, {0, 0}, {1, 0}, { 0, -1}, { 1, -1}}
truelight@0: 	};
truelight@0: 
rubidium@6205: 	/* Ensure sea-level canals and buoys on canal borders do not flood */
rubidium@6205: 	if ((IsTileType(tile, MP_WATER) || IsBuoyTile(tile)) && !IsTileOwner(tile, OWNER_WATER)) return;
peter1138@4087: 
tron@926: 	if (IS_INT_INSIDE(TileX(tile), 1, MapSizeX() - 3 + 1) &&
tron@926: 			IS_INT_INSIDE(TileY(tile), 1, MapSizeY() - 3 + 1)) {
tron@2989: 		uint i;
tron@2989: 
tron@2639: 		for (i = 0; i != lengthof(_tile_loop_offs_array); i++) {
truelight@0: 			TileLoopWaterHelper(tile, _tile_loop_offs_array[i]);
tron@2639: 		}
truelight@0: 	}
belugas@6928: 	/* _current_player can be changed by TileLoopWaterHelper.. reset it back here */
truelight@314: 	_current_player = OWNER_NONE;
dominik@43: 
belugas@6928: 	/* edges */
tron@2951: 	if (TileX(tile) == 0 && IS_INT_INSIDE(TileY(tile), 1, MapSizeY() - 3 + 1)) { //NE
dominik@43: 		TileLoopWaterHelper(tile, _tile_loop_offs_array[2]);
tron@2951: 	}
dominik@43: 
tron@2639: 	if (TileX(tile) == MapSizeX() - 2 && IS_INT_INSIDE(TileY(tile), 1, MapSizeY() - 3 + 1)) { //SW
dominik@43: 		TileLoopWaterHelper(tile, _tile_loop_offs_array[0]);
tron@2639: 	}
dominik@43: 
tron@2639: 	if (TileY(tile) == 0 && IS_INT_INSIDE(TileX(tile), 1, MapSizeX() - 3 + 1)) { //NW
dominik@43: 		TileLoopWaterHelper(tile, _tile_loop_offs_array[1]);
tron@2639: 	}
dominik@43: 
tron@2639: 	if (TileY(tile) == MapSizeY() - 2 && IS_INT_INSIDE(TileX(tile), 1, MapSizeX() - 3 + 1)) { //SE
dominik@43: 		TileLoopWaterHelper(tile, _tile_loop_offs_array[3]);
tron@2639: 	}
truelight@0: }
truelight@0: 
rubidium@7179: static uint32 GetTileTrackStatus_Water(TileIndex tile, TransportType mode, uint sub_mode)
truelight@0: {
celestar@3423: 	static const byte coast_tracks[] = {0, 32, 4, 0, 16, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0};
tron@4169: 
tron@4169: 	TrackBits ts;
tron@4169: 
tron@2951: 	if (mode != TRANSPORT_WATER) return 0;
truelight@0: 
celestar@3423: 	switch (GetWaterTileType(tile)) {
rubidium@6507: 		case WATER_TILE_CLEAR: ts = TRACK_BIT_ALL; break;
rubidium@6507: 		case WATER_TILE_COAST: ts = (TrackBits)coast_tracks[GetTileSlope(tile, NULL) & 0xF]; break;
rubidium@6507: 		case WATER_TILE_LOCK:  ts = AxisToTrackBits(DiagDirToAxis(GetLockDirection(tile))); break;
rubidium@6507: 		case WATER_TILE_DEPOT: ts = AxisToTrackBits(GetShipDepotAxis(tile)); break;
celestar@3423: 		default: return 0;
truelight@0: 	}
KUDr@3900: 	if (TileX(tile) == 0) {
belugas@6928: 		/* NE border: remove tracks that connects NE tile edge */
KUDr@3900: 		ts &= ~(TRACK_BIT_X | TRACK_BIT_UPPER | TRACK_BIT_RIGHT);
KUDr@3900: 	}
KUDr@3900: 	if (TileY(tile) == 0) {
belugas@6928: 		/* NW border: remove tracks that connects NW tile edge */
KUDr@3900: 		ts &= ~(TRACK_BIT_Y | TRACK_BIT_LEFT | TRACK_BIT_UPPER);
KUDr@3900: 	}
KUDr@3900: 	return ts * 0x101;
truelight@0: }
truelight@0: 
tron@1977: static void ClickTile_Water(TileIndex tile)
truelight@0: {
rubidium@6507: 	if (GetWaterTileType(tile) == WATER_TILE_DEPOT) {
celestar@3423: 		TileIndex tile2 = GetOtherShipDepotTile(tile);
truelight@193: 
rubidium@6585: 		ShowDepotWindow(tile < tile2 ? tile : tile2, VEH_SHIP);
truelight@0: 	}
truelight@0: }
truelight@0: 
Darkvater@2436: static void ChangeTileOwner_Water(TileIndex tile, PlayerID old_player, PlayerID new_player)
truelight@0: {
tron@1901: 	if (!IsTileOwner(tile, old_player)) return;
truelight@0: 
Darkvater@4848: 	if (new_player != PLAYER_SPECTATOR) {
tron@1902: 		SetTileOwner(tile, new_player);
truelight@0: 	} else {
tron@3491: 		DoCommand(tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
truelight@0: 	}
truelight@0: }
truelight@0: 
tron@1977: static uint32 VehicleEnter_Water(Vehicle *v, TileIndex tile, int x, int y)
truelight@0: {
rubidium@6317: 	return VETSB_CONTINUE;
truelight@0: }
truelight@0: 
truelight@0: 
rubidium@5838: extern const TileTypeProcs _tile_type_water_procs = {
rubidium@4344: 	DrawTile_Water,           /* draw_tile_proc */
rubidium@4344: 	GetSlopeZ_Water,          /* get_slope_z_proc */
rubidium@4344: 	ClearTile_Water,          /* clear_tile_proc */
rubidium@4344: 	GetAcceptedCargo_Water,   /* get_accepted_cargo_proc */
rubidium@4344: 	GetTileDesc_Water,        /* get_tile_desc_proc */
rubidium@4344: 	GetTileTrackStatus_Water, /* get_tile_track_status_proc */
rubidium@4344: 	ClickTile_Water,          /* click_tile_proc */
rubidium@4344: 	AnimateTile_Water,        /* animate_tile_proc */
rubidium@4344: 	TileLoop_Water,           /* tile_loop_clear */
rubidium@4344: 	ChangeTileOwner_Water,    /* change_tile_owner_clear */
rubidium@4344: 	NULL,                     /* get_produced_cargo_proc */
rubidium@4344: 	VehicleEnter_Water,       /* vehicle_enter_tile_proc */
rubidium@4344: 	GetSlopeTileh_Water,      /* get_slope_tileh_proc */
truelight@0: };