Update app.py

app.py

@@ -6,13 +6,12 @@ import json
 import pandas as pd
 import uuid
 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 ---
 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)
+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 ---
@@ -20,83 +19,77 @@ os.makedirs(SAVE_DIR, exist_ok=True)
 
 # --- Helper Functions ---
 
-@st.cache_data(ttl=3600) # Cache plot list
-def load_plot_metadata():
+# 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 = []
-    st.write(f"Scanning directory: {os.path.abspath(SAVE_DIR)}") # Debug print
     try:
         plot_files = sorted([f for f in os.listdir(SAVE_DIR) if f.endswith(".csv") and f.startswith("plot_X")])
-        st.write(f"Found files: {plot_files}") # Debug print
     except FileNotFoundError:
         st.error(f"Save directory '{SAVE_DIR}' not found.")
-        return []
+        return [] # Return empty list on error
     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)
+            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], # Use filename base as unique ID
+                'id': filename[:-4],
                 'filename': filename,
-                'grid_x': grid_x,
-                'grid_z': grid_z,
-                'name': plot_name,
+                '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
+                'z_offset': grid_z * PLOT_DEPTH
             })
         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']))
-    st.write(f"Loaded metadata for {len(parsed_plots)} plots.") # Debug print
+    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)
-        # 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.") # Can be noisy
-             return []
-        # Add defaults for optional columns
+             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()
-            # Apply world offset
             obj_data['pos_x'] += x_offset
-            obj_data['pos_z'] += z_offset # Apply Z offset too
+            obj_data['pos_z'] += z_offset
             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 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 to plot origin."""
+    """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):
@@ -107,6 +100,7 @@ def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
         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':
@@ -124,66 +118,60 @@ def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
         relative_objects.append(relative_obj)
 
     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)
-        # Success message handled in the calling block
-        # st.success(f"Saved {len(relative_objects)} objects to {filename}")
+        # st.success(f"Saved/Updated {len(relative_objects)} objects to {filename}") # Success message in calling block
         return True
     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="Infinite World Builder", layout="wide")
+st.set_page_config( page_title="Synced World Builder", layout="wide")
 
 # --- Initialize Session State ---
 if 'selected_object' not in st.session_state: st.session_state.selected_object = 'None'
-# Removed 'new_plot_name' state as it wasn't used for saving anymore
 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
 
-# --- Load Plot Metadata ---
-# Cached function returns list of plots
-# Note: next_plot_x_offset isn't returned/needed anymore
-plots_metadata = load_plot_metadata()
+# --- 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...") # Debug
+# st.write(f"Loading objects for {len(plots_metadata)} plots...") # Less verbose now
 for plot in plots_metadata:
-    loaded_count = len(all_initial_objects)
     all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
-    # st.write(f"  Loaded {len(all_initial_objects) - loaded_count} objects from {plot['filename']}") # Verbose Debug
-st.write(f"Total objects loaded: {len(all_initial_objects)}") # Debug
+# st.write(f"Total objects loaded: {len(all_initial_objects)}")
 
 # --- Sidebar ---
 with st.sidebar:
     st.title("🏗️ World Controls")
 
-    # *** NEW: Refresh Button ***
+    # *** Refresh Button Logic ***
     if st.button("🔄 Refresh World View", key="refresh_button"):
-        st.info("Clearing cache and reloading world data...")
-        load_plot_metadata.clear() # Clear the cache for plot metadata
-        # No need to clear all_initial_objects, it's rebuilt after rerun
-        st.rerun() # Force the script to rerun from the top
+        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
 
     st.header("Navigation (Plots)")
     st.caption("Click to teleport player to a plot.")
-    max_cols = 2 # Adjust columns for potentially more buttons
+    max_cols = 2
     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']}"):
-            # Teleport near center of plot
-            target_x = plot['x_offset'] + PLOT_WIDTH / 2
-            target_z = plot['z_offset'] + PLOT_DEPTH / 2
+            target_x = plot['x_offset'] + PLOT_WIDTH / 2 # Center X
+            target_z = plot['z_offset'] + PLOT_DEPTH / 2 # Center Z
             try:
                 js_code = f"teleportPlayer({target_x}, {target_z});"
                 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}")
+            except Exception as e: st.error(f"Teleport command failed: {e}")
         col_idx = (col_idx + 1) % max_cols
 
     st.markdown("---")
@@ -197,34 +185,35 @@ with st.sidebar:
     )
     if selected_object_type_widget != st.session_state.selected_object:
          st.session_state.selected_object = selected_object_type_widget
-         # Selecting causes rerun, state injection handles update in JS, sessionStorage preserves placed objects
+         # Rerun will update JS via injection, sessionStorage handles unsaved items
 
     st.markdown("---")
 
     # --- Saving ---
     st.header("Save Work")
-    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 name
-        streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor") # Store result
-        st.rerun() # Rerun to process result
+    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
+        js_get_data_code = "getSaveDataAndPosition();"
+        streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
+        st.rerun()
 
 
 # --- Process Save Data ---
 save_data_from_js = st.session_state.get("js_save_processor", None)
 
-if save_data_from_js is not None: # Process only if data is present
-    st.info("Received save data from client...")
+if save_data_from_js is not None:
+    st.info("Processing save request...")
     save_processed_successfully = False
     try:
         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']
+            # These are ALL objects JS found within the target plot boundaries
             objects_to_save = payload['objectsToSave']
 
-            if isinstance(objects_to_save, list): # Allow saving empty list
+            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)
@@ -233,26 +222,23 @@ if save_data_from_js is not None: # Process only if data is present
                 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})")
+                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))
 
-                # --- Save the data ---
+                # --- Save/Overwrite the data ---
                 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 crucial for others/refresh
-                    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}")
+                    # 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}")
                     save_processed_successfully = True
                 else:
                     st.error(f"Failed to save plot data to file: {target_filename}")
             else: st.error("Invalid 'objectsToSave' format (expected list).")
-        else: st.error("Invalid save payload structure received.")
+        else: st.error("Invalid save payload structure received (missing keys).")
 
     except json.JSONDecodeError:
         st.error("Failed to decode save data from client.")
@@ -261,55 +247,49 @@ if save_data_from_js is not None: # Process only if data is present
         st.error(f"Error processing save: {e}")
         st.exception(e)
 
-    # Clear the trigger data from session state IMPORTANT!
+    # Clear the trigger data from session state
     st.session_state.js_save_processor = None
-    # Rerun after processing save to reflect changes
+    # Rerun after processing save to reload the world state
     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("Infinite Shared 3D World")
-st.caption(f"Location: {os.getcwd()}. Saving to sub-directory: '{SAVE_DIR}'. Plots loaded: {len(plots_metadata)}")
+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.")
 
 # --- Load and Prepare HTML ---
 html_file_path = 'index.html'
-html_content_with_state = None # Initialize
+html_content_with_state = None
 
 try:
     with open(html_file_path, 'r', encoding='utf-8') as f:
         html_template = f.read()
 
-    # --- Inject Python state into JavaScript ---
-    # Send plot metadata so JS knows where existing ground is
     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)};
+    window.PLOTS_METADATA = {json.dumps(plots_metadata)}; // Needed for ground generation logic
     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:", {{
         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
+        plotCount: window.PLOTS_METADATA ? window.PLOTS_METADATA.length : 0
     }});
 </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
-    )
+    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.")
+    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 preparation or component rendering: {e}")
+    st.error(f"An critical error occurred during HTML prep/render: {e}")
     st.exception(e)