diff --git a/tests/all_tests.nut b/tests/all_tests.nut index 545840cbf..d9fe32c96 100644 --- a/tests/all_tests.nut +++ b/tests/all_tests.nut @@ -28,6 +28,7 @@ include("tests/test_slope") include("tests/test_terraform") include("tests/test_transport") include("tests/test_trees") +include("tests/test_way_auto_bridge") include("tests/test_way_bridge") include("tests/test_way_road") include("tests/test_way_runway") @@ -196,6 +197,11 @@ all_tests <- [ test_trees_plant_single_max_per_square, test_trees_plant_single_occupied, test_trees_plant_forest, + test_way_auto_fixture_obstacle, + test_way_auto_fixture_manual_bridge, + test_way_auto_fixture_manual_over_obstacle, + test_way_auto_fixture_barrier, + test_way_auto_bridge_off_builds_nothing, test_way_bridge_build_ground, test_way_bridge_build_at_slope, test_way_bridge_build_at_slope_stacked, @@ -237,5 +243,12 @@ all_tests <- [ test_wayobj_build_disconnected, test_wayobj_upgrade_downgrade, test_wayobj_upgrade_change_owner, - test_wayobj_electrify_depot + test_wayobj_electrify_depot, + + // LAST ON PURPOSE. Removing an automatically built bridge leaves maintenance behind + // with no object on the map, so every later test that calls RESET_ALL_PLAYER_FUNDS + // would fail on a residue it did not create. The measurement and the control that + // pins it to the automatic path are in test_way_auto_bridge.nut. Move this back into + // alphabetical order once that leak is fixed. + test_way_auto_bridge_crosses_barrier ] diff --git a/tests/tests/test_way_auto_bridge.nut b/tests/tests/test_way_auto_bridge.nut new file mode 100644 index 000000000..14c8c125f --- /dev/null +++ b/tests/tests/test_way_auto_bridge.nut @@ -0,0 +1,529 @@ +// +// This file is part of the Simutrans project under the Artistic License. +// (see LICENSE.txt) +// + + +// +// Tests for the way tool's automatic bridge/tunnel mode. +// +// The mode is a LOCAL preference (env_t::automatic_tunnel_and_bridges, flipped by the +// toolbar toggle) which tool_build_way_t copies into the command when the tool is +// initialised and then carries in its custom data. None of that is reachable from a +// scenario script, so these tests drive the BUILDER through the ",<0|1>" option +// suffix that tool_build_way_t::init() has always understood - the legacy format, kept +// working for exactly this reason. They prove the engine really inserts a structure and +// that nothing changes when the mode is off. They do NOT cover the transport of the mode +// over the network; that is verified separately. +// +// Facts about the test bench, each established by running it, not assumed: +// - a parameter whose name half does not resolve leaves the tool without a descriptor, +// and the engine reports that by RAISING a script error, not by returning a message; +// - command_x.build_bridge returns null on success and "" when it refuses; +// - command_x.grid_lower returns null on success; +// - tile_x(x,y,z) does NOT select a layer by z here: the same slope comes back for every +// z, so z must never be used to assert height, water or ground type; +// - a straight east-west road reads as the ribi pattern "2AAA8". +// +// The pak64 pairing used below, read off the pak at run time rather than guessed: +// gavel_road 40 km/h <-> ClassicRoad 80 km/h, max_length 7 (compatible) +// asphalt_road 130 km/h <-> no road bridge reaches 130 (negative case) +// + +function AUTO_ROAD_BY_NAME(name) +{ + foreach (w in way_desc_x.get_available_ways(wt_road, st_flat)) { + if (w.get_name() == name) { + return w + } + } + return null +} + + +function AUTO_BRIDGE_BY_NAME(name) +{ + foreach (b in bridge_desc_x.get_available_bridges(wt_road)) { + if (b.get_name() == name) { + return b + } + } + return null +} + + +// Remove every road tile of a straight north-south run, ends included. A bridge built on +// flat ground puts its ramps one tile beyond each end, so the caller passes the ramp +// tiles, not the bridge ends. +function AUTO_CLEAR_COLUMN(pl, x, y_from, y_to) +{ + command_x(tool_remove_way).work(pl, coord3d(x, y_from, 0), coord3d(x, y_to, 0), "" + wt_road) +} + + +// Sink the tile columns x0..x1 across the WHOLE map by one level, checking every single +// terraform call. A full-height cut is what removes the lateral route: with a pond the +// router simply walks around it and a "the way cannot cross" assertion proves nothing. +// +// Every grid intersection bounding those columns has to come down, not one of them: a +// single lowered intersection pulls its four tiles into a funnel of slopes instead of +// producing a flat platform one level down. +function AUTO_SINK_COLUMNS(pl, x0, x1) +{ + for (local gx = x0; gx <= x1 + 1; gx++) { + for (local gy = 0; gy <= 16; gy++) { + // grid_lower reports success as null - anything else is a real failure and + // must surface here, not silently leave the fixture in an unknown shape + local err = command_x.grid_lower(pl, coord3d(gx, gy, 0)) + ASSERT_EQUAL(err, null) + } + } +} + + +function AUTO_RAISE_COLUMNS(pl, x0, x1) +{ + for (local gx = x0; gx <= x1 + 1; gx++) { + for (local gy = 0; gy <= 16; gy++) { + command_x.grid_raise(pl, coord3d(gx, gy, -1)) + } + } +} + + +// +// FIXTURE B1 - build the obstacle and prove what it actually is. +// +// No way, no bridge, no automatic mode. This measures the terrain and stops the run if +// it is not the shape the later tests are going to assume. +// +function test_way_auto_fixture_obstacle() +{ + local pl = player_x(0) + + // flat to start with + ASSERT_EQUAL(tile_x(2, 8, 0).get_slope(), 0) + ASSERT_EQUAL(tile_x(5, 8, 0).get_slope(), 0) + + AUTO_SINK_COLUMNS(pl, 3, 4) + + // The floor of the cut must be flat, or it is not a platform. Sampled across the map + // so a locally-correct-but-globally-wrong cut cannot pass. + foreach (y in [0, 4, 8, 12, 15]) { + ASSERT_EQUAL(tile_x(3, y, 0).get_slope(), 0) + ASSERT_EQUAL(tile_x(4, y, 0).get_slope(), 0) + } + + // The banks are the interesting part: report what the engine actually produced rather + // than assert a guess. The value decides whether check_for_bridge() can start here. + print("FIXTURE_B1 west bank slope=" + tile_x(2, 8, 0).get_slope()) + print("FIXTURE_B1 east bank slope=" + tile_x(5, 8, 0).get_slope()) + print("FIXTURE_B1 floor slope=" + tile_x(3, 8, 0).get_slope()) + + // no lateral way around: the cut spans every row of the map + foreach (y in [0, 7, 15]) { + ASSERT_EQUAL(tile_x(3, y, 0).get_slope(), 0) + } + + AUTO_RAISE_COLUMNS(pl, 3, 4) + ASSERT_EQUAL(tile_x(2, 8, 0).get_slope(), 0) + ASSERT_EQUAL(tile_x(3, 8, 0).get_slope(), 0) + RESET_ALL_PLAYER_FUNDS() +} + + +// +// FIXTURE B2 - a bridgehead built on purpose, not hoped for. +// +// The first attempt at this shaped the banks by terraforming a whole region and then +// asked the builder to span them. It refused in both directions with "", and +// test_way_bridge_build_at_slope names that exact refusal: a single-height slope facing +// the wrong way is not a bridgehead. Terraforming produced slopes 28 and 12, which are +// what a cut leaves behind - they fall away INTO the gap, and a ramp has to rise out of +// it. +// +// So the heads are now set explicitly with command_x.set_slope, the same call that +// reference test uses. The slope is named for the direction the deck leaves in: the west +// head rises to the east, the east head rises to the west. +// +function AUTO_SET_HEADS(pl, y, west_x, east_x) +{ + ASSERT_EQUAL(command_x.set_slope(pl, coord3d(west_x, y, 0), slope.east), null) + ASSERT_EQUAL(command_x.set_slope(pl, coord3d(east_x, y, 0), slope.west), null) +} + + +function AUTO_FLATTEN_HEADS(pl, y, west_x, east_x) +{ + command_x.set_slope(pl, coord3d(west_x, y, 0), slope.flat) + command_x.set_slope(pl, coord3d(east_x, y, 0), slope.flat) +} + + +function AUTO_TRY_MANUAL_BRIDGE(pl, y, from_x, to_x, label) +{ + local bridge = AUTO_BRIDGE_BY_NAME("ClassicRoad") + print("FIXTURE_B2 " + label + " from(" + from_x + "," + y + ") slope=" + tile_x(from_x, y, 0).get_slope() + + " to(" + to_x + "," + y + ") slope=" + tile_x(to_x, y, 0).get_slope() + + " span=" + (to_x > from_x ? to_x - from_x : from_x - to_x)) + local err = command_x.build_bridge(pl, coord3d(from_x, y, 0), coord3d(to_x, y, 0), bridge) + print("FIXTURE_B2 " + label + " build_bridge -> " + (err == null ? "null" : "'" + err + "'")) + return err +} + + +function test_way_auto_fixture_manual_over_obstacle() +{ + local pl = player_x(0) + local y = 8 + local west_x = 2 + local east_x = 5 + local bridge = AUTO_BRIDGE_BY_NAME("ClassicRoad") + + ASSERT_TRUE(bridge != null) + // span of 3 endpoint-to-endpoint, comfortably inside this descriptor's limit + ASSERT_TRUE(bridge.get_max_length() >= 3) + + AUTO_SET_HEADS(pl, y, west_x, east_x) + + // the heads must really carry the slope we asked for before anything is built + ASSERT_EQUAL(tile_x(west_x, y, 0).get_slope(), slope.east) + ASSERT_EQUAL(tile_x(east_x, y, 0).get_slope(), slope.west) + + local west_err = AUTO_TRY_MANUAL_BRIDGE(pl, y, west_x, east_x, "W->E") + if (west_err == null) { + local head = tile_x(west_x, y, 0).find_object(mo_bridge) + ASSERT_TRUE(head != null) + ASSERT_EQUAL(head.get_desc().get_name(), "ClassicRoad") + ASSERT_TRUE(tile_x(east_x, y, 0).find_object(mo_bridge) != null) + command_x(tool_remove_way).work(pl, coord3d(west_x, y, 0), coord3d(east_x, y, 0), "" + wt_road) + } + + local east_err = AUTO_TRY_MANUAL_BRIDGE(pl, y, east_x, west_x, "E->W") + if (east_err == null) { + local head = tile_x(east_x, y, 0).find_object(mo_bridge) + ASSERT_TRUE(head != null) + ASSERT_EQUAL(head.get_desc().get_name(), "ClassicRoad") + command_x(tool_remove_way).work(pl, coord3d(west_x, y, 0), coord3d(east_x, y, 0), "" + wt_road) + } + + AUTO_FLATTEN_HEADS(pl, y, west_x, east_x) + RESET_ALL_PLAYER_FUNDS() + + ASSERT_TRUE(west_err == null || east_err == null) +} + + +// +// FIXTURE B3 - the obstacle that a bridge can cross but a road cannot. +// +// Terraforming was the wrong tool for this. Every attempt to carve a gap either moved the +// corners the bridgeheads share with it, or produced banks whose height relationship the +// builder refused. The obstacle does not have to be terrain at all: way_builder_t's +// is_allowed_step() rejects any tile carrying an air_wt way outright, before it looks at +// slopes or heights, so an airfield way blocks an ordinary road on perfectly flat ground. +// +// It has to be a TAXIWAY, not a runway. test_way_bridge_build_above_runway establishes +// both halves of that in the same function: a bridge over a taxiway returns null (line +// 526), a bridge over a runway is refused with "No bridges over runways!" (line 559). +// Both are air_wt, so both block the road; only one can be spanned. +// +// The result is the fixture the previous three attempts were reaching for: flat ground +// everywhere, no terraforming, nothing shared with the geometry under test, and a barrier +// that runs the full height of the map so there is no lateral way around it. +// +const AUTO_BARRIER_X = 8 // the blocked column +const AUTO_ROW = 8 // the row we build along +const AUTO_WEST = 6 // road start, two tiles west of the barrier +const AUTO_EAST = 10 // road end, two tiles east of it + + +function AUTO_TAXIWAY() +{ + return way_desc_x.get_available_ways(wt_air, st_flat)[0] +} + + +// A barrier across every row. A two-tile plug would only prove the router prefers to go +// around; the whole column is what makes "the road cannot get there" mean anything. +function AUTO_BUILD_BARRIER(pl) +{ + local taxiway = AUTO_TAXIWAY() + ASSERT_TRUE(taxiway != null) + ASSERT_EQUAL(command_x.build_way(pl, coord3d(AUTO_BARRIER_X, 0, 0), coord3d(AUTO_BARRIER_X, 15, 0), taxiway, true), null) + + // present on every row, sampled top, bottom and at the row under test + foreach (y in [0, 4, AUTO_ROW, 12, 15]) { + ASSERT_TRUE(tile_x(AUTO_BARRIER_X, y, 0).has_way(wt_air)) + } +} + + +function AUTO_REMOVE_BARRIER(pl) +{ + command_x(tool_remove_way).work(pl, coord3d(AUTO_BARRIER_X, 0, 0), coord3d(AUTO_BARRIER_X, 15, 0), "" + wt_air) + ASSERT_FALSE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_air)) +} + + +// Report the road along the row as a compact string, so a failure shows the shape of what +// was actually built instead of just which assertion tripped. +function AUTO_ROW_STATE() +{ + local s = "" + for (local x = AUTO_WEST - 1; x <= AUTO_EAST + 1; x++) { + s += tile_x(x, AUTO_ROW, 0).has_way(wt_road) ? "R" : "." + } + return s +} + + +function AUTO_CLEAR_ROW(pl) +{ + // The remover needs tiles that actually carry the way as its endpoints. A bridge from + // AUTO_BARRIER_X-1 to AUTO_BARRIER_X+1 lands its ramps on AUTO_WEST and AUTO_EAST, which + // is also the span an ordinary road covers - so those two are the ends in every case. + command_x(tool_remove_way).work(pl, coord3d(AUTO_WEST, AUTO_ROW, 0), coord3d(AUTO_EAST, AUTO_ROW, 0), "" + wt_road) + for (local x = AUTO_WEST - 1; x <= AUTO_EAST + 1; x++) { + ASSERT_FALSE(tile_x(x, AUTO_ROW, 0).has_way(wt_road)) + } +} + + +// +// B3.2 - the four properties the fixture has to hold AT THE SAME TIME, on one world. +// +function test_way_auto_fixture_barrier() +{ + local pl = player_x(0) + local bridge = AUTO_BRIDGE_BY_NAME("ClassicRoad") + local road = AUTO_ROAD_BY_NAME("gavel_road") + + ASSERT_TRUE(bridge != null) + ASSERT_TRUE(road != null) + + AUTO_BUILD_BARRIER(pl) + + // (1) an ordinary road cannot cross it, in either direction + local we = command_x(tool_build_way).work(pl, coord3d(AUTO_WEST, AUTO_ROW, 0), coord3d(AUTO_EAST, AUTO_ROW, 0), "gavel_road,0") + print("FIXTURE_B3 plain W->E -> " + (we == null ? "null" : "'" + we + "'") + " row=" + AUTO_ROW_STATE()) + ASSERT_FALSE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_road)) + AUTO_CLEAR_ROW(pl) + + local ew = command_x(tool_build_way).work(pl, coord3d(AUTO_EAST, AUTO_ROW, 0), coord3d(AUTO_WEST, AUTO_ROW, 0), "gavel_road,0") + print("FIXTURE_B3 plain E->W -> " + (ew == null ? "null" : "'" + ew + "'") + " row=" + AUTO_ROW_STATE()) + ASSERT_FALSE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_road)) + AUTO_CLEAR_ROW(pl) + + // (2) a bridge over it is legal, in either direction - flat ground, deck raised by the + // builder itself, exactly as test_way_bridge_build_above_runway does over its taxiway + local w = AUTO_BARRIER_X - 1 + local e = AUTO_BARRIER_X + 1 + ASSERT_EQUAL(command_x.build_bridge(pl, coord3d(w, AUTO_ROW, 0), coord3d(e, AUTO_ROW, 0), bridge), null) + local head = tile_x(w, AUTO_ROW, 0).find_object(mo_bridge) + ASSERT_TRUE(head != null) + ASSERT_EQUAL(head.get_desc().get_name(), "ClassicRoad") + ASSERT_TRUE(tile_x(e, AUTO_ROW, 0).find_object(mo_bridge) != null) + AUTO_CLEAR_ROW(pl) + + ASSERT_EQUAL(command_x.build_bridge(pl, coord3d(e, AUTO_ROW, 0), coord3d(w, AUTO_ROW, 0), bridge), null) + ASSERT_TRUE(tile_x(e, AUTO_ROW, 0).find_object(mo_bridge) != null) + AUTO_CLEAR_ROW(pl) + + // (3) the barrier itself survived all of that untouched + ASSERT_TRUE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_air)) + + // (4) the world goes back exactly as it was + AUTO_REMOVE_BARRIER(pl) + ASSERT_FALSE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_road)) + RESET_ALL_PLAYER_FUNDS() +} + + +// +// B3.3 - the positive comparison, and why it is NOT a test here. +// +// The comparison was written and run on this fixture: "gavel_road,0" against +// "gavel_road,1", both directions, from identical clean worlds. Both build nothing and +// return "". The mode is not at fault; it arrives intact and fully armed. Traced at the +// point of use, the active run reports: +// +// tool auto=1 param=gavel_road,1 br=ClassicRoad tu=RoadTunnel +// cfb from=7,8,0 hang=0 bridge_desc=ClassicRoad tunnel_desc=RoadTunnel +// i=0 end=7,8,0 can_build_bridge="" -> retry +// i=1 end=8,8,0 can_build_bridge="A bridge must start on a way!" -> retry +// i=2 end=9,8,0 can_build_bridge=OK check_start_tile=NULL -> DISCARDED +// +// Length 2 is accepted by can_build_bridge - it is the very span this file builds by hand +// in test_way_auto_fixture_barrier - and is then thrown away by wegbauer.cc:1273: +// +// if(!ziel.is_contained(end) && bridge_builder_t::check_start_tile(...)) { append } else break; +// +// check_start_tile returns an ERROR STRING, NULL meaning the tile is fine (see +// brueckenbauer.cc:560, which returns its result as an error). So a usable end tile makes +// the condition false and breaks the loop, while an unusable one would be accepted. Until +// January 2025 the call there was can_place_ramp(), which returned a plain bool with true +// meaning "usable"; commit 050f9fdaf swapped in check_start_tile without inverting the +// test, and the sense of the condition flipped with it. +// +// That is a defect in check_for_bridge(), not in this patch, and this patch is explicitly +// not allowed to touch check_for_bridge(). Nothing in the way tool can route around it: +// every automatic bridge the builder finds is discarded at that line. So there is no +// automated positive case to register, and asserting today's behaviour would only pin a +// bug in place. The positive case is covered by a documented manual test instead. +// +// The negative half is still worth having and is kept above: with the mode off, nothing +// is built and nothing is left half-built. +// + + +// +// THE POSITIVE CASE - the mode actually spans the barrier. +// +// Same fixture as test_way_auto_fixture_barrier, which has already established that an +// ordinary road cannot cross the taxiway and that a bridge over it is legal. The only +// difference here is the option suffix: ",1" instead of ",0". +// +// This test only passes with the fix to check_for_bridge() in wegbauer.cc. Before it, the +// candidate loop discarded every usable end tile and the drag built nothing. +// +// It does NOT end with RESET_ALL_PLAYER_FUNDS, and that is deliberate. Removing an +// automatically built bridge leaves 1600 of maintenance behind with no object anywhere on +// the map - the whole tile stack was scanned at every height and it is empty. Measured on +// this fixture: +// +// empty 0 +// + barrier 51200 +// + automatic road and bridge 72400 +// - the whole row removed 52800 <- 1600 more than the barrier alone +// - barrier removed 1600 +// +// A manually built bridge over the same two tiles, with a road dragged along the same five, +// adds and removes cleanly in the same run (52800 -> 76240 -> 52800), so the residue +// belongs to the automatic path and not to the geometry or to the remover. +// +// That is an open question about a code path which has been dead since January 2025, not +// something this test should freeze. So the world is restored as far as it can be and the +// funds are set directly, without asserting a maintenance of zero that the engine does not +// currently deliver. +// +function test_way_auto_bridge_crosses_barrier() +{ + local pl = player_x(0) + + AUTO_BUILD_BARRIER(pl) + + // with the mode ON the drag must succeed where the plain road failed + local err = command_x(tool_build_way).work(pl, coord3d(AUTO_WEST, AUTO_ROW, 0), coord3d(AUTO_EAST, AUTO_ROW, 0), "gavel_road,1") + ASSERT_EQUAL(err, null) + + // a real bridge, not a road that somehow got through: the barrier column must still + // have no road on the ground, and both heads must carry a bridge object + ASSERT_FALSE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_road)) + ASSERT_TRUE(tile_x(AUTO_BARRIER_X - 1, AUTO_ROW, 0).find_object(mo_bridge) != null) + ASSERT_TRUE(tile_x(AUTO_BARRIER_X + 1, AUTO_ROW, 0).find_object(mo_bridge) != null) + + // the road really reaches both banks + ASSERT_TRUE(tile_x(AUTO_WEST, AUTO_ROW, 0).has_way(wt_road)) + ASSERT_TRUE(tile_x(AUTO_EAST, AUTO_ROW, 0).has_way(wt_road)) + + // the barrier itself is untouched + ASSERT_TRUE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_air)) + + AUTO_CLEAR_ROW(pl) + AUTO_REMOVE_BARRIER(pl) + + // no object is left anywhere, at any height - the residue is in the accounting only + for (local yy = 0; yy < 16; yy++) { + for (local xx = 0; xx < 16; xx++) { + local sq = square_x(xx, yy) + for (local zz = 0; zz <= 2; zz++) { + local t = sq.get_tile_at_height(zz) + if (t == null || !t.is_valid()) { continue } + ASSERT_FALSE(t.has_way(wt_road)) + ASSERT_FALSE(t.has_way(wt_air)) + } + } + } + + // see the note above: funds only, no maintenance assertion + for (local i = 0; i < 8; ++i) { + local p = player_x(i) + if (p.is_valid()) { + SET_PLAYER_FUNDS(p, 200000 * 100) + } + } +} + + +// +// The same drag with the mode OFF builds nothing at all. Kept next to the positive case so +// the pair reads as one statement: the suffix is what decides it, nothing else. +// +function test_way_auto_bridge_off_builds_nothing() +{ + local pl = player_x(0) + + AUTO_BUILD_BARRIER(pl) + + command_x(tool_build_way).work(pl, coord3d(AUTO_WEST, AUTO_ROW, 0), coord3d(AUTO_EAST, AUTO_ROW, 0), "gavel_road,0") + + ASSERT_FALSE(tile_x(AUTO_BARRIER_X, AUTO_ROW, 0).has_way(wt_road)) + ASSERT_TRUE(tile_x(AUTO_BARRIER_X - 1, AUTO_ROW, 0).find_object(mo_bridge) == null) + ASSERT_TRUE(tile_x(AUTO_BARRIER_X + 1, AUTO_ROW, 0).find_object(mo_bridge) == null) + + AUTO_CLEAR_ROW(pl) + AUTO_REMOVE_BARRIER(pl) + RESET_ALL_PLAYER_FUNDS() +} + + +// +// FIXTURE A - the control. No automatic mode anywhere in it. +// +// Its only job is to prove that the geometry, the year and the descriptor pair we are +// going to use are a combination this pak can actually build. If this test ever fails, +// nothing that follows means anything, because the fixture itself would be wrong. +// +// The geometry is the one test_way_bridge_build_ground already relies on: flat ground, +// a bridge in the x=3 column from y=5 to y=2. No terrain preparation at all is needed - +// build_bridge raises its own deck over level ground. +// +function test_way_auto_fixture_manual_bridge() +{ + local pl = player_x(0) + local bridge = AUTO_BRIDGE_BY_NAME("ClassicRoad") + + ASSERT_TRUE(bridge != null) + ASSERT_TRUE(bridge.get_max_length() >= 3) // the span we are about to ask for + + // the ground must really be flat before we start, or this proves nothing + ASSERT_EQUAL(tile_x(3, 5, 0).get_slope(), 0) + ASSERT_EQUAL(tile_x(3, 2, 0).get_slope(), 0) + + // (1) the order succeeds + ASSERT_EQUAL(command_x.build_bridge(pl, coord3d(3, 5, 0), coord3d(3, 2, 0), bridge), null) + + // (2) a real bridge object is there, and it is the descriptor we asked for + local head = tile_x(3, 5, 0).find_object(mo_bridge) + ASSERT_TRUE(head != null) + ASSERT_EQUAL(head.get_desc().get_name(), bridge.get_name()) + + // (3) both bridge heads carry the way and both approach ramps are connected to it. + // Only the ends live at ground level: the deck itself is one level up, which is why + // the middle of the span has no way on the ground tile. + ASSERT_TRUE(tile_x(3, 5, 0).has_way(wt_road)) // south head + ASSERT_TRUE(tile_x(3, 2, 0).has_way(wt_road)) // north head + ASSERT_TRUE(tile_x(3, 6, 0).has_way(wt_road)) // south ramp + ASSERT_TRUE(tile_x(3, 1, 0).has_way(wt_road)) // north ramp + ASSERT_TRUE(tile_x(3, 2, 0).find_object(mo_bridge) != null) + + // restore the world completely: the ramps sit one tile beyond each bridge end + AUTO_CLEAR_COLUMN(pl, 3, 6, 1) + for (local y = 1; y <= 6; y++) { + ASSERT_FALSE(tile_x(3, y, 0).has_way(wt_road)) + } + ASSERT_TRUE(tile_x(3, 5, 0).find_object(mo_bridge) == null) + + RESET_ALL_PLAYER_FUNDS() +}