snakeia-server 1.1.5 → 1.2.0

package/.drone.yml

@@ -15,4 +15,5 @@ steps:
     password:
       from_secret: REGISTRY_PASSWORD
     tags:
-      - latest
+      - latest
+      - 1.2.0

package/GameEngineMultithreading.js

@@ -23,20 +23,57 @@ const Position                     = snakeia.Position;
 const Grid                         = snakeia.Grid;
 const Snake                        = snakeia.Snake;
 const GameEngine                   = snakeia.GameEngine;
-const seedrandom                   = require("seedrandom");
 
 let game;
 
 function copySnakes(snakes) {
-  var copy = JSON.parse(JSON.stringify(snakes));
+  const snakesCopy = [];
 
-  if(copy) {
-    for(var i = 0; i < copy.length; i++) {
-      delete copy[i]["grid"];
-    }
+  if(snakes) {
+    snakes.forEach(snake => {
+      if(snake) {
+        const snakeCopy = new Snake();
+  
+        snakeCopy.color = snake.color;
+        snakeCopy.direction = snake.direction;
+        snakeCopy.errorInit = snake.errorInit;
+        snakeCopy.gameOver = snake.gameOver;
+        snakeCopy.autoRetry = snake.autoRetry;
+        snakeCopy.aiLevel = snake.aiLevel;
+  
+        if(snake.lastTail) {
+          snakeCopy.lastTail = JSON.parse(JSON.stringify(snake.lastTail));
+        }
+  
+        if(snake.lastHead) {
+          snakeCopy.lastHead = JSON.parse(JSON.stringify(snake.lastHead));
+        }
+  
+        snakeCopy.lastTailMoved = snake.lastTailMoved;
+        snakeCopy.lastHeadMoved = snake.lastHeadMoved;
+        snakeCopy.name = snake.name;
+        snakeCopy.player = snake.player;
+  
+        if(snake.queue) {
+          snakeCopy.queue = JSON.parse(JSON.stringify(snake.queue));
+        }
+  
+        snakeCopy.score = snake.score;
+        snakeCopy.scoreMax = snake.scoreMax;
+        snakeCopy.ticksDead = snake.ticksDead;
+        snakeCopy.ticksWithoutAction = snake.ticksWithoutAction;
+        snakeCopy.grid = null;
+  
+        if(snake.snakeAI && snake.snakeAI.aiLevelText) {
+          snakeCopy.snakeAI.aiLevelText = snake.snakeAI.aiLevelText;
+        }
+  
+        snakesCopy.push(snakeCopy);
+      }
+    });
   }
 
-  return copy;
+  return snakesCopy;
 }
 
 function copyGrid(grid) {
@@ -51,35 +88,22 @@ function copyGrid(grid) {
 }
 
 function parseSnakes(snakes, grid) {
-  if(game) {
-    var grid = grid != null ? grid : game.grid;
-  }
-
-  grid = Object.assign(new Grid(), grid);
+  let gridCopy = game ? (grid ?? game.grid) : grid;
+  gridCopy = Object.assign(new Grid(), gridCopy);
 
-  if(!snakes && game) {
-    snakes = game.snakes;
-  }
-  
-  for(var i = 0; i < snakes.length; i++) {
-    snakes[i].grid = grid;
-    snakes[i] = Object.assign(new Snake(), snakes[i]);
-
-    for(var j = 0; j < snakes[i].queue.length; j++) {
-      snakes[i].queue[j] = Object.assign(new Position(), snakes[i].queue[j]);
-    }
-
-    snakes[i].initAI();
-  }
+  snakes = snakes ?? game?.snakes;
+  const snakesCopy = (Array.isArray(snakes) ? snakes : [snakes]).map(snake => {
+    const newSnake = Object.assign(new Snake(), snake);
+    newSnake.grid = gridCopy;
+    newSnake.queue = newSnake.queue.map(pos => Object.assign(new Position(), pos));
+    return newSnake;
+  });
 
-  return {
-    grid: grid,
-    snakes: snakes
-  };
+  return { grid: gridCopy, snakes: snakesCopy };
 }
 
 if(!isMainThread) {
-  parentPort.on("message", (data) => {
+  parentPort.on("message", async data => {
     const type = data.type;
     const keys = Object.keys(data);
 
@@ -89,8 +113,17 @@ if(!isMainThread) {
       const snakes = parsed["snakes"];
 
       if(!game) {
-        game = new GameEngine(grid, snakes, data.speed, data.enablePause, data.enableRetry, data.progressiveSpeed);
-        game.init();
+        try {
+          game = new GameEngine(grid, snakes, data.speed, data.enablePause, data.enableRetry, data.progressiveSpeed, data.aiStuckLimit, data.disableStuckAIDetection, data.aiUltraModelSettings);
+          await game.init();
+        } catch(e) {
+          console.error(e);
+          
+          parentPort.postMessage({
+            type: "init",
+            errorOccurred: true
+          });
+        }
   
         parentPort.postMessage({
           type: "init",
@@ -100,7 +133,8 @@ if(!isMainThread) {
           "enableRetry": game.enableRetry,
           "progressiveSpeed": game.progressiveSpeed,
           "offsetFrame": game.speed * GameConstants.Setting.TIME_MULTIPLIER,
-          "errorOccurred": game.errorOccurred
+          "errorOccurred": game.errorOccurred,
+          "engineLoading": game.engineLoading
         });
     
         game.onReset(() => {
@@ -127,7 +161,8 @@ if(!isMainThread) {
             "getInfosGame": false,
             "errorOccurred": game.errorOccurred,
             "aiStuck": game.aiStuck,
-            "precAiStuck": false
+            "precAiStuck": false,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -144,7 +179,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -156,7 +192,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -167,7 +204,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -182,7 +220,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -197,7 +236,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -214,7 +254,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -243,7 +284,8 @@ if(!isMainThread) {
             "numFruit": game.numFruit,
             "offsetFrame": 0,
             "errorOccurred": game.errorOccurred,
-            "aiStuck": game.aiStuck
+            "aiStuck": game.aiStuck,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -266,14 +308,25 @@ if(!isMainThread) {
             "speed": game.speed,
             "countBeforePlay": game.countBeforePlay,
             "numFruit": game.numFruit,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
       } else {
         game.snakes = snakes;
         game.grid = grid;
         game.countBeforePlay = 3;
-        game.init();
+
+        try {
+          await game.init();
+        } catch(e) {
+          console.error(e);
+
+          parentPort.postMessage({
+            type: "init",
+            errorOccurred: true
+          });
+        }
       }
     } else if(game) {
       switch(type) {

package/GameEngineMultithreadingController.js

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020 Eliastik (eliastiksofts.com)
+ * Copyright (C) 2020-2025 Eliastik (eliastiksofts.com)
  *
  * This file is part of "SnakeIA Server".
  *
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU General Public License
  * along with "SnakeIA Server".  If not, see <http://www.gnu.org/licenses/>.
  */
-const { Worker } = require('worker_threads');
+const { Worker } = require("worker_threads");
 const snakeia    = require("snakeia");
 const GameEngine = snakeia.GameEngine;
 const Grid       = snakeia.Grid;
@@ -25,132 +25,145 @@ const Position   = snakeia.Position;
 let logger;
 
 class GameEngineMultithreadingController extends GameEngine {
-  constructor(grid, snakes, speed, enablePause, enableRetry, progressiveSpeed) {
-    super(grid, snakes, speed, enablePause, enableRetry, progressiveSpeed);
+
+  constructor(grid, snakes, speed, enablePause, enableRetry, progressiveSpeed, aiStuckLimit, disableStuckAIDetection, aiUltraModelSettings) {
+    super(grid, snakes, speed, enablePause, enableRetry, progressiveSpeed, aiStuckLimit, disableStuckAIDetection, aiUltraModelSettings);
     this.worker = new Worker("./GameEngineMultithreading.js");
+    this.workerReady = false;
+    this.messageQueue = []; // Queue of message if the worker is still loading
     this.eventsInit = false;
   }
 
-  init() {
-    if(!this.eventsInit) {
-      this.worker.on("message", (data) => {
-        const type = data.type;
-        const dataKeys = Object.keys(data);
+  async init() {
+    return new Promise(resolve => {
+      if(!this.eventsInit) {
+        this.worker.on("message", (data) => {
+          const type = data.type;
+          const dataKeys = Object.keys(data);
 
-        if(dataKeys.length > 1) {
-          let grid = this.grid;
-          let snakes = this.snakes;
+          if(dataKeys.length > 1) {
+            let grid = this.grid;
+            let snakes = this.snakes;
 
-          if(data.grid) {
-            grid = Object.assign(new Grid(), data.grid);
-            data.grid = grid;
-          }
-          
-          if(data.snakes) {
-            for(let i = 0; i < data.snakes.length; i++) {
-              data.snakes[i].grid = grid;
-              data.snakes[i] = Object.assign(new Snake(), data.snakes[i]);
-
-              for(let j = 0; j < data.snakes[i].queue.length; j++) {
-                data.snakes[i].queue[j] = Object.assign(new Position(), data.snakes[i].queue[j]);
-              }
+            if(data.grid) {
+              grid = Object.assign(new Grid(), data.grid);
+              data.grid = grid;
             }
+            
+            if(data.snakes) {
+              for(let i = 0; i < data.snakes.length; i++) {
+                data.snakes[i].grid = grid;
+                data.snakes[i] = Object.assign(new Snake(), data.snakes[i]);
+
+                for(let j = 0; j < data.snakes[i].queue.length; j++) {
+                  data.snakes[i].queue[j] = Object.assign(new Position(), data.snakes[i].queue[j]);
+                }
+              }
 
-            snakes = data.snakes;
-          }
+              snakes = data.snakes;
+            }
 
-          this.snakes = snakes;
-          this.grid = grid;
+            this.snakes = snakes;
+            this.grid = grid;
 
-          for(let i = 0; i < dataKeys.length; i++) {
-            if(dataKeys[i] != "snakes" && dataKeys[i] != "grid") {
-              this[dataKeys[i]] = data[dataKeys[i]];
+            for(let i = 0; i < dataKeys.length; i++) {
+              if(dataKeys[i] != "snakes" && dataKeys[i] != "grid") {
+                this[dataKeys[i]] = data[dataKeys[i]];
+              }
             }
           }
-        }
-
-        switch(type) {
-          case "reset":
-            this.reactor.dispatchEvent("onReset");
-            break;
-          case "start":
-            this.reactor.dispatchEvent("onStart");
-            break;
-          case "pause":
-            this.reactor.dispatchEvent("onPause");
-            break;
-          case "continue":
-            this.reactor.dispatchEvent("onContinue");
-            break;
-          case "stop":
-            this.reactor.dispatchEvent("onStop");
-            break;
-          case "exit":
-            this.reactor.dispatchEvent("onExit");
-            break;
-          case "kill":
-            this.reactor.dispatchEvent("onKill");
-            break;
-          case "scoreIncreased":
-            this.reactor.dispatchEvent("onScoreIncreased");
-            break;
-          case "update":
-            this.reactor.dispatchEvent("onUpdate");
-            break;
-          case "updateCounter":
-            this.reactor.dispatchEvent("onUpdateCounter");
-            break;
-        }
-      });
-      
-      this.worker.on("error", (error) => {
-        if(logger) logger.error("Error in GameEngineMultithreading", error);
-        this.errorOccurred = true;
-        this.reactor.dispatchEvent("onStop");
-      });
-      
-      this.worker.on("exit", () => {
-        this.gameFinished = true;
-        this.reactor.dispatchEvent("onStop");
-      });
-
-      this.eventsInit = true;
-    }
 
-    if(this.grid) {
-      this.grid.rngGrid = null;
-      this.grid.rngGame = null;
-    }
-
-    this.worker.postMessage({
-      type: "init",
-      grid: this.grid,
-      snakes: this.snakes,
-      speed: this.speed,
-      enablePause: this.enablePause,
-      enableRetry: this.enableRetry,
-      progressiveSpeed: this.progressiveSpeed
+          switch(type) {
+            case "init":
+              this.workerReady = true;
+              this.passQueuedMessages();
+              resolve();
+              break;
+            case "reset":
+              this.reactor.dispatchEvent("onReset");
+              break;
+            case "start":
+              this.reactor.dispatchEvent("onStart");
+              break;
+            case "pause":
+              this.reactor.dispatchEvent("onPause");
+              break;
+            case "continue":
+              this.reactor.dispatchEvent("onContinue");
+              break;
+            case "stop":
+              this.reactor.dispatchEvent("onStop");
+              break;
+            case "exit":
+              this.reactor.dispatchEvent("onExit");
+              break;
+            case "kill":
+              this.reactor.dispatchEvent("onKill");
+              break;
+            case "scoreIncreased":
+              this.reactor.dispatchEvent("onScoreIncreased");
+              break;
+            case "update":
+              this.reactor.dispatchEvent("onUpdate");
+              break;
+            case "updateCounter":
+              this.reactor.dispatchEvent("onUpdateCounter");
+              break;
+          }
+        });
+        
+        this.worker.on("error", (error) => {
+          if(logger) logger.error("Error in GameEngineMultithreading", error);
+          this.errorOccurred = true;
+          this.reactor.dispatchEvent("onStop");
+        });
+        
+        this.worker.on("exit", () => {
+          this.gameFinished = true;
+          this.reactor.dispatchEvent("onStop");
+        });
+
+        this.eventsInit = true;
+      }
+
+      if(this.grid) {
+        this.grid.rngGrid = null;
+        this.grid.rngGame = null;
+      }
+
+      this.worker.postMessage({
+        type: "init",
+        grid: this.grid,
+        snakes: this.snakes,
+        speed: this.speed,
+        enablePause: this.enablePause,
+        enableRetry: this.enableRetry,
+        progressiveSpeed: this.progressiveSpeed,
+        aiStuckLimit: this.aiStuckLimit,
+        disableStuckAIDetection: this.disableStuckAIDetection,
+        aiUltraModelSettings: this.aiUltraModelSettings
+      });
     });
   }
 
   reset() {
-    if(this.worker) this.worker.postMessage({ type: "reset" });
+    this.passMessage({ type: "reset" });
   }
 
   start() {
-    if(this.worker) this.worker.postMessage({ type: "start" });
+    this.passMessage({ type: "start" });
   }
 
   stop(finish) {
-    if(this.worker) this.worker.postMessage({ type: finish ? "finish" : "stop" });
+    this.passMessage({ type: finish ? "finish" : "stop" });
   }
 
   finish(finish) {
-    if(this.worker) this.worker.postMessage({ type: finish ? "finish" : "stop" });
+    this.passMessage({ type: finish ? "finish" : "stop" });
   }
 
   pause() {
-    if(this.worker) this.worker.postMessage({ type: "pause" });
+    this.passMessage({ type: "pause" });
   }
 
   kill() {
@@ -162,27 +175,27 @@ class GameEngineMultithreadingController extends GameEngine {
   }
 
   tick() {
-    if(this.worker) this.worker.postMessage({ type: "tick" });
+    this.passMessage({ type: "tick" });
   }
 
   exit() {
-    if(this.worker) this.worker.postMessage({ type: "exit" });
+    this.passMessage({ type: "exit" });
   }
 
   key(key, numSnake) {
-    if(this.worker) this.worker.postMessage({ type: "key", key: key, numSnake: numSnake });
+    this.passMessage({ type: "key", key: key, numSnake: numSnake });
   }
 
   setGameOver(numSnake) {
-    if(this.worker) this.worker.postMessage({ type: "setGameOver", numSnake: numSnake });
+    this.passMessage({ type: "setGameOver", numSnake: numSnake });
   }
   
   forceStart() {
-    if(this.worker) this.worker.postMessage({ type: "forceStart" });
+    this.passMessage({ type: "forceStart" });
   }
 
   updateEngine(key, data) {
-    if(this.worker) this.worker.postMessage({ type: "update", key: key, data: data });
+    this.passMessage({ type: "update", key: key, data: data });
   }
 
   onReset(callback) {
@@ -224,6 +237,24 @@ class GameEngineMultithreadingController extends GameEngine {
   onUpdateCounter(callback) {
     this.reactor.addEventListener("onUpdateCounter", callback);
   }
+
+  passMessage(message) {
+    if(this.workerReady && this.worker) {
+      this.worker.postMessage(message);
+    } else {
+      this.messageQueue.push(message);
+    }
+  }
+
+  passQueuedMessages() {
+    if(this.workerReady && this.worker) {
+      this.messageQueue.forEach(message => {
+        this.worker.postMessage(message);
+      });
+
+      this.messageQueue = [];
+    }
+  }
 }
 
 module.exports = function(l) {

package/Player.js

@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2020-2025 Eliastik (eliastiksofts.com)
+ *
+ * This file is part of "SnakeIA Server".
+ *
+ * "SnakeIA Server" is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * "SnakeIA Server" is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with "SnakeIA Server".  If not, see <http://www.gnu.org/licenses/>.
+ */
+class Player {
+  constructor(token, id, snake, ready, version) {
+    this.token = token;
+    this.id = id;
+    this.snake = snake;
+    this.ready = ready;
+    this.version = version;
+  }
+
+  get username() {
+    return Player.getUsername(this);
+  }
+
+  static getPlayer(array, id) {
+    for (let i = 0; i < array.length; i++) {
+      if (array[i] != null && array[i].id == id) {
+        return array[i];
+      }
+    }
+
+    return null;
+  }
+
+  static getPlayerAllGames(id, games) {
+    const keys = Object.keys(games);
+
+    for (let i = 0; i < keys.length; i++) {
+      const game = games[keys[i]];
+
+      if (game) {
+        const p = this.getPlayer(game.players, id);
+        const p2 = this.getPlayer(game.spectators, id);
+        if (p) return p;
+        if (p2) return p2;
+      }
+    }
+
+    return null;
+  }
+
+  static getPlayerToken(array, token) {
+    if (!token) return null;
+    for (let i = 0; i < array.length; i++) {
+      if (array[i] != null && array[i].token == token) {
+        return array[i];
+      }
+    }
+
+    return null;
+  }
+
+  static getPlayerAllGamesToken(token, games) {
+    if (!token) return null;
+    const keys = Object.keys(games);
+
+    for (let i = 0; i < keys.length; i++) {
+      const game = games[keys[i]];
+
+      if (game) {
+        const p = this.getPlayerToken(game.players, token);
+        const p2 = this.getPlayerToken(game.spectators, token);
+        if (p) return p;
+        if (p2) return p2;
+      }
+    }
+
+    return null;
+  }
+
+  static containsId(array, id) {
+    return Player.getPlayer(array, id) != null;
+  }
+
+  static containsToken(array, token) {
+    return Player.getPlayerToken(array, token) != null;
+  }
+
+  static containsIdAllGames(id, games) {
+    return Player.getPlayerAllGames(id, games) != null;
+  }
+
+  static containsTokenAllGames(token, games) {
+    return Player.getPlayerAllGamesToken(token, games) != null;
+  }
+
+  static getUsername(player) {
+    try {
+      const decoded_token = jwt.verify(player.token, jsonWebTokenSecretKey);
+      return decoded_token && decoded_token.username
+        ? decoded_token.username
+        : null;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  static getUsernameSocket(socket) {
+    try {
+      const decoded_token = jwt.verify(
+        socket.handshake.auth.token ||
+          socket.handshake.query.token ||
+          socket.request.cookies.token,
+        jsonWebTokenSecretKey
+      );
+      return decoded_token && decoded_token.username
+        ? decoded_token.username
+        : null;
+    } catch (e) {
+      return null;
+    }
+  }
+}
+
+module.exports = Player;