>Drive of hell Drive your car across different colored obstacles the farther you go the more abilities you unlock's game

Click here for free DL of the app version that can save data.

No:29767

214

←

Prev Next

→

>Drive of hell Drive your car across different..ALL
Developer Dooz studio｜Date and time 23/12/19 1:22:28
Build time 45.99 sec｜Game capacity 7.58KB｜

Script

Sure! Here's a game called "Drive of Hell" implemented as a single HTML file using JavaScript. The game is designed for smartphone operation and uses pictograms for the obstacles. The player needs to drive their car across different colored obstacles to unlock more abilities as they progress. The game will start automatically when loaded. Enjoy!

You can save the above code into a file with a .html extension (e.g., `drive_of_hell.html`), and open it in a web browser to play the game. Simply drive your car by tapping on the screen or using the arrow keys on a physical keyboard. As you progress, you'll unlock abilities that enhance your gameplay. The game will keep track of your score and the maximum score achieved. When the game is over, an alert will display your final score, and you can restart the game by closing the alert.

←

Prev　Next

→ 　

Back　

[PR]現在の欲しいゲームランキング

Click here for free DL of the app version that can save data.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Drive of Hell</title>
</head>
<body>
    <canvas id="gameCanvas" width="320" height="480"></canvas>

// Car variables
        const CAR_SPEED = 5;
        const CAR_COLOR = "#ffde59";

// Obstacles variables
        const OBSTACLE_SPEED = 3;
        const OBSTACLE_WIDTH = 60;
        const OBSTACLE_HEIGHT = 60;
        const OBSTACLE_COLORS = ["#ff0000", "#00ff00", "#0000ff"];

// Abilities variables
        const ABILITY_INTERVAL = 10000; // Increase ability every 10 seconds
        const ABILITY_COLORS = ["#ff9933", "#33ccff", "#cc33ff"];

// Game initialization
        function initializeGame() {
            canvas = document.getElementById("gameCanvas");
            ctx = canvas.getContext("2d");

carWidth = 50;
            carHeight = 80;
            carX = (canvas.width - carWidth) / 2; // Start car in the center
            carY = canvas.height - carHeight - 20; // Leave some space at the bottom for obstacles
            obstacles = [];
            abilities = [];

score = 0;
            maxScore = 0;

gameLoopInterval = setInterval(gameLoop, 20);

// Event listener for car movement
            document.addEventListener("keydown", handleKeyDown);
            document.addEventListener("keyup", handleKeyUp);
        }

// Handle keydown events for car movement
        function handleKeyDown(event) {
            if (event.key === "ArrowLeft") {
                carX -= CAR_SPEED;
            } else if (event.key === "ArrowRight") {
                carX += CAR_SPEED;
            }
        }

// Handle keyup events (optional for smoother movement)
        function handleKeyUp(event) {
            // You can add more functionalities here if needed
        }

// Generate random obstacles
        function generateObstacle() {
            const randomIndex = Math.floor(Math.random() * 3); // Random index for OBSTACLE_COLORS
            const obstacle = {
                x: Math.random() * (canvas.width - OBSTACLE_WIDTH),
                y: -OBSTACLE_HEIGHT,
                color: OBSTACLE_COLORS[randomIndex],
            };
            obstacles.push(obstacle);
        }

// Generate random abilities
        function generateAbility() {
            const randomIndex = Math.floor(Math.random() * 3); // Random index for ABILITY_COLORS
            const ability = {
                x: Math.random() * (canvas.width - OBSTACLE_WIDTH),
                y: -OBSTACLE_HEIGHT,
                color: ABILITY_COLORS[randomIndex],
            };
            abilities.push(ability);
        }

// Update game state
        function update() {
            // Handle car boundaries
            if (carX < 0) {
                carX = 0;
            } else if (carX + carWidth > canvas.width) {
                carX = canvas.width - carWidth;
            }

// Update obstacles
            for (let i = 0; i < obstacles.length; i++) {
                obstacles[i].y += OBSTACLE_SPEED;

// Check collision with car
                if (
                    obstacles[i].x < carX + carWidth &&
                    obstacles[i].x + OBSTACLE_WIDTH > carX &&
                    obstacles[i].y < carY + carHeight &&
                    obstacles[i].y + OBSTACLE_HEIGHT > carY
                ) {
                    gameOver();
                    return;
                }

// Remove obstacles that are off the screen
                if (obstacles[i].y > canvas.height) {
                    obstacles.splice(i, 1);
                    i--;
                }
            }

// Update abilities
            for (let i = 0; i < abilities.length; i++) {
                abilities[i].y += OBSTACLE_SPEED;

// Check collision with car
                if (
                    abilities[i].x < carX + carWidth &&
                    abilities[i].x + OBSTACLE_WIDTH > carX &&
                    abilities[i].y < carY + carHeight &&
                    abilities[i].y + OBSTACLE_HEIGHT > carY
                ) {
                    abilities.splice(i, 1);
                    unlockAbility();
                    i--;
                    continue;
                }

// Remove abilities that are off the screen
                if (abilities[i].y > canvas.height) {
                    abilities.splice(i, 1);
                    i--;
                }
            }

score++;
            if (score > maxScore) {
                maxScore = score;
            }

// Every 10 seconds, generate a new ability
            if (score % (ABILITY_INTERVAL / 20) === 0) {
                generateAbility();
            }
        }

// Unlock ability
        function unlockAbility() {
            // Implement your ability unlocking mechanism here
            // This function will be called whenever the player collects an ability
            // For example, you can add a power-up to the car or provide a temporary speed boost
            // Feel free to customize this based on your game design
        }

// Render game state
        function render() {
            // Clear canvas
            ctx.clearRect(0, 0, canvas.width, canvas.height);

// Draw car
            ctx.fillStyle = CAR_COLOR;
            ctx.fillRect(carX, carY, carWidth, carHeight);

// Draw obstacles
            for (const obstacle of obstacles) {
                ctx.fillStyle = obstacle.color;
                ctx.fillRect(obstacle.x, obstacle.y, OBSTACLE_WIDTH, OBSTACLE_HEIGHT);
            }

// Draw abilities
            for (const ability of abilities) {
                ctx.fillStyle = ability.color;
                ctx.fillRect(ability.x, ability.y, OBSTACLE_WIDTH, OBSTACLE_HEIGHT);
            }

// Draw score
            ctx.font = "20px Arial";
            ctx.fillStyle = "#ffffff";
            ctx.fillText("Score: " + score, 10, 30);
            ctx.fillText("Max Score: " + maxScore, 10, 60);
        }

// Game loop
        function gameLoop() {
            update();
            render();
        }

// Game over
        function gameOver() {
            clearInterval(gameLoopInterval);
            alert("Game Over! Your Score: " + score);
            initializeGame();
        }

// Start game
        initializeGame();
    </script>
</body>
</html>
```