Repository: RoboEden/jux (language: python)

Issue:
v2.1.0 updates 



Discussion / hints:

Fix patch:
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 5e342ae..15ea428 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -13,7 +13,7 @@ repos:
     -   id: yapf
         additional_dependencies: [toml]
 -   repo: https://github.com/PyCQA/isort
-    rev: 5.10.1
+    rev: 5.12.0
     hooks:
     -   id: isort
 -   repo: https://github.com/PyCQA/autoflake
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b6142a9..b4d3b12 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,11 @@
 # Change Log
+## v2.1.0
+Major changes:
+ - Implement same game logic as `luxai-s2==2.1.0`. See [Lux-Design-S2/ChangeLog.md](https://github.com/Lux-AI-Challenge/Lux-Design-S2/blob/v2.1.0/ChangeLog.md) for details.
+ - `jax` is removed from the dependency list, and need to be installed by user manually. This is because `jax` must be compatible with cuDNN, and only the user knows which version of cuDNN is installed on their machine.
+
+Bug fixes:
+ - fix a bug that leads to crash when env seed exceed int32 max range.
 
 ## v2.0.0
 Major changes:
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8a9a174..060a94d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -6,51 +6,52 @@ We are going to support `python>=3.7,<3.11`.
 Make sure you have nvcc, cuda-toolkit and cudnn installed. There are two ways to get them ready, either by conda or docker (recommended).
 
 For conda users, you can install them with the following commands.
-```console
-$ conda install -c nvidia cuda-nvcc cuda-python
-$ conda install cudnn
+```sh
+conda install -c nvidia cuda-nvcc cuda-python
+conda install cudnn
 ```
 For docker users, you can use the [NVIDIA CUDA docker image](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/cuda) or the [PyTorch docker image](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch), which has all of them ready and compatible with each other.
 
 ### Install JAX
-Please follow the [official installation guide](https://github.com/google/jax#installation) to install JAX.
-
+Please follow the [official installation guide](https://github.com/google/jax#installation) to install JAX. Note: JAX must be compatible with your cuDNN.
+- If cudnn >= 8.2 and < 8.6, please install `"jax[cuda11_cudnn82]"`.
+- If cudnn >= 8.6, please install `"jax[cuda11_cudnn86]"`.
 
 ### Install JUX
 Finally, upgrade your pip and install JUX.
-```console
-$ pip install --upgrade pip
-$ pip install -e '.[dev,torch]'
+```sh
+pip install --upgrade pip
+pip install -e '.[dev,torch]'
 ```
 
 ## Setup pre-commit hooks
 Install pre-commit hooks.
-```console
-$ pre-commit install
-$ pre-commit run --all-files
+```sh
+pre-commit install
+pre-commit run --all-files
 ```
 It may take a while for the first run.
 
 # Before commit
 Make sure your code passes all tests.
-```console
-$ pytest
+```sh
+pytest
 ```
 
 Check your code with pytype and make it happy (Optional).
-```console
-$ pytype jux -k -j 4
+```sh
+pytype jux -k -j 4
 ```
 If you are sure that pytype is complaining about a false positive, you can add a `# pytype: disable=...` comment to the offending line.
 
 If you successfully go through all above check, congratulations! You can commit your code now.
-```console
-$ git commit -m "your commit message"
+```sh
+git commit -m "your commit message"
 ```
 
 # Before merge into master
 Test your code against different python versions.
-```console
-$ tox
+```sh
+tox
 ```
 If it fails in a specific python version (e.g. `py38`), you can run `tox -e py38` to solely test against that version. Only after tests on all python versions pass, you can merge your code into master.
diff --git a/README.md b/README.md
index c59bc18..1ee8741 100644
--- a/README.md
+++ b/README.md
@@ -6,25 +6,26 @@ JUX is a <ins>J</ins>ax-accelerated game core for L<ins>ux</ins> AI Challenge Se
 One of the main dependencies is JAX, which in turn relies on NVCC, CUDA Toolkit and cuDNN. There are two ways to get them ready, either by conda or docker (recommended).
 
 For conda users, you can install them with the following commands.
-```console
-$ conda install -c nvidia cuda-nvcc cuda-python
-$ conda install cudnn
+```sh
+conda install -c nvidia cuda-nvcc cuda-python
+conda install cudnn
 ```
 For docker users, you can use the [NVIDIA CUDA docker image](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/cuda) or the [PyTorch docker image](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/pytorch), which has all of them ready and compatible with each other.
 
 ### Install JAX
-Please follow the [official installation guide](https://github.com/google/jax#installation) to install JAX.
-
+Please follow the [official installation guide](https://github.com/google/jax#installation) to install JAX. Note: JAX must be compatible with your cuDNN.
+- If cudnn >= 8.2 and < 8.6, please install `"jax[cuda11_cudnn82]"`.
+- If cudnn >= 8.6, please install `"jax[cuda11_cudnn86]"`.
 
 ### Install JUX
 Finally, upgrade your pip and install JUX.
-```console
-$ pip install --upgrade pip
-$ pip install juxai-s2
+```sh
+pip install --upgrade pip
+pip install juxai-s2
 ```
 
 ## Usage
- See [tutorial.ipynb](tutorial.ipynb) for a quick start. JUX is guaranteed to implement the same game logic as `luxai_s2==2.0.0`, if players' input actions are valid. When players' input actions are invalid, JUX and LuxAI-S2 may process them differently.
+See [tutorial.ipynb](tutorial.ipynb) for a quick start. JUX is guaranteed to implement the same game logic as `luxai_s2==2.1.0`, if players' input actions are valid. When players' input actions are invalid, JUX and LuxAI-S2 may process them differently.
 
 ## Performance
 JUX maps all game logic to array operators in JAX so that we can harvest the computational power of modern GPUs and support tons of environments running in parallel. We benchmarked JUX on several different GPUs, and increased the throughput by hundreds to thousands of times, compared with the original single-thread Python implementation.
diff --git a/jux/__init__.py b/jux/__init__.py
index afced14..a33997d 100644
--- a/jux/__init__.py
+++ b/jux/__init__.py
@@ -1,1 +1,1 @@
-__version__ = '2.0.0'
+__version__ = '2.1.0'
diff --git a/jux/actions.py b/jux/actions.py
index fdca17b..bb00d93 100644
--- a/jux/actions.py
+++ b/jux/actions.py
@@ -18,7 +18,7 @@
 from jux.map.position import Direction, Position
 from jux.team import FactionTypes
 from jux.unit_cargo import ResourceType, UnitCargo
-from jux.utils import INT8_MAX, INT32_MAX
+from jux.utils import INT16_MAX
 
 try:
     import torch
@@ -64,7 +64,7 @@ class UnitAction(NamedTuple):
     direction: jnp.int8 = jnp.int8(0)
     resource_type: jnp.int8 = jnp.int8(0)
     amount: jnp.int16 = jnp.int16(0)
-    repeat: jnp.int8 = jnp.int8(0)
+    repeat: jnp.int16 = jnp.int16(0)
     n: jnp.int16 = jnp.int16(0)
 
     @classmethod
@@ -74,7 +74,7 @@ def new(
         direction: Union[Direction, int] = 0,
         resource_type: Union[ResourceType, int] = 0,
         amount: jnp.int16 = 0,
-        repeat: jnp.int8 = 0,
+        repeat: jnp.int16 = 0,
         n: jnp.int16 = 0,
     ) -> "UnitAction":
         return UnitAction(
@@ -82,7 +82,7 @@ def new(
             jnp.int8(direction),
             jnp.int8(resource_type),
             jnp.int16(amount),
-            jnp.int8(repeat),
+            jnp.int16(repeat),
             jnp.int16(n),
         )
 
@@ -165,7 +165,8 @@ def is_valid(self, max_transfer_amount) -> bool:
             (0 <= self.direction) & (self.direction <= len(Direction) - 1) & \
             (0 <= self.resource_type) & (self.resource_type <= len(ResourceType) - 1) & \
             (0 <= self.amount) & (self.amount <= max_transfer_amount) & \
-            (-1 <= self.repeat) & (self.repeat <= INT8_MAX) \
+            (0 <= self.n) & (self.n <= INT16_MAX) & \
+            (0 <= self.repeat) & (self.repeat <= INT16_MAX) \
         )
 
 
diff --git a/jux/config.py b/jux/config.py
index d2a89ed..0103e93 100644
--- a/jux/config.py
+++ b/jux/config.py
@@ -45,8 +45,8 @@ class EnvConfig(NamedTuple):
     validate_action_space: bool = True
 
     ### Constants ###
-    # you can only ever transfer in/out 1000 as this is the max cargo space.
-    max_transfer_amount: int = 10000
+    # you can only ever transfer in/out 3000 as this is the max cargo space.
+    max_transfer_amount: int = 3000
     MIN_FACTORIES: int = 2
     MAX_FACTORIES: int = 5
     CYCLE_LENGTH: int = 50
@@ -102,7 +102,7 @@ class EnvConfig(NamedTuple):
             MOVE_COST=1,
             RUBBLE_MOVEMENT_COST=0.05,
             DIG_COST=5,
-            SELF_DESTRUCT_COST=5,
+            SELF_DESTRUCT_COST=10,
             DIG_RUBBLE_REMOVED=2,
             DIG_RESOURCE_GAIN=2,
             DIG_LICHEN_REMOVED=10,
diff --git a/jux/map/board.py b/jux/map/board.py
index 878143c..5f36c1f 100644
--- a/jux/map/board.py
+++ b/jux/map/board.py
@@ -10,7 +10,7 @@
 
 from jux.config import EnvConfig, JuxBufferConfig, LuxEnvConfig
 from jux.map.position import Position
-from jux.map_generator.generator import GameMap, MapType, SymmetryType
+from jux.map_generator.generator import GameMap, MapDistributionType, MapType, SymmetryType
 from jux.utils import INT32_MAX, imax
 
 radius = 6
@@ -24,7 +24,7 @@
 
 
 class Board(NamedTuple):
-    seed: int
+    seed: jnp.uint32
     factories_per_team: jnp.int8
 
     map: GameMap
@@ -117,12 +117,23 @@ def new(cls, seed: int, env_cfg: EnvConfig, buf_cfg: JuxBufferConfig, factories_
             key=subkey,
             a=jnp.array([SymmetryType.HORIZONTAL, SymmetryType.VERTICAL]),
         )
+        key, subkey = jax.random.split(key)
+        map_distribution_type = jax.random.choice(
+            key=subkey,
+            a=jnp.array([
+                MapDistributionType.HIGH_ICE_HIGH_ORE,
+                MapDistributionType.HIGH_ICE_LOW_ORE,
+                MapDistributionType.LOW_ICE_HIGH_ORE,
+                MapDistributionType.LOW_ICE_LOW_ORE,
+            ]),
+        )
         map = GameMap.random_map(
             seed=seed,
             symmetry=symmetry,
             map_type=map_type,
             width=width,
             height=height,
+            map_distribution_type=map_distribution_type,
         )
         key, subkey = jax.random.split(key)
         if factories_per_team is None:
diff --git a/jux/map_generator/flood.py b/jux/map_generator/flood.py
index 0ec420c..74ea589 100644
--- a/jux/map_generator/flood.py
+++ b/jux/map_generator/flood.py
@@ -124,14 +124,27 @@ def _body(args):
 @jax.jit
 def component_sum(data, color):
     """
-    A flood fill algorithm that returns the color of each cell.
+    Compute the sum of data within each component.
 
     Args:
-        int[H, W, 2]: the color of each cell. Calculated by `flood_fill()` or
+        data: broadcastable to int[H, W]. the data to be summed.
+        color: int[H, W, 2]. the color of each cell. Calculated by `flood_fill()` or
         `_flood_fill()`.
 
     Returns:
         [H, W]: the sum of data within the component each cell is located.
+
+    Example:
+        ```python
+        >>> mask = jnp.array([[0, 0, 1],
+        ...                   [0, 1, 0],
+        ...                   [1, 0, 0]])
+        >>> color = flood_fill(mask)
+        >>> component_sum(1, color) # calculate the number of cells in each component
+        DeviceArray([[3, 3, 1],
+                    [3, 1, 3],
+                    [1, 3, 3]], dtype=int32)
+        ```
     """
     cmp_sum = jnp.zeros(color.shape[:2], jnp.asarray(data).dtype)
     cmp_sum = cmp_sum.at[color[..., 0], color[..., 1]].add(data)
@@ -142,16 +155,33 @@ def component_sum(data, color):
 @jax.jit
 def boundary_sum(data, color, mask):
     """
-    A flood fill algorithm that returns the color of each cell.
+    Compute the sum of data at component boundary.
 
     Args:
-        int[H, W, 2]: the color of each cell. Calculated by `flood_fill()` or
-        `_flood_fill()`.
+        data: broadcastable to int[H, W]. the data to be summed.
+        color: int[H, W, 2]. the color of each cell. Calculated by `flood_fill(mask)`.
+        mask: bool[H, W] that stores the barriers on the map. False
+            means no barrier, True means barrier.
 
     Returns:
         [H, W]: the sum of data in the boundary of the component each cell is
-        located. Component boundary refers to the cells that are adjacent to the
+        located. Component boundary refers to the barriers that are adjacent to the
         component but not in the component.
+
+
+    Example:
+        ```python
+        >>> mask = jnp.array([
+        ...     [1, 0, 0],
+        ...     [0, 1, 0],
+        ...     [0, 0, 1]
+        ... ], dtype=jnp.bool_)
+        >>> color = flood_fill(mask)
+        >>> boundary_sum(1, color, mask) # calculate the boundary size
+        DeviceArray([[0, 3, 3],
+                    [3, 0, 3],
+                    [3, 3, 0]], dtype=int32)
+        ```
     """
     H, W = mask.shape
 
diff --git a/jux/map_generator/generator.py b/jux/map_generator/generator.py
index 3919ca9..230693e 100644
--- a/jux/map_generator/generator.py
+++ b/jux/map_generator/generator.py
@@ -1,4 +1,3 @@
-from enum import IntEnum
 from functools import partial
 from typing import NamedTuple, Optional, Type
 
@@ -12,26 +11,11 @@
 
 from jux.config import EnvConfig, JuxBufferConfig
 from jux.map_generator.flood import boundary_sum, component_sum, flood_fill
+from jux.map_generator.generator_config import CaveConfig, MapDistributionType, MapType, MountainConfig
 from jux.map_generator.symnoise import SymmetryNoise, SymmetryType, symmetrize
 from jux.utils import INT32_MAX
 
 
-class MapType(IntEnum):
-    CAVE = 0
-    CRATERS = 1
-    ISLAND = 2
-    MOUNTAIN = 3
-
-    @classmethod
-    def from_lux(cls, map_type: str) -> "MapType":
-        idx = ["Cave", "Craters", "Island", "Mountain"].index(map_type)
-        return cls(idx)
-
-    @classmethod
-    def to_lux(self) -> str:
-        return ["Cave", "Craters", "Island", "Mountain"][self.value]
-
-
 class GameMap(NamedTuple):
     rubble: jnp.int8  # int8[height, width]
     ice: jnp.bool_  # bool[height, width]
@@ -60,14 +44,15 @@ def random_map(seed: jnp.int32 = None,
                    map_type: Optional[MapType] = None,
                    symmetry: Optional[SymmetryType] = None,
                    width: jnp.int32 = None,
-                   height: jnp.int32 = None) -> "GameMap":
+                   height: jnp.int32 = None,
+                   map_distribution_type: jnp.int32 = None) -> "GameMap":
         noise = SymmetryNoise(seed=seed, symmetry=symmetry, octaves=3)
         map_rand = lax.switch(map_type, [
             partial(cave, width, height),
             partial(craters, width, height),
             partial(island, width, height),
             partial(mountain, width, height),
-        ], symmetry, noise)
+        ], symmetry, noise, map_distribution_type)
         return GameMap.new(
             map_rand.rubble,
             map_rand.ice,
@@ -131,7 +116,14 @@ def maximum_filter(matrix, window_dimensions=(4, 4)):
     return matrix
 
 
-def cave(width: jnp.int32, height: jnp.int32, symmetry: SymmetryType, noise: SymmetryNoise) -> "GameMap":
+def cave(
+    width: jnp.int32,
+    height: jnp.int32,
+    symmetry: SymmetryType,
+    noise: SymmetryNoise,
+    map_distribution_type: MapDistributionType,
+) -> "GameMap":
+    config: CaveConfig = CaveConfig.new(map_distribution_type=map_distribution_type)
     seed = noise.seed
     key = jax.random.PRNGKey(seed)
     key, subkey = jax.random.split(key)
@@ -167,19 +159,21 @@ def cave(width: jnp.int32, height: jnp.int32, symmetry: SymmetryType, noise: Sym
     ice = noise.noise(x, y + 100)
     ice = ice * (mask <= 1)
     ice = ice * (mask != 0)
-    mid_mask = (ice < jnp.percentile(ice, 92)) & (ice > jnp.percentile(ice, 91))
-    ice = ice * (ice >= jnp.percentile(ice, 98))
-    ice = ice != 0
-    ice = mid_mask + ice * (~mid_mask)
+    mid_mask = (ice > jnp.percentile(ice, config.ice_mid_range[0])) & (ice < jnp.percentile(
+        ice, config.ice_mid_range[1]))
+    high_mask = (ice > jnp.percentile(ice, config.ice_high_range[0])) & (ice < jnp.percentile(
+        ice, config.ice_high_range[1]))
+    ice = mid_mask | high_mask
 
     # Make some noisy ore, most ore is outside caves
     ore = noise.noise(x, y - 100)
     ore = ore * (mask != 1)
     ore = ore * (mask != 0)
-    mid_mask = (ore < jnp.percentile(ore, 92)) & (ore > jnp.percentile(ore, 91))
-    ore = ore * (~(ore < jnp.percentile(ore, 98)))
-    ore = ore != 0
-    ore = mid_mask + ore * (~mid_mask)
+    mid_mask = (ore > jnp.percentile(ore, config.ore_mid_range[0])) & (ore < jnp.percentile(
+        ore, config.ore_mid_range[1]))
+    high_mask = (ore > jnp.percentile(ore, config.ore_high_range[0])) & (ore < jnp.percentile(
+        ore, config.ore_high_range[1]))
+    ore = mid_mask | high_mask
 
     return GameMap(
         rubble=rubble,
@@ -189,7 +183,13 @@ def cave(width: jnp.int32, height: jnp.int32, symmetry: SymmetryType, noise: Sym
     )
 
 
-def craters(width: jnp.int32, height: jnp.int32, symmetry: SymmetryType, noise: SymmetryNoise) -> "GameMap":
+def craters(
+    width: jnp.int32,
+    height: jnp.int32,
+    symmetry: SymmetryType,
+    noise: SymmetryNoise,
+    map_distribution_type: MapDistributionType,
+) -> "GameMap":
     min_craters = jnp.maximum(2, width * height // 1000)
     max_craters = jnp.maximum(4, width * height // 500)
     seed = noise.seed
@@ -290,9 +290,8 @@ def solve_poisson(f):
     cy = jnp.cos(jnp.pi * jnp.arange(ny) / (ny - 1))
     f = cx[:, None] + cy[None, :] - 2
 
-    dct = jnp.divide(dct, f) * (f != 0)
-    dct = jnp.nan_to_num(dct, copy=True)
-    dct = dct * (f != 0)
+    dct = jnp.divide(dct, f)
+    dct = jnp.nan_to_num(dct, copy=True, nan=0.0, posinf=0.0, neginf=0.0)
 
     # Return to normal space
     potential = idctn1(dct)
@@ -317,7 +316,14 @@ def convolve2d_reflect(matrix, kernel):
     return matrix
 
 
-def mountain(width: jnp.int32, height: jnp.int32, symmetry: SymmetryType, noise: SymmetryNoise) -> "GameMap":
+def mountain(
+    width: jnp.int32,
+    height: jnp.int32,
+    symmetry: SymmetryType,
+    noise: SymmetryNoise,
+    map_distribution_type: MapDistributionType,
+) -> "GameMap":
+    config: MountainConfig = MountainConfig.new(map_distribution_type=map_distribution_type)
     seed = noise.seed
     f = jnp.zeros((height, width))
 
@@ -395,20 +401,22 @@ def mountain(width: jnp.int32, height: jnp.int32, symmetry: SymmetryType, noise:
     mask = mask / jnp.amax(mask)
 
     rubble = (100 * mask).round()
-    ice = (100 * mask).round()
-    mid_mask = (ice < jnp.percentile(ice, 50)) & (ice > jnp.percentile(ice, 48)) | (ice < jnp.percentile(
-        ice, 20)) & (ice > jnp.percentile(ice, 0))
-    ice = ice * (ice >= jnp.percentile(ice, 98))
-    ice = ice != 0
-    ice = ice * (~mid_mask) + mid_mask
-    ice = ice.astype(jnp.bool_)
-
-    ore = (100 * mask).round()
-    mid_mask = (ore < jnp.percentile(ore, 62)) & (ore > jnp.percentile(ore, 60))
-    ore = (ore >= jnp.percentile(ore, 83.5)) & (ore <= jnp.percentile(ore, 84.5))
-    ore = ore != 0
-    ore = ore * (~mid_mask) + mid_mask
-    ore = ore.astype(jnp.bool_)
+    ice = (100 * mask)
+    high_mask = (ice > jnp.percentile(ice, config.ice_high_range[0])) & (ice < jnp.percentile(
+        ice, config.ice_high_range[1]))
+    mid_mask = (ice > jnp.percentile(ice, config.ice_mid_range[0])) & (ice < jnp.percentile(
+        ice, config.ice_mid_range[1]))
+    low_mask = (ice > jnp.percentile(ice, config.ice_low_range[0])) & (ice < jnp.percentile(
+        ice, config.ice_low_range[1]))
+    ice = low_mask | mid_mask | high_mask
+    ore = (100 * mask)
+
+    mid_mask = (ore > jnp.percentile(ore, config.ore_mid_range[0])) & (ore < jnp.percentile(
+        ore, config.ore_mid_range[1]))
+    low_mask = (ore > jnp.percentile(ore, config.ore_low_range[0])) & (ore < jnp.percentile(
+        ore, config.ore_low_range[1]))
+
+    ore = low_mask | mid_mask
 
     return GameMap(
         rubble=rubble,
@@ -434,7 +442,13 @@ def convolve2d_fill(matrix: Array, kernel: Array, fillvalue: jnp.float32):
     return matrix_full
 
 
-def island(width: jnp.int32, height: jnp.int32, symmetry: SymmetryType, noise: SymmetryNoise) -> "GameMap":
+def island(
+    width: jnp.int32,
+    height: jnp.int32,
+    symmetry: SymmetryType,
+    noise: SymmetryNoise,
+    map_distribution_type: MapDistributionType,
+) -> "GameMap":
     # at the end, 0 = island, 1 = sea (of rubble)
     seed = noise.seed
     key = jax.random.PRNGKey(seed)
@@ -496,30 +510,3 @@ def _body_func(val):
         ore=ore,
         symmetry=symmetry,
     )
-
-
-if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="Generate maps for Lux AI 2022.")
-    parser.add_argument("-t", "--map_type", help="Map type ('Cave', 'Craters', 'Island', 'Mountain')", required=False)
-    parser.add_argument("-s", "--size", help="Size (32-64)", required=False)
-    parser.add_argument("-d", "--seed", help="Seed")
-    parser.add_argument("-m", "--symmetry", help="Symmetry ('horizontal', 'rotational', 'vertical', '/', '\\')")
-
-    args = vars(parser.parse_args())
-    map_type = args.get("map_type", None)
-    symmetry = args.get("symmetry", None)
-    if args.get("size", None):
-        width = height = int(args["size"])
-    else:
-        width = height = None
-    if args.get("seed", None):
-        seed = int(args["seed"])
-    else:
-        seed = None
-
-    map_type = MapType.from_lux(map_type)
-    symmetry = MapType.from_lux(symmetry)
-    game_map = GameMap.random_map(seed=seed, symmetry=symmetry, map_type=map_type, width=width, height=height)
-    lux_viz(game_map)
-    input()
diff --git a/jux/map_generator/generator_config.py b/jux/map_generator/generator_config.py
new file mode 100644
index 0000000..d393330
--- /dev/null
+++ b/jux/map_generator/generator_config.py
@@ -0,0 +1,120 @@
+from enum import IntEnum
+from typing import NamedTuple, Tuple
+
+from jax import lax
+
+
+class MapType(IntEnum):
+    CAVE = 0
+    CRATERS = 1
+    ISLAND = 2
+    MOUNTAIN = 3
+
+    @classmethod
+    def from_lux(cls, map_type: str) -> "MapType":
+        idx = ["Cave", "Craters", "Island", "Mountain"].index(map_type)
+        return cls(idx)
+
+    def to_lux(self) -> str:
+        return ["Cave", "Craters", "Island", "Mountain"][self.value]
+
+
+class MapDistributionType(IntEnum):
+    HIGH_ICE_HIGH_ORE = 0
+    HIGH_ICE_LOW_ORE = 1
+    LOW_ICE_HIGH_ORE = 2
+    LOW_ICE_LOW_ORE = 3
+
+    @classmethod
+    def from_lux(cls, map_distribution_type: str) -> "MapDistributionType":
+        idx = [
+            "high_ice_high_ore",
+            "high_ice_low_ore",
+            "low_ice_high_ore",
+            "low_ice_low_ore",
+        ].index(map_distribution_type)
+        return cls(idx)
+
+    def to_lux(self) -> str:
+        return [
+            "high_ice_high_ore",
+            "high_ice_low_ore",
+            "low_ice_high_ore",
+            "low_ice_low_ore",
+        ][self.value]
+
+
+class CaveConfig(NamedTuple):
+    ice_high_range: Tuple[float, float] = (99., 100.)
+    ice_mid_range: Tuple[float, float] = (91., 91.7)
+    ore_high_range: Tuple[float, float] = (98.7, 100.)
+    ore_mid_range: Tuple[float, float] = (81., 81.5)
+
+    @staticmethod
+    def new(map_distribution_type: MapDistributionType):
+        cave_config = lax.switch(
+            map_distribution_type,
+            [
+                lambda: CaveConfig(),  # high_ice_high_ore
+                lambda: CaveConfig(
+                    ore_high_range=(99.5, 100.),
+                    ore_mid_range=(81., 81.4),
+                ),  # high_ice_low_ore
+                lambda: CaveConfig(
+                    ice_high_range=(99.6, 100.),
+                    ice_mid_range=(91., 91.5),
+                ),  # low_ice_high_ore
+                lambda: CaveConfig(
+                    ore_high_range=(99.5, 100.),
+                    ore_mid_range=(81., 81.4),
+                    ice_high_range=(99.6, 100.),
+                    ice_mid_range=(91., 91.5),
+                )  # low_ice_low_ore
+            ],
+        )
+        return cave_config
+
+
+class MountainConfig(NamedTuple):
+
+    # controls amount of ice spread along mountain peaks
+    ice_high_range: Tuple[float, float] = (98.9, 100.)
+
+    # around middle level
+    ice_mid_range: Tuple[float, float] = (52.5, 53.)
+
+    # around lower level
+    ice_low_range: Tuple[float, float] = (0., 21.)
+
+    # controls amount of ore spread along middle of the way to the mountain peaks
+    ore_mid_range: Tuple[float, float] = (84., 85.)
+
+    # controls amount of ore spread along lower part of the mountain peaks,
+    # should be smaller than ore_mid_range
+    ore_low_range: Tuple[float, float] = (61.4, 62.)
+
+    @staticmethod
+    def new(map_distribution_type: MapDistributionType):
+        cave_config = lax.switch(
+            map_distribution_type,
+            [
+                lambda: MountainConfig(),  # high_ice_high_ore
+                lambda: MountainConfig(
+                    ore_low_range=(61.6, 62.),
+                    ore_mid_range=(84.5, 85.),
+                ),  # high_ice_low_ore
+                lambda: MountainConfig(
+                    ice_high_range=(99.4, 100.),
+                    ice_mid_range=(52.7, 53.),
+                    ice_low_range=(0., 20.),
+                ),  # low_ice_high_ore
+                lambda: MountainConfig(
+                    ice_high_range=(99.4, 100.),
+                    ice_mid_range=(52.7, 53.),
+                    ice_low_range=(0., 20.),
+                    ore_low_range=(61.6, 62.),
+                    ore_mid_range=(84.5, 85.),
+                )  # low_ice_low_ore
+            ],
+        )
+        return cave_config
diff --git a/jux/state/state.py b/jux/state/state.py
index 37529ad..9f8e49a 100644
--- a/jux/state/state.py
+++ b/jux/state/state.py
@@ -8,6 +8,7 @@
 from jax import Array
 from luxai_s2.state import State as LuxState
 
+import jux.map_generator.flood
 import jux.tree_util
 from jux.actions import FactoryAction, JuxAction, UnitAction, UnitActionType
 from jux.config import EnvConfig, JuxBufferConfig
@@ -37,7 +38,7 @@ def sort_by_unit_id(units: Union[Unit, Factory]):
 class State(NamedTuple):
     env_cfg: EnvConfig
 
-    seed: int  # the seed for reproducibility
+    seed: jnp.uint32  # the seed for reproducibility
     rng_state: jax.random.KeyArray  # current rng state
 
     env_steps: jnp.int16
@@ -152,7 +153,7 @@ def next_player(self):
     def new(cls, seed: int, env_cfg: EnvConfig, buf_cfg: JuxBufferConfig) -> "State":
         key = jax.random.PRNGKey(seed)
         board = Board.new(
-            seed=seed,
+            seed=jnp.uint32(seed),
             env_cfg=env_cfg,
             buf_cfg=buf_cfg,
         )
@@ -174,7 +175,7 @@ def new(cls, seed: int, env_cfg: EnvConfig, buf_cfg: JuxBufferConfig) -> "State"
 
         state = cls(
             env_cfg=env_cfg,
-            seed=seed,
+            seed=jnp.uint32(seed),
             rng_state=key,
             env_steps=State.__annotations__['env_steps'](0),
             board=board,
@@ -267,7 +268,7 @@ def convert_factories(lux_factories: LuxFactory) -> Tuple[Factory, Array]:
 
             state = State(
                 env_cfg=env_cfg,
-                seed=seed,
+                seed=jnp.uint32(seed),
                 rng_state=jax.random.PRNGKey(seed),
                 env_steps=State.__annotations__['env_steps'](lux_state.env_steps),
                 board=Board.from_lux(lux_state.board, buf_cfg),
@@ -405,6 +406,15 @@ def _to_lux_factories(factories: Factory, n_factory: int) -> Dict[str, LuxFactor
             global_id=int(self.global_id),
         )
 
+    def to_torch(self) -> 'State':
+        # convert seed from uint32 to int32, because torch does not support uint32
+        self = self._replace(
+            seed=self.seed.astype(jnp.int32),
+            rng_state=self.rng_state.astype(jnp.int32),
+            board=self.board._replace(seed=self.board.seed.astype(jnp.int32)),
+        )
+        return jax.tree_map(jux.torch.to_torch, self)
+
     def __eq__(self, other: 'State') -> bool:
         if not isinstance(other, State):
             return False
@@ -720,7 +730,7 @@ def _step_late_game(self, actions: JuxAction) -> 'State':
 
         self = self.add_rubble_for_dead_units(dead)
 
-        color, grow_lichen_size = self._cache_water_info(factory_actions)
+        color, grow_lichen_size, connected_lichen_size = self._cache_water_info(factory_actions)
         self = self._handle_factory_water_actions(factory_actions, color, grow_lichen_size)
         self = self._handle_transfer_actions(unit_action, action_info['valid_transfer'])
         self = self._handle_pickup_actions(unit_action, action_info['valid_pickup'])
@@ -757,7 +767,7 @@ def _step_late_game(self, actions: JuxAction) -> 'State':
         self = self._replace(factories=factories)
 
         # factories gain power
-        delta_power = self.env_cfg.FACTORY_CHARGE + grow_lichen_size * self.env_cfg.POWER_PER_CONNECTED_LICHEN_TILE
+        delta_power = self.env_cfg.FACTORY_CHARGE + connected_lichen_size * self.env_cfg.POWER_PER_CONNECTED_LICHEN_TILE
         new_factory_power = self.factories.power + jnp.where(self.factory_mask, delta_power, 0)
         self = self._replace(factories=self.factories._replace(power=new_factory_power))
 
@@ -1469,7 +1479,7 @@ def _handle_factory_water_actions(self, factory_actions: Array, color: Array, gr
 
         return self
 
-    def _cache_water_info(self, factory_actions: Array) -> Tuple[Array, Array]:
+    def _cache_water_info(self, factory_actions: Array) -> Tuple[Array, Array, Array]:
         """
         Run flood fill algorithm to color cells. All cells to be watered by the
         same factory will have the same color.
@@ -1485,8 +1495,10 @@ def _cache_water_info(self, factory_actions: Array) -> Tuple[Array, Array]:
             grow_lichen_size: int[2, F].
                 The number of positions to be watered by each factory.
         """
-        # The key idea here is to prepare a list of neighbors for each cell it connects to when watered.
-        # neighbor_ij is a 4x2xHxW array, where the first dimension is the neighbors (4 at most), the second dimension is the 2 coordinates.
+        # The key idea here is to prepare a list of neighbors for each cell it
+        # connects to when watered. neighbor_ij is a 4x2xHxW array, where the
+        # first dimension is the neighbors (4 at most), the second dimension is
+        # the coordinates (x,y) of neighbors.
         H, W = self.board.lichen_strains.shape
 
         ij = jnp.mgrid[:H, :W].astype(Position.dtype())
@@ -1535,6 +1547,11 @@ def _cache_water_info(self, factory_actions: Array) -> Tuple[Array, Array]:
         connected_lichen = connected_lichen.at[color[..., 0], color[..., 1]]\
                                            .get(mode='fill', fill_value=imax(connected_lichen.dtype))
 
+        # compute connected lichen size
+        connected_lichen_size = jux.map_generator.flood.component_sum(UnitCargo.dtype()(1), color)  # int[H, W]
+        # -9 for the factory occupied cells
+        connected_lichen_size = connected_lichen_size[self.factories.pos.x, self.factories.pos.y] - 9  # int[2, F]
+
         # 2. handle cells to expand to.
         # 2.1 cells that are allowed to expand to, only if
         #   1. it is not a lichen strain, and
@@ -1588,7 +1605,7 @@ def _cache_water_info(self, factory_actions: Array) -> Tuple[Array, Array]:
         # -9 for the factory occupied cells
         grow_lichen_size = cmp_cnt[self.factories.pos.x, self.factories.pos.y] - 9  # int[2, F]
 
-        return color, grow_lichen_size
+        return color, grow_lichen_size, connected_lichen_size
 
     def _mars_quake(self) -> 'State':
         return self.add_rubble_for_dead_units(self.unit_mask)
diff --git a/jux/unit.py b/jux/unit.py
index cb88f50..6d9e454 100644
--- a/jux/unit.py
+++ b/jux/unit.py
@@ -117,11 +117,13 @@ def next_action(self) -> UnitAction:
 
     def repeat_action(self, success: bool) -> 'Unit':
         '''
-        Currently, invalid actions in luxai2021 are not executed and also not
-        removed from the action queue. So, wee need an indicator 'success' to
+        Currently, invalid actions in luxai_s2 are not executed and also not
+        removed from the action queue. So, we need an indicator 'success' to
         indicate whether the action is executed successfully. Only when the
         action is executed successfully, we can pop/repeat it.
 
+        From luxai_s2, we set the action's n value equal to repeat if we pop and push back
+
         Args:
             success (bool[2, U]): whether the action is executed successfully
         Returns:
@@ -134,10 +136,10 @@ def repeat_action(self, success: bool) -> 'Unit':
         pop_only = (act.n <= 1) & ~act.repeat & success & not_empty
         pop_and_push_back = (act.n <= 1) & act.repeat & success & not_empty
 
-        data = jax.tree_map(
+        data: UnitAction = jax.tree_map(
             lambda queue, a: queue.at[self.action_queue.rear].set(a),
             self.action_queue.data,
-            act._replace(n=jnp.where(pop_and_push_back, 1, act.n)),
+            act._replace(n=jnp.where(pop_and_push_back, act.repeat, act.n)),
         )
         n = data.n.at[self.action_queue.front].add(-n_minus_one.astype(data.n.dtype))
         data = data._replace(n=n)
diff --git a/jux/utils/__init__.py b/jux/utils/__init__.py
index afc7df2..5af731d 100644
--- a/jux/utils/__init__.py
+++ b/jux/utils/__init__.py
@@ -11,7 +11,7 @@
 from luxai_s2 import LuxAI_S2
 
 INT32_MAX = jnp.iinfo(jnp.int32).max
-INT16_MAX = jnp.iinfo(jnp.int32).max
+INT16_MAX = jnp.iinfo(jnp.int16).max
 INT8_MAX = jnp.iinfo(jnp.int8).max
 
 
diff --git a/pyproject.toml b/pyproject.toml
index 796a84f..cbd9ccc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,71 +1,72 @@
 [build-system]
-    requires = ["setuptools", "setuptools-scm"]
-    build-backend = "setuptools.build_meta"
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
 
 [project]
-    name = "juxai-s2"
-    description = "JUX is a jax-accelerated engine for Lux-2022."
-    requires-python = ">=3.7, <3.11"
-    license = { file = "LICENSE" }
-    readme = "README.md"
-    authors = [
-        { name = "Qimai Li", email = "qimaili@chaocanshu.ai" },
-        { name = "Yuhao Jiang", email = "yuhaojiang@chaocanshu.ai" },
-    ]
-    keywords = ["JAX", "LuxAI-S2"]
-    classifiers = [
-        "Programming Language :: Python :: 3",
-        "Environment :: GPU :: NVIDIA CUDA",
-        "License :: OSI Approved :: MIT License",
-        "Topic :: Games/Entertainment :: Real Time Strategy",
-        "Topic :: Scientific/Engineering :: Artificial Intelligence",
-    ]
-    dependencies = [
-        "luxai-s2==2.0.0",
-        "jax[cuda]",
-        "chex",
-    ]
-    dynamic = ["version"]
+name = "juxai-s2"
+description = "JUX is a jax-accelerated engine for Lux-2022."
+requires-python = ">=3.7, <3.11"
+license = { file = "LICENSE" }
+readme = "README.md"
+authors = [
+    { name = "Qimai Li", email = "qimaili@chaocanshu.ai" },
+    { name = "Yuhao Jiang", email = "yuhaojiang@chaocanshu.ai" },
+]
+keywords = ["JAX", "LuxAI-S2"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Environment :: GPU :: NVIDIA CUDA",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: Games/Entertainment :: Real Time Strategy",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "luxai-s2==2.1.0",
+    # "jax[cuda]",
+    "chex",
+]
+dynamic = ["version"]
 
-    [project.urls]
-    repository = "https://github.com/RoboEden/jux"
-    "Bug Tracker" = "https://github.com/RoboEden/jux/issues"
-    # TODO: add homepage url
-    # TODO: add documentation url
+[project.urls]
+repository = "https://github.com/RoboEden/jux"
+"Bug Tracker" = "https://github.com/RoboEden/jux/issues"
+# TODO: add homepage url
+# TODO: add documentation url
 
-    [project.optional-dependencies]
-    torch = [
-        "torch",
-        "torchvision",
-        "torchaudio",
-    ]
+[project.optional-dependencies]
+torch = ["torch"]
 
-    dev = [
-        "toml",
-        "pre-commit",
-        "pytype",
-        "tox",
-        "tox-conda",
-        "pytest",
-        "pytest-cov",
-        "isort",
-        "autoflake",
-        "yapf",
-        "bump2version",
-        "rich",
-        "pandas",
-        "ipywidgets>=7.0,<8.0",
-        "notebook",
-        "build",
-        "twine",
-    ]
+dev = [
+    "toml",
+    "pre-commit",
+    "pytype",
+    "tox",
+    "tox-conda",
+    "pytest",
+    "pytest-cov",
+    "isort",
+    "autoflake",
+    "yapf",
+    "bump2version",
+    "rich",
+    "pandas",
+    "ipywidgets>=7.0,<8.0",
+    "notebook",
+    "build",
+    "twine",
+]
 
 [tool.setuptools.dynamic]
-    version = { attr = "jux.__version__" }
+version = { attr = "jux.__version__" }
 
 [tool.yapf]
-    column_limit = 120
-    indent_width = 4
+column_limit = 120
+indent_width = 4
 
 [tool.autoflake]
-    imports = ["jax", "numpy", "chex"]
+imports = ["jax", "numpy", "chex"]
+
+[tool.isort]
+multi_line_output = 3
+include_trailing_comma = true
+line_length = 120
diff --git a/tox.ini b/tox.ini
index 6fd9a80..a1b3e08 100644
--- a/tox.ini
+++ b/tox.ini
@@ -14,6 +14,7 @@ deps =
     pytest-cov
     rich
     chex
+    jax[cuda11_cudnn82]
 extras = torch
 install_command =
     pip install -f https://storage.googleapis.com/jax-releases/jax_cuda_releases.html {opts} {packages}
diff --git a/tutorial.ipynb b/tutorial.ipynb
index 70b545e..ab0895c 100644
--- a/tutorial.ipynb
+++ b/tutorial.ipynb
@@ -129,7 +129,7 @@
             "outputs": [
                 {
                     "data": {
-                        "image/png": "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",
+                        "image/png": "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",
                         "text/plain": [
                             "<Figure size 640x480 with 1 Axes>"
                         ]
@@ -170,7 +170,7 @@
             "source": [
                 "import jux.utils\n",
                 "\n",
-                "lux_env, lux_actions = jux.utils.load_replay(f'tests/replay2.0_0.json.gz')\n",
+                "lux_env, lux_actions = jux.utils.load_replay(f'https://www.kaggleusercontent.com/episodes/{46215591}.json')\n",
                 "\n",
                 "jux_env, state = JuxEnv.from_lux(lux_env, buf_cfg=JuxBufferConfig(MAX_N_UNITS=200))"
             ]
@@ -212,11 +212,11 @@
                     "output_type": "stream",
                     "text": [
                         "bid action in Lux:\n",
-                        "{'player_0': {'bid': 5, 'faction': 'AlphaStrike'},\n",
-                        " 'player_1': {'bid': 4, 'faction': 'AlphaStrike'}}\n",
+                        "{'player_0': {'bid': 0, 'faction': 'AlphaStrike'},\n",
+                        " 'player_1': {'bid': 0, 'faction': 'AlphaStrike'}}\n",
                         "\n",
                         "bid action in Jux:\n",
-                        "bid = [5 4], faction = [0 0]\n"
+                        "bid = [0 0], faction = [0 0]\n"
                     ]
                 }
             ],
@@ -334,26 +334,14 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "lux_act = {'player_0': {'spawn': [31, 35], 'metal': 191.0, 'water': 141.0}, 'player_1': {}}\n",
-                        "player_0 place a factory at [31 35] with water=141, metal=191.\n",
-                        "lux_act = {'player_0': {}, 'player_1': {'spawn': [34, 20], 'metal': 164.0, 'water': 122.0}}\n",
-                        "player_1 place a factory at [34 20] with water=122, metal=164.\n",
-                        "lux_act = {'player_0': {'spawn': [19, 18], 'metal': 199.0, 'water': 114.0}, 'player_1': {}}\n",
-                        "player_0 place a factory at [19 18] with water=114, metal=199.\n",
-                        "lux_act = {'player_0': {}, 'player_1': {'spawn': [16, 37], 'metal': 108.0, 'water': 114.0}}\n",
-                        "player_1 place a factory at [16 37] with water=114, metal=108.\n",
-                        "lux_act = {'player_0': {'spawn': [6, 27], 'metal': 120.0, 'water': 153.0}, 'player_1': {}}\n",
-                        "player_0 place a factory at [ 6 27] with water=153, metal=120.\n",
-                        "lux_act = {'player_0': {}, 'player_1': {'spawn': [22, 6], 'metal': 123.0, 'water': 125.0}}\n",
-                        "player_1 place a factory at [22  6] with water=125, metal=123.\n",
-                        "lux_act = {'player_0': {'spawn': [22, 36], 'metal': 164.0, 'water': 118.0}, 'player_1': {}}\n",
-                        "player_0 place a factory at [22 36] with water=118, metal=164.\n",
-                        "lux_act = {'player_0': {}, 'player_1': {'spawn': [14, 8], 'metal': 160.0, 'water': 181.0}}\n",
-                        "player_1 place a factory at [14  8] with water=181, metal=160.\n",
-                        "lux_act = {'player_0': {'spawn': [20, 26], 'metal': 71.0, 'water': 187.0}, 'player_1': {}}\n",
-                        "player_0 place a factory at [20 26] with water=187, metal=71.\n",
-                        "lux_act = {'player_0': {}, 'player_1': {'spawn': [24, 16], 'metal': 155.0, 'water': 183.0}}\n",
-                        "player_1 place a factory at [24 16] with water=183, metal=155.\n"
+                        "lux_act = {'player_0': {'metal': 150, 'spawn': [27, 25], 'water': 150}, 'player_1': {}}\n",
+                        "player_0 place a factory at [27 25] with water=150, metal=150.\n",
+                        "lux_act = {'player_0': {}, 'player_1': {'metal': 150, 'spawn': [19, 31], 'water': 150}}\n",
+                        "player_1 place a factory at [19 31] with water=150, metal=150.\n",
+                        "lux_act = {'player_0': {'metal': 150, 'spawn': [7, 10], 'water': 150}, 'player_1': {}}\n",
+                        "player_0 place a factory at [ 7 10] with water=150, metal=150.\n",
+                        "lux_act = {'player_0': {}, 'player_1': {'metal': 150, 'spawn': [7, 3], 'water': 150}}\n",
+                        "player_1 place a factory at [7 3] with water=150, metal=150.\n"
                     ]
                 }
             ],
@@ -415,7 +403,7 @@
             "outputs": [
                 {
                     "data": {
-                        "image/png": "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",
+                        "image/png": "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",
                         "text/plain": [
                             "<Figure size 640x480 with 1 Axes>"
                         ]
@@ -448,7 +436,7 @@
             "outputs": [
                 {
                     "data": {
-                        "image/png": "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",
+                        "image/png": "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",
                         "text/plain": [
                             "<Figure size 640x480 with 1 Axes>"
                         ]
@@ -541,7 +529,7 @@
                     "data": {
                         "text/html": [
                             "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">Board</span><span style=\"font-weight: bold\">(</span>\n",
-                            "    <span style=\"color: #808000; text-decoration-color: #808000\">seed</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int32<span style=\"font-weight: bold\">[]</span>, <span style=\"color: #808000; text-decoration-color: #808000\">weak_type</span>=<span style=\"color: #00ff00; text-decoration-color: #00ff00; font-style: italic\">True</span><span style=\"font-weight: bold\">)</span>,\n",
+                            "    <span style=\"color: #808000; text-decoration-color: #808000\">seed</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int32<span style=\"font-weight: bold\">[])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">factories_per_team</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">map</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">GameMap</span><span style=\"font-weight: bold\">(</span>\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">rubble</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">48</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">48</span><span style=\"font-weight: bold\">])</span>,\n",
@@ -560,7 +548,7 @@
                         ],
                         "text/plain": [
                             "\u001b[1;35mBoard\u001b[0m\u001b[1m(\u001b[0m\n",
-                            "    \u001b[33mseed\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint32\u001b[1m[\u001b[0m\u001b[1m]\u001b[0m, \u001b[33mweak_type\u001b[0m=\u001b[3;92mTrue\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "    \u001b[33mseed\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint32\u001b[1m[\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mfactories_per_team\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mmap\u001b[0m=\u001b[1;35mGameMap\u001b[0m\u001b[1m(\u001b[0m\n",
                             "        \u001b[33mrubble\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m48\u001b[0m,\u001b[1;36m48\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
@@ -605,7 +593,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "state.n_factories = DeviceArray([5, 5], dtype=int8)\n"
+                        "state.n_factories = DeviceArray([2, 2], dtype=int8)\n"
                     ]
                 },
                 {
@@ -702,7 +690,7 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "state.n_units = DeviceArray([4, 5], dtype=int16)\n"
+                        "state.n_units = DeviceArray([2, 2], dtype=int16)\n"
                     ]
                 },
                 {
@@ -716,7 +704,7 @@
                             "            <span style=\"color: #808000; text-decoration-color: #808000\">direction</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "            <span style=\"color: #808000; text-decoration-color: #808000\">resource_type</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "            <span style=\"color: #808000; text-decoration-color: #808000\">amount</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "            <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
+                            "            <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "            <span style=\"color: #808000; text-decoration-color: #808000\">n</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>\n",
                             "        <span style=\"font-weight: bold\">)</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">front</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
@@ -740,7 +728,7 @@
                             "            \u001b[33mdirection\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "            \u001b[33mresource_type\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "            \u001b[33mamount\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "            \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "            \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "            \u001b[33mn\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
                             "        \u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mfront\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
@@ -808,7 +796,7 @@
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">direction</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">DeviceArray</span><span style=\"font-weight: bold\">(</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span>, <span style=\"color: #808000; text-decoration-color: #808000\">dtype</span>=<span style=\"color: #800080; text-decoration-color: #800080\">int8</span><span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">resource_type</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">DeviceArray</span><span style=\"font-weight: bold\">(</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>, <span style=\"color: #808000; text-decoration-color: #808000\">dtype</span>=<span style=\"color: #800080; text-decoration-color: #800080\">int8</span><span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">amount</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">DeviceArray</span><span style=\"font-weight: bold\">(</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>, <span style=\"color: #808000; text-decoration-color: #808000\">dtype</span>=<span style=\"color: #800080; text-decoration-color: #800080\">int16</span><span style=\"font-weight: bold\">)</span>,\n",
-                            "    <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">DeviceArray</span><span style=\"font-weight: bold\">(</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>, <span style=\"color: #808000; text-decoration-color: #808000\">dtype</span>=<span style=\"color: #800080; text-decoration-color: #800080\">int8</span><span style=\"font-weight: bold\">)</span>,\n",
+                            "    <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">DeviceArray</span><span style=\"font-weight: bold\">(</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0</span>, <span style=\"color: #808000; text-decoration-color: #808000\">dtype</span>=<span style=\"color: #800080; text-decoration-color: #800080\">int16</span><span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">n</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">DeviceArray</span><span style=\"font-weight: bold\">(</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">1</span>, <span style=\"color: #808000; text-decoration-color: #808000\">dtype</span>=<span style=\"color: #800080; text-decoration-color: #800080\">int16</span><span style=\"font-weight: bold\">)</span>\n",
                             "<span style=\"font-weight: bold\">)</span>\n",
                             "</pre>\n"
@@ -819,7 +807,7 @@
                             "    \u001b[33mdirection\u001b[0m=\u001b[1;35mDeviceArray\u001b[0m\u001b[1m(\u001b[0m\u001b[1;36m1\u001b[0m, \u001b[33mdtype\u001b[0m=\u001b[35mint8\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mresource_type\u001b[0m=\u001b[1;35mDeviceArray\u001b[0m\u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[33mdtype\u001b[0m=\u001b[35mint8\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mamount\u001b[0m=\u001b[1;35mDeviceArray\u001b[0m\u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[33mdtype\u001b[0m=\u001b[35mint16\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "    \u001b[33mrepeat\u001b[0m=\u001b[1;35mDeviceArray\u001b[0m\u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[33mdtype\u001b[0m=\u001b[35mint8\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "    \u001b[33mrepeat\u001b[0m=\u001b[1;35mDeviceArray\u001b[0m\u001b[1m(\u001b[0m\u001b[1;36m0\u001b[0m, \u001b[33mdtype\u001b[0m=\u001b[35mint16\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mn\u001b[0m=\u001b[1;35mDeviceArray\u001b[0m\u001b[1m(\u001b[0m\u001b[1;36m1\u001b[0m, \u001b[33mdtype\u001b[0m=\u001b[35mint16\u001b[0m\u001b[1m)\u001b[0m\n",
                             "\u001b[1m)\u001b[0m\n"
                         ]
@@ -966,7 +954,7 @@
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">direction</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">resource_type</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">amount</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
+                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">n</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>\n",
                             "    <span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">front</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[])</span>,\n",
@@ -982,7 +970,7 @@
                             "        \u001b[33mdirection\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mresource_type\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mamount\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mn\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
                             "    \u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mfront\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
@@ -1033,7 +1021,7 @@
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">direction</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">resource_type</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">amount</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
+                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">n</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>\n",
                             "    <span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">front</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
@@ -1049,7 +1037,7 @@
                             "        \u001b[33mdirection\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mresource_type\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mamount\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mn\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
                             "    \u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mfront\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
@@ -1086,7 +1074,7 @@
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">direction</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">resource_type</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">amount</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "    <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
+                            "    <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">n</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>\n",
                             "<span style=\"font-weight: bold\">)</span>\n",
                             "</pre>\n"
@@ -1097,7 +1085,7 @@
                             "    \u001b[33mdirection\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mresource_type\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mamount\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "    \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "    \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mn\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
                             "\u001b[1m)\u001b[0m\n"
                         ]
@@ -1142,7 +1130,7 @@
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">direction</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">resource_type</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">amount</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
+                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">n</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>\n",
                             "    <span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">unit_action_queue_count</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
@@ -1158,7 +1146,7 @@
                             "        \u001b[33mdirection\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mresource_type\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mamount\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mn\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
                             "    \u001b[1m)\u001b[0m,\n",
                             "    \u001b[33munit_action_queue_count\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
@@ -1396,7 +1384,7 @@
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">direction</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">resource_type</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">amount</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
+                            "        <span style=\"color: #808000; text-decoration-color: #808000\">repeat</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">n</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int16<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">20</span><span style=\"font-weight: bold\">])</span>\n",
                             "    <span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">unit_action_queue_count</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">ShapedArray</span><span style=\"font-weight: bold\">(</span>int8<span style=\"font-weight: bold\">[</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>,<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">200</span><span style=\"font-weight: bold\">])</span>,\n",
@@ -1412,7 +1400,7 @@
                             "        \u001b[33mdirection\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m,\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mresource_type\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m,\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mamount\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m,\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m,\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "        \u001b[33mrepeat\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m,\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mn\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint16\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m,\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m,\u001b[1;36m20\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
                             "    \u001b[1m)\u001b[0m,\n",
                             "    \u001b[33munit_action_queue_count\u001b[0m=\u001b[1;35mShapedArray\u001b[0m\u001b[1m(\u001b[0mint8\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m,\u001b[1;36m2\u001b[0m,\u001b[1;36m200\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
@@ -1462,7 +1450,7 @@
                             "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">State</span><span style=\"font-weight: bold\">(</span>\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">env_cfg</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-style: italic\">None</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">seed</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "    <span style=\"color: #808000; text-decoration-color: #808000\">rng_state</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-style: italic\">None</span>,\n",
+                            "    <span style=\"color: #808000; text-decoration-color: #808000\">rng_state</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span><span style=\"font-weight: bold\">])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">env_steps</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span><span style=\"font-weight: bold\">])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">board</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">Board</span><span style=\"font-weight: bold\">(</span>\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">seed</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span><span style=\"font-weight: bold\">])</span>,\n",
@@ -1519,7 +1507,8 @@
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">init_metal</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">factories_to_place</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span><span style=\"font-weight: bold\">])</span>,\n",
                             "        <span style=\"color: #808000; text-decoration-color: #808000\">factory_strains</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">6</span><span style=\"font-weight: bold\">])</span>,\n",
-                            "        <span style=\"color: #808000; text-decoration-color: #808000\">n_factory</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span><span style=\"font-weight: bold\">])</span>\n",
+                            "        <span style=\"color: #808000; text-decoration-color: #808000\">n_factory</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span><span style=\"font-weight: bold\">])</span>,\n",
+                            "        <span style=\"color: #808000; text-decoration-color: #808000\">bid</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span><span style=\"font-weight: bold\">])</span>\n",
                             "    <span style=\"font-weight: bold\">)</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">global_id</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span><span style=\"font-weight: bold\">])</span>,\n",
                             "    <span style=\"color: #808000; text-decoration-color: #808000\">place_first</span>=<span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">torch</span><span style=\"color: #800080; text-decoration-color: #800080; font-weight: bold\">.Size</span><span style=\"font-weight: bold\">([</span><span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span><span style=\"font-weight: bold\">])</span>\n",
@@ -1530,7 +1519,7 @@
                             "\u001b[1;35mState\u001b[0m\u001b[1m(\u001b[0m\n",
                             "    \u001b[33menv_cfg\u001b[0m=\u001b[3;35mNone\u001b[0m,\n",
                             "    \u001b[33mseed\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "    \u001b[33mrng_state\u001b[0m=\u001b[3;35mNone\u001b[0m,\n",
+                            "    \u001b[33mrng_state\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33menv_steps\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mboard\u001b[0m=\u001b[1;35mBoard\u001b[0m\u001b[1m(\u001b[0m\n",
                             "        \u001b[33mseed\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
@@ -1587,7 +1576,8 @@
                             "        \u001b[33minit_metal\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mfactories_to_place\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "        \u001b[33mfactory_strains\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m, \u001b[1;36m2\u001b[0m, \u001b[1;36m6\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
-                            "        \u001b[33mn_factory\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
+                            "        \u001b[33mn_factory\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
+                            "        \u001b[33mbid\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m, \u001b[1;36m2\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
                             "    \u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mglobal_id\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m,\n",
                             "    \u001b[33mplace_first\u001b[0m=\u001b[1;35mtorch\u001b[0m\u001b[1;35m.Size\u001b[0m\u001b[1m(\u001b[0m\u001b[1m[\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1m]\u001b[0m\u001b[1m)\u001b[0m\n",
@@ -1599,19 +1589,17 @@
                 }
             ],
             "source": [
-                "import jux.torch\n",
-                "\n",
-                "# rng_state cannot be converted to torch\n",
                 "# remove env_cfg to reduce output size\n",
-                "torch_state = jax.tree_map(jux.torch.to_torch, states._replace(rng_state=None, env_cfg=None))\n",
+                "torch_state = states._replace(env_cfg=None).to_torch()\n",
                 "rich.print(jax.tree_map(lambda x: x.shape, torch_state))"
             ]
         },
         {
+            "attachments": {},
             "cell_type": "markdown",
             "metadata": {},
             "source": [
-                "You can also convert PyTorch tensors to JAX arrays by `jux.torch.from_torch`. Typical usage is to convert actions generated by PyTorch models to JAX arrays, so they can be feed into `JuxEnv.step_*()`."
+                "You can also convert between PyTorch tensors and JAX arrays by `jux.torch.from_torch` and `jux.torch.to_torch`. Typical usage is to convert actions generated by PyTorch models to JAX arrays, so they can be feed into `JuxEnv.step_*()`."
             ]
         },
         {
@@ -1632,10 +1620,31 @@
             ],
             "source": [
                 "import torch\n",
+                "import jux.torch\n",
                 "\n",
                 "jux.torch.from_torch(torch.arange(10))"
             ]
         },
+        {
+            "cell_type": "code",
+            "execution_count": 34,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], device='cuda:0', dtype=torch.int32)"
+                        ]
+                    },
+                    "execution_count": 34,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "jux.torch.to_torch(jnp.arange(10))"
+            ]
+        },
         {
             "cell_type": "markdown",
             "metadata": {},
@@ -1660,7 +1669,7 @@
             "name": "python",
             "nbconvert_exporter": "python",
             "pygments_lexer": "ipython3",
-            "version": "3.8.13 | packaged by conda-forge | (default, Mar 25 2022, 06:04:10) \n[GCC 10.3.0]"
+            "version": "3.8.13"
         },
         "orig_nbformat": 4,
         "vscode": {


Test patch:
diff --git a/tests/map_generator/test_generator.py b/tests/map_generator/test_generator.py
index 013f75e..b995dab 100644
--- a/tests/map_generator/test_generator.py
+++ b/tests/map_generator/test_generator.py
@@ -1,10 +1,13 @@
 import os
 
 import chex
+import jax
+import jax.numpy as jnp
 import numpy as np
 
 from jux.config import JuxBufferConfig
 from jux.map_generator.generator import GameMap, LuxGameMap, MapType
+from jux.map_generator.generator_config import MapDistributionType
 from jux.map_generator.symnoise import SymmetryType
 
 os.environ["XLA_PYTHON_CLIENT_MEM_FRACTION"] = "0.50"
@@ -34,7 +37,7 @@ def test_init(self):
         assert lux_game_map_eq(game_map.to_lux(), lux_game_map)
         assert game_map == GameMap.from_lux((game_map.to_lux()))
 
-    @chex.variants(with_jit=True, without_jit=True, with_device=True, without_device=True)
+    @chex.variants(with_jit=True, without_jit=True, with_device=True)
     def test_map(self):
         seed = 42
         map_type = MapType.MOUNTAIN
@@ -46,10 +49,22 @@ def test_map(self):
             GameMap.random_map,
             static_argnames=("width", "height"),
         )
+        key = jax.random.PRNGKey(seed)
+        key, subkey = jax.random.split(key)
+        map_distribution_type = jax.random.choice(
+            key=subkey,
+            a=jnp.array([
+                MapDistributionType.HIGH_ICE_HIGH_ORE,
+                MapDistributionType.HIGH_ICE_LOW_ORE,
+                MapDistributionType.LOW_ICE_HIGH_ORE,
+                MapDistributionType.LOW_ICE_LOW_ORE,
+            ]),
+        )
         map_grid = map_generator(
             seed=seed,
             map_type=map_type,
             symmetry=symmetry,
             width=width,
             height=height,
+            map_distribution_type=map_distribution_type,
         )
diff --git a/tests/state/test_state.py b/tests/state/test_state.py
index 14efe91..a77d189 100644
--- a/tests/state/test_state.py
+++ b/tests/state/test_state.py
@@ -25,7 +25,7 @@ class TestState(chex.TestCase):
 
     def test_from_to_lux(self):
         buf_cfg = JuxBufferConfig(MAX_N_UNITS=30)
-        env, actions = jux.utils.load_replay('tests/replay-45702251.json.gz')
+        env, actions = jux.utils.load_replay(f'https://www.kaggleusercontent.com/episodes/{46215591}.json')
         for i in range(10):
             action = next(actions)
             env.step(action)
@@ -42,7 +42,7 @@ def test_step_late_game(self):
 
         # 2. prepare an environment
         buf_cfg = JuxBufferConfig(MAX_N_UNITS=100)
-        env, actions = jux.utils.load_replay('tests/replay2.0_0.json.gz')
+        env, actions = jux.utils.load_replay(f'https://www.kaggleusercontent.com/episodes/{46215591}.json')
 
         # skip early stage
         while env.env_steps < 11:
@@ -84,7 +84,6 @@ def assert_state_eq(jux_state, lux_state):
         assert_state_eq(jux_state, lux_state)
 
     @chex.variants(with_jit=True, without_jit=True, with_device=True)
-    @pytest.mark.skip(reason="no way of currently testing this without v2.0.0 replay")
     def test_recharge_action(self):
         chex.clear_trace_counter()
 
@@ -94,7 +93,7 @@ def test_recharge_action(self):
         # 2. prepare an environment
         buf_cfg = JuxBufferConfig(MAX_N_UNITS=100)
 
-        env, actions = jux.utils.load_replay("https://www.kaggleusercontent.com/episodes/45885903.json")
+        env, actions = jux.utils.load_replay("https://www.kaggleusercontent.com/episodes/46215591.json")
 
         # skip first several steps, since it contains no recharge action
         while env.env_steps < 10 + 149:
@@ -132,7 +131,6 @@ def assert_state_eq(jux_state, lux_state):
             assert_state_eq(jux_state, lux_state)
 
     @chex.variants(with_jit=True, without_jit=True, with_device=True)
-    @pytest.mark.skip(reason="no way of currently testing this without v2.0.0 replay")
     def test_step_factory_water(self):
         chex.clear_trace_counter()
 
@@ -141,7 +139,7 @@ def test_step_factory_water(self):
 
         # 2. prepare an environment
         buf_cfg = JuxBufferConfig(MAX_N_UNITS=100)
-        env, actions = jux.utils.load_replay("https://www.kaggleusercontent.com/episodes/45885903.json")
+        env, actions = jux.utils.load_replay("https://www.kaggleusercontent.com/episodes/46215591.json")
         # The first 905 steps do not contains any FactoryAction.Water, so we skip them.
         while env.env_steps < 300:
             act = next(actions)
@@ -183,16 +181,14 @@ def assert_state_eq(jux_state, lux_state):
             else:
                 env.step(act)
 
-    @pytest.mark.skip(reason="no way of currently testing this without v2.0.0 replay")
     def test_episode(self):
         chex.clear_trace_counter()
         cases = [
             # Some steps are skipped because of bugs in the official one.
             # episode id and skip steps.
-            ('45885449', []),
-            ('45885731', []),
-            ('45885907', []),
-            ('45886082', []),
+            ('46215591', []),
+            ('46217254', []),
+            ('46217201', []),
         ]
         buf_cfg = JuxBufferConfig(MAX_N_UNITS=200)
 
@@ -240,9 +236,8 @@ def assert_state_eq(jux_state, lux_state):
                     jux_state, lux_state = step_both(jux_state, env, act)
             assert_state_eq(jux_state, lux_state)
 
-    @pytest.mark.skip(reason="no way of currently testing this without v2.0.0 replay")
     def test_team_lichen_score(self):
-        env, actions = jux.utils.load_replay("https://www.kaggleusercontent.com/episodes/45885903.json")
+        env, actions = jux.utils.load_replay("https://www.kaggleusercontent.com/episodes/46215591.json")
         for act in actions:
             _, lux_rewards, _, _ = env.step(act)
         lux_rewards = jnp.array(list(lux_rewards.values()))
diff --git a/tests/test_env.py b/tests/test_env.py
index 496bc3e..0bc0994 100644
--- a/tests/test_env.py
+++ b/tests/test_env.py
@@ -27,7 +27,7 @@ def test_new(self):
         assert state___eq___jitted(state1, state2)
 
     def test_step_bid_and_factory_placement(self):
-        lux_env, actions = jux.utils.load_replay(f'tests/replay2.0_0.json.gz')
+        lux_env, actions = jux.utils.load_replay(f'https://www.kaggleusercontent.com/episodes/{46215591}.json')
 
         buf_cfg = JuxBufferConfig(MAX_N_UNITS=200)
         jux_env, jux_state = JuxEnv.from_lux(lux_env, buf_cfg=buf_cfg)
@@ -78,13 +78,12 @@ def test_step_bid_and_factory_placement(self):
             assert jux_rewards[0] == lux_rewards['player_0']
             assert jux_rewards[1] == lux_rewards['player_1']
 
-    @pytest.mark.skip(reason="no way of currently testing this without v2.0.0 replay")
     def test_step_late_game(self):
         chex.clear_trace_counter()
         episode_list = [
-            '45740641',
-            '45885903',
-            '45750090',
+            '46215591',
+            '46217254',
+            '46217201',
         ]
         buf_cfg = JuxBufferConfig(MAX_N_UNITS=200)
         jux_env = JuxEnv(buf_cfg=buf_cfg)
@@ -151,9 +150,9 @@ def test_new(self):
     def test_step_bid_and_factory_placement(self):
         chex.clear_trace_counter()
         episode_list = [
-            '45740641',
-            '45885903',
-            '45750090',
+            '46215591',
+            '46217254',
+            '46217201',
         ]
         lux_env_list = []
         lux_actions_list = []