Update app.py

app.py

@@ -16,6 +16,7 @@ import asyncio
 from datetime import datetime
 from PyPDF2 import PdfReader
 import threading
+import pandas as pd
 from PIL import Image
 from streamlit_javascript import st_javascript
 
@@ -105,7 +106,7 @@ def generate_filename(content, username, extension):
 def initialize_history_file():
     ensure_dir(SAVED_WORLDS_DIR)
     if not os.path.exists(WORLD_STATE_FILE):
-        initial_state = {"objects": {}, "players": {}}
+        initial_state = {"objects": {}, "players": {}, "action_history": []}
         with open(WORLD_STATE_FILE, 'w', encoding='utf-8') as f:
             json.dump(initial_state, f, indent=2)
 
@@ -113,10 +114,15 @@ def read_history_file():
     initialize_history_file()
     try:
         with open(WORLD_STATE_FILE, 'r', encoding='utf-8') as f:
-            return json.load(f)
+            state = json.load(f)
+            # Ensure all expected keys exist
+            state.setdefault("objects", {})
+            state.setdefault("players", {})
+            state.setdefault("action_history", [])
+            return state
     except Exception as e:
         print(f"Error reading history file: {e}")
-        return {"objects": {}, "players": {}}
+        return {"objects": {}, "players": {}, "action_history": []}
 
 def write_history_file(state):
     with state_lock:
@@ -149,26 +155,57 @@ def update_player_state(username, position=None):
         players[username]["last_action_timestamp"] = time.time()
     state["players"] = players
     write_history_file(state)
+    if position:
+        update_action_history(username, "move", {"position": position}, state)
     return state
 
-def add_object_to_state(obj_data, username):
-    state = read_history_file()
-    state = prune_inactive_players(state)
-    state["objects"][obj_data["obj_id"]] = obj_data
+# 📊 Update Action History: Records actions in session state and history file
+def update_action_history(username, action_type, data, state):
+    timestamp = get_current_time_str()
+    action_entry = {
+        "timestamp": timestamp,
+        "username": username,
+        "action": action_type,
+        "data": data
+    }
+    if 'action_history' not in st.session_state:
+        st.session_state.action_history = []
+    st.session_state.action_history.append(action_entry)
+    state["action_history"].append(action_entry)
     write_history_file(state)
-    log_action(username, "place", obj_data)
-    return state
 
-def remove_object_from_state(obj_id, username):
+# 🛠️ Persist World Objects: Validates and saves object data to history.json
+def persist_world_objects(obj_data, username, action_type):
+    if not obj_data or not isinstance(obj_data, dict) or 'obj_id' not in obj_data:
+        print(f"Invalid object data for {action_type}: {obj_data}")
+        return read_history_file()
+    
     state = read_history_file()
     state = prune_inactive_players(state)
-    if obj_id in state["objects"]:
-        obj_data = state["objects"][obj_id]
-        del state["objects"][obj_id]
-        write_history_file(state)
-        log_action(username, "delete", {"obj_id": obj_id})
-        return state, obj_data
-    return state, None
+    
+    if action_type == "place":
+        if 'type' not in obj_data or obj_data['type'] not in PRIMITIVE_MAP.values():
+            print(f"Invalid object type: {obj_data.get('type', 'None')}")
+            return state
+        state["objects"][obj_data['obj_id']] = obj_data
+        update_action_history(username, "place", {
+            "obj_id": obj_data['obj_id'],
+            "type": obj_data['type'],
+            "position": obj_data['position']
+        }, state)
+    elif action_type == "delete":
+        if obj_data['obj_id'] in state["objects"]:
+            obj_info = state["objects"][obj_data['obj_id']]
+            del state["objects"][obj_data['obj_id']]
+            update_action_history(username, "delete", {
+                "obj_id": obj_data['obj_id'],
+                "type": obj_info['type'],
+                "position": obj_info['position']
+            }, state)
+    
+    write_history_file(state)
+    log_action(username, action_type, obj_data)
+    return state
 
 def log_action(username, action_type, data):
     timestamp = get_current_time_str()
@@ -192,6 +229,96 @@ def log_action(username, action_type, data):
     except Exception as e:
         print(f"Error writing to player history log {player_log_file}: {e}")
 
+# 📩 Save and Log Chat: Saves chat message to chat_logs and logs to history_logs
+async def save_and_log_chat(username, message, voice):
+    if not message.strip():
+        print("Empty chat message, skipping save.")
+        return None, None
+    
+    timestamp_str = get_current_time_str()
+    entry = f"[{timestamp_str}] {username} ({voice}): {message}"
+    md_filename_base = generate_filename(message, username, "md")
+    md_file_path = os.path.join(CHAT_DIR, md_filename_base)
+    
+    try:
+        ensure_dir(CHAT_DIR)
+        with open(md_file_path, 'w', encoding='utf-8') as f:
+            f.write(entry)
+    except Exception as e:
+        print(f"Error saving chat to {md_file_path}: {e}")
+        return None, None
+
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+    st.session_state.chat_history.append(entry)
+
+    audio_file = None
+    if st.session_state.get('enable_audio', True):
+        text_cleaned = clean_text_for_tts(message)
+        if text_cleaned and text_cleaned != "No text":
+            filename_base = generate_filename(text_cleaned, username, "mp3")
+            save_path = os.path.join(AUDIO_DIR, filename_base)
+            ensure_dir(AUDIO_DIR)
+            try:
+                communicate = edge_tts.Communicate(text_cleaned, voice)
+                await communicate.save(save_path)
+                if os.path.exists(save_path) and os.path.getsize(save_path) > 0:
+                    audio_file = save_path
+                else:
+                    print(f"Audio file {save_path} failed generation.")
+            except Exception as e:
+                print(f"Edge TTS Error: {e}")
+
+    state = read_history_file()
+    update_action_history(username, "chat", {"message": message}, state)
+    return md_file_path, audio_file
+
+# 💾 Save World State: Saves current state to a named file
+def save_world_state(world_name):
+    if not world_name.strip():
+        st.error("World name cannot be empty.")
+        return False
+    clean_name = clean_filename_part(world_name)
+    timestamp = get_current_time_str()
+    filename = f"world_{clean_name}_{timestamp}.json"
+    save_path = os.path.join(SAVED_WORLDS_DIR, filename)
+    
+    state = read_history_file()
+    try:
+        with open(save_path, 'w', encoding='utf-8') as f:
+            json.dump(state, f, indent=2)
+        print(f"Saved world state to {save_path}")
+        st.success(f"Saved world as {filename}")
+        return True
+    except Exception as e:
+        print(f"Error saving world state to {save_path}: {e}")
+        st.error(f"Failed to save world: {e}")
+        return False
+
+# 📂 Load World State: Loads a saved state from a file
+def load_world_state(filename):
+    load_path = os.path.join(SAVED_WORLDS_DIR, filename)
+    if not os.path.exists(load_path):
+        st.error(f"World file not found: {filename}")
+        return False
+    try:
+        with open(load_path, 'r', encoding='utf-8') as f:
+            state = json.load(f)
+        state.setdefault("objects", {})
+        state.setdefault("players", {})
+        state.setdefault("action_history", [])
+        write_history_file(state)
+        st.session_state.world_state = state
+        st.session_state.action_history = state["action_history"]
+        print(f"Loaded world state from {load_path}")
+        st.success(f"Loaded world {filename}")
+        st.rerun()
+        return True
+    except Exception as e:
+        print(f"Error loading world state from {load_path}: {e}")
+        st.error(f"Failed to load world: {e}")
+        return False
+
 # ==============================================================================
 # JavaScript Message Handling
 # ==============================================================================
@@ -210,16 +337,15 @@ def handle_js_messages():
             payload = data.get("payload", {})
             username = payload.get("username", st.session_state.username)
             if action == "place_object":
-                state = add_object_to_state(payload["object_data"], username)
+                state = persist_world_objects(payload["object_data"], username, "place")
                 st.session_state.world_state = state
                 st.rerun()
             elif action == "delete_object":
-                state, obj_data = remove_object_from_state(payload["obj_id"], username)
+                state = persist_world_objects({"obj_id": payload["obj_id"]}, username, "delete")
                 st.session_state.world_state = state
                 st.rerun()
             elif action == "move_player":
                 state = update_player_state(username, payload["position"])
-                log_action(username, "move", payload["position"])
                 st.session_state.world_state = state
                 st.rerun()
         except json.JSONDecodeError:
@@ -253,6 +379,7 @@ def init_session_state():
         'audio_cache': {},
         'tts_voice': "en-US-AriaNeural",
         'chat_history': [],
+        'action_history': [],
         'enable_audio': True,
         'download_link_cache': {},
         'username': None,
@@ -261,7 +388,7 @@ def init_session_state():
         'selected_object': 'None',
         'paste_image_base64': "",
         'new_world_name': "MyWorld",
-        'world_state': {"objects": {}, "players": {}}
+        'world_state': {"objects": {}, "players": {}, "action_history": []}
     }
     for k, v in defaults.items():
         if k not in st.session_state:
@@ -270,9 +397,17 @@ def init_session_state():
         st.session_state.audio_cache = {}
     if not isinstance(st.session_state.download_link_cache, dict):
         st.session_state.download_link_cache = {}
+    if not isinstance(st.session_state.action_history, list):
+        st.session_state.action_history = []
     if 'username' not in st.session_state or not st.session_state.username:
-        st.session_state.username = random.choice(list(FUN_USERNAMES.keys()))
+        saved_username = load_username()
+        st.session_state.username = saved_username if saved_username else random.choice(list(FUN_USERNAMES.keys()))
         save_username(st.session_state.username)
+    
+    # Load history on startup
+    state = read_history_file()
+    st.session_state.world_state = state
+    st.session_state.action_history = state.get("action_history", [])
     update_player_state(st.session_state.username)
 
 # ==============================================================================
@@ -324,34 +459,6 @@ def get_download_link(file_path, file_type="md"):
             return f"<small>Err</small>"
     return st.session_state.download_link_cache.get(cache_key, "<small>CacheErr</small>")
 
-async def async_edge_tts_generate(text, voice, username):
-    if not text:
-        return None
-    cache_key = hashlib.md5(f"{text[:150]}_{voice}".encode()).hexdigest()
-    if 'audio_cache' not in st.session_state:
-        st.session_state.audio_cache = {}
-    cached_path = st.session_state.audio_cache.get(cache_key)
-    if cached_path and os.path.exists(cached_path):
-        return cached_path
-    text_cleaned = clean_text_for_tts(text)
-    if not text_cleaned or text_cleaned == "No text":
-        return None
-    filename_base = generate_filename(text_cleaned, username, "mp3")
-    save_path = os.path.join(AUDIO_DIR, filename_base)
-    ensure_dir(AUDIO_DIR)
-    try:
-        communicate = edge_tts.Communicate(text_cleaned, voice)
-        await communicate.save(save_path)
-        if os.path.exists(save_path) and os.path.getsize(save_path) > 0:
-            st.session_state.audio_cache[cache_key] = save_path
-            return save_path
-        else:
-            print(f"Audio file {save_path} failed generation.")
-            return None
-    except Exception as e:
-        print(f"Edge TTS Error: {e}")
-        return None
-
 def play_and_download_audio(file_path):
     if file_path and os.path.exists(file_path):
         try:
@@ -361,24 +468,6 @@ def play_and_download_audio(file_path):
         except Exception as e:
             st.error(f"Audio display error for {os.path.basename(file_path)}: {e}")
 
-async def save_chat_entry(username, message, voice, is_markdown=False):
-    if not message.strip():
-        return None, None
-    timestamp_str = get_current_time_str()
-    entry = f"[{timestamp_str}] {username} ({voice}): {message}" if not is_markdown else f"[{timestamp_str}] {username} ({voice}):\n```markdown\n{message}\n```"
-    md_filename_base = generate_filename(message, username, "md")
-    md_file_path = os.path.join(CHAT_DIR, md_filename_base)
-    md_file = create_file(entry, username, "md", save_path=md_file_path)
-    if 'chat_history' not in st.session_state:
-        st.session_state.chat_history = []
-    st.session_state.chat_history.append(entry)
-    audio_file = None
-    if st.session_state.get('enable_audio', True):
-        tts_message = message
-        audio_file = await async_edge_tts_generate(tts_message, voice, username)
-    log_action(username, "chat", {"message": message})
-    return md_file, audio_file
-
 async def load_chat_history():
     if 'chat_history' not in st.session_state:
         st.session_state.chat_history = []
@@ -607,6 +696,7 @@ def render_sidebar():
         st.header("💾 World State")
         st.caption("Manage the shared world state.")
 
+        # Active Players
         state = read_history_file()
         players = state.get("players", {})
         st.subheader("Active Players")
@@ -616,6 +706,57 @@ def render_sidebar():
             minutes_ago = (current_time - last_action) / 60
             st.write(f"{username}: Last active {minutes_ago:.1f} minutes ago")
 
+        # Action History Dataset
+        st.subheader("Action History")
+        history_data = []
+        for entry in st.session_state.action_history:
+            data = entry["data"]
+            if entry["action"] in ["place", "delete"]:
+                pos = data.get("position", {})
+                position_str = f"({pos.get('x', 0):.1f}, {pos.get('y', 0):.1f}, {pos.get('z', 0):.1f})"
+                history_data.append({
+                    "Time": entry["timestamp"],
+                    "Player": entry["username"],
+                    "Action": entry["action"].capitalize(),
+                    "Object Type": data.get("type", "N/A"),
+                    "Position": position_str
+                })
+            elif entry["action"] == "move":
+                pos = data.get("position", {})
+                position_str = f"({pos.get('x', 0):.1f}, {pos.get('y', 0):.1f}, {pos.get('z', 0):.1f})"
+                history_data.append({
+                    "Time": entry["timestamp"],
+                    "Player": entry["username"],
+                    "Action": "Move",
+                    "Object Type": "Player",
+                    "Position": position_str
+                })
+            elif entry["action"] == "chat":
+                history_data.append({
+                    "Time": entry["timestamp"],
+                    "Player": entry["username"],
+                    "Action": "Chat",
+                    "Object Type": "Message",
+                    "Position": data.get("message", "N/A")[:50]
+                })
+        if history_data:
+            st.dataframe(pd.DataFrame(history_data), height=200, use_container_width=True)
+        else:
+            st.caption("No actions recorded yet.")
+
+        # Save World
+        st.subheader("Save World")
+        world_name = st.text_input("World Name", value="MyWorld", key="save_world_name")
+        if st.button("💾 Save World", key="save_world"):
+            save_world_state(world_name)
+
+        # Load World
+        st.subheader("Load World")
+        saved_worlds = [os.path.basename(f) for f in glob.glob(os.path.join(SAVED_WORLDS_DIR, "world_*.json"))]
+        selected_world = st.selectbox("Select Saved World", ["None"] + saved_worlds, key="load_world_select")
+        if selected_world != "None" and st.button("📂 Load World", key="load_world"):
+            load_world_state(selected_world)
+
         st.markdown("---")
         st.header("🏗️ Build Tools")
         st.caption("Select an object to place.")
@@ -658,6 +799,7 @@ def render_sidebar():
                 if st.session_state.selected_object != name:
                     st.session_state.selected_object = name
                     update_player_state(st.session_state.username)
+                    update_action_history(st.session_state.username, "tool_change", {"tool": name}, read_history_file())
                     st.rerun()
             col_idx += 1
         st.markdown("---")
@@ -665,6 +807,7 @@ def render_sidebar():
             if st.session_state.selected_object != 'None':
                 st.session_state.selected_object = 'None'
                 update_player_state(st.session_state.username)
+                update_action_history(st.session_state.username, "tool_change", {"tool": "None"}, read_history_file())
                 st.rerun()
 
         st.markdown("---")
@@ -687,6 +830,7 @@ def render_sidebar():
             st.session_state.tts_voice = FUN_USERNAMES[new_username]
             save_username(st.session_state.username)
             update_player_state(st.session_state.username)
+            update_action_history(st.session_state.username, "rename", {"old_username": old_username, "new_username": new_username}, state)
             st.rerun()
         st.session_state['enable_audio'] = st.toggle("Enable TTS Audio", value=st.session_state.get('enable_audio', True))
 
@@ -698,8 +842,7 @@ def render_main_content():
     with tab_world:
         st.header("Shared 3D World")
         st.caption("Click to place objects with the selected tool, or click to move player. Right-click to delete. State is saved in history.json.")
-        state = read_history_file()
-        st.session_state.world_state = state
+        state = st.session_state.world_state
         html_file_path = 'index.html'
         try:
             with open(html_file_path, 'r', encoding='utf-8') as f:
@@ -740,7 +883,7 @@ def render_main_content():
             if message_to_send.strip() and message_to_send != st.session_state.get('last_message', ''):
                 st.session_state.last_message = message_to_send
                 voice = FUN_USERNAMES.get(st.session_state.username, "en-US-AriaNeural")
-                asyncio.run(save_chat_entry(st.session_state.username, message_to_send, voice))
+                asyncio.run(save_and_log_chat(st.session_state.username, message_to_send, voice))
                 update_player_state(st.session_state.username)
                 st.session_state.message_counter = st.session_state.get('message_counter', 0) + 1
                 st.rerun()
@@ -752,9 +895,10 @@ def render_main_content():
         st.header("📂 Files & Settings")
         st.subheader("💾 World State Management")
         if st.button("Clear World State", key="clear_world_state"):
-            state = {"objects": {}, "players": {}}
+            state = {"objects": {}, "players": {}, "action_history": []}
             write_history_file(state)
             st.session_state.world_state = state
+            st.session_state.action_history = []
             st.success("World state cleared!")
             st.rerun()
 
@@ -764,7 +908,7 @@ def render_main_content():
             col_zip1, col_zip2, col_zip3 = st.columns(3)
             with col_zip1:
                 if st.button("Zip Worlds"):
-                    create_zip_of_files([WORLD_STATE_FILE], "Worlds")
+                    create_zip_of_files([WORLD_STATE_FILE] + glob.glob(os.path.join(SAVED_WORLDS_DIR, "world_*.json")), "Worlds")
             with col_zip2:
                 if st.button("Zip Chats"):
                     create_zip_of_files(glob.glob(os.path.join(CHAT_DIR, "*.md")), "Chats")