Update backup1.app.py

backup1.app.py

@@ -3,358 +3,316 @@ import streamlit as st
 import streamlit.components.v1 as components
 import os
 import json
+import pandas as pd
 import uuid
-from PIL import Image, ImageDraw # For minimap
-import urllib.parse # For decoding save data
+from PIL import Image, ImageDraw # Not used for minimap anymore, but kept just in case
+from streamlit_js_eval import streamlit_js_eval # For JS communication
 
 # --- Constants ---
 SAVE_DIR = "saved_worlds"
-WORLD_MAP_FILE = os.path.join(SAVE_DIR, "world_map.json")
-DEFAULT_SPACE_SIZE = 50 # Matches ground plane size in JS (approx)
-MINIMAP_CELL_SIZE = 10 # Pixels per cell in minimap image
+PLOT_WIDTH = 50.0 # Width of each plot in 3D space (adjust as needed)
+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 for Persistence ---
-
-def load_world_map():
-    """Loads the world map metadata."""
-    if os.path.exists(WORLD_MAP_FILE):
-        try:
-            with open(WORLD_MAP_FILE, 'r') as f:
-                return json.load(f)
-        except json.JSONDecodeError:
-            st.error("Error reading world map file. Starting fresh.")
-            return {"spaces": {}} # Return empty if corrupt
-    return {"spaces": {}} # SpaceID -> {"grid_x": int, "grid_y": int, "name": str}
-
-def save_world_map(world_data):
-    """Saves the world map metadata."""
+# --- Helper Functions ---
+
+@st.cache_data(ttl=3600) # Cache plot list for an hour, or clear manually
+def load_plot_metadata():
+    """Scans save dir, sorts plots, calculates metadata."""
+    plots = []
+    # Ensure consistent sorting, e.g., alphabetically which often aligns with plot_001, plot_002 etc.
     try:
-        with open(WORLD_MAP_FILE, 'w') as f:
-            json.dump(world_data, f, indent=4)
+        plot_files = sorted([f for f in os.listdir(SAVE_DIR) if f.endswith(".csv")])
+    except FileNotFoundError:
+        st.error(f"Save directory '{SAVE_DIR}' not found.")
+        return [], 0.0 # Return empty if dir doesn't exist
     except Exception as e:
-        st.error(f"Error saving world map: {e}")
-
-
-def save_space_data(space_id, objects_data):
-    """Saves the object data for a specific space."""
-    file_path = os.path.join(SAVE_DIR, f"{space_id}.json")
+        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."""
+    file_path = os.path.join(SAVE_DIR, filename)
+    objects = []
     try:
-        with open(file_path, 'w') as f:
-            # Store objects directly, could add metadata later
-            json.dump({"objects": objects_data}, f, indent=4)
+        df = pd.read_csv(file_path)
+        # Check if required columns exist, handle gracefully if not
+        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.")
+             return []
+        # Ensure optional columns default to something sensible if missing
+        # Use vectorized operations for defaults where possible
+        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
+            obj_data['pos_x'] += x_offset
+            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 []
     except Exception as e:
-        st.error(f"Error saving space data for {space_id}: {e}")
-
-
-def load_space_data(space_id):
-    """Loads object data for a specific space."""
-    file_path = os.path.join(SAVE_DIR, f"{space_id}.json")
-    if os.path.exists(file_path):
-        try:
-            with open(file_path, 'r') as f:
-                data = json.load(f)
-                return data.get("objects", []) # Return objects list or empty
-        except json.JSONDecodeError:
-            st.error(f"Error reading space file {space_id}.json.")
-            return []
-        except Exception as e:
-            st.error(f"Error loading space data for {space_id}: {e}")
-            return []
-    return [] # Return empty list if file doesn't exist
-
-def find_next_available_grid_slot(world_data):
-    """Finds the next empty slot in a spiral pattern (simple version)."""
-    occupied = set((d["grid_x"], d["grid_y"]) for d in world_data.get("spaces", {}).values())
-    x, y = 0, 0
-    dx, dy = 0, -1
-    limit = 1 # How many steps in current direction
-    steps = 0 # Steps taken in current direction
-    leg = 0   # Current leg of the spiral (0=right, 1=up, 2=left, 3=down)
-
-    while True:
-        if (x, y) not in occupied:
-            return x, y
-
-        # Move
-        x, y = x + dx, y + dy
-        steps += 1
-
-        # Check if direction needs changing
-        if steps == limit:
-            steps = 0
-            leg = (leg + 1) % 4
-            if leg == 0: # Right
-                dx, dy = 1, 0
-            elif leg == 1: # Up
-                dx, dy = 0, 1
-                limit += 1 # Increase steps after moving up
-            elif leg == 2: # Left
-                dx, dy = -1, 0
-            elif leg == 3: # Down
-                dx, dy = 0, -1
-                limit += 1 # Increase steps after moving down
-
-        # Safety break (increase if expecting huge maps)
-        if limit > 100:
-             st.error("Could not find empty grid slot easily! Map too full?")
-             return None, None
-
-
-# --- Minimap Generation ---
-def generate_minimap(world_data, current_space_id=None):
-    spaces = world_data.get("spaces", {})
-    if not spaces:
-        return None # No map if no spaces saved
+        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."""
+    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
+
+        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
+            '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),
+            'rot_order': rot.get('_order', 'XYZ')
+        }
+        relative_objects.append(relative_obj)
 
     try:
-        coords = [(d["grid_x"], d["grid_y"]) for d in spaces.values()]
-        # Handle case where coords might be empty if spaces dict is malformed
-        if not coords: return None
-
-        min_x = min(c[0] for c in coords)
-        max_x = max(c[0] for c in coords)
-        min_y = min(c[1] for c in coords)
-        max_y = max(c[1] for c in coords)
-
-        # Add padding around the edges
-        padding = 1
-        img_width = (max_x - min_x + 1 + 2 * padding) * MINIMAP_CELL_SIZE
-        img_height = (max_y - min_y + 1 + 2 * padding) * MINIMAP_CELL_SIZE
-
-        img = Image.new('RGB', (img_width, img_height), color = 'lightgrey')
-        draw = ImageDraw.Draw(img)
-
-        for space_id, data in spaces.items():
-            # Calculate position including padding offset
-            cell_x = (data["grid_x"] - min_x + padding) * MINIMAP_CELL_SIZE
-            cell_y = (data["grid_y"] - min_y + padding) * MINIMAP_CELL_SIZE
-            color = "blue"
-            if space_id == current_space_id:
-                color = "red" # Highlight current space
-
-            draw.rectangle(
-                [cell_x, cell_y, cell_x + MINIMAP_CELL_SIZE -1, cell_y + MINIMAP_CELL_SIZE -1],
-                fill=color, outline="black"
-            )
-            # Optional: Draw space name/ID lightly
-            # draw.text((cell_x + 1, cell_y + 1), data.get("name", sid[:2]), fill="white", font_size=8)
-
-
-        return img
+        # 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}")
+        return True
     except Exception as e:
-        st.error(f"Error generating minimap: {e}")
-        return None
-
+        st.error(f"Failed to save plot data to {filename}: {e}")
+        return False
 
 # --- Page Config ---
 st.set_page_config(
-    page_title="Multiplayer World Builder",
+    page_title="Shared World Builder",
     layout="wide"
 )
 
 # --- Initialize Session State ---
 if 'selected_object' not in st.session_state:
     st.session_state.selected_object = 'None'
-if 'current_space_id' not in st.session_state:
-    st.session_state.current_space_id = None # Will be set when loading/creating
-if 'space_name' not in st.session_state:
-     st.session_state.space_name = ""
-if 'initial_objects' not in st.session_state:
-     st.session_state.initial_objects = [] # Objects to load into JS
-if 'trigger_rerun' not in st.session_state:
-     st.session_state.trigger_rerun = 0 # Counter to force reruns cleanly
-
-
-# --- Load initial world data ---
-world_data = load_world_map()
-
-# --- Handle Save Data from JS (Query Param Workaround) ---
-query_params = st.query_params.to_dict()
-save_data_encoded = query_params.get("save_data")
-
-
-if save_data_encoded:
-    st.session_state.trigger_rerun += 1 # Increment to signal change
-    save_successful = False
-    try:
-        save_data_json = urllib.parse.unquote(save_data_encoded[0]) # Get first value if list
-        objects_to_save = json.loads(save_data_json)
-
-        # Get ID/Name from URL or fall back to session state if not in URL (e.g., if redirect failed partially)
-        space_id_to_save = query_params.get("space_id", [st.session_state.current_space_id])[0]
-        space_name_to_save = urllib.parse.unquote(query_params.get("space_name", [st.session_state.space_name])[0])
-
-
-        if not space_id_to_save or space_id_to_save == 'null': # JS might send 'null' string
-            space_id_to_save = str(uuid.uuid4()) # Create new ID
-            is_new_space = True
-            st.session_state.current_space_id = space_id_to_save # Update state
-        else:
-            is_new_space = False
-
-        # Save the actual object data
-        save_space_data(space_id_to_save, objects_to_save)
-
-        # Update world map only if needed (new space or name change)
-        map_updated = False
-        world_spaces = world_data.setdefault("spaces", {})
-
-        if is_new_space:
-            grid_x, grid_y = find_next_available_grid_slot(world_data)
-            if grid_x is not None:
-                 world_spaces[space_id_to_save] = {
-                     "grid_x": grid_x,
-                     "grid_y": grid_y,
-                     "name": space_name_to_save or f"Space_{space_id_to_save[:6]}"
-                 }
-                 map_updated = True
-            else:
-                 st.error("Failed to assign grid position!")
-        elif space_id_to_save in world_spaces and world_spaces[space_id_to_save].get("name") != space_name_to_save:
-             # Update name if it changed for existing space
-             world_spaces[space_id_to_save]["name"] = space_name_to_save
-             map_updated = True
-
-        if map_updated:
-             save_world_map(world_data)
-
-        st.session_state.space_name = space_name_to_save # Ensure state matches saved name
-
-        st.success(f"Space '{space_name_to_save or space_id_to_save}' saved successfully!")
-        save_successful = True
-
-
-    except Exception as e:
-        st.error(f"Error processing save data: {e}")
-        st.exception(e) # Show full traceback for debugging
-
-    # IMPORTANT: Clear query param to prevent resave on refresh/rerun
-    st.query_params.clear()
-
-    # Force a rerun IF save was processed, to reload objects and clear URL state visually
-    # Do this AFTER clearing query_params
-    if save_successful:
-        # No need to explicitly call st.rerun() here, Streamlit's flow after
-        # clearing query params and updating state often handles it.
-        # If visual updates lag, uncommenting st.rerun() might be necessary,
-        # but can sometimes cause double reruns.
-        # st.rerun()
-        pass
-
-
-# --- Load Space Data if ID is set ---
-# This runs on every script execution, including after save/load actions
-if st.session_state.current_space_id:
-     st.session_state.initial_objects = load_space_data(st.session_state.current_space_id)
-     # Ensure name is loaded if space ID exists but name state is empty
-     if not st.session_state.space_name and st.session_state.current_space_id in world_data.get("spaces", {}):
-          st.session_state.space_name = world_data["spaces"][st.session_state.current_space_id].get("name", "")
-
-
-# --- Sidebar Controls ---
+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
+
+# --- Load Plot Metadata ---
+# Cached function returns list of plots and the next starting x_offset
+plots_metadata, next_plot_x_offset = 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']))
+
+# --- Sidebar ---
 with st.sidebar:
     st.title("🏗️ World Controls")
 
-    # --- Space Management ---
-    st.subheader("Manage Spaces")
-    saved_spaces = list(world_data.get("spaces", {}).items()) # List of (id, data) tuples
-    space_options = {sid: data.get("name", f"Unnamed ({sid[:6]}...)") for sid, data in saved_spaces}
-    options_list = ["_new_"] + list(space_options.keys())
-
-    # Determine current index for selectbox
-    current_selection_index = 0 # Default to "Create New"
-    if st.session_state.current_space_id in space_options:
-        try:
-            current_selection_index = options_list.index(st.session_state.current_space_id)
-        except ValueError:
-            current_selection_index = 0 # Fallback if ID somehow not in list
-
-    selected_space_option = st.selectbox(
-        "Load or Create Space:",
-        options = options_list,
-        format_func = lambda x: space_options.get(x, "Select...") if x != "_new_" else "✨ Create New Space ✨",
-        index=current_selection_index,
-        key="space_selection_widget" # Use a dedicated key for the widget
-    )
-
-    # --- Handle Load/Create Logic ---
-    # Compare widget state to session state to detect user change
-    if selected_space_option != st.session_state.get('_last_selected_space', None):
-        st.session_state._last_selected_space = selected_space_option # Track selection change
-        if selected_space_option == "_new_":
-            # User explicitly selected "Create New"
-            if st.session_state.current_space_id is not None: # Check if switching *from* an existing space
-                st.session_state.current_space_id = None
-                st.session_state.initial_objects = []
-                st.session_state.space_name = ""
-                st.rerun() # Rerun to clear the space
-        else:
-            # User selected an existing space
-            if st.session_state.current_space_id != selected_space_option:
-                st.session_state.current_space_id = selected_space_option
-                # Loading data and name happens naturally at top of script now
-                st.rerun() # Rerun to reflect the load
-
-    # --- Name Input ---
-    current_name = st.text_input(
-         "Current Space Name:",
-         value=st.session_state.space_name, # Reflect current loaded/new name state
-         key="current_space_name_input"
-    )
-    # Update session state if user types a new name
-    if current_name != st.session_state.space_name:
-        st.session_state.space_name = current_name
-        # Note: The name is only saved to world_map.json when the JS save is triggered
+    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
+    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
+            target_x = plot['x_offset']
+            try:
+                streamlit_js_eval(js_code=f"teleportPlayer({target_x});", key=f"teleport_{plot['filename']}")
+            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
 
-    st.info(f"Current Space ID: {st.session_state.current_space_id or 'None (New)'}")
-    st.caption("Click 'Save Work' in the 3D view to save changes.")
     st.markdown("---")
 
-
-    # --- Object Placement Controls ---
-    st.subheader("Place Objects")
+    # --- Object Placement ---
+    st.header("Place Objects")
     object_types = ["None", "Simple House", "Tree", "Rock", "Fence Post"]
-    # Ensure selectbox reflects current state
     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 if invalid
+        st.session_state.selected_object = "None" # Reset to default
+        current_object_index = 0
 
     selected_object_type_widget = st.selectbox(
-        "Select Object to Place:",
+        "Select Object:",
         options=object_types,
         index=current_object_index,
-        key="selected_object_widget"
+        key="selected_object_widget" # Use a distinct key for the widget
     )
-    # Update state based on widget interaction
+    # 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
-         st.rerun() # Rerun to update JS injection
+         # 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.
+
 
     st.markdown("---")
 
-    # --- Minimap ---
-    st.subheader("World Minimap")
-    # Regenerate map data fresh each time
-    current_world_data_for_map = load_world_map()
-    minimap_img = generate_minimap(current_world_data_for_map, st.session_state.current_space_id)
-    if minimap_img:
-        st.image(minimap_img, caption="Blue: Saved Spaces, Red: Current", use_column_width=True)
-    else:
-        st.caption("No spaces saved yet.")
+    # --- 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
+    )
+
+    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
+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...")
+    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
+            else:
+                st.error("Failed to save plot data to file.")
+
+        else:
+             st.error(f"Received invalid save data format from client (expected list): {type(objects_to_save)}")
+
+
+    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
+    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.
+    st.session_state.js_save_processor = None
+
+    # Rerun AGAIN after processing save to reflect changes (new plot loaded, cache cleared etc.)
+    if save_processed_successfully:
+        st.rerun()
 
 
 # --- Main Area ---
-st.header("3D Space Editor")
-st.caption(f"Editing: {st.session_state.space_name or 'New Space'}")
+st.header("Shared 3D World")
+st.caption("Build side-by-side with others. Saving adds a new plot to the right.")
 
 # --- Load and Prepare HTML ---
 html_file_path = 'index.html'
-html_content_with_state = None # Initialize to None
+html_content_with_state = None # Initialize
 
 try:
     # --- Read the HTML template file ---
@@ -366,16 +324,16 @@ try:
     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.SELECTED_OBJECT_TYPE = {json.dumps(st.session_state.selected_object)};
-    window.INITIAL_OBJECTS = {json.dumps(st.session_state.initial_objects)};
-    window.CURRENT_SPACE_ID = {json.dumps(st.session_state.current_space_id)};
-    window.CURRENT_SPACE_NAME = {json.dumps(st.session_state.space_name)};
+    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
     console.log("Streamlit State Injected:", {{
         selectedObject: window.SELECTED_OBJECT_TYPE,
-        initialObjectsCount: window.INITIAL_OBJECTS ? window.INITIAL_OBJECTS.length : 0,
-        spaceId: window.CURRENT_SPACE_ID,
-        spaceName: window.CURRENT_SPACE_NAME
+        initialObjectsCount: window.ALL_INITIAL_OBJECTS ? window.ALL_INITIAL_OBJECTS.length : 0,
+        plotWidth: window.PLOT_WIDTH,
+        nextPlotX: window.NEXT_PLOT_X_OFFSET
     }});
 </script>
 """
@@ -396,5 +354,4 @@ except FileNotFoundError:
     st.warning(f"Please make sure `{html_file_path}` is in the same directory as `app.py` and that the `{SAVE_DIR}` directory 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
-    # Do NOT attempt to render components.html if html_content_with_state is not defined
+    st.exception(e) # Show full traceback for debugging