Update app.py

app.py

@@ -8,57 +8,71 @@ from datetime import datetime
 from pathlib import Path
 import base64
 from io import BytesIO
-from urllib.parse import urlencode
 import numpy as np
 
-# Constants for game board
+# Constants
 GRID_WIDTH = 16
 GRID_HEIGHT = 9
-REFRESH_RATE = 5  # seconds
-INTERACTION_RADIUS = 2  # tiles
+REFRESH_RATE = 5
+INTERACTION_RADIUS = 2
 POINTS_PER_INTERACTION = 1
 
-# Fantasy name generator
+# Singleton cache for game resources
+@st.experimental_singleton
+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')
+    }
+
+@st.experimental_singleton
+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']
+    }
+
 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)
-
-def get_query_params():
-    """Get game state from URL query parameters"""
-    query_params = st.experimental_get_query_params()
-    
-    if 'player_name' in query_params:
-        st.session_state.player_name = query_params['player_name'][0]
+    """Generate random fantasy name using cached components"""
+    name_parts = get_name_components()
+    return random.choice(name_parts['prefixes']) + random.choice(name_parts['suffixes'])
+
+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 = {
-            'x': int(query_params.get('x', [random.randint(0, GRID_WIDTH - 1)])[0]),
-            'y': int(query_params.get('y', [random.randint(0, GRID_HEIGHT - 1)])[0])
+            '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(query_params.get('STR', [10])[0]),
-            'DEX': int(query_params.get('DEX', [10])[0]),
-            'CON': int(query_params.get('CON', [10])[0]),
-            'INT': int(query_params.get('INT', [10])[0]),
-            'WIS': int(query_params.get('WIS', [10])[0]),
-            'CHA': int(query_params.get('CHA', [10])[0]),
-            'HP': int(query_params.get('HP', [20])[0]),
-            'MAX_HP': int(query_params.get('MAX_HP', [40])[0]),
-            'score': int(query_params.get('score', [0])[0]),
-            'created_at': float(query_params.get('created_at', [time.time()])[0])
+            '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()))
         }
 
-def update_query_params():
-    """Update URL query parameters with current game state"""
+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': st.session_state.position['x'],
-            'y': st.session_state.position['y'],
-            **st.session_state.character_stats
+            '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.experimental_set_query_params(**params)
+        st.query_params.from_dict(params)
 
 # Initialize session state
 if 'initialized' not in st.session_state:
@@ -76,7 +90,19 @@ if 'initialized' not in st.session_state:
     }
     st.session_state.last_move = time.time()
     st.session_state.nearby_players = []
-    get_query_params()
+    load_game_state()
+
+@st.experimental_singleton(validate=lambda x: time.time() - x['last_update'] < 60)
+def load_all_players():
+    """Cache and load all player states with validation"""
+    players = {}
+    if os.path.exists('players'):
+        for filename in os.listdir('players'):
+            if filename.endswith('.json'):
+                with open(f"players/{filename}", 'r') as f:
+                    player_data = json.load(f)
+                    players[player_data['name']] = player_data
+    return {'players': players, 'last_update': time.time()}
 
 def save_player_state():
     """Save player state to JSON file"""
@@ -91,19 +117,7 @@ def save_player_state():
         os.makedirs('players', exist_ok=True)
         with open(f"players/{st.session_state.player_name}.json", 'w') as f:
             json.dump(player_data, f)
-
-def load_all_players():
-    """Load all player states from JSON files"""
-    players = {}
-    if os.path.exists('players'):
-        for filename in os.listdir('players'):
-            if filename.endswith('.json'):
-                with open(f"players/{filename}", 'r') as f:
-                    player_data = json.load(f)
-                    # Only include active players (updated in last minute)
-                    if time.time() - player_data['last_update'] < 60:
-                        players[player_data['name']] = player_data
-    return players
+        save_game_state()
 
 def calculate_distance(pos1, pos2):
     """Calculate Manhattan distance between two positions with wrapping"""
@@ -124,11 +138,10 @@ def update_position(direction):
     
     st.session_state.last_move = time.time()
     save_player_state()
-    update_query_params()
 
 def update_nearby_players():
     """Update list of nearby players and calculate score gains"""
-    all_players = load_all_players()
+    all_players = load_all_players()['players']
     nearby = []
     score_gain = 0
     
@@ -146,18 +159,13 @@ def update_nearby_players():
     if score_gain > 0:
         st.session_state.character_stats['score'] += score_gain
         save_player_state()
-        update_query_params()
     
     st.session_state.nearby_players = nearby
 
 def create_game_board():
     """Create and display the game board"""
-    all_players = load_all_players()
-    
-    # Create placeholder images for tiles
-    tile_image = Image.new('RGB', (50, 50), color='green')
-    player_image = Image.new('RGB', (50, 50), color='blue')
-    other_player_image = Image.new('RGB', (50, 50), color='red')
+    all_players = load_all_players()['players']
+    images = get_game_images()
     
     # Create columns for each row
     for y in range(GRID_HEIGHT):
@@ -174,13 +182,13 @@ def create_game_board():
             
             # Display appropriate image and tooltip
             if x == st.session_state.position['x'] and y == st.session_state.position['y']:
-                cols[x].image(player_image, use_column_width=True)
+                cols[x].image(images['player'], use_column_width=True)
                 cols[x].markdown(f"**You** ({st.session_state.character_stats['score']} pts)")
             elif player_here:
-                cols[x].image(other_player_image, use_column_width=True)
+                cols[x].image(images['other_player'], use_column_width=True)
                 cols[x].markdown(f"**{player_here}** ({all_players[player_here]['stats']['score']} pts)")
             else:
-                cols[x].image(tile_image, use_column_width=True)
+                cols[x].image(images['tile'], use_column_width=True)
 
 def main():
     # Update nearby players on refresh
@@ -197,9 +205,19 @@ def main():
         if st.sidebar.button("Start Playing"):
             st.session_state.player_name = player_name
             if st.session_state.character_stats is None:
-                st.session_state.character_stats = roll_stats()
+                st.session_state.character_stats = {
+                    'STR': sum(sorted([random.randint(1, 6) for _ in range(4)])[1:]),
+                    'DEX': sum(sorted([random.randint(1, 6) for _ in range(4)])[1:]),
+                    'CON': sum(sorted([random.randint(1, 6) for _ in range(4)])[1:]),
+                    'INT': sum(sorted([random.randint(1, 6) for _ in range(4)])[1:]),
+                    'WIS': sum(sorted([random.randint(1, 6) for _ in range(4)])[1:]),
+                    'CHA': sum(sorted([random.randint(1, 6) for _ in range(4)])[1:]),
+                    'HP': random.randint(1, 20) * 2 + random.randint(1, 20),
+                    'MAX_HP': 40,
+                    'score': 0,
+                    'created_at': time.time()
+                }
             save_player_state()
-            update_query_params()
             st.rerun()
     else:
         # Display nearby players
@@ -226,12 +244,11 @@ def main():
             update_position("right")
             st.rerun()
         
-        # Display bookmark URL
-        st.sidebar.markdown("### Save Your Progress")
-        st.sidebar.markdown(
-            "Bookmark this URL to continue where you left off:"
-        )
-        st.sidebar.code(st.experimental_get_query_params())
+        # Clear game state button
+        if st.sidebar.button("Clear Game State"):
+            st.query_params.clear()
+            st.experimental_singleton.clear()
+            st.rerun()
 
     # Main game area
     st.title("Multiplayer Tile Game")