A game where you make snowballs And throw them at AI people That will throw snowballs back You can make big snowballs by rolling them in the snow The AI will sometimes do it too The AI is just like you the player You can choose your throw Attack Make sure You can't choose A custom 1You have 5 options and the game Will give you them And when too many snowballs Are throwed at you then You will freeze to death's game

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

No:37038

←

Prev Next

→

A game where you make snowballs And throw them at ..ALL
Developer Game Studio｜Date and time 24/1/20 0:20:40
Build time 24.173 sec｜Game capacity 6.114KB｜

Script

Sure! Here's an example of how you can implement the game using JavaScript and HTML:

In this game, you control the player using the left and right arrow keys to move and the spacebar to throw snowballs at the AI. The AI will also throw snowballs back at you randomly. You have to avoid getting hit by too many snowballs, as crossing the specified freeze threshold will end the game. The game is displayed on a canvas element with a blue background. The player is represented by a red rectangle at the bottom center of the canvas, while the snowballs are represented by white circles (for player) and green circles (for AI). The snowballs move upwards from the bottom of the canvas. You can customize the game further and add more features as per your requirements.

←

Prev　Next

→ 　

Back　

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

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

Sure! Here's an example of how you can implement the game using JavaScript and HTML:

```html
<!DOCTYPE html>
<html>
<head>
    <title>Snowball Fight</title>
    <style>
        #gameCanvas {
            width: 100%;
            height: 500px;
            background-color: lightblue;
        }
        
        #player {
            position: absolute;
            bottom: 0;
            left: 50%;
            transform: translateX(-50%);
            width: 50px;
            height: 50px;
            background-color: red;
        }
        
        .snowball {
            position: absolute;
            width: 20px;
            height: 20px;
            border-radius: 50%;
            background-color: white;
        }
        
        .snowball.ai {
            background-color: green;
        }
    </style>
</head>
<body>
    <canvas id="gameCanvas"></canvas>
    <script>
        // Game Constants
        const GAME_WIDTH = 500;
        const GAME_HEIGHT = 500;
        const PLAYER_SPEED = 5;
        const SNOWBALL_SPEED = 2;
        const MAX_SNOWBALLS = 5;
        const SNOWBALL_SIZE = 20;
        const AI_THROW_PROBABILITY = 0.03;
        const FREEZE_THRESHOLD = 10;
        
        // Game Variables
        let playerX = GAME_WIDTH / 2;
        const snowballs = [];
        let freezeCount = 0;
        
        // Game Canvas
        const canvas = document.getElementById('gameCanvas');
        canvas.width = GAME_WIDTH;
        canvas.height = GAME_HEIGHT;
        const context = canvas.getContext('2d');
        
        // Player Controls
        document.addEventListener('keydown', function(event) {
            if (event.keyCode === 37) { // Left Arrow Key
                movePlayer(-PLAYER_SPEED);
            } else if (event.keyCode === 39) { // Right Arrow Key
                movePlayer(PLAYER_SPEED);
            } else if (event.keyCode === 32) { // Spacebar
                throwSnowball(playerX);
            }
        });
        
        // Move the player
        function movePlayer(direction) {
            playerX += direction;
            if (playerX < 0) {
                playerX = 0;
            } else if (playerX > GAME_WIDTH) {
                playerX = GAME_WIDTH;
            }
        }
        
        // Throw a snowball
        function throwSnowball(x) {
            if (snowballs.length < MAX_SNOWBALLS) {
                snowballs.push({
                    x: x - SNOWBALL_SIZE / 2,
                    y: GAME_HEIGHT - SNOWBALL_SIZE,
                    isPlayer: true
                });
            }
        }
        
        // Update the game state
        function update() {
            // Move snowballs
            snowballs.forEach(function(snowball) {
                snowball.y -= SNOWBALL_SPEED;
                if (snowball.y < 0) {
                    snowball.isDestroyed = true;
                }
            });
            
            // Remove destroyed snowballs
            snowballs.forEach(function(snowball, index) {
                if (snowball.isDestroyed) {
                    snowballs.splice(index, 1);
                }
            });
            
            // AI throws snowballs randomly
            if (Math.random() < AI_THROW_PROBABILITY && snowballs.length < MAX_SNOWBALLS) {
                snowballs.push({
                    x: Math.random() * GAME_WIDTH - SNOWBALL_SIZE / 2,
                    y: 0,
                    isPlayer: false
                });
            }
            
            // Check for collisions
            snowballs.forEach(function(snowball) {
                if (Math.abs(snowball.x - playerX) <= SNOWBALL_SIZE &&
                    snowball.y >= GAME_HEIGHT - SNOWBALL_SIZE) {
                        if (snowball.isPlayer) {
                            // Player hit by AI snowball
                            freezeCount++;
                        } else {
                            // AI hit by player snowball
                            snowball.isDestroyed = true;
                        }
                    }
            });
            
            // Check freeze count
            if (freezeCount >= FREEZE_THRESHOLD) {
                endGame();
            }
            
            // Draw the game
            draw();
        }
        
        // Draw the game on the canvas
        function draw() {
            // Clear canvas
            context.clearRect(0, 0, GAME_WIDTH, GAME_HEIGHT);
            
            // Draw player
            context.fillStyle = 'red';
            context.fillRect(playerX - 25, GAME_HEIGHT - 50, 50, 50);
            
            // Draw snowballs
            snowballs.forEach(function(snowball) {
                context.fillStyle = snowball.isPlayer ? 'white' : 'green';
                context.beginPath();
                context.arc(snowball.x + SNOWBALL_SIZE / 2, snowball.y + SNOWBALL_SIZE / 2,
                            SNOWBALL_SIZE / 2, 0, Math.PI*2);
                context.fill();
            });
        }
        
        // End the game
        function endGame() {
            // Clear interval and show game over screen
            clearInterval(gameInterval);
            alert('You froze to death!');
        }
        
        // Start the game
        function startGame() {
            gameInterval = setInterval(update, 10);
        }
        
        startGame();
    </script>
</body>
</html>
```

The game is displayed on a canvas element with a blue background. The player is represented by a red rectangle at the bottom center of the canvas, while the snowballs are represented by white circles (for player) and green circles (for AI). The snowballs move upwards from the bottom of the canvas.

You can customize the game further and add more features as per your requirements.