Tutorial avanzado de QML 4: toques finales
Añadiendo un toque especial
Ahora vamos a hacer dos cosas para darle más vida al juego: animar los bloques y añadir un sistema de puntuación máxima.
En previsión de las nuevas animaciones de los bloques, el fichero « Block.qml » pasa a llamarse « BoomBlock.qml ».
Animación del movimiento de los bloques
En primer lugar, animaremos los bloques para que se muevan con fluidez. QML dispone de varios métodos para añadir movimiento fluido y, en este caso, vamos a utilizar el tipo « Behavior » para añadir un « SpringAnimation ». En « BoomBlock.qml », aplicamos un comportamiento « SpringAnimation » a las propiedades « x » y « y » para que el bloque siga y anime su movimiento a modo de resorte hacia la posición especificada (cuyos valores se establecerán mediante « samegame.js »). A continuación se muestra el código añadido a « BoomBlock.qml »:
property bool spawned: false
Behavior on x {
enabled: block.spawned;
SpringAnimation{ spring: 2; damping: 0.2 }
}
Behavior on y {
SpringAnimation{ spring: 2; damping: 0.2 }
}Los valores de « spring » y « damping » se pueden modificar para ajustar el efecto de resorte de la animación.
El ajuste enabled: spawned hace referencia al valor spawned que se establece desde createBlock() en samegame.js. Esto garantiza que el SpringAnimation en x solo se active después de que createBlock() haya colocado el bloque en la posición correcta. De lo contrario, los bloques se deslizarán fuera de la esquina (0,0) al comenzar la partida, en lugar de caer desde arriba en filas. (Prueba a comentar enabled: spawned y compruébalo por ti mismo).
Animación de los cambios de opacidad de los bloques
A continuación, añadiremos una animación de salida suave. Para ello, utilizaremos el tipo « Behavior », que nos permite especificar una animación predeterminada cuando se produce un cambio en una propiedad. En este caso, cuando cambie la propiedad « opacity » de un bloque, animaremos el valor de opacidad para que aparezca y desaparezca gradualmente, en lugar de cambiar bruscamente entre estar totalmente visible e invisible. Para ello, aplicaremos un « Behavior » a la propiedad « opacity » del tipo « Image » en « BoomBlock.qml »:
Image {
id: img
anchors.fill: parent
source: {
if (block.type == 0)
return "pics/redStone.png";
else if (block.type == 1)
return "pics/blueStone.png";
else
return "pics/greenStone.png";
}
opacity: 0
Behavior on opacity {
NumberAnimation { properties:"opacity"; duration: 200 }
}
}Fíjate en ` opacity: 0 `, que significa que el bloque es transparente cuando se crea por primera vez. Podríamos establecer la opacidad en ` samegame.js ` al crear y destruir los bloques, pero en su lugar utilizaremos estados, ya que esto resulta útil para la siguiente animación que vamos a añadir. Inicialmente, añadimos estos estados al tipo raíz de ` BoomBlock.qml`:
property bool dying: false
states: [
State{ name: "AliveState"; when: spawned == true && dying == false
PropertyChanges { target: img; opacity: 1 }
},
State{ name: "DeathState"; when: dying == true
PropertyChanges { target: img; opacity: 0 }
}
]Ahora los bloques aparecerán automáticamente con un efecto de fundido, ya que hemos establecido spawned en «true» al implementar las animaciones de los bloques. Para que desaparezcan con un efecto de fundido, establecemos dying en «true» en lugar de poner la opacidad a 0 cuando se destruye un bloque (en la función floodFill() ).
Añadir efectos de partículas
Por último, añadiremos un efecto de partículas muy chulo a los bloques cuando sean destruidos. Para ello, primero añadimos un ParticleSystem en BoomBlock.qml, de la siguiente manera:
ParticleSystem {
id: sys
anchors.centerIn: parent
ImageParticle {
// ![0]
source: {
if (block.type == 0)
return "pics/redStar.png";
else if (block.type == 1)
return "pics/blueStar.png";
else
return "pics/greenStar.png";
}
rotationVelocityVariation: 360
// ![0]
}
Emitter {
id: particles
anchors.centerIn: parent
emitRate: 0
lifeSpan: 700
velocity: AngleDirection {angleVariation: 360; magnitude: 80; magnitudeVariation: 40}
size: 16
}
}Para entenderlo a la perfección, deberías leer «Uso del sistema de partículas de Qt Quick », pero es importante tener en cuenta que ` emitRate ` está establecido en cero para que las partículas no se emitan de forma normal. Además, ampliamos el estado ` dying `, que crea una ráfaga de partículas al llamar al método ` burst() ` sobre el tipo de partículas. El código de los estados queda ahora así:
states: [
State {
name: "AliveState"
when: block.spawned == true && block.dying == false
PropertyChanges { img.opacity: 1 }
},
State {
name: "DeathState"
when: block.dying == true
StateChangeScript { script: particles.burst(50); }
PropertyChanges { img.opacity: 0 }
StateChangeScript { script: block.destroy(1000); }
}
]Ahora el juego cuenta con unas animaciones magníficas, con animaciones sutiles (o no tan sutiles) añadidas para todas las acciones del jugador. El resultado final se muestra a continuación, con un conjunto diferente de imágenes para demostrar la personalización básica de la temática:
El cambio de tema aquí se consigue simplemente sustituyendo las imágenes de los bloques. Esto se puede hacer en tiempo de ejecución cambiando la propiedad ` Image ` source, así que, como reto adicional, podrías añadir un botón que alterne entre temas con imágenes diferentes.
Mantener una tabla de mejores puntuaciones
Otra característica que podríamos querer añadir al juego es un método para almacenar y recuperar las puntuaciones más altas.
Para ello, mostraremos un cuadro de diálogo al finalizar la partida para solicitar el nombre del jugador y añadirlo a una tabla de mejores puntuaciones. Esto requiere algunos cambios en Dialog.qml. Además de un tipo Text, ahora cuenta con un elemento secundario TextInput para recibir la entrada de texto del teclado:
Rectangle {
id: container
...
TextInput {
id: textInput
anchors { verticalCenter: parent.verticalCenter; left: dialogText.right }
width: 80
text: ""
onAccepted: container.hide() // close dialog when Enter is pressed
}
...
}También añadiremos una función ` showWithInput() `. La entrada de texto solo será visible si se llama a esta función en lugar de a ` show()`. Cuando se cierra el cuadro de diálogo, emite una señal ` closed() `, y otros tipos pueden recuperar el texto introducido por el usuario a través de la propiedad ` inputText `:
Rectangle {
id: container
property string inputText: textInput.text
signal closed
function show(text) {
dialogText.text = text;
container.opacity = 1;
textInput.opacity = 0;
}
function showWithInput(text) {
show(text);
textInput.opacity = 1;
textInput.focus = true;
textInput.text = ""
}
function hide() {
textInput.focus = false;
container.opacity = 0;
container.closed();
}
...
}Ahora el cuadro de diálogo se puede utilizar en samegame.qml:
Dialog {
id: nameInputDialog
anchors.centerIn: parent
z: 100
onClosed: {
if (nameInputDialog.inputText != "")
SameGame.saveHighScore(nameInputDialog.inputText);
}
}Cuando el cuadro de diálogo emite la señal closed, llamamos a la nueva función saveHighScore() en samegame.js, que almacena la puntuación más alta localmente en una base de datos SQL y, además, envía la puntuación a una base de datos en línea si es posible.
La señal « nameInputDialog » se activa en la función « victoryCheck() » de samegame.js:
function victoryCheck() {
...
//Check whether game has finished
if (deservesBonus || !(floodMoveCheck(0, maxRow - 1, -1))) {
gameDuration = new Date() - gameDuration;
nameInputDialog.showWithInput("You won! Please enter your name: ");
}
}Almacenamiento de las puntuaciones más altas sin conexión
Ahora tenemos que implementar la funcionalidad para guardar realmente la tabla de puntuaciones más altas.
Aquí está la función ` saveHighScore() ` en ` samegame.js`:
function saveHighScore(name) {
if (gameCanvas.score == 0)
return;
if (scoresURL != "")
sendHighScore(name);
var db = Sql.LocalStorage.openDatabaseSync("SameGameScores", "1.0", "Local SameGame High Scores", 100);
var dataStr = "INSERT INTO Scores VALUES(?, ?, ?, ?)";
var data = [name, gameCanvas.score, maxColumn + "x" + maxRow, Math.floor(gameDuration / 1000)];
db.transaction(function(tx) {
tx.executeSql('CREATE TABLE IF NOT EXISTS Scores(name TEXT, score NUMBER, gridSize TEXT, time NUMBER)');
tx.executeSql(dataStr, data);
var rs = tx.executeSql('SELECT * FROM Scores WHERE gridSize = "12x17" ORDER BY score desc LIMIT 10');
var r = "\nHIGH SCORES for a standard sized grid\n\n"
for (var i = 0; i < rs.rows.length; i++) {
r += (i + 1) + ". " + rs.rows.item(i).name + ' got ' + rs.rows.item(i).score + ' points in ' + rs.rows.item(i).time + ' seconds.\n';
}
dialog.show(r);
});
}En primer lugar, llamamos a ` sendHighScore() ` (como se explica en la sección siguiente) si es posible enviar las puntuaciones máximas a una base de datos en línea.
A continuación, utilizamos ` Local Storage API ` para mantener una base de datos SQL persistente exclusiva de esta aplicación. Creamos una base de datos de almacenamiento sin conexión para las puntuaciones más altas utilizando ` openDatabaseSync() ` y preparamos los datos y la consulta SQL que queremos utilizar para guardarla. La API de almacenamiento sin conexión utiliza consultas SQL para la manipulación y recuperación de datos, y en la llamada a db.transaction() utilizamos tres consultas SQL para inicializar la base de datos (si es necesario) y, a continuación, añadir y recuperar las puntuaciones más altas. Para utilizar los datos devueltos, los convertimos en una cadena con una línea por cada fila devuelta y mostramos un cuadro de diálogo que contiene dicha cadena.
Esta es una forma de almacenar y mostrar las puntuaciones más altas de forma local, pero desde luego no es la única. Una alternativa más compleja sería crear un componente de diálogo de puntuaciones más altas y pasarle los resultados para su procesamiento y visualización (en lugar de reutilizar ` Dialog`). Esto permitiría un diálogo más personalizable que pudiera presentar mejor las puntuaciones más altas. Si tu QML es la interfaz de usuario de una aplicación en C++, también podrías haber pasado la puntuación a una función de C++ para almacenarla localmente de diversas formas, incluyendo un formato sencillo sin SQL o en otra base de datos SQL.
Almacenamiento de puntuaciones máximas en línea
Ya has visto cómo se pueden almacenar las puntuaciones más altas de forma local, pero también es fácil integrar un sistema de almacenamiento de puntuaciones más altas basado en la web en tu aplicación QML. La implementación que hemos realizado aquí es muy sencilla: los datos de las puntuaciones más altas se envían a un script PHP que se ejecuta en un servidor en algún lugar, y ese servidor los almacena y los muestra a los visitantes. También podrías solicitar un archivo XML o QML desde ese mismo servidor, que contenga y muestre las puntuaciones, pero eso queda fuera del alcance de este tutorial. El script PHP que utilizamos aquí está disponible en el directorio examples.
Si el jugador ha introducido su nombre, podemos enviar los datos al servicio web
Si el jugador introduce un nombre, enviamos los datos al servicio utilizando este código de samegame.js:
function sendHighScore(name) {
var postman = new XMLHttpRequest()
var postData = "name=" + name + "&score=" + gameCanvas.score + "&gridSize=" + maxColumn + "x" + maxRow + "&time=" + Math.floor(gameDuration / 1000);
postman.open("POST", scoresURL, true);
postman.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
postman.onreadystatechange = function() {
if (postman.readyState == postman.DONE) {
dialog.show("Your score has been uploaded.");
}
}
postman.send(postData);
}El XMLHttpRequest de este código es el mismo que el de XMLHttpRequest(), tal y como se encuentra en el JavaScript estándar de los navegadores, y puede utilizarse de la misma manera para obtener dinámicamente XML o QML del servicio web con el fin de mostrar las puntuaciones más altas. En este caso no nos preocupamos por la respuesta: simplemente enviamos los datos de la puntuación más alta al servidor web. Si hubiera devuelto un archivo QML (o una URL a un archivo QML), podrías instanciarlo de forma muy similar a como lo hiciste con los bloques.
Una forma alternativa de acceder y enviar datos web sería utilizar tipos QML diseñados para este fin. XmlListModel facilita enormemente la obtención y visualización de datos basados en XML, como RSS, en una aplicación QML.
¡Y ya está!
Al seguir este tutorial, has visto cómo se puede escribir una aplicación totalmente funcional en QML:
- Compila tu aplicación con QML types
- Añade la lógica de la aplicación con código JavaScript
- Añade animaciones con Behaviors y estados
- Almacena datos persistentes de la aplicación utilizando, por ejemplo, QtQuick.LocalStorage o XMLHttpRequest
Hay mucho más que aprender sobre QML y que no hemos podido tratar en este tutorial. ¡Echa un vistazo a todos los ejemplos y a la documentación para descubrir todo lo que puedes hacer con QML!
© 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.