Update app.py

app.py

@@ -3,159 +3,208 @@ import streamlit as st
 import streamlit.components.v1 as components
 import os
 import json
-import pandas as pd
+import sqlite3 # Use SQLite for robust state management
 import uuid
-import math # For floor function
+import math
 from streamlit_js_eval import streamlit_js_eval # For JS communication
 
 # --- Constants ---
-SAVE_DIR = "saved_worlds"
-PLOT_WIDTH = 50.0 # Width of each plot in 3D space
-PLOT_DEPTH = 50.0 # Depth of each plot
-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)
-
-# --- Helper Functions ---
-
-# Cache key now depends on refresh_trigger to force reload when counter changes
-@st.cache_data(ttl=3600)
-def load_plot_metadata(refresh_trigger):
-    """Scans save dir for plot_X*_Z*.csv, sorts, calculates metadata."""
-    # This function depends on refresh_trigger only to invalidate cache.
-    # The value of refresh_trigger itself isn't used inside.
-    st.write(f"Cache Trigger: {refresh_trigger}. Reloading plot metadata...") # Debug log
-
-    plots = []
-    plot_files = []
-    try:
-        plot_files = sorted([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 [] # Return empty list on error
-    except Exception as e:
-        st.error(f"Error listing save directory '{SAVE_DIR}': {e}")
-        return []
-
-    parsed_plots = []
-    for filename in plot_files:
-        try:
-            parts = filename[:-4].split('_')
-            grid_x = int(parts[1][1:])
-            grid_z = int(parts[2][1:])
-            # Default name is coordinates, override if name parts exist
-            plot_name = " ".join(parts[3:]) if len(parts) > 3 else f"Plot ({grid_x},{grid_z})"
-
-            parsed_plots.append({
-                'id': filename[:-4],
-                '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
-            })
-        except (IndexError, ValueError):
-            st.warning(f"Could not parse grid coordinates from filename: {filename}. Skipping.")
-            continue
-
-    parsed_plots.sort(key=lambda p: (p['grid_x'], p['grid_z']))
-    st.write(f"Metadata loaded for {len(parsed_plots)} plots.") # Debug log
-    return parsed_plots
-
-# No caching needed for loading objects, should always load fresh based on metadata
-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)
-        if not all(col in df.columns for col in ['type', 'pos_x', 'pos_y', 'pos_z']):
-             return [] # Skip files missing essential columns silently now
-        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()
-            obj_data['pos_x'] += x_offset
-            obj_data['pos_z'] += z_offset
-            objects.append(obj_data)
-        return objects
-    except FileNotFoundError: return [] # File might have been deleted between metadata load and object load
-    except pd.errors.EmptyDataError: return [] # Empty file is okay
-    except Exception as e:
-        st.error(f"Error loading objects from {filename}: {e}")
-        return []
-
-# Overwrites the target file with the provided objects
-def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
-    """Saves object data list to a CSV, making positions relative. Overwrites file."""
-    file_path = os.path.join(SAVE_DIR, filename)
-    relative_objects = []
-    if not isinstance(objects_data_list, list):
-        st.error("Invalid data format received for saving (expected a list).")
-        return False
+DB_FILE = "world_state.db" # SQLite database file
+PLOT_WIDTH = 50.0
+PLOT_DEPTH = 50.0
 
-    for obj in objects_data_list:
-        pos = obj.get('position', {})
-        rot = obj.get('rotation', {})
-        obj_type = obj.get('type', 'Unknown')
-        # Use ID provided by JS if available (important for consistency if JS tracks it)
-        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)
+# --- Database Setup ---
+def init_db():
+    """Initializes the SQLite database and creates tables if they don't exist."""
+    try:
+        conn = sqlite3.connect(DB_FILE)
+        cursor = conn.cursor()
+        # Plots table: grid coordinates are the primary key
+        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: references plots using grid coords
+        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
+            )
+        ''')
+        # Index for faster object lookups by plot
+        cursor.execute('''
+            CREATE INDEX IF NOT EXISTS idx_objects_plot ON objects (plot_grid_x, plot_grid_z)
+        ''')
+        conn.commit()
+        conn.close()
+        # st.success("Database initialized successfully.") # Optional success message
+    except sqlite3.Error as e:
+        st.error(f"Database initialization error: {e}")
+        st.stop() # Stop execution if DB can't be initialized
+
+# Call init function once at the start
+init_db()
+
+# --- Helper Functions (Database Operations) ---
+
+def load_world_state_from_db():
+    """Loads all plot metadata and object data fresh from the SQLite DB."""
+    plots_metadata = []
+    all_objects_by_plot = {} # Temp store: (gx, gz) -> [obj_dict, ...]
+    all_initial_objects_world = [] # Final list with world coords
 
     try:
-        # Overwrite the file with the new data (or empty if list is empty)
-        df = pd.DataFrame(relative_objects, columns=CSV_COLUMNS)
-        df.to_csv(file_path, index=False)
-        # st.success(f"Saved/Updated {len(relative_objects)} objects to {filename}") # Success message in calling block
+        conn = sqlite3.connect(DB_FILE)
+        conn.row_factory = sqlite3.Row # Return rows as dict-like objects
+        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()
+        for row in plot_rows:
+            gx, gz = row['grid_x'], row['grid_z']
+            plots_metadata.append({
+                'id': f"plot_X{gx}_Z{gz}", # Reconstruct ID for consistency if needed
+                'grid_x': gx, 'grid_z': gz, 'name': row['name'] or f"Plot ({gx},{gz})",
+                'x_offset': gx * PLOT_WIDTH,
+                'z_offset': gz * PLOT_DEPTH
+            })
+            all_objects_by_plot[(gx, gz)] = [] # Initialize empty list for objects
+
+        # 2. Load All Objects
+        cursor.execute("SELECT * FROM objects")
+        object_rows = cursor.fetchall()
+        for row in object_rows:
+            plot_key = (row['plot_grid_x'], row['plot_grid_z'])
+            if plot_key in all_objects_by_plot:
+                 # Store object data with RELATIVE coordinates from DB
+                 all_objects_by_plot[plot_key].append(dict(row))
+
+        conn.close()
+
+        # 3. Combine and Calculate World Coordinates
+        for plot_meta in plots_metadata:
+            plot_key = (plot_meta['grid_x'], plot_meta['grid_z'])
+            for obj_data in all_objects_by_plot[plot_key]:
+                 # Create a copy to modify coordinates for injection
+                 world_obj_data = obj_data.copy()
+                 # Apply offset to relative DB coords to get world coords for JS
+                 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']
+                 # Keep original relative pos_y as world pos_y
+                 world_obj_data['pos_y'] = obj_data['pos_y']
+                 all_initial_objects_world.append(world_obj_data)
+
+        st.write(f"DB Load: Found {len(plots_metadata)} plots and {len(all_initial_objects_world)} total objects.") # Debug
+
+    except sqlite3.Error as e:
+        st.error(f"Database load error: {e}")
+        # Return empty lists to prevent downstream errors
+        return [], []
+
+    return plots_metadata, all_initial_objects_world
+
+
+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 for that plot."""
+    plot_x_offset = target_grid_x * PLOT_WIDTH
+    plot_z_offset = target_grid_z * PLOT_DEPTH
+    plot_name = f"Plot ({target_grid_x},{target_grid_z})" # Simple default name
+
+    conn = None # Ensure conn is defined for finally block
+    try:
+        conn = sqlite3.connect(DB_FILE)
+        cursor = conn.cursor()
+        cursor.execute('BEGIN TRANSACTION') # Start transaction
+
+        # 1. Ensure plot exists in plots table (Upsert)
+        cursor.execute('''
+            INSERT INTO plots (grid_x, grid_z, name) VALUES (?, ?, ?)
+            ON CONFLICT(grid_x, grid_z) DO UPDATE SET name = excluded.name, last_updated = CURRENT_TIMESTAMP
+        ''', (target_grid_x, target_grid_z, plot_name))
+
+        # 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))
+        deleted_count = cursor.rowcount
+        # st.write(f"DB Save: Deleted {deleted_count} old objects for plot ({target_grid_x},{target_grid_z}).") # Debug
+
+        # 3. Insert the new objects
+        insert_count = 0
+        if isinstance(objects_data_list, list):
+            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())) # Use ID from JS
+
+                if not all(k in pos for k in ['x', 'y', 'z']) or obj_type == 'Unknown':
+                    print(f"Skipping malformed object during DB save prep: {obj}")
+                    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) # Y is absolute
+
+                cursor.execute('''
+                    INSERT 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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ''', (
+                    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')
+                ))
+                insert_count += 1
+
+        conn.commit() # Commit transaction
+        st.success(f"Plot ({target_grid_x},{target_grid_z}) saved with {insert_count} objects.")
         return True
-    except Exception as e:
-        st.error(f"Failed to save plot data to {filename}: {e}")
+
+    except sqlite3.Error as e:
+        st.error(f"Database save error for plot ({target_grid_x},{target_grid_z}): {e}")
+        if conn:
+            conn.rollback() # Rollback on error
         return False
+    finally:
+        if conn:
+            conn.close()
 
 # --- Page Config ---
-st.set_page_config( page_title="Synced World Builder", layout="wide")
+st.set_page_config( page_title="DB Synced World Builder", layout="wide")
 
-# --- Initialize Session State ---
+# --- Initialize Session State (Simpler Now) ---
 if 'selected_object' not in st.session_state: st.session_state.selected_object = 'None'
 if 'js_save_data_result' not in st.session_state: st.session_state.js_save_data_result = None
-# Counter for forcing cache refresh
-if 'refresh_counter' not in st.session_state: st.session_state.refresh_counter = 0
+# Remove refresh_counter - not needed as we load fresh every time
 
-# --- Load Plot Metadata (using refresh counter) ---
-plots_metadata = load_plot_metadata(st.session_state.refresh_counter)
-
-# --- Load ALL Objects for Rendering ---
-all_initial_objects = []
-# st.write(f"Loading objects for {len(plots_metadata)} plots...") # Less verbose now
-for plot in plots_metadata:
-    all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
-# st.write(f"Total objects loaded: {len(all_initial_objects)}")
+# --- Load World State From DB (Runs on every script execution/rerun) ---
+# No caching - always reads the current DB state
+plots_metadata, all_initial_objects = load_world_state_from_db()
 
 # --- Sidebar ---
 with st.sidebar:
     st.title("🏗️ World Controls")
 
-    # *** Refresh Button Logic ***
+    # *** Refresh Button - Simpler Logic ***
     if st.button("🔄 Refresh World View", key="refresh_button"):
-        st.session_state.refresh_counter += 1 # Increment counter
-        load_plot_metadata.clear() # Clear cache explicitly
-        st.info(f"Refresh triggered (Counter: {st.session_state.refresh_counter}). Reloading...")
-        st.rerun() # Force rerun with new counter value
+        # Simply rerun the script. The data loading above will fetch fresh data from DB.
+        st.info("Reloading world state from database...")
+        st.rerun()
 
     st.header("Navigation (Plots)")
     st.caption("Click to teleport player to a plot.")
@@ -166,8 +215,8 @@ with st.sidebar:
     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 # Center X
-            target_z = plot['z_offset'] + PLOT_DEPTH / 2 # Center Z
+            target_x = plot['x_offset'] + PLOT_WIDTH / 2
+            target_z = plot['z_offset'] + PLOT_DEPTH / 2
             try:
                 js_code = f"teleportPlayer({target_x}, {target_z});"
                 streamlit_js_eval(js_code=js_code, key=f"teleport_{plot['id']}")
@@ -185,16 +234,16 @@ with st.sidebar:
     )
     if selected_object_type_widget != st.session_state.selected_object:
          st.session_state.selected_object = selected_object_type_widget
-         # Rerun will update JS via injection, sessionStorage handles unsaved items
+         # Rerun will happen, JS state handled by sessionStorage
 
     st.markdown("---")
 
     # --- Saving ---
     st.header("Save Work")
-    st.caption("Saves ALL objects currently within the player's plot, overwriting previous save for that plot.")
-    if st.button("💾 Save Current Plot", key="save_button"): # Renamed button slightly
-        # JS func now sends ALL objects in current plot + player position
+    st.caption("Saves ALL objects in the player's current plot to the central database, overwriting previous data for that plot.")
+    if st.button("💾 Save Current Plot", key="save_button"):
         js_get_data_code = "getSaveDataAndPosition();"
+        # Use key to store result in session state
         streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
         st.rerun()
 
@@ -210,35 +259,30 @@ if save_data_from_js is not None:
 
         if isinstance(payload, dict) and 'playerPosition' in payload and 'objectsToSave' in payload:
             player_pos = payload['playerPosition']
-            # These are ALL objects JS found within the target plot boundaries
+            # These are ALL objects JS found within the target plot boundaries (world coords)
             objects_to_save = payload['objectsToSave']
 
             if isinstance(objects_to_save, list):
-                # 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)
 
-                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"Saving plot: {target_filename} (Player at: x={player_pos.get('x', 0):.1f}, z={player_pos.get('z', 0):.1f})")
-                is_new_plot_file = not os.path.exists(os.path.join(SAVE_DIR, target_filename))
+                st.write(f"Attempting DB save for plot ({target_grid_x},{target_grid_z})")
 
-                # --- Save/Overwrite the data ---
-                save_ok = save_plot_data(target_filename, objects_to_save, target_plot_x_offset, target_plot_z_offset)
+                # --- 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:
-                    # Clear cache so next reload/refresh sees the change
-                    load_plot_metadata.clear()
-                    # No need to call JS reset function anymore
-                    if is_new_plot_file: st.success(f"New plot created/saved: {target_filename}")
-                    else: st.success(f"Updated existing plot: {target_filename}")
+                    # No cache clear needed! DB is source of truth.
+                    # Optional: Could tell JS to clear sessionStorage here if desired, but maybe not necessary
+                    # try:
+                    #      streamlit_js_eval(js_code="clearUnsavedSessionState();", key="clear_session_js")
+                    # except Exception as js_e: st.warning(f"Could not clear JS session state: {js_e}")
+                    st.success(f"Plot ({target_grid_x},{target_grid_z}) state saved to database.")
                     save_processed_successfully = True
                 else:
-                    st.error(f"Failed to save plot data to file: {target_filename}")
+                    st.error(f"Failed to save plot ({target_grid_x},{target_grid_z}) data to database.")
             else: st.error("Invalid 'objectsToSave' format (expected list).")
-        else: st.error("Invalid save payload structure received (missing keys).")
+        else: st.error("Invalid save payload structure received.")
 
     except json.JSONDecodeError:
         st.error("Failed to decode save data from client.")
@@ -249,15 +293,14 @@ if save_data_from_js is not None:
 
     # Clear the trigger data from session state
     st.session_state.js_save_processor = None
-    # Rerun after processing save to reload the world state
+    # Rerun after processing save to reload world state from DB
     if save_processed_successfully:
-        st.session_state.refresh_counter += 1 # Increment counter to ensure cache miss on THIS rerun
         st.rerun()
 
 
 # --- Main Area ---
-st.header("Synced Infinite 3D World")
-st.caption(f"Saving to '{SAVE_DIR}'. Plots loaded: {len(plots_metadata)}. Use 'Refresh' button to see others' saves.")
+st.header("Database Synced 3D World")
+st.caption(f"World state loaded from '{DB_FILE}'. Plots loaded: {len(plots_metadata)}. Use 'Refresh' to reload.")
 
 # --- Load and Prepare HTML ---
 html_file_path = 'index.html'
@@ -267,11 +310,11 @@ try:
     with open(html_file_path, 'r', encoding='utf-8') as f:
         html_template = f.read()
 
+    # Inject data loaded fresh from DB
     js_injection_script = f"""
 <script>
-    // Inject necessary data for JS initialization
     window.ALL_INITIAL_OBJECTS = {json.dumps(all_initial_objects)};
-    window.PLOTS_METADATA = {json.dumps(plots_metadata)}; // Needed for ground generation logic
+    window.PLOTS_METADATA = {json.dumps(plots_metadata)};
     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)};
@@ -284,12 +327,11 @@ try:
 """
     html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
 
-    # --- Embed HTML Component ---
+    # 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 nearby and `{SAVE_DIR}` exists.")
 except Exception as e:
     st.error(f"An critical error occurred during HTML prep/render: {e}")
     st.exception(e)