Initial commit

tests/test_block.py

@@ -0,0 +1,176 @@
+"""The unified `block` trap: modes, deadly/fake/crumble, jitter, sensing."""
+
+import pygame
+from conftest import FakeGame, FakeLevel, reversals, step, run, place, hold
+from game.traps import Block, expand_spec
+
+
+def block(**spec):
+    spec.setdefault("type", "block")
+    spec.setdefault("at", [16, 6])
+    return Block(spec, FakeLevel())
+
+
+def test_stationary_is_solid():
+    b = block(at=[3, 3])
+    assert b.solid_rects() == [b._rect()]
+    assert b.hazard_rects() == []
+
+
+def test_deadly_is_hazard_not_solid():
+    b = block(at=[3, 3], deadly=True)
+    assert b.solid_rects() == []
+    assert b.hazard_rects()          # non-empty
+
+
+def test_fake_is_drawn_but_not_solid():
+    b = block(at=[3, 3], fake=True)
+    assert b.solid_rects() == []     # you fall through
+    assert b.sprite == "fake_block"  # looks like a real block
+
+
+def test_crumble_cycle_and_emerge_kill(make_game):
+    g = make_game("""
+name: t
+tile_size: 32
+map: |
+  ######
+  #.P..#
+  #...G#
+  ######
+traps:
+  - type: block
+    at: [2, 2]
+    crumble: true
+    crumble_delay: 0.3
+    respawn: 0.8
+""")
+    cb = g.level.traps[0]
+    states, killed, d0 = set(), False, g.deaths
+    for _ in range(300):
+        step(g)
+        states.add(cb.cstate)
+        if g.deaths > d0:
+            killed = True
+            break
+    assert "gone" in states          # it crumbled away
+    assert killed                    # re-formed onto the standing player
+
+
+def test_moving_block_that_crumbles(make_game):
+    g = make_game("""
+name: t
+tile_size: 32
+map: |
+  ##########
+  #........#
+  #........#
+  #.......G#
+  ##########
+traps:
+  - type: block
+    at: [2, 2]
+    path: [[2, 2], [7, 2]]
+    mode: pingpong
+    speed: 90
+    crumble: true
+    crumble_delay: 0.3
+    respawn: 1.0
+""")
+    b = g.level.traps[0]
+    place(g, 2, 1)                   # ride the platform
+    moved = crumbled = False
+    start = b.x
+    for _ in range(200):
+        step(g)
+        moved |= abs(b.x - start) > 20
+        crumbled |= b.cstate != "solid"
+        if g.state != "playing":
+            break
+    assert moved and crumbled
+
+
+def test_patrol_loop_visits_all_waypoints():
+    b = block(at=[0, 0], path=[[0, 0], [4, 0], [4, 3]], mode="loop", speed=400)
+    g = FakeGame(pygame.Rect(0, 0, 4, 4))
+    seen = set()
+    for _ in range(600):
+        b.update(1 / 60, g)
+        seen.add((round(b.x / 32), round(b.y / 32)))
+    assert {(0, 0), (4, 0), (4, 3)} <= seen
+
+
+def test_slider_once_no_jitter_and_retracts():
+    # sense=home (default): a slider moving away can't toggle its own trigger.
+    b = block(at=[16, 6], move=[-3, 0], speed=260, trigger={"within": 3})
+    g = FakeGame(pygame.Rect(17 * 32, 6 * 32, 23, 29))   # player parked to the right
+    xs = [(b.update(1 / 60, g), b.x)[1] for _ in range(120)]
+    assert reversals(xs) == 0 and abs(xs[-1] - 13 * 32) < 2   # committed to displaced
+    g.player.rect.x = 30 * 32                                 # leave
+    xs = [(b.update(1 / 60, g), b.x)[1] for _ in range(120)]
+    assert reversals(xs) == 0 and abs(xs[-1] - 16 * 32) < 2   # retracted to base
+
+
+def test_sense_current_rides_down():
+    # A dropper (sense=current) commits to the bottom and holds while ridden.
+    b = block(at=[21, 9], move=[0, 4], speed=220, sense="current",
+              trigger={"all": [{"within": 5}, {"dir": "above", "aligned": True}]})
+    # player standing on top of it
+    p = pygame.Rect(21 * 32 + 4, 9 * 32 - 29, 23, 29)
+    g = FakeGame(p)
+    ys = []
+    for _ in range(90):
+        b.update(1 / 60, g)
+        # keep the player riding the block top
+        p.bottom = b._rect().top
+        ys.append(b.y)
+    assert reversals(ys) == 0 and abs(ys[-1] - 13 * 32) < 2   # dropped fully, no bob
+
+
+def test_carriers_reports_motion():
+    b = block(at=[0, 5], path=[[0, 5], [5, 5]], mode="pingpong", speed=120)
+    g = FakeGame(pygame.Rect(0, 0, 4, 4))
+    b.update(1 / 60, g)
+    (rect, dx, dy), = b.carriers()
+    assert dx != 0 and dy == 0        # moving horizontally
+
+
+# --- array expansion (count / spacing) --------------------------------------
+def test_expand_no_count_yields_one():
+    specs = list(expand_spec({"type": "block", "at": [2, 3]}))
+    assert specs == [{"type": "block", "at": [2, 3]}]
+
+
+def test_expand_line():
+    ats = [s["at"] for s in expand_spec({"type": "spike", "at": [1, 1], "count": 4})]
+    assert ats == [[1, 1], [2, 1], [3, 1], [4, 1]]
+
+
+def test_expand_grid_with_spacing():
+    ats = [s["at"] for s in expand_spec(
+        {"type": "block", "at": [0, 0], "count": [3, 2], "spacing": [2, 3]})]
+    assert ats == [[0, 0], [2, 0], [4, 0], [0, 3], [2, 3], [4, 3]]
+    # count/spacing are stripped from each expanded spec
+    for s in expand_spec({"type": "block", "at": [0, 0], "count": [2, 1]}):
+        assert "count" not in s and "spacing" not in s
+
+
+def test_array_expands_in_level(make_level):
+    lvl = make_level("""
+name: t
+tile_size: 32
+map: |
+  ########
+  #......#
+  #P....G#
+  ########
+traps:
+  - type: block
+    at: [2, 1]
+    deadly: true
+    count: [4, 1]
+""")
+    blocks = [t for t in lvl.traps if isinstance(t, Block)]
+    assert len(blocks) == 4
+    assert all(b.deadly for b in blocks)
+    assert sorted(b.current_rect().x for b in blocks) == [2 * 32, 3 * 32, 4 * 32, 5 * 32]