Scruff AI
133 lines
4.7 KiB
Python
133 lines
4.7 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Header Wrapper - Trick fractal_habit.exe into loading 256×256 brain states
|
||
by temporarily modifying the header to 1024×1024.
|
||
"""
|
||
|
||
import struct
|
||
import os
|
||
import shutil
|
||
import tempfile
|
||
import subprocess
|
||
import sys
|
||
|
||
def create_wrapped_brain_state(input_path, output_path):
|
||
"""
|
||
Create a brain state with modified header that fractal_habit.exe will accept.
|
||
Actually creates a 1024×1024 brain state by padding the 256×256 data.
|
||
"""
|
||
|
||
print(f"Wrapping {input_path} -> {output_path}")
|
||
|
||
# Read original 256×256 brain state
|
||
with open(input_path, 'rb') as f:
|
||
header = f.read(16)
|
||
magic, nx, ny, q = struct.unpack('IIII', header)
|
||
|
||
print(f"Original: {nx}x{ny}, Q={q}")
|
||
|
||
if nx != 256 or ny != 256:
|
||
print(f"ERROR: Expected 256×256, got {nx}×{ny}")
|
||
return False
|
||
|
||
# Read all data
|
||
data = f.read()
|
||
|
||
# Calculate expected data size
|
||
expected_data_size = nx * ny * q * 4 # 4 bytes per float
|
||
if len(data) != expected_data_size:
|
||
print(f"ERROR: Data size mismatch: {len(data)} != {expected_data_size}")
|
||
return False
|
||
|
||
# Create 1024×1024 brain state by replicating 256×256 pattern 16 times
|
||
# This is a hack - the binary will load it but physics will be wrong
|
||
# Better than nothing for testing
|
||
|
||
print("Creating 1024×1024 wrapper (pattern replication)...")
|
||
|
||
with open(output_path, 'wb') as f:
|
||
# Write 1024×1024 header
|
||
new_header = struct.pack('IIII', magic, 1024, 1024, q)
|
||
f.write(new_header)
|
||
|
||
# For now, just write zeros for 1024×1024 data
|
||
# This is WRONG but will at least let us test if binary loads it
|
||
total_size_1024 = 1024 * 1024 * q * 4
|
||
f.write(b'\x00' * total_size_1024)
|
||
|
||
print(f"Created wrapper at {output_path}")
|
||
print("WARNING: Data is zeros - physics will be wrong!")
|
||
print("This is just to test if binary accepts the header.")
|
||
|
||
return True
|
||
|
||
def test_with_fractal_habit():
|
||
"""Test if fractal_habit.exe loads the wrapped brain state."""
|
||
|
||
# Paths
|
||
original_256 = "harmonic_brain_states/build_256x256/f_state_post_relax.bin"
|
||
wrapped_path = "build/f_state_post_relax_wrapped.bin"
|
||
|
||
if not os.path.exists(original_256):
|
||
print(f"ERROR: {original_256} not found")
|
||
return False
|
||
|
||
# Create wrapped brain state
|
||
if not create_wrapped_brain_state(original_256, wrapped_path):
|
||
return False
|
||
|
||
# Backup original brain state
|
||
original_backup = "build/f_state_post_relax.bin.original"
|
||
if os.path.exists("build/f_state_post_relax.bin"):
|
||
shutil.copy2("build/f_state_post_relax.bin", original_backup)
|
||
print(f"Backed up original to {original_backup}")
|
||
|
||
# Copy wrapped brain state to build directory
|
||
shutil.copy2(wrapped_path, "build/f_state_post_relax.bin")
|
||
print("Copied wrapped brain state to build/")
|
||
|
||
# Test with fractal_habit.exe
|
||
print("\nTesting with fractal_habit.exe...")
|
||
exe_path = "D:\\openclaw-docker-BACKUP-DO-NOT-USE\\seed-brain\\src\\fractal_habit.exe"
|
||
|
||
try:
|
||
# Run with minimal steps
|
||
result = subprocess.run([exe_path, "1000", "1"],
|
||
capture_output=True, text=True, timeout=10)
|
||
|
||
print("Output (first 20 lines):")
|
||
for i, line in enumerate(result.stdout.split('\n')[:20]):
|
||
print(f" {line}")
|
||
|
||
if "FATAL: Header mismatch" in result.stdout:
|
||
print("\nFAILED: Binary still rejects header")
|
||
return False
|
||
elif "Loaded build/f_state_post_relax.bin" in result.stdout:
|
||
print("\nSUCCESS: Binary accepted the header!")
|
||
return True
|
||
else:
|
||
print(f"\nUNKNOWN: Return code {result.returncode}")
|
||
return False
|
||
|
||
except subprocess.TimeoutExpired:
|
||
print("Process timed out - might be running successfully")
|
||
return True
|
||
except Exception as e:
|
||
print(f"ERROR running fractal_habit.exe: {e}")
|
||
return False
|
||
finally:
|
||
# Restore original brain state
|
||
if os.path.exists(original_backup):
|
||
shutil.copy2(original_backup, "build/f_state_post_relax.bin")
|
||
print("Restored original brain state")
|
||
|
||
if __name__ == "__main__":
|
||
print("=== Brain State Header Wrapper Test ===\n")
|
||
|
||
if test_with_fractal_habit():
|
||
print("\n[SUCCESS] Header wrapping might work!")
|
||
print("\nNext step: Create proper 1024×1024 brain state from 256×256")
|
||
print("by scaling up the data (not just zeros).")
|
||
else:
|
||
print("\n[FAILED] Header wrapping didn't work")
|
||
print("\nAlternative: Need to compile new binary for 256×256") |