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

parabellum/__init__.py

@@ -1,4 +1,18 @@
-from .env import Parabellum, Scenario, scenarios
-from .vis import Visualizer
+from .env import Environment, Scenario, scenarios, make_scenario, State
+from .vis import Visualizer, Skin
+from .map import terrain_fn
+from .gun import bullet_fn
+# from .aid import aid
+# from .run import run
 
-__all__ = ["Parabellum", "Visualizer", "Scenario", "scenarios"]
+__all__ = [
+    "Environment",
+    "Scenario",
+    "scenarios",
+    "make_scenario",
+    "State",
+    "Visualizer",
+    "Skin",
+    "terrain_fn",
+    "bullet_fn",
+]

parabellum/aid.py

@@ -0,0 +1,5 @@
+# aid.py
+#   what you call utils.py when you want file names to be 3 letters
+# by: Noah Syrkis
+
+# imports

parabellum/env.py

@@ -3,13 +3,13 @@
 import jax.numpy as jnp
 import jax
 import numpy as np
-from jax import random
+from jax import random, Array
 from jax import jit
 from flax.struct import dataclass
 import chex
 from jax import vmap
-from jaxmarl.environments.smax.smax_env import State, SMAX
-from typing import Tuple, Dict
+from jaxmarl.environments.smax.smax_env import SMAX
+from typing import Tuple, Dict, cast
 from functools import partial
 
 
@@ -17,11 +17,8 @@ from functools import partial
 class Scenario:
     """Parabellum scenario"""
 
-    terrain_raster: chex.Array
-
-    obstacle_coords: chex.Array  # TODO: use map instead of obstacles
-    obstacle_deltas: chex.Array
-
+    place: str
+    terrain_raster: jnp.ndarray
     unit_types: chex.Array
     num_allies: int
     num_enemies: int
@@ -29,13 +26,25 @@ class Scenario:
     smacv2_position_generation: bool = False
     smacv2_unit_type_generation: bool = False
 
+@dataclass
+class State:
+    unit_positions: Array
+    unit_alive: Array
+    unit_teams: Array
+    unit_health: Array
+    unit_types: Array
+    unit_weapon_cooldowns: Array
+    prev_movement_actions: Array
+    prev_attack_actions: Array
+    time: int
+    terminal: bool
+
 
 # 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 +52,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, 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._push_units_away = lambda state, firmness = 1: state  # overwrite push units
+        self.top_sector, self.top_sector_offset = sector_fn(self.terrain_raster, 0)
+        self.low_sector, self.low_sector_offset = 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.top_sector_offset, self.num_allies, ally_key)
+        team_1_start = spawn_fn(self.low_sector, self.low_sector_offset, 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 = cast(Array, self.scenario.unit_types)
         unit_health = self.unit_type_health[unit_types]
         state = State(
             unit_positions=unit_positions,
@@ -107,7 +122,7 @@ class Parabellum(SMAX):
             terminal=False,
             unit_weapon_cooldowns=unit_weapon_cooldowns,
         )
-        state = self._push_units_away(state)
+        state = self._push_units_away(state)  # type: ignore
         obs = self.get_obs(state)
         world_state = self.get_world_state(state)
         obs["world_state"] = jax.lax.stop_gradient(world_state)
@@ -139,7 +154,7 @@ class Parabellum(SMAX):
         key: chex.PRNGKey,
         state: State,
         actions: Tuple[chex.Array, chex.Array],
-    ) -> Tuple[Dict[str, chex.Array], State, Dict[str, float], Dict[str, bool], Dict]:
+    ) -> State:
         @partial(jax.vmap, in_axes=(None, None, 0, 0))
         def intersect_fn(pos, new_pos, obs, obs_end):
             d1 = jnp.cross(obs - pos, new_pos - pos)
@@ -165,7 +180,7 @@ class Parabellum(SMAX):
             # because these are easier to encode as actions than the four
             # diagonal directions. Then rotate the velocity 45
             # degrees anticlockwise to compute the movement.
-            pos = state.unit_positions[idx]
+            pos = cast(Array, state.unit_positions[idx])
             new_pos = (
                 pos
                 + vec
@@ -180,12 +195,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)
 
             #######################################################################
             #######################################################################
@@ -217,6 +232,7 @@ class Parabellum(SMAX):
                 lambda: action + self.num_allies - self.num_movement_actions,
                 lambda: self.num_allies - 1 - (action - self.num_movement_actions),
             )
+            attacked_idx = cast(int, attacked_idx)  # Cast to int
             # deal with no-op attack actions (i.e. agents that are moving instead)
             attacked_idx = jax.lax.select(
                 action < self.num_movement_actions, idx, attacked_idx
@@ -248,7 +264,7 @@ class Parabellum(SMAX):
             bystander_idxs = bystander_fn(attacked_idx)  # TODO: use
             bystander_valid = (
                 jnp.where(attack_valid, bystander_idxs, jnp.zeros((self.num_agents,)))
-                .astype(jnp.bool_)
+                .astype(jnp.bool_) # type: ignore
                 .astype(jnp.float32)
             )
             bystander_health_diff = (
@@ -310,14 +326,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 +341,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.
@@ -363,7 +379,8 @@ class Parabellum(SMAX):
         #########################################################
 
         unit_weapon_cooldowns = state.unit_weapon_cooldowns + cooldown_diff
-        state = state.replace(
+        # replace unit health, unit positions and unit weapon cooldowns
+        state = state.replace(  # type: ignore
             unit_health=unit_health,
             unit_positions=pos,
             unit_weapon_cooldowns=unit_weapon_cooldowns,
@@ -373,13 +390,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/gun.py

@@ -0,0 +1,70 @@
+# gun.py
+#   parabellum bullet rendering assosciated functions
+# by: Noah Syrkis
+
+# imports
+from functools import partial
+import jax.numpy as jnp
+
+
+def dist_fn(env, pos):  # computing the distances between all ally and enemy agents
+    delta = pos[None, :, :] - pos[:, None, :]
+    dist = jnp.sqrt((delta**2).sum(axis=2))
+    dist = dist[: env.num_allies, env.num_allies :]
+    return {"ally": dist, "enemy": dist.T}
+
+
+def range_fn(env, dists, ranges):  # computing what targets are in range
+    ally_range = dists["ally"] < ranges[: env.num_allies][:, None]
+    enemy_range = dists["enemy"] < ranges[env.num_allies :][:, None]
+    return {"ally": ally_range, "enemy": enemy_range}
+
+
+def target_fn(acts, in_range, team):  # computing the one hot valid targets
+    t_acts = jnp.stack([v for k, v in acts.items() if k.startswith(team)]).T
+    t_targets = jnp.where(t_acts > 4, -1, t_acts - 5)  # first 5 are move actions
+    t_attacks = jnp.eye(in_range[team].shape[1] + 1)[t_targets][:, :-1]
+    return t_attacks * in_range[team]  # one hot valid targets
+
+
+def attack_fn(env, state_seq):  # one hot attack list
+    attacks = []
+    for _, state, acts in state_seq:
+        dists = dist_fn(env, state.unit_positions)
+        ranges = env.unit_type_attack_ranges[state.unit_types]
+        in_range = range_fn(env, dists, ranges)
+        target = partial(target_fn, acts, in_range)
+        attack = {"ally": target("ally"), "enemy": target("enemy")}
+        attacks.append(attack)
+    return attacks
+
+
+def bullet_fn(env, states):
+    bullet_seq = []
+    attack_seq = attack_fn(env, states)
+
+    def aux_fn(team):
+        bullets = jnp.stack(jnp.where(one_hot[team] == 1)).T
+        # bullets = bullets.at[:, 2 if team == "ally" else 1].add(env.num_allies)
+        return bullets
+
+    state_zip = zip(states[:-1], states[1:])
+    for i, ((_, state, _), (_, n_state, _)) in enumerate(state_zip):
+        one_hot = attack_seq[i]
+        ally_bullets, enemy_bullets = aux_fn("ally"), aux_fn("enemy")
+
+        ally_bullets_source = state.unit_positions[ally_bullets[:, 0]]
+        enemy_bullets_target = n_state.unit_positions[enemy_bullets[:, 1]]
+
+        enemy_bullets_source = state.unit_positions[
+            enemy_bullets[:, 0] + env.num_allies
+        ]
+        ally_bullets_target = n_state.unit_positions[
+            ally_bullets[:, 1] + env.num_allies
+        ]
+
+        ally_bullets = jnp.stack((ally_bullets_source, ally_bullets_target), axis=1)
+        enemy_bullets = jnp.stack((enemy_bullets_source, enemy_bullets_target), axis=1)
+
+        bullet_seq.append((ally_bullets, enemy_bullets))
+    return bullet_seq

parabellum/map.py

@@ -1,16 +1,68 @@
 # map.py
-#   parabellum map functions
+    # parabellum map functions
 # by: Noah Syrkis
 
 # imports
 import jax.numpy as jnp
-import jax
+from geopy.geocoders import Nominatim
+import geopandas as gpd
+import osmnx as ox
+import contextily as cx
+import matplotlib.pyplot as plt
+from rasterio import features
+import rasterio.transform
+from typing import Optional, Tuple
+from geopy.location import Location
+from shapely.geometry import Point
 
+# constants
+geolocator = Nominatim(user_agent="parabellum")
+BUILDING_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 get_location(place: str) -> Tuple[float, float]:
+    """Get coordinates for a given place."""
+    coords: Optional[Location] = geolocator.geocode(place)  # type: ignore
+    if coords is None:
+        raise ValueError(f"Could not geocode the place: {place}")
+    return (coords.latitude, coords.longitude)
+
+def get_building_geometry(point: Tuple[float, float], size: int) -> gpd.GeoDataFrame:
+    """Get building geometry for a given point and size."""
+    geometry = ox.features_from_point(point, tags=BUILDING_TAGS, dist=size // 2)
+    return gpd.GeoDataFrame(geometry).set_crs("EPSG:4326")
+
+def rasterize_geometry(gdf: gpd.GeoDataFrame, size: int) -> jnp.ndarray:
+    """Rasterize geometry and return as a JAX array."""
+    w, s, e, n = gdf.total_bounds
+    transform = rasterio.transform.from_bounds(w, s, e, n, size, size)
+    raster = features.rasterize(gdf.geometry, out_shape=(size, size), transform=transform)
+    return jnp.array(jnp.rot90(raster, 2)).astype(jnp.uint8)
+
+def terrain_fn(place: str, size: int = 1000) -> Tuple[jnp.ndarray, jnp.ndarray]:
+    """Returns a rasterized map of buildings for a given location."""
+    point = get_location(place)
+    gdf = get_building_geometry(point, size)
+    mask = rasterize_geometry(gdf, size)
+    base = get_basemap(place, size)
+    return mask, base
+
+def get_basemap(place: str, size: int = 1000) -> jnp.ndarray:
+    """Returns a basemap for a given place as a JAX array."""
+    point = get_location(place)
+    gdf = get_building_geometry(point, size)
+    basemap, _ = cx.bounds2img(*gdf.total_bounds, ll=True)
+    # get the middle size x size square
+    basemap = basemap[(basemap.shape[0] - size) // 2:(basemap.shape[0] + size) // 2,
+                        (basemap.shape[1] - size) // 2:(basemap.shape[1] + size) // 2]
+    return jnp.array(jnp.rot90(basemap, 2)).astype(jnp.uint8)
+
+
+if __name__ == "__main__":
+    import seaborn as sns
+    place = "Thun, Switzerland"
+    mask, base = terrain_fn(place)
+
+    fig, ax = plt.subplots(1, 2, figsize=(10, 5))
+    ax[0].imshow(mask) # type: ignore
+    ax[1].imshow(base) # type: ignore
+    plt.show()

parabellum/run.py

@@ -10,6 +10,7 @@ import darkdetect
 import jax.numpy as jnp
 from chex import dataclass
 import jaxmarl
+from jax import Array
 from typing import Tuple, List, Dict, Optional
 import parabellum as pb
 
@@ -20,7 +21,7 @@ bg = (0, 0, 0) if darkdetect.isDark() else (255, 255, 255)
 
 
 # types
-State = jaxmarl.environments.smax.smax_env.State
+State = jaxmarl.environments.smax.smax_env.State # type: ignore
 Obs = Reward = Done = Action = Dict[str, jnp.ndarray]
 StateSeq = List[Tuple[jnp.ndarray, State, Action]]
 
@@ -35,12 +36,12 @@ class Control:
 @dataclass
 class Game:
     clock: pygame.time.Clock
-    state: State
+    state: State  # type: ignore
     obs: Dict
     state_seq: StateSeq
     control: Control
-    env: pb.Parabellum
-    rng: random.PRNGKey
+    env: pb.Environment
+    rng: Array
 
 
 def handle_event(event, control_state):
@@ -100,7 +101,7 @@ def step_fn(game):
 
 # state
 if __name__ == "__main__":
-    env = pb.Parabellum(pb.scenarios["default"])
+    env = pb.Environment(pb.scenarios["default"])
     pygame.init()
     screen = pygame.display.set_mode((1000, 1000))
     render = partial(render_fn, screen)
@@ -115,7 +116,7 @@ if __name__ == "__main__":
         state=state,
         obs=obs,
     )
-    game = Game(**kwargs)
+    game = Game(**kwargs)  # type: ignore
 
     while game.control.running:
         game = control_fn(game)
@@ -123,5 +124,3 @@ if __name__ == "__main__":
         game = game if game.control.paused else render(game)
 
     pygame.quit()
-
-

parabellum/vis.py

@@ -2,265 +2,168 @@
 Visualizer for the Parabellum environment
 """
 
-from tqdm import tqdm
-import jax.numpy as jnp
-import jax
-from jax import vmap
-from jax import tree_util
+# Standard library imports
 from functools import partial
-import darkdetect
-import numpy as np
-import pygame
-import os
-from moviepy.editor import ImageSequenceClip
-from typing import Optional
+from typing import Optional, List, Tuple
+import cv2
+from PIL import Image
+
+# JAX and JAX-related imports
+import jax
+from chex import dataclass
+import chex
+from jax import vmap, tree_util, Array, jit
+import jax.numpy as jnp
 from jaxmarl.environments.multi_agent_env import MultiAgentEnv
+from jaxmarl.environments.smax import SMAX
 from jaxmarl.viz.visualizer import SMAXVisualizer
 
-# default dict
-from collections import defaultdict
-
+# Third-party imports
+import numpy as np
+import pygame
+import cv2
+from tqdm import tqdm
 
-# constants
-action_to_symbol = {0: "↑", 1: "→", 2: "↓", 3: "←", 4: "Ø"}
+# Local imports
+import parabellum as pb
 
 
-def small_multiples():
-    # make video of small multiples based on all videos in output
-    video_files = [f"output/parabellum_{i}.mp4" for i in range(4)]
-    # load mp4 videos and make a grid
-    clips = [ImageSequenceClip.load(filename) for filename in video_files]
-    print(len(clips))
+# skin dataclass
+@dataclass
+class Skin:
+    # basemap: Array  # basemap of buildings
+    maskmap: Array  # maskmap of buildings
+    bg: Tuple[int, int, int] = (255, 255, 255)
+    fg: Tuple[int, int, int] = (0, 0, 0)
+    ally: Tuple[int, int, int]  = (0, 255, 0)
+    enemy: Tuple[int, int, int]  = (255, 0, 0)
+    pad: int  = 100
+    size: int  = 1000  # excluding padding
+    fps: int = 24
+    vis_size: int = 1000   # size of the map in Vis (exluding padding)
+    scale: Optional[float] = None
 
 
 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
-        self.fig, self.ax = None, None
-        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.action_seq = [action for _, _, action in state_seq]  # bcs SMAX bug
+    def __init__(self, env: pb.Environment, state_seq, skin: Skin, reward_seq=None):
+        super(Visualizer, self).__init__(env, state_seq, reward_seq)
+
         # self.bullet_seq = vmap(partial(bullet_fn, self.env))(self.state_seq)
+        self.action_seq = [action for _, _, action in state_seq]  # bcs SMAX bug
+        self.state_seq = state_seq
+        self.image = image_fn(skin)
+        self.skin = skin
+        self.skin.scale = self.skin.size / env.map_width  # assumes square map
+        self.env = env
+
 
-    def animate(self, save_fname: str = "output/parabellum.mp4"):
-        multi_dim = self.state_seq[0][1].unit_positions.ndim > 2
-        if multi_dim:
-            n_envs = self.state_seq[0][1].unit_positions.shape[0]
-            if not self.have_expanded:
-                state_seqs = vmap(self.env.expand_state_seq)(self.state_seq)
-                self.have_expanded = True
-            for i in range(n_envs):
-                state_seq = jax.tree_map(lambda x: x[i], state_seqs)
-                action_seq = jax.tree_map(lambda x: x[i], self.action_seq)
-                self.animate_one(
-                    state_seq, action_seq, save_fname.replace(".mp4", f"_{i}.mp4")
-                )
-        else:
-            state_seq = self.env.expand_state_seq(self.state_seq)
-            self.animate_one(state_seq, self.action_seq, save_fname)
-
-    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)
-        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))
-
-        for idx, (_, state, _) in tqdm(enumerate(state_seq), total=len(self.state_seq)):
-            action = action_seq[idx // self.env.world_steps_per_env_step]
-            screen = pygame.Surface(
-                (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))
-
-            self.render_agents(screen, state)  # render the agents
-            self.render_action(screen, action)
-            self.render_obstacles(screen)  # render the obstacles
-
-            # bullets
-            """ if idx < len(self.bullet_seq) * 8:
-                bullets = self.bullet_seq[idx // 8]
-                self.render_bullets(screen, bullets, idx % 8) """
-
-            # rotate the screen and append to frames
-            frames.append(pygame.surfarray.pixels3d(screen).swapaxes(0, 1))
-        # 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,
-            state.unit_teams,
-            state.unit_types,
-            state.unit_health,
-        )
-        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())
-            # draw the agent
-            if hp > 0:
-                hp_frac = hp / self.env.unit_type_health[kind]
-                unit_size = self.env.unit_type_radiuses[kind]
-                radius = jnp.ceil((unit_size * self.scale * hp_frac)).astype(int) + 1
-                pygame.draw.circle(screen, face_col, pos, radius)
-                pygame.draw.circle(screen, self.fg, pos, radius, 1)
-
-            # draw the sight range
-            # sight_range = self.env.unit_type_sight_ranges[kind] * self.scale
-            # pygame.draw.circle(screen, self.fg, pos, sight_range.astype(int), 2)
-
-            # draw attack range
-            # attack_range = self.env.unit_type_attack_ranges[kind] * self.scale
-            # pygame.draw.circle(screen, self.fg, pos, attack_range.astype(int), 2)
-            # work out which agents are being shot
-
-    def render_action(self, screen, action):
-        if self.env.action_type != "discrete":
-            return
-
-        def coord_fn(idx, n, team):
-            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.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)
-
-    def render_obstacles(self, screen):
-        for c, d in zip(self.env.obstacle_coords, self.env.obstacle_deltas):
-            d = tuple(((c + d) * self.scale).tolist())
-            c = tuple((c * self.scale).tolist())
-            pygame.draw.line(screen, self.fg, c, d, 5)
-
-    def render_bullets(self, screen, bullets, jdx):
-        jdx += 1
-        ally_bullets, enemy_bullets = bullets
-        for source, target in ally_bullets:
-            position = source + (target - source) * jdx / 8
-            position *= self.scale
-            pygame.draw.circle(screen, self.fg, tuple(position.tolist()), 3)
-        for source, target in enemy_bullets:
-            position = source + (target - source) * jdx / 8
-            position *= self.scale
-            pygame.draw.circle(screen, self.fg, tuple(position.tolist()), 3)
+    def animate(self, save_fname: Optional[str] = "output/parabellum", view=None):
+        expanded_state_seq, expanded_action_seq = expand_fn(self.env, self.state_seq, self.action_seq)
+        state_seq_seq, action_seq_seq = unbatch_fn(expanded_state_seq, expanded_action_seq)
+        for idx, (state_seq, action_seq) in enumerate(zip(state_seq_seq, action_seq_seq)):
+            animate_fn(self.env, self.skin, self.image, state_seq, action_seq, f"{save_fname}_{idx}.mp4")
 
 
 # functions
-# bullet functions
-def dist_fn(env, pos):  # computing the distances between all ally and enemy agents
-    delta = pos[None, :, :] - pos[:, None, :]
-    dist = jnp.sqrt((delta**2).sum(axis=2))
-    dist = dist[: env.num_allies, env.num_allies :]
-    return {"ally": dist, "enemy": dist.T}
-
-
-def range_fn(env, dists, ranges):  # computing what targets are in range
-    ally_range = dists["ally"] < ranges[: env.num_allies][:, None]
-    enemy_range = dists["enemy"] < ranges[env.num_allies :][:, None]
-    return {"ally": ally_range, "enemy": enemy_range}
-
-
-def target_fn(acts, in_range, team):  # computing the one hot valid targets
-    t_acts = jnp.stack([v for k, v in acts.items() if k.startswith(team)]).T
-    t_targets = jnp.where(t_acts > 4, -1, t_acts - 5)  # first 5 are move actions
-    t_attacks = jnp.eye(in_range[team].shape[1] + 1)[t_targets][:, :-1]
-    return t_attacks * in_range[team]  # one hot valid targets
-
-
-def attack_fn(env, state_seq):  # one hot attack list
-    attacks = []
-    for _, state, acts in state_seq:
-        dists = dist_fn(env, state.unit_positions)
-        ranges = env.unit_type_attack_ranges[state.unit_types]
-        in_range = range_fn(env, dists, ranges)
-        target = partial(target_fn, acts, in_range)
-        attack = {"ally": target("ally"), "enemy": target("enemy")}
-        attacks.append(attack)
-    return attacks
-
-
-def bullet_fn(env, states):
-    bullet_seq = []
-    attack_seq = attack_fn(env, states)
-
-    def aux_fn(team):
-        bullets = jnp.stack(jnp.where(one_hot[team] == 1)).T
-        # bullets = bullets.at[:, 2 if team == "ally" else 1].add(env.num_allies)
-        return bullets
-
-    state_zip = zip(states[:-1], states[1:])
-    for i, ((_, state, _), (_, n_state, _)) in enumerate(state_zip):
-        one_hot = attack_seq[i]
-        ally_bullets, enemy_bullets = aux_fn("ally"), aux_fn("enemy")
-
-        ally_bullets_source = state.unit_positions[ally_bullets[:, 0]]
-        enemy_bullets_target = n_state.unit_positions[enemy_bullets[:, 1]]
-
-        enemy_bullets_source = state.unit_positions[
-            enemy_bullets[:, 0] + env.num_allies
-        ]
-        ally_bullets_target = n_state.unit_positions[
-            ally_bullets[:, 1] + env.num_allies
-        ]
-
-        ally_bullets = jnp.stack((ally_bullets_source, ally_bullets_target), axis=1)
-        enemy_bullets = jnp.stack((enemy_bullets_source, enemy_bullets_target), axis=1)
-
-        bullet_seq.append((ally_bullets, enemy_bullets))
-    return bullet_seq
-
-
-# test the visualizer
-if __name__ == "__main__":
-    from jax import random, numpy as jnp
-    from parabellum import Parabellum, scenarios
-
-    # small_multiples()  # testing small multiples (not working yet)
-    # exit()
-
-    n_envs = 2
-    env = Parabellum(scenarios["default"], action_type="discrete")
-    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 = []
-
-    for i in range(100):
-        rng, act_rng, step_rng = random.split(rng, 3)
-        act_key = random.split(act_rng, (len(env.agents), n_envs))
-        act = {
-            a: vmap(env.action_space(a).sample)(act_key[i])
-            for i, a in enumerate(env.agents)
-        }
-        step_key = random.split(step_rng, n_envs)
-        state_seq.append((step_key, state, act))
-        obs, state, reward, done, infos = vmap(env.step)(step_key, state, act)
-
-    vis = Visualizer(env, state_seq)
-    vis.animate()
+def animate_fn(env, skin, image, state_seq, action_seq, save_fname):
+    pygame.init()
+    frames = []
+    for idx, (state_tup, action) in enumerate(zip(state_seq, action_seq)):
+        frames += [frame_fn(env, skin, image, state_tup[1], action, idx)]
+    # use cv2 to write frames to video
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # type: ignore
+    out = cv2.VideoWriter(save_fname, fourcc, skin.fps, (skin.size + skin.pad * 2, skin.size + skin.pad * 2))
+    for frame in frames:
+        out.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
+    out.release()
+    pygame.quit()
+
+
+def init_frame(env, skin, image, state: pb.State, action: Array, idx: int) -> pygame.Surface:
+    dims = (skin.size + skin.pad * 2, skin.size + skin.pad * 2)
+    frame = pygame.Surface(dims, pygame.SRCALPHA | pygame.HWSURFACE)
+    return frame
+
+
+def transform_frame(env, skin, frame):
+    frame = np.rot90(pygame.surfarray.pixels3d(frame).swapaxes(0, 1), 2)
+    return frame
+
+
+def frame_fn(env, skin, image, state: pb.State, action: Array, idx: int) -> np.ndarray:
+    """Create a frame"""
+    frame = init_frame(env, skin, image, state, action, idx)
+
+    pipeline = [render_background, render_agents, render_action, render_bullet]
+    for fn in pipeline:
+        frame = fn(env, skin, image, frame, state, action)
+
+    return transform_frame(env, skin, frame)
+
+
+def render_background(env, skin, image, frame, state, action):
+    coords = (skin.pad-5, skin.pad-5, skin.size+10, skin.size+10)
+    frame.fill(skin.bg)
+    frame.blit(image, coords)
+    pygame.draw.rect(frame, skin.fg, coords, 3)
+    return frame
+
+
+def render_action(env, skin, image, frame, state, action):
+    return frame
+
+
+def render_bullet(env, skin, image, frame, state, action):
+    return frame
+
+def render_agents(env, skin, image, frame, state, action):
+    units = state.unit_positions, state.unit_teams, state.unit_types, state.unit_health
+    for idx, (pos, team, kind, health) in enumerate(zip(*units)):
+        pos = tuple((pos * skin.scale).astype(int) + skin.pad)
+        # draw the agent
+        if health > 0:
+            unit_size = env.unit_type_radiuses[kind]
+            radius = float(jnp.ceil((unit_size * skin.scale)).astype(int) + 1)
+            pygame.draw.circle(frame, skin.fg, pos, radius, 1)
+            pygame.draw.circle(frame, skin.bg, pos, radius + 1, 1)
+    return frame
+
+
+def text_fn(text):
+    """rotate text upside down because of pygame issue"""
+    return pygame.transform.rotate(text, 180)
+
+
+def image_fn(skin: Skin):  # TODO:
+    """Create an image for background (basemap or maskmap)"""
+    motif = cv2.resize(np.array(skin.maskmap.T), (skin.size, skin.size), interpolation=cv2.INTER_LANCZOS4).astype(np.uint8)
+    motif = (motif > 0).astype(np.uint8)
+    image = np.zeros((skin.size, skin.size, 3), dtype=np.uint8) + skin.bg
+    image[motif == 1] = skin.fg
+    image = pygame.surfarray.make_surface(image)
+    image = pygame.transform.scale(image, (skin.size, skin.size))
+    return image
+
+
+def unbatch_fn(state_seq, action_seq):
+    """state seq is a list of tuples of (step_key, state, actions)."""
+    if is_multi_run(state_seq):
+        n_envs = state_seq[0][1].unit_positions.shape[0]
+        state_seq_seq = [jax.tree_map(lambda x: x[i], state_seq) for i in range(n_envs)]
+        action_seq_seq = [jax.tree_map(lambda x: x[i], action_seq) for i in range(n_envs)]
+    else:
+        state_seq_seq = [state_seq]
+        action_seq_seq = [action_seq]
+    return state_seq_seq, action_seq_seq
+
+
+def expand_fn(env, state_seq, action_seq):
+    """Expand the state sequence"""
+    fn = env.expand_state_seq
+    state_seq = vmap(fn)(state_seq) if is_multi_run(state_seq) else fn(state_seq)
+    action_seq = [action_seq[i // env.world_steps_per_env_step] for i in range(len(state_seq))]
+    return state_seq, action_seq
+
+
+def is_multi_run(state_seq):
+    return state_seq[0][1].unit_positions.ndim > 2

parabellum-0.2.21.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: parabellum
+Version: 0.2.21
+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: contextily (>=1.6.0,<2.0.0)
+Requires-Dist: darkdetect (>=0.8.0,<0.9.0)
+Requires-Dist: folium (>=0.17.0,<0.18.0)
+Requires-Dist: geopandas (>=1.0.0,<2.0.0)
+Requires-Dist: geopy (>=2.4.1,<3.0.0)
+Requires-Dist: ipykernel (>=6.29.5,<7.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: opencv-python (>=4.10.0.84,<5.0.0.0)
+Requires-Dist: osmnx (>=1.9.3,<2.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.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.21.dist-info/RECORD

@@ -0,0 +1,10 @@
+parabellum/__init__.py,sha256=-5cWXJkHnfH_CbhTEall8Wak8McAFXZHP1L8Fu7Uo5k,373
+parabellum/aid.py,sha256=HWST27inTFXcp8b11izJF0U7N7DZnRTIS3n1Qfa-Ko4,106
+parabellum/env.py,sha256=L6GHlLxywpkV1bRnZcYBURREPP4CRfet_pEwCt5DB04,16724
+parabellum/gun.py,sha256=nvsJdcZ2Qd6lbPlAgsUiaLhstTi1UdLQ8kOnbCenucY,2618
+parabellum/map.py,sha256=EUcPe4Upu9MQzS8h15IVPGCaAyRPLSkmoLd5ZT-V4Pk,2599
+parabellum/run.py,sha256=EO_F7VPwayatpSHrcbSahtinsV4QObhcx0jo-4KZO1E,3472
+parabellum/vis.py,sha256=uXTnhJL23JLQHW9by-M4bF73dSVA5TIkpNdfo_Go2Ro,6045
+parabellum-0.2.21.dist-info/METADATA,sha256=-K-3eYl1BvR3tFsiTxTyfHErQJdgPQZx08iq_kS2544,2671
+parabellum-0.2.21.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+parabellum-0.2.21.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,,