mirror_maker/lainTSX
1
0
Fork 0
mirror of https://github.com/ad044/lainTSX.git synced 2024-10-22 15:09:05 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #4 from Solitai7e/master

Browse source 
node algo refactor attempt
This commit is contained in:
ad 2021-01-31 18:57:26 +04:00 committed by GitHub
commit 9b6e2775cc
3 changed files with 165 additions and 327 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/core/mainSceneEventHandler.ts
View file

@ -1,10 +1,5 @@
import nodeSelector, { getNode, getNodeById, getNodeHud } from "./nodeSelector";
import {
findNodeDown,
findNodeLeft,
findNodeRight,
findNodeUp,
} from "./utils/nodeUtils";
import { findNode } from "./utils/nodeUtils";
const handleMainSceneEvent = (gameContext: any) => {
let event;
@ -34,18 +29,17 @@ const handleMainSceneEvent = (gameContext: any) => {
case "RIGHT":
const keyPressToLower = keyPress.toLowerCase();
const fn = keyPressToLower === "left" ? findNodeLeft : findNodeRight;
const nodeData = fn.apply(null, [
const nodeData = findNode.apply(null, [
keyPressToLower,
nodeMatrixIndices,
level,
currentSite,
gameProgress,
gameProgress
]);
if (nodeData) {
return {
event: nodeData.didRotate
event: nodeData.didMove
? `site_${keyPressToLower}`
: "change_node",
siteRotY:
@ -60,12 +54,12 @@ const handleMainSceneEvent = (gameContext: any) => {
case "UP":
case "DOWN":
const keyp = keyPress.toLowerCase();
const tt = keyp === "up" ? findNodeUp : findNodeDown;
const t = tt.apply(null, [
const t = findNode.apply(null, [
keyp,
nodeMatrixIndices,
level,
currentSite,
gameProgress,
gameProgress
]);
if (t) {
return {

24
src/core/nodeSelector.ts
View file

@ -10,8 +10,7 @@ import level_y_values from "../resources/level_y_values.json";
import node_huds from "../resources/node_huds.json";
import filterInvisibleNodes from "./utils/filterInvisibleNodes";
import {
findNodeLeft,
findNodeRight,
findNode,
getVisibleNodesMatrix,
} from "./utils/nodeUtils";
@ -389,20 +388,13 @@ const nodeSelector = (context: NodeSelectorContext) => {
switch (context.action) {
case "site_left":
case "site_right":
const t =
context.action === "site_right"
? findNodeRight(
context.nodeMatrixIndices,
context.level,
context.currentSite,
context.gameProgress
)
: findNodeLeft(
context.nodeMatrixIndices,
context.level,
context.currentSite,
context.gameProgress
);
const t = findNode(
context.action === "site_right" ? "right" : "left",
context.nodeMatrixIndices,
context.level,
context.currentSite,
context.gameProgress
);
move = context.action === "site_left" ? "left" : "right";
newNodeData = findNodeHorizontal(

446
src/core/utils/nodeUtils.ts
View file

@ -42,324 +42,176 @@ export const getVisibleNodesMatrix = (
);
};
const generateRowPrecedence = (rowIdx: number) => {
switch (rowIdx) {
case 0:
return [0, 1, 2];
case 1:
return [1, 0, 2];
case 2:
return [2, 1, 0];
default:
return [0, 1, 2];
}
function reorder<T>(array: T[], order: number[]): T[]
{
return order.map(i => array[i]);
}
function RowPrecedence(rowIdx: number): number[]
{
switch (rowIdx) {
default: case 0: return [0, 1, 2];
case 1: return [1, 0, 2];
case 2: return [2, 1, 0];
}
};
export const findNodeLeft = (
nodeMatrixIndices: {
function ColPrecedence(colIdx: number): number[]
{
switch (colIdx) {
default: 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];
}
}
function getNodesMatrixWithIndices
(
matrixIdx: number,
activeLevel: number,
currentSite: string,
gameProgress: any
)
: any[][]
{
return getVisibleNodesMatrix(
matrixIdx,
activeLevel,
currentSite,
gameProgress
)
.map(
(r, i) => r.map(
(n, j) => n ? {
node: n,
matrixIndices: {
matrixIdx,
rowIdx: i,
colIdx: j
}
} : null
)
);
}
interface NodeMatrixIndices {
matrixIdx: number;
rowIdx: number;
colIdx: number;
},
}
function findNode_current
(
direction: string,
{matrixIdx, rowIdx, colIdx}: NodeMatrixIndices,
level: number,
currentSite: string,
gameProgress: any
) => {
const { matrixIdx, rowIdx, colIdx } = nodeMatrixIndices;
const visibleNodes = getVisibleNodesMatrix(
)
: any | undefined
{
const nodes = getNodesMatrixWithIndices(
matrixIdx,
level,
currentSite,
gameProgress
);
const precedence = generateRowPrecedence(rowIdx);
const filters: any = {
left: () => reorder(nodes, RowPrecedence(rowIdx))
.flatMap(r => r.slice(0, colIdx).reverse()),
let chosenNode;
let matrixIndices;
loop: for (let col = colIdx - 1; col > -1; col--) {
for (let i = 0; i < 3; i++) {
const current = visibleNodes[precedence[i]][col];
if (current) {
chosenNode = current;
matrixIndices = {
matrixIdx: matrixIdx,
rowIdx: precedence[i],
colIdx: col,
};
break loop;
}
}
}
right: () => reorder(nodes, RowPrecedence(rowIdx))
.flatMap(r => r.slice(colIdx + 1)),
if (chosenNode) {
return {
node: chosenNode,
matrixIndices: matrixIndices,
didRotate: false,
};
} else {
const newMatrixIdx = matrixIdx + 1 > 8 ? 1 : matrixIdx + 1;
const visibleNodes = getVisibleNodesMatrix(
newMatrixIdx,
level,
currentSite,
gameProgress
);
up: () => nodes.slice(0, rowIdx).reverse()
.flatMap(r => reorder(r, ColPrecedence(colIdx))),
loop: for (let col = 0; col < 4; col++) {
for (let i = 0; i < 3; i++) {
const current = visibleNodes[precedence[i]][col];
if (current) {
chosenNode = current;
matrixIndices = {
matrixIdx: newMatrixIdx,
rowIdx: precedence[i],
colIdx: col,
};
break loop;
}
}
}
down: () => nodes.slice(rowIdx + 1)
.flatMap(r => reorder(r, ColPrecedence(colIdx)))
};
if (chosenNode)
return {
node: chosenNode,
matrixIndices: matrixIndices,
didRotate: true,
};
}
};
const chosen = filters[direction]().find((e: any) => e);
if (chosen) return {...chosen, didMove: false};
}
export const findNodeRight = (
nodeMatrixIndices: {
matrixIdx: number;
rowIdx: number;
colIdx: number;
},
function findNode_next
(
direction: string,
{matrixIdx, rowIdx, colIdx}: NodeMatrixIndices,
level: number,
currentSite: string,
gameProgress: any
) => {
const { matrixIdx, rowIdx, colIdx } = nodeMatrixIndices;
)
: any | undefined
{
const funcs: any = {
left: {
getMatrix: () => getNodesMatrixWithIndices(
matrixIdx + 1 > 8 ? 1 : matrixIdx + 1,
level,
currentSite,
gameProgress
),
const visibleNodes = getVisibleNodesMatrix(
matrixIdx,
level,
currentSite,
gameProgress
filter: (ns: any[]) => ns.flat()
},
right: {
getMatrix: () => getNodesMatrixWithIndices(
matrixIdx - 1 < 1 ? 8 : matrixIdx - 1,
level,
currentSite,
gameProgress
),
filter: (ns: any[]) => ns.flatMap(r => [...r].reverse())
},
up: {
getMatrix: () => getNodesMatrixWithIndices(
matrixIdx,
level + 1,
currentSite,
gameProgress
),
filter: (ns: any[]) => ns
.reverse()
.flatMap(r => reorder(r, ColPrecedence(colIdx)))
},
down: {
getMatrix: () => getNodesMatrixWithIndices(
matrixIdx,
level - 1,
currentSite,
gameProgress
),
filter: (ns: any[]) => ns
.flatMap(r => reorder(r, ColPrecedence(colIdx)))
}
};
const {getMatrix, filter} = funcs[direction];
const chosen = filter(getMatrix()).find((e: any) => e);
if (chosen) return {...chosen, didMove: true};
}
export function findNode(...args: [
string,
NodeMatrixIndices,
number,
string,
any
])
: any | undefined
{
return (
findNode_current(...args) ??
findNode_next(...args)
);
const precedence = generateRowPrecedence(rowIdx);
let chosenNode;
let matrixIndices;
loop: for (let col = colIdx + 1; col < 4; col++) {
for (let i = 0; i < 3; i++) {
const current = visibleNodes[precedence[i]][col];
if (current) {
chosenNode = current;
matrixIndices = {
matrixIdx: matrixIdx,
rowIdx: precedence[i],
colIdx: col,
};
break loop;
}
}
}
if (chosenNode) {
return { node: chosenNode, didRotate: false, matrixIndices: matrixIndices };
} else {
const newMatrixIdx = matrixIdx - 1 < 1 ? 8 : matrixIdx - 1;
const visibleNodes = getVisibleNodesMatrix(
newMatrixIdx,
level,
currentSite,
gameProgress
);
loop: for (let col = 3; col > -1; col--) {
for (let i = 0; i < 3; i++) {
const current = visibleNodes[precedence[i]][col];
if (current) {
chosenNode = current;
matrixIndices = {
matrixIdx: newMatrixIdx,
rowIdx: precedence[i],
colIdx: col,
};
break loop;
}
}
}
if (chosenNode)
return {
node: chosenNode,
matrixIndices: matrixIndices,
didRotate: true,
};
}
};
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,
};
}
};
}