openttd-ottdgrfs: comparison src/tunnelbridge

equal deleted inserted replaced

-:d8811e327d12
+:cd9968b6f96b
 		case TRANSPORT_RAIL:
 			railtype = (RailType)GB(p2, 8, 8);
 			if (!ValParamRailtype(railtype)) return CMD_ERROR;
 			break;
+		case TRANSPORT_WATER:
+			break;
 		default:
-			/* For now, only TRANSPORT_RAIL and TRANSPORT_ROAD are allowed.
+			/* Airports don't have tunnels. */
-			 * But let not this stops us for preparing the future */
 			return CMD_ERROR;
 	}
 	x = TileX(end_tile);
 	y = TileY(end_tile);
 		if (x > sx) Swap(x, sx);
 	} else {
 		return_cmd_error(STR_500A_START_AND_END_MUST_BE_IN);
 	}
-	/* set and test bridge length, availability */
 	bridge_len = sx + sy - x - y - 1;
-	if (!CheckBridge_Stuff(bridge_type, bridge_len)) return_cmd_error(STR_5015_CAN_T_BUILD_BRIDGE_HERE);
+	if (transport_type != TRANSPORT_WATER) {
+		/* set and test bridge length, availability */
+		if (!CheckBridge_Stuff(bridge_type, bridge_len)) return_cmd_error(STR_5015_CAN_T_BUILD_BRIDGE_HERE);
+	}
 	/* retrieve landscape height and ensure it's on land */
 	tile_start = TileXY(x, y);
 	tile_end = TileXY(sx, sy);
 	if (IsWaterTile(tile_start) || IsWaterTile(tile_end)) {
 		/* Do not remove road types when upgrading a bridge */
 		roadtypes |= GetRoadTypes(tile_start);
 	} else {
 		/* Build a new bridge. */
-		bool allow_on_slopes = (!_is_old_ai_player && _settings_game.construction.build_on_slopes);
+		bool allow_on_slopes = (!_is_old_ai_player && _settings_game.construction.build_on_slopes && transport_type != TRANSPORT_WATER);
 		/* Try and clear the start landscape */
 		ret = DoCommand(tile_start, 0, 0, flags, CMD_LANDSCAPE_CLEAR);
 		if (CmdFailed(ret)) return ret;
 		cost = ret;
 		/* false - end tile slope check */
 		if (CmdFailed(terraform_cost_south) || (terraform_cost_south.GetCost() != 0 && !allow_on_slopes))
 			return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 		cost.AddCost(terraform_cost_south);
+		if (transport_type == TRANSPORT_WATER && (tileh_start == SLOPE_FLAT || tileh_end == SLOPE_FLAT)) return_cmd_error(STR_1000_LAND_SLOPED_IN_WRONG_DIRECTION);
 	}
 	if (!replace_bridge) {
 		TileIndex Heads[] = {tile_start, tile_end};
 		int i;
 				break;
 			case TRANSPORT_ROAD:
 				MakeRoadBridgeRamp(tile_start, owner, bridge_type, dir,                 roadtypes);
 				MakeRoadBridgeRamp(tile_end,   owner, bridge_type, ReverseDiagDir(dir), roadtypes);
+				break;
+			case TRANSPORT_WATER:
+				MakeAqueductBridgeRamp(tile_start, owner, dir);
+				MakeAqueductBridgeRamp(tile_end,   owner, ReverseDiagDir(dir));
 				break;
 			default:
 				NOT_REACHED();
 				break;
 		if (IsValidPlayer(_current_player) && !_is_old_ai_player)
 			bridge_len = CalcBridgeLenCostFactor(bridge_len);
 		cost.AddCost((int64)bridge_len * _price.build_bridge * GetBridgeSpec(bridge_type)->price >> 8);
+		/* Aqueducts are a little more expensive. */
+		if (transport_type == TRANSPORT_WATER) cost.AddCost((int64)bridge_len * _price.clear_water);
 	}
 	return cost;
 }
 * @param type Bridge type.
 * @param x Sprite X position of front pillar.
 * @param y Sprite Y position of front pillar.
 * @param z_bridge Absolute height of bridge bottom.
 */
-static void DrawBridgePillars(const PalSpriteID *psid, const TileInfo* ti, Axis axis, BridgeType type, int x, int y, int z_bridge)
+static void DrawBridgePillars(const PalSpriteID *psid, const TileInfo* ti, Axis axis, bool drawfarpillar, int x, int y, int z_bridge)
 {
 	/* Do not draw bridge pillars if they are invisible */
 	if (IsInvisibilitySet(TO_BRIDGES)) return;
 	SpriteID image = psid->sprite;
 	if (image != 0) {
-		bool drawfarpillar = !HasBit(GetBridgeSpec(type)->flags, 0);
 		/* "side" specifies the side the pillars stand on.
 		 * The length of the pillars is then set to the height of the bridge over the corners of this edge.
 		 *
 		 *                axis==AXIS_X  axis==AXIS_Y
 		 *   side==false      SW            NW
 		base_offset += (6 - tunnelbridge_direction) % 4;
 		if (ti->tileh == SLOPE_FLAT) base_offset += 4; // sloped bridge head
 		/* Table number 6 always refers to the bridge heads for any bridge type */
-		psid = &GetBridgeSpriteTable(GetBridgeType(ti->tile), 6)[base_offset];
+		if (transport_type != TRANSPORT_WATER) {
+			psid = &GetBridgeSpriteTable(GetBridgeType(ti->tile), 6)[base_offset];
+		} else {
+			psid = _aqueduct_sprites + base_offset;
+		}
 		if (!ice) {
 			DrawClearLandTile(ti, 3);
 		} else {
 			DrawGroundSprite(SPR_FLAT_SNOWY_TILE + _tileh_to_sprite[ti->tileh], PAL_NONE);
 	 */
 	/* Z position of the bridge sprites relative to bridge height (downwards) */
 	static const int BRIDGE_Z_START = 3;
-	const PalSpriteID* psid;
-	uint base_offset;
-	TileIndex rampnorth;
-	TileIndex rampsouth;
-	TransportType transport_type;
-	Axis axis;
-	uint piece;
-	BridgeType type;
-	int x;
-	int y;
-	uint z;
 	if (!IsBridgeAbove(ti->tile)) return;
-	rampnorth = GetNorthernBridgeEnd(ti->tile);
+	TileIndex rampnorth = GetNorthernBridgeEnd(ti->tile);
-	rampsouth = GetSouthernBridgeEnd(ti->tile);
+	TileIndex rampsouth = GetSouthernBridgeEnd(ti->tile);
-	transport_type = GetTunnelBridgeTransportType(rampsouth);
+	TransportType transport_type = GetTunnelBridgeTransportType(rampsouth);
-	axis = GetBridgeAxis(ti->tile);
+	Axis axis = GetBridgeAxis(ti->tile);
-	piece = CalcBridgePiece(
+	uint piece = CalcBridgePiece(
 		GetTunnelBridgeLength(ti->tile, rampnorth) + 1,
 		GetTunnelBridgeLength(ti->tile, rampsouth) + 1
 	);
-	type = GetBridgeType(rampsouth);
+	const PalSpriteID *psid;
-	if (transport_type == TRANSPORT_RAIL) {
+	bool drawfarpillar;
-		base_offset = GetRailTypeInfo(GetRailType(rampsouth))->bridge_offset;
+	if (transport_type != TRANSPORT_WATER) {
+		BridgeType type =  GetBridgeType(rampsouth);
+		drawfarpillar = !HasBit(GetBridgeSpec(type)->flags, 0);
+		uint base_offset;
+		if (transport_type == TRANSPORT_RAIL) {
+			base_offset = GetRailTypeInfo(GetRailType(rampsouth))->bridge_offset;
+		} else {
+			base_offset = 8;
+		}
+		psid = base_offset + GetBridgeSpriteTable(type, piece);
 	} else {
-		base_offset = 8;
+		drawfarpillar = true;
-	}
+		psid = _aqueduct_sprites;
+	}
-	psid = base_offset + GetBridgeSpriteTable(type, piece);
 	if (axis != AXIS_X) psid += 4;
-	x = ti->x;
+	int x = ti->x;
-	y = ti->y;
+	int y = ti->y;
 	uint bridge_z = GetBridgeHeight(rampsouth);
-	z = bridge_z - BRIDGE_Z_START;
+	uint z = bridge_z - BRIDGE_Z_START;
 	/* Add a bounding box, that separates the bridge from things below it. */
 	AddSortableSpriteToDraw(SPR_EMPTY_BOUNDING_BOX, PAL_NONE, x, y, 16, 16, 1, bridge_z - TILE_HEIGHT + BB_Z_SEPARATOR);
 	/* Draw Trambits as SpriteCombine */
 			DrawGroundSpriteAt(image, pal, x, y, z);
 		}
 	} else if (_settings_client.gui.bridge_pillars) {
 		/* draw pillars below for high bridges */
-		DrawBridgePillars(psid, ti, axis, type, x, y, z);
+		DrawBridgePillars(psid, ti, axis, drawfarpillar, x, y, z);
 	}
 }
 static uint GetSlopeZ_TunnelBridge(TileIndex tile, uint x, uint y)
 	/* not used */
 }
 static void GetTileDesc_TunnelBridge(TileIndex tile, TileDesc *td)
 {
+	TransportType tt = GetTunnelBridgeTransportType(tile);
 	if (IsTunnel(tile)) {
-		td->str = (GetTunnelBridgeTransportType(tile) == TRANSPORT_RAIL) ?
+		td->str = (tt == TRANSPORT_RAIL) ? STR_5017_RAILROAD_TUNNEL : STR_5018_ROAD_TUNNEL;
-			STR_5017_RAILROAD_TUNNEL : STR_5018_ROAD_TUNNEL;
+	} else { // IsBridge(tile)
-	} else { //so it must be a bridge
+		td->str = (tt == TRANSPORT_WATER) ? STR_AQUEDUCT : GetBridgeSpec(GetBridgeType(tile))->transport_name[tt];
-		td->str = GetBridgeSpec(GetBridgeType(tile))->transport_name[GetTunnelBridgeTransportType(tile)];
 	}
 	td->owner[0] = GetTileOwner(tile);
 }
 		SetTileOwner(tile, new_player);
 	} else {
 		if (CmdFailed(DoCommand(tile, 0, 0, DC_EXEC | DC_BANKRUPT, CMD_LANDSCAPE_CLEAR))) {
 			/* When clearing the bridge/tunnel failed there are still vehicles on/in
 			 * the bridge/tunnel. As all *our* vehicles are already removed, they
-			 * must be of another owner. Therefor this must be a road bridge/tunnel.
+			 * must be of another owner. Therefore this can't be rail tunnel/bridge.
 			 * In that case we can safely reassign the ownership to OWNER_NONE. */
-			assert(GetTunnelBridgeTransportType(tile) == TRANSPORT_ROAD);
+			assert(GetTunnelBridgeTransportType(tile) != TRANSPORT_RAIL);
 			SetTileOwner(tile, OWNER_NONE);
 		}
 	}
 }
 				return VETSB_ENTERED_WORMHOLE;
 			}
 		}
 	} else { // IsBridge(tile)
-		if (v->IsPrimaryVehicle()) {
+		if (v->IsPrimaryVehicle() && v->type != VEH_SHIP) {
 			/* modify speed of vehicle */
 			uint16 spd = GetBridgeSpec(GetBridgeType(tile))->speed;
 			if (v->type == VEH_ROAD) spd *= 2;
 			if (v->cur_speed > spd) v->cur_speed = spd;
 				case DIAGDIR_NE: if ((x & 0xF) != 0)             return VETSB_CONTINUE; break;
 				case DIAGDIR_SE: if ((y & 0xF) != TILE_SIZE - 1) return VETSB_CONTINUE; break;
 				case DIAGDIR_SW: if ((x & 0xF) != TILE_SIZE - 1) return VETSB_CONTINUE; break;
 				case DIAGDIR_NW: if ((y & 0xF) != 0)             return VETSB_CONTINUE; break;
 			}
-			if (v->type == VEH_TRAIN) {
+			switch (v->type) {
-				v->u.rail.track = TRACK_BIT_WORMHOLE;
+				case VEH_TRAIN:
-				ClrBit(v->u.rail.flags, VRF_GOINGUP);
+					v->u.rail.track = TRACK_BIT_WORMHOLE;
-				ClrBit(v->u.rail.flags, VRF_GOINGDOWN);
+					ClrBit(v->u.rail.flags, VRF_GOINGUP);
-			} else {
+					ClrBit(v->u.rail.flags, VRF_GOINGDOWN);
-				v->u.road.state = RVSB_WORMHOLE;
+					break;
+				case VEH_ROAD:
+					v->u.road.state = RVSB_WORMHOLE;
+					break;
+				case VEH_SHIP:
+					v->u.ship.state = TRACK_BIT_WORMHOLE;
+					break;
+				default: NOT_REACHED();
 			}
 			return VETSB_ENTERED_WORMHOLE;
 		} else if (DirToDiagDir(v->direction) == ReverseDiagDir(dir)) {
 			v->tile = tile;
-			if (v->type == VEH_TRAIN) {
+			switch (v->type) {
-				if (v->u.rail.track == TRACK_BIT_WORMHOLE) {
+				case VEH_TRAIN:
-					v->u.rail.track = (DiagDirToAxis(dir) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y);
+					if (v->u.rail.track == TRACK_BIT_WORMHOLE) {
-					return VETSB_ENTERED_WORMHOLE;
+						v->u.rail.track = (DiagDirToAxis(dir) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y);
-				}
+						return VETSB_ENTERED_WORMHOLE;
-			} else {
+					}
-				if (v->u.road.state == RVSB_WORMHOLE) {
+					break;
-					v->u.road.state = _road_exit_tunnel_state[dir];
-					v->u.road.frame = 0;
+				case VEH_ROAD:
-					return VETSB_ENTERED_WORMHOLE;
+					if (v->u.road.state == RVSB_WORMHOLE) {
-				}
+						v->u.road.state = _road_exit_tunnel_state[dir];
-			}
+						v->u.road.frame = 0;
-			return VETSB_CONTINUE;
+						return VETSB_ENTERED_WORMHOLE;
+					}
+					break;
+				case VEH_SHIP:
+					if (v->u.ship.state == TRACK_BIT_WORMHOLE) {
+						v->u.ship.state = (DiagDirToAxis(dir) == AXIS_X ? TRACK_BIT_X : TRACK_BIT_Y);
+						return VETSB_ENTERED_WORMHOLE;
+					}
+					break;
+				default: NOT_REACHED();
+			}
 		}
 	}
 	return VETSB_CONTINUE;
 }
 static CommandCost TerraformTile_TunnelBridge(TileIndex tile, uint32 flags, uint z_new, Slope tileh_new)
 {
-	if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() && IsBridge(tile)) {
+	if (_settings_game.construction.build_on_slopes && AutoslopeEnabled() && IsBridge(tile) && GetTunnelBridgeTransportType(tile) != TRANSPORT_WATER) {
 		DiagDirection direction = GetTunnelBridgeDirection(tile);
 		Axis axis = DiagDirToAxis(direction);
 		CommandCost res;
 		uint z_old;
 		Slope tileh_old = GetTileSlope(tile, &z_old);

branch	NewGRF_ports
changeset 10994	cd9968b6f96b
parent 10991	d8811e327d12