Refactor to ES6 classes with GameObject inheritance pattern

- Convert from function-based to class-based architecture
- Create GameObject base class with common functionality (position, collision, scene management)
- Implement Player, Coin, and Obstacle classes extending GameObject
- Add Game class to manage game lifecycle and state
- Fix shadow rendering by configuring directional light shadow camera bounds
- Fix player collision to prevent sinking below ground (horizontal push only)
- Improve code organization and maintainability with OOP principles

index.html

@@ -92,42 +92,277 @@
 
     <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
     <script>
-        // Game variables
+        // Base GameObject class
-        let scene, camera, renderer;
+        class GameObject {
-        let player;
+            constructor(scene, groundSize) {
-        let coins = [];
+                this.scene = scene;
-        let obstacles = [];
+                this.groundSize = groundSize;
-        let score = 0;
+                this.mesh = this.createMesh();
-        let health = 100;
+                this.initialize();
-        let gameActive = true;
+                scene.add(this.mesh);
+            }
             
-        // Movement
+            // Override in child classes
-        const keys = {};
+            createMesh() {
-        const playerSpeed = 0.15;
+                throw new Error('createMesh() must be implemented by child class');
-        const groundSize = 30;
+            }
             
-        // Initialize the game
+            // Override in child classes for initialization
-        function init() {
+            initialize() {
-            // Scene setup
+                // Default implementation - can be overridden
-            scene = new THREE.Scene();
+            }
-            scene.background = new THREE.Color(0x87CEEB);
-            scene.fog = new THREE.Fog(0x87CEEB, 0, 50);
             
-            // Camera setup
+            // Override in child classes for update logic
-            camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+            update(...args) {
-            camera.position.set(0, 10, 15);
+                // Default implementation - can be overridden
-            camera.lookAt(0, 0, 0);
+            }
             
-            // Renderer setup
+            // Common collision detection
-            renderer = new THREE.WebGLRenderer({ antialias: true });
+            checkCollision(otherPosition, collisionRadius) {
-            renderer.setSize(window.innerWidth, window.innerHeight);
+                const distance = this.mesh.position.distanceTo(otherPosition);
-            renderer.shadowMap.enabled = true;
+                return distance < collisionRadius;
-            renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+            }
-            document.body.appendChild(renderer.domElement);
             
-            // Lights
+            // Common position getter
+            getPosition() {
+                return this.mesh.position;
+            }
+            
+            // Remove from scene
+            remove() {
+                this.scene.remove(this.mesh);
+            }
+            
+            // Set position
+            setPosition(x, y, z) {
+                this.mesh.position.set(x, y, z);
+            }
+            
+            // Get position vector
+            getPositionVector() {
+                return this.mesh.position.clone();
+            }
+        }
+        
+        // Player class extends GameObject
+        class Player extends GameObject {
+            constructor(scene, groundSize) {
+                super(scene, groundSize);
+                this.speed = 0.15;
+            }
+            
+            createMesh() {
+                const geometry = new THREE.BoxGeometry(1, 1, 1);
+                const material = new THREE.MeshStandardMaterial({ 
+                    color: 0x4169E1,
+                    metalness: 0.3,
+                    roughness: 0.4
+                });
+                const mesh = new THREE.Mesh(geometry, material);
+                mesh.castShadow = true;
+                mesh.receiveShadow = true;
+                return mesh;
+            }
+            
+            initialize() {
+                this.reset();
+            }
+            
+            reset() {
+                this.setPosition(0, 0.5, 0);
+                this.mesh.rotation.y = 0;
+            }
+            
+            update(keys) {
+                const moveVector = new THREE.Vector3();
+                
+                if (keys['w'] || keys['arrowup']) moveVector.z -= this.speed;
+                if (keys['s'] || keys['arrowdown']) moveVector.z += this.speed;
+                if (keys['a'] || keys['arrowleft']) moveVector.x -= this.speed;
+                if (keys['d'] || keys['arrowright']) moveVector.x += this.speed;
+                
+                this.mesh.position.add(moveVector);
+                
+                // Boundary checks
+                const boundary = this.groundSize / 2 - 0.5;
+                this.mesh.position.x = Math.max(-boundary, Math.min(boundary, this.mesh.position.x));
+                this.mesh.position.z = Math.max(-boundary, Math.min(boundary, this.mesh.position.z));
+                
+                // Rotate player based on movement
+                if (moveVector.length() > 0) {
+                    this.mesh.rotation.y += 0.1;
+                }
+            }
+            
+            handleCollision(obstaclePosition) {
+                const pushDirection = this.mesh.position.clone().sub(obstaclePosition);
+                pushDirection.y = 0;
+                pushDirection.normalize();
+                this.mesh.position.add(pushDirection.multiplyScalar(0.3));
+                this.mesh.position.y = 0.5;
+            }
+        }
+        
+        // Coin class extends GameObject
+        class Coin extends GameObject {
+            constructor(scene, groundSize, index = 0) {
+                super(scene, groundSize);
+                this.index = index;
+                this.rotationSpeed = 0.02;
+                this.collisionRadius = 0.8;
+            }
+            
+            createMesh() {
+                const geometry = new THREE.SphereGeometry(0.3, 16, 16);
+                const material = new THREE.MeshStandardMaterial({ 
+                    color: 0xFFD700,
+                    metalness: 0.8,
+                    roughness: 0.2,
+                    emissive: 0xFFD700,
+                    emissiveIntensity: 0.3
+                });
+                const mesh = new THREE.Mesh(geometry, material);
+                mesh.castShadow = true;
+                mesh.receiveShadow = true;
+                return mesh;
+            }
+            
+            initialize() {
+                this.setRandomPosition();
+            }
+            
+            setRandomPosition() {
+                const x = (Math.random() - 0.5) * (this.groundSize - 4);
+                const z = (Math.random() - 0.5) * (this.groundSize - 4);
+                this.setPosition(x, 0.5, z);
+            }
+            
+            update() {
+                this.mesh.rotation.y += this.rotationSpeed;
+                this.mesh.position.y = 0.5 + Math.sin(Date.now() * 0.003 + this.index) * 0.2;
+            }
+            
+            checkCollisionWithPlayer(playerPosition) {
+                return this.checkCollision(playerPosition, this.collisionRadius);
+            }
+        }
+        
+        // Obstacle class extends GameObject
+        class Obstacle extends GameObject {
+            constructor(scene, groundSize) {
+                super(scene, groundSize);
+                this.direction = this.createRandomDirection();
+                this.collisionRadius = 1.5;
+            }
+            
+            createMesh() {
+                const geometry = new THREE.BoxGeometry(1.5, 2, 1.5);
+                const material = new THREE.MeshStandardMaterial({ 
+                    color: 0xFF4500,
+                    metalness: 0.3,
+                    roughness: 0.7
+                });
+                const mesh = new THREE.Mesh(geometry, material);
+                mesh.castShadow = true;
+                mesh.receiveShadow = true;
+                return mesh;
+            }
+            
+            initialize() {
+                this.setRandomPosition();
+                this.mesh.position.y = 1;
+            }
+            
+            createRandomDirection() {
+                return new THREE.Vector3(
+                    (Math.random() - 0.5) * 0.05,
+                    0,
+                    (Math.random() - 0.5) * 0.05
+                );
+            }
+            
+            setRandomPosition() {
+                let posX, posZ;
+                do {
+                    posX = (Math.random() - 0.5) * (this.groundSize - 4);
+                    posZ = (Math.random() - 0.5) * (this.groundSize - 4);
+                } while (Math.abs(posX) < 3 && Math.abs(posZ) < 3);
+                
+                this.setPosition(posX, 1, posZ);
+            }
+            
+            update() {
+                this.mesh.position.add(this.direction);
+                
+                // Bounce off boundaries
+                const boundary = this.groundSize / 2 - 1;
+                if (Math.abs(this.mesh.position.x) > boundary) {
+                    this.direction.x *= -1;
+                }
+                if (Math.abs(this.mesh.position.z) > boundary) {
+                    this.direction.z *= -1;
+                }
+            }
+            
+            checkCollisionWithPlayer(playerPosition) {
+                return this.checkCollision(playerPosition, this.collisionRadius);
+            }
+        }
+        
+        // Game class
+        class Game {
+            constructor() {
+                this.groundSize = 30;
+                this.score = 0;
+                this.health = 100;
+                this.gameActive = true;
+                this.keys = {};
+                this.coins = [];
+                this.obstacles = [];
+                
+                this.init();
+                this.setupEventListeners();
+                this.animate();
+            }
+            
+            init() {
+                this.setupScene();
+                this.setupCamera();
+                this.setupRenderer();
+                this.setupLights();
+                this.setupGround();
+                this.setupPlayer();
+                this.createGameObjects();
+            }
+            
+            setupScene() {
+                this.scene = new THREE.Scene();
+                this.scene.background = new THREE.Color(0x87CEEB);
+                this.scene.fog = new THREE.Fog(0x87CEEB, 0, 50);
+            }
+            
+            setupCamera() {
+                this.camera = new THREE.PerspectiveCamera(
+                    75, 
+                    window.innerWidth / window.innerHeight, 
+                    0.1, 
+                    1000
+                );
+                this.camera.position.set(0, 10, 15);
+                this.camera.lookAt(0, 0, 0);
+            }
+            
+            setupRenderer() {
+                this.renderer = new THREE.WebGLRenderer({ antialias: true });
+                this.renderer.setSize(window.innerWidth, window.innerHeight);
+                this.renderer.shadowMap.enabled = true;
+                this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+                document.body.appendChild(this.renderer.domElement);
+            }
+            
+            setupLights() {
                 const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
-            scene.add(ambientLight);
+                this.scene.add(ambientLight);
                 
                 const directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
                 directionalLight.position.set(10, 20, 10);
@@ -140,10 +375,11 @@
                 directionalLight.shadow.camera.bottom = -20;
                 directionalLight.shadow.camera.near = 0.5;
                 directionalLight.shadow.camera.far = 50;
-            scene.add(directionalLight);
+                this.scene.add(directionalLight);
+            }
             
-            // Ground
+            setupGround() {
-            const groundGeometry = new THREE.PlaneGeometry(groundSize, groundSize);
+                const groundGeometry = new THREE.PlaneGeometry(this.groundSize, this.groundSize);
                 const groundMaterial = new THREE.MeshStandardMaterial({ 
                     color: 0x90EE90,
                     roughness: 0.8
@@ -151,254 +387,146 @@
                 const ground = new THREE.Mesh(groundGeometry, groundMaterial);
                 ground.rotation.x = -Math.PI / 2;
                 ground.receiveShadow = true;
-            scene.add(ground);
+                this.scene.add(ground);
                 
-            // Grid helper
+                const gridHelper = new THREE.GridHelper(this.groundSize, 20, 0x000000, 0x000000);
-            const gridHelper = new THREE.GridHelper(groundSize, 20, 0x000000, 0x000000);
                 gridHelper.material.opacity = 0.2;
                 gridHelper.material.transparent = true;
-            scene.add(gridHelper);
+                this.scene.add(gridHelper);
-            
-            // Player
-            const playerGeometry = new THREE.BoxGeometry(1, 1, 1);
-            const playerMaterial = new THREE.MeshStandardMaterial({ 
-                color: 0x4169E1,
-                metalness: 0.3,
-                roughness: 0.4
-            });
-            player = new THREE.Mesh(playerGeometry, playerMaterial);
-            player.position.y = 0.5;
-            player.castShadow = true;
-            player.receiveShadow = true;
-            scene.add(player);
-            
-            // Create initial game objects
-            createCoins(10);
-            createObstacles(8);
-            
-            // Event listeners
-            window.addEventListener('keydown', (e) => keys[e.key.toLowerCase()] = true);
-            window.addEventListener('keyup', (e) => keys[e.key.toLowerCase()] = false);
-            window.addEventListener('resize', onWindowResize);
-            document.getElementById('restartBtn').addEventListener('click', restartGame);
-            
-            // Start animation loop
-            animate();
             }
             
-        // Create coins
+            setupPlayer() {
-        function createCoins(count) {
+                this.player = new Player(this.scene, this.groundSize);
+            }
+            
+            createGameObjects() {
+                this.createCoins(10);
+                this.createObstacles(8);
+            }
+            
+            createCoins(count) {
                 for (let i = 0; i < count; i++) {
-                const coinGeometry = new THREE.SphereGeometry(0.3, 16, 16);
+                    const coin = new Coin(this.scene, this.groundSize, this.coins.length);
-                const coinMaterial = new THREE.MeshStandardMaterial({ 
+                    this.coins.push(coin);
-                    color: 0xFFD700,
-                    metalness: 0.8,
-                    roughness: 0.2,
-                    emissive: 0xFFD700,
-                    emissiveIntensity: 0.3
-                });
-                const coin = new THREE.Mesh(coinGeometry, coinMaterial);
-                
-                // Random position
-                coin.position.x = (Math.random() - 0.5) * (groundSize - 4);
-                coin.position.z = (Math.random() - 0.5) * (groundSize - 4);
-                coin.position.y = 0.5;
-                
-                coin.castShadow = true;
-                coin.receiveShadow = true;
-                coin.userData.rotationSpeed = 0.02;
-                
-                scene.add(coin);
-                coins.push(coin);
                 }
             }
             
-        // Create obstacles
+            createObstacles(count) {
-        function createObstacles(count) {
                 for (let i = 0; i < count; i++) {
-                const obstacleGeometry = new THREE.BoxGeometry(1.5, 2, 1.5);
+                    const obstacle = new Obstacle(this.scene, this.groundSize);
-                const obstacleMaterial = new THREE.MeshStandardMaterial({ 
+                    this.obstacles.push(obstacle);
-                    color: 0xFF4500,
+                }
-                    metalness: 0.3,
+            }
-                    roughness: 0.7
+            
+            setupEventListeners() {
+                window.addEventListener('keydown', (e) => {
+                    this.keys[e.key.toLowerCase()] = true;
                 });
-                const obstacle = new THREE.Mesh(obstacleGeometry, obstacleMaterial);
+                window.addEventListener('keyup', (e) => {
-                
+                    this.keys[e.key.toLowerCase()] = false;
-                // Random position (ensure not too close to player start)
+                });
-                let posX, posZ;
+                window.addEventListener('resize', () => this.onWindowResize());
-                do {
+                document.getElementById('restartBtn').addEventListener('click', () => this.restart());
-                    posX = (Math.random() - 0.5) * (groundSize - 4);
-                    posZ = (Math.random() - 0.5) * (groundSize - 4);
-                } while (Math.abs(posX) < 3 && Math.abs(posZ) < 3);
-                
-                obstacle.position.x = posX;
-                obstacle.position.z = posZ;
-                obstacle.position.y = 1;
-                
-                obstacle.castShadow = true;
-                obstacle.receiveShadow = true;
-                
-                // Random movement pattern
-                obstacle.userData.direction = new THREE.Vector3(
-                    (Math.random() - 0.5) * 0.05,
-                    0,
-                    (Math.random() - 0.5) * 0.05
-                );
-                
-                scene.add(obstacle);
-                obstacles.push(obstacle);
-            }
             }
             
-        // Update player movement
+            updatePlayer() {
-        function updatePlayer() {
+                if (!this.gameActive) return;
-            if (!gameActive) return;
+                this.player.update(this.keys);
-            
-            const moveVector = new THREE.Vector3();
-            
-            if (keys['w'] || keys['arrowup']) moveVector.z -= playerSpeed;
-            if (keys['s'] || keys['arrowdown']) moveVector.z += playerSpeed;
-            if (keys['a'] || keys['arrowleft']) moveVector.x -= playerSpeed;
-            if (keys['d'] || keys['arrowright']) moveVector.x += playerSpeed;
-            
-            // Apply movement
-            player.position.add(moveVector);
-            
-            // Boundary checks
-            const boundary = groundSize / 2 - 0.5;
-            player.position.x = Math.max(-boundary, Math.min(boundary, player.position.x));
-            player.position.z = Math.max(-boundary, Math.min(boundary, player.position.z));
-            
-            // Rotate player based on movement
-            if (moveVector.length() > 0) {
-                player.rotation.y += 0.1;
-            }
             }
             
-        // Update coins
+            updateCoins() {
-        function updateCoins() {
+                this.coins.forEach((coin, index) => {
-            coins.forEach((coin, index) => {
+                    coin.update();
-                // Rotate coins
-                coin.rotation.y += coin.userData.rotationSpeed;
-                coin.position.y = 0.5 + Math.sin(Date.now() * 0.003 + index) * 0.2;
                     
-                // Check collision with player
+                    if (coin.checkCollisionWithPlayer(this.player.getPosition())) {
-                const distance = player.position.distanceTo(coin.position);
+                        coin.remove();
-                if (distance < 0.8) {
+                        this.coins.splice(index, 1);
-                    // Collect coin
+                        this.score += 10;
-                    scene.remove(coin);
+                        this.updateUI();
-                    coins.splice(index, 1);
+                        this.createCoins(1);
-                    score += 10;
-                    updateUI();
-                    
-                    // Create new coin
-                    createCoins(1);
                     }
                 });
             }
             
-        // Update obstacles
+            updateObstacles() {
-        function updateObstacles() {
+                if (!this.gameActive) return;
-            if (!gameActive) return;
                 
-            obstacles.forEach(obstacle => {
+                this.obstacles.forEach(obstacle => {
-                // Move obstacle
+                    obstacle.update();
-                obstacle.position.add(obstacle.userData.direction);
                     
-                // Bounce off boundaries
+                    if (obstacle.checkCollisionWithPlayer(this.player.getPosition())) {
-                const boundary = groundSize / 2 - 1;
+                        this.health -= 1;
-                if (Math.abs(obstacle.position.x) > boundary) {
+                        this.updateUI();
-                    obstacle.userData.direction.x *= -1;
+                        this.player.handleCollision(obstacle.getPosition());
-                }
-                if (Math.abs(obstacle.position.z) > boundary) {
-                    obstacle.userData.direction.z *= -1;
-                }
                         
-                // Check collision with player
+                        if (this.health <= 0) {
-                const distance = player.position.distanceTo(obstacle.position);
+                            this.gameOver();
-                if (distance < 1.5) {
-                    health -= 1;
-                    updateUI();
-                    
-                    // Push player away (only on X and Z axis, keep Y constant)
-                    const pushDirection = player.position.clone().sub(obstacle.position);
-                    pushDirection.y = 0; // Keep player on ground level
-                    pushDirection.normalize();
-                    player.position.add(pushDirection.multiplyScalar(0.3));
-                    player.position.y = 0.5; // Ensure player stays at ground level
-                    
-                    // Check game over
-                    if (health <= 0) {
-                        gameOver();
                         }
                     }
                 });
             }
             
-        // Update UI
+            updateCamera() {
-        function updateUI() {
+                const playerPos = this.player.getPosition();
-            document.getElementById('score').textContent = score;
+                this.camera.position.x = playerPos.x;
-            document.getElementById('health').textContent = Math.max(0, health);
+                this.camera.position.z = playerPos.z + 15;
+                this.camera.lookAt(playerPos);
             }
             
-        // Game over
+            updateUI() {
-        function gameOver() {
+                document.getElementById('score').textContent = this.score;
-            gameActive = false;
+                document.getElementById('health').textContent = Math.max(0, this.health);
-            document.getElementById('finalScore').textContent = score;
+            }
+            
+            gameOver() {
+                this.gameActive = false;
+                document.getElementById('finalScore').textContent = this.score;
                 document.getElementById('gameOver').style.display = 'block';
             }
             
-        // Restart game
+            restart() {
-        function restartGame() {
                 // Remove all coins and obstacles
-            coins.forEach(coin => scene.remove(coin));
+                this.coins.forEach(coin => coin.remove());
-            obstacles.forEach(obstacle => scene.remove(obstacle));
+                this.obstacles.forEach(obstacle => obstacle.remove());
-            coins = [];
+                this.coins = [];
-            obstacles = [];
+                this.obstacles = [];
                 
                 // Reset player
-            player.position.set(0, 0.5, 0);
+                this.player.reset();
-            player.rotation.y = 0;
                 
                 // Reset game state
-            score = 0;
+                this.score = 0;
-            health = 100;
+                this.health = 100;
-            gameActive = true;
+                this.gameActive = true;
                 
                 // Recreate game objects
-            createCoins(10);
+                this.createGameObjects();
-            createObstacles(8);
                 
                 // Hide game over screen
                 document.getElementById('gameOver').style.display = 'none';
-            updateUI();
+                this.updateUI();
             }
             
-        // Handle window resize
+            onWindowResize() {
-        function onWindowResize() {
+                this.camera.aspect = window.innerWidth / window.innerHeight;
-            camera.aspect = window.innerWidth / window.innerHeight;
+                this.camera.updateProjectionMatrix();
-            camera.updateProjectionMatrix();
+                this.renderer.setSize(window.innerWidth, window.innerHeight);
-            renderer.setSize(window.innerWidth, window.innerHeight);
             }
             
-        // Animation loop
+            animate() {
-        function animate() {
+                requestAnimationFrame(() => this.animate());
-            requestAnimationFrame(animate);
                 
-            updatePlayer();
+                this.updatePlayer();
-            updateCoins();
+                this.updateCoins();
-            updateObstacles();
+                this.updateObstacles();
+                this.updateCamera();
                 
-            // Camera follows player
+                this.renderer.render(this.scene, this.camera);
-            camera.position.x = player.position.x;
+            }
-            camera.position.z = player.position.z + 15;
-            camera.lookAt(player.position);
-            
-            renderer.render(scene, camera);
         }
         
         // Start the game
-        init();
+        const game = new Game();
     </script>
 </body>
 </html>