Update app.py

app.py

@@ -3,273 +3,266 @@ import streamlit as st
 import streamlit.components.v1 as components
 import os
 import json
-import sqlite3 # Use SQLite for robust state management
+import pandas as pd
 import uuid
-import math
-import time # For potential delays if needed
+import math # For floor function
+# from PIL import Image, ImageDraw # No longer needed for minimap
 from streamlit_js_eval import streamlit_js_eval # For JS communication
 
 # --- Constants ---
-DB_FILE = "world_state_v3.db" # Use a new DB file name to ensure fresh start
-PLOT_WIDTH = 50.0
-PLOT_DEPTH = 50.0
-
-# --- Database Setup ---
-def init_db():
-    """Initializes the SQLite database and tables."""
-    st.write(f"DEBUG: Initializing Database '{os.path.abspath(DB_FILE)}'...")
-    try:
-        # Ensure connection closes even if errors occur during table creation
-        with sqlite3.connect(DB_FILE, timeout=10) as conn: # Added timeout
-            cursor = conn.cursor()
-            # Enable WAL mode for potentially better concurrency - might help?
-            # cursor.execute('PRAGMA journal_mode=WAL;')
-            # Plots table
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS plots (
-                    grid_x INTEGER NOT NULL, grid_z INTEGER NOT NULL, name TEXT,
-                    last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                    PRIMARY KEY (grid_x, grid_z)
-                )
-            ''')
-            # Objects table
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS objects (
-                    obj_id TEXT PRIMARY KEY, plot_grid_x INTEGER NOT NULL, plot_grid_z INTEGER NOT NULL,
-                    type TEXT NOT NULL, pos_x REAL NOT NULL, pos_y REAL NOT NULL, pos_z REAL NOT NULL,
-                    rot_x REAL DEFAULT 0.0, rot_y REAL DEFAULT 0.0, rot_z REAL DEFAULT 0.0, rot_order TEXT DEFAULT 'XYZ',
-                    FOREIGN KEY (plot_grid_x, plot_grid_z) REFERENCES plots(grid_x, grid_z) ON DELETE CASCADE
-                )
-            ''')
-            cursor.execute('CREATE INDEX IF NOT EXISTS idx_objects_plot ON objects (plot_grid_x, plot_grid_z)')
-        print(f"DEBUG: Database {DB_FILE} initialized/checked.") # To console
-    except sqlite3.Error as e:
-        st.exception(f"CRITICAL DATABASE INIT ERROR: {e}")
-        st.stop()
-
-init_db() # Run initialization at the start
-
-# --- Helper Functions (Database Operations - Robust Connections) ---
-
-# *** REMOVED @st.cache_data - Load fresh every time ***
-def load_world_state_from_db():
-    """Loads all plot metadata and object data fresh from the SQLite DB."""
-    session_id = st.runtime.scriptrunner.get_script_run_ctx().session_id[:5] # Short ID for logging
-    st.write(f"DEBUG [{session_id}]: Executing load_world_state_from_db...")
-    plots_metadata = []
-    all_initial_objects_world = []
-
-    try:
-        # Ensure connection is opened and closed for each load operation
-        with sqlite3.connect(DB_FILE, timeout=10) as conn:
-            conn.row_factory = sqlite3.Row
-            cursor = conn.cursor()
-
-            # 1. Load Plot Metadata
-            cursor.execute("SELECT grid_x, grid_z, name FROM plots ORDER BY grid_x, grid_z")
-            plot_rows = cursor.fetchall()
-            st.write(f"DEBUG [{session_id}]: DB Read Found {len(plot_rows)} plot rows.")
-            if not plot_rows:
-                 st.write(f"DEBUG [{session_id}]: No plots found in DB.")
-
-            plot_keys = set() # To efficiently map objects later
-            for row in plot_rows:
-                gx, gz = row['grid_x'], row['grid_z']
-                plots_metadata.append({
-                    'id': f"plot_X{gx}_Z{gz}", 'grid_x': gx, 'grid_z': gz,
-                    'name': row['name'] or f"Plot ({gx},{gz})",
-                    'x_offset': gx * PLOT_WIDTH, 'z_offset': gz * PLOT_DEPTH
-                })
-                plot_keys.add((gx, gz))
-
-            # 2. Load All Objects
-            cursor.execute("SELECT obj_id, plot_grid_x, plot_grid_z, type, pos_x, pos_y, pos_z, rot_x, rot_y, rot_z, rot_order FROM objects")
-            object_rows = cursor.fetchall()
-            st.write(f"DEBUG [{session_id}]: DB Read Found {len(object_rows)} object rows.")
-
-            # 3. Combine and Calculate World Coordinates
-            objects_loaded_count = 0
-            for row in object_rows:
-                plot_key = (row['plot_grid_x'], row['plot_grid_z'])
-                # Ensure the object belongs to a known plot (data integrity check)
-                if plot_key in plot_keys:
-                    obj_data = dict(row) # Convert row object to dict
-                    # Find corresponding plot metadata for offset calculation
-                    plot_meta = next((p for p in plots_metadata if p['grid_x'] == row['plot_grid_x'] and p['grid_z'] == row['plot_grid_z']), None)
-                    if plot_meta:
-                        world_obj_data = obj_data.copy()
-                        world_obj_data['pos_x'] = obj_data['pos_x'] + plot_meta['x_offset']
-                        world_obj_data['pos_z'] = obj_data['pos_z'] + plot_meta['z_offset']
-                        world_obj_data['pos_y'] = obj_data['pos_y'] # Y is already world Y
-                        all_initial_objects_world.append(world_obj_data)
-                        objects_loaded_count += 1
-                    else:
-                         print(f"WARN: Object {obj_data['obj_id']} references non-existent plot {plot_key}") # To console
-                else:
-                     print(f"WARN: Object {obj_data['obj_id']} references unknown plot {plot_key}") # To console
-
-
-        st.write(f"DEBUG [{session_id}]: DB Load Complete. Processed {len(plots_metadata)} plots, {objects_loaded_count} objects.")
-
-    except sqlite3.Error as e:
-        st.exception(f"Database load error for session {session_id}: {e}")
-        return [], [] # Return empty on error
-
-    return plots_metadata, all_initial_objects_world
+SAVE_DIR = "saved_worlds"
+PLOT_WIDTH = 50.0 # Width of each plot in 3D space
+PLOT_DEPTH = 50.0 # Depth of each plot (can be same as width)
+CSV_COLUMNS = ['obj_id', 'type', 'pos_x', 'pos_y', 'pos_z', 'rot_x', 'rot_y', 'rot_z', 'rot_order']
 
+# --- Ensure Save Directory Exists ---
+os.makedirs(SAVE_DIR, exist_ok=True)
 
-def save_plot_data_to_db(target_grid_x, target_grid_z, objects_data_list):
-    """Saves object data list to DB for a specific plot. Overwrites existing objects."""
-    st.write(f"DEBUG: Executing save_plot_data_to_db for plot ({target_grid_x},{target_grid_z})...")
-    plot_x_offset = target_grid_x * PLOT_WIDTH
-    plot_z_offset = target_grid_z * PLOT_DEPTH
-    # Use a generic name or allow passing one if needed later
-    plot_name = f"Plot ({target_grid_x},{target_grid_z})"
+# --- Helper Functions ---
 
+@st.cache_data(ttl=3600) # Cache plot list
+def load_plot_metadata():
+    """Scans save dir for plot_X*_Z*.csv, sorts, calculates metadata."""
+    plots = []
+    plot_files = []
+    try:
+        plot_files = [f for f in os.listdir(SAVE_DIR) if f.endswith(".csv") and f.startswith("plot_X")]
+    except FileNotFoundError:
+        st.error(f"Save directory '{SAVE_DIR}' not found.")
+        return []
+    except Exception as e:
+        st.error(f"Error listing save directory '{SAVE_DIR}': {e}")
+        return []
+
+    # Parse filenames to get grid coordinates
+    parsed_plots = []
+    for filename in plot_files:
+        try:
+            parts = filename[:-4].split('_') # Remove .csv
+            grid_x = int(parts[1][1:]) # Extract number after X
+            grid_z = int(parts[2][1:]) # Extract number after Z
+            # Extract name if present (parts after Z coordinate)
+            plot_name = " ".join(parts[3:]) if len(parts) > 3 else f"Plot ({grid_x},{grid_z})"
+
+            parsed_plots.append({
+                'id': filename[:-4], # Use filename base as unique ID
+                'filename': filename,
+                'grid_x': grid_x,
+                'grid_z': grid_z,
+                'name': plot_name,
+                'x_offset': grid_x * PLOT_WIDTH,
+                'z_offset': grid_z * PLOT_DEPTH # Use PLOT_DEPTH for Z offset
+            })
+        except (IndexError, ValueError):
+            st.warning(f"Could not parse grid coordinates from filename: {filename}. Skipping.")
+            continue
+
+    # Sort primarily by X, then by Z
+    parsed_plots.sort(key=lambda p: (p['grid_x'], p['grid_z']))
+
+    return parsed_plots
+
+def load_plot_objects(filename, x_offset, z_offset):
+    """Loads objects from a CSV, applying the plot's world offsets."""
+    file_path = os.path.join(SAVE_DIR, filename)
+    objects = []
+    try:
+        df = pd.read_csv(file_path)
+        # Check required columns
+        if not all(col in df.columns for col in ['type', 'pos_x', 'pos_y', 'pos_z']):
+             st.warning(f"CSV '{filename}' missing essential columns. Skipping.")
+             return []
+        # Add defaults for optional columns
+        df['obj_id'] = df.get('obj_id', pd.Series([str(uuid.uuid4()) for _ in range(len(df))]))
+        for col, default in [('rot_x', 0.0), ('rot_y', 0.0), ('rot_z', 0.0), ('rot_order', 'XYZ')]:
+             if col not in df.columns: df[col] = default
+
+        for _, row in df.iterrows():
+            obj_data = row.to_dict()
+            # Apply world offset
+            obj_data['pos_x'] += x_offset
+            obj_data['pos_z'] += z_offset # Apply Z offset too
+            objects.append(obj_data)
+        return objects
+    except FileNotFoundError:
+        st.error(f"File not found during object load: {filename}")
+        return []
+    except pd.errors.EmptyDataError:
+         return [] # Empty file is valid
+    except Exception as e:
+        st.error(f"Error loading objects from {filename}: {e}")
+        return []
+
+def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
+    """Saves object data list to a CSV, making positions relative to plot origin."""
+    file_path = os.path.join(SAVE_DIR, filename)
+    relative_objects = []
     if not isinstance(objects_data_list, list):
-        st.error("Save Error: Invalid object data format (expected list).")
+        st.error("Invalid data format received for saving (expected a list).")
         return False
 
-    try:
-        # Use 'with' for automatic transaction handling and closing
-        with sqlite3.connect(DB_FILE, timeout=10) as conn:
-            cursor = conn.cursor()
-
-            # 1. Upsert Plot (ensures plot exists, updates timestamp)
-            cursor.execute('''
-                INSERT INTO plots (grid_x, grid_z, name) VALUES (?, ?, ?)
-                ON CONFLICT(grid_x, grid_z) DO UPDATE SET last_updated = CURRENT_TIMESTAMP
-            ''', (target_grid_x, target_grid_z, plot_name))
-            # st.write(f"DEBUG: Upserted plot metadata for ({target_grid_x},{target_grid_z})")
-
-            # 2. Delete ALL existing objects for this specific plot
-            cursor.execute("DELETE FROM objects WHERE plot_grid_x = ? AND plot_grid_z = ?", (target_grid_x, target_grid_z))
-            # st.write(f"DEBUG: Deleted {cursor.rowcount} old objects for plot.")
-
-            # 3. Insert the new objects
-            objects_to_insert = []
-            for obj in objects_data_list:
-                pos = obj.get('position', {})
-                rot = obj.get('rotation', {})
-                obj_type = obj.get('type', 'Unknown')
-                obj_id = obj.get('obj_id', str(uuid.uuid4()))
-
-                if not all(k in pos for k in ['x', 'y', 'z']) or obj_type == 'Unknown': continue
-
-                rel_x = pos.get('x', 0.0) - plot_x_offset
-                rel_z = pos.get('z', 0.0) - plot_z_offset
-                rel_y = pos.get('y', 0.0)
-
-                objects_to_insert.append((
-                    obj_id, target_grid_x, target_grid_z, obj_type,
-                    rel_x, rel_y, rel_z,
-                    rot.get('_x', 0.0), rot.get('_y', 0.0), rot.get('_z', 0.0), rot.get('_order', 'XYZ')
-                ))
-
-            if objects_to_insert:
-                cursor.executemany('''
-                    INSERT OR REPLACE INTO objects
-                    (obj_id, plot_grid_x, plot_grid_z, type, pos_x, pos_y, pos_z, rot_x, rot_y, rot_z, rot_order)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                ''', objects_to_insert) # Use INSERT OR REPLACE based on obj_id primary key
-                st.write(f"DEBUG: Inserted/Replaced {len(objects_to_insert)} objects.")
-            else:
-                 st.write(f"DEBUG: No objects provided to insert for plot ({target_grid_x},{target_grid_z}). Plot cleared.")
-
-            # Commit happens automatically when 'with' block exits without error
+    for obj in objects_data_list:
+        pos = obj.get('position', {})
+        rot = obj.get('rotation', {})
+        obj_type = obj.get('type', 'Unknown')
+        obj_id = obj.get('obj_id', str(uuid.uuid4()))
+
+        if not all(k in pos for k in ['x', 'y', 'z']) or obj_type == 'Unknown':
+            print(f"Skipping malformed object during save prep: {obj}")
+            continue
+
+        relative_obj = {
+            'obj_id': obj_id, 'type': obj_type,
+            'pos_x': pos.get('x', 0.0) - plot_x_offset, # Make relative X
+            'pos_y': pos.get('y', 0.0),
+            'pos_z': pos.get('z', 0.0) - plot_z_offset, # Make relative Z
+            'rot_x': rot.get('_x', 0.0), 'rot_y': rot.get('_y', 0.0), 'rot_z': rot.get('_z', 0.0),
+            'rot_order': rot.get('_order', 'XYZ')
+        }
+        relative_objects.append(relative_obj)
 
-        st.success(f"Plot ({target_grid_x},{target_grid_z}) saved successfully to DB.")
+    try:
+        df = pd.DataFrame(relative_objects, columns=CSV_COLUMNS)
+        df.to_csv(file_path, index=False)
+        st.success(f"Saved {len(relative_objects)} objects to {filename}")
         return True
-
-    except sqlite3.Error as e:
-        st.exception(f"DATABASE SAVE ERROR for plot ({target_grid_x},{target_grid_z}): {e}")
+    except Exception as e:
+        st.error(f"Failed to save plot data to {filename}: {e}")
         return False
 
 # --- Page Config ---
-st.set_page_config( page_title="DB Synced World Builder v3", layout="wide")
+st.set_page_config( page_title="Infinite World Builder", layout="wide")
 
 # --- Initialize Session State ---
 if 'selected_object' not in st.session_state: st.session_state.selected_object = 'None'
+if 'new_plot_name' not in st.session_state: st.session_state.new_plot_name = "" # No longer used for filename
 if 'js_save_data_result' not in st.session_state: st.session_state.js_save_data_result = None
-# No refresh counter needed
 
-# --- Load World State From DB (Fresh on each run/rerun) ---
-plots_metadata, all_initial_objects = load_world_state_from_db()
+# --- Load Plot Metadata ---
+# This is now the source of truth for saved plots
+plots_metadata = load_plot_metadata()
+
+# --- Load ALL Objects for Rendering ---
+all_initial_objects = []
+for plot in plots_metadata:
+    all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
 
 # --- Sidebar ---
 with st.sidebar:
     st.title("🏗️ World Controls")
 
-    # Refresh Button (Just reruns the script)
-    if st.button("🔄 Refresh World View", key="refresh_button"):
-        st.info("Reloading world state from database...")
-        st.rerun() # Rerun forces call to load_world_state_from_db
-
     st.header("Navigation (Plots)")
-    # ... (Navigation button code unchanged - uses latest plots_metadata) ...
     st.caption("Click to teleport player to a plot.")
-    max_cols = 2; cols = st.columns(max_cols); col_idx = 0
+    max_cols = 2 # Adjust columns for potentially more buttons
+    cols = st.columns(max_cols)
+    col_idx = 0
+    # Sort buttons by grid coords for logical layout
     sorted_plots_for_nav = sorted(plots_metadata, key=lambda p: (p['grid_x'], p['grid_z']))
     for plot in sorted_plots_for_nav:
         button_label = f"➡️ {plot.get('name', plot['id'])} ({plot['grid_x']},{plot['grid_z']})"
         if cols[col_idx].button(button_label, key=f"nav_{plot['id']}"):
-            target_x = plot['x_offset'] + PLOT_WIDTH/2; target_z = plot['z_offset'] + PLOT_DEPTH/2
-            try: streamlit_js_eval(js_code=f"teleportPlayer({target_x}, {target_z});", key=f"teleport_{plot['id']}")
-            except Exception as e: st.error(f"Teleport command failed: {e}")
+            target_x = plot['x_offset']
+            target_z = plot['z_offset'] # Use Z offset too
+            try:
+                # Tell JS where to teleport (center of plot approx)
+                js_code = f"teleportPlayer({target_x + PLOT_WIDTH/2}, {target_z + PLOT_DEPTH/2});"
+                streamlit_js_eval(js_code=js_code, key=f"teleport_{plot['id']}")
+            except Exception as e:
+                 st.error(f"Failed to send teleport command: {e}")
         col_idx = (col_idx + 1) % max_cols
+
     st.markdown("---")
 
     # --- Object Placement ---
     st.header("Place Objects")
-    # ... (Object selection unchanged) ...
     object_types = ["None", "Simple House", "Tree", "Rock", "Fence Post"]
     current_object_index = object_types.index(st.session_state.selected_object) if st.session_state.selected_object in object_types else 0
-    selected_object_type_widget = st.selectbox( "Select Object:", options=object_types, index=current_object_index, key="selected_object_widget")
-    if selected_object_type_widget != st.session_state.selected_object: st.session_state.selected_object = selected_object_type_widget
+    selected_object_type_widget = st.selectbox(
+        "Select Object:", options=object_types, index=current_object_index, key="selected_object_widget"
+    )
+    if selected_object_type_widget != st.session_state.selected_object:
+         st.session_state.selected_object = selected_object_type_widget
+         # Rerun will happen, JS reloads state via sessionStorage, Python injects new selection
+
     st.markdown("---")
 
     # --- Saving ---
     st.header("Save Work")
-    st.caption("Saves ALL objects in the player's current plot to the central database.")
-    if st.button("💾 Save Current Plot", key="save_button"):
-        js_get_data_code = "getSaveDataAndPosition();"
+    st.caption("Saves newly placed objects to the plot the player is currently in. If it's a new area, a new plot file is created.")
+    if st.button("💾 Save Current Work", key="save_button"):
+        # Trigger JS to get data AND player position
+        js_get_data_code = "getSaveDataAndPosition();" # JS function needs update
         streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
-        st.rerun()
+        st.rerun() # Rerun to process result
 
 
 # --- Process Save Data ---
 save_data_from_js = st.session_state.get("js_save_processor", None)
 
 if save_data_from_js is not None:
-    st.write("DEBUG: Processing save request from JS...") # Debug
+    st.info("Received save data from client...")
     save_processed_successfully = False
     try:
+        # Expecting { playerPosition: {x,y,z}, objectsToSave: [...] }
         payload = json.loads(save_data_from_js) if isinstance(save_data_from_js, str) else save_data_from_js
+
         if isinstance(payload, dict) and 'playerPosition' in payload and 'objectsToSave' in payload:
             player_pos = payload['playerPosition']
-            objects_to_save = payload['objectsToSave'] # World coords from JS
-            if isinstance(objects_to_save, list):
+            objects_to_save = payload['objectsToSave']
+
+            if isinstance(objects_to_save, list): # Allow saving empty list (clears new objects)
+                # Determine target plot based on player position
                 target_grid_x = math.floor(player_pos.get('x', 0.0) / PLOT_WIDTH)
-                target_grid_z = math.floor(player_pos.get('z', 0.0) / PLOT_DEPTH)
-                # --- Save the data to SQLite DB ---
-                save_ok = save_plot_data_to_db(target_grid_x, target_grid_z, objects_to_save)
-                if save_ok: save_processed_successfully = True # Flag success
-                else: st.error(f"Failed DB save for plot ({target_grid_x},{target_grid_z}).")
-            else: st.error("Save Error: 'objectsToSave' format invalid (expected list).")
-        else: st.error("Save Error: Invalid payload structure received.")
-    except json.JSONDecodeError: st.error("Save Error: Failed to decode JSON data from client.")
-    except Exception as e: st.exception(f"Save Error: An unexpected error occurred: {e}")
-
-    # Clear the trigger data from session state ALWAYS after processing attempt
+                target_grid_z = math.floor(player_pos.get('z', 0.0) / PLOT_DEPTH) # Use Z pos too
+
+                target_filename = f"plot_X{target_grid_x}_Z{target_grid_z}.csv"
+                target_plot_x_offset = target_grid_x * PLOT_WIDTH
+                target_plot_z_offset = target_grid_z * PLOT_DEPTH
+
+                st.write(f"Attempting to save plot: {target_filename} (Player at: x={player_pos.get('x', 0):.1f}, z={player_pos.get('z', 0):.1f})")
+
+                # Check if this plot already exists in metadata (for logging/future logic)
+                is_new_plot_file = not os.path.exists(os.path.join(SAVE_DIR, target_filename))
+
+                save_ok = save_plot_data(target_filename, objects_to_save, target_plot_x_offset, target_plot_z_offset)
+
+                if save_ok:
+                    load_plot_metadata.clear() # Clear cache to force reload metadata
+                    try: # Tell JS to clear its unsaved state
+                         streamlit_js_eval(js_code="resetNewlyPlacedObjects();", key="reset_js_state")
+                    except Exception as js_e:
+                         st.warning(f"Could not reset JS state after save: {js_e}")
+
+                    if is_new_plot_file:
+                        st.success(f"New plot created and saved: {target_filename}")
+                    else:
+                        st.success(f"Updated existing plot: {target_filename}")
+                    save_processed_successfully = True
+                else:
+                    st.error(f"Failed to save plot data to file: {target_filename}")
+            else:
+                st.error("Invalid 'objectsToSave' format received (expected list).")
+        else:
+            st.error("Invalid save payload structure received from client.")
+            print("Received payload:", payload) # Log for debugging
+
+    except json.JSONDecodeError:
+        st.error("Failed to decode save data from client.")
+        print("Received raw data:", save_data_from_js)
+    except Exception as e:
+        st.error(f"Error processing save: {e}")
+        st.exception(e)
+
+    # Clear the trigger data from session state
     st.session_state.js_save_processor = None
-    # Rerun ONLY if save was flagged successful to reload the state
+    # Rerun after processing to reflect changes
     if save_processed_successfully:
         st.rerun()
 
 
 # --- Main Area ---
-st.header("Database Synced 3D World")
-st.caption(f"DB: '{os.path.abspath(DB_FILE)}'. Plots loaded: {len(plots_metadata)}. Use 'Refresh' button to sync.")
+st.header("Infinite Shared 3D World")
+st.caption("Move to empty areas to expand the world. Use sidebar 'Save' to save work to current plot.")
 
 # --- Load and Prepare HTML ---
 html_file_path = 'index.html'
@@ -279,21 +272,35 @@ try:
     with open(html_file_path, 'r', encoding='utf-8') as f:
         html_template = f.read()
 
-    # Inject data loaded fresh from DB
+    # --- Inject Python state into JavaScript ---
     js_injection_script = f"""
 <script>
     window.ALL_INITIAL_OBJECTS = {json.dumps(all_initial_objects)};
-    window.PLOTS_METADATA = {json.dumps(plots_metadata)};
+    window.PLOTS_METADATA = {json.dumps(plots_metadata)}; // Send plot info to JS
     window.SELECTED_OBJECT_TYPE = {json.dumps(st.session_state.selected_object)};
     window.PLOT_WIDTH = {json.dumps(PLOT_WIDTH)};
     window.PLOT_DEPTH = {json.dumps(PLOT_DEPTH)};
-    console.log("Streamlit State Injected:", {{ /* Basic logging */ }});
+    console.log("Streamlit State Injected:", {{
+        selectedObject: window.SELECTED_OBJECT_TYPE,
+        initialObjectsCount: window.ALL_INITIAL_OBJECTS ? window.ALL_INITIAL_OBJECTS.length : 0,
+        plotCount: window.PLOTS_METADATA ? window.PLOTS_METADATA.length : 0,
+        plotWidth: window.PLOT_WIDTH,
+        plotDepth: window.PLOT_DEPTH
+    }});
 </script>
 """
     html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
 
-    # Embed HTML Component
-    components.html( html_content_with_state, height=750, scrolling=False )
-
-except FileNotFoundError: st.error(f"CRITICAL ERROR: Could not find file '{html_file_path}'.")
-except Exception as e: st.exception(f"HTML prep/render error: {e}")
+    # --- Embed HTML Component ---
+    components.html(
+        html_content_with_state,
+        height=750,
+        scrolling=False
+    )
+
+except FileNotFoundError:
+    st.error(f"CRITICAL ERROR: Could not find the file '{html_file_path}'.")
+    st.warning(f"Make sure `{html_file_path}` is in the same directory as `app.py` and `{SAVE_DIR}` exists.")
+except Exception as e:
+    st.error(f"An critical error occurred during HTML preparation or component rendering: {e}")
+    st.exception(e)