Update app.py

app.py

@@ -1,10 +1,6 @@
 import streamlit as st
-import asyncio
-import websockets
-import uuid
-from datetime import datetime
 import os
-import random
+import json
 import time
 import hashlib
 import glob
@@ -15,16 +11,9 @@ import edge_tts
 import nest_asyncio
 import re
 import pytz
-import shutil
+from datetime import datetime
 from PyPDF2 import PdfReader
 import threading
-import json
-import zipfile
-from dotenv import load_dotenv
-from streamlit_marquee import streamlit_marquee
-from collections import defaultdict, Counter
-import pandas as pd
-from streamlit_js_eval import streamlit_js_eval
 from PIL import Image
 
 # ==============================================================================
@@ -61,7 +50,8 @@ SAVED_WORLDS_DIR = "saved_worlds"
 HISTORY_LOG_DIR = "history_logs"
 PLOT_WIDTH = 50.0
 PLOT_DEPTH = 50.0
-WORLD_STATE_FILE_MD_PREFIX = "🌍_"
+WORLD_STATE_FILE = os.path.join(SAVED_WORLDS_DIR, "history.json")
+PLAYER_TIMEOUT_SECONDS = 15 * 60  # 15 minutes
 
 FILE_EMOJIS = {"md": "📝", "mp3": "🎵", "png": "🖼️", "mp4": "🎥", "zip": "📦", "json": "📄"}
 
@@ -75,9 +65,7 @@ PRIMITIVE_MAP = {
 for d in [CHAT_DIR, AUDIO_DIR, AUDIO_CACHE_DIR, SAVED_WORLDS_DIR, HISTORY_LOG_DIR]:
     os.makedirs(d, exist_ok=True)
 
-world_objects_lock = threading.Lock()
-world_objects = defaultdict(dict)
-connected_clients = set()
+state_lock = threading.Lock()
 
 # ==============================================================================
 # Utility Functions
@@ -98,21 +86,6 @@ def clean_filename_part(text, max_len=30):
     text = re.sub(r'[^\w\-.]', '', text)
     return text[:max_len]
 
-def run_async(async_func, *args, **kwargs):
-    try:
-        loop = asyncio.get_running_loop()
-        return loop.create_task(async_func(*args, **kwargs))
-    except RuntimeError:
-        print(f"Warning: Running async func {async_func.__name__} in new event loop.")
-        try:
-            return asyncio.run(async_func(*args, **kwargs))
-        except Exception as e:
-            print(f"Error running async func {async_func.__name__} in new loop: {e}")
-            return None
-    except Exception as e:
-        print(f"Error scheduling async task {async_func.__name__}: {e}")
-        return None
-
 def ensure_dir(dir_path):
     os.makedirs(dir_path, exist_ok=True)
 
@@ -122,121 +95,70 @@ def generate_filename(content, username, extension):
     clean_username = clean_filename_part(username)
     return f"{clean_username}_{timestamp}_{content_hash}.{extension}"
 
-def format_timestamp_prefix(prefix):
-    return f"{prefix}_{get_current_time_str()}"
-
 # ==============================================================================
-# World State File Handling (Markdown + JSON)
+# History File Management
 # ==============================================================================
 
-def generate_world_save_filename(name="World"):
-    timestamp = get_current_time_str()
-    clean_name = clean_filename_part(name)
-    rand_hash = hashlib.md5(str(time.time()).encode() + name.encode()).hexdigest()[:6]
-    return f"{WORLD_STATE_FILE_MD_PREFIX}{clean_name}_{timestamp}_{rand_hash}.md"
-
-def parse_world_filename(filename):
-    basename = os.path.basename(filename)
-    if basename.startswith(WORLD_STATE_FILE_MD_PREFIX) and basename.endswith(".md"):
-        core_name = basename[len(WORLD_STATE_FILE_MD_PREFIX):-3]
-        parts = core_name.split('_')
-        if len(parts) >= 3:
-            timestamp_str = parts[-2]
-            name_parts = parts[:-2]
-            name = "_".join(name_parts) if name_parts else "Untitled"
-            dt_obj = None
-            try:
-                dt_obj = datetime.strptime(timestamp_str, '%Y%m%d_%H%M%S')
-                dt_obj = pytz.utc.localize(dt_obj)
-            except (ValueError, pytz.exceptions.AmbiguousTimeError, pytz.exceptions.NonExistentTimeError):
-                dt_obj = None
-            return {"name": name.replace('_', ' '), "timestamp": timestamp_str, "dt": dt_obj, "filename": filename}
-    dt_fallback = None
-    try:
-        mtime = os.path.getmtime(filename)
-        dt_fallback = datetime.fromtimestamp(mtime, tz=pytz.utc)
-    except Exception:
-        pass
-    return {"name": basename.replace('.md',''), "timestamp": "Unknown", "dt": dt_fallback, "filename": filename}
-
-def save_world_state_to_md(target_filename_base):
-    global world_objects
-    save_path = os.path.join(SAVED_WORLDS_DIR, target_filename_base)
-    print(f"Acquiring lock to save world state to: {save_path}...")
-    success = False
-    with world_objects_lock:
-        world_data_dict = dict(world_objects)
-        print(f"Saving {len(world_data_dict)} objects...")
-        parsed_info = parse_world_filename(save_path)
-        timestamp_save = get_current_time_str()
-        md_content = f"""# World State: {parsed_info['name']}
-* **File Saved:** {timestamp_save} (UTC)
-* **Source Timestamp:** {parsed_info['timestamp']}
-* **Objects:** {len(world_data_dict)}
-
-```json
-{json.dumps(world_data_dict, indent=2)}
-```"""
-        try:
-            ensure_dir(SAVED_WORLDS_DIR)
-            with open(save_path, 'w', encoding='utf-8') as f:
-                f.write(md_content)
-            print(f"World state saved successfully to {target_filename_base}")
-            success = True
-            username = st.session_state.get('username', 'Anonymous')
-            clean_username = clean_filename_part(username)
-            player_filename_base = f"{clean_username}_{target_filename_base}"
-            player_save_path = os.path.join(SAVED_WORLDS_DIR, player_filename_base)
-            with open(player_save_path, 'w', encoding='utf-8') as f:
-                f.write(md_content)
-            print(f"Player-specific world state saved to {player_filename_base}")
-        except Exception as e:
-            print(f"Error saving world state to {save_path}: {e}")
-    return success
-
-def load_world_state_from_md(filename_base):
-    global world_objects
-    load_path = os.path.join(SAVED_WORLDS_DIR, filename_base)
-    print(f"Loading world state from MD file: {load_path}...")
-    if not os.path.exists(load_path):
-        st.error(f"World file not found: {filename_base}")
-        return False
-    try:
-        with open(load_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-        json_match = re.search(r"```json\s*(\{[\s\S]*?\})\s*```", content, re.IGNORECASE)
-        if not json_match:
-            st.error(f"Could not find valid JSON block in {filename_base}")
-            return False
-        world_data_dict = json.loads(json_match.group(1))
-        print(f"Acquiring lock to update world state from {filename_base}...")
-        with world_objects_lock:
-            world_objects.clear()
-            for k, v in world_data_dict.items():
-                world_objects[str(k)] = v
-            loaded_count = len(world_objects)
-        print(f"Loaded {loaded_count} objects from {filename_base}. Lock released.")
-        st.session_state.current_world_file = filename_base
-        return True
-    except json.JSONDecodeError as e:
-        st.error(f"Invalid JSON found in {filename_base}: {e}")
-        return False
-    except Exception as e:
-        st.error(f"Error loading world state from {filename_base}: {e}")
-        st.exception(e)
-        return False
+def initialize_history_file():
+    ensure_dir(SAVED_WORLDS_DIR)
+    if not os.path.exists(WORLD_STATE_FILE):
+        initial_state = {"objects": {}, "players": {}}
+        with open(WORLD_STATE_FILE, 'w', encoding='utf-8') as f:
+            json.dump(initial_state, f, indent=2)
 
-def get_saved_worlds():
+def read_history_file():
+    initialize_history_file()
     try:
-        ensure_dir(SAVED_WORLDS_DIR)
-        world_files = glob.glob(os.path.join(SAVED_WORLDS_DIR, "*.md"))
-        parsed_worlds = [parse_world_filename(f) for f in world_files]
-        parsed_worlds.sort(key=lambda x: x['dt'] if x['dt'] else datetime.min.replace(tzinfo=pytz.utc), reverse=True)
-        return parsed_worlds
+        with open(WORLD_STATE_FILE, 'r', encoding='utf-8') as f:
+            return json.load(f)
     except Exception as e:
-        print(f"Error scanning saved worlds: {e}")
-        st.error(f"Could not scan saved worlds: {e}")
-        return []
+        print(f"Error reading history file: {e}")
+        return {"objects": {}, "players": {}}
+
+def write_history_file(state):
+    with state_lock:
+        try:
+            with open(WORLD_STATE_FILE, 'w', encoding='utf-8') as f:
+                json.dump(state, f, indent=2)
+        except Exception as e:
+            print(f"Error writing history file: {e}")
+
+def prune_inactive_players(state):
+    current_time = time.time()
+    players = state.get("players", {})
+    updated_players = {}
+    for username, data in players.items():
+        last_action = data.get("last_action_timestamp", 0)
+        if current_time - last_action <= PLAYER_TIMEOUT_SECONDS:
+            updated_players[username] = data
+    state["players"] = updated_players
+    return state
+
+def update_player_state(username, position=None):
+    state = read_history_file()
+    state = prune_inactive_players(state)
+    players = state.get("players", {})
+    if username not in players:
+        players[username] = {"position": position or {"x": PLOT_WIDTH / 2, "y": 0.5, "z": PLOT_DEPTH / 2}, "last_action_timestamp": time.time()}
+    else:
+        if position:
+            players[username]["position"] = position
+        players[username]["last_action_timestamp"] = time.time()
+    state["players"] = players
+    write_history_file(state)
+
+def add_object_to_state(obj_data):
+    state = read_history_file()
+    state = prune_inactive_players(state)
+    state["objects"][obj_data["obj_id"]] = obj_data
+    write_history_file(state)
+
+def remove_object_from_state(obj_id):
+    state = read_history_file()
+    state = prune_inactive_players(state)
+    if obj_id in state["objects"]:
+        del state["objects"][obj_id]
+        write_history_file(state)
 
 def log_action(username, action_type, data):
     timestamp = get_current_time_str()
@@ -282,26 +204,22 @@ def load_username():
 
 def init_session_state():
     defaults = {
-        'server_running_flag': False, 'server_instance': None, 'server_task': None,
-        'active_connections': defaultdict(dict), 'last_chat_update': 0, 'message_input': "",
-        'audio_cache': {}, 'tts_voice': "en-US-AriaNeural", 'chat_history': [],
-        'marquee_settings': {"background": "#1E1E1E", "color": "#FFFFFF", "font-size": "14px", "animationDuration": "20s", "width": "100%", "lineHeight": "35px"},
-        'enable_audio': True, 'download_link_cache': {}, 'username': None, 'autosend': False,
-        'last_message': "", 'timer_start': time.time(), 'last_sent_transcript': "",
-        'last_refresh': time.time(), 'auto_refresh': False, 'refresh_rate': 30,
-        'selected_object': 'None', 'initial_world_state_loaded': False,
-        'current_world_file': None, 'operation_timings': {}, 'performance_metrics': defaultdict(list),
-        'paste_image_base64': "", 'new_world_name': "MyWorld"
+        'message_input': "",
+        'audio_cache': {},
+        'tts_voice': "en-US-AriaNeural",
+        'chat_history': [],
+        'enable_audio': True,
+        'download_link_cache': {},
+        'username': None,
+        'autosend': False,
+        'last_message': "",
+        'selected_object': 'None',
+        'paste_image_base64': "",
+        'new_world_name': "MyWorld"
     }
     for k, v in defaults.items():
         if k not in st.session_state:
             st.session_state[k] = v
-    if not isinstance(st.session_state.active_connections, defaultdict):
-        st.session_state.active_connections = defaultdict(dict)
-    if not isinstance(st.session_state.chat_history, list):
-        st.session_state.chat_history = []
-    if not isinstance(st.session_state.marquee_settings, dict):
-        st.session_state.marquee_settings = defaults['marquee_settings']
     if not isinstance(st.session_state.audio_cache, dict):
         st.session_state.audio_cache = {}
     if not isinstance(st.session_state.download_link_cache, dict):
@@ -309,6 +227,7 @@ def init_session_state():
     if 'username' not in st.session_state or not st.session_state.username:
         st.session_state.username = random.choice(list(FUN_USERNAMES.keys()))
         save_username(st.session_state.username)
+    update_player_state(st.session_state.username)
 
 # ==============================================================================
 # Audio / TTS / Chat / File Handling Helpers
@@ -437,7 +356,7 @@ def create_zip_of_files(files_to_zip, prefix="Archive"):
     if not files_to_zip:
         st.warning("No files provided to zip.")
         return None
-    timestamp = format_timestamp_prefix(f"Zip_{prefix}")
+    timestamp = get_current_time_str()
     zip_name = f"{prefix}_{timestamp}.zip"
     try:
         print(f"Creating zip: {zip_name}...")
@@ -456,7 +375,7 @@ def create_zip_of_files(files_to_zip, prefix="Archive"):
         return None
 
 def delete_files(file_patterns, exclude_files=None):
-    protected = [STATE_FILE, "app.py", "index.html", "requirements.txt", "README.md"]
+    protected = [STATE_FILE, "app.py", "index.html", "requirements.txt", "README.md", WORLD_STATE_FILE]
     if exclude_files:
         protected.extend(exclude_files)
     deleted_count = 0
@@ -496,7 +415,7 @@ async def save_pasted_image(image, username):
         return None
     try:
         img_hash = hashlib.md5(image.tobytes()).hexdigest()[:8]
-        timestamp = format_timestamp_prefix(username)
+        timestamp = get_current_time_str()
         filename = f"{timestamp}_pasted_{img_hash}.png"
         filepath = os.path.join(MEDIA_DIR, filename)
         image.save(filepath, "PNG")
@@ -632,291 +551,28 @@ def process_pdf_tab(pdf_file, max_pages, voice):
         st.error(f"Err read PDF: {pdf_e}")
         st.exception(pdf_e)
 
-# ==============================================================================
-# WebSocket Server Logic
-# ==============================================================================
-
-async def register_client(websocket):
-    client_id = str(websocket.id)
-    connected_clients.add(client_id)
-    if 'active_connections' not in st.session_state:
-        st.session_state.active_connections = defaultdict(dict)
-    st.session_state.active_connections[client_id] = websocket
-    print(f"Client registered: {client_id}. Total: {len(connected_clients)}")
-
-async def unregister_client(websocket):
-    client_id = str(websocket.id)
-    connected_clients.discard(client_id)
-    if 'active_connections' in st.session_state:
-        st.session_state.active_connections.pop(client_id, None)
-    print(f"Client unregistered: {client_id}. Remaining: {len(connected_clients)}")
-
-async def send_safely(websocket, message, client_id):
-    try:
-        await websocket.send(message)
-    except websockets.ConnectionClosed:
-        print(f"WS Send failed (Closed) client {client_id}")
-        raise
-    except RuntimeError as e:
-        print(f"WS Send failed (Runtime {e}) client {client_id}")
-        raise
-    except Exception as e:
-        print(f"WS Send failed (Other {e}) client {client_id}")
-        raise
-
-async def broadcast_message(message, exclude_id=None):
-    if not connected_clients:
-        return
-    tasks = []
-    current_client_ids = list(connected_clients)
-    active_connections_copy = st.session_state.active_connections.copy()
-    for client_id in current_client_ids:
-        if client_id == exclude_id:
-            continue
-        websocket = active_connections_copy.get(client_id)
-        if websocket:
-            tasks.append(asyncio.create_task(send_safely(websocket, message, client_id)))
-    if tasks:
-        await asyncio.gather(*tasks, return_exceptions=True)
-
-async def broadcast_world_update():
-    with world_objects_lock:
-        current_state_payload = dict(world_objects)
-    update_msg = json.dumps({"type": "initial_state", "payload": current_state_payload})
-    print(f"Broadcasting full world update ({len(current_state_payload)} objects)...")
-    await broadcast_message(update_msg)
-
-async def websocket_handler(websocket, path):
-    await register_client(websocket)
-    client_id = str(websocket.id)
-    username = st.session_state.get('username', f"User_{client_id[:4]}")
-    try:
-        with world_objects_lock:
-            initial_state_payload = dict(world_objects)
-        initial_state_msg = json.dumps({"type": "initial_state", "payload": initial_state_payload})
-        await websocket.send(initial_state_msg)
-        print(f"Sent initial state ({len(initial_state_payload)} objs) to {client_id}")
-        await broadcast_message(json.dumps({"type": "user_join", "payload": {"username": username, "id": client_id}}), exclude_id=client_id)
-    except Exception as e:
-        print(f"Error initial phase {client_id}: {e}")
-
-    try:
-        async for message in websocket:
-            try:
-                data = json.loads(message)
-                msg_type = data.get("type")
-                payload = data.get("payload", {})
-                sender_username = payload.get("username", username)
-
-                if msg_type == "chat_message":
-                    chat_text = payload.get('message', '')
-                    voice = payload.get('voice', FUN_USERNAMES.get(sender_username, "en-US-AriaNeural"))
-                    run_async(save_chat_entry, sender_username, chat_text, voice)
-                    await broadcast_message(message, exclude_id=client_id)
-
-                elif msg_type == "place_object":
-                    obj_data = payload.get("object_data")
-                    if obj_data and 'obj_id' in obj_data and 'type' in obj_data:
-                        with world_objects_lock:
-                            world_objects[obj_data['obj_id']] = obj_data
-                        broadcast_payload = json.dumps({"type": "object_placed", "payload": {"object_data": obj_data, "username": sender_username}})
-                        await broadcast_message(broadcast_payload, exclude_id=client_id)
-                        current_file = st.session_state.get('current_world_file')
-                        if current_file:
-                            run_async(save_world_state_to_md, current_file)
-                        else:
-                            new_filename = generate_world_save_filename(f"AutoSave_{sender_username}")
-                            if run_async(save_world_state_to_md, new_filename):
-                                st.session_state.current_world_file = new_filename
-                        log_action(sender_username, "place", obj_data)
-
-                elif msg_type == "delete_object":
-                    obj_id = payload.get("obj_id")
-                    removed = False
-                    if obj_id:
-                        with world_objects_lock:
-                            if obj_id in world_objects:
-                                del world_objects[obj_id]
-                                removed = True
-                        if removed:
-                            broadcast_payload = json.dumps({"type": "object_deleted", "payload": {"obj_id": obj_id, "username": sender_username}})
-                            await broadcast_message(broadcast_payload, exclude_id=client_id)
-                            current_file = st.session_state.get('current_world_file')
-                            if current_file:
-                                run_async(save_world_state_to_md, current_file)
-                            else:
-                                new_filename = generate_world_save_filename(f"AutoSave_{sender_username}")
-                                if run_async(save_world_state_to_md, new_filename):
-                                    st.session_state.current_world_file = new_filename
-                            log_action(sender_username, "delete", {"obj_id": obj_id})
-
-                elif msg_type == "tool_selected":
-                    tool_type = payload.get("tool_type")
-                    if tool_type in PRIMITIVE_MAP.values() or tool_type == "None":
-                        st.session_state.selected_object = tool_type
-                        print(f"Tool updated to {tool_type} for {sender_username}")
-                        broadcast_payload = json.dumps({"type": "tool_selected", "payload": {"tool_type": tool_type, "username": sender_username}})
-                        await broadcast_message(broadcast_payload, exclude_id=client_id)
-
-            except json.JSONDecodeError:
-                print(f"WS Invalid JSON from {client_id}: {message[:100]}...")
-            except Exception as e:
-                print(f"WS Error processing msg from {client_id}: {e}")
-    except websockets.ConnectionClosed:
-        print(f"WS Client disconnected: {client_id} ({username})")
-    except Exception as e:
-        print(f"WS Unexpected handler error {client_id}: {e}")
-    finally:
-        await broadcast_message(json.dumps({"type": "user_leave", "payload": {"username": username, "id": client_id}}), exclude_id=client_id)
-        await unregister_client(websocket)
-
-async def run_websocket_server():
-    if st.session_state.get('server_running_flag', False):
-        return
-    st.session_state['server_running_flag'] = True
-    print("Attempting start WS server 0.0.0.0:8765...")
-    stop_event = asyncio.Event()
-    st.session_state['websocket_stop_event'] = stop_event
-    server = None
-    try:
-        server = await websockets.serve(websocket_handler, "0.0.0.0", 8765)
-        st.session_state['server_instance'] = server
-        print(f"WS server started: {server.sockets[0].getsockname()}. Waiting for stop signal...")
-        await stop_event.wait()
-    except OSError as e:
-        print(f"### FAILED START WS SERVER: {e}")
-        st.session_state['server_running_flag'] = False
-    except Exception as e:
-        print(f"### UNEXPECTED WS SERVER ERROR: {e}")
-        st.session_state['server_running_flag'] = False
-    finally:
-        print("WS server task finishing...")
-        if server:
-            server.close()
-            await server.wait_closed()
-            print("WS server closed.")
-        st.session_state['server_running_flag'] = False
-        st.session_state['server_instance'] = None
-        st.session_state['websocket_stop_event'] = None
-
-def start_websocket_server_thread():
-    if st.session_state.get('server_task') and st.session_state.server_task.is_alive():
-        return
-    if st.session_state.get('server_running_flag', False):
-        return
-    print("Creating/starting new server thread.")
-    def run_loop():
-        loop = None
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-        try:
-            loop.run_until_complete(run_websocket_server())
-        finally:
-            if loop and not loop.is_closed():
-                tasks = asyncio.all_tasks(loop)
-                for task in tasks:
-                    task.cancel()
-                try:
-                    loop.run_until_complete(asyncio.gather(*tasks, return_exceptions=True))
-                except asyncio.CancelledError:
-                    pass
-                finally:
-                    loop.close()
-                    print("Server thread loop closed.")
-            else:
-                print("Server thread loop already closed or None.")
-    st.session_state.server_task = threading.Thread(target=run_loop, daemon=True)
-    st.session_state.server_task.start()
-    time.sleep(1.5)
-    if not st.session_state.server_task.is_alive():
-        print("### Server thread failed to stay alive!")
-
 # ==============================================================================
 # Streamlit UI Layout Functions
 # ==============================================================================
 
 def render_sidebar():
     with st.sidebar:
-        st.header("💾 World Versions")
-        st.caption("Load or save named world states.")
-
-        saved_worlds = get_saved_worlds()
-        world_options_display = {
-            os.path.basename(w['filename']): (
-                f"{w['name']} ({w['timestamp']})" if not w['filename'].startswith(clean_filename_part(st.session_state.get('username', '')))
-                else f"{w['name']} ({w['timestamp']}) [Your Save]"
-            ) for w in saved_worlds
-        }
-        radio_options_basenames = [None] + [os.path.basename(w['filename']) for w in saved_worlds]
-        current_selection_basename = st.session_state.get('current_world_file', None)
-        current_radio_index = 0
-        if current_selection_basename and current_selection_basename in radio_options_basenames:
-            try:
-                current_radio_index = radio_options_basenames.index(current_selection_basename)
-            except ValueError:
-                current_radio_index = 0
-
-        selected_basename = st.radio(
-            "Load World:",
-            options=radio_options_basenames,
-            index=current_radio_index,
-            format_func=lambda x: "Live State (Unsaved)" if x is None else world_options_display.get(x, x),
-            key="world_selector_radio"
-        )
-
-        if selected_basename != current_selection_basename:
-            st.session_state.current_world_file = selected_basename
-            if selected_basename:
-                with st.spinner(f"Loading {selected_basename}..."):
-                    if load_world_state_from_md(selected_basename):
-                        run_async(broadcast_world_update)
-                        st.toast("World loaded!", icon="✅")
-                    else:
-                        st.error("Failed to load world.")
-                        st.session_state.current_world_file = None
-            else:
-                print("Switched to live state.")
-                st.toast("Switched to Live State.")
-            st.rerun()
-
-        st.caption("Download:")
-        cols = st.columns([4, 1])
-        with cols[0]:
-            st.write("**Name** (Timestamp)")
-        with cols[1]:
-            st.write("**DL**")
-        display_limit = 10
-        for i, world_info in enumerate(saved_worlds):
-            if i >= display_limit and len(saved_worlds) > display_limit + 1:
-                with st.expander(f"Show {len(saved_worlds)-display_limit} more..."):
-                    for world_info_more in saved_worlds[display_limit:]:
-                        f_basename = os.path.basename(world_info_more['filename'])
-                        f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename)
-                        display_name = world_info_more.get('name', f_basename)
-                        timestamp = world_info_more.get('timestamp', 'N/A')
-                        colA, colB = st.columns([4, 1])
-                        with colA:
-                            st.write(f"<small>{display_name} ({timestamp})</small>", unsafe_allow_html=True)
-                        with colB:
-                            st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
-                break
-            f_basename = os.path.basename(world_info['filename'])
-            f_fullpath = os.path.join(SAVED_WORLDS_DIR, f_basename)
-            display_name = world_info.get('name', f_basename)
-            timestamp = world_info.get('timestamp', 'N/A')
-            col1, col2 = st.columns([4, 1])
-            with col1:
-                st.write(f"<small>{display_name} ({timestamp})</small>", unsafe_allow_html=True)
-            with col2:
-                st.markdown(get_download_link(f_fullpath, "md"), unsafe_allow_html=True)
+        st.header("💾 World State")
+        st.caption("Manage the shared world state.")
+
+        state = read_history_file()
+        players = state.get("players", {})
+        st.subheader("Active Players")
+        current_time = time.time()
+        for username, data in players.items():
+            last_action = data.get("last_action_timestamp", 0)
+            minutes_ago = (current_time - last_action) / 60
+            st.write(f"{username}: Last active {minutes_ago:.1f} minutes ago")
 
         st.markdown("---")
         st.header("🏗️ Build Tools")
         st.caption("Select an object to place.")
-        
+
         # CSS for tool buttons
         st.markdown("""
         <style>
@@ -954,31 +610,13 @@ def render_sidebar():
             if cols[col_idx % 5].button(emoji, key=button_key, help=name, type=button_type, use_container_width=True):
                 if st.session_state.selected_object != name:
                     st.session_state.selected_object = name
-                    # Send WebSocket message to update tool selection
-                    ws_message = json.dumps({
-                        "type": "tool_selected",
-                        "payload": {"tool_type": name, "username": st.session_state.username}
-                    })
-                    run_async(broadcast_message, ws_message)
-                    # Update JavaScript tool state
-                    run_async(lambda: streamlit_js_eval(
-                        f"updateSelectedObjectType('{name}');",
-                        key=f"update_tool_js_{name}"
-                    ))
+                    update_player_state(st.session_state.username)
             col_idx += 1
         st.markdown("---")
         if st.button("🚫 Clear Tool", key="clear_tool", use_container_width=True):
             if st.session_state.selected_object != 'None':
                 st.session_state.selected_object = 'None'
-                ws_message = json.dumps({
-                    "type": "tool_selected",
-                    "payload": {"tool_type": "None", "username": st.session_state.username}
-                })
-                run_async(broadcast_message, ws_message)
-                run_async(lambda: streamlit_js_eval(
-                    "updateSelectedObjectType('None');",
-                    key="update_tool_js_none"
-                ))
+                update_player_state(st.session_state.username)
 
         st.markdown("---")
         st.header("🗣️ Voice & User")
@@ -992,11 +630,14 @@ def render_sidebar():
         new_username = st.selectbox("Change Name/Voice", options=username_options, index=current_index, key="username_select", format_func=lambda x: x.split(" ")[0])
         if new_username != st.session_state.username:
             old_username = st.session_state.username
-            change_msg = json.dumps({"type":"user_rename", "payload": {"old_username": old_username, "new_username": new_username}})
-            run_async(broadcast_message, change_msg)
+            state = read_history_file()
+            if old_username in state["players"]:
+                state["players"][new_username] = state["players"].pop(old_username)
+                write_history_file(state)
             st.session_state.username = new_username
             st.session_state.tts_voice = FUN_USERNAMES[new_username]
             save_username(st.session_state.username)
+            update_player_state(st.session_state.username)
             st.rerun()
         st.session_state['enable_audio'] = st.toggle("Enable TTS Audio", value=st.session_state.get('enable_audio', True))
 
@@ -1007,33 +648,19 @@ def render_main_content():
 
     with tab_world:
         st.header("Shared 3D World")
-        st.caption("Click to place objects with the selected tool. Right-click to delete. Changes are shared live!")
-        current_file_basename = st.session_state.get('current_world_file', None)
-        if current_file_basename:
-            parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file_basename))
-            st.info(f"Current World: **{parsed['name']}** (`{current_file_basename}`)")
-        else:
-            st.info("Live State Active (Unsaved changes only persist if saved)")
-
+        st.caption("Click to place objects with the selected tool. Right-click to delete. State is saved in history.json.")
+        state = read_history_file()
         html_file_path = 'index.html'
         try:
             with open(html_file_path, 'r', encoding='utf-8') as f:
                 html_template = f.read()
-            ws_url = "ws://localhost:8765"
-            try:
-                from streamlit.web.server.server import Server
-                session_info = Server.get_current()._get_session_info(st.runtime.scriptrunner.get_script_run_ctx().session_id)
-                server_host = session_info.ws.stream.request.host.split(':')[0]
-                ws_url = f"ws://{server_host}:8765"
-            except Exception as e:
-                print(f"WS URL detection failed ({e}), using localhost.")
             js_injection_script = f"""<script>
     window.USERNAME = {json.dumps(st.session_state.username)};
-    window.WEBSOCKET_URL = {json.dumps(ws_url)};
     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:", {{ username: window.USERNAME, websocketUrl: window.WEBSOCKET_URL, selectedObject: window.SELECTED_OBJECT_TYPE }});
+    window.WORLD_STATE = {json.dumps(state)};
+    console.log("Streamlit State Injected:", {{ username: window.USERNAME, selectedObject: window.SELECTED_OBJECT_TYPE, worldState: window.WORLD_STATE }});
 </script>"""
             html_content_with_state = html_template.replace('</head>', js_injection_script + '\n</head>', 1)
             components.html(html_content_with_state, height=700, scrolling=False)
@@ -1045,12 +672,11 @@ def render_main_content():
 
     with tab_chat:
         st.header(f"{START_ROOM} Chat")
-        chat_history_task = run_async(load_chat_history)
-        chat_history = chat_history_task.result() if chat_history_task else st.session_state.chat_history
+        chat_history_task = asyncio.run(load_chat_history())
         chat_container = st.container(height=500)
         with chat_container:
-            if chat_history:
-                st.markdown("----\n".join(reversed(chat_history[-50:])))
+            if chat_history_task:
+                st.markdown("----\n".join(reversed(chat_history_task[-50:])))
             else:
                 st.caption("No chat messages yet.")
 
@@ -1063,9 +689,8 @@ 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")
-                ws_message = json.dumps({"type": "chat_message", "payload": {"username": st.session_state.username, "message": message_to_send, "voice": voice}})
-                run_async(broadcast_message, ws_message)
-                run_async(save_chat_entry, st.session_state.username, message_to_send, voice)
+                asyncio.run(save_chat_entry(st.session_state.username, message_to_send, voice))
+                update_player_state(st.session_state.username)
                 st.session_state.message_input = ""
                 st.rerun()
             elif send_button_clicked:
@@ -1084,80 +709,19 @@ def render_main_content():
     with tab_files:
         st.header("📂 Files & Settings")
         st.subheader("💾 World State Management")
-        current_file_basename = st.session_state.get('current_world_file', None)
-        if current_file_basename:
-            parsed = parse_world_filename(os.path.join(SAVED_WORLDS_DIR, current_file_basename))
-            save_label = f"Save Changes to '{parsed['name']}'"
-            if st.button(save_label, key="save_current_world", help=f"Overwrite '{current_file_basename}'"):
-                with st.spinner(f"Overwriting {current_file_basename}..."):
-                    if save_world_state_to_md(current_file_basename):
-                        st.success("Current world saved!")
-                    else:
-                        st.error("Failed to save world state.")
-        else:
-            st.info("Load a world from the sidebar to enable saving changes to it.")
-
-        st.subheader("Save As New Version")
-        new_name_files = st.text_input("New World Name:", key="new_world_name_files", value=st.session_state.get('new_world_name', 'MyWorld'))
-        if st.button("💾 Save Live State as New Version", key="save_new_version_files"):
-            if new_name_files.strip():
-                new_filename_base = generate_world_save_filename(new_name_files)
-                with st.spinner(f"Saving new version '{new_name_files}'..."):
-                    if save_world_state_to_md(new_filename_base):
-                        st.success(f"Saved as {new_filename_base}")
-                        st.session_state.current_world_file = new_filename_base
-                        st.session_state.new_world_name = "MyWorld"
-                        st.rerun()
-                    else:
-                        st.error("Failed to save new version.")
-            else:
-                st.warning("Please enter a name.")
-
-        st.subheader("⚙️ Server Status")
-        col_ws, col_clients = st.columns(2)
-        with col_ws:
-            server_alive = st.session_state.get('server_task') and st.session_state.server_task.is_alive()
-            ws_status = "Running" if server_alive else "Stopped"
-            st.metric("WebSocket Server", ws_status)
-            if not server_alive and st.button("Restart Server Thread", key="restart_ws"):
-                start_websocket_server_thread()
-                st.rerun()
-        with col_clients:
-            st.metric("Connected Clients", len(connected_clients))
-
-        st.subheader("🗑️ Delete Files")
-        st.warning("Deletion is permanent!", icon="⚠️")
-        col_del1, col_del2, col_del3, col_del4 = st.columns(4)
-        with col_del1:
-            if st.button("🗑️ Chats", key="del_chat_md"):
-                delete_files([os.path.join(CHAT_DIR, "*.md")])
-                st.session_state.chat_history = []
-                st.rerun()
-        with col_del2:
-            if st.button("🗑️ Audio", key="del_audio_mp3"):
-                delete_files([os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3")])
-                st.session_state.audio_cache = {}
-                st.rerun()
-        with col_del3:
-            if st.button("🗑️ Worlds", key="del_worlds_md"):
-                delete_files([os.path.join(SAVED_WORLDS_DIR, f"{WORLD_STATE_FILE_MD_PREFIX}*.md")])
-                st.session_state.current_world_file = None
-                st.rerun()
-        with col_del4:
-            if st.button("🗑️ All Gen", key="del_all_gen"):
-                delete_files([os.path.join(CHAT_DIR, "*.md"), os.path.join(AUDIO_DIR, "*.mp3"), os.path.join(AUDIO_CACHE_DIR, "*.mp3"), os.path.join(SAVED_WORLDS_DIR, "*.md"), "*.zip"])
-                st.session_state.chat_history = []
-                st.session_state.audio_cache = {}
-                st.session_state.current_world_file = None
-                st.rerun()
+        if st.button("Clear World State", key="clear_world_state"):
+            state = {"objects": {}, "players": {}}
+            write_history_file(state)
+            st.success("World state cleared!")
+            st.rerun()
 
         st.subheader("📦 Download Archives")
-        zip_files = sorted(glob.glob(os.path.join(MEDIA_DIR,"*.zip")), key=os.path.getmtime, reverse=True)
+        zip_files = sorted(glob.glob(os.path.join(MEDIA_DIR, "*.zip")), key=os.path.getmtime, reverse=True)
         if zip_files:
             col_zip1, col_zip2, col_zip3 = st.columns(3)
             with col_zip1:
                 if st.button("Zip Worlds"):
-                    create_zip_of_files([w['filename'] for w in get_saved_worlds()], "Worlds")
+                    create_zip_of_files([WORLD_STATE_FILE], "Worlds")
             with col_zip2:
                 if st.button("Zip Chats"):
                     create_zip_of_files(glob.glob(os.path.join(CHAT_DIR, "*.md")), "Chats")
@@ -1174,35 +738,7 @@ def render_main_content():
 # Main Execution Logic
 # ==============================================================================
 
-def initialize_world():
-    if not st.session_state.get('initial_world_state_loaded', False):
-        print("Performing initial world load for session...")
-        saved_worlds = get_saved_worlds()
-        loaded_successfully = False
-        if saved_worlds:
-            latest_world_file_basename = os.path.basename(saved_worlds[0]['filename'])
-            print(f"Loading most recent world on startup: {latest_world_file_basename}")
-            if load_world_state_from_md(latest_world_file_basename):
-                loaded_successfully = True
-            else:
-                print("Failed to load most recent world, starting empty.")
-        else:
-            print("No saved worlds found, starting with empty state.")
-        if not loaded_successfully:
-            with world_objects_lock:
-                world_objects.clear()
-            st.session_state.current_world_file = None
-        st.session_state.initial_world_state_loaded = True
-        print("Initial world load process complete.")
-
 if __name__ == "__main__":
     init_session_state()
-    server_thread = st.session_state.get('server_task')
-    server_alive = server_thread is not None and server_thread.is_alive()
-    if not st.session_state.get('server_running_flag', False) and not server_alive:
-        start_websocket_server_thread()
-    elif server_alive and not st.session_state.get('server_running_flag', False):
-        st.session_state.server_running_flag = True
-    initialize_world()
     render_sidebar()
     render_main_content()