jungle-board-service
Version:
Jungle board service
248 lines (247 loc) • 13 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createComputerMove = exports.getPossibleMoves = void 0;
const gameLogic = __importStar(require("./gameLogic"));
function getPossibleMoves(board, computerTurn) {
const lowLevelMoves = [];
const midLevelMoves = [];
const highLevelMoves = [];
if (!board) {
return {
lowLevelMoves,
midLevelMoves,
highLevelMoves,
};
}
const opponentTurn = computerTurn === gameLogic.PlayerSymbol.B ? gameLogic.PlayerSymbol.W : gameLogic.PlayerSymbol.B;
for (let row = 0; row < gameLogic.ROWS; row++) {
for (let col = 0; col < gameLogic.COLS; col++) {
const piece = board[row][col];
if (piece === gameLogic.PieceName.L || piece === gameLogic.PieceName.R || piece.charAt(0) !== computerTurn) {
continue;
}
const deltaFrom = { row, col };
let possibleMoves = [];
switch (piece.substring(1)) {
case gameLogic.Animal.Elephant:
possibleMoves = gameLogic.getElephantPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
case gameLogic.Animal.Lion:
possibleMoves = gameLogic.getLionPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
case gameLogic.Animal.Tiger:
possibleMoves = gameLogic.getTigerPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
case gameLogic.Animal.Leopard:
possibleMoves = gameLogic.getLeopardPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
case gameLogic.Animal.Dog:
possibleMoves = gameLogic.getDogPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
case gameLogic.Animal.Wolf:
possibleMoves = gameLogic.getWolfPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
case gameLogic.Animal.Cat:
possibleMoves = gameLogic.getCatPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
case gameLogic.Animal.Rat:
possibleMoves = gameLogic.getRatPossibleMoves(board, computerTurn, deltaFrom);
if (possibleMoves.length > 0) {
for (const deltaTo of possibleMoves) {
const pieceTo = board[deltaTo.row][deltaTo.col];
const opponentDen = opponentTurn + gameLogic.Structure.Den;
const opponentTrap = opponentTurn + gameLogic.Structure.Trap;
if (pieceTo === gameLogic.PieceName.L || pieceTo === gameLogic.PieceName.R) {
lowLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentDen) {
highLevelMoves.push([deltaFrom, deltaTo]);
}
else if (pieceTo === opponentTrap) {
midLevelMoves.push([deltaFrom, deltaTo]);
}
else {
midLevelMoves.push([deltaFrom, deltaTo]);
}
}
}
break;
}
}
}
return {
lowLevelMoves,
midLevelMoves,
highLevelMoves,
};
}
exports.getPossibleMoves = getPossibleMoves;
function createComputerMove(board, computerTurn) {
const { lowLevelMoves, midLevelMoves, highLevelMoves } = getPossibleMoves(board, computerTurn);
let returnedIndex = 0;
if (highLevelMoves.length > 0) {
return highLevelMoves[returnedIndex];
}
if (midLevelMoves.length === 1) {
return midLevelMoves[returnedIndex];
}
if (midLevelMoves.length > 1) {
returnedIndex = Math.floor(Math.random() * midLevelMoves.length);
return midLevelMoves[returnedIndex];
}
returnedIndex = Math.floor(Math.random() * lowLevelMoves.length);
return lowLevelMoves[returnedIndex];
}
exports.createComputerMove = createComputerMove;