def make_goal_state(agent_on_goal: bool) -> State:
"""makes a simple state with a wall in front of the agent"""
grid = Grid(2, 1)
grid[0, 0] = Goal()
agent_position = (0, 0) if agent_on_goal else (1, 0)
agent = Agent(agent_position, Orientation.N)
return State(grid, agent)
def make_moving_obstacle_state(agent_on_obstacle: bool) -> State:
"""makes a simple state with goal object and agent on or off the goal"""
grid = Grid(2, 1)
grid[0, 0] = MovingObstacle()
agent_position = (0, 0) if agent_on_obstacle else (1, 0)
agent = Agent(agent_position, Orientation.N)
return State(grid, agent)
def test_grid_set_item():
grid = Grid(3, 4)
pos = Position(0, 0)
obj = Floor()
assert grid[pos] is not obj
grid[pos] = obj
assert grid[pos] is obj
def test_move_action_blocked_by_grid_object():
""" Puts an object on (2,0) and try to move there"""
grid = Grid(height=3, width=2)
agent = Agent(position=(2, 1), orientation=Orientation.N)
grid[2, 0] = Door(Door.Status.CLOSED, Color.YELLOW)
move_agent(agent, grid, action=Action.MOVE_LEFT)
assert agent.position == (2, 1)
def test_grid_get_position():
grid = Grid(3, 4)
# testing position -> grid_object -> position roundtrip
for position in grid.positions():
obj = grid[position]
assert grid.get_position(obj) == position
# testing exception when object is not in grid
with pytest.raises(ValueError):
grid.get_position(Floor())
def test_move_action_can_go_on_non_block_objects():
grid = Grid(height=3, width=2)
agent = Agent(position=(2, 1), orientation=Orientation.N)
grid[2, 0] = Door(Door.Status.OPEN, Color.YELLOW)
move_agent(agent, grid, action=Action.MOVE_LEFT)
assert agent.position == (2, 0)
grid[2, 1] = Key(Color.BLUE)
move_agent(agent, grid, action=Action.MOVE_RIGHT)
assert agent.position == (2, 1)
def test_observation_hash():
wall_position = (0, 0)
agent_position = (0, 1)
agent_orientation = Orientation.N
agent_object = None
grid = Grid(2, 2)
grid[wall_position] = Wall()
agent = Agent(agent_position, agent_orientation, agent_object)
observation = Observation(grid, agent)
hash(observation)
def test_pickup_mechanics_swap():
grid = Grid(height=3, width=4)
agent = Agent(position=(1, 2), orientation=Orientation.S)
item_pos = (2, 2)
agent.obj = Key(Color.BLUE)
grid[item_pos] = Key(Color.GREEN)
state = State(grid, agent)
next_state = step_with_copy(state, Action.PICK_N_DROP)
assert state.grid[item_pos] == next_state.agent.obj
assert state.agent.obj == next_state.grid[item_pos]
def test_state_hash():
wall_position = (0, 0)
agent_position = (0, 1)
agent_orientation = Orientation.N
agent_object = None
grid = Grid(2, 2)
grid[wall_position] = Wall()
agent = Agent(agent_position, agent_orientation, agent_object)
state = State(grid, agent)
hash(state)
def test_move_action(
position: PositionOrTuple,
orientation: Orientation,
actions: Sequence[Action],
expected: PositionOrTuple,
):
grid = Grid(height=3, width=2)
agent = Agent(position=position, orientation=orientation)
for action in actions:
move_agent(agent, grid, action=action)
assert agent.position == expected
def test_grid_object_types():
grid = Grid(3, 4)
assert grid.object_types() == set([Floor])
grid[0, 0] = Wall()
assert grid.object_types() == set([Floor, Wall])
grid[0, 0] = Goal()
assert grid.object_types() == set([Floor, Goal])
grid[1, 1] = Wall()
assert grid.object_types() == set([Floor, Goal, Wall])
def test_minigrid_observation(agent: Agent):
grid = Grid(10, 10)
grid[5, 5] = Wall()
state = State(grid, agent)
observation_space = ObservationSpace(Shape(6, 5), [], [])
observation = minigrid_observation(
state, observation_space=observation_space
)
assert observation.agent.position == (5, 2)
assert observation.agent.orientation == Orientation.N
assert observation.agent.obj == state.agent.obj
assert observation.grid.shape == Shape(6, 5)
assert isinstance(observation.grid[3, 0], Wall)
def test_actuate_box(
content: GridObject,
orientation: Orientation,
action: Action,
expected: bool,
):
grid = Grid(2, 1)
grid[0, 0] = box = Box(content)
agent = Agent((1, 0), orientation)
state = State(grid, agent)
actuate_box(state, action)
assert (grid[0, 0] is box) != expected
assert (grid[0, 0] is content) == expected
def test_teleport(
position_telepod1: Position,
position_telepod2: Position,
position_agent: Position,
expected: Position,
):
grid = Grid(2, 2)
grid[position_telepod1] = Telepod(Color.RED)
grid[position_telepod2] = Telepod(Color.RED)
agent = Agent(position_agent, Orientation.N)
state = State(grid, agent)
step_telepod(state, Action.ACTUATE)
assert state.agent.position == expected
def test_actuate_door(
door_state: Door.Status,
door_color: Color,
key_color: Color,
action: Action,
expected_state: Door.Status,
):
# agent facing door
grid = Grid(2, 1)
grid[0, 0] = door = Door(door_state, door_color)
agent = Agent((1, 0), Orientation.N, Key(key_color))
state = State(grid, agent)
actuate_door(state, action)
assert door.state == expected_state
# agent facing away
grid = Grid(2, 1)
grid[0, 0] = door = Door(door_state, door_color)
agent = Agent((1, 0), Orientation.S, Key(key_color))
state = State(grid, agent)
actuate_door(state, action)
assert door.state == door_state
def test_pickup_mechanics_nothing_to_pickup():
grid = Grid(height=3, width=4)
agent = Agent(position=(1, 2), orientation=Orientation.S)
item_pos = (2, 2)
state = State(grid, agent)
# Cannot pickup floor
next_state = step_with_copy(state, Action.PICK_N_DROP)
assert state == next_state
# Cannot pickup door
grid[item_pos] = Door(Door.Status.CLOSED, Color.GREEN)
next_state = step_with_copy(state, Action.PICK_N_DROP)
assert state == next_state
assert isinstance(next_state.grid[item_pos], Door)
def test_pickup_mechanics_pickup():
grid = Grid(height=3, width=4)
agent = Agent(position=(1, 2), orientation=Orientation.S)
item_pos = (2, 2)
grid[item_pos] = Key(Color.GREEN)
state = State(grid, agent)
# Pick up works
next_state = step_with_copy(state, Action.PICK_N_DROP)
assert grid[item_pos] == next_state.agent.obj
assert isinstance(next_state.grid[item_pos], Floor)
# Pick up only works with correct action
next_state = step_with_copy(state, Action.MOVE_LEFT)
assert grid[item_pos] != next_state.agent.obj
assert next_state.grid[item_pos] == grid[item_pos]
def test_pickup_mechanics_drop():
grid = Grid(height=3, width=4)
agent = Agent(position=(1, 2), orientation=Orientation.S)
item_pos = (2, 2)
agent.obj = Key(Color.BLUE)
state = State(grid, agent)
# Can drop:
next_state = step_with_copy(state, Action.PICK_N_DROP)
assert isinstance(next_state.agent.obj, NoneGridObject)
assert agent.obj == next_state.grid[item_pos]
# Cannot drop:
state.grid[item_pos] = Wall()
next_state = step_with_copy(state, Action.PICK_N_DROP)
assert isinstance(next_state.grid[item_pos], Wall)
assert agent.obj == next_state.agent.obj
def reset_empty(
height: int,
width: int,
random_agent: bool = False,
random_goal: bool = False,
*,
rng: Optional[rnd.Generator] = None,
) -> State:
"""An empty environment"""
if height < 4 or width < 4:
raise ValueError('height and width need to be at least 4')
rng = get_gv_rng_if_none(rng)
# TODO test creation (e.g. count number of walls, goals, check held item)
grid = Grid(height, width)
draw_wall_boundary(grid)
if random_goal:
goal_y = rng.integers(1, height - 2, endpoint=True)
goal_x = rng.integers(1, width - 2, endpoint=True)
else:
goal_y = height - 2
goal_x = width - 2
grid[goal_y, goal_x] = Goal()
if random_agent:
agent_position = rng.choice([
position for position in grid.positions()
if isinstance(grid[position], Floor)
])
agent_orientation = rng.choice(list(Orientation))
else:
agent_position = (1, 1)
agent_orientation = Orientation.E
agent = Agent(agent_position, agent_orientation)
return State(grid, agent)
def test_grid_swap():
grid = Grid(3, 4)
# caching positions and objects before swap
objects_before = {
position: grid[position]
for position in grid.positions()
}
pos1 = Position(0, 0)
pos2 = Position(1, 1)
grid.swap(pos1, pos2)
# caching positions and objects after swap
objects_after = {position: grid[position] for position in grid.positions()}
# testing swapped objects
assert objects_before[pos1] is objects_after[pos2]
assert objects_before[pos2] is objects_after[pos1]
# testing all other objects are the same
for position in grid.positions():
if position not in (pos1, pos2):
assert objects_before[position] is objects_after[position]
draw_cartesian_product,
draw_line_horizontal,
draw_line_vertical,
draw_room,
draw_room_grid,
draw_wall_boundary,
)
from gym_gridverse.geometry import Area
from gym_gridverse.grid import Grid
from gym_gridverse.grid_object import Floor, Wall
@pytest.mark.parametrize(
'grid',
[
Grid(2, 3),
Grid(4, 5),
Grid(5, 6),
],
)
def test_draw_wall_boundary(grid: Grid):
draw_wall_boundary(grid)
for y in range(grid.height):
assert isinstance(grid[y, 0], Wall)
assert isinstance(grid[y, grid.width - 1], Wall)
for x in range(grid.width):
assert isinstance(grid[0, x], Wall)
assert isinstance(grid[grid.height - 1, x], Wall)
from gym_gridverse.grid_object import (
Box,
Color,
Floor,
Goal,
GridObject,
Hidden,
Key,
Wall,
)
@pytest.mark.parametrize(
'grid,expected',
[
(Grid(3, 4), Shape(3, 4)),
(Grid(4, 3), Shape(4, 3)),
(Grid(5, 5), Shape(5, 5)),
],
)
def test_grid_shape(grid: Grid, expected: Shape):
assert grid.shape == expected
@pytest.mark.parametrize(
'grid,position,expected',
[
(Grid(3, 4), (0, 0), True),
(Grid(3, 4), (2, 3), True),
(Grid(3, 4), (-1, 0), False),
(Grid(3, 4), (0, -1), False),
def reset_rooms( # pylint: disable=too-many-locals
height: int,
width: int,
layout: Tuple[int, int],
*,
rng: Optional[rnd.Generator] = None,
) -> State:
rng = get_gv_rng_if_none(rng)
# TODO test creation (e.g. count number of walls, goals, check held item)
layout_height, layout_width = layout
y_splits = np.linspace(
0,
height - 1,
num=layout_height + 1,
dtype=int,
)
if len(y_splits) != len(set(y_splits)):
raise ValueError(
f'insufficient height ({height}) for layout ({layout})')
x_splits = np.linspace(
0,
width - 1,
num=layout_width + 1,
dtype=int,
)
if len(x_splits) != len(set(x_splits)):
raise ValueError(
f'insufficient width ({height}) for layout ({layout})')
grid = Grid(height, width)
draw_room_grid(grid, y_splits, x_splits, Wall)
# passages in horizontal walls
for y in y_splits[1:-1]:
for x_from, x_to in mitt.pairwise(x_splits):
x = rng.integers(x_from + 1, x_to)
grid[y, x] = Floor()
# passages in vertical walls
for y_from, y_to in mitt.pairwise(y_splits):
for x in x_splits[1:-1]:
y = rng.integers(y_from + 1, y_to)
grid[y, x] = Floor()
# sample agent and goal positions
agent_position, goal_position = rng.choice(
[
position for position in grid.positions()
if isinstance(grid[position], Floor)
],
size=2,
replace=False,
)
agent_orientation = rng.choice(list(Orientation))
grid[goal_position] = Goal()
agent = Agent(agent_position, agent_orientation)
return State(grid, agent)
observation.agent.orientation = observation.agent.orientation.rotate_back()
def _change_agent_object(observation: Observation):
"""changes agent object"""
observation.agent.obj = (
Key(Color.RED)
if isinstance(observation.agent.obj, NoneGridObject)
else NoneGridObject()
)
@pytest.mark.parametrize(
'observation',
[
Observation(Grid(2, 3), Agent((0, 0), Orientation.N)),
Observation(Grid(3, 2), Agent((1, 1), Orientation.S, Key(Color.RED))),
],
)
def test_observation_eq(observation: Observation):
other_observation = deepcopy(observation)
assert observation == other_observation
other_observation = deepcopy(observation)
_change_grid(other_observation)
assert observation != other_observation
other_observation = deepcopy(observation)
_change_agent_position(other_observation)
assert observation != other_observation
def test_grid_get_item():
grid = Grid(3, 4)
pos = Position(0, 0)
assert isinstance(grid[pos], Floor)
assert grid[pos] is grid[pos]
def simple_state_without_object() -> State:
""" Returns a 2x2 (empty) grid with an agent without an item """
return State(
Grid(height=2, width=2),
Agent(position=(0, 0), orientation=Orientation.N, obj=Floor()),
)
def make_5x5_goal_state() -> State:
"""makes a simple 5x5 state with goal object in the middle"""
grid = Grid(5, 5)
grid[2, 2] = Goal()
agent = Agent((0, 0), Orientation.N)
return State(grid, agent)
def make_key_state(has_key: bool) -> State:
"""makes a simple state with a door"""
grid = Grid(1, 1)
obj = Key(Color.RED) if has_key else None
agent = Agent((0, 0), Orientation.N, obj)
return State(grid, agent)
def make_door_state(door_status: Door.Status) -> State:
"""makes a simple state with a door"""
grid = Grid(2, 1)
grid[0, 0] = Door(door_status, Color.RED)
agent = Agent((1, 0), Orientation.N)
return State(grid, agent)
def make_wall_state(orientation: Orientation = Orientation.N) -> State:
"""makes a simple state with goal object and agent on or off the goal"""
grid = Grid(2, 1)
grid[0, 0] = Wall()
agent = Agent((1, 0), orientation)
return State(grid, agent)