Merge pull request #256 from AbstractPlay/bluestone

Penta-Hex Graph and Bluestone Implementation

Author: humanat

locales/en/apgames.json

@@ -28,6 +28,7 @@
         "blockade": "Blockade (also known as Cul-de-sac) is a 'beat the barrier' game where you get one of your pawns to a starting space of your opponent. Players place 2-wide walls to block each other.",
         "blooms": "Each player owns 2 colours of stones. Players take turns placing one or two stones each turn (if you place two, they must be different colours), then capture all fenced enemy blooms. The first player to capture a certain number of stones wins.",
         "bloqueo": "Manipulate pawns to create towers of player pieces. Score points based on connected groups of controlled towers. Highest score wins.",
+        "bluestone": "Connect your groups to as many of the blue pieces on the perimeter of the board, in this mixture of territory and connection game.",
         "boom": "A minimalist abstract that combines simple move and capture mechanics with a scoring mechanic. Score by bearing your stacks off the opposing side of the board, but you'll want to reduce your opponent's scoring opportunities at the same time.",
         "bounce": "Manoeuvre your disconnected checkers into a single, orthogonally connected whole.",
         "boxes": "A territorial game where you try to complete boxes by drawing lines to connect the dots. If a box is claimed, you may make another move.",
@@ -590,6 +591,14 @@
                 "name": "Largest board (base 10)"
             }
         },
+        "bluestone": {
+            "#board": {
+                "name": "Default board (25 blue stones)"
+            },
+            "size-8": {
+                "name": "Larger board (35 blue stones)"
+            }
+        },
         "boom": {
             "#setup": {
                 "name": "4 pieces each"
@@ -3413,6 +3422,11 @@
             "PARTIAL_dest": "Select the destination.",
             "PARTIAL_place": "Select a cell to place one of your pieces."
         },
+        "bluestone": {
+            "INITIAL_INSTRUCTIONS_FIRST_TURN": "Place one pieces onto any empty intersection.",
+            "INITIAL_INSTRUCTIONS": "Place one or two pieces onto empty intersections.",
+            "FULL_INSTRUCTIONS": "Place one or two pieces onto empty intersections. You cannot place both pieces as a part of the same group or where they would be immediately removed."
+        },
         "boom": {
             "INITIAL_INSTRUCTIONS": "Select a stack to move or attack with.",
             "OUT_OF_RANGE": "Stacks can only move/attack a distance equal to the stack's height.",

src/common/graphs/index.ts

@@ -19,8 +19,13 @@ import { SquareOrth3DGraph } from "./square-orth-3d";
 import { SquareDiag3DGraph } from "./square-diag-3d";
 import { HexFieldGraph } from "./hex-field";
 import { SquareDiamondsDirectedGraph } from "./square-diamonds-directed";
+import { PentaHexGraph } from "./penta-hex";
 
-export { IGraph, IGraph3D, Square3DGraph, SquareGraph, SquareDirectedGraph, SquareOrth3DGraph, SquareOrthGraph, SquareOrthDirectedGraph, SquareDiag3DGraph, SquareDiagGraph, SquareFanoronaGraph, SnubSquareGraph, OnyxGraph, HexTriGraph, HexMoonGraph, HexSlantedGraph, HexConeGraph, HexFieldGraph, BaoGraph, SowingNoEndsGraph, SquareDiamondsDirectedGraph };
+export { IGraph, IGraph3D, Square3DGraph, SquareGraph, SquareDirectedGraph,
+        SquareOrth3DGraph, SquareOrthGraph, SquareOrthDirectedGraph, SquareDiag3DGraph,
+        SquareDiagGraph, SquareFanoronaGraph, SnubSquareGraph, OnyxGraph, HexTriGraph,
+        HexMoonGraph, HexSlantedGraph, HexConeGraph, HexFieldGraph, BaoGraph,
+        SowingNoEndsGraph, SquareDiamondsDirectedGraph, PentaHexGraph };
 
 import { UndirectedGraph } from "graphology";
 import { connectedComponents } from "graphology-components";

src/common/graphs/penta-hex.ts

@@ -0,0 +1,102 @@
+import { UndirectedGraph } from "graphology";
+import { bidirectional } from 'graphology-shortest-path/unweighted';
+import { IGraph } from "./IGraph";
+
+// Similar to PentaHexGraph but the center node only has 5 edges
+export class PentaHexGraph implements IGraph {
+    public readonly size: number;
+    public graph: UndirectedGraph;
+
+    constructor(size: number) {
+        if (size < 2) throw new Error(`PentaHexGraph cannot be less than size 2`);
+        this.size = size;
+        this.graph = this.buildGraph();
+    }
+
+    public coords2algebraic(x: number, y: number): string {
+        if (y < 0 || y > this.size) throw new Error(`The x coord must be a circle inside the graph`);
+        if (y == 0) return "0-0";
+        let trueX = x;
+        do {
+            trueX += 5*y;
+        } while (trueX < 0);
+        return y + "-" + (trueX%(5*y));
+    }
+
+    public algebraic2coords(cell: string): [number, number] {
+        const pair: string[] = cell.split("-");
+        const y = Number(pair[0]);
+        const x = Number(pair[1]);
+        if (y === undefined || isNaN(y) || x === undefined || isNaN(x)) {
+            throw new Error(`The algebraic coords cannot be parsed`);
+        }
+        return [x,y];
+    }
+
+    private buildGraph(): UndirectedGraph {
+        const graph = new UndirectedGraph();
+        for (let y = 0; y < this.size; y++) {
+            if (y == 0) {
+                graph.addNode(this.coords2algebraic(0,0));
+            }
+            for (let x = 0; x < 5*y; x++) {
+                graph.addNode(this.coords2algebraic(x,y));
+            }
+        }
+
+        for (let y = 0; y < this.size; y++) {
+            if (y == 0) {
+                const cell = this.coords2algebraic(0,0);
+                graph.addEdge(cell, this.coords2algebraic(0,1));
+                graph.addEdge(cell, this.coords2algebraic(1,1));
+                graph.addEdge(cell, this.coords2algebraic(2,1));
+                graph.addEdge(cell, this.coords2algebraic(3,1));
+                graph.addEdge(cell, this.coords2algebraic(4,1));
+            }
+            let counter = -1;
+            for (let x = 0; x < 5*y; x++) {
+                const cell = this.coords2algebraic(x,y);
+                graph.addEdge(cell, this.coords2algebraic(x+1, y));
+                if (y+1 >= this.size) continue;
+                if (x % y == 0) {
+                    //Three edges
+                    graph.addEdge(cell, this.coords2algebraic(x+counter++, y+1));
+                    graph.addEdge(cell, this.coords2algebraic(x+counter++, y+1));
+                    graph.addEdge(cell, this.coords2algebraic(x+counter--, y+1));
+                } else {
+                    //Two edges
+                    graph.addEdge(cell, this.coords2algebraic(x+counter++, y+1));
+                    graph.addEdge(cell, this.coords2algebraic(x+counter--, y+1));
+                }
+            }
+        }
+        return graph;
+    }
+
+    public listCells(ordered = false): string[] | string[][] {
+        if (!ordered) {
+            return this.graph.nodes();
+        } else {
+            const result: string[][] = [];
+            for (let y = 0; y < this.size; y++) {
+                const node: string[] = [];
+                if (y == 0) {
+                    node.push(this.coords2algebraic(0,0));
+                }
+                for (let x = 0; x < 5*y; x++) {
+                    node.push(this.coords2algebraic(x,y));
+                }
+                result.push(node);
+            }
+            return result;
+        }
+    }
+
+    public neighbours(node: string): string[] {
+        return this.graph.neighbors(node);
+    }
+
+    public path(from: string, to: string): string[] | null {
+        return bidirectional(this.graph, from, to);
+    }
+}