Update app.py

app.py

@@ -5,12 +5,14 @@ import os
 import json
 import pandas as pd
 import uuid
-from PIL import Image, ImageDraw # Not used for minimap anymore, but kept just in case
+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 (adjust as needed)
+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 ---
@@ -18,340 +20,287 @@ os.makedirs(SAVE_DIR, exist_ok=True)
 
 # --- Helper Functions ---
 
-@st.cache_data(ttl=3600) # Cache plot list for an hour, or clear manually
+@st.cache_data(ttl=3600) # Cache plot list
 def load_plot_metadata():
-    """Scans save dir, sorts plots, calculates metadata."""
+    """Scans save dir for plot_X*_Z*.csv, sorts, calculates metadata."""
     plots = []
-    # Ensure consistent sorting, e.g., alphabetically which often aligns with plot_001, plot_002 etc.
+    plot_files = []
     try:
-        plot_files = sorted([f for f in os.listdir(SAVE_DIR) if f.endswith(".csv")])
+        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 [], 0.0 # Return empty if dir doesn't exist
+        return []
     except Exception as e:
         st.error(f"Error listing save directory '{SAVE_DIR}': {e}")
-        return [], 0.0
-
-
-    current_x_offset = 0.0
-    for i, filename in enumerate(plot_files):
-        # Extract name - assumes format like 'plot_001_MyName.csv' or just 'plot_001.csv'
-        parts = filename[:-4].split('_') # Remove .csv and split by underscore
-        plot_id = filename[:-4] # Use filename (without ext) as a unique ID for now
-        plot_name = " ".join(parts[1:]) if len(parts) > 1 else f"Plot {i+1}" # Try to extract name
-
-        plots.append({
-            'id': plot_id, # Use filename as ID
-            'name': plot_name,
-            'filename': filename,
-            'x_offset': current_x_offset
-        })
-        current_x_offset += PLOT_WIDTH
-    # Also return the offset where the next plot would start
-    return plots, current_x_offset
-
-def load_plot_objects(filename, x_offset):
-    """Loads objects from a CSV, applying the plot's x_offset."""
+        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 if required columns exist, handle gracefully if not
+        # 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 (type, pos_x/y/z). Skipping.")
+             st.warning(f"CSV '{filename}' missing essential columns. Skipping.")
              return []
-        # Ensure optional columns default to something sensible if missing
-        # Use vectorized operations for defaults where possible
+        # 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 accumulated during loading
+            # 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:
-        # This shouldn't happen if called via load_plot_metadata results, but handle anyway
         st.error(f"File not found during object load: {filename}")
         return []
     except pd.errors.EmptyDataError:
-         # An empty file is valid, represents an empty plot
-         return []
+         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):
-    """Saves object data list to a new CSV file, making positions relative."""
+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 = []
-    # Ensure objects_data_list is actually a list
     if not isinstance(objects_data_list, list):
         st.error("Invalid data format received for saving (expected a list).")
-        print("Invalid save data:", objects_data_list) # Log for debugging
         return False
 
     for obj in objects_data_list:
-        # Validate incoming object structure more carefully
         pos = obj.get('position', {})
         rot = obj.get('rotation', {})
         obj_type = obj.get('type', 'Unknown')
-        obj_id = obj.get('obj_id', str(uuid.uuid4())) # Generate ID if missing from JS
+        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 to plot start
+            '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),
-            'rot_x': rot.get('_x', 0.0),
-            'rot_y': rot.get('_y', 0.0),
-            'rot_z': rot.get('_z', 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)
 
     try:
-        # Only save if there are objects to save
-        if relative_objects:
-            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}")
-        else:
-            # Create an empty file with headers if nothing new was placed
-            pd.DataFrame(columns=CSV_COLUMNS).to_csv(file_path, index=False)
-            st.info(f"Saved empty plot file: {filename}")
+        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 Exception as e:
         st.error(f"Failed to save plot data to {filename}: {e}")
         return False
 
 # --- Page Config ---
-st.set_page_config(
-    page_title="Shared World Builder",
-    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 = ""
-# Use a more descriptive key for clarity
-if 'js_save_data_result' not in st.session_state:
-    st.session_state.js_save_data_result = None
+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
 
 # --- Load Plot Metadata ---
-# Cached function returns list of plots and the next starting x_offset
-plots_metadata, next_plot_x_offset = load_plot_metadata()
+# This is now the source of truth for saved plots
+plots_metadata = load_plot_metadata()
 
 # --- Load ALL Objects for Rendering ---
-# This could be slow with many plots!
 all_initial_objects = []
 for plot in plots_metadata:
-    all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset']))
+    all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
 
 # --- Sidebar ---
 with st.sidebar:
     st.title("🏗️ World Controls")
 
     st.header("Navigation (Plots)")
-    st.caption("Click to teleport player to the start of a plot.")
-
-    # Use columns for a horizontal button layout if desired
-    max_cols = 3 # Adjust number of columns
+    st.caption("Click to teleport player to a plot.")
+    max_cols = 2 # Adjust columns for potentially more buttons
     cols = st.columns(max_cols)
     col_idx = 0
-    for plot in plots_metadata:
-        # Use an emoji + name for the button
-        button_label = f"➡️ {plot.get('name', plot['id'])}" # Fallback to id if name missing
-        # Use plot filename (unique) as key
-        if cols[col_idx].button(button_label, key=f"nav_{plot['filename']}"):
-            # Send command to JS to move the player
+    # 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']
+            target_z = plot['z_offset'] # Use Z offset too
             try:
-                streamlit_js_eval(js_code=f"teleportPlayer({target_x});", key=f"teleport_{plot['filename']}")
+                # 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}")
-            # No rerun needed here, JS handles the move instantly
-
-        col_idx = (col_idx + 1) % max_cols # Cycle through columns
+        col_idx = (col_idx + 1) % max_cols
 
     st.markdown("---")
 
     # --- Object Placement ---
     st.header("Place Objects")
     object_types = ["None", "Simple House", "Tree", "Rock", "Fence Post"]
-    current_object_index = 0
-    try:
-        # Ensure robustness if selected_object is somehow not in list
-        current_object_index = object_types.index(st.session_state.selected_object)
-    except ValueError:
-        st.session_state.selected_object = "None" # Reset to default
-        current_object_index = 0
-
+    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" # Use a distinct key for the widget
+        "Select Object:", options=object_types, index=current_object_index, key="selected_object_widget"
     )
-    # Update session state only if the widget's value actually changes
-    # This change WILL trigger a rerun because Streamlit tracks widget state.
-    # The JS side now handles preserving its state across the resulting reload via sessionStorage.
     if selected_object_type_widget != st.session_state.selected_object:
          st.session_state.selected_object = selected_object_type_widget
-         # We don't *need* to force a rerun here, Streamlit handles it.
-         # The important part is that the NEXT run will inject the new selected type,
-         # and the JS will restore placed objects from sessionStorage.
-
+         # Rerun will happen, JS reloads state via sessionStorage, Python injects new selection
 
     st.markdown("---")
 
     # --- Saving ---
-    st.header("Save New Plot")
-    # Ensure text input reflects current state value
-    st.session_state.new_plot_name = st.text_input(
-        "Name for New Plot:",
-        value=st.session_state.new_plot_name,
-        placeholder="My Awesome Creation",
-        key="new_plot_name_input" # Use distinct key
-    )
+    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 needs update
+        streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
+        st.rerun() # Rerun to process result
 
-    if st.button("💾 Save Current Work as New Plot", key="save_button"):
-        # 1. Trigger JS function `getSaveData()` defined in index.html
-        # This function collects data for newly placed objects and returns a JSON string.
-        # The key argument ('js_save_processor') stores the JS result in session_state.
-        streamlit_js_eval(
-             js_code="getSaveData();",
-             key="js_save_processor" # Store result under this key
-        )
-        # Small delay MAY sometimes help ensure the value is set before rerun, but usually not needed
-        # import time
-        # time.sleep(0.1)
-        st.rerun() # Rerun to process the result in the next step
-
-
-# --- Process Save Data (if received from JS via the key) ---
-# Check the session state key set by the streamlit_js_eval call
+
+# --- 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
+if save_data_from_js is not None:
     st.info("Received save data from client...")
     save_processed_successfully = False
     try:
-        # Ensure data is treated as a string before loading json
-        if isinstance(save_data_from_js, str):
-            objects_to_save = json.loads(save_data_from_js)
-        else:
-             # Handle case where it might already be parsed by chance (less likely)
-             objects_to_save = save_data_from_js
-
-        # Proceed only if we have a list (even an empty one is ok now)
-        if isinstance(objects_to_save, list):
-            # Determine filename for the new plot
-            new_plot_index = len(plots_metadata) # 0-based index -> number of plots
-            # Sanitize name: replace spaces, keep only alphanumeric/underscore
-            plot_name_sanitized = "".join(c for c in st.session_state.new_plot_name if c.isalnum() or c in (' ')).strip().replace(' ', '_')
-            if not plot_name_sanitized: # Ensure there is a name part
-                plot_name_sanitized = f"Plot_{new_plot_index + 1}"
-
-            new_filename = f"plot_{new_plot_index:03d}_{plot_name_sanitized}.csv"
-
-            # Save the data, converting world coords to relative coords inside the func
-            save_ok = save_plot_data(new_filename, objects_to_save, next_plot_x_offset)
-
-            if save_ok:
-                # Clear the plot metadata cache so it reloads with the new file
-                load_plot_metadata.clear()
-                # Reset the new plot name field for next time
-                st.session_state.new_plot_name = ""
-                # Reset newly placed objects in JS AFTER successful save
-                try:
-                     # This call tells JS to clear its internal 'newlyPlacedObjects' array AND sessionStorage
-                     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}")
-
-                st.success(f"New plot '{plot_name_sanitized}' saved!")
-                save_processed_successfully = True
+        # 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']
+
+            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) # 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("Failed to save plot data to file.")
-
+                st.error("Invalid 'objectsToSave' format received (expected list).")
         else:
-             st.error(f"Received invalid save data format from client (expected list): {type(objects_to_save)}")
-
+            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. Data might be corrupted or empty.")
-        print("Received raw data:", save_data_from_js) # Log raw data
+        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)
 
-    # IMPORTANT: Clear the session state key regardless of success/failure
-    # to prevent reprocessing on the next rerun unless the button is clicked again.
+    # Clear the trigger data from session state
     st.session_state.js_save_processor = None
-
-    # Rerun AGAIN after processing save to reflect changes (new plot loaded, cache cleared etc.)
+    # Rerun after processing to reflect changes
     if save_processed_successfully:
         st.rerun()
 
 
 # --- Main Area ---
-st.header("Shared 3D World")
-st.caption("Build side-by-side with others. Saving adds a new plot to the right.")
+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'
-html_content_with_state = None # Initialize
+html_content_with_state = None
 
 try:
-    # --- Read the HTML template file ---
     with open(html_file_path, 'r', encoding='utf-8') as f:
         html_template = f.read()
 
-    # --- Prepare JavaScript code to inject state ---
-    # Ensure all state variables are correctly serialized as JSON
+    # --- Inject Python state into JavaScript ---
     js_injection_script = f"""
 <script>
-    // Set global variables BEFORE the main script runs
-    window.ALL_INITIAL_OBJECTS = {json.dumps(all_initial_objects)}; // All objects from all plots
+    window.ALL_INITIAL_OBJECTS = {json.dumps(all_initial_objects)};
+    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.NEXT_PLOT_X_OFFSET = {json.dumps(next_plot_x_offset)}; // Needed for save calculation & ground size
-    // Basic logging to verify state in browser console
+    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,
-        nextPlotX: window.NEXT_PLOT_X_OFFSET
+        plotDepth: window.PLOT_DEPTH
     }});
 </script>
 """
-    # --- Inject the script into the HTML template ---
-    # Replacing just before </head> is generally safe
     html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
 
-    # --- Embed HTML Component (ONLY if HTML loading and preparation succeeded) ---
+    # --- Embed HTML Component ---
     components.html(
         html_content_with_state,
-        height=750, # Adjust height as needed
+        height=750,
         scrolling=False
     )
 
-# --- Error Handling ---
 except FileNotFoundError:
     st.error(f"CRITICAL ERROR: Could not find the file '{html_file_path}'.")
-    st.warning(f"Please make sure `{html_file_path}` is in the same directory as `app.py` and that the `{SAVE_DIR}` directory exists.")
+    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) # Show full traceback for debugging
+    st.exception(e)