Updated Pippinzip

locales/en/apgames.json

@@ -298,6 +298,7 @@
         "pigs": "Unlike the old Super Duper Games implementation, this one implements the core rule set. Each player enters all five moves, and they are resolved at once.\n\nMovement is resolved before damage is applied.",
         "pigs2": "This is the same as the old Super Duper Games. The game starts by you programming three moves, but only one move is resolved and added each turn.\n\nMovement is resolved before damage is applied. Unlike most other AP games, if players resign or timeout, the game does not immediately end. Instead, they're eliminated and their robot becomes inactive, but the other players can play on.",
         "pinch": "Pinch is a 2026 redesign of an original 2019 concept, proposing a new perspective to the orthogonal connection genre. At its core is the **pinch capture**: when two friendly stones flank an enemy piece at a right angle, the captured stone is relocated rather than removed.  This mechanic can trigger a cascade of further relocations, creating a chain-reaction that expands one local capture into changes over multiple sections of the board.",
+        "pippinzip": "Initially, each player places 1-3 WHITE stones in the auction phase, until one player 'takes' and becomes 'Zip'. Zip will play a SINGLE white stone per turn. The opponent becomes 'Pip' and will play TWO black stones per turn, which cannot be orthogonally adjacent. Immediately after 'take' is announced, Pip is the next to move.\n\nZip wins by connecting all FOUR sides of the board with a chain of white stones that are orthogonally and/or diagonally adjacent; Pip wins by connecting any TWO opposite sides with a chain of black stones that are orthogonally adjacent.\n\nIn this implementation, the white stones are neutral gray stones, and the black stones will be the player's color which takes the auction and becomes Zip.",
         "pletore": "An intersection is controlled by a player if they 'pinch' it while the opponent does not. You 'pinch' an intersection if you have pieces that can see that intersection from two different axes. Your score is the sum of the number of stones of your color on the board and the number of empty points you control, plus a komi bonus and a button bonus. The button is used when the komi value plus the number of intersections on the board is even, and any player may take a turn off and claim the button if it has yet to be claimed. The game ends when both players pass in succession, but claiming the button does not count toward this. Players cannot pass until the entire board is occupied or controlled.",
         "plurality": "Plurality is a finite territorial game. The concept of territory exist disconnected from concepts like groups or liberty. Territories' ownership depend on the most represented color in their perimeters. On their turn, players drop two friendly stones and one adversary stone as a single orthogonally connected group (a tromino). It is forbidden to make a 2x2 shape of stones of any color configuration.",
         "queensland": "After the first game completes, the board resets and you play a second game but with blue playing first. Highest combined score wins.",

src/games/pippinzip.ts

@@ -33,6 +33,7 @@ export class PippinzipGame extends GameBase {
         dateAdded: "2026-06-03",
         // i18next.t("apgames:descriptions.pippinzip")
         description: "apgames:descriptions.pippinzip",
+        notes: "apgames:notes.pippinzip",
         urls: ["https://boardgamegeek.com/boardgame/298409/pippinzip"],
         people: [
             {
@@ -428,6 +429,8 @@ export class PippinzipGame extends GameBase {
         }
         if (path1 === null) return [];
 
+        path.push("0"); // include separator (for rendering purposes)
+
         // check East/West
         let path2 = null;
         for (const source of this.lines[1][0]) {
@@ -533,12 +536,31 @@ export class PippinzipGame extends GameBase {
                 }
             }
             if (this.connPath.length > 0) {
-                const targets: RowCol[] = [];
-                for (const cell of this.connPath) {
-                    const [x,y] = PippinzipGame.algebraic2coords(cell, this.boardSize);
-                    targets.push({row: y, col: x})
+                if ( this.connPath.includes("0") ) { // it is a four edge connection
+                    const i = this.connPath.indexOf("0"); // find where the separator is, to draw each path separately
+                    let targets: RowCol[] = [];
+                    const path1 = this.connPath.slice(0,i);
+                    for (const cell of path1) {
+                        const [x,y] = PippinzipGame.algebraic2coords(cell, this.boardSize);
+                        targets.push({row: y, col: x})
+                    }
+                    rep.annotations.push({type: "move", targets: targets as [RowCol, ...RowCol[]], arrow: false});
+
+                    targets = [];
+                    const path2 = this.connPath.slice(i+1);
+                    for (const cell of path2) {
+                        const [x,y] = PippinzipGame.algebraic2coords(cell, this.boardSize);
+                        targets.push({row: y, col: x})
+                    }
+                    rep.annotations.push({type: "move", targets: targets as [RowCol, ...RowCol[]], arrow: false});
+                } else { // it is a connection between opposite edges
+                    const targets: RowCol[] = [];
+                    for (const cell of this.connPath) {
+                        const [x,y] = PippinzipGame.algebraic2coords(cell, this.boardSize);
+                        targets.push({row: y, col: x})
+                    }
+                    rep.annotations.push({type: "move", targets: targets as [RowCol, ...RowCol[]], arrow: false});
                 }
-                rep.annotations.push({type: "move", targets: targets as [RowCol, ...RowCol[]], arrow: false});
             }
         }