// SnipSnip

(define "SitesAtOmniDiagonal"
    (difference
        (difference 
            (sites Around (sites Around (from) <Board:adj>) <Board:adj>)
            (sites (from) {{F} {F F}}) 
        )
        (from)
))

(define "DiagonallyConnectedDomainsOf" // (player)
    (union
        (sites Occupied by:(player #1))
        (sites
            (results
                from:(sites Occupied by:(player #1))
                to:(intersection (sites Occupied by:(player #1)) "SitesAtOmniDiagonal")
                (regionSite
                    (intersection
                        (sites Around (from) <Board:adj>)
                        (sites Around (to) <Board:adj>)
                    )
                    index:0
)))))

(define "SetDiagonalGroupScores"
    (forEach Player
        (set Score
            (player (player)) 
            (* #1
                (max 0
                    (+ 1
                        (max 
                            (results
                                from:(sites Occupied by:(player (player)))
                                to:(from)
                                (size Array
                                    (array 
                                        (intersection
                                            (sites
                                                Distance <Board:adj>
                                                (step <Board:adj>
                                                    (to
                                                        if:(is In (to) ("DiagonallyConnectedDomainsOf" (player)))
                                                ))
                                                from:(from)
                                                (min 0)
                                            )
                                            (sites Occupied by:(player (player)))
                        )))))
))))))

(define "SetStoneScores"
    (set Score  P1 (* #1 (count Pieces  P1))
        (then
            (set Score P2 (* #1 (count Pieces P2)))
)))

(define "SetGroupScores"
    (forEach Player
        (set Score
            (player (player)) 
            (* #1
                (max 0
                    (max 
                        (sizes Group <Board:adj> of:(player)) 
))))))

(define "SetPairScores"
    (forEach Player
        (set Score
            (player (player)) 
            (* #1
                (/
                    (+
                        (results 
                            from:(sites Occupied by:(player (player)))
                            to:(sites Around (from) <Board:adj> if:(is In (to) (sites Occupied by:(player (player)))))
                            1
                    ))
                    2
)))))

(define "SitesAllowedDiagonal"
    (difference
        (sites Empty)
        (sites
            (results 
                from:(sites Occupied by:P1)
                to:(forEach
                    of:(intersection
                        "SitesAtOmniDiagonal"
                        (sites Occupied by:P2)
                    )
                    (intersection
                        {
                        (sites Around (from) <Board:adj>) 
                        (sites Around (site) <Board:adj>) 
                        (sites Empty) 
                        }
                ))
                (to)
))))

(define "Sites2RemoveDiagonal" // Mover/Next
    (sites
        (results 
            from:(last To) 
            to:(forEach
                of:(intersection
                    "SitesAtOmniDiagonal"
                    (sites Occupied by:#1) 
                )
                (intersection
                    {
                    (sites Around (from) <Board:adj>)
                    (sites Around (site) <Board:adj>)
                    (sites Occupied by:#1) 
                    }
            ))
            (to)
)))

(define "SitesAllowedBetween"
    (difference
        (sites Empty)
        (sites
            (results 
                from:(sites Occupied by:P1)
                to:(forEach
                    of:(sites Distance
                        <Board:adj>
                        from:(from)
                        (exact 2)
                    )
                    (sites Between
                        <Board:adj>
                        from:(from)
                        to:(site)
                        cond:(and
                            (is In (site) (sites Occupied by:P2))
                            (is Empty (between))
                )))
                (to)
))))

(define "Sites2RemoveBetween"
    (forEach 
        of:(sites Distance 
            (step (to if:(is Next (who at:(to)))))
            from:(last To) 
            (exact 2)
        )
        (sites Between
            <Board:adj>
            from:(last To)
            to:(site)
            cond:(is In (between) (sites Occupied by:#1))
)))

//---------------------------------------
// Main routine
//---------------------------------------

(game "SnipSnip"
    (players 2)
    (equipment
        {
        (board <Board:size> use:Vertex)
        (piece "Ball" Each)
        }
    )
    (rules
        (start
            {
            (set Score Each 0)
            }   
        ) 
        (play
            (if
                (= 1 (value Player Mover))
                (move Remove (<Pattern:capture> Next)
                    (then
                        (and
                            {
                            (set Value Mover 0)
                            <Scoring:forcedTurns> // (moveAgain)
                            }
                )))
                (move Add
                    (to <Pattern:placement>)
                    (then
                        (if
                            (< 0
                                (count Pieces 
                                    in:(<Pattern:capture> Next)
                            ))
                            (set Value Mover 1 
                                (then 
                                    (moveAgain)
                )))))
                (then <Scoring:option>)
        ))
        (end 
            {
            
            (if 
                (and
                    (no Moves Next)
                    (= (score P1) (score P2))
                )
                (result Next Loss)
            )
            
            (if 
                (and
                    (no Moves Next)
                    (!= (score P1) (score P2))
                )
                (byScore)
            )
            }
        )
    )
)

//---------------------------------------

(define "Misere" -1)

(option "Scoring" <Scoring> args:{ <option> <forcedTurns> <connectionHighlights>}
    {
    (item "Groups - Misere" <("SetGroupScores"  "Misere")> <(moveAgain)> < > "Misere: Score one negative point for each stone in your largest group of adjacent stones")**
    
    (item "Groups" <("SetGroupScores" 1)> < > < > "Score one point for each stone in your largest group of adjacent stones")
    
    (item "Diagonal-linked Groups - Misere" <("SetDiagonalGroupScores"  "Misere")> <(moveAgain)> <"HighlightConnections"> "Misere: Score one negative point for each stone in your largest group of adjacent stones")
    
    (item "Diagonal-linked Groups" <("SetDiagonalGroupScores" 1)> < > <"HighlightConnections"> "Score one point for each stone in your largest group of adjacent stones")*
    
    //  (item "Pairs - Misere" <("SetPairScores" "Misere")> <(moveAgain)> < > "Misere: Score one negative point for each adjacent pair of your stones")
    
    //  (item "Pairs" <("SetPairScores" 1)> < > < > "Score one point for each adjacent pair of your stones")
    
    //  (item "Stones - Misere" <("SetStoneScores" "Misere")> <(moveAgain)> < > "Misere: Score one negative point for each stone")
    
    //  (item "Stones" <("SetStoneScores" 1)> < > < > "Score one point for each stone")
    }
)

(option "Capture" <Pattern> args:{ <capture> <placement>}
    {
    (item "Between" <"Sites2RemoveBetween"> <("SitesAllowedBetween")> "Capture opponent's stones between your stone and an opponent's stone in a line of 3.")
    
    (item "Diagonal" <"Sites2RemoveDiagonal"> <("SitesAllowedDiagonal")> "Capture one of the opponent's stones on the 2  sites orthogonally between your stone and a diagonally adjacent opponent's stone.")**
    }
) 

(define "Tri46Bug"  (tri {4 6 4 7 4}))
(define "Tri56Bug"  (tri {5 6 5 7 5}))
(define "Tri57Bug"  (tri {5 7 5 8 5}))
(define "Tri78Bug"  (tri {7 8 7 10 6}))

(option "Board Size" <Board> args:{ <size> <adj> <diag> }
    {
    (item "Hex 2-3 (12)"         <(tri {2 3 2 3 2})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 2 and 4")
    (item "Equiversi 2-4 (18)"   <(tri {2 4 2 4 2})>    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 2 and 4")****
    (item "Equiversi 3-5 (36)"   <(tri {3 5 3 5 3})>    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 3 and 5")***
    (item "Hex 4-5 (48)"         <(tri {4 5 4 5 4})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 4 and 5")**
    (item "Equiversi 4-6 (60)"   <"Tri46Bug">    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 4 and 6")
    (item "Equiversi 5-7 (90)"   <"Tri57Bug">    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 5 and 7")**
    (item "Hex 6-7 (108)"        <(tri {6 7 6 7 6})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 6 and 7")
    (item "Equiversi 6-8 (126)"  <(tri {6 8 6 8 6})>    <Orthogonal> <Hidden>  "Board & size: Equiversi Hexhex with edges alternating 6 and 8") 
    (item "Square 4 ortho (16)"  <(square 4)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 5") 
    (item "Square 6 ortho (36)"  <(square 6)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 7") 
    (item "Square 8 ortho (64)"  <(square 8)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 9") 
    (item "Square 10 ortho (100)" <(square 10)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 10") 
    (item "Hex 3 (19)"           <(tri Hexagon 3)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 3")
    (item "Hex 3-4 (27)"         <(tri {3 4 3 4 3})>   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 3 and 4")
    (item "Hex 4 (37)"           <(tri Hexagon 4)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 4")
    (item "Hex 5 (61)"           <(tri Hexagon 5)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 5") 
    (item "Hex 5-6 (75)"         <"Tri56Bug">   <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 5 and 6") // standard strategy
    (item "Hex 6 (91)"           <(tri Hexagon 6)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 6") 
    (item "Hex 7 (127)"          <(tri Hexagon 7)>     <Orthogonal> <Hidden>  "Board & size: Hexhex 7")
    (item "Hex 7-8 (147)"        <"Tri78Bug">  <Orthogonal> <Hidden>  "Board & size: Hexhex with edges alternating 7 and 8")
    (item "Square 5 ortho (25)" <(square 5)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 5") 
    (item "Square 7 ortho (49)" <(square 7)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 7") 
    (item "Square 9 ortho (81)" <(square 9)>          <Orthogonal> <Hidden>  "Board & size: Orthogonal 9") 
    (item "Square 3 omni (13)" 
        <(add
            (remove (square 5) vertices:{
                0  1     3  4
                5           9 
                
                15          19
            20 21    23 24})
            edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 11} {9 12} {11 12}}
        )> 
    <All> <Thin> "Board & size: Orthogonal 3")
    (item "Square 4 omni (25)" 
        <(add
            (remove (square 7) vertices:{ 0 1 2 4 5 6 7 8 12 13 14 20 28 34 35 36 40 41 42 43 44 46 47 48})
            edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 20} {16 21} {20 23} {21 24} {23 24}}
        )> 
    <All> <Thin> "Board & size: Orthogonal 4")
    
    (item "Square 5 omni (41)" 
        <(add
            (remove (square 9) vertices:{
                0  1  2  3     5  6  7  8
                9 10 11          15 16 17
                18 19                25 26
                27                      35
                
                45                      53
                54 55                61 62 
                63 64 65          69 70 71
            72 73 74 75    77 78 79 80 })
            
        edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 24} {16 25} {24 31} {25 32} {31 36} {32 37} {36 39} {37 40} {39 40}} )> 
        
    <All> <Thin> "Board & size: Orthogonal 5")
    
    (item "Square 6 omni (61)" 
        <(add 
            (remove (square 11) vertices:{
                0   1   2   3   4       6   7   8   9  10 
                11  12  13  14              18  19  20  21 
                22  23  24                      30  31  32  
                33  34                              42  43  
                44                                      54  
                
                66                                      76  
                77  78                              86  87  
                88  89  90                      96  97  98  
                99 100 101 102             106 107 108 109 
            110 111 112 113 114     116 117 118 119 120 }) 
            
        edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 24} {16 25} {24 35} {25 36} {35 44} {36 45} {44 51} {45 52} {51 56} {52 57} {56 59} {57 60} {59 60}} )>
        
    <All> <Thin> "Board & size: Orthogonal 6") 
    
    (item "Square 7 omni (85)" 
        <(add
            (remove (square 13) vertices:{
                0   1   2   3   4   5       7   8   9  10  11  12  
                13  14  15  16  17              21  22  23  24  25  
                26  27  28  29                      35  36  37  38  
                39  40  41                              49  50  51  
                52  53                                      63  64  
                65                                              77  
                
                91                                             103 
                104 105                                     115 116 
                117 118 119                             127 128 129 
                130 131 132 133                     139 140 141 142 
                143 144 145 146 147             151 152 153 154 155 
            156 157 158 159 160 161     163 164 165 166 167 168 })
            
        edges:{{0 1} {0 3} {3 8} {1 4} {4 9} {8 15} {9 16} {15 24} {16 25} {24 35} {25 36} {35 48} {36 49} {48 59} {49 60} {59 68} {60 69} {68 75} {69 76} {75 80} {76 81} {80 83} {81 84} {83 84}} )>
        
    <All> <Thin> "Board & size: Orthogonal 7") 
    }
)

//----------------------------------------------------------

(metadata
    (info
        {
        (description "SnipSnip is an outgrowth of 'Tri-It-Out', a pattern capture game, in which the capture pattern involves pieces of both player's symmetrically, and is used to exclude captured sites from immediate replacement. SnipSnip uses more local capture patterns: options of between, or diagonally between, opposing pieces. These patterns are self-limiting in the sense of not allowing cyclic captures.
            
            These capture patterns dictate dead sites that typically result in alternating linear and honeycomb arrangements of pieces with tactical exceptions.
            
            In addition the goal of 'SnipSnip' is changed from 'Tri-It-Out's 'most pieces' to 'largest Group', which creates greater drama and opportunities for turn-around tactics, and is the reason for the SnipSnip name.
            
        'Tri-It-Out' is Misere. 'SnipSnip' also includes non-Misere variants.")
        (rules "SnipSnip is a 2-player strategy game
            It may be played: 
            -- on a hex grid
            -- on a square grid
            -- on a square plus diagonal grid
            Goal: Largest Group (in Misere, the largest Group loses.)
            
            Definitions:
            A Group is a set of all the pieces that can be reached from any one of them by a series of steps, where a step means movement from one piece to another of the same color, next to it.
            
            Note: For the Diagonal-Linked Group options a step also include diagonals (double-steps that are not in the same grid direction).
            
            A site is a board intersection.
            
            'Between' Variant:
            -- A Capture site is any site adjacent to two stones of opposite color in the same line (i.e. directly between them.)
            
            'Diagonal' Variant:
            -- A Capture site is any site adjacent to each of two stones of opposite color, where those stones are not on the same grid-line.
            
            Play:
            Players take turn, starting on an empty board with White to play.
            
            On a turn
        1) The mover places to an empty site that is not a Capture site.
    2) Then, if possible, the mover removes one of the opponent's checkers from a Capture site that lies adjacent to the placement just made.
    
    In the case of Misere, the mover must take an additional turn after each capture.
    
    Otherwise, the next player becomes the mover.
    
    The game ends when no placement is possible.
In the case of a tie, the player who would have been next to place loses.")
(id "3863")
(version "1.3.12")
(classification "experimental")
(author "Dale W. Walton")
(credit "Dale W. Walton")
(date "04-01-2023")
}
)

(define "HighlightConnections"
    (show Symbol "Disc.svg" Vertex
        ("DiagonallyConnectedDomainsOf" 2)
        fillColour:(colour 0 0 255 50) edgeColour:(colour 0 0 0 0) scale:1
    )
    (show Symbol "Disc.svg" Vertex
        ("DiagonallyConnectedDomainsOf" 1)
        fillColour:(colour 255 255 0 100) edgeColour:(colour 0 0 0 0) scale:1
))

(graphics 
    {
    (board Style Graph)
    (board Colour InnerEdges (colour 62 72 55))
    (board Colour OuterEdges (colour 62 72 55))
    (board StyleThickness OuterEdges .25)
    (board StyleThickness InnerEdges .25)
    (show Edges Diagonal <Board:diag> (colour 62 72 55))
    <Scoring:connectionHighlights>
    (piece Scale P1 "Ball" 0.75)
    (piece Scale P2 "Ball" 0.75)
    (piece Scale P3 "Ball" 0.75)
    (piece Scale P4 "Ball" 0.75)
    (piece Scale P5 "Ball" 0.75)
    (piece Scale P6 "Ball" 0.75)
    }
)
)