199 lines
6.9 KiB
Python
199 lines
6.9 KiB
Python
"""Tests for room rendering functions."""
|
|
|
|
from mudlib.entity import Mob
|
|
from mudlib.render.room import (
|
|
render_entity_lines,
|
|
render_exits,
|
|
render_location,
|
|
render_nearby,
|
|
render_where,
|
|
)
|
|
from mudlib.zone import Zone
|
|
|
|
|
|
def test_render_where():
|
|
"""render_where returns 'Where: {zone description}'."""
|
|
zone = Zone(name="overworld", description="The Overworld")
|
|
assert render_where(zone.description) == "Where: The Overworld"
|
|
|
|
zone2 = Zone(name="cave", description="Dark Cave")
|
|
assert render_where(zone2.description) == "Where: Dark Cave"
|
|
|
|
|
|
def test_render_location_center():
|
|
"""render_location shows 'center' for positions near zone center."""
|
|
zone = Zone(name="test", width=50, height=50, terrain=[])
|
|
# Center should be around 25, 25 (middle third of both axes)
|
|
assert render_location(zone, 25, 25) == "Location: center 25, 25"
|
|
assert render_location(zone, 20, 20) == "Location: center 20, 20"
|
|
assert render_location(zone, 30, 30) == "Location: center 30, 30"
|
|
|
|
|
|
def test_render_location_quadrants():
|
|
"""render_location shows correct quadrants based on position."""
|
|
zone = Zone(name="test", width=60, height=60, terrain=[])
|
|
# Thirds: 0-19 west/north, 20-39 center, 40-59 east/south
|
|
|
|
# Northwest
|
|
assert render_location(zone, 5, 5) == "Location: northwest 5, 5"
|
|
assert render_location(zone, 10, 10) == "Location: northwest 10, 10"
|
|
|
|
# North (center horizontally, north vertically)
|
|
assert render_location(zone, 30, 5) == "Location: north 30, 5"
|
|
|
|
# Northeast
|
|
assert render_location(zone, 50, 5) == "Location: northeast 50, 5"
|
|
|
|
# West (west horizontally, center vertically)
|
|
assert render_location(zone, 5, 30) == "Location: west 5, 30"
|
|
|
|
# East
|
|
assert render_location(zone, 50, 30) == "Location: east 50, 30"
|
|
|
|
# Southwest
|
|
assert render_location(zone, 5, 50) == "Location: southwest 5, 50"
|
|
|
|
# South
|
|
assert render_location(zone, 30, 50) == "Location: south 30, 50"
|
|
|
|
# Southeast
|
|
assert render_location(zone, 50, 50) == "Location: southeast 50, 50"
|
|
|
|
|
|
def test_render_nearby_empty():
|
|
"""render_nearby returns empty string when no nearby entities."""
|
|
assert render_nearby([], None) == ""
|
|
|
|
|
|
def test_render_nearby_single():
|
|
"""render_nearby shows count and single entity name."""
|
|
mob = Mob(name="saibaman", x=10, y=10)
|
|
result = render_nearby([mob], None)
|
|
assert result == "Nearby: (1) saibaman"
|
|
|
|
|
|
def test_render_nearby_multiple():
|
|
"""render_nearby shows count and names separated by '/'."""
|
|
mobs = [
|
|
Mob(name="saibaman", x=10, y=10),
|
|
Mob(name="Master Roshi", x=11, y=10),
|
|
Mob(name="Goku", x=10, y=11),
|
|
]
|
|
result = render_nearby(mobs, None)
|
|
assert result == "Nearby: (3) saibaman / Master Roshi / Goku"
|
|
|
|
|
|
def test_render_exits_all_directions():
|
|
"""render_exits shows all passable cardinal directions."""
|
|
# Create zone with all passable terrain (grass)
|
|
terrain = [["." for _ in range(10)] for _ in range(10)]
|
|
zone = Zone(
|
|
name="test", width=10, height=10, terrain=terrain, impassable={"^", "~"}
|
|
)
|
|
|
|
result = render_exits(zone, 5, 5)
|
|
assert result == "Exits: north south east west"
|
|
|
|
|
|
def test_render_exits_blocked_directions():
|
|
"""render_exits only shows passable directions."""
|
|
# Create zone with mountains (^) blocking some directions
|
|
terrain = [
|
|
[".", ".", ".", ".", "."],
|
|
[".", ".", "^", ".", "."], # mountain north
|
|
[".", "^", ".", "^", "."], # mountains west and east
|
|
[".", ".", "^", ".", "."], # mountain south
|
|
[".", ".", ".", ".", "."],
|
|
]
|
|
zone = Zone(name="test", width=5, height=5, terrain=terrain, impassable={"^", "~"})
|
|
|
|
# Position at center (2, 2) — surrounded by mountains
|
|
result = render_exits(zone, 2, 2)
|
|
assert result == "Exits:" # no passable exits
|
|
|
|
|
|
def test_render_exits_partial():
|
|
"""render_exits shows only available exits."""
|
|
terrain = [
|
|
[".", ".", "."],
|
|
["^", ".", "."], # mountain to west
|
|
[".", "^", "."], # mountain to south
|
|
]
|
|
zone = Zone(name="test", width=3, height=3, terrain=terrain, impassable={"^"})
|
|
|
|
# Position at (1, 1) — north and east are passable
|
|
result = render_exits(zone, 1, 1)
|
|
assert result == "Exits: north east"
|
|
|
|
|
|
def test_render_exits_includes_up_for_grounded_viewer():
|
|
"""Grounded viewer should see up as a vertical exit."""
|
|
terrain = [["." for _ in range(3)] for _ in range(3)]
|
|
zone = Zone(name="test", width=3, height=3, terrain=terrain, impassable={"^"})
|
|
|
|
class Viewer:
|
|
flying = False
|
|
|
|
result = render_exits(zone, 1, 1, Viewer())
|
|
assert result == "Exits: north south east west up"
|
|
|
|
|
|
def test_render_exits_includes_down_for_flying_viewer():
|
|
"""Flying viewer should see down as a vertical exit."""
|
|
terrain = [["." for _ in range(3)] for _ in range(3)]
|
|
zone = Zone(name="test", width=3, height=3, terrain=terrain, impassable={"^"})
|
|
|
|
class Viewer:
|
|
flying = True
|
|
|
|
result = render_exits(zone, 1, 1, Viewer())
|
|
assert result == "Exits: north south east west down"
|
|
|
|
|
|
def test_render_entity_lines_empty():
|
|
"""render_entity_lines returns empty string when no entities."""
|
|
assert render_entity_lines([], None) == ""
|
|
|
|
|
|
def test_render_entity_lines_single():
|
|
"""render_entity_lines shows single entity with posture."""
|
|
mob = Mob(name="saibaman", x=10, y=10)
|
|
# Default posture is "standing" (fallback)
|
|
result = render_entity_lines([mob], None)
|
|
assert result == "saibaman is standing here."
|
|
|
|
|
|
def test_render_entity_lines_multiple():
|
|
"""render_entity_lines shows multiple entities, each on own line."""
|
|
# Create entities with different states that affect posture
|
|
mob1 = Mob(name="saibaman", x=10, y=10) # standing by default
|
|
mob2 = Mob(name="Master Roshi", x=10, y=10, resting=True) # resting
|
|
|
|
result = render_entity_lines([mob1, mob2], None)
|
|
lines = result.split("\n")
|
|
assert len(lines) == 2
|
|
assert lines[0] == "saibaman is standing here."
|
|
assert lines[1] == "Master Roshi is resting here."
|
|
|
|
|
|
def test_render_entity_lines_postures():
|
|
"""render_entity_lines handles different posture types based on entity state."""
|
|
# Standing (default state)
|
|
mob = Mob(name="Goku", x=10, y=10)
|
|
assert render_entity_lines([mob], None) == "Goku is standing here."
|
|
|
|
# Resting (resting=True)
|
|
mob_resting = Mob(name="Goku", x=10, y=10, resting=True)
|
|
assert render_entity_lines([mob_resting], None) == "Goku is resting here."
|
|
|
|
# Unconscious (pl <= 0)
|
|
mob_unconscious = Mob(name="Goku", x=10, y=10, pl=0)
|
|
assert render_entity_lines([mob_unconscious], None) == "Goku is unconscious."
|
|
|
|
# Unconscious (stamina <= 0)
|
|
mob_exhausted = Mob(name="Goku", x=10, y=10, stamina=0)
|
|
assert render_entity_lines([mob_exhausted], None) == "Goku is unconscious."
|
|
|
|
# Sleeping
|
|
mob_sleeping = Mob(name="Goku", x=10, y=10, sleeping=True, resting=True)
|
|
assert render_entity_lines([mob_sleeping], None) == "Goku is sleeping here."
|