AI game creator

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

No:41681

←

Prev Next

→

Tetris
Developer User13365｜Date and time 24/2/9 5:13:19
Build time 26.439 sec｜Game capacity 7.828KB｜

Script

←

Prev　Next

→ 　

Back　

[PR]現在の人気ゲームランキング

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

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>Tetris Game</title>
    <style>
        body {
            margin: 0;
            padding: 0;
        }
        canvas {
            display: block;
            margin: 0 auto;
            background: #000;
        }
    </style>
</head>
<body>
    <canvas id="tetris" width="240" height="400"></canvas>
    
    <script>
        document.addEventListener('DOMContentLoaded', () => {
            const canvas = document.getElementById('tetris');
            const context = canvas.getContext('2d');
            const scale = 20;
        
            const rows = canvas.height / scale;
            const columns = canvas.width / scale;
        
            let score = 0;
        
            const colors = [
                'rgba(0, 0, 0, 0)',
                'rgba(255, 0, 0, 1)',
                'rgba(0, 255, 255, 1)',
                'rgba(0, 255, 0, 1)',
                'rgba(255, 255, 0, 1)',
                'rgba(255, 165, 0, 1)',
                'rgba(0, 0, 255, 1)',
                'rgba(128, 0, 128, 1)'
            ];
        
            const tetrominoes = [
                [],
                [[1, 1, 1, 1]],
                [[1, 1], [1, 1]],
                [[1, 1, 0], [0, 1, 1]],
                [[0, 1, 1], [1, 1, 0]],
                [[1, 1, 1], [0, 1, 0]],
                [[0, 1, 0], [1, 1, 1]],
                [[1, 0, 0], [1, 1, 1]]
            ];
        
            const createMatrix = (rows, columns) => {
                const matrix = [];
                while (rows--) {
                    matrix.push(new Array(columns).fill(0));
                }
                return matrix;
            };
        
            const arena = createMatrix(rows, columns);
            const player = {
                matrix: tetrominoes[Math.floor(Math.random() * tetrominoes.length)],
                position: { x: 0, y: 0 }
            };
        
            const collide = (arena, player) => {
                const [m, o] = [player.matrix, player.position];
                for (let y = 0; y < m.length; y++) {
                    for (let x = 0; x < m[y].length; x++) {
                        if (m[y][x] !== 0 && (arena[y + o.y] && arena[y + o.y][x + o.x]) !== 0) {
                            return true;
                        }
                    }
                }
                return false;
            };
        
            const merge = (arena, player) => {
                player.matrix.forEach((row, y) => {
                    row.forEach((value, x) => {
                        if (value !== 0) {
                            arena[y + player.position.y][x + player.position.x] = value;
                        }
                    });
                });
            };
        
            const rotate = (matrix, direction) => {
                for (let y = 0; y < matrix.length; y++) {
                    for (let x = 0; x < y; x++) {
                        [matrix[x][y], matrix[y][x]] = [matrix[y][x], matrix[x][y]];
                    }
                }
                if (direction > 0) {
                    matrix.forEach(row => row.reverse());
                } else {
                    matrix.reverse();
                }
            };
        
            const drawMatrix = (matrix, offset) => {
                matrix.forEach((row, y) => {
                    row.forEach((value, x) => {
                        if (value !== 0) {
                            context.fillStyle = colors[value];
                            context.fillRect((x + offset.x) * scale, (y + offset.y) * scale, scale, scale);
                            context.strokeStyle = '#000';
                            context.lineWidth = 0.5;
                            context.strokeRect((x + offset.x) * scale, (y + offset.y) * scale, scale, scale);
                        }
                    });
                });
            };
        
            const draw = () => {
                context.fillStyle = '#000';
                context.fillRect(0, 0, canvas.width, canvas.height);
        
                drawMatrix(arena, { x: 0, y: 0 });
                drawMatrix(player.matrix, player.position);
            };
        
            const playerDrop = () => {
                player.position.y++;
                if (collide(arena, player)) {
                    player.position.y--;
                    merge(arena, player);
                    playerReset();
                    arenaSweep();
                    updateScore();
                }
            };
        
            const playerMove = direction => {
                player.position.x += direction;
                if (collide(arena, player)) {
                    player.position.x -= direction;
                }
            };
        
            const playerReset = () => {
                player.matrix = tetrominoes[Math.floor(Math.random() * tetrominoes.length)];
                player.position.y = 0;
                player.position.x = Math.floor(columns / 2) - Math.floor(player.matrix[0].length / 2);
                if (collide(arena, player)) {
                    arena.forEach(row => row.fill(0));
                    score = 0;
                    updateScore();
                }
            };
        
            const playerRotate = direction => {
                const position = player.position.x;
                let offset = 1;
                rotate(player.matrix, direction);
                while (collide(arena, player)) {
                    player.position.x += offset;
                    offset = -(offset + (offset > 0 ? 1 : -1));
                    if (offset > player.matrix[0].length) {
                        rotate(player.matrix, -direction);
                        player.position.x = position;
                        return;
                    }
                }
            };
        
            const arenaSweep = () => {
                outer: for (let y = arena.length - 1; y > 0; y--) {
                    for (let x = 0; x < arena[y].length; x++) {
                        if (arena[y][x] === 0) {
                            continue outer;
                        }
                    }
                    const row = arena.splice(y, 1)[0].fill(0);
                    arena.unshift(row);
                    y++;
        
                    score += 10;
                }
            };
        
            const updateScore = () => {
                document.getElementById('score').innerText = score;
            };
        
            document.addEventListener('keydown', event => {
                if (event.keyCode === 37) {
                    playerMove(-1); // Left arrow key
                } else if (event.keyCode === 39) {
                    playerMove(1); // Right arrow key
                } else if (event.keyCode === 40) {
                    playerDrop(); // Down arrow key
                } else if (event.keyCode === 38) {
                    playerRotate(1); // Up arrow key (rotate clockwise)
                } else if (event.keyCode === 32) {
                    playerRotate(-1); // Space key (rotate counter-clockwise)
                }
            });
        
            const dropInterval = 1000; // 1 second
        
            let lastTime = 0;
            let deltaTime = 0;
        
            const update = time => {
                deltaTime += time - lastTime;
                lastTime = time;
        
                if (deltaTime > dropInterval) {
                    playerDrop();
                }
        
                draw();
                requestAnimationFrame(update);
            };
        
            updateScore();
            playerReset();
            update();
        });
    </script>
</body>
</html>