En esta página

Tutorial avanzado de QML 3: Implementación de la lógica del juego

Creación de un juego jugable

Ahora que ya tenemos todos los componentes del juego, podemos añadir la lógica del juego que determina cómo interactúa el jugador con los bloques y cómo se desarrolla la partida hasta que se gana o se pierde.

Para ello, hemos añadido las siguientes funciones a ` samegame.js`:

  • handleClick(x,y)
  • floodFill(xIdx,yIdx,type)
  • shuffleDown()
  • victoryCheck()
  • floodMoveCheck(xIdx, yIdx, type)

Dado que este es un tutorial sobre QML, y no sobre diseño de juegos, a continuación solo analizaremos handleClick() y victoryCheck(), ya que interactúan directamente con los tipos de QML. Ten en cuenta que, aunque la lógica del juego aquí está escrita en JavaScript, podría haberse escrito en C++ y luego haberse expuesto a QML.

Habilitar la interacción mediante clics del ratón

Para facilitar que el código JavaScript interactúe con los tipos de QML, hemos añadido un elemento llamado « gameCanvas » a « samegame.qml ». Este sustituye al fondo como el elemento que contiene los bloques. Además, acepta la entrada del ratón por parte del usuario. Este es el código del elemento:

        Item {
            id: gameCanvas

            property int score: 0
            property int blockSize: 40

            width: parent.width - (parent.width % blockSize)
            height: parent.height - (parent.height % blockSize)
            anchors.centerIn: parent

            MouseArea {
                anchors.fill: parent
                onClicked: (mouse)=> SameGame.handleClick(mouse.x, mouse.y)
            }
        }

El elemento « gameCanvas » tiene exactamente el mismo tamaño que el tablero y cuenta con una propiedad « score » y un « MouseArea » para gestionar los clics del ratón. Los bloques se crean ahora como sus elementos hijos, y sus dimensiones se utilizan para determinar el tamaño del tablero, de modo que la aplicación se adapte al tamaño de pantalla disponible. Dado que su tamaño está vinculado a un múltiplo de blockSize, blockSize se ha trasladado de samegame.js a samegame.qml como una propiedad QML. Ten en cuenta que aún se puede acceder a ella desde el script.

Al hacer clic, el MouseArea llama a handleClick() en samegame.js, que determina si el clic del jugador debe provocar la eliminación de algún bloque y actualiza gameCanvas.score con la puntuación actual si es necesario. Aquí está la función handleClick():

function handleClick(xPos, yPos) {
    var column = Math.floor(xPos / gameCanvas.blockSize);
    var row = Math.floor(yPos / gameCanvas.blockSize);
    if (column >= maxColumn || column < 0 || row >= maxRow || row < 0)
        return;
    if (board[index(column, row)] == null)
        return;
    //If it's a valid block, remove it and all connected (does nothing if it's not connected)
    floodFill(column, row, -1);
    if (fillFound <= 0)
        return;
    gameCanvas.score += (fillFound - 1) * (fillFound - 1);
    shuffleDown();
    victoryCheck();
}

Ten en cuenta que si score fuera una variable global en el archivo samegame.js, no podrías vincularla. Solo se pueden vincular propiedades de QML.

Actualización de la puntuación

Cuando el jugador hace clic en un bloque y activa ` handleClick()`, ` handleClick() ` también llama a ` victoryCheck() ` para actualizar la puntuación y comprobar si el jugador ha completado el juego. Aquí está el código de ` victoryCheck() `:

function victoryCheck() {
    //Award bonus points if no blocks left
    var deservesBonus = true;
    for (var column = maxColumn - 1; column >= 0; column--)
        if (board[index(column, maxRow - 1)] != null)
        deservesBonus = false;
    if (deservesBonus)
        gameCanvas.score += 500;

    //Check whether game has finished
    if (deservesBonus || !(floodMoveCheck(0, maxRow - 1, -1)))
        dialog.show("Game Over. Your score is " + gameCanvas.score);
}

Esto actualiza el valor de « gameCanvas.score » y muestra un cuadro de diálogo «Game Over» si el juego ha terminado.

El cuadro de diálogo «Game Over» se crea utilizando un tipo Dialog definido en Dialog.qml. Aquí está el código de Dialog.qml. Fíjate en cómo está diseñado para poder utilizarse de forma imperativa desde el archivo de script, a través de las funciones y señales:

import QtQuick

Rectangle {
    id: container

    function show(text) {
        dialogText.text = text;
        container.opacity = 1;
    }

    function hide() {
        container.opacity = 0;
    }

    width: dialogText.width + 20
    height: dialogText.height + 20
    opacity: 0

    Text {
        id: dialogText
        anchors.centerIn: parent
        text: ""
    }

    MouseArea {
        anchors.fill: parent
        onClicked: hide();
    }
}

Y así es como se utiliza en el archivo principal de « samegame.qml »:

    Dialog {
        id: dialog
        anchors.centerIn: parent
        z: 100
    }

Le asignamos al cuadro de diálogo un valor de z de 100 para garantizar que se muestre por encima del resto de componentes. El valor predeterminado de z para un elemento es 0.

Un toque de color

No es muy divertido jugar a Same Game si todos los bloques son del mismo color, así que hemos modificado la función createBlock() de samegame.js para que genere aleatoriamente un tipo diferente de bloque (rojo, verde o azul) cada vez que se llama a la función. También hemos modificado Block.qml para que cada bloque contenga una imagen diferente según su tipo:

import QtQuick

Item {
    id: block

    property int type: 0

    Image {
        id: img

        anchors.fill: parent
        source: {
            if (type == 0)
                return "pics/redStone.png";
            else if (type == 1)
                return "pics/blueStone.png";
            else
                return "pics/greenStone.png";
        }
    }
}
Un juego que funciona

¡Ahora ya tenemos un juego que funciona! Se puede hacer clic en los bloques, el jugador puede sumar puntos y el juego puede terminar (y entonces puedes empezar uno nuevo). Aquí tienes una captura de pantalla de lo que hemos conseguido hasta ahora:

Juego en funcionamiento con bloques de colores parcialmente eliminados

Así es como se ve ahora samegame.qml:

import QtQuick
import "samegame.js" as SameGame

Rectangle {
    id: screen

    width: 490; height: 720

    SystemPalette { id: activePalette }

    Item {
        width: parent.width
        anchors { top: parent.top; bottom: toolBar.top }

        Image {
            id: background
            anchors.fill: parent
            source: "pics/background.jpg"
            fillMode: Image.PreserveAspectCrop
        }

        Item {
            id: gameCanvas

            property int score: 0
            property int blockSize: 40

            width: parent.width - (parent.width % blockSize)
            height: parent.height - (parent.height % blockSize)
            anchors.centerIn: parent

            MouseArea {
                anchors.fill: parent
                onClicked: (mouse)=> SameGame.handleClick(mouse.x, mouse.y)
            }
        }
    }

    Dialog {
        id: dialog
        anchors.centerIn: parent
        z: 100
    }

    Rectangle {
        id: toolBar
        width: parent.width; height: 30
        color: activePalette.window
        anchors.bottom: screen.bottom

        Button {
            anchors { left: parent.left; verticalCenter: parent.verticalCenter }
            text: "New Game"
            onClicked: SameGame.startNewGame()
        }

        Text {
            id: score
            anchors { right: parent.right; verticalCenter: parent.verticalCenter }
            text: "Score: Who knows?"
        }
    }
}

El juego funciona, pero de momento resulta un poco aburrido. ¿Dónde están las transiciones animadas fluidas? ¿Dónde están las puntuaciones más altas? Si fueras un experto en QML, podrías haberlas implementado en la primera iteración, pero en este tutorial se han dejado para el siguiente capítulo, ¡donde tu aplicación cobrará vida!

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.