Update app.py

app.py

@@ -9,13 +9,28 @@ from pathlib import Path
 import base64
 from io import BytesIO
 import numpy as np
+from py_mp import CommandServer, CommandClient, ClientCommand, ServerSideServerCommand
+from py_mp.commands import NetworkFlag
+import threading
+import queue
 
+# 🎮 Game Constants
 GRID_WIDTH = 16
 GRID_HEIGHT = 9
 REFRESH_RATE = 5
 INTERACTION_RADIUS = 2
 POINTS_PER_INTERACTION = 1
 
+# 🌐 Network Settings
+SERVER_HOST = "localhost"
+SERVER_PORT = 5000
+message_queue = queue.Queue()
+
+# ⏰ Time Sync
+def get_server_time():
+    return time.time()
+
+# 🎨 Resource Management
 @st.cache_resource(show_spinner="Loading game resources...")
 def get_game_images():
     return {
@@ -24,6 +39,7 @@ def get_game_images():
         'other_player': Image.new('RGB', (50, 50), color='red')
     }
 
+# 📝 Name Generation
 @st.cache_data
 def get_name_components():
     return {
@@ -33,7 +49,8 @@ def get_name_components():
                     'is', 'ax', 'on', 'ir', 'ex', 'az', 'er', 'eth', 'ys', 'ix']
     }
 
-@st.cache_data(ttl=5)
+# 🔄 Player Synchronization
+@st.cache_data(ttl=2)
 def load_all_players(timestamp):
     players = {}
     if os.path.exists('players'):
@@ -46,52 +63,75 @@ def load_all_players(timestamp):
                             players[player_data['name']] = player_data
                     except json.JSONDecodeError:
                         continue
-    return {'players': players, 'last_update': time.time()}
+    return {'players': players, 'last_update': timestamp}
 
-def clear_caches():
-    st.cache_resource.clear()
-    st.cache_data.clear()
+# 🔄 Auto-Refresh Implementation
+def create_autorefresh():
+    refresh_html = """
+        <script>
+            let lastUpdate = Date.now();
+            let serverTimeOffset = 0;
+            
+            async function syncTime() {
+                const response = await fetch('/server_time');
+                const serverTime = await response.json();
+                serverTimeOffset = serverTime - Date.now();
+            }
+            
+            function getServerTime() {
+                return Date.now() + serverTimeOffset;
+            }
+            
+            function checkForUpdates() {
+                const now = getServerTime();
+                if (now - lastUpdate >= 5000) {
+                    lastUpdate = now;
+                    window.parent.document.querySelector('.stApp').classList.add('refreshing');
+                    setTimeout(() => window.location.reload(), 100);
+                }
+            }
 
-def generate_fantasy_name():
-    name_parts = get_name_components()
-    return random.choice(name_parts['prefixes']) + random.choice(name_parts['suffixes'])
+            function startAutoRefresh() {
+                syncTime();
+                setInterval(syncTime, 30000);
+                setInterval(checkForUpdates, 1000);
+                
+                document.addEventListener('visibilitychange', function() {
+                    if (!document.hidden) {
+                        syncTime();
+                        lastUpdate = getServerTime() - 4900;
+                    }
+                });
+            }
 
-def load_game_state():
-    if 'player_name' in st.query_params:
-        st.session_state.player_name = st.query_params.player_name
-        st.session_state.position = {
-            'x': int(st.query_params.get('x', random.randint(0, GRID_WIDTH - 1))),
-            'y': int(st.query_params.get('y', random.randint(0, GRID_HEIGHT - 1)))
-        }
-        st.session_state.character_stats = {
-            'STR': int(st.query_params.get('STR', 10)),
-            'DEX': int(st.query_params.get('DEX', 10)),
-            'CON': int(st.query_params.get('CON', 10)),
-            'INT': int(st.query_params.get('INT', 10)),
-            'WIS': int(st.query_params.get('WIS', 10)),
-            'CHA': int(st.query_params.get('CHA', 10)),
-            'HP': int(st.query_params.get('HP', 20)),
-            'MAX_HP': int(st.query_params.get('MAX_HP', 40)),
-            'score': int(st.query_params.get('score', 0)),
-            'created_at': float(st.query_params.get('created_at', time.time()))
-        }
+            if (document.readyState === 'complete') {
+                startAutoRefresh();
+            } else {
+                window.addEventListener('load', startAutoRefresh);
+            }
+        </script>
+    """
+    st.components.v1.html(refresh_html, height=0)
 
+# 💾 State Management
 def save_game_state():
     if st.session_state.player_name and st.session_state.character_stats:
         params = {
             'player_name': st.session_state.player_name,
             'x': str(st.session_state.position['x']),
             'y': str(st.session_state.position['y']),
-            **{k: str(v) for k, v in st.session_state.character_stats.items()}
+            **{k: str(v) for k, v in st.session_state.character_stats.items()},
+            'last_sync': str(get_server_time())
         }
         st.query_params.from_dict(params)
 
+# 🎲 Game State Initialization
 if 'initialized' not in st.session_state:
     st.session_state.initialized = False
     st.session_state.game_state = {
         'players': {},
         'chat_messages': [],
-        'last_sync': time.time()
+        'last_sync': get_server_time()
     }
     st.session_state.player_name = None
     st.session_state.character_stats = None
@@ -99,28 +139,30 @@ if 'initialized' not in st.session_state:
         'x': random.randint(0, GRID_WIDTH - 1),
         'y': random.randint(0, GRID_HEIGHT - 1)
     }
-    st.session_state.last_move = time.time()
+    st.session_state.last_move = get_server_time()
     st.session_state.nearby_players = []
-    load_game_state()
 
+# 🎮 Player State Management
 def save_player_state():
     if st.session_state.player_name:
         player_data = {
             'name': st.session_state.player_name,
             'position': st.session_state.position,
             'stats': st.session_state.character_stats,
-            'last_update': time.time()
+            'last_update': get_server_time()
         }
         os.makedirs('players', exist_ok=True)
         with open(f"players/{st.session_state.player_name}.json", 'w') as f:
             json.dump(player_data, f)
         save_game_state()
 
+# 📏 Distance Calculation
 def calculate_distance(pos1, pos2):
     dx = min(abs(pos1['x'] - pos2['x']), GRID_WIDTH - abs(pos1['x'] - pos2['x']))
     dy = min(abs(pos1['y'] - pos2['y']), GRID_HEIGHT - abs(pos1['y'] - pos2['y']))
     return dx + dy
 
+# 🏃‍♂️ Movement System
 def update_position(direction):
     if direction == "up":
         st.session_state.position['y'] = (st.session_state.position['y'] - 1) % GRID_HEIGHT
@@ -130,11 +172,12 @@ def update_position(direction):
         st.session_state.position['x'] = (st.session_state.position['x'] - 1) % GRID_WIDTH
     elif direction == "right":
         st.session_state.position['x'] = (st.session_state.position['x'] + 1) % GRID_WIDTH
-    st.session_state.last_move = time.time()
+    st.session_state.last_move = get_server_time()
     save_player_state()
 
+# 👥 Nearby Players Update
 def update_nearby_players():
-    current_time = time.time()
+    current_time = get_server_time()
     all_players = load_all_players(current_time)['players']
     nearby = []
     score_gain = 0
@@ -145,7 +188,8 @@ def update_nearby_players():
                 nearby.append({
                     'name': player_name,
                     'distance': distance,
-                    'score': player_data['stats']['score']
+                    'score': player_data['stats']['score'],
+                    'last_seen': current_time - player_data['last_update']
                 })
                 score_gain += POINTS_PER_INTERACTION
     if score_gain > 0:
@@ -153,10 +197,12 @@ def update_nearby_players():
         save_player_state()
     st.session_state.nearby_players = nearby
 
+# 🎨 Game Board Creation
 def create_game_board():
-    current_time = time.time()
+    current_time = get_server_time()
     all_players = load_all_players(current_time)['players']
     images = get_game_images()
+    
     for y in range(GRID_HEIGHT):
         cols = st.columns(GRID_WIDTH)
         for x in range(GRID_WIDTH):
@@ -165,6 +211,7 @@ def create_game_board():
                 if (player_data['position']['x'] == x and 
                     player_data['position']['y'] == y):
                     player_here = player_name
+            
             if x == st.session_state.position['x'] and y == st.session_state.position['y']:
                 cols[x].image(images['player'], use_column_width=True)
                 cols[x].markdown(f"**You** ({st.session_state.character_stats['score']} pts)")
@@ -174,38 +221,7 @@ def create_game_board():
             else:
                 cols[x].image(images['tile'], use_column_width=True)
 
-def create_autorefresh():
-    refresh_html = """
-        <script>
-            let lastUpdate = Date.now();
-            
-            function checkForUpdates() {
-                const now = Date.now();
-                if (now - lastUpdate >= 5000) {
-                    lastUpdate = now;
-                    window.parent.document.querySelector('.stApp').classList.add('refreshing');
-                    setTimeout(() => window.location.reload(), 100);
-                }
-            }
-
-            function startAutoRefresh() {
-                setInterval(checkForUpdates, 1000);
-                document.addEventListener('visibilitychange', function() {
-                    if (!document.hidden) {
-                        lastUpdate = Date.now() - 4900;
-                    }
-                });
-            }
-
-            if (document.readyState === 'complete') {
-                startAutoRefresh();
-            } else {
-                window.addEventListener('load', startAutoRefresh);
-            }
-        </script>
-    """
-    st.components.v1.html(refresh_html, height=0)
-
+# 🎮 Main Game Loop
 def main():
     create_autorefresh()
     update_nearby_players()
@@ -228,14 +244,17 @@ def main():
                     'HP': random.randint(1, 20) * 2 + random.randint(1, 20),
                     'MAX_HP': 40,
                     'score': 0,
-                    'created_at': time.time()
+                    'created_at': get_server_time()
                 }
             save_player_state()
             st.rerun()
     else:
         st.sidebar.markdown("### Nearby Players")
         for player in st.session_state.nearby_players:
-            st.sidebar.markdown(f"**{player['name']}** - {player['distance']} tiles away - {player['score']} pts")
+            st.sidebar.markdown(
+                f"**{player['name']}** - {player['distance']} tiles away - {player['score']} pts\n"
+                f"Last seen: {player['last_seen']:.1f}s ago"
+            )
         
         st.sidebar.markdown("### Movement Controls")
         move_cols = st.sidebar.columns(3)
@@ -255,7 +274,8 @@ def main():
         
         if st.sidebar.button("Clear Game State"):
             st.query_params.clear()
-            clear_caches()
+            st.cache_resource.clear()
+            st.cache_data.clear()
             st.rerun()
 
     st.title("Multiplayer Tile Game")