synth-ai 0.2.9.dev11__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/environments/examples/crafter_classic/world_config_patch_simple.py

@@ -1,299 +0,0 @@
-"""
-Simplified monkey patch for configurable world generation in crafter.
-This version modifies generation parameters rather than rewriting functions.
-"""
-
-import json
-import os
-from typing import Any, Dict, Optional
-
-import crafter
-
-print("[PATCH] Attempting to apply simplified Crafter world configuration patch...")
-
-# World configuration presets
-WORLD_CONFIGS = {
-    "easy": {
-        "name": "Easy Mode",
-        "description": "More resources, fewer enemies",
-        # Modify spawn probabilities by multiplying original values
-        "spawn_multipliers": {
-            "tree": 1.5,  # 50% more trees
-            "coal": 1.5,  # 50% more coal
-            "iron": 1.5,  # 50% more iron
-            "diamond": 3.0,  # 3x more diamonds
-            "cow": 2.0,  # 2x more cows
-            "zombie": 0.3,  # 70% fewer zombies
-            "skeleton": 0.2,  # 80% fewer skeletons
-        },
-        # Modify spawn distances
-        "spawn_distances": {
-            "zombie": 15,  # Farther away (default 10)
-            "skeleton": 10,  # Farther away (default varies)
-            "cow": 2,  # Closer (default 3)
-        },
-    },
-    "normal": {
-        "name": "Normal Mode",
-        "description": "Standard crafter experience",
-        "spawn_multipliers": {
-            "tree": 1.0,
-            "coal": 1.0,
-            "iron": 1.0,
-            "diamond": 1.0,
-            "cow": 1.0,
-            "zombie": 1.0,
-            "skeleton": 1.0,
-        },
-        "spawn_distances": {"zombie": 10, "skeleton": 7, "cow": 3},
-    },
-    "hard": {
-        "name": "Hard Mode",
-        "description": "Fewer resources, more enemies",
-        "spawn_multipliers": {
-            "tree": 0.5,  # 50% fewer trees
-            "coal": 0.5,  # 50% less coal
-            "iron": 0.5,  # 50% less iron
-            "diamond": 0.3,  # 70% fewer diamonds
-            "cow": 0.3,  # 70% fewer cows
-            "zombie": 3.0,  # 3x more zombies
-            "skeleton": 3.0,  # 3x more skeletons
-        },
-        "spawn_distances": {
-            "zombie": 5,  # Much closer
-            "skeleton": 4,  # Much closer
-            "cow": 8,  # Farther away
-        },
-    },
-    "peaceful": {
-        "name": "Peaceful Mode",
-        "description": "No enemies, more resources",
-        "spawn_multipliers": {
-            "tree": 2.0,
-            "coal": 2.0,
-            "iron": 2.0,
-            "diamond": 5.0,
-            "cow": 3.0,
-            "zombie": 0.0,  # No zombies
-            "skeleton": 0.0,  # No skeletons
-        },
-        "spawn_distances": {"zombie": 100, "skeleton": 100, "cow": 1},
-    },
-}
-
-# Store active configuration
-_active_config = WORLD_CONFIGS["normal"]
-_original_balance_chunk = None
-_last_loaded_config = None  # Track what was last loaded to avoid duplicate prints
-
-
-def load_world_config(
-    config_name: str = "normal", config_path: Optional[str] = None
-) -> Dict[str, Any]:
-    """Load world configuration."""
-    global _active_config, _last_loaded_config
-
-    # Create a config identifier
-    config_id = config_path if config_path else config_name
-
-    # Only print if configuration actually changed
-    if _last_loaded_config != config_id:
-        if config_path and os.path.exists(config_path):
-            with open(config_path, "r") as f:
-                _active_config = json.load(f)
-            # print(f"[PATCH] Loaded custom world config from {config_path}")
-        elif config_name in WORLD_CONFIGS:
-            _active_config = WORLD_CONFIGS[config_name]
-            # print(f"[PATCH] Loaded '{config_name}' world configuration")
-        else:
-            _active_config = WORLD_CONFIGS["normal"]
-            # print(f"[PATCH] Unknown config '{config_name}', using 'normal'")
-
-        _last_loaded_config = config_id
-    else:
-        # Configuration hasn't changed, just return the active one
-        if config_path and os.path.exists(config_path):
-            with open(config_path, "r") as f:
-                _active_config = json.load(f)
-        elif config_name in WORLD_CONFIGS:
-            _active_config = WORLD_CONFIGS[config_name]
-        else:
-            _active_config = WORLD_CONFIGS["normal"]
-
-    return _active_config
-
-
-# Patch world generation to use configuration
-original_generate_world = crafter.worldgen.generate_world
-
-
-def patched_generate_world(world, player):
-    """Patched world generation that applies spawn multipliers."""
-    # Apply configuration without modifying numpy RandomState
-    multipliers = _active_config.get("spawn_multipliers", {})
-    distances = _active_config.get("spawn_distances", {})
-
-    # Call original generation first
-    result = original_generate_world(world, player)
-
-    # Post-process to adjust spawns based on multipliers
-    # This is a simpler approach that modifies objects after generation
-    if multipliers:
-        # Remove some objects based on multipliers < 1.0
-        objects_to_remove = []
-        for obj in world._objects:
-            if obj is None or obj is player:
-                continue
-
-            obj_type = type(obj).__name__.lower()
-
-            # Check if we should remove this object based on multiplier
-            multiplier = 1.0
-            if "tree" in obj_type or hasattr(obj, "kind") and getattr(obj, "kind") == "tree":
-                multiplier = multipliers.get("tree", 1.0)
-            elif "cow" in obj_type:
-                multiplier = multipliers.get("cow", 1.0)
-            elif "zombie" in obj_type:
-                multiplier = multipliers.get("zombie", 1.0)
-            elif "skeleton" in obj_type:
-                multiplier = multipliers.get("skeleton", 1.0)
-
-            # Remove objects if multiplier < 1.0
-            if multiplier < 1.0 and world.random.random() > multiplier:
-                objects_to_remove.append(obj)
-
-        # Remove marked objects
-        for obj in objects_to_remove:
-            world.remove(obj)
-
-        # Add extra objects if multiplier > 1.0
-        # (This is more complex and would require spawning new objects)
-
-    # Post-process to adjust spawn distances
-    if distances:
-        # Adjust initial enemy positions based on distance config
-        for obj in list(world._objects):
-            if obj is None:
-                continue
-
-            obj_type = type(obj).__name__.lower()
-            if obj_type in distances:
-                min_dist = distances[obj_type]
-                player_pos = player.pos
-                obj_pos = obj.pos
-                dist = abs(obj_pos[0] - player_pos[0]) + abs(obj_pos[1] - player_pos[1])
-
-                if dist < min_dist:
-                    # Remove objects too close to player
-                    world.remove(obj)
-
-    return result
-
-
-# Patch the balance function for dynamic spawning
-def patched_balance_chunk(self, chunk, objs=None):
-    """Patched chunk balancing with config support."""
-    global _original_balance_chunk
-    if _original_balance_chunk is None:
-        return
-
-    multipliers = _active_config.get("spawn_multipliers", {})
-    distances = _active_config.get("spawn_distances", {})
-
-    # Call original balance function with objs parameter
-    if objs is not None:
-        _original_balance_chunk(self, chunk, objs)
-    else:
-        _original_balance_chunk(self, chunk)
-
-    # Post-process spawned objects based on multipliers
-    # Check if any new objects were spawned and adjust them
-    if multipliers:
-        # Get the chunk bounds
-        chunk_x = chunk[0] * self._world._chunk_size
-        chunk_y = chunk[1] * self._world._chunk_size
-        chunk_w = self._world._chunk_size
-        chunk_h = self._world._chunk_size
-
-        objects_to_remove = []
-        for obj in self._world._objects:
-            if obj is None:
-                continue
-
-            # Check if object is in this chunk
-            try:
-                pos_x, pos_y = obj.pos[0], obj.pos[1]
-                if chunk_x <= pos_x < chunk_x + chunk_w and chunk_y <= pos_y < chunk_y + chunk_h:
-                    obj_type = type(obj).__name__.lower()
-                    multiplier = 1.0
-
-                    if "zombie" in obj_type:
-                        multiplier = multipliers.get("zombie", 1.0)
-                    elif "skeleton" in obj_type:
-                        multiplier = multipliers.get("skeleton", 1.0)
-                    elif "cow" in obj_type:
-                        multiplier = multipliers.get("cow", 1.0)
-
-                    # Remove objects based on multiplier
-                    if multiplier < 1.0 and self._world.random.random() > multiplier:
-                        objects_to_remove.append(obj)
-            except (ValueError, AttributeError):
-                # Skip objects with invalid position data
-                continue
-
-        # Remove marked objects
-        for obj in objects_to_remove:
-            self._world.remove(obj)
-
-
-# Apply patches
-crafter.worldgen.generate_world = patched_generate_world
-
-# Store original balance_chunk
-_original_balance_chunk = crafter.Env._balance_chunk
-crafter.Env._balance_chunk = patched_balance_chunk
-
-# Extend Env.__init__ to accept world_config
-original_env_init = crafter.Env.__init__
-
-
-def patched_env_init(
-    self,
-    area=(64, 64),
-    view=(9, 9),
-    length=10000,
-    seed=None,
-    world_config="normal",
-    world_config_path=None,
-):
-    """Extended Env.__init__ that accepts world configuration."""
-    # Load configuration
-    load_world_config(world_config, world_config_path)
-
-    # Call original init
-    original_env_init(self, area=area, view=view, length=length, seed=seed)
-
-    # Store config name
-    self._world_config_name = world_config if not world_config_path else "custom"
-
-
-crafter.Env.__init__ = patched_env_init
-
-print("[PATCH] Simplified Crafter world configuration patch complete.")
-print("[PATCH] Available configs: easy, normal, hard, peaceful")
-
-# Example custom config
-EXAMPLE_CUSTOM_CONFIG = {
-    "name": "Custom Config",
-    "description": "My custom world",
-    "spawn_multipliers": {
-        "tree": 1.2,
-        "coal": 1.3,
-        "iron": 1.4,
-        "diamond": 2.0,
-        "cow": 1.5,
-        "zombie": 0.5,
-        "skeleton": 0.5,
-    },
-    "spawn_distances": {"zombie": 12, "skeleton": 8, "cow": 4},
-}

synth_ai/environments/examples/crafter_custom/__init__.py

@@ -1,4 +0,0 @@
-"""Custom Crafter environments with configurable world generation."""
-
-# Note: Registration happens in the service app.py file
-# This module just provides the CrafterCustomEnvironment class

synth_ai/environments/examples/crafter_custom/agent_demos/__init__.py

@@ -1 +0,0 @@
-"""Agent demonstrations for custom Crafter environments."""

synth_ai/environments/examples/crafter_custom/agent_demos/trace_eval.py

@@ -1,202 +0,0 @@
-#!/usr/bin/env python3
-"""
-Trace evaluation functions for Crafter episodes.
-Scores traces based on achievements and invalid actions.
-"""
-
-import json
-from collections import defaultdict
-from pathlib import Path
-from typing import Any, Dict, List, Tuple
-
-# Scoring weights
-WEIGHTS = {
-    'easy_achievement': 1.0,      # Easy achievement (e.g., collect_wood)
-    'medium_achievement': 2.5,    # Medium achievement (e.g., make_wood_pickaxe)
-    'hard_achievement': 5.0,      # Hard achievement (e.g., make_iron_sword)
-    'invalid_action': -0.05,      # Invalid action penalty (50 invalid = -1 medium achievement)
-}
-
-# Map hook names to scoring categories
-HOOK_TO_SCORE_TYPE = {
-    'easy_achievement': 'easy_achievement',
-    'medium_achievement': 'medium_achievement', 
-    'hard_achievement': 'hard_achievement',
-    'invalid_action': 'invalid_action'
-}
-
-
-def evaluate_event(event: Dict[str, Any]) -> Tuple[float, str]:
-    """
-    Evaluate a single event based on its hooks.
-    Returns: (score, symbol) where symbol is '+', '-', or '0'
-    """
-    score = 0.0
-    symbol = '0'
-    
-    # Check if event has metadata from hooks
-    event_metadata = event.get('event_metadata', [])
-    
-    for metadata in event_metadata:
-        hook_name = metadata.get('hook_name', '')
-        
-        if hook_name in HOOK_TO_SCORE_TYPE:
-            score_type = HOOK_TO_SCORE_TYPE[hook_name]
-            weight = WEIGHTS[score_type]
-            score += weight
-            
-            # Determine symbol
-            if weight > 0:
-                symbol = '+'
-            elif weight < 0:
-                symbol = '-'
-    
-    return score, symbol
-
-
-def evaluate_trace(trace_path: Path) -> Dict[str, Any]:
-    """
-    Evaluate an entire trace file.
-    Returns detailed scoring breakdown and trajectory visualization.
-    """
-    with open(trace_path, 'r') as f:
-        trace_data = json.load(f)
-    
-    # Track counts
-    counts = defaultdict(int)
-    total_score = 0.0
-    trajectory_symbols = []
-    
-    # Process event history
-    event_history = trace_data.get('event_history', [])
-    
-    for event in event_history:
-        event_score, symbol = evaluate_event(event)
-        total_score += event_score
-        
-        # Only add symbol if score is non-zero
-        if event_score != 0:
-            trajectory_symbols.append(symbol)
-        
-        # Count hook types
-        for metadata in event.get('event_metadata', []):
-            hook_name = metadata.get('hook_name', '')
-            if hook_name in HOOK_TO_SCORE_TYPE:
-                score_type = HOOK_TO_SCORE_TYPE[hook_name]
-                counts[score_type] += 1
-    
-    # Create trajectory string
-    trajectory_str = ''.join(trajectory_symbols) if trajectory_symbols else '(no scored events)'
-    
-    return {
-        'total_score': total_score,
-        'counts': dict(counts),
-        'trajectory': trajectory_str,
-        'num_events': len(event_history),
-        'trace_file': trace_path.name
-    }
-
-
-def print_trace_evaluation(eval_result: Dict[str, Any]):
-    """Print a formatted evaluation result for a single trace."""
-    print(f"\n📊 Trace: {eval_result['trace_file']}")
-    print(f"   Score: {eval_result['total_score']:.2f}")
-    print(f"   Events: {eval_result['num_events']}")
-    
-    counts = eval_result['counts']
-    if counts:
-        print("   Breakdown:")
-        if 'easy_achievement' in counts:
-            print(f"     Easy achievements: {counts['easy_achievement']} × {WEIGHTS['easy_achievement']} = {counts['easy_achievement'] * WEIGHTS['easy_achievement']:.2f}")
-        if 'medium_achievement' in counts:
-            print(f"     Medium achievements: {counts['medium_achievement']} × {WEIGHTS['medium_achievement']} = {counts['medium_achievement'] * WEIGHTS['medium_achievement']:.2f}")
-        if 'hard_achievement' in counts:
-            print(f"     Hard achievements: {counts['hard_achievement']} × {WEIGHTS['hard_achievement']} = {counts['hard_achievement'] * WEIGHTS['hard_achievement']:.2f}")
-        if 'invalid_action' in counts:
-            print(f"     Invalid actions: {counts['invalid_action']} × {WEIGHTS['invalid_action']} = {counts['invalid_action'] * WEIGHTS['invalid_action']:.2f}")
-    
-    print(f"   Trajectory: {eval_result['trajectory']}")
-
-
-def evaluate_all_traces(trace_dir: Path, pattern: str = "*.json") -> List[Dict[str, Any]]:
-    """
-    Evaluate all trace files in a directory.
-    Returns list of evaluation results sorted by score.
-    """
-    trace_files = list(trace_dir.glob(pattern))
-    results = []
-    
-    for trace_file in trace_files:
-        try:
-            result = evaluate_trace(trace_file)
-            results.append(result)
-        except Exception as e:
-            print(f"⚠️  Error evaluating {trace_file.name}: {e}")
-    
-    # Sort by score (descending)
-    results.sort(key=lambda x: x['total_score'], reverse=True)
-    
-    return results
-
-
-def print_evaluation_summary(results: List[Dict[str, Any]]):
-    """Print a summary of all trace evaluations."""
-    if not results:
-        print("No traces to evaluate.")
-        return
-    
-    print("\n" + "=" * 80)
-    print("📈 TRACE EVALUATION SUMMARY")
-    print("=" * 80)
-    print(f"{'Rank':<6} {'Score':<10} {'Trajectory':<50} {'File':<30}")
-    print("-" * 80)
-    
-    for i, result in enumerate(results, 1):
-        trajectory = result['trajectory']
-        if len(trajectory) > 50:
-            trajectory = trajectory[:47] + "..."
-        print(f"{i:<6} {result['total_score']:<10.2f} {trajectory:<50} {result['trace_file'][:30]:<30}")
-    
-    print("-" * 80)
-    
-    # Summary statistics
-    scores = [r['total_score'] for r in results]
-    avg_score = sum(scores) / len(scores) if scores else 0
-    max_score = max(scores) if scores else 0
-    min_score = min(scores) if scores else 0
-    
-    print(f"Average Score: {avg_score:.2f}")
-    print(f"Best Score: {max_score:.2f}")
-    print(f"Worst Score: {min_score:.2f}")
-    print("=" * 80)
-
-
-if __name__ == "__main__":
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Evaluate Crafter trace files")
-    parser.add_argument("trace_path", type=str, help="Directory containing trace files or single trace file")
-    parser.add_argument("--pattern", type=str, default="*.json", help="File pattern to match (for directories)")
-    parser.add_argument("--verbose", action="store_true", help="Show detailed evaluation for each trace")
-    
-    args = parser.parse_args()
-    
-    trace_path = Path(args.trace_path)
-    if not trace_path.exists():
-        print(f"❌ Path not found: {trace_path}")
-        exit(1)
-    
-    # Check if it's a file or directory
-    if trace_path.is_file():
-        print(f"🔍 Evaluating single trace: {trace_path}")
-        result = evaluate_trace(trace_path)
-        print_trace_evaluation(result)
-    else:
-        print(f"🔍 Evaluating traces in: {trace_path}")
-        results = evaluate_all_traces(trace_path, args.pattern)
-        
-        if args.verbose:
-            for result in results:
-                print_trace_evaluation(result)
-        
-        print_evaluation_summary(results)

synth_ai/environments/examples/crafter_custom/crafter/__init__.py

@@ -1,7 +0,0 @@
-from . import constants
-from .config import PRESETS, WorldGenConfig
-from .env import Env
-from .recorder import Recorder
-
-# Note: We don't register with gym since this is a custom version
-# Users should import directly from this module

synth_ai/environments/examples/crafter_custom/crafter/config.py

@@ -1,182 +0,0 @@
-"""
-Configuration system for customizable Crafter environment.
-"""
-
-import json
-import os
-from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, Optional
-
-
-@dataclass
-class WorldGenConfig:
-    """Configuration for world generation parameters."""
-
-    # Material generation thresholds and probabilities
-    coal_threshold: float = 0.0
-    coal_probability: float = 0.15
-    iron_threshold: float = 0.4
-    iron_probability: float = 0.25
-    diamond_threshold: float = 0.18
-    diamond_probability: float = 0.006
-    tree_threshold: float = 0.0
-    tree_probability: float = 0.2
-    lava_threshold: float = 0.35
-
-    # Cave generation
-    cave_threshold: float = 0.6
-
-    # Initial spawn configuration
-    cow_spawn_probability: float = 0.015
-    cow_min_distance: int = 3
-    zombie_spawn_probability: float = 0.007
-    zombie_min_distance: int = 10
-    skeleton_spawn_probability: float = 0.05
-
-    # Dynamic spawn configuration for zombies
-    zombie_spawn_rate: float = 0.3
-    zombie_despawn_rate: float = 0.4
-    zombie_min_spawn_distance: int = 6
-    zombie_max_count: float = 3.5
-    zombie_min_count: float = 0.0
-
-    # Dynamic spawn configuration for skeletons
-    skeleton_spawn_rate: float = 0.1
-    skeleton_despawn_rate: float = 0.1
-    skeleton_min_spawn_distance: int = 7
-    skeleton_max_count: float = 2.0
-    skeleton_min_count: float = 0.0
-
-    # Dynamic spawn configuration for cows
-    cow_spawn_rate: float = 0.01
-    cow_despawn_rate: float = 0.1
-    cow_min_spawn_distance: int = 5
-    cow_max_count: float = 2.5
-    cow_min_count: float = 0.0
-
-    # World generation areas
-    spawn_clear_radius: int = 4
-    water_threshold: float = -0.3
-    sand_threshold: float = -0.2
-    mountain_threshold: float = 0.15
-
-    @classmethod
-    def from_json(cls, path: str) -> "WorldGenConfig":
-        """Load configuration from JSON file."""
-        with open(path, "r") as f:
-            data = json.load(f)
-        return cls(**data)
-
-    @classmethod
-    def from_preset(cls, preset: str) -> "WorldGenConfig":
-        """Load configuration from preset name."""
-        config_dir = os.path.dirname(__file__)
-        preset_path = os.path.join(config_dir, "config", f"{preset}.json")
-        if os.path.exists(preset_path):
-            return cls.from_json(preset_path)
-        else:
-            print(f"Warning: preset '{preset}' not found, using default config")
-            return cls()
-
-    def to_json(self, path: str) -> None:
-        """Save configuration to JSON file."""
-        with open(path, "w") as f:
-            json.dump(asdict(self), f, indent=2)
-
-
-# Preset configurations
-PRESETS = {
-    "easy": WorldGenConfig(
-        # More resources
-        coal_threshold=-0.2,
-        coal_probability=0.25,
-        iron_threshold=0.2,
-        iron_probability=0.35,
-        diamond_threshold=0.15,
-        diamond_probability=0.02,
-        tree_threshold=-0.2,
-        tree_probability=0.35,
-        lava_threshold=0.5,
-        # More friendly spawns
-        cow_spawn_probability=0.03,
-        cow_min_distance=2,
-        zombie_spawn_probability=0.003,
-        zombie_min_distance=15,
-        skeleton_spawn_probability=0.01,
-        # Fewer dynamic enemies
-        zombie_spawn_rate=0.1,
-        zombie_despawn_rate=0.6,
-        zombie_min_spawn_distance=10,
-        zombie_max_count=1.5,
-        skeleton_spawn_rate=0.02,
-        skeleton_despawn_rate=0.3,
-        skeleton_min_spawn_distance=12,
-        skeleton_max_count=0.5,
-        cow_spawn_rate=0.03,
-        cow_despawn_rate=0.05,
-        cow_min_spawn_distance=3,
-        cow_max_count=4.0,
-    ),
-    "hard": WorldGenConfig(
-        # Fewer resources
-        coal_threshold=0.2,
-        coal_probability=0.08,
-        iron_threshold=0.5,
-        iron_probability=0.15,
-        diamond_threshold=0.25,
-        diamond_probability=0.002,
-        tree_threshold=0.2,
-        tree_probability=0.1,
-        lava_threshold=0.25,
-        # More dangerous spawns
-        cow_spawn_probability=0.005,
-        cow_min_distance=5,
-        zombie_spawn_probability=0.02,
-        zombie_min_distance=6,
-        skeleton_spawn_probability=0.15,
-        # Many dynamic enemies
-        zombie_spawn_rate=0.5,
-        zombie_despawn_rate=0.2,
-        zombie_min_spawn_distance=4,
-        zombie_max_count=6.0,
-        skeleton_spawn_rate=0.3,
-        skeleton_despawn_rate=0.05,
-        skeleton_min_spawn_distance=5,
-        skeleton_max_count=4.0,
-        cow_spawn_rate=0.002,
-        cow_despawn_rate=0.2,
-        cow_min_spawn_distance=8,
-        cow_max_count=1.0,
-    ),
-    "peaceful": WorldGenConfig(
-        # Abundant resources
-        coal_threshold=-0.3,
-        coal_probability=0.3,
-        iron_threshold=0.1,
-        iron_probability=0.4,
-        diamond_threshold=0.1,
-        diamond_probability=0.03,
-        tree_threshold=-0.3,
-        tree_probability=0.4,
-        lava_threshold=0.6,
-        # No enemies, many cows
-        cow_spawn_probability=0.05,
-        cow_min_distance=2,
-        zombie_spawn_probability=0.0,
-        zombie_min_distance=100,
-        skeleton_spawn_probability=0.0,
-        # No dynamic enemies
-        zombie_spawn_rate=0.0,
-        zombie_despawn_rate=1.0,
-        zombie_min_spawn_distance=100,
-        zombie_max_count=0.0,
-        skeleton_spawn_rate=0.0,
-        skeleton_despawn_rate=1.0,
-        skeleton_min_spawn_distance=100,
-        skeleton_max_count=0.0,
-        cow_spawn_rate=0.05,
-        cow_despawn_rate=0.02,
-        cow_min_spawn_distance=2,
-        cow_max_count=5.0,
-    ),
-}