Update app.py

app.py

@@ -5,26 +5,25 @@ import os
 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
+import math
+import time
+
+# Import our GameState class
+from gamestate import GameState
 
 # --- 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_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 ---
-
-@st.cache_data(ttl=3600) # Cache plot list
+@st.cache_data(ttl=3600)
 def load_plot_metadata():
-    """Scans save dir for plot_X*_Z*.csv, sorts, calculates metadata."""
+    """Scans SAVE_DIR for plot files and returns metadata."""
     plots = []
-    plot_files = []
     try:
         plot_files = [f for f in os.listdir(SAVE_DIR) if f.endswith(".csv") and f.startswith("plot_X")]
     except FileNotFoundError:
@@ -34,67 +33,60 @@ def load_plot_metadata():
         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('_')  # Remove .csv
+            grid_x = int(parts[1][1:])  # After 'X'
+            grid_z = int(parts[2][1:])  # After 'Z'
             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,
                 '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']))
-
     return parsed_plots
 
 def load_plot_objects(filename, x_offset, z_offset):
-    """Loads objects from a CSV, applying the plot's world offsets."""
+    """Loads objects from a CSV file and applies world offsets."""
     file_path = os.path.join(SAVE_DIR, filename)
     objects = []
     try:
         df = pd.read_csv(file_path)
-        # Check required columns
         if not all(col in df.columns for col in ['type', 'pos_x', 'pos_y', 'pos_z']):
-             st.warning(f"CSV '{filename}' missing essential columns. Skipping.")
-             return []
-        # Add defaults for optional columns
+            st.warning(f"CSV '{filename}' missing essential columns. Skipping.")
+            return []
         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
+            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
+        return []
     except Exception as e:
         st.error(f"Error loading objects from {filename}: {e}")
         return []
 
 def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
-    """Saves object data list to a CSV, making positions relative to plot origin."""
+    """Saves object data list to a CSV file, making positions relative to the plot origin."""
     file_path = os.path.join(SAVE_DIR, filename)
     relative_objects = []
     if not isinstance(objects_data_list, list):
@@ -113,11 +105,11 @@ def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
 
         relative_obj = {
             'obj_id': obj_id, 'type': obj_type,
-            'pos_x': pos.get('x', 0.0) - plot_x_offset, # Make relative X
+            'pos_x': pos.get('x', 0.0) - plot_x_offset,
             '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')
+            'pos_z': pos.get('z', 0.0) - plot_z_offset,
+            '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)
 
@@ -130,19 +122,26 @@ def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
         st.error(f"Failed to save plot data to {filename}: {e}")
         return False
 
+# --- Initialize GameState Singleton ---
+@st.cache_resource
+def get_game_state():
+    # This instance is shared across all sessions and reruns.
+    return GameState(save_dir=SAVE_DIR, csv_filename="world_state.csv")
+
+game_state = get_game_state()
+
 # --- Page Config ---
-st.set_page_config( page_title="Infinite 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 = "" # No longer used for filename
-if 'js_save_data_result' not in st.session_state: st.session_state.js_save_data_result = None
+# --- Session State Initialization ---
+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 = ""
+if 'js_save_data_result' not in st.session_state:
+    st.session_state.js_save_data_result = None
 
-# --- Load Plot Metadata ---
-# This is now the source of truth for saved plots
 plots_metadata = load_plot_metadata()
-
-# --- Load ALL Objects for Rendering ---
 all_initial_objects = []
 for plot in plots_metadata:
     all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
@@ -150,93 +149,74 @@ for plot in plots_metadata:
 # --- Sidebar ---
 with st.sidebar:
     st.title("🏗️ World Controls")
-
     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']}"):
             target_x = plot['x_offset']
-            target_z = plot['z_offset'] # Use Z offset too
+            target_z = plot['z_offset']
             try:
-                # Tell JS where to teleport (center of plot approx)
                 js_code = f"teleportPlayer({target_x + PLOT_WIDTH/2}, {target_z + PLOT_DEPTH/2});"
+                from streamlit_js_eval import streamlit_js_eval
                 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}")
+                st.error(f"Failed to send teleport command: {e}")
         col_idx = (col_idx + 1) % max_cols
 
     st.markdown("---")
-
-    # --- Object Placement ---
     st.header("Place Objects")
     object_types = ["None", "Simple House", "Tree", "Rock", "Fence Post"]
     current_object_index = object_types.index(st.session_state.selected_object) if st.session_state.selected_object in object_types else 0
-    selected_object_type_widget = st.selectbox(
-        "Select Object:", options=object_types, index=current_object_index, key="selected_object_widget"
-    )
+    selected_object_type_widget = st.selectbox("Select Object:", options=object_types, index=current_object_index, key="selected_object_widget")
     if selected_object_type_widget != st.session_state.selected_object:
          st.session_state.selected_object = selected_object_type_widget
-         # Rerun will happen, JS reloads state via sessionStorage, Python injects new selection
 
     st.markdown("---")
-
-    # --- Saving ---
     st.header("Save Work")
-    st.caption("Saves newly placed objects to the plot the player is currently in. If it's a new area, a new plot file is created.")
+    st.caption("Saves newly placed objects to the current plot. A new plot file is created for new areas.")
     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
+        from streamlit_js_eval import streamlit_js_eval
+        js_get_data_code = "getSaveDataAndPosition();"
         streamlit_js_eval(js_code=js_get_data_code, key="js_save_processor")
-        st.rerun() # Rerun to process result
-
+        st.rerun()
 
-# --- Process Save Data ---
+# --- Process Save Data from JS ---
 save_data_from_js = st.session_state.get("js_save_processor", None)
-
 if save_data_from_js is not None:
     st.info("Received save data from client...")
     save_processed_successfully = False
     try:
-        # Expecting { playerPosition: {x,y,z}, objectsToSave: [...] }
         payload = json.loads(save_data_from_js) if isinstance(save_data_from_js, str) else save_data_from_js
-
         if isinstance(payload, dict) and 'playerPosition' in payload and 'objectsToSave' in payload:
             player_pos = payload['playerPosition']
             objects_to_save = payload['objectsToSave']
-
-            if isinstance(objects_to_save, list): # Allow saving empty list (clears new objects)
-                # Determine target plot based on player position
+            if isinstance(objects_to_save, list):
                 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_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"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")
+                    load_plot_metadata.clear()  # Clear cache so metadata reloads
+                    try:
+                        from streamlit_js_eval import streamlit_js_eval
+                        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.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}")
+                    # Update shared game state with new objects from this session
+                    game_state.update_state(objects_to_save)
                     save_processed_successfully = True
                 else:
                     st.error(f"Failed to save plot data to file: {target_filename}")
@@ -244,63 +224,36 @@ if save_data_from_js is not None:
                 st.error("Invalid 'objectsToSave' format received (expected list).")
         else:
             st.error("Invalid save payload structure received from client.")
-            print("Received payload:", payload) # Log for debugging
-
     except json.JSONDecodeError:
         st.error("Failed to decode save data from client.")
-        print("Received raw data:", save_data_from_js)
     except Exception as e:
         st.error(f"Error processing save: {e}")
-        st.exception(e)
-
-    # Clear the trigger data from session state
     st.session_state.js_save_processor = None
-    # Rerun after processing to reflect changes
     if save_processed_successfully:
         st.rerun()
 
-
 # --- Main Area ---
 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.")
+st.caption("Move to empty areas to expand the world. Use the sidebar 'Save' to store your work.")
+
+# Inject state into JS—including the shared GAME_STATE from our GameState singleton.
+injected_state = {
+    "ALL_INITIAL_OBJECTS": all_initial_objects,
+    "PLOTS_METADATA": plots_metadata,
+    "SELECTED_OBJECT_TYPE": st.session_state.selected_object,
+    "PLOT_WIDTH": PLOT_WIDTH,
+    "PLOT_DEPTH": PLOT_DEPTH,
+    "GAME_STATE": game_state.get_state()
+}
 
-# --- Load and Prepare HTML ---
 html_file_path = 'index.html'
 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 ---
     js_injection_script = f"""
 <script>
-    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.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
-    }});
-</script>
-"""
-    html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
-
-    # --- Embed HTML Component ---
-    components.html(
-        html_content_with_state,
-        height=750,
-        scrolling=False
-    )
-
-except FileNotFoundError:
-    st.error(f"CRITICAL ERROR: Could not find the file '{html_file_path}'.")
-    st.warning(f"Make sure `{html_file_path}` is in the same directory as `app.py` and `{SAVE_DIR}` exists.")
-except Exception as e:
-    st.error(f"An critical error occurred during HTML preparation or component rendering: {e}")
-    st.exception(e)
+    window.ALL_INITIAL_OBJECTS = {json.dumps(injected_state["ALL_INITIAL_OBJECTS"])};
+    window.PLOTS_METADATA = {json.dumps(injected_state["PLOTS_METADATA"])};
+    window.SELECTED_OBJECT_TYPE = {json