inga-lovinde
/
sample-tictactoe
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

improved formatting (line width set to 120)

Browse Source
main
Inga 🏳‍🌈 6 days ago
parent d823eab61f
commit ca311400ea
10 changed files with 107 additions and 342 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 1
      .prettierrc
  2. 5
      eslint.config.js
  3. 8
      src/lib/board.ts
  4. 9
      src/lib/datatypes.spec.ts
  5. 35
      src/lib/opponent.spec.ts
  6. 26
      src/lib/opponent.ts
  7. 56
      src/lib/solver.spec.ts
  8. 46
      src/lib/solver.ts
  9. 251
      src/lib/tictactoe-rules.spec.ts
  10. 12
      src/lib/tictactoe-rules.ts

1
.prettierrc
Unescape View File

@ -1,4 +1,5 @@
{
"printWidth": 120,
"tabWidth": 2,
"useTabs": false
}

5
eslint.config.js
Unescape View File

@ -18,10 +18,7 @@ export default tsEslint.config(
{
rules: {
"@typescript-eslint/consistent-type-definitions": ["error", "type"],
"@typescript-eslint/restrict-template-expressions": [
"error",
{ allowNumber: true, allowNever: true },
],
"@typescript-eslint/restrict-template-expressions": ["error", { allowNumber: true, allowNever: true }],
},
},
{

8
src/lib/board.ts
Unescape View File

@ -36,9 +36,7 @@ export class Board {
}
static createEmpty(rows: number, columns: number) {
const row = [...(new Array(columns) as unknown[])].map(
() => SquareState.Unoccupied,
);
const row = [...(new Array(columns) as unknown[])].map(() => SquareState.Unoccupied);
const boardState = [...(new Array(rows) as unknown[])].map(() => row);
return new Board(boardState);
}
@ -75,9 +73,7 @@ export class Board {
case SquareState.X:
return "X";
default:
throw new Error(
`Unsupported square state: ${unreachable(squareState)}`,
);
throw new Error(`Unsupported square state: ${unreachable(squareState)}`);
}
})
.join(""),

9
src/lib/datatypes.spec.ts
Unescape View File

@ -31,12 +31,9 @@ void t.test("getExpectedOutcomeByCurrentOutcome", async (t) => {
movesLeft: 0,
});
t.throws(
() => getExpectedOutcomeByCurrentOutcome(CurrentOutcome.Undecided as any),
{
message: "Unsupported current outcome: 201",
},
);
t.throws(() => getExpectedOutcomeByCurrentOutcome(CurrentOutcome.Undecided as any), {
message: "Unsupported current outcome: 201",
});
t.throws(() => getExpectedOutcomeByCurrentOutcome("test" as any), {
message: "Unsupported current outcome: test",

35
src/lib/opponent.spec.ts
Unescape View File

@ -35,12 +35,7 @@ void t.test("createOpponent", async (t) => {
expectedNextBoardSerialized: string,
) => {
t.equal(
opponent
.getNextMove(
Board.fromSerialized(currentBoardSerialized),
currentPlayer,
)
.serialize(),
opponent.getNextMove(Board.fromSerialized(currentBoardSerialized), currentPlayer).serialize(),
expectedNextBoardSerialized,
);
};
@ -48,20 +43,16 @@ void t.test("createOpponent", async (t) => {
checkNextMove("X_|__|__", Player.O, "X_|__|_O");
checkNextMove("X_|__|__", Player.X, "XX|__|__");
t.throws(
() => opponent.getNextMove(Board.fromSerialized("XO|XO|XO"), Player.X),
{ message: "There are no possible moves left: XO|XO|XO" },
);
t.throws(
() => opponent.getNextMove(Board.fromSerialized("XX|XX|XX"), Player.X),
{ message: "Board is not solved: XX|XX|XX" },
);
t.throws(
() => opponent.getNextMove(Board.fromSerialized("XX|XX|X_"), Player.X),
{ message: "Next board is not solved: XX|XX|XX" },
);
t.throws(
() => opponent.getNextMove(Board.fromSerialized("OO|OO|__"), Player.O),
{ message: "Cannot find appropriate next move: OO|OO|__" },
);
t.throws(() => opponent.getNextMove(Board.fromSerialized("XO|XO|XO"), Player.X), {
message: "There are no possible moves left: XO|XO|XO",
});
t.throws(() => opponent.getNextMove(Board.fromSerialized("XX|XX|XX"), Player.X), {
message: "Board is not solved: XX|XX|XX",
});
t.throws(() => opponent.getNextMove(Board.fromSerialized("XX|XX|X_"), Player.X), {
message: "Next board is not solved: XX|XX|XX",
});
t.throws(() => opponent.getNextMove(Board.fromSerialized("OO|OO|__"), Player.O), {
message: "Cannot find appropriate next move: OO|OO|__",
});
});

26
src/lib/opponent.ts
Unescape View File

@ -1,14 +1,6 @@
import {
BoardType,
ExpectedOutcome,
Player,
SquareState,
getOccupiedStateByPlayer,
} from "./datatypes.ts";
import { BoardType, ExpectedOutcome, Player, SquareState, getOccupiedStateByPlayer } from "./datatypes.ts";
export const createOpponent = (
outcomesByBoard: Map<string, ExpectedOutcome>,
) => {
export const createOpponent = (outcomesByBoard: Map<string, ExpectedOutcome>) => {
const getNextMove = (board: BoardType, currentPlayer: Player) => {
const currentExpectedOutcome = outcomesByBoard.get(board.serialize());
if (!currentExpectedOutcome) {
@ -24,20 +16,14 @@ export const createOpponent = (
for (let column = 0; board.hasSquare(row, column); column++) {
if (board.get(row, column) === SquareState.Unoccupied) {
const nextBoard = board.with(row, column, occupiedState);
const nextExpectedOutcome = outcomesByBoard.get(
nextBoard.serialize(),
);
const nextExpectedOutcome = outcomesByBoard.get(nextBoard.serialize());
if (!nextExpectedOutcome) {
throw new Error(
`Next board is not solved: ${nextBoard.serialize()}`,
);
throw new Error(`Next board is not solved: ${nextBoard.serialize()}`);
}
if (
nextExpectedOutcome.finalOutcome ===
currentExpectedOutcome.finalOutcome &&
nextExpectedOutcome.movesLeft ===
currentExpectedOutcome.movesLeft - 1
nextExpectedOutcome.finalOutcome === currentExpectedOutcome.finalOutcome &&
nextExpectedOutcome.movesLeft === currentExpectedOutcome.movesLeft - 1
) {
return nextBoard;
}

56
src/lib/solver.spec.ts
Unescape View File

@ -60,35 +60,23 @@ void t.test("getPreferredNextOutcome", async (t) => {
movesLeft: 140,
});
t.matchOnlyStrict(
getPreferredNextOutcome(nextOutcomes.slice(0, 5), Player.X),
{
finalOutcome: FinalOutcome.WinX,
movesLeft: 60,
},
);
t.matchOnlyStrict(
getPreferredNextOutcome(nextOutcomes.slice(0, 5), Player.O),
{
finalOutcome: FinalOutcome.Draw,
movesLeft: 150,
},
);
t.matchOnlyStrict(
getPreferredNextOutcome(nextOutcomes.slice(0, 3), Player.X),
{
finalOutcome: FinalOutcome.Draw,
movesLeft: 150,
},
);
t.matchOnlyStrict(
getPreferredNextOutcome(nextOutcomes.slice(0, 3), Player.O),
{
finalOutcome: FinalOutcome.Draw,
movesLeft: 150,
},
);
t.matchOnlyStrict(getPreferredNextOutcome(nextOutcomes.slice(0, 5), Player.X), {
finalOutcome: FinalOutcome.WinX,
movesLeft: 60,
});
t.matchOnlyStrict(getPreferredNextOutcome(nextOutcomes.slice(0, 5), Player.O), {
finalOutcome: FinalOutcome.Draw,
movesLeft: 150,
});
t.matchOnlyStrict(getPreferredNextOutcome(nextOutcomes.slice(0, 3), Player.X), {
finalOutcome: FinalOutcome.Draw,
movesLeft: 150,
});
t.matchOnlyStrict(getPreferredNextOutcome(nextOutcomes.slice(0, 3), Player.O), {
finalOutcome: FinalOutcome.Draw,
movesLeft: 150,
});
t.throws(() => getPreferredNextOutcome([], Player.X), {
message: "Could not find the best outcome out of 0 possible next outcomes",
@ -101,10 +89,7 @@ void t.test("computeAllSolutions", async (t) => {
columns: number,
expectedSolutions: Record<string, ExpectedOutcome>,
) => {
t.matchOnlyStrict(
Object.fromEntries(computeAllSolutions(rows, columns, rules).entries()),
expectedSolutions,
);
t.matchOnlyStrict(Object.fromEntries(computeAllSolutions(rows, columns, rules).entries()), expectedSolutions);
};
const checkSolutionsIncomplete = (
@ -115,10 +100,7 @@ void t.test("computeAllSolutions", async (t) => {
) => {
const allSolutions = computeAllSolutions(rows, columns, rules);
t.equal(allSolutions.size, expectedSolutionsCount);
t.matchStrict(
Object.fromEntries(allSolutions.entries()),
expectedSolutionsIncomplete,
);
t.matchStrict(Object.fromEntries(allSolutions.entries()), expectedSolutionsIncomplete);
};
checkSolutionsComplete(0, 0, {

46
src/lib/solver.ts
Unescape View File

@ -24,10 +24,7 @@ export const getPreferredNextOutcome = (
for (const nextOutcome of possibleNextOutcomes) {
if (nextOutcome.finalOutcome === desiredFinalOutcome) {
// If there are multiple winning options, give preference to the one that wins in less moves
if (
!bestDesiredNextOutcome ||
bestDesiredNextOutcome.movesLeft > nextOutcome.movesLeft
) {
if (!bestDesiredNextOutcome || bestDesiredNextOutcome.movesLeft > nextOutcome.movesLeft) {
bestDesiredNextOutcome = nextOutcome;
}
}
@ -39,21 +36,14 @@ export const getPreferredNextOutcome = (
}
{
const leastDesiredFinalOutcome =
getUndesiredFinalOutcomeByPlayer(currentPlayer);
for (const undesiredFinalOutcome of [
FinalOutcome.Draw,
leastDesiredFinalOutcome,
]) {
const leastDesiredFinalOutcome = getUndesiredFinalOutcomeByPlayer(currentPlayer);
for (const undesiredFinalOutcome of [FinalOutcome.Draw, leastDesiredFinalOutcome]) {
let leastBadUndesiredNextOutcome: ExpectedOutcome | null = null;
for (const nextOutcome of possibleNextOutcomes) {
if (nextOutcome.finalOutcome === undesiredFinalOutcome) {
// If there are multiple draw options, or multiple losing options,
// give preference to the one that protracts for most moves
if (
!leastBadUndesiredNextOutcome ||
leastBadUndesiredNextOutcome.movesLeft < nextOutcome.movesLeft
) {
if (!leastBadUndesiredNextOutcome || leastBadUndesiredNextOutcome.movesLeft < nextOutcome.movesLeft) {
leastBadUndesiredNextOutcome = nextOutcome;
}
}
@ -65,22 +55,13 @@ export const getPreferredNextOutcome = (
}
}
throw new Error(
`Could not find the best outcome out of ${possibleNextOutcomes.length} possible next outcomes`,
);
throw new Error(`Could not find the best outcome out of ${possibleNextOutcomes.length} possible next outcomes`);
};
export const computeAllSolutions = (
rows: number,
columns: number,
rules: GameRules,
) => {
export const computeAllSolutions = (rows: number, columns: number, rules: GameRules) => {
const expectedOutcomesByBoard = new Map<string, ExpectedOutcome>();
const getExpectedOutcomeForBoard = (
board: BoardType,
currentPlayer: Player,
): ExpectedOutcome => {
const getExpectedOutcomeForBoard = (board: BoardType, currentPlayer: Player): ExpectedOutcome => {
// assuming that currentPlayer is always the same for the same board
// (which is true, because for correct board states, currentPlayer is determined by
// parity of the number of occupied cells)
@ -98,8 +79,7 @@ export const computeAllSolutions = (
{
const currentOutcome = rules.getBoardOutcome(board);
if (currentOutcome !== CurrentOutcome.Undecided) {
const expectedOutcome =
getExpectedOutcomeByCurrentOutcome(currentOutcome);
const expectedOutcome = getExpectedOutcomeByCurrentOutcome(currentOutcome);
expectedOutcomesByBoard.set(key, expectedOutcome);
return expectedOutcome;
}
@ -114,20 +94,14 @@ export const computeAllSolutions = (
if (board.get(row, column) === SquareState.Unoccupied) {
// Recursion is not a problem here, because every time the number of occupied squares increases,
// therefore the depth of recursion is limited by the number of originally free squares
const nextOutcome = getExpectedOutcomeForBoard(
board.with(row, column, occupiedState),
nextPlayer,
);
const nextOutcome = getExpectedOutcomeForBoard(board.with(row, column, occupiedState), nextPlayer);
possibleNextOutcomes.push(nextOutcome);
}
}
}
}
const preferredNextOutcome = getPreferredNextOutcome(
possibleNextOutcomes,
currentPlayer,
);
const preferredNextOutcome = getPreferredNextOutcome(possibleNextOutcomes, currentPlayer);
const expectedOutcome: ExpectedOutcome = {
finalOutcome: preferredNextOutcome.finalOutcome,
movesLeft: preferredNextOutcome.movesLeft + 1,

251
src/lib/tictactoe-rules.spec.ts
Unescape View File

@ -16,24 +16,15 @@ void t.test("getSequenceOutcome", async (t) => {
});
void t.test("all sequences of length 2", async (t) => {
t.equal(
getSequenceOutcome([SquareState.Unoccupied, SquareState.Unoccupied]),
null,
);
t.equal(getSequenceOutcome([SquareState.Unoccupied, SquareState.Unoccupied]), null);
t.equal(getSequenceOutcome([SquareState.Unoccupied, SquareState.X]), null);
t.equal(getSequenceOutcome([SquareState.Unoccupied, SquareState.O]), null);
t.equal(getSequenceOutcome([SquareState.X, SquareState.Unoccupied]), null);
t.equal(
getSequenceOutcome([SquareState.X, SquareState.X]),
CurrentOutcome.WinX,
);
t.equal(getSequenceOutcome([SquareState.X, SquareState.X]), CurrentOutcome.WinX);
t.equal(getSequenceOutcome([SquareState.X, SquareState.O]), null);
t.equal(getSequenceOutcome([SquareState.O, SquareState.Unoccupied]), null);
t.equal(getSequenceOutcome([SquareState.O, SquareState.X]), null);
t.equal(
getSequenceOutcome([SquareState.O, SquareState.O]),
CurrentOutcome.WinO,
);
t.equal(getSequenceOutcome([SquareState.O, SquareState.O]), CurrentOutcome.WinO);
});
void t.test("sequences of length 7", async (t) => {
@ -135,211 +126,69 @@ void t.test("getSequenceOutcome", async (t) => {
void t.test("getBoardOutcome", async (t) => {
void t.test("1x1 boards", async (t) => {
t.equal(
getBoardOutcome(Board.fromSerialized("_")),
CurrentOutcome.Undecided,
);
t.equal(getBoardOutcome(Board.fromSerialized("_")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("X")), CurrentOutcome.Draw);
t.equal(getBoardOutcome(Board.fromSerialized("O")), CurrentOutcome.Draw);
});
void t.test("2x2 boards", async (t) => {
t.equal(
getBoardOutcome(Board.fromSerialized("__|__")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XX|X_")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XX|XX")),
CurrentOutcome.Draw,
);
t.equal(
getBoardOutcome(Board.fromSerialized("OO|OO")),
CurrentOutcome.Draw,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XO|OX")),
CurrentOutcome.Draw,
);
t.equal(getBoardOutcome(Board.fromSerialized("__|__")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("XX|X_")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("XX|XX")), CurrentOutcome.Draw);
t.equal(getBoardOutcome(Board.fromSerialized("OO|OO")), CurrentOutcome.Draw);
t.equal(getBoardOutcome(Board.fromSerialized("XO|OX")), CurrentOutcome.Draw);
});
void t.test("3x3 boards", async (t) => {
t.equal(
getBoardOutcome(Board.fromSerialized("___|___|___")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("___|_X_|___")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XX_|___|___")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("___|___|_XX")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("X__|X__|___")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("___|__X|__X")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("X__|_X_|___")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("___|_X_|__X")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("__X|_X_|___")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("___|_X_|X__")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XXX|O_O|O_O")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("O_O|O_O|XXX")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XOO|X__|XOO")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("OOX|__X|OOX")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XOO|OXO|OOX")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("OOX|OXO|XOO")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XXO|XOX|OXX")),
CurrentOutcome.WinO,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XOX|XXO|OXO")),
CurrentOutcome.Draw,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XOX|XXO|OX_")),
CurrentOutcome.Undecided,
);
t.equal(getBoardOutcome(Board.fromSerialized("___|___|___")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("___|_X_|___")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("XX_|___|___")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("___|___|_XX")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("X__|X__|___")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("___|__X|__X")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("X__|_X_|___")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("___|_X_|__X")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("__X|_X_|___")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("___|_X_|X__")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("XXX|O_O|O_O")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("O_O|O_O|XXX")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("XOO|X__|XOO")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("OOX|__X|OOX")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("XOO|OXO|OOX")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("OOX|OXO|XOO")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("XXO|XOX|OXX")), CurrentOutcome.WinO);
t.equal(getBoardOutcome(Board.fromSerialized("XOX|XXO|OXO")), CurrentOutcome.Draw);
t.equal(getBoardOutcome(Board.fromSerialized("XOX|XXO|OX_")), CurrentOutcome.Undecided);
});
void t.test("5x5 boards", async (t) => {
t.equal(
getBoardOutcome(Board.fromSerialized("_____|_____|_____|_____|_____")),
CurrentOutcome.Undecided,
);
t.equal(
getBoardOutcome(Board.fromSerialized("XXX__|_____|_____|_____|_____")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("X____|X____|X____|_____|_____")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("X____|_X___|__X__|_____|_____")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("__X__|_X___|X____|_____|_____")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("_____|_____|_____|_____|__XXX")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("_____|_____|____X|____X|____X")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("_____|_____|__X__|___X_|____X")),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(Board.fromSerialized("_____|_____|____X|___X_|__X__")),
CurrentOutcome.WinX,
);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|_____|_____|_____")), CurrentOutcome.Undecided);
t.equal(getBoardOutcome(Board.fromSerialized("XXX__|_____|_____|_____|_____")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("X____|X____|X____|_____|_____")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("X____|_X___|__X__|_____|_____")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("__X__|_X___|X____|_____|_____")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|_____|_____|__XXX")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|____X|____X|____X")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|__X__|___X_|____X")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|____X|___X_|__X__")), CurrentOutcome.WinX);
});
void t.test("6x5 boards", async (t) => {
t.equal(
getBoardOutcome(
Board.fromSerialized("_____|_____|_____|_____|_____|__XXX"),
),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(
Board.fromSerialized("_____|_____|_____|____X|____X|____X"),
),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(
Board.fromSerialized("_____|_____|_____|__X__|___X_|____X"),
),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(
Board.fromSerialized("_____|_____|_____|____X|___X_|__X__"),
),
CurrentOutcome.WinX,
);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|_____|_____|_____|__XXX")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|_____|____X|____X|____X")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|_____|__X__|___X_|____X")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("_____|_____|_____|____X|___X_|__X__")), CurrentOutcome.WinX);
});
void t.test("5x6 boards", async (t) => {
t.equal(
getBoardOutcome(
Board.fromSerialized("______|______|______|______|___XXX"),
),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(
Board.fromSerialized("______|______|_____X|_____X|_____X"),
),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(
Board.fromSerialized("______|______|___X__|____X_|_____X"),
),
CurrentOutcome.WinX,
);
t.equal(
getBoardOutcome(
Board.fromSerialized("______|______|_____X|____X_|___X__"),
),
CurrentOutcome.WinX,
);
t.equal(getBoardOutcome(Board.fromSerialized("______|______|______|______|___XXX")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("______|______|_____X|_____X|_____X")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("______|______|___X__|____X_|_____X")), CurrentOutcome.WinX);
t.equal(getBoardOutcome(Board.fromSerialized("______|______|_____X|____X_|___X__")), CurrentOutcome.WinX);
});
});

12
src/lib/tictactoe-rules.ts
Unescape View File

@ -20,11 +20,7 @@ export const getSequenceOutcome = (sequence: SquareState[]) => {
export const getBoardOutcome: GameRules["getBoardOutcome"] = (board) => {
for (let row = 0; board.hasRow(row); row++) {
for (let column = 2; board.hasSquare(row, column); column++) {
const tripleLeft = [
board.get(row, column - 2),
board.get(row, column - 1),
board.get(row, column - 0),
];
const tripleLeft = [board.get(row, column - 2), board.get(row, column - 1), board.get(row, column - 0)];
const outcome = getSequenceOutcome(tripleLeft);
if (outcome) {
@ -35,11 +31,7 @@ export const getBoardOutcome: GameRules["getBoardOutcome"] = (board) => {
for (let row = 2; board.hasRow(row); row++) {
for (let column = 0; board.hasSquare(row, column); column++) {
const tripleUp = [
board.get(row - 2, column),
board.get(row - 1, column),
board.get(row - 0, column),
];
const tripleUp = [board.get(row - 2, column), board.get(row - 1, column), board.get(row - 0, column)];
const outcome = getSequenceOutcome(tripleUp);
if (outcome) {

Write Preview
Loading…
Cancel
Save