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:

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!
© 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.