synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/environments/examples/crafter_custom/environment.py

@@ -1,312 +0,0 @@
-"""CrafterCustomEnvironment — Custom Crafter with configurable world generation."""
-
-from __future__ import annotations
-
-import dataclasses
-import logging
-import time
-from typing import Any, Dict, List, Optional, Union
-
-# Import logging configuration to suppress JAX debug messages
-from synth_ai.environments.examples.crafter_classic.config_logging import safe_compare
-
-# Import tracing abstractions
-from synth_ai.tracing_v3.abstractions import (
-    RuntimeEvent,
-    SessionEventMarkovBlanketMessage,
-    TimeRecord,
-)
-
-logger = logging.getLogger(__name__)
-
-# Import the base Crafter components
-from pydantic import BaseModel, Field
-
-from synth_ai.environments.environment.shared_engine import (
-    GetObservationCallable,
-    InternalObservation,
-)
-from synth_ai.environments.environment.tools import (
-    TOOL_REGISTRY,
-    AbstractTool,
-    EnvToolCall,
-    ToolResult,
-    register_tool,
-)
-from synth_ai.environments.examples.crafter_classic.engine import (
-    CrafterEngine,
-    CrafterEngineSnapshot,
-    CrafterPrivateState,
-    CrafterPublicState,
-)
-
-# Use the same tool and observation classes as CrafterClassic
-from synth_ai.environments.examples.crafter_classic.environment import (
-    CrafterActionInput,
-    CrafterInteractTool,
-    SynthCrafterObservationCallable,
-)
-from synth_ai.environments.examples.crafter_classic.taskset import CrafterTaskInstance
-from synth_ai.environments.reproducibility.core import ReproducibleEnvironment
-from synth_ai.environments.stateful.core import StatefulEnvironment
-
-
-class CrafterCustomEnvironment(StatefulEnvironment, ReproducibleEnvironment[CrafterEngine]):
-    """Custom Crafter environment with configurable world generation."""
-
-    def __init__(
-        self,
-        task_instance: "CrafterTaskInstance",
-        custom_step_obs: Optional[GetObservationCallable] = None,
-        custom_ckpt_obs: Optional[GetObservationCallable] = None,
-        session_tracer: Optional[Any] = None,  # SessionTracer from higher level
-    ) -> None:
-        self.name = "CrafterCustom"
-        self.task_instance = task_instance
-        self.custom_step_observation_callable = custom_step_obs or SynthCrafterObservationCallable()
-        self.custom_checkpoint_observation_callable = (
-            custom_ckpt_obs or SynthCrafterObservationCallable()
-        )
-
-        # Ensure task instance has world configuration
-        if hasattr(task_instance, "metadata"):
-            logger.info(
-                f"Creating CrafterCustom with world_config: {getattr(task_instance.metadata, 'world_config', 'default')}"
-            )
-
-        self.engine = CrafterEngine(task_instance)
-        self.session_tracer = session_tracer  # Store tracer for runtime events
-
-        self._interact_tool = CrafterInteractTool(self.engine, session_tracer=session_tracer)
-
-        # Register tool with a unique name for this environment
-        tool_name = f"{self.name.lower()}_interact"
-        if tool_name not in TOOL_REGISTRY:
-            # Create a copy of the tool with the custom name
-            self._interact_tool.name = tool_name
-            register_tool(self._interact_tool)
-
-    # ────────────────────────────────────────────────────────────────────
-    # Lifecycle helpers
-    # ────────────────────────────────────────────────────────────────────
-
-    async def initialize(self) -> InternalObservation:  # type: ignore[override]
-        priv, pub = await self.engine._reset_engine()
-        return await self._to_observation(priv, pub, self.custom_step_observation_callable)
-
-    async def terminate(self) -> InternalObservation:  # type: ignore[override]
-        pub = self.engine._get_public_state_from_env()
-        priv = self.engine._get_private_state_from_env(0, True, False)  # Terminated state
-        priv.terminated = True
-        obs_dict = {"status": "Environment terminated."}
-        return await self._to_observation(
-            priv, pub, self.custom_step_observation_callable, extra_obs=obs_dict
-        )
-
-    # ────────────────────────────────────────────────────────────────────
-    # Step + checkpoint
-    # ────────────────────────────────────────────────────────────────────
-
-    def validate_tool_calls(
-        self, tool_calls: Union[EnvToolCall, List[EnvToolCall], List[List[EnvToolCall]]]
-    ) -> EnvToolCall:
-        # Store the original tool calls for tracing
-        state_before = {"tool_calls": tool_calls}
-
-        # Normalize and validate to a single EnvToolCall
-        if isinstance(tool_calls, list):
-            if not tool_calls:
-                raise ValueError("Received empty list of tool calls.")
-            if isinstance(tool_calls[0], list):
-                if not tool_calls[0]:
-                    raise ValueError("Received empty inner list of tool calls.")
-                agent_call = tool_calls[0][0]
-            else:
-                agent_call = tool_calls[0]
-        elif isinstance(tool_calls, EnvToolCall):
-            agent_call = tool_calls
-        else:
-            raise TypeError(f"Unexpected type for tool_calls: {type(tool_calls)}")
-
-        if not isinstance(agent_call, EnvToolCall):
-            raise TypeError(f"Processed call is not EnvToolCall: {type(agent_call)}")
-
-        # Accept both "interact" and "craftercustom_interact"
-        if agent_call.tool not in ["interact", f"{self.name.lower()}_interact"]:
-            raise ValueError(
-                f"Unknown tool: {agent_call.tool}. Expected 'interact' or '{self.name.lower()}_interact'."
-            )
-
-        # Record runtime event for tool call validation
-        if (
-            self.session_tracer
-            and hasattr(self.session_tracer, "current_session")
-            and self.session_tracer.current_session
-        ):
-            runtime_validation_event = RuntimeEvent()
-            runtime_validation_event.time_record = TimeRecord()
-            runtime_validation_event.time_record.event_time = time.time()
-            runtime_validation_event.time_record.message_time = None
-            runtime_validation_event.system_instance_id = "crafter_custom_environment"
-            runtime_validation_event.system_state_before = state_before
-            runtime_validation_event.system_state_after = {"validated_call": agent_call}
-            runtime_validation_event.metadata = {"validation_step": "tool_call_validation"}
-            # Add directly to event history, bypassing timestep requirement
-            self.session_tracer.current_session.add_event(runtime_validation_event)
-
-        return agent_call
-
-    async def step(
-        self, tool_calls: Union[EnvToolCall, List[EnvToolCall], List[List[EnvToolCall]]]
-    ) -> InternalObservation:  # type: ignore[override]
-        agent_call = self.validate_tool_calls(tool_calls)
-        tool_result: ToolResult = await self._interact_tool(agent_call)
-
-        payload_dict = tool_result.payload
-        pub_state: CrafterPublicState
-        priv_state: CrafterPrivateState
-
-        if tool_result.ok:
-            # payload contains the actual state objects from the interact tool
-            priv_state = payload_dict.get("private_state")
-            pub_state = payload_dict.get("public_state")
-
-            # Validate we got the expected state objects
-            if not isinstance(priv_state, CrafterPrivateState) or not isinstance(
-                pub_state, CrafterPublicState
-            ):
-                logger.error(
-                    f"Invalid state types in payload: priv={type(priv_state)}, pub={type(pub_state)}"
-                )
-                # Fall back to getting current state
-                pub_state = self.engine._get_public_state_from_env()
-                health_dead = safe_compare(0, self.engine.env._player.health, ">=")
-                step_exceeded = safe_compare(self.engine.env._length, self.engine.env._step, "<=")
-                priv_state = self.engine._get_private_state_from_env(0, health_dead, step_exceeded)
-                pub_state.error_info = "Invalid state types in tool result"
-        else:
-            # Tool call failed, use states from payload if available, otherwise get current state
-            priv_state = payload_dict.get("private_state")
-            pub_state = payload_dict.get("public_state")
-
-            if not isinstance(priv_state, CrafterPrivateState) or not isinstance(
-                pub_state, CrafterPublicState
-            ):
-                # Fall back to getting current state
-                pub_state = self.engine._get_public_state_from_env()
-                health_dead = safe_compare(0, self.engine.env._player.health, ">=")
-                step_exceeded = safe_compare(self.engine.env._length, self.engine.env._step, "<=")
-                priv_state = self.engine._get_private_state_from_env(0, health_dead, step_exceeded)
-
-            if tool_result.error:
-                pub_state.error_info = tool_result.error
-
-        return await self._to_observation(
-            priv_state, pub_state, self.custom_step_observation_callable
-        )
-
-    async def checkpoint(self) -> InternalObservation:  # type: ignore[override]
-        engine_snapshot: CrafterEngineSnapshot = await self.engine._serialize_engine()
-        priv = self.engine._get_private_state_from_env(0, False, False)  # Get current state for obs
-        pub = self.engine._get_public_state_from_env()
-        obs_data = await self._to_observation(
-            priv, pub, self.custom_checkpoint_observation_callable
-        )
-        if isinstance(obs_data, dict):
-            obs_data["engine_snapshot_data"] = engine_snapshot.model_dump()
-        return obs_data
-
-    async def get_metadata(self) -> Dict[str, Any]:
-        """Get metadata about the current environment configuration."""
-        metadata = {
-            "environment_type": "CrafterCustom",
-            "engine_seed": getattr(self.engine.env, "_seed", None),
-            "world_area": self.engine.env._area,
-            "max_steps": self.engine.env._length,
-            "current_step": self.engine.env._step,
-        }
-
-        # Add task instance metadata
-        if hasattr(self.task_instance, "metadata"):
-            task_metadata = self.task_instance.metadata
-            metadata.update(
-                {
-                    "difficulty": getattr(task_metadata, "difficulty", None),
-                    "world_config": getattr(task_metadata, "world_config", None),
-                    "world_config_path": getattr(task_metadata, "world_config_path", None),
-                    "num_trees_radius": getattr(task_metadata, "num_trees_radius", None),
-                    "num_cows_radius": getattr(task_metadata, "num_cows_radius", None),
-                    "num_hostiles_radius": getattr(task_metadata, "num_hostiles_radius", None),
-                }
-            )
-
-        # Add current world statistics
-        if hasattr(self.engine, "env") and hasattr(self.engine.env, "_world"):
-            world = self.engine.env._world
-            object_counts = {}
-
-            for obj in world._objects:
-                if obj is None:
-                    continue
-                obj_type = type(obj).__name__
-                object_counts[obj_type] = object_counts.get(obj_type, 0) + 1
-
-            metadata["world_object_counts"] = object_counts
-
-        return metadata
-
-    # ────────────────────────────────────────────────────────────────────
-    # Helpers
-    # ────────────────────────────────────────────────────────────────────
-
-    async def _to_observation(
-        self,
-        priv: CrafterPrivateState,
-        pub: CrafterPublicState,
-        obs_cb: Optional[GetObservationCallable],
-        extra_obs: Optional[Dict[str, Any]] = None,
-    ) -> InternalObservation:
-        # Store state before observation generation
-        state_before = {"private_state": priv, "public_state": pub}
-
-        active_obs_cb = obs_cb or SynthCrafterObservationCallable()
-        observation = await active_obs_cb.get_observation(pub, priv)
-        if extra_obs and isinstance(observation, dict):
-            observation.update(extra_obs)
-
-        # Record runtime event for observation generation
-        if (
-            self.session_tracer
-            and hasattr(self.session_tracer, "current_session")
-            and self.session_tracer.current_session
-        ):
-            runtime_obs_event = RuntimeEvent()
-            runtime_obs_event.time_record = TimeRecord()
-            runtime_obs_event.time_record.event_time = time.time()
-            runtime_obs_event.time_record.message_time = None
-            runtime_obs_event.system_instance_id = "observation_generator"
-            runtime_obs_event.system_state_before = state_before
-            runtime_obs_event.system_state_after = {"observation": observation}
-            runtime_obs_event.metadata = {"observation_step": "state_to_obs_conversion"}
-            # Add directly to event history, bypassing timestep requirement
-            self.session_tracer.current_session.add_event(runtime_obs_event)
-
-        return observation
-
-    # ────────────────────────────────────────────────────────────────────
-    # ReproducibleEnvironment plumbing
-    # ────────────────────────────────────────────────────────────────────
-
-    async def _serialize_engine(self) -> CrafterEngineSnapshot:
-        return await self.engine._serialize_engine()
-
-    @classmethod
-    async def _deserialize_engine(
-        cls, snapshot: CrafterEngineSnapshot, task_instance: "CrafterTaskInstance"
-    ) -> "CrafterCustomEnvironment":
-        eng = await CrafterEngine._deserialize_engine(snapshot, task_instance)
-        env = cls(task_instance)
-        env.engine = eng
-        # CRITICAL: Update the interact tool to use the new engine!
-        env._interact_tool.engine = eng
-        return env

synth_ai/environments/examples/crafter_custom/old/analyze_diamond_issue.py

@@ -1,159 +0,0 @@
-"""
-Detailed analysis of why diamonds aren't spawning despite high probability.
-"""
-
-import numpy as np
-import opensimplex
-from crafter.config import WorldGenConfig
-from crafter.worldgen import _simplex
-
-def trace_single_position(x, y, config, simplex):
-    """Trace through the exact logic for a single position."""
-    print(f"\nTracing position ({x}, {y}):")
-    
-    # Terrain generation
-    water = _simplex(simplex, x, y, 3, {15: 1, 5: 0.15}, False) + 0.1
-    mountain = _simplex(simplex, x, y, 0, {15: 1, 5: 0.3})
-    mountain -= 0.3 * water
-    
-    print(f"  Water value: {water:.3f}")
-    print(f"  Mountain value: {mountain:.3f}")
-    print(f"  Mountain threshold: {config.mountain_threshold}")
-    
-    if mountain <= config.mountain_threshold:
-        print(f"  ❌ Not in mountain area (mountain={mountain:.3f} <= threshold={config.mountain_threshold})")
-        return False
-    
-    print(f"  ✓ In mountain area")
-    
-    # Check each condition in order
-    # Cave check
-    cave1 = _simplex(simplex, x, y, 6, 7)
-    cave2 = _simplex(simplex, x, y, 6, 5)
-    print(f"  Cave check 1: {cave1:.3f} > 0.15 and mountain > 0.3? {cave1 > 0.15 and mountain > 0.3}")
-    print(f"  Cave check 2: {cave2:.3f} > {config.cave_threshold}? {cave2 > config.cave_threshold}")
-    
-    if (cave1 > 0.15 and mountain > 0.3) or cave2 > config.cave_threshold:
-        print(f"  ❌ Blocked by cave")
-        return False
-    
-    # Tunnel checks
-    h_tunnel = _simplex(simplex, 2 * x, y / 5, 7, 3)
-    v_tunnel = _simplex(simplex, x / 5, 2 * y, 7, 3)
-    print(f"  Horizontal tunnel: {h_tunnel:.3f} > 0.4? {h_tunnel > 0.4}")
-    print(f"  Vertical tunnel: {v_tunnel:.3f} > 0.4? {v_tunnel > 0.4}")
-    
-    if h_tunnel > 0.4 or v_tunnel > 0.4:
-        print(f"  ❌ Blocked by tunnel")
-        return False
-    
-    # Coal check
-    coal_noise = _simplex(simplex, x, y, 1, 8)
-    coal_random = np.random.uniform()
-    print(f"  Coal noise: {coal_noise:.3f} > {config.coal_threshold}? {coal_noise > config.coal_threshold}")
-    print(f"  Coal random: {coal_random:.3f} > {1 - config.coal_probability:.3f}? {coal_random > (1 - config.coal_probability)}")
-    
-    if coal_noise > config.coal_threshold and coal_random > (1 - config.coal_probability):
-        print(f"  ❌ Blocked by coal")
-        return False
-    
-    # Iron check
-    iron_noise = _simplex(simplex, x, y, 2, 6)
-    iron_random = np.random.uniform()
-    print(f"  Iron noise: {iron_noise:.3f} > {config.iron_threshold}? {iron_noise > config.iron_threshold}")
-    print(f"  Iron random: {iron_random:.3f} > {1 - config.iron_probability:.3f}? {iron_random > (1 - config.iron_probability)}")
-    
-    if iron_noise > config.iron_threshold and iron_random > (1 - config.iron_probability):
-        print(f"  ❌ Blocked by iron")
-        return False
-    
-    # Diamond check
-    print(f"  Diamond threshold check: {mountain:.3f} > {config.diamond_threshold}? {mountain > config.diamond_threshold}")
-    
-    if mountain > config.diamond_threshold:
-        diamond_random = np.random.uniform()
-        print(f"  ✓ Diamond threshold met!")
-        print(f"  Diamond random: {diamond_random:.3f} > {1 - config.diamond_probability:.3f}? {diamond_random > (1 - config.diamond_probability)}")
-        
-        if diamond_random > (1 - config.diamond_probability):
-            print(f"  ✅ DIAMOND SPAWNED!")
-            return True
-        else:
-            print(f"  ❌ Diamond probability check failed")
-    else:
-        print(f"  ❌ Mountain value too low for diamonds")
-    
-    return False
-
-def find_diamond_candidates(config, num_positions=1000, seed=42):
-    """Find positions that meet the diamond threshold."""
-    np.random.seed(seed)
-    simplex = opensimplex.OpenSimplex(seed=seed)
-    
-    candidates = []
-    
-    for i in range(num_positions):
-        x = np.random.randint(10, 200)
-        y = np.random.randint(10, 200)
-        
-        water = _simplex(simplex, x, y, 3, {15: 1, 5: 0.15}, False) + 0.1
-        mountain = _simplex(simplex, x, y, 0, {15: 1, 5: 0.3})
-        mountain -= 0.3 * water
-        
-        if mountain > config.diamond_threshold:
-            # Check if it would pass all other checks
-            cave1 = _simplex(simplex, x, y, 6, 7) > 0.15 and mountain > 0.3
-            cave2 = _simplex(simplex, x, y, 6, 5) > config.cave_threshold
-            h_tunnel = _simplex(simplex, 2 * x, y / 5, 7, 3) > 0.4
-            v_tunnel = _simplex(simplex, x / 5, 2 * y, 7, 3) > 0.4
-            
-            if not (cave1 or cave2 or h_tunnel or v_tunnel):
-                # This position could potentially spawn a diamond
-                candidates.append((x, y, mountain))
-    
-    return candidates
-
-# The key issue: the probability condition
-print("THE KEY ISSUE WITH DIAMOND SPAWNING:")
-print("=" * 50)
-print("\nIn the worldgen.py code, line 55:")
-print("  elif mountain > config.diamond_threshold and uniform() > (1 - config.diamond_probability):")
-print()
-print("With default diamond_probability = 0.006:")
-print(f"  The condition uniform() > (1 - 0.006) means uniform() > 0.994")
-print(f"  This means we need to roll > 0.994 to spawn a diamond")
-print(f"  That's only a 0.6% chance!")
-print()
-print("The comment says 'high probability' but 0.006 is actually VERY LOW!")
-print()
-print("To have 'high probability', diamond_probability should be something like:")
-print("  - 0.5 for 50% chance")
-print("  - 0.8 for 80% chance")
-print("  - 0.95 for 95% chance")
-print()
-
-# Demonstrate with actual positions
-print("\nDemonstration with a few random positions:")
-print("=" * 50)
-
-config = WorldGenConfig(diamond_probability=0.006)  # Default low probability
-np.random.seed(42)
-simplex = opensimplex.OpenSimplex(seed=42)
-
-# Find some candidate positions
-candidates = find_diamond_candidates(config, num_positions=5000)
-print(f"\nFound {len(candidates)} positions that could spawn diamonds")
-
-if candidates:
-    # Trace a few
-    for i in range(min(3, len(candidates))):
-        x, y, mountain = candidates[i]
-        trace_single_position(x, y, config, simplex)
-
-print("\n" + "=" * 50)
-print("\nNow testing with HIGH probability (0.95):")
-config_high = WorldGenConfig(diamond_probability=0.95)
-
-if candidates:
-    x, y, mountain = candidates[0]
-    trace_single_position(x, y, config_high, simplex)

synth_ai/environments/examples/crafter_custom/old/analyze_diamond_spawning.py

@@ -1,158 +0,0 @@
-"""
-Analyze diamond spawning in Crafter world generation.
-This script helps understand why diamonds aren't appearing with high probability.
-"""
-
-import numpy as np
-import opensimplex
-from crafter.config import WorldGenConfig
-from crafter.worldgen import _simplex
-
-def analyze_diamond_conditions(config=None, num_samples=10000, seed=42):
-    """Analyze how often diamond spawning conditions are met."""
-    if config is None:
-        config = WorldGenConfig()
-    
-    np.random.seed(seed)
-    simplex = opensimplex.OpenSimplex(seed=seed)
-    
-    # Track statistics
-    stats = {
-        'total_positions': num_samples,
-        'mountain_positions': 0,
-        'diamond_threshold_met': 0,
-        'diamonds_spawned': 0,
-        'blocked_by_coal': 0,
-        'blocked_by_iron': 0,
-        'blocked_by_caves': 0,
-        'blocked_by_tunnels': 0,
-        'blocked_by_lava': 0,
-        'mountain_values': [],
-        'positions_checked': []
-    }
-    
-    # Simulate world generation at random positions
-    for i in range(num_samples):
-        x = np.random.randint(10, 200)  # Avoid spawn area
-        y = np.random.randint(10, 200)
-        
-        # Simulate terrain generation (simplified - no player spawn adjustment)
-        water = _simplex(simplex, x, y, 3, {15: 1, 5: 0.15}, False) + 0.1
-        mountain = _simplex(simplex, x, y, 0, {15: 1, 5: 0.3})
-        mountain -= 0.3 * water  # Simplified without spawn adjustment
-        
-        stats['mountain_values'].append(mountain)
-        
-        # Check if in mountain area
-        if mountain > config.mountain_threshold:
-            stats['mountain_positions'] += 1
-            
-            # Check cave conditions
-            cave_check1 = _simplex(simplex, x, y, 6, 7) > 0.15 and mountain > 0.3
-            cave_check2 = _simplex(simplex, x, y, 6, 5) > config.cave_threshold
-            if cave_check1 or cave_check2:
-                stats['blocked_by_caves'] += 1
-                continue
-                
-            # Check tunnel conditions
-            h_tunnel = _simplex(simplex, 2 * x, y / 5, 7, 3) > 0.4
-            v_tunnel = _simplex(simplex, x / 5, 2 * y, 7, 3) > 0.4
-            if h_tunnel or v_tunnel:
-                stats['blocked_by_tunnels'] += 1
-                continue
-                
-            # Check coal condition
-            coal_noise = _simplex(simplex, x, y, 1, 8) > config.coal_threshold
-            coal_prob = np.random.uniform() > (1 - config.coal_probability)
-            if coal_noise and coal_prob:
-                stats['blocked_by_coal'] += 1
-                continue
-                
-            # Check iron condition
-            iron_noise = _simplex(simplex, x, y, 2, 6) > config.iron_threshold
-            iron_prob = np.random.uniform() > (1 - config.iron_probability)
-            if iron_noise and iron_prob:
-                stats['blocked_by_iron'] += 1
-                continue
-                
-            # Check diamond threshold
-            if mountain > config.diamond_threshold:
-                stats['diamond_threshold_met'] += 1
-                
-                # Check if diamond probability passes
-                if np.random.uniform() > (1 - config.diamond_probability):
-                    # Check lava condition (which comes after diamond)
-                    lava_check = mountain > 0.3 and _simplex(simplex, x, y, 6, 5) > config.lava_threshold
-                    if not lava_check:
-                        stats['diamonds_spawned'] += 1
-                        stats['positions_checked'].append((x, y, mountain))
-                    else:
-                        stats['blocked_by_lava'] += 1
-    
-    return stats
-
-def print_analysis(stats, config):
-    """Print analysis results."""
-    print("Diamond Spawning Analysis")
-    print("=" * 50)
-    print(f"Configuration:")
-    print(f"  Mountain threshold: {config.mountain_threshold}")
-    print(f"  Diamond threshold: {config.diamond_threshold}")
-    print(f"  Diamond probability: {config.diamond_probability}")
-    print(f"  Coal threshold: {config.coal_threshold}")
-    print(f"  Coal probability: {config.coal_probability}")
-    print(f"  Iron threshold: {config.iron_threshold}")
-    print(f"  Iron probability: {config.iron_probability}")
-    print()
-    
-    print(f"Results from {stats['total_positions']} positions:")
-    print(f"  Mountain positions: {stats['mountain_positions']} ({100 * stats['mountain_positions'] / stats['total_positions']:.2f}%)")
-    
-    if stats['mountain_positions'] > 0:
-        print(f"  Within mountain areas:")
-        print(f"    Blocked by caves: {stats['blocked_by_caves']} ({100 * stats['blocked_by_caves'] / stats['mountain_positions']:.2f}%)")
-        print(f"    Blocked by tunnels: {stats['blocked_by_tunnels']} ({100 * stats['blocked_by_tunnels'] / stats['mountain_positions']:.2f}%)")
-        print(f"    Blocked by coal: {stats['blocked_by_coal']} ({100 * stats['blocked_by_coal'] / stats['mountain_positions']:.2f}%)")
-        print(f"    Blocked by iron: {stats['blocked_by_iron']} ({100 * stats['blocked_by_iron'] / stats['mountain_positions']:.2f}%)")
-        print(f"    Diamond threshold met: {stats['diamond_threshold_met']} ({100 * stats['diamond_threshold_met'] / stats['mountain_positions']:.2f}%)")
-        
-        if stats['diamond_threshold_met'] > 0:
-            print(f"    Of positions meeting diamond threshold:")
-            print(f"      Diamonds spawned: {stats['diamonds_spawned']} ({100 * stats['diamonds_spawned'] / stats['diamond_threshold_met']:.2f}%)")
-            print(f"      Blocked by lava: {stats['blocked_by_lava']} ({100 * stats['blocked_by_lava'] / stats['diamond_threshold_met']:.2f}%)")
-    
-    print(f"\n  Overall diamond spawn rate: {stats['diamonds_spawned']} ({100 * stats['diamonds_spawned'] / stats['total_positions']:.4f}%)")
-    
-    # Mountain value statistics
-    mountain_values = np.array(stats['mountain_values'])
-    print(f"\nMountain value statistics:")
-    print(f"  Min: {mountain_values.min():.3f}")
-    print(f"  Max: {mountain_values.max():.3f}")
-    print(f"  Mean: {mountain_values.mean():.3f}")
-    print(f"  Std: {mountain_values.std():.3f}")
-    print(f"  Percentiles:")
-    for p in [50, 75, 90, 95, 99]:
-        print(f"    {p}th: {np.percentile(mountain_values, p):.3f}")
-
-if __name__ == "__main__":
-    # Test with default config
-    print("Testing with default configuration:")
-    config = WorldGenConfig()
-    stats = analyze_diamond_conditions(config)
-    print_analysis(stats, config)
-    
-    print("\n" + "=" * 50 + "\n")
-    
-    # Test with modified config
-    print("Testing with increased diamond probability (0.5):")
-    config_high_prob = WorldGenConfig(diamond_probability=0.5)
-    stats_high = analyze_diamond_conditions(config_high_prob)
-    print_analysis(stats_high, config_high_prob)
-    
-    print("\n" + "=" * 50 + "\n")
-    
-    # Test with lower diamond threshold
-    print("Testing with lower diamond threshold (0.16):")
-    config_low_threshold = WorldGenConfig(diamond_threshold=0.16)
-    stats_low = analyze_diamond_conditions(config_low_threshold)
-    print_analysis(stats_low, config_low_threshold)