parabellum 0.2.19__py3-none-any.whl → 0.2.20__py3-none-any.whl

parabellum/__init__.py

@@ -1,4 +1,12 @@
-from .env import Parabellum, Scenario, scenarios
+from .env import Environment, Scenario, scenarios, make_scenario
 from .vis import Visualizer
+from .map import terrain_fn
 
-__all__ = ["Parabellum", "Visualizer", "Scenario", "scenarios"]
+__all__ = [
+    "Environment",
+    "Scenario",
+    "scenarios",
+    "make_scenario",
+    "Visualizer",
+    "terrain_fn",
+]

parabellum/env.py

@@ -17,11 +17,8 @@ from functools import partial
 class Scenario:
     """Parabellum scenario"""
 
+    place: str
     terrain_raster: chex.Array
-
-    obstacle_coords: chex.Array  # TODO: use map instead of obstacles
-    obstacle_deltas: chex.Array
-
     unit_types: chex.Array
     num_allies: int
     num_enemies: int
@@ -33,9 +30,8 @@ class Scenario:
 # default scenario
 scenarios = {
     "default": Scenario(
+        "Identity Town",
         jnp.eye(64, dtype=jnp.uint8),
-        jnp.array([[80, 0], [16, 12]]),
-        jnp.array([[0, 80], [0, 20]]),
         jnp.zeros((19,), dtype=jnp.uint8),
         9,
         10,
@@ -43,57 +39,63 @@ scenarios = {
 }
 
 
-class Parabellum(SMAX):
+def make_scenario(place, terrain_raster, num_allies=9, num_enemies=10):
+    """Create a scenario"""
+    num_agents = num_allies + num_enemies
+    unit_types = jnp.zeros((num_agents,)).astype(jnp.uint8)
+    return Scenario(place, terrain_raster, unit_types, num_allies, num_enemies)
+
+
+def spawn_fn(pool: jnp.ndarray, offset: jnp.ndarray, n: int, rng: jnp.ndarray):
+    """Spawns n agents on a map."""
+    rng, key_start, key_noise = random.split(rng, 3)
+    noise = random.uniform(key_noise, (n, 2)) * 0.5
+
+    # select n random (x, y)-coords where sector == True
+    idxs = random.choice(key_start, pool[0].shape[0], (n,), replace=False)
+    coords = jnp.array([pool[0][idxs], pool[1][idxs]]).T
+
+    return coords + noise + offset
+
+
+def sector_fn(terrain: jnp.ndarray, sector_id: int):
+    """return sector slice of terrain"""
+    width, height = terrain.shape
+    coordx, coordy = sector_id // 5 * width // 5, sector_id % 5 * height // 5
+    sector = terrain[coordx : coordx + width // 5, coordy : coordy + height // 5] == 0
+    offset = jnp.array([coordx, coordy])
+    # sector is jnp.nonzero
+    return jnp.nonzero(sector), offset
+
+
+class Environment(SMAX):
     def __init__(self, scenario: Scenario, **kwargs):
         map_height, map_width = scenario.terrain_raster.shape
         args = dict(scenario=scenario, map_height=map_height, map_width=map_width)
-        super(Parabellum, self).__init__(**args, **kwargs)
+        super(Environment, self).__init__(**args, walls_cause_death=False, **kwargs)
         self.terrain_raster = scenario.terrain_raster
-        self.obstacle_coords = scenario.obstacle_coords
-        self.obstacle_deltas = scenario.obstacle_deltas
-        self.unit_type_attack_blasts = jnp.zeros((19,), dtype=jnp.float32)
+        # self.unit_type_names = ["tinker", "tailor", "soldier", "spy"]
+        # self.unit_type_health = jnp.array([100, 100, 100, 100], dtype=jnp.float32)
+        # self.unit_type_damage = jnp.array([10, 10, 10, 10], dtype=jnp.float32)
+        self.scenario = scenario
+        self.unit_type_attack_blasts = jnp.zeros((3,), dtype=jnp.float32)  # TODO: add
         self.max_steps = 200
         self._push_units_away = lambda x: x  # overwrite push units
+        self.top_sector = sector_fn(self.terrain_raster, 0)
+        self.low_sector = sector_fn(self.terrain_raster, 24)
 
     @partial(jax.jit, static_argnums=(0,))
-    def reset(self, key: chex.PRNGKey) -> Tuple[Dict[str, chex.Array], State]:
+    def reset(self, rng: chex.PRNGKey) -> Tuple[Dict[str, chex.Array], State]:
         """Environment-specific reset."""
-        key, team_0_key, team_1_key = jax.random.split(key, num=3)
-        team_0_start = jnp.stack(
-            [jnp.array([self.map_width / 4, self.map_height / 2])] * self.num_allies
-        )
-        team_0_start_noise = jax.random.uniform(
-            team_0_key, shape=(self.num_allies, 2), minval=-2, maxval=2
-        )
-        team_0_start = team_0_start + team_0_start_noise
-        team_1_start = jnp.stack(
-            [jnp.array([self.map_width / 4 * 3, self.map_height / 2])]
-            * self.num_enemies
-        )
-        team_1_start_noise = jax.random.uniform(
-            team_1_key, shape=(self.num_enemies, 2), minval=-2, maxval=2
-        )
-        team_1_start = team_1_start + team_1_start_noise
+        ally_key, enemy_key = jax.random.split(rng)
+        team_0_start = spawn_fn(*self.top_sector, self.num_allies, ally_key)
+        team_1_start = spawn_fn(*self.low_sector, self.num_enemies, enemy_key)
         unit_positions = jnp.concatenate([team_0_start, team_1_start])
-        key, pos_key = jax.random.split(key)
-        generated_unit_positions = self.position_generator.generate(pos_key)
-        unit_positions = jax.lax.select(
-            self.smacv2_position_generation, generated_unit_positions, unit_positions
-        )
         unit_teams = jnp.zeros((self.num_agents,))
         unit_teams = unit_teams.at[self.num_allies :].set(1)
         unit_weapon_cooldowns = jnp.zeros((self.num_agents,))
         # default behaviour spawn all marines
-        unit_types = (
-            jnp.zeros((self.num_agents,), dtype=jnp.uint8)
-            if self.scenario is None
-            else self.scenario
-        )
-        key, unit_type_key = jax.random.split(key)
-        generated_unit_types = self.unit_type_generator.generate(unit_type_key)
-        unit_types = jax.lax.select(
-            self.smacv2_unit_type_generation, generated_unit_types, unit_types
-        )
+        unit_types = self.scenario.unit_types
         unit_health = self.unit_type_health[unit_types]
         state = State(
             unit_positions=unit_positions,
@@ -180,12 +182,12 @@ class Parabellum(SMAX):
 
             #######################################################################
             ############################################ avoid going into obstacles
-            obs = self.obstacle_coords
+            """ obs = self.obstacle_coords
             obs_end = obs + self.obstacle_deltas
-            inters = jnp.any(intersect_fn(pos, new_pos, obs, obs_end))
-            rastersects = raster_crossing(pos, new_pos)
-            flag = jnp.logical_or(inters, rastersects)
-            new_pos = jnp.where(flag, pos, new_pos)
+            inters = jnp.any(intersect_fn(pos, new_pos, obs, obs_end)) """
+            clash = raster_crossing(pos, new_pos)
+            # flag = jnp.logical_or(inters, rastersects)
+            new_pos = jnp.where(clash, pos, new_pos)
 
             #######################################################################
             #######################################################################
@@ -310,14 +312,14 @@ class Parabellum(SMAX):
                 [self.map_width, 0],
             ]
         )
-        obstacle_coords = jnp.concatenate(
+        """ obstacle_coords = jnp.concatenate(
             [self.obstacle_coords, bondaries_coords]
         )  # add the map boundaries to the obstacles to avoid
         obstacle_deltas = jnp.concatenate(
             [self.obstacle_deltas, bondaries_deltas]
         )  # add the map boundaries to the obstacles to avoid
         obst_start = obstacle_coords
-        obst_end = obst_start + obstacle_deltas
+        obst_end = obst_start + obstacle_deltas """
 
         def check_obstacles(pos, new_pos, obst_start, obst_end):
             intersects = jnp.any(intersect_fn(pos, new_pos, obst_start, obst_end))
@@ -325,9 +327,9 @@ class Parabellum(SMAX):
             flag = jnp.logical_or(intersects, rastersect)
             return jnp.where(flag, pos, new_pos)
 
-        pos = jax.vmap(check_obstacles, in_axes=(0, 0, None, None))(
+        """ pos = jax.vmap(check_obstacles, in_axes=(0, 0, None, None))(
             pos, new_pos, obst_start, obst_end
-        )
+        ) """
 
         # Multiple enemies can attack the same unit.
         # We have `(health_diff, attacked_idx)` pairs.
@@ -373,13 +375,16 @@ class Parabellum(SMAX):
 
 if __name__ == "__main__":
     n_envs = 4
-    kwargs = dict(map_width=64, map_height=64)
-    env = Parabellum(scenarios["default"], **kwargs)
+
+    env = Environment(scenarios["default"])
     rng, reset_rng = random.split(random.PRNGKey(0))
     reset_key = random.split(reset_rng, n_envs)
     obs, state = vmap(env.reset)(reset_key)
     state_seq = []
 
+    print(state.unit_positions)
+    exit()
+
     for i in range(10):
         rng, act_rng, step_rng = random.split(rng, 3)
         act_key = random.split(act_rng, (len(env.agents), n_envs))

parabellum/map.py

@@ -4,13 +4,46 @@
 
 # imports
 import jax.numpy as jnp
-import jax
+from geopy.geocoders import Nominatim
+import geopandas as gpd
+import osmnx as ox
+import rasterio
+from jax import random
+from rasterio import features
+import rasterio.transform
+
+# constants
+geolocator = Nominatim(user_agent="parabellum")
+tags = {"building": True}
 
 
 # functions
-def map_fn(width, height, obst_coord, obst_delta):
-    """Create a map from the given width, height, and obstacle coordinates and deltas."""
-    m = jnp.zeros((width, height))
-    for (x, y), (dx, dy) in zip(obst_coord, obst_delta):
-        m = m.at[x : x + dx, y : y + dy].set(1)
-    return m
+def terrain_fn(place: str, size: int = 1000):
+    """Returns a rasterized map of a given location."""
+
+    # location info
+    location = geolocator.geocode(place)
+    coords = (location.latitude, location.longitude)
+
+    # shape info
+    geometry = ox.features_from_point(coords, tags=tags, dist=size // 2)
+    gdf = gpd.GeoDataFrame(geometry).set_crs("EPSG:4326")
+
+    # raster info
+    t = rasterio.transform.from_bounds(*gdf.total_bounds, size, size)
+    raster = features.rasterize(gdf.geometry, out_shape=(size, size), transform=t)
+
+    # rotate 180 degrees
+    raster = jnp.rot90(raster, 2)
+
+    return jnp.array(raster).astype(jnp.uint8)
+
+
+if __name__ == "__main__":
+    import seaborn as sns
+
+    place = "Vesterbro, Copenhagen, Denmark"
+    terrain = terrain_fn(place)
+    rng, key = random.split(random.PRNGKey(0))
+    agents = spawn_fn(terrain, 12, 100, key)
+    print(agents)

parabellum/run.py

@@ -39,7 +39,7 @@ class Game:
     obs: Dict
     state_seq: StateSeq
     control: Control
-    env: pb.Parabellum
+    env: pb.Environment
     rng: random.PRNGKey
 
 
@@ -123,5 +123,3 @@ if __name__ == "__main__":
         game = game if game.control.paused else render(game)
 
     pygame.quit()
-
-

parabellum/vis.py

@@ -11,6 +11,7 @@ from functools import partial
 import darkdetect
 import numpy as np
 import pygame
+import matplotlib.pyplot as plt
 import os
 from moviepy.editor import ImageSequenceClip
 from typing import Optional
@@ -33,15 +34,24 @@ def small_multiples():
     print(len(clips))
 
 
+def text_fn(text):
+    """rotate text upside down because of pygame issue"""
+    return pygame.transform.rotate(text, 180)
+
+
 class Visualizer(SMAXVisualizer):
-    def __init__(self, env: MultiAgentEnv, state_seq, reward_seq=None):
-        super().__init__(env, state_seq, reward_seq)
-        # remove fig and ax from super
+    def __init__(self, env: MultiAgentEnv, state_seq, reward_seq=None, skin=None):
         self.fig, self.ax = None, None
+        super().__init__(env, state_seq, reward_seq)
+        # clear the figure made by SMAXVisualizer
+        plt.close()
         self.bg = (0, 0, 0) if darkdetect.isDark() else (255, 255, 255)
         self.fg = (255, 255, 255) if darkdetect.isDark() else (0, 0, 0)
-        self.s = 1000
-        self.scale = self.s / self.env.map_width
+        self.pad = 75
+        # TODO: make sure it's always a 1024x1024 image
+        self.width = 1000
+        self.s = self.width + self.pad + self.pad
+        self.scale = self.width / env.map_width
         self.action_seq = [action for _, _, action in state_seq]  # bcs SMAX bug
         # self.bullet_seq = vmap(partial(bullet_fn, self.env))(self.state_seq)
 
@@ -65,13 +75,13 @@ class Visualizer(SMAXVisualizer):
     def animate_one(self, state_seq, action_seq, save_fname):
         frames = []  # frames for the video
         pygame.init()  # initialize pygame
-        terrain = np.array(self.env.terrain_raster)
+        terrain = np.array(self.env.terrain_raster.T)
         rgb_array = np.zeros((terrain.shape[0], terrain.shape[1], 3), dtype=np.uint8)
         if darkdetect.isLight():
             rgb_array += 255
         rgb_array[terrain == 1] = self.fg
         mask_surface = pygame.surfarray.make_surface(rgb_array)
-        mask_surface = pygame.transform.scale(mask_surface, (self.s, self.s))
+        mask_surface = pygame.transform.scale(mask_surface, (self.width, self.width))
 
         for idx, (_, state, _) in tqdm(enumerate(state_seq), total=len(self.state_seq)):
             action = action_seq[idx // self.env.world_steps_per_env_step]
@@ -79,11 +89,33 @@ class Visualizer(SMAXVisualizer):
                 (self.s, self.s), pygame.HWSURFACE | pygame.DOUBLEBUF
             )
             screen.fill(self.bg)  # fill the screen with the background color
-            screen.blit(mask_surface, (0, 0))
+            screen.blit(
+                mask_surface,
+                (self.pad, self.pad, self.width, self.width),
+            )
+            # add env.scenario.place to the title (in top padding)
+            font = pygame.font.SysFont("Fira Code", 18)
+            width = self.env.map_width
+            title = f"{width}x{width}m in {self.env.scenario.place}"
+            text = text_fn(font.render(title, True, self.fg))
+            # center the text
+            screen.blit(text, (self.s // 2 - text.get_width() // 2, self.pad // 4))
+            # draw edge around terrain
+            pygame.draw.rect(
+                screen,
+                self.fg,
+                (
+                    self.pad - 2,
+                    self.pad - 2,
+                    self.width + 4,
+                    self.width + 4,
+                ),
+                2,
+            )
 
             self.render_agents(screen, state)  # render the agents
             self.render_action(screen, action)
-            self.render_obstacles(screen)  # render the obstacles
+            # self.render_obstacles(screen)  # render the obstacles
 
             # bullets
             """ if idx < len(self.bullet_seq) * 8:
@@ -91,15 +123,16 @@ class Visualizer(SMAXVisualizer):
                 self.render_bullets(screen, bullets, idx % 8) """
 
             # rotate the screen and append to frames
-            frames.append(pygame.surfarray.pixels3d(screen).swapaxes(0, 1))
+            pixels = pygame.surfarray.pixels3d(screen).swapaxes(0, 1)
+            # rotate the screen 180 degrees (transpose and flip)
+            pixels = np.rot90(pixels, 2)  # pygame starts in bottom left
+            frames.append(pixels)
         # save the images
         clip = ImageSequenceClip(frames, fps=48)
         clip.write_videofile(save_fname, fps=48)
         clip.write_gif(save_fname.replace(".mp4", ".gif"), fps=24)
         pygame.quit()
 
-        return clip
-
     def render_agents(self, screen, state):
         time_tuple = zip(
             state.unit_positions,
@@ -109,7 +142,7 @@ class Visualizer(SMAXVisualizer):
         )
         for idx, (pos, team, kind, hp) in enumerate(time_tuple):
             face_col = self.fg if int(team.item()) == 0 else self.bg
-            pos = tuple((pos * self.scale).tolist())
+            pos = tuple(((pos * self.scale) + self.pad).tolist())
             # draw the agent
             if hp > 0:
                 hp_frac = hp / self.env.unit_type_health[kind]
@@ -131,26 +164,28 @@ class Visualizer(SMAXVisualizer):
         if self.env.action_type != "discrete":
             return
 
-        def coord_fn(idx, n, team):
+        def coord_fn(idx, n, team, text):
+            text_adj = text.get_width() / 2
+            is_ally = team == "ally"
             return (
-                self.s / 20 if team == 0 else self.s - self.s / 20,
                 # vertically centered so that n / 2 is above and below the center
+                self.pad + self.width + self.pad / 2 - text_adj
+                if is_ally
+                else self.pad / 2 - text_adj,
                 self.s / 2 - (n / 2) * self.s / 20 + idx * self.s / 20,
             )
 
-        for idx in range(self.env.num_allies):
-            symb = action_to_symbol.get(action[f"ally_{idx}"].astype(int).item(), "Ø")
-            font = pygame.font.SysFont("Fira Code", jnp.sqrt(self.s).astype(int).item())
-            text = font.render(symb, True, self.fg)
-            coord = coord_fn(idx, self.env.num_allies, 0)
-            screen.blit(text, coord)
-
-        for idx in range(self.env.num_enemies):
-            symb = action_to_symbol.get(action[f"enemy_{idx}"].astype(int).item(), "Ø")
-            font = pygame.font.SysFont("Fira Code", jnp.sqrt(self.s).astype(int).item())
-            text = font.render(symb, True, self.fg)
-            coord = coord_fn(idx, self.env.num_enemies, 1)
-            screen.blit(text, coord)
+        for team, number in [("ally", 0), ("enemy", 1)]:
+            for idx in range(self.env.num_allies):
+                symb = action_to_symbol.get(
+                    action[f"{team}_{idx}"].astype(int).item(), "Ø"
+                )
+                font = pygame.font.SysFont(
+                    "Fira Code", jnp.sqrt(self.s).astype(int).item()
+                )
+                text = text_fn(font.render(symb, True, self.fg))
+                coord = coord_fn(idx, self.env.num_allies, team, text)
+                screen.blit(text, coord)
 
     def render_obstacles(self, screen):
         for c, d in zip(self.env.obstacle_coords, self.env.obstacle_deltas):

parabellum-0.2.20.dist-info/METADATA

@@ -0,0 +1,90 @@
+Metadata-Version: 2.1
+Name: parabellum
+Version: 0.2.20
+Summary: Parabellum environment for parallel warfare simulation
+Home-page: https://github.com/syrkis/parabellum
+License: MIT
+Keywords: warfare,simulation,parallel,environment
+Author: Noah Syrkis
+Author-email: desk@syrkis.com
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: darkdetect (>=0.8.0,<0.9.0)
+Requires-Dist: geopandas (>=1.0.0,<2.0.0)
+Requires-Dist: geopy (>=2.4.1,<3.0.0)
+Requires-Dist: jax (==0.4.17)
+Requires-Dist: jaxmarl (==0.0.3)
+Requires-Dist: jupyterlab (>=4.2.2,<5.0.0)
+Requires-Dist: moviepy (>=1.0.3,<2.0.0)
+Requires-Dist: numpy (<2)
+Requires-Dist: osmnx (>=1.9.3,<2.0.0)
+Requires-Dist: poetry (>=1.8.3,<2.0.0)
+Requires-Dist: pygame (>=2.5.2,<3.0.0)
+Requires-Dist: rasterio (>=1.3.10,<2.0.0)
+Requires-Dist: seaborn (>=0.13.2,<0.14.0)
+Requires-Dist: tqdm (>=4.66.4,<5.0.0)
+Project-URL: Repository, https://github.com/syrkis/parabellum
+Description-Content-Type: text/markdown
+
+# Parabellum
+
+Ultra-scalable JaxMARL based warfare simulation engine developed with Armasuisse funding.
+
+[![Documentation Status](https://readthedocs.org/projects/parabellum/badge/?version=latest)](https://parabellum.readthedocs.io/en/latest/?badge=latest)
+
+## Features
+
+- Obstacles and terrain integration
+- Rasterized maps
+- Blast radii simulation
+- Friendly fire mechanics
+- Pygame visualization
+- JAX-based parallelization
+
+## Install
+
+```bash
+pip install parabellum
+```
+
+## Quick Start
+
+```python
+import parabellum as pb
+from jax import random
+
+terrain = pb.terrain_fn("Thun, Switzerland", 1000)
+scenario = pb.make_scenario("Thun", terrain, 10, 10)
+env = pb.Parabellum(scenario)
+
+rng, key = random.split(random.PRNGKey(0))
+obs, state = env.reset(key)
+
+# Simulation loop
+for _ in range(100):
+    rng, rng_act, key_step = random.split(key)
+    key_act = random.split(rng_act, len(env.agents))
+    act = {a: env.action_space(a).sample(k) for a, k in zip(env.agents, key_act)}
+    obs, state, reward, done, info = env.step(key_step, act, state)
+
+# Visualize
+vis = pb.Visualizer(env, state_sequence)
+vis.animate()
+```
+
+## Documentation
+
+Full documentation: [parabellum.readthedocs.io](https://parabellum.readthedocs.io)
+
+## Team
+
+- Noah Syrkis
+- Timothée Anne
+- Supervisor: Sebastian Risi
+
+## License
+
+MIT

parabellum-0.2.20.dist-info/RECORD

@@ -0,0 +1,8 @@
+parabellum/__init__.py,sha256=cI1kxVQ274VZrBLxUYvB_j6UqhFY44sId4NgVjbf678,245
+parabellum/env.py,sha256=B2WaEzCQnakVB1AuYqFsb7aiPIbaUsuq0CjdKq4pQm8,16204
+parabellum/map.py,sha256=CdPebRuGafj9fAydAyTa8bqpr-PldZw7heKRReGTDBg,1257
+parabellum/run.py,sha256=HyPdz5iVD8q0iYaZL2Nf02fGHByHpecUGoPlQrq9v8s,3411
+parabellum/vis.py,sha256=uIhN9VSJlT4XoNuNCiU_Bw2VSNoJFOYlScCTNrMkGsg,11977
+parabellum-0.2.20.dist-info/METADATA,sha256=IO3Wsx_nTM3v63FtbnJqaEfPfXOyhNGtKOm_ppchUqo,2453
+parabellum-0.2.20.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+parabellum-0.2.20.dist-info/RECORD,,

parabellum-0.2.19.dist-info/METADATA

@@ -1,104 +0,0 @@
-Metadata-Version: 2.1
-Name: parabellum
-Version: 0.2.19
-Summary: Parabellum environment for parallel warfare simulation
-Home-page: https://github.com/syrkis/parabellum
-License: MIT
-Keywords: warfare,simulation,parallel,environment
-Author: Noah Syrkis
-Author-email: desk@syrkis.com
-Requires-Python: >=3.11,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: darkdetect (>=0.8.0,<0.9.0)
-Requires-Dist: jax (==0.4.17)
-Requires-Dist: jaxmarl (==0.0.3)
-Requires-Dist: jupyterlab (>=4.2.2,<5.0.0)
-Requires-Dist: moviepy (>=1.0.3,<2.0.0)
-Requires-Dist: poetry (>=1.8.3,<2.0.0)
-Requires-Dist: pygame (>=2.5.2,<3.0.0)
-Requires-Dist: tqdm (>=4.66.4,<5.0.0)
-Project-URL: Repository, https://github.com/syrkis/parabellum
-Description-Content-Type: text/markdown
-
-# parabellum
-
-Parabellum is an ultra-scalable, high-performance warfare simulation engine.
-It is based on JaxMARL's SMAX environment, but has been heavily modified to
-support a wide range of new features and improvements.
-
-## Installation
-
-Parabellum is written in Python 3.11 and can be installed using pip:
-
-```bash
-pip install parabellum
-```
-
-## Usage
-
-Parabellum is designed to be used in conjunction with JAX, a high-performance
-numerical computing library. Here is a simple example of how to use Parabellum
-to simulate a game with 10 agents and 10 enemies, each taking random actions:
-
-```python
-import parabellum as pb
-from jax import random
-
-# define the scenario
-kwargs = dict(obstacle_coords=[(7, 7)], obstacle_deltas=[(10, 0)])
-scenario = pb.Scenario(**kwargs)  # <- Scenario is an important part of parabellum
-
-# create the environment
-kwargs = dict(map_width=256, map_height=256, num_agents=10, num_enemies=10)
-env = pb.Parabellum(**kwargs)  # <- Parabellum is the central class of parabellum
-
-# initiate stochasticity
-rng = random.PRNGKey(0)
-rng, key = random.split(rng)
-
-# initialize the environment state
-obs, state = env.reset(key)
-state_sequence = []
-
-for _ in range(1000):
-
-    # manage stochasticity
-    rng, rng_act, key_step = random.split(key)
-    key_act = random.split(rng_act, len(env.agents))
-
-    # sample actions and append to state sequence
-    act = {a: env.action_space(a).sample(k)
-        for a, k in zip(env.agents, key_act)}
-
-    # step the environment
-    state_sequence.append((key_act, state, act))
-    obs, state, reward, done, info = env.step(key_step, act, state)
-
-
-# save visualization of the state sequence
-vis = pb.Visualizer(env, state_sequence)  # <- Visualizer is a nice to have class
-vis.animate()
-```
-
-
-## Features
-
-- Obstacles — can be inserted in
-
-## TODO
-
-- [x] Parallel pygame vis
-    - [ ] Parallel bullet renderings
-    - [ ] Combine parallell plots into one (maybe out of parabellum scope)
-- [ ] Color for health?
-- [ ] Add the ability to see ongoing game.
-- [ ] Bug test friendly fire.
-- [x] Start sim from arbitrary state.
-- [ ] Save when the episode ends in some state/obs variable
-- [ ] Look for the source of the bug when using more Allies than Enemies
-- [ ] Y inversed axis for parabellum visualization
-- [ ] Units see through obstacles? 
-

parabellum-0.2.19.dist-info/RECORD

@@ -1,8 +0,0 @@
-parabellum/__init__.py,sha256=TjZVlHZdi7CEm0gjagm3j6epPZxjR6C9G3CYtX7d-2o,142
-parabellum/env.py,sha256=Z8zpdCaEi5HFwN0Vd2hukOarkPSg0EKZErTRts3JQ5E,16023
-parabellum/map.py,sha256=SQeNl1kkGsnnqYoo-60zJNv36fD-8VSKasiS1_WARao,410
-parabellum/run.py,sha256=0IWpqcQ_qfFeElbupF5vOs_CByFfpXYuGGUHYuurFM4,3412
-parabellum/vis.py,sha256=JFVTnBg-LV4jZNw6cysU6NS8ZxeMpg5wz3JOi-lrnzY,10699
-parabellum-0.2.19.dist-info/METADATA,sha256=DsEBAlESj8BwGSphmPPylStoXH_g_x_Iy3WJ3KEwjc0,3223
-parabellum-0.2.19.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-parabellum-0.2.19.dist-info/RECORD,,