Spaces:

OrbitMC
/

yt

Runtime error

App Files Files Community

OrbitMC commited on Feb 13

Commit

10f2308

verified ·

1 Parent(s): a8dc970

Upload 4 files

Browse files

Files changed (4) hide show

admin.html +31 -0
index.html +370 -0
main.py +405 -0
requirements.txt +2 -0

admin.html ADDED Viewed

	@@ -0,0 +1,31 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <title>Void City Admin</title>
+    <style>
+        body { background: #222; color: white; font-family: sans-serif; display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100vh; }
+        button { padding: 20px 40px; font-size: 24px; margin: 10px; cursor: pointer; border: none; border-radius: 5px; }
+        .start { background: #2ecc71; color: white; }
+        .stop { background: #e74c3c; color: white; }
+    </style>
+    <script src="https://cdn.socket.io/4.7.4/socket.io.min.js"></script>
+</head>
+<body>
+    <h1>Admin Control Panel</h1>
+    <button class="start" onclick="send('start_tournament')">Start Tournament</button>
+    <button class="stop" onclick="send('stop_tournament')">Stop & Show Results</button>
+    <script>
+        // Use the same token as the client for simplicity in this MVP
+        // In prod, you'd want a separate admin auth mechanism
+        const token = sessionStorage.getItem('game_token');
+        const socket = io({ auth: { token: token } });
+        function send(cmd) {
+            if(confirm("Are you sure?")) {
+                socket.emit('admin_cmd', { cmd: cmd });
+            }
+        }
+    </script>
+</body>
+</html>

index.html ADDED Viewed

	@@ -0,0 +1,370 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+    <title>Void City 3D - Multiplayer</title>
+    <style>
+        * { box-sizing: border-box; user-select: none; -webkit-user-select: none; touch-action: none; }
+        body, html { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background-color: #1a1a1a; font-family: -apple-system, sans-serif; }
+        #gameCanvas { display: block; width: 100%; height: 100%; }
+        #uiLayer { position: absolute; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; }
+        #scoreBoard { position: absolute; top: 20px; right: 20px; text-align: right; color: white; text-shadow: 0 2px 4px rgba(0,0,0,0.8); }
+        .score-row { margin-bottom: 5px; font-weight: bold; font-size: 16px; display: flex; align-items: center; justify-content: flex-end; }
+        .lb-avatar { width: 20px; height: 20px; border-radius: 50%; margin-right: 8px; border: 1px solid white; }
+        #loginScreen { position: absolute; top: 0; left: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.9); display: flex; flex-direction: column; align-items: center; justify-content: center; z-index: 100; pointer-events: auto; }
+        .discord-btn { background: #5865F2; color: white; padding: 15px 30px; border-radius: 5px; font-size: 20px; font-weight: bold; border: none; cursor: pointer; }
+        #resultsScreen { display: none; position: absolute; top: 0; left: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.95); z-index: 200; flex-direction: column; align-items: center; justify-content: center; color: white; pointer-events: auto; }
+        .res-entry { font-size: 24px; margin: 10px; display: flex; align-items: center; }
+    </style>
+    <script src="https://cdn.socket.io/4.7.4/socket.io.min.js"></script>
+</head>
+<body>
+    <canvas id="gameCanvas"></canvas>
+    <div id="uiLayer">
+        <div id="scoreBoard">Connecting...</div>
+    </div>
+    <div id="loginScreen">
+        <h1 style="color:white; font-size:50px; margin-bottom:30px;">VOID CITY 3D</h1>
+        <button class="discord-btn" onclick="login()">Login with Discord</button>
+    </div>
+    <div id="resultsScreen">
+        <h1>TOURNAMENT ENDED</h1>
+        <div id="resultsList"></div>
+    </div>
+    <script>
+        const COLORS = { ground: '#95a5a6', road: '#2c3e50', marking: '#f1c40f', crosswalk: '#ecf0f1' };
+        const GRID_SIZE = 8;
+        const BLOCK_SIZE = 280;
+        const ROAD_WIDTH = 90;
+        const CELL_SIZE = BLOCK_SIZE + ROAD_WIDTH;
+        // --- AUTH ---
+        const urlParams = new URLSearchParams(window.location.search);
+        const token = urlParams.get('token') || sessionStorage.getItem('game_token');
+        if (token) {
+            sessionStorage.setItem('game_token', token);
+            document.getElementById('loginScreen').style.display = 'none';
+            window.history.replaceState({}, document.title, "/");
+        }
+        function login() { window.location.href = '/login'; }
+        // --- ENGINE ---
+        const canvas = document.getElementById('gameCanvas');
+        const ctx = canvas.getContext('2d', { alpha: false });
+        let socket;
+        let mapConfig = { width: 3000, height: 3000 };
+        const camera = { x: 0, y: 0, zoom: 1 };
+        let staticEntities = [];
+        let cars = [];
+        // OPTIMIZATION: Cache static player data (name, avatar, color)
+        let playerCache = {};
+        let players = [];
+        let myId = null;
+        const input = { active: false, startX:0, startY:0, currX:0, currY:0 };
+        function resize() {
+            canvas.width = window.innerWidth;
+            canvas.height = window.innerHeight;
+        }
+        window.addEventListener('resize', resize);
+        resize();
+        if (token) {
+            socket = io({ auth: { token: token } });
+            socket.on('connect', () => { myId = token; });
+            // New Init Event
+            socket.on('init_game', (data) => {
+                mapConfig.width = data.width;
+                mapConfig.height = data.height;
+                staticEntities = data.static_entities;
+                // Populate cache
+                data.players_meta.forEach(p => playerCache[p.id] = p);
+            });
+            // Player Management
+            socket.on('player_joined', (meta) => { playerCache[meta.id] = meta; });
+            socket.on('player_left', (data) => { delete playerCache[data.id]; });
+            // Lean Game Update
+            socket.on('game_update', (state) => {
+                // Merge dynamic state with static cache
+                players = state.players.map(p => {
+                    const meta = playerCache[p.id] || { username: 'Unknown', color: '#fff', avatar: '' };
+                    return { ...p, ...meta };
+                });
+                cars = state.cars;
+                if(state.removed.length > 0) {
+                    staticEntities = staticEntities.filter(e => !state.removed.includes(e.id));
+                }
+                updateUI();
+            });
+            socket.on('tournament_reset', (data) => {
+                staticEntities = data.static_entities;
+                document.getElementById('resultsScreen').style.display = 'none';
+            });
+            socket.on('tournament_end', (data) => {
+                const list = document.getElementById('resultsList');
+                list.innerHTML = data.results.map((p, i) => `
+                    <div class="res-entry">#${i+1} <img src="${p.avatar}" style="width:30px;border-radius:50%;margin:0 10px">${p.username}: ${p.score}</div>
+                `).join('');
+                document.getElementById('resultsScreen').style.display = 'flex';
+            });
+        }
+        // --- INPUT ---
+        function sendInput() {
+            if (!socket || !input.active) {
+                if(socket) socket.emit('input_data', { angle: 0, force: 0 });
+                return;
+            }
+            const dx = input.currX - input.startX;
+            const dy = input.currY - input.startY;
+            const angle = Math.atan2(dy, dx);
+            const force = Math.min(Math.hypot(dx, dy) / 50, 1);
+            socket.emit('input_data', { angle, force });
+        }
+        setInterval(sendInput, 50);
+        function handleStart(x, y) { input.active = true; input.startX = x; input.startY = y; input.currX = x; input.currY = y; }
+        function handleMove(x, y) { if(input.active) { input.currX = x; input.currY = y; } }
+        function handleEnd() { input.active = false; }
+        canvas.addEventListener('mousedown', e => handleStart(e.clientX, e.clientY));
+        window.addEventListener('mousemove', e => handleMove(e.clientX, e.clientY));
+        window.addEventListener('mouseup', handleEnd);
+        canvas.addEventListener('touchstart', e => { e.preventDefault(); handleStart(e.touches[0].clientX, e.touches[0].clientY); }, {passive:false});
+        canvas.addEventListener('touchmove', e => { e.preventDefault(); handleMove(e.touches[0].clientX, e.touches[0].clientY); }, {passive:false});
+        canvas.addEventListener('touchend', handleEnd);
+        // --- DRAWING ---
+        function drawCityFloor() {
+            ctx.fillStyle = COLORS.ground;
+            ctx.fillRect(0, 0, mapConfig.width, mapConfig.height);
+            for(let iy=0; iy<=GRID_SIZE; iy++) {
+                const y = iy * CELL_SIZE;
+                ctx.fillStyle = COLORS.road;
+                ctx.fillRect(0, y - ROAD_WIDTH/2, mapConfig.width, ROAD_WIDTH);
+                ctx.strokeStyle = COLORS.marking; ctx.lineWidth = 2; ctx.setLineDash([20, 20]);
+                ctx.beginPath(); ctx.moveTo(0, y); ctx.lineTo(mapConfig.width, y); ctx.stroke(); ctx.setLineDash([]);
+                for(let ix=0; ix<=GRID_SIZE; ix++) {
+                    const x = ix * CELL_SIZE; ctx.fillStyle = COLORS.crosswalk;
+                    for(let k=-ROAD_WIDTH/2; k<ROAD_WIDTH/2; k+=10) {
+                       ctx.fillRect(x - ROAD_WIDTH/2 - 10, y + k, 8, 5); ctx.fillRect(x + ROAD_WIDTH/2 + 2, y + k, 8, 5);
+                    }
+                }
+            }
+            for(let ix=0; ix<=GRID_SIZE; ix++) {
+                const x = ix * CELL_SIZE;
+                ctx.fillStyle = COLORS.road; ctx.fillRect(x - ROAD_WIDTH/2, 0, ROAD_WIDTH, mapConfig.height);
+                ctx.strokeStyle = COLORS.marking; ctx.lineWidth = 2; ctx.setLineDash([20, 20]);
+                ctx.beginPath(); ctx.moveTo(x, 0); ctx.lineTo(x, mapConfig.height); ctx.stroke(); ctx.setLineDash([]);
+                for(let iy=0; iy<=GRID_SIZE; iy++) {
+                    const y = iy * CELL_SIZE; ctx.fillStyle = COLORS.crosswalk;
+                    for(let k=-ROAD_WIDTH/2; k<ROAD_WIDTH/2; k+=10) {
+                       ctx.fillRect(x + k, y - ROAD_WIDTH/2 - 10, 5, 8); ctx.fillRect(x + k, y + ROAD_WIDTH/2 + 2, 5, 8);
+                    }
+                }
+            }
+        }
+        function drawBox(ctx, x, y, w, l, h, rotation, color, rx, ry, isFalling) {
+            const hw = w/2; const hl = l/2;
+            const b_tl = {x: -hw, y: -hl}; const b_tr = {x: hw, y: -hl};
+            const b_br = {x: hw, y: hl}; const b_bl = {x: -hw, y: hl};
+            const r_tl = {x: b_tl.x + rx, y: b_tl.y + ry}; const r_tr = {x: b_tr.x + rx, y: b_tr.y + ry};
+            const r_br = {x: b_br.x + rx, y: b_br.y + ry}; const r_bl = {x: b_bl.x + rx, y: b_bl.y + ry};
+            const drawFace = (p1, p2, p3, p4, c) => {
+                ctx.fillStyle = c; ctx.beginPath(); ctx.moveTo(p1.x, p1.y); ctx.lineTo(p2.x, p2.y);
+                ctx.lineTo(p3.x, p3.y); ctx.lineTo(p4.x, p4.y); ctx.closePath(); ctx.fill();
+            };
+            drawFace(b_tl, r_tl, r_tr, b_tr, color); drawFace(b_tr, r_tr, r_br, b_br, color);
+            drawFace(b_br, r_br, r_bl, b_bl, color); drawFace(b_bl, r_bl, r_tl, b_tl, color);
+            ctx.fillStyle = color; ctx.beginPath(); ctx.moveTo(r_tl.x, r_tl.y); ctx.lineTo(r_tr.x, r_tr.y);
+            ctx.lineTo(r_br.x, r_br.y); ctx.lineTo(r_bl.x, r_bl.y); ctx.closePath(); ctx.fill();
+            ctx.fillStyle = 'rgba(255,255,255,0.1)'; ctx.fill(); ctx.strokeStyle = 'rgba(0,0,0,0.1)'; ctx.lineWidth = 1; ctx.stroke();
+        }
+        function draw3DEntity(ent, falling) {
+            ctx.save(); ctx.translate(ent.x, ent.y);
+            const h = ent.h || 10; const TILT_FACTOR = 1.2; const PERSPECTIVE_X = 0.0003;
+            const rx_screen = (ent.x - camera.x) * (h * PERSPECTIVE_X);
+            const ry_screen = -h * TILT_FACTOR;
+            const ang = -(ent.rotation || 0);
+            const rx = rx_screen * Math.cos(ang) - ry_screen * Math.sin(ang);
+            const ry = rx_screen * Math.sin(ang) + ry_screen * Math.cos(ang);
+            if (ent.type === 'car') {
+                ctx.rotate(ent.rotation || 0);
+                if (!falling) {
+                    ctx.fillStyle = '#111';
+                    const wx = ent.w/2 - 8; const wy = ent.l/2;
+                    ctx.fillRect(wx, -wy-2, 6, 4); ctx.fillRect(wx, wy-2, 6, 4);
+                    ctx.fillRect(-wx, -wy-2, 6, 4); ctx.fillRect(-wx, wy-2, 6, 4);
+                }
+                drawBox(ctx, 0, 0, ent.w, ent.l, ent.h, 0, ent.color, rx, ry, falling);
+                const ch = ent.cabinH || 10;
+                const rx_screen_cab = (ent.x - camera.x) * (ch * PERSPECTIVE_X);
+                const ry_screen_cab = -ch * TILT_FACTOR;
+                const rx_cab = rx_screen_cab * Math.cos(ang) - ry_screen_cab * Math.sin(ang);
+                const ry_cab = rx_screen_cab * Math.sin(ang) + ry_screen_cab * Math.cos(ang);
+                ctx.translate(rx, ry);
+                const cw = ent.cabinW; const cl = ent.cabinL;
+                const hw = cw/2; const hl = cl/2;
+                const b_tl = {x: -hw, y: -hl}; const b_tr = {x: hw, y: -hl};
+                const b_br = {x: hw, y: hl}; const b_bl = {x: -hw, y: hl};
+                const r_tl = {x: b_tl.x + rx_cab, y: b_tl.y + ry_cab}; const r_tr = {x: b_tr.x + rx_cab, y: b_tr.y + ry_cab};
+                const r_br = {x: b_br.x + rx_cab, y: b_br.y + ry_cab}; const r_bl = {x: b_bl.x + rx_cab, y: b_bl.y + ry_cab};
+                const drawPoly = (pts, color) => {
+                    ctx.fillStyle = color; ctx.beginPath(); ctx.moveTo(pts[0].x, pts[0].y);
+                    for(let i=1; i<pts.length; i++) ctx.lineTo(pts[i].x, pts[i].y); ctx.closePath(); ctx.fill();
+                };
+                drawPoly([b_tl, r_tl, r_tr, b_tr], '#34495e'); drawPoly([b_tr, r_tr, r_br, b_br], '#34495e');
+                drawPoly([b_br, r_br, r_bl, b_bl], '#34495e'); drawPoly([b_bl, r_bl, r_tl, b_tl], '#34495e');
+                drawPoly([r_tl, r_tr, r_br, r_bl], '#34495e'); ctx.fillStyle = 'rgba(255,255,255,0.1)'; ctx.fill();
+            } else if (ent.type === 'building') {
+                ctx.rotate(ent.rotation || 0);
+                const w = ent.w; const l = ent.l; const hw = w/2; const hl = l/2;
+                const b_tl = {x: -hw, y: -hl}; const b_tr = {x: hw, y: -hl};
+                const b_br = {x: hw, y: hl}; const b_bl = {x: -hw, y: hl};
+                const r_tl = {x: b_tl.x + rx, y: b_tl.y + ry}; const r_tr = {x: b_tr.x + rx, y: b_tr.y + ry};
+                const r_br = {x: b_br.x + rx, y: b_br.y + ry}; const r_bl = {x: b_bl.x + rx, y: b_bl.y + ry};
+                const drawFace = (p1, p2, p3, p4, color, isSide) => {
+                    ctx.fillStyle = color; ctx.beginPath(); ctx.moveTo(p1.x, p1.y); ctx.lineTo(p2.x, p2.y);
+                    ctx.lineTo(p3.x, p3.y); ctx.lineTo(p4.x, p4.y); ctx.closePath(); ctx.fill();
+                };
+                const sideCol = ent.sideColor || ent.color;
+                drawFace(b_tl, r_tl, r_tr, b_tr, sideCol, false); drawFace(b_tr, r_tr, r_br, b_br, sideCol, true);
+                drawFace(b_br, r_br, r_bl, b_bl, sideCol, true); drawFace(b_bl, r_bl, r_tl, b_tl, sideCol, true);
+                ctx.fillStyle = ent.color; ctx.beginPath(); ctx.moveTo(r_tl.x, r_tl.y); ctx.lineTo(r_tr.x, r_tr.y);
+                ctx.lineTo(r_br.x, r_br.y); ctx.lineTo(r_bl.x, r_bl.y); ctx.closePath(); ctx.fill();
+                ctx.strokeStyle = 'rgba(255,255,255,0.2)'; ctx.lineWidth = 2; ctx.stroke();
+            } else {
+                const rx = (ent.x - camera.x) * (ent.h * PERSPECTIVE_X);
+                const ry = -ent.h * TILT_FACTOR;
+                ctx.fillStyle = 'rgba(0,0,0,0.2)'; ctx.beginPath(); ctx.arc(0,0, ent.r, 0, Math.PI*2); ctx.fill();
+                if(ent.type === 'rock') {
+                    ctx.fillStyle = ent.color; ctx.beginPath();
+                    ctx.moveTo(0, -ent.r + ry); ctx.lineTo(ent.r, 0 + ry);
+                    ctx.lineTo(0, ent.r + ry); ctx.lineTo(-ent.r, 0 + ry); ctx.fill();
+                } else if (ent.type === 'flower') {
+                    ctx.strokeStyle = '#27ae60'; ctx.lineWidth = 2;
+                    ctx.beginPath(); ctx.moveTo(0,0); ctx.lineTo(rx, ry); ctx.stroke();
+                    ctx.fillStyle = ent.color; ctx.beginPath(); ctx.arc(rx, ry, ent.r, 0, Math.PI*2); ctx.fill();
+                    ctx.fillStyle = 'yellow'; ctx.beginPath(); ctx.arc(rx, ry, ent.r/2, 0, Math.PI*2); ctx.fill();
+                } else if (ent.type === 'tree') {
+                   const layers = 4; ctx.strokeStyle = '#5d4037'; ctx.lineWidth = ent.r * 0.4;
+                   ctx.beginPath(); ctx.moveTo(0,0); ctx.lineTo(rx*0.5, ry*0.5); ctx.stroke();
+                   for(let i=0; i<layers; i++) {
+                       const ratio = i / (layers-1);
+                       const lrx = rx * (0.2 + ratio * 0.8); const lry = ry * (0.2 + ratio * 0.8);
+                       ctx.fillStyle = i % 2 === 0 ? ent.color : '#2ecc71';
+                       const size = ent.r * (1.2 - ratio * 0.4);
+                       ctx.beginPath(); ctx.arc(lrx, lry, size, 0, Math.PI*2); ctx.fill();
+                   }
+                } else {
+                    ctx.lineWidth = ent.r * 2; ctx.strokeStyle = ent.sideColor || ent.color; ctx.lineCap = 'round';
+                    ctx.beginPath(); ctx.moveTo(0,0); ctx.lineTo(rx, ry); ctx.stroke();
+                    ctx.fillStyle = ent.color; ctx.beginPath(); ctx.arc(rx, ry, ent.r, 0, Math.PI*2); ctx.fill();
+                }
+            }
+            ctx.restore();
+        }
+        function render() {
+            if (!socket) { requestAnimationFrame(render); return; }
+            ctx.fillStyle = '#111';
+            ctx.fillRect(0, 0, canvas.width, canvas.height);
+            const me = players.find(p => p.id === myId);
+            if (me) {
+                camera.x += (me.x - camera.x) * 0.1;
+                camera.y += (me.y - camera.y) * 0.1;
+                const targetZoom = Math.max(0.3, Math.min(1.0, 400 / (me.r * 2)));
+                camera.zoom += (targetZoom - camera.zoom) * 0.05;
+            }
+            ctx.save();
+            ctx.translate(canvas.width/2, canvas.height/2);
+            ctx.scale(camera.zoom, camera.zoom);
+            ctx.translate(-camera.x, -camera.y);
+            drawCityFloor();
+            // Draw Players
+            players.forEach(p => {
+                if(!p.alive) return;
+                ctx.beginPath(); ctx.arc(p.x, p.y, p.r, 0, Math.PI*2);
+                ctx.fillStyle = 'black'; ctx.fill();
+                ctx.strokeStyle = p.color; ctx.lineWidth = 4; ctx.stroke();
+                ctx.fillStyle = 'white'; ctx.font = `bold ${Math.max(14, p.r/2)}px Arial`;
+                ctx.textAlign = 'center'; ctx.fillText(p.username, p.x, p.y - p.r - 10);
+            });
+            // Clip holes
+            ctx.save();
+            ctx.beginPath();
+            ctx.rect(camera.x - (canvas.width/camera.zoom), camera.y - (canvas.height/camera.zoom), canvas.width*2/camera.zoom, canvas.height*2/camera.zoom);
+            players.forEach(p => { if(p.alive) { ctx.moveTo(p.x, p.y); ctx.arc(p.x, p.y, p.r, 0, Math.PI*2, true); } });
+            ctx.clip();
+            // Draw Ents
+            const viewW = (canvas.width / camera.zoom) / 2 + 200;
+            const viewH = (canvas.height / camera.zoom) / 2 + 200;
+            const visibleStatic = staticEntities.filter(e => Math.abs(e.x - camera.x) < viewW && Math.abs(e.y - camera.y) < viewH);
+            const allEnts = [...visibleStatic, ...cars];
+            allEnts.sort((a,b) => (a.y + (a.l||0)/2) - (b.y + (b.l||0)/2));
+            allEnts.forEach(ent => draw3DEntity(ent, false));
+            ctx.restore(); ctx.restore();
+            // Joystick
+            if (input.active) {
+                ctx.beginPath(); ctx.arc(input.startX, input.startY, 50, 0, Math.PI*2);
+                ctx.strokeStyle = 'rgba(255,255,255,0.2)'; ctx.lineWidth = 2; ctx.stroke();
+                ctx.beginPath(); ctx.arc(input.currX, input.currY, 20, 0, Math.PI*2);
+                ctx.fillStyle = 'rgba(255,255,255,0.4)'; ctx.fill();
+            }
+            requestAnimationFrame(render);
+        }
+        function updateUI() {
+            const sb = document.getElementById('scoreBoard');
+            const sorted = [...players].sort((a,b) => b.score - a.score).slice(0, 5);
+            sb.innerHTML = sorted.map(p => `
+                <div class="score-row">
+                    ${p.avatar ? `<img src="${p.avatar}" class="lb-avatar">` : ''}
+                    ${p.username}: ${p.score}
+                </div>
+            `).join('');
+        }
+        render();
+    </script>
+</body>
+</html>

main.py ADDED Viewed

	@@ -0,0 +1,405 @@

+import os
+import json
+import asyncio
+import math
+import uuid
+import random
+import time
+from collections import defaultdict
+from aiohttp import web, ClientSession
+import socketio
+# --- CONFIGURATION ---
+PORT = int(os.getenv('SERVER_PORT', 8080))
+ADMIN_PATH = os.getenv('ADMIN_PATH', '/secret-admin-panel')
+# !!! REPLACE WITH YOUR DISCORD APP DETAILS !!!
+DISCORD_CLIENT_ID = "1457974183383535649"
+DISCORD_CLIENT_SECRET = "_RoLp-VIb1nC7IOlZd_zvPWHnG4cNMbB"
+DISCORD_REDIRECT_URI = "http://212.227.65.132:15080/callback"
+GAME_TICK_RATE = 30
+GRID_SIZE = 8
+BLOCK_SIZE = 280
+ROAD_WIDTH = 90
+CELL_SIZE = BLOCK_SIZE + ROAD_WIDTH
+MAP_WIDTH = GRID_SIZE * CELL_SIZE
+MAP_HEIGHT = GRID_SIZE * CELL_SIZE
+# --- ASSET DEFINITIONS ---
+ENTITY_TYPES = {
+    'ROCK':    {'r': 8, 'h': 8, 'color': '#7f8c8d', 'score': 1, 'type': 'rock'},
+    'FLOWER':  {'r': 6, 'h': 4, 'color': '#e84393', 'score': 1, 'type': 'flower'},
+    'FENCE':   {'w': 20, 'l': 4, 'h': 10, 'color': '#8e44ad', 'score': 1, 'type': 'building'},
+    'HYDRANT': {'r': 6, 'h': 12, 'color': '#e74c3c', 'sideColor': '#c0392b', 'score': 1, 'type': 'cylinder'},
+    'POST':    {'r': 4, 'h': 40, 'color': '#bdc3c7', 'sideColor': '#7f8c8d', 'score': 2, 'type': 'cylinder'},
+    'BUSH':    {'r': 12, 'h': 10, 'color': '#2ecc71', 'score': 3, 'type': 'bush'},
+    'TREE':    {'r': 18, 'h': 70, 'color': '#27ae60', 'score': 5, 'type': 'tree'},
+    'CAR':     {'w': 48, 'l': 24, 'h': 12, 'cabinW': 28, 'cabinL': 20, 'cabinH': 10, 'color': '#e74c3c', 'score': 10, 'type': 'car', 'mobile': True},
+    'HOUSE_S': {'w': 70, 'l': 70, 'h': 60, 'color': '#e67e22', 'sideColor': '#d35400', 'score': 50, 'type': 'building', 'windows': True},
+    'HOUSE_M': {'w': 100, 'l': 90, 'h': 90, 'color': '#3498db', 'sideColor': '#2980b9', 'score': 100, 'type': 'building', 'windows': True},
+    'OFFICE':  {'w': 110, 'l': 110, 'h': 160, 'color': '#9b59b6', 'sideColor': '#8e44ad', 'score': 200, 'type': 'building', 'windows': True},
+    'TOWER':   {'w': 130, 'l': 130, 'h': 280, 'color': '#34495e', 'sideColor': '#2c3e50', 'score': 300, 'type': 'building', 'windows': True}
+}
+sio = socketio.AsyncServer(async_mode='aiohttp', cors_allowed_origins='*')
+app = web.Application()
+sio.attach(app)
+class GameState:
+    def __init__(self):
+        self.players = {}
+        self.sockets = {}
+        self.static_entities = []
+        # Spatial Hash Grid for Static Entities: key=(gridX, gridY), val=[entities]
+        self.static_grid = defaultdict(list)
+        self.dynamic_entities = []
+        self.removed_entities = []
+        self.active = True
+        self.user_data_file = 'user_data.json'
+        self.persistent_data = self.load_data()
+        self.generate_map()
+    def load_data(self):
+        if os.path.exists(self.user_data_file):
+            try:
+                with open(self.user_data_file, 'r') as f: return json.load(f)
+            except: return {}
+        return {}
+    def save_data(self):
+        with open(self.user_data_file, 'w') as f:
+            json.dump(self.persistent_data, f, indent=2)
+    def generate_map(self):
+        self.static_entities = []
+        self.static_grid.clear()
+        self.dynamic_entities = []
+        # Grid Generation
+        for ix in range(GRID_SIZE + 1):
+            for iy in range(GRID_SIZE + 1):
+                x = ix * CELL_SIZE
+                y = iy * CELL_SIZE
+                if ix < GRID_SIZE and iy < GRID_SIZE:
+                    self.generate_block(x + ROAD_WIDTH/2, y + ROAD_WIDTH/2)
+        # Car Generation
+        lane_offset = ROAD_WIDTH / 4
+        for _ in range(60):
+            self.spawn_car(lane_offset)
+    def add_entity(self, x, y, template, **kwargs):
+        ent = template.copy()
+        ent.update(kwargs)
+        ent['x'] = x
+        ent['y'] = y
+        ent['id'] = str(uuid.uuid4())
+        ent['startX'] = x
+        ent['startY'] = y
+        ent['varSeed'] = random.random()
+        ent['rotation'] = kwargs.get('rotation', 0)
+        if ent['type'] in ['building', 'car']:
+            ent['radius'] = math.hypot(ent['w']/2, ent.get('l', ent['w'])/2)
+        else:
+            ent['radius'] = ent['r']
+        if ent['type'] == 'flower':
+            ent['color'] = random.choice(['#e84393', '#fd79a8', '#00b894', '#fab1a0'])
+        # Add to main list AND spatial grid
+        self.static_entities.append(ent)
+        gx = int(x // CELL_SIZE)
+        gy = int(y // CELL_SIZE)
+        self.static_grid[(gx, gy)].append(ent)
+    def get_nearby_static(self, x, y):
+        # Return entities in the 3x3 grid cells around the point
+        gx = int(x // CELL_SIZE)
+        gy = int(y // CELL_SIZE)
+        nearby = []
+        for ix in range(gx - 1, gx + 2):
+            for iy in range(gy - 1, gy + 2):
+                nearby.extend(self.static_grid[(ix, iy)])
+        return nearby
+    def generate_block(self, bx, by):
+        cx = bx + BLOCK_SIZE/2
+        cy = by + BLOCK_SIZE/2
+        b_type = random.random()
+        if b_type < 0.2: # Park
+            inset = 10
+            sz = BLOCK_SIZE - inset*2
+            for k in range(0, int(sz), 25):
+                self.add_entity(bx + inset + k, by + inset, ENTITY_TYPES['FENCE'])
+                self.add_entity(bx + inset + k, by + BLOCK_SIZE - inset, ENTITY_TYPES['FENCE'])
+            for k in range(0, int(sz), 25):
+                self.add_entity(bx + inset, by + inset + k, ENTITY_TYPES['FENCE'], w=5, l=20)
+                self.add_entity(bx + BLOCK_SIZE - inset, by + inset + k, ENTITY_TYPES['FENCE'], w=5, l=20)
+            for _ in range(10):
+                ox = random.random() * (sz-40) + 20
+                oy = random.random() * (sz-40) + 20
+                tmpl = ENTITY_TYPES['TREE'] if random.random() > 0.6 else ENTITY_TYPES['FLOWER']
+                self.add_entity(bx+inset+ox, by+inset+oy, tmpl)
+            self.add_entity(cx, cy, ENTITY_TYPES['HYDRANT'])
+        elif b_type < 0.6: # Residential
+            q = BLOCK_SIZE/4
+            self.add_entity(cx - q, cy - q, ENTITY_TYPES['HOUSE_S'])
+            self.add_entity(cx + q, cy - q, ENTITY_TYPES['HOUSE_M'])
+            self.add_entity(cx - q, cy + q, ENTITY_TYPES['HOUSE_M'])
+            self.add_entity(cx + q, cy + q, ENTITY_TYPES['HOUSE_S'])
+            self.add_entity(cx, cy, ENTITY_TYPES['TREE'])
+            self.add_entity(bx + 10, cy, ENTITY_TYPES['BUSH'])
+            self.add_entity(bx + BLOCK_SIZE - 10, cy, ENTITY_TYPES['BUSH'])
+        else: # Downtown
+            if random.random() > 0.5:
+                self.add_entity(cx, cy, ENTITY_TYPES['TOWER'])
+            else:
+                self.add_entity(cx - 50, cy, ENTITY_TYPES['OFFICE'])
+                self.add_entity(cx + 50, cy, ENTITY_TYPES['OFFICE'])
+            self.add_entity(bx + 20, by + 20, ENTITY_TYPES['POST'])
+            self.add_entity(bx + BLOCK_SIZE - 20, by + 20, ENTITY_TYPES['POST'])
+            self.add_entity(bx + 20, by + BLOCK_SIZE - 20, ENTITY_TYPES['POST'])
+            self.add_entity(bx + BLOCK_SIZE - 20, by + BLOCK_SIZE - 20, ENTITY_TYPES['POST'])
+    def spawn_car(self, offset):
+        orient = 0 if random.random() > 0.5 else 1
+        if orient == 0:
+            iy = random.randint(0, GRID_SIZE)
+            y = iy * CELL_SIZE
+            x = random.random() * MAP_WIDTH
+            dir = 1 if random.random() > 0.5 else -1
+            y += dir * offset
+            rot = 0 if dir == 1 else math.pi
+        else:
+            ix = random.randint(0, GRID_SIZE)
+            x = ix * CELL_SIZE
+            y = random.random() * MAP_HEIGHT
+            dir = 1 if random.random() > 0.5 else -1
+            x += dir * offset
+            rot = math.pi/2 if dir == 1 else -math.pi/2
+        car = ENTITY_TYPES['CAR'].copy()
+        car.update({
+            'x': x, 'y': y, 'rotation': rot, 'id': str(uuid.uuid4()),
+            'radius': math.hypot(24, 12), 'type': 'car', 'mobile': True,
+            'color': random.choice(['#e74c3c', '#3498db', '#f1c40f', '#ecf0f1', '#2c3e50'])
+        })
+        self.dynamic_entities.append(car)
+    def add_player(self, session_id, user_info):
+        saved = self.persistent_data.get(session_id, {})
+        self.players[session_id] = {
+            'id': session_id,
+            'discord_id': user_info['id'],
+            'username': user_info['username'],
+            'avatar': f"https://cdn.discordapp.com/avatars/{user_info['id']}/{user_info['avatar']}.png" if user_info['avatar'] else "",
+            'x': random.random() * MAP_WIDTH,
+            'y': random.random() * MAP_HEIGHT,
+            'r': saved.get('r', 35),
+            'target_r': saved.get('r', 35),
+            'score': saved.get('score', 0),
+            'color': '#3498db',
+            'input_angle': 0, 'input_force': 0, 'vx': 0, 'vy': 0,
+            'alive': True, 'respawn_timer': 0
+        }
+        if session_id not in self.persistent_data:
+            self.persistent_data[session_id] = {'r': 35, 'score': 0, 'username': user_info['username']}
+            self.save_data()
+    def update(self, dt):
+        if not self.active: return
+        self.removed_entities = []
+        sorted_players = sorted(self.players.values(), key=lambda p: p['r'], reverse=True)
+        for p in sorted_players:
+            if not p['alive']:
+                p['respawn_timer'] -= dt
+                if p['respawn_timer'] <= 0:
+                    p['alive'] = True
+                    p['r'] = 35; p['target_r'] = 35; p['score'] = 0
+                    p['x'] = random.random() * MAP_WIDTH
+                    p['y'] = random.random() * MAP_HEIGHT
+                continue
+            speed = 180 * (1 - (p['r'] / 800))
+            p['vx'] = math.cos(p['input_angle']) * p['input_force'] * speed
+            p['vy'] = math.sin(p['input_angle']) * p['input_force'] * speed
+            p['x'] = max(p['r'], min(MAP_WIDTH - p['r'], p['x'] + p['vx'] * dt))
+            p['y'] = max(p['r'], min(MAP_HEIGHT - p['r'], p['y'] + p['vy'] * dt))
+            if p['r'] < p['target_r']: p['r'] += (p['target_r'] - p['r']) * dt
+            # Eat Static (OPTIMIZED: Use Spatial Hash)
+            nearby_static = self.get_nearby_static(p['x'], p['y'])
+            for ent in nearby_static:
+                # Basic check before expensive sqrt
+                if abs(p['x'] - ent['x']) > p['r'] or abs(p['y'] - ent['y']) > p['r']: continue
+                dist = math.hypot(p['x'] - ent['x'], p['y'] - ent['y'])
+                if dist < p['r'] and p['r'] > ent['radius']:
+                    self.static_entities.remove(ent)
+                    # Also remove from grid for consistency (slow, but eats are rare compared to frames)
+                    gx, gy = int(ent['x']//CELL_SIZE), int(ent['y']//CELL_SIZE)
+                    if ent in self.static_grid[(gx, gy)]:
+                         self.static_grid[(gx, gy)].remove(ent)
+                    self.removed_entities.append(ent['id'])
+                    p['score'] += ent['score']
+                    p['target_r'] += math.sqrt(ent['score']) * 0.3
+            # Eat Cars
+            for car in self.dynamic_entities:
+                dist = math.hypot(p['x'] - car['x'], p['y'] - car['y'])
+                if dist < p['r'] and p['r'] > car['radius']:
+                    p['score'] += car['score']
+                    p['target_r'] += math.sqrt(car['score']) * 0.3
+                    car['x'] = random.randint(0, GRID_SIZE) * CELL_SIZE
+                    car['y'] = random.random() * MAP_HEIGHT
+                    self.removed_entities.append(car['id'])
+            # Eat Players
+            for other in sorted_players:
+                if p == other or not other['alive']: continue
+                dist = math.hypot(p['x'] - other['x'], p['y'] - other['y'])
+                if p['r'] > other['r'] * 1.1 and dist < p['r'] - other['r']*0.4:
+                    other['alive'] = False
+                    other['respawn_timer'] = 5
+                    p['score'] += 50 + other['score'] * 0.5
+                    p['target_r'] += 5
+                    self.persistent_data[p['id']]['score'] = p['score']
+                    self.persistent_data[p['id']]['r'] = p['target_r']
+                    self.persistent_data[other['id']]['score'] = 0
+                    self.persistent_data[other['id']]['r'] = 35
+                    self.save_data()
+        # Update Cars
+        for car in self.dynamic_entities:
+            speed = 150
+            car['x'] += math.cos(car['rotation']) * speed * dt
+            car['y'] += math.sin(car['rotation']) * speed * dt
+            if car['x'] > MAP_WIDTH: car['x'] = 0
+            if car['x'] < 0: car['x'] = MAP_WIDTH
+            if car['y'] > MAP_HEIGHT: car['y'] = 0
+            if car['y'] < 0: car['y'] = MAP_HEIGHT
+game = GameState()
+# --- WEB HANDLERS ---
+async def handle_index(request): return web.FileResponse('./index.html')
+async def handle_admin(request): return web.FileResponse('./admin.html')
+async def handle_login(request):
+    return web.HTTPFound(f"https://discord.com/api/oauth2/authorize?client_id={DISCORD_CLIENT_ID}&redirect_uri={DISCORD_REDIRECT_URI}&response_type=code&scope=identify")
+async def handle_callback(request):
+    code = request.query.get('code')
+    if not code: return web.Response(text="No code")
+    async with ClientSession() as s:
+        data = {'client_id': DISCORD_CLIENT_ID, 'client_secret': DISCORD_CLIENT_SECRET, 'grant_type': 'authorization_code', 'code': code, 'redirect_uri': DISCORD_REDIRECT_URI}
+        async with s.post('https://discord.com/api/oauth2/token', data=data) as r:
+            token_data = await r.json()
+            if 'access_token' not in token_data: return web.Response(text="Auth failed")
+        headers = {'Authorization': f"Bearer {token_data['access_token']}"}
+        async with s.get('https://discord.com/api/users/@me', headers=headers) as r:
+            user_data = await r.json()
+    sid = str(uuid.uuid4())
+    game.add_player(sid, user_data)
+    # Broadcast new player metadata to everyone
+    p = game.players[sid]
+    meta = {'id': p['id'], 'username': p['username'], 'avatar': p['avatar'], 'color': p['color']}
+    await sio.emit('player_joined', meta)
+    return web.HTTPFound(f"/?token={sid}")
+app.router.add_get('/', handle_index)
+app.router.add_get('/login', handle_login)
+app.router.add_get('/callback', handle_callback)
+app.router.add_get(ADMIN_PATH, handle_admin)
+@sio.event
+async def connect(sid, environ, auth):
+    token = auth.get('token') if auth else None
+    if not token or token not in game.players: return False
+    game.sockets[sid] = token
+    # Send Static Info (Map + All Player Metadata)
+    all_players_meta = [
+        {'id': p['id'], 'username': p['username'], 'avatar': p['avatar'], 'color': p['color']}
+        for p in game.players.values()
+    ]
+    await sio.emit('init_game', {
+        'width': MAP_WIDTH, 'height': MAP_HEIGHT,
+        'static_entities': game.static_entities,
+        'players_meta': all_players_meta
+    }, to=sid)
+@sio.event
+async def disconnect(sid):
+    if sid in game.sockets:
+        pid = game.sockets[sid]
+        del game.sockets[sid]
+        await sio.emit('player_left', {'id': pid})
+@sio.event
+async def input_data(sid, data):
+    if sid in game.sockets:
+        p = game.players[game.sockets[sid]]
+        p['input_angle'] = data.get('angle', 0)
+        p['input_force'] = min(max(data.get('force', 0), 0), 1)
+@sio.event
+async def admin_cmd(sid, data):
+    cmd = data.get('cmd')
+    if cmd == 'start_tournament':
+        game.active = True
+        game.generate_map()
+        for p in game.players.values():
+             p['r'] = 35; p['target_r'] = 35; p['score'] = 0; p['alive'] = True
+             p['x'] = random.random() * MAP_WIDTH; p['y'] = random.random() * MAP_HEIGHT
+        await sio.emit('tournament_reset', {'static_entities': game.static_entities})
+    elif cmd == 'stop_tournament':
+        game.active = False
+        res = [{'username': p['username'], 'score': int(p['score']), 'avatar': p['avatar']} for p in game.players.values()]
+        await sio.emit('tournament_end', {'results': sorted(res, key=lambda x: x['score'], reverse=True)})
+async def game_loop():
+    while True:
+        start = time.time()
+        if game.active:
+            game.update(1/GAME_TICK_RATE)
+            # OPTIMIZED PACKET: Strip static data (avatar, username, color, car dimensions)
+            # Only send dynamic data (id, x, y, r, score, alive)
+            state = {
+                'players': [
+                    {'id': p['id'], 'x': int(p['x']), 'y': int(p['y']), 'r': int(p['r']),
+                     'alive': p['alive'], 'score': int(p['score'])}
+                    for p in game.players.values() if p['alive']
+                ],
+                'cars': [
+                    {'id': c['id'], 'x': int(c['x']), 'y': int(c['y']), 'rotation': round(c['rotation'], 2),
+                     'color': c['color'], 'w': c['w'], 'l': c['l'], 'h': c['h'], # Keep car static for now as they respawn often
+                     'cabinW': c.get('cabinW'), 'cabinL': c.get('cabinL'), 'type': 'car'}
+                    for c in game.dynamic_entities
+                ],
+                'removed': game.removed_entities
+            }
+            await sio.emit('game_update', state)
+        await asyncio.sleep(max(0, (1/GAME_TICK_RATE) - (time.time() - start)))
+async def init_app():
+    asyncio.create_task(game_loop())
+    return app
+if __name__ == '__main__':
+    web.run_app(init_app(), port=PORT)

requirements.txt ADDED Viewed

	@@ -0,0 +1,2 @@


1	+ aiohttp==3.9.3
2	+ python-socketio==5.11.1