diff --git a/cs2-browser/index.html b/cs2-browser/index.html
new file mode 100644
index 0000000..81158b8
--- /dev/null
+++ b/cs2-browser/index.html
@@ -0,0 +1,1564 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>CS2 — Browser Edition</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body { overflow: hidden; background: #000; font-family: 'Segoe UI', 'Stratum2', Arial, sans-serif; }
+        canvas { display: block; }
+
+        /* --- MAIN MENU --- */
+        #mainMenu {
+            position: fixed; inset: 0; z-index: 1000;
+            background: linear-gradient(135deg, #0a0e17 0%, #131a2b 40%, #1a1a2e 100%);
+            display: flex; flex-direction: column; align-items: center; justify-content: center;
+            color: #e0e0e0;
+        }
+        #mainMenu .logo {
+            font-size: 72px; font-weight: 900; letter-spacing: 6px;
+            color: #f0c040; text-shadow: 0 0 40px rgba(240,192,64,0.4);
+            margin-bottom: 8px;
+        }
+        #mainMenu .subtitle {
+            font-size: 16px; color: #8899aa; letter-spacing: 4px; margin-bottom: 60px;
+        }
+        #mainMenu button {
+            display: block; width: 320px; padding: 16px 0; margin: 8px;
+            background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.1);
+            color: #ccd; font-size: 16px; letter-spacing: 2px; cursor: pointer;
+            transition: all 0.2s;
+        }
+        #mainMenu button:hover {
+            background: rgba(240,192,64,0.15); border-color: #f0c040; color: #f0c040;
+        }
+
+        /* --- HUD --- */
+        #hud {
+            position: fixed; inset: 0; z-index: 100; pointer-events: none;
+            display: none;
+        }
+        #crosshair {
+            position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);
+            width: 24px; height: 24px;
+        }
+        #crosshair .ch { position: absolute; background: #0f0; }
+        #crosshair .ch-t { width: 2px; height: 8px; top: 0; left: 11px; }
+        #crosshair .ch-b { width: 2px; height: 8px; bottom: 0; left: 11px; }
+        #crosshair .ch-l { width: 8px; height: 2px; left: 0; top: 11px; }
+        #crosshair .ch-r { width: 8px; height: 2px; right: 0; top: 11px; }
+
+        /* Bottom HUD bar */
+        #hudBottom {
+            position: absolute; bottom: 0; left: 0; right: 0; height: 80px;
+            display: flex; justify-content: space-between; align-items: center;
+            padding: 0 20px;
+        }
+        .hud-panel {
+            background: rgba(0,0,0,0.65); border-radius: 4px; padding: 8px 16px;
+            color: #fff; font-size: 14px; display: flex; align-items: center; gap: 12px;
+        }
+        .hud-panel .big { font-size: 32px; font-weight: 700; }
+        .hud-panel .label { font-size: 11px; color: #999; text-transform: uppercase; }
+
+        #healthPanel .health-icon { color: #4f4; font-size: 24px; }
+        #healthPanel .health-val { color: #4f4; }
+        #armorPanel .armor-icon { color: #4af; font-size: 24px; }
+        #armorPanel .armor-val { color: #4af; }
+        #ammoPanel .ammo-cur { color: #fc4; }
+        #ammoPanel .ammo-sep { color: #666; margin: 0 4px; font-size: 24px; }
+        #ammoPanel .ammo-res { color: #999; font-size: 20px; }
+
+        /* Top HUD */
+        #hudTop {
+            position: absolute; top: 0; left: 0; right: 0; height: 48px;
+            display: flex; justify-content: center; align-items: center;
+        }
+        #roundTimer {
+            background: rgba(0,0,0,0.7); padding: 8px 24px; border-radius: 0 0 8px 8px;
+            color: #fff; font-size: 24px; font-weight: 700; letter-spacing: 2px;
+        }
+        #teamScores {
+            position: absolute; top: 0; width: 100%;
+            display: flex; justify-content: center; gap: 40px; padding-top: 8px;
+        }
+        .team-score {
+            font-size: 28px; font-weight: 700; padding: 4px 20px;
+            border-radius: 4px;
+        }
+        .team-ct { color: #5ac; background: rgba(90,170,204,0.15); }
+        .team-t { color: #da4; background: rgba(221,170,68,0.15); }
+
+        /* Money */
+        #moneyDisplay {
+            position: absolute; top: 56px; right: 20px;
+            color: #4c4; font-size: 18px; font-weight: 700;
+        }
+
+        /* Kill feed */
+        #killFeed {
+            position: absolute; top: 60px; right: 20px;
+            display: flex; flex-direction: column; gap: 4px; align-items: flex-end;
+        }
+        .kill-entry {
+            background: rgba(0,0,0,0.6); padding: 4px 12px; border-radius: 4px;
+            font-size: 13px; color: #ccc; animation: fadeKill 4s forwards;
+        }
+        .kill-entry .killer { color: #5ac; }
+        .kill-entry .victim { color: #da4; }
+        .kill-entry .weapon { color: #888; margin: 0 8px; }
+        @keyframes fadeKill { 0%{opacity:1} 80%{opacity:1} 100%{opacity:0} }
+
+        /* Weapon display */
+        #weaponName {
+            position: absolute; bottom: 90px; right: 20px;
+            color: #999; font-size: 13px; letter-spacing: 1px;
+        }
+
+        /* Hit marker */
+        #hitMarker {
+            position: absolute; top: 50%; left: 50%; transform: translate(-50%,-50%);
+            width: 20px; height: 20px; opacity: 0; transition: opacity 0.1s;
+        }
+        #hitMarker.show { opacity: 1; }
+        #hitMarker .hm { position: absolute; background: #fff; }
+        #hitMarker .hm1 { width: 2px; height: 8px; transform: rotate(45deg); top: 0; left: 12px; }
+        #hitMarker .hm2 { width: 2px; height: 8px; transform: rotate(-45deg); top: 0; right: 12px; }
+        #hitMarker .hm3 { width: 2px; height: 8px; transform: rotate(45deg); bottom: 0; right: 12px; }
+        #hitMarker .hm4 { width: 2px; height: 8px; transform: rotate(-45deg); bottom: 0; left: 12px; }
+
+        /* Damage overlay */
+        #damageOverlay {
+            position: absolute; inset: 0;
+            border: 0px solid rgba(255,0,0,0);
+            pointer-events: none; transition: border 0.1s;
+        }
+        #damageOverlay.hit { border: 20px solid rgba(255,0,0,0.3); }
+
+        /* Buy menu */
+        #buyMenu {
+            position: fixed; inset: 0; z-index: 200;
+            background: rgba(0,0,0,0.85);
+            display: none; flex-direction: column; align-items: center; justify-content: center;
+            pointer-events: all;
+        }
+        #buyMenu h2 { color: #f0c040; font-size: 28px; margin-bottom: 24px; letter-spacing: 3px; }
+        #buyMenu .buy-grid {
+            display: grid; grid-template-columns: repeat(3, 200px); gap: 12px;
+        }
+        #buyMenu .buy-item {
+            background: rgba(255,255,255,0.05); border: 1px solid rgba(255,255,255,0.1);
+            padding: 16px; cursor: pointer; transition: all 0.2s; text-align: center;
+        }
+        #buyMenu .buy-item:hover {
+            background: rgba(240,192,64,0.15); border-color: #f0c040;
+        }
+        #buyMenu .buy-item .item-name { color: #ddd; font-size: 14px; margin-bottom: 4px; }
+        #buyMenu .buy-item .item-price { color: #4c4; font-size: 13px; }
+        #buyMenu .buy-close { color: #888; margin-top: 20px; font-size: 13px; }
+
+        /* Scoreboard */
+        #scoreboard {
+            position: fixed; inset: 0; z-index: 200;
+            background: rgba(0,0,0,0.85);
+            display: none; flex-direction: column; align-items: center; justify-content: center;
+            pointer-events: none;
+        }
+        #scoreboard h2 { color: #f0c040; font-size: 24px; margin-bottom: 16px; }
+        #scoreboard table {
+            border-collapse: collapse; min-width: 500px;
+        }
+        #scoreboard th {
+            color: #888; font-size: 12px; text-transform: uppercase; padding: 8px 16px;
+            text-align: left; border-bottom: 1px solid #333;
+        }
+        #scoreboard td {
+            color: #ddd; font-size: 14px; padding: 8px 16px; border-bottom: 1px solid #222;
+        }
+
+        /* Round announcements */
+        #announcement {
+            position: absolute; top: 30%; left: 50%; transform: translate(-50%,-50%);
+            font-size: 36px; font-weight: 700; color: #f0c040;
+            text-shadow: 0 0 20px rgba(240,192,64,0.5);
+            opacity: 0; transition: opacity 0.5s;
+            text-align: center;
+        }
+        #announcement.show { opacity: 1; }
+
+        /* Death screen */
+        #deathScreen {
+            position: absolute; inset: 0;
+            background: rgba(100,0,0,0.3);
+            display: none; align-items: center; justify-content: center;
+            flex-direction: column;
+        }
+        #deathScreen .death-text {
+            font-size: 48px; color: #ff4444; font-weight: 700;
+        }
+        #deathScreen .death-sub {
+            font-size: 16px; color: #cc8888; margin-top: 8px;
+        }
+
+        /* Radar */
+        #radar {
+            position: absolute; top: 12px; left: 12px;
+            width: 160px; height: 160px;
+            background: rgba(0,0,0,0.6); border: 1px solid rgba(255,255,255,0.15);
+            border-radius: 4px;
+        }
+        #radarCanvas { width: 160px; height: 160px; }
+
+        /* Weapon view model hint */
+        #weaponViewModel {
+            position: absolute; bottom: 0; right: 0;
+            width: 350px; height: 250px;
+            pointer-events: none;
+        }
+    </style>
+</head>
+<body>
+    <!-- Main Menu -->
+    <div id="mainMenu">
+        <div class="logo">COUNTER-STRIKE 2</div>
+        <div class="subtitle">BROWSER EDITION</div>
+        <button onclick="startGame('deathmatch')">DEATHMATCH</button>
+        <button onclick="startGame('competitive')">COMPETITIVE</button>
+        <button onclick="showSettings()">SETTINGS</button>
+    </div>
+
+    <!-- HUD -->
+    <div id="hud">
+        <!-- Crosshair -->
+        <div id="crosshair">
+            <div class="ch ch-t"></div>
+            <div class="ch ch-b"></div>
+            <div class="ch ch-l"></div>
+            <div class="ch ch-r"></div>
+        </div>
+
+        <!-- Hit Marker -->
+        <div id="hitMarker">
+            <div class="hm hm1"></div>
+            <div class="hm hm2"></div>
+            <div class="hm hm3"></div>
+            <div class="hm hm4"></div>
+        </div>
+
+        <!-- Damage overlay -->
+        <div id="damageOverlay"></div>
+
+        <!-- Top HUD -->
+        <div id="hudTop">
+            <div id="teamScores">
+                <div class="team-score team-ct" id="ctScore">0</div>
+                <div id="roundTimer">1:55</div>
+                <div class="team-score team-t" id="tScore">0</div>
+            </div>
+        </div>
+
+        <!-- Money -->
+        <div id="moneyDisplay">$800</div>
+
+        <!-- Kill Feed -->
+        <div id="killFeed"></div>
+
+        <!-- Radar -->
+        <div id="radar">
+            <canvas id="radarCanvas" width="160" height="160"></canvas>
+        </div>
+
+        <!-- Weapon name -->
+        <div id="weaponName">AK-47</div>
+
+        <!-- Bottom HUD -->
+        <div id="hudBottom">
+            <div class="hud-panel" id="healthPanel">
+                <span class="health-icon">+</span>
+                <div>
+                    <div class="big health-val" id="healthVal">100</div>
+                </div>
+                <div style="margin-left:16px">
+                    <span class="armor-icon">🛡</span>
+                </div>
+                <div>
+                    <div class="big armor-val" id="armorVal">0</div>
+                </div>
+            </div>
+            <div class="hud-panel" id="ammoPanel">
+                <div>
+                    <span class="big ammo-cur" id="ammoCur">30</span>
+                    <span class="ammo-sep">/</span>
+                    <span class="ammo-res" id="ammoRes">90</span>
+                </div>
+            </div>
+        </div>
+
+        <!-- Announcements -->
+        <div id="announcement"></div>
+
+        <!-- Death Screen -->
+        <div id="deathScreen">
+            <div class="death-text">YOU DIED</div>
+            <div class="death-sub">Respawning...</div>
+        </div>
+    </div>
+
+    <!-- Buy Menu -->
+    <div id="buyMenu">
+        <h2>BUY MENU</h2>
+        <div class="buy-grid" id="buyGrid"></div>
+        <div class="buy-close">Press [B] to close</div>
+    </div>
+
+    <!-- Scoreboard -->
+    <div id="scoreboard">
+        <h2>SCOREBOARD</h2>
+        <table id="scoreTable">
+            <thead><tr><th>Player</th><th>K</th><th>D</th><th>Score</th></tr></thead>
+            <tbody id="scoreBody"></tbody>
+        </table>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script>
+    /* ================================================================
+       CS2 BROWSER EDITION — Full Implementation
+       ================================================================ */
+
+    // ---- GLOBALS ----
+    let scene, camera, renderer, clock;
+    let player, bots = [], bullets = [];
+    let walls = [], floors = [];
+    let gameState = 'menu'; // menu, playing, dead, buyPhase
+    let gameMode = 'deathmatch';
+    let isPointerLocked = false;
+    let moveState = { forward: false, backward: false, left: false, right: false, jump: false, crouch: false };
+    let velocity = new THREE.Vector3();
+    let playerOnGround = true;
+    let yaw = 0, pitch = 0;
+    let mouseSensitivity = 0.002;
+
+    // Weapon state
+    const weapons = {
+        knife: { name: 'Knife', damage: 40, fireRate: 0.8, ammo: Infinity, maxAmmo: Infinity, reloadTime: 0, spread: 0, auto: false, price: 0, range: 3 },
+        glock: { name: 'Glock-18', damage: 23, fireRate: 0.15, ammo: 20, maxAmmo: 120, reloadTime: 2.2, spread: 0.03, auto: false, price: 200, range: 200 },
+        usp: { name: 'USP-S', damage: 28, fireRate: 0.17, ammo: 12, maxAmmo: 24, reloadTime: 2.2, spread: 0.02, auto: false, price: 200, range: 200 },
+        ak47: { name: 'AK-47', damage: 27, fireRate: 0.1, ammo: 30, maxAmmo: 90, reloadTime: 2.5, spread: 0.02, auto: true, price: 2700, range: 300 },
+        m4a4: { name: 'M4A4', damage: 23, fireRate: 0.09, ammo: 30, maxAmmo: 90, reloadTime: 3.1, spread: 0.018, auto: true, price: 3100, range: 300 },
+        awp: { name: 'AWP', damage: 115, fireRate: 1.5, ammo: 5, maxAmmo: 30, reloadTime: 3.7, spread: 0.005, auto: false, price: 4750, range: 500 },
+        deagle: { name: 'Desert Eagle', damage: 53, fireRate: 0.4, ammo: 7, maxAmmo: 35, reloadTime: 2.2, spread: 0.04, auto: false, price: 700, range: 200 },
+        famas: { name: 'FAMAS', damage: 20, fireRate: 0.09, ammo: 25, maxAmmo: 75, reloadTime: 3.3, spread: 0.025, auto: true, price: 2050, range: 250 },
+        mp9: { name: 'MP9', damage: 15, fireRate: 0.07, ammo: 30, maxAmmo: 120, reloadTime: 2.1, spread: 0.04, auto: true, price: 1250, range: 150 },
+    };
+
+    let currentWeapon = 'ak47';
+    let weaponAmmo = {};
+    let weaponReserve = {};
+    let lastFireTime = 0;
+    let isReloading = false;
+    let reloadTimer = 0;
+    let isFiring = false;
+
+    // Player stats
+    let playerStats = { health: 100, armor: 0, money: 800, kills: 0, deaths: 0 };
+    let roundTime = 115; // 1:55
+    let roundTimerInterval;
+    let ctScore = 0, tScore = 0;
+
+    // Sound simulation (visual feedback only)
+    let muzzleFlash;
+    let weaponModel;
+
+    // ---- INITIALIZATION ----
+    function init() {
+        scene = new THREE.Scene();
+        scene.background = new THREE.Color(0x87CEEB);
+        scene.fog = new THREE.Fog(0x87CEEB, 100, 400);
+
+        camera = new THREE.PerspectiveCamera(90, window.innerWidth / window.innerHeight, 0.1, 1000);
+        camera.position.set(0, 5, 0);
+
+        renderer = new THREE.WebGLRenderer({ antialias: true });
+        renderer.setSize(window.innerWidth, window.innerHeight);
+        renderer.shadowMap.enabled = true;
+        renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+        document.body.appendChild(renderer.domElement);
+
+        clock = new THREE.Clock();
+
+        // Lighting — warm sunlight like CS2 Dust2
+        const ambientLight = new THREE.AmbientLight(0xffeedd, 0.5);
+        scene.add(ambientLight);
+
+        const sunLight = new THREE.DirectionalLight(0xfff4e0, 1.2);
+        sunLight.position.set(50, 80, 30);
+        sunLight.castShadow = true;
+        sunLight.shadow.mapSize.width = 2048;
+        sunLight.shadow.mapSize.height = 2048;
+        sunLight.shadow.camera.near = 0.5;
+        sunLight.shadow.camera.far = 200;
+        sunLight.shadow.camera.left = -100;
+        sunLight.shadow.camera.right = 100;
+        sunLight.shadow.camera.top = 100;
+        sunLight.shadow.camera.bottom = -100;
+        scene.add(sunLight);
+
+        const hemisphereLight = new THREE.HemisphereLight(0x87CEEB, 0xd4a574, 0.4);
+        scene.add(hemisphereLight);
+
+        buildMap();
+        createWeaponModel();
+        createMuzzleFlash();
+        setupControls();
+        populateBuyMenu();
+
+        window.addEventListener('resize', () => {
+            camera.aspect = window.innerWidth / window.innerHeight;
+            camera.updateProjectionMatrix();
+            renderer.setSize(window.innerWidth, window.innerHeight);
+        });
+    }
+
+    // ---- MAP BUILDING (Dust2 inspired) ----
+    function buildMap() {
+        // Ground
+        const groundGeo = new THREE.PlaneGeometry(300, 300);
+        const groundMat = new THREE.MeshLambertMaterial({ color: 0xd4a574 });
+        const ground = new THREE.Mesh(groundGeo, groundMat);
+        ground.rotation.x = -Math.PI / 2;
+        ground.receiveShadow = true;
+        scene.add(ground);
+        floors.push(ground);
+
+        // Materials
+        const wallMat = new THREE.MeshLambertMaterial({ color: 0xc4a882 });
+        const wallMat2 = new THREE.MeshLambertMaterial({ color: 0xb09070 });
+        const darkWallMat = new THREE.MeshLambertMaterial({ color: 0x8a7660 });
+        const crateMat = new THREE.MeshLambertMaterial({ color: 0x8B7355 });
+        const metalMat = new THREE.MeshLambertMaterial({ color: 0x666666 });
+
+        function addWall(x, y, z, w, h, d, mat) {
+            const geo = new THREE.BoxGeometry(w, h, d);
+            const mesh = new THREE.Mesh(geo, mat || wallMat);
+            mesh.position.set(x, y, z);
+            mesh.castShadow = true;
+            mesh.receiveShadow = true;
+            scene.add(mesh);
+            walls.push(mesh);
+            return mesh;
+        }
+
+        // Perimeter walls
+        addWall(0, 5, -150, 300, 12, 2, wallMat); // North
+        addWall(0, 5, 150, 300, 12, 2, wallMat);  // South
+        addWall(-150, 5, 0, 2, 12, 300, wallMat);  // West
+        addWall(150, 5, 0, 2, 12, 300, wallMat);   // East
+
+        // --- A SITE ---
+        // Platform
+        const aSitePlatGeo = new THREE.BoxGeometry(30, 1, 30);
+        const aSitePlat = new THREE.Mesh(aSitePlatGeo, new THREE.MeshLambertMaterial({ color: 0xc8b898 }));
+        aSitePlat.position.set(60, 0.5, -60);
+        aSitePlat.receiveShadow = true;
+        scene.add(aSitePlat);
+        walls.push(aSitePlat);
+
+        // A site boxes
+        addWall(55, 2.5, -55, 5, 5, 5, crateMat);
+        addWall(65, 2.5, -65, 5, 5, 5, crateMat);
+        addWall(55, 2.5, -70, 3, 5, 8, crateMat);
+
+        // A site walls
+        addWall(45, 5, -50, 2, 10, 40, wallMat2);
+        addWall(75, 5, -50, 2, 10, 40, wallMat2);
+        addWall(60, 5, -80, 32, 10, 2, wallMat2);
+
+        // --- B SITE ---
+        const bSitePlatGeo = new THREE.BoxGeometry(30, 1, 30);
+        const bSitePlat = new THREE.Mesh(bSitePlatGeo, new THREE.MeshLambertMaterial({ color: 0xc8b898 }));
+        bSitePlat.position.set(-60, 0.5, -60);
+        bSitePlat.receiveShadow = true;
+        scene.add(bSitePlat);
+        walls.push(bSitePlat);
+
+        // B site boxes
+        addWall(-55, 2.5, -55, 5, 5, 5, crateMat);
+        addWall(-65, 2.5, -65, 5, 5, 5, crateMat);
+        addWall(-60, 5, -55, 8, 10, 3, crateMat);
+
+        // B site walls
+        addWall(-45, 5, -50, 2, 10, 40, wallMat2);
+        addWall(-75, 5, -50, 2, 10, 40, wallMat2);
+        addWall(-60, 5, -80, 32, 10, 2, wallMat2);
+
+        // --- MID ---
+        // Long corridor walls
+        addWall(-10, 5, -30, 2, 10, 60, darkWallMat);
+        addWall(10, 5, -30, 2, 10, 60, darkWallMat);
+
+        // Mid boxes for cover
+        addWall(0, 2, -20, 4, 4, 4, crateMat);
+        addWall(0, 2, 10, 6, 4, 3, crateMat);
+
+        // --- LONG A ---
+        addWall(30, 5, -10, 40, 10, 2, wallMat2);
+        addWall(30, 5, 10, 40, 10, 2, wallMat2);
+
+        // Long A boxes
+        addWall(25, 2, 0, 4, 4, 4, crateMat);
+        addWall(40, 1.5, 0, 3, 3, 3, crateMat);
+
+        // --- SHORT A (Catwalk) ---
+        const catwalkGeo = new THREE.BoxGeometry(8, 3, 30);
+        const catwalk = new THREE.Mesh(catwalkGeo, new THREE.MeshLambertMaterial({ color: 0xb8a888 }));
+        catwalk.position.set(30, 1.5, -40);
+        catwalk.receiveShadow = true;
+        scene.add(catwalk);
+        walls.push(catwalk);
+
+        // --- TUNNELS (B) ---
+        addWall(-30, 5, -10, 2, 10, 30, darkWallMat);
+        addWall(-30, 5, 10, 20, 10, 2, darkWallMat);
+
+        // Tunnel boxes
+        addWall(-35, 2, 0, 4, 4, 4, crateMat);
+        addWall(-25, 1.5, -15, 3, 3, 3, crateMat);
+
+        // --- T SPAWN area ---
+        addWall(-20, 3, 60, 6, 6, 6, crateMat);
+        addWall(20, 3, 60, 6, 6, 6, crateMat);
+        addWall(0, 2, 70, 4, 4, 8, crateMat);
+
+        // Spawn building walls
+        addWall(-30, 5, 80, 60, 10, 2, wallMat);
+        addWall(-30, 5, 50, 2, 10, 30, wallMat);
+        addWall(30, 5, 50, 2, 10, 30, wallMat);
+
+        // --- CT SPAWN area ---
+        addWall(-20, 3, -100, 6, 6, 6, crateMat);
+        addWall(20, 3, -100, 6, 6, 6, crateMat);
+
+        // CT spawn building
+        addWall(0, 5, -120, 60, 10, 2, wallMat);
+        addWall(-30, 5, -105, 2, 10, 30, wallMat);
+        addWall(30, 5, -105, 2, 10, 30, wallMat);
+
+        // --- ADDITIONAL COVER ---
+        // Mid doors (double doors style)
+        addWall(-3, 5, -55, 1.5, 10, 6, metalMat);
+        addWall(3, 5, -55, 1.5, 10, 6, metalMat);
+
+        // Extra boxes scattered
+        addWall(80, 2, 30, 5, 4, 5, crateMat);
+        addWall(-80, 2, 30, 5, 4, 5, crateMat);
+        addWall(100, 2, -30, 4, 4, 4, crateMat);
+        addWall(-100, 2, -30, 4, 4, 4, crateMat);
+
+        // Ramp to A site
+        const rampGeo = new THREE.BoxGeometry(10, 0.5, 20);
+        const ramp = new THREE.Mesh(rampGeo, new THREE.MeshLambertMaterial({ color: 0xb8a888 }));
+        ramp.position.set(50, 0.5, -40);
+        ramp.rotation.x = -0.1;
+        ramp.receiveShadow = true;
+        scene.add(ramp);
+
+        // Skybox — simple gradient
+        const skyGeo = new THREE.SphereGeometry(450, 32, 32);
+        const skyMat = new THREE.MeshBasicMaterial({
+            color: 0x87CEEB,
+            side: THREE.BackSide
+        });
+        const sky = new THREE.Mesh(skyGeo, skyMat);
+        scene.add(sky);
+
+        // Some buildings/structures in background
+        for (let i = 0; i < 8; i++) {
+            const bw = 15 + Math.random() * 20;
+            const bh = 15 + Math.random() * 30;
+            const bd = 15 + Math.random() * 20;
+            const bx = (Math.random() - 0.5) * 250;
+            const bz = -140 - Math.random() * 30;
+            const buildGeo = new THREE.BoxGeometry(bw, bh, bd);
+            const buildMat = new THREE.MeshLambertMaterial({
+                color: new THREE.Color().setHSL(0.08, 0.2 + Math.random() * 0.2, 0.5 + Math.random() * 0.2)
+            });
+            const building = new THREE.Mesh(buildGeo, buildMat);
+            building.position.set(bx, bh / 2, bz);
+            building.castShadow = true;
+            scene.add(building);
+        }
+    }
+
+    // ---- WEAPON MODEL (First person) ----
+    function createWeaponModel() {
+        weaponModel = new THREE.Group();
+
+        // Gun body
+        const bodyGeo = new THREE.BoxGeometry(0.08, 0.08, 0.6);
+        const bodyMat = new THREE.MeshLambertMaterial({ color: 0x2a2a2a });
+        const body = new THREE.Mesh(bodyGeo, bodyMat);
+        body.position.set(0, 0, -0.3);
+        weaponModel.add(body);
+
+        // Magazine
+        const magGeo = new THREE.BoxGeometry(0.06, 0.15, 0.08);
+        const magMat = new THREE.MeshLambertMaterial({ color: 0x333333 });
+        const mag = new THREE.Mesh(magGeo, magMat);
+        mag.position.set(0, -0.1, -0.2);
+        mag.rotation.x = 0.2;
+        weaponModel.add(mag);
+
+        // Barrel
+        const barrelGeo = new THREE.CylinderGeometry(0.015, 0.015, 0.3, 8);
+        const barrelMat = new THREE.MeshLambertMaterial({ color: 0x1a1a1a });
+        const barrel = new THREE.Mesh(barrelGeo, barrelMat);
+        barrel.rotation.x = Math.PI / 2;
+        barrel.position.set(0, 0.02, -0.72);
+        weaponModel.add(barrel);
+
+        // Stock
+        const stockGeo = new THREE.BoxGeometry(0.06, 0.06, 0.2);
+        const stockMat = new THREE.MeshLambertMaterial({ color: 0x5a3a1a });
+        const stock = new THREE.Mesh(stockGeo, stockMat);
+        stock.position.set(0, 0, 0.1);
+        weaponModel.add(stock);
+
+        // Grip
+        const gripGeo = new THREE.BoxGeometry(0.04, 0.1, 0.04);
+        const grip = new THREE.Mesh(gripGeo, new THREE.MeshLambertMaterial({ color: 0x5a3a1a }));
+        grip.position.set(0, -0.08, -0.05);
+        grip.rotation.x = 0.3;
+        weaponModel.add(grip);
+
+        // Sight
+        const sightGeo = new THREE.BoxGeometry(0.02, 0.03, 0.04);
+        const sight = new THREE.Mesh(sightGeo, new THREE.MeshLambertMaterial({ color: 0x111111 }));
+        sight.position.set(0, 0.06, -0.15);
+        weaponModel.add(sight);
+
+        weaponModel.position.set(0.25, -0.2, -0.4);
+        camera.add(weaponModel);
+        scene.add(camera);
+    }
+
+    function createMuzzleFlash() {
+        const flashGeo = new THREE.SphereGeometry(0.05, 8, 8);
+        const flashMat = new THREE.MeshBasicMaterial({ color: 0xffaa00, transparent: true, opacity: 0 });
+        muzzleFlash = new THREE.Mesh(flashGeo, flashMat);
+        muzzleFlash.position.set(0, 0.02, -0.85);
+        weaponModel.add(muzzleFlash);
+    }
+
+    // ---- BOT AI ----
+    function createBot(x, z) {
+        const bot = new THREE.Group();
+
+        // Body
+        const bodyGeo = new THREE.BoxGeometry(1.2, 2.5, 0.8);
+        const bodyMat = new THREE.MeshLambertMaterial({ color: 0xcc8833 });
+        const body = new THREE.Mesh(bodyGeo, bodyMat);
+        body.position.y = 2.5;
+        body.castShadow = true;
+        bot.add(body);
+
+        // Head
+        const headGeo = new THREE.BoxGeometry(0.7, 0.7, 0.7);
+        const headMat = new THREE.MeshLambertMaterial({ color: 0xddaa66 });
+        const head = new THREE.Mesh(headGeo, headMat);
+        head.position.y = 4.2;
+        head.castShadow = true;
+        bot.add(head);
+
+        // Legs
+        for (let side of [-0.3, 0.3]) {
+            const legGeo = new THREE.BoxGeometry(0.4, 1.5, 0.4);
+            const leg = new THREE.Mesh(legGeo, new THREE.MeshLambertMaterial({ color: 0x445566 }));
+            leg.position.set(side, 0.75, 0);
+            leg.castShadow = true;
+            bot.add(leg);
+        }
+
+        // Arms
+        for (let side of [-0.8, 0.8]) {
+            const armGeo = new THREE.BoxGeometry(0.3, 1.8, 0.3);
+            const arm = new THREE.Mesh(armGeo, new THREE.MeshLambertMaterial({ color: 0xcc8833 }));
+            arm.position.set(side, 2.6, 0);
+            arm.castShadow = true;
+            bot.add(arm);
+        }
+
+        // Bot weapon
+        const gunGeo = new THREE.BoxGeometry(0.1, 0.1, 0.5);
+        const gun = new THREE.Mesh(gunGeo, new THREE.MeshLambertMaterial({ color: 0x222222 }));
+        gun.position.set(0.5, 2.2, -0.4);
+        bot.add(gun);
+
+        bot.position.set(x, 0, z);
+
+        const botData = {
+            mesh: bot,
+            health: 100,
+            speed: 3 + Math.random() * 3,
+            target: new THREE.Vector3(),
+            fireTimer: 0,
+            fireCooldown: 0.8 + Math.random() * 1.5,
+            state: 'patrol', // patrol, chase, attack
+            patrolTarget: new THREE.Vector3(
+                (Math.random() - 0.5) * 200,
+                0,
+                (Math.random() - 0.5) * 200
+            ),
+            name: ['Ivan', 'Dmitry', 'Sergei', 'Alex', 'Nikolai', 'Viktor', 'Pavel', 'Andrei', 'Boris', 'Oleg'][Math.floor(Math.random() * 10)],
+            detectionRange: 50 + Math.random() * 30,
+            accuracy: 0.3 + Math.random() * 0.4,
+            kills: 0,
+            deaths: 0,
+        };
+
+        scene.add(bot);
+        bots.push(botData);
+        return botData;
+    }
+
+    function updateBots(dt) {
+        const playerPos = camera.position.clone();
+        playerPos.y = 0;
+
+        bots.forEach(bot => {
+            if (bot.health <= 0) return;
+
+            const botPos = bot.mesh.position.clone();
+            botPos.y = 0;
+            const distToPlayer = botPos.distanceTo(playerPos);
+
+            // State machine
+            if (distToPlayer < bot.detectionRange && playerStats.health > 0) {
+                bot.state = distToPlayer < 30 ? 'attack' : 'chase';
+            } else {
+                bot.state = 'patrol';
+            }
+
+            let moveTarget;
+            switch (bot.state) {
+                case 'patrol':
+                    moveTarget = bot.patrolTarget;
+                    if (botPos.distanceTo(bot.patrolTarget) < 3) {
+                        bot.patrolTarget.set(
+                            (Math.random() - 0.5) * 200,
+                            0,
+                            (Math.random() - 0.5) * 200
+                        );
+                    }
+                    break;
+                case 'chase':
+                    moveTarget = playerPos;
+                    break;
+                case 'attack':
+                    moveTarget = null;
+                    // Face player
+                    bot.mesh.lookAt(new THREE.Vector3(playerPos.x, bot.mesh.position.y, playerPos.z));
+
+                    // Shoot at player
+                    bot.fireTimer += dt;
+                    if (bot.fireTimer >= bot.fireCooldown) {
+                        bot.fireTimer = 0;
+                        if (Math.random() < bot.accuracy) {
+                            const damage = 8 + Math.floor(Math.random() * 15);
+                            takeDamage(damage, bot.name);
+                        }
+                    }
+                    break;
+            }
+
+            if (moveTarget) {
+                const dir = new THREE.Vector3().subVectors(moveTarget, botPos).normalize();
+                const newPos = bot.mesh.position.clone();
+                newPos.x += dir.x * bot.speed * dt;
+                newPos.z += dir.z * bot.speed * dt;
+
+                // Simple collision
+                let canMove = true;
+                for (const wall of walls) {
+                    const box = new THREE.Box3().setFromObject(wall);
+                    const botBox = new THREE.Box3().setFromCenterAndSize(
+                        newPos, new THREE.Vector3(1.2, 5, 0.8)
+                    );
+                    if (box.intersectsBox(botBox)) {
+                        canMove = false;
+                        bot.patrolTarget.set((Math.random() - 0.5) * 200, 0, (Math.random() - 0.5) * 200);
+                        break;
+                    }
+                }
+                if (canMove) {
+                    bot.mesh.position.x = newPos.x;
+                    bot.mesh.position.z = newPos.z;
+                }
+
+                bot.mesh.lookAt(new THREE.Vector3(moveTarget.x, bot.mesh.position.y, moveTarget.z));
+            }
+
+            // Animate legs slightly
+            const time = clock.getElapsedTime();
+            if (bot.state !== 'attack') {
+                bot.mesh.children.forEach((child, i) => {
+                    if (i >= 2 && i <= 3) { // legs
+                        child.rotation.x = Math.sin(time * 5 + i) * 0.3;
+                    }
+                });
+            }
+        });
+    }
+
+    // ---- PLAYER CONTROLS ----
+    function setupControls() {
+        document.addEventListener('keydown', (e) => {
+            if (gameState === 'menu') return;
+
+            switch (e.code) {
+                case 'KeyW': moveState.forward = true; break;
+                case 'KeyS': moveState.backward = true; break;
+                case 'KeyA': moveState.left = true; break;
+                case 'KeyD': moveState.right = true; break;
+                case 'Space': if (playerOnGround) { velocity.y = 8; playerOnGround = false; } break;
+                case 'ControlLeft': case 'ControlRight': moveState.crouch = true; break;
+                case 'KeyR': startReload(); break;
+                case 'KeyB':
+                    if (document.getElementById('buyMenu').style.display === 'flex') {
+                        document.getElementById('buyMenu').style.display = 'none';
+                    } else {
+                        document.getElementById('buyMenu').style.display = 'flex';
+                    }
+                    break;
+                case 'Tab':
+                    e.preventDefault();
+                    document.getElementById('scoreboard').style.display = 'flex';
+                    updateScoreboard();
+                    break;
+                case 'Digit1': switchWeapon('ak47'); break;
+                case 'Digit2': switchWeapon('glock'); break;
+                case 'Digit3': switchWeapon('knife'); break;
+                case 'Digit4': switchWeapon('awp'); break;
+            }
+        });
+
+        document.addEventListener('keyup', (e) => {
+            switch (e.code) {
+                case 'KeyW': moveState.forward = false; break;
+                case 'KeyS': moveState.backward = false; break;
+                case 'KeyA': moveState.left = false; break;
+                case 'KeyD': moveState.right = false; break;
+                case 'ControlLeft': case 'ControlRight': moveState.crouch = false; break;
+                case 'Tab':
+                    document.getElementById('scoreboard').style.display = 'none';
+                    break;
+            }
+        });
+
+        document.addEventListener('mousedown', (e) => {
+            if (gameState !== 'playing') return;
+            if (e.button === 0) {
+                isFiring = true;
+                fireWeapon();
+            }
+        });
+
+        document.addEventListener('mouseup', (e) => {
+            if (e.button === 0) isFiring = false;
+        });
+
+        document.addEventListener('mousemove', (e) => {
+            if (!isPointerLocked || gameState !== 'playing') return;
+            yaw -= e.movementX * mouseSensitivity;
+            pitch -= e.movementY * mouseSensitivity;
+            pitch = Math.max(-Math.PI / 2 + 0.01, Math.min(Math.PI / 2 - 0.01, pitch));
+        });
+
+        document.addEventListener('pointerlockchange', () => {
+            isPointerLocked = document.pointerLockElement === renderer.domElement;
+        });
+
+        renderer.domElement.addEventListener('click', () => {
+            if (gameState === 'playing' && !isPointerLocked) {
+                renderer.domElement.requestPointerLock();
+            }
+        });
+
+        // Mouse wheel weapon switch
+        document.addEventListener('wheel', (e) => {
+            if (gameState !== 'playing') return;
+            const weaponList = Object.keys(weaponAmmo);
+            let idx = weaponList.indexOf(currentWeapon);
+            if (e.deltaY > 0) idx = (idx + 1) % weaponList.length;
+            else idx = (idx - 1 + weaponList.length) % weaponList.length;
+            switchWeapon(weaponList[idx]);
+        });
+    }
+
+    // ---- WEAPON MECHANICS ----
+    function initWeapons() {
+        weaponAmmo = {};
+        weaponReserve = {};
+        // Start with default weapons
+        ['knife', 'glock'].forEach(w => {
+            weaponAmmo[w] = weapons[w].ammo;
+            weaponReserve[w] = weapons[w].maxAmmo;
+        });
+        currentWeapon = 'glock';
+        updateHUD();
+    }
+
+    function switchWeapon(w) {
+        if (!weaponAmmo.hasOwnProperty(w)) return;
+        if (isReloading) return;
+        currentWeapon = w;
+        isReloading = false;
+
+        // Update weapon appearance
+        const wData = weapons[w];
+        document.getElementById('weaponName').textContent = wData.name;
+
+        // Change weapon model color based on weapon
+        if (w === 'knife') {
+            weaponModel.children[0].scale.set(0.3, 0.3, 0.5);
+            weaponModel.children[0].material.color.setHex(0x888888);
+        } else if (w === 'awp') {
+            weaponModel.children[0].scale.set(1, 1, 1.8);
+            weaponModel.children[0].material.color.setHex(0x2a3a2a);
+        } else {
+            weaponModel.children[0].scale.set(1, 1, 1);
+            weaponModel.children[0].material.color.setHex(0x2a2a2a);
+        }
+
+        updateHUD();
+    }
+
+    function fireWeapon() {
+        if (gameState !== 'playing' || isReloading) return;
+
+        const wData = weapons[currentWeapon];
+        const now = clock.getElapsedTime();
+
+        if (now - lastFireTime < wData.fireRate) return;
+
+        if (currentWeapon === 'knife') {
+            lastFireTime = now;
+            knifeAttack();
+            return;
+        }
+
+        if (weaponAmmo[currentWeapon] <= 0) {
+            startReload();
+            return;
+        }
+
+        lastFireTime = now;
+        weaponAmmo[currentWeapon]--;
+
+        // Muzzle flash
+        muzzleFlash.material.opacity = 1;
+        setTimeout(() => { muzzleFlash.material.opacity = 0; }, 50);
+
+        // Recoil animation
+        weaponModel.rotation.x -= 0.1;
+        setTimeout(() => { weaponModel.rotation.x = 0; }, 80);
+
+        // Camera recoil
+        pitch += 0.008 + Math.random() * 0.005;
+
+        // Raycast for hit detection
+        const spread = wData.spread * (moveState.forward || moveState.backward || moveState.left || moveState.right ? 2 : 1);
+        const direction = new THREE.Vector3(
+            (Math.random() - 0.5) * spread,
+            (Math.random() - 0.5) * spread,
+            -1
+        ).normalize();
+        direction.applyQuaternion(camera.quaternion);
+
+        const raycaster = new THREE.Raycaster(camera.position, direction, 0, wData.range);
+
+        // Check bot hits
+        let hitBot = false;
+        bots.forEach(bot => {
+            if (bot.health <= 0) return;
+            const intersects = raycaster.intersectObjects(bot.mesh.children, true);
+            if (intersects.length > 0) {
+                const isHeadshot = intersects[0].object.position.y > 3.5;
+                const damage = isHeadshot ? wData.damage * 4 : wData.damage;
+                bot.health -= damage;
+
+                showHitMarker(isHeadshot);
+
+                // Hit feedback on bot
+                intersects[0].object.material.emissive = new THREE.Color(0xff0000);
+                setTimeout(() => {
+                    if (intersects[0].object.material) {
+                        intersects[0].object.material.emissive = new THREE.Color(0x000000);
+                    }
+                }, 100);
+
+                if (bot.health <= 0) {
+                    botDied(bot, isHeadshot);
+                }
+                hitBot = true;
+            }
+        });
+
+        // Bullet trail
+        if (!hitBot) {
+            createBulletTrail(camera.position.clone(), direction);
+        }
+
+        // Wall hit sparks
+        if (!hitBot) {
+            const wallIntersects = raycaster.intersectObjects(walls, true);
+            if (wallIntersects.length > 0) {
+                createImpactEffect(wallIntersects[0].point);
+            }
+        }
+
+        updateHUD();
+    }
+
+    function knifeAttack() {
+        // Knife swing animation
+        weaponModel.rotation.z = 0.5;
+        setTimeout(() => { weaponModel.rotation.z = 0; }, 200);
+
+        const wData = weapons.knife;
+        const direction = new THREE.Vector3(0, 0, -1).applyQuaternion(camera.quaternion);
+        const raycaster = new THREE.Raycaster(camera.position, direction, 0, wData.range);
+
+        bots.forEach(bot => {
+            if (bot.health <= 0) return;
+            const intersects = raycaster.intersectObjects(bot.mesh.children, true);
+            if (intersects.length > 0) {
+                bot.health -= wData.damage;
+                showHitMarker(false);
+                if (bot.health <= 0) {
+                    botDied(bot, false);
+                }
+            }
+        });
+    }
+
+    function startReload() {
+        if (isReloading || currentWeapon === 'knife') return;
+        const wData = weapons[currentWeapon];
+        if (weaponAmmo[currentWeapon] >= wData.ammo) return;
+        if (weaponReserve[currentWeapon] <= 0) return;
+
+        isReloading = true;
+        reloadTimer = wData.reloadTime;
+
+        // Reload animation
+        const origY = weaponModel.position.y;
+        weaponModel.position.y -= 0.3;
+        setTimeout(() => {
+            weaponModel.position.y = origY;
+        }, wData.reloadTime * 1000);
+    }
+
+    function updateReload(dt) {
+        if (!isReloading) return;
+        reloadTimer -= dt;
+        if (reloadTimer <= 0) {
+            isReloading = false;
+            const wData = weapons[currentWeapon];
+            const needed = wData.ammo - weaponAmmo[currentWeapon];
+            const available = Math.min(needed, weaponReserve[currentWeapon]);
+            weaponAmmo[currentWeapon] += available;
+            weaponReserve[currentWeapon] -= available;
+            updateHUD();
+        }
+    }
+
+    // ---- EFFECTS ----
+    function showHitMarker(headshot) {
+        const hm = document.getElementById('hitMarker');
+        hm.className = 'show';
+        if (headshot) {
+            hm.querySelectorAll('.hm').forEach(el => el.style.background = '#f00');
+        } else {
+            hm.querySelectorAll('.hm').forEach(el => el.style.background = '#fff');
+        }
+        setTimeout(() => { hm.className = ''; }, 150);
+    }
+
+    function createBulletTrail(origin, direction) {
+        const lineGeo = new THREE.BufferGeometry().setFromPoints([
+            origin,
+            origin.clone().add(direction.clone().multiplyScalar(100))
+        ]);
+        const lineMat = new THREE.LineBasicMaterial({ color: 0xffff88, transparent: true, opacity: 0.4 });
+        const line = new THREE.Line(lineGeo, lineMat);
+        scene.add(line);
+        setTimeout(() => scene.remove(line), 80);
+    }
+
+    function createImpactEffect(point) {
+        const sparkGeo = new THREE.SphereGeometry(0.1, 4, 4);
+        const sparkMat = new THREE.MeshBasicMaterial({ color: 0xffcc44 });
+        const spark = new THREE.Mesh(sparkGeo, sparkMat);
+        spark.position.copy(point);
+        scene.add(spark);
+        setTimeout(() => scene.remove(spark), 150);
+
+        // Dust particles
+        for (let i = 0; i < 5; i++) {
+            const dustGeo = new THREE.SphereGeometry(0.05, 4, 4);
+            const dustMat = new THREE.MeshBasicMaterial({ color: 0xccbb99, transparent: true, opacity: 0.5 });
+            const dust = new THREE.Mesh(dustGeo, dustMat);
+            dust.position.copy(point);
+            dust.velocity = new THREE.Vector3(
+                (Math.random() - 0.5) * 3,
+                Math.random() * 3,
+                (Math.random() - 0.5) * 3
+            );
+            scene.add(dust);
+            bullets.push({ mesh: dust, velocity: dust.velocity, life: 0.5 });
+        }
+    }
+
+    // ---- GAME LOGIC ----
+    function botDied(bot, headshot) {
+        playerStats.kills++;
+        bot.deaths++;
+        playerStats.money += headshot ? 600 : 300;
+
+        // Kill feed
+        addKillFeed('Player', bot.name, weapons[currentWeapon].name, headshot);
+
+        // Remove bot body with delay
+        bot.mesh.rotation.x = Math.PI / 2;
+        bot.mesh.position.y = 0.5;
+
+        setTimeout(() => {
+            respawnBot(bot);
+        }, 5000);
+
+        updateHUD();
+    }
+
+    function respawnBot(bot) {
+        bot.health = 100;
+        bot.mesh.rotation.x = 0;
+        bot.mesh.position.set(
+            (Math.random() - 0.5) * 200,
+            0,
+            (Math.random() - 0.5) * 200
+        );
+        bot.state = 'patrol';
+        bot.patrolTarget.set((Math.random() - 0.5) * 200, 0, (Math.random() - 0.5) * 200);
+    }
+
+    function takeDamage(damage, attackerName) {
+        if (playerStats.health <= 0) return;
+
+        let actualDamage = damage;
+        if (playerStats.armor > 0) {
+            const armorAbsorb = Math.floor(damage * 0.5);
+            const armorReduce = Math.min(armorAbsorb, playerStats.armor);
+            playerStats.armor -= armorReduce;
+            actualDamage = damage - armorReduce;
+        }
+
+        playerStats.health = Math.max(0, playerStats.health - actualDamage);
+
+        // Red flash
+        const overlay = document.getElementById('damageOverlay');
+        overlay.className = 'hit';
+        setTimeout(() => { overlay.className = ''; }, 200);
+
+        if (playerStats.health <= 0) {
+            playerDied(attackerName);
+        }
+
+        updateHUD();
+    }
+
+    function playerDied(killerName) {
+        gameState = 'dead';
+        playerStats.deaths++;
+
+        document.getElementById('deathScreen').style.display = 'flex';
+        addKillFeed(killerName, 'Player', 'AK-47', false);
+
+        // Respawn
+        setTimeout(() => {
+            playerStats.health = 100;
+            camera.position.set(0, 5, 60);
+            yaw = 0;
+            pitch = 0;
+            gameState = 'playing';
+            document.getElementById('deathScreen').style.display = 'none';
+            updateHUD();
+        }, 3000);
+    }
+
+    function addKillFeed(killer, victim, weapon, headshot) {
+        const feed = document.getElementById('killFeed');
+        const entry = document.createElement('div');
+        entry.className = 'kill-entry';
+        entry.innerHTML = `<span class="killer">${killer}</span><span class="weapon"> [${weapon}${headshot ? ' HS' : ''}] </span><span class="victim">${victim}</span>`;
+        feed.appendChild(entry);
+        setTimeout(() => entry.remove(), 4000);
+    }
+
+    // ---- PLAYER MOVEMENT ----
+    function updatePlayer(dt) {
+        if (gameState !== 'playing') return;
+
+        // Camera rotation
+        camera.rotation.order = 'YXZ';
+        camera.rotation.y = yaw;
+        camera.rotation.x = pitch;
+
+        // Movement
+        const speed = moveState.crouch ? 4 : 8;
+        const forward = new THREE.Vector3(0, 0, -1).applyQuaternion(camera.quaternion);
+        forward.y = 0;
+        forward.normalize();
+        const right = new THREE.Vector3(1, 0, 0).applyQuaternion(camera.quaternion);
+        right.y = 0;
+        right.normalize();
+
+        const moveDir = new THREE.Vector3();
+        if (moveState.forward) moveDir.add(forward);
+        if (moveState.backward) moveDir.sub(forward);
+        if (moveState.right) moveDir.add(right);
+        if (moveState.left) moveDir.sub(right);
+
+        if (moveDir.length() > 0) moveDir.normalize();
+
+        const targetVelX = moveDir.x * speed;
+        const targetVelZ = moveDir.z * speed;
+
+        velocity.x += (targetVelX - velocity.x) * 10 * dt;
+        velocity.z += (targetVelZ - velocity.z) * 10 * dt;
+
+        // Gravity
+        velocity.y -= 20 * dt;
+
+        // New position
+        const newPos = camera.position.clone();
+        newPos.x += velocity.x * dt;
+        newPos.z += velocity.z * dt;
+        newPos.y += velocity.y * dt;
+
+        // Height
+        const standHeight = 5;
+        const crouchHeight = 3.5;
+        const playerHeight = moveState.crouch ? crouchHeight : standHeight;
+
+        // Ground collision
+        if (newPos.y <= playerHeight) {
+            newPos.y = playerHeight;
+            velocity.y = 0;
+            playerOnGround = true;
+        }
+
+        // Wall collision
+        const playerRadius = 0.5;
+        for (const wall of walls) {
+            const box = new THREE.Box3().setFromObject(wall);
+            // Expand check
+            if (newPos.x > box.min.x - playerRadius && newPos.x < box.max.x + playerRadius &&
+                newPos.y - playerHeight < box.max.y && newPos.y > box.min.y &&
+                newPos.z > box.min.z - playerRadius && newPos.z < box.max.z + playerRadius) {
+
+                // Check if standing on top
+                if (camera.position.y >= box.max.y &&
+                    newPos.x > box.min.x - playerRadius && newPos.x < box.max.x + playerRadius &&
+                    newPos.z > box.min.z - playerRadius && newPos.z < box.max.z + playerRadius) {
+                    newPos.y = box.max.y + playerHeight;
+                    velocity.y = 0;
+                    playerOnGround = true;
+                    continue;
+                }
+
+                // Side collision — push out
+                const oldPos = camera.position;
+                if (oldPos.x <= box.min.x - playerRadius || oldPos.x >= box.max.x + playerRadius) {
+                    newPos.x = oldPos.x;
+                    velocity.x = 0;
+                }
+                if (oldPos.z <= box.min.z - playerRadius || oldPos.z >= box.max.z + playerRadius) {
+                    newPos.z = oldPos.z;
+                    velocity.z = 0;
+                }
+            }
+        }
+
+        // Map bounds
+        newPos.x = Math.max(-148, Math.min(148, newPos.x));
+        newPos.z = Math.max(-148, Math.min(148, newPos.z));
+
+        camera.position.copy(newPos);
+
+        // Auto fire for auto weapons
+        if (isFiring && weapons[currentWeapon].auto) {
+            fireWeapon();
+        }
+
+        // Head bob
+        if (moveDir.length() > 0 && playerOnGround) {
+            const bobSpeed = moveState.crouch ? 4 : 8;
+            const bobAmount = moveState.crouch ? 0.02 : 0.04;
+            weaponModel.position.y = -0.2 + Math.sin(clock.getElapsedTime() * bobSpeed) * bobAmount;
+            weaponModel.position.x = 0.25 + Math.cos(clock.getElapsedTime() * bobSpeed * 0.5) * bobAmount * 0.5;
+        }
+    }
+
+    // ---- PARTICLES UPDATE ----
+    function updateParticles(dt) {
+        for (let i = bullets.length - 1; i >= 0; i--) {
+            const p = bullets[i];
+            p.mesh.position.add(p.velocity.clone().multiplyScalar(dt));
+            p.velocity.y -= 10 * dt;
+            p.life -= dt;
+            p.mesh.material.opacity = p.life;
+            if (p.life <= 0) {
+                scene.remove(p.mesh);
+                bullets.splice(i, 1);
+            }
+        }
+    }
+
+    // ---- RADAR ----
+    function updateRadar() {
+        const canvas = document.getElementById('radarCanvas');
+        const ctx = canvas.getContext('2d');
+        ctx.clearRect(0, 0, 160, 160);
+
+        // Background
+        ctx.fillStyle = 'rgba(0, 20, 0, 0.8)';
+        ctx.fillRect(0, 0, 160, 160);
+
+        const scale = 0.4;
+        const cx = 80, cy = 80;
+
+        // Player
+        ctx.fillStyle = '#4f4';
+        ctx.beginPath();
+        ctx.arc(cx, cy, 4, 0, Math.PI * 2);
+        ctx.fill();
+
+        // Player direction
+        const dirX = Math.sin(yaw);
+        const dirZ = Math.cos(yaw);
+        ctx.strokeStyle = '#4f4';
+        ctx.lineWidth = 2;
+        ctx.beginPath();
+        ctx.moveTo(cx, cy);
+        ctx.lineTo(cx + dirX * 12, cy - dirZ * 12);
+        ctx.stroke();
+
+        // Bots
+        bots.forEach(bot => {
+            if (bot.health <= 0) return;
+            const relX = (bot.mesh.position.x - camera.position.x) * scale;
+            const relZ = (bot.mesh.position.z - camera.position.z) * scale;
+
+            // Rotate relative to player yaw
+            const rotX = relX * Math.cos(-yaw) - relZ * Math.sin(-yaw);
+            const rotZ = relX * Math.sin(-yaw) + relZ * Math.cos(-yaw);
+
+            const bx = cx + rotX;
+            const by = cy - rotZ;
+
+            if (bx > 5 && bx < 155 && by > 5 && by < 155) {
+                ctx.fillStyle = '#f44';
+                ctx.beginPath();
+                ctx.arc(bx, by, 3, 0, Math.PI * 2);
+                ctx.fill();
+            }
+        });
+    }
+
+    // ---- HUD UPDATE ----
+    function updateHUD() {
+        document.getElementById('healthVal').textContent = playerStats.health;
+        document.getElementById('armorVal').textContent = playerStats.armor;
+        document.getElementById('moneyDisplay').textContent = '$' + playerStats.money;
+
+        if (currentWeapon === 'knife') {
+            document.getElementById('ammoCur').textContent = '—';
+            document.getElementById('ammoRes').textContent = '';
+        } else {
+            document.getElementById('ammoCur').textContent = weaponAmmo[currentWeapon] || 0;
+            document.getElementById('ammoRes').textContent = weaponReserve[currentWeapon] || 0;
+        }
+
+        // Health color
+        const hv = document.getElementById('healthVal');
+        const hp = playerStats.health;
+        if (hp > 50) hv.style.color = '#4f4';
+        else if (hp > 25) hv.style.color = '#ff4';
+        else hv.style.color = '#f44';
+    }
+
+    // ---- SCOREBOARD ----
+    function updateScoreboard() {
+        const body = document.getElementById('scoreBody');
+        body.innerHTML = '';
+
+        // Player
+        const row = document.createElement('tr');
+        row.innerHTML = `<td style="color:#5ac">Player (You)</td><td>${playerStats.kills}</td><td>${playerStats.deaths}</td><td>${playerStats.kills * 2}</td>`;
+        body.appendChild(row);
+
+        // Bots
+        bots.forEach(bot => {
+            const row = document.createElement('tr');
+            row.innerHTML = `<td style="color:#da4">${bot.name}</td><td>${bot.kills}</td><td>${bot.deaths}</td><td>${bot.kills * 2}</td>`;
+            body.appendChild(row);
+        });
+    }
+
+    // ---- BUY MENU ----
+    function populateBuyMenu() {
+        const grid = document.getElementById('buyGrid');
+        grid.innerHTML = '';
+        const buyable = ['glock', 'usp', 'deagle', 'mp9', 'famas', 'ak47', 'm4a4', 'awp'];
+
+        buyable.forEach(wKey => {
+            const w = weapons[wKey];
+            const item = document.createElement('div');
+            item.className = 'buy-item';
+            item.innerHTML = `<div class="item-name">${w.name}</div><div class="item-price">$${w.price}</div>`;
+            item.onclick = () => buyWeapon(wKey);
+            grid.appendChild(item);
+        });
+
+        // Armor
+        const armorItem = document.createElement('div');
+        armorItem.className = 'buy-item';
+        armorItem.innerHTML = `<div class="item-name">Kevlar + Helmet</div><div class="item-price">$1000</div>`;
+        armorItem.onclick = () => {
+            if (playerStats.money >= 1000) {
+                playerStats.money -= 1000;
+                playerStats.armor = 100;
+                updateHUD();
+            }
+        };
+        grid.appendChild(armorItem);
+    }
+
+    function buyWeapon(wKey) {
+        const w = weapons[wKey];
+        if (playerStats.money >= w.price) {
+            playerStats.money -= w.price;
+            weaponAmmo[wKey] = w.ammo;
+            weaponReserve[wKey] = w.maxAmmo;
+            switchWeapon(wKey);
+            updateHUD();
+        }
+    }
+
+    // ---- ROUND TIMER ----
+    function startRoundTimer() {
+        roundTime = 115;
+        updateTimerDisplay();
+        roundTimerInterval = setInterval(() => {
+            roundTime--;
+            updateTimerDisplay();
+            if (roundTime <= 0) {
+                clearInterval(roundTimerInterval);
+                endRound();
+            }
+        }, 1000);
+    }
+
+    function updateTimerDisplay() {
+        const min = Math.floor(roundTime / 60);
+        const sec = roundTime % 60;
+        document.getElementById('roundTimer').textContent = `${min}:${sec.toString().padStart(2, '0')}`;
+    }
+
+    function endRound() {
+        // In deathmatch, just restart timer
+        if (gameMode === 'deathmatch') {
+            showAnnouncement('ROUND OVER');
+            setTimeout(() => {
+                startRoundTimer();
+            }, 3000);
+        }
+    }
+
+    function showAnnouncement(text) {
+        const el = document.getElementById('announcement');
+        el.textContent = text;
+        el.className = 'show';
+        setTimeout(() => { el.className = ''; }, 2500);
+    }
+
+    // ---- GAME START ----
+    function startGame(mode) {
+        gameMode = mode;
+        gameState = 'playing';
+
+        document.getElementById('mainMenu').style.display = 'none';
+        document.getElementById('hud').style.display = 'block';
+
+        // Player position (T spawn)
+        camera.position.set(0, 5, 60);
+
+        // Init weapons
+        initWeapons();
+
+        // Reset stats
+        playerStats = { health: 100, armor: 0, money: 800, kills: 0, deaths: 0 };
+        ctScore = 0;
+        tScore = 0;
+
+        // Spawn bots
+        const botCount = mode === 'deathmatch' ? 10 : 5;
+        for (let i = 0; i < botCount; i++) {
+            createBot(
+                (Math.random() - 0.5) * 180,
+                (Math.random() - 0.5) * 180
+            );
+        }
+
+        startRoundTimer();
+        updateHUD();
+
+        showAnnouncement('ROUND START');
+
+        // Request pointer lock
+        setTimeout(() => {
+            renderer.domElement.requestPointerLock();
+        }, 500);
+    }
+
+    function showSettings() {
+        // Simple settings via prompt
+        const sens = prompt('Mouse sensitivity (0.001 - 0.01):', mouseSensitivity);
+        if (sens) mouseSensitivity = parseFloat(sens);
+    }
+
+    // ---- MAIN GAME LOOP ----
+    function animate() {
+        requestAnimationFrame(animate);
+
+        const dt = Math.min(clock.getDelta(), 0.05);
+
+        if (gameState === 'playing' || gameState === 'dead') {
+            updatePlayer(dt);
+            updateBots(dt);
+            updateReload(dt);
+            updateParticles(dt);
+            updateRadar();
+        }
+
+        renderer.render(scene, camera);
+    }
+
+    // ---- START ----
+    init();
+    animate();
+    </script>
+</body>
+</html>
