cleaned up a bit of stuff

src/core/mainSceneEventHandler.ts

@@ -1,4 +1,10 @@
-import nodeSelector, { getNode, getNodeHud } from "./nodeSelector";
+import nodeSelector, { getNode, getNodeById, getNodeHud } from "./nodeSelector";
+import {
+  findNodeDown,
+  findNodeLeft,
+  findNodeRight,
+  findNodeUp,
+} from "./utils/nodeUtils";
 
 const handleMainSceneEvent = (gameContext: any) => {
   let event;
@@ -23,38 +29,56 @@ const handleMainSceneEvent = (gameContext: any) => {
   let scene = gameContext.scene;
 
   if (subscene === "site") {
-    let selectedNodeData;
     switch (keyPress) {
       case "LEFT":
       case "RIGHT":
-      case "DOWN":
-      case "UP":
-        selectedNodeData = nodeSelector({
-          action: `site_${keyPress.toLowerCase()}`,
-          activeId: activeNode,
-          nodeMatrixIndices: nodeMatrixIndices,
-          level: level,
-          siteRotY: siteRotY,
-          sitePosY: sitePosY,
-          gameProgress: gameProgress,
-          currentSite: currentSite,
-        });
+        const keyPressToLower = keyPress.toLowerCase();
 
-        if (selectedNodeData) {
-          event = selectedNodeData.event;
-          activeNode = selectedNodeData.node;
-          nodeMatrixIndices = selectedNodeData.newNodeMatrixIndices;
-          siteRotY = selectedNodeData.newSiteRotY;
-          sitePosY = selectedNodeData.newSitePosY;
-          level = selectedNodeData.newLevel!;
-          activeHud = selectedNodeData.newActiveHud;
+        const fn = keyPressToLower === "left" ? findNodeLeft : findNodeRight;
+
+        const nodeData = fn.apply(null, [
+          nodeMatrixIndices,
+          level,
+          currentSite,
+          gameProgress,
+        ]);
+
+        if (nodeData) {
+          return {
+            event: nodeData.didRotate
+              ? `site_${keyPressToLower}`
+              : "change_node",
+            siteRotY:
+              keyPressToLower === "left"
+                ? siteRotY + Math.PI / 4
+                : siteRotY - Math.PI / 4,
+            nodeMatrixIndices: nodeData.matrixIndices,
+            node: getNodeById(nodeData.node, currentSite),
+          };
+        }
+        break;
+      case "UP":
+      case "DOWN":
+        const keyp = keyPress.toLowerCase();
+        const tt = keyp === "up" ? findNodeUp : findNodeDown;
+        const t = tt.apply(null, [
+          nodeMatrixIndices,
+          level,
+          currentSite,
+          gameProgress,
+        ]);
+        if (t) {
+          return {
+            event: t.didMove ? `site_${keyp}` : "change_node",
+            nodeMatrixIndices: t.matrixIndices,
+            level: (keyp === "up" ? level + 1 : level - 1)
+              .toString()
+              .padStart(2, "0"),
+            node: getNodeById(t.node, currentSite),
+          };
         }
-
         break;
       case "CIRCLE":
-        // in this case we have to check the type of the blue orb
-        // and dispatch an action depending on that, so we have to precalculate the
-        // new active blue orb here.
         activeNode = getNode(level, nodeMatrixIndices, currentSite);
 
         const nodeType = activeNode.type;

src/core/utils/nodeUtils.ts

@@ -204,3 +204,162 @@ export const findNodeRight = (
       };
   }
 };
+
+const generateColPrecedence = (colIdx: number) => {
+  switch (colIdx) {
+    case 0:
+      return [0, 1, 2, 3];
+    case 1:
+      return [1, 0, 2, 3];
+    case 2:
+      return [2, 1, 3, 0];
+    case 3:
+      return [3, 2, 1, 0];
+    default:
+      return [0, 1, 2, 3];
+  }
+};
+
+export const findNodeUp = (
+  nodeMatrixIndices: {
+    matrixIdx: number;
+    rowIdx: number;
+    colIdx: number;
+  },
+  level: number,
+  currentSite: string,
+  gameProgress: any
+) => {
+  const { matrixIdx, rowIdx, colIdx } = nodeMatrixIndices;
+
+  const visibleNodes = getVisibleNodesMatrix(
+    matrixIdx,
+    level,
+    currentSite,
+    gameProgress
+  );
+
+  const precedence = generateColPrecedence(colIdx);
+
+  let chosenNode;
+  let matrixIndices;
+  loop: for (let row = rowIdx - 1; row > -1; row--) {
+    for (let i = 0; i < 4; i++) {
+      const current = visibleNodes[row][precedence[i]];
+      if (current) {
+        chosenNode = current;
+        matrixIndices = {
+          matrixIdx: matrixIdx,
+          rowIdx: row,
+          colIdx: precedence[i],
+        };
+        break loop;
+      }
+    }
+  }
+
+  if (chosenNode) {
+    return { node: chosenNode, didMove: false, matrixIndices: matrixIndices };
+  } else {
+    const visibleNodes = getVisibleNodesMatrix(
+      matrixIdx,
+      level + 1,
+      currentSite,
+      gameProgress
+    );
+
+    loop: for (let row = 2; row > -1; row--) {
+      for (let i = 0; i < 4; i++) {
+        const current = visibleNodes[row][precedence[i]];
+        if (current) {
+          chosenNode = current;
+          matrixIndices = {
+            matrixIdx: matrixIdx,
+            rowIdx: row,
+            colIdx: precedence[i],
+          };
+          break loop;
+        }
+      }
+    }
+
+    if (chosenNode)
+      return {
+        node: chosenNode,
+        matrixIndices: matrixIndices,
+        didMove: true,
+      };
+  }
+};
+
+export const findNodeDown = (
+  nodeMatrixIndices: {
+    matrixIdx: number;
+    rowIdx: number;
+    colIdx: number;
+  },
+  level: number,
+  currentSite: string,
+  gameProgress: any
+) => {
+  const { matrixIdx, rowIdx, colIdx } = nodeMatrixIndices;
+
+  const visibleNodes = getVisibleNodesMatrix(
+    matrixIdx,
+    level,
+    currentSite,
+    gameProgress
+  );
+
+  const precedence = generateColPrecedence(colIdx);
+
+  let chosenNode;
+  let matrixIndices;
+  loop: for (let row = rowIdx + 1; row < 3; row++) {
+    for (let i = 0; i < 4; i++) {
+      const current = visibleNodes[row][precedence[i]];
+      if (current) {
+        chosenNode = current;
+        matrixIndices = {
+          matrixIdx: matrixIdx,
+          rowIdx: row,
+          colIdx: precedence[i],
+        };
+        break loop;
+      }
+    }
+  }
+
+  if (chosenNode) {
+    return { node: chosenNode, didMove: false, matrixIndices: matrixIndices };
+  } else {
+    const visibleNodes = getVisibleNodesMatrix(
+      matrixIdx,
+      level - 1,
+      currentSite,
+      gameProgress
+    );
+
+    loop: for (let row = 0; row < 3; row++) {
+      for (let i = 0; i < 4; i++) {
+        const current = visibleNodes[row][precedence[i]];
+        if (current) {
+          chosenNode = current;
+          matrixIndices = {
+            matrixIdx: matrixIdx,
+            rowIdx: row,
+            colIdx: precedence[i],
+          };
+          break loop;
+        }
+      }
+    }
+
+    if (chosenNode)
+      return {
+        node: chosenNode,
+        matrixIndices: matrixIndices,
+        didMove: true,
+      };
+  }
+};