multi-agent-rlenv 3.7.0__py3-none-any.whl → 3.7.2__py3-none-any.whl

marlenv/adapters/__init__.py

@@ -1,25 +1,28 @@
-from importlib.util import find_spec
 from .pymarl_adapter import PymarlAdapter
-from marlenv.utils import dummy_type, dummy_function
+from marlenv.utils import dummy_function
 
-HAS_GYM = find_spec("gymnasium") is not None
-if HAS_GYM:
+try:
     from .gym_adapter import Gym, make
-else:
-    Gym = dummy_type("gymnasium")
+
+    HAS_GYM = True
+except ImportError:
+    HAS_GYM = False
     make = dummy_function("gymnasium")
 
-HAS_PETTINGZOO = find_spec("pettingzoo") is not None
-if HAS_PETTINGZOO:
+try:
     from .pettingzoo_adapter import PettingZoo
-else:
-    PettingZoo = dummy_type("pettingzoo")
 
-HAS_SMAC = find_spec("smac") is not None
-if HAS_SMAC:
+    HAS_PETTINGZOO = True
+except ImportError:
+    HAS_PETTINGZOO = False
+
+try:
     from .smac_adapter import SMAC
-else:
-    SMAC = dummy_type("smac", "https://github.com/oxwhirl/smac.git")
+
+    HAS_SMAC = True
+except ImportError:
+    HAS_SMAC = False
+
 
 __all__ = [
     "PymarlAdapter",

marlenv/adapters/pettingzoo_adapter.py

@@ -3,7 +3,7 @@ from typing import Sequence
 
 import numpy as np
 import numpy.typing as npt
-from gymnasium import spaces  # pettingzoo uses gymnasium spaces
+from gymnasium import spaces
 from pettingzoo import ParallelEnv
 
 from marlenv.models import MARLEnv, Observation, State, Step, DiscreteSpace, ContinuousSpace, Space

marlenv/adapters/smac_adapter.py

@@ -3,7 +3,7 @@ from typing import overload
 
 import numpy as np
 import numpy.typing as npt
-from smac.env import StarCraft2Env  # type:ignore[import]
+from smac.env import StarCraft2Env  # pyright: ignore[reportMissingImports]
 
 from marlenv.models import MARLEnv, Observation, State, Step, MultiDiscreteSpace, DiscreteSpace
 
@@ -181,20 +181,7 @@ class SMAC(MARLEnv[MultiDiscreteSpace]):
 
     def step(self, action):
         reward, done, info = self._env.step(action)
-        obs = Observation(
-            self._env.get_obs(),  # type: ignore
-            self.available_actions(),
-        )
-        state = self.get_state()
-        step = Step(
-            obs,
-            state,
-            reward,
-            done,
-            False,
-            info,
-        )
-        return step
+        return Step(self.get_observation(), self.get_state(), reward, done, False, info)
 
     def available_actions(self) -> npt.NDArray[np.bool]:
         return np.array(self._env.get_avail_actions()) == 1

marlenv/catalog/__init__.py

@@ -1,13 +1,15 @@
-from marlenv.adapters import SMAC
 from .deepsea import DeepSea
+from .matrix_game import MatrixGame
+from .coordinated_grid import CoordinatedGrid
 
 
-__all__ = [
-    "SMAC",
-    "DeepSea",
-    "lle",
-    "overcooked",
-]
+__all__ = ["smac", "DeepSea", "lle", "overcooked", "MatrixGame", "connect_n", "CoordinatedGrid"]
+
+
+def smac():
+    from marlenv.adapters import SMAC
+
+    return SMAC
 
 
 def lle():
@@ -20,3 +22,9 @@ def overcooked():
     from overcooked import Overcooked  # pyright: ignore[reportMissingImports]
 
     return Overcooked
+
+
+def connect_n():
+    from .connectn import ConnectN
+
+    return ConnectN

marlenv/catalog/connectn/__init__.py

@@ -0,0 +1,11 @@
+"""
+Connect-N game environment.
+
+Inspiration from: https://github.com/Gualor/connect4-montecarlo
+"""
+
+from .board import GameBoard
+from .env import ConnectN
+
+
+__all__ = ["ConnectN", "GameBoard"]

marlenv/catalog/connectn/board.py

@@ -0,0 +1,186 @@
+from enum import IntEnum
+
+import numpy as np
+
+
+class StepResult(IntEnum):
+    NOTHING = 0
+    TIE = 1
+    WIN = 2
+
+
+class GameBoard:
+    """Connect4 game board class."""
+
+    def __init__(self, width: int, height: int, n: int):
+        assert width >= n or height >= height, "Impossible to win with this combination of width, height and n"
+        self.turn = 1
+        self.board = np.zeros(shape=(height, width), dtype=np.float32)
+        self.width = width
+        self.height = height
+        self.n_to_align = n
+        self.n_items_in_column = np.zeros(width, dtype=np.int32)
+
+        self.str_row = "+" + "-" * (self.width * 4 - 1) + "+"
+        self.numbers = "|" + " ".join([f" {i} " for i in range(self.width)]) + "|"
+
+    def valid_moves(self):
+        """Get list of valid moves (i.e. not full columns)."""
+        return self.n_items_in_column < self.height
+
+    def clear(self):
+        self.board = np.zeros(shape=(self.height, self.width), dtype=np.float32)
+        self.n_items_in_column = np.zeros(self.width, dtype=np.int32)
+        self.turn = 0
+
+    def show(self):
+        """Print out game board on console."""
+        print(self.str_row)
+        for j in range(self.height - 1, -1, -1):
+            for i in range(self.width):
+                match self.board[j, i]:
+                    case 1:
+                        print("| X", end=" ")
+                    case -1:
+                        print("| O", end=" ")
+                    case _:
+                        print("|  ", end=" ")
+            print("|")
+        print(self.str_row)
+        print(self.numbers)
+        print(self.str_row)
+
+    def check_win(self, move_played: tuple[int, int]) -> bool:
+        if self.check_rows(move_played):
+            return True
+        if self.check_cols(move_played):
+            return True
+        if self.check_diags(move_played):
+            return True
+        return False
+
+    def check_tie(self) -> bool:
+        """
+        Check whether the game is a tie (i.e. the board is full).
+
+        Note that it does not check for a win, so it should be called after check_win.
+        """
+        # If the last row is full, the game is a tie
+        return bool(np.all(self.board[-1] != 0))
+
+    def check_rows(self, move_played: tuple[int, int]) -> bool:
+        row, col = move_played
+        start_index = max(0, col - self.n_to_align + 1)
+        end_index = min(self.width - self.n_to_align, col) + 1
+        for start in range(start_index, end_index):
+            slice = self.board[row, start : start + self.n_to_align]
+            if np.all(slice == self.turn):
+                return True
+        return False
+
+    def check_cols(self, move_played: tuple[int, int]) -> bool:
+        row, col = move_played
+        start_index = max(0, row - self.n_to_align + 1)
+        end_index = min(self.height - self.n_to_align, row) + 1
+        for start in range(start_index, end_index):
+            slice = self.board[start : start + self.n_to_align, col]
+            if np.all(slice == self.turn):
+                return True
+        return False
+
+    def check_diags(self, move_played: tuple[int, int]) -> bool:
+        row, col = move_played
+        # count the adjacent items in the / diagonal
+        n_adjacent = 0
+        # Top right
+        row_i, col_i = row + 1, col + 1
+        while row_i < self.height and col_i < self.width and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i += 1
+            col_i += 1
+        # Bottom left
+        row_i, col_i = row - 1, col - 1
+        while row_i >= 0 and col_i >= 0 and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i -= 1
+            col_i -= 1
+        if n_adjacent >= self.n_to_align - 1:
+            return True
+
+        # Count adjacent items in the \ diagonal
+        n_adjacent = 0
+        # Top left
+        row_i, col_i = row + 1, col - 1
+        while row_i < self.height and col_i >= 0 and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i += 1
+            col_i -= 1
+        # Bottom right
+        row_i, col_i = row - 1, col + 1
+        while row_i >= 0 and col_i < self.width and self.board[row_i, col_i] == self.turn:
+            n_adjacent += 1
+            row_i -= 1
+            col_i += 1
+
+        return n_adjacent >= self.n_to_align - 1
+
+    def play(self, column: int) -> StepResult:
+        """Apply move to board.
+
+        Args:
+            column (int): Selected column index (between 0 and the number of cols - 1).
+
+        Returns:
+            bool: whether the player has won.
+        """
+        row_index = self.n_items_in_column[column]
+        if row_index >= self.height:
+            raise ValueError(f"Column {column} is full, use `valid_moves` to check valid moves.")
+        self.n_items_in_column[column] += 1
+        self.board[row_index, column] = self.turn
+        if self.check_win((row_index, column)):
+            result = StepResult.WIN
+        elif self.check_tie():
+            result = StepResult.TIE
+        else:
+            result = StepResult.NOTHING
+        self.switch_turn()
+        return result
+
+    def switch_turn(self) -> None:
+        """Switch turn between players."""
+        self.turn = -self.turn
+
+
+def test_win():
+    board = GameBoard(4, 1, 2)
+    assert board.play(0) == StepResult.NOTHING
+    assert board.play(2) == StepResult.NOTHING
+    assert board.play(1) == StepResult.WIN
+
+
+def test_tie():
+    board = GameBoard(4, 1, 2)
+    assert board.play(0) == StepResult.NOTHING
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(2) == StepResult.NOTHING
+    assert board.play(3) == StepResult.TIE
+
+
+def test_win_diag():
+    board = GameBoard(2, 2, 2)
+    assert board.play(0) == StepResult.NOTHING
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(1) == StepResult.WIN
+
+    board.clear()
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(1) == StepResult.NOTHING
+    assert board.play(0) == StepResult.WIN
+
+
+if __name__ == "__main__":
+    test_win()
+    test_tie()
+    test_win_diag()
+    print("All tests passed!")

marlenv/catalog/connectn/env.py

@@ -0,0 +1,51 @@
+from typing import Sequence
+import numpy as np
+import numpy.typing as npt
+from marlenv import MARLEnv, MultiDiscreteSpace, Step, State, Observation, DiscreteSpace
+
+from .board import GameBoard, StepResult
+
+
+class ConnectN(MARLEnv[MultiDiscreteSpace]):
+    def __init__(self, width: int = 7, height: int = 6, n: int = 4):
+        self.board = GameBoard(width, height, n)
+        action_space = DiscreteSpace(self.board.width).repeat(1)
+        observation_shape = (self.board.height, self.board.width)
+        state_shape = observation_shape
+        super().__init__(1, action_space, observation_shape, state_shape)
+
+    def reset(self):
+        self.board.clear()
+        return self.get_observation(), self.get_state()
+
+    def step(self, action: Sequence[int] | npt.NDArray[np.uint32]):
+        match self.board.play(action[0]):
+            case StepResult.NOTHING:
+                done = False
+                reward = 0
+            case StepResult.WIN:
+                done = True
+                reward = 1
+            case StepResult.TIE:
+                done = True
+                reward = 0
+        return Step(self.get_observation(), self.get_state(), reward, done, False)
+
+    def available_actions(self):
+        """Full columns are not available."""
+        return np.expand_dims(self.board.valid_moves(), axis=0)
+
+    def get_observation(self):
+        return Observation(self.board.board.copy(), self.available_actions())
+
+    def get_state(self):
+        return State(self.board.board.copy(), np.array([self.board.turn]))
+
+    def set_state(self, state: State):
+        self.board.board = state.data.copy()  # type: ignore Currently a type error because of the unchecked shape
+        self.board.turn = int(state.extras[0])
+        n_completed = np.count_nonzero(self.board.board, axis=0)
+        self.board.n_items_in_column = n_completed
+
+    def render(self):
+        self.board.show()

marlenv/catalog/coordinated_grid.py

@@ -0,0 +1,139 @@
+import numpy as np
+import itertools
+from marlenv import MARLEnv, DiscreteSpace, Observation, State, Step
+
+
+N_ROWS = 11
+N_COLS = 12
+
+
+class CoordinatedGrid(MARLEnv):
+    """
+    Coordinated grid world environment used in the EMC paper to test the effectiveness of the proposed method.
+    https://proceedings.neurips.cc/paper_files/paper/2021/file/1e8ca836c962598551882e689265c1c5-Paper.pdf
+    """
+
+    def __init__(
+        self,
+        episode_limit=30,
+        time_penalty=2,
+    ):
+        super().__init__(
+            n_agents=2,
+            action_space=DiscreteSpace(5, ["SOUTH", "NORTH", "WEST", "EAST", "STAY"]).repeat(2),
+            observation_shape=(N_ROWS + N_COLS,),
+            state_shape=(N_ROWS + N_COLS,) * 2,
+        )
+        self._episode_steps = 0
+        self.episode_limit = episode_limit
+        self.center = N_COLS // 2
+        ###larger gridworld
+        visible_row = [i for i in range(N_ROWS // 2 - 2, N_ROWS // 2 + 3)]
+        visible_col = [i for i in range(N_COLS // 2 - 3, N_COLS // 2 + 3)]
+        self.vision_index = [[i, j] for i, j in list(itertools.product(visible_row, visible_col))]
+        self.agents_location = [[0, 0], [N_ROWS - 1, N_COLS - 1]]
+        self.time_penalty = time_penalty
+
+    def reset(self):
+        self.agents_location = [[0, 0], [N_ROWS - 1, N_COLS - 1]]
+        self._episode_steps = 0
+        return self.get_observation(), self.get_state()
+
+    def get_observation(self):
+        obs_1 = [[0 for _ in range(N_ROWS)], [0 for _ in range(N_COLS)]]
+        # obs_2 = obs_1.copy()
+        import copy
+
+        obs_2 = copy.deepcopy(obs_1)
+
+        obs_1[0][self.agents_location[0][0]] = 1
+        obs_1[1][self.agents_location[0][1]] = 1
+        obs_1 = obs_1[0] + obs_1[1]
+
+        obs_2[0][self.agents_location[1][0]] = 1
+        obs_2[1][self.agents_location[1][1]] = 1
+        obs_2 = obs_2[0] + obs_2[1]
+
+        if self.agents_location[0] in self.vision_index and self.agents_location[1] in self.vision_index:
+            temp = obs_1.copy()
+            obs_1 += obs_2.copy()
+            obs_2 += temp.copy()
+        elif self.agents_location[0] in self.vision_index:
+            obs_2 += obs_1.copy()
+            obs_1 += [0 for _ in range(N_ROWS + N_COLS)]
+        elif self.agents_location[1] in self.vision_index:
+            obs_1 += obs_2.copy()
+            obs_2 += [0 for _ in range(N_ROWS + N_COLS)]
+        else:
+            obs_2 += [0 for _ in range(N_ROWS + N_COLS)]
+            obs_1 += [0 for _ in range(N_ROWS + N_COLS)]
+
+        obs_data = np.array([obs_1, obs_2])
+        return Observation(obs_data, self.available_actions())
+
+    def get_state(self):
+        obs = self.get_observation()
+        state_data = obs.data.reshape(-1)
+        return State(state_data)
+
+    def available_actions(self):
+        avail_actions = np.full((self.n_agents, self.n_actions), True)
+        for agent_num, (y, x) in enumerate(self.agents_location):
+            if x == 0:
+                avail_actions[agent_num, 0] = 0
+            elif x == N_ROWS - 1:
+                avail_actions[agent_num, 1] = 0
+            if y == 0:
+                avail_actions[agent_num, 2] = 0
+            # Check for center line (depends on the agent number)
+            elif y == self.center + agent_num - 1:
+                avail_actions[agent_num, 3] = 0
+        return avail_actions
+
+    def step(self, action):
+        for idx, action in enumerate(action):
+            match action:
+                case 0:
+                    self.agents_location[idx][0] -= 1
+                case 1:
+                    self.agents_location[idx][0] += 1
+                case 2:
+                    self.agents_location[idx][1] -= 1
+                case 3:
+                    self.agents_location[idx][1] += 1
+                case 4:
+                    pass
+                case _:
+                    raise ValueError(f"Invalid action {action} for agent {idx}!")
+
+        self._episode_steps += 1
+        terminated = self._episode_steps >= self.episode_limit
+        env_info = {"battle_won": False}
+        n_arrived = self.n_agents_arrived()
+        if n_arrived == 1:
+            reward = -self.time_penalty
+        elif n_arrived == 2:
+            reward = 10
+            terminated = True
+            env_info = {"battle_won": True}
+        else:
+            reward = 0
+        return Step(self.get_observation(), self.get_state(), reward, terminated, terminated, env_info)
+
+    def n_agents_arrived(self):
+        n = 0
+        if self.agents_location[0] == [N_ROWS // 2, self.center - 1]:
+            n += 1
+        if self.agents_location[1] == [N_ROWS // 2, self.center]:
+            n += 1
+        return n
+
+    def render(self):
+        print("Agents location: ", self.agents_location)
+        for row in range(N_ROWS):
+            for col in range(N_COLS):
+                if [row, col] in self.agents_location:
+                    print("X", end=" ")
+                else:
+                    print(".", end=" ")
+            print()

marlenv/catalog/matrix_game.py

@@ -0,0 +1,52 @@
+import numpy as np
+from marlenv import MARLEnv, Observation, DiscreteSpace, State, Step
+
+
+class MatrixGame(MARLEnv):
+    """Single step matrix game used in QTRAN, Qatten and QPLEX papers."""
+
+    N_AGENTS = 2
+    UNIT_DIM = 1
+    OBS_SHAPE = (1,)
+    STATE_SIZE = UNIT_DIM * N_AGENTS
+
+    QPLEX_PAYOFF_MATRIX = [
+        [8.0, -12.0, -12.0],
+        [-12.0, 0.0, 0.0],
+        [-12.0, 0.0, 0.0],
+    ]
+
+    def __init__(self, payoff_matrix: list[list[float]]):
+        action_names = [chr(ord("A") + i) for i in range(len(payoff_matrix[0]))]
+        super().__init__(
+            2,
+            action_space=DiscreteSpace(len(payoff_matrix[0]), action_names).repeat(2),
+            observation_shape=MatrixGame.OBS_SHAPE,
+            state_shape=(MatrixGame.STATE_SIZE,),
+        )
+        self.current_step = 0
+        self.payoffs = payoff_matrix
+
+    def reset(self):
+        self.current_step = 0
+        return self.get_observation(), self.get_state()
+
+    def get_observation(self):
+        return Observation(
+            np.array([[self.current_step]] * MatrixGame.N_AGENTS, np.float32),
+            self.available_actions(),
+        )
+
+    def step(self, action):
+        action = list(action)
+        self.current_step += 1
+        return Step(self.get_observation(), self.get_state(), self.payoffs[action[0]][action[1]], True)
+
+    def render(self):
+        return
+
+    def get_state(self):
+        return State(np.zeros((MatrixGame.STATE_SIZE,), np.float32))
+
+    def seed(self, seed_value):
+        return

marlenv/models/observation.py

@@ -92,7 +92,7 @@ class Observation:
         """
         Convert the observation to a tuple of tensors of shape (1, n_agents, <dim>).
         """
-        import torch
+        import torch  # pyright: ignore[reportMissingImports]
 
         data = torch.from_numpy(self.data).unsqueeze(0).to(device, non_blocking=True)
         extras = torch.from_numpy(self.extras).unsqueeze(0).to(device, non_blocking=True)

marlenv/models/state.py

@@ -55,7 +55,7 @@ class State(Generic[StateType]):
 
     def as_tensors(self, device=None):
         """Convert the state to a tuple of tensors of shape (1, <dim>)."""
-        import torch
+        import torch  # pyright: ignore[reportMissingImports]
 
         data = torch.from_numpy(self.data).unsqueeze(0).to(device, non_blocking=True)
         extras = torch.from_numpy(self.extras).unsqueeze(0).to(device, non_blocking=True)

marlenv/utils/import_placeholders.py

@@ -3,6 +3,8 @@ from types import SimpleNamespace
 
 
 def _raise_error(module_name: str, package_name: Optional[str] = None):
+    if package_name is None:
+        package_name = module_name
     raise ImportError(
         f"The optional dependency `{module_name}` is not installed.\nInstall the `{package_name}` package (e.g. pip install {package_name})."
     )

marlenv/wrappers/state_counter.py

@@ -0,0 +1,35 @@
+from typing import Sequence
+from marlenv import RLEnvWrapper, MARLEnv, Space, State
+import numpy as np
+from dataclasses import dataclass
+
+
+@dataclass
+class StateCounter[S: Space](RLEnvWrapper[S]):
+    def __init__(self, wrapped: MARLEnv[S]):
+        super().__init__(wrapped)
+        self._per_agent = [set[int]() for _ in range(self.n_agents)]
+        self._joint = set[int]()
+
+    def _register(self, state: State):
+        self._joint.add(hash(state))
+        eh = hash(state.extras.tobytes())
+        for i in range(self.n_agents):
+            agent_data = state.data[i * self.agent_state_size : (i + 1) * self.agent_state_size]
+            h = hash((agent_data.tobytes(), eh))
+            self._per_agent[i].add(h)
+
+    def step(self, action: np.ndarray | Sequence):
+        step = super().step(action)
+        self._register(step.state)
+        if step.is_terminal:
+            step.info = step.info | {
+                "joint-count": len(self._joint),
+                **{f"agent-{i}-count": len(agent_set) for i, agent_set in enumerate(self._per_agent)},
+            }
+        return step
+
+    def reset(self):
+        obs, state = super().reset()
+        self._register(state)
+        return obs, state

{multi_agent_rlenv-3.7.0.dist-info → multi_agent_rlenv-3.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: multi-agent-rlenv
-Version: 3.7.0
+Version: 3.7.2
 Summary: A strongly typed Multi-Agent Reinforcement Learning framework
 Project-URL: repository, https://github.com/yamoling/multi-agent-rlenv
 Author-email: Yannick Molinghen <yannick.molinghen@ulb.be>

{multi_agent_rlenv-3.7.0.dist-info → multi_agent_rlenv-3.7.2.dist-info}/RECORD

@@ -4,25 +4,30 @@ marlenv/env_pool.py,sha256=mJhJUROX9k2A2njwnUOBl2EAuhotksQMugH_Zydg1IU,951
 marlenv/exceptions.py,sha256=gJUC_2rVAvOfK_ypVFc7Myh-pIfSU3To38VBVS_0rZA,1179
 marlenv/mock_env.py,sha256=rvl4QAn046HM79IMMiAj1Aoy3_GBSNBBR1_9fHPutR8,4682
 marlenv/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-marlenv/adapters/__init__.py,sha256=JsKWaeXvUjWEg3JC9TOtyjtZlTI9AAkLyab-jDa5yzM,783
+marlenv/adapters/__init__.py,sha256=G-PwyGDymdAMFWtCpnlHkHQuSE40Q8bv_-yQ7gVcbbM,600
 marlenv/adapters/gym_adapter.py,sha256=DXQ1czcvRoL9hTwcVzfMyXArZeVIHP1gAKqZJO87y7Y,3065
-marlenv/adapters/pettingzoo_adapter.py,sha256=A3dcwsQa7jlWc14TybXpBknl0FPK5YK9w-6tzMBHlDI,2913
+marlenv/adapters/pettingzoo_adapter.py,sha256=UzSUdP4EUJOt49AB7H45ToA8rUkGmPQgrJKegvK86og,2877
 marlenv/adapters/pymarl_adapter.py,sha256=2s7EY31s1hrml3q-BBaXo_eDMXTjkebozZPvzsgrb9c,3353
-marlenv/adapters/smac_adapter.py,sha256=0OuhBvmsMIocwXqfLvU0NC4riEdOHFTYHQptSPzFsyU,8491
-marlenv/catalog/__init__.py,sha256=dlT_xXdjV9gdXc518xRXC4Np1TSpAMV5Wdwk4M2br8c,351
+marlenv/adapters/smac_adapter.py,sha256=OIR0_do9KavLlZ2f1YQNJwhl_yLCa6SVvCrp78hwU20,8279
+marlenv/catalog/__init__.py,sha256=l9_lvqpV2wKKMYDrStbW93WGEBDhGw6KjgbZsOcLKx0,570
+marlenv/catalog/coordinated_grid.py,sha256=Kq5UzG9rr5gYRO0QWFCmKmO56JIzgIR19an9_pvypJU,4997
 marlenv/catalog/deepsea.py,sha256=yTyvskWZiAZem11L8cZwHedBIDQ4EAxE2IaUKrjKL2U,2413
+marlenv/catalog/matrix_game.py,sha256=zkErnh6ZIa1kBryYMVLw-jeMCd2AJ-BlP2yROxpbb0w,1519
 marlenv/catalog/two_steps.py,sha256=lI-q4-Q8283QZTjY0wk7OfXWB6Ln-lquYUjHyT4URi4,2970
+marlenv/catalog/connectn/__init__.py,sha256=BKfM0ZofMK6zqGURi2bzILyNFfYjfbZpKTs5ikKiJAk,195
+marlenv/catalog/connectn/board.py,sha256=GVcFA1OJgLUmQoTIfOO9M7nL9dFv-4T3tGrVsP15zyg,6124
+marlenv/catalog/connectn/env.py,sha256=Ot5vfAbzS6eRe3-nLW_AkhEH7F1WVvv4_odoxZU7HNg,1905
 marlenv/models/__init__.py,sha256=uihmRs71Gg5z7Bvau_xtaQVg7xEtX8sTzi74bIHL5P0,443
 marlenv/models/env.py,sha256=BG1iVHxGD_p827mF0ewyOBn6wU2gtFsHLW1b4UtW-V0,7841
 marlenv/models/episode.py,sha256=zsyxsW4LIioPKyY4DZKn64A31e5ZvlwOf3HIGuRUzhs,13531
-marlenv/models/observation.py,sha256=RhvKvmys4bu3UwwVsvu7fJ7TMKt2QkKnBD1e0hw2r7s,3528
+marlenv/models/observation.py,sha256=6uY2h0zHBm6g1ECzD8jZLXuSzuuX-U60QW0E_b4qPuc,3569
 marlenv/models/spaces.py,sha256=d_aIPWwPdaOWZeNRUUdzSiDxs9XQb9itPnrE_EyhhfQ,7810
-marlenv/models/state.py,sha256=LbP--JxBzRwMFpEAaZyxCX13xKQ27xPE2fabohaq9YI,2058
+marlenv/models/state.py,sha256=JvCXwf0l7L2UMHkvYp-WM_aDegJ-hePpQI2yiUw6X_g,2099
 marlenv/models/step.py,sha256=00PhD_ccdCIYAY1SVJdJU91weU0Y_tNIJwK16TN_53I,3056
 marlenv/models/transition.py,sha256=UkJVRNxZoyRkjE7YmKtUf_4xA7cOEh20O60dTldbvys,5070
 marlenv/utils/__init__.py,sha256=ky5mz_T7EF65YNaEN1UDCUYZVlz7hFyKResgIJlE_1Q,462
 marlenv/utils/cached_property_collector.py,sha256=IOjbr61f0DqLhcidXKrl7MhN1BOEGiTzCANIKQCxaF0,600
-marlenv/utils/import_placeholders.py,sha256=QN7gsfbFgSP2Lh-7YBC1RH-SNjbFacvRFmBgNs4Eb90,972
+marlenv/utils/import_placeholders.py,sha256=nNcOGHSsBVmcUXRALJD7YBg5WzX6vTQGTfsl8LnMQgA,1036
 marlenv/utils/schedule.py,sha256=4S0V0RyYHuReVafeHnpfvSLf3oF0buAzD09qMFfexa0,9133
 marlenv/wrappers/__init__.py,sha256=Z4_M-mxRNKQeu52tkmQ4B2m3-zrsmjfXXL5NsWQ4vu4,952
 marlenv/wrappers/action_randomizer.py,sha256=A1kejqGOTA0sc_RQL0EOd6sMSbcIdiV5zlscjKUlzdY,474
@@ -37,9 +42,10 @@ marlenv/wrappers/paddings.py,sha256=DlYYnPbRPTBcpYuuUQPTlU0ZT4j26WmUIrJP-B5RF44,
 marlenv/wrappers/penalty_wrapper.py,sha256=3YBoUV6ETksZ8tFEOq1WYXvPs3ejMAehE6-QA8e4JOE,864
 marlenv/wrappers/potential_shaping.py,sha256=9-CtYe1uGcPTfbc-jx5jHPbgjZ2DpwuyNjmOyhaUvKQ,1659
 marlenv/wrappers/rlenv_wrapper.py,sha256=iFSQsDMkUUbQJKEO8l6SosNi-eOUVSh4pIJVu7aM8Qo,2991
+marlenv/wrappers/state_counter.py,sha256=QmEMb55vOnK-VJuvKsDIIBgcNRsHuovqgpK2pcCY7sA,1211
 marlenv/wrappers/time_limit.py,sha256=HctKeiepPQ2NAIa208SnvknioSkRIuUQ4X-Xhf_XTs0,3974
 marlenv/wrappers/video_recorder.py,sha256=mtWcqaYNCu-zjVXvpa8DJe3_062tpK_TChOu-Xyxs3s,2533
-multi_agent_rlenv-3.7.0.dist-info/METADATA,sha256=r_SzCu0nvthSQ7c4HPL1BR3oFSFG_ZlWRPr1j-IVprM,5751
-multi_agent_rlenv-3.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-multi_agent_rlenv-3.7.0.dist-info/licenses/LICENSE,sha256=_eeiGVoIJ7kYt6l1zbIvSBQppTnw0mjnYk1lQ4FxEjE,1074
-multi_agent_rlenv-3.7.0.dist-info/RECORD,,
+multi_agent_rlenv-3.7.2.dist-info/METADATA,sha256=loGAqI0-dvtGJEM6txWjaP00TImesivli2RI0Pd2OK0,5751
+multi_agent_rlenv-3.7.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+multi_agent_rlenv-3.7.2.dist-info/licenses/LICENSE,sha256=_eeiGVoIJ7kYt6l1zbIvSBQppTnw0mjnYk1lQ4FxEjE,1074
+multi_agent_rlenv-3.7.2.dist-info/RECORD,,