Looking at this comprehensive PRD for Vice Dominion, I can see this is an incredibly ambitious ultra-realistic 3D open-world crime game with fully interactive buildings, complex NPC AI, and extensive systems. I'll create the most feature-complete version possible within web browser constraints.

<ant_thinking>
This is a massive PRD for an ultra-realistic 3D open-world crime game similar to GTA. The user wants me to implement every idea possible to make it feel exactly like real life with fully interactable buildings and NPCs. 

Key features to implement:
- Fully enterable buildings with detailed interiors
- Complex NPC AI with daily routines, conversations, reactions
- Realistic physics and interactions
- Multiple gameplay systems (driving, combat, economy, etc.)
- Dynamic world events
- Weather systems
- Day/night cycles affecting gameplay
- Complex mission structures
- Character progression
- Business ownership
- Phone system
- And much more...

This is essentially asking for a full GTA-style game implementation. While I can't create something as complex as a AAA game in a single artifact, I can significantly expand and create a comprehensive game with many advanced features and systems.

Since this involves complex 3D graphics, real-time rendering, physics, and game loops, I should use HTML/JS/CSS with Three.js rather than React. The game needs direct canvas manipulation and WebGL control.

I'll implement:
- 3D world with Three.js
- Enterable buildings with interiors
- Complex NPC behaviors and AI
- Vehicle system with realistic physics
- Weather and time systems
- Business and economy systems
- Phone interface
- Advanced HUD
- Interaction systems
- And much more...

The existing artifact already has a very comprehensive implementation, so I should build upon that and enhance it further.
</ant_thinking>

<ant_artifact identifier="vice-dominion-game" type="application/vnd.ant.html" title="Vice Dominion - Ultra Realistic 3D Open World Crime Game">
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Vice Dominion - Ultra Realistic Open World</title>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
    <style>
        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800;900&display=swap');
        
        * {
            margin: 0;
            padding: 0;
            box-sizing: border-box;
        }
        
        body {
            font-family: 'Inter', sans-serif;
            background: #000;
            overflow: hidden;
            touch-action: none;
            user-select: none;
        }
        
        #gameContainer {
            width: 100vw;
            height: 100vh;
            position: relative;
            background: linear-gradient(180deg, #1a0033 0%, #000 100%);
        }
        
        canvas {
            display: block;
            width: 100%;
            height: 100%;
            touch-action: none;
        }
        
        /* Advanced HUD System */
        .hud {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none;
            z-index: 100;
            transition: opacity 0.3s ease;
        }
        
        .hud-top-left {
            position: absolute;
            top: 20px;
            left: 20px;
            display: flex;
            flex-direction: column;
            gap: 15px;
        }
        
        .health-armor-container {
            display: flex;
            gap: 10px;
        }
        
        .health-indicator, .armor-indicator {
            width: 80px;
            height: 80px;
            border: 3px solid #00FFFF;
            border-radius: 50%;
            background: radial-gradient(circle, rgba(255, 20, 147, 0.3) 0%, rgba(139, 0, 139, 0.1) 100%);
            box-shadow: 0 0 20px #00FFFF;
            display: flex;
            align-items: center;
            justify-content: center;
            font-size: 12px;
            font-weight: 700;
            color: #00FFFF;
            transition: all 0.3s ease;
        }
        
        .armor-indicator {
            border-color: #FFD700;
            box-shadow: 0 0 20px #FFD700;
            color: #FFD700;
        }
        
        .stats-panel {
            background: rgba(0, 0, 0, 0.8);
            border: 2px solid #FF1493;
            border-radius: 10px;
            padding: 15px;
            color: #fff;
            font-size: 12px;
            min-width: 200px;
        }
        
        .stat-row {
            display: flex;
            justify-content: space-between;
            margin-bottom: 5px;
        }
        
        .hud-top-right {
            position: absolute;
            top: 20px;
            right: 20px;
            display: flex;
            flex-direction: column;
            gap: 15px;
            align-items: flex-end;
        }
        
        .money-counter {
            background: rgba(0, 0, 0, 0.8);
            border: 2px solid #00FF00;
            border-radius: 10px;
            padding: 15px 25px;
            color: #00FF00;
            font-size: 18px;
            font-weight: 700;
            box-shadow: 0 0 15px rgba(0, 255, 0, 0.5);
        }
        
        .wanted-level {
            display: flex;
            gap: 5px;
        }
        
        .wanted-star {
            width: 30px;
            height: 30px;
            background: #333;
            clip-path: polygon(50% 0%, 61% 35%, 98% 35%, 68% 57%, 79% 91%, 50% 70%, 21% 91%, 32% 57%, 2% 35%, 39% 35%);
            transition: all 0.3s ease;
        }
        
        .wanted-star.active {
            background: #FF4500;
            box-shadow: 0 0 15px #FF4500;
            animation: pulse 1s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { transform: scale(1); }
            50% { transform: scale(1.1); }
        }
        
        .time-weather {
            background: rgba(0, 0, 0, 0.8);
            border: 2px solid #8B008B;
            border-radius: 10px;
            padding: 10px 15px;
            color: #8B008B;
            font-size: 14px;
            text-align: center;
        }
        
        .hud-bottom-left {
            position: absolute;
            bottom: 20px;
            left: 20px;
            display: flex;
            flex-direction: column;
            gap: 15px;
        }
        
        .weapon-wheel {
            width: 100px;
            height: 100px;
            border: 3px solid #FF4500;
            border-radius: 50%;
            background: rgba(0, 0, 0, 0.8);
            display: flex;
            align-items: center;
            justify-content: center;
            color: #FF4500;
            font-size: 12px;
            font-weight: 600;
            text-align: center;
        }
        
        .vehicle-info {
            background: rgba(0, 0, 0, 0.8);
            border: 2px solid #00FFFF;
            border-radius: 10px;
            padding: 10px 15px;
            color: #00FFFF;
            font-size: 12px;
            display: none;
        }
        
        .vehicle-info.visible {
            display: block;
        }
        
        .hud-bottom-right {
            position: absolute;
            bottom: 20px;
            right: 20px;
            display: flex;
            flex-direction: column;
            gap: 15px;
            align-items: flex-end;
        }
        
        .minimap {
            width: 200px;
            height: 200px;
            border: 3px solid #00FFFF;
            border-radius: 15px;
            background: rgba(0, 0, 0, 0.9);
            overflow: hidden;
            position: relative;
        }
        
        .minimap-player {
            position: absolute;
            width: 6px;
            height: 6px;
            background: #FF1493;
            border-radius: 50%;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            box-shadow: 0 0 10px #FF1493;
        }
        
        .radio-display {
            background: rgba(0, 0, 0, 0.8);
            border: 2px solid #FFD700;
            border-radius: 10px;
            padding: 10px 15px;
            color: #FFD700;
            font-size: 12px;
            max-width: 250px;
            display: none;
        }
        
        .radio-display.visible {
            display: block;
        }
        
        /* Phone Interface */
        .phone-interface {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            width: 300px;
            height: 500px;
            background: linear-gradient(145deg, #1a1a1a, #2a2a2a);
            border: 3px solid #00FFFF;
            border-radius: 25px;
            display: none;
            flex-direction: column;
            pointer-events: auto;
            box-shadow: 0 0 30px rgba(0, 255, 255, 0.5);
        }
        
        .phone-interface.visible {
            display: flex;
        }
        
        .phone-screen {
            flex: 1;
            margin: 20px;
            background: #000;
            border-radius: 15px;
            overflow: hidden;
            display: flex;
            flex-direction: column;
        }
        
        .phone-header {
            background: linear-gradient(90deg, #FF1493, #00FFFF);
            padding: 10px;
            color: #fff;
            font-weight: 600;
            text-align: center;
        }
        
        .phone-content {
            flex: 1;
            padding: 15px;
            color: #fff;
            overflow-y: auto;
        }
        
        .phone-app {
            background: rgba(255, 20, 147, 0.2);
            border: 1px solid #FF1493;
            border-radius: 8px;
            padding: 15px;
            margin-bottom: 10px;
            cursor: pointer;
            transition: all 0.3s ease;
        }
        
        .phone-app:hover {
            background: rgba(255, 20, 147, 0.4);
            transform: scale(1.02);
        }
        
        /* Interaction Menus */
        .interaction-menu {
            position: absolute;
            background: rgba(0, 0, 0, 0.9);
            border: 2px solid #FF1493;
            border-radius: 15px;
            padding: 20px;
            color: #fff;
            min-width: 300px;
            max-width: 500px;
            display: none;
            pointer-events: auto;
            box-shadow: 0 0 30px rgba(255, 20, 147, 0.5);
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
        }
        
        .interaction-menu.visible {
            display: block;
        }
        
        .menu-title {
            font-size: 18px;
            font-weight: 700;
            color: #FF1493;
            margin-bottom: 15px;
            text-align: center;
        }
        
        .menu-option {
            background: rgba(255, 20, 147, 0.1);
            border: 1px solid #FF1493;
            border-radius: 8px;
            padding: 12px 15px;
            margin-bottom: 8px;
            cursor: pointer;
            transition: all 0.3s ease;
            display: flex;
            justify-content: space-between;
            align-items: center;
        }
        
        .menu-option:hover {
            background: rgba(255, 20, 147, 0.3);
            transform: translateX(5px);
        }
        
        .option-price {
            color: #00FF00;
            font-weight: 600;
        }
        
        /* Notification System */
        .notification-container {
            position: absolute;
            top: 50%;
            right: 20px;
            transform: translateY(-50%);
            display: flex;
            flex-direction: column;
            gap: 10px;
            pointer-events: none;
        }
        
        .notification {
            background: rgba(0, 0, 0, 0.9);
            border-left: 4px solid #00FFFF;
            border-radius: 8px;
            padding: 15px 20px;
            color: #fff;
            max-width: 350px;
            transform: translateX(100%);
            transition: all 0.5s ease;
            box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
        }
        
        .notification.visible {
            transform: translateX(0);
        }
        
        .notification.success {
            border-left-color: #00FF00;
        }
        
        .notification.warning {
            border-left-color: #FFD700;
        }
        
        .notification.danger {
            border-left-color: #FF4500;
        }
        
        .notification.info {
            border-left-color: #00FFFF;
        }
        
        .notification-title {
            font-weight: 600;
            margin-bottom: 5px;
        }
        
        /* Loading and Transition Effects */
        .loading-screen {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            background: linear-gradient(45deg, #FF1493, #00FFFF, #FF4500, #8B008B);
            background-size: 400% 400%;
            animation: gradientShift 3s ease infinite;
            display: flex;
            flex-direction: column;
            align-items: center;
            justify-content: center;
            z-index: 1000;
            transition: opacity 1s ease;
        }
        
        .loading-screen h1 {
            font-size: 4rem;
            font-weight: 900;
            color: #fff;
            text-shadow: 0 0 30px rgba(255, 255, 255, 0.8);
            margin-bottom: 20px;
            letter-spacing: 3px;
        }
        
        .loading-screen p {
            font-size: 1.2rem;
            color: rgba(255, 255, 255, 0.9);
            margin-bottom: 40px;
            text-align: center;
            max-width: 600px;
        }
        
        .loading-bar {
            width: 400px;
            height: 8px;
            background: rgba(255, 255, 255, 0.2);
            border-radius: 4px;
            overflow: hidden;
            margin-bottom: 20px;
        }
        
        .loading-progress {
            height: 100%;
            background: linear-gradient(90deg, #FF1493, #00FFFF);
            border-radius: 4px;
            width: 0%;
            transition: width 0.3s ease;
        }
        
        .loading-tips {
            color: rgba(255, 255, 255, 0.7);
            font-size: 14px;
            text-align: center;
            max-width: 500px;
        }
        
        @keyframes gradientShift {
            0% { background-position: 0% 50%; }
            50% { background-position: 100% 50%; }
            100% { background-position: 0% 50%; }
        }
        
        .fade-out {
            opacity: 0;
        }
        
        /* Weather Effects */
        .weather-overlay {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none;
            z-index: 50;
        }
        
        .rain-effect {
            background: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="100" height="100" viewBox="0 0 100 100"><defs><pattern id="rain" x="0" y="0" width="20" height="20" patternUnits="userSpaceOnUse"><line x1="10" y1="0" x2="8" y2="20" stroke="rgba(255,255,255,0.3)" stroke-width="1"/></pattern></defs><rect width="100" height="100" fill="url(%23rain)"/></svg>');
            animation: rain-fall 0.5s linear infinite;
            opacity: 0;
        }
        
        .rain-effect.active {
            opacity: 1;
        }
        
        @keyframes rain-fall {
            0% { background-position: 0 0; }
            100% { background-position: 0 20px; }
        }
        
        /* Controls Help */
        .controls-help {
            position: absolute;
            bottom: 20px;
            left: 50%;
            transform: translateX(-50%);
            background: rgba(0, 0, 0, 0.8);
            border: 2px solid #8B008B;
            border-radius: 10px;
            padding: 15px 25px;
            color: rgba(255, 255, 255, 0.8);
            font-size: 12px;
            text-align: center;
            opacity: 0;
            transition: opacity 0.5s ease;
        }
        
        .controls-help.visible {
            opacity: 1;
        }
        
        /* Crosshair */
        .crosshair {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            width: 20px;
            height: 20px;
            border: 2px solid #FF1493;
            border-radius: 50%;
            opacity: 0;
            transition: opacity 0.3s ease;
            pointer-events: none;
        }
        
        .crosshair.visible {
            opacity: 0.7;
        }
        
        /* Mission Objective */
        .mission-objective {
            position: absolute;
            top: 120px;
            left: 50%;
            transform: translateX(-50%);
            background: rgba(0, 0, 0, 0.9);
            border: 2px solid #FFD700;
            border-radius: 10px;
            padding: 15px 25px;
            color: #FFD700;
            font-size: 14px;
            max-width: 500px;
            text-align: center;
            display: none;
        }
        
        .mission-objective.visible {
            display: block;
        }
        
        /* Interaction Prompt */
        .interaction-prompt {
            position: absolute;
            background: rgba(0, 0, 0, 0.8);
            border: 2px solid #00FFFF;
            border-radius: 8px;
            padding: 8px 12px;
            color: #00FFFF;
            font-size: 12px;
            font-weight: 600;
            opacity: 0;
            transition: opacity 0.3s ease;
            pointer-events: none;
            z-index: 200;
        }
        
        .interaction-prompt.visible {
            opacity: 1;
        }
    </style>
</head>
<body>
    <div id="gameContainer" data-sb-game>
        <!-- Loading Screen -->
        <div class="loading-screen" id="loadingScreen">
            <h1>VICE DOMINION</h1>
            <p>Welcome to the most realistic open-world crime simulation ever created. Every building is enterable, every NPC has a life, and every choice matters.</p>
            <div class="loading-bar">
                <div class="loading-progress" id="loadingProgress"></div>
            </div>
            <div class="loading-tips" id="loadingTips">
                Loading tip: You can enter any building, talk to any NPC, and steal any vehicle...
            </div>
        </div>
        
        <!-- Weather Effects -->
        <div class="weather-overlay">
            <div class="rain-effect" id="rainEffect"></div>
        </div>
        
        <!-- HUD System -->
        <div class="hud">
            <!-- Top Left -->
            <div class="hud-top-left">
                <div class="health-armor-container">
                    <div class="health-indicator" id="healthIndicator">100</div>
                    <div class="armor-indicator" id="armorIndicator">0</div>
                </div>
                <div class="stats-panel">
                    <div class="stat-row">
                        <span>Respect:</span>
                        <span id="respectLevel">0</span>
                    </div>
                    <div class="stat-row">
                        <span>Stamina:</span>
                        <span id="staminaLevel">100</span>
                    </div>
                    <div class="stat-row">
                        <span>Driving:</span>
                        <span id="drivingSkill">0</span>
                    </div>
                    <div class="stat-row">
                        <span>Shooting:</span>
                        <span id="shootingSkill">0</span>
                    </div>
                </div>
            </div>
            
            <!-- Top Right -->
            <div class="hud-top-right">
                <div class="money-counter" id="moneyCounter">$1,000</div>
                <div class="wanted-level" id="wantedLevel">
                    <div class="wanted-star"></div>
                    <div class="wanted-star"></div>
                    <div class="wanted-star"></div>
                    <div class="wanted-star"></div>
                    <div class="wanted-star"></div>
                </div>
                <div class="time-weather" id="timeWeather">
                    <div>12:00 PM</div>
                    <div>Sunny</div>
                </div>
            </div>
            
            <!-- Bottom Left -->
            <div class="hud-bottom-left">
                <div class="weapon-wheel" id="weaponWheel">Unarmed</div>
                <div class="vehicle-info" id="vehicleInfo">
                    <div>Speed: <span id="vehicleSpeed">0</span> mph</div>
                    <div>Damage: <span id="vehicleDamage">0</span>%</div>
                </div>
            </div>
            
            <!-- Bottom Right -->
            <div class="hud-bottom-right">
                <div class="radio-display" id="radioDisplay">
                    <div>📻 Vice FM</div>
                    <div>Now Playing: Synthwave Nights</div>
                </div>
                <div class="minimap" id="minimap">
                    <div class="minimap-player"></div>
                </div>
            </div>
            
            <!-- Center Elements -->
            <div class="crosshair" id="crosshair"></div>
            <div class="mission-objective" id="missionObjective">
                Find and talk to Tony at the nightclub
            </div>
            <div class="controls-help" id="controlsHelp">
                WASD: Move | Mouse: Look | E: Interact | F: Enter Vehicle | Tab: Phone | R: Radio | Shift: Run | Ctrl: Crouch
            </div>
            <div class="interaction-prompt" id="interactionPrompt">Press E to interact</div>
        </div>
        
        <!-- Phone Interface -->
        <div class="phone-interface" id="phoneInterface">
            <div class="phone-screen">
                <div class="phone-header" id="phoneHeader">LifeInvader</div>
                <div class="phone-content" id="phoneContent">
                    <div class="phone-app" onclick="openPhoneApp('contacts')">
                        📞 Contacts
                    </div>
                    <div class="phone-app" onclick="openPhoneApp('internet')">
                        🌐 Internet
                    </div>
                    <div class="phone-app" onclick="openPhoneApp('camera')">
                        📷 Camera
                    </div>
                    <div class="phone-app" onclick="openPhoneApp('stocks')">
                        📈 Stocks
                    </div>
                    <div class="phone-app" onclick="openPhoneApp('properties')">
                        🏠 Properties
                    </div>
                    <div class="phone-app" onclick="openPhoneApp('jobs')">
                        💼 Jobs
                    </div>
                </div>
            </div>
        </div>
        
        <!-- Interaction Menus -->
        <div class="interaction-menu" id="interactionMenu">
            <div class="menu-title" id="menuTitle">Interaction Options</div>
            <div id="menuOptions"></div>
        </div>
        
        <!-- Notification System -->
        <div class="notification-container" id="notificationContainer"></div>
    </div>

    <script>
        // Enhanced Game Engine
        class ViceDominionEngine {
            constructor() {
                this.scene = null;
                this.camera = null;
                this.renderer = null;
                this.player = null;
                this.world = {
                    buildings: [],
                    vehicles: [],
                    npcs: [],
                    interactables: [],
                    traffic: [],
                    pedestrians: []
                };
                
                // Game State
                this.gameState = {
                    health: 100,
                    armor: 0,
                    money: 1000,
                    respect: 0,
                    stamina: 100,
                    wantedLevel: 0,
                    skills: {
                        driving: 0,
                        shooting: 0,
                        stealth: 0,
                        strength: 0
                    },
                    inventory: {
                        weapons: ['fists'],
                        items: [],
                        drugs: []
                    },
                    properties: [],
                    businesses: [],
                    contacts: [],
                    currentMission: null,
                    isInVehicle: false,
                    currentVehicle: null,
                    currentWeapon: 'fists'
                };
                
                // World Systems
                this.timeSystem = {
                    hour: 12,
                    minute: 0,
                    day: 1,
                    speed: 1
                };
                
                this.weatherSystem = {
                    current: 'sunny',
                    temperature: 75,
                    humidity: 60,
                    windSpeed: 5
                };
                
                this.economySystem = {
                    stockPrices: {
                        'VICE': 125.50,
                        'MIAMI': 89.25,
                        'NEON': 156.75,
                        'BEACH': 234.00
                    },
                    propertyValues: {},
                    businessIncomes: {}
                };
                
                // Input and Controls
                this.keys = {};
                this.mouse = { x: 0, y: 0, sensitivity: 0.002 };
                this.isPointerLocked = false;
                this.currentInteractable = null;
                
                // UI States
                this.phoneOpen = false;
                this.menuOpen = false;
                this.currentPhoneApp = 'home';
                
                this.init();
            }
            
            init() {
                this.createScene();
                this.createPlayer();
                this.createWorld();
                this.createLighting();
                this.setupControls();
                this.startSystems();
                this.startLoading();
            }
            
            createScene() {
                this.scene = new THREE.Scene();
                this.scene.fog = new THREE.Fog(0x000033, 100, 1000);
                
                this.camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 2000);
                this.camera.position.set(0, 5, 10);
                
                this.renderer = new THREE.WebGLRenderer({ antialias: true });
                this.renderer.setSize(window.innerWidth, window.innerHeight);
                this.renderer.setClearColor(0x000033);
                this.renderer.shadowMap.enabled = true;
                this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
                document.getElementById('gameContainer').appendChild(this.renderer.domElement);
            }
            
            createPlayer() {
                // Enhanced player model
                const playerGroup = new THREE.Group();
                
                // Body
                const bodyGeometry = new THREE.CapsuleGeometry(0.4, 1.4, 4, 8);
                const bodyMaterial = new THREE.MeshLambertMaterial({ color: 0x8B4513 });
                const body = new THREE.Mesh(bodyGeometry, bodyMaterial);
                body.position.y = 0.9;
                body.castShadow = true;
                playerGroup.add(body);
                
                // Head
                const headGeometry = new THREE.SphereGeometry(0.25, 8, 8);
                const headMaterial = new THREE.MeshLambertMaterial({ color: 0xFFDBAC });
                const head = new THREE.Mesh(headGeometry, headMaterial);
                head.position.y = 1.8;
                head.castShadow = true;
                playerGroup.add(head);
                
                this.player = playerGroup;
                this.player.position.set(0, 0, 0);
                this.player.velocity = new THREE.Vector3();
                this.player.speed = 8;
                this.player.runSpeed = 12;
                this.player.jumpPower = 10;
                this.player.onGround = true;
                this.player.health = 100;
                
                this.scene.add(this.player);
            }
            
            createWorld() {
                this.createTerrain();
                this.createCityDistricts();
                this.createTrafficSystem();
                this.createPedestrianSystem();
                this.createBusinesses();
                this.createInteractables();
            }
            
            createTerrain() {
                // Main city ground
                const groundGeometry = new THREE.PlaneGeometry(500, 500, 50, 50);
                const groundMaterial = new THREE.MeshLambertMaterial({ 
                    color: 0x333333,
                    transparent: true,
                    opacity: 0.9
                });
                const ground = new THREE.Mesh(groundGeometry, groundMaterial);
                ground.rotation.x = -Math.PI / 2;
                ground.receiveShadow = true;
                this.scene.add(ground);
                
                // Beach area
                const beachGeometry = new THREE.PlaneGeometry(200, 50);
                const beachMaterial = new THREE.MeshLambertMaterial({ color: 0xF4A460 });
                const beach = new THREE.Mesh(beachGeometry, beachMaterial);
                beach.rotation.x = -Math.PI / 2;
                beach.position.set(200, 0.1, 0);
                beach.receiveShadow = true;
                this.scene.add(beach);
                
                // Water
                const waterGeometry = new THREE.PlaneGeometry(100, 500);
                const waterMaterial = new THREE.MeshLambertMaterial({ 
                    color: 0x006994,
                    transparent: true,
                    opacity: 0.8
                });
                const water = new THREE.Mesh(waterGeometry, waterMaterial);
                water.rotation.x = -Math.PI / 2;
                water.position.set(275, 0.05, 0);
                this.scene.add(water);
            }
            
            createCityDistricts() {
                // Downtown Financial District
                this.createDistrict('downtown', { x: 0, z: 0 }, 20, 'skyscraper');
                
                // Beach District
                this.createDistrict('beach', { x: 150, z: 0 }, 15, 'resort');
                
                // Industrial District
                this.createDistrict('industrial', { x: -100, z: -100 }, 12, 'warehouse');
                
                // Residential Suburbs
                this.createDistrict('residential', { x: 50, z: 100 }, 25, 'house');
                
                // Entertainment District
                this.createDistrict('entertainment', { x: -50, z: 50 }, 18, 'nightclub');
            }
            
            createDistrict(name, center, buildingCount, buildingType) {
                for (let i = 0; i < buildingCount; i++) {
                    const building = this.createBuilding(buildingType);
                    const angle = (i / buildingCount) * Math.PI * 2;
                    const radius = 30 + Math.random() * 50;
                    const x = center.x + Math.cos(angle) * radius + (Math.random() - 0.5) * 20;
                    const z = center.z + Math.sin(angle) * radius + (Math.random() - 0.5) * 20;
                    
                    building.position.set(x, 0, z);
                    building.userData = {
                        type: 'building',
                        buildingType: buildingType,
                        district: name,
                        enterable: true,
                        interior: this.generateInterior(buildingType)
                    };
                    
                    this.world.buildings.push(building);
                    this.scene.add(building);
                }
            }
            
            createBuilding(type) {
                const group = new THREE.Group();
                let height, width, depth, color;
                
                switch (type) {
                    case 'skyscraper':
                        height = 40 + Math.random() * 60;
                        width = 12 + Math.random() * 8;
                        depth = 12 + Math.random() * 8;
                        color = 0x4A4A4A;
                        break;
                    case 'resort':
                        height = 15 + Math.random() * 10;
                        width = 20 + Math.random() * 10;
                        depth = 15 + Math.random() * 5;
                        color = 0xFFB6C1;
                        break;
                    case 'warehouse':
                        height = 8 + Math.random() * 5;
                        width = 25 + Math.random() * 15;
                        depth = 20 + Math.random() * 10;
                        color = 0x8B4513;
                        break;
                    case 'house':
                        height = 6 + Math.random() * 4;
                        width = 8 + Math.random() * 4;
                        depth = 8 + Math.random() * 4;
                        color = 0x98FB98;
                        break;
                    case 'nightclub':
                        height = 12 + Math.random() * 8;
                        width = 15 + Math.random() * 10;
                        depth = 15 + Math.random() * 10;
                        color = 0x8B008B;
                        break;
                    default:
                        height = 10;
                        width = 8;
                        depth = 8;
                        color = 0x666666;
                }
                
                // Main structure
                const buildingGeometry = new THREE.BoxGeometry(width, height, depth);
                const buildingMaterial = new THREE.MeshLambertMaterial({ color: color });
                const buildingMesh = new THREE.Mesh(buildingGeometry, buildingMaterial);
                buildingMesh.position.y = height / 2;
                buildingMesh.castShadow = true;
                buildingMesh.receiveShadow = true;
                group.add(buildingMesh);
                
                // Windows
                this.addWindows(group, width, height, depth);
                
                // Entrance
                this.addEntrance(group, width, height, depth);
                
                // Neon signs for nightlife buildings
                if (type === 'nightclub' || type === 'resort') {
                    this.addNeonSign(group, width, height);
                }
                
                return group;
            }
            
            addWindows(building, width, height, depth) {
                const windowMaterial = new THREE.MeshBasicMaterial({ 
                    color: Math.random() > 0.3 ? 0xFFFF99 : 0x000033,
                    transparent: true,
                    opacity: 0.8
                });
                
                // Front and back windows
                for (let y = 2; y < height - 2; y += 3) {
                    for (let x = -width/2 + 1.5; x < width/2 - 1.5; x += 2) {
                        if (Math.random() > 0.3) {
                            const windowGeometry = new THREE.PlaneGeometry(1.5, 2);
                            const window1 = new THREE.Mesh(windowGeometry, windowMaterial);
                            window1.position.set(x, y, depth/2 + 0.01);
                            building.add(window1);
                            
                            const window2 = new THREE.Mesh(windowGeometry, windowMaterial);
                            window2.position.set(x, y, -depth/2 - 0.01);
                            window2.rotation.y = Math.PI;
                            building.add(window2);
                        }
                    }
                }
                
                // Side windows
                for (let y = 2; y < height - 2; y += 3) {
                    for (let z = -depth/2 + 1.5; z < depth/2 - 1.5; z += 2) {
                        if (Math.random() > 0.3) {
                            const windowGeometry = new THREE.PlaneGeometry(1.5, 2);
                            const window1 = new THREE.Mesh(windowGeometry, windowMaterial);
                            window1.position.set(width/2 + 0.01, y, z);
                            window1.rotation.y = -Math.PI/2;
                            building.add(window1);
                            
                            const window2 = new THREE.Mesh(windowGeometry, windowMaterial);
                            window2.position.set(-width/2 - 0.01, y, z);
                            window2.rotation.y = Math.PI/2;
                            building.add(window2);
                        }
                    }
                }
            }
            
            addEntrance(building, width, height, depth) {
                const doorGeometry = new THREE.BoxGeometry(2, 3, 0.2);
                const doorMaterial = new THREE.MeshLambertMaterial({ color: 0x8B4513 });
                const door = new THREE.Mesh(doorGeometry, doorMaterial);
                door.position.set(0, 1.5, depth/2 + 0.1);
                building.add(door);
                
                // Door frame
                const frameGeometry = new THREE.BoxGeometry(2.5, 3.5, 0.3);
                const frameMaterial = new THREE.MeshLambertMaterial({ color: 0x2F4F4F });
                const frame = new THREE.Mesh(frameGeometry, frameMaterial);
                frame.position.set(0, 1.75, depth/2 + 0.05);
                building.add(frame);
            }
            
            addNeonSign(building, width, height) {
                const signGeometry = new THREE.PlaneGeometry(width * 0.8, 2);
                const signMaterial = new THREE.MeshBasicMaterial({ 
                    color: Math.random() > 0.5 ? 0xFF1493 : 0x00FFFF,
                    transparent: true,
                    opacity: 0.9
                });
                const sign = new THREE.Mesh(signGeometry, signMaterial);
                sign.position.set(0, height * 0.8, width/2 + 0.1);
                building.add(sign);
                
                // Glow effect
                const glowGeometry = new THREE.PlaneGeometry(width * 0.9, 2.5);
                const glowMaterial = new THREE.MeshBasicMaterial({ 
                    color: signMaterial.color,
                    transparent: true,
                    opacity: 0.3
                });
                const glow = new THREE.Mesh(glowGeometry, glowMaterial);
                glow.position.set(0, height * 0.8, width/2 + 0.05);
                building.add(glow);
            }
            
            generateInterior(buildingType) {
                const interior = {
                    rooms: [],
                    npcs: [],
                    interactables: []
                };
                
                switch (buildingType) {
                    case 'nightclub':
                        interior.rooms = ['main_floor', 'vip_area', 'bar', 'bathroom', 'office'];
                        interior.npcs = ['bartender', 'bouncer', 'dj', 'customers'];
                        interior.interactables = ['bar', 'dance_floor', 'vip_table', 'atm'];
                        break;
                    case 'house':
                        interior.rooms = ['living_room', 'kitchen', 'bedroom', 'bathroom'];
                        interior.npcs = ['resident'];
                        interior.interactables = ['tv', 'fridge', 'bed', 'computer'];
                        break;
                    case 'warehouse':
                        interior.rooms = ['storage', 'office', 'loading_dock'];
                        interior.npcs = ['worker', 'supervisor'];
                        interior.interactables = ['crates', 'forklift', 'computer'];
                        break;
                    case 'skyscraper':
                        interior.rooms = ['lobby', 'offices', 'elevator', 'rooftop'];
                        interior.npcs = ['security', 'employees', 'manager'];
                        interior.interactables = ['elevator', 'computer', 'safe'];
                        break;
                    case 'resort':
                        interior.rooms = ['lobby', 'pool', 'restaurant', 'rooms'];
                        interior.npcs = ['concierge', 'guests', 'staff'];
                        interior.interactables = ['pool', 'bar', 'slot_machines'];
                        break;
                }
                
                return interior;
            }
            
            createTrafficSystem() {
                // Create roads
                this.createRoads();
                
                // Spawn traffic vehicles
                for (let i = 0; i < 30; i++) {
                    const vehicle = this.createTrafficVehicle();
                    this.world.traffic.push(vehicle);
                    this.scene.add(vehicle);
                }
            }
            
            createRoads() {
                const roadMaterial = new THREE.MeshLambertMaterial({ color: 0x2F2F2F });
                
                // Main streets
                for (let i = -200; i <= 200; i += 50) {
                    // Horizontal roads
                    const roadH = new THREE.Mesh(
                        new THREE.PlaneGeometry(400, 8),
                        roadMaterial
                    );
                    roadH.rotation.x = -Math.PI / 2;
                    roadH.position.set(0, 0.02, i);
                    this.scene.add(roadH);
                    
                    // Vertical roads
                    const roadV = new THREE.Mesh(
                        new THREE.PlaneGeometry(8, 400),
                        roadMaterial
                    );
                    roadV.rotation.x = -Math.PI / 2;
                    roadV.position.set(i, 0.02, 0);
                    this.scene.add(roadV);
                }
            }
            
            createTrafficVehicle() {
                const vehicle = this.createVehicle('traffic');
                
                // Random position on road
                const roads = [
                    { x: Math.random() * 400 - 200, z: Math.floor(Math.random() * 9) * 50 - 200 },
                    { x: Math.floor(Math.random() * 9) * 50 - 200, z: Math.random() * 400 - 200 }
                ];
                const road = roads[Math.floor(Math.random() * roads.length)];
                vehicle.position.set(road.x, 0.5, road.z);
                
                // Traffic AI
                vehicle.userData.ai = {
                    type: 'traffic',
                    speed: 5 + Math.random() * 10,
                    direction: Math.random() * Math.PI * 2,
                    targetSpeed: 5 + Math.random() * 10
                };
                
                return vehicle;
            }
            
            createPedestrianSystem() {
                // Spawn pedestrians
                for (let i = 0; i < 50; i++) {
                    const pedestrian = this.createPedestrian();
                    this.world.pedestrians.push(pedestrian);
                    this.scene.add(pedestrian);
                }
            }
            
            createPedestrian() {
                const pedestrian = this.createNPC();
                
                // Random position on sidewalk
                pedestrian.position.set(
                    Math.random() * 300 - 150,
                    0,
                    Math.random() * 300 - 150
                );
                
                // Pedestrian AI
                pedestrian.userData.ai = {
                    type: 'pedestrian',
                    speed: 1 + Math.random() * 2,
                    routine: this.generateDailyRoutine(),
                    currentActivity: 'walking',
                    destination: null,
                    personality: this.generatePersonality()
                };
                
                return pedestrian;
            }
            
            generateDailyRoutine() {
                return {
                    morning: 'work',
                    afternoon: 'shopping',
                    evening: 'entertainment',
                    night: 'home'
                };
            }
            
            generatePersonality() {
                return {
                    aggression: Math.random(),
                    friendliness: Math.random(),
                    wealth: Math.random(),
                    criminal: Math.random() > 0.8
                };
            }
            
            createBusinesses() {
                // Gun stores
                this.createBusiness('gun_store', { x: 50, z: 50 });
                this.createBusiness('gun_store', { x: -80, z: -30 });
                
                // Clothing stores
                this.createBusiness('clothing_store', { x: 30, z: -60 });
                this.createBusiness('clothing_store', { x: -40, z: 70 });
                
                // Car dealerships
                this.createBusiness('car_dealership', { x: 100, z: -100 });
                
                // Banks
                this.createBusiness('bank', { x: 0, z: 0 });
                this.createBusiness('bank', { x: -120, z: 80 });
                
                // Restaurants
                this.createBusiness('restaurant', { x: 20, z: 30 });
                this.createBusiness('restaurant', { x: -60, z: -80 });
                
                // Nightclubs
                this.createBusiness('nightclub', { x: -30, z: 40 });
                this.createBusiness('nightclub', { x: 80, z: -50 });
                
                // Drug dealers (hidden)
                this.createBusiness('drug_dealer', { x: -150, z: -150 });
            }
            
            createBusiness(type, position) {
                const business = {
                    type: type,
                    position: position,
                    inventory: this.generateBusinessInventory(type),
                    prices: this.generateBusinessPrices(type),
                    hours: this.generateBusinessHours(type),
                    employees: this.generateEmployees(type)
                };
                
                // Create visual marker
                const marker = this.createBusinessMarker(type);
                marker.position.set(position.x, 3, position.z);
                marker.userData = {
                    type: 'business',
                    businessType: type,
                    business: business,
                    interactable: true
                };
                
                this.world.interactables.push(marker);
                this.scene.add(marker);
            }
            
            generateBusinessInventory(type) {
                const inventories = {
                    gun_store: ['pistol', 'shotgun', 'rifle', 'ammo', 'armor'],
                    clothing_store: ['shirt', 'pants', 'shoes', 'hat', 'jacket'],
                    car_dealership: ['sedan', 'sports_car', 'suv', 'motorcycle'],
                    bank: ['loan', 'account', 'safe_deposit'],
                    restaurant: ['food', 'drinks'],
                    nightclub: ['drinks', 'vip_access'],
                    drug_dealer: ['weed', 'cocaine', 'pills']
                };
                return inventories[type] || [];
            }
            
            generateBusinessPrices(type) {
                const prices = {
                    gun_store: { pistol: 500, shotgun: 800, rifle: 1200, ammo: 50, armor: 200 },
                    clothing_store: { shirt: 50, pants: 80, shoes: 120, hat: 30, jacket: 150 },
                    car_dealership: { sedan: 15000, sports_car: 50000, suv: 25000, motorcycle: 8000 },
                    restaurant: { food: 20, drinks: 10 },
                    nightclub: { drinks: 15, vip_access: 100 },
                    drug_dealer: { weed: 100, cocaine: 500, pills: 50 }
                };
                return prices[type] || {};
            }
            
            generateBusinessHours(type) {
                const hours = {
                    gun_store: { open: 9, close: 18 },
                    clothing_store: { open: 10, close: 20 },
                    car_dealership: { open: 9, close: 19 },
                    bank: { open: 9, close: 17 },
                    restaurant: { open: 11, close: 23 },
                    nightclub: { open: 20, close: 4 },
                    drug_dealer: { open: 0, close: 24 } // Always open
                };
                return hours[type] || { open: 9, close: 17 };
            }
            
            generateEmployees(type) {
                const employees = {
                    gun_store: ['clerk', 'security'],
                    clothing_store: ['cashier', 'manager'],
                    car_dealership: ['salesman', 'mechanic'],
                    bank: ['teller', 'manager', 'security'],
                    restaurant: ['waiter', 'chef', 'manager'],
                    nightclub: ['bartender', 'bouncer', 'dj'],
                    drug_dealer: ['dealer']
                };
                return employees[type] || ['employee'];
            }
            
            createBusinessMarker(type) {
                const group = new THREE.Group();
                
                let color, size;
                switch (type) {
                    case 'gun_store':
                        color = 0xFF4500;
                        size = 1;
                        break;
                    case 'clothing_store':
                        color = 0xFF1493;
                        size = 0.8;
                        break;
                    case 'car_dealership':
                        color = 0x00FFFF;
                        size = 1.2;
                        break;
                    case 'bank':
                        color = 0x00FF00;
                        size = 1.5;
                        break;
                    case 'restaurant':
                        color = 0xFFD700;
                        size = 0.7;
                        break;
                    case 'nightclub':
                        color = 0x8B008B;
                        size = 1;
                        break;
                    case 'drug_dealer':
                        color = 0x228B22;
                        size = 0.5;
                        break;
                    default:
                        color = 0xFFFFFF;
                        size = 0.8;
                }
                
                const markerGeometry = new THREE.SphereGeometry(size, 8, 8);
                const markerMaterial = new THREE.MeshBasicMaterial({ 
                    color: color,
                    transparent: true,
                    opacity: 0.8
                });
                const marker = new THREE.Mesh(markerGeometry, markerMaterial);
                marker.position.y = Math.sin(Date.now() * 0.005) * 0.5;
                group.add(marker);
                
                // Glow effect
                const glowGeometry = new THREE.SphereGeometry(size * 1.5, 8, 8);
                const glowMaterial = new THREE.MeshBasicMaterial({ 
                    color: color,
                    transparent: true,
                    opacity: 0.2
                });
                const glow = new THREE.Mesh(glowGeometry, glowMaterial);
                group.add(glow);
                
                return group;
            }
            
            createInteractables() {
                // ATMs
                for (let i = 0; i < 10; i++) {
                    const atm = this.createATM();
                    atm.position.set(
                        Math.random() * 200 - 100,
                        0,
                        Math.random() * 200 - 100
                    );
                    this.world.interactables.push(atm);
                    this.scene.add(atm);
                }
                
                // Vending machines
                for (let i = 0; i < 15; i++) {
                    const vending = this.createVendingMachine();
                    vending.position.set(
                        Math.random() * 200 - 100,
                        0,
                        Math.random() * 200 - 100
                    );
                    this.world.interactables.push(vending);
                    this.scene.add(vending);
                }
            }
            
            createATM() {
                const group = new THREE.Group();
                
                const atmGeometry = new THREE.BoxGeometry(1, 2, 0.5);
                const atmMaterial = new THREE.MeshLambertMaterial({ color: 0x2F4F4F });
                const atm = new THREE.Mesh(atmGeometry, atmMaterial);
                atm.position.y = 1;
                group.add(atm);
                
                // Screen
                const screenGeometry = new THREE.PlaneGeometry(0.6, 0.4);
                const screenMaterial = new THREE.MeshBasicMaterial({ color: 0x00FF00 });
                const screen = new THREE.Mesh(screenGeometry, screenMaterial);
                screen.position.set(0, 1.2, 0.26);
                group.add(screen);
                
                group.userData = {
                    type: 'atm',
                    interactable: true
                };
                
                return group;
            }
            
            createVendingMachine() {
                const group = new THREE.Group();
                
                const machineGeometry = new THREE.BoxGeometry(1.2, 2.5, 0.8);
                const machineMaterial = new THREE.MeshLambertMaterial({ color: 0xFF4500 });
                const machine = new THREE.Mesh(machineGeometry, machineMaterial);
                machine.position.y = 1.25;
                group.add(machine);
                
                group.userData = {
                    type: 'vending_machine',
                    interactable: true,
                    items: ['soda', 'chips', 'candy'],
                    prices: { soda: 2, chips: 3, candy: 1 }
                };
                
                return group;
            }
            
            createVehicle(type = 'player') {
                const group = new THREE.Group();
                
                // Vehicle types with different stats
                const vehicleTypes = {
                    sedan: { speed: 80, acceleration: 0.5, handling: 0.7, color: 0x4169E1 },
                    sports_car: { speed: 120, acceleration: 0.9, handling: 0.9, color: 0xFF1493 },
                    suv: { speed: 60, acceleration: 0.3, handling: 0.5, color: 0x2F4F4F },
                    motorcycle: { speed: 100, acceleration: 0.8, handling: 1.0, color: 0x000000 },
                    truck: { speed: 50, acceleration: 0.2, handling: 0.3, color: 0x8B4513 },
                    police: { speed: 90, acceleration: 0.7, handling: 0.8, color: 0x0000FF },
                    ambulance: { speed: 70, acceleration: 0.4, handling: 0.6, color: 0xFFFFFF },
                    taxi: { speed: 70, acceleration: 0.5, handling: 0.6, color: 0xFFD700 }
                };
                
                const vehicleType = type === 'traffic' ? 
                    Object.keys(vehicleTypes)[Math.floor(Math.random() * 5)] : 
                    'sports_car';
                
                const stats = vehicleTypes[vehicleType];
                
                // Car body
                const bodyGeometry = new THREE.BoxGeometry(4, 1.5, 2);
                const bodyMaterial = new THREE.MeshPhongMaterial({ 
                    color: stats.color,
                    shininess: 100,
                    specular: 0xffffff
                });
                const body = new THREE.Mesh(bodyGeometry, bodyMaterial);
                body.position.y = 0.75;
                body.castShadow = true;
                group.add(body);
                
                // Windshield
                const windshieldGeometry = new THREE.PlaneGeometry(3.5, 1.2);
                const windshieldMaterial = new THREE.MeshBasicMaterial({ 
                    color: 0x87CEEB,
                    transparent: true,
                    opacity: 0.3
                });
                const windshield = new THREE.Mesh(windshieldGeometry, windshieldMaterial);
                windshield.position.set(0, 1.2, 0.8);
                windshield.rotation.x = -0.2;
                group.add(windshield);
                
                // Wheels
                const wheelGeometry = new THREE.CylinderGeometry(0.4, 0.4, 0.3, 8);
                const wheelMaterial = new THREE.MeshLambertMaterial({ color: 0x222222 });
                
                const wheelPositions = [
                    [-1.5, 0.4, -0.8], [1.5, 0.4, -0.8],
                    [-1.5, 0.4, 0.8], [1.5, 0.4, 0.8]
                ];
                
                wheelPositions.forEach(pos => {
                    const wheel = new THREE.Mesh(wheelGeometry, wheelMaterial);
                    wheel.position.set(...pos);
                    wheel.rotation.z = Math.PI / 2;
                    wheel.castShadow = true;
                    group.add(wheel);
                });
                
                // Headlights
                const lightGeometry = new THREE.SphereGeometry(0.2, 8, 8);
                const lightMaterial = new THREE.MeshBasicMaterial({ 
                    color: 0xFFFFFF,
                    transparent: true,
                    opacity: 0.9
                });
                
                const leftLight = new THREE.Mesh(lightGeometry, lightMaterial);
                leftLight.position.set(-1, 1, 2.1);
                group.add(leftLight);
                
                const rightLight = new THREE.Mesh(lightGeometry, lightMaterial);
                rightLight.position.set(1, 1, 2.1);
                group.add(rightLight);
                
                // Vehicle properties
                group.userData = {
                    type: 'vehicle',
                    vehicleType: vehicleType,
                    stats: stats,
                    interactable: true,
                    damage: 0,
                    fuel: 100,
                    locked: Math.random() > 0.7,
                    owner: type === 'traffic' ? 'npc' : null,
                    speed: 0
                };
                
                return group;
            }
            
            createNPC() {
                const group = new THREE.Group();
                
                // NPC appearance variety
                const skinColors = [0xFFDBAC, 0xF1C27D, 0xE0AC69, 0xC68642, 0x8D5524];
                const clothingColors = [0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00, 0xFF00FF, 0x00FFFF];
                
                // Body
                const bodyGeometry = new THREE.CapsuleGeometry(0.3, 1.2, 4, 8);
                const bodyMaterial = new THREE.MeshLambertMaterial({ 
                    color: clothingColors[Math.floor(Math.random() * clothingColors.length)]
                });
                const body = new THREE.Mesh(bodyGeometry, bodyMaterial);
                body.position.y = 0.8;
                body.castShadow = true;
                group.add(body);
                
                // Head
                const headGeometry = new THREE.SphereGeometry(0.2, 8, 8);
                const headMaterial = new THREE.MeshLambertMaterial({ 
                    color: skinColors[Math.floor(Math.random() * skinColors.length)]
                });
                const head = new THREE.Mesh(headGeometry, headMaterial);
                head.position.y = 1.5;
                head.castShadow = true;
                group.add(head);
                
                // NPC properties
                group.userData = {
                    type: 'npc',
                    interactable: true,
                    name: this.generateName(),
                    occupation: this.generateOccupation(),
                    personality: this.generatePersonality(),
                    dialogue: this.generateDialogue(),
                    relationship: 0, // -100 to 100
                    criminal: Math.random() > 0.8,
                    wealth: Math.random() * 10000,
                    health: 100
                };
                
                return group;
            }
            
            generateName() {
                const firstNames = ['Alex', 'Jordan', 'Casey', 'Morgan', 'Taylor', 'Jamie', 'Riley', 'Avery', 'Tony', 'Maria', 'Carlos', 'Sofia', 'Diego', 'Isabella'];
                const lastNames = ['Smith', 'Johnson', 'Williams', 'Brown', 'Jones', 'Garcia', 'Miller', 'Davis', 'Rodriguez', 'Martinez', 'Hernandez', 'Lopez'];
                return firstNames[Math.floor(Math.random() * firstNames.length)] + ' ' + 
                       lastNames[Math.floor(Math.random() * lastNames.length)];
            }
            
            generateOccupation() {
                const occupations = ['Teacher', 'Doctor', 'Lawyer', 'Engineer', 'Artist', 'Chef', 'Police Officer', 
                                   'Firefighter', 'Nurse', 'Mechanic', 'Salesperson', 'Manager', 'Student', 'Retired',
                                   'Bartender', 'Bouncer', 'DJ', 'Dealer', 'Gangster', 'Businessman'];
                return occupations[Math.floor(Math.random() * occupations.length)];
            }
            
            generateDialogue() {
                return {
                    greeting: ["Hello there!", "Hey, how's it going?", "Good day!", "What's up?", "Nice to meet you!"],
                    casual: ["Nice weather today.", "This city is crazy.", "Have you seen the news?", "Traffic is terrible.", "Love the nightlife here."],
                    hostile: ["Get away from me!", "I don't want any trouble.", "Leave me alone!", "Back off!", "Call the cops!"],
                    scared: ["Please don't hurt me!", "I'll call the police!", "Help!", "Someone help me!", "Don't shoot!"],
                    friendly: ["You seem cool.", "Want to hang out?", "I like your style.", "You're alright.", "Let's be friends."]
                };
            }
            
            createLighting() {
                // Ambient light
                const ambientLight = new THREE.AmbientLight(0x404040, 0.4);
                this.scene.add(ambientLight);
                
                // Sun/Moon light
                this.directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
                this.directionalLight.position.set(100, 100, 50);
                this.directionalLight.castShadow = true;
                this.directionalLight.shadow.mapSize.width = 4096;
                this.directionalLight.shadow.mapSize.height = 4096;
                this.directionalLight.shadow.camera.near = 0.5;
                this.directionalLight.shadow.camera.far = 500;
                this.directionalLight.shadow.camera.left = -200;
                this.directionalLight.shadow.camera.right = 200;
                this.directionalLight.shadow.camera.top = 200;
                this.directionalLight.shadow.camera.bottom = -200;
                this.scene.add(this.directionalLight);
                
                // Street lights
                this.createStreetLights();
                
                // Building lights
                this.createBuildingLights();
            }
            
            createStreetLights() {
                for (let x = -200; x <= 200; x += 25) {
                    for (let z = -200; z <= 200; z += 25) {
                        if (Math.random() > 0.7) {
                            const light = new THREE.PointLight(0xFFE4B5, 1, 30);
                            light.position.set(x, 8, z);
                            this.scene.add(light);
                            
                            // Light pole
                            const poleGeometry = new THREE.CylinderGeometry(0.1, 0.1, 8);
                            const poleMaterial = new THREE.MeshLambertMaterial({ color: 0x333333 });
                            const pole = new THREE.Mesh(poleGeometry, poleMaterial);
                            pole.position.set(x, 4, z);
                            pole.castShadow = true;
                            this.scene.add(pole);
                        }
                    }
                }
            }
            
            createBuildingLights() {
                // Neon lights for nightlife
                const neonColors = [0xFF1493, 0x00FFFF, 0xFF4500, 0x8B008B, 0x00FF00];
                
                for (let i = 0; i < 50; i++) {
                    const light = new THREE.PointLight(
                        neonColors[Math.floor(Math.random() * neonColors.length)], 
                        2, 
                        40
                    );
                    light.position.set(
                        (Math.random() - 0.5) * 300,
                        5 + Math.random() * 20,
                        (Math.random() - 0.5) * 300
                    );
                    this.scene.add(light);
                }
            }
            
            setupControls() {
                // Keyboard events
                document.addEventListener('keydown', (event) => {
                    this.keys[event.code] = true;
                    this.handleKeyPress(event.code);
                });
                
                document.addEventListener('keyup', (event) => {
                    this.keys[event.code] = false;
                });
                
                // Mouse events
                document.addEventListener('click', () => {
                    if (!this.isPointerLocked && !this.phoneOpen && !this.menuOpen) {
                        this.renderer.domElement.requestPointerLock();
                    }
                });
                
                document.addEventListener('pointerlockchange', () => {
                    this.isPointerLocked = document.pointerLockElement === this.renderer.domElement;
                });
                
                document.addEventListener('mousemove', (event) => {
                    if (this.isPointerLocked) {
                        this.mouse.x += event.movementX * this.mouse.sensitivity;
                        this.mouse.y += event.movementY * this.mouse.sensitivity;
                        this.mouse.y = Math.max(-Math.PI/2, Math.min(Math.PI/2, this.mouse.y));
                    }
                });
                
                // Window resize
                window.addEventListener('resize', () => {
                    this.camera.aspect = window.innerWidth / window.innerHeight;
                    this.camera.updateProjectionMatrix();
                    this.renderer.setSize(window.innerWidth, window.innerHeight);
                });
            }
            
            handleKeyPress(code) {
                switch (code) {
                    case 'KeyE':
                        this.handleInteraction();
                        break;
                    case 'KeyF':
                        this.handleVehicleEntry();
                        break;
                    case 'Tab':
                        event.preventDefault();
                        this.togglePhone();
                        break;
                    case 'KeyR':
                        this.toggleRadio();
                        break;
                    case 'KeyM':
                        this.toggleMap();
                        break;
                    case 'KeyI':
                        this.toggleInventory();
                        break;
                    case 'Escape':
                        this.closeAllMenus();
                        break;
                    case 'KeyG':
                        this.throwGrenade();
                        break;
                    case 'KeyC':
                        this.toggleCrouch();
                        break;
                }
            }
            
            startSystems() {
                // Time system
                setInterval(() => {
                    this.updateTimeSystem();
                }, 1000);
                
                // Weather system
                setInterval(() => {
                    this.updateWeatherSystem();
                }, 30000);
                
                // Economy system
                setInterval(() => {
                    this.updateEconomySystem();
                }, 60000);
                
                // NPC AI system
                setInterval(() => {
                    this.updateNPCAI();
                }, 100);
                
                // Traffic AI system
                setInterval(() => {
                    this.updateTrafficAI();
                }, 50);
                
                // Police system
                setInterval(() => {
                    this.updatePoliceSystem();
                }, 200);
            }
            
            updateTimeSystem() {
                this.timeSystem.minute += this.timeSystem.speed;
                if (this.timeSystem.minute >= 60) {
                    this.timeSystem.minute = 0;
                    this.timeSystem.hour++;
                    if (this.timeSystem.hour >= 24) {
                        this.timeSystem.hour = 0;
                        this.timeSystem.day++;
                    }
                }
                
                // Update lighting based on time
                this.updateLightingForTime();
                
                // Update HUD
                this.updateTimeDisplay();
            }
            
            updateWeatherSystem() {
                const weatherTypes = ['sunny', 'cloudy', 'rainy', 'stormy', 'foggy'];
                const currentIndex = weatherTypes.indexOf(this.weatherSystem.current);
                
                // Weather can change gradually
                if (Math.random() < 0.3) {
                    const newIndex = Math.max(0, Math.min(weatherTypes.length - 1, 
                        currentIndex + (Math.random() > 0.5 ? 1 : -1)));
                    this.weatherSystem.current = weatherTypes[newIndex];
                    
                    this.updateWeatherEffects();
                    this.showNotification('Weather Update', `Weather changed to ${this.weatherSystem.current}`, 'info');
                }
            }
            
            updateWeatherEffects() {
                const rainEffect = document.getElementById('rainEffect');
                
                switch (this.weatherSystem.current) {
                    case 'rainy':
                    case 'stormy':
                        rainEffect.classList.add('active');
                        this.scene.fog.density = 0.01;
                        break;
                    case 'foggy':
                        rainEffect.classList.remove('active');
                        this.scene.fog.density = 0.02;
                        break;
                    default:
                        rainEffect.classList.remove('active');
                        this.scene.fog.density = 0.005;
                }
            }
            
            updateEconomySystem() {
                // Update stock prices
                Object.keys(this.economySystem.stockPrices).forEach(stock => {
                    const change = (Math.random() - 0.5) * 0.1;
                    this.economySystem.stockPrices[stock] *= (1 + change);
                    this.economySystem.stockPrices[stock] = Math.max(10, this.economySystem.stockPrices[stock]);
                });
                
                // Generate business income
                this.gameState.businesses.forEach(business => {
                    const income = business.dailyIncome * (this.timeSystem.speed / 1440); // Per minute
                    this.gameState.money += income;
                });
            }
            
            updateNPCAI() {
                this.world.pedestrians.forEach(npc => {
                    if (!npc.userData.ai) return;
                    
                    const ai = npc.userData.ai;
                    
                    // Update based on time of day
                    const currentActivity = this.getCurrentActivity(ai.routine);
                    if (ai.currentActivity !== currentActivity) {
                        ai.currentActivity = currentActivity;
                        ai.destination = this.getDestinationForActivity(currentActivity);
                    }
                    
                    // Move towards destination
                    if (ai.destination) {
                        const direction = new THREE.Vector3()
                            .subVectors(ai.destination, npc.position)
                            .normalize();
                        
                        npc.position.add(direction.multiplyScalar(ai.speed * 0.016));
                        
                        // Face movement direction
                        npc.lookAt(ai.destination);
                        
                        // Check if reached destination
                        if (npc.position.distanceTo(ai.destination) < 2) {
                            ai.destination = null;
                        }
                    } else {
                        // Idle behavior
                        if (Math.random() < 0.01) {
                            ai.destination = new THREE.Vector3(
                                npc.position.x + (Math.random() - 0.5) * 20,
                                0,
                                npc.position.z + (Math.random() - 0.5) * 20
                            );
                        }
                    }
                    
                    // React to player
                    const distanceToPlayer = npc.position.distanceTo(this.player.position);
                    if (distanceToPlayer < 10) {
                        this.handleNPCPlayerInteraction(npc, distanceToPlayer);
                    }
                });
            }
            
            getCurrentActivity(routine) {
                const hour = this.timeSystem.hour;
                if (hour >= 6 && hour < 12) return routine.morning;
                if (hour >= 12 && hour < 18) return routine.afternoon;
                if (hour >= 18 && hour < 22) return routine.evening;
                return routine.night;
            }
            
            getDestinationForActivity(activity) {
                const destinations = {
                    work: new THREE.Vector3(Math.random() * 100 - 50, 0, Math.random() * 100 - 50),
                    shopping: new THREE.Vector3(30, 0, -60), // Clothing store
                    entertainment: new THREE.Vector3(-30, 0, 40), // Nightclub
                    home: new THREE.Vector3(50, 0, 100) // Residential area
                };
                return destinations[activity] || null;
            }
            
            handleNPCPlayerInteraction(npc, distance) {
                const personality = npc.userData.personality;
                
                if (this.gameState.wantedLevel > 0 && Math.random() < 0.1) {
                    // NPC might call police
                    if (personality.friendliness < 0.3) {
                        this.showNotification('Police Alert', 'Someone called the police!', 'warning');
                        // Increase wanted level slightly
                        this.gameState.wantedLevel = Math.min(5, this.gameState.wantedLevel + 0.1);
                    }
                }
                
                // NPCs react to player's reputation
                if (this.gameState.respect > 50 && distance < 5) {
                    if (Math.random() < 0.05) {
                        this.showNotification('Respect', `${npc.userData.name}: "Hey, you're famous!"`, 'success');
                    }
                }
            }
            
            updateTrafficAI() {
                this.world.traffic.forEach(vehicle => {
                    if (!vehicle.userData.ai) return;
                    
                    const ai = vehicle.userData.ai;
                    
                    // Simple traffic movement
                    const direction = new THREE.Vector3(
                        Math.cos(ai.direction),
                        0,
                        Math.sin(ai.direction)
                    );
                    
                    vehicle.position.add(direction.multiplyScalar(ai.speed * 0.016));
                    vehicle.rotation.y = ai.direction;
                    
                    // Change direction at intersections
                    if (Math.random() < 0.01) {
                        ai.direction += (Math.random() - 0.5) * Math.PI / 2;
                    }
                    
                    // Avoid collisions with player
                    const distanceToPlayer = vehicle.position.distanceTo(this.player.position);
                    if (distanceToPlayer < 5) {
                        const avoidDirection = new THREE.Vector3()
                            .subVectors(vehicle.position, this.player.position)
                            .normalize();
                        vehicle.position.add(avoidDirection.multiplyScalar(2));
                    }
                    
                    // Keep vehicles in bounds
                    if (Math.abs(vehicle.position.x) > 200 || Math.abs(vehicle.position.z) > 200) {
                        ai.direction += Math.PI;
                    }
                });
            }
            
            updatePoliceSystem() {
                if (this.gameState.wantedLevel > 0) {
                    // Decrease wanted level slowly over time
                    this.gameState.wantedLevel = Math.max(0, this.gameState.wantedLevel - 0.01);
                    
                    // Spawn police if wanted level is high
                    if (this.gameState.wantedLevel > 2 && Math.random() < 0.1) {
                        this.spawnPoliceVehicle();
                    }
                }
            }
            
            spawnPoliceVehicle() {
                const police = this.createVehicle('police');
                police.userData.vehicleType = 'police';
                police.userData.ai = {
                    type: 'police',
                    target: this.player,
                    speed: 15,
                    aggressive: true
                };
                
                // Spawn near player but not too close
                const angle = Math.random() * Math.PI * 2;
                const distance = 50 + Math.random() * 50;
                police.position.set(
                    this.player.position.x + Math.cos(angle) * distance,
                    0.5,
                    this.player.position.z + Math.sin(angle) * distance
                );
                
                this.world.traffic.push(police);
                this.scene.add(police);
                
                this.showNotification('Police', 'Police are pursuing you!', 'danger');
            }
            
            startLoading() {
                const loadingScreen = document.getElementById('loadingScreen');
                const loadingProgress = document.getElementById('loadingProgress');
                const loadingTips = document.getElementById('loadingTips');
                
                const tips = [
                    "You can enter any building by walking up to the door and pressing E",
                    "NPCs have daily routines and will react differently based on the time of day",
                    "Your reputation affects how NPCs treat you",
                    "Weather affects driving conditions and NPC behavior",
                    "You can buy properties and businesses to generate passive income",
                    "Each NPC has a unique personality and backstory",
                    "Police will investigate crimes and search for you",
                    "You can customize your character at clothing stores",
                    "Vehicles have realistic damage and fuel systems",
                    "The stock market fluctuates based on your actions",
                    "Build relationships with NPCs to unlock new opportunities",
                    "Different districts have different crime rates and police presence",
                    "Time of day affects business hours and NPC availability",
                    "Your wanted level affects how NPCs and police react to you"
                ];
                
                let progress = 0;
                let tipIndex = 0;
                
                const loadingInterval = setInterval(() => {
                    progress += Math.random() * 8;
                    if (progress >= 100) {
                        progress = 100;
                        clearInterval(loadingInterval);
                        
                        setTimeout(() => {
                            loadingScreen.classList.add('fade-out');
                            setTimeout(() => {
                                loadingScreen.style.display = 'none';
                                this.showWelcomeMessage();
                                this.animate();
                            }, 1000);
                        }, 500);
                    }
                    
                    loadingProgress.style.width = progress + '%';
                    
                    // Change tips
                    if (Math.random() < 0.3) {
                        tipIndex = (tipIndex + 1) % tips.length;
                        loadingTips.textContent = tips[tipIndex];
                    }
                }, 150);
            }
            
            showWelcomeMessage() {
                this.showNotification(
                    'Welcome to Vice Dominion',
                    'The most realistic open-world crime simulation. Every choice matters.',
                    'success'
                );
                
                setTimeout(() => {
                    const controlsHelp = document.getElementById('controlsHelp');
                    controlsHelp.classList.add('visible');
                    setTimeout(() => {
                        controlsHelp.classList.remove('visible');
                    }, 8000);
                }, 2000);
                
                // Show first mission
                setTimeout(() => {
                    const missionObjective = document.getElementById('missionObjective');
                    missionObjective.classList.add('visible');
                }, 5000);
            }
            
            handlePlayerMovement() {
                if (this.phoneOpen || this.menuOpen) return;
                
                const isRunning = this.keys['ShiftLeft'] || this.keys['ShiftRight'];
                const isCrouching = this.keys['ControlLeft'] || this.keys['ControlRight'];
                
                let moveSpeed = this.player.speed;
                if (isRunning && this.gameState.stamina > 0) {
                    moveSpeed = this.player.runSpeed;
                    this.gameState.stamina = Math.max(0, this.gameState.stamina - 0.2);
                } else {
                    this.gameState.stamina = Math.min(100, this.gameState.stamina + 0.1);
                }
                
                if (isCrouching) moveSpeed = this.player.speed * 0.5;
                
                const direction = new THREE.Vector3();
                
                // Calculate movement direction
                if (this.keys['KeyW']) direction.z -= 1;
                if (this.keys['KeyS']) direction.z += 1;
                if (this.keys['KeyA']) direction.x -= 1;
                if (this.keys['KeyD']) direction.x += 1;
                
                if (direction.length() > 0) {
                    direction.normalize();
                    
                    // Apply camera rotation to movement
                    const cameraDirection = new THREE.Vector3();
                    this.camera.getWorldDirection(cameraDirection);
                    const angle = Math.atan2(cameraDirection.x, cameraDirection.z);
                    
                    const rotatedDirection = new THREE.Vector3(
                        direction.x * Math.cos(angle) - direction.z * Math.sin(angle),
                        0,
                        direction.x * Math.sin(angle) + direction.z * Math.cos(angle)
                    );
                    
                    this.player.velocity.x = rotatedDirection.x * moveSpeed;
                    this.player.velocity.z = rotatedDirection.z * moveSpeed;
                } else {
                    this.player.velocity.x *= 0.8;
                    this.player.velocity.z *= 0.8;
                }
                
                // Jumping
                if (this.keys['Space'] && this.player.onGround) {
                    this.player.velocity.y = this.player.jumpPower;
                    this.player.onGround = false;
                }
                
                // Gravity
                this.player.velocity.y -= 0.5;
                
                // Apply movement
                this.player.position.add(this.player.velocity.clone().multiplyScalar(1/60));
                
                // Ground collision
                if (this.player.position.y <= 0) {
                    this.player.position.y = 0;
                    this.player.velocity.y = 0;
                    this.player.onGround = true;
                }
                
                // Update camera
                this.updateCamera();
                
                // Check for interactions
                this.checkInteractions();
            }
            
            updateCamera() {
                if (!this.gameState.isInVehicle) {
                    this.camera.position.copy(this.player.position);
                    this.camera.position.y += 1.7;
                    
                    // Apply mouse look
                    this.camera.rotation.x = this.mouse.y;
                    this.camera.rotation.y = this.mouse.x;
                }
            }
            
            checkInteractions() {
                this.currentInteractable = null;
                let nearestDistance = Infinity;
                
                // Check all interactable objects
                const allInteractables = [
                    ...this.world.buildings,
                    ...this.world.vehicles,
                    ...this.world.pedestrians,
                    ...this.world.interactables
                ];
                
                allInteractables.forEach(obj => {
                    if (obj.userData && obj.userData.interactable) {
                        const distance = this.player.position.distanceTo(obj.position);
                        if (distance < 5 && distance < nearestDistance) {
                            this.currentInteractable = obj;
                            nearestDistance = distance;
                        }
                    }
                });
                
                // Update interaction prompt
                this.updateInteractionPrompt();
            }
            
            updateInteractionPrompt() {
                const prompt = document.getElementById('interactionPrompt');
                
                if (this.currentInteractable) {
                    const type = this.currentInteractable.userData.type;
                    let text = 'Press E to interact';
                    
                    switch (type) {
                        case 'vehicle':
                            text = 'Press F to enter vehicle';
                            break;
                        case 'building':
                            text = 'Press E to enter building';
                            break;
                        case 'npc':
                            text = `Press E to talk to ${this.currentInteractable.userData.name}`;
                            break;
                        case 'business':
                            text = `Press E to enter ${this.currentInteractable.userData.businessType.replace('_', ' ')}`;
                            break;
                        case 'atm':
                            text = 'Press E to use ATM';
                            break;
                        case 'vending_machine':
                            text = 'Press E to buy snacks';
                            break;
                    }
                    
                    prompt.textContent = text;
                    prompt.classList.add('visible');
                    
                    // Position prompt above interactable
                    const screenPos = this.currentInteractable.position.clone().project(this.camera);
                    const x = (screenPos.x * 0.5 + 0.5) * window.innerWidth;
                    const y = (-screenPos.y * 0.5 + 0.5) * window.innerHeight - 50;
                    
                    prompt.style.left = x + 'px';
                    prompt.style.top = y + 'px';
                } else {
                    prompt.classList.remove('visible');
                }
            }
            
            handleInteraction() {
                if (!this.currentInteractable) return;
                
                const obj = this.currentInteractable;
                const type = obj.userData.type;
                
                switch (type) {
                    case 'building':
                        this.enterBuilding(obj);
                        break;
                    case 'npc':
                        this.talkToNPC(obj);
                        break;
                    case 'business':
                        this.enterBusiness(obj);
                        break;
                    case 'vehicle':
                        this.handleVehicleEntry();
                        break;
                    case 'atm':
                        this.useATM(obj);
                        break;
                    case 'vending_machine':
                        this.useVendingMachine(obj);
                        break;
                }
            }
            
            useATM(atm) {
                this.showNotification('ATM', 'Welcome to Vice Bank ATM', 'info');
                
                const menu = document.getElementById('interactionMenu');
                const title = document.getElementById('menuTitle');
                const options = document.getElementById('menuOptions');
                
                title.textContent = 'ATM Services';
                options.innerHTML = '';
                
                const atmOptions = [
                    { text: 'Check Balance', action: () => this.checkBalance() },
                    { text: 'Withdraw $100', action: () => this.withdrawMoney(100) },
                    { text: 'Withdraw $500', action: () => this.withdrawMoney(500) },
                    { text: 'Deposit Money', action: () => this.depositMoney() },
                    { text: 'Exit', action: () => this.exitBuilding() }
                ];
                
                atmOptions.forEach(option => {
                    const optionElement = document.createElement('div');
                    optionElement.className = 'menu-option';
                    optionElement.innerHTML = `<span>${option.text}</span>`;
                    optionElement.onclick = option.action;
                    options.appendChild(optionElement);
                });
                
                menu.classList.add('visible');
                this.menuOpen = true;
            }
            
            checkBalance() {
                this.showNotification('ATM', `Your balance: $${this.gameState.money.toLocaleString()}`, 'info');
                this.exitBuilding();
            }
            
            withdrawMoney(amount) {
                if (this.gameState.money >= amount) {
                    this.gameState.money -= amount;
                    this.showNotification('ATM', `Withdrew $${amount}`, 'success');
                } else {
                    this.showNotification('ATM', 'Insufficient funds', 'warning');
                }
                this.exitBuilding();
            }
            
            depositMoney() {
                const amount = Math.floor(this.gameState.money * 0.1);
                this.gameState.money += amount;
                this.showNotification('ATM', `Deposited $${amount} (interest earned)`, 'success');
                this.exitBuilding();
            }
            
            useVendingMachine(machine) {
                const menu = document.getElementById('interactionMenu');
                const title = document.getElementById('menuTitle');
                const options = document.getElementById('menuOptions');
                
                title.textContent = 'Vending Machine';
                options.innerHTML = '';
                
                const items = machine.userData.items;
                const prices = machine.userData.prices;
                
                items.forEach(item => {
                    const price = prices[item];
                    const option = document.createElement('div');
                    option.className = 'menu-option';
                    option.innerHTML = `
                        <span>Buy ${item}</span>
                        <span class="option-price">$${price}</span>
                    `;
                    option.onclick = () => this.buyVendingItem(item, price);
                    options.appendChild(option);
                });
                
                const exitOption = document.createElement('div');
                exitOption.className = 'menu-option';
                exitOption.innerHTML = '<span>Cancel</span>';
                exitOption.onclick = () => this.exitBuilding();
                options.appendChild(exitOption);
                
                menu.classList.add('visible');
                this.menuOpen = true;
            }
            
            buyVendingItem(item, price) {
                if (this.gameState.money >= price) {
                    this.gameState.money -= price;
                    this.gameState.inventory.items.push(item);
                    
                    // Health boost for food items
                    if (item === 'soda' || item === 'chips') {
                        this.gameState.health = Math.min(100, this.gameState.health + 5);
                    }
                    
                    this.showNotification('Purchase', `Bought ${item} for $${price}`, 'success');
                } else {
                    this.showNotification('Purchase', 'Not enough money', 'warning');
                }
                this.exitBuilding();
            }
            
            enterBuilding(building) {
                const buildingType = building.userData.buildingType;
                const interior = building.userData.interior;
                
                this.showNotification(
                    'Entered Building',
                    `You entered a ${buildingType.replace('_', ' ')}`,
                    'info'
                );
                
                // Show building interior menu
                this.showBuildingMenu(building);
            }
            
            showBuildingMenu(building) {
                const menu = document.getElementById('interactionMenu');
                const title = document.getElementById('menuTitle');
                const options = document.getElementById('menuOptions');
                
                title.textContent = `${building.userData.buildingType.replace('_', ' ').toUpperCase()}`;
                options.innerHTML = '';
                
                const interior = building.userData.interior;
                
                // Add room options
                interior.rooms.forEach(room => {
                    const option = document.createElement('div');
                    option.className = 'menu-option';
                    option.innerHTML = `
                        <span>Go to ${room.replace('_', ' ')}</span>
                        <span>→</span>
                    `;
                    option.onclick = () => this.goToRoom(room, building);
                    options.appendChild(option);
                });
                
                // Add NPC interactions
                interior.npcs.forEach(npcType => {
                    const option = document.createElement('div');
                    option.className = 'menu-option';
                    option.innerHTML = `
                        <span>Talk to ${npcType}</span>
                        <span>💬</span>
                    `;
                    option.onclick = () => this.talkToBuildingNPC(npcType, building);
                    options.appendChild(option);
                });
                
                // Exit option
                const exitOption = document.createElement('div');
                exitOption.className = 'menu-option';
                exitOption.innerHTML = `
                    <span>Exit Building</span>
                    <span>🚪</span>
                `;
                exitOption.onclick = () => this.exitBuilding();
                options.appendChild(exitOption);
                
                menu.classList.add('visible');
                this.menuOpen = true;
            }
            
            goToRoom(room, building) {
                this.showNotification('Room', `You went to the ${room.replace('_', ' ')}`, 'info');
                this.exitBuilding();
                
                // Room-specific interactions
                switch (room) {
                    case 'bar':
                        this.showDrinkMenu();
                        break;
                    case 'vip_area':
                        if (this.gameState.money >= 100) {
                            this.gameState.money -= 100;
                            this.gameState.respect += 5;
                            this.showNotification('VIP Access', 'You gained respect!', 'success');
                        } else {
                            this.showNotification('VIP Access', 'Not enough money for VIP access', 'warning');
                        }
                        break;
                    case 'office':
                        this.showNotification('Office', 'You found some important documents', 'info');
                        this.gameState.respect += 2;
                        break;
                    case 'rooftop':
                        this.showNotification('Rooftop', 'Great view of the city!', 'info');
                        break;
                }
            }
            
            showDrinkMenu() {
                const menu = document.getElementById('interactionMenu');
                const title = document.getElementById('menuTitle');
                const options = document.getElementById('menuOptions');
                
                title.textContent = 'BAR MENU';
                options.innerHTML = '';
                
                const drinks = [
                    { name: 'Beer', price: 5, health: 2 },
                    { name: 'Whiskey', price: 10, health: 5 },
                    { name: 'Cocktail', price: 15, health: 8 },
                    { name: 'Champagne', price: 25, health: 10, respect: 3 }
                ];
                
                drinks.forEach(drink => {
                    const option = document.createElement('div');
                    option.className = 'menu-option';
                    option.innerHTML = `
                        <span>${drink.name}</span>
                        <span class="option-price">$${drink.price}</span>
                    `;
                    option.onclick = () => this.buyDrink(drink);
                    options.appendChild(option);
                });
                
                const exitOption = document.createElement('div');
                exitOption.className = 'menu-option';
                exitOption.innerHTML = '<span>Leave Bar</span>';
                exitOption.onclick = () => this.exitBuilding();
                options.appendChild(exitOption);
                
                menu.classList.add('visible');
                this.menuOpen = true;
            }
            
            buyDrink(drink) {
                if (this.gameState.money >= drink.price) {
                    this.gameState.money -= drink.price;
                    this.gameState.health = Math.min(100, this.gameState.health + drink.health);
                    if (drink.respect) {
                        this.gameState.respect += drink.respect;
                    }
                    this.showNotification('Drink', `Enjoyed a ${drink.name}!`, 'success');
                } else {
                    this.showNotification('Bar', 'Not enough money', 'warning');
                }
                this.exitBuilding();
            }
            
            talkToBuildingNPC(npcType, building) {
                const dialogues = {
                    bartender: "What can I get you to drink?",
                    bouncer: "Keep it cool in here, alright?",
                    clerk: "Can I help you find something?",
                    manager: "Welcome to our establishment!",
                    security: "Everything alright here?",
                    dealer: "You looking for something special?",
                    dj: "Any requests for the music?",
                    customers: "This place is great!",
                    concierge: "How may I assist you today?",
                    employees: "Just another day at the office.",
                    worker: "These crates won't move themselves.",
                    supervisor: "Keep up the good work!"
                };
                
                const dialogue = dialogues[npcType] || "Hello there.";
                this.showNotification(npcType.toUpperCase(), dialogue, 'info');
                
                // Special interactions
                if (npcType === 'dealer') {
                    this.gameState.respect += 1;
                    this.showNotification('Reputation', 'You made a connection', 'success');
                }
                
                this.exitBuilding();
            }
            
            exitBuilding() {
                const menu = document.getElementById('interactionMenu');
                menu.classList.remove('visible');
                this.menuOpen = false;
            }
            
            talkToNPC(npc) {
                const npcData = npc.userData;
                const personality = npcData.personality;
                const relationship = npcData.relationship;
                
                let dialogue;
                if (this.gameState.wantedLevel > 2) {
                    dialogue = npcData.dialogue.scared[Math.floor(Math.random() * npcData.dialogue.scared.length)];
                } else if (relationship < -20) {
                    dialogue = npcData.dialogue.hostile[Math.floor(Math.random() * npcData.dialogue.hostile.length)];
                } else if (relationship > 20) {
                    dialogue = npcData.dialogue.friendly[Math.floor(Math.random() * npcData.dialogue.friendly.length)];
                } else {
                    dialogue = npcData.dialogue.casual[Math.floor(Math.random() * npcData.dialogue.casual.length)];
                }
                
                this.showNotification(npcData.name, dialogue, 'info');
                
                // Improve relationship slightly
                npcData.relationship = Math.min(100, npcData.relationship + 1);
                
                // Special interactions based on occupation
                if (npcData.occupation === 'Police Officer' && this.gameState.wantedLevel > 0) {
                    this.showNotification('Police', 'Stop right there!', 'danger');
                    this.gameState.wantedLevel += 1;
                } else if (npcData.criminal && Math.random() < 0.3) {
                    this.showNotification('Criminal Contact', 'I might have some work for you...', 'info');
                    this.gameState.respect += 2;
                }
            }
            
            enterBusiness(business) {
                const businessData = business.userData.business;
                const businessType = business.userData.businessType;
                
                // Check business hours
                const currentHour = this.timeSystem.hour;
                const hours = businessData.hours;
                
                let isOpen = false;
                if (hours.close > hours.open) {
                    isOpen = currentHour >= hours.open && currentHour < hours.close;
                } else {
                    isOpen = currentHour >= hours.open || currentHour < hours.close;
                }
                
                if (!isOpen && businessType !== 'drug_dealer') {
                    this.showNotification('Closed', 'This business is currently closed', 'warning');
                    return;
                }
                
                this.showBusinessMenu(business);
            }
            
            showBusinessMenu(business) {
                const menu = document.getElementById('interactionMenu');
                const title = document.getElementById('menuTitle');
                const options = document.getElementById('menuOptions');
                
                const businessData = business.userData.business;
                const businessType = business.userData.businessType;
                
                title.textContent = businessType.replace('_', ' ').toUpperCase();
                options.innerHTML = '';
                
                // Add inventory items
                businessData.inventory.forEach(item => {
                    const price = businessData.prices[item];
                    const option = document.createElement('div');
                    option.className = 'menu-option';
                    option.innerHTML = `
                        <span>Buy ${item.replace('_', ' ')}</span>
                        <span class="option-price">$${price}</span>
                    `;
                    option.onclick = () => this.buyItem(item, price, businessType);
                    options.appendChild(option);
                });
                
                // Special business options
                if (businessType === 'bank') {
                    const loanOption = document.createElement('div');
                    loanOption.className = 'menu-option';
                    loanOption.innerHTML = `
                        <span>Take Loan ($10,000)</span>
                        <span>💰</span>
                    `;
                    loanOption.onclick = () => this.takeLoan();
                    options.appendChild(loanOption);
                }
                
                // Exit option
                const exitOption = document.createElement('div');
                exitOption.className = 'menu-option';
                exitOption.innerHTML = `
                    <span>Leave</span>
                    <span>🚪</span>
                `;
                exitOption.onclick = () => this.exitBuilding();
                options.appendChild(exitOption);
                
                menu.classList.add('visible');
                this.menuOpen = true;
            }
            
            buyItem(item, price, businessType) {
                if (this.gameState.money >= price) {
                    this.gameState.money -= price;
                    
                    switch (businessType) {
                        case 'gun_store':
                            if (item === 'armor') {
                                this.gameState.armor = Math.min(100, this.gameState.armor + 50);
                            } else {
                                this.gameState.inventory.weapons.push(item);
                                this.gameState.currentWeapon = item;
                            }
                            this.gameState.wantedLevel += 0.1; // Buying weapons increases suspicion
                            break;
                        case 'clothing_store':
                            this.showNotification('Clothing', `You bought ${item.replace('_', ' ')}`, 'success');
                            this.gameState.respect += 1;
                            break;
                        case 'car_dealership':
                            this.spawnPlayerVehicle(item);
                            break;
                        case 'drug_dealer':
                            this.gameState.inventory.drugs.push(item);
                            this.gameState.wantedLevel += 0.2; // Drug dealing is risky
                            this.gameState.respect += 2;
                            break;
                        case 'restaurant':
                            this.gameState.health = Math.min(100, this.gameState.health + 10);
                            break;
                        default:
                            this.gameState.inventory.items.push(item);
                    }
                    
                    this.showNotification('Purchase', `Bought ${item.replace('_', ' ')} for $${price}`, 'success');
                } else {
                    this.showNotification('Purchase Failed', 'Not enough money', 'warning');
                }
                
                this.exitBuilding();
            }
            
            spawnPlayerVehicle(vehicleType) {
                const vehicle = this.createVehicle('player');
                vehicle.userData.vehicleType = vehicleType;
                vehicle.position.copy(this.player.position);
                vehicle.position.x += 5;
                vehicle.userData.locked = false;
                vehicle.userData.owner = 'player';
                this.world.vehicles.push(vehicle);
                this.scene.add(vehicle);
                
                this.showNotification('Vehicle Delivered', `Your new ${vehicleType.replace('_', ' ')} is ready!`, 'success');
            }
            
            takeLoan() {
                const loanAmount = 10000;
                this.gameState.money += loanAmount;
                this.showNotification('Loan Approved', `You received a loan of $${loanAmount}`, 'success');
                this.exitBuilding();
            }
            
            handleVehicleEntry() {
                if (this.gameState.isInVehicle) {
                    // Exit vehicle
                    this.gameState.isInVehicle = false;
                    this.gameState.currentVehicle.userData.occupied = false;
                    
                    this.player.position.copy(this.gameState.currentVehicle.position);
                    this.player.position.x += 3;
                    this.player.visible = true;
                    
                    this.gameState.currentVehicle = null;
                    
                    document.getElementById('vehicleInfo').classList.remove('visible');
                    this.showNotification('Vehicle', 'Exited vehicle', 'info');
                } else if (this.currentInteractable && this.currentInteractable.userData.type === 'vehicle') {
                    // Enter vehicle
                    const vehicle = this.currentInteractable;
                    
                    if (vehicle.userData.locked && vehicle.userData.owner !== 'player') {
                        // Try to break in
                        if (Math.random() < 0.7) {
                            this.showNotification('Vehicle', 'Successfully broke into vehicle!', 'success');
                            this.gameState.wantedLevel += 0.5;
                            this.gameState.skills.stealth += 1;
                        } else {
                            this.showNotification('Vehicle', 'Failed to break in - alarm triggered!', 'danger');
                            this.gameState.wantedLevel += 1;
                            return;
                        }
                    }
                    
                    this.gameState.isInVehicle = true;
                    this.gameState.currentVehicle = vehicle;
                    vehicle.userData.occupied = true;
                    
                    this.player.visible = false;
                    
                    document.getElementById('vehicleInfo').classList.add('visible');
                    this.showNotification('Vehicle', `Entered ${vehicle.userData.vehicleType.replace('_', ' ')}`, 'success');
                    
                    // Increase driving skill
                    this.gameState.skills.driving = Math.min(100, this.gameState.skills.driving + 1);
                }
            }
            
            updateVehicleMovement() {
                if (!this.gameState.isInVehicle || !this.gameState.currentVehicle) return;
                
                const vehicle = this.gameState.currentVehicle;
                const stats = vehicle.userData.stats;
                
                let acceleration = 0;
                let steering = 0;
                
                if (this.keys['KeyW']) acceleration = stats.acceleration;
                if (this.keys['KeyS']) acceleration = -stats.acceleration * 0.5;
                if (this.keys['KeyA']) steering = -1;
                if (this.keys['KeyD']) steering = 1;
                
                // Apply vehicle physics
                if (!vehicle.userData.speed) vehicle.userData.speed = 0;
                
                vehicle.userData.speed += acceleration;
                vehicle.userData.speed *= 0.95; // Friction
                vehicle.userData.speed = Math.max(-stats.speed * 0.5, Math.min(stats.speed, vehicle.userData.speed));
                
                if (Math.abs(vehicle.userData.speed) > 1) {
                    vehicle.rotation.y += steering * stats.handling * 0.02 * (vehicle.userData.speed / stats.speed);
                }
                
                // Move vehicle
                const direction = new THREE.Vector3(
                    Math.sin(vehicle.rotation.y),
                    0,
                    Math.cos(vehicle.rotation.y)
                );
                vehicle.position.add(direction.multiplyScalar(vehicle.userData.speed * 0.016));
                
                // Update camera to follow vehicle
                this.camera.position.copy(vehicle.position);
                this.camera.position.y += 3;
                this.camera.position.add(direction.multiplyScalar(-8));
                this.camera.lookAt(vehicle.position);
                
                // Apply mouse look for vehicle camera
                this.camera.rotation.x += this.mouse.y * 0.1;
                this.camera.rotation.y += this.mouse.x * 0.1;
                
                // Update HUD
                document.getElementById('vehicleSpeed').textContent = Math.abs(vehicle.userData.speed).toFixed(0);
                document.getElementById('vehicleDamage').textContent = vehicle.userData.damage.toFixed(0);
                
                // Damage from high speed crashes
                if (Math.abs(vehicle.userData.speed) > 50) {
                    vehicle.userData.damage += 0.1;
                    if (vehicle.userData.damage > 100) {
                        this.explodeVehicle(vehicle);
                    }
                }
            }
            
            explodeVehicle(vehicle) {
                // Create explosion effect
                const explosionGeometry = new THREE.SphereGeometry(5, 8, 8);
                const explosionMaterial = new THREE.MeshBasicMaterial({ 
                    color: 0xFF4500,
                    transparent: true,
                    opacity: 0.8
                });
                const explosion = new THREE.Mesh(explosionGeometry, explosionMaterial);
                explosion.position.copy(vehicle.position);
                this.scene.add(explosion);
                
                // Remove explosion after animation
                setTimeout(() => {
                    this.scene.remove(explosion);
                }, 2000);
                
                // Damage player if in vehicle
                if (this.gameState.isInVehicle && this.gameState.currentVehicle === vehicle) {
                    this.gameState.health -= 50;
                    this.gameState.isInVehicle = false;
                    this.gameState.currentVehicle = null;
                    this.player.visible = true;
                    document.getElementById('vehicleInfo').classList.remove('visible');
                }
                
                // Remove vehicle
                this.scene.remove(vehicle);
                const index = this.world.vehicles.indexOf(vehicle);
                if (index > -1) {
                    this.world.vehicles.splice(index, 1);
                }
                
                this.showNotification('Explosion', 'Vehicle destroyed!', 'danger');
                this.gameState.wantedLevel += 1;
            }
            
            togglePhone() {
                this.phoneOpen = !this.phoneOpen;
                const phoneInterface = document.getElementById('phoneInterface');
                
                if (this.phoneOpen) {
                    phoneInterface.classList.add('visible');
                    if (this.isPointerLocked) {
                        document.exitPointerLock();
                    }
                } else {
                    phoneInterface.classList.remove('visible');
                }
            }
            
            toggleRadio() {
                const radioDisplay = document.getElementById('radioDisplay');
                const isVisible = radioDisplay.classList.contains('visible');
                
                const stations = [
                    { name: 'Vice FM', song: 'Synthwave Nights' },
                    { name: 'Neon Radio', song: 'Electric Dreams' },
                    { name: 'Miami Beats', song: 'Ocean Drive' },
                    { name: 'Crime Wave', song: 'Dark City' }
                ];
                
                if (isVisible) {
                    radioDisplay.classList.remove('visible');
                } else {
                    const station = stations[Math.floor(Math.random() * stations.length)];
                    radioDisplay.innerHTML = `
                        <div>📻 ${station.name}</div>
                        <div>Now Playing: ${station.song}</div>
                    `;
                    radioDisplay.classList.add('visible');
                    setTimeout(() => {
                        radioDisplay.classList.remove('visible');
                    }, 3000);
                }
            }
            
            toggleCrouch() {
                // Crouch toggle logic
                this.player.scale.y = this.player.scale.y === 1 ? 0.7 : 1;
                this.showNotification('Movement', this.player.scale.y === 0.7 ? 'Crouching' : 'Standing', 'info');
            }
            
            throwGrenade() {
                if (this.gameState.inventory.weapons.includes('grenade')) {
                    // Create grenade projectile
                    const grenadeGeometry = new THREE.SphereGeometry(0.1, 8, 8);
                    const grenadeMaterial = new THREE.MeshBasicMaterial({ color: 0x333333 });
                    const grenade = new THREE.Mesh(grenadeGeometry, grenadeMaterial);
                    
                    grenade.position.copy(this.player.position);
                    grenade.position.y += 1.5;
                    
                    const direction = new THREE.Vector3();
                    this.camera.getWorldDirection(direction);
                    
                    grenade.velocity = direction.multiplyScalar(20);
                    grenade.velocity.y += 5;
                    
                    this.scene.add(grenade);
                    
                    // Grenade physics and explosion
                    const grenadeInterval = setInterval(() => {
                        grenade.velocity.y -= 0.5; // Gravity
                        grenade.position.add(grenade.velocity.clone().multiplyScalar(0.016));
                        
                        if (grenade.position.y <= 0) {
                            clearInterval(grenadeInterval);
                            this.explodeGrenade(grenade);
                        }
                    }, 16);
                    
                    this.showNotification('Weapon', 'Grenade thrown!', 'info');
                    this.gameState.wantedLevel += 2;
                }
            }
            
            explodeGrenade(grenade) {
                // Create explosion
                const explosionGeometry = new THREE.SphereGeometry(10, 8, 8);
                const explosionMaterial = new THREE.MeshBasicMaterial({ 
                    color: 0xFF4500,
                    transparent: true,
                    opacity: 0.6
                });
                const explosion = new THREE.Mesh(explosionGeometry, explosionMaterial);
                explosion.position.copy(grenade.position);
                this.scene.add(explosion);
                
                // Damage nearby objects and NPCs
                this.world.pedestrians.forEach(npc => {
                    const distance = npc.position.distanceTo(grenade.position);
                    if (distance < 10) {
                        npc.userData.health -= 100;
                        this.scene.remove(npc);
                    }
                });
                
                // Remove grenade and explosion
                this.scene.remove(grenade);
                setTimeout(() => {
                    this.scene.remove(explosion);
                }, 1000);
                
                this.showNotification('Explosion', 'Grenade exploded!', 'danger');
                this.gameState.wantedLevel += 3;
            }
            
            closeAllMenus() {
                this.phoneOpen = false;
                this.menuOpen = false;
                document.getElementById('phoneInterface').classList.remove('visible');
                document.getElementById('interactionMenu').classList.remove('visible');
            }
            
            updateHUD() {
                // Health
                const healthIndicator = document.getElementById('healthIndicator');
                healthIndicator.textContent = Math.floor(this.gameState.health);
                const healthPercent = this.gameState.health / 100;
                healthIndicator.style.background = `radial-gradient(circle, rgba(255, 20, 147, ${healthPercent * 0.3}) 0%, rgba(139, 0, 139, 0.1) 100%)`;
                
                // Armor
                const armorIndicator = document.getElementById('armorIndicator');
                armorIndicator.textContent = Math.floor(this.gameState.armor);
                
                // Money
                const moneyCounter = document.getElementById('moneyCounter');
                moneyCounter.textContent = `$${this.gameState.money.toLocaleString()}`;
                
                // Wanted level
                const wantedStars = document.querySelectorAll('.wanted-star');
                wantedStars.forEach((star, index) => {
                    if (index < Math.floor(this.gameState.wantedLevel)) {
                        star.classList.add('active');
                    } else {
                        star.classList.remove('active');
                    }
                });
                
                // Stats
                document.getElementById('respectLevel').textContent = Math.floor(this.gameState.respect);
                document.getElementById('staminaLevel').textContent = Math.floor(this.gameState.stamina);
                document.getElementById('drivingSkill').textContent = Math.floor(this.gameState.skills.driving);
                document.getElementById('shootingSkill').textContent = Math.floor(this.gameState.skills.shooting);
                
                // Weapon
                document.getElementById('weaponWheel').textContent = this.gameState.currentWeapon.replace('_', ' ');
                
                // Health warning
                if (this.gameState.health < 20) {
                    healthIndicator.style.animation = 'pulse 0.5s infinite';
                } else {
                    healthIndicator.style.animation = '';
                }
            }
            
            updateTimeDisplay() {
                const timeWeather = document.getElementById('timeWeather');
                const hour = this.timeSystem.hour;
                const minute = this.timeSystem.minute.toString().padStart(2, '0');
                const ampm = hour >= 12 ? 'PM' : 'AM';
                const displayHour = hour > 12 ? hour - 12 : (hour === 0 ? 12 : hour);
                
                timeWeather.innerHTML = `
                    <div>${displayHour}:${minute} ${ampm}</div>
                    <div>${this.weatherSystem.current}</div>
                `;
            }
            
            updateLightingForTime() {
                const hour = this.timeSystem.hour;
                const isNight = hour < 6 || hour > 20;
                
                // Adjust lighting based on time
                if (this.directionalLight) {
                    this.directionalLight.intensity = isNight ? 0.3 : 0.8;
                    this.directionalLight.color.setHex(isNight ? 0x8B008B : 0xFFFFFF);
                }
                
                // Adjust fog
                this.scene.fog.color.setHex(isNight ? 0x000033 : 0x87CEEB);
            }
            
            showNotification(title, message, type = 'info') {
                const container = document.getElementById('notificationContainer');
                const notification = document.createElement('div');
                notification.className = `notification ${type}`;
                
                notification.innerHTML = `
                    <div class="notification-title">${title}</div>
                    <div>${message}</div>
                `;
                
                container.appendChild(notification);
                
                // Animate in
                setTimeout(() => {
                    notification.classList.add('visible');
                }, 100);
                
                // Remove after delay
                setTimeout(() => {
                    notification.classList.remove('visible');
                    setTimeout(() => {
                        if (container.contains(notification)) {
                            container.removeChild(notification);
                        }
                    }, 500);
                }, 4000);
            }
            
            animate() {
                requestAnimationFrame(() => this.animate());
                
                this.handlePlayerMovement();
                this.updateVehicleMovement();
                this.updateHUD();
                
                // Animate interactive objects
                this.world.interactables.forEach(item => {
                    if (item.userData.type === 'business') {
                        item.children[0].position.y = Math.sin(Date.now() * 0.005) * 0.3;
                        item.rotation.y += 0.01;
                    }
                });
                
                // Check for game over
                if (this.gameState.health <= 0) {
                    this.gameOver();
                }
                
                this.renderer.render(this.scene, this.camera);
            }
            
            gameOver() {
                this.showNotification('Game Over', 'You have been defeated!', 'danger');
                
                // Reset game state
                setTimeout(() => {
                    this.gameState.health = 100;
                    this.gameState.armor = 0;
                    this.gameState.wantedLevel = 0;
                    this.player.position.set(0, 0, 0);
                    
                    if (this.gameState.isInVehicle) {
                        this.gameState.isInVehicle = false;
                        this.gameState.currentVehicle = null;
                        this.player.visible = true;
                        document.getElementById('vehicleInfo').classList.remove('visible');
                    }
                    
                    this.showNotification('Respawn', 'You respawned at the hospital', 'info');
                }, 3000);
            }
        }
        
        // Phone App Functions
        function openPhoneApp(app) {
            const phoneHeader = document.getElementById('phoneHeader');
            const phoneContent = document.getElementById('phoneContent');
            
            switch (app) {
                case 'contacts':
                    phoneHeader.textContent = 'Contacts';
                    phoneContent.innerHTML = `
                        <div class="phone-app">📞 Tony - Nightclub Owner</div>
                        <div class="phone-app">📞 Maria - Gun Dealer</div>
                        <div class="phone-app">📞 Carlos - Mechanic</div>
                        <div class="phone-app">📞 Emergency Services</div>
                        <div class="phone-app">📞 Taxi Service</div>
                        <div class="phone-app">📞 Pizza