synth-ai 0.2.4.dev8__py3-none-any.whl → 0.2.4.dev9__py3-none-any.whl

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

@@ -0,0 +1,159 @@
+"""
+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

@@ -0,0 +1,158 @@
+"""
+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)

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

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+Compare agent performance across different world configurations.
+"""
+
+import subprocess
+import json
+from pathlib import Path
+import sys
+
+def run_evaluation(world_config, episodes=2, max_turns=20):
+    """Run evaluation with a specific world configuration."""
+    print(f"\n{'='*60}")
+    print(f"Testing {world_config.upper()} world configuration")
+    print(f"{'='*60}")
+    
+    cmd = [
+        sys.executable, "-m",
+        "synth_ai.environments.examples.crafter_custom.agent_demos.test_crafter_custom_agent",
+        "--model", "gpt-4.1-nano",
+        "--world-config", world_config,
+        "--episodes", str(episodes),
+        "--max-turns", str(max_turns),
+        "--evaluate-traces"
+    ]
+    
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    
+    # Extract key metrics from output
+    lines = result.stdout.split('\n')
+    metrics = {}
+    
+    for line in lines:
+        if "Mean Score" in line:
+            metrics["mean_score"] = float(line.split()[-1])
+        elif "Avg Achievements/Episode" in line:
+            metrics["avg_achievements"] = float(line.split()[-1])
+        elif "Average Score:" in line and "📊" not in line:
+            metrics["trace_score"] = float(line.split()[-1])
+    
+    return metrics
+
+def main():
+    print("🎮 Crafter World Configuration Comparison")
+    print("=" * 60)
+    
+    configs = ["peaceful", "easy", "normal", "hard"]
+    results = {}
+    
+    for config in configs:
+        results[config] = run_evaluation(config, episodes=2, max_turns=15)
+        print(f"\nResults for {config}: {results[config]}")
+    
+    # Summary comparison
+    print("\n" + "="*60)
+    print("📊 COMPARISON SUMMARY")
+    print("="*60)
+    print(f"{'Config':<10} {'Mean Score':<12} {'Avg Achievements':<18} {'Trace Score':<12}")
+    print("-"*60)
+    
+    for config in configs:
+        r = results[config]
+        print(f"{config:<10} {r.get('mean_score', 0):<12.2f} {r.get('avg_achievements', 0):<18.2f} {r.get('trace_score', 0):<12.2f}")
+    
+    print("\n💡 Analysis:")
+    print("- Peaceful worlds should have highest scores (no enemies)")
+    print("- Hard worlds should have lowest scores (many enemies, few resources)")
+    print("- Resource availability directly impacts achievement unlocking")
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""
+Display statistics about Crafter datasets
+"""
+
+import json
+from pathlib import Path
+from collections import Counter
+import sys
+
+
+def analyze_dataset(dataset_path: Path):
+    """Analyze a single dataset"""
+    # Load metadata
+    with open(dataset_path / "metadata.json", "r") as f:
+        metadata = json.load(f)
+    
+    # Load instances
+    with open(dataset_path / "instances.json", "r") as f:
+        instances = json.load(f)
+    
+    print(f"\nDataset: {metadata['name']}")
+    print(f"Description: {metadata['description']}")
+    print(f"Total instances: {metadata['num_instances']}")
+    print(f"Train/Val/Test split: {len(instances) - len(metadata['split_info']['val_instance_ids']) - len(metadata['split_info']['test_instance_ids'])}/{len(metadata['split_info']['val_instance_ids'])}/{len(metadata['split_info']['test_instance_ids'])}")
+    
+    # Analyze by difficulty
+    difficulties = Counter(inst['metadata']['difficulty'] for inst in instances)
+    print(f"\nInstances by difficulty:")
+    for diff, count in sorted(difficulties.items()):
+        print(f"  {diff}: {count} ({count/len(instances)*100:.1f}%)")
+    
+    # Analyze by impetus type
+    impetus_types = Counter()
+    for inst in instances:
+        instructions = inst['impetus']['instructions'].lower()
+        if 'speedrun' in instructions:
+            impetus_types['speedrun'] += 1
+        elif 'focus on' in instructions:
+            impetus_types['focused'] += 1
+        else:
+            impetus_types['general'] += 1
+    
+    print(f"\nInstances by type:")
+    for type_name, count in sorted(impetus_types.items()):
+        print(f"  {type_name}: {count} ({count/len(instances)*100:.1f}%)")
+    
+    # Analyze achievement focuses
+    focus_counts = Counter()
+    speedrun_targets = Counter()
+    
+    for inst in instances:
+        if inst['impetus'].get('achievement_focus'):
+            for ach in inst['impetus']['achievement_focus']:
+                focus_counts[ach] += 1
+        
+        if 'speedrun' in inst['impetus']['instructions'].lower():
+            # Extract speedrun target
+            instructions = inst['impetus']['instructions']
+            if ':' in instructions:
+                target = instructions.split(':')[1].strip().split(' ')[0]
+                speedrun_targets[target] += 1
+    
+    if focus_counts:
+        print(f"\nTop achievement focuses:")
+        for ach, count in focus_counts.most_common(10):
+            print(f"  {ach}: {count}")
+    
+    if speedrun_targets:
+        print(f"\nSpeedrun targets:")
+        for target, count in speedrun_targets.most_common():
+            print(f"  {target}: {count}")
+    
+    # Sample some instances
+    print(f"\nSample instances:")
+    for i, inst in enumerate(instances[:3]):
+        print(f"\n  Instance {i+1}:")
+        print(f"    ID: {inst['id']}")
+        print(f"    Difficulty: {inst['metadata']['difficulty']}")
+        print(f"    Seed: {inst['metadata']['world_seed']}")
+        print(f"    Instructions: {inst['impetus']['instructions'][:80]}...")
+
+
+def main():
+    dataset_dir = Path("dataset")
+    
+    print("Crafter Dataset Statistics")
+    print("=" * 60)
+    
+    # Find all datasets
+    datasets = [d for d in dataset_dir.iterdir() if d.is_dir() and (d / "metadata.json").exists()]
+    
+    if not datasets:
+        print("No datasets found in dataset/")
+        return
+    
+    print(f"Found {len(datasets)} dataset(s)")
+    
+    for dataset_path in sorted(datasets):
+        analyze_dataset(dataset_path)
+        print("\n" + "-" * 60)
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,119 @@
+"""
+Summary of the diamond spawning issue in Crafter.
+"""
+
+def explain_probability_condition():
+    """Explain how the probability condition works."""
+    print("DIAMOND SPAWNING PROBABILITY EXPLANATION")
+    print("=" * 60)
+    print()
+    print("The code uses this condition to spawn diamonds:")
+    print("  uniform() > (1 - config.diamond_probability)")
+    print()
+    print("This means:")
+    print("  - uniform() generates a random number between 0 and 1")
+    print("  - We spawn a diamond if this random number is GREATER than (1 - diamond_probability)")
+    print()
+    print("Examples:")
+    print("-" * 60)
+    
+    probabilities = [0.006, 0.1, 0.5, 0.8, 0.95]
+    
+    for prob in probabilities:
+        threshold = 1 - prob
+        actual_chance = 1 - threshold
+        print(f"\nWith diamond_probability = {prob}:")
+        print(f"  Condition: uniform() > {threshold:.3f}")
+        print(f"  Actual spawn chance: {actual_chance:.1%}")
+        print(f"  Description: {'VERY LOW' if prob < 0.1 else 'LOW' if prob < 0.3 else 'MODERATE' if prob < 0.7 else 'HIGH' if prob < 0.9 else 'VERY HIGH'}")
+
+def show_cascading_conditions():
+    """Show how conditions cascade in the world generation."""
+    print("\n\nCASCADING CONDITIONS IN WORLD GENERATION")
+    print("=" * 60)
+    print()
+    print("For a position in a mountain area, materials are checked in this order:")
+    print()
+    print("1. Cave check (two conditions)")
+    print("   └─ If true → place 'path'")
+    print()
+    print("2. Horizontal tunnel check") 
+    print("   └─ If true → place 'path'")
+    print()
+    print("3. Vertical tunnel check")
+    print("   └─ If true → place 'path'")
+    print()
+    print("4. Coal check (noise threshold AND probability)")
+    print("   └─ If true → place 'coal'")
+    print()
+    print("5. Iron check (noise threshold AND probability)")
+    print("   └─ If true → place 'iron'")
+    print()
+    print("6. Diamond check (mountain threshold AND probability)")
+    print("   └─ If true → place 'diamond'")
+    print()
+    print("7. Lava check")
+    print("   └─ If true → place 'lava'")
+    print()
+    print("8. Default: place 'stone'")
+    print()
+    print("IMPORTANT: Once any condition is met, no further checks are done!")
+    print("This means diamonds can be blocked by caves, tunnels, coal, or iron.")
+
+def calculate_effective_spawn_rate():
+    """Calculate the effective diamond spawn rate."""
+    print("\n\nEFFECTIVE DIAMOND SPAWN RATE")
+    print("=" * 60)
+    print()
+    print("Based on the analysis of 10,000 positions:")
+    print()
+    
+    # Data from our analysis
+    total_positions = 10000
+    mountain_positions = 2402
+    blocked_caves = 431
+    blocked_tunnels = 445
+    blocked_coal = 104
+    blocked_iron = 41
+    diamond_threshold_met = 1185
+    diamond_probability = 0.006
+    
+    print(f"Total positions: {total_positions}")
+    print(f"Mountain positions: {mountain_positions} ({100*mountain_positions/total_positions:.1f}%)")
+    print(f"  Blocked by caves: {blocked_caves}")
+    print(f"  Blocked by tunnels: {blocked_tunnels}")
+    print(f"  Blocked by coal: {blocked_coal}")
+    print(f"  Blocked by iron: {blocked_iron}")
+    print(f"  Reached diamond check: {diamond_threshold_met}")
+    print()
+    print(f"Diamond spawn probability: {diamond_probability} ({diamond_probability*100:.1f}%)")
+    print()
+    
+    expected_diamonds = diamond_threshold_met * diamond_probability
+    overall_rate = expected_diamonds / total_positions
+    
+    print(f"Expected diamonds: {expected_diamonds:.1f}")
+    print(f"Overall spawn rate: {overall_rate:.4%}")
+    print()
+    print("This explains why diamonds are so rare!")
+
+if __name__ == "__main__":
+    explain_probability_condition()
+    show_cascading_conditions()
+    calculate_effective_spawn_rate()
+    
+    print("\n\nRECOMMENDATION")
+    print("=" * 60)
+    print()
+    print("To make diamonds appear with 'high probability', you should:")
+    print()
+    print("1. Increase diamond_probability to at least 0.5 (50% chance)")
+    print("   or even 0.8-0.9 for truly 'high' probability")
+    print()
+    print("2. Consider adjusting other thresholds to reduce blocking:")
+    print("   - Increase coal_threshold (currently 0.0)")
+    print("   - Increase iron_threshold (currently 0.4)")
+    print("   - Decrease coal_probability and iron_probability")
+    print()
+    print("3. Optionally lower diamond_threshold slightly (currently 0.18)")
+    print("   to increase the number of positions that can spawn diamonds")

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

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+Example usage of Crafter datasets
+"""
+
+import os
+import sys
+sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
+
+from run_dataset import CrafterDatasetRunner
+
+
+def main():
+    runner = CrafterDatasetRunner()
+    
+    print("=== Example 1: Run 5 easy instances ===")
+    runner.run_batch(
+        dataset_name="crafter_balanced_v1",
+        num_instances=5,
+        difficulties=["easy"],
+        max_steps=500
+    )
+    
+    print("\n\n=== Example 2: Run validation set instances ===")
+    runner.run_batch(
+        dataset_name="crafter_balanced_v1",
+        num_instances=5,
+        split="val",
+        max_steps=500
+    )
+    
+    print("\n\n=== Example 3: Run speedrun challenges ===")
+    runner.run_batch(
+        dataset_name="crafter_balanced_v1",
+        num_instances=5,
+        impetus_types=["speedrun"],
+        max_steps=500
+    )
+    
+    print("\n\n=== Example 4: Compare difficulties ===")
+    for difficulty in ["easy", "normal", "hard"]:
+        print(f"\n--- Testing {difficulty} ---")
+        runner.run_batch(
+            dataset_name="crafter_progression_v1",
+            num_instances=3,
+            difficulties=[difficulty],
+            max_steps=300
+        )
+
+
+if __name__ == "__main__":
+    main()