Upload 4 files

Dockerfile

@@ -0,0 +1,26 @@
+# Use an official Python runtime as a parent image
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements file into the container at /app
+COPY requirements.txt .
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application's code into the container at /app
+COPY . .
+
+# Make port 7860 available to the world outside this container
+# Hugging Face Spaces uses this port by default
+EXPOSE 7860
+
+# Define environment variable for the port
+ENV PORT=7860
+
+# Run app.py when the container launches using Gunicorn
+# Gunicorn is a production-ready web server.
+# We bind to 0.0.0.0 to allow external connections.
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "--workers", "1", "app:app"] 

app.py

@@ -0,0 +1,289 @@
+import os
+import random
+import json
+import uuid
+import requests
+import base64
+from flask import Flask, jsonify, render_template, request
+from dotenv import load_dotenv
+
+load_dotenv()
+
+app = Flask(__name__)
+app.config['SECRET_KEY'] = os.urandom(24)
+
+# In-memory "database"
+ZONES_FILE = 'zones.json'
+games = {}
+zones = {
+    "easy": [],
+    "medium": [],
+    "hard": []
+}
+
+# --- Zone Persistence Functions ---
+def save_zones_to_file():
+    with open(ZONES_FILE, 'w') as f:
+        json.dump(zones, f, indent=4)
+
+def load_zones_from_file():
+    global zones
+    if os.path.exists(ZONES_FILE):
+        try:
+            with open(ZONES_FILE, 'r') as f:
+                loaded_zones = json.load(f)
+            
+            # Basic format validation
+            if not (isinstance(loaded_zones, dict) and all(k in loaded_zones for k in ["easy", "medium", "hard"])):
+                raise ValueError("Invalid format")
+
+            migrated = False
+            for difficulty in loaded_zones:
+                for zone in loaded_zones[difficulty]:
+                    # Assign ID if missing
+                    if 'id' not in zone:
+                        zone['id'] = uuid.uuid4().hex
+                        migrated = True
+            
+            zones = loaded_zones
+            print(zones)
+            if migrated:
+                print("Info: Migrated old zone data by adding unique IDs.")
+                save_zones_to_file()
+
+        except (json.JSONDecodeError, IOError, ValueError):
+            print(f"Warning: '{ZONES_FILE}' is corrupted or invalid. Recreating with empty zones.")
+            save_zones_to_file() # This creates a fresh, empty, and valid file
+    else:
+        # If file doesn't exist, create an empty one.
+        save_zones_to_file()
+
+# Predefined locations for the game, used as a fallback
+LOCATIONS = [
+    {'lat': 48.85824, 'lng': 2.2945},    # Eiffel Tower, Paris
+    {'lat': 40.748440, 'lng': -73.985664}, # Empire State Building, New York
+    {'lat': 35.689487, 'lng': 139.691711}, # Tokyo, Japan
+    {'lat': -33.856784, 'lng': 151.215297} # Sydney Opera House, Australia
+]
+
+def generate_game_id():
+    return ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=10))
+
+@app.route('/')
+def index():
+    google_maps_api_key = os.getenv('GOOGLE_MAPS_API_KEY')
+    if not google_maps_api_key:
+        return "Error: GOOGLE_MAPS_API_KEY not set. Please set it in a .env file.", 500
+    return render_template('index.html', google_maps_api_key=google_maps_api_key)
+
+@app.route('/admin')
+def admin():
+    google_maps_api_key = os.getenv('GOOGLE_MAPS_API_KEY')
+    if not google_maps_api_key:
+        return "Error: GOOGLE_MAPS_API_KEY not set. Please set it in a .env file.", 500
+    return render_template('admin.html', google_maps_api_key=google_maps_api_key)
+
+@app.route('/api/zones', methods=['GET', 'POST', 'DELETE'])
+def handle_zones():
+    if request.method == 'POST':
+        data = request.json
+        difficulty = data.get('difficulty')
+        zone_data = data.get('zone')
+        if difficulty and zone_data and difficulty in zones:
+            zone_data['id'] = uuid.uuid4().hex
+            zones[difficulty].append(zone_data)
+            save_zones_to_file()
+            return jsonify({'message': 'Zone saved successfully'}), 201
+        return jsonify({'error': 'Invalid data'}), 400
+    
+    if request.method == 'DELETE':
+        data = request.json
+        zone_id = data.get('zone_id')
+        if not zone_id:
+            return jsonify({'error': 'Zone ID is required'}), 400
+        
+        for difficulty in zones:
+            zones[difficulty] = [z for z in zones[difficulty] if z.get('id') != zone_id]
+            
+        save_zones_to_file()
+        return jsonify({'message': 'Zone deleted successfully'})
+        
+    # GET request
+    return jsonify(zones)
+
+@app.route('/start_game', methods=['POST'])
+def start_game():
+    data = request.json or {}
+    difficulty = data.get('difficulty', 'easy')
+    
+    start_location = None
+    
+    if difficulty in zones and zones[difficulty]:
+        selected_zone_list = zones[difficulty]
+        print("selected_zone_list", selected_zone_list)
+        selected_zone = random.choice(selected_zone_list)
+        print("selected_zone", selected_zone)
+        
+        if selected_zone['type'] == 'rectangle':
+            bounds = selected_zone['bounds']
+            north, south, east, west = bounds['north'], bounds['south'], bounds['east'], bounds['west']
+            
+            # Handle antimeridian crossing
+            if west > east:
+                east += 360
+            
+            rand_lng = random.uniform(west, east)
+            if rand_lng > 180:
+                rand_lng -= 360
+
+            rand_lat = random.uniform(south, north)
+            start_location = {'lat': rand_lat, 'lng': rand_lng}
+    
+    # Fallback to predefined locations if no zones are defined
+    if not start_location:
+        start_location = random.choice(LOCATIONS)
+        
+    game_id = generate_game_id()
+    games[game_id] = {
+        'start_location': start_location,
+        'current_location': start_location,
+        'guesses': [],
+        'moves': 0,
+        'actions': [],
+        'game_over': False
+    }
+    
+    google_maps_api_key = os.getenv('GOOGLE_MAPS_API_KEY')
+    
+    # Fetch Street View image
+    streetview_image = None
+    compass_heading = random.randint(0, 359)  # Random compass direction
+    if google_maps_api_key:
+        try:
+            lat, lng = start_location['lat'], start_location['lng']
+            streetview_url = f"https://maps.googleapis.com/maps/api/streetview?size=640x400&location={lat},{lng}&heading={compass_heading}&pitch=0&fov=90&key={google_maps_api_key}"
+            
+            response = requests.get(streetview_url)
+            if response.status_code == 200:
+                # Convert image to base64
+                streetview_image = base64.b64encode(response.content).decode('utf-8')
+        except Exception as e:
+            print(f"Error fetching Street View image: {e}")
+    
+    return jsonify({
+        'game_id': game_id, 
+        'streetview_image': streetview_image,
+        'compass_heading': compass_heading
+    })
+
+@app.route('/game/<game_id>/state', methods=['GET'])
+def get_game_state(game_id):
+    game = games.get(game_id)
+    if not game:
+        return jsonify({'error': 'Game not found'}), 404
+    return jsonify(game)
+
+@app.route('/game/<game_id>/move', methods=['POST'])
+def move(game_id):
+    game = games.get(game_id)
+    if not game:
+        return jsonify({'error': 'Game not found'}), 404
+    if game['game_over']:
+        return jsonify({'error': 'Game is over'}), 400
+
+    data = request.json
+    new_lat = data.get('lat')
+    new_lng = data.get('lng')
+
+    if new_lat is None or new_lng is None:
+        return jsonify({'error': 'Missing lat/lng for move'}), 400
+
+    game['current_location'] = {'lat': new_lat, 'lng': new_lng}
+    game['moves'] += 1
+    game['actions'].append({'type': 'move', 'location': {'lat': new_lat, 'lng': new_lng}})
+
+    # Fetch Street View image for the new location
+    google_maps_api_key = os.getenv('GOOGLE_MAPS_API_KEY')
+    streetview_image = None
+    compass_heading = random.randint(0, 359)  # Random compass direction
+    if google_maps_api_key:
+        try:
+            streetview_url = f"https://maps.googleapis.com/maps/api/streetview?size=640x400&location={new_lat},{new_lng}&heading={compass_heading}&pitch=0&fov=90&key={google_maps_api_key}"
+            
+            response = requests.get(streetview_url)
+            if response.status_code == 200:
+                # Convert image to base64
+                streetview_image = base64.b64encode(response.content).decode('utf-8')
+        except Exception as e:
+            print(f"Error fetching Street View image: {e}")
+
+    return jsonify({
+        'message': 'Move successful', 
+        'streetview_image': streetview_image,
+        'compass_heading': compass_heading
+    })
+
+@app.route('/game/<game_id>/guess', methods=['POST'])
+def guess(game_id):
+    game = games.get(game_id)
+    if not game:
+        return jsonify({'error': 'Game not found'}), 404
+    if game['game_over']:
+        return jsonify({'error': 'Game is over'}), 400
+
+    data = request.json
+    guess_lat = data.get('lat')
+    guess_lng = data.get('lng')
+
+    if guess_lat is None or guess_lng is None:
+        return jsonify({'error': 'Missing lat/lng for guess'}), 400
+
+    guess_location = {'lat': guess_lat, 'lng': guess_lng}
+    game['guesses'].append(guess_location)
+    
+    # Calculate score (simple distance for now)
+    # This is a placeholder for a more complex scoring function.
+    from math import radians, cos, sin, asin, sqrt
+    def haversine(lat1, lon1, lat2, lon2):
+        # convert decimal degrees to radians 
+        lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2])
+        # haversine formula 
+        dlon = lon2 - lon1 
+        dlat = lat2 - lat1 
+        a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
+        c = 2 * asin(sqrt(a)) 
+        r = 6371 # Radius of earth in kilometers.
+        return c * r
+
+    distance = haversine(
+        game['start_location']['lat'], game['start_location']['lng'],
+        guess_lat, guess_lng
+    )
+    
+    # Simple scoring
+    max_score = 5000
+    score = max(0, max_score - distance) # The closer, the higher the score
+
+    game['actions'].append({
+        'type': 'guess', 
+        'location': guess_location,
+        'result': {
+            'distance_km': distance,
+            'score': score
+        }
+    })
+    game['game_over'] = True # For now, one guess ends the game.
+
+    return jsonify({
+        'message': 'Guess received', 
+        'guess_location': guess_location,
+        'actual_location': game['start_location'],
+        'distance_km': distance,
+        'score': score
+    })
+
+# Load zones at startup
+load_zones_from_file()
+
+if __name__ == '__main__':
+    app.run(debug=True) 

requirements.txt

@@ -0,0 +1,5 @@
+Flask
+python-dotenv
+requests
+gunicorn
+mcp[cli]

zones.json

@@ -0,0 +1,66 @@
+{
+    "easy": [
+        {
+            "type": "rectangle",
+            "bounds": {
+                "south": 48.8336736971006,
+                "west": 2.28515625,
+                "north": 48.87885155432368,
+                "east": 2.39776611328125
+            },
+            "id": "fc849008dae8481092eb79750ffb29b3"
+        },
+        {
+            "type": "rectangle",
+            "bounds": {
+                "south": 35.66847408359237,
+                "west": 139.62718704877395,
+                "north": 35.737615509324385,
+                "east": 139.8218510502388
+            },
+            "id": "898886b44cad43b9abfec296a553daea"
+        },
+        {
+            "type": "rectangle",
+            "bounds": {
+                "south": 37.536938882023136,
+                "west": 126.94755460738277,
+                "north": 37.557898527241505,
+                "east": 127.01244260787105
+            },
+            "id": "ba27424f2f584ed0b238795608503149"
+        },
+        {
+            "type": "rectangle",
+            "bounds": {
+                "south": 18.953448012353313,
+                "west": 72.81336899465802,
+                "north": 18.976825403712557,
+                "east": 72.83911820120099
+            },
+            "id": "71ec558ad7d7476297452801a170f10c"
+        },
+        {
+            "type": "rectangle",
+            "bounds": {
+                "south": 40.713060179679026,
+                "west": -74.00079248380419,
+                "north": 40.76040587151275,
+                "east": -73.97933481168505
+            },
+            "id": "c03e32aeb33a444f8eac20b24d946b34"
+        },
+        {
+            "type": "rectangle",
+            "bounds": {
+                "south": 37.77180843179515,
+                "west": -122.4442846812313,
+                "north": 37.80328200680126,
+                "east": -122.40857911482505
+            },
+            "id": "41ce7507e12a44b8b964d9c1d2755c42"
+        }
+    ],
+    "medium": [],
+    "hard": []
+}