Qt 5.11 | Qt Quick | Qt Quick Demo - Same Game | samegame.js Example File

Qt 5.11.3 Reference Documentation

# samegame.js Example File

demos/samegame/content/samegame.js

      /****************************************************************************
      **
      ** Copyright (C) 2017 The Qt Company Ltd.
      ** Contact: https://www.qt.io/licensing/
      **
      ** This file is part of the examples of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** Commercial License Usage
      ** Licensees holding valid commercial Qt licenses may use this file in
      ** accordance with the commercial license agreement provided with the
      ** Software or, alternatively, in accordance with the terms contained in
      ** a written agreement between you and The Qt Company. For licensing terms
      ** and conditions see https://www.qt.io/terms-conditions. For further
      ** information use the contact form at https://www.qt.io/contact-us.
      **
      ** BSD License Usage
      ** Alternatively, you may use this file under the terms of the BSD license
      ** as follows:
      **
      ** "Redistribution and use in source and binary forms, with or without
      ** modification, are permitted provided that the following conditions are
      ** met:
      **   * Redistributions of source code must retain the above copyright
      **     notice, this list of conditions and the following disclaimer.
      **   * Redistributions in binary form must reproduce the above copyright
      **     notice, this list of conditions and the following disclaimer in
      **     the documentation and/or other materials provided with the
      **     distribution.
      **   * Neither the name of The Qt Company Ltd nor the names of its
      **     contributors may be used to endorse or promote products derived
      **     from this software without specific prior written permission.
      **
      **
      ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
      ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
      ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
      ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
      ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
      ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
      ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
      ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
      ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
      ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
      ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
      **
      ** $QT_END_LICENSE$
      **
      ****************************************************************************/

      /* This script file handles the game logic */
      .pragma library
      .import QtQuick.LocalStorage 2.0 as Sql

      var maxColumn = 10;
      var maxRow = 13;
      var types = 3;
      var maxIndex = maxColumn*maxRow;
      var board = new Array(maxIndex);
      var blockSrc = "Block.qml";
      var gameDuration;
      var component = Qt.createComponent(blockSrc);
      var gameCanvas;
      var betweenTurns = false;

      var puzzleLevel = null;
      var puzzlePath = "";

      var gameMode = "arcade"; //Set in new game, then tweaks behaviour of other functions
      var gameOver = false;

      function changeBlock(src)
      {
          blockSrc = src;
          component = Qt.createComponent(blockSrc);
      }

      // Index function used instead of a 2D array
      function index(column, row)
      {
          return column + row * maxColumn;
      }

      function timeStr(msecs)
      {
          var secs = Math.floor(msecs/1000);
          var m = Math.floor(secs/60);
          var ret = "" + m + "m " + (secs%60) + "s";
          return ret;
      }

      function cleanUp()
      {
          if (gameCanvas == undefined)
              return;
          // Delete blocks from previous game
          for (var i = 0; i < maxIndex; i++) {
              if (board[i] != null)
                  board[i].destroy();
              board[i] = null;
          }
          if (puzzleLevel != null){
              puzzleLevel.destroy();
              puzzleLevel = null;
          }
          gameCanvas.mode = ""
      }

      function startNewGame(gc, mode, map)
      {
          gameCanvas = gc;
          if (mode == undefined)
              gameMode = "arcade";
          else
              gameMode = mode;
          gameOver = false;

          cleanUp();

          gc.gameOver = false;
          gc.mode = gameMode;
          // Calculate board size
          maxColumn = Math.floor(gameCanvas.width/gameCanvas.blockSize);
          maxRow = Math.floor(gameCanvas.height/gameCanvas.blockSize);
          maxIndex = maxRow * maxColumn;
          if (gameMode == "arcade") //Needs to be after board sizing
              getHighScore();

          // Initialize Board
          board = new Array(maxIndex);
          gameCanvas.score = 0;
          gameCanvas.score2 = 0;
          gameCanvas.moves = 0;
          gameCanvas.curTurn = 1;
          if (gameMode == "puzzle")
              loadMap(map);
          else//Note that we load them in reverse order for correct visual stacking
              for (var column = maxColumn - 1; column >= 0; column--)
                  for (var row = maxRow - 1; row >= 0; row--)
                      createBlock(column, row);
          if (gameMode == "puzzle")
              getLevelHistory();//Needs to be after map load
          gameDuration = new Date();
      }

      var fillFound;  // Set after a floodFill call to the number of blocks found
      var floodBoard; // Set to 1 if the floodFill reaches off that node

      // NOTE: Be careful with vars named x,y, as the calling object's x,y are still in scope
      function handleClick(x,y)
      {
          if (betweenTurns || gameOver || gameCanvas == undefined)
              return;
          var column = Math.floor(x/gameCanvas.blockSize);
          var row = Math.floor(y/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;
          if (gameMode == "multiplayer" && gameCanvas.curTurn == 2)
              gameCanvas.score2 += (fillFound - 1) * (fillFound - 1);
          else
              gameCanvas.score += (fillFound - 1) * (fillFound - 1);
          if (gameMode == "multiplayer" && gameCanvas.curTurn == 2)
              shuffleUp();
          else
              shuffleDown();
          gameCanvas.moves += 1;
          if (gameMode == "endless")
              refill();
          else if (gameMode != "multiplayer")
              victoryCheck();
          if (gameMode == "multiplayer" && !gc.gameOver){
              betweenTurns = true;
              gameCanvas.swapPlayers();//signal, animate and call turnChange() when ready
          }
      }

      function floodFill(column,row,type)
      {
          if (board[index(column, row)] == null)
              return;
          var first = false;
          if (type == -1) {
              first = true;
              type = board[index(column,row)].type;

              // Flood fill initialization
              fillFound = 0;
              floodBoard = new Array(maxIndex);
          }
          if (column >= maxColumn || column < 0 || row >= maxRow || row < 0)
              return;
          if (floodBoard[index(column, row)] == 1 || (!first && type != board[index(column, row)].type))
              return;
          floodBoard[index(column, row)] = 1;
          floodFill(column + 1, row, type);
          floodFill(column - 1, row, type);
          floodFill(column, row + 1, type);
          floodFill(column, row - 1, type);
          if (first == true && fillFound == 0)
              return; // Can't remove single blocks
          board[index(column, row)].dying = true;
          board[index(column, row)] = null;
          fillFound += 1;
      }

      function shuffleDown()
      {
          // Fall down
          for (var column = 0; column < maxColumn; column++) {
              var fallDist = 0;
              for (var row = maxRow - 1; row >= 0; row--) {
                  if (board[index(column,row)] == null) {
                      fallDist += 1;
                  } else {
                      if (fallDist > 0) {
                          var obj = board[index(column, row)];
                          obj.y = (row + fallDist) * gameCanvas.blockSize;
                          board[index(column, row + fallDist)] = obj;
                          board[index(column, row)] = null;
                      }
                  }
              }
          }
          // Fall to the left
          fallDist = 0;
          for (column = 0; column < maxColumn; column++) {
              if (board[index(column, maxRow - 1)] == null) {
                  fallDist += 1;
              } else {
                  if (fallDist > 0) {
                      for (row = 0; row < maxRow; row++) {
                          obj = board[index(column, row)];
                          if (obj == null)
                              continue;
                          obj.x = (column - fallDist) * gameCanvas.blockSize;
                          board[index(column - fallDist,row)] = obj;
                          board[index(column, row)] = null;
                      }
                  }
              }
          }
      }

      function shuffleUp()
      {
          // Fall up
          for (var column = 0; column < maxColumn; column++) {
              var fallDist = 0;
              for (var row = 0; row < maxRow; row++) {
                  if (board[index(column,row)] == null) {
                      fallDist += 1;
                  } else {
                      if (fallDist > 0) {
                          var obj = board[index(column, row)];
                          obj.y = (row - fallDist) * gameCanvas.blockSize;
                          board[index(column, row - fallDist)] = obj;
                          board[index(column, row)] = null;
                      }
                  }
              }
          }
          // Fall to the left (or should it be right, so as to be left for P2?)
          fallDist = 0;
          for (column = 0; column < maxColumn; column++) {
              if (board[index(column, 0)] == null) {
                  fallDist += 1;
              } else {
                  if (fallDist > 0) {
                      for (row = 0; row < maxRow; row++) {
                          obj = board[index(column, row)];
                          if (obj == null)
                              continue;
                          obj.x = (column - fallDist) * gameCanvas.blockSize;
                          board[index(column - fallDist,row)] = obj;
                          board[index(column, row)] = null;
                      }
                  }
              }
          }
      }

      function turnChange()//called by ui outside
      {
          betweenTurns = false;
          if (gameCanvas.curTurn == 1){
              shuffleUp();
              gameCanvas.curTurn = 2;
              victoryCheck();
          }else{
              shuffleDown();
              gameCanvas.curTurn = 1;
              victoryCheck();
          }
      }

      function refill()
      {
          for (var column = 0; column < maxColumn; column++) {
              for (var row = 0; row < maxRow; row++) {
                  if (board[index(column, row)] == null)
                      createBlock(column, row);
              }
          }
      }

      function victoryCheck()
      {
          // Awards bonuses for no blocks left
          var deservesBonus = true;
          if (board[index(0,maxRow - 1)] != null || board[index(0,0)] != null)
              deservesBonus = false;
          // Checks for game over
          if (deservesBonus){
              if (gameCanvas.curTurn = 1)
                  gameCanvas.score += 1000;
              else
                  gameCanvas.score2 += 1000;
          }
          gameOver = deservesBonus;
          if (gameCanvas.curTurn == 1){
              if (!(floodMoveCheck(0, maxRow - 1, -1)))
                  gameOver = true;
          }else{
              if (!(floodMoveCheck(0, 0, -1, true)))
                  gameOver = true;
          }
          if (gameMode == "puzzle"){
              puzzleVictoryCheck(deservesBonus);//Takes it from here
              return;
          }
          if (gameOver) {
              var winnerScore = Math.max(gameCanvas.score, gameCanvas.score2);
              if (gameMode == "multiplayer"){
                  gameCanvas.score = winnerScore;
                  saveHighScore(gameCanvas.score2);
              }
              saveHighScore(gameCanvas.score);
              gameDuration = new Date() - gameDuration;
              gameCanvas.gameOver = true;
          }
      }

      // Only floods up and right, to see if it can find adjacent same-typed blocks
      function floodMoveCheck(column, row, type, goDownInstead)
      {
          if (column >= maxColumn || column < 0 || row >= maxRow || row < 0)
              return false;
          if (board[index(column, row)] == null)
              return false;
          var myType = board[index(column, row)].type;
          if (type == myType)
              return true;
          if (goDownInstead)
              return floodMoveCheck(column + 1, row, myType, goDownInstead) ||
                     floodMoveCheck(column, row + 1, myType, goDownInstead);
          else
              return floodMoveCheck(column + 1, row, myType) ||
                     floodMoveCheck(column, row - 1, myType);
      }

      function createBlock(column,row,type)
      {
          // Note that we don't wait for the component to become ready. This will
          // only work if the block QML is a local file. Otherwise the component will
          // not be ready immediately. There is a statusChanged signal on the
          // component you could use if you want to wait to load remote files.
          if (component.status == 1){
              if (type == undefined)
                  type = Math.floor(Math.random() * types);
              if (type < 0 || type > 4) {
                  console.log("Invalid type requested");//TODO: Is this triggered by custom levels much?
                  return;
              }
              var dynamicObject = component.createObject(gameCanvas,
                      {"type": type,
                      "x": column*gameCanvas.blockSize,
                      "y": -1*gameCanvas.blockSize,
                      "width": gameCanvas.blockSize,
                      "height": gameCanvas.blockSize,
                      "particleSystem": gameCanvas.ps});
              if (dynamicObject == null){
                  console.log("error creating block");
                  console.log(component.errorString());
                  return false;
              }
              dynamicObject.y = row*gameCanvas.blockSize;
              dynamicObject.spawned = true;

              board[index(column,row)] = dynamicObject;
          }else{
              console.log("error loading block component");
              console.log(component.errorString());
              return false;
          }
          return true;
      }

      function showPuzzleError(str)
      {
          //TODO: Nice user visible UI?
          console.log(str);
      }

      function loadMap(map)
      {
          puzzlePath = map;
          var levelComp = Qt.createComponent(puzzlePath);
          if (levelComp.status != 1){
              console.log("Error loading level");
              showPuzzleError(levelComp.errorString());
              return;
          }
          puzzleLevel = levelComp.createObject();
          if (puzzleLevel == null || !puzzleLevel.startingGrid instanceof Array) {
              showPuzzleError("Bugger!");
              return;
          }
          gameCanvas.showPuzzleGoal(puzzleLevel.goalText);
          //showPuzzleGoal should call finishLoadingMap as the next thing it does, before handling more events
      }

      function finishLoadingMap()
      {
          for (var i in puzzleLevel.startingGrid)
              if (! (puzzleLevel.startingGrid[i] >= 0 && puzzleLevel.startingGrid[i] <= 9) )
                  puzzleLevel.startingGrid[i] = 0;
          //TODO: Don't allow loading larger levels, leads to cheating
          while (puzzleLevel.startingGrid.length > maxIndex) puzzleLevel.startingGrid.shift();
          while (puzzleLevel.startingGrid.length < maxIndex) puzzleLevel.startingGrid.unshift(0);
          for (var i in puzzleLevel.startingGrid)
              if (puzzleLevel.startingGrid[i] > 0)
                  createBlock(i % maxColumn, Math.floor(i / maxColumn), puzzleLevel.startingGrid[i] - 1);

          //### Experimental feature - allow levels to contain arbitrary QML scenes as well!
          //while (puzzleLevel.children.length)
          //    puzzleLevel.children[0].parent = gameCanvas;
          gameDuration = new Date(); //Don't start until we finish loading
      }

      function puzzleVictoryCheck(clearedAll)//gameOver has also been set if no more moves
      {
          var won = true;
          var soFar = new Date() - gameDuration;
          if (puzzleLevel.scoreTarget != -1 && gameCanvas.score < puzzleLevel.scoreTarget){
              won = false;
          } if (puzzleLevel.scoreTarget != -1 && gameCanvas.score >= puzzleLevel.scoreTarget && !puzzleLevel.mustClear){
              gameOver = true;
          } if (puzzleLevel.timeTarget != -1 && soFar/1000.0 > puzzleLevel.timeTarget){
              gameOver = true;
          } if (puzzleLevel.moveTarget != -1 && gameCanvas.moves >= puzzleLevel.moveTarget){
              gameOver = true;
          } if (puzzleLevel.mustClear && gameOver && !clearedAll) {
              won = false;
          }

          if (gameOver) {
              gameCanvas.gameOver = true;
              gameCanvas.showPuzzleEnd(won);

              if (won) {
                  // Store progress
                  saveLevelHistory();
              }
          }
      }

      function getHighScore()
      {
          var db = Sql.LocalStorage.openDatabaseSync(
              "SameGame",
              "2.0",
              "SameGame Local Data",
              100
          );
          db.transaction(
              function(tx) {
                  tx.executeSql('CREATE TABLE IF NOT EXISTS Scores(game TEXT, score NUMBER, gridSize TEXT, time NUMBER)');
                  // Only show results for the current grid size
                  var rs = tx.executeSql('SELECT * FROM Scores WHERE gridSize = "'
                      + maxColumn + "x" + maxRow + '" AND game = "' + gameMode + '" ORDER BY score desc');
                  if (rs.rows.length > 0)
                      gameCanvas.highScore = rs.rows.item(0).score;
                  else
                      gameCanvas.highScore = 0;
              }
          );
      }

      function saveHighScore(score)
      {
          // Offline storage
          var db = Sql.LocalStorage.openDatabaseSync(
              "SameGame",
              "2.0",
              "SameGame Local Data",
              100
          );
          var dataStr = "INSERT INTO Scores VALUES(?, ?, ?, ?)";
          var data = [
              gameMode,
              score,
              maxColumn + "x" + maxRow,
              Math.floor(gameDuration / 1000)
          ];
          if (score >= gameCanvas.highScore)//Update UI field
              gameCanvas.highScore = score;

          db.transaction(
              function(tx) {
                  tx.executeSql('CREATE TABLE IF NOT EXISTS Scores(game TEXT, score NUMBER, gridSize TEXT, time NUMBER)');
                  tx.executeSql(dataStr, data);
              }
          );
      }

      function getLevelHistory()
      {
          var db = Sql.LocalStorage.openDatabaseSync(
              "SameGame",
              "2.0",
              "SameGame Local Data",
              100
          );
          db.transaction(
              function(tx) {
                  tx.executeSql('CREATE TABLE IF NOT EXISTS Puzzle(level TEXT, score NUMBER, moves NUMBER, time NUMBER)');
                  var rs = tx.executeSql('SELECT * FROM Puzzle WHERE level = "' + puzzlePath + '" ORDER BY score desc');
                  if (rs.rows.length > 0) {
                      gameCanvas.puzzleWon = true;
                      gameCanvas.highScore = rs.rows.item(0).score;
                  } else {
                      gameCanvas.puzzleWon = false;
                      gameCanvas.highScore = 0;
                  }
              }
          );
      }

      function saveLevelHistory()
      {
          var db = Sql.LocalStorage.openDatabaseSync(
              "SameGame",
              "2.0",
              "SameGame Local Data",
              100
          );
          var dataStr = "INSERT INTO Puzzle VALUES(?, ?, ?, ?)";
          var data = [
              puzzlePath,
              gameCanvas.score,
              gameCanvas.moves,
              Math.floor(gameDuration / 1000)
          ];
          gameCanvas.puzzleWon = true;

          db.transaction(
              function(tx) {
                  tx.executeSql('CREATE TABLE IF NOT EXISTS Puzzle(level TEXT, score NUMBER, moves NUMBER, time NUMBER)');
                  tx.executeSql(dataStr, data);
              }
          );
      }

      function nuke() //For "Debug mode"
      {
          for (var row = 1; row <= 5; row++) {
              for (var col = 0; col < 5; col++) {
                  if (board[index(col, maxRow - row)] != null) {
                      board[index(col, maxRow - row)].dying = true;
                      board[index(col, maxRow - row)] = null;
                  }
              }
          }
          if (gameMode == "multiplayer" && gameCanvas.curTurn == 2)
              shuffleUp();
          else
              shuffleDown();
          if (gameMode == "endless")
              refill();
          else
              victoryCheck();
      }