Update backup3.app.py

backup3.app.py

@@ -9,38 +9,72 @@ from pathlib import Path
 import base64
 from io import BytesIO
 import numpy as np
+import asyncio
+import threading
+from typing import Optional
+import queue
+import atexit
 
-# Constants
+# 🎮 Game Constants
 GRID_WIDTH = 16
 GRID_HEIGHT = 9
 REFRESH_RATE = 5
 INTERACTION_RADIUS = 2
 POINTS_PER_INTERACTION = 1
 
-# Resource cache for game resources - using cache_resource for mutable objects
+# 🕒 Timer Management
+class GameTimer:
+    def __init__(self):
+        self.running = True
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self.update_queue = queue.Queue()
+        self.thread = threading.Thread(target=self._run_timer, daemon=True)
+        self.thread.start()
+
+    def _run_timer(self):
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_until_complete(self._timer_loop())
+
+    async def _timer_loop(self):
+        while self.running:
+            try:
+                current_time = time.time()
+                self.update_queue.put(('update', current_time))
+                await asyncio.sleep(REFRESH_RATE)
+            except Exception as e:
+                print(f"Timer error: {e}")
+                await asyncio.sleep(1)
+
+    def stop(self):
+        self.running = False
+        if self._loop:
+            self._loop.stop()
+
+# Initialize timer in session state
+if 'game_timer' not in st.session_state:
+    st.session_state.game_timer = GameTimer()
+
+# 📝 Name Generation
+def generate_fantasy_name():
+    prefixes = ['Aer', 'Bal', 'Cal', 'Dor', 'El', 'Fae', 'Gor', 'Hel', 'Il', 'Jor',
+                'Kal', 'Lyr', 'Mel', 'Nym', 'Oro', 'Pyr', 'Qar', 'Ryn', 'Syl', 'Tyr']
+    suffixes = ['ian', 'or', 'ion', 'us', 'ix', 'ar', 'en', 'yr', 'el', 'an',
+                'is', 'ax', 'on', 'ir', 'ex', 'az', 'er', 'eth', 'ys', 'ix']
+    return random.choice(prefixes) + random.choice(suffixes)
+
+# 🎨 Resource Management
 @st.cache_resource(show_spinner="Loading game resources...")
 def get_game_images():
-    """Cache game images to improve performance"""
     return {
         'tile': Image.new('RGB', (50, 50), color='green'),
         'player': Image.new('RGB', (50, 50), color='blue'),
         'other_player': Image.new('RGB', (50, 50), color='red')
     }
 
-# Data cache for immutable data
-@st.cache_data
-def get_name_components():
-    """Cache name generation components"""
-    return {
-        'prefixes': ['Aer', 'Bal', 'Cal', 'Dor', 'El', 'Fae', 'Gor', 'Hel', 'Il', 'Jor',
-                    'Kal', 'Lyr', 'Mel', 'Nym', 'Oro', 'Pyr', 'Qar', 'Ryn', 'Syl', 'Tyr'],
-        'suffixes': ['ian', 'or', 'ion', 'us', 'ix', 'ar', 'en', 'yr', 'el', 'an',
-                    'is', 'ax', 'on', 'ir', 'ex', 'az', 'er', 'eth', 'ys', 'ix']
-    }
-
-@st.cache_data(ttl=5)  # Cache for 5 seconds to match refresh rate
+# 🔄 Player Synchronization
+@st.cache_data(ttl=2)
 def load_all_players(timestamp):
-    """Cache and load all player states with TTL"""
     players = {}
     if os.path.exists('players'):
         for filename in os.listdir('players'):
@@ -52,20 +86,69 @@ 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():
-    """Clear all caches properly"""
     st.cache_resource.clear()
     st.cache_data.clear()
 
-def generate_fantasy_name():
-    """Generate random fantasy name using cached components"""
-    name_parts = get_name_components()
-    return random.choice(name_parts['prefixes']) + random.choice(name_parts['suffixes'])
+# 🔄 Auto-Refresh Implementation
+def create_autorefresh():
+    refresh_html = """
+        <script>
+            let lastUpdate = Date.now();
+            let updateInterval = null;
+            
+            function checkForUpdates() {
+                const now = Date.now();
+                if (now - lastUpdate >= 5000) {
+                    lastUpdate = now;
+                    window.parent.document.querySelector('.stApp').classList.add('refreshing');
+                    window.location.reload();
+                }
+            }
+
+            function startAutoRefresh() {
+                if (!updateInterval) {
+                    updateInterval = setInterval(checkForUpdates, 1000);
+                }
+                
+                document.addEventListener('visibilitychange', function() {
+                    if (!document.hidden) {
+                        lastUpdate = Date.now() - 4900;
+                    }
+                });
+            }
+
+            if (document.readyState === 'complete') {
+                startAutoRefresh();
+            } else {
+                window.addEventListener('load', startAutoRefresh);
+            }
+
+            // Cleanup on unload
+            window.addEventListener('unload', function() {
+                if (updateInterval) {
+                    clearInterval(updateInterval);
+                }
+            });
+        </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()},
+            'last_sync': str(time.time())
+        }
+        st.query_params.from_dict(params)
 
 def load_game_state():
-    """Load game state from query parameters"""
     if 'player_name' in st.query_params:
         st.session_state.player_name = st.query_params.player_name
         st.session_state.position = {
@@ -85,18 +168,7 @@ def load_game_state():
             'created_at': float(st.query_params.get('created_at', time.time()))
         }
 
-def save_game_state():
-    """Save game state to query parameters"""
-    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()}
-        }
-        st.query_params.from_dict(params)
-
-# Initialize session state
+# 🎲 Game State Initialization
 if 'initialized' not in st.session_state:
     st.session_state.initialized = False
     st.session_state.game_state = {
@@ -114,8 +186,8 @@ if 'initialized' not in st.session_state:
     st.session_state.nearby_players = []
     load_game_state()
 
+# 🎮 Player State Management
 def save_player_state():
-    """Save player state to JSON file"""
     if st.session_state.player_name:
         player_data = {
             'name': st.session_state.player_name,
@@ -123,20 +195,19 @@ def save_player_state():
             'stats': st.session_state.character_stats,
             'last_update': time.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):
-    """Calculate Manhattan distance between two positions with wrapping"""
     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):
-    """Update player position with wrapping"""
     if direction == "up":
         st.session_state.position['y'] = (st.session_state.position['y'] - 1) % GRID_HEIGHT
     elif direction == "down":
@@ -145,17 +216,15 @@ 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()
     save_player_state()
 
+# 👥 Nearby Players Update
 def update_nearby_players():
-    """Update list of nearby players and calculate score gains"""
     current_time = time.time()
     all_players = load_all_players(current_time)['players']
     nearby = []
     score_gain = 0
-    
     for player_name, player_data in all_players.items():
         if player_name != st.session_state.player_name:
             distance = calculate_distance(st.session_state.position, player_data['position'])
@@ -163,36 +232,28 @@ 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:
         st.session_state.character_stats['score'] += score_gain
         save_player_state()
-    
     st.session_state.nearby_players = nearby
 
+# 🎨 Game Board Creation
 def create_game_board():
-    """Create and display the game board"""
     current_time = time.time()
     all_players = load_all_players(current_time)['players']
     images = get_game_images()
-    
-    # Create columns for each row
     for y in range(GRID_HEIGHT):
         cols = st.columns(GRID_WIDTH)
         for x in range(GRID_WIDTH):
-            current_pos = {'x': x, 'y': y}
-            
-            # Check if any player is on this tile
             player_here = None
             for player_name, player_data in all_players.items():
                 if (player_data['position']['x'] == x and 
                     player_data['position']['y'] == y):
                     player_here = player_name
-            
-            # Display appropriate image and tooltip
             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)")
@@ -202,18 +263,25 @@ def create_game_board():
             else:
                 cols[x].image(images['tile'], use_column_width=True)
 
+# 🎮 Main Game Loop
 def main():
-    # Update nearby players on refresh
-    update_nearby_players()
+    create_autorefresh()
+    
+    # Process any queued updates
+    try:
+        while not st.session_state.game_timer.update_queue.empty():
+            update_type, timestamp = st.session_state.game_timer.update_queue.get_nowait()
+            if update_type == 'update':
+                update_nearby_players()
+                save_player_state()
+    except queue.Empty:
+        pass
     
-    # Sidebar for player info and controls
     st.sidebar.title("Player Info")
     
-    # Player name handling
     if st.session_state.player_name is None:
         default_name = generate_fantasy_name()
-        player_name = st.sidebar.text_input("Enter your name or use generated name:",
-                                          value=default_name)
+        player_name = st.sidebar.text_input("Enter your name or use generated name:", value=default_name)
         if st.sidebar.button("Start Playing"):
             st.session_state.player_name = player_name
             if st.session_state.character_stats is None:
@@ -232,14 +300,13 @@ def main():
             save_player_state()
             st.rerun()
     else:
-        # Display nearby players
         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"
+                f"**{player['name']}** - {player['distance']} tiles away - {player['score']} pts\n"
+                f"Last seen: {player['last_seen']:.1f}s ago"
             )
         
-        # Movement controls
         st.sidebar.markdown("### Movement Controls")
         move_cols = st.sidebar.columns(3)
         if move_cols[1].button("⬆️", key="up"):
@@ -256,23 +323,22 @@ def main():
             update_position("right")
             st.rerun()
         
-        # Clear game state button
         if st.sidebar.button("Clear Game State"):
+            st.session_state.game_timer.stop()
             st.query_params.clear()
             clear_caches()
             st.rerun()
 
-    # Main game area
     st.title("Multiplayer Tile Game")
-    
-    # Display game board
     create_game_board()
-    
-    # Auto-refresh logic
-    if (time.time() - st.session_state.last_move) > REFRESH_RATE:
-        st.session_state.last_move = time.time()
-        save_player_state()
-        st.rerun()
+
+# 🧹 Cleanup on exit
+def cleanup():
+    if 'game_timer' in st.session_state:
+        st.session_state.game_timer.stop()
+
+# Register cleanup
+atexit.register(cleanup)
 
 if __name__ == "__main__":
     main()