Hula rules update (#233)

* Hula: correctly find shortest winning loops

* Hula: new end-of-game rules

* tests

Author: th555

src/common/index.ts

@@ -1,4 +1,5 @@
 import { RectGrid } from "./rectGrid";
+import { StackSet} from "./stackset";
 import { reviver, replacer, sortingReplacer } from "./serialization";
 import { shuffle } from "./shuffle";
 import { UserFacingError } from "./errors";
@@ -9,7 +10,7 @@ import { hexhexAi2Ap, hexhexAp2Ai, triAi2Ap, triAp2Ai } from "./aiai";
 import stringify from "json-stringify-deterministic";
 import fnv from "fnv-plus";
 
-export { RectGrid, reviver, replacer, sortingReplacer, shuffle, UserFacingError, HexTriGraph, SnubSquareGraph, SquareOrthGraph, SquareDiagGraph, SquareGraph, Square3DGraph, SquareDirectedGraph, SquareFanoronaGraph, BaoGraph, SowingNoEndsGraph, wng, projectPoint, ptDistance, smallestDegreeDiff, normDeg, deg2rad, rad2deg, toggleFacing, calcBearing, matrixRectRot90, matrixRectRotN90, transposeRect, hexhexAi2Ap, hexhexAp2Ai, triAi2Ap, triAp2Ai, circle2poly, midpoint, distFromCircle };
+export { RectGrid, StackSet, reviver, replacer, sortingReplacer, shuffle, UserFacingError, HexTriGraph, SnubSquareGraph, SquareOrthGraph, SquareDiagGraph, SquareGraph, Square3DGraph, SquareDirectedGraph, SquareFanoronaGraph, BaoGraph, SowingNoEndsGraph, wng, projectPoint, ptDistance, smallestDegreeDiff, normDeg, deg2rad, rad2deg, toggleFacing, calcBearing, matrixRectRot90, matrixRectRotN90, transposeRect, hexhexAi2Ap, hexhexAp2Ai, triAi2Ap, triAp2Ai, circle2poly, midpoint, distFromCircle };
 
 export type DirectionCardinal = "N" | "E" | "S" | "W";
 export type DirectionDiagonal = "NE" | "SE" | "SW" | "NW";

src/common/stackset.ts

@@ -0,0 +1,40 @@
+/**
+ * A StackSet helper class.
+ * Converted from graphology source.
+ */
+export class StackSet {
+    set: Set<string> = new Set<string>();
+    stack: string[] = [];
+
+    has(value: string): boolean {
+        return this.set.has(value);
+    }
+
+    push(value: string): void {
+        this.stack.push(value);
+        this.set.add(value);
+    }
+
+    pop(): void {
+        this.set.delete(this.stack.pop() as string);
+    }
+
+    path(value: string): string[] {
+        return this.stack.concat(value);
+    }
+
+    static of(value: string, cycle: boolean): StackSet{
+        const set = new StackSet();
+
+        if (!cycle) {
+            // Normally we add source both to set & stack
+            set.push(value);
+        } else {
+            // But in case of cycle, we only add to stack so that we may reach the
+            // source again (as it was not already visited)
+            set.stack.push(value);
+        }
+
+        return set;
+    }
+}

src/games/hula.ts

@@ -4,11 +4,11 @@ import { GameBase, IAPGameState, IClickResult, IIndividualState, IValidationResu
 import { APGamesInformation } from "../schemas/gameinfo";
 import { APRenderRep, RowCol } from "@abstractplay/renderer/src/schemas/schema";
 import { APMoveResult } from "../schemas/moveresults";
-import { HexTriGraph, reviver, UserFacingError } from "../common";
-import { allSimplePaths } from 'graphology-simple-path';
+import { HexTriGraph, reviver, UserFacingError, StackSet } from "../common";
 import { bfsFromNode, dfsFromNode } from 'graphology-traversal';
 import i18next from "i18next";
 
+
 export type playerid = 1|2;
 export type cellcontent = playerid|"neutral";
 
@@ -292,18 +292,14 @@ export class HulaGame extends GameBase {
         return this;
     }
 
-    public getWinningLoop(player: playerid, lastmove: string): string[] {
-        const blockers = new Set<string>();
 
-        let graph = this.getGraph(false);
-        const center = graph.coords2algebraic(this.boardsize - 1, this.boardsize - 1);
+    private enclosesCenter(group: Set<string>): boolean {
+        const graph = this.getGraph(false); // The board, including center cell
 
+        const center = graph.coords2algebraic(this.boardsize - 1, this.boardsize - 1);
         let reachedOuter = false;
-
         bfsFromNode(graph.graph, center, (cell) => {
-            const value = this.board.get(cell);
-            if (value === player || value === "neutral") {
-                blockers.add(cell);
+            if (group.has(cell)) {
                 return true;
             }
             else if (this.outerRing.has(cell)) {
@@ -312,32 +308,150 @@ export class HulaGame extends GameBase {
             return false;
         });
 
-        if (reachedOuter) { return []; }
+        return !reachedOuter;
+    }
 
-        graph = this.getGraph();
+    private allShortestCycles(group: Set<string>, source: string): string[][] {
+        /* Adapted from Graphology's allSimplePaths. Finds the shortest winning cycle,
+        and any other cycles (if existing) of the same length, then returns them in
+        an array. The reason for returning all of them is because we might need the one
+        with the least amount of neutrals, which is not necessarily the first-found one.
+        */
+        const groupGraph = this.getGraph();
         for (const cell of this.graph.graph.nodes()) {
-            if (!blockers.has(cell)) { graph.graph.dropNode(cell); }
+            if (!group.has(cell)) { groupGraph.graph.dropNode(cell); }
         }
+        const graph = groupGraph.graph;
+
+        let found = false;
+        /* Iterative deepening dfs */
+        for(let maxDepth = 6; maxDepth <= group.size; maxDepth++){
+            const stack = [graph.outboundNeighbors(source)];
+            const visited = StackSet.of(source, true);
+
+            const paths: string[][] = [];
+            let p: string[];
+            let children;
+            let child;
+
+            while (stack.length !== 0) {
+                children = stack[stack.length - 1];
+                child = children.pop();
+
+                if (!child) {
+                    stack.pop();
+                    visited.pop();
+                } else {
+                    if (visited.has(child)) continue;
+
+                    /* Check whether the last three nodes of the path form a triangle,
+                    if so we can skip the rest of this branch, because the shortest loop
+                    will never contain an acute angle. */
+                    p = visited.path(child);
+                    const tri = p.slice(-3);
+                    if(graph.hasEdge(tri[0], tri[1]) && graph.hasEdge(tri[1], tri[2]) &&
+                        graph.hasEdge(tri[2], tri[0])){
+                        continue;
+                    }
+
+                    if (child === source) {
+                        if(this.enclosesCenter(new Set(p))){
+                            paths.push(p);
+                            found = true;
+                        }
+                    }
+
+                    visited.push(child);
+
+                    if (!visited.has(source) && stack.length < maxDepth) {
+                        stack.push(graph.outboundNeighbors(child));
+                    } else {
+                        visited.pop();
+                    }
+                }
+            }
+            if(found){
+                return paths;
+            }
+        }
+        return [];
+    }
 
-        let cycles = allSimplePaths(graph.graph, lastmove, lastmove);
-        cycles = cycles.filter(c => c.length > 6);
-        cycles.sort((a,b) => a.length - b.length);
+    public getWinningLoop(player: playerid, lastmove: string): [string[], number] {
+        /*
+        Do a BFS to find all possible paths emanating from the placed stone, for each check if it's a winning loop.
+        Since it is a BFS the shortest one will be found first.
+        Could be sped up by not taking sharp-angled steps in the BFS.
+        */
+        const graph = this.getGraph(false); // The board, including center cell
+
+        // Find the current group of player + neutral stones
+        const currentGroup = new Set<string>();
+        bfsFromNode(graph.graph, lastmove, (cell) => {
+            const value = this.board.get(cell);
+            if (value === player || value === "neutral") {
+                currentGroup.add(cell);
+                return false;
+            } else {
+                return true;
+            }
+        });
+
+        // First check if there's a winning loop at all (i.e. path from center to edge is blocked by player + neutral stones)
+        if (!this.enclosesCenter(currentGroup)) { return [[], 0]; };
+
+        const cycles = this.allShortestCycles(currentGroup, lastmove);
+
+        let fewestNeutrals = Infinity;
+        let bestCycle: string[] = [];
+        for(const cycle of cycles){
+            let neutrals = 0;
+            for(const cell of cycle){
+                if(this.board.get(cell) === "neutral"){
+                    neutrals++;
+                }
+            }
+            if(neutrals < fewestNeutrals){
+                fewestNeutrals = neutrals;
+                bestCycle = cycle;
+            }
+        }
 
-        return cycles[0];
+        return [bestCycle, fewestNeutrals];
     }
 
     protected checkEOG(): HulaGame {
-
-        for(const player of [this.currplayer, this.otherPlayer()]) {
-            const loop = this.getWinningLoop(player, this.lastmove!);
-            if (loop.length > 0) {
-                this.winner.push(player);
-                this.gameover = true;
-                this.winningLoop = loop;
-                break;
+        /* If both players get a loop simultaneously, the shortest loop wins.
+        If they are equally long, the loop with fewer neutrals wins.
+        If this is equal too, p2 wins. */
+        if(this.board.get(this.lastmove!) === "neutral"){
+            const [p1loop, p1neutrals] = this.getWinningLoop(1, this.lastmove!);
+            const [p2loop, p2neutrals] = this.getWinningLoop(2, this.lastmove!);
+            if (p1loop.length && !p2loop.length) {
+                this.winner.push(1);
+            } else if (p2loop.length && !p1loop.length) {
+                this.winner.push(2);
+            } else if (p1loop.length && p2loop.length) {
+                if (p1loop.length === p2loop.length) {
+                    if (p1neutrals === p2neutrals) {
+                        this.winner.push(2);
+                    } else {
+                        this.winner.push((p1neutrals < p2neutrals) ? 1 : 2);
+                    }
+                } else {
+                    this.winner.push((p1loop.length < p2loop.length) ? 1 : 2);
+                }
+            }
+            this.winningLoop = (this.winner[0] === 1) ? p1loop : p2loop;
+        } else {
+            const currloop = this.getWinningLoop(this.currplayer, this.lastmove!)[0];
+            if (currloop.length > 0) {
+                this.winner.push(this.currplayer);
+                this.winningLoop = currloop;
             }
         }
 
+        this.gameover = this.winner.length > 0;
         if (this.gameover) {
             this.results.push(
                 {type: "eog"},