snakeia-server 1.1.5 → 1.2.1

package/.drone.yml

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

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);
-
-  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]);
-    }
+  let gridCopy = game ? (grid ?? game.grid) : grid;
+  gridCopy = Object.assign(new Grid(), gridCopy);
 
-    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,19 +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();
-  
-        parentPort.postMessage({
-          type: "init",
-          "snakes": copySnakes(game.snakes),
-          "grid": copyGrid(game.grid),
-          "enablePause": game.enablePause,
-          "enableRetry": game.enableRetry,
-          "progressiveSpeed": game.progressiveSpeed,
-          "offsetFrame": game.speed * GameConstants.Setting.TIME_MULTIPLIER,
-          "errorOccurred": game.errorOccurred
-        });
+        try {
+          game = new GameEngine(grid, snakes, data.speed, data.enablePause, data.enableRetry, data.progressiveSpeed, data.aiStuckLimit, data.disableStuckAIDetection, data.aiUltraModelSettings);
+          await initGame();
+        } catch(e) {
+          console.error(e);
+          
+          parentPort.postMessage({
+            type: "init",
+            errorOccurred: true
+          });
+        }
     
         game.onReset(() => {
           parentPort.postMessage({
@@ -127,7 +149,8 @@ if(!isMainThread) {
             "getInfosGame": false,
             "errorOccurred": game.errorOccurred,
             "aiStuck": game.aiStuck,
-            "precAiStuck": false
+            "precAiStuck": false,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -144,7 +167,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -156,7 +180,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -167,7 +192,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -182,7 +208,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -197,7 +224,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -214,7 +242,8 @@ if(!isMainThread) {
             "confirmExit": false,
             "getInfos": false,
             "getInfosGame": false,
-            "errorOccurred": game.errorOccurred
+            "errorOccurred": game.errorOccurred,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -243,7 +272,8 @@ if(!isMainThread) {
             "numFruit": game.numFruit,
             "offsetFrame": 0,
             "errorOccurred": game.errorOccurred,
-            "aiStuck": game.aiStuck
+            "aiStuck": game.aiStuck,
+            "engineLoading": game.engineLoading
           });
         });
     
@@ -266,14 +296,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 initGame();
+        } catch(e) {
+          console.error(e);
+
+          parentPort.postMessage({
+            type: "init",
+            errorOccurred: true
+          });
+        }
       }
     } else if(game) {
       switch(type) {
@@ -347,4 +388,20 @@ if(!isMainThread) {
       }
     }
   });
+}
+
+async function initGame() {
+  await game.init();
+
+  parentPort.postMessage({
+    type: "init",
+    "snakes": copySnakes(game.snakes),
+    "grid": copyGrid(game.grid),
+    "enablePause": game.enablePause,
+    "enableRetry": game.enableRetry,
+    "progressiveSpeed": game.progressiveSpeed,
+    "offsetFrame": game.speed * GameConstants.Setting.TIME_MULTIPLIER,
+    "errorOccurred": game.errorOccurred,
+    "engineLoading": game.engineLoading
+  });
 }

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,157 @@ 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() {
+  async init() {
     if(!this.eventsInit) {
-      this.worker.on("message", (data) => {
-        const type = data.type;
-        const dataKeys = Object.keys(data);
+      this.initEventHandlers();
+    }
 
-        if(dataKeys.length > 1) {
-          let grid = this.grid;
-          let snakes = this.snakes;
+    if(this.grid) {
+      this.grid.rngGrid = null;
+      this.grid.rngGame = null;
+    }
 
-          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]);
-              }
-            }
+    return new Promise(resolve => {
+      const handleMessage = (data) => {
+        if(data.type === "init") {
+          this.worker.off("message", handleMessage);
+          resolve();
+        }
+      };
+
+      this.worker.on("message", handleMessage);
+
+      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
+      });
+    });
+  }
 
-            snakes = data.snakes;
-          }
+  initEventHandlers() {
+    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 (data.grid) {
+          grid = Object.assign(new Grid(), data.grid);
+          data.grid = grid;
+        }
 
-          this.snakes = snakes;
-          this.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 i = 0; i < dataKeys.length; i++) {
-            if(dataKeys[i] != "snakes" && dataKeys[i] != "grid") {
-              this[dataKeys[i]] = data[dataKeys[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]);
             }
           }
-        }
 
-        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;
+          snakes = data.snakes;
         }
-      });
-      
-      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;
-    }
+        this.snakes = snakes;
+        this.grid = grid;
 
-    if(this.grid) {
-      this.grid.rngGrid = null;
-      this.grid.rngGame = null;
-    }
+        for (let i = 0; i < dataKeys.length; i++) {
+          if (dataKeys[i] != "snakes" && dataKeys[i] != "grid") {
+            this[dataKeys[i]] = data[dataKeys[i]];
+          }
+        }
+      }
+
+      switch (type) {
+        case "init":
+          this.workerReady = true;
+          this.passQueuedMessages();
+          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.postMessage({
-      type: "init",
-      grid: this.grid,
-      snakes: this.snakes,
-      speed: this.speed,
-      enablePause: this.enablePause,
-      enableRetry: this.enableRetry,
-      progressiveSpeed: this.progressiveSpeed
+    this.worker.on("exit", () => {
+      this.gameFinished = true;
+      this.reactor.dispatchEvent("onStop");
     });
+
+    this.eventsInit = true;
   }
 
   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 +187,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 +249,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) {