- You can use the left/right arrow keys to view the history of the game.
-
- This game is written in Haskell. The code is open source.
- David Peter, 2014-2023
-
-
-
-
-
diff --git a/info/screenshot.png b/info/screenshot.png
deleted file mode 100644
index 50dadfd..0000000
Binary files a/info/screenshot.png and /dev/null differ
diff --git a/info/turn-structure.svg b/info/turn-structure.svg
deleted file mode 100644
index f42b7a0..0000000
--- a/info/turn-structure.svg
+++ /dev/null
@@ -1,675 +0,0 @@
-
-
-
-
diff --git a/main.css b/main.css
deleted file mode 100644
index f4e98f0..0000000
--- a/main.css
+++ /dev/null
@@ -1,50 +0,0 @@
-body {
- margin: 0;
- padding: 0;
-}
-
-h1 {
- margin: 0;
- padding: 0;
- text-align: center;
-
- font-family: 'Open Sans', sans-serif;
- font-weight: 800;
- font-size: 80px;
-
- color: #fff;
- text-shadow: 0 0 10px #26ADE4;
-
- background-color: #4DBCE9;
- border-bottom: 4px solid #26ADE4;
-}
-
-.small {
- font-size: 70px;
-}
-
-#center {
- margin-top: 40px;
- margin-bottom: 40px;
- text-align: center;
-}
-
-canvas {
- cursor: crosshair;
- outline: none;
-}
-
-.disclaimer {
- text-align: center;
-
- font-family: 'Open Sans', sans-serif;
- font-weight: 400;
- font-size: 15px;
- color: #aaa;
- text-align: center;
-}
-
-a {
- color: #26ADE4;
- text-decoration: none;
-}
diff --git a/src/AI.hs b/src/AI.hs
deleted file mode 100644
index 31cf34f..0000000
--- a/src/AI.hs
+++ /dev/null
@@ -1,97 +0,0 @@
-{-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE UndecidableInstances #-}
-
-module AI where
-
-import qualified Data.Tree.Game_tree.Game_tree as GT
-import qualified Data.Tree.Game_tree.Negascout as NS
-
-import Data.Maybe (fromJust)
-import Data.List (nubBy, sort)
-
-import Yinsh
-
--- | Every AI should provide a function @ai..@, returning an AIFunction.
-type AIFunction = GameState -> GameState
-
--- | Result of an heuristic evaluation function
-type AIValue = Int
-
--- | Wrapper class for AI players which encapsules the current game state.
-class AIPlayer a where
- -- | Heuristic evaluation function for a game state. Everything is calulated
- -- from the perspective of the white player. This is sufficient since
- -- Yinsh is a zero sum game.
- valueForWhite :: a -> AIValue
-
- -- | Number of turns to look ahead in the game tree.
- getPlies :: a -> Int
-
- -- | Unwrap the gamestate inside the AI.
- getGamestate :: a -> GameState
-
- -- | Update AI with new gamestate
- update :: a -> GameState -> a
-
--- | Make the GameState (wrapped in the AIPlayer) an instance of Game_tree
--- (actually rather an instance of a node in the game tree).
-instance (AIPlayer a) => GT.Game_tree a where
- is_terminal = terminalState . getGamestate
- children ai = map (update ai) (gamestates (getGamestate ai))
- node_value ai = sign * valueForWhite ai
- where sign | activePlayer gs == W = 1
- | otherwise = -1
- gs = getGamestate ai
-
--- | Possible new game states. The input and output game states are guaranteed
--- to be in turn mode AddRing, AddMarker, RemoveRun or Wait*.
-gamestates :: GameState -> [GameState]
-gamestates gs | terminalState gs = []
- | otherwise =
- case turnMode gs of
- AddRing -> freeCoords >>= newGS gs
- AddMarker -> rings' >>= newGS gs
- (RemoveRun _) -> runCoords' >>= newGS gs
- (WaitRemoveRun _) -> [fromJust (newGameState gs (0, 0))]
- WaitAddMarker -> [fromJust (newGameState gs (0, 0))]
- (MoveRing _) -> error "This is not supposed to happen"
- (RemoveRing _) -> error "This is not supposed to happen"
- where freeCoords = filter (freeCoord (board gs)) coords -- TODO: factor out, optimize
- rings' = rings (activePlayer gs) (board gs)
- runCoords' = removeDups $ filter (partOfRun markers') coords
- markers' = markers (activePlayer gs) (board gs)
- removeDups = nubBy (\c1 c2 -> sort (runCoords markers' c1) == sort (runCoords markers' c2))
- newGS gs' c = case turnMode nextGS of
- AddRing -> [nextGS]
- AddMarker -> [nextGS]
- (RemoveRun _) -> [nextGS]
- (WaitRemoveRun _) -> [nextGS]
- WaitAddMarker -> [nextGS]
- (MoveRing start) -> ringMoves (board nextGS) start >>= newGS nextGS
- (RemoveRing _) -> rings (activePlayer nextGS) (board gs') >>= newGS nextGS
- where nextGS = fromJust $ newGameState gs' c
-
--- | Get new game state after the AI turn.
-aiTurn :: (AIPlayer ai) => ai -> GameState
-aiTurn ai = case turnMode gs of
- (WaitRemoveRun _) -> fromJust $ newGameState gs (0, 0)
- WaitAddMarker -> fromJust $ newGameState gs (0, 0)
- _ -> pv !! 1
- where pv = aiPV ai
- gs = getGamestate ai
-
--- | Get the whole principal variation.
-aiPV :: (AIPlayer ai) => ai -> [GameState]
-aiPV ai = map getGamestate gss
- where (gss, _) = NS.negascout ai ply
- ply = getPlies ai
--- TODO: negascout really seems to be the fastest. But test this for more game states
--- NS.alpha_beta_search gs ply
--- NS.principal_variation_search gs ply
-
--- | A large number for symbolizing a win.
--- Very ugly: if this number is higher than 2^31, there is an integer overflow
--- in haste/javascript, resulting in the AI playing *very* bad.
--- So 2^31 - 1 ~ 2 * 10^9 is our hardcoded magic 'huge' number.
-hugeNumber :: Int
-hugeNumber = 2147483647
diff --git a/src/Floyd.hs b/src/Floyd.hs
deleted file mode 100644
index 8535af7..0000000
--- a/src/Floyd.hs
+++ /dev/null
@@ -1,95 +0,0 @@
--- | Simply the best AI for Yinsh, seriously.
-
-module Floyd ( aiFloyd
- , mhNumber
- , rhRingMoves
- , rhConnected
- , rhControlledMarkers
- , rhCombined
- , rhZero
- )
- where
-
-import AI
-import Yinsh
-
--- TODO: adjust numbers: 5, 10
-floydHeuristic :: Floyd -> AIValue
-floydHeuristic ai | points' W >= pointsForWin = hugeNumber
- | points' B >= pointsForWin = -hugeNumber
- | otherwise = value W - value B
- where gs' = getGamestate ai
- board' = board gs'
- ap' = activePlayer gs'
- tm' = turnMode gs'
- points W = pointsW gs'
- points B = pointsB gs'
-
- points' p = points p + futurePoints p
- -- If we are in RemoveRun phase, already include the point for the
- -- active player.
- -- If we are is WaitRemoveRun, the *opponent* of the current player
- -- will necessarily have one more point next turn.
- futurePoints p = case tm' of
- (RemoveRun _) -> if ap' == p then 1 else 0
- (WaitRemoveRun _) -> if ap' == p then 0 else 1
- _ -> 0
-
- valuePoints p = 100000 * points' p
- valueMarkers = markerH ai
- valueRings = ringH ai
-
- value p = valuePoints p
- + valueMarkers board' p
- + valueRings board' p
-
-
-type MarkerHeuristic = Board -> Player -> AIValue
-type RingHeuristic = Board -> Player -> AIValue
-
-mhNumber :: MarkerHeuristic
-mhNumber b p = (10 *) $ length $ markers p b
-
-rhRingMoves :: RingHeuristic
-rhRingMoves b p = (1 *) $ sum $ map (length . ringMoves b) $ rings p b
-
-rhConnected :: RingHeuristic
-rhConnected b p = (1 *) $ length $ filter connectedToRings coords
- where connectedToRings c = any (c `connected`) (rings p b)
-
-rhControlledMarkers :: RingHeuristic
-rhControlledMarkers b p = sum $ map controlledM (rings p b)
- where controlledM :: YCoord -> Int
- controlledM start = sum $ map markersBetween endPos
- where endPos = ringMoves b start
- markersBetween end = length $ filter (isMarker b) $ coordLine start end
-
-rhCombined :: [(Int, RingHeuristic)] -> RingHeuristic
-rhCombined list b p = sum $ zipWith (*) points vs
- where (vs, hs) = unzip list
- points = map (\h -> h b p) hs
-
-rhZero :: RingHeuristic
-rhZero _ _ = 0
-
-data Floyd = Floyd { gs :: GameState
- , plies :: Int
- , markerH :: MarkerHeuristic
- , ringH :: RingHeuristic
- }
-
-instance AIPlayer Floyd where
- valueForWhite = floydHeuristic
- getGamestate = gs
- getPlies = plies
- update ai gs' = ai { gs = gs' }
-
-mkFloyd :: Int -> MarkerHeuristic -> RingHeuristic -> GameState -> Floyd
-mkFloyd plies' mh' rh' gs' = Floyd { gs = gs'
- , plies = plies'
- , markerH = mh'
- , ringH = rh'
- }
-
-aiFloyd :: Int -> MarkerHeuristic -> RingHeuristic -> AIFunction
-aiFloyd plies' mh' rh' gs' = aiTurn $ mkFloyd plies' mh' rh' gs'
diff --git a/src/Pink.hs b/src/Pink.hs
deleted file mode 100644
index 3cc7380..0000000
--- a/src/Pink.hs
+++ /dev/null
@@ -1,70 +0,0 @@
--- | Trying to complete with the best
-
-module Pink ( aiPink
- -- , mhNumber
- -- , rhRingMoves
- -- , rhConnected
- -- , rhZero
- )
- where
-
-import AI
-import Yinsh
-
-pinkHeuristic :: Pink -> AIValue
-pinkHeuristic ai | points W >= pointsForWin = hugeNumber
- | points B >= pointsForWin = -hugeNumber
- | otherwise = value W - value B
- where gs' = getGamestate ai
- points W = pointsW gs'
- points B = pointsB gs'
- board' = board gs'
-
- valueMarkers = markerH ai
- valueRings = ringH ai
-
- value p = valuePoints p
- + valueMarkers board' p
- + valueRings board' p
-
- valuePoints p = 100000 * points p
-
-type MarkerHeuristic = Board -> Player -> AIValue
-type RingHeuristic = Board -> Player -> AIValue
-
-mhNumber :: MarkerHeuristic
-mhNumber b p = (10 *) $ length $ markers p b
-
-rhRingMoves :: RingHeuristic
-rhRingMoves b p = (1 *) $ sum $ map (length . ringMoves b) $ rings p b
-
-rhConnected :: RingHeuristic
-rhConnected b p = (1 *) $ length $ filter connectedToRings coords
- where connectedToRings c = any (c `connected`) (rings p b)
-
--- rhControlledMarkers :: RingHeuristic
--- rhControlledMarkers b p = length $ nub $ controlledM =<< (rings p b)
--- controlledM :: YCoord -> [YCoord]
--- controlledM c = ringMoves b c
-
-rhZero :: RingHeuristic
-rhZero _ _ = 0
-
-data Pink = Pink { gs :: GameState
- , plies :: Int
- , markerH :: MarkerHeuristic
- , ringH :: RingHeuristic
- }
-
-instance AIPlayer Pink where
- valueForWhite = pinkHeuristic
- getGamestate = gs
- getPlies = plies
- update ai gs' = ai { gs = gs' }
-
-aiPink :: Int -> MarkerHeuristic -> RingHeuristic -> AIFunction
-aiPink plies' mh' rh' gs' = aiTurn Pink { gs = gs'
- , plies = plies'
- , markerH = mh'
- , ringH = rh'
- }
diff --git a/src/RaiCharles.hs b/src/RaiCharles.hs
deleted file mode 100644
index f6117c2..0000000
--- a/src/RaiCharles.hs
+++ /dev/null
@@ -1,22 +0,0 @@
--- | Random AI (RAI) Charles, playing not really randomly.
-
-module RaiCharles (aiRaiCharles) where
-
-import AI
-import Yinsh
-
-heuristic :: RaiCharles -> AIValue
-heuristic _ = 42 -- yeah..
-
-data RaiCharles = RaiCharles { gs :: GameState
- , pl :: Int
- }
-
-instance AIPlayer RaiCharles where
- valueForWhite = heuristic
- getGamestate = gs
- getPlies = pl
- update ai gs' = ai { gs = gs' }
-
-aiRaiCharles :: Int -> AIFunction
-aiRaiCharles plies' gs' = aiTurn RaiCharles { gs = gs', pl = plies' }
diff --git a/src/Yinsh.hs b/src/Yinsh.hs
deleted file mode 100644
index f06aabb..0000000
--- a/src/Yinsh.hs
+++ /dev/null
@@ -1,431 +0,0 @@
-{-# LANGUAGE BangPatterns #-}
-
--- |
--- Data structures and functions for playing the board game Yinsh.
-
-module Yinsh where
-
-import Control.Monad (guard)
-import qualified Data.Map.Lazy as M
-import Data.List (delete, foldl', sortBy)
-import Data.Ord (comparing)
-
--- $setup
--- >>> import Data.List (sort, nub)
--- >>> import Test.QuickCheck hiding (vector)
--- >>> let boardCoords = elements coords
--- >>> instance Arbitrary Direction where arbitrary = elements directions
-
--- | Yinsh hex coordinates.
-type YCoord = (Int, Int)
-
--- | The six hex directions.
-data Direction = N | NE | SE | S | SW | NW
- deriving (Eq, Enum, Bounded, Show, Read)
-
--- | Board element (ring or marker).
-data Element = Ring Player
- | Marker Player
- deriving (Show, Eq, Read)
-
--- | Status of the game (required action). The two modes @WaitRemoveRun@ and
--- @WaitAddMarker@ are introduced to preserve the alternating turn structure
--- for the minmax-algorithm. The full structure is explained in the figure:
---
--- <>
-data TurnMode = AddRing -- ^ place a ring on a free field
- | AddMarker -- ^ place a marker in one of your rings
- | MoveRing YCoord -- ^ move the ring at the given position
- | RemoveRun Player -- ^ remove (one of your) run(s).
- -- the parameter holds the last player who
- -- moved a ring
- | RemoveRing Player -- ^ remove one of your rings
- | WaitRemoveRun Player -- ^ do nothing
- | WaitAddMarker -- ^ do nothing
- deriving (Eq, Show, Read)
-
--- | Player types: black & white (or blue & green).
-data Player = B | W
- deriving (Eq, Enum, Bounded, Show, Read)
-
--- | Efficient data structure for the board with two-way access.
--- The Map is used to get log(n) access to the element at a certain
--- coordinate while the lists are used to get direct access to the
--- coordinates of the markers and rings (which would need a reverse
--- lookup otherwise). This comes at the cost of complete redundancy.
--- Either bmap or the other four fields would be enough to reconstruct
--- the whole board.
-data Board = Board { bmap :: M.Map YCoord Element
- , ringsB :: [YCoord]
- , ringsW :: [YCoord]
- , markersB :: [YCoord]
- , markersW :: [YCoord]
- } deriving (Eq, Show, Read)
-
--- | Yinsh game state.
-data GameState = GameState
- { activePlayer :: Player -- ^ player which has to move next
- , turnMode :: TurnMode -- ^ required action
- , board :: Board -- ^ current Yinsh board
- , pointsB :: Int -- ^ number of runs / rings removed (black)
- , pointsW :: Int -- ^ number of runs / rings removed (white)
- } deriving (Eq, Show, Read)
-
--- | Get all marker coordinates of one player.
-markers :: Player -> Board -> [YCoord]
-markers B = markersB
-markers W = markersW
-
--- | Get all ring coordinates of one player.
-rings :: Player -> Board -> [YCoord]
-rings B = ringsB
-rings W = ringsW
-
--- | Returns (Just) the element at a certain position or Nothing if the
--- coordinate is free (or invalid).
-elementAt :: Board -> YCoord -> Maybe Element
-elementAt b c = M.lookup c (bmap b)
-
--- | Returns True if the element at the given point is a marker of any color.
-isMarker :: Board -> YCoord -> Bool
-isMarker b c = case elementAt b c of
- (Just (Marker _)) -> True
- _ -> False
-
--- | Returns True if the element at the given point is a ring of any color.
-isRing :: Board -> YCoord -> Bool
-isRing b c = case elementAt b c of
- (Just (Ring _)) -> True
- _ -> False
-
--- | Returns True if a certain point on the board is free. Does not check the
--- validity of the coordinate.
-freeCoord :: Board -> YCoord -> Bool
-freeCoord b c = not $ M.member c (bmap b)
-
--- | Returns a new board with the specified element added at the given
--- coordinate.
-addElement :: Board -> YCoord -> Element -> Board
-addElement b c e = case e of
- Ring B -> b { bmap = bmap'
- , ringsB = c : ringsB b }
- Ring W -> b { bmap = bmap'
- , ringsW = c : ringsW b }
- Marker B -> b { bmap = bmap'
- , markersB = c : markersB b }
- Marker W -> b { bmap = bmap'
- , markersW = c : markersW b }
- where bmap' = M.insert c e (bmap b)
-
--- | Returns a new board with the element at the given point removed.
-removeElement :: Board -> YCoord -> Board
-removeElement b c = case e of
- Ring B -> b { bmap = bmap'
- , ringsB = delete c (ringsB b) }
- Ring W -> b { bmap = bmap'
- , ringsW = delete c (ringsW b) }
- Marker B -> b { bmap = bmap'
- , markersB = delete c (markersB b) }
- Marker W -> b { bmap = bmap'
- , markersW = delete c (markersW b) }
- where bmap' = M.delete c (bmap b)
- e = bmap b M.! c
-
--- | Returns a new board with the element at the given point replaced.
-modifyElement :: Board -> YCoord -> Element -> Board
-modifyElement b c = addElement (removeElement b c) c
--- TODO: this can certainly be optimizied:
-
--- | Yinsh board without any elements.
-emptyBoard :: Board
-emptyBoard = Board { bmap = M.empty
- , ringsB = []
- , ringsW = []
- , markersB = []
- , markersW = []
- }
-
--- | Required runs for a win.
-pointsForWin = 3
-pointsForWin :: Int
-
--- | Similar to Enum's succ, but for cyclic data structures.
--- Wraps around to the beginning when it reaches the 'last' element.
-next :: (Eq a, Enum a, Bounded a) => a -> a
-next x | x == maxBound = minBound
- | otherwise = succ x
-
--- | All six directions on the board.
-directions :: [Direction]
-directions = [minBound .. maxBound]
-
--- | Opposite direction (rotated by 180°).
---
--- prop> (opposite . opposite) d == d
-opposite :: Direction -> Direction
-opposite = next . next . next
-
--- | Vector to the next point on the board in a given direction.
-vector :: Direction -> YCoord
-vector N = ( 0, 1)
-vector NE = ( 1, 1)
-vector SE = ( 1, 0)
-vector S = ( 0, -1)
-vector SW = (-1, -1)
-vector NW = (-1, 0)
-
--- | Check if the point is within the boundaries of the board.
--- All Yinsh coordinates lie on a hexagonal grid within a circle of radius 4.6.
-validCoord :: YCoord -> Bool
-validCoord (x', y') = (0.5 * sqrt 3 * x)**2 + (0.5 * x - y)**2 <= 4.6**2
- where x = fromIntegral x'
- y = fromIntegral y'
-
--- | All points on the board.
---
--- >>> length coords
--- 85
---
-coords :: [YCoord]
-coords = sortCoords [ (x, y) | x <- [-5 .. 5]
- , y <- [-5 .. 5]
- , validCoord (x, y) ]
-
--- | Sort the coords once with respect to the distance from the center
--- for a better move ordering in the game tree.
-sortCoords :: [YCoord] -> [YCoord]
-sortCoords = sortBy (comparing norm2)
-
--- | Check if two points are connected by a line.
---
--- >>> connected (3, 4) (8, 4)
--- True
---
--- prop> connected c1 c2 == connected c2 c1
---
-connected :: YCoord -> YCoord -> Bool
-connected (x, y) (a, b) = x == a
- || y == b
- || x - y == a - b
-
--- | Vectorially add two coordinates.
-add :: YCoord -> YCoord -> YCoord
-add (!x1, !y1) (!x2, !y2) = (x1 + x2, y1 + y2)
-
--- | Vectorially subtract two coordinates.
-sub :: YCoord -> YCoord -> YCoord
-sub (!x1, !y1) (!x2, !y2) = (x1 - x2, y1 - y2)
-
--- | Squared norm.
-norm2 :: YCoord -> Int
-norm2 (x, y) = x * x + y * y
-
--- | Get a line of points from a given coordinate to the edge of the board.
-ray :: YCoord -> Direction -> [YCoord]
-ray s d = takeWhile validCoord $ adjacent s d
-
--- | All coordinates for a ring move in a given direction.
-ringMovesD :: Board -> YCoord -> Direction -> [YCoord]
-ringMovesD b s d = free ++ freeAfterJump
- where line = tail (ray s d)
- (free, rest) = span (freeCoord b) line
- freeAfterJump = jumpPos rest
- jumpPos [] = []
- jumpPos (c:cs) = case elementAt b c of
- (Just (Ring _)) -> []
- (Just (Marker _)) -> jumpPos cs
- Nothing -> [c]
-
--- | Get all valid ring moves starting from a given point.
-ringMoves :: Board -> YCoord -> [YCoord]
-ringMoves b start = ringMovesD b start =<< directions
-
--- | Check if a player has a run of five in a row.
-hasRun :: Board -> Player -> Bool
-hasRun b p = any (hasRunD b p) [NW, N, NE]
-
-isMarkerOf :: Board -> Player -> YCoord -> Bool
-isMarkerOf b p c = case elementAt b c of
- Just (Marker x) -> x == p
- _ -> False
-
-hasRunD :: Board -> Player -> Direction -> Bool
-hasRunD b p d = any middleOfRun ms
- where ms = markers p b
- middleOfRun c = all (isMarkerOf b p) surrounding
- where surrounding = left ++ right
- left = take 2 $ tail $ adjacent c d
- right = take 2 $ tail $ adjacent c $ opposite d
--- TODO: this can be improved.. we are checking for every marker if it sits
--- in the middle of a run
-
--- | Check if a coordinate is one of five in a row.
---
--- prop> partOfRun (take 5 $ adjacent c d) c == True
-partOfRun :: [YCoord] -> YCoord -> Bool
-partOfRun ms start = any partOfRunD [NW, N, NE]
- where partOfRunD :: Direction -> Bool
- partOfRunD dir = length (runCoordsD ms start dir) == 5
-
--- | Return the coordinates of the markers making up a run.
-runCoords :: [YCoord] -> YCoord -> [YCoord]
-runCoords ms start = if null cs then [] else head cs
- where cs = filter ((== 5) . length) $ map (runCoordsD ms start) [NW, N, NE]
-
--- | Combine two lists by taking elements alternatingly. If one list is longer,
--- append the rest.
---
--- prop> zipAlternate [] l == l
--- prop> zipAlternate l [] == l
--- prop> zipAlternate l l == (l >>= (\x -> [x, x]))
-zipAlternate :: [a] -> [a] -> [a]
-zipAlternate [] ys = ys
-zipAlternate (x:xs) ys = x : zipAlternate ys xs
-
--- | Get adjacent coordinates in a given direction which could belong to a run.
---
--- prop> runCoordsD (take 7 $ adjacent c d) c d == (take 5 $ adjacent c d)
-runCoordsD :: [YCoord] -> YCoord -> Direction -> [YCoord]
-runCoordsD ms start dir = if start `elem` ms
- then take 5 $ zipAlternate right left
- else []
- where right = takeAvailable dir
- left = tail $ takeAvailable (opposite dir) -- use tail to avoid taking the start twice
- takeAvailable d = takeWhile (`elem` ms) $ adjacent start d
-
--- | Get the adjacent (including start) coordinates in a given direction.
-adjacent :: YCoord -> Direction -> [YCoord]
-adjacent start dir = iterate step start
- where step = add (vector dir)
-
--- | Get all coordinates connecting two points.
-coordLine :: YCoord -> YCoord -> [YCoord]
-coordLine p1 p2 = take (num - 1) . tail $ iterate (add step) p1
- where (!dx, !dy) = p2 `sub` p1
- !num = max (abs dx) (abs dy)
- !step = (dx `div` num, dy `div` num)
-
--- | Flip all markers between two given coordinates.
-flippedMarkers :: Board -> YCoord -> YCoord -> Board
-flippedMarkers b s e = foldl' flipMaybe b (coordLine s e)
- where flipMaybe b' c = case elementAt b' c of
- Nothing -> b'
- (Just (Marker B)) -> modifyElement b' c (Marker W)
- (Just (Marker W)) -> modifyElement b' c (Marker B)
- _ -> error "trying to flip something that is not a marker (invalid ring move?)"
-
--- | Check whether one player has won the game.
-terminalState :: GameState -> Bool
-terminalState gs = pointsB gs == pointsForWin || pointsW gs == pointsForWin
--- TODO: we need to support draws (if no moves are possible)
-
--- | Get new game state after 'interacting' at a certain coordinate. Returns
--- @Nothing@ if the action leads to an invalid turn. For details, see
--- documentation of the @TurnMode@ type.
-newGameState :: GameState -> YCoord -> Maybe GameState
--- TODO: the guards should be (?) unnecessary when calling this function
--- from 'gamestates'.. (for AI-only matches). unless the AI tries to cheat..
-newGameState gs cc =
- case turnMode gs of
- AddRing -> do
- guard (freeCoord board' cc)
- Just gs { activePlayer = nextPlayer
- , turnMode = if numRings < 9 then AddRing else AddMarker
- , board = addElement board' cc (Ring activePlayer')
- }
- where numRings = length (ringsB board') + length (ringsW board')
- AddMarker -> do
- guard (cc `elem` rings activePlayer' board')
- Just gs { turnMode = MoveRing cc
- , board = addElement removedRing cc (Marker activePlayer')
- }
- (MoveRing start) -> do
- guard (cc `elem` ringMoves board' start)
- Just gs { activePlayer = nextPlayer
- , turnMode = nextTurnMode
- , board = addElement flippedBoard cc (Ring activePlayer')
- }
- where nextTurnMode | hasRun flippedBoard activePlayer' = WaitRemoveRun activePlayer'
- | hasRun flippedBoard nextPlayer = RemoveRun activePlayer'
- | otherwise = AddMarker
- flippedBoard = flippedMarkers board' start cc
- (RemoveRun lastRingMove) -> do
- guard (partOfRun playerMarkers cc)
- Just gs { turnMode = RemoveRing lastRingMove
- , board = removedRun
- }
- (RemoveRing lastRingMove) -> do
- guard (cc `elem` rings activePlayer' board')
- Just gs { activePlayer = nextPlayer
- , turnMode = nextTurnMode
- , board = removedRing
- , pointsB = if activePlayer' == B then pointsB gs + 1 else pointsB gs
- , pointsW = if activePlayer' == W then pointsW gs + 1 else pointsW gs
- }
- where nextTurnMode | hasRun removedRing activePlayer'
- = WaitRemoveRun lastRingMove -- player has a second run
- | hasRun removedRing nextPlayer
- = RemoveRun lastRingMove -- opponent also has a run
- | otherwise
- = if lastRingMove == activePlayer'
- then AddMarker
- else WaitAddMarker
- (WaitRemoveRun lastRingMove) ->
- Just gs { activePlayer = nextPlayer
- , turnMode = RemoveRun lastRingMove
- }
- WaitAddMarker ->
- Just gs { activePlayer = nextPlayer
- , turnMode = AddMarker
- }
- where activePlayer' = activePlayer gs
- nextPlayer = next activePlayer'
- removedRing = removeElement board' cc
- removedRun = foldl' removeElement board' (runCoords playerMarkers cc)
- board' = board gs
- playerMarkers = markers activePlayer' board'
-
-initialGameState :: GameState
-initialGameState = GameState { activePlayer = B
- , turnMode = AddRing
- , board = emptyBoard
- , pointsW = 0
- , pointsB = 0
- }
-
--- Testing stuff
-
-testBoard :: Board
-testBoard = foldl' (\b (c, e) -> addElement b c e) emptyBoard
- [ ((3 - 6, 4 - 6), Ring B)
- , ((4 - 6, 9 - 6), Ring B)
- , ((7 - 6, 9 - 6), Ring B)
- , ((8 - 6, 9 - 6), Ring B)
- , ((7 - 6, 10 - 6), Ring B)
- , ((8 - 6, 7 - 6), Ring W)
- , ((6 - 6, 3 - 6), Ring W)
- , ((4 - 6, 8 - 6), Ring W)
- , ((4 - 6, 2 - 6), Ring W)
- , ((2 - 6, 5 - 6), Ring W)
- , ((6 - 6, 4 - 6), Marker W)
- , ((6 - 6, 5 - 6), Marker W)
- , ((6 - 6, 7 - 6), Marker W)
- , ((5 - 6, 5 - 6), Marker W)
- , ((4 - 6, 5 - 6), Marker W)
- , ((3 - 6, 5 - 6), Marker W)
- , ((6 - 6, 6 - 6), Marker B)]
-
-testGameState = GameState { activePlayer = B
- , turnMode = AddMarker
- , board = testBoard
- , pointsW = 0
- , pointsB = 0
- }
-
-testGameStateW = GameState { activePlayer = W
- , turnMode = AddMarker
- , board = testBoard
- , pointsW = 0
- , pointsB = 0
- }
-
diff --git a/src/ai/evaluator.rs b/src/ai/evaluator.rs
new file mode 100644
index 0000000..5a146ad
--- /dev/null
+++ b/src/ai/evaluator.rs
@@ -0,0 +1,51 @@
+use minimax::{Evaluation, Evaluator};
+
+use crate::{GameState, Move, Player, TurnMode};
+
+use super::game::Yinsh;
+
+pub trait Heuristic {
+ fn identifier(&self) -> String;
+
+ fn evaluate_for_player_a(&self, state: &GameState) -> Evaluation;
+}
+
+pub struct YinshEvaluator<'a, H: Heuristic> {
+ heuristic: &'a H,
+}
+
+impl<'a, H: Heuristic> YinshEvaluator<'a, H> {
+ pub fn new(heuristic: &'a H) -> Self {
+ Self { heuristic }
+ }
+}
+
+impl<'a, H: Heuristic> Evaluator for YinshEvaluator<'a, H> {
+ type G = Yinsh;
+
+ fn evaluate(&self, state: &GameState) -> Evaluation {
+ match state.turn_mode {
+ TurnMode::WaitForRingMovement(_)
+ | TurnMode::WaitForRunRemoval(_)
+ | TurnMode::WaitForRingRemoval(_)
+ | TurnMode::WaitForMarkerPlacement => {
+ // Look one move ahead if we are in a waiting state.
+ let mut state_copy = state.clone();
+ state_copy.perform_move(&Move::Wait);
+ return -self.evaluate(&state_copy);
+ }
+ TurnMode::RingPlacement
+ | TurnMode::MarkerPlacement
+ | TurnMode::RingMovement(_)
+ | TurnMode::RunRemoval(_)
+ | TurnMode::RingRemoval(_) => {}
+ }
+
+ let score = self.heuristic.evaluate_for_player_a(state);
+
+ match state.active_player {
+ Player::A => score,
+ Player::B => -score,
+ }
+ }
+}
diff --git a/src/ai/game.rs b/src/ai/game.rs
new file mode 100644
index 0000000..e89d475
--- /dev/null
+++ b/src/ai/game.rs
@@ -0,0 +1,67 @@
+use std::iter;
+
+use minimax::{Game, Winner};
+
+use crate::{GameState, Move, TurnMode};
+
+pub struct Yinsh;
+
+impl Game for Yinsh {
+ type S = GameState;
+
+ type M = Move;
+
+ fn generate_moves(state: &Self::S, moves: &mut Vec) {
+ moves.extend(possible_moves(state));
+ }
+
+ fn apply(state: &mut Self::S, m: Self::M) -> Option {
+ let mut new_state = state.clone(); // TODO: is this necessary?
+ new_state.perform_move(&m);
+ Some(new_state) // TODO: we can avoid cloning here by returning None and implementing undo
+ }
+
+ fn get_winner(state: &Self::S) -> Option {
+ match state.winner() {
+ Some(p) if p == state.active_player => Some(Winner::PlayerToMove),
+ Some(_) => Some(Winner::PlayerJustMoved),
+ None => None,
+ }
+ }
+}
+
+pub fn possible_moves<'a>(state: &'a GameState) -> Box + 'a> {
+ match state.turn_mode {
+ TurnMode::RingPlacement => Box::new(state.board.free_coords().map(Move::PlaceRing)),
+ TurnMode::MarkerPlacement => Box::new(
+ state
+ .board
+ .marker_moves(state.active_player)
+ .map(Move::PlaceMarker),
+ ),
+ TurnMode::RingMovement(start) => Box::new(
+ state
+ .board
+ .ring_moves(start)
+ .into_iter()
+ .map(move |end| Move::MoveRing(start, end)),
+ ),
+ TurnMode::RunRemoval(_) => Box::new(
+ state
+ .board
+ .run_coords(state.active_player)
+ .into_iter()
+ .map(Move::RemoveRun), // TODO: this produces too many moves
+ ),
+ TurnMode::RingRemoval(_) => Box::new(
+ state
+ .board
+ .ring_coords(state.active_player)
+ .map(Move::RemoveRing),
+ ),
+ TurnMode::WaitForRunRemoval(_)
+ | TurnMode::WaitForMarkerPlacement
+ | TurnMode::WaitForRingMovement(_)
+ | TurnMode::WaitForRingRemoval(_) => Box::new(iter::once(Move::Wait)),
+ }
+}
diff --git a/src/ai/heuristics.rs b/src/ai/heuristics.rs
new file mode 100644
index 0000000..dfcfbe1
--- /dev/null
+++ b/src/ai/heuristics.rs
@@ -0,0 +1,90 @@
+use minimax::Evaluation;
+
+use super::evaluator::Heuristic;
+
+use crate::{yinsh::GameState, Board, Coord, Player};
+
+#[derive(Debug, Clone, Copy, Default)]
+struct RingPositionStatistics {
+ controlled_markers_own: usize,
+ controlled_markers_opponent: usize,
+ accessible_fields: usize,
+}
+
+fn ring_position_statistics(board: &Board, player: Player) -> RingPositionStatistics {
+ let mut statistics = RingPositionStatistics::default();
+
+ for ring in board.ring_coords(player) {
+ for move_end in board.ring_moves(ring) {
+ statistics.accessible_fields += 1;
+
+ Coord::between(ring, move_end).iter().for_each(|coord| {
+ // TODO: We double-count here, but maybe that's not a problem (since it's good to control a marker with multiple rings?)
+ match board.element_color_at(*coord) {
+ Some(p) if p == player => statistics.controlled_markers_own += 1,
+ Some(_) => statistics.controlled_markers_opponent += 1,
+ None => {}
+ }
+ });
+ }
+ }
+
+ statistics
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct SimpleHeuristic {
+ pub f_points: Evaluation,
+ pub f_markers: Evaluation,
+ pub f_controlled_markers_own: Evaluation,
+ pub f_controlled_markers_opponent: Evaluation,
+ pub f_accessible_fields: Evaluation,
+}
+
+impl Default for SimpleHeuristic {
+ fn default() -> Self {
+ Self {
+ f_points: 10_000,
+ f_markers: 100,
+ f_controlled_markers_own: 5,
+ f_controlled_markers_opponent: 10,
+ f_accessible_fields: 1,
+ // f_controlled_markers_own: 3,
+ // f_controlled_markers_opponent: 10,
+ // f_accessible_fields: 1,
+ }
+ }
+}
+
+impl Heuristic for SimpleHeuristic {
+ fn evaluate_for_player_a(&self, state: &GameState) -> Evaluation {
+ type Score = Evaluation;
+
+ let score_points = (state.points_a as Score) - (state.points_b as Score);
+
+ let score_markers = (state.board.num_markers(Player::A) as Score)
+ - (state.board.num_markers(Player::B) as Score);
+
+ let rps_a = ring_position_statistics(&state.board, Player::A);
+ let rps_b = ring_position_statistics(&state.board, Player::B);
+
+ let score_rings = self.f_controlled_markers_own
+ * (Score::try_from(rps_a.controlled_markers_own).unwrap()
+ - Score::try_from(rps_b.controlled_markers_own).unwrap())
+ + self.f_controlled_markers_opponent
+ * (Score::try_from(rps_a.controlled_markers_opponent).unwrap()
+ - Score::try_from(rps_b.controlled_markers_opponent).unwrap())
+ + self.f_accessible_fields
+ * (Score::try_from(rps_a.accessible_fields).unwrap()
+ - Score::try_from(rps_b.accessible_fields).unwrap());
+
+ let score = self.f_points * score_points + self.f_markers * score_markers + score_rings;
+
+ score
+ }
+
+ fn identifier(&self) -> String {
+ format!("SimpleHeuristic {{ f_points: {}, f_markers: {}, f_controlled_markers_own: {}, f_controlled_markers_opponent: {}, f_accessible_fields: {} }}",
+ self.f_points, self.f_markers, self.f_controlled_markers_own, self.f_controlled_markers_opponent, self.f_accessible_fields)
+ }
+}
diff --git a/src/ai/mod.rs b/src/ai/mod.rs
new file mode 100644
index 0000000..c1cf5af
--- /dev/null
+++ b/src/ai/mod.rs
@@ -0,0 +1,76 @@
+mod evaluator;
+mod game;
+mod heuristics;
+
+pub use evaluator::Heuristic;
+pub use game::possible_moves;
+pub use heuristics::SimpleHeuristic;
+
+use evaluator::YinshEvaluator;
+use minimax::{Negamax, Strategy};
+
+use crate::yinsh::{GameState, Move, TurnMode};
+
+pub struct YinshAi {
+ heuristic: H,
+ search_depth: usize,
+}
+
+impl YinshAi {
+ pub fn new(heuristic: H, search_depth: usize) -> Self {
+ Self {
+ heuristic,
+ search_depth,
+ }
+ }
+}
+
+pub trait YinshAiPlayer: Sync {
+ fn identifier(&self) -> String;
+
+ fn search_depth(&self) -> usize;
+
+ fn choose_move(&self, state: &GameState) -> Move;
+}
+
+impl YinshAiPlayer for YinshAi {
+ fn identifier(&self) -> String {
+ self.heuristic.identifier()
+ }
+
+ fn search_depth(&self) -> usize {
+ self.search_depth
+ }
+
+ fn choose_move(&self, state: &GameState) -> Move {
+ // Early return if the only thing we can do is wait. Would be great
+ // if this could be handled by 'minimax' itself (if there is only one
+ // possible move in choose_move, return that immediately).
+ match state.turn_mode {
+ TurnMode::WaitForRunRemoval(_)
+ | TurnMode::WaitForRingMovement(_)
+ | TurnMode::WaitForRingRemoval(_)
+ | TurnMode::WaitForMarkerPlacement => {
+ return Move::Wait;
+ }
+ _ => {}
+ }
+
+ let depth: u8 = if matches!(state.turn_mode, TurnMode::RingPlacement) {
+ 3
+ } else {
+ self.search_depth.try_into().unwrap()
+ };
+
+ let mut strategy = Negamax::new(YinshEvaluator::new(&self.heuristic), depth);
+ let player_move = strategy.choose_move(&state).unwrap();
+
+ // dbg!(strategy.root_value());
+
+ player_move
+ }
+}
+
+pub fn get_ai_move(search_depth: usize, state: &GameState) -> Move {
+ YinshAi::new(SimpleHeuristic::default(), search_depth).choose_move(state)
+}
diff --git a/src/gui/ai.rs b/src/gui/ai.rs
new file mode 100644
index 0000000..ddc3c24
--- /dev/null
+++ b/src/gui/ai.rs
@@ -0,0 +1,76 @@
+use bevy::prelude::*;
+
+use bevy_async_task::{AsyncTaskRunner, AsyncTaskStatus};
+use yinsh::{GameState, Move, Player};
+
+use super::state_update::{PlayerMoveEvent, StateUpdateSet};
+
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct AiSet;
+
+#[derive(Resource)]
+pub struct AiPlayerStrength(pub usize);
+
+#[derive(Event)]
+pub enum AiComputationEvent {
+ Start(Player, GameState),
+
+ #[allow(unused)]
+ Cancel,
+}
+
+fn perform_ai_moves(
+ mut task_runner: AsyncTaskRunner>,
+ mut events: EventReader,
+ strength: Res,
+ mut player_move_events: EventWriter,
+) {
+ for event in events.read() {
+ match event {
+ AiComputationEvent::Start(player, ref game_state) => {
+ let player = *player;
+ let game_state = game_state.clone();
+ let search_depth = strength.0;
+ task_runner.start(async move {
+ // TODO! This is a hack to make sure the AI takes at least as long as
+ // the animation.
+ #[cfg(not(target_arch = "wasm32"))]
+ {
+ use super::graphics::ANIMATION_DURATION;
+ use yinsh::TurnMode;
+
+ if matches!(game_state.turn_mode, TurnMode::MarkerPlacement) {
+ std::thread::sleep(ANIMATION_DURATION);
+ }
+ }
+
+ Some((player, yinsh::get_ai_move(search_depth, &game_state)))
+ });
+ }
+ AiComputationEvent::Cancel => {
+ // Replace current computation with dummy task
+ task_runner.start(async move { None });
+ }
+ }
+ }
+
+ match task_runner.poll() {
+ AsyncTaskStatus::Idle | AsyncTaskStatus::Pending | AsyncTaskStatus::Finished(None) => {}
+ AsyncTaskStatus::Finished(Some((player, player_move))) => {
+ player_move_events.send(PlayerMoveEvent(player, player_move));
+ }
+ }
+}
+
+pub fn plugin(app: &mut App) {
+ app.insert_resource(AiPlayerStrength(if cfg!(debug_assertions) {
+ 9
+ } else {
+ 15
+ }))
+ .add_event::()
+ .add_systems(
+ Update,
+ (perform_ai_moves).in_set(AiSet).after(StateUpdateSet),
+ );
+}
diff --git a/src/gui/board.rs b/src/gui/board.rs
new file mode 100644
index 0000000..aba8924
--- /dev/null
+++ b/src/gui/board.rs
@@ -0,0 +1,12 @@
+use bevy::prelude::*;
+
+use yinsh::{Coord, Player};
+
+#[derive(Component)]
+pub struct BoardElement(pub Coord, pub Player);
+
+#[derive(Component)]
+pub struct Ring;
+
+#[derive(Component)]
+pub struct Marker;
diff --git a/src/gui/board_update_event.rs b/src/gui/board_update_event.rs
new file mode 100644
index 0000000..8dbb060
--- /dev/null
+++ b/src/gui/board_update_event.rs
@@ -0,0 +1,13 @@
+use bevy::prelude::Event;
+
+use yinsh::{Coord, Player};
+
+#[derive(Event)]
+pub enum BoardUpdateEvent {
+ AddRing(Coord, Player),
+ AddMarker(Coord, Player),
+ MoveRing(Coord, Coord),
+ RemoveRing(Coord),
+ RemoveRun(Vec),
+ FlipMarkers(Coord, Coord, Vec),
+}
diff --git a/src/gui/graphics.rs b/src/gui/graphics.rs
new file mode 100644
index 0000000..17a2c57
--- /dev/null
+++ b/src/gui/graphics.rs
@@ -0,0 +1,266 @@
+use std::time::Duration;
+
+use bevy::{
+ core_pipeline::bloom::BloomSettings,
+ prelude::*,
+ render::view::RenderLayers,
+ sprite::{MaterialMesh2dBundle, Mesh2dHandle},
+ window::PrimaryWindow,
+};
+
+use yinsh::{Coord, Player};
+
+use super::{
+ board::{BoardElement, Marker, Ring},
+ grid::draw_grid,
+ PLAYER_HUMAN,
+};
+
+pub const FOREGROUND_RENDER_LAYER: RenderLayers = RenderLayers::layer(2);
+pub const BACKGROUND_RENDER_LAYER: RenderLayers = RenderLayers::layer(1);
+
+pub const COLOR_GRID: Color = Color::hsl(0.0, 0.0, 0.2);
+
+pub const COLOR_BACKGROUND: Color = Color::hsl(0.0, 0.0, 0.05);
+
+pub const COLOR_RING_MOVEMENT_INDICATOR: Color = Color::hsla(0.0, 0.0, 1.5, 0.1);
+
+pub const COLOR_HUMAN_R: f32 = 255.;
+pub const COLOR_HUMAN_G: f32 = 226.;
+pub const COLOR_HUMAN_B: f32 = 55.;
+
+pub const COLOR_HUMAN_BLOOM: f32 = 1.5;
+
+pub const COLOR_HUMAN: Color = Color::srgba(
+ COLOR_HUMAN_BLOOM * COLOR_HUMAN_R / 255.,
+ COLOR_HUMAN_BLOOM * COLOR_HUMAN_G / 255.,
+ COLOR_HUMAN_BLOOM * COLOR_HUMAN_B / 255.,
+ 1.0,
+);
+pub const COLOR_HUMAN_HIGHLIGHTED: Color = Color::srgba(
+ 4.0 * COLOR_HUMAN_R / 255.,
+ 4.0 * COLOR_HUMAN_G / 255.,
+ 4.0 * COLOR_HUMAN_B / 255.,
+ 1.0,
+);
+pub const COLOR_HUMAN_TRANSPARENT: Color = Color::srgba(
+ COLOR_HUMAN_BLOOM * COLOR_HUMAN_R / 255.,
+ COLOR_HUMAN_BLOOM * COLOR_HUMAN_G / 255.,
+ COLOR_HUMAN_BLOOM * COLOR_HUMAN_B / 255.,
+ 0.2,
+);
+
+pub const COLOR_AI_R: f32 = 81.;
+pub const COLOR_AI_G: f32 = 151.;
+pub const COLOR_AI_B: f32 = 242.;
+
+pub const COLOR_AI_BLOOM: f32 = 1.3;
+
+pub const COLOR_AI: Color = Color::srgba(
+ COLOR_AI_BLOOM * COLOR_AI_R / 255.,
+ COLOR_AI_BLOOM * COLOR_AI_G / 255.,
+ COLOR_AI_BLOOM * COLOR_AI_B / 255.,
+ 1.0,
+);
+
+pub fn color_for_player(player: Player) -> Color {
+ if player == PLAYER_HUMAN {
+ COLOR_HUMAN
+ } else {
+ COLOR_AI
+ }
+}
+
+pub const ANIMATION_DURATION: Duration = Duration::from_millis(500);
+
+#[derive(Component)]
+pub struct MainCamera;
+
+#[derive(Resource, Debug, Clone, Copy)]
+pub struct ScaleFactor {
+ pub spacing: f32,
+ pub factor: f32,
+}
+
+impl ScaleFactor {
+ pub fn screen_point(&self, coord: Coord) -> Vec3 {
+ Vec3::new(
+ self.spacing * (0.5 * 3_f32.sqrt() * coord.x as f32),
+ self.spacing * (-coord.y as f32 + 0.5 * coord.x as f32),
+ 0.,
+ )
+ }
+}
+
+impl Default for ScaleFactor {
+ fn default() -> Self {
+ Self {
+ spacing: 80.0,
+ factor: 1.0,
+ }
+ }
+}
+
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct ScaleFactorSet;
+
+#[derive(Resource)]
+pub struct PlayerColors {
+ pub human: Handle,
+ pub human_highlighted: Handle,
+ pub human_transparent: Handle,
+ pub ai: Handle,
+ pub animated_markers: [Handle; 8],
+}
+
+pub fn ring_mesh(
+ meshes: &mut Assets,
+ color_material: Handle,
+ visibility: Visibility,
+) -> MaterialMesh2dBundle {
+ MaterialMesh2dBundle {
+ mesh: Mesh2dHandle(meshes.add(Annulus::new(20., 25.))),
+ material: color_material,
+ visibility,
+ ..default()
+ }
+}
+
+pub fn marker_mesh(
+ meshes: &mut Assets,
+ color_material: Handle,
+ visibility: Visibility,
+) -> MaterialMesh2dBundle {
+ MaterialMesh2dBundle {
+ mesh: Mesh2dHandle(meshes.add(Circle::new(16.))),
+ material: color_material,
+ visibility,
+ ..default()
+ }
+}
+
+pub fn spawn_ring(
+ commands: &mut Commands,
+ meshes: &mut Assets,
+ player_colors: &PlayerColors,
+ coord: Coord,
+ player: Player,
+) {
+ let color = if player == PLAYER_HUMAN {
+ player_colors.human.clone()
+ } else {
+ player_colors.ai.clone()
+ };
+
+ commands.spawn((
+ ring_mesh(meshes, color, Visibility::Visible),
+ BoardElement(coord, player),
+ Ring,
+ FOREGROUND_RENDER_LAYER,
+ ));
+}
+
+pub fn spawn_marker(
+ commands: &mut Commands,
+ meshes: &mut Assets,
+ player_colors: &PlayerColors,
+ coord: Coord,
+ player: Player,
+) {
+ let color = if player == PLAYER_HUMAN {
+ player_colors.human.clone()
+ } else {
+ player_colors.ai.clone()
+ };
+
+ commands.spawn((
+ marker_mesh(meshes, color, Visibility::Visible),
+ BoardElement(coord, player),
+ Marker,
+ FOREGROUND_RENDER_LAYER,
+ ));
+}
+
+fn setup_graphics(
+ mut commands: Commands,
+ mut config_store: ResMut,
+ mut materials: ResMut>,
+) {
+ commands.insert_resource(ClearColor(COLOR_BACKGROUND));
+
+ // Render layer 1 is for the grid
+ commands.spawn((
+ Camera2dBundle {
+ camera: Camera {
+ hdr: true,
+ order: 1,
+ ..default()
+ },
+ ..default()
+ },
+ BloomSettings::default(),
+ BACKGROUND_RENDER_LAYER,
+ ));
+
+ // Render layer 2 is for the board elements
+ commands.spawn((
+ Camera2dBundle {
+ camera: Camera {
+ hdr: true,
+ order: 2,
+ ..default()
+ },
+ ..default()
+ },
+ BloomSettings::default(),
+ FOREGROUND_RENDER_LAYER,
+ MainCamera,
+ ));
+
+ commands.insert_resource(PlayerColors {
+ human: materials.add(COLOR_HUMAN),
+ human_highlighted: materials.add(COLOR_HUMAN_HIGHLIGHTED),
+ human_transparent: materials.add(COLOR_HUMAN_TRANSPARENT),
+ ai: materials.add(COLOR_AI),
+ animated_markers: [
+ materials.add(COLOR_AI),
+ materials.add(COLOR_AI),
+ materials.add(COLOR_AI),
+ materials.add(COLOR_AI),
+ materials.add(COLOR_AI),
+ materials.add(COLOR_AI),
+ materials.add(COLOR_AI),
+ materials.add(COLOR_AI),
+ ],
+ });
+
+ let (config, _) = config_store.config_mut::();
+ config.render_layers = BACKGROUND_RENDER_LAYER;
+}
+
+pub fn set_scale_factor(
+ mut scale_factor: ResMut,
+ window: Query<&Window, With>,
+) {
+ const BASE_SPACING_AT_800_PIXELS: f32 = 80.0;
+
+ let window = window.single();
+ let height = (window.physical_height() as f32) / (window.scale_factor() as f32);
+ let width = (window.physical_width() as f32) / (window.scale_factor() as f32);
+ let factor = ((height.min(width)) / 800.0).min(1.5);
+ scale_factor.factor = factor;
+ scale_factor.spacing = BASE_SPACING_AT_800_PIXELS * factor;
+}
+
+pub fn plugin(app: &mut App) {
+ app.insert_resource(Msaa::Sample8)
+ .insert_resource(ScaleFactor::default())
+ .add_systems(PreStartup, (setup_graphics, set_scale_factor))
+ .add_systems(
+ Update,
+ (
+ set_scale_factor.in_set(ScaleFactorSet),
+ draw_grid.after(ScaleFactorSet),
+ ),
+ );
+}
diff --git a/src/gui/grid.rs b/src/gui/grid.rs
new file mode 100644
index 0000000..9273912
--- /dev/null
+++ b/src/gui/grid.rs
@@ -0,0 +1,54 @@
+use bevy::prelude::*;
+
+use yinsh::Coord;
+
+use super::graphics::{ScaleFactor, COLOR_GRID};
+
+pub fn draw_grid(mut gizmos: Gizmos, scale_factor: Res) {
+ let grid_line_color = COLOR_GRID;
+
+ // Draw lines parallel to y-axis
+ for x in -5i8..=5i8 {
+ let coords: Vec<_> = (-5..=5)
+ .map(|y| Coord { x, y })
+ .filter(|c| c.is_inside_board())
+ .collect();
+
+ let min_y = coords.iter().map(|c| c.y).min().unwrap();
+ let max_y = coords.iter().map(|c| c.y).max().unwrap();
+
+ let start = scale_factor.screen_point(Coord { x, y: min_y });
+ let end = scale_factor.screen_point(Coord { x, y: max_y });
+ gizmos.line(start, end, grid_line_color);
+ }
+
+ // Draw lines parallel to x-axis
+ for y in -5i8..=5i8 {
+ let coords: Vec<_> = (-5..=5)
+ .map(|x| Coord { x, y })
+ .filter(|c| c.is_inside_board())
+ .collect();
+
+ let min_x = coords.iter().map(|c| c.x).min().unwrap();
+ let max_x = coords.iter().map(|c| c.x).max().unwrap();
+
+ let start = scale_factor.screen_point(Coord { x: min_x, y });
+ let end = scale_factor.screen_point(Coord { x: max_x, y });
+ gizmos.line(start, end, grid_line_color);
+ }
+
+ // Draw lines parallel to y = x
+ for d in -5i8..=5i8 {
+ let coords: Vec<_> = (-5..=5)
+ .map(|x| Coord { x, y: x + d })
+ .filter(|c| c.is_inside_board())
+ .collect();
+
+ let min = coords.iter().map(|c| c.x).min().unwrap();
+ let max = coords.iter().map(|c| c.x).max().unwrap();
+
+ let start = scale_factor.screen_point(Coord { x: min, y: min + d });
+ let end = scale_factor.screen_point(Coord { x: max, y: max + d });
+ gizmos.line(start, end, grid_line_color);
+ }
+}
diff --git a/src/gui/history.rs b/src/gui/history.rs
new file mode 100644
index 0000000..bc10b5b
--- /dev/null
+++ b/src/gui/history.rs
@@ -0,0 +1,72 @@
+use bevy::prelude::*;
+use yinsh::{Player, TurnMode};
+
+use super::{
+ ai::AiComputationEvent,
+ board::BoardElement,
+ board_update_event::BoardUpdateEvent,
+ graphics::ScaleFactorSet,
+ interaction::CursorElement,
+ state_update::{GameState, StateUpdateSet},
+};
+
+pub fn save_and_load_game_state(
+ keyboard: Res>,
+ mut commands: Commands,
+ mut game_state: ResMut,
+ mut ai_computation_events: EventWriter,
+ mut board_update_events: EventWriter,
+ q_board_elements: Query, Without)>,
+) {
+ let filename = "gamestate.yml";
+
+ if keyboard.just_pressed(KeyCode::KeyS) {
+ println!("Saving game state to {}", filename);
+ if matches!(
+ game_state.turn_mode,
+ TurnMode::RingPlacement | TurnMode::MarkerPlacement
+ ) {
+ game_state.save_to(filename);
+ } else {
+ println!(
+ "Cannot save game state in turn mode {:?}",
+ game_state.turn_mode
+ );
+ }
+ } else if keyboard.just_pressed(KeyCode::KeyL) || keyboard.just_pressed(KeyCode::KeyR) {
+ println!("Loading game state from {}", filename);
+ *game_state.as_deref_mut() = yinsh::GameState::load_from(filename);
+
+ assert!(matches!(
+ game_state.turn_mode,
+ TurnMode::RingPlacement | TurnMode::MarkerPlacement
+ ));
+
+ ai_computation_events.send(AiComputationEvent::Cancel);
+
+ // Despawn all board elements
+ for entity in q_board_elements.iter() {
+ commands.entity(entity).despawn();
+ }
+
+ // Respawn board elements
+ for p in [Player::A, Player::B] {
+ for coord in game_state.board.ring_coords(p) {
+ board_update_events.send(BoardUpdateEvent::AddRing(coord, p));
+ }
+
+ for coord in game_state.board.marker_coords(p) {
+ board_update_events.send(BoardUpdateEvent::AddMarker(coord, p));
+ }
+ }
+ }
+}
+
+pub fn plugin(app: &mut App) {
+ app.add_systems(
+ Update,
+ save_and_load_game_state
+ .before(StateUpdateSet)
+ .after(ScaleFactorSet),
+ );
+}
diff --git a/src/gui/information_display.rs b/src/gui/information_display.rs
new file mode 100644
index 0000000..de63a39
--- /dev/null
+++ b/src/gui/information_display.rs
@@ -0,0 +1,66 @@
+use bevy::prelude::*;
+
+use yinsh::Player;
+
+use super::{
+ ai::AiPlayerStrength,
+ graphics::BACKGROUND_RENDER_LAYER,
+ interaction::CursorCoord,
+ state_update::{GameState, InteractionState},
+};
+
+#[derive(Component)]
+struct GameStateInformation;
+
+fn setup_information_display(mut commands: Commands) {
+ commands.spawn((
+ TextBundle::from_section(
+ "",
+ TextStyle {
+ font_size: 18.0,
+ color: Color::hsl(0., 0., 0.3),
+ ..default()
+ },
+ )
+ .with_style(Style {
+ position_type: PositionType::Absolute,
+ top: Val::Px(10.),
+ left: Val::Px(10.),
+ ..default()
+ }),
+ GameStateInformation,
+ BACKGROUND_RENDER_LAYER,
+ ));
+}
+
+fn update_information_display(
+ game_state: Res,
+ mut q_text: Query<&mut Text, With>,
+ cursor_coord: Res,
+ interaction_state: Res,
+ ai_player_strength: Res,
+) {
+ q_text.single_mut().sections[0].value =
+ format!(
+ "Score: {points_a}:{points_b}\nMode: {mode}\nAI strength: {strength} [weaker: J, stronger: K]\n{coord}",
+ points_a=game_state.points_a,
+ points_b=game_state.points_b,
+ mode=match *interaction_state {
+ InteractionState::RingPlacement(_) => "Place a ring on the board",
+ InteractionState::MarkerPlacement(_) => "Place a marker in one of your rings",
+ InteractionState::RingMovement(_, _) => "Move the selected ring",
+ InteractionState::RunRemoval { .. } => "Select a run of five markers to remove",
+ InteractionState::RingRemoval(_) => "Select one of your rings to remove it",
+ InteractionState::AutoMove | InteractionState::WaitForAI => "Floyd is thinking...",
+ InteractionState::Winner(Player::A) => "Game over. You win!",
+ InteractionState::Winner(Player::B) => "Game over. Floyd wins!",
+ },
+ strength=ai_player_strength.0,
+ coord=if let Some (coord) = cursor_coord.0 { format!("({x}, {y})", x=coord.x, y=coord.y) } else { "".to_string() },
+ );
+}
+
+pub fn plugin(app: &mut App) {
+ app.add_systems(Startup, setup_information_display)
+ .add_systems(Update, update_information_display.ambiguous_with_all());
+}
diff --git a/src/gui/interaction.rs b/src/gui/interaction.rs
new file mode 100644
index 0000000..2816a9b
--- /dev/null
+++ b/src/gui/interaction.rs
@@ -0,0 +1,443 @@
+use std::time::Duration;
+
+use bevy::prelude::*;
+
+use bevy::window::PrimaryWindow;
+
+use bevy_tweening::lens::ColorMaterialColorLens;
+use bevy_tweening::{lens::TransformPositionLens, Animator, EaseFunction, Tween, TweeningPlugin};
+use bevy_tweening::{AnimationSystem, AssetAnimator, Delay, EaseMethod};
+use yinsh::{all_coords, Coord, Move};
+
+use super::ai::AiSet;
+use super::board::{BoardElement, Marker, Ring};
+use super::board_update_event::BoardUpdateEvent;
+use super::graphics::{
+ color_for_player, marker_mesh, ring_mesh, spawn_marker, spawn_ring, MainCamera, PlayerColors,
+ ScaleFactor, ScaleFactorSet, ANIMATION_DURATION, FOREGROUND_RENDER_LAYER,
+};
+use super::state_update::{GameState, PlayerMoveEvent, StateUpdateSet};
+use super::PLAYER_HUMAN;
+use super::{graphics::COLOR_RING_MOVEMENT_INDICATOR, state_update::InteractionState};
+
+#[derive(Component)]
+pub struct CursorElement;
+
+#[derive(Resource)]
+pub struct CursorCoord(pub Option);
+
+fn setup_interaction_cursors(
+ mut commands: Commands,
+ mut meshes: ResMut>,
+ player_colors: Res,
+) {
+ commands.spawn((
+ ring_mesh(
+ &mut meshes,
+ player_colors.human_transparent.clone(),
+ Visibility::Hidden,
+ ),
+ BoardElement(Coord::new(0, 0), PLAYER_HUMAN),
+ Ring,
+ CursorElement,
+ FOREGROUND_RENDER_LAYER,
+ ));
+
+ commands.spawn((
+ marker_mesh(
+ &mut meshes,
+ player_colors.human_transparent.clone(),
+ Visibility::Hidden,
+ ),
+ BoardElement(Coord::new(0, 0), PLAYER_HUMAN),
+ Marker,
+ CursorElement,
+ FOREGROUND_RENDER_LAYER,
+ ));
+}
+
+fn draw_ring_move_indicators(
+ scale_factor: Res,
+ mut gizmos: Gizmos,
+ interaction_state: Res,
+) {
+ let indicator_color = COLOR_RING_MOVEMENT_INDICATOR;
+
+ if let InteractionState::RingMovement(_, ref possible_moves) = *interaction_state {
+ for coord in possible_moves {
+ let screen_pos = scale_factor.screen_point(*coord);
+ gizmos.circle(
+ screen_pos,
+ Dir3::Z,
+ scale_factor.spacing / 8.,
+ indicator_color,
+ );
+ }
+ }
+}
+
+fn update_board_elements(
+ mut board_update_events: EventReader,
+ mut commands: Commands,
+ scale_factor: Res,
+ mut meshes: ResMut>,
+ player_colors: Res,
+ mut q_rings: Query<
+ (Entity, &mut BoardElement),
+ (With, (Without, Without)),
+ >,
+ mut q_markers: Query<
+ (Entity, &mut BoardElement, &mut Handle),
+ (With, Without),
+ >,
+) {
+ for event in board_update_events.read() {
+ match *event {
+ BoardUpdateEvent::AddRing(coord, player) => {
+ spawn_ring(&mut commands, &mut meshes, &player_colors, coord, player);
+ }
+ BoardUpdateEvent::AddMarker(coord, player) => {
+ spawn_marker(&mut commands, &mut meshes, &player_colors, coord, player);
+ }
+ BoardUpdateEvent::MoveRing(old_coord, new_coord) => {
+ for (entity, mut ring) in q_rings.iter_mut() {
+ if ring.0 == old_coord {
+ let tween = Tween::new(
+ EaseFunction::QuadraticInOut,
+ ANIMATION_DURATION,
+ TransformPositionLens {
+ start: scale_factor.screen_point(old_coord),
+ end: scale_factor.screen_point(new_coord),
+ },
+ );
+
+ commands.entity(entity).insert(Animator::new(tween));
+
+ ring.0 = new_coord; // To make the change permanent
+
+ break;
+ }
+ }
+ }
+ BoardUpdateEvent::RemoveRun(ref run_coords) => {
+ for (entity, element, _) in q_markers.iter_mut() {
+ if run_coords.contains(&element.0) {
+ commands.entity(entity).despawn();
+ }
+ }
+ }
+ BoardUpdateEvent::RemoveRing(coord) => {
+ for (entity, element) in q_rings.iter_mut() {
+ if element.0 == coord {
+ commands.entity(entity).despawn();
+ break;
+ }
+ }
+ }
+ BoardUpdateEvent::FlipMarkers(start, end, ref marker_coords) => {
+ let mut i = 0;
+ let total_distance = (end - start).norm();
+
+ for (entity, mut element, mut color_material) in q_markers.iter_mut() {
+ if marker_coords.contains(&element.0) {
+ let distance_from_start = (element.0 - start).norm();
+
+ let delay =
+ ANIMATION_DURATION.mul_f32(distance_from_start / total_distance);
+
+ let tween = Tween::new(
+ EaseMethod::Linear,
+ Duration::from_secs_f32(1e-9),
+ ColorMaterialColorLens {
+ start: color_for_player(element.1),
+ end: color_for_player(element.1),
+ },
+ )
+ .then(Delay::new(delay).then(Tween::new(
+ EaseMethod::Linear,
+ ANIMATION_DURATION.div_f32(5.0),
+ ColorMaterialColorLens {
+ start: color_for_player(element.1),
+ end: color_for_player(element.1.next()),
+ },
+ )));
+
+ *color_material = player_colors.animated_markers[i].clone();
+ commands.entity(entity).insert(AssetAnimator::new(tween));
+
+ element.1.flip(); // To make the change permanent
+
+ i += 1;
+ }
+ }
+ }
+ }
+ }
+}
+
+fn clear_animators(mut q: Query<(Entity, &Animator)>, mut commands: Commands) {
+ for (entity, animator) in q.iter_mut() {
+ if animator.tweenable().times_completed() == 1 {
+ commands.entity(entity).remove::>();
+ }
+ }
+}
+
+fn clear_asset_animators(
+ mut q: Query<(Entity, &AssetAnimator)>,
+ mut commands: Commands,
+) {
+ for (entity, animator) in q.iter_mut() {
+ if animator.tweenable().times_completed() == 1 {
+ commands
+ .entity(entity)
+ .remove::>();
+ }
+ }
+}
+
+fn move_board_elements(
+ scale_factor: Res,
+ mut query: Query<(&BoardElement, &mut Transform), Without>>,
+) {
+ for (BoardElement(coord, _), mut transform) in query.iter_mut() {
+ transform.translation = scale_factor.screen_point(*coord);
+ }
+}
+
+fn scale_board_elements(
+ scale_factor: Res,
+ mut query: Query<&mut Transform, With>,
+) {
+ for mut transform in query.iter_mut() {
+ transform.scale = Vec3::splat(scale_factor.factor);
+ }
+}
+
+fn colorize_board_elements(
+ mut query: Query<(
+ &BoardElement,
+ &mut Handle,
+ Option<&Ring>,
+ Option<&Marker>,
+ Option<&CursorElement>,
+ Option<&AssetAnimator>,
+ )>,
+ interaction_state: Res,
+ player_colors: Res,
+ mouse_cursor_coord: Res,
+) {
+ for (BoardElement(coord, player), mut color_material, ring, marker, cursor_element, animated) in
+ query.iter_mut()
+ {
+ if animated.is_some() {
+ continue;
+ }
+
+ *color_material = if player == &PLAYER_HUMAN {
+ if cursor_element.is_some() {
+ player_colors.human_transparent.clone()
+ } else {
+ match *interaction_state {
+ InteractionState::RingMovement(start, _) => {
+ if *coord == start && ring.is_some() {
+ player_colors.human_highlighted.clone()
+ } else {
+ player_colors.human.clone()
+ }
+ }
+ InteractionState::RunRemoval {
+ ref all_run_coords,
+ ref run_from_seed,
+ } => match mouse_cursor_coord.0 {
+ Some(cursor_coord) if all_run_coords.contains(&cursor_coord) => {
+ let run_from_cursor = run_from_seed.get(&cursor_coord).unwrap();
+ if run_from_cursor.contains(coord) {
+ player_colors.human_highlighted.clone()
+ } else {
+ player_colors.human.clone()
+ }
+ }
+ _ => {
+ if marker.is_some() && all_run_coords.contains(coord) {
+ player_colors.human_highlighted.clone()
+ } else {
+ player_colors.human.clone()
+ }
+ }
+ },
+ _ => player_colors.human.clone(),
+ }
+ }
+ } else {
+ player_colors.ai.clone()
+ };
+ }
+}
+
+fn grid_cursor_system(
+ scale_factor: Res,
+ mut q_window: Query<&mut Window, With>,
+ q_camera: Query<(&Camera, &GlobalTransform), With>,
+ mut cursor_ring: Query<
+ (&mut BoardElement, &mut Visibility),
+ (With, Without, With),
+ >,
+ mut cursor_marker: Query<
+ (&mut BoardElement, &mut Visibility),
+ (With, Without, With),
+ >,
+ interaction_state: Res,
+ mut mouse_cursor_coord: ResMut,
+) {
+ let Ok(mut window) = q_window.get_single_mut() else {
+ return;
+ };
+
+ window.cursor.icon = match *interaction_state {
+ InteractionState::WaitForAI => CursorIcon::Progress,
+ InteractionState::Winner(_) => CursorIcon::Default,
+ _ => CursorIcon::Pointer,
+ };
+
+ if let Some(cursor_position) = window.cursor_position() {
+ let (camera, camera_transform) = q_camera.single();
+
+ if let Some(cursor_position) = camera
+ .viewport_to_world(camera_transform, cursor_position)
+ .map(|ray| ray.origin.truncate())
+ {
+ let cursor_coord = yinsh::all_coords()
+ .into_iter()
+ .min_by_key(|c| {
+ let screen_pos = scale_factor.screen_point(*c);
+ let cursor_pos = Vec3::new(cursor_position.x, cursor_position.y, 0.0);
+ let diff = screen_pos - cursor_pos;
+ diff.length_squared() as i32
+ })
+ .unwrap();
+
+ let (mut cursor_ring_coord, mut cursor_ring_visibility) = cursor_ring.single_mut();
+ *cursor_ring_visibility = Visibility::Hidden;
+
+ let (mut cursor_marker_coord, mut cursor_marker_visibility) =
+ cursor_marker.single_mut();
+ *cursor_marker_visibility = Visibility::Hidden;
+
+ match *interaction_state {
+ InteractionState::RingPlacement(ref free_coords) => {
+ if free_coords.contains(&cursor_coord) {
+ *cursor_ring_visibility = Visibility::Visible;
+ cursor_ring_coord.0 = cursor_coord;
+ }
+ }
+ InteractionState::MarkerPlacement(ref ring_coords) => {
+ if ring_coords.contains(&cursor_coord) {
+ *cursor_marker_visibility = Visibility::Visible;
+ cursor_marker_coord.0 = cursor_coord;
+ }
+ }
+ InteractionState::RingMovement(_, ref possible_ring_moves) => {
+ if possible_ring_moves.contains(&cursor_coord) {
+ *cursor_ring_visibility = Visibility::Visible;
+ cursor_ring_coord.0 = cursor_coord;
+ }
+ }
+ InteractionState::RunRemoval { .. } => {}
+ InteractionState::RingRemoval(_) => {}
+ InteractionState::AutoMove => {}
+ InteractionState::WaitForAI => {}
+ InteractionState::Winner(_) => {}
+ }
+
+ mouse_cursor_coord.0 = Some(cursor_coord);
+ }
+ }
+}
+
+fn mouse_interaction_system(
+ buttons: Res>,
+ interaction_state: Res,
+ cursor_coord: Res,
+ mut player_move_events: EventWriter,
+) {
+ if matches!(*interaction_state, InteractionState::AutoMove) {
+ // TODO
+ player_move_events.send(PlayerMoveEvent(PLAYER_HUMAN, Move::Wait));
+ }
+
+ if let Some(cursor_coord) = cursor_coord.0 {
+ if buttons.just_pressed(MouseButton::Left) {
+ match *interaction_state {
+ InteractionState::RingPlacement(ref free_coords) => {
+ if free_coords.contains(&cursor_coord) {
+ player_move_events
+ .send(PlayerMoveEvent(PLAYER_HUMAN, Move::PlaceRing(cursor_coord)));
+ }
+ }
+ InteractionState::MarkerPlacement(ref ring_coords) => {
+ if ring_coords.contains(&cursor_coord) {
+ player_move_events.send(PlayerMoveEvent(
+ PLAYER_HUMAN,
+ Move::PlaceMarker(cursor_coord),
+ ));
+ }
+ }
+ InteractionState::RingMovement(start, ref possible_ring_moves) => {
+ if possible_ring_moves.contains(&cursor_coord) {
+ player_move_events.send(PlayerMoveEvent(
+ PLAYER_HUMAN,
+ Move::MoveRing(start, cursor_coord),
+ ));
+ }
+ }
+ InteractionState::WaitForAI => {}
+ InteractionState::RunRemoval {
+ ref all_run_coords, ..
+ } => {
+ if all_run_coords.contains(&cursor_coord) {
+ player_move_events
+ .send(PlayerMoveEvent(PLAYER_HUMAN, Move::RemoveRun(cursor_coord)));
+ }
+ }
+ InteractionState::RingRemoval(ref ring_coords) => {
+ if ring_coords.contains(&cursor_coord) {
+ player_move_events.send(PlayerMoveEvent(
+ PLAYER_HUMAN,
+ Move::RemoveRing(cursor_coord),
+ ));
+ }
+ }
+ InteractionState::AutoMove => {}
+ InteractionState::Winner(_) => {}
+ }
+ }
+ }
+}
+
+pub fn plugin(app: &mut App) {
+ app.add_plugins(TweeningPlugin)
+ .insert_resource(InteractionState::RingPlacement(all_coords()))
+ .insert_resource(CursorCoord(None))
+ .insert_resource(GameState::initial())
+ .add_systems(Startup, setup_interaction_cursors)
+ .add_systems(
+ Update,
+ (
+ draw_ring_move_indicators,
+ (
+ clear_animators,
+ clear_asset_animators,
+ grid_cursor_system,
+ update_board_elements,
+ move_board_elements.ambiguous_with(AnimationSystem::AnimationUpdate),
+ scale_board_elements.ambiguous_with(AnimationSystem::AnimationUpdate),
+ colorize_board_elements.ambiguous_with(AnimationSystem::AnimationUpdate),
+ mouse_interaction_system.ambiguous_with(AiSet),
+ )
+ .chain(),
+ )
+ .after(StateUpdateSet)
+ .after(ScaleFactorSet),
+ );
+}
diff --git a/src/gui/keyboard_control.rs b/src/gui/keyboard_control.rs
new file mode 100644
index 0000000..e02067a
--- /dev/null
+++ b/src/gui/keyboard_control.rs
@@ -0,0 +1,30 @@
+use bevy::prelude::*;
+
+use super::{
+ ai::{AiComputationEvent, AiPlayerStrength, AiSet},
+ state_update::GameState,
+ PLAYER_HUMAN,
+};
+
+fn keyboard_control(
+ keyboard: Res>,
+ mut exit: EventWriter,
+ mut ai_player_strength: ResMut,
+ mut ai_computation_events: EventWriter,
+ game_state: Res,
+) {
+ if keyboard.just_pressed(KeyCode::Escape) || keyboard.just_pressed(KeyCode::KeyQ) {
+ exit.send(AppExit::Success);
+ } else if keyboard.just_pressed(KeyCode::KeyK) {
+ ai_player_strength.0 = ai_player_strength.0 + 1;
+ } else if keyboard.just_pressed(KeyCode::KeyJ) {
+ ai_player_strength.0 = (ai_player_strength.0 - 1).max(1);
+ } else if keyboard.just_pressed(KeyCode::KeyA) {
+ ai_computation_events.send(AiComputationEvent::Start(PLAYER_HUMAN, game_state.clone()));
+ // TODO: remove this feature, or implement it properly
+ }
+}
+
+pub fn plugin(app: &mut App) {
+ app.add_systems(Update, keyboard_control.ambiguous_with(AiSet));
+}
diff --git a/src/gui/mod.rs b/src/gui/mod.rs
new file mode 100644
index 0000000..abb1b59
--- /dev/null
+++ b/src/gui/mod.rs
@@ -0,0 +1,17 @@
+use yinsh::Player;
+
+pub mod ai;
+pub mod board;
+pub mod board_update_event;
+pub mod graphics;
+pub mod grid;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod history;
+pub mod information_display;
+pub mod interaction;
+pub mod keyboard_control;
+pub mod resources;
+pub mod state_update;
+
+pub const PLAYER_HUMAN: Player = Player::A;
+pub const PLAYER_AI: Player = Player::B;
diff --git a/src/gui/resources.rs b/src/gui/resources.rs
new file mode 100644
index 0000000..e69de29
diff --git a/src/gui/state_update.rs b/src/gui/state_update.rs
new file mode 100644
index 0000000..380df0c
--- /dev/null
+++ b/src/gui/state_update.rs
@@ -0,0 +1,150 @@
+use std::ops::{Deref, DerefMut};
+
+use yinsh::{Coord, Move, Player, TurnMode};
+
+use bevy::{prelude::*, utils::HashMap};
+
+use crate::gui::PLAYER_HUMAN;
+
+use super::{ai::AiComputationEvent, board_update_event::BoardUpdateEvent, PLAYER_AI};
+
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct StateUpdateSet;
+
+#[derive(Resource)]
+pub struct GameState(yinsh::GameState);
+
+impl Deref for GameState {
+ type Target = yinsh::GameState;
+
+ fn deref(&self) -> &Self::Target {
+ &self.0
+ }
+}
+
+impl DerefMut for GameState {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
+ }
+}
+
+impl GameState {
+ pub fn initial() -> Self {
+ Self(yinsh::GameState::initial())
+ }
+}
+
+#[derive(Resource)]
+pub enum InteractionState {
+ RingPlacement(Vec),
+ MarkerPlacement(Vec),
+ RingMovement(Coord, Vec),
+ RunRemoval {
+ all_run_coords: Vec,
+ run_from_seed: HashMap>,
+ },
+ RingRemoval(Vec),
+ AutoMove,
+ WaitForAI,
+ Winner(Player),
+}
+
+impl InteractionState {
+ pub fn from_game_state(game_state: &yinsh::GameState) -> Self {
+ if let Some(winner) = game_state.winner() {
+ Self::Winner(winner)
+ } else if game_state.active_player == PLAYER_AI {
+ Self::WaitForAI
+ } else {
+ match game_state.turn_mode {
+ TurnMode::RingPlacement => {
+ Self::RingPlacement(game_state.board.free_coords().collect())
+ }
+ TurnMode::MarkerPlacement => {
+ Self::MarkerPlacement(game_state.board.marker_moves(PLAYER_HUMAN).collect())
+ }
+ TurnMode::RingMovement(start) => {
+ Self::RingMovement(start, game_state.board.ring_moves(start))
+ }
+ TurnMode::RunRemoval(_) => {
+ let all_run_coords = game_state.board.run_coords(PLAYER_HUMAN);
+ Self::RunRemoval {
+ all_run_coords: all_run_coords.clone(),
+ run_from_seed: all_run_coords
+ .into_iter()
+ .map(|seed| (seed, game_state.board.run_coords_from(seed).unwrap()))
+ .collect(),
+ }
+ }
+ TurnMode::RingRemoval(_) => {
+ Self::RingRemoval(game_state.board.ring_coords(PLAYER_HUMAN).collect())
+ }
+ TurnMode::WaitForRunRemoval(_)
+ | TurnMode::WaitForMarkerPlacement
+ | TurnMode::WaitForRingMovement(_)
+ | TurnMode::WaitForRingRemoval(_) => Self::AutoMove,
+ }
+ }
+ }
+}
+
+#[derive(Event)]
+pub struct PlayerMoveEvent(pub Player, pub Move);
+
+fn state_update(
+ mut player_move_events: EventReader,
+ mut game_state: ResMut,
+ mut interaction_state: ResMut,
+ mut ai_computation_events: EventWriter,
+ mut board_update_events: EventWriter,
+) {
+ for PlayerMoveEvent(player, player_move) in player_move_events.read() {
+ assert!(player == &game_state.active_player);
+
+ match player_move {
+ Move::PlaceRing(coord) => {
+ board_update_events.send(BoardUpdateEvent::AddRing(*coord, *player));
+ }
+ Move::PlaceMarker(coord) => {
+ board_update_events.send(BoardUpdateEvent::AddMarker(*coord, *player));
+ }
+ Move::MoveRing(start, end) => {
+ board_update_events.send(BoardUpdateEvent::MoveRing(*start, *end));
+ board_update_events.send(BoardUpdateEvent::FlipMarkers(
+ *start,
+ *end,
+ Coord::between(*start, *end)
+ .into_iter()
+ .filter(|&coord| game_state.board.has_marker_at(coord))
+ .collect(),
+ ));
+ }
+ Move::RemoveRun(seed) => {
+ board_update_events.send(BoardUpdateEvent::RemoveRun(
+ game_state.board.run_coords_from(*seed).unwrap(),
+ ));
+ }
+ Move::RemoveRing(coord) => {
+ board_update_events.send(BoardUpdateEvent::RemoveRing(*coord));
+ }
+ Move::Wait => {}
+ }
+
+ game_state.perform_move(player_move);
+
+ if game_state.active_player == PLAYER_AI && game_state.winner().is_none() {
+ ai_computation_events.send(AiComputationEvent::Start(PLAYER_AI, game_state.clone()));
+ }
+ }
+
+ *interaction_state = InteractionState::from_game_state(&game_state);
+}
+
+pub fn plugin(app: &mut App) {
+ let initial_game_state = GameState::initial();
+ app.insert_resource(InteractionState::from_game_state(&initial_game_state))
+ .insert_resource(initial_game_state)
+ .add_event::()
+ .add_event::()
+ .add_systems(Update, state_update.in_set(StateUpdateSet));
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..c51aca1
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,5 @@
+mod ai;
+mod yinsh;
+
+pub use ai::{get_ai_move, possible_moves, Heuristic, SimpleHeuristic, YinshAi, YinshAiPlayer};
+pub use yinsh::*;
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..cf14e81
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,38 @@
+mod gui;
+
+use bevy::{
+ prelude::*,
+ window::{WindowMode, WindowResolution},
+};
+
+fn main() {
+ App::new()
+ .add_plugins((
+ DefaultPlugins.set(WindowPlugin {
+ primary_window: Some(Window {
+ title: "Yinsh".into(),
+ name: Some("yinsh".into()),
+ resolution: WindowResolution::new(760., 760.),
+ mode: WindowMode::Windowed,
+ canvas: Some("#yinsh-canvas".into()),
+ ..default()
+ }),
+ ..default()
+ }),
+ gui::state_update::plugin,
+ gui::ai::plugin,
+ gui::graphics::plugin,
+ gui::interaction::plugin,
+ gui::information_display::plugin,
+ gui::keyboard_control::plugin,
+ #[cfg(not(target_arch = "wasm32"))]
+ gui::history::plugin,
+ ))
+ // .edit_schedule(Update, |schedule| {
+ // schedule.set_build_settings(ScheduleBuildSettings {
+ // ambiguity_detection: LogLevel::Warn,
+ // ..default()
+ // });
+ // })
+ .run();
+}
diff --git a/src/yinsh/board.rs b/src/yinsh/board.rs
new file mode 100644
index 0000000..86395b6
--- /dev/null
+++ b/src/yinsh/board.rs
@@ -0,0 +1,511 @@
+use std::iter;
+
+use itertools::Itertools;
+use serde::{Deserialize, Serialize};
+
+use crate::yinsh::core::AXES;
+
+use super::{core::all_coords, Coord, Player, DIRECTIONS};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Element {
+ Ring(Player),
+ Marker(Player),
+ Empty,
+}
+
+impl Element {
+ pub fn is_marker(&self) -> bool {
+ matches!(self, Element::Marker(_))
+ }
+
+ fn is_ring(&self) -> bool {
+ matches!(self, Element::Ring(_))
+ }
+
+ fn is_empty(&self) -> bool {
+ matches!(self, Element::Empty)
+ }
+
+ fn player(&self) -> Option {
+ match self {
+ Element::Ring(player) => Some(*player),
+ Element::Marker(player) => Some(*player),
+ Element::Empty => None,
+ }
+ }
+}
+
+impl Default for Element {
+ fn default() -> Self {
+ Element::Empty
+ }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct CheckRunResult {
+ a_has_run: bool,
+ b_has_run: bool,
+}
+
+impl CheckRunResult {
+ fn or(&mut self, other: &Self) {
+ self.a_has_run |= other.a_has_run;
+ self.b_has_run |= other.b_has_run;
+ }
+
+ pub fn has_run(&self, player: Player) -> bool {
+ match player {
+ Player::A => self.a_has_run,
+ Player::B => self.b_has_run,
+ }
+ }
+
+ pub fn no_runs(&self) -> bool {
+ !self.a_has_run && !self.b_has_run
+ }
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Board {
+ #[serde(skip)]
+ board: [[Element; 11]; 11],
+
+ rings_a: Vec,
+ rings_b: Vec,
+ markers_a: Vec,
+ markers_b: Vec,
+}
+
+impl Board {
+ pub fn empty() -> Self {
+ Self::default()
+ }
+
+ /// Returns the element at a certain position or None if the coordinate is free (or invalid).
+ /// Does not check for validity.
+ fn element_at_unchecked(&self, coord: Coord) -> Element {
+ self.board[(coord.y + 5) as usize][(coord.x + 5) as usize]
+ }
+
+ /// Returns the element at a certain position or None if the coordinate is free (or invalid)
+ fn element_at(&self, coord: Coord) -> Element {
+ if coord.is_inside_board() {
+ self.board[(coord.y + 5) as usize][(coord.x + 5) as usize]
+ } else {
+ Element::Empty
+ }
+ }
+
+ /// Returns the element at a certain position or None if the coordinate is free. Does not
+ /// check for validity.
+ fn element_at_mut_unchecked(&mut self, coord: Coord) -> &mut Element {
+ &mut self.board[(coord.y + 5) as usize][(coord.x + 5) as usize]
+ }
+
+ fn insert_board_element_at(&mut self, coord: Coord, element: Element) {
+ debug_assert!(coord.is_inside_board());
+
+ *self.element_at_mut_unchecked(coord) = element;
+ }
+
+ fn remove_board_element_at(&mut self, coord: &Coord) {
+ debug_assert!(coord.is_inside_board());
+
+ *self.element_at_mut_unchecked(*coord) = Element::Empty;
+ }
+
+ /// Returns true if a certain point on the board is free. Does not check for validity.
+ pub fn is_free(&self, coord: Coord) -> bool {
+ self.element_at(coord).is_empty()
+ }
+
+ /// Returns true if the element at the given point is a ring of any color.
+ pub fn has_ring_at(&self, coord: Coord, player: Player) -> bool {
+ self.check_invariants();
+
+ self.element_at(coord) == Element::Ring(player)
+ }
+
+ /// Returns true if the element at the given point is a marker of any color.
+ pub fn has_marker_at(&self, coord: Coord) -> bool {
+ self.check_invariants();
+
+ self.element_at(coord).is_marker()
+ }
+
+ /// Returns the color/player of the board element at the given coordinate.
+ pub fn element_color_at(&self, coord: Coord) -> Option {
+ self.check_invariants();
+
+ self.element_at(coord).player()
+ }
+
+ pub fn add_ring(&mut self, player: Player, coord: Coord) {
+ self.check_invariants();
+ debug_assert!(self.is_free(coord));
+
+ self.insert_board_element_at(coord, Element::Ring(player));
+ match player {
+ Player::A => self.rings_a.push(coord),
+ Player::B => self.rings_b.push(coord),
+ }
+ }
+
+ pub fn remove_ring(&mut self, coord: Coord) {
+ self.check_invariants();
+ debug_assert!(self.element_at(coord).is_ring());
+
+ self.remove_board_element_at(&coord);
+ self.rings_a.retain(|&x| x != coord);
+ self.rings_b.retain(|&x| x != coord);
+ }
+
+ pub fn num_rings(&self) -> usize {
+ self.check_invariants();
+
+ self.rings_a.len() + self.rings_b.len()
+ }
+
+ pub fn add_marker(&mut self, player: Player, coord: Coord) {
+ self.check_invariants();
+ debug_assert!(self.is_free(coord));
+
+ self.insert_board_element_at(coord, Element::Marker(player));
+ match player {
+ Player::A => self.markers_a.push(coord),
+ Player::B => self.markers_b.push(coord),
+ }
+ }
+
+ pub fn remove_marker(&mut self, coord: Coord) {
+ self.check_invariants();
+ debug_assert!(self.has_marker_at(coord));
+
+ self.remove_board_element_at(&coord);
+ self.markers_a.retain(|&x| x != coord);
+ self.markers_b.retain(|&x| x != coord);
+ }
+
+ pub fn num_markers(&self, player: Player) -> usize {
+ self.check_invariants();
+
+ match player {
+ Player::A => self.markers_a.len(),
+ Player::B => self.markers_b.len(),
+ }
+ }
+
+ pub fn free_coords(&self) -> impl Iterator + '_ {
+ self.check_invariants();
+
+ all_coords()
+ .into_iter()
+ .filter(|&coord| self.is_free(coord))
+ }
+
+ pub fn ring_coords(&self, player: Player) -> impl Iterator + '_ {
+ self.check_invariants();
+
+ match player {
+ Player::A => self.rings_a.iter().copied(),
+ Player::B => self.rings_b.iter().copied(),
+ }
+ }
+
+ pub fn marker_coords(&self, player: Player) -> impl Iterator + '_ {
+ self.check_invariants();
+
+ match player {
+ Player::A => self.markers_a.iter().copied(),
+ Player::B => self.markers_b.iter().copied(),
+ }
+ }
+
+ pub fn ring_moves(&self, start: Coord) -> Vec {
+ self.check_invariants();
+
+ let mut moves = Vec::new();
+
+ for d in DIRECTIONS {
+ let mut current = start + d.direction();
+
+ // Skip over arbitrarily many free spaces
+ while current.is_inside_board() && self.is_free(current) {
+ moves.push(current);
+ current = current + d.direction();
+ }
+
+ // Skip over arbitrarily many markers, but stop immediately after
+ while self.has_marker_at(current) && current.is_inside_board() {
+ current = current + d.direction();
+ }
+
+ if current.is_inside_board() && self.is_free(current) {
+ moves.push(current);
+ }
+ }
+
+ moves
+ }
+
+ pub fn is_valid_ring_move(&self, start: Coord, end: Coord) -> bool {
+ self.check_invariants();
+
+ self.ring_moves(start).contains(&end)
+ }
+
+ fn can_place_marker_at(&self, coord: Coord, player: Player) -> bool {
+ self.check_invariants();
+
+ // TODO: is this logic correct?
+ (self.element_at(coord) == Element::Ring(player)) && !self.ring_moves(coord).is_empty()
+ }
+
+ pub fn marker_moves(&self, player: Player) -> impl Iterator + '_ {
+ self.check_invariants();
+
+ self.ring_coords(player)
+ .filter(move |c| self.can_place_marker_at(*c, player))
+ }
+
+ pub fn flip_markers_between(&mut self, start: Coord, end: Coord) {
+ self.check_invariants();
+
+ debug_assert!(start.is_inside_board());
+ debug_assert!(end.is_inside_board());
+
+ for coord in Coord::between(start, end) {
+ if let Element::Marker(player) = self.element_at_mut_unchecked(coord) {
+ player.flip();
+
+ if *player == Player::A {
+ self.markers_a.push(coord);
+ self.markers_b.retain(|&x| x != coord);
+ } else {
+ self.markers_b.push(coord);
+ self.markers_a.retain(|&x| x != coord);
+ }
+ }
+ }
+ }
+
+ /// Returns the coordinates of a run (if one exists), starting at the given seed.
+ pub fn run_coords_from(&self, start: Coord) -> Option> {
+ self.check_invariants();
+
+ let seed = self.element_at(start);
+ let player = seed.player().unwrap();
+
+ debug_assert!(seed.is_marker());
+
+ for a in AXES {
+ let markers_positive = (1i8..=4i8)
+ .map(|i| start + a.direction() * i)
+ .take_while(|c| self.element_at(*c) == Element::Marker(player));
+ let markers_negative = (1i8..=4i8)
+ .map(|i| start - a.direction() * i)
+ .take_while(|c| self.element_at(*c) == Element::Marker(player));
+
+ let run_coords: Vec<_> = iter::once(start)
+ .chain(markers_positive.interleave(markers_negative))
+ .take(5)
+ .collect();
+
+ if run_coords.len() == 5 {
+ return Some(run_coords);
+ }
+ }
+
+ None
+ }
+
+ fn check_run_along_line(&self, start: Coord, direction: Coord, steps: i8) -> CheckRunResult {
+ let mut num_consecutive = 0;
+ let mut player = None;
+
+ let mut a_has_run = false;
+ let mut b_has_run = false;
+
+ for n in 0..steps {
+ let coord = start + direction * n;
+
+ match self.element_at_unchecked(coord) {
+ Element::Marker(p) => {
+ if Some(p) == player {
+ num_consecutive += 1;
+
+ if num_consecutive == 5 {
+ if p == Player::A {
+ a_has_run = true;
+ } else {
+ b_has_run = true;
+ }
+ }
+ } else {
+ player = Some(p);
+ num_consecutive = 1;
+ }
+ }
+ _ => {
+ player = None;
+ num_consecutive = 0;
+ }
+ }
+ }
+
+ CheckRunResult {
+ a_has_run,
+ b_has_run,
+ }
+ }
+
+ /// Returns true if the player has a run
+ pub fn check_run(&self) -> CheckRunResult {
+ self.check_invariants();
+
+ let mut result = CheckRunResult {
+ a_has_run: false,
+ b_has_run: false,
+ };
+
+ // This is not pretty, but it's 10x faster than the naive implementation using run_coords_from
+ // and 5x faster than running across the [-5..5] x [-5..5] grid and checking for valid coordinates.
+
+ // x direction
+ let x = Coord::new(1, 0);
+ result.or(&self.check_run_along_line(Coord::new(-1, 4), x, 7));
+ result.or(&self.check_run_along_line(Coord::new(-2, 3), x, 8));
+ result.or(&self.check_run_along_line(Coord::new(-3, 2), x, 9));
+ result.or(&self.check_run_along_line(Coord::new(-4, 1), x, 10));
+ result.or(&self.check_run_along_line(Coord::new(-4, 0), x, 9));
+ result.or(&self.check_run_along_line(Coord::new(-5, -1), x, 10));
+ result.or(&self.check_run_along_line(Coord::new(-5, -2), x, 9));
+ result.or(&self.check_run_along_line(Coord::new(-5, -3), x, 8));
+ result.or(&self.check_run_along_line(Coord::new(-5, -4), x, 7));
+
+ // y direction
+ let y = Coord::new(0, 1);
+ result.or(&self.check_run_along_line(Coord::new(-4, -5), y, 7));
+ result.or(&self.check_run_along_line(Coord::new(-3, -5), y, 8));
+ result.or(&self.check_run_along_line(Coord::new(-2, -5), y, 9));
+ result.or(&self.check_run_along_line(Coord::new(-1, -5), y, 10));
+ result.or(&self.check_run_along_line(Coord::new(0, -4), y, 9));
+ result.or(&self.check_run_along_line(Coord::new(1, -4), y, 10));
+ result.or(&self.check_run_along_line(Coord::new(2, -3), y, 9));
+ result.or(&self.check_run_along_line(Coord::new(3, -2), y, 8));
+ result.or(&self.check_run_along_line(Coord::new(4, -1), y, 7));
+
+ // diagonal direction
+ let d = Coord::new(1, 1);
+ result.or(&self.check_run_along_line(Coord::new(-5, -1), d, 7));
+ result.or(&self.check_run_along_line(Coord::new(-5, -2), d, 8));
+ result.or(&self.check_run_along_line(Coord::new(-5, -3), d, 9));
+ result.or(&self.check_run_along_line(Coord::new(-5, -4), d, 10));
+ result.or(&self.check_run_along_line(Coord::new(-4, -4), d, 9));
+ result.or(&self.check_run_along_line(Coord::new(-4, -5), d, 10));
+ result.or(&self.check_run_along_line(Coord::new(-3, -5), d, 9));
+ result.or(&self.check_run_along_line(Coord::new(-2, -5), d, 8));
+ result.or(&self.check_run_along_line(Coord::new(-1, -5), d, 7));
+
+ result
+ }
+
+ /// Return coordinates that belong to a run. Multiple runs can exist at the same time.
+ pub fn run_coords(&self, player: Player) -> Vec {
+ self.check_invariants();
+
+ let mut run_coords = Vec::new();
+ for coord in self.marker_coords(player) {
+ if let Some(coords) = self.run_coords_from(coord) {
+ run_coords.extend(coords);
+ }
+ }
+ run_coords
+ }
+
+ pub fn remove_run(&mut self, seed: Coord) {
+ self.check_invariants();
+
+ let run_coords = self
+ .run_coords_from(seed)
+ .expect("remove_run called with invalid seed");
+ for coord in run_coords {
+ self.remove_marker(coord);
+ }
+ }
+
+ #[cfg(debug_assertions)]
+ fn check_invariants(&self) {
+ for coord in all_coords() {
+ match self.element_at(coord) {
+ Element::Ring(Player::A) => {
+ debug_assert!(self.rings_a.contains(&coord));
+ debug_assert!(!self.rings_b.contains(&coord));
+ }
+ Element::Ring(Player::B) => {
+ debug_assert!(self.rings_b.contains(&coord));
+ debug_assert!(!self.rings_a.contains(&coord));
+ }
+ Element::Marker(Player::A) => {
+ debug_assert!(self.markers_a.contains(&coord));
+ debug_assert!(!self.markers_b.contains(&coord));
+ }
+ Element::Marker(Player::B) => {
+ debug_assert!(self.markers_b.contains(&coord));
+ debug_assert!(!self.markers_a.contains(&coord));
+ }
+ Element::Empty => {
+ debug_assert!(!self.rings_a.contains(&coord));
+ debug_assert!(!self.rings_b.contains(&coord));
+ debug_assert!(!self.markers_a.contains(&coord));
+ debug_assert!(!self.markers_b.contains(&coord));
+ }
+ }
+ }
+
+ for coord in self.rings_a.iter().copied() {
+ debug_assert!(self.element_at(coord) == Element::Ring(Player::A));
+ }
+
+ for coord in self.rings_b.iter().copied() {
+ debug_assert!(self.element_at(coord) == Element::Ring(Player::B));
+ }
+
+ for coord in self.markers_a.iter().copied() {
+ debug_assert!(self.element_at(coord) == Element::Marker(Player::A));
+ }
+
+ for coord in self.markers_b.iter().copied() {
+ debug_assert!(self.element_at(coord) == Element::Marker(Player::B));
+ }
+ }
+
+ pub fn fill_board_from_lists(&mut self) {
+ let rings_a = self.rings_a.clone();
+ let rings_b = self.rings_b.clone();
+ let markers_a = self.markers_a.clone();
+ let markers_b = self.markers_b.clone();
+
+ for coord in rings_a {
+ self.insert_board_element_at(coord, Element::Ring(Player::A));
+ }
+
+ for coord in rings_b {
+ self.insert_board_element_at(coord, Element::Ring(Player::B));
+ }
+
+ for coord in markers_a {
+ self.insert_board_element_at(coord, Element::Marker(Player::A));
+ }
+
+ for coord in markers_b {
+ self.insert_board_element_at(coord, Element::Marker(Player::B));
+ }
+
+ self.check_invariants();
+ }
+
+ #[cfg(not(debug_assertions))]
+ fn check_invariants(&self) {}
+}
diff --git a/src/yinsh/core.rs b/src/yinsh/core.rs
new file mode 100644
index 0000000..03d5f37
--- /dev/null
+++ b/src/yinsh/core.rs
@@ -0,0 +1,164 @@
+use std::ops::{Add, Mul, Sub};
+
+use serde::{Deserialize, Serialize};
+
+/// All Yinsh coordinates lie on a hexagonal grid within a circle of radius 4.6.
+const BOARD_RADIUS_SQUARED: f32 = 4.6_f32 * 4.6_f32;
+
+/// Yinsh hex coordinates
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct Coord {
+ pub x: i8,
+ pub y: i8,
+}
+
+impl Coord {
+ pub fn new(x: i8, y: i8) -> Self {
+ Coord { x, y }
+ }
+
+ /// Check if the point lies within the boundaries of the board.
+ pub fn is_inside_board(&self) -> bool {
+ let sqrt_3 = 3.0_f32.sqrt();
+ let x = self.x as f32;
+ let y = self.y as f32;
+ (0.5 * sqrt_3 * x).powi(2) + (0.5 * x - y).powi(2) <= BOARD_RADIUS_SQUARED
+ }
+
+ pub fn is_on_same_line_as(&self, other: Coord) -> bool {
+ (self.x == other.x) || (self.y == other.y) || ((self.x - self.y) == (other.x - other.y))
+ }
+
+ fn shorten(&self) -> Coord {
+ Coord {
+ x: self.x.max(-1).min(1),
+ y: self.y.max(-1).min(1),
+ }
+ }
+
+ pub fn between(a: Coord, b: Coord) -> Vec {
+ let mut coords = Vec::new();
+ let delta = (b - a).shorten();
+ let mut current = a + delta;
+ while current != b {
+ coords.push(current);
+ current = current + delta;
+ }
+ coords
+ }
+
+ pub fn norm(&self) -> f32 {
+ ((self.x as f32).powi(2) + (self.y as f32).powi(2)).sqrt()
+ }
+}
+
+impl Add for Coord {
+ type Output = Coord;
+
+ fn add(self, other: Coord) -> Coord {
+ Coord {
+ x: self.x + other.x,
+ y: self.y + other.y,
+ }
+ }
+}
+
+impl Sub for Coord {
+ type Output = Coord;
+
+ fn sub(self, rhs: Coord) -> Self::Output {
+ Coord {
+ x: self.x - rhs.x,
+ y: self.y - rhs.y,
+ }
+ }
+}
+
+impl Mul for Coord {
+ type Output = Coord;
+
+ fn mul(self, rhs: i8) -> Self::Output {
+ Coord {
+ x: self.x * rhs,
+ y: self.y * rhs,
+ }
+ }
+}
+
+/// The six hex directions
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Direction {
+ N,
+ NE,
+ SE,
+ S,
+ SW,
+ NW,
+}
+
+impl Direction {
+ pub fn direction(&self) -> Coord {
+ match self {
+ Direction::N => Coord { x: -1, y: 0 },
+ Direction::S => Coord { x: 1, y: 0 },
+ Direction::NE => Coord { x: -1, y: -1 },
+ Direction::SW => Coord { x: 1, y: 1 },
+ Direction::NW => Coord { x: 0, y: 1 },
+ Direction::SE => Coord { x: 0, y: -1 },
+ }
+ }
+}
+
+pub const DIRECTIONS: &'static [Direction; 6] = &[
+ Direction::N,
+ Direction::NE,
+ Direction::SE,
+ Direction::S,
+ Direction::SW,
+ Direction::NW,
+];
+
+pub const AXES: &'static [Direction; 3] = &[Direction::N, Direction::NE, Direction::NW];
+
+/// Player types (white and black)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Player {
+ A,
+ B,
+}
+
+impl Player {
+ pub fn next(self) -> Self {
+ match self {
+ Player::A => Player::B,
+ Player::B => Player::A,
+ }
+ }
+
+ pub fn flip(&mut self) {
+ *self = self.next();
+ }
+}
+
+pub fn all_coords() -> Vec {
+ let mut coords = Vec::new();
+ for x in -5..=5 {
+ for y in -5..=5 {
+ let coord = Coord { x, y };
+ if coord.is_inside_board() {
+ coords.push(coord);
+ }
+ }
+ }
+ coords
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn number_of_grid_intersections() {
+ assert_eq!(all_coords().len(), 85);
+ }
+}
diff --git a/src/yinsh/game_state.rs b/src/yinsh/game_state.rs
new file mode 100644
index 0000000..8dfa2e6
--- /dev/null
+++ b/src/yinsh/game_state.rs
@@ -0,0 +1,181 @@
+use std::path::Path;
+
+use serde::{Deserialize, Serialize};
+
+use super::{Board, Coord, Player};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum TurnMode {
+ /// place a ring on a free field
+ RingPlacement,
+
+ /// place a marker in one of your rings
+ MarkerPlacement,
+
+ /// wait for ring movement
+ WaitForRingMovement(Coord),
+
+ /// move the ring at the given position
+ RingMovement(Coord),
+
+ /// Remove (one of your) run(s). The parameter
+ /// holds the last player who moved a ring.
+ RunRemoval(Player),
+
+ /// Wait for run removal
+ WaitForRunRemoval(Player),
+
+ /// Remove one of your rings
+ RingRemoval(Player),
+
+ WaitForRingRemoval(Player),
+
+ /// Do nothing
+ WaitForMarkerPlacement,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Move {
+ PlaceRing(Coord),
+ PlaceMarker(Coord),
+ MoveRing(Coord, Coord),
+ RemoveRun(Coord),
+ RemoveRing(Coord),
+ Wait,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct GameState {
+ pub active_player: Player,
+ pub turn_mode: TurnMode,
+ pub board: Board,
+ pub points_a: usize,
+ pub points_b: usize,
+}
+
+impl GameState {
+ pub fn initial() -> Self {
+ Self {
+ active_player: Player::A,
+ turn_mode: TurnMode::RingPlacement,
+ board: Board::empty(),
+ points_a: 0,
+ points_b: 0,
+ }
+ }
+
+ pub fn perform_move(&mut self, player_move: &Move) {
+ // println!();
+ // println!("Current turn mode: {:?}", self.turn_mode);
+ // println!("Current active player: {:?}", self.active_player);
+ // println!("Move: {:?}", player_move);
+
+ match (&self.turn_mode, player_move) {
+ (TurnMode::RingPlacement, Move::PlaceRing(coord)) => {
+ self.board.add_ring(self.active_player, *coord);
+
+ self.turn_mode = if self.board.num_rings() <= 9 {
+ TurnMode::RingPlacement
+ } else {
+ TurnMode::MarkerPlacement
+ };
+ }
+ (TurnMode::MarkerPlacement, Move::PlaceMarker(coord)) => {
+ self.board.remove_ring(*coord);
+ self.board.add_marker(self.active_player, *coord);
+
+ self.turn_mode = TurnMode::WaitForRingMovement(*coord);
+ }
+ (TurnMode::WaitForRingMovement(start), Move::Wait) => {
+ self.turn_mode = TurnMode::RingMovement(*start);
+ }
+ (TurnMode::RingMovement(_), Move::MoveRing(start, end)) => {
+ self.board.add_ring(self.active_player, *end);
+
+ self.board.flip_markers_between(*start, *end);
+
+ let result = self.board.check_run();
+
+ if result.has_run(self.active_player) {
+ self.turn_mode = TurnMode::WaitForRunRemoval(self.active_player);
+ } else if result.has_run(self.active_player.next()) {
+ self.turn_mode = TurnMode::RunRemoval(self.active_player);
+ } else {
+ self.turn_mode = TurnMode::MarkerPlacement;
+ }
+ }
+ (TurnMode::WaitForRunRemoval(player_last_ring_move), Move::Wait) => {
+ self.turn_mode = TurnMode::RunRemoval(*player_last_ring_move);
+ }
+ (TurnMode::RunRemoval(player_last_ring_move), Move::RemoveRun(coord)) => {
+ self.board.remove_run(*coord);
+
+ if self.active_player == Player::A {
+ self.points_a += 1;
+ } else {
+ self.points_b += 1;
+ }
+
+ self.turn_mode = TurnMode::WaitForRingRemoval(*player_last_ring_move);
+ }
+ (TurnMode::WaitForRingRemoval(player_last_ring_move), Move::Wait) => {
+ self.turn_mode = TurnMode::RingRemoval(*player_last_ring_move);
+ }
+ (TurnMode::RingRemoval(player_last_ring_move), Move::RemoveRing(coord)) => {
+ self.board.remove_ring(*coord);
+
+ let result = self.board.check_run();
+
+ self.turn_mode = if result.has_run(self.active_player) {
+ // Active player has a second run, other player needs to wait
+ TurnMode::WaitForRunRemoval(*player_last_ring_move)
+ } else if result.has_run(self.active_player.next()) {
+ // Other player has a run, active player needs to remove it
+ TurnMode::RunRemoval(*player_last_ring_move)
+ } else if self.active_player == *player_last_ring_move {
+ TurnMode::MarkerPlacement
+ } else {
+ TurnMode::WaitForMarkerPlacement
+ };
+ }
+ (TurnMode::WaitForMarkerPlacement, Move::Wait) => {
+ self.turn_mode = TurnMode::MarkerPlacement;
+ }
+ (turn_mode, player_move) => {
+ unreachable!(
+ "Received unexpected player move {player_move:?} in mode {turn_mode:?}"
+ )
+ }
+ }
+
+ self.active_player.flip();
+
+ // println!("New turn mode: {:?}", self.turn_mode);
+ // println!("New active player: {:?}", self.active_player);
+ }
+
+ pub fn winner(&self) -> Option {
+ if self.points_a >= 3 {
+ Some(Player::A)
+ } else if self.points_b >= 3 {
+ Some(Player::B)
+ } else {
+ None
+ }
+ }
+
+ pub fn save_to>(&self, path: P) {
+ let file = std::fs::File::create(path).unwrap();
+ serde_yaml::to_writer(file, &self).unwrap();
+ }
+
+ pub fn load_from>(path: P) -> Self {
+ let file = std::fs::File::open(path).unwrap();
+ let mut game_state: GameState = serde_yaml::from_reader(file).unwrap();
+
+ // Patch up the 2D board, which is not serialized/deserialized
+ game_state.board.fill_board_from_lists();
+
+ game_state
+ }
+}
diff --git a/src/yinsh/mod.rs b/src/yinsh/mod.rs
new file mode 100644
index 0000000..4be0fd0
--- /dev/null
+++ b/src/yinsh/mod.rs
@@ -0,0 +1,8 @@
+mod board;
+mod core;
+mod game_state;
+
+pub use board::Board;
+pub use core::all_coords;
+pub use core::{Coord, Player, DIRECTIONS};
+pub use game_state::{Move, GameState, TurnMode};
diff --git a/tests/ai.rs b/tests/ai.rs
new file mode 100644
index 0000000..41a0344
--- /dev/null
+++ b/tests/ai.rs
@@ -0,0 +1,56 @@
+use yinsh::{Coord, GameState, Heuristic, Move, Player, SimpleHeuristic};
+
+#[test]
+fn midgame_1() {
+ let heuristic = SimpleHeuristic {
+ f_points: 1_000,
+ f_markers: 10,
+ f_controlled_markers_own: 0,
+ f_controlled_markers_opponent: 0,
+ f_accessible_fields: 0,
+ };
+
+ let mut game_state = GameState::load_from("tests/midgame_1.yml");
+
+ assert_eq!(game_state.active_player, Player::A);
+
+ game_state.perform_move(&Move::PlaceMarker(Coord::new(2, 1)));
+ game_state.perform_move(&Move::Wait);
+ game_state.perform_move(&Move::MoveRing(Coord::new(2, 1), Coord::new(2, 2)));
+
+ assert_eq!(game_state.active_player, Player::B);
+
+ game_state.perform_move(&Move::PlaceMarker(Coord::new(-3, -4)));
+ game_state.perform_move(&Move::Wait);
+ game_state.perform_move(&Move::MoveRing(Coord::new(-3, -4), Coord::new(-4, -4)));
+
+ assert_eq!(game_state.active_player, Player::A);
+
+ game_state.perform_move(&Move::PlaceMarker(Coord::new(2, 2)));
+ game_state.perform_move(&Move::Wait);
+ game_state.perform_move(&Move::MoveRing(Coord::new(2, 2), Coord::new(2, 3)));
+
+ assert_eq!(game_state.active_player, Player::B);
+
+ game_state.perform_move(&Move::Wait);
+
+ assert_eq!(heuristic.evaluate_for_player_a(&game_state), -1080);
+
+ game_state.perform_move(&Move::RemoveRun(Coord::new(2, 2)));
+ game_state.perform_move(&Move::Wait);
+
+ assert_eq!(
+ heuristic.evaluate_for_player_a(&game_state),
+ -1080 + 1000 - 5 * 10
+ );
+
+ game_state.perform_move(&Move::RemoveRing(Coord::new(0, -3)));
+ game_state.perform_move(&Move::PlaceMarker(Coord::new(-1, 1)));
+ game_state.perform_move(&Move::Wait);
+ game_state.perform_move(&Move::MoveRing(Coord::new(-1, 1), Coord::new(-1, 2)));
+
+ assert_eq!(
+ heuristic.evaluate_for_player_a(&game_state),
+ -1080 + 1000 - 5 * 10 - 10
+ );
+}
diff --git a/tests/board.rs b/tests/board.rs
new file mode 100644
index 0000000..25ef418
--- /dev/null
+++ b/tests/board.rs
@@ -0,0 +1,90 @@
+use yinsh::{Board, Coord, Player, DIRECTIONS};
+
+#[test]
+fn basic_marker_placement() {
+ let mut board = Board::empty();
+
+ for c in yinsh::all_coords() {
+ assert!(board.is_free(c));
+ }
+
+ let marker_coord = Coord::new(3, -2);
+ board.add_marker(Player::A, marker_coord);
+
+ assert!(!board.is_free(marker_coord));
+ assert_eq!(board.num_markers(Player::A), 1);
+ assert_eq!(board.num_markers(Player::B), 0);
+
+ board.remove_marker(marker_coord);
+
+ assert!(board.is_free(marker_coord));
+
+ assert_eq!(board, Board::empty());
+}
+
+#[test]
+fn basic_ring_placement() {
+ let mut board = Board::empty();
+
+ let ring_coord = Coord::new(3, -2);
+ board.add_ring(Player::A, ring_coord);
+
+ assert!(!board.is_free(ring_coord));
+
+ assert!(board.has_ring_at(ring_coord, Player::A));
+
+ board.remove_ring(ring_coord);
+
+ assert!(board.is_free(ring_coord));
+
+ assert_eq!(board, Board::empty());
+}
+
+#[test]
+fn check_run_basic() {
+ let mut board = Board::empty();
+
+ assert!(board.check_run().no_runs());
+
+ board.add_marker(Player::A, Coord::new(0, -2));
+ board.add_marker(Player::A, Coord::new(0, -1));
+ board.add_marker(Player::A, Coord::new(0, 0));
+ board.add_marker(Player::A, Coord::new(0, 1));
+
+ assert!(board.check_run().no_runs());
+
+ board.add_marker(Player::A, Coord::new(0, 2));
+
+ assert!(board.check_run().has_run(Player::A));
+ assert!(!board.check_run().has_run(Player::B));
+
+ board.add_marker(Player::B, Coord::new(-1, -1));
+ board.add_marker(Player::B, Coord::new(-1, 0));
+ board.add_marker(Player::B, Coord::new(-1, 1));
+ board.add_marker(Player::B, Coord::new(-1, 2));
+
+ assert!(!board.check_run().has_run(Player::B));
+
+ board.add_marker(Player::B, Coord::new(-1, -2));
+
+ assert!(board.check_run().has_run(Player::A));
+ assert!(board.check_run().has_run(Player::B));
+}
+
+#[test]
+fn check_run_exhaustive() {
+ for c in yinsh::all_coords() {
+ for d in DIRECTIONS {
+ if (c + d.direction() * 4).is_inside_board() {
+ dbg!(c, d.direction());
+ let mut board = Board::empty();
+
+ for i in 0..=4i8 {
+ board.add_marker(Player::A, c + d.direction() * i);
+ }
+
+ assert!(board.check_run().has_run(Player::A));
+ }
+ }
+ }
+}
diff --git a/tests/midgame_1.yml b/tests/midgame_1.yml
new file mode 100644
index 0000000..42907ab
--- /dev/null
+++ b/tests/midgame_1.yml
@@ -0,0 +1,81 @@
+active_player: A
+turn_mode: MarkerPlacement
+board:
+ rings_a:
+ - x: -1
+ y: -2
+ - x: 0
+ y: -3
+ - x: 0
+ y: 1
+ - x: -2
+ y: -4
+ - x: 2
+ y: 1
+ rings_b:
+ - x: -1
+ y: 1
+ - x: -3
+ y: -4
+ - x: -2
+ y: -1
+ - x: 1
+ y: -1
+ markers_a:
+ - x: -2
+ y: -2
+ - x: 1
+ y: -2
+ - x: -5
+ y: -4
+ - x: -2
+ y: -3
+ - x: -3
+ y: -3
+ - x: 1
+ y: -3
+ - x: 2
+ y: -2
+ - x: 2
+ y: -1
+ - x: 2
+ y: 0
+ markers_b:
+ - x: 3
+ y: 4
+ - x: 1
+ y: 4
+ - x: 3
+ y: 1
+ - x: -4
+ y: -5
+ - x: 3
+ y: 3
+ - x: -2
+ y: -5
+ - x: 1
+ y: 2
+ - x: 1
+ y: 3
+ - x: 0
+ y: 2
+ - x: -4
+ y: -2
+ - x: -4
+ y: -1
+ - x: -4
+ y: -3
+ - x: -1
+ y: 0
+ - x: 1
+ y: 0
+ - x: -3
+ y: 0
+ - x: -3
+ y: -2
+ - x: -1
+ y: -3
+ - x: 0
+ y: -2
+points_a: 0
+points_b: 1
diff --git a/web/.gitignore b/web/.gitignore
new file mode 100644
index 0000000..3c68218
--- /dev/null
+++ b/web/.gitignore
@@ -0,0 +1,2 @@
+/yinsh_bg.wasm
+/yinsh.js
diff --git a/web/index.html b/web/index.html
new file mode 100644
index 0000000..0f0c06f
--- /dev/null
+++ b/web/index.html
@@ -0,0 +1,38 @@
+
+
+
+
+
+
+