Upload 28 files

app.py

@@ -0,0 +1,239 @@
+import os
+import sys
+import threading
+import time
+import numpy as np
+import gradio as gr
+import pygame
+
+# 1. Headless Config (Must be before pygame.init)
+os.environ["SDL_VIDEODRIVER"] = "dummy"
+os.environ["SDL_AUDIODRIVER"] = "dummy"
+
+# 2. Path Setup
+current_dir = os.path.dirname(os.path.abspath(__file__))
+pydino_path = os.path.join(current_dir, "pydino")
+sys.path.append(pydino_path)
+
+# 3. Imports from existing codebase
+import pickle
+from dimensions import Dimensions
+from watch_model import ModelWatcher
+# Import necessary classes effectively re-using watch_model logic
+# We need to load the brain manually
+
+# Global State
+GAME_INSTANCE = None
+CURRENT_FRAME = None
+CURRENT_FRAME = None
+CURRENT_BRAIN_DATA = {"inputs": [], "hidden": [], "outputs": []}
+BRAIN_WEIGHTS_JSON = "{}" 
+LOCK = threading.Lock()
+TARGET_TPS = 60
+
+# --- JS Visualizer Code (Global Injection) ---
+# This JS will be injected once at page load via demo.load(js=...)
+# It defines window.drawBrain which is called by the data stream.
+
+def load_web_ui_asset(filename):
+    asset_path = os.path.join(current_dir, "neurodino", "web-ui", filename)
+    if not os.path.exists(asset_path):
+        print(f"Warning: Asset not found: {asset_path}")
+        return ""
+    with open(asset_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+VISUALIZER_JS_TEMPLATE = load_web_ui_asset("visualizer.js")
+
+def load_brain(brain_path="best_brain.pkl"):
+    """Load the best brain."""
+    if not os.path.exists(brain_path):
+        return None
+    try:
+        with open(brain_path, "rb") as f:
+            data = pickle.load(f)
+            if isinstance(data, tuple):
+                return data[0] # brain, score
+            return data # just brain
+    except Exception as e:
+        print(f"Error loading brain: {e}")
+        return None
+
+def game_thread_func():
+    """Background thread calling the game update loop."""
+    global GAME_INSTANCE, CURRENT_FRAME, CURRENT_BRAIN_DATA, TARGET_TPS
+    
+    clock = pygame.time.Clock()
+    print("Game thread started.")
+    
+    while True:
+        try:
+            if GAME_INSTANCE:
+                pygame.event.pump()
+                GAME_INSTANCE.update()
+                
+                if GAME_INSTANCE.crashed:
+                    GAME_INSTANCE.restart_game()
+                
+                view = pygame.surfarray.array3d(GAME_INSTANCE.screen)
+                view = view.transpose([1, 0, 2])
+                
+                if hasattr(GAME_INSTANCE, 'brain'):
+                    b = GAME_INSTANCE.brain
+                    # Force flatten using numpy to handle both lists and arrays robustly
+                    inputs = np.array(b.last_inputs).flatten().tolist()
+                    hidden = np.array(b.last_hidden).flatten().tolist()
+                    outputs = np.array(b.last_outputs).flatten().tolist()
+                    
+                    brain_data = {
+                        "inputs": inputs,
+                        "hidden": hidden,
+                        "outputs": outputs
+                    }
+                else:
+                    brain_data = {"inputs": [], "hidden": [], "outputs": []}
+
+                with LOCK:
+                    CURRENT_FRAME = view
+                    CURRENT_BRAIN_DATA = brain_data
+            
+            if TARGET_TPS > 0:
+                clock.tick(TARGET_TPS) 
+            else:
+                clock.tick()
+            
+        except Exception as e:
+            print(f"Error in game loop: {e}")
+            time.sleep(1)
+
+def set_speed(choice):
+    global TARGET_TPS
+    if choice == "Yavaş (30 FPS)":
+        TARGET_TPS = 30
+    elif choice == "Normal (60 FPS)":
+        TARGET_TPS = 60
+    elif choice == "Hızlı (120 FPS)":
+        TARGET_TPS = 120
+    elif choice == "Maksimum (Unlimited)":
+        TARGET_TPS = 0
+    return f"Hız ayarlandı: {choice}"
+
+def start_game_server():
+    global GAME_INSTANCE, BRAIN_WEIGHTS_JSON
+    
+    pygame.init()
+    brain = load_brain()
+    if not brain: return False
+
+    # Extract static weights
+    import json
+    weights = {
+        "ih": brain.weights_ih.tolist() if hasattr(brain.weights_ih, 'tolist') else brain.weights_ih,
+        "ho": brain.weights_ho.tolist() if hasattr(brain.weights_ho, 'tolist') else brain.weights_ho,
+        "bh": np.array(brain.bias_h).flatten().tolist(),
+        "bo": np.array(brain.bias_o).flatten().tolist()
+    }
+    BRAIN_WEIGHTS_JSON = json.dumps(weights)
+
+    pygame.display.set_mode((600, 150))
+    dims = Dimensions(width=600, height=150)
+    game_surface = pygame.Surface((dims.width, dims.height))
+    
+    GAME_INSTANCE = ModelWatcher(game_surface, dims, brain, silent=False)
+    GAME_INSTANCE.start()
+    
+    t = threading.Thread(target=game_thread_func, daemon=True)
+    t.start()
+    return True
+
+def data_producer():
+    """Yields (image, json_data) tuple."""
+    while True:
+        with LOCK:
+                yield (CURRENT_FRAME, CURRENT_BRAIN_DATA)
+        # Reduce sleep to almost zero (1ms) to maximize frame rate
+        # Gradio will yield as fast as network permits
+        
+        # Adaptive Streaming: If Unlimited (0), throttle stream to 20 FPS to save CPU
+        if TARGET_TPS == 0:
+            time.sleep(0.05) # 20 FPS cap for visuals
+        else:
+            time.sleep(1.0 / TARGET_TPS) # Sync with Game Speed (e.g. 60 FPS) for smoothness
+
+# --- Gradio UI ---
+description = """
+# 🦖 NeuroDino Canlı Yayın
+Bu demo, **Genetik Algoritma** ile eğitilmiş bir Yapay Zeka'nın (Neural Network) canlı oynayışını gösterir.
+"""
+
+# HTML for the Canvas (No Script here)
+CANVAS_HTML = load_web_ui_asset("canvas.html")
+
+# CSS
+CSS = load_web_ui_asset("style.css")
+
+# HTML for Custom Controls
+CUSTOM_CONTROLS_HTML = load_web_ui_asset("custom_controls.html")
+
+# JS to force Light Mode
+FORCE_LIGHT_JS = """
+function refresh() {
+    const url = new URL(window.location);
+    if (url.searchParams.get('__theme') !== 'light') {
+        url.searchParams.set('__theme', 'light');
+        window.location.href = url.href;
+    }
+}
+"""
+
+with gr.Blocks(css=CSS, theme=gr.themes.Default(), js="document.body.classList.remove('dark');") as demo:
+    
+    with gr.Row(elem_id="main_row"):
+        with gr.Column(scale=1.5, elem_id="left_game_col"):
+            # Added elem_id="game_display" and removed internal height cap
+            image_out = gr.Image(label="Oyun Görünümü", streaming=True, elem_id="game_display", show_label=False)
+            
+            # Custom Controls (Pixel Art Style)
+            gr.HTML(CUSTOM_CONTROLS_HTML)
+            
+            with gr.Row():
+                 speed_radio = gr.Radio(
+                    choices=["Yavaş (30 FPS)", "Normal (60 FPS)", "Hızlı (120 FPS)", "Maksimum (Unlimited)"],
+                    value="Normal (60 FPS)",
+                    label="Oyun Hızı",
+                    interactive=True
+                )
+        
+        with gr.Column(scale=2):
+            # Just the canvas container
+            gr.HTML(CANVAS_HTML)
+            
+            # Hidden JSON sink
+            brain_data_sink = gr.JSON(visible=False)
+
+    # Initialize Server & Get JS
+    if start_game_server():
+        # Inject Javascript Global Code
+        js_code = VISUALIZER_JS_TEMPLATE.replace("__WEIGHTS_PLACEHOLDER__", BRAIN_WEIGHTS_JSON)
+        demo.load(None, None, None, js=js_code)
+    
+
+    
+    
+    # Stream Loop
+    demo.load(data_producer, inputs=None, outputs=[image_out, brain_data_sink])
+    
+    # Trigger JS draw on data update
+    brain_data_sink.change(
+        fn=None,
+        inputs=[brain_data_sink],
+        js="(data) => { if(window.drawBrain) window.drawBrain(data); }"
+    )   
+    
+    # Speed control connection
+    status_msg = gr.Markdown(visible=False)
+    speed_radio.change(fn=set_speed, inputs=speed_radio, outputs=status_msg)
+
+if __name__ == "__main__":
+    # Server already started in block definition to get weights, just launch
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860, share=True)

best_brain.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5c129d232c3cfe7025f4efbec52209217c6177488090ffa36c3c7d4c7ddb947
+size 7200

neurodino/web-ui/canvas.html

@@ -0,0 +1,4 @@
+<div id="canvas-container"
+    style="position: relative; width: 100%; min-height: 600px; height: auto; background: transparent; border-radius: 8px; overflow: auto;">
+    <canvas id="brainCanvas"></canvas>
+</div>

neurodino/web-ui/custom_controls.html

@@ -0,0 +1,364 @@
+<div id="neuro-custom-controls"
+    style="font-family: 'PressStart2P', monospace; background: #fff; padding: 20px 20px 5px 20px; border: 2px solid #535353; margin-top: 20px;">
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Press+Start+2P&display=swap');
+
+        /* Header Toggle Style */
+        .neuro-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            cursor: pointer;
+            padding-bottom: 15px;
+            user-select: none;
+        }
+
+        #neuro-custom-controls h3 {
+            margin: 0;
+            color: #535353;
+            font-size: 14px;
+        }
+
+        #neuro-arrow {
+            transition: transform 0.3s ease;
+            transform: rotate(-90deg);
+            /* Start collapsed state */
+            font-size: 12px;
+            color: #535353;
+        }
+
+        /* Collapsible Content */
+        #neuro-controls-content {
+            max-height: 0;
+            overflow: hidden;
+            transition: max-height 0.4s ease-out, opacity 0.3s ease-out, padding 0.3s ease;
+            opacity: 0;
+            padding-top: 0;
+            padding-bottom: 0;
+        }
+
+        .neuro-control-group {
+            margin-bottom: 20px;
+        }
+
+        .neuro-row {
+            display: flex;
+            align-items: center;
+            margin-bottom: 10px;
+            gap: 10px;
+        }
+
+        .neuro-label {
+            font-size: 10px;
+            color: #535353;
+            min-width: 120px;
+        }
+
+        /* Custom Pixel Checkbox */
+        .neuro-checkbox-wrapper {
+            display: flex;
+            align-items: center;
+            cursor: pointer;
+            user-select: none;
+        }
+
+        .neuro-checkbox {
+            width: 16px;
+            height: 16px;
+            border: 2px solid #535353;
+            display: inline-block;
+            margin-right: 8px;
+            position: relative;
+        }
+
+        .neuro-checkbox.checked::after {
+            content: '';
+            position: absolute;
+            top: 2px;
+            left: 2px;
+            width: 8px;
+            height: 8px;
+            background-color: #535353;
+        }
+
+        /* Custom Pixel Slider */
+        .neuro-slider-container {
+            flex-grow: 1;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            padding: 8px 0;
+            /* Add vertical padding for thumb overflow */
+            overflow: visible;
+        }
+
+        .neuro-slider {
+            -webkit-appearance: none;
+            appearance: none;
+            width: 100%;
+            height: 4px;
+            background: #e0e0e0;
+            outline: none;
+            border: 1px solid #535353;
+        }
+
+        .neuro-slider::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            appearance: none;
+            width: 16px;
+            height: 16px;
+            background: #fff;
+            border: 2px solid #535353;
+            box-sizing: border-box;
+            margin-top: 0px;
+            /* Center thumb on track */
+            cursor: pointer;
+        }
+
+        .neuro-slider::-webkit-slider-thumb:hover {
+            background: #535353;
+        }
+
+        .neuro-value {
+            font-size: 10px;
+            min-width: 30px;
+            text-align: right;
+        }
+
+        /* Color Picker Wrapper */
+        .neuro-color {
+            width: 24px;
+            height: 24px;
+            border: 2px solid #535353;
+            padding: 0;
+            background: none;
+            cursor: pointer;
+            -webkit-appearance: none;
+            appearance: none;
+        }
+
+        .neuro-color::-webkit-color-swatch-wrapper {
+            padding: 0;
+        }
+
+        .neuro-color::-webkit-color-swatch {
+            border: none;
+        }
+    </style>
+
+    <div class="neuro-header" onclick="toggleCustomControls()">
+        <h3>CUSTOM KONTROL PANELI</h3>
+        <span id="neuro-arrow">▼</span>
+    </div>
+
+    <!-- Collapsible Wrapper -->
+    <div id="neuro-controls-content">
+        <div style="border-top: 2px solid #535353; margin-bottom: 20px;"></div>
+
+        <!-- GROUP 1: EDGES -->
+        <div class="neuro-control-group">
+            <div class="neuro-header" onclick="toggleNeuroGroup('group-edges', 'arrow-edges')"
+                style="padding-bottom: 5px;">
+                <h4 style="margin: 0; color: #535353; font-size: 10px; text-decoration: none;">BAĞLANTILAR (EDGES)</h4>
+                <span id="arrow-edges"
+                    style="font-size: 10px; color: #535353; transition: transform 0.3s ease; transform: rotate(-90deg);">▼</span>
+            </div>
+
+            <div id="group-edges"
+                style="max-height: 0; overflow: hidden; transition: max-height 0.3s ease, opacity 0.3s ease; opacity: 0; padding-left: 5px;">
+                <div class="neuro-row neuro-checkbox-wrapper" onclick="toggleNeuroCheck('bezier_check', 'useBezier')">
+                    <div id="neuro_bezier_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Bezier (Kavisli)</span>
+                </div>
+                <div class="neuro-row neuro-checkbox-wrapper"
+                    onclick="toggleNeuroCheck('vertical_check', 'useVerticalLayout')">
+                    <div id="neuro_vertical_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Dikey Görünüm (Vertical)</span>
+                </div>
+                <div class="neuro-row neuro-checkbox-wrapper"
+                    onclick="toggleNeuroCheck('active_check', 'showActiveEdgesOnly')">
+                    <div id="neuro_active_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Canlı Sinyal Modu</span>
+                </div>
+
+                <div class="neuro-row neuro-checkbox-wrapper"
+                    onclick="toggleNeuroCheck('weight_color_check', 'useWeightColor')">
+                    <div id="neuro_weight_color_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Ağırlığa Göre Renk</span>
+                </div>
+
+                <!-- Conditional Color Pickers -->
+                <div id="neuro-weight-colors" style="display: none; padding-left: 20px; margin-bottom: 10px;">
+                    <div class="neuro-row">
+                        <span class="neuro-label" style="min-width: 100px;">Pozitif (+):</span>
+                        <input type="color" class="neuro-color" value="#0000ff"
+                            oninput="updateNeuroColor('posColor', this.value)">
+                    </div>
+                    <div class="neuro-row">
+                        <span class="neuro-label" style="min-width: 100px;">Negatif (-):</span>
+                        <input type="color" class="neuro-color" value="#ff0000"
+                            oninput="updateNeuroColor('negColor', this.value)">
+                    </div>
+                </div>
+
+                <!-- Default Color Picker (Visible when Weight Color is OFF) -->
+                <div id="neuro-default-color" style="display: block; padding-left: 20px; margin-bottom: 10px;">
+                    <div class="neuro-row">
+                        <span class="neuro-label" style="min-width: 100px;">Standart Renk:</span>
+                        <input type="color" class="neuro-color" value="#505050"
+                            oninput="updateNeuroColor('defaultEdgeColor', this.value)">
+                    </div>
+                </div>
+
+                <div class="neuro-row neuro-checkbox-wrapper"
+                    onclick="toggleNeuroCheck('prop_width_check', 'useProportionalWidth')">
+                    <div id="neuro_prop_width_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Ağırlığa Göre Kalınlık</span>
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Baz Kalınlık</span>
+                    <div class="neuro-slider-container">
+                        <input type="range" class="neuro-slider" min="0" max="3" step="0.1" value="0.5"
+                            oninput="updateNeuroVal('edgeWidth', this.value, 'val_edgeWidth')">
+                        <span id="val_edgeWidth" class="neuro-value">0.5</span>
+                    </div>
+                </div>
+
+                <div class="neuro-row neuro-checkbox-wrapper"
+                    onclick="toggleNeuroCheck('prop_opacity_check', 'useProportionalOpacity')">
+                    <div id="neuro_prop_opacity_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Ağırlığa Göre Opaklık</span>
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Baz Opaklık</span>
+                    <div class="neuro-slider-container">
+                        <input type="range" class="neuro-slider" min="0.1" max="1.0" step="0.1" value="1.0"
+                            oninput="updateNeuroVal('edgeOpacity', this.value, 'val_opacity')">
+                        <span id="val_opacity" class="neuro-value">1.0</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div style="border-top: 1px dashed #ccc; margin: 15px 0;"></div>
+
+        <!-- GROUP 2: NODES -->
+        <div class="neuro-control-group">
+            <div class="neuro-header" onclick="toggleNeuroGroup('group-nodes', 'arrow-nodes')"
+                style="padding-bottom: 5px;">
+                <h4 style="margin: 0; color: #535353; font-size: 10px; text-decoration: none;">NÖRONLAR (NODES)</h4>
+                <span id="arrow-nodes"
+                    style="font-size: 10px; color: #535353; transition: transform 0.3s ease; transform: rotate(-90deg);">▼</span>
+            </div>
+
+            <div id="group-nodes"
+                style="max-height: 0; overflow: hidden; transition: max-height 0.3s ease, opacity 0.3s ease; opacity: 0; padding-left: 5px;">
+                <div class="neuro-row neuro-checkbox-wrapper"
+                    onclick="toggleNeuroCheck('pixel_check', 'usePixelNodes')">
+                    <div id="neuro_pixel_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Piksel Modu</span>
+                </div>
+
+                <div class="neuro-row neuro-checkbox-wrapper" onclick="toggleNeuroCheck('bias_check', 'showBiases')">
+                    <div id="neuro_bias_check" class="neuro-checkbox checked"></div> <!-- Default Checked -->
+                    <span class="neuro-label">Bias Göster</span>
+                </div>
+
+                <div class="neuro-row neuro-checkbox-wrapper"
+                    onclick="toggleNeuroCheck('activation_color_check', 'useNodeActivationColor')">
+                    <div id="neuro_activation_color_check" class="neuro-checkbox"></div>
+                    <span class="neuro-label">Aktivasyon Rengi</span>
+                </div>
+
+                <!-- Conditional Activation Colors -->
+                <div id="neuro-activation-colors" style="display: none; padding-left: 20px; margin-bottom: 10px;">
+                    <div class="neuro-row">
+                        <span class="neuro-label" style="min-width: 100px;">Pozitif (+):</span>
+                        <input type="color" class="neuro-color" value="#0000ff"
+                            oninput="updateNeuroColor('posColor', this.value)">
+                    </div>
+                    <div class="neuro-row">
+                        <span class="neuro-label" style="min-width: 100px;">Negatif (-):</span>
+                        <input type="color" class="neuro-color" value="#ff0000"
+                            oninput="updateNeuroColor('negColor', this.value)">
+                    </div>
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Node Rengi:</span>
+                    <input type="color" class="neuro-color" value="#ffffff"
+                        oninput="updateNeuroColor('nodeColor', this.value)">
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Çerçeve:</span>
+                    <input type="color" class="neuro-color" value="#333333"
+                        oninput="updateNeuroColor('nodeBorderColor', this.value)">
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Node Çapı</span>
+                    <div class="neuro-slider-container">
+                        <input type="range" class="neuro-slider" min="2" max="50" step="1" value="10"
+                            oninput="updateNeuroVal('targetRadius', this.value/2, 'val_radius', this.value)">
+                        <span id="val_radius" class="neuro-value">10</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <div style="border-top: 1px dashed #ccc; margin: 15px 0;"></div>
+
+        <!-- GROUP 3: LAYOUT -->
+        <div class="neuro-control-group">
+            <div class="neuro-header" onclick="toggleNeuroGroup('group-layout', 'arrow-layout')"
+                style="padding-bottom: 5px;">
+                <h4 style="margin: 0; color: #535353; font-size: 10px; text-decoration: none;">YERLEŞİM (LAYOUT)</h4>
+                <span id="arrow-layout"
+                    style="font-size: 10px; color: #535353; transition: transform 0.3s ease; transform: rotate(-90deg);">▼</span>
+            </div>
+
+            <div id="group-layout"
+                style="max-height: 0; overflow: hidden; transition: max-height 0.3s ease, opacity 0.3s ease; opacity: 0; padding-left: 5px;">
+                <div class="neuro-row">
+                    <span class="neuro-label">Katman Aralığı</span>
+                    <div class="neuro-slider-container">
+                        <input type="range" class="neuro-slider" min="50" max="400" step="10" value="290"
+                            oninput="updateNeuroVal('layerSpacing', this.value, 'val_spacing')">
+                        <span id="val_spacing" class="neuro-value">290</span>
+                    </div>
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Giriş Dikey</span>
+                    <div class="neuro-slider-container">
+                        <input type="range" class="neuro-slider" min="5" max="100" step="1" value="30"
+                            oninput="updateNeuroVal('vSpacingInput', this.value, 'val_v_input')">
+                        <span id="val_v_input" class="neuro-value">30</span>
+                    </div>
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Gizli Dikey</span>
+                    <div class="neuro-slider-container">
+                        <input type="range" class="neuro-slider" min="5" max="100" step="1" value="10"
+                            oninput="updateNeuroVal('vSpacingHidden', this.value, 'val_v_hidden')">
+                        <span id="val_v_hidden" class="neuro-value">10</span>
+                    </div>
+                </div>
+
+                <div class="neuro-row">
+                    <span class="neuro-label">Çıkış Dikey</span>
+                    <div class="neuro-slider-container">
+                        <input type="range" class="neuro-slider" min="5" max="100" step="1" value="30"
+                            oninput="updateNeuroVal('vSpacingOutput', this.value, 'val_v_output')">
+                        <span id="val_v_output" class="neuro-value">30</span>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+</div>

neurodino/web-ui/visualizer.js

@@ -0,0 +1,1036 @@
+function setupNeuroDino() {
+    // --- Color Lerp Helper ---
+    function lerpColor(colorA, colorB, t, alpha = 1.0) {
+        // Parse rgb(r, g, b) or hex format
+        const parseColor = (c) => {
+            if (c.startsWith('rgb')) {
+                const m = c.match(/rgb\((\d+),\s*(\d+),\s*(\d+)\)/);
+                return m ? [parseInt(m[1]), parseInt(m[2]), parseInt(m[3])] : [80, 80, 80];
+            } else if (c.startsWith('#')) {
+                const hex = c.slice(1);
+                return [parseInt(hex.slice(0, 2), 16), parseInt(hex.slice(2, 4), 16), parseInt(hex.slice(4, 6), 16)];
+            }
+            return [80, 80, 80];
+        };
+        const a = parseColor(colorA);
+        const b = parseColor(colorB);
+        const r = Math.round(a[0] + (b[0] - a[0]) * t);
+        const g = Math.round(a[1] + (b[1] - a[1]) * t);
+        const bl = Math.round(a[2] + (b[2] - a[2]) * t);
+        return `rgba(${r}, ${g}, ${bl}, ${alpha})`;
+    }
+
+    // Inject weights from Python
+    const weights = __WEIGHTS_PLACEHOLDER__;
+    window.useBezier = false;
+    window.edgeWidth = 0.5;
+    window.useProportionalWidth = false;
+    window.useProportionalOpacity = false;
+    window.useWeightColor = false;
+    window.usePixelNodes = false;
+    window.useVerticalLayout = false;
+    window.useNodeActivationColor = false;
+    window.showBiases = true;
+    window.posColor = "rgb(0, 0, 255)";
+    window.negColor = "rgb(255, 0, 0)";
+    window.defaultEdgeColor = "rgb(80, 80, 80)";
+    window.nodeColor = "white";
+    window.nodeBorderColor = "#333333";
+    window.edgeOpacity = 1.0;
+    window.showActiveEdgesOnly = false;
+
+    // --- UI Control Functions (Global) ---
+    window.updateNeuroVal = function (globalVar, value, displayId, displayVal) {
+        window[globalVar] = parseFloat(value);
+        if (displayId) {
+            const el = document.getElementById(displayId);
+            if (el) el.innerText = displayVal || value;
+        }
+    };
+
+    window.toggleNeuroCheck = function (elemId, globalVar) {
+        const el = document.getElementById('neuro_' + elemId);
+        if (!el) return;
+
+        const isChecked = el.classList.contains('checked');
+        if (isChecked) {
+            el.classList.remove('checked');
+            window[globalVar] = false;
+        } else {
+            el.classList.add('checked');
+            window[globalVar] = true;
+        }
+
+        // Special handling for Weight Color toggle to show/hide pickers
+        if (elemId === 'weight_color_check') {
+            const weightContainer = document.getElementById('neuro-weight-colors');
+            const defaultContainer = document.getElementById('neuro-default-color');
+
+            if (window[globalVar]) {
+                // Weight Color ON: Show Pos/Neg, Hide Default
+                if (weightContainer) weightContainer.style.display = 'block';
+                if (defaultContainer) defaultContainer.style.display = 'none';
+            } else {
+                // Weight Color OFF: Hide Pos/Neg, Show Default
+                if (weightContainer) weightContainer.style.display = 'none';
+                if (defaultContainer) defaultContainer.style.display = 'block';
+            }
+        }
+
+
+
+        // Special handling for Node Activation Color toggle
+        if (elemId === 'activation_color_check') {
+            const actContainer = document.getElementById('neuro-activation-colors');
+            if (actContainer) {
+                actContainer.style.display = window[globalVar] ? 'block' : 'none';
+            }
+
+            // Also update the inner group accordion height
+            const groupNodes = document.getElementById('group-nodes');
+            if (groupNodes && groupNodes.style.maxHeight) {
+                setTimeout(() => {
+                    groupNodes.style.maxHeight = (groupNodes.scrollHeight + 20) + "px";
+                }, 10);
+            }
+        }
+
+        // Recalculate Accordion Height if it's open
+        const content = document.getElementById('neuro-controls-content');
+        if (content && content.style.maxHeight) {
+            // Wait for display change to render, then update height
+            setTimeout(() => {
+                content.style.maxHeight = (content.scrollHeight + 50) + "px";
+            }, 10);
+        }
+    };
+
+    window.updateNeuroColor = function (globalVar, value) {
+        window[globalVar] = value;
+    };
+
+
+    window.toggleCustomControls = function () {
+        const content = document.getElementById('neuro-controls-content');
+        const arrow = document.getElementById('neuro-arrow');
+
+        if (content.style.maxHeight) {
+            content.style.maxHeight = null;
+            content.style.paddingTop = "0px";
+            content.style.paddingBottom = "0px";
+            content.style.opacity = "0";
+            arrow.style.transform = "rotate(-90deg)";
+        } else {
+            // Add extra height for the padding we are about to add (10px top + 10px bottom = 20px)
+            content.style.maxHeight = (content.scrollHeight + 50) + "px";
+            content.style.paddingTop = "10px";
+            content.style.paddingBottom = "10px"; // match css
+            content.style.opacity = "1";
+            arrow.style.transform = "rotate(0deg)";
+        }
+    };
+
+    window.toggleNeuroGroup = function (groupId, arrowId) {
+        const content = document.getElementById(groupId);
+        const arrow = document.getElementById(arrowId);
+        const parentContent = document.getElementById('neuro-controls-content');
+
+        if (content.style.maxHeight && content.style.maxHeight !== "0px") {
+            // Collapse
+            content.style.maxHeight = "0px";
+            content.style.opacity = "0";
+            content.style.marginBottom = "0px";
+            if (arrow) arrow.style.transform = "rotate(-90deg)";
+        } else {
+            // Expand
+            content.style.maxHeight = (content.scrollHeight + 20) + "px";
+            content.style.opacity = "1";
+            content.style.marginBottom = "20px";
+            if (arrow) arrow.style.transform = "rotate(0deg)";
+        }
+
+        // Parent Height Recalculation
+        if (parentContent && parentContent.style.maxHeight) {
+            setTimeout(() => {
+                // Determine new height needed. 
+                // We add a large buffer because 'scrollHeight' might not update instantly during transition,
+                // and max-height doesn't force height, just limits it. 
+                // So setting it generously avoids cutting off content.
+                parentContent.style.maxHeight = (parentContent.scrollHeight + content.scrollHeight + 200) + "px";
+            }, 50);
+        }
+    };
+    // -------------------------------------
+
+    // Smooth Transition States
+    window.smoothEdgeWidth = 2.0;
+    window.smoothRadius = 10.0;
+    window.smoothEdgeOpacity = 1.0;
+    window.smoothLayerSpacing = 290;
+
+    window.smoothLayerSpacing = 290;
+
+    // Target Vertical Spacings (Controlled by UI)
+    window.vSpacingInput = 30;
+    window.vSpacingHidden = 10;
+    window.vSpacingOutput = 30;
+
+    // Smooth Variables (Initialized to target)
+    window.smoothVSpacingInput = 30;
+    window.smoothVSpacingHidden = 10;
+    window.smoothVSpacingOutput = 30;
+    window.smoothVSpacingOutput = 40;
+
+    window.smoothPropFactor = 0.0;
+    window.smoothPropOpacityFactor = 0.0;
+    window.smoothBezierFactor = 0.0;
+    window.smoothNodeColorFactor = 0.0;
+    window.smoothActiveFactor = 0.0;
+    window.smoothWeightColorFactor = 0.0;
+
+    window.layerSpacing = 290;
+    window.targetRadius = 5;
+    window.latestData = null;
+    window.vSpacingInput = 30;
+    window.vSpacingHidden = 10;
+    window.vSpacingHidden = 10;
+    window.vSpacingOutput = 40;
+
+    // Zoom & Pan State
+    window.vizScale = 1;
+    window.panX = 0;
+    window.panY = 0;
+    window.isDragging = false;
+    window.lastX = 0;
+    window.lastY = 0;
+
+    // Interaction State
+    window.activeNode = null; // {layer: 'input'|'hidden'|'output', index: 0}
+    window.nodePositions = []; // List of {x, y, r, layer, index} populated every frame
+
+    // Main Draw Function (Updates Data ONLY)
+    window.drawBrain = function (data) {
+        window.latestData = data;
+
+        // Start Loop if not started (idempotent check ideally, 
+        // but we can just rely on the separate loop starter)
+    };
+
+    // Animation Loop
+    function renderLoop() {
+        requestAnimationFrame(renderLoop);
+
+        // Smooth Parameter Interpolation
+        if (window.smoothEdgeWidth === undefined) window.smoothEdgeWidth = window.edgeWidth;
+        // Lerp factor 0.1 for smooth transition
+        window.smoothEdgeWidth += (window.edgeWidth - window.smoothEdgeWidth) * 0.1;
+
+        // Clamp to avoid tiny jitter when close
+        if (Math.abs(window.edgeWidth - window.smoothEdgeWidth) < 0.001) {
+            window.smoothEdgeWidth = window.edgeWidth;
+        }
+
+        // Smooth Radius Interpolation
+        if (window.smoothRadius === undefined) window.smoothRadius = window.targetRadius;
+        window.smoothRadius += (window.targetRadius - window.smoothRadius) * 0.1;
+        if (Math.abs(window.targetRadius - window.smoothRadius) < 0.01) window.smoothRadius = window.targetRadius;
+
+        // Smooth Opacity Interpolation
+        if (window.smoothEdgeOpacity === undefined) window.smoothEdgeOpacity = window.edgeOpacity;
+        window.smoothEdgeOpacity += (window.edgeOpacity - window.smoothEdgeOpacity) * 0.1;
+        if (Math.abs(window.edgeOpacity - window.smoothEdgeOpacity) < 0.001) window.smoothEdgeOpacity = window.edgeOpacity;
+
+        // Smooth Layer Spacing Interpolation
+        if (window.smoothLayerSpacing === undefined) window.smoothLayerSpacing = window.layerSpacing;
+        window.smoothLayerSpacing += (window.layerSpacing - window.smoothLayerSpacing) * 0.1;
+        if (Math.abs(window.layerSpacing - window.smoothLayerSpacing) < 0.1) window.smoothLayerSpacing = window.layerSpacing;
+
+        // Smooth Vertical Spacing Interpolation
+        if (window.smoothVSpacingInput === undefined) window.smoothVSpacingInput = window.vSpacingInput;
+        window.smoothVSpacingInput += (window.vSpacingInput - window.smoothVSpacingInput) * 0.1;
+        if (Math.abs(window.vSpacingInput - window.smoothVSpacingInput) < 0.1) window.smoothVSpacingInput = window.vSpacingInput;
+
+        if (window.smoothVSpacingHidden === undefined) window.smoothVSpacingHidden = window.vSpacingHidden;
+        window.smoothVSpacingHidden += (window.vSpacingHidden - window.smoothVSpacingHidden) * 0.1;
+        if (Math.abs(window.vSpacingHidden - window.smoothVSpacingHidden) < 0.1) window.smoothVSpacingHidden = window.vSpacingHidden;
+
+        if (window.smoothVSpacingOutput === undefined) window.smoothVSpacingOutput = window.vSpacingOutput;
+        window.smoothVSpacingOutput += (window.vSpacingOutput - window.smoothVSpacingOutput) * 0.1;
+        if (Math.abs(window.vSpacingOutput - window.smoothVSpacingOutput) < 0.1) window.smoothVSpacingOutput = window.vSpacingOutput;
+
+        // Smooth Proportional Width Factor (Toggle Animation)
+        const targetPropFactor = window.useProportionalWidth ? 1.0 : 0.0;
+        if (window.smoothPropFactor === undefined) window.smoothPropFactor = targetPropFactor;
+        window.smoothPropFactor += (targetPropFactor - window.smoothPropFactor) * 0.1;
+
+        // Smooth Proportional Opacity Factor
+        const targetPropOpacityFactor = window.useProportionalOpacity ? 1.0 : 0.0;
+        if (window.smoothPropOpacityFactor === undefined) window.smoothPropOpacityFactor = targetPropOpacityFactor;
+        window.smoothPropOpacityFactor += (targetPropOpacityFactor - window.smoothPropOpacityFactor) * 0.1;
+
+        // Smooth Bezier Factor (0.0 = Straight, 1.0 = Curved)
+        const targetBezier = window.useBezier ? 1.0 : 0.0;
+        if (window.smoothBezierFactor === undefined) window.smoothBezierFactor = targetBezier;
+        window.smoothBezierFactor += (targetBezier - window.smoothBezierFactor) * 0.1;
+
+        // Smooth Node Color Factor
+        const targetNodeColor = window.useNodeActivationColor ? 1.0 : 0.0;
+        if (window.smoothNodeColorFactor === undefined) window.smoothNodeColorFactor = targetNodeColor;
+        window.smoothNodeColorFactor += (targetNodeColor - window.smoothNodeColorFactor) * 0.1;
+
+        let targetActiveFactor = window.showActiveEdgesOnly ? 1.0 : 0.0;
+        window.smoothActiveFactor += (targetActiveFactor - window.smoothActiveFactor) * 0.1;
+
+        // Smooth Weight Color Factor
+        const targetWeightColorFactor = window.useWeightColor ? 1.0 : 0.0;
+        if (window.smoothWeightColorFactor === undefined) window.smoothWeightColorFactor = targetWeightColorFactor;
+        window.smoothWeightColorFactor += (targetWeightColorFactor - window.smoothWeightColorFactor) * 0.1;
+
+        // Smooth Vertical Layout Factor
+        const targetVerticalFactor = window.useVerticalLayout ? 1.0 : 0.0;
+        if (window.smoothVerticalFactor === undefined) window.smoothVerticalFactor = targetVerticalFactor;
+        window.smoothVerticalFactor += (targetVerticalFactor - window.smoothVerticalFactor) * 0.1;
+
+        // --- Data Interpolation (Signal Smoothing) ---
+        if (!window.displayData && window.latestData) {
+            // First frame initialization (Deep Clone to avoid ref issues)
+            window.displayData = JSON.parse(JSON.stringify(window.latestData));
+        }
+
+        if (window.displayData && window.latestData) {
+            const lerpFactor = 0.15; // Tuning: 0.15 gives a nice fluid feel
+
+            // Helper to Lerp Value or Object->Value
+            const lerpVal = (current, target) => {
+                const cVal = (typeof current === 'object' && current !== null) ? current.val : current;
+                const tVal = (typeof target === 'object' && target !== null) ? target.val : target;
+
+                // If structure mismatch or undefined, jump to target
+                if (cVal === undefined || tVal === undefined) return target;
+
+                const newVal = cVal + (tVal - cVal) * lerpFactor;
+
+                if (typeof current === 'object' && current !== null) {
+                    current.val = newVal;
+                    return current;
+                }
+                return newVal;
+            };
+
+            // Interpolate Inputs
+            if (window.displayData.inputs && window.latestData.inputs) {
+                for (let i = 0; i < window.latestData.inputs.length; i++) {
+                    // Ensure source array is large enough
+                    if (window.displayData.inputs[i] === undefined) window.displayData.inputs[i] = window.latestData.inputs[i];
+                    else window.displayData.inputs[i] = lerpVal(window.displayData.inputs[i], window.latestData.inputs[i]);
+                }
+            }
+
+            // Interpolate Hidden
+            if (window.displayData.hidden && window.latestData.hidden) {
+                for (let i = 0; i < window.latestData.hidden.length; i++) {
+                    if (window.displayData.hidden[i] === undefined) window.displayData.hidden[i] = window.latestData.hidden[i];
+                    else window.displayData.hidden[i] = lerpVal(window.displayData.hidden[i], window.latestData.hidden[i]);
+                }
+            }
+
+            // Interpolate Outputs
+            if (window.displayData.outputs && window.latestData.outputs) {
+                for (let i = 0; i < window.latestData.outputs.length; i++) {
+                    if (window.displayData.outputs[i] === undefined) window.displayData.outputs[i] = window.latestData.outputs[i];
+                    else window.displayData.outputs[i] = lerpVal(window.displayData.outputs[i], window.latestData.outputs[i]);
+                }
+            }
+        }
+
+        const canvas = document.getElementById('brainCanvas');
+        if (!canvas) return;
+
+        // Initialize Events Once
+        if (!canvas.listenersAdded) {
+            canvas.listenersAdded = true;
+
+            canvas.addEventListener('mousedown', (e) => {
+                const rect = canvas.getBoundingClientRect();
+                const mouseX = e.clientX - rect.left;
+                const mouseY = e.clientY - rect.top;
+
+                // Get World Coordinates
+                const dpr = window.devicePixelRatio || 1;
+                // Note: nodePositions are stored in LOGICAL coordinates (unscaled by dpr, but scaled by vizScale in world?)
+                // Actually my nodePositions capture logic below uses the transform? 
+                // Let's ensure nodePositions stores WORLD coordinates (before Pan/Scale).
+                // Wait, if I grab x,y inside drawLayer, that is in World Space (after translate/scale).
+                // No, ctx calls use Local Coords.
+                // ctx.translate(panX, panY); ctx.scale(scale); ctx.arc(x,y).
+                // So 'x, y' in drawLayer are LOCAL coordinates relative to the scene origin (0,0).
+                // So we need to transform Mouse -> View -> World.
+
+                const worldX = (mouseX - window.panX) / window.vizScale;
+                const worldY = (mouseY - window.panY) / window.vizScale;
+
+                // Check collisions
+                let hitNode = null;
+                for (const node of window.nodePositions) {
+                    const dx = worldX - node.x;
+                    const dy = worldY - node.y;
+                    if (dx * dx + dy * dy < node.r * node.r) {
+                        hitNode = node;
+                        break;
+                    }
+                }
+
+                if (hitNode) {
+                    window.activeNode = { layer: hitNode.layer, index: hitNode.index };
+                    window.isDragging = false; // Don't pan if we clicked a node
+                } else {
+                    window.activeNode = null;
+                    window.isDragging = true;
+                    window.lastX = e.clientX;
+                    window.lastY = e.clientY;
+                    canvas.style.cursor = 'grabbing';
+                }
+            });
+
+            window.addEventListener('mouseup', () => {
+                if (window.activeNode) {
+                    window.activeNode = null; // Release hold
+                }
+                window.isDragging = false;
+                if (canvas) canvas.style.cursor = 'grab';
+            });
+
+            canvas.addEventListener('mouseleave', () => {
+                window.isDragging = false;
+                if (canvas) canvas.style.cursor = 'grab';
+            });
+
+            canvas.addEventListener('mousemove', (e) => {
+                if (!window.isDragging) return;
+                const dx = e.clientX - window.lastX;
+                const dy = e.clientY - window.lastY;
+                window.panX += dx;
+                window.panY += dy;
+                window.lastX = e.clientX;
+                window.lastY = e.clientY;
+            });
+
+            canvas.addEventListener('wheel', (e) => {
+                e.preventDefault();
+                const zoomIntensity = 0.0015;
+                const rect = canvas.getBoundingClientRect();
+                const mouseX = e.clientX - rect.left;
+                const mouseY = e.clientY - rect.top;
+
+                const worldX = (mouseX - window.panX) / window.vizScale;
+                const worldY = (mouseY - window.panY) / window.vizScale;
+
+                const factor = Math.exp(-e.deltaY * zoomIntensity);
+                // Unlimited Zoom (0.001x to 1000x)
+                const newScale = Math.min(Math.max(0.001, window.vizScale * factor), 1000);
+
+                window.vizScale = newScale;
+                window.panX = mouseX - worldX * newScale;
+                window.panY = mouseY - worldY * newScale;
+            });
+
+            canvas.style.cursor = 'grab';
+        }
+
+        const data = window.displayData || window.latestData;
+        if (!data || !weights) return;
+
+        const ctx = canvas.getContext('2d');
+
+        // Resize & Auto-Expand
+        const pad = 40;
+        const iCount = data.inputs.length;
+        const hCount = data.hidden.length;
+        const oCount = data.outputs.length;
+
+        // Auto-Scale Spacing to prevent Overlap
+        // Ensure spacing is at least (Diameter + 2px padding)
+        const minSpacing = (window.smoothRadius * 2) + 2;
+
+        // Use effective spacing (User setting OR Minimum required)
+        const effSpacingInput = Math.max(window.smoothVSpacingInput, minSpacing);
+        const effSpacingHidden = Math.max(window.smoothVSpacingHidden, minSpacing);
+        const effSpacingOutput = Math.max(window.smoothVSpacingOutput, minSpacing);
+
+        // Calculate needed height
+        const hInput = (iCount - 1) * effSpacingInput;
+        const hHidden = (hCount - 1) * effSpacingHidden;
+        const hOutput = (oCount - 1) * effSpacingOutput;
+
+        const contentHeight = Math.max(hInput, hHidden, hOutput);
+        const neededHeight = contentHeight + (pad * 2);
+
+        if (canvas.parentElement) {
+            let clientW, clientH;
+
+            // Windowed Mode: Auto-expand height
+            clientW = canvas.parentElement.clientWidth;
+            clientH = Math.max(855, neededHeight);
+            canvas.style.width = clientW + 'px';
+            canvas.style.height = clientH + 'px';
+
+            // High-DPI Support
+            const dpr = window.devicePixelRatio || 1;
+
+            // Set physical size (resolution)
+            canvas.width = clientW * dpr;
+            canvas.height = clientH * dpr;
+        }
+
+        const w = canvas.width;
+        const h = canvas.height;
+        ctx.clearRect(0, 0, w, h);
+
+        // Reset node positions for this frame
+        window.nodePositions = [];
+
+        // Verify pan/zoom
+        ctx.save();
+
+        // Apply High-DPI Scale first
+        const dpr = window.devicePixelRatio || 1;
+        ctx.scale(dpr, dpr);
+
+        ctx.translate(window.panX, window.panY);
+        ctx.scale(window.vizScale, window.vizScale);
+
+        const layoutPad = 40;
+        // input, hidden(center), output
+        // Use Logical Width/Height for valid coordinates
+        const logicalW = canvas.width / dpr;
+        const logicalH = canvas.height / dpr;
+
+        const cx = logicalW / 2;
+        const cy = logicalH / 2;
+
+        // Horizontal layer centers (X)
+        const layerX_H = [cx - window.smoothLayerSpacing, cx, cx + window.smoothLayerSpacing];
+        // Vertical layer centers (Y)
+        const layerY_V = [cy - window.smoothLayerSpacing, cy, cy + window.smoothLayerSpacing];
+
+        function getPos(layerIdx, index, count, spacing) {
+            // Horizontal (Default)
+            const colH = (count - 1) * spacing;
+            const startY = (logicalH - colH) / 2;
+            const hX = layerX_H[layerIdx];
+            const hY = startY + index * spacing;
+
+            // Vertical
+            const colW = (count - 1) * spacing;
+            const startX = (logicalW - colW) / 2;
+            const vY = layerY_V[layerIdx];
+            const vX = startX + index * spacing;
+
+            // Blend
+            const f = window.smoothVerticalFactor;
+            return {
+                x: hX + (vX - hX) * f,
+                y: hY + (vY - hY) * f
+            };
+        }
+
+        // Draw Weights (Input -> Hidden)
+        for (let i = 0; i < iCount; i++) {
+            for (let j = 0; j < hCount; j++) {
+                // Visibility Check
+                let visible = true;
+                if (window.activeNode) {
+                    const an = window.activeNode;
+                    // Connects if: Active is Input(i) OR Active is Hidden(j)
+                    const connected = (an.layer === 'input' && an.index === i) ||
+                        (an.layer === 'hidden' && an.index === j);
+                    if (!connected) visible = false;
+                }
+
+                // Draw Faded or Full
+                let baseAlpha = visible ? window.smoothEdgeOpacity : 0.02;
+                let alpha = baseAlpha;
+
+                const weight = weights.ih[j][i];
+
+                if (visible) {
+                    // Smooth Blend for Opacity: Uniform vs Proportional
+                    // Proportional: Scale alpha by weight magnitude (min 0.1)
+                    const propAlpha = Math.min(baseAlpha, Math.max(0.1, Math.abs(weight) * baseAlpha));
+                    // Blend: baseAlpha (Uniform) -> propAlpha (Proportional)
+                    alpha = baseAlpha + (propAlpha - baseAlpha) * window.smoothPropOpacityFactor;
+
+                    // Signal-Based Visibility (Active Edges)
+                    // Signal = Source Node Activation * Weight
+                    const rawVal = data.inputs[i];
+                    const sourceVal = (rawVal && rawVal.val !== undefined) ? rawVal.val : rawVal;
+                    const signal = Math.abs(sourceVal * weight);
+                    // Signal Alpha: Scale by signal strength (boosted 3x for visibility)
+                    const signalAlpha = Math.min(baseAlpha, signal * 3.0);
+
+                    // Blend: Standard Alpha -> Signal Alpha based on smoothActiveFactor
+                    alpha = alpha + (signalAlpha - alpha) * window.smoothActiveFactor;
+                }
+
+                if (window.smoothEdgeWidth > 0.05) {
+                    ctx.beginPath();
+                    const p1 = getPos(0, i, iCount, effSpacingInput);
+                    const p2 = getPos(1, j, hCount, effSpacingHidden);
+
+                    ctx.moveTo(p1.x, p1.y);
+
+                    // Always use Bezier to allow interpolation (Straight <-> Curved)
+                    const x1 = p1.x;
+                    const y1 = p1.y;
+                    const x2 = p2.x;
+                    const y2 = p2.y;
+
+                    // Bezier Factor: 0.0 (CPs at ends) -> 1.0 (CPs at midpoints)
+                    const factor = window.smoothBezierFactor;
+
+                    // Calculate control points based on orientation
+                    const fV = window.smoothVerticalFactor;
+                    const dx = (x2 - x1) * 0.5 * factor;
+                    const dy = (y2 - y1) * 0.5 * factor;
+
+                    // Blend CP offsets: Horizontal uses X offset, Vertical uses Y offset
+                    const cx1 = x1 + dx * (1 - fV);
+                    const cy1 = y1 + dy * fV;
+                    const cx2 = x2 - dx * (1 - fV);
+                    const cy2 = y2 - dy * fV;
+
+                    ctx.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);
+
+                    // Smooth Weight Color Transition
+                    const weightColorTarget = weight > 0 ? window.posColor : window.negColor;
+                    const blendedColor = lerpColor(window.defaultEdgeColor, weightColorTarget, window.smoothWeightColorFactor, alpha);
+                    ctx.strokeStyle = blendedColor;
+
+                    // Smooth Blend: Uniform vs Proportional (Replaces above block visually if factor used)
+                    const wUniform = window.smoothEdgeWidth;
+                    const wProp = Math.abs(weight) * window.smoothEdgeWidth * 3;
+                    ctx.lineWidth = wUniform + (wProp - wUniform) * window.smoothPropFactor;
+
+                    ctx.stroke();
+                }
+            }
+        }
+
+        // Draw Weights (Hidden -> Output)
+        for (let j = 0; j < hCount; j++) {
+            for (let k = 0; k < oCount; k++) {
+                // Visibility Check
+                let visible = true;
+                if (window.activeNode) {
+                    const an = window.activeNode;
+                    const connected = (an.layer === 'hidden' && an.index === j) ||
+                        (an.layer === 'output' && an.index === k);
+                    if (!connected) visible = false;
+                }
+                let baseAlpha = visible ? window.smoothEdgeOpacity : 0.02;
+                let alpha = baseAlpha;
+
+                const weight = weights.ho[k][j];
+
+                if (visible) {
+                    // Smooth Blend for Opacity: Uniform vs Proportional
+                    const propAlpha = Math.min(baseAlpha, Math.max(0.1, Math.abs(weight) * baseAlpha));
+                    alpha = baseAlpha + (propAlpha - baseAlpha) * window.smoothPropOpacityFactor;
+
+                    // Signal-Based Visibility
+                    const rawVal = data.hidden[j];
+                    const sourceVal = (rawVal && rawVal.val !== undefined) ? rawVal.val : rawVal;
+                    const signal = Math.abs(sourceVal * weight);
+                    const signalAlpha = Math.min(baseAlpha, signal * 3.0);
+
+                    alpha = alpha + (signalAlpha - alpha) * window.smoothActiveFactor;
+                }
+
+                if (window.smoothEdgeWidth > 0.05) {
+                    ctx.beginPath();
+                    const p1 = getPos(1, j, hCount, effSpacingHidden);
+                    const p2 = getPos(2, k, oCount, effSpacingOutput);
+
+                    ctx.moveTo(p1.x, p1.y);
+
+                    // Always use Bezier to allow interpolation
+                    const x1 = p1.x;
+                    const y1 = p1.y;
+                    const x2 = p2.x;
+                    const y2 = p2.y;
+
+                    const factor = window.smoothBezierFactor;
+
+                    // Calculate control points based on orientation
+                    const fV = window.smoothVerticalFactor;
+                    const dx = (x2 - x1) * 0.5 * factor;
+                    const dy = (y2 - y1) * 0.5 * factor;
+
+                    // Blend CP offsets
+                    const cx1 = x1 + dx * (1 - fV);
+                    const cy1 = y1 + dy * fV;
+                    const cx2 = x2 - dx * (1 - fV);
+                    const cy2 = y2 - dy * fV;
+
+                    ctx.bezierCurveTo(cx1, cy1, cx2, cy2, x2, y2);
+
+                    // Smooth Weight Color Transition
+                    const weightColorTarget = weight > 0 ? window.posColor : window.negColor;
+                    const blendedColor = lerpColor(window.defaultEdgeColor, weightColorTarget, window.smoothWeightColorFactor, alpha);
+                    ctx.strokeStyle = blendedColor;
+
+                    // Smooth Blend: Uniform vs Proportional
+                    const wUniform = window.smoothEdgeWidth;
+                    const wProp = Math.abs(weight) * window.smoothEdgeWidth * 3;
+                    ctx.lineWidth = wUniform + (wProp - wUniform) * window.smoothPropFactor;
+
+                    ctx.stroke();
+                }
+            }
+        }
+
+
+
+
+
+        function drawLayerLabels(ctx, layerX_H, layerY_V, counts, logicalW, logicalH, contentHeight) {
+            ctx.save();
+            ctx.font = "12px Arial, sans-serif";
+            ctx.fillStyle = "rgb(84, 84, 84)";
+            const labels = ["Input Layer", "Hidden Layer", "Output Layer"];
+            const fV = window.smoothVerticalFactor;
+
+            const superscriptMap = {
+                '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴',
+                '5': '⁵', '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹'
+            };
+
+            for (let i = 0; i < 3; i++) {
+                const count = counts[i];
+                const superCount = count.toString().split('').map(c => superscriptMap[c] || c).join('');
+                const text = `${labels[i]} \u2208 \u211d${superCount}`;
+
+                // Horizontal Position
+                const hX = layerX_H[i];
+                const hY = (logicalH + contentHeight) / 2 + 40;
+
+                // Vertical Position
+                const vX = (logicalW + contentHeight) / 2 + 60;
+                const vY = layerY_V[i];
+
+                const finalX = hX + (vX - hX) * fV;
+                const finalY = hY + (vY - hY) * fV;
+
+                ctx.textAlign = fV > 0.5 ? "left" : "center";
+                ctx.fillText(text, finalX, finalY);
+            }
+            ctx.restore();
+        }
+
+        function drawLayer(count, activations, dummy_x, spacing, layerName, labels = null, biases = null) {
+            const radius = window.smoothRadius;
+            for (let i = 0; i < count; i++) {
+                try {
+                    const pos = getPos(getLayerIdx(layerName), i, count, spacing);
+                    const x = pos.x;
+                    const y = pos.y;
+                    let val = activations ? activations[i] : 0;
+
+                    // Robust Handling: Flatten arrays if nested JS arrays arrive
+                    if (Array.isArray(val)) val = val[0];
+                    if (val === undefined || val === null || isNaN(val)) val = 0;
+
+                    // --- Node Visibility Logic ---
+                    let visible = true;
+                    if (window.activeNode) {
+                        const an = window.activeNode;
+                        // Show if Self
+                        if (an.layer === layerName && an.index === i) visible = true;
+                        // Show if Neighbor
+                        else if (layerName === 'input' && an.layer === 'hidden') visible = true; // Is it ANY input? technically all inputs connect to all hiddens
+                        else if (layerName === 'hidden' && an.layer === 'input') visible = true;
+                        else if (layerName === 'hidden' && an.layer === 'output') visible = true;
+                        else if (layerName === 'output' && an.layer === 'hidden') visible = true;
+                        else visible = false;
+
+                        // Refined Neighbor Logic: only connected?
+                        // Since full dense, all Input<->Hidden are connected. All Hidden<->Output are connected.
+                        // So if I select Input3, ALL hidden nodes are neighbors.
+                        // If I select Hidden5, ALL inputs and ALL outputs are neighbors.
+                        // If I select Output2, ALL hidden nodes are neighbors.
+                        // So logical filtering:
+                        // If Active is Input: Show Active Input, All Hiddens.
+                        // If Active is Hidden: Show All Inputs, Active Hidden, All Outputs.
+                        // If Active is Output: Show All Hiddens, Active Output.
+
+                        // Actually, simpler visual:
+                        // Fade everything out.
+                        // Always show Active node full.
+                        // If Active is Input: Fade all other Inputs. Show Hiddens (neighbors) full.
+                        // If Active is Output: Fade all other Outputs. Show Hiddens (neighbors) full.
+                        // If Active is Hidden: Fade all other Hiddens. Show Inputs and Outputs full.
+
+                        // Let's implement this simpler node visibility logic:
+                        if (an.layer === layerName && an.index !== i) visible = false; // Hide siblings
+                        // Neighbors are strictly in adjacent layers
+                        if (Math.abs(getLayerIdx(layerName) - getLayerIdx(an.layer)) > 1) visible = false; // Hide non-neighbors
+                        // Wait, Input(0) and Output(2) diff is 2. So correct.
+                    }
+                    const alpha = visible ? 1.0 : 0.1;
+
+                    ctx.globalAlpha = alpha;
+
+                    ctx.beginPath();
+                    ctx.fillStyle = window.nodeColor;
+                    ctx.lineWidth = 0.5;
+                    ctx.strokeStyle = window.nodeBorderColor;
+
+                    if (window.usePixelNodes) {
+                        // Rasterized Circle (Round Pixel)
+                        // Dynamic pSize for better roundness
+                        let pSize = Math.max(1, Math.floor(radius / 4));
+
+                        for (let dy = -radius; dy <= radius; dy += pSize) {
+                            for (let dx = -radius; dx <= radius; dx += pSize) {
+                                const dist = Math.sqrt(dx * dx + dy * dy);
+
+                                if (dist <= radius) {
+                                    // Default to Border
+                                    ctx.fillStyle = window.nodeBorderColor;
+
+                                    // Inner Fill Logic (Radius - BorderThickness)
+                                    // Standard border is 0.5 lineWidth, here let's make it 1 pSize unit
+                                    if (dist <= radius - pSize) {
+                                        ctx.fillStyle = window.nodeColor;
+
+                                        // Activation Logic (Inner-most core)
+                                        // val is 0.0 to 1.0. 
+                                        // If we are deep enough inside relative to activation size?
+                                        // Activation Radius = radius * 0.5 * val? No, just proportional fill.
+                                        // Original logic: radius * 0.5 + val * (radius * 0.5)
+                                        const actRadius = (radius * 0.5) + (val * radius * 0.5);
+                                        if (dist <= actRadius) {
+                                            // Blend Logic? Canvas doesn't support per-pixel alpha easily in this loop efficiently
+                                            // So just decide check:
+                                            // Activation color is black with alpha val.
+                                            // Here we just make it dark gray magnitude?
+                                            // Simpler: If within activation radius, draw activation color (black)
+                                            // Logic: inner fill is white. Activation is black overlay.
+                                            // If we are in activation zone, draw gray/black based on strength?
+                                            // Improved: If val > 0.1 and dist <= (radius * 0.8 * val), draw Black.
+                                            // Let's mimic original:
+                                            // Original draws Fill(NodeColor) THEN Fill(BlackAlpha).
+                                            // Here we pick ONE color for the pixel.
+
+                                            // Mix NodeColor and Black based on val?
+                                            // If NodeColor is White, result is Grey.
+                                            // Simply: If dist < actRadius, draw Darker.
+                                            if (dist <= radius * val) {
+                                                ctx.fillStyle = `rgba(0,0,0,${val})`;
+                                                // Note: rgba works with fillRect, it blends with canvas background (white? transparent?)
+                                                // But we are drawing pixel-by-pixel. Overlap?
+                                                // Actually, if we just set fillStyle to rgba(0,0,0,val) and draw rect
+                                                // over the canvas, it's fine.
+                                                // BUT we need to paint the NodeColor underneath first if transparency matters?
+                                                // Yes.
+                                            }
+                                        }
+                                    }
+
+                                    // Draw Pixel
+                                    // Snap to integer grid to avoid anti-aliasing artifacts
+                                    const px = Math.floor(x + dx);
+                                    const py = Math.floor(y + dy);
+
+                                    // 1. Draw Solid Base (Hides background lines)
+                                    // We must reset fillStyle to nodeColor or nodeBorderColor based on position
+                                    if (dist <= radius - pSize) {
+                                        ctx.fillStyle = window.nodeColor;
+                                    } else {
+                                        ctx.fillStyle = window.nodeBorderColor;
+                                    }
+                                    ctx.fillRect(px, py, pSize, pSize);
+
+                                    // 2. Draw Semi-Transparent Activation on Top
+                                    const absVal = Math.abs(val);
+                                    if (dist <= radius - pSize) {
+                                        if (dist <= radius * absVal) { // Math Fix
+                                            if (window.useNodeActivationColor) {
+                                                const color = val > 0 ? window.posColor : window.negColor;
+                                                ctx.fillStyle = color;
+                                                ctx.globalAlpha = Math.min(absVal, 1.0);
+                                                ctx.fillRect(px, py, pSize, pSize);
+                                                ctx.globalAlpha = 1.0;
+                                            } else {
+                                                ctx.fillStyle = `rgba(0, 0, 0, ${absVal})`;
+                                                ctx.fillRect(px, py, pSize, pSize);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
+                    } else {
+                        // Original Vector Circle
+                        ctx.fillStyle = window.nodeColor;
+                        ctx.lineWidth = 0.5;
+                        ctx.strokeStyle = window.nodeBorderColor;
+                        ctx.beginPath();
+                        ctx.arc(x, y, radius, 0, Math.PI * 2);
+                        ctx.fill();
+                        ctx.stroke();
+
+                        // Activation
+                        const absVal = Math.abs(val);
+                        // Clamp Radius Calculation
+                        // Math Fix: Use absVal for sizing. 
+                        // Logic: Base inner circle is 0.5r. Grow to 1.0r with activation.
+                        const actRadius = radius * 0.5 + Math.min(absVal, 1.0) * (radius * 0.5);
+
+                        ctx.beginPath();
+                        ctx.arc(x, y, actRadius, 0, Math.PI * 2);
+
+                        if (window.useNodeActivationColor) {
+                            // Color Mode
+                            const color = val > 0 ? window.posColor : window.negColor;
+                            ctx.fillStyle = color;
+                            ctx.globalAlpha = Math.min(absVal, 1.0); // Use global alpha for hex colors
+                            ctx.fill();
+                            ctx.globalAlpha = 1.0;
+                        } else {
+                            // Grayscale Mode (Math Fix Applied)
+                            ctx.fillStyle = `rgba(0,0,0,${Math.min(absVal, 1.0)})`;
+                            ctx.fill();
+                        }
+                    }
+
+                    // Bias Visualization (Indicator)
+                    // Draw small dot/square on top-right rim
+                    // Bias range is usually -0.5 to 0.5 or larger.
+
+                    if (window.showBiases && biases && biases[i] !== undefined) {
+                        const biasVal = Array.isArray(biases[i]) ? biases[i][0] : biases[i]; // Handle [val] format
+                        const biasMag = Math.abs(biasVal);
+                        // Color Logic: Red for Negative, Green for Positive
+                        const biasColor = biasVal >= 0 ? "rgb(0, 255, 0)" : "rgb(255, 0, 0)";
+
+                        if (window.usePixelNodes) {
+                            // Pixel Indiciator on rim
+                            const pSize = Math.max(1, Math.floor(radius / 4));
+                            // Position: Top Right Corner relative to center
+                            // 45 degrees. dx = r * 0.707
+                            const offset = Math.floor(radius * 0.75);
+                            const px = Math.floor(x + offset);
+                            const py = Math.floor(y - offset);
+
+                            ctx.fillStyle = biasColor;
+                            ctx.fillRect(px, py, pSize * 2, pSize * 2); // Slightly larger dot
+                        } else {
+                            // Vector Indicator
+                            const offset = radius * 0.8;
+                            const bx = x + offset;
+                            const by = y - offset;
+
+                            ctx.beginPath();
+                            ctx.arc(bx, by, radius * 0.3, 0, Math.PI * 2);
+                            ctx.fillStyle = biasColor;
+                            ctx.fill();
+                            // Optional border for visibility?
+                            // ctx.strokeStyle = "black";
+                            // ctx.lineWidth = 0.5;
+                            // ctx.stroke();
+                        }
+                    }
+
+                    if (labels && labels[i]) {
+                        ctx.save();
+                        ctx.fillStyle = "rgb(84, 84, 84)";
+                        ctx.font = "10px 'PressStart2P'";
+
+                        const fV = window.smoothVerticalFactor;
+
+                        // Target Positions & Rotation
+                        // Horizontal (fV=0): x-12, y+4, rot=0
+                        // Vertical (fV=1): x, y-20, rot=-90deg
+                        const targetRot = -Math.PI / 2;
+                        const currentRot = targetRot * fV;
+
+                        const hX = x - 12;
+                        const hY = y + 4;
+                        const vX = x;
+                        const vY = y - 20;
+
+                        const finalX = hX + (vX - hX) * fV;
+                        const finalY = hY + (vY - hY) * fV;
+
+                        ctx.translate(finalX, finalY);
+                        ctx.rotate(currentRot);
+
+                        ctx.textAlign = fV > 0.5 ? "left" : "right";
+                        ctx.fillText(labels[i] + " " + val.toFixed(2), 0, 0);
+
+                        ctx.restore();
+                    }
+
+                } catch (err) {
+                    // Suppress error to allow other nodes to draw
+                    // console.error("Node draw error:", err); 
+                }
+            }
+        }
+
+        function getLayerIdx(name) {
+            if (name === 'input') return 0;
+            if (name === 'hidden') return 1;
+            if (name === 'output') return 2;
+            return -1;
+        }
+
+        drawLayer(iCount, data.inputs, null, effSpacingInput, 'input', ["Obj1 Dist", "Obj1 Act", "Obj1 W", "Obj2 Dist", "Obj2 Act", "Obj2 W", "Speed", "Gap", "DinoY", "DinoVel", "Air", "Duck"]);
+        drawLayer(hCount, data.hidden, null, effSpacingHidden, 'hidden', null, weights.bh);
+        drawLayer(oCount, data.outputs, null, effSpacingOutput, 'output', null, weights.bo);
+
+        // Draw Dynamic Layer Labels (Math Notation)
+        drawLayerLabels(ctx, layerX_H, layerY_V, [iCount, hCount, oCount], logicalW, logicalH, contentHeight);
+
+        // Labels Output
+        const outLabels = ["JUMP", "DUCK", "RUN"];
+        const fV = window.smoothVerticalFactor;
+
+        for (let i = 0; i < oCount; i++) {
+            const pos = getPos(2, i, oCount, effSpacingOutput);
+            ctx.save();
+            ctx.fillStyle = "rgb(84, 84, 84)";
+            ctx.font = "10px 'PressStart2P'";
+
+            const fV = window.smoothVerticalFactor;
+
+            // Target Positions & Rotation
+            // Horizontal (fV=0): x+15, y+4, rot=0
+            // Vertical (fV=1): x, y+25, rot=90deg
+            const targetRot = Math.PI / 2;
+            const currentRot = targetRot * fV;
+
+            const hX = pos.x + 15;
+            const hY = pos.y + 4;
+            const vX = pos.x;
+            const vY = pos.y + 30;
+
+            const finalX = hX + (vX - hX) * fV;
+            const finalY = hY + (vY - hY) * fV;
+
+            ctx.translate(finalX, finalY);
+            ctx.rotate(currentRot);
+
+            ctx.textAlign = "left";
+            ctx.fillText(outLabels[i] + " " + Math.round(data.outputs[i] * 100) + "%", 0, 0);
+            ctx.restore();
+        }
+
+        ctx.restore();
+    }
+
+    // Start loop
+    requestAnimationFrame(renderLoop);
+}

pydino/background_el.py

@@ -0,0 +1,195 @@
+# background_el.py
+# 1:1 pygame port of Chrome Dino background_el.ts
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+
+import pygame
+
+try:
+    from constants import IS_HIDPI
+    from utils import get_random_num
+except ImportError:
+    from .constants import IS_HIDPI
+    from .utils import get_random_num  # alias -> utils.get_random_num
+
+
+# -----------------------------------------------------------------------------
+# Config dataclasses (TS interface eşdeğerleri)
+# -----------------------------------------------------------------------------
+@dataclass
+class BackgroundElSpriteConfig:
+    height: int
+    width: int
+    offset: int
+    xPos: int
+    fixed: bool
+    fixedXPos: Optional[int] = None
+    fixedYPos1: Optional[int] = None
+    fixedYPos2: Optional[int] = None
+
+
+@dataclass
+class BackgroundElConfig:
+    maxBgEls: int
+    maxGap: int
+    minGap: int
+    pos: int
+    speed: float
+    yPos: int
+    msPerFrame: int = 0  # only needed when spriteConfig.fixed is true
+
+
+# -----------------------------------------------------------------------------
+# Global config (TS: module-level mutable)
+# -----------------------------------------------------------------------------
+_global_config = BackgroundElConfig(
+    maxBgEls=0,
+    maxGap=0,
+    minGap=0,
+    msPerFrame=0,
+    pos=0,
+    speed=0.0,
+    yPos=0,
+)
+
+
+def get_global_config() -> BackgroundElConfig:
+    return _global_config
+
+
+def set_global_config(config: BackgroundElConfig) -> None:
+    global _global_config
+    _global_config = config
+
+
+# TS-style aliases (opsiyonel)
+getGlobalConfig = get_global_config
+setGlobalConfig = set_global_config
+
+
+# -----------------------------------------------------------------------------
+# Background element
+# -----------------------------------------------------------------------------
+class BackgroundEl:
+    gap: int
+    xPos: float
+    remove: bool
+
+    def __init__(
+        self,
+        canvas: pygame.Surface,
+        spritePos: Dict[str, int],  # SpritePosition {x,y}
+        containerWidth: int,
+        type_name: str,
+        imageSpriteProvider: Any,  # ImageSpriteProvider
+    ) -> None:
+        """
+        Background item. Similar to cloud, without random y position.
+        """
+        self.canvas: pygame.Surface = canvas
+        self.canvasCtx: pygame.Surface = canvas
+        self.spritePos = spritePos
+        self.imageSpriteProvider = imageSpriteProvider
+
+        self.xPos = float(containerWidth)
+        self.type = type_name
+        self.remove = False
+
+        # Rastgele gap
+        gc = get_global_config()
+        self.gap = getRandomNum(gc.minGap, gc.maxGap)
+
+        # Sprite config'i provider'dan al
+        sprite_def = imageSpriteProvider.getSpriteDefinition()
+        assert sprite_def is not None
+        cfg_raw = sprite_def["backgroundEl"][self.type]
+        # cfg_raw dict → dataclass'a sar
+        self.spriteConfig = BackgroundElSpriteConfig(
+            height=int(cfg_raw["height"]),
+            width=int(cfg_raw["width"]),
+            offset=int(cfg_raw["offset"]),
+            xPos=int(cfg_raw["xPos"]),
+            fixed=bool(cfg_raw["fixed"]),
+            fixedXPos=cfg_raw.get("fixedXPos"),
+            fixedYPos1=cfg_raw.get("fixedYPos1"),
+            fixedYPos2=cfg_raw.get("fixedYPos2"),
+        )
+
+        # Y konumu / sabit x ayarı
+        self.yPos: float = 0.0
+        self.animTimer: float = 0.0
+        self.switchFrames: bool = False
+
+        self.init()
+
+    # ------------------------------------------------------------------
+    # TS parity methods
+    # ------------------------------------------------------------------
+    def init(self) -> None:
+        if self.spriteConfig.fixed and self.spriteConfig.fixedXPos is not None:
+            self.xPos = float(self.spriteConfig.fixedXPos)
+
+        gc = get_global_config()
+        # yPos = global.yPos - height + offset
+        self.yPos = float(gc.yPos - self.spriteConfig.height + self.spriteConfig.offset)
+
+        self.draw()
+
+    def draw(self) -> None:
+        imageSprite: pygame.Surface = self.imageSpriteProvider.getRunnerImageSprite()
+        assert imageSprite is not None
+
+        # Kaynak kare (sprite sheet üzerinde)
+        sourceWidth = self.spriteConfig.width
+        sourceHeight = self.spriteConfig.height
+        sourceX = self.spriteConfig.xPos
+        sourceY = self.spritePos["y"]
+
+        scale = 2 if IS_HIDPI else 1
+        sx = sourceX * scale
+        sy = sourceY * scale
+        sw = sourceWidth * scale
+        sh = sourceHeight * scale
+
+        src_rect = pygame.Rect(sx, sy, sw, sh)
+        frame = imageSprite.subsurface(src_rect).copy()
+
+        # Hedef boyut: lo-dpi mantıksal piksel (TS çizimde output=sourceWidth/Height;
+        # pygame tarafında HiDPI için 2x örneklediğimiz kareyi mantıksal boyuta indiriyoruz)
+        if frame.get_width() != sourceWidth or frame.get_height() != sourceHeight:
+            frame = pygame.transform.scale(frame, (sourceWidth, sourceHeight))
+
+        # Blit
+        self.canvasCtx.blit(frame, (int(self.xPos), int(self.yPos)))
+
+    def update(self, speed: float) -> None:
+        if self.remove:
+            return
+
+        if self.spriteConfig.fixed:
+            gc = get_global_config()
+            # Animasyon zamanlayıcı (msPerFrame zorunlu)
+            assert gc.msPerFrame is not None
+            self.animTimer += speed
+            if self.animTimer > gc.msPerFrame:
+                self.animTimer = 0.0
+                self.switchFrames = not self.switchFrames
+
+            if self.spriteConfig.fixedYPos1 is not None and self.spriteConfig.fixedYPos2 is not None:
+                self.yPos = float(self.spriteConfig.fixedYPos1 if self.switchFrames else self.spriteConfig.fixedYPos2)
+        else:
+            # Sabit hız (oyun hızından bağımsız)
+            self.xPos -= get_global_config().speed
+
+        self.draw()
+
+        # Canvas dışında kaldı mı?
+        if not self.isVisible():
+            self.remove = True
+
+    def isVisible(self) -> bool:
+        # Sağ kenar > 0 ise görünür
+        return (self.xPos + self.spriteConfig.width) > 0

pydino/cloud.py

@@ -0,0 +1,120 @@
+# cloud.py
+# 1:1 pygame port of Chrome Dino cloud.ts
+
+from __future__ import annotations
+
+import math
+from typing import Any, Dict
+
+import pygame
+
+try:
+    from constants import IS_HIDPI
+    from utils import get_random_num
+except ImportError:
+    from .constants import IS_HIDPI
+    from .utils import get_random_num
+
+
+class CloudConfig:
+    HEIGHT = 14
+    MAX_CLOUD_GAP = 400
+    MAX_SKY_LEVEL = 30
+    MIN_CLOUD_GAP = 100
+    MIN_SKY_LEVEL = 71
+    WIDTH = 46
+
+
+def _pos(obj: Dict[str, int] | Any, key: str) -> int:
+    """Accept both dict-like {'x':...} and attr-like .x."""
+    if isinstance(obj, dict):
+        return int(obj[key])
+    return int(getattr(obj, key))
+
+
+class Cloud:
+    """Cloud background item.
+    Obstacle'a benzer ama çarpışma kutusu yok.
+    """
+
+    # TS: public fields
+    gap: int
+    xPos: float
+    remove: bool = False
+
+    # TS: private yPos/canvasCtx/spritePos/imageSpriteProvider
+    _yPos: float
+    _canvas: pygame.Surface
+    _spritePos: Dict[str, int] | Any
+    _imageSpriteProvider: Any
+
+    def __init__(
+        self,
+        canvas: pygame.Surface,
+        sprite_pos: Dict[str, int] | Any,
+        container_width: int,
+        image_sprite_provider: Any,  # ImageSpriteProvider
+    ) -> None:
+        self._canvas = canvas
+        self._spritePos = sprite_pos
+        self._imageSpriteProvider = image_sprite_provider
+
+        self.xPos = float(container_width)
+        self.gap = get_random_num(CloudConfig.MIN_CLOUD_GAP, CloudConfig.MAX_CLOUD_GAP)
+        self.remove = False
+        self._yPos = 0.0
+
+        self.init()
+
+    # ------------------------------------------------------------------ #
+    # TS: init() — bulutun yüksekliğini belirle ve çiz
+    # ------------------------------------------------------------------ #
+    def init(self) -> None:
+        self._yPos = float(
+            get_random_num(CloudConfig.MAX_SKY_LEVEL, CloudConfig.MIN_SKY_LEVEL)
+        )
+        self.draw()
+
+    # ------------------------------------------------------------------ #
+    # TS: draw()
+    # ------------------------------------------------------------------ #
+    def draw(self) -> None:
+        runner_image_sprite: pygame.Surface = self._imageSpriteProvider.getRunnerImageSprite()
+        assert runner_image_sprite is not None, "Runner image sprite is required"
+
+        source_w = CloudConfig.WIDTH
+        source_h = CloudConfig.HEIGHT
+        output_w = source_w
+        output_h = source_h
+
+        # HiDPI ise kaynak 2x
+        if IS_HIDPI:
+            source_w *= 2
+            source_h *= 2
+
+        src_x = _pos(self._spritePos, "x")
+        src_y = _pos(self._spritePos, "y")
+
+        src_rect = pygame.Rect(src_x, src_y, source_w, source_h)
+        frame = runner_image_sprite.subsurface(src_rect).copy()
+        if frame.get_size() != (output_w, output_h):
+            frame = pygame.transform.scale(frame, (output_w, output_h))
+
+        self._canvas.blit(frame, (int(self.xPos), int(self._yPos)))
+
+    # ------------------------------------------------------------------ #
+    # TS: update(speed)
+    # ------------------------------------------------------------------ #
+    def update(self, speed: float) -> None:
+        if not self.remove:
+            self.xPos -= math.ceil(speed)
+            self.draw()
+
+            if not self.isVisible():
+                self.remove = True
+
+    # ------------------------------------------------------------------ #
+    # TS: isVisible()
+    # ------------------------------------------------------------------ #
+    def isVisible(self) -> bool:
+        return (self.xPos + CloudConfig.WIDTH) > 0

pydino/constants.py

@@ -0,0 +1,33 @@
+# constants.py
+# 1:1 port of Chrome Dino constants.ts for a pygame project.
+
+from __future__ import annotations
+import os
+import sys
+from dimensions import Dimensions  # width, height dataclass
+
+# Browser-only bayrakların pygame eşleniği:
+# - IS_IOS / IS_MOBILE: masaüstünde genelde False. İstersen ENV ile zorlayabilirsin.
+# - IS_HIDPI: tarayıcıdaki devicePixelRatio yerine ENV kullanıyoruz (varsayılan False).
+# - IS_RTL: DOM yok; ister ENV ile ayarla, ister sabit False kalsın.
+
+def _env_flag(name: str, default: bool = False) -> bool:
+    val = os.environ.get(name)
+    if val is None:
+        return default
+    return val.strip().lower() in ("1", "true", "yes", "on")
+
+# TODO(salg): Use preprocessor to filter IOS code at build time.  (TS notunu koruyoruz)
+IS_IOS: bool = _env_flag("NEURODINO_IOS", default=("ios" in sys.platform))
+IS_HIDPI: bool = _env_flag("NEURODINO_HIDPI", default=False)
+IS_MOBILE: bool = _env_flag(
+    "NEURODINO_MOBILE",
+    default=("android" in sys.platform or IS_IOS),
+)
+IS_RTL: bool = _env_flag("NEURODINO_RTL", default=False)
+
+# Frames per second.
+FPS: int = 60
+
+# Default logical dimensions of the game surface.
+DEFAULT_DIMENSIONS: Dimensions = Dimensions(width=600, height=150)

pydino/debug_overlay.py

@@ -0,0 +1,65 @@
+# debug_overlay.py
+import pygame
+
+def _get(obj, name, default=None):
+    """Safe attribute/key getter: works with objects or dicts."""
+    if hasattr(obj, name):
+        return getattr(obj, name)
+    if isinstance(obj, dict):
+        return obj.get(name, default)
+    return default
+
+class CollisionDebugOverlay:
+    def __init__(self):
+        # Varsayılan kapalı; F3 ile toggle
+        self.enabled = False
+
+    def draw(self, screen: pygame.Surface, trex, obstacles: list):
+        if not self.enabled or trex is None:
+            return
+
+        # --- T-Rex ana hitbox
+        tw = int(_get(trex.config, "width", 44))
+        th = int(_get(trex.config, "height", 47))
+        t_rect = pygame.Rect(
+            int(trex.xPos) + 1,
+            int(trex.yPos) + 1,
+            max(1, tw - 2),
+            max(1, th - 2),
+        )
+        pygame.draw.rect(screen, (0, 255, 0), t_rect, 1)
+
+        # --- T-Rex parçalı kutular
+        for b in trex.getCollisionBoxes():
+            r = pygame.Rect(
+                int(trex.xPos) + 1 + int(b.x),
+                int(trex.yPos) + 1 + int(b.y),
+                int(b.width),
+                int(b.height),
+            )
+            pygame.draw.rect(screen, (0, 200, 0), r, 1)
+
+        if not obstacles:
+            return
+
+        # --- İlk engelin ana hitbox'ı (istersen tümünü dolaşabilirsin)
+        ob = obstacles[0]
+        ow = int(_get(ob.typeConfig, "width", 0))
+        oh = int(_get(ob.typeConfig, "height", 0))
+        o_rect = pygame.Rect(
+            int(ob.xPos) + 1,
+            int(ob.yPos) + 1,
+            max(1, ow * int(getattr(ob, "size", 1)) - 2),
+            max(1, oh - 2),
+        )
+        pygame.draw.rect(screen, (255, 0, 0), o_rect, 1)
+
+        # --- Engelin parçalı kutuları
+        for b in getattr(ob, "collisionBoxes", []):
+            r = pygame.Rect(
+                int(ob.xPos) + 1 + int(b.x),
+                int(ob.yPos) + 1 + int(b.y),
+                int(b.width),
+                int(b.height),
+            )
+            pygame.draw.rect(screen, (200, 0, 0), r, 1)

pydino/dimensions.py

@@ -0,0 +1,8 @@
+# dimensions.py
+# 1:1 port of dimensions.ts (Chrome Dino)
+from dataclasses import dataclass
+
+@dataclass
+class Dimensions:
+    width: int
+    height: int

pydino/distance_meter.py

@@ -0,0 +1,302 @@
+# distance_meter.py
+# 1:1 pygame port of Chrome Dino distance_meter.ts
+
+from __future__ import annotations
+
+from typing import List, Optional, Tuple, Any
+
+import pygame
+
+try:
+    from constants import IS_HIDPI, IS_RTL
+except ImportError:
+    from .constants import IS_HIDPI, IS_RTL
+from offline_sprite_definitions import CollisionBox
+# SpritePosition: dict-like {"x": int, "y": int}
+from utils import getTimeStamp
+
+
+# ---------------------------------------------------------------------------
+# Dimensions / Config (TS'deki enum sabitleri)
+# ---------------------------------------------------------------------------
+class _Dim:
+    WIDTH = 10        # tek rakam kaynağındaki genişlik
+    HEIGHT = 13       # tek rakam kaynağındaki yükseklik
+    DEST_WIDTH = 11   # hedefte rakamlar arası adım
+
+
+class _Cfg:
+    MAX_DISTANCE_UNITS = 5
+    ACHIEVEMENT_DISTANCE = 100
+    COEFFICIENT = 0.025
+    FLASH_DURATION = 1000 / 4          # ms
+    FLASH_ITERATIONS = 3
+    HIGH_SCORE_HIT_AREA_PADDING = 4
+
+
+class DistanceMeter:
+    achievement: bool = False
+
+    def __init__(self, canvas: pygame.Surface, spritePos: dict, canvasWidth: int,
+                 imageSpriteProvider: Any) -> None:
+        """Handles displaying the distance meter."""
+        self.canvas = canvas
+        self.canvasCtx = canvas  # pygame.Surface
+        self.image: pygame.Surface = imageSpriteProvider.getRunnerImageSprite()
+        self.spritePos = spritePos  # {"x": int, "y": int}
+
+        self.x: int = 0
+        self.y: int = 5
+        self.maxScore: int = 0
+        self.highScore: str = ""
+        self._show_high_score: bool = False
+        self.digits: List[str] = []
+        self.defaultString: str = ""
+        self.flashTimer: float = 0.0
+        self.flashIterations: int = 0
+
+        self.flashingRafId = None  # TS uyumu için placeholder
+        self.highScoreBounds: Optional[CollisionBox] = None
+        self.highScoreFlashing: bool = False
+        self.maxScoreUnits: int = _Cfg.MAX_DISTANCE_UNITS
+        self.canvasWidth: int = canvasWidth
+        self.frameTimeStamp: Optional[int] = None
+
+        self.init(canvasWidth)
+
+    # -----------------------------------------------------------------------
+    # TS parity methods
+    # -----------------------------------------------------------------------
+    def init(self, width: int) -> None:
+        """Initialise the distance meter to '00000'."""
+        maxDistanceStr = ""
+        self.calcXpos(width)
+        self.maxScore = self.maxScoreUnits
+        for i in range(self.maxScoreUnits):
+            self.draw(i, 0)
+            self.defaultString += "0"
+            maxDistanceStr += "9"
+        self.maxScore = int(maxDistanceStr, 10)
+
+    def calcXpos(self, canvasWidth: int) -> None:
+        """Calculate the xPos in the canvas."""
+        self.x = canvasWidth - (_Dim.DEST_WIDTH * (self.maxScoreUnits + 1))
+
+    def _blit_sprite_digit(self, source_x: int, source_y: int, source_w: int, source_h: int,
+                           dest_x: int, dest_y: int, dest_w: int, dest_h: int) -> None:
+        """Helper: copy region from sprite sheet and blit to canvas, handling HiDPI."""
+        scale = 2 if IS_HIDPI else 1
+        sx = source_x * scale
+        sy = source_y * scale
+        sw = source_w * scale
+        sh = source_h * scale
+
+        src_rect = pygame.Rect(sx, sy, sw, sh)
+        frame = self.image.subsurface(src_rect).copy()
+
+        # hedef boyut (lo-dpi mantığı) sabit: WIDTH/HEIGHT
+        if frame.get_width() != dest_w or frame.get_height() != dest_h:
+            frame = pygame.transform.scale(frame, (dest_w, dest_h))
+
+        self.canvasCtx.blit(frame, (dest_x, dest_y))
+
+    def draw(self, digitPos: int, value: int, highScore: bool = False) -> None:
+        """Draw a digit to canvas."""
+        sourceWidth = _Dim.WIDTH
+        sourceHeight = _Dim.HEIGHT
+        sourceX = _Dim.WIDTH * value
+        sourceY = 0
+
+        # Hedefte rakamlar dEST_WIDTH ile yan yana
+        targetX = digitPos * _Dim.DEST_WIDTH
+        targetY = self.y
+        targetWidth = _Dim.WIDTH
+        targetHeight = _Dim.HEIGHT
+
+        # Kaynak sprite sheet ofsetleri
+        sourceX += int(self.spritePos["x"])
+        sourceY += int(self.spritePos["y"])
+
+        # RTL konumlama (TS'deki translate + scale yerine mutlak X hesaplıyoruz)
+        if IS_RTL:
+            if highScore:
+                translateX = self.canvasWidth - (_Dim.WIDTH * (self.maxScoreUnits + 3))
+            else:
+                translateX = self.canvasWidth - _Dim.WIDTH
+            dest_x = translateX - targetX  # ayna etkisi nedeniyle ters
+        else:
+            highScoreX = self.x - (self.maxScoreUnits * 2) * _Dim.WIDTH
+            dest_base = highScoreX if highScore else self.x
+            dest_x = dest_base + targetX
+
+        dest_y = targetY
+
+        self._blit_sprite_digit(sourceX, sourceY, sourceWidth, sourceHeight,
+                                dest_x, dest_y, targetWidth, targetHeight)
+
+    def getActualDistance(self, distance: float) -> int:
+        """Convert pixel distance to a 'real' distance."""
+        return int(round(distance * _Cfg.COEFFICIENT)) if distance else 0
+
+    def update(self, deltaTime: float, distance: float) -> bool:
+        """Update the distance meter. Returns whether achievement sound should play."""
+        paint = True
+        playSound = False
+
+        if not self.achievement:
+            distance_real = self.getActualDistance(distance)
+
+            # Score genişlerse bir haneyi arttır
+            if distance_real > self.maxScore and self.maxScoreUnits == _Cfg.MAX_DISTANCE_UNITS:
+                self.maxScoreUnits += 1
+                self.maxScore = int(f"{self.maxScore}9", 10)
+
+            if distance_real > 0:
+                # Achievement
+                if distance_real % _Cfg.ACHIEVEMENT_DISTANCE == 0:
+                    self.achievement = True
+                    self.flashTimer = 0.0
+                    playSound = True
+
+                # '00042' gibi sol sıfırlarla dizgi
+                s = (self.defaultString + str(distance_real))[-self.maxScoreUnits:]
+                self.digits = list(s)
+            else:
+                self.digits = list(self.defaultString)
+        else:
+            # Achievement flashing
+            if self.flashIterations <= _Cfg.FLASH_ITERATIONS:
+                self.flashTimer += deltaTime
+                if self.flashTimer < _Cfg.FLASH_DURATION:
+                    paint = False
+                elif self.flashTimer > _Cfg.FLASH_DURATION * 2:
+                    self.flashTimer = 0.0
+                    self.flashIterations += 1
+            else:
+                self.achievement = False
+                self.flashIterations = 0
+                self.flashTimer = 0.0
+
+        # Draw digits
+        if paint:
+            for i in range(len(self.digits) - 1, -1, -1):
+                self.draw(i, int(self.digits[i]))
+
+        # High score daima üstüne çizilir
+        self.drawHighScore()
+
+        # (TS: flashHighScore ayrı rAF ile çalışır) — burada da ilerletelim:
+        if self.highScoreFlashing:
+            self._step_high_score_flash(deltaTime)
+
+        return playSound
+
+    def drawHighScore(self) -> None:
+        if not getattr(self, "_show_high_score", False) or len(self.highScore) == 0:
+            return
+
+        # Yüksek skoru biraz saydam çiz
+        # pygame: global alpha yok; yüzeyi geçici modla doldurmak yerine direkt çiziyoruz
+        # (görsel eşleşme tam değil ama işlev aynı)
+        for i in range(len(self.highScore) - 1, -1, -1):
+            ch = self.highScore[i]
+            # 0-9 normal; 'H'->10, 'I'->11
+            if ch.isdigit():
+                pos = int(ch)
+            elif ch == "H":
+                pos = 10
+            elif ch == "I":
+                pos = 11
+            else:
+                continue
+            self.draw(i, pos, True)
+
+    def setHighScore(self, distance: float) -> None:
+        distance_real = self.getActualDistance(distance)
+        s = (self.defaultString + str(distance_real))[-self.maxScoreUnits:]
+        self.highScore = "HI " + s
+        self._show_high_score = True
+
+    # -----------------------------------------------------------------------
+    # High score mouse/touch alanı ve flashing
+    # -----------------------------------------------------------------------
+    def hasClickedOnHighScore(self, e: Any) -> bool:
+        """Pygame uyarlaması: e.pos veya (x,y) tuple bekler."""
+        if isinstance(e, tuple) and len(e) == 2:
+            x, y = e
+        elif hasattr(e, "pos"):
+            x, y = getattr(e, "pos")
+        else:
+            # Diğer event tipleri desteklenmiyor; dışarıdan (x,y) ile çağır.
+            return False
+
+        self.highScoreBounds = self.getHighScoreBounds()
+        hb = self.highScoreBounds
+        return (x >= hb.x and x <= hb.x + hb.width and
+                y >= hb.y and y <= hb.y + hb.height)
+
+    def getHighScoreBounds(self) -> CollisionBox:
+        return CollisionBox(
+            x=(self.x - (self.maxScoreUnits * 2) * _Dim.WIDTH) - _Cfg.HIGH_SCORE_HIT_AREA_PADDING,
+            y=self.y,
+            width=_Dim.WIDTH * (len(self.highScore) + 1) + _Cfg.HIGH_SCORE_HIT_AREA_PADDING,
+            height=_Dim.HEIGHT + (_Cfg.HIGH_SCORE_HIT_AREA_PADDING * 2),
+        )
+
+    def _step_high_score_flash(self, deltaTime: float) -> None:
+        """TS'deki requestAnimationFrame döngüsünü deltaTime ile taklit eder."""
+        now = getTimeStamp()
+        prev = self.frameTimeStamp or now
+        self.frameTimeStamp = now
+
+        # Reached max flashes?
+        if self.flashIterations > _Cfg.FLASH_ITERATIONS * 2:
+            self.cancelHighScoreFlashing()
+            return
+
+        paint = True
+        self.flashTimer += (now - prev) if deltaTime == 0 else deltaTime
+        if self.flashTimer < _Cfg.FLASH_DURATION:
+            paint = False
+        elif self.flashTimer > _Cfg.FLASH_DURATION * 2:
+            self.flashTimer = 0.0
+            self.flashIterations += 1
+
+        if paint:
+            self.drawHighScore()
+        else:
+            self.clearHighScoreBounds()
+
+    def clearHighScoreBounds(self) -> None:
+        if not self.highScoreBounds:
+            self.highScoreBounds = self.getHighScoreBounds()
+        hb = self.highScoreBounds
+        rect = pygame.Rect(hb.x, hb.y, hb.width, hb.height)
+        pygame.draw.rect(self.canvasCtx, (247, 247, 247), rect)
+
+    def startHighScoreFlashing(self) -> None:
+        self.highScoreFlashing = True
+        # TS rAF yerine zaman damgası başlat
+        self.frameTimeStamp = getTimeStamp()
+        self.flashTimer = 0.0
+        self.flashIterations = 0
+
+    def isHighScoreFlashing(self) -> bool:
+        return self.highScoreFlashing
+
+    def cancelHighScoreFlashing(self) -> None:
+        self.flashIterations = 0
+        self.flashTimer = 0.0
+        self.highScoreFlashing = False
+        self.clearHighScoreBounds()
+        self.drawHighScore()
+
+    def resetHighScore(self) -> None:
+        self.highScore = ""
+        self._show_high_score = False
+        self.cancelHighScoreFlashing()
+
+    def reset(self) -> None:
+        """Reset the distance meter back to '00000'."""
+        self.update(0, 0)
+        self.achievement = False

pydino/game_over_panel.py

@@ -0,0 +1,272 @@
+# game_over_panel.py
+# 1:1 pygame port of Chrome Dino game_over_panel.ts
+
+from __future__ import annotations
+
+from typing import Optional, Any, Dict
+
+import pygame
+
+try:
+    from constants import IS_HIDPI, IS_RTL
+except ImportError:
+    from .constants import IS_HIDPI, IS_RTL
+from dimensions import Dimensions
+from offline_sprite_definitions import sprite_definition_by_type
+from utils import getTimeStamp
+
+
+RESTART_ANIM_DURATION: int = 875
+LOGO_PAUSE_DURATION: int = 875
+FLASH_ITERATIONS: int = 5
+
+
+class _AnimConfig:
+    frames = [0, 36, 72, 108, 144, 180, 216, 252]
+    msPerFrame = RESTART_ANIM_DURATION / 8
+
+
+class _DefaultPanelDims:
+    # TS: GameOverPanelDimensions
+    textX = 0
+    textY = 13
+    textWidth = 191
+    textHeight = 11
+    restartWidth = 36
+    restartHeight = 32
+
+
+class GameOverPanel:
+    def __init__(
+        self,
+        canvas: pygame.Surface,
+        text_img_pos: Dict[str, int],      # SpritePosition: {"x": int, "y": int}
+        restart_img_pos: Dict[str, int],   # SpritePosition
+        dimensions: Dimensions,
+        image_sprite_provider: Any,
+        alt_game_end_img_pos: Optional[Dict[str, int]] = None,  # SpritePosition
+        alt_game_active: Optional[bool] = None,
+    ) -> None:
+        self.canvasCtx: pygame.Surface = canvas
+        self.canvasDimensions: Dimensions = dimensions
+        self.textImgPos = text_img_pos
+        self.restartImgPos = restart_img_pos
+        self.imageSpriteProvider = image_sprite_provider
+        self.altGameEndImgPos = alt_game_end_img_pos
+        self.altGameModeActive: bool = bool(alt_game_active)
+
+        self.frameTimeStamp: int = 0
+        self.animTimer: float = 0.0
+        self.currentFrame: int = 0
+
+        self.flashTimer: float = 0.0
+        self.flashCounter: int = 0
+        self.originalText: bool = True
+
+    # ------------------------------------------------------------------ #
+    # Public API                                                          #
+    # ------------------------------------------------------------------ #
+    def update_dimensions(self, width: int, height: Optional[int] = None) -> None:
+        self.canvasDimensions.width = width
+        if height is not None:
+            self.canvasDimensions.height = height
+        # Boyut değiştiğinde animasyonu son kareye ayarla
+        self.currentFrame = len(_AnimConfig.frames) - 1
+
+    def draw(self, alt_game_mode_active: Optional[bool] = None, t_rex: Optional[Any] = None) -> None:
+        if alt_game_mode_active is not None:
+            self.altGameModeActive = alt_game_mode_active
+
+        # Metni (orijinal) çiz
+        self._draw_game_over_text(_DefaultPanelDims, use_alt_text=False)
+        # Restart butonu (mevcut frame)
+        self._draw_restart_button()
+        # Alt game öğeleri TRex üzerinde
+        if t_rex is not None:
+            self._draw_alt_game_elements(t_rex)
+
+        # Zaman ve animasyon adımı
+        self._step()
+
+    def reset(self) -> None:
+        self.animTimer = 0.0
+        self.frameTimeStamp = 0
+        self.currentFrame = 0
+        self.flashTimer = 0.0
+        self.flashCounter = 0
+        self.originalText = True
+
+    # ------------------------------------------------------------------ #
+    # Internal                                                            #
+    # ------------------------------------------------------------------ #
+    def _draw_game_over_text(self, dims, use_alt_text: bool = False) -> None:
+        centerX = self.canvasDimensions.width / 2
+
+        textSourceX = dims.textX
+        textSourceY = dims.textY
+        textSourceWidth = dims.textWidth
+        textSourceHeight = dims.textHeight
+
+        textTargetX = round(centerX - (dims.textWidth / 2))
+        textTargetY = round((self.canvasDimensions.height - 25) / 3)
+        textTargetWidth = dims.textWidth
+        textTargetHeight = dims.textHeight
+
+        if IS_HIDPI:
+            textSourceY *= 2
+            textSourceX *= 2
+            textSourceWidth *= 2
+            textSourceHeight *= 2
+
+        if not use_alt_text:
+            textSourceX += int(self.textImgPos["x"])
+            textSourceY += int(self.textImgPos["y"])
+
+        spriteSource = (
+            self.imageSpriteProvider.getAltCommonImageSprite()
+            if use_alt_text
+            else self.imageSpriteProvider.getOrigImageSprite()
+        )
+        assert spriteSource is not None
+
+        # Kaynaktan bölge
+        src_rect = pygame.Rect(textSourceX, textSourceY, textSourceWidth, textSourceHeight)
+        frame = spriteSource.subsurface(src_rect).copy()
+        if frame.get_size() != (textTargetWidth, textTargetHeight):
+            frame = pygame.transform.scale(frame, (textTargetWidth, textTargetHeight))
+
+        # RTL: ayna konumlandırma
+        if IS_RTL:
+            dest_x = self.canvasDimensions.width - textTargetX - textTargetWidth
+        else:
+            dest_x = textTargetX
+
+        self.canvasCtx.blit(frame, (dest_x, textTargetY))
+
+    def _draw_alt_game_elements(self, t_rex: Any) -> None:
+        spriteDefinition = self.imageSpriteProvider.getSpriteDefinition()
+        if self.altGameModeActive and spriteDefinition:
+            assert self.altGameEndImgPos is not None
+            alt_cfg = spriteDefinition.get("altGameEndConfig")
+            assert alt_cfg is not None
+
+            alt_w = int(alt_cfg["width"])
+            alt_h = int(alt_cfg["height"])
+            target_x = int(t_rex.xPos + alt_cfg["xOffset"])
+            target_y = int(t_rex.yPos + alt_cfg["yOffset"])
+
+            src_w = alt_w * (2 if IS_HIDPI else 1)
+            src_h = alt_h * (2 if IS_HIDPI else 1)
+
+            altCommon = self.imageSpriteProvider.getAltCommonImageSprite()
+            assert altCommon is not None
+
+            src_rect = pygame.Rect(self.altGameEndImgPos["x"], self.altGameEndImgPos["y"], src_w, src_h)
+            frame = altCommon.subsurface(src_rect).copy()
+            if frame.get_size() != (alt_w, alt_h):
+                frame = pygame.transform.scale(frame, (alt_w, alt_h))
+
+            # RTL: sadece x'i aynala
+            if IS_RTL:
+                dest_x = self.canvasDimensions.width - target_x - alt_w
+            else:
+                dest_x = target_x
+
+            self.canvasCtx.blit(frame, (dest_x, target_y))
+
+    def _draw_restart_button(self) -> None:
+        dims = _DefaultPanelDims
+        # Clamp frame index to avoid IndexError when animation steps past last frame
+        frame_index = self.currentFrame
+        if frame_index < 0:
+            frame_index = 0
+        max_idx = len(_AnimConfig.frames) - 1
+        if frame_index > max_idx:
+            frame_index = max_idx
+            
+        framePosX = _AnimConfig.frames[frame_index]
+        src_w = dims.restartWidth
+        src_h = dims.restartHeight
+
+        target_x = int((self.canvasDimensions.width / 2) - (dims.restartWidth / 2))
+        target_y = int(self.canvasDimensions.height / 2)
+
+        if IS_HIDPI:
+            src_w *= 2
+            src_h *= 2
+            framePosX *= 2
+
+        origSprite = self.imageSpriteProvider.getOrigImageSprite()
+        assert origSprite is not None
+
+        src_rect = pygame.Rect(self.restartImgPos["x"] + framePosX, self.restartImgPos["y"], src_w, src_h)
+        frame = origSprite.subsurface(src_rect).copy()
+        if frame.get_size() != (dims.restartWidth, dims.restartHeight):
+            frame = pygame.transform.scale(frame, (dims.restartWidth, dims.restartHeight))
+
+        if IS_RTL:
+            dest_x = self.canvasDimensions.width - target_x - dims.restartWidth
+        else:
+            dest_x = target_x
+
+        self.canvasCtx.blit(frame, (dest_x, target_y))
+
+    def _clear_game_over_text_bounds(self, dims=_DefaultPanelDims) -> None:
+        # TS clearRect → pygame'de beyaz dolduruyoruz
+        rect = pygame.Rect(
+            round(self.canvasDimensions.width / 2 - (dims.textWidth / 2)),
+            round((self.canvasDimensions.height - 25) / 3),
+            dims.textWidth,
+            dims.textHeight + 4,
+        )
+        # <--- DÜZELTME: Renk (255, 255, 255) yerine (247, 247, 247) olmalı
+        pygame.draw.rect(self.canvasCtx, (247, 247, 247), rect)
+
+    def _step(self) -> None:
+        now = getTimeStamp()
+        delta = now - (self.frameTimeStamp or now)
+        self.frameTimeStamp = now
+        self.animTimer += delta
+        self.flashTimer += delta
+
+        # Restart logosu animasyonu
+        if self.currentFrame == 0 and self.animTimer > LOGO_PAUSE_DURATION:
+            self.animTimer = 0
+            self.currentFrame += 1
+            # self._draw_restart_button() # <--- Çizim zaten draw() içinde yapılıyor
+        # <--- === DÜZELTME 1: Animasyonun son karede durması için ===
+        elif 0 < self.currentFrame < len(_AnimConfig.frames) - 1:
+        # =========================================================
+            if self.animTimer >= _AnimConfig.msPerFrame:
+                self.currentFrame += 1
+                # self._draw_restart_button() # <--- Çizim zaten draw() içinde yapılıyor
+
+        # <--- === DÜZELTME 2: Döngüye neden olan bloğu kaldır ===
+        # elif (not self.altGameModeActive) and self.currentFrame == len(_AnimConfig.frames):
+        #     self.reset()
+        #     return
+        # =====================================================
+
+        # Game Over yazısı (Alt game metni / flashing)
+        altTextCfg = sprite_definition_by_type["original"].get("altGameOverTextConfig")
+        if self.altGameModeActive and altTextCfg:
+            if altTextCfg.get("flashing"):
+                if self.flashCounter < FLASH_ITERATIONS and self.flashTimer > altTextCfg["flashDuration"]:
+                    self.flashTimer = 0
+                    self.originalText = not self.originalText
+                    self._clear_game_over_text_bounds()
+                    if self.originalText:
+                        self._draw_game_over_text(_DefaultPanelDims, use_alt_text=False)
+                        self.flashCounter += 1
+                    else:
+                        self._draw_game_over_text(altTextCfg, use_alt_text=True)
+                elif self.flashCounter >= FLASH_ITERATIONS:
+                    # <--- DÜZELTME 3: Döngüyü kaldır, sadece geç ===
+                    # self.reset()
+                    # return
+                    pass
+                    # ==============================================
+            else:
+                # flash yoksa, doğrudan alt metni bas
+                self._clear_game_over_text_bounds(altTextCfg)
+                self._draw_game_over_text(altTextCfg, use_alt_text=True)

pydino/horizon.py

@@ -0,0 +1,352 @@
+# horizon.py
+# Pygame port of horizon.ts (dict/attr uyumlu, 1:1 mantık)
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+from typing import Any, Callable, List, Optional
+
+import pygame
+
+try:
+    # Senin utils.py farklı isimde olabilir.
+    from utils import get_random_num as getRandomNum
+except Exception:
+    from utils import getRandomNum  # type: ignore
+
+from background_el import (
+    BackgroundEl,
+    get_global_config as getBackgroundElGlobalConfig,
+    set_global_config as setBackgroundElGlobalConfig,
+)
+from cloud import Cloud
+from dimensions import Dimensions
+from horizon_line import HorizonLine
+from image_sprite_provider import ImageSpriteProvider
+from night_mode import NightMode
+from obstacle import (
+    Obstacle,
+    set_max_gap_coefficient as setMaxObstacleGapCoefficient,
+    set_max_obstacle_length as setMaxObstacleLength,
+)
+from offline_sprite_definitions import sprite_definition_by_type
+
+
+__all__ = ["Horizon"]  # dışa açık isim
+
+def _get(container: Any, key: str, default: Any = None) -> Any:
+    """dict / obj uyumlu erişim."""
+    if hasattr(container, key):
+        return getattr(container, key)
+    if isinstance(container, dict):
+        return container.get(key, default)
+    return default
+
+
+@dataclass(frozen=True)
+class HorizonConfig:
+    BG_CLOUD_SPEED: float
+    BUMPY_THRESHOLD: float
+    CLOUD_FREQUENCY: float
+    HORIZON_HEIGHT: int
+    MAX_CLOUDS: int
+
+
+horizonConfig = HorizonConfig(
+    BG_CLOUD_SPEED=0.2,
+    BUMPY_THRESHOLD=0.3,
+    CLOUD_FREQUENCY=0.5,
+    HORIZON_HEIGHT=16,
+    MAX_CLOUDS=6,
+)
+
+
+class Horizon:
+    obstacles: List[Obstacle]
+
+    def __init__(
+        self,
+        canvas: pygame.Surface,
+        spritePos: dict,           # SpritePositions (dict)
+        dimensions: Dimensions,
+        gapCoefficient: float,
+        resourceProvider: ImageSpriteProvider,  # + getConfig(), hasSlowdown, hasAudioCues
+    ) -> None:
+        self.obstacles = []
+        self.canvas = canvas
+        self.canvasCtx = canvas  # pygame Surface
+        self.config = horizonConfig
+        self.dimensions = dimensions
+        self.gapCoefficient = gapCoefficient
+        self.resourceProvider = resourceProvider
+
+        self.obstacleHistory: List[str] = []
+        self.cloudFrequency = self.config.CLOUD_FREQUENCY
+        self.spritePos = spritePos
+        self.cloudSpeed = self.config.BG_CLOUD_SPEED
+
+        self.altGameModeActive: bool = False
+        self.obstacleTypes: List[dict] = []
+
+        # Collections
+        self.clouds: List[Cloud] = []
+        self.backgroundEls: List[BackgroundEl] = []
+        self.lastEl: Optional[str] = None
+        self.horizonLines: List[HorizonLine] = []
+
+        # Başlangıç tanımları
+        self.obstacleTypes = list(sprite_definition_by_type["original"]["obstacles"])
+        self.addCloud()
+
+        runnerSpriteDefinition = self.resourceProvider.getSpriteDefinition()
+        assert runnerSpriteDefinition is not None
+
+        for lineDef in runnerSpriteDefinition["lines"]:
+            self.horizonLines.append(
+                HorizonLine(self.canvas, lineDef, self.resourceProvider)
+            )
+
+        self.nightMode = NightMode(
+            self.canvas, _get(self.spritePos, "moon"), self.dimensions.width, self.resourceProvider
+        )
+
+    # -------- helpers --------
+    def adjustObstacleSpeed(self) -> None:
+        """Slow mode için obstacle tanımlarını ayarla."""
+        if not getattr(self.resourceProvider, "hasSlowdown", False):
+            return
+        for ob in self.obstacleTypes:
+            # Güvenli okuma: yoksa değiştirmiyoruz
+            if "multipleSpeed" in ob and isinstance(ob["multipleSpeed"], (int, float)):
+                ob["multipleSpeed"] = ob["multipleSpeed"] / 2
+            if "minGap" in ob and isinstance(ob["minGap"], (int, float)):
+                ob["minGap"] = ob["minGap"] * 1.5
+            if "minSpeed" in ob and isinstance(ob["minSpeed"], (int, float)):
+                ob["minSpeed"] = ob["minSpeed"] / 2
+            yPos = ob.get("yPos")
+            if isinstance(yPos, list) and len(yPos) > 1:
+                ob["yPos"] = yPos[0]
+
+    def enableAltGameMode(self, spritePos: dict) -> None:
+        runnerSpriteDefinition = self.resourceProvider.getSpriteDefinition()
+        assert runnerSpriteDefinition is not None
+
+        # temizle
+        self.clouds = []
+        self.backgroundEls = []
+
+        self.altGameModeActive = True
+        self.spritePos = spritePos
+
+        self.obstacleTypes = list(runnerSpriteDefinition["obstacles"])
+        self.adjustObstacleSpeed()
+
+        setMaxObstacleGapCoefficient(runnerSpriteDefinition["maxGapCoefficient"])
+        setMaxObstacleLength(runnerSpriteDefinition["maxObstacleLength"])
+        setBackgroundElGlobalConfig(runnerSpriteDefinition["backgroundElConfig"])
+
+        self.horizonLines = []
+        for lineDef in runnerSpriteDefinition["lines"]:
+            self.horizonLines.append(
+                HorizonLine(self.canvas, lineDef, self.resourceProvider)
+            )
+        self.reset()
+
+    # -------- frame update --------
+    def update(
+        self,
+        deltaTime: float,
+        currentSpeed: float,
+        updateObstacles: bool,
+        showNightMode: bool,
+    ) -> None:
+        runnerSpriteDefinition = self.resourceProvider.getSpriteDefinition()
+        assert runnerSpriteDefinition is not None
+
+        if self.altGameModeActive:
+            self._updateBackgroundEls(deltaTime)
+
+        for line in self.horizonLines:
+            line.update(deltaTime, currentSpeed)
+
+        if (not self.altGameModeActive) or runnerSpriteDefinition["hasClouds"]:
+            self.nightMode.update(showNightMode)
+            self._updateClouds(deltaTime, currentSpeed)
+
+        if updateObstacles:
+            self._updateObstacles(deltaTime, currentSpeed)
+
+    # -------- background elements / clouds --------
+    def _updateBackgroundEl(
+        self,
+        elSpeed: float,
+        bgElArray: List[Cloud | BackgroundEl],
+        maxBgEl: int,
+        bgElAddFunction: Callable[[], None],
+        frequency: float,
+    ) -> None:
+        numElements = len(bgElArray)
+
+        if not numElements:
+            bgElAddFunction()
+            return
+
+        for i in range(numElements - 1, -1, -1):
+            bgElArray[i].update(elSpeed)
+
+        lastEl = bgElArray[-1]
+
+        if (
+            numElements < maxBgEl
+            and (self.dimensions.width - lastEl.xPos) > getattr(lastEl, "gap", 0)
+            and frequency > random.random()
+        ):
+            bgElAddFunction()
+
+    def _updateClouds(self, deltaTime: float, speed: float) -> None:
+        elSpeed = self.cloudSpeed / 1000.0 * deltaTime * speed
+        self._updateBackgroundEl(
+            elSpeed, self.clouds, self.config.MAX_CLOUDS, self.addCloud, self.cloudFrequency
+        )
+        # temizle
+        self.clouds = [c for c in self.clouds if not c.remove]
+
+    def _updateBackgroundEls(self, deltaTime: float) -> None:
+        self._updateBackgroundEl(
+            deltaTime,
+            self.backgroundEls,
+            _get(getBackgroundElGlobalConfig(), "maxBgEls"),
+            self.addBackgroundEl,
+            self.cloudFrequency,
+        )
+        self.backgroundEls = [b for b in self.backgroundEls if not b.remove]
+
+    # -------- obstacles --------
+    def _updateObstacles(self, deltaTime: float, currentSpeed: float) -> None:
+        updated = self.obstacles[:]
+        for ob in self.obstacles:
+            ob.update(deltaTime, currentSpeed)
+            if ob.remove and updated:
+                updated.pop(0)
+        self.obstacles = updated
+
+        if self.obstacles:
+            last = self.obstacles[-1]
+            if (
+                last
+                and not last.followingObstacleCreated
+                and last.isVisible()
+                and (last.xPos + last.width + last.gap) < self.dimensions.width
+            ):
+                self.addNewObstacle(currentSpeed)
+                last.followingObstacleCreated = True
+        else:
+            self.addNewObstacle(currentSpeed)
+
+    def removeFirstObstacle(self) -> None:
+        if self.obstacles:
+            self.obstacles.pop(0)
+
+    def addNewObstacle(self, currentSpeed: float) -> None:
+        if not self.obstacleTypes:
+            return
+
+        lastType = self.obstacleTypes[-1]
+        lastTypeName = _get(lastType, "type")
+
+        if (
+            lastTypeName != "collectable"
+            or (
+                getattr(self.resourceProvider, "isAltGameModeEnabled", lambda: False)()
+                and not self.altGameModeActive
+            )
+            or self.altGameModeActive
+        ):
+            obstacleCount = len(self.obstacleTypes) - 1
+        else:
+            obstacleCount = len(self.obstacleTypes) - 2
+
+        idx = getRandomNum(0, obstacleCount) if obstacleCount > 0 else 0
+        obstacleType = self.obstacleTypes[idx]
+        obstacleTypeName = _get(obstacleType, "type")
+
+        # tekrar & hız kontrol
+        if (
+            (obstacleCount > 0 and self.duplicateObstacleCheck(obstacleTypeName))
+            or currentSpeed < float(_get(obstacleType, "minSpeed", 0))
+        ):
+            self.addNewObstacle(currentSpeed)
+            return
+
+        obstacleSpritePos = _get(self.spritePos, obstacleTypeName)
+
+        self.obstacles.append(
+            Obstacle(
+                self.canvasCtx,
+                obstacleType,
+                obstacleSpritePos,
+                self.dimensions,
+                self.gapCoefficient,
+                currentSpeed,
+                int(_get(obstacleType, "width", 0)),
+                self.resourceProvider,   # ImageSpriteProvider & GameStateProvider
+                self.altGameModeActive,
+            )
+        )
+
+        self.obstacleHistory.insert(0, obstacleTypeName)
+        if len(self.obstacleHistory) > 1:
+            maxDup = _get(self.resourceProvider.getConfig(), "maxObstacleDuplication", 2)
+            del self.obstacleHistory[int(maxDup):]
+
+    def duplicateObstacleCheck(self, nextType: str) -> bool:
+        dup = 0
+        for t in self.obstacleHistory:
+            if t == nextType:
+                dup += 1
+            else:
+                dup = 0
+        maxDup = _get(self.resourceProvider.getConfig(), "maxObstacleDuplication", 2)
+        return dup >= maxDup
+
+    # -------- misc --------
+    def reset(self) -> None:
+        self.obstacles = []
+        for line in self.horizonLines:
+            line.reset()
+        self.nightMode.reset()
+
+    def resize(self, width: int, height: int) -> None:
+        # pygame Surface boyutu display.set_mode ile ayarlanır; burada no-op
+        pass
+
+    def addCloud(self) -> None:
+        self.clouds.append(
+            Cloud(self.canvas, _get(self.spritePos, "cloud"), self.dimensions.width, self.resourceProvider)
+        )
+
+    def addBackgroundEl(self) -> None:
+        runnerSpriteDefinition = self.resourceProvider.getSpriteDefinition()
+        assert runnerSpriteDefinition is not None
+        backgroundElDict = runnerSpriteDefinition["backgroundEl"]
+        backgroundElTypes = list(backgroundElDict.keys())
+        if not backgroundElTypes:
+            return
+
+        index = getRandomNum(0, len(backgroundElTypes) - 1)
+        elType = backgroundElTypes[index]
+        while elType == self.lastEl and len(backgroundElTypes) > 1:
+            index = getRandomNum(0, len(backgroundElTypes) - 1)
+            elType = backgroundElTypes[index]
+
+        self.lastEl = elType
+        self.backgroundEls.append(
+            BackgroundEl(
+                self.canvas,
+                _get(self.spritePos, "backgroundEl"),
+                self.dimensions.width,
+                elType,
+                self.resourceProvider,
+            )
+        )

pydino/horizon_line.py

@@ -0,0 +1,114 @@
+# horizon_line.py
+# Pygame port of horizon_line.ts (dict/attr uyumlu)
+
+from __future__ import annotations
+
+from typing import Any, Dict, Tuple
+import pygame
+
+try:
+    from constants import FPS, IS_HIDPI
+except ImportError:
+    from .constants import FPS, IS_HIDPI
+from image_sprite_provider import ImageSpriteProvider
+
+SpritePosition = Dict[str, int]  # {"x": int, "y": int}
+
+def _get(container: Any, key: str, default=None):
+    if isinstance(container, dict):
+        return container.get(key, default)
+    return getattr(container, key, default)
+
+class HorizonLine:
+    def __init__(
+        self,
+        canvas: pygame.Surface,
+        line_config: Dict[str, int] | Any,
+        image_sprite_provider: ImageSpriteProvider,
+    ) -> None:
+        # Kaynak konumları (sprite sheet içindeki yatay 2 parça)
+        source_x = _get(line_config, "sourceX")
+        source_y = _get(line_config, "sourceY")
+        width = _get(line_config, "width")
+        height = _get(line_config, "height")
+        self.yPos = _get(line_config, "yPos")
+
+        if source_x is None or source_y is None or width is None or height is None:
+            raise ValueError("HorizonLine: line_config eksik alan içeriyor.")
+
+        if IS_HIDPI:
+            source_x *= 2
+            source_y *= 2
+
+        # Canvas & provider
+        self.canvas = canvas
+        self.canvasCtx = canvas  # pygame Surface
+        self.imageSpriteProvider = image_sprite_provider
+
+        # Sprite sheet üzerindeki başlangıç x’leri
+        self.spritePos: SpritePosition = {"x": source_x, "y": source_y}
+        self.dimensions: Tuple[int, int] = (width, height)
+
+        # İki parça halinde zemin çizgisi
+        self.sourceXPos = [self.spritePos["x"], self.spritePos["x"] + width]
+        self.xPos = [0, width]
+
+        # Kesilecek kaynak boyutları (HiDPI’de 2x)
+        self.sourceDimensions = {
+            "width": width * (2 if IS_HIDPI else 1),
+            "height": height * (2 if IS_HIDPI else 1),
+        }
+
+        self.bumpThreshold = 0.5  # bumpy/flat geçiş olasılığı
+        self.draw()
+
+    def getRandomType(self) -> int:
+        """Bumpy/flat seçimi: ikinci parçanın kaynak offset’i."""
+        return self.dimensions[0] if (pygame.time.get_ticks() % 1000) / 1000.0 > self.bumpThreshold else 0
+
+    def draw(self) -> None:
+        runner_image = self.image_sprite_provider_image()
+        sw = self.sourceDimensions["width"]
+        sh = self.sourceDimensions["height"]
+        dw, dh = self.dimensions
+
+        # parça 1
+        self.canvasCtx.blit(
+            runner_image,
+            (self.xPos[0], self.yPos),
+            (self.sourceXPos[0], self.spritePos["y"], sw, sh),
+        )
+        # parça 2
+        self.canvasCtx.blit(
+            runner_image,
+            (self.xPos[1], self.yPos),
+            (self.sourceXPos[1], self.spritePos["y"], sw, sh),
+        )
+
+    def updatexPos(self, pos: int, increment: int) -> None:
+        line1 = pos
+        line2 = 1 - pos
+
+        self.xPos[line1] -= increment
+        self.xPos[line2] = self.xPos[line1] + self.dimensions[0]
+
+        if self.xPos[line1] <= -self.dimensions[0]:
+            self.xPos[line1] += self.dimensions[0] * 2
+            self.xPos[line2] = self.xPos[line1] - self.dimensions[0]
+            # bumpy/flat seçimi: ikinci “kaynak x” başlangıcı
+            self.sourceXPos[line1] = self.getRandomType() + self.spritePos["x"]
+
+    def update(self, deltaTime: float, speed: float) -> None:
+        increment = int(speed * (FPS / 1000.0) * deltaTime)
+        self.updatexPos(0 if self.xPos[0] <= 0 else 1, increment)
+        self.draw()
+
+    def reset(self) -> None:
+        self.xPos[0] = 0
+        self.xPos[1] = self.dimensions[0]
+
+    # ---- helpers ----
+    def image_sprite_provider_image(self) -> pygame.Surface:
+        img = self.imageSpriteProvider.getRunnerImageSprite()
+        assert img is not None
+        return img

pydino/image_sprite_provider.py

@@ -0,0 +1,80 @@
+# image_sprite_provider.py
+# 1:1 pygame port of image_sprite_provider.ts (interface + a simple impl)
+
+from __future__ import annotations
+
+from typing import Optional, Protocol
+
+import pygame
+
+from offline_sprite_definitions import SpriteDefinition, sprite_definition_by_type
+
+
+class ImageSpriteProvider(Protocol):
+    """Dino oyununda paylaşılan sprite sheet'lere erişim arayüzü."""
+
+    def getOrigImageSprite(self) -> pygame.Surface: ...
+    def getRunnerImageSprite(self) -> pygame.Surface: ...
+    def getRunnerAltGameImageSprite(self) -> Optional[pygame.Surface]: ...
+    def getAltCommonImageSprite(self) -> Optional[pygame.Surface]: ...
+    def getSpriteDefinition(self) -> SpriteDefinition: ...
+
+
+def _load_image(path: str) -> pygame.Surface:
+    """Load image with guaranteed alpha preservation, even before display init."""
+    if not pygame.get_init():
+        pygame.init()
+    if not pygame.display.get_init():
+        pygame.display.init()
+        pygame.display.set_mode((1, 1))
+    surf = pygame.image.load(path)
+    if surf.get_alpha() is not None:
+        surf = surf.convert_alpha()
+    else:
+        surf = surf.convert()
+        surf.set_colorkey((0, 0, 0))
+    return surf
+
+
+def _get_original_sprite_definition() -> SpriteDefinition:
+    """TS tarafında spriteDefinitionByType.original vardı;
+    Python port'unda dict/attr her iki olasılığı da destekle."""
+    try:
+        return sprite_definition_by_type["original"]  # dict tarzı
+    except Exception:
+        return getattr(sprite_definition_by_type, "original")  # attr tarzı
+
+
+class PygameImageSpriteProvider(ImageSpriteProvider):
+    """Basit bir sağlayıcı: tek bir sprite sheet kullanır (orig=runner).
+    Alt oyun görselleri opsiyoneldir (None döner)."""
+
+    def __init__(
+        self,
+        sprite_path: str,
+        *,
+        alt_game_path: Optional[str] = None,
+        alt_common_path: Optional[str] = None,
+    ) -> None:
+        self._orig = _load_image(sprite_path)
+        # Chrome dino'da orig ve runner aynı sheet olabilir; bire bir yapıyoruz.
+        self._runner = self._orig
+        self._alt_game = _load_image(alt_game_path) if alt_game_path else None
+        self._alt_common = _load_image(alt_common_path) if alt_common_path else None
+        self._sprite_def = _get_original_sprite_definition()
+
+    # --- ImageSpriteProvider implementation ---
+    def getOrigImageSprite(self) -> pygame.Surface:
+        return self._orig
+
+    def getRunnerImageSprite(self) -> pygame.Surface:
+        return self._runner
+
+    def getRunnerAltGameImageSprite(self) -> Optional[pygame.Surface]:
+        return self._alt_game
+
+    def getAltCommonImageSprite(self) -> Optional[pygame.Surface]:
+        return self._alt_common
+
+    def getSpriteDefinition(self) -> SpriteDefinition:
+        return self._sprite_def

pydino/night_mode.py

@@ -0,0 +1,149 @@
+# night_mode.py
+# Pygame port of night_mode.ts (dict/attr uyumlu)
+
+from __future__ import annotations
+from typing import Any, Dict, List, TypedDict
+import pygame
+
+try:
+    from constants import IS_HIDPI
+except ImportError:
+    from .constants import IS_HIDPI
+from offline_sprite_definitions import sprite_definition_by_type
+from utils import get_random_num
+
+# Ay fazlarının spritesheet içindeki x-pozisyonları (ldpi referansı)
+PHASES: List[int] = [140, 120, 100, 60, 40, 20, 0]
+
+class _Cfg:
+    FADE_SPEED = 0.035
+    HEIGHT = 40
+    MOON_SPEED = 0.25
+    NUM_STARS = 2
+    STAR_SIZE = 9
+    STAR_SPEED = 0.3
+    STAR_MAX_Y = 70
+    WIDTH = 20
+
+class NightMode:
+    def __init__(
+        self,
+        canvas: pygame.Surface,
+        sprite_pos: Dict[str, int],   # {"x": int, "y": int}
+        container_width: int,
+        image_sprite_provider
+    ) -> None:
+        self.canvas = canvas
+        self.canvasCtx = canvas
+        self.sprite_pos = sprite_pos
+        self.provider = image_sprite_provider
+
+        self.container_width = container_width
+
+        self.xPos: float = 0.0
+        self.yPos: float = 30.0
+        self.currentPhase: int = 0
+        self.opacity: float = 0.0
+        self.drawStars: bool = False
+
+        # yıldızlar: x,y, sourceY
+        self.stars: List[Dict[str, float]] = [dict(x=0.0, y=0.0, sourceY=0.0) for _ in range(_Cfg.NUM_STARS)]
+
+        self._place_stars()
+
+    def update(self, activated: bool) -> None:
+        # Ay fazı geçişi yalnızca görünür olmaya başlarken değişsin
+        if activated and self.opacity == 0:
+            self.currentPhase += 1
+            if self.currentPhase >= len(PHASES):
+                self.currentPhase = 0
+
+        # Fade in / out
+        if activated and (self.opacity < 1 or self.opacity == 0):
+            self.opacity += _Cfg.FADE_SPEED
+            if self.opacity > 1:
+                self.opacity = 1
+        elif self.opacity > 0:
+            self.opacity -= _Cfg.FADE_SPEED
+            if self.opacity < 0:
+                self.opacity = 0
+
+        # Pozisyon güncelle / çiz
+        if self.opacity > 0:
+            self.xPos = self._update_xpos(self.xPos, _Cfg.MOON_SPEED)
+            if self.drawStars:
+                for s in self.stars:
+                    s["x"] = self._update_xpos(float(s["x"]), _Cfg.STAR_SPEED)
+            self._draw()
+        else:
+            # Görünür değilken yıldızları yeniden yerleştir
+            self._place_stars()
+
+        self.drawStars = True
+
+    def reset(self) -> None:
+        self.currentPhase = 0
+        self.opacity = 0
+        self.update(False)
+
+    # ---- iç yardımcılar ----
+    def _update_xpos(self, current: float, speed: float) -> float:
+        if current < -_Cfg.WIDTH:
+            return float(self.container_width)
+        return current - speed
+
+    def _draw(self) -> None:
+        # Ay kaynak dikdörtgeni
+        moon_src_w = _Cfg.WIDTH * (2 if self.currentPhase == 3 else 1)
+        moon_src_h = _Cfg.HEIGHT
+        phase_offset = PHASES[self.currentPhase]
+        moon_src_x = self.sprite_pos["x"] + phase_offset
+        moon_src_y = self.sprite_pos["y"]
+
+        # HiDPI düzeltmeleri (spritesheet 2x ise kaynak boyutları 2x)
+        star_src_size = _Cfg.STAR_SIZE
+        star_sheet = sprite_definition_by_type["original"]["ldpi"]["star"]
+        if IS_HIDPI:
+            moon_src_w *= 2
+            moon_src_h *= 2
+            moon_src_x = self.sprite_pos["x"] + (phase_offset * 2)
+            star_src_size *= 2
+            star_sheet = sprite_definition_by_type["original"]["hdpi"]["star"]
+
+        # Kaynak görsel (orijinal sheet)
+        runner_orig = self.provider.getOrigImageSprite()
+        assert runner_orig is not None
+
+        # --- YENI: opacity'den alpha hesapla ve fade'i gerçekten uygula ---
+        alpha = int(max(0, min(255, self.opacity * 255)))
+        if alpha <= 0:
+            return  # görünmezken çizme
+
+        # Yıldızlar
+        for s in self.stars:
+            src_rect = pygame.Rect(star_sheet["x"], int(s["sourceY"]), star_src_size, star_src_size)
+            # subsurface -> copy -> alpha uygula
+            star_tile = runner_orig.subsurface(src_rect).copy()
+            star_tile.set_alpha(alpha)
+            self.canvasCtx.blit(star_tile, (int(s["x"]), int(s["y"])))
+
+        # Ay
+        moon_src_rect = pygame.Rect(moon_src_x, moon_src_y, moon_src_w, moon_src_h)
+        moon_tile = runner_orig.subsurface(moon_src_rect).copy()
+        moon_tile.set_alpha(alpha)
+        self.canvasCtx.blit(moon_tile, (int(self.xPos), int(self.yPos)))
+
+    def _place_stars(self) -> None:
+        # ldpi/hdpi y bazları
+        if IS_HIDPI:
+            star_y_base = sprite_definition_by_type["original"]["hdpi"]["star"]["y"]
+            step = _Cfg.STAR_SIZE * 2
+        else:
+            star_y_base = sprite_definition_by_type["original"]["ldpi"]["star"]["y"]
+            step = _Cfg.STAR_SIZE
+
+        segment = max(1, round(self.container_width / _Cfg.NUM_STARS))
+        for i in range(_Cfg.NUM_STARS):
+            self.stars[i]["x"] = float(get_random_num(segment * i, segment * (i + 1)))
+            self.stars[i]["y"] = float(get_random_num(0, _Cfg.STAR_MAX_Y))
+            self.stars[i]["sourceY"] = float(star_y_base + step * i)

pydino/obstacle.py

@@ -0,0 +1,294 @@
+# obstacle.py
+# 1:1 pygame port of obstacle.ts
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+import pygame
+
+try:
+    from constants import FPS, IS_HIDPI, IS_MOBILE
+    from utils import get_random_num
+except ImportError:
+    from .constants import FPS, IS_HIDPI, IS_MOBILE
+    from .utils import get_random_num
+from offline_sprite_definitions import CollisionBox  # your py version
+
+
+# -----------------------------------------------------------------------------
+# Global tunables (match TS module-level state)
+# -----------------------------------------------------------------------------
+max_gap_coefficient: float = 1.5
+max_obstacle_length: int = 3
+
+
+def set_max_gap_coefficient(coefficient: float) -> None:
+    global max_gap_coefficient
+    max_gap_coefficient = coefficient
+
+
+def set_max_obstacle_length(length: int) -> None:
+    global max_obstacle_length
+    max_obstacle_length = int(length)
+
+
+# TS-compatible aliases (so imports like setMaxGapCoefficient work)
+setMaxGapCoefficient = set_max_gap_coefficient
+setMaxObstacleLength = set_max_obstacle_length
+
+
+# -----------------------------------------------------------------------------
+# Helpers
+# -----------------------------------------------------------------------------
+def _get(obj: Any, name: str, default: Any = None) -> Any:
+    """Support both dataclass/attr objects and dict-like configs."""
+    if hasattr(obj, name):
+        return getattr(obj, name)
+    if isinstance(obj, dict):
+        return obj.get(name, default)
+    return default
+
+
+def _blit_region(
+    dst_surface: pygame.Surface,
+    src_surface: pygame.Surface,
+    src_rect: pygame.Rect,
+    dest_xy: tuple[int, int],
+    dest_wh: tuple[int, int],
+) -> None:
+    sub = src_surface.subsurface(src_rect)
+    if sub.get_width() != dest_wh[0] or sub.get_height() != dest_wh[1]:
+        sub = pygame.transform.scale(sub, dest_wh)
+    dst_surface.blit(sub, dest_xy)
+
+
+# -----------------------------------------------------------------------------
+# Obstacle
+# -----------------------------------------------------------------------------
+class Obstacle:
+    # Public fields (match TS names exactly)
+    collisionBoxes: list[CollisionBox]
+    followingObstacleCreated: bool
+    gap: int
+    jumpAlerted: bool
+    remove: bool
+    size: int
+    width: int
+    xPos: int
+    yPos: int
+    typeConfig: Any  # ObstacleType in TS
+
+    # private-ish
+    _canvas: pygame.Surface
+    _sprite_pos: Any  # SpritePosition (expects .x, .y)
+    _gap_coefficient: float
+    _speed_offset: float
+    _alt_game_mode_active: bool
+    _image_sprite: pygame.Surface
+    _current_frame: int
+    _timer: float
+    _resource_provider: Any  # ImageSpriteProvider & GameStateProvider
+
+    def __init__(
+        self,
+        canvas_ctx: pygame.Surface,
+        type_config: Any,          # ObstacleType (dataclass/dict)
+        sprite_img_pos: Any,       # SpritePosition (.x, .y)
+        dimensions: Any,           # Dimensions (width, height)
+        gap_coefficient: float,
+        speed: float,
+        x_offset: float = 0,
+        resource_provider: Any = None,  # provides image sprites & state flags
+        is_alt_game_mode: bool = False,
+    ) -> None:
+        self._canvas = canvas_ctx
+        self._sprite_pos = sprite_img_pos
+        self.typeConfig = type_config
+        self._resource_provider = resource_provider
+
+        has_slowdown = bool(getattr(resource_provider, "hasSlowdown", False))
+        self._gap_coefficient = gap_coefficient * 2 if has_slowdown else gap_coefficient
+
+        self.size = get_random_num(1, max_obstacle_length)
+        self.xPos = int(_get(dimensions, "width", 600) + x_offset)
+        self.yPos = 0
+
+        self.followingObstacleCreated = False
+        self.gap = 0
+        self.jumpAlerted = False
+        self.remove = False
+        self.width = 0
+
+        self._alt_game_mode_active = bool(is_alt_game_mode)
+        self._speed_offset = 0.0
+        self._current_frame = 0
+        self._timer = 0.0
+
+        # Pick correct sprite sheet surface
+        img_surface: Optional[pygame.Surface]
+        t_type = _get(self.typeConfig, "type")
+        if t_type == "collectable":
+            img_surface = getattr(resource_provider, "getAltCommonImageSprite")()
+        elif self._alt_game_mode_active:
+            img_surface = getattr(resource_provider, "getRunnerAltGameImageSprite")()
+        else:
+            img_surface = getattr(resource_provider, "getRunnerImageSprite")()
+        assert img_surface is not None, "Image sprite surface could not be loaded."
+        self._image_sprite = img_surface
+
+        # Finish setup
+        self._init(speed)
+
+    # -------------------------------------------------------------------------
+    # TS private init()
+    # -------------------------------------------------------------------------
+    def _init(self, speed: float) -> None:
+        self.cloneCollisionBoxes()
+
+        # Only allow sizing if at the right speed.
+        multiple_speed = float(_get(self.typeConfig, "multipleSpeed", 9999))
+        if self.size > 1 and multiple_speed > speed:
+            self.size = 1
+
+        base_width = int(_get(self.typeConfig, "width", 0))
+        base_height = int(_get(self.typeConfig, "height", 0))
+        self.width = base_width * self.size
+
+        # yPos can be an int or a list (with optional yPosMobile)
+        y_pos = _get(self.typeConfig, "yPos")
+        if isinstance(y_pos, (list, tuple)):
+            y_mobile = _get(self.typeConfig, "yPosMobile", y_pos)
+            selectable = y_mobile if IS_MOBILE else y_pos
+            idx = get_random_num(0, len(selectable) - 1)
+            self.yPos = int(selectable[idx])
+        else:
+            self.yPos = int(y_pos)
+
+        # Initial draw
+        self._draw()
+
+        # Adjust collision boxes for size > 1
+        if self.size > 1 and len(self.collisionBoxes) >= 3:
+            # center box width spans total width minus side boxes
+            left = self.collisionBoxes[0]
+            center = self.collisionBoxes[1]
+            right = self.collisionBoxes[2]
+            center.width = self.width - left.width - right.width
+            right.x = self.width - right.width
+
+        # speedOffset
+        speed_offset = _get(self.typeConfig, "speedOffset")
+        if speed_offset:
+            self._speed_offset = float(speed_offset if (get_random_num(0, 1) == 1) else -speed_offset)
+
+        # gap
+        self.gap = self.getGap(self._gap_coefficient, speed)
+
+        # Increase gap if audio cues enabled
+        if bool(getattr(self._resource_provider, "hasAudioCues", False)):
+            self.gap *= 2
+
+    # -------------------------------------------------------------------------
+    # TS private draw()
+    # -------------------------------------------------------------------------
+    def _draw(self) -> None:
+        source_w = int(_get(self.typeConfig, "width", 0))
+        source_h = int(_get(self.typeConfig, "height", 0))
+
+        # HIDPI ise kaynaktan 2x alan oku
+        src_w_px = source_w * (2 if IS_HIDPI else 1)
+        src_h_px = source_h * (2 if IS_HIDPI else 1)
+
+        # Sprite sheet üzerindeki başlangıç X konumu:
+        # (sourceWidth * size) * (0.5 * (size - 1)) + spritePos.x
+        base = (src_w_px * self.size) * (0.5 * (self.size - 1))
+
+        # sprite_pos hem dict hem obje olabilir — güvenli oku
+        pos_x = int(_get(self._sprite_pos, "x", 0))
+        pos_y = int(_get(self._sprite_pos, "y", 0))
+
+        src_x = int(base + pos_x)
+        src_y = pos_y
+
+        # Animasyon çerçevesi ofseti
+        if self._current_frame > 0:
+            src_x += src_w_px * self._current_frame
+
+        # Kaynak dikdörtgen ve hedef boyut (mantıksal ölçekte)
+        src_rect = pygame.Rect(src_x, src_y, src_w_px * self.size, src_h_px)
+        dest_wh = (source_w * self.size, source_h)
+
+        _blit_region(
+            self._canvas,
+            self._image_sprite,
+            src_rect,
+            (int(self.xPos), int(self.yPos)),
+            dest_wh,
+        )
+
+    # -------------------------------------------------------------------------
+    # TS update(deltaTime, speed)
+    # -------------------------------------------------------------------------
+    def update(self, delta_time: float, speed: float) -> None:
+        if self.remove:
+            return
+
+        # Per-obstacle speed offset
+        if _get(self.typeConfig, "speedOffset"):
+            speed = float(speed) + self._speed_offset
+
+        # Move left
+        self.xPos -= int((speed * (FPS / 1000.0)) * delta_time)
+
+        # Animated obstacles
+        num_frames = _get(self.typeConfig, "numFrames")
+        if num_frames:
+            frame_rate = float(_get(self.typeConfig, "frameRate", 0))
+            self._timer += delta_time
+            if self._timer >= frame_rate:
+                self._current_frame = 0 if self._current_frame >= int(num_frames) - 1 else self._current_frame + 1
+                self._timer = 0.0
+
+        # Draw current frame
+        self._draw()
+
+        # Cull when off-screen
+        if not self.isVisible():
+            self.remove = True
+
+    # -------------------------------------------------------------------------
+    # TS getGap(...)
+    # -------------------------------------------------------------------------
+    def getGap(self, gap_coefficient: float, speed: float) -> int:
+        min_gap = int(round(self.width * speed + _get(self.typeConfig, "minGap", 0) * gap_coefficient))
+        max_gap = int(round(min_gap * max_gap_coefficient))
+        return get_random_num(min_gap, max_gap)
+
+    # -------------------------------------------------------------------------
+    # TS isVisible()
+    # -------------------------------------------------------------------------
+    def isVisible(self) -> bool:
+        return (self.xPos + self.width) > 0
+
+    # Pythonic alias
+    def is_visible(self) -> bool:
+        return self.isVisible()
+
+    # -------------------------------------------------------------------------
+    # TS cloneCollisionBoxes()
+    # -------------------------------------------------------------------------
+    def cloneCollisionBoxes(self) -> None:
+        self.collisionBoxes = []
+        boxes = _get(self.typeConfig, "collisionBoxes", []) or []
+        for b in boxes:
+            # b may be dict or CollisionBox-like
+            self.collisionBoxes.append(
+                CollisionBox(
+                    x=int(_get(b, "x", 0)),
+                    y=int(_get(b, "y", 0)),
+                    width=int(_get(b, "width", 0)),
+                    height=int(_get(b, "height", 0)),
+                )
+            )

pydino/offline_sprite_definitions.py

@@ -0,0 +1,245 @@
+# offline_sprite_definitions.py
+# 1:1 port of Chrome Dino offline_sprite_definitions.ts for pygame.
+
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union, TypedDict, Any
+
+# --- helpers to allow both dict["x"] and obj.x access ----------------------
+class _DotAccessDict(dict):
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(key)
+
+    def __setattr__(self, key, value):
+        if key in ("__setstate__",):
+            return super().__setattr__(key, value)
+        self[key] = value
+
+    def __delattr__(self, key):
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(key)
+
+class SpritePos(_DotAccessDict):
+    def __init__(self, x: int, y: int):
+        super().__init__({"x": int(x), "y": int(y)})
+
+class LineConf(_DotAccessDict):
+    def __init__(self, sourceX: int, sourceY: int, width: int, height: int, yPos: int):
+        super().__init__({
+            "sourceX": int(sourceX),
+            "sourceY": int(sourceY),
+            "width": int(width),
+            "height": int(height),
+            "yPos": int(yPos),
+        })
+
+# ---------------------------------------------------------------------------
+# Types (lightweight Python equivalents)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class CollisionBox:
+    x: int
+    y: int
+    width: int
+    height: int
+
+
+@dataclass
+class ObstacleType:
+    # Keys mirror TS interface
+    type: str
+    width: int
+    height: int
+    yPos: Union[int, List[int]]
+    multipleSpeed: float
+    minGap: int
+    minSpeed: float
+    collisionBoxes: List[CollisionBox]
+    # optional
+    yPosMobile: Optional[List[int]] = None
+    speedOffset: Optional[float] = None
+    numFrames: Optional[int] = None
+    frameRate: Optional[float] = None
+
+
+class SpritePosition(TypedDict):
+    x: int
+    y: int
+
+
+# SpritePositions in TS is an object with many sprite anchors.
+SpritePositions = Dict[str, SpritePosition]
+
+# Loosely typed containers for convenience (dict-like)
+SpriteDefinition = Dict[str, Any]
+SpriteDefinitionByType = Dict[str, SpriteDefinition]
+
+# ---------------------------------------------------------------------------
+# GAME_TYPE list (TS exports an empty list; keep parity)
+# ---------------------------------------------------------------------------
+GAME_TYPE: List[str] = []
+
+# ---------------------------------------------------------------------------
+# Sprite definitions (values copied 1:1 from TS)
+# ---------------------------------------------------------------------------
+
+_ldpi_positions: SpritePositions = {
+    "backgroundEl": {"x": 86,  "y": 2},
+    "cactusLarge":  {"x": 332, "y": 2},
+    "cactusSmall":  {"x": 228, "y": 2},
+    "obstacle2":    {"x": 332, "y": 2},
+    "obstacle":     {"x": 228, "y": 2},
+    "cloud":        {"x": 86,  "y": 2},
+    "horizon":      {"x": 2,   "y": 54},
+    "moon":         {"x": 484, "y": 2},
+    "pterodactyl":  {"x": 134, "y": 2},
+    "restart":      {"x": 2,   "y": 68},
+    "textSprite":   {"x": 655, "y": 2},
+    "tRex":         {"x": 848, "y": 2},
+    "star":         {"x": 645, "y": 2},
+    "collectable":  {"x": 0,   "y": 0},
+    "altGameEnd":   {"x": 32,  "y": 0},
+}
+
+_hdpi_positions: SpritePositions = {
+    "backgroundEl": {"x": 166,  "y": 2},
+    "cactusLarge":  {"x": 652,  "y": 2},
+    "cactusSmall":  {"x": 446,  "y": 2},
+    "obstacle2":    {"x": 652,  "y": 2},
+    "obstacle":     {"x": 446,  "y": 2},
+    "cloud":        {"x": 166,  "y": 2},
+    "horizon":      {"x": 2,    "y": 104},
+    "moon":         {"x": 954,  "y": 2},
+    "pterodactyl":  {"x": 260,  "y": 2},
+    "restart":      {"x": 2,    "y": 130},
+    "textSprite":   {"x": 1294, "y": 2},
+    "tRex":         {"x": 1678, "y": 2},
+    "star":         {"x": 1276, "y": 2},
+    "collectable":  {"x": 0,    "y": 0},
+    "altGameEnd":   {"x": 64,   "y": 0},
+}
+
+# Wrap sprite positions to support both ["x"] and .x usage
+_ldpi_positions_wrapped: SpritePositions = {k: SpritePos(v["x"], v["y"]) for k, v in _ldpi_positions.items()}
+_hdpi_positions_wrapped: SpritePositions = {k: SpritePos(v["x"], v["y"]) for k, v in _hdpi_positions.items()}
+
+# Obstacles (dataclass instances for attribute access)
+_obstacles: List[ObstacleType] = [
+    ObstacleType(
+        type="cactusSmall",
+        width=17,
+        height=35,
+        yPos=105,
+        multipleSpeed=4,
+        minGap=120,
+        minSpeed=0,
+        collisionBoxes=[
+            CollisionBox(x=0,  y=7,  width=5, height=27),
+            CollisionBox(x=4,  y=0,  width=6, height=34),
+            CollisionBox(x=10, y=4,  width=7, height=14),
+        ],
+    ),
+    ObstacleType(
+        type="cactusLarge",
+        width=25,
+        height=50,
+        yPos=90,
+        multipleSpeed=7,
+        minGap=120,
+        minSpeed=0,
+        collisionBoxes=[
+            CollisionBox(x=0,  y=12, width=7,  height=38),
+            CollisionBox(x=8,  y=0,  width=7,  height=49),
+            CollisionBox(x=13, y=10, width=10, height=38),
+        ],
+    ),
+    ObstacleType(
+        type="pterodactyl",
+        width=46,
+        height=40,
+        yPos=[100, 75, 50],          # variable heights
+        yPosMobile=[100, 50],
+        multipleSpeed=999,
+        minSpeed=8.5,
+        minGap=150,
+        collisionBoxes=[
+            CollisionBox(x=15, y=15, width=16, height=5),
+            CollisionBox(x=18, y=21, width=24, height=6),
+            CollisionBox(x=2,  y=14, width=4,  height=3),
+            CollisionBox(x=6,  y=10, width=4,  height=7),
+            CollisionBox(x=10, y=8,  width=6,  height=9),
+        ],
+        numFrames=2,
+        frameRate=1000.0 / 6.0,
+        speedOffset=0.8,
+    ),
+    ObstacleType(
+        type="collectable",
+        width=31,
+        height=24,
+        yPos=104,
+        multipleSpeed=1000,
+        minGap=9999,
+        minSpeed=0,
+        collisionBoxes=[
+            CollisionBox(x=0, y=0, width=32, height=25),
+        ],
+    ),
+]
+
+_background_el: Dict[str, Dict[str, Union[int, float, bool]]] = {
+    "CLOUD": {
+        "height": 14,
+        "offset": 4,
+        "width": 46,
+        "xPos": 1,
+        "fixed": False,
+    },
+}
+
+_background_el_config: Dict[str, Union[int, float]] = {
+    "maxBgEls": 1,
+    "maxGap": 400,
+    "minGap": 100,
+    "pos": 0,
+    "speed": 0.5,
+    "yPos": 125,
+}
+
+_lines: List[Dict[str, int]] = [
+    {"sourceX": 2, "sourceY": 52, "width": 600, "height": 12, "yPos": 127},
+]
+
+_lines_wrapped = [LineConf(**line) for line in _lines]
+
+_alt_game_over_text_config: Dict[str, Union[int, float, bool]] = {
+    "textX": 32,
+    "textY": 0,
+    "textWidth": 246,
+    "textHeight": 17,
+    "flashDuration": 1500,
+    "flashing": False,
+}
+
+sprite_definition_by_type: SpriteDefinitionByType = {
+    "original": {
+        "ldpi": _ldpi_positions_wrapped,
+        "hdpi": _hdpi_positions_wrapped,
+        "maxGapCoefficient": 1.5,
+        "maxObstacleLength": 3,
+        "hasClouds": True,
+        "bottomPad": 10,
+        "obstacles": _obstacles,
+        "backgroundEl": _background_el,
+        "backgroundElConfig": _background_el_config,
+        "lines": _lines_wrapped,
+        "altGameOverTextConfig": _alt_game_over_text_config,
+        # "altGameEndConfig": ...   # optional, not used in original
+    }
+}

pydino/runner.py

@@ -0,0 +1,766 @@
+from __future__ import annotations
+import math
+import os
+import pygame
+from dataclasses import dataclass
+
+from typing import Dict, Optional, List, Any
+
+# Debug overlay (optional)
+try:
+    from debug_overlay import CollisionDebugOverlay
+except Exception:
+    CollisionDebugOverlay = None  # overlay is optional; keep game running if missing
+
+# NumPy import'unu en başta yapıyoruz
+try:
+    import numpy as np
+    import pygame.surfarray as sarr
+    NUMPY_AVAILABLE = True
+except ImportError:
+    NUMPY_AVAILABLE = False
+    
+# ==== USER PATHS (dynamic) ==================================================
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+ASSETS_DIR = os.path.join(BASE_DIR, "assets")
+SOUNDS_DIR = os.path.join(BASE_DIR, "sounds")
+
+SPRITE_PATH = os.path.join(ASSETS_DIR, "100-offline-sprite.png")
+SND_BUTTON  = os.path.join(SOUNDS_DIR, "button-press.mp3")
+SND_HIT     = os.path.join(SOUNDS_DIR, "hit.mp3")
+SND_SCORE   = os.path.join(SOUNDS_DIR, "score-reached.mp3")
+# ============================================================================
+
+# ==== Imports from your ported modules ======================================
+# ==== Imports from your ported modules ======================================
+try:
+    from constants import FPS
+    from dimensions import Dimensions
+    from horizon import Horizon
+    from distance_meter import DistanceMeter
+    from game_over_panel import GameOverPanel
+    from trex import Trex, Status as TrexStatus
+    from offline_sprite_definitions import (
+        sprite_definition_by_type,    
+        CollisionBox, GAME_TYPE
+    )
+except ImportError:
+    from .constants import FPS
+    from .dimensions import Dimensions
+    from .horizon import Horizon
+    from .distance_meter import DistanceMeter
+    from .game_over_panel import GameOverPanel
+    from .trex import Trex, Status as TrexStatus
+    from .offline_sprite_definitions import (
+        sprite_definition_by_type,    
+        CollisionBox, GAME_TYPE
+    )
+    print("Lütfen tüm .py dosyalarının aynı dizinde olduğundan emin olun.")
+    raise SystemExit(1)
+
+# ==== Configs (merged from defaultBaseConfig + normalModeConfig) =============
+@dataclass 
+class Config:
+    # defaultBaseConfig
+    audiocueProximityThreshold: int = 190
+    audiocueProximityThresholdMobileA11y: int = 250
+    bgCloudSpeed: float = 0.2
+    bottomPad: int = 10
+    canvasInViewOffset: int = -10
+    clearTime: int = 3000
+    cloudFrequency: float = 0.5
+    fadeDuration: float = 1
+    flashDuration: int = 1000
+    gameoverClearTime: int = 1200
+    initialJumpVelocity: float = 12
+    invertFadeDuration: int = 12000
+    maxBlinkCount: int = 3
+    maxClouds: int = 6
+    maxObstacleLength: int = 3
+    maxObstacleDuplication: int = 2
+    resourceTemplateId: str = "audio-resources"
+    speedDropCoefficient: float = 3
+    arcadeModeInitialTopPosition: int = 35
+    arcadeModeTopPositionPercent: float = 0.1
+    # normalModeConfig
+    acceleration: float = 0.001
+    gapCoefficient: float = 0.6
+    invertDistance: int = 700
+    maxSpeed: float = 13.0
+    mobileSpeedCoefficient: float = 1.2
+    speed: float = 6.0
+
+
+# ==== Utility (canvas scaling / collisions) ==================================
+def create_adjusted_box(box: CollisionBox, adj: CollisionBox) -> CollisionBox:
+    return CollisionBox(box.x + adj.x, box.y + adj.y, box.width, box.height)
+
+def box_intersect(a: CollisionBox, b: CollisionBox) -> bool:
+    return (
+        a.x < b.x + b.width and
+        a.x + a.width > b.x and
+        a.y < b.y + b.height and
+        a.height + a.y > b.y
+    )
+
+def _get(obj, name, default=None):
+    """dict / obje uyumlu alan okuma"""
+    if hasattr(obj, name):
+        return getattr(obj, name)
+    if isinstance(obj, dict):
+        return obj.get(name, default)
+    return default
+
+
+# ==== Runner =================================================================
+class Runner:
+    """
+    Pygame orchestrator matching Chrome Dino Runner logic.
+    Provides ImageSpriteProvider, GameStateProvider, ConfigProvider interfaces.
+    """
+    # Key map
+    KEY_JUMP = (pygame.K_UP, pygame.K_SPACE)
+    KEY_DUCK = (pygame.K_DOWN,)
+    KEY_RESTART = (pygame.K_RETURN,)
+    
+    # Yeni sabitler
+    NIGHT_ALPHA_MAX = 180
+    VISUAL_INVERT_MS = 1000
+    
+    def _get_visual_invert_ms(self) -> int:
+        ms = self.VISUAL_INVERT_MS
+        if self._invert_mode_pixels:
+            ms = int(ms * 0.75)
+        return max(120, ms)
+
+    def _ease_in_out_cubic(self, t: float) -> float:
+        """CSS-like ease-in-out (cubic) for more natural fade perception."""
+        if t <= 0.0:
+            return 0.0
+        if t >= 1.0:
+            return 1.0
+        if t < 0.5:
+            return 4.0 * t * t * t
+        return 1.0 - ((-2.0 * t + 2.0) ** 3) / 2.0
+
+    def __init__(self, screen: pygame.Surface, dimensions: Dimensions,
+                 use_audio: bool = True) -> None:
+        self.screen = screen
+        self.dimensions = dimensions
+        self.config = Config()
+        self.ms_per_frame = 1000.0 / FPS
+
+        # provider state
+        self._has_slowdown = False
+        self._has_audio_cues = use_audio
+        self._alt_game_mode_active = False
+        self._alt_game_assets_failed = False
+        self._game_type: Optional[str] = None
+
+        # spritesheet (LDPI by default)
+        self.sprite_image: Optional[pygame.Surface] = None
+        self.sprite_alt_game_image: Optional[pygame.Surface] = None 
+        self.sprite_alt_common_image: Optional[pygame.Surface] = None 
+
+        # sprite positions (ldpi)
+        self.sprite_def = sprite_definition_by_type["original"]["ldpi"]
+
+        # Components
+        self.horizon: Optional[Horizon] = None
+        self.distance_meter: Optional[DistanceMeter] = None
+        self.trex: Optional[Trex] = None
+        self.game_over_panel: Optional[GameOverPanel] = None
+
+        # Game flow flags/state
+        self.activated = False
+        self.playing = False
+        self.playing_intro = False
+        self.crashed = False
+        self.paused = False
+        self.inverted = False
+        self.is_dark_mode = False
+        self.update_pending = False
+
+        # Intro zamanlayıcı
+        self.intro_start_time = 0
+        self.INTRO_DURATION = 400  # 400ms
+        self.intro_start_width = 44
+        # Intro sadece ilk açılışta oynasın
+        self.did_intro = False
+        
+        # Gece modu overlay yüzeyi ve bayrakları
+        self._night_overlay = pygame.Surface((self.dimensions.width, self.dimensions.height), pygame.SRCALPHA)
+        self._invert_mode_pixels = NUMPY_AVAILABLE 
+        # Debug overlay instance (may be None if import failed)
+        self.debug = CollisionDebugOverlay() if CollisionDebugOverlay else None
+
+        # Timers & numeric state
+        self.time_ms = pygame.time.get_ticks()
+        self.distance_ran = 0.0
+        self.running_time = 0.0
+        self.current_speed = self.config.speed
+        self.invert_timer = 0.0
+        self.invert_trigger = False
+        self.fade_in_timer = 0.0
+        self.alt_game_mode_flash_timer: Optional[float] = None
+        # Game over bekleme süresi için damga
+        self.game_over_time: Optional[int] = None
+
+        # Night-mode state machine
+        self._inv_phase = "day"
+        self._inv_progress = 0.0
+        self._next_invert_score = self.config.invertDistance
+
+        # High score
+        self.highest_score = 0
+        self.sync_highest_score = False
+
+        # Sounds
+        self.snd_button = None
+        self.snd_hit = None
+        self.snd_score = None
+        if self._has_audio_cues:
+            self._load_sounds()
+
+        # Load images & init components
+        self._load_images()
+        self._init_components()
+
+        # Intro başlangıç genişliği (Trex oluştuktan sonra)
+        assert self.trex is not None
+        trex_width = _get(self.trex.config, "width", 44)
+        self.intro_start_width = self.trex.xPos + trex_width
+
+    # ========== Provider interfaces ==========
+    @property
+    def hasSlowdown(self) -> bool:
+        return self._has_slowdown
+
+    @property
+    def hasAudioCues(self) -> bool:
+        return self._has_audio_cues
+
+    def isAltGameModeEnabled(self) -> bool:
+        return False if self._alt_game_assets_failed else False
+
+    def getSpriteDefinition(self) -> Dict[str, Any]:
+        return sprite_definition_by_type["original"]
+
+    def getOrigImageSprite(self) -> pygame.Surface:
+        assert self.sprite_image is not None
+        return self.sprite_image
+
+    def getRunnerImageSprite(self) -> pygame.Surface:
+        assert self.sprite_image is not None
+        return self.sprite_image
+
+    def getRunnerAltGameImageSprite(self) -> Optional[pygame.Surface]:
+        return self.sprite_alt_game_image
+
+    def getAltCommonImageSprite(self) -> Optional[pygame.Surface]:
+        return self.sprite_alt_common_image
+
+    def getConfig(self) -> Config:
+        return self.config
+
+    # ========== Asset loading ==========
+    def _load_images(self) -> None:
+        try:
+            img = pygame.image.load(SPRITE_PATH).convert_alpha()
+            self.sprite_image = img
+            self.sprite_def = sprite_definition_by_type["original"]["ldpi"]
+        except pygame.error as e:
+            print(f"HATA: Sprite dosyası yüklenemedi: {SPRITE_PATH}")
+            print(f"Detay: {e}")
+            raise e
+
+    def _load_sounds(self) -> None:
+        try:
+            # Daha stabil/düşük gecikme ve yeterli kanal
+            pygame.mixer.pre_init(44100, -16, 2, 512)
+            pygame.mixer.init()
+            pygame.mixer.set_num_channels(8)
+
+            def _try_load_sound(path: str) -> pygame.mixer.Sound:
+                try:
+                    return pygame.mixer.Sound(path)
+                except Exception:
+                    # Yedek uzantıları dene (.wav/.ogg)
+                    base, _ = os.path.splitext(path)
+                    for ext in ('.wav', '.ogg'):
+                        alt = base + ext
+                        if os.path.exists(alt):
+                            try:
+                                return pygame.mixer.Sound(alt)
+                            except Exception:
+                                continue
+                    raise
+
+            self.snd_button = _try_load_sound(SND_BUTTON)
+            self.snd_hit    = _try_load_sound(SND_HIT)
+            self.snd_score  = _try_load_sound(SND_SCORE)
+
+            # Varsayılan ses seviyeleri
+            try:
+                self.snd_button.set_volume(0.6)
+                self.snd_hit.set_volume(0.8)
+                self.snd_score.set_volume(0.7)
+            except Exception:
+                pass
+
+            self._has_audio_cues = True
+        except Exception:
+            self._has_audio_cues = False
+            self.snd_button = self.snd_hit = self.snd_score = None
+            print("Uyarı: Ses dosyaları yüklenemedi, sesler devre dışı bırakıldı.")
+
+    # ========== Init components ==========
+    def _init_components(self) -> None:
+        self.screen.fill((247, 247, 247))
+        self.horizon = Horizon(
+            self.screen, self.sprite_def, self.dimensions,
+            self.config.gapCoefficient, self
+        )
+        self.distance_meter = DistanceMeter(
+            self.screen, self.sprite_def["textSprite"],
+            self.dimensions.width, self
+        )
+        self.trex = Trex(self.screen, self.sprite_def["tRex"], self)
+        
+    # ========== Public controls ==========
+    def start(self) -> None:
+        self.playing = True
+        self.paused = False
+        
+    def stop(self) -> None:
+        self.playing = False
+        self.paused = True
+
+    def restart(self) -> None:
+        assert self.horizon and self.trex and self.distance_meter
+        self.playing = True
+        self.paused = False
+        self.crashed = False
+        # Restart'ta intro yok; direkt aktif başla
+        self.activated = True
+        self.playing_intro = False
+        if self.trex:
+            self.trex.playing_intro = False
+        self.distance_ran = 0.0
+        self.running_time = 0.0
+        self.current_speed = self.config.speed
+        self.time_ms = pygame.time.get_ticks()
+        self.horizon.reset()
+        self.trex.reset()
+        self.distance_meter.reset()
+        self._play_sound(self.snd_button)
+
+        # Game over panel reset
+        if self.game_over_panel:
+            self.game_over_panel.reset()
+
+        # Game-over zamanı sıfırla
+        self.game_over_time = None
+            
+        self.invert(reset=True)
+
+    # ========== Event handling ==========
+    def handle_event(self, e: pygame.event.Event) -> None:
+        if e.type == pygame.KEYDOWN:
+            # CRASH SONRASI:
+            #   Enter  -> anında restart
+            #   Space/Up -> 1200 ms bekleme kuralı
+            if self.crashed:
+                if e.key in self.KEY_RESTART:           # Enter
+                    self._on_restart(force=True)
+                    return
+                if e.key in self.KEY_JUMP:              # Space veya Up
+                    self._on_restart(force=False)
+                    return
+            if e.key in self.KEY_JUMP:
+                self._on_jump_down()
+            elif e.key in self.KEY_DUCK:
+                self._on_duck_down()
+            elif e.key == pygame.K_F3 and self.debug is not None:
+                # Toggle collision debug visualization
+                self.debug.enabled = not self.debug.enabled
+
+        elif e.type == pygame.KEYUP:
+            if e.key in self.KEY_JUMP:
+                self._on_jump_up()
+            elif e.key in self.KEY_DUCK:
+                self._on_duck_up()
+        elif e.type == pygame.WINDOWFOCUSLOST:
+            pass
+
+    def _on_jump_down(self) -> None:
+        assert self.trex
+        if not self.playing and not self.crashed:
+            self.start()
+        # Havada değil ve eğilmiyorken: zıpla + ses
+        if not self.trex.jumping and not self.trex.ducking:
+            self._play_sound(self.snd_button)
+            self.trex.startJump(self.current_speed)
+
+    def _on_duck_down(self) -> None:
+        assert self.trex
+        if self.playing:
+            if self.trex.jumping:
+                self.trex.setSpeedDrop()
+            elif not self.trex.ducking:
+                self.trex.setDuck(True)
+
+    def _on_jump_up(self) -> None:
+        assert self.trex
+        if self.playing:
+            self.trex.endJump()
+        elif self.crashed:
+            self._on_restart()
+
+    def _on_duck_up(self) -> None:
+        assert self.trex
+        self.trex.speedDrop = False
+        self.trex.setDuck(False)
+
+    def _on_restart(self, force: bool = False) -> None:
+        # force=True ise (Enter), beklemeden anında başlat
+        if force:
+            self.restart()
+            return
+
+        # Space/Up için: gameoverClearTime (1200 ms) bekleme kuralı
+        now = pygame.time.get_ticks()
+        t0 = self.game_over_time if self.game_over_time is not None else self.time_ms
+        if now - t0 >= self.config.gameoverClearTime:
+            self.restart()
+
+    # ========== Update loop ==========
+    def update(self) -> None:
+        """Call this once per frame from your game loop."""
+        assert self.trex and self.horizon and self.distance_meter
+        now = pygame.time.get_ticks()
+        delta = now - self.time_ms
+        self.time_ms = now
+
+        # Alt game flash timer
+        if self.alt_game_mode_flash_timer is not None:
+            if self.alt_game_mode_flash_timer <= 0:
+                self.alt_game_mode_flash_timer = None
+                self.trex.setFlashing(False)
+            else:
+                self.alt_game_mode_flash_timer -= delta
+                self.trex.update(delta)
+                delta = 0
+
+        # 1. EKRANI TEMİZLE
+        self.screen.fill((247, 247, 247)) 
+
+        # 2. GÜNCELLEMELER (FİZİK/ZAMANLAMA)
+        if self.playing and self.trex.jumping:
+            self.trex.updateJump(delta)
+
+        if self.playing:
+            self.running_time += delta
+            
+        has_obstacles = self.running_time > self.config.clearTime
+
+        clip_rect = None # Varsayılan klip
+        horizon_delta = delta 
+        horizon_speed = self.current_speed 
+        show_night_mode = (self.is_dark_mode != self.inverted)
+        
+        # 3. INTRO DURUM KONTROLÜ VE KLİP HESAPLAMA
+        # Intro sadece ilk açılışta, ilk zıplamada tetiklensin
+        if (not self.did_intro) and self.trex.jumpCount == 1 and not self.playing_intro and not self.activated:
+            self.playing_intro = True
+            self.trex.playing_intro = True
+            self.intro_start_time = pygame.time.get_ticks()
+            self.activated = True
+
+        if not self.activated:
+            tx = int(getattr(self.trex, "xPos", 0))
+            tw = int(_get(self.trex.config, "width", 44))
+            ideal = tx + tw
+            if ideal > self.intro_start_width:
+                self.intro_start_width = min(self.dimensions.width, ideal)
+
+            clip_rect = pygame.Rect(0, 0, self.intro_start_width, self.dimensions.height)
+            horizon_delta = 0
+            show_night_mode = False
+
+        elif self.playing_intro:
+            elapsed_time = pygame.time.get_ticks() - self.intro_start_time
+            if elapsed_time >= self.INTRO_DURATION:
+                self.playing_intro = False
+                self.trex.playing_intro = False
+                self.running_time = 0
+                self.did_intro = True  # bir kez oynatıldı
+            else:
+                progress = self._ease_in_out_cubic(elapsed_time / self.INTRO_DURATION)
+                end_width = self.dimensions.width
+                start_width = self.intro_start_width 
+                current_width = start_width + (end_width - start_width) * progress
+                clip_rect = pygame.Rect(0, 0, int(current_width), self.dimensions.height)
+                horizon_delta = 0
+                show_night_mode = False
+
+        elif self.crashed:
+            horizon_delta = 0  # Zemin durmalı
+
+        # 4. KLİP AYARLAMA
+        self.screen.set_clip(clip_rect)  # None ise tüm ekranı kullanır
+
+        # 5. KLİPLİ ÇİZİM
+        # Crashed olsa bile horizon'ı son durumuyla çiz (donmuş arka plan)
+        if (self.playing and not self.crashed) or not self.activated or self.crashed:
+            self.horizon.update(horizon_delta, horizon_speed, has_obstacles, show_night_mode)
+
+        # DistanceMeter (sadece oynarken güncelle)
+        play_achievement = False
+        if self.playing:
+            play_achievement = self.distance_meter.update(delta, math.ceil(self.distance_ran))
+        elif self.crashed:
+            # Kaza anında skor tablosunu ekranda tut
+            self.distance_meter.update(0, math.ceil(self.distance_ran))
+        
+        # Trex
+        self.trex.update(delta) 
+        if not self.playing and not self.activated and hasattr(self.trex, "draw"):
+            self.trex.draw(0, 0)
+
+        # 6. KLİP KALDIR
+        self.screen.set_clip(None)
+
+        # 7. OYUN MANTIĞI
+        if self.playing and not self.playing_intro and not self.crashed:
+            first_obstacle = self.horizon.obstacles[0] if self.horizon.obstacles else None
+            collision = False
+            if has_obstacles and first_obstacle:
+                collision_result = self._check_for_collision(first_obstacle, self.trex)
+                if collision_result:
+                    collision = True
+            
+            if not collision:
+                self.distance_ran += self.current_speed * (delta / self.ms_per_frame)
+                if self.current_speed < self.config.maxSpeed:
+                    self.current_speed += self.config.acceleration
+            else:
+                self._game_over()
+            
+            if play_achievement and self._has_audio_cues:
+                self._play_sound(self.snd_score)
+
+            # Gece modu
+            actual = self.distance_meter.getActualDistance(math.ceil(self.distance_ran))
+            if not self.isAltGameModeEnabled():
+                if self.invert_timer > self.config.invertFadeDuration:
+                    self.invert_timer = 0
+                    self.invert_trigger = False
+                    self.invert(reset=False)
+                elif self.invert_timer:
+                    self.invert_timer += delta
+                else:
+                    if actual > 0 and (actual % self.config.invertDistance == 0) and not self.invert_trigger:
+                        self.invert_timer += delta
+                        self.invert(reset=False)
+                        self.invert_trigger = True
+                    elif (actual % self.config.invertDistance) != 0:
+                        self.invert_trigger = False
+
+            T = self.config.invertFadeDuration
+            t = self.invert_timer
+            vis = self._get_visual_invert_ms()
+
+            inv_factor = 0.0
+            if self.inverted: 
+                if t == 0:
+                    inv_factor = 1.0 
+                elif t < vis:
+                    inv_factor = self._ease_in_out_cubic(t / vis)
+                elif t <= (T - vis):
+                    inv_factor = 1.0
+                else:
+                    inv_factor = self._ease_in_out_cubic(1.0 - ((t - (T - vis)) / vis))
+            else: 
+                if t > 0:
+                    if t > (T - vis):
+                         inv_factor = self._ease_in_out_cubic(1.0 - ((t - (T - vis)) / vis))
+            
+            # 8. OVERLAY
+            if inv_factor > 0:
+                if self._invert_mode_pixels:
+                    self._apply_invert_pixels(inv_factor)
+                else:
+                    self._apply_night_overlay_fallback(inv_factor)
+        
+        # 9. GAME OVER PANELİ
+        if self.crashed and self.game_over_panel:
+            self.game_over_panel.draw(self._alt_game_mode_active, self.trex)
+
+        # 10. DEBUG OVERLAY (draw last so it sits on top)
+        if self.debug is not None and self.debug.enabled:
+            self.debug.draw(self.screen, self.trex, self.horizon.obstacles if self.horizon else [])
+
+    # ========== Game over ==========
+    def _game_over(self) -> None:
+        assert self.distance_meter and self.trex
+        self._play_sound(self.snd_hit)
+        self.stop()
+        self.crashed = True
+        self.distance_meter.achievement = False
+        self.trex.update(100, TrexStatus.CRASHED)
+        if self.game_over_panel is None:
+            orig_def = sprite_definition_by_type["original"]["ldpi"]
+            self.game_over_panel = GameOverPanel(
+                self.screen, orig_def["textSprite"], orig_def["restart"],
+                self.dimensions, self
+            )
+        
+        if self.distance_ran > self.highest_score:
+            self.highest_score = int(math.ceil(self.distance_ran))
+            self.distance_meter.setHighScore(self.highest_score)
+
+        # Skoru/HI'ı çöküş karesinde de çizer (delta=0 ile donmuş)
+        self.distance_meter.update(0, math.ceil(self.distance_ran))
+
+        # Game over anını damgala (restart bekleme için)
+        self.game_over_time = pygame.time.get_ticks()
+        self.time_ms = self.game_over_time
+
+    # ========== Helpers ==========
+    def invert(self, reset: bool) -> None:
+        if reset:
+            self.invert_timer = 0
+            self.inverted = False
+        else:
+            self.inverted = not self.inverted
+    
+    def _get_invert_fade_factor(self) -> float:
+        if self.invert_timer == 0:
+            return 0.0 if not self.inverted else 1.0
+        
+        current_factor = min(1.0, self.invert_timer / self.config.invertFadeDuration)
+        return current_factor if self.inverted else (1.0 - current_factor)
+
+    def _apply_invert_pixels(self, fade_factor: float):
+        if fade_factor <= 0.0:
+            return
+        try:
+            src = sarr.pixels3d(self.screen).copy().astype(np.float32)
+            out = src * (1.0 - fade_factor) + (255.0 - src) * fade_factor
+            np.rint(out, out=out)
+            sarr.blit_array(self.screen, out.astype(np.uint8))
+        except Exception:
+            self._apply_night_overlay_fallback(fade_factor)
+
+    def _apply_night_overlay_fallback(self, fade_factor: float):
+        a = int(self.NIGHT_ALPHA_MAX * fade_factor)
+        if a > 0:
+            self._night_overlay.fill((0, 0, 0, a))
+            self.screen.blit(self._night_overlay, (0, 0))
+
+    def _play_sound(self, snd: Optional[pygame.mixer.Sound]) -> None:
+        if snd is not None and self._has_audio_cues:
+            try:
+                ch = pygame.mixer.find_channel(True)  # boş kanal bul, yoksa yarat
+                if ch is not None:
+                    ch.play(snd)
+                else:
+                    snd.play()
+            except Exception:
+                pass
+
+    # Collision port
+    def _check_for_collision(self, obstacle, trex: Trex) -> Optional[List[CollisionBox]]:
+        t_width = _get(trex.config, "width")
+        t_height = _get(trex.config, "height")
+        tbox = CollisionBox(
+            trex.xPos + 1,
+            trex.yPos + 1,
+            int(t_width) - 2,
+            int(t_height) - 2,
+        )
+
+        o_width = _get(obstacle.typeConfig, "width")
+        o_height = _get(obstacle.typeConfig, "height")
+        obox = CollisionBox(
+            obstacle.xPos + 1,
+            obstacle.yPos + 1,
+            int(o_width) * obstacle.size - 2,
+            int(o_height) - 2,
+        )
+
+        if not (
+            tbox.x < obox.x + obox.width and
+            tbox.x + tbox.width > obox.x and
+            tbox.y < obox.y + obox.height and
+            tbox.height + tbox.y > obox.y
+        ):
+            return None
+
+        if self.isAltGameModeEnabled():
+            runner_sprite_def = self.getSpriteDefinition()
+            tboxes = _get(_get(runner_sprite_def, "tRex", {}), "collisionBoxes", []) or []
+            norm = []
+            for b in tboxes:
+                if isinstance(b, CollisionBox):
+                    norm.append(b)
+                else:
+                    norm.append(
+                        CollisionBox(
+                            int(_get(b, "x", 0)),
+                            int(_get(b, "y", 0)),
+                            int(_get(b, "width", 0)),
+                            int(_get(b, "height", 0)),
+                        )
+                    )
+            tboxes = norm
+        else:
+            tboxes = trex.getCollisionBoxes()
+
+        for tb in tboxes:
+            for ob in obstacle.collisionBoxes:
+                adj_t = create_adjusted_box(tb, tbox)
+                adj_o = create_adjusted_box(ob, obox)
+                if (
+                    adj_t.x < adj_o.x + adj_o.width and
+                    adj_t.x + adj_t.width > adj_o.x and
+                    adj_t.y < adj_o.y + adj_o.height and
+                    adj_t.height + adj_o.y > adj_o.y
+                ):
+                    return [adj_t, adj_o]
+        return None
+
+
+# ==== Optional standalone run for smoke test =================
+if __name__ == "__main__":
+    # Ses için mixer’i init’ten önce yapılandır
+    pygame.mixer.pre_init(44100, -16, 2, 512)
+    pygame.init()
+    pygame.display.set_caption("NeuroDino — Runner (pygame)")
+    dims = Dimensions(width=600, height=150)
+    screen = pygame.display.set_mode((dims.width, dims.height))
+    clock = pygame.time.Clock()
+    
+    try:
+        runner = Runner(screen, dims, use_audio=True)
+    except Exception as e:
+        print(f"Oyun başlatılırken kritik bir hata oluştu: {e}")
+        pygame.quit()
+        raise SystemExit(1)
+
+    running = True
+    while running:
+        clock.tick(FPS)
+
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                running = False
+            if event.type == pygame.WINDOWFOCUSLOST:
+                continue
+            runner.handle_event(event)
+
+        runner.update()
+        pygame.display.flip()
+
+    pygame.quit()

pydino/trex.py

@@ -0,0 +1,488 @@
+# trex.py
+# pygame port of Chrome Dino trex.ts (config fixed to avoid dataclass issues)
+
+from __future__ import annotations
+from typing import Dict, List, Optional, Any
+import random # Göz kırpma için random import edildi
+
+import pygame
+
+def _blit_region_alpha(dst: pygame.Surface,
+                       src: pygame.Surface,
+                       src_rect: pygame.Rect,
+                       dest_xy: tuple[int, int],
+                       dest_wh: tuple[int, int] | None = None,
+                       overall_alpha: int | None = None) -> None:
+    """
+    Sprite sheet'ten bir dikdörtgeni per‑pixel alpha veya colorkey ile çizer.
+    Colorkey ve convert() kullanarak siyah arka planı kaldırır.
+    """
+    try:
+        # Alt yüzey al, colorkey uygula ve convert et.
+        frame = src.subsurface(src_rect).copy() 
+        frame.set_colorkey((0, 0, 0)) # Siyah rengi transparan anahtar olarak ayarla
+        frame = frame.convert() # Convert (alpha değil) çağırarak colorkey'i etkinleştir.
+
+        if dest_wh is not None and (frame.get_width(), frame.get_height()) != dest_wh:
+            # Ölçeklemede alpha kullanılmadığı için scale kullanmak daha iyi olabilir
+            frame = pygame.transform.scale(frame, dest_wh)
+            # Ölçekleme sonrası yeni yüzeye colorkey ayarını tekrar uygulayın
+            frame.set_colorkey((0, 0, 0)) 
+
+        # Alpha ayarı (Colorkey kullanıldığı için bu satırlar büyük ihtimalle etkisiz kalacaktır)
+        if overall_alpha is not None:
+            frame.set_alpha(overall_alpha)
+        else:
+            frame.set_alpha(None) # Alpha'yı kaldırır (varsayılan opaklık)
+            
+        dst.blit(frame, dest_xy)
+    except ValueError:
+        # Subsurface koordinatları hatalıysa görmezden gel (geçici çözüm)
+        # print(f"Uyarı: Geçersiz subsurface rect: {src_rect}")
+        pass
+
+
+try:
+    from constants import DEFAULT_DIMENSIONS, FPS
+    from offline_sprite_definitions import CollisionBox
+except ImportError:
+    from .constants import DEFAULT_DIMENSIONS, FPS
+    from .offline_sprite_definitions import CollisionBox
+
+# utils.get_time_stamp -> getTimeStamp fallback to pygame time
+try:
+    from utils import get_time_stamp as getTimeStamp
+except Exception:  # fallback
+    def getTimeStamp() -> int:
+        return pygame.time.get_ticks()
+
+
+# ---------------- Config helper (dict + attribute access) ------------------
+class TrexConfigDict(dict):
+    """Allow both dict-style and attribute-style access."""
+    def __getattr__(self, key):
+        try:
+            return self[key]
+        except KeyError as e:
+            raise AttributeError(key) from e
+    def __setattr__(self, key, value):
+        self[key] = value
+
+
+# Default base config and jump configs (mirrors trex.ts)
+DEFAULT_TREX_BASE: Dict[str, Any] = {
+    "dropVelocity": -5,
+    "flashOff": 175,
+    "flashOn": 100,
+    "height": 47, 
+    "heightDuck": 25,
+    "introDuration": 1500,
+    "speedDropCoefficient": 3,
+    "spriteWidth": 262,
+    "startXPos": 10, # <--- Başlangıç X pozisyonunu tanımla
+    "width": 44,
+    "widthDuck": 59,
+    "invertJump": False,
+    # Optional widths used in alt game states
+    "widthCrashed": None,
+    "widthJump": None,
+}
+
+SLOW_JUMP: Dict[str, Any] = {
+    "gravity": 0.25,
+    "maxJumpHeight": 50,
+    "minJumpHeight": 45,
+    "initialJumpVelocity": -20,
+}
+
+NORMAL_JUMP: Dict[str, Any] = {
+    "gravity": 0.6,
+    "maxJumpHeight": 30,
+    "minJumpHeight": 30,
+    "initialJumpVelocity": -10,
+}
+
+
+# ---------------- Collision boxes ------------------
+collisionBoxes_trex: Dict[str, List[CollisionBox]] = {
+    "ducking": [CollisionBox(1, 18, 55, 25)],
+    "running": [
+        CollisionBox(22, 0, 17, 16),
+        CollisionBox(1, 18, 30, 9),
+        CollisionBox(10, 35, 14, 8),
+        CollisionBox(1, 24, 29, 5),
+        CollisionBox(5, 30, 21, 4),
+        CollisionBox(9, 34, 15, 4),
+    ],
+}
+
+
+# ---------------- Status enum ------------------
+class Status:
+    CRASHED = 0
+    DUCKING = 1
+    JUMPING = 2
+    RUNNING = 3
+    WAITING = 4
+
+
+# Animation frames (pixels from sprite origin)
+BLINK_TIMING = 7000
+# Gözün kapalı kalacağı (ms) — orijinale göre daha kısa
+BLINK_CLOSED_MS = 120
+FrameInfo = Dict[str, Any]
+
+# DÜZELTME: Orijinal TS kodundaki gibi, WAITING için Göz Açık (ilk frame 0), Göz Kapalı (ikinci frame 44)
+animFrames: Dict[int, FrameInfo] = {
+    Status.WAITING: {"frames": [0, 44], "msPerFrame": 1000 / 3},
+    Status.RUNNING: {"frames": [88, 132], "msPerFrame": 1000 / 12},
+    Status.CRASHED: {"frames": [220], "msPerFrame": 1000 / 60},
+    Status.JUMPING: {"frames": [0], "msPerFrame": 1000 / 60},
+    Status.DUCKING: {"frames": [264, 323], "msPerFrame": 1000 / 8},
+}
+
+
+class Trex:
+    # resourceProvider: ConfigProvider & GameStateProvider & ImageSpriteProvider & (opt) GeneratedSoundFxProvider
+
+    def __init__(self, canvas: pygame.Surface, spritePos: Dict[str, int], resourceProvider: Any):
+        self.canvasCtx: pygame.Surface = canvas
+        self.spritePos: Dict[str, int] = spritePos
+        self.resourceProvider = resourceProvider
+
+        # Config (dict-like) : default base + normal jump
+        self.config = TrexConfigDict(**{**DEFAULT_TREX_BASE, **NORMAL_JUMP})
+
+        # Position / state
+        self.playingIntro: bool = False
+        self.xPos: int = 0 
+        self.yPos: int = 0
+        self.xInitialPos: int = self.config.startXPos 
+        self.groundYPos: int = 0
+        self.jumpCount: int = 0
+        self.ducking: bool = False
+        self.blinkCount: int = 0
+        self.jumping: bool = False
+        self.speedDrop: bool = False
+        self.status: int = Status.WAITING
+        self.reachedMinHeight: bool = False
+        self.altGameModeEnabled: bool = False
+        self.flashing: bool = False
+
+        # Animation / time
+        self.currentFrameIndex: int = 0 # frame index (0 or 1 for WAITING/RUNNING/DUCKING)
+        self.currentAnimFrames: List[int] = [] # x coordinates from sprite sheet
+        self.blinkDelay: int = 0
+        self.animStartTime: int = 0 # Used for blink timing
+        self.timer: float = 0.0 # Used for general frame advancement
+        self.msPerFrame: float = 1000.0 / FPS
+
+        # Motion / jump
+        self.jumpVelocity: float = 0.0
+        self.minJumpHeight: int = 0
+
+        # Ground position
+        runnerDefaultDimensions = DEFAULT_DIMENSIONS
+        runnerBottomPadding = self.resourceProvider.getConfig().bottomPad
+        assert runnerBottomPadding is not None
+        self.groundYPos = runnerDefaultDimensions.height - self.config.height - int(runnerBottomPadding)
+        self.yPos = self.groundYPos
+        self.minJumpHeight = self.groundYPos - self.config.minJumpHeight
+        self.xPos = self.xInitialPos 
+
+        # İlk update WAITING olarak çağrılacak
+        self.update(0, Status.WAITING)
+
+    # ---------------- Speed / config ------------------
+    def enableSlowConfig(self):
+        jump = SLOW_JUMP if getattr(self.resourceProvider, "hasSlowdown", False) else NORMAL_JUMP
+        for k, v in jump.items():
+            self.config[k] = v
+        self.adjustAltGameConfigForSlowSpeed()
+
+    def enableAltGameMode(self, spritePos: Dict[str, int]):
+        self.altGameModeEnabled = True
+        self.spritePos = spritePos
+        spriteDefinition = self.resourceProvider.getSpriteDefinition()
+        # Adjust bottom placement
+        self.groundYPos = DEFAULT_DIMENSIONS.height - self.config.height - spriteDefinition.get("bottomPad", 10)
+        self.yPos = self.groundYPos
+        self.reset()
+
+    def adjustAltGameConfigForSlowSpeed(self, gravityValue: Optional[float] = None):
+        if getattr(self.resourceProvider, "hasSlowdown", False):
+            if gravityValue is not None:
+                self.config["gravity"] = gravityValue / 1.5
+            self.config["minJumpHeight"] = int(self.config["minJumpHeight"] * 1.5)
+            self.config["maxJumpHeight"] = int(self.config["maxJumpHeight"] * 1.5)
+            self.config["initialJumpVelocity"] *= 1.5
+
+    # ---------------- Visual / state ------------------
+    def setFlashing(self, status: bool):
+        self.flashing = status
+
+    def setJumpVelocity(self, setting: float):
+        self.config["initialJumpVelocity"] = -setting
+        self.config["dropVelocity"] = -setting / 2.0
+
+    # <--- === GÜNCELLENMİŞ UPDATE FONKSİYONU (Orijinal TS Mantığına Daha Yakın) === --->
+    def update(self, deltaTime: float, status: Optional[int] = None):
+        self.timer += deltaTime # Genel zamanlayıcıyı ilerlet
+
+        # Update the status if changed
+        if status is not None and self.status != status:
+            self.status = status
+            self.currentFrameIndex = 0
+            self.msPerFrame = animFrames[status]["msPerFrame"]
+            self.currentAnimFrames = animFrames[status]["frames"]
+            self.timer = 0 # Reset general timer only when status changes
+            if status == Status.WAITING:
+                self.animStartTime = getTimeStamp()
+                self._setBlinkDelay()
+        
+        # Game intro animation
+        if self.playingIntro and self.xPos < self.config.startXPos:
+            self.xPos += round((self.config.startXPos / self.config.introDuration) * deltaTime)
+
+        # --- Drawing and Animation Frame Logic ---
+        if self.status == Status.WAITING:
+            self._blink(getTimeStamp()) # Blink handles its own drawing and timing
+        else:
+            # Draw current frame for non-WAITING states
+            sprite_x_to_draw = self.currentAnimFrames[self.currentFrameIndex]
+            self.draw(sprite_x_to_draw, 0)
+
+            # Advance frame based on timer for RUNNING and DUCKING
+            # Orijinal TS'deki gibi, yanıp sönme durumunda da kare ilerler
+            # Sadece çizim sırasında alpha değişir.
+            if self.timer >= self.msPerFrame:
+                 if self.status in [Status.RUNNING, Status.DUCKING]:
+                     self.currentFrameIndex = (self.currentFrameIndex + 1) % len(self.currentAnimFrames)
+                 self.timer = 0 # Reset general timer after frame change
+
+        # Speed drop becomes duck once on ground
+        if self.speedDrop and self.yPos == self.groundYPos:
+            self.speedDrop = False
+            self.setDuck(True)
+    # <--- === UPDATE BİTİŞ === --->
+
+    def draw(self, x: int, y: int):
+        # Force WAITING state to always use the blink frame, regardless of caller.
+        if self.status == Status.WAITING:
+            wait_frames = animFrames[Status.WAITING]["frames"]
+            if wait_frames:
+                idx = self.currentFrameIndex % len(wait_frames)
+                x = wait_frames[idx]
+        runnerImageSprite: pygame.Surface = self.resourceProvider.getRunnerImageSprite()
+        assert runnerImageSprite is not None
+
+        sourceX = x
+        sourceY = y
+        sourceWidth = self.config.widthDuck if (self.ducking and self.status != Status.CRASHED) else self.config.width
+        sourceHeight = self.config.height
+
+        outputHeight = sourceHeight
+        outputWidth = self.config.width if self.status != Status.CRASHED else (self.config.widthCrashed or self.config.width)
+
+        # Alt-mode width adjustments
+        if self.altGameModeEnabled:
+            if self.jumping and self.status != Status.CRASHED and self.config.widthJump:
+                sourceWidth = self.config.widthJump
+            elif self.status == Status.CRASHED and self.config.widthCrashed:
+                sourceWidth = self.config.widthCrashed
+
+        # Pygame'de HIDPI yönetimi farklıdır, scale faktörünü doğrudan kullanmıyoruz
+        # Sprite tanımındaki x,y,w,h değerlerini doğrudan kullanacağız
+        # IS_HIDPI kontrolü kaldırıldı
+        scale = 1 # Varsayılan ölçek
+
+        sx = int(self.spritePos["x"] + sourceX) # * scale kaldırıldı
+        sy = int(self.spritePos["y"] + sourceY) # * scale kaldırıldı
+        sw = int(sourceWidth)                   # * scale kaldırıldı
+        sh = int(sourceHeight)                  # * scale kaldırıldı
+        
+        # Koordinatların geçerli olup olmadığını kontrol et
+        img_w, img_h = runnerImageSprite.get_size()
+        # spritePos genellikle LDPI içindir, HDPI sprite kullanıyorsak düzeltme gerekebilir
+        # Şimdilik LDPI varsayalım
+        if sx < 0 or sy < 0 or sx + sw > img_w or sy + sh > img_h:
+             # print(f"Uyarı: Geçersiz kaynak koordinatları: Rect({sx}, {sy}, {sw}, {sh}), Img Size: ({img_w}, {img_h})")
+             return 
+
+        src_rect = pygame.Rect(sx, sy, sw, sh)
+
+        # Target size (logical output) - Ölçekleme yoksa kaynakla aynı
+        dw = int(sourceWidth) # Output width düzeltmesi
+        dh = int(sourceHeight) # Output height düzeltmesi
+
+        # Hedef boyutları config'den al (ducking durumu için)
+        dw_config = self.config.widthDuck if (self.ducking and self.status != Status.CRASHED) else outputWidth
+        dh_config = outputHeight
+        dw = int(dw_config)
+        dh = int(dh_config)
+
+
+        # Alt jump xOffset (optional in sprite definition)
+        dx = self.xPos
+        if self.altGameModeEnabled and self.jumping and self.status != Status.CRASHED:
+            # Alt game mode desteklenmiyor, bu bloğu yoksayabiliriz şimdilik
+            pass 
+            # spriteDefinition = self.resourceProvider.getSpriteDefinition()
+            # tRexDef = spriteDefinition.get("tRex")
+            # if tRexDef and isinstance(tRexDef, dict):
+            #     xo = tRexDef.get("jumping", {}).get("xOffset", 0)
+            #     dx = self.xPos - xo # scale kaldırıldı
+
+        # Flashing alpha kontrolü
+        overall_alpha = None
+        if self.flashing:
+            # Orijinal TS mantığına daha yakın: Genel zamanlayıcıyı kullan
+            flash_timer_check = self.timer % (self.config.flashOn + self.config.flashOff)
+            if flash_timer_check < self.config.flashOn:
+                overall_alpha = 128 # Yarı saydam
+            # else: Tam opak (alpha=None) - _blit_region_alpha bunu halleder
+        
+        # Per-pixel alpha safe blit (prevents black boxes)
+        _blit_region_alpha(
+            dst=self.canvasCtx,
+            src=runnerImageSprite,
+            src_rect=src_rect,
+            dest_xy=(int(dx), int(self.yPos)), 
+            dest_wh=(dw, dh), # Hedef boyutları kullan
+            overall_alpha=overall_alpha,
+        )
+
+    def _setBlinkDelay(self):
+        # Orijinal TS Math.ceil(Math.random() * BLINK_TIMING) -> 1 ile BLINK_TIMING arası
+        self.blinkDelay = random.randint(1, BLINK_TIMING) 
+
+    # <--- === GÜNCELLENMİŞ BLINK FONKSİYONU (Orijinal TS Mantığına Daha Yakın) === --->
+    def _blink(self, time_ms: int):
+        """Make t-rex blink at random intervals."""
+        deltaTime = time_ms - self.animStartTime
+
+        # WAITING animasyon bilgilerini al
+        wait_anim = animFrames[Status.WAITING]
+        wait_frames = wait_anim["frames"] # [Göz Açık X, Göz Kapalı X]
+        closed_eye_duration = BLINK_CLOSED_MS  # Gözün kapalı kalma süresi (ms)
+
+        # Geçerli sprite X koordinatını belirle
+        sprite_x_to_draw = wait_frames[self.currentFrameIndex]
+
+        # Dinozoru çiz
+        self.draw(sprite_x_to_draw, 0)
+
+        # Zamanlamayı kontrol et ve kareyi değiştir (Orijinal TS Mantığı)
+        # Eğer göz kırpma zamanı geldiyse (ve şu an göz açıksa - index 0)
+        if self.currentFrameIndex == 0 and deltaTime >= self.blinkDelay:
+             self.currentFrameIndex = 1 # Göz kapalı kareye geç (index 1)
+             self.animStartTime = time_ms # Gözün kapalı kalma süresini başlat
+        
+        # Eğer göz kapalıysa (index 1) ve kapalı kalma süresi dolduysa
+        elif self.currentFrameIndex == 1 and deltaTime >= closed_eye_duration:
+             self.currentFrameIndex = 0 # Göz açık kareye geç (index 0)
+             self._setBlinkDelay()      # Yeni bir blink zamanı ayarla
+             self.animStartTime = time_ms # Gözün açık kalma süresini başlat
+             self.blinkCount += 1
+    # <--- === BLINK BİTİŞ === --->
+
+    # ---------------- Jump / motion (DEĞİŞİKLİK YOK) ------------------
+    def startJump(self, speed: float):
+        if not self.jumping:
+            # self.update(0, Status.JUMPING) # update'i direkt çağırma, state'i ayarla
+            self.status = Status.JUMPING
+            self.currentFrameIndex = 0
+            self.timer = 0
+            self.msPerFrame = animFrames[Status.JUMPING]["msPerFrame"]
+            self.currentAnimFrames = animFrames[Status.JUMPING]["frames"]
+            
+            self.jumpVelocity = self.config.initialJumpVelocity - (speed / 10.0)
+            self.jumping = True
+            self.reachedMinHeight = False
+            self.speedDrop = False
+            if self.config.invertJump:
+                self.minJumpHeight = self.groundYPos + self.config.minJumpHeight
+
+    def endJump(self):
+        if self.reachedMinHeight and self.jumpVelocity < self.config.dropVelocity:
+            self.jumpVelocity = self.config.dropVelocity
+
+    def updateJump(self, deltaTime: float):
+        # msPerFrame JUMPING durumundan alınmalı
+        msPerFrame = animFrames[Status.JUMPING]["msPerFrame"]
+        framesElapsed = (deltaTime / msPerFrame) if msPerFrame > 0 else 1.0
+
+        if self.speedDrop:
+            self.yPos += round(self.jumpVelocity * self.config.speedDropCoefficient * framesElapsed)
+        elif self.config.invertJump:
+            self.yPos -= round(self.jumpVelocity * framesElapsed)
+        else:
+            self.yPos += round(self.jumpVelocity * framesElapsed)
+
+        self.jumpVelocity += self.config.gravity * framesElapsed
+
+        # Min height reached?
+        if (self.config.invertJump and (self.yPos > self.minJumpHeight)) or \
+           ((not self.config.invertJump) and (self.yPos < self.minJumpHeight)) or \
+           self.speedDrop:
+            self.reachedMinHeight = True
+
+        # Max height logic
+        if (self.config.invertJump and (self.yPos > -self.config.maxJumpHeight)) or \
+           ((not self.config.invertJump) and (self.yPos < self.config.maxJumpHeight)) or \
+           self.speedDrop:
+            self.endJump()
+
+        # Back down at ground level. Jump completed.
+        if (self.config.invertJump and (self.yPos < self.groundYPos)) or \
+           ((not self.config.invertJump) and (self.yPos > self.groundYPos)):
+            self.reset()
+            self.jumpCount += 1
+            if getattr(self.resourceProvider, "hasAudioCues", False):
+                if hasattr(self.resourceProvider, "getGeneratedSoundFx"):
+                    try:
+                        self.resourceProvider.getGeneratedSoundFx().loopFootSteps()
+                    except Exception:
+                        pass
+
+    def setSpeedDrop(self):
+        self.speedDrop = True
+        self.jumpVelocity = 1
+
+    def setDuck(self, isDucking: bool):
+        if isDucking and self.status != Status.DUCKING:
+            # self.update(0, Status.DUCKING) # update'i çağırma
+            self.status = Status.DUCKING
+            self.currentFrameIndex = 0
+            self.timer = 0
+            self.msPerFrame = animFrames[Status.DUCKING]["msPerFrame"]
+            self.currentAnimFrames = animFrames[Status.DUCKING]["frames"]
+            self.ducking = True
+        elif self.status == Status.DUCKING and not isDucking: 
+            # self.update(0, Status.RUNNING) # update'i çağırma
+            self.status = Status.RUNNING
+            self.currentFrameIndex = 0
+            self.timer = 0
+            self.msPerFrame = animFrames[Status.RUNNING]["msPerFrame"]
+            self.currentAnimFrames = animFrames[Status.RUNNING]["frames"]
+            self.ducking = False
+
+    def reset(self):
+        self.xPos = self.xInitialPos # reset'te xInitialPos'a dönmeli
+        self.yPos = self.groundYPos
+        self.jumpVelocity = 0
+        self.jumping = False
+        self.ducking = False
+        
+        self.status = Status.RUNNING # Sadece durumu ayarla
+        self.currentFrameIndex = 0   # Animasyonu sıfırla
+        self.timer = 0               # Zamanlayıcıyı sıfırla
+        self.currentAnimFrames = animFrames[Status.RUNNING]["frames"] # Kareleri ayarla
+        self.msPerFrame = animFrames[Status.RUNNING]["msPerFrame"] # Hızı ayarla
+
+        self.speedDrop = False
+        self.jumpCount = 0
+
+    def getCollisionBoxes(self) -> List[CollisionBox]:
+        return collisionBoxes_trex["ducking"] if self.ducking else collisionBoxes_trex["running"]
+

pydino/utils.py

@@ -0,0 +1,32 @@
+# utils.py
+# 1:1 port of utils.ts for a pygame-based Chrome Dino port.
+
+from __future__ import annotations
+import random
+import time
+try:
+    from constants import IS_IOS
+except ImportError:
+    IS_IOS = False
+
+
+def get_random_num(min_val: int, max_val: int) -> int:
+    """Inclusive integer random: [min_val, max_val]."""
+    # TS: Math.floor(Math.random() * (max - min + 1)) + min
+    return random.randint(min_val, max_val)
+
+
+def get_time_stamp() -> int:
+    """Current timestamp in milliseconds.
+    TS: IS_IOS ? Date().getTime() : performance.now()
+    """
+    if IS_IOS:
+        # Wall-clock ms
+        return int(time.time() * 1000)
+    # High-resolution monotonic ms
+    return int(time.perf_counter() * 1000)
+
+
+# --- Aliases for TS-style imports (camelCase) ---
+getRandomNum = get_random_num
+getTimeStamp = get_time_stamp

watch_model.py

@@ -0,0 +1,650 @@
+#!/usr/bin/env python3
+"""
+NeuroDino - Model Watcher (Inference Mode)
+
+Watch your trained brain play the game without training.
+Press 'S' to toggle between 60 FPS and Unlimited FPS.
+Press 'R' to restart the game.
+Press 'Q' or ESC to quit.
+
+Usage:
+    python watch_model.py                    # Load best_brain.pkl
+    python watch_model.py --brain path.pkl   # Load specific brain file
+    python watch_model.py --fast             # Start in unlimited FPS mode
+    python watch_model.py --silent           # No display, just run and print scores
+"""
+
+import os
+import sys
+import argparse
+import pickle
+import pygame
+
+# Add pydino directory to sys.path
+pydino_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "pydino")
+sys.path.append(pydino_path)
+
+from dimensions import Dimensions
+from pydino.runner import Runner, Config
+from pydino.trex import Trex, Status as TrexStatus
+from neurodino.neuro_trex import NeuroTrex
+from neurodino.brain import Brain
+import numpy as np
+import math
+
+# Constants (must match training)
+GAME_HEIGHT = 150
+MAX_OBSTACLE_WIDTH = 75
+MAX_TTI_FRAMES = 50.0
+DUCK_THRESHOLD_Y = 75
+
+
+class ModelWatcher(Runner):
+    """
+    Simplified runner for watching a single trained brain play.
+    No training, no population - just inference.
+    """
+    
+    def __init__(self, screen, dimensions, brain: Brain, target_fps=60, silent=False):
+        super().__init__(screen, dimensions, use_audio=not silent)
+        
+        self.brain = brain
+        self.target_fps = target_fps
+        self.score = 0
+        self.high_score = 0
+        self.games_played = 0
+        self.silent = silent
+        self.last_10k = 0  # Track last 10K milestone for silent mode
+        
+        # Night mode variables (matching original Runner)
+        self.inverted = False
+        self.invert_timer = 0
+        self.invert_trigger = False
+        self.NIGHT_ALPHA_MAX = 180
+        self.VISUAL_INVERT_MS = 1000
+        self._night_overlay = pygame.Surface((dimensions.width, dimensions.height), pygame.SRCALPHA)
+        
+        # Visualization toggles
+        self.viz_bezier = True      # B - Use Bezier curves
+        self.viz_width = True       # W - Edge width proportional to weights
+        self.viz_opacity = True     # O - Edge opacity proportional to weights
+        self.viz_color = True       # C - Edge color by weight sign (blue/red vs gray)
+        
+        # Replace default trex with our NeuroTrex
+        self._setup_neuro_trex()
+    
+    def _setup_neuro_trex(self):
+        """Setup a single NeuroTrex with the loaded brain."""
+        self.dino = NeuroTrex(self.screen, self.sprite_def["tRex"], self)
+        self.dino.brain = self.brain
+        self.dino.visible = True
+        self.trex = self.dino  # For compatibility with base Runner
+    
+    def _get_inputs(self):
+        """Get inputs for the brain (same as training)."""
+        dino = self.dino
+        speed = self.current_speed / self.config.maxSpeed
+        
+        # Dino state
+        ground_y = dino.groundYPos
+        max_jump = dino.config.maxJumpHeight
+        
+        dino_y_normalized = 0.0
+        if dino.jumping:
+            height_above_ground = ground_y - dino.yPos
+            dino_y_normalized = min(1.0, max(0.0, height_above_ground / max_jump))
+        
+        dino_velocity = 0.0
+        if dino.jumping:
+            dino_velocity = max(-1.0, min(1.0, dino.jumpVelocity / 10.0))
+        
+        is_airborne = 1.0 if dino.jumping else 0.0
+        is_ducking = 1.0 if dino.ducking else 0.0
+        
+        # Obstacles
+        obs1_dist = 0.0
+        obs1_action = 0.0
+        obs1_w = 0.0
+        obs2_dist = 0.0
+        obs2_action = 0.0
+        obs2_w = 0.0
+        gap = 0.0
+        
+        if self.horizon and self.horizon.obstacles:
+            dino_front = dino.xPos
+            future_obstacles = [o for o in self.horizon.obstacles if o.xPos > dino_front]
+            future_obstacles.sort(key=lambda o: o.xPos)
+            
+            if len(future_obstacles) > 0:
+                o1 = future_obstacles[0]
+                dist1 = o1.xPos - dino.xPos
+                tti1 = dist1 / max(1.0, self.current_speed)
+                obs1_dist = 1.0 - min(1.0, tti1 / MAX_TTI_FRAMES)
+                obs1_action = 1.0 if o1.yPos < DUCK_THRESHOLD_Y else 0.0
+                obs1_w = min(1.0, o1.width / MAX_OBSTACLE_WIDTH)
+                
+                if len(future_obstacles) > 1:
+                    o2 = future_obstacles[1]
+                    dist2 = o2.xPos - dino.xPos
+                    tti2 = dist2 / max(1.0, self.current_speed)
+                    obs2_dist = 1.0 - min(1.0, tti2 / MAX_TTI_FRAMES)
+                    obs2_action = 1.0 if o2.yPos < DUCK_THRESHOLD_Y else 0.0
+                    obs2_w = min(1.0, o2.width / MAX_OBSTACLE_WIDTH)
+                    
+                    raw_gap = o2.xPos - (o1.xPos + o1.width)
+                    time_gap = raw_gap / max(1.0, self.current_speed)
+                    gap = 1.0 - min(1.0, time_gap / 15.0)
+        
+        return np.array([
+            obs1_dist, obs1_action, obs1_w,
+            obs2_dist, obs2_action, obs2_w,
+            speed, gap,
+            dino_y_normalized, dino_velocity,
+            is_airborne, is_ducking
+        ])
+    
+    def update(self):
+        """Game loop with AI control."""
+        now = pygame.time.get_ticks()
+        delta = 1000.0 / 60  # Fixed 60 FPS physics
+        self.time_ms = now
+        
+        # Clear screen (skip in silent mode)
+        if not self.silent:
+            self.screen.fill((247, 247, 247))
+        
+        # Update game state
+        if self.playing:
+            self.running_time += delta
+        
+        has_obstacles = self.running_time > self.config.clearTime
+        
+        # Night mode logic (from original Runner) - always update timer, even in turbo
+        show_night_mode = self.inverted
+        if self.playing:
+            actual_score = int(self.distance_ran * 0.025)
+            
+            # Timer-based fade cycle
+            if self.invert_timer > self.config.invertFadeDuration:
+                self.invert_timer = 0
+                self.invert_trigger = False
+                self.inverted = not self.inverted
+            elif self.invert_timer > 0:
+                self.invert_timer += delta
+            else:
+                # Trigger at each invertDistance milestone
+                if actual_score > 0 and (actual_score % self.config.invertDistance == 0) and not self.invert_trigger:
+                    self.invert_timer += delta
+                    self.inverted = not self.inverted
+                    self.invert_trigger = True
+                elif (actual_score % self.config.invertDistance) != 0:
+                    self.invert_trigger = False
+        
+        # Draw horizon FIRST (includes moon, stars, clouds, ground) 
+        self.horizon.update(delta, self.current_speed, has_obstacles, show_night_mode)
+        
+        # AI Decision and Dino update (draws dino ON TOP of horizon)
+        if self.playing and not self.crashed and self.dino.status != TrexStatus.CRASHED:
+            inputs = self._get_inputs()
+            outputs = self.dino.brain.predict(inputs)
+            action = np.argmax(outputs)
+            self.dino.act(action)
+            self.dino.update(delta)  # This draws dino
+            
+            if self.dino.jumping:
+                self.dino.updateJump(delta)
+        
+        if self.playing and not self.silent:
+            self.distance_meter.update(delta, math.ceil(self.distance_ran))
+        
+        # Collision detection
+        if self.playing and not self.crashed:
+            if has_obstacles and self.horizon.obstacles:
+                for obstacle in self.horizon.obstacles:
+                    if self._check_for_collision(obstacle, self.dino):
+                        self.dino.update(100, TrexStatus.CRASHED)
+                        self.crashed = True
+                        self._on_game_over()
+                        break
+            
+            if not self.crashed:
+                self.distance_ran += self.current_speed * (delta / self.ms_per_frame)
+                self.score = int(self.distance_ran * 0.025)
+                
+                # Silent mode: Print every 10K
+                if self.silent:
+                    current_10k = self.score // 10000
+                    if current_10k > self.last_10k:
+                        self.last_10k = current_10k
+                        print(f"📈 Score: {self.score:,}")
+                
+                if self.current_speed < self.config.maxSpeed:
+                    self.current_speed += self.config.acceleration
+        
+        # Draw game over panel if crashed (skip in silent mode)
+        if not self.silent and self.crashed and self.game_over_panel:
+            self.game_over_panel.draw(False, self.dino)
+        
+        # Apply night overlay (skip in silent mode)
+        if not self.silent:
+            fade_factor = self._get_invert_fade_factor()
+            if fade_factor > 0:
+                self._apply_night_overlay(fade_factor)
+        
+        # Draw stats overlay (skip in silent mode)
+        # Blit game surface to main screen (centered)
+        if not self.silent and hasattr(self, 'main_screen'):
+            # Clear main screen
+            self.main_screen.fill((247, 247, 247))
+            # Blit game surface centered
+            offset = getattr(self, 'game_offset', 0)
+            self.main_screen.blit(self.screen, (offset, 0))
+            # Draw stats and brain on main screen
+            self._draw_stats(self.main_screen, offset)
+            self._draw_brain(self.main_screen)
+    
+    def _get_invert_fade_factor(self):
+        """Calculate fade factor for night mode transition (from original Runner)."""
+        T = self.config.invertFadeDuration
+        t = self.invert_timer
+        vis = self.VISUAL_INVERT_MS
+        
+        if self.inverted:
+            if t == 0:
+                return 1.0
+            elif t < vis:
+                return self._ease_in_out_cubic(t / vis)
+            elif t <= (T - vis):
+                return 1.0
+            else:
+                return self._ease_in_out_cubic(1.0 - ((t - (T - vis)) / vis))
+        else:
+            if t > 0 and t > (T - vis):
+                return self._ease_in_out_cubic(1.0 - ((t - (T - vis)) / vis))
+        return 0.0
+    
+    def _ease_in_out_cubic(self, t):
+        """CSS-like ease-in-out for smooth transitions."""
+        if t <= 0.0:
+            return 0.0
+        if t >= 1.0:
+            return 1.0
+        if t < 0.5:
+            return 4.0 * t * t * t
+        return 1.0 - ((-2.0 * t + 2.0) ** 3) / 2.0
+    
+    def _apply_night_overlay(self, fade_factor):
+        if fade_factor <= 0.0:
+            return
+        
+        try:
+            # Get pixels as array (only for game area, not brain viz)
+            game_rect = pygame.Rect(0, 0, self.screen.get_width(), 150)
+            game_surface = self.screen.subsurface(game_rect)
+            
+            # Convert to array, invert, then blend
+            pixels = pygame.surfarray.pixels3d(game_surface)
+            inverted = 255 - pixels
+            
+            # Blend between original and inverted based on fade_factor
+            blended = pixels * (1.0 - fade_factor) + inverted * fade_factor
+            np.copyto(pixels, blended.astype(np.uint8))
+            del pixels  # Release surface lock
+        except Exception:
+            # Fallback to dark overlay if pixel manipulation fails
+            alpha = int(self.NIGHT_ALPHA_MAX * fade_factor)
+            if alpha > 0:
+                self._night_overlay.fill((0, 0, 0, alpha))
+                self.screen.blit(self._night_overlay, (0, 0))
+    
+    def _on_game_over(self):
+        """Handle game over."""
+        self.games_played += 1
+        if self.score > self.high_score:
+            self.high_score = self.score
+        
+        if self.silent:
+            print(f"💀 ÖLDÜ! Score: {self.score:,} | High: {self.high_score:,} | Game #{self.games_played}")
+        else:
+            print(f"Game {self.games_played}: Score {self.score} | High Score: {self.high_score}")
+    
+    def restart_game(self):
+        """Restart the game."""
+        self.crashed = False
+        self.playing = True
+        self.distance_ran = 0
+        self.score = 0
+        self.last_10k = 0  # Reset 10K tracker
+        self.current_speed = self.config.speed
+        self.running_time = 0
+        
+        # Reset night mode
+        self.inverted = False
+        self.invert_timer = 0
+        self.invert_trigger = False
+        
+        self.horizon.reset()
+        if not self.silent:
+            self.distance_meter.reset()
+        
+        # Reset dino
+        self._setup_neuro_trex()
+        self.dino.update(0, TrexStatus.RUNNING)
+    
+    def _draw_stats(self, target_screen, offset=0):
+        """Draw stats overlay - only speed."""
+        font = pygame.font.Font(None, 28)
+        txt = font.render(f"Speed: {self.current_speed:.1f}", True, (80, 80, 80))
+        target_screen.blit(txt, (offset + 10, 10))
+    
+    def _draw_brain(self, target_screen):
+        """Draw brain visualization."""
+        brain = self.brain
+        if not hasattr(brain, "last_inputs"):
+            return
+        
+        start_y = 150
+        w = target_screen.get_width()
+        h = target_screen.get_height() - start_y
+        
+        # Background - white
+        surf = pygame.Surface((w, h))
+        surf.fill((255, 255, 255))
+        target_screen.blit(surf, (0, start_y))
+        
+        # Layout - use screen width for positioning
+        layer_x = [80, w // 2, w - 80]
+        input_y = np.linspace(start_y + 30, start_y + h - 30, brain.input_nodes)
+        hidden_y = np.linspace(start_y + 20, start_y + h - 20, brain.hidden_nodes)
+        
+        # Center output nodes vertically (3 nodes with 60px spacing)
+        center_y = start_y + h // 2
+        output_spacing = 80
+        output_y = [center_y - output_spacing, center_y, center_y + output_spacing]
+        
+        input_labels = ["O1 TTI", "O1 Act", "O1 W", "O2 TTI", "O2 Act", "O2 W", 
+                       "Speed", "Gap", "DinoY", "DinoVel", "Air", "Duck"]
+        output_labels = ["Jump", "Duck", "Run"]
+        
+        font = pygame.font.Font(None, 18)
+        
+        def get_color(val):
+            v = max(0, min(1, abs(val)))
+            return (int(v*255), int(v*255), int(v*255))
+        
+        def draw_bezier(start, end, color, width=1):
+            """Draw a Bezier curve between two points."""
+            x1, y1 = start
+            x2, y2 = end
+            # Control points for smooth curve
+            mid_x = (x1 + x2) // 2
+            ctrl1 = (mid_x, y1)
+            ctrl2 = (mid_x, y2)
+            
+            # Generate curve points
+            points = []
+            for t in range(0, 21):
+                t = t / 20.0
+                # Cubic Bezier formula
+                x = int((1-t)**3 * x1 + 3*(1-t)**2*t * ctrl1[0] + 3*(1-t)*t**2 * ctrl2[0] + t**3 * x2)
+                y = int((1-t)**3 * y1 + 3*(1-t)**2*t * ctrl1[1] + 3*(1-t)*t**2 * ctrl2[1] + t**3 * y2)
+                points.append((x, y))
+            
+            if len(points) > 1:
+                if width > 1:
+                    pygame.draw.lines(target_screen, color, False, points, width)
+                else:
+                    pygame.draw.aalines(target_screen, color, False, points)
+        
+        # Draw weights with curves or lines (only strong connections)
+        def draw_edge(start, end, weight):
+            # Base color based on viz_color toggle
+            if self.viz_color:
+                # Colored mode: blue = positive, red = negative
+                if weight < 0:
+                    base_color = (255, 0, 0)    # Red for negative
+                else:
+                    base_color = (0, 0, 255)    # Blue for positive
+            else:
+                # Gray mode
+                base_color = (80, 80, 80)
+            
+            # Apply opacity if enabled - NN-SVG style (linear 0-1, weak weights invisible)
+            if self.viz_opacity:
+                # Linear scale like NN-SVG: domain([0, 1]).range([0, 1])
+                w_norm = min(1.0, abs(weight))
+                if w_norm < 0.05:
+                    return  # Skip drawing very weak connections
+                # Blend from white background (255,255,255) to base_color based on weight
+                # weak = white (invisible on white bg), strong = base_color
+                color = (int(255 - (255 - base_color[0]) * w_norm),
+                        int(255 - (255 - base_color[1]) * w_norm),
+                        int(255 - (255 - base_color[2]) * w_norm))
+            else:
+                color = base_color
+            
+            # Apply width if enabled - FCNN style (weak = thin/invisible)
+            if self.viz_width:
+                # Linear scale: weight 0 -> width 0, weight 1 -> width 3
+                width = int(abs(weight) * 3)
+                if width < 1:
+                    return  # Skip drawing very thin connections
+            else:
+                width = 1
+            
+            # Draw Bezier or straight line
+            if self.viz_bezier:
+                draw_bezier(start, end, color, width)
+            else:
+                pygame.draw.line(target_screen, color, start, end, width)
+        
+        # Threshold: show all when opacity OFF, filter weak when ON
+        threshold = 0.05 if self.viz_opacity else 0.001
+        
+        for i in range(brain.input_nodes):
+            for j in range(brain.hidden_nodes):
+                weight = brain.weights_ih[j][i]
+                if abs(weight) > threshold:
+                    draw_edge((layer_x[0], int(input_y[i])), 
+                             (layer_x[1], int(hidden_y[j])), weight)
+        
+        for j in range(brain.hidden_nodes):
+            for k in range(brain.output_nodes):
+                weight = brain.weights_ho[k][j]
+                if abs(weight) > threshold:
+                    draw_edge((layer_x[1], int(hidden_y[j])),
+                             (layer_x[2], int(output_y[k])), weight)
+        
+        # Draw input nodes
+        for i, val in enumerate(brain.last_inputs):
+            pos = (layer_x[0], int(input_y[i]))
+            pygame.draw.circle(target_screen, (255, 255, 255), pos, 8)
+            pygame.draw.circle(target_screen, (51, 51, 51), pos, 8, 1)
+            lbl = font.render(f"{input_labels[i]}:{val:.2f}", True, (0, 0, 0))
+            target_screen.blit(lbl, (pos[0]-40, pos[1]-12))
+        
+        # Draw hidden nodes
+        for i, val in enumerate(brain.last_hidden):
+            pos = (layer_x[1], int(hidden_y[i]))
+            pygame.draw.circle(target_screen, (255, 255, 255), pos, 6)
+            pygame.draw.circle(target_screen, (51, 51, 51), pos, 6, 1)
+        
+        # Draw output nodes
+        max_idx = np.argmax(brain.last_outputs)
+        for i, val in enumerate(brain.last_outputs):
+            color = (0, 255, 0) if i == max_idx else (255, 255, 255)
+            pos = (layer_x[2], int(output_y[i]))
+            radius = 10 + int(val * 10)
+            pygame.draw.circle(target_screen, color, pos, radius)
+            pygame.draw.circle(target_screen, (51, 51, 51), pos, radius, 2)
+            lbl = font.render(f"{output_labels[i]} ({val:.0%})", True, (0, 0, 0))
+            target_screen.blit(lbl, (pos[0]+20, pos[1]-8))
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Watch trained NeuroDino model')
+    parser.add_argument('--brain', type=str, default='best_brain.pkl',
+                        help='Path to brain file (default: best_brain.pkl)')
+    parser.add_argument('--fast', action='store_true',
+                        help='Start in unlimited FPS mode')
+    parser.add_argument('--silent', action='store_true',
+                        help='No display, just run simulation and print scores')
+    args = parser.parse_args()
+    
+    # Load brain
+    if not os.path.exists(args.brain):
+        print(f"Error: Brain file not found: {args.brain}")
+        print("Train a model first with: python main_train.py")
+        sys.exit(1)
+    
+    try:
+        with open(args.brain, "rb") as f:
+            data = pickle.load(f)
+            if isinstance(data, tuple):
+                brain, score = data
+                print(f"✅ Loaded brain from {args.brain}")
+                print(f"   Training score: {score:,}")
+            else:
+                brain = data
+                print(f"✅ Loaded brain from {args.brain} (legacy format)")
+    except Exception as e:
+        print(f"Error loading brain: {e}")
+        sys.exit(1)
+    
+    # Silent mode setup
+    if args.silent:
+        os.environ['SDL_VIDEODRIVER'] = 'dummy'
+        os.environ['SDL_AUDIODRIVER'] = 'dummy'
+        print("🔇 SILENT MODE - No display, maximum speed")
+        print("   Press Ctrl+C to stop\n")
+    
+    # Initialize pygame
+    pygame.init()
+    
+    if not args.silent:
+        pygame.display.set_caption("NeuroDino - Model Watcher")
+    
+    # Game area stays fixed at 600x150, neural network area expanded
+    dims = Dimensions(width=600, height=150)
+    screen = pygame.display.set_mode((900, 850))  # Wider and taller for NN
+    
+    # Create separate surface for game at original size
+    game_surface = pygame.Surface((dims.width, dims.height))
+    game_offset = (900 - 600) // 2  # Center horizontally
+    
+    clock = pygame.time.Clock()
+    
+    # Create watcher - pass game_surface as the drawing target for the game
+    watcher = ModelWatcher(game_surface, dims, brain, silent=args.silent)
+    watcher.main_screen = screen  # Store main screen for NN drawing
+    watcher.game_offset = game_offset  # Store offset for centering
+    watcher.start()
+    
+    # FPS modes: 0=60fps, 1=unlimited, 2=turbo
+    speed_mode = 0
+    if args.fast:
+        speed_mode = 1
+    if args.silent:
+        speed_mode = 2
+    
+    turbo_mode = False  # Runtime turbo toggle (no drawing)
+    
+    if not args.silent:
+        print("\n🎮 Controls:")
+        print("   S - Toggle speed (60 FPS → Unlimited → Turbo)")
+        print("   B - Toggle Bezier curves")
+        print("   W - Toggle edge width proportional to weights")
+        print("   O - Toggle edge opacity proportional to weights")
+        print("   C - Toggle edge color (Blue/Red vs Gray)")
+        print("   R - Restart game")
+        print("   Q/ESC - Quit\n")
+    
+    
+    running = True
+    last_log_time = pygame.time.get_ticks()
+    frame_count = 0
+    
+    try:
+        while running:
+            # FPS control based on mode
+            if speed_mode == 0:
+                clock.tick(60)
+            else:
+                clock.tick()  # Unlimited
+            
+            frame_count += 1
+            
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    running = False
+                elif event.type == pygame.KEYDOWN and not args.silent:
+                    if event.key == pygame.K_q or event.key == pygame.K_ESCAPE:
+                        running = False
+                    elif event.key == pygame.K_s:
+                        # Cycle through 3 modes
+                        speed_mode = (speed_mode + 1) % 3
+                        turbo_mode = (speed_mode == 2)
+                        watcher.silent = turbo_mode
+                        
+                        mode_names = ["60 FPS", "UNLIMITED", "🚀 TURBO (no draw)"]
+                        print(f"Speed: {mode_names[speed_mode]}")
+                    elif event.key == pygame.K_r:
+                        watcher.restart_game()
+                        print("Game restarted!")
+                    elif event.key == pygame.K_b:
+                        watcher.viz_bezier = not watcher.viz_bezier
+                        print(f"Bezier curves: {'ON' if watcher.viz_bezier else 'OFF'}")
+                    elif event.key == pygame.K_w:
+                        watcher.viz_width = not watcher.viz_width
+                        print(f"Edge width: {'ON' if watcher.viz_width else 'OFF'}")
+                    elif event.key == pygame.K_o:
+                        watcher.viz_opacity = not watcher.viz_opacity
+                        print(f"Edge opacity: {'ON' if watcher.viz_opacity else 'OFF'}")
+                    elif event.key == pygame.K_c:
+                        watcher.viz_color = not watcher.viz_color
+                        print(f"Edge color: {'Blue/Red' if watcher.viz_color else 'Gray'}")
+            
+            watcher.update()
+            
+            if not args.silent and not turbo_mode:
+                pygame.display.flip()
+            
+            # Auto-restart on crash
+            if watcher.crashed:
+                if not args.silent and not turbo_mode:
+                    pygame.time.wait(500)
+                watcher.restart_game()
+
+            # Logging for Turbo/Silent/Headless Modes
+            if args.silent or turbo_mode:
+                current_time = pygame.time.get_ticks()
+                if current_time - last_log_time > 1000: # 10 seconds
+                    elapsed_seconds = (current_time - last_log_time) / 1000.0
+                    real_sps = int(frame_count / elapsed_seconds)
+                    print(f"  [Watch] Score: {watcher.score:,} | High: {watcher.high_score:,} | SPS: {real_sps} (Sim/Sec)")
+                    
+                    last_log_time = current_time
+                    frame_count = 0
+            
+            # Update title (only in display mode)
+            if not args.silent and not turbo_mode:
+                mode_names = ["60", "MAX", "TURBO"]
+                fps_val = clock.get_fps()
+                if fps_val == float('inf') or fps_val > 99999:
+                    fps_text = f"MAX ({mode_names[speed_mode]})"
+                else:
+                    fps_text = f"{int(fps_val)} ({mode_names[speed_mode]})"
+                pygame.display.set_caption(
+                    f"NeuroDino | Score: {watcher.score:,} | High: {watcher.high_score:,} | FPS: {fps_text}"
+                )
+    except KeyboardInterrupt:
+        print("\n\n⏹️  Stopped by user")
+    
+    pygame.quit()
+    print(f"\n📊 Session Stats:")
+    print(f"   Games Played: {watcher.games_played}")
+    print(f"   High Score: {watcher.high_score}")
+
+
+if __name__ == "__main__":
+    main()