Update app.py

app.py

@@ -1,243 +1,211 @@
-# app.py
-import streamlit as st
-import streamlit.components.v1 as components
-import os
-import json
-import pandas as pd
-import uuid
-import math
-import time
-
-# Import our GameState class
-from gamestate import GameState
-
-# --- Page Config ---
+import streamlit as st  # 🌐 Streamlit magic
+import streamlit.components.v1 as components  # 🖼️ Embed custom HTML/JS
+import os  # 📂 File operations
+import json  # 🔄 JSON encoding/decoding
+import pandas as pd  # 📊 DataFrame handling
+import uuid  # 🆔 Unique IDs
+import math  # ➗ Math utils
+import time  # ⏳ Time utilities
+
+from gamestate import GameState  # 💼 Shared game-state singleton
+
+# 🚀 Page setup
 st.set_page_config(page_title="Infinite World Builder", layout="wide")
 
-# --- Constants ---
+# 📏 Constants for world dimensions & CSV schema
 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 ---
+PLOT_WIDTH = 50.0  # ↔️ Plot width in world units
+PLOT_DEPTH = 50.0  # ↕️ Plot depth in world units
+CSV_COLUMNS = [
+    'obj_id', 'type',
+    'pos_x', 'pos_y', 'pos_z',
+    'rot_x', 'rot_y', 'rot_z', 'rot_order'
+]
+
+# 🗂️ Ensure directory for plots exists
 os.makedirs(SAVE_DIR, exist_ok=True)
 
-@st.cache_data(ttl=3600)
+@st.cache_data(ttl=3600)  # 🕒 Cache for 1h
 def load_plot_metadata():
-    """Scans SAVE_DIR for plot files and returns metadata."""
-    plots = []
+    # 🔍 Scan SAVE_DIR for plot CSVs
     try:
-        plot_files = [f for f in os.listdir(SAVE_DIR) if f.endswith(".csv") and f.startswith("plot_X")]
+        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.")
+        st.error(f"Folder '{SAVE_DIR}' missing! 🚨")
         return []
     except Exception as e:
-        st.error(f"Error listing save directory '{SAVE_DIR}': {e}")
+        st.error(f"Error reading '{SAVE_DIR}': {e}")
         return []
 
-    parsed_plots = []
-    for filename in plot_files:
+    parsed = []
+    for fn in plot_files:
         try:
-            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],
-                '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
+            parts = fn[:-4].split('_')  # strip .csv
+            gx = int(parts[1][1:])  # X index
+            gz = int(parts[2][1:])  # Z index
+            name = " ".join(parts[3:]) if len(parts)>3 else f"Plot({gx},{gz})"
+            parsed.append({
+                'id': fn[:-4],
+                'filename': fn,
+                'grid_x': gx,
+                'grid_z': gz,
+                'name': name,
+                'x_offset': gx * PLOT_WIDTH,
+                'z_offset': gz * PLOT_DEPTH
             })
-        except (IndexError, ValueError):
-            st.warning(f"Could not parse grid coordinates from filename: {filename}. Skipping.")
-            continue
+        except Exception:
+            st.warning(f"Skip invalid file: {fn}")
+    parsed.sort(key=lambda p: (p['grid_x'], p['grid_z']))
+    return parsed
 
-    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 file and applies world offsets."""
-    file_path = os.path.join(SAVE_DIR, filename)
-    objects = []
+    # 📥 Load objects from a plot CSV and shift by offsets
+    path = os.path.join(SAVE_DIR, filename)
     try:
-        df = pd.read_csv(file_path)
-        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.")
+        df = pd.read_csv(path)
+        # 🛡️ Ensure essentials exist
+        if not all(c in df.columns for c in ['type','pos_x','pos_y','pos_z']):
+            st.warning(f"Missing cols in {filename} 🧐")
             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')]:
+        # 🆔 Guarantee obj_id
+        df['obj_id'] = df.get('obj_id', pd.Series([str(uuid.uuid4()) for _ in df.index]))
+        # 🔄 Fill missing rotation
+        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
 
+        objs = []
         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
+            o = row.to_dict()
+            o['pos_x'] += x_offset
+            o['pos_z'] += z_offset
+            objs.append(o)
+        return objs
     except FileNotFoundError:
-        st.error(f"File not found during object load: {filename}")
+        st.error(f"CSV not found: {filename}")
         return []
     except pd.errors.EmptyDataError:
         return []
     except Exception as e:
-        st.error(f"Error loading objects from {filename}: {e}")
+        st.error(f"Load error {filename}: {e}")
         return []
 
-def save_plot_data(filename, objects_data_list, plot_x_offset, plot_z_offset):
-    """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):
-        st.error("Invalid data format received for saving (expected a list).")
-        return False
 
-    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()))
+def save_plot_data(filename, objects_list, px, pz):
+    # 💾 Save list of new objects relative to plot origin
+    path = os.path.join(SAVE_DIR, filename)
+    if not isinstance(objects_list, list):
+        st.error("👎 Invalid data format for save")
+        return False
 
-        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}")
+    rel = []
+    for o in objects_list:
+        pos = o.get('position', {})
+        rot = o.get('rotation', {})
+        typ = o.get('type','Unknown')
+        oid = o.get('obj_id', str(uuid.uuid4()))
+        # 🛑 Skip bad objects
+        if not all(k in pos for k in ['x','y','z']) or typ=='Unknown':
             continue
-
-        relative_obj = {
-            'obj_id': obj_id, 'type': obj_type,
-            '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,
-            '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)
-
+        rel.append({
+            'obj_id': oid, 'type': typ,
+            'pos_x': pos['x']-px, 'pos_y': pos['y'], 'pos_z': pos['z']-pz,
+            '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')
+        })
     try:
-        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}")
+        pd.DataFrame(rel, columns=CSV_COLUMNS).to_csv(path, index=False)
+        st.success(f"🎉 Saved {len(rel)} to {filename}")
         return True
     except Exception as e:
-        st.error(f"Failed to save plot data to {filename}: {e}")
+        st.error(f"Save failed: {e}")
         return False
 
-# --- Initialize GameState Singleton ---
+# 🔒 Singleton for global world state
 @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()
 
-# --- 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
+# 🧠 Session state defaults
+st.session_state.setdefault('selected_object','None')
+st.session_state.setdefault('new_plot_name','')
+st.session_state.setdefault('js_save_data_result',None)
 
+# 🔄 Load everything
 plots_metadata = load_plot_metadata()
 all_initial_objects = []
-for plot in plots_metadata:
-    all_initial_objects.extend(load_plot_objects(plot['filename'], plot['x_offset'], plot['z_offset']))
+for p in plots_metadata:
+    all_initial_objects += load_plot_objects(p['filename'], p['x_offset'], p['z_offset'])
 
-# --- Sidebar ---
+# 🖥️ Sidebar UI
 with st.sidebar:
     st.title("🏗️ World Controls")
-    st.header("Navigation (Plots)")
-    st.caption("Click to teleport player to a plot.")
-    max_cols = 2
-    cols = st.columns(max_cols)
-    col_idx = 0
-    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']
+    st.header("📍 Navigate Plots")
+    cols = st.columns(2)
+    i = 0
+    for p in sorted(plots_metadata, key=lambda x:(x['grid_x'],x['grid_z'])):
+        label = f"➡️ {p['name']} ({p['grid_x']},{p['grid_z']})"
+        if cols[i].button(label, key=f"nav_{p['id']}"):
             try:
-                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']}")
+                js = f"teleportPlayer({p['x_offset']+PLOT_WIDTH/2},{p['z_offset']+PLOT_DEPTH/2});"
+                streamlit_js_eval(js_code=js, key=f"tp_{p['id']}")
             except Exception as e:
-                st.error(f"Failed to send teleport command: {e}")
-        col_idx = (col_idx + 1) % max_cols
+                st.error(f"TP fail: {e}")
+        i = (i+1)%2
 
     st.markdown("---")
-    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")
-    if selected_object_type_widget != st.session_state.selected_object:
-         st.session_state.selected_object = selected_object_type_widget
+    st.header("🌲 Place Objects")
+    opts = ["None","Simple House","Tree","Rock","Fence Post"]
+    idx = opts.index(st.session_state.selected_object) if st.session_state.selected_object in opts else 0
+    sel = st.selectbox("Select:", opts, index=idx, key="selected_object_widget")
+    if sel != st.session_state.selected_object:
+        st.session_state.selected_object = sel
 
     st.markdown("---")
-    st.header("Save Work")
-    st.caption("Saves newly placed objects to the current plot. A new plot file is created for new areas.")
+    st.header("💾 Save Work")
     if st.button("💾 Save Current Work", key="save_button"):
         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")
+        streamlit_js_eval(js_code="getSaveDataAndPosition();", key="js_save_processor")
         st.rerun()
 
-# --- 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
+# 📨 Handle incoming save data
+raw = st.session_state.get("js_save_processor")
+if raw:
+    st.info("📬 Got save data!")
+    ok=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']
-            objects_to_save = payload['objectsToSave']
-            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)
-                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})")
-                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 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}")
-                    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}")
-            else:
-                st.error("Invalid 'objectsToSave' format received (expected list).")
-        else:
-            st.error("Invalid save payload structure received from client.")
-    except json.JSONDecodeError:
-        st.error("Failed to decode save data from client.")
+        pay = json.loads(raw) if isinstance(raw,str) else raw
+        pos, objs = pay.get('playerPosition'), pay.get('objectsToSave')
+        if isinstance(objs,list) and pos:
+            gx, gz = math.floor(pos['x']/PLOT_WIDTH), math.floor(pos['z']/PLOT_DEPTH)
+            fn = f"plot_X{gx}_Z{gz}.csv"
+            if save_plot_data(fn, objs, gx*PLOT_WIDTH, gz*PLOT_DEPTH):
+                load_plot_metadata.clear()
+                try:
+                    from streamlit_js_eval import streamlit_js_eval
+                    streamlit_js_eval(js_code="resetNewlyPlacedObjects();", key="reset_js")
+                except:
+                    pass
+                game_state.update_state(objs)
+                ok=True
+        if not ok:
+            st.error("❌ Save error")
     except Exception as e:
-        st.error(f"Error processing save: {e}")
-    st.session_state.js_save_processor = None
-    if save_processed_successfully:
-        st.rerun()
+        st.error(f"Err: {e}")
+    st.session_state.js_save_processor=None
+    if ok: st.rerun()
 
-# --- Main Area ---
-st.header("Infinite Shared 3D World")
-st.caption("Move to empty areas to expand the world. Use the sidebar 'Save' to store your work.")
+# 🏠 Main view
+st.header("🌍 Infinite Shared 3D World")
+st.caption("➡️ Explore, click to build, 💾 to save!")
 
-# Inject state into JS—including the shared GAME_STATE from our GameState singleton.
-injected_state = {
+# 🔌 Inject state into JS
+state = {
     "ALL_INITIAL_OBJECTS": all_initial_objects,
     "PLOTS_METADATA": plots_metadata,
     "SELECTED_OBJECT_TYPE": st.session_state.selected_object,
@@ -246,33 +214,27 @@ injected_state = {
     "GAME_STATE": game_state.get_state()
 }
 
-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()
-
-    js_injection_script = f"""
+    with open('index.html','r',encoding='utf-8') as f:
+        html = f.read()
+    script = f"""
 <script>
-    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.dumps(injected_state["SELECTED_OBJECT_TYPE"])};
-    window.PLOT_WIDTH = {json.dumps(injected_state["PLOT_WIDTH"])};
-    window.PLOT_DEPTH = {json.dumps(injected_state["PLOT_DEPTH"])};
-    window.GAME_STATE = {json.dumps(injected_state["GAME_STATE"])};
-    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,
-        gameStateObjects: window.GAME_STATE ? window.GAME_STATE.length : 0
+    window.ALL_INITIAL_OBJECTS = {json.dumps(state['ALL_INITIAL_OBJECTS'])};
+    window.PLOTS_METADATA   = {json.dumps(state['PLOTS_METADATA'])};
+    window.SELECTED_OBJECT_TYPE = {json.dumps(state['SELECTED_OBJECT_TYPE'])};
+    window.PLOT_WIDTH = {json.dumps(state['PLOT_WIDTH'])};
+    window.PLOT_DEPTH = {json.dumps(state['PLOT_DEPTH'])};
+    window.GAME_STATE = {json.dumps(state['GAME_STATE'])};
+    console.log('👍 State injected!', {{
+        objs: window.ALL_INITIAL_OBJECTS.length,
+        plots: window.PLOTS_METADATA.length,
+        gs: window.GAME_STATE.length
     }});
 </script>
 """
-    html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
-    components.html(html_content_with_state, height=750, scrolling=False)
+    html = html.replace('</head>', script + '\n</head>', 1)
+    components.html(html, 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.error("❌ index.html missing!")
 except Exception as e:
-    st.error(f"An critical error occurred during HTML preparation or component rendering: {e}")
-    st.exception(e)
+    st.error(f"😱 HTML inject failed: {e}")