Update app.py

app.py

@@ -8,11 +8,15 @@ 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
 GRID_WIDTH = 16
 GRID_HEIGHT = 9
 REFRESH_RATE = 5  # seconds
+INTERACTION_RADIUS = 2  # tiles
+POINTS_PER_INTERACTION = 1
 
 # Fantasy name generator
 def generate_fantasy_name():
@@ -22,6 +26,40 @@ def generate_fantasy_name():
                 '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]
+        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])
+        }
+        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])
+        }
+
+def update_query_params():
+    """Update URL query parameters with current game state"""
+    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
+        }
+        st.experimental_set_query_params(**params)
+
 # Initialize session state
 if 'initialized' not in st.session_state:
     st.session_state.initialized = False
@@ -37,60 +75,41 @@ if 'initialized' not in st.session_state:
         'y': random.randint(0, GRID_HEIGHT - 1)
     }
     st.session_state.last_move = time.time()
+    st.session_state.nearby_players = []
+    get_query_params()
 
-def roll_stats():
-    return {
-        '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()
-    }
-
-def save_character_sheet(player_name, stats):
-    """Save character sheet as markdown"""
-    filepath = f"characters/{player_name}.md"
-    os.makedirs('characters', exist_ok=True)
-    
-    markdown = f"""# {player_name}'s Character Sheet
-    
-## Stats
-- **STR**: {stats['STR']}
-- **DEX**: {stats['DEX']}
-- **CON**: {stats['CON']}
-- **INT**: {stats['INT']}
-- **WIS**: {stats['WIS']}
-- **CHA**: {stats['CHA']}
-
-## Health
-HP: {stats['HP']}/{stats['MAX_HP']}
-
-## Score
-Current Score: {stats['score']}
+def save_player_state():
+    """Save player state to JSON file"""
+    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()
+        }
+        
+        os.makedirs('players', exist_ok=True)
+        with open(f"players/{st.session_state.player_name}.json", 'w') as f:
+            json.dump(player_data, f)
 
-## Position
-X: {st.session_state.position['x']}, Y: {st.session_state.position['y']}
+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
 
-## Session Info
-Created: {datetime.fromtimestamp(stats['created_at']).strftime('%Y-%m-%d %H:%M:%S')}
-Last Updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-"""
-    
-    with open(filepath, 'w') as f:
-        f.write(markdown)
-
-def load_character_sheet(player_name):
-    """Load character sheet if it exists"""
-    filepath = f"characters/{player_name}.md"
-    if os.path.exists(filepath):
-        with open(filepath, 'r') as f:
-            return f.read()
-    return None
+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
 
 def update_position(direction):
     """Update player position with wrapping"""
@@ -104,27 +123,69 @@ def update_position(direction):
         st.session_state.position['x'] = (st.session_state.position['x'] + 1) % GRID_WIDTH
     
     st.session_state.last_move = time.time()
-    if st.session_state.character_stats:
-        save_character_sheet(st.session_state.player_name, st.session_state.character_stats)
+    save_player_state()
+    update_query_params()
+
+def update_nearby_players():
+    """Update list of nearby players and calculate score gains"""
+    all_players = load_all_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'])
+            if distance <= INTERACTION_RADIUS:
+                nearby.append({
+                    'name': player_name,
+                    'distance': distance,
+                    'score': player_data['stats']['score']
+                })
+                score_gain += POINTS_PER_INTERACTION
+    
+    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')
     
     # Create columns for each row
     for y in range(GRID_HEIGHT):
         cols = st.columns(GRID_WIDTH)
         for x in range(GRID_WIDTH):
-            # Display player or tile
-            if (x == st.session_state.position['x'] and 
-                y == st.session_state.position['y']):
+            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(player_image, 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].markdown(f"**{player_here}** ({all_players[player_here]['stats']['score']} pts)")
             else:
                 cols[x].image(tile_image, use_column_width=True)
 
 def main():
+    # Update nearby players on refresh
+    update_nearby_players()
+    
     # Sidebar for player info and controls
     st.sidebar.title("Player Info")
     
@@ -137,23 +198,16 @@ def main():
             st.session_state.player_name = player_name
             if st.session_state.character_stats is None:
                 st.session_state.character_stats = roll_stats()
-            save_character_sheet(player_name, st.session_state.character_stats)
+            save_player_state()
+            update_query_params()
             st.rerun()
     else:
-        # Show current name and allow changes
-        new_name = st.sidebar.text_input("Your name:", 
-                                       value=st.session_state.player_name)
-        if new_name != st.session_state.player_name:
-            old_name = st.session_state.player_name
-            st.session_state.player_name = new_name
-            os.rename(f"characters/{old_name}.md", 
-                     f"characters/{new_name}.md")
-            st.rerun()
-        
-        # Display character sheet
-        character_sheet = load_character_sheet(st.session_state.player_name)
-        if character_sheet:
-            st.sidebar.markdown(character_sheet)
+        # 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"
+            )
         
         # Movement controls
         st.sidebar.markdown("### Movement Controls")
@@ -171,6 +225,13 @@ def main():
         if cols[2].button("➡️", key="right"):
             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())
 
     # Main game area
     st.title("Multiplayer Tile Game")
@@ -181,6 +242,7 @@ def main():
     # 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()
 
 if __name__ == "__main__":