AI game creator

Warning: count(): Parameter must be an array or an object that implements Countable in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 157

Warning: in_array() expects parameter 2 to be array, bool given in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 476

Warning: count(): Parameter must be an array or an object that implements Countable in /home/yukuri/crypto-app.tokyo/public_html/AIGameCreator/Com0.php on line 484
Créame tetris's game | AI game creator

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

No:41497

139

←

Prev Next

→

Créame tetris
Developer User18588｜Date and time 24/2/7 23:16:28
Build time 42.779 sec｜Game capacity 10.545KB｜

Script

Aquí tienes un ejemplo de un juego de tetris implementado en un solo archivo HTML, utilizando JavaScript y pictogramas para una operación en un smartphone:

Este código implementa el clásico juego de tetris en un solo archivo HTML utilizando JavaScript. El tablero de juego se muestra en un contenedor div con el id `tetris-container` y se utiliza CSS para darle estilo al tablero y a las celdas individuales. Las formas de los tetriminos se representan como matrices de números, donde 1 indica una celda ocupada. El jugador puede mover y rotar el tetrimino utilizando las flechas del teclado. Espero que esto cumpla con tus requisitos y que disfrutes jugando al tetris. Buena suerte!

←

Prev　Next

→ 　

Back　

[PR]現在の売れ筋ゲームランキング

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

Aquí tienes un ejemplo de un juego de tetris implementado en un solo archivo HTML, utilizando JavaScript y pictogramas para una operación en un smartphone:

```html
<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Tetris - Juego</title>
    <style>
        #tetris-container {
            display: flex;
            flex-wrap: wrap;
            width: 300px;
            height: 600px;
            border: 2px solid black;
            overflow: hidden;
        }
        .cell {
            width: 30px;
            height: 30px;
            border: 1px solid black;
        }
    </style>
</head>
<body>
    <div id="tetris-container"></div>

// Dimensiones del tablero
        const filas = 20;
        const columnas = 10;

// Pictogramas para las formas del tetrimino
        const formas = [
            [
                [1, 1],
                [1, 1],
            ],
            [
                [1, 1, 1, 1]
            ],
            [
                [0, 1, 0],
                [1, 1, 1]
            ],
            [
                [1, 1, 0],
                [0, 1, 1]
            ],
            [
                [1, 1, 1],
                [0, 0, 1]
            ],
            [
                [1, 1, 1],
                [1, 0, 0]
            ],
            [
                [1, 1, 1, 1]
            ]
        ];

// Clase para representar los tetriminos
        class Tetrimino {
            constructor(formaIndex) {
                this.forma = formas[formaIndex];
                this.fila = -this.forma.length; // Comienza arriba del tablero
                this.columna = Math.floor(columnas / 2) - Math.floor(this.forma[0].length / 2); // Comienza en el centro del tablero
            }
        }

// Función para crear el tablero del juego
        function crearTablero() {
            const contenedor = document.getElementById('tetris-container');

for (let fila = 0; fila < filas; fila++) {
                for (let columna = 0; columna < columnas; columna++) {
                    const celda = document.createElement('div');
                    celda.className = 'cell';
                    contenedor.appendChild(celda);
                    tablero.push(celda);
                }
            }
        }

// Función para dibujar el tetrimino actual en el tablero
        function dibujarTetrimino(tetrimino) {
            for (let i = 0; i < tetrimino.forma.length; i++) {
                for (let j = 0; j < tetrimino.forma[i].length; j++) {
                    if (tetrimino.forma[i][j]) {
                        const indice = (tetrimino.fila + i) * columnas + (tetrimino.columna + j);
                        tablero[indice].style.backgroundColor = 'black';
                    }
                }
            }
        }

// Función para borrar el tetrimino actual del tablero
        function borrarTetrimino(tetrimino) {
            for (let i = 0; i < tetrimino.forma.length; i++) {
                for (let j = 0; j < tetrimino.forma[i].length; j++) {
                    if (tetrimino.forma[i][j]) {
                        const indice = (tetrimino.fila + i) * columnas + (tetrimino.columna + j);
                        tablero[indice].style.backgroundColor = 'transparent';
                    }
                }
            }
        }

// Función para mover el tetrimino hacia abajo
        function moverAbajo() {
            const puedeMoverse = validarMovimiento(actualTetrimino, actualTetrimino.fila + 1, actualTetrimino.columna);
            if (puedeMoverse) {
                borrarTetrimino(actualTetrimino);
                actualTetrimino.fila++;
                dibujarTetrimino(actualTetrimino);
            } else {
                // Tetrimino ha llegado al final
                fijarTetrimino(actualTetrimino);
                borrarFilasCompletas();
                generarNuevoTetrimino();
            }
        }

// Función para mover el tetrimino hacia la izquierda
        function moverIzquierda() {
            const puedeMoverse = validarMovimiento(actualTetrimino, actualTetrimino.fila, actualTetrimino.columna - 1);
            if (puedeMoverse) {
                borrarTetrimino(actualTetrimino);
                actualTetrimino.columna--;
                dibujarTetrimino(actualTetrimino);
            }
        }

// Función para mover el tetrimino hacia la derecha
        function moverDerecha() {
            const puedeMoverse = validarMovimiento(actualTetrimino, actualTetrimino.fila, actualTetrimino.columna + 1);
            if (puedeMoverse) {
                borrarTetrimino(actualTetrimino);
                actualTetrimino.columna++;
                dibujarTetrimino(actualTetrimino);
            }
        }

// Función para rotar el tetrimino
        function rotar() {
            const formaActual = actualTetrimino.forma;
            const nuevaForma = [];

for (let columna = 0; columna < formaActual[0].length; columna++) {
                const filaNueva = [];
                for (let fila = formaActual.length - 1; fila >= 0; fila--) {
                    filaNueva.push(formaActual[fila][columna]);
                }
                nuevaForma.push(filaNueva);
            }

const puedeRotar = validarMovimiento(actualTetrimino, actualTetrimino.fila, actualTetrimino.columna, nuevaForma);
            if (puedeRotar) {
                borrarTetrimino(actualTetrimino);
                actualTetrimino.forma = nuevaForma;
                dibujarTetrimino(actualTetrimino);
            }
        }

// Función para verificar si un movimiento es válido
        function validarMovimiento(tetrimino, nuevaFila, nuevaColumna, nuevaForma) {
            nuevaForma = nuevaForma || tetrimino.forma;

for (let i = 0; i < nuevaForma.length; i++) {
                for (let j = 0; j < nuevaForma[i].length; j++) {
                    if (nuevaForma[i][j]) {
                        const fila = nuevaFila + i;
                        const columna = nuevaColumna + j;

if (fila < 0 || fila >= filas || columna < 0 || columna >= columnas) {
                            return false; // Movimiento fuera de los límites
                        }

const indice = fila * columnas + columna;
                        if (tablero[indice].style.backgroundColor !== 'transparent') {
                            return false; // Celda ocupada
                        }
                    }
                }
            }

return true;
        }

// Función para fijar un tetrimino en su posición final
        function fijarTetrimino(tetrimino) {
            for (let i = 0; i < tetrimino.forma.length; i++) {
                for (let j = 0; j < tetrimino.forma[i].length; j++) {
                    if (tetrimino.forma[i][j]) {
                        const fila = tetrimino.fila + i;
                        const columna = tetrimino.columna + j;
                        const indice = fila * columnas + columna;
                        tablero[indice].style.backgroundColor = 'black';
                    }
                }
            }
        }

// Función para borrar filas completas y mover las superiores hacia abajo
        function borrarFilasCompletas() {
            let filaCompleta = true;
            let filasBorradas = 0;

for (let fila = filas - 1; fila >= 0; fila--) {
                filaCompleta = true;

for (let columna = 0; columna < columnas; columna++) {
                    const indice = fila * columnas + columna;

if (tablero[indice].style.backgroundColor === 'transparent') {
                        filaCompleta = false;
                        break;
                    }
                }

if (filaCompleta) {
                    // Borrar fila
                    for (let columna = 0; columna < columnas; columna++) {
                        const indice = fila * columnas + columna;
                        tablero[indice].style.backgroundColor = 'transparent';
                    }

filasBorradas++;
                } else if (filasBorradas > 0) {
                    // Mover filas hacia abajo
                    for (let columna = 0; columna < columnas; columna++) {
                        const indiceOrigen = fila * columnas + columna;
                        const indiceDestino = (fila + filasBorradas) * columnas + columna;
                        tablero[indiceDestino].style.backgroundColor = tablero[indiceOrigen].style.backgroundColor;
                        tablero[indiceOrigen].style.backgroundColor = 'transparent';
                    }
                }
            }
        }

// Función para generar un nuevo tetrimino aleatorio
        function generarNuevoTetrimino() {
            const formaIndex = Math.floor(Math.random() * formas.length);
            actualTetrimino = new Tetrimino(formaIndex);
            dibujarTetrimino(actualTetrimino);
        }

// Iniciar el juego
        crearTablero();
        generarNuevoTetrimino();
        setInterval(moverAbajo, 1000); // Mover el tetrimino hacia abajo cada segundo

// Escuchar eventos de teclado para mover o rotar el tetrimino
        document.addEventListener('keydown', function(event) {
            if (event.key === 'ArrowUp') {
                rotar();
            } else if (event.key === 'ArrowDown') {
                moverAbajo();
            } else if (event.key === 'ArrowLeft') {
                moverIzquierda();
            } else if (event.key === 'ArrowRight') {
                moverDerecha();
            }
        });
    </script>
</body>
</html>
```

Espero que esto cumpla con tus requisitos y que disfrutes jugando al tetris. Buena suerte!