continual-foragax 0.30.1__py3-none-any.whl → 0.31.0__py3-none-any.whl

{continual_foragax-0.30.1.dist-info → continual_foragax-0.31.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: continual-foragax
-Version: 0.30.1
+Version: 0.31.0
 Summary: A continual reinforcement learning benchmark
 Author-email: Steven Tang <stang5@ualberta.ca>
 Requires-Python: >=3.8

{continual_foragax-0.30.1.dist-info → continual_foragax-0.31.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 foragax/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 foragax/colors.py,sha256=rqNPiywP4Nvr0POhsGpasRk-nMMTS3DOwFRUgperlUk,2065
-foragax/env.py,sha256=4NZ5JsUGjAepmzw2uxu5_ikyVZnZ7vazy062Xzx22Zg,27481
-foragax/objects.py,sha256=M0nECANGfUvvBRMKSS7akGtoO2Suv5eroI-9Aj326sw,10368
-foragax/registry.py,sha256=Dxg6cWIPwg91fNrCPxADJv35u6jFg_8dI5iTpCMFEFA,15229
+foragax/env.py,sha256=j7u8Xv8Fz4-GZU0SXXUP40Nz4NCvRrX02h9gl8PZMK4,32456
+foragax/objects.py,sha256=FBO0k4X6tKidWWsk6E-GotA9jXYXc8GXjZxNQJItvWI,14119
+foragax/registry.py,sha256=zF3RtW8ssWvnDKS31xJ_Ac9hP5sv8DWy4xBu4uCbHpQ,16060
 foragax/rendering.py,sha256=bms7wvBZTofoR-K-2QD2Ggeed7Viw8uwAEiEpEM3eSo,2768
 foragax/weather.py,sha256=KNAiwuFz8V__6G75vZIWQKPocLzXqxXn-Vt4TbHIpcA,1258
 foragax/data/ECA_non-blended_custom/TG_SOUID100897.txt,sha256=N7URbX6VlCZvCboUogYjMzy1I-0cfNPOn0QTLSHHfQ0,1776751
@@ -128,8 +128,8 @@ foragax/data/ECA_non-blended_custom/TG_SOUID156887.txt,sha256=juzTPgJoJxfqmZkorL
 foragax/data/ECA_non-blended_custom/elements.txt,sha256=OtcUBoDAHxuln79BPKGu0tsQxG_5G2BfAX3Ck130kEA,4507
 foragax/data/ECA_non-blended_custom/metadata.txt,sha256=nudnmOCy5cPJfSXt_IjyX0S5-T7NkCZREICZSimqeqc,48260
 foragax/data/ECA_non-blended_custom/sources.txt,sha256=1j3lSmINAoCMqPqFrHfZJriOz6sTYZNOhXzUwvTLas0,20857
-continual_foragax-0.30.1.dist-info/METADATA,sha256=9iwHDGT1ZbvjL_CNRFQRQsPBPWKTFBetxrJPk_OXKug,4897
-continual_foragax-0.30.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-continual_foragax-0.30.1.dist-info/entry_points.txt,sha256=Qiu6iE_XudrDO_bVAMeA435h4PO9ourt8huvSHiuMPc,41
-continual_foragax-0.30.1.dist-info/top_level.txt,sha256=-z3SDK6RfLIcLI24n8rdbeFzlVY3hunChzlu-v1Fncs,8
-continual_foragax-0.30.1.dist-info/RECORD,,
+continual_foragax-0.31.0.dist-info/METADATA,sha256=o5l0-uCkTUx4jEV9qc49cOagYlRcksIBUkumbbPde8U,4897
+continual_foragax-0.31.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+continual_foragax-0.31.0.dist-info/entry_points.txt,sha256=Qiu6iE_XudrDO_bVAMeA435h4PO9ourt8huvSHiuMPc,41
+continual_foragax-0.31.0.dist-info/top_level.txt,sha256=-z3SDK6RfLIcLI24n8rdbeFzlVY3hunChzlu-v1Fncs,8
+continual_foragax-0.31.0.dist-info/RECORD,,

foragax/env.py

@@ -62,6 +62,7 @@ class EnvState(environment.EnvState):
     biome_grid: jax.Array
     time: int
     digestion_buffer: jax.Array
+    object_spawn_time_grid: jax.Array
 
 
 class ForagaxEnv(environment.Environment):
@@ -114,6 +115,12 @@ class ForagaxEnv(environment.Environment):
         self.reward_fns = [o.reward for o in objects]
         self.regen_delay_fns = [o.regen_delay for o in objects]
         self.reward_delay_fns = [o.reward_delay for o in objects]
+        self.expiry_regen_delay_fns = [o.expiry_regen_delay for o in objects]
+
+        # Expiry times per object (None becomes -1 for no expiry)
+        self.object_expiry_time = jnp.array(
+            [o.expiry_time if o.expiry_time is not None else -1 for o in objects]
+        )
 
         # Compute reward steps per object (using max_reward_delay attribute)
         object_max_reward_delay = jnp.array([o.max_reward_delay for o in objects])
@@ -193,6 +200,47 @@ class ForagaxEnv(environment.Environment):
             max_steps_in_episode=None,
         )
 
+    def _place_timer_at_position(
+        self, grid: jax.Array, y: int, x: int, timer_val: int
+    ) -> jax.Array:
+        """Place a timer at a specific position."""
+        return grid.at[y, x].set(timer_val)
+
+    def _place_timer_at_random_position(
+        self,
+        grid: jax.Array,
+        y: int,
+        x: int,
+        timer_val: int,
+        biome_grid: jax.Array,
+        rand_key: jax.Array,
+    ) -> jax.Array:
+        """Place a timer at a random valid position within the same biome."""
+        # Set the original position to empty temporarily
+        grid_temp = grid.at[y, x].set(0)
+
+        # Find all valid spawn locations (empty cells within the same biome)
+        biome_id = biome_grid[y, x]
+        biome_mask = biome_grid == biome_id
+        empty_mask = grid_temp == 0
+        valid_spawn_mask = biome_mask & empty_mask
+
+        num_valid_spawns = jnp.sum(valid_spawn_mask)
+
+        # Get indices of valid spawn locations, padded to a static size
+        y_indices, x_indices = jnp.nonzero(
+            valid_spawn_mask, size=self.size[0] * self.size[1], fill_value=-1
+        )
+        valid_spawn_indices = jnp.stack([y_indices, x_indices], axis=1)
+
+        # Select a random valid location
+        random_idx = jax.random.randint(rand_key, (), 0, num_valid_spawns)
+        new_spawn_pos = valid_spawn_indices[random_idx]
+
+        # Place the timer at the new random position
+        new_grid = grid_temp.at[new_spawn_pos[0], new_spawn_pos[1]].set(timer_val)
+        return new_grid
+
     def step_env(
         self,
         key: jax.Array,
@@ -277,54 +325,129 @@ class ForagaxEnv(environment.Environment):
             is_timer, state.object_grid + num_obj_types, state.object_grid
         )
 
+        # Track which objects just respawned (timer -> object transition)
+        # An object respawned if it was negative and is now positive
+        just_respawned = is_timer & (object_grid > 0)
+
+        # Update spawn times for objects that just respawned
+        object_spawn_time_grid = jnp.where(
+            just_respawned, state.time, state.object_spawn_time_grid
+        )
+
         # Collect object: set a timer
         regen_delay = jax.lax.switch(
             obj_at_pos, self.regen_delay_fns, state.time, regen_subkey
         )
         encoded_timer = obj_at_pos - ((regen_delay + 1) * num_obj_types)
 
-        def place_at_current_pos(current_grid, timer_val):
-            return current_grid.at[pos[1], pos[0]].set(timer_val)
-
-        def place_at_random_pos(current_grid, timer_val):
-            # Set the collected position to empty temporarily
-            grid = current_grid.at[pos[1], pos[0]].set(0)
-
-            # Find all valid spawn locations (empty cells within the same biome)
-            biome_id = state.biome_grid[pos[1], pos[0]]
-            biome_mask = state.biome_grid == biome_id
-            empty_mask = grid == 0
-            valid_spawn_mask = biome_mask & empty_mask
-
-            num_valid_spawns = jnp.sum(valid_spawn_mask)
-
-            # Get indices of valid spawn locations, padded to a static size
-            y_indices, x_indices = jnp.nonzero(
-                valid_spawn_mask, size=self.size[0] * self.size[1], fill_value=-1
-            )
-            valid_spawn_indices = jnp.stack([y_indices, x_indices], axis=1)
-
-            # Select a random valid location
-            random_idx = jax.random.randint(rand_key, (), 0, num_valid_spawns)
-            new_spawn_pos = valid_spawn_indices[random_idx]
-
-            # Place the timer at the new random position
-            return grid.at[new_spawn_pos[0], new_spawn_pos[1]].set(timer_val)
-
         # If collected, replace object with timer; otherwise, keep it
         val_at_pos = object_grid[pos[1], pos[0]]
         should_collect = is_collectable & (val_at_pos > 0)
 
         # When not collecting, the value at the position remains unchanged.
         # When collecting, we either place the timer at the current position or a random one.
+        def do_collection():
+            return jax.lax.cond(
+                self.object_random_respawn[obj_at_pos],
+                lambda: self._place_timer_at_random_position(
+                    object_grid,
+                    pos[1],
+                    pos[0],
+                    encoded_timer,
+                    state.biome_grid,
+                    rand_key,
+                ),
+                lambda: self._place_timer_at_position(
+                    object_grid, pos[1], pos[0], encoded_timer
+                ),
+            )
+
+        def no_collection():
+            return object_grid
+
         object_grid = jax.lax.cond(
             should_collect,
-            lambda: jax.lax.cond(
-                self.object_random_respawn[obj_at_pos],
-                lambda: place_at_random_pos(object_grid, encoded_timer),
-                lambda: place_at_current_pos(object_grid, encoded_timer),
-            ),
-            lambda: object_grid,
+            do_collection,
+            no_collection,
+        )
+
+        # 3.5. HANDLE OBJECT EXPIRY
+        # Check each cell for objects that have exceeded their expiry time
+        current_objects_for_expiry = jnp.maximum(0, object_grid)
+
+        # Calculate age of each object (current_time - spawn_time)
+        object_ages = state.time - object_spawn_time_grid
+
+        # Get expiry time for each object type in the grid
+        expiry_times = self.object_expiry_time[current_objects_for_expiry]
+
+        # Check if object should expire (age >= expiry_time and expiry_time >= 0)
+        should_expire = (
+            (object_ages >= expiry_times)
+            & (expiry_times >= 0)
+            & (current_objects_for_expiry > 0)
+        )
+
+        # For expired objects, calculate expiry regen delay
+        key, expiry_key = jax.random.split(key)
+
+        # Process expiry for all positions that need it
+        def process_expiry(y, x, grid, spawn_grid, key):
+            obj_id = current_objects_for_expiry[y, x]
+            should_exp = should_expire[y, x]
+
+            def expire_object():
+                # Get expiry regen delay for this object
+                exp_key = jax.random.fold_in(key, y * self.size[0] + x)
+                exp_delay = jax.lax.switch(
+                    obj_id, self.expiry_regen_delay_fns, state.time, exp_key
+                )
+                encoded_exp_timer = obj_id - ((exp_delay + 1) * num_obj_types)
+
+                # Check if this object should respawn randomly
+                should_random_respawn = self.object_random_respawn[obj_id]
+
+                # Use second split for randomness in random placement
+                rand_key = jax.random.split(exp_key)[1]
+
+                # Place timer either at current position or random position
+                new_grid = jax.lax.cond(
+                    should_random_respawn,
+                    lambda: self._place_timer_at_random_position(
+                        grid, y, x, encoded_exp_timer, state.biome_grid, rand_key
+                    ),
+                    lambda: self._place_timer_at_position(
+                        grid, y, x, encoded_exp_timer
+                    ),
+                )
+
+                return new_grid, spawn_grid
+
+            def no_expire():
+                return grid, spawn_grid
+
+            return jax.lax.cond(should_exp, expire_object, no_expire)
+
+        # Apply expiry to all cells (vectorized)
+        def scan_expiry_row(carry, y):
+            grid, spawn_grid, key = carry
+
+            def scan_expiry_col(carry_col, x):
+                grid_col, spawn_grid_col, key_col = carry_col
+                grid_col, spawn_grid_col = process_expiry(
+                    y, x, grid_col, spawn_grid_col, key_col
+                )
+                return (grid_col, spawn_grid_col, key_col), None
+
+            (grid, spawn_grid, key), _ = jax.lax.scan(
+                scan_expiry_col, (grid, spawn_grid, key), jnp.arange(self.size[0])
+            )
+            return (grid, spawn_grid, key), None
+
+        (object_grid, object_spawn_time_grid, _), _ = jax.lax.scan(
+            scan_expiry_row,
+            (object_grid, object_spawn_time_grid, expiry_key),
+            jnp.arange(self.size[1]),
         )
 
         info = {"discount": self.discount(state, params)}
@@ -345,6 +468,7 @@ class ForagaxEnv(environment.Environment):
             biome_grid=state.biome_grid,
             time=state.time + 1,
             digestion_buffer=digestion_buffer,
+            object_spawn_time_grid=object_spawn_time_grid,
         )
 
         done = self.is_terminal(state, params)
@@ -378,12 +502,16 @@ class ForagaxEnv(environment.Environment):
         # Place agent in the center of the world
         agent_pos = jnp.array([self.size[0] // 2, self.size[1] // 2])
 
+        # Initialize spawn times to 0 (all objects spawn at time 0)
+        object_spawn_time_grid = jnp.zeros((self.size[1], self.size[0]), dtype=int)
+
         state = EnvState(
             pos=agent_pos,
             object_grid=object_grid,
             biome_grid=biome_grid,
             time=0,
             digestion_buffer=jnp.zeros((self.max_reward_delay,)),
+            object_spawn_time_grid=object_spawn_time_grid,
         )
 
         return self.get_obs(state, params), state
@@ -450,6 +578,12 @@ class ForagaxEnv(environment.Environment):
                     (self.max_reward_delay,),
                     float,
                 ),
+                "object_spawn_time_grid": spaces.Box(
+                    0,
+                    jnp.inf,
+                    (self.size[1], self.size[0]),
+                    int,
+                ),
             }
         )
 

foragax/objects.py

@@ -18,6 +18,7 @@ class BaseForagaxObject:
         color: Tuple[int, int, int] = (0, 0, 0),
         random_respawn: bool = False,
         max_reward_delay: int = 0,
+        expiry_time: Optional[int] = None,
     ):
         self.name = name
         self.blocking = blocking
@@ -25,6 +26,7 @@ class BaseForagaxObject:
         self.color = color
         self.random_respawn = random_respawn
         self.max_reward_delay = max_reward_delay
+        self.expiry_time = expiry_time
 
     @abc.abstractmethod
     def reward(self, clock: int, rng: jax.Array) -> float:
@@ -36,6 +38,11 @@ class BaseForagaxObject:
         """Reward delay function."""
         raise NotImplementedError
 
+    @abc.abstractmethod
+    def expiry_regen_delay(self, clock: int, rng: jax.Array) -> int:
+        """Expiry regeneration delay function."""
+        raise NotImplementedError
+
 
 class DefaultForagaxObject(BaseForagaxObject):
     """Base class for default objects in the Foragax environment."""
@@ -51,15 +58,24 @@ class DefaultForagaxObject(BaseForagaxObject):
         random_respawn: bool = False,
         reward_delay: int = 0,
         max_reward_delay: Optional[int] = None,
+        expiry_time: Optional[int] = None,
+        expiry_regen_delay: Tuple[int, int] = (10, 100),
     ):
         if max_reward_delay is None:
             max_reward_delay = reward_delay
         super().__init__(
-            name, blocking, collectable, color, random_respawn, max_reward_delay
+            name,
+            blocking,
+            collectable,
+            color,
+            random_respawn,
+            max_reward_delay,
+            expiry_time,
         )
         self.reward_val = reward
         self.regen_delay_range = regen_delay
         self.reward_delay_val = reward_delay
+        self.expiry_regen_delay_range = expiry_regen_delay
 
     def reward(self, clock: int, rng: jax.Array) -> float:
         """Default reward function."""
@@ -74,6 +90,11 @@ class DefaultForagaxObject(BaseForagaxObject):
         """Default reward delay function."""
         return self.reward_delay_val
 
+    def expiry_regen_delay(self, clock: int, rng: jax.Array) -> int:
+        """Default expiry regeneration delay function."""
+        min_delay, max_delay = self.expiry_regen_delay_range
+        return jax.random.randint(rng, (), min_delay, max_delay)
+
 
 class NormalRegenForagaxObject(DefaultForagaxObject):
     """Object with regeneration delay from a normal distribution."""
@@ -89,7 +110,16 @@ class NormalRegenForagaxObject(DefaultForagaxObject):
         random_respawn: bool = False,
         reward_delay: int = 0,
         max_reward_delay: Optional[int] = None,
+        expiry_time: Optional[int] = None,
+        mean_expiry_regen_delay: Optional[int] = None,
+        std_expiry_regen_delay: Optional[int] = None,
     ):
+        # If expiry regen delays not provided, use same as normal regen
+        if mean_expiry_regen_delay is None:
+            mean_expiry_regen_delay = mean_regen_delay
+        if std_expiry_regen_delay is None:
+            std_expiry_regen_delay = std_regen_delay
+
         super().__init__(
             name=name,
             reward=reward,
@@ -99,15 +129,27 @@ class NormalRegenForagaxObject(DefaultForagaxObject):
             random_respawn=random_respawn,
             reward_delay=reward_delay,
             max_reward_delay=max_reward_delay,
+            expiry_time=expiry_time,
+            expiry_regen_delay=(mean_expiry_regen_delay, mean_expiry_regen_delay),
         )
         self.mean_regen_delay = mean_regen_delay
         self.std_regen_delay = std_regen_delay
+        self.mean_expiry_regen_delay = mean_expiry_regen_delay
+        self.std_expiry_regen_delay = std_expiry_regen_delay
 
     def regen_delay(self, clock: int, rng: jax.Array) -> int:
         """Regeneration delay from a normal distribution."""
         delay = self.mean_regen_delay + jax.random.normal(rng) * self.std_regen_delay
         return jnp.maximum(0, delay).astype(int)
 
+    def expiry_regen_delay(self, clock: int, rng: jax.Array) -> int:
+        """Expiry regeneration delay from a normal distribution."""
+        delay = (
+            self.mean_expiry_regen_delay
+            + jax.random.normal(rng) * self.std_expiry_regen_delay
+        )
+        return jnp.maximum(0, delay).astype(int)
+
 
 class WeatherObject(NormalRegenForagaxObject):
     """Object with reward based on temperature data."""
@@ -124,6 +166,9 @@ class WeatherObject(NormalRegenForagaxObject):
         random_respawn: bool = False,
         reward_delay: int = 0,
         max_reward_delay: Optional[int] = None,
+        expiry_time: Optional[int] = None,
+        mean_expiry_regen_delay: Optional[int] = None,
+        std_expiry_regen_delay: Optional[int] = None,
     ):
         super().__init__(
             name=name,
@@ -134,6 +179,9 @@ class WeatherObject(NormalRegenForagaxObject):
             random_respawn=random_respawn,
             reward_delay=reward_delay,
             max_reward_delay=max_reward_delay,
+            expiry_time=expiry_time,
+            mean_expiry_regen_delay=mean_expiry_regen_delay,
+            std_expiry_regen_delay=std_expiry_regen_delay,
         )
         self.rewards = rewards * multiplier
         self.repeat = repeat
@@ -332,6 +380,44 @@ GREEN_FAKE_UNIFORM_RANDOM = DefaultForagaxObject(
     random_respawn=True,
 )
 
+# Random respawn variants with expiry
+BROWN_MOREL_UNIFORM_RANDOM_EXPIRY = DefaultForagaxObject(
+    name="brown_morel",
+    reward=10.0,
+    collectable=True,
+    color=(63, 30, 25),
+    regen_delay=(90, 110),
+    random_respawn=True,
+    expiry_time=500,
+)
+BROWN_OYSTER_UNIFORM_RANDOM_EXPIRY = DefaultForagaxObject(
+    name="brown_oyster",
+    reward=1.0,
+    collectable=True,
+    color=(63, 30, 25),
+    regen_delay=(9, 11),
+    random_respawn=True,
+    expiry_time=500,
+)
+GREEN_DEATHCAP_UNIFORM_RANDOM_EXPIRY = DefaultForagaxObject(
+    name="green_deathcap",
+    reward=-5.0,
+    collectable=True,
+    color=(0, 255, 0),
+    regen_delay=(9, 11),
+    random_respawn=True,
+    expiry_time=500,
+)
+GREEN_FAKE_UNIFORM_RANDOM_EXPIRY = DefaultForagaxObject(
+    name="green_fake",
+    reward=0.0,
+    collectable=True,
+    color=(0, 255, 0),
+    regen_delay=(9, 11),
+    random_respawn=True,
+    expiry_time=500,
+)
+
 
 def create_weather_objects(
     file_index: int = 0,
@@ -340,6 +426,9 @@ def create_weather_objects(
     same_color: bool = False,
     random_respawn: bool = False,
     reward_delay: int = 0,
+    expiry_time: Optional[int] = None,
+    mean_expiry_regen_delay: Optional[int] = None,
+    std_expiry_regen_delay: Optional[int] = None,
 ):
     """Create HOT and COLD WeatherObject instances using the specified file.
 
@@ -348,6 +437,11 @@ def create_weather_objects(
         repeat: How many steps each temperature value repeats for.
         multiplier: Base multiplier applied to HOT; COLD will use -multiplier.
         same_color: If True, both HOT and COLD use the same color.
+        random_respawn: If True, objects respawn at random locations.
+        reward_delay: Number of steps before reward is delivered.
+        expiry_time: Time steps before object expires (None = no expiry).
+        mean_expiry_regen_delay: Mean delay for expiry respawn.
+        std_expiry_regen_delay: Standard deviation for expiry respawn delay.
 
     Returns:
         A tuple (HOT, COLD) of WeatherObject instances.
@@ -370,6 +464,9 @@ def create_weather_objects(
         color=hot_color,
         random_respawn=random_respawn,
         reward_delay=reward_delay,
+        expiry_time=expiry_time,
+        mean_expiry_regen_delay=mean_expiry_regen_delay,
+        std_expiry_regen_delay=std_expiry_regen_delay,
     )
 
     cold_color = hot_color if same_color else (0, 255, 255)
@@ -381,6 +478,9 @@ def create_weather_objects(
         color=cold_color,
         random_respawn=random_respawn,
         reward_delay=reward_delay,
+        expiry_time=expiry_time,
+        mean_expiry_regen_delay=mean_expiry_regen_delay,
+        std_expiry_regen_delay=std_expiry_regen_delay,
     )
 
     return hot, cold

foragax/registry.py

@@ -12,18 +12,22 @@ from foragax.objects import (
     BROWN_MOREL_2,
     BROWN_MOREL_UNIFORM,
     BROWN_MOREL_UNIFORM_RANDOM,
+    BROWN_MOREL_UNIFORM_RANDOM_EXPIRY,
     BROWN_OYSTER,
     BROWN_OYSTER_UNIFORM,
     BROWN_OYSTER_UNIFORM_RANDOM,
+    BROWN_OYSTER_UNIFORM_RANDOM_EXPIRY,
     GREEN_DEATHCAP,
     GREEN_DEATHCAP_2,
     GREEN_DEATHCAP_3,
     GREEN_DEATHCAP_UNIFORM,
     GREEN_DEATHCAP_UNIFORM_RANDOM,
+    GREEN_DEATHCAP_UNIFORM_RANDOM_EXPIRY,
     GREEN_FAKE,
     GREEN_FAKE_2,
     GREEN_FAKE_UNIFORM,
     GREEN_FAKE_UNIFORM_RANDOM,
+    GREEN_FAKE_UNIFORM_RANDOM_EXPIRY,
     LARGE_MOREL,
     LARGE_OYSTER,
     MEDIUM_MOREL,
@@ -304,6 +308,26 @@ ENV_CONFIGS: Dict[str, Dict[str, Any]] = {
         "nowrap": True,
         "deterministic_spawn": True,
     },
+    "ForagaxTwoBiome-v17": {
+        "size": (15, 15),
+        "aperture_size": None,
+        "objects": (
+            BROWN_MOREL_UNIFORM_RANDOM_EXPIRY,
+            BROWN_OYSTER_UNIFORM_RANDOM_EXPIRY,
+            GREEN_DEATHCAP_UNIFORM_RANDOM_EXPIRY,
+            GREEN_FAKE_UNIFORM_RANDOM_EXPIRY,
+        ),
+        "biomes": (
+            # Morel biome
+            Biome(start=(3, 0), stop=(5, 15), object_frequencies=(0.25, 0.0, 0.5, 0.0)),
+            # Oyster biome
+            Biome(
+                start=(10, 0), stop=(12, 15), object_frequencies=(0.0, 0.25, 0.0, 0.5)
+            ),
+        ),
+        "nowrap": False,
+        "deterministic_spawn": True,
+    },
     "ForagaxTwoBiomeSmall-v1": {
         "size": (16, 8),
         "aperture_size": None,