136 lines
4.1 KiB
Haskell
136 lines
4.1 KiB
Haskell
module PatienceBoard
|
|
( Game (..)
|
|
, Board (..)
|
|
, amountOfGameStacks
|
|
, amountOfEndingStacks
|
|
|
|
, handleInputs
|
|
, initGame
|
|
) where
|
|
|
|
import CardDeck
|
|
import Selector
|
|
|
|
import InputHandler
|
|
|
|
----------------------------- Constants ------------------------------
|
|
|
|
-- Prepresentation of a Patience game
|
|
data Game = Game {
|
|
-- The playboard
|
|
board :: Board,
|
|
-- The selector
|
|
selector :: Selector
|
|
} deriving (Show)
|
|
|
|
-- Representation of a Patience board
|
|
data Board = Board {
|
|
-- 7 colums of cards (the 'playing field')
|
|
gameStacks :: [Stack],
|
|
-- 4 ending stacks (top right corner, usually)
|
|
endingStacks :: [Stack],
|
|
-- Stack of cards that are not yet on the board
|
|
pile :: Stack
|
|
} deriving (Show)
|
|
|
|
amountOfGameStacks :: Int
|
|
amountOfGameStacks = 7
|
|
|
|
amountOfEndingStacks :: Int
|
|
amountOfEndingStacks = 4
|
|
|
|
rotateStep :: Int
|
|
rotateStep = 3
|
|
|
|
------------------------------- Init ---------------------------------
|
|
|
|
-- Split a full deck into 7 gameStacks and one pile of unused cards.
|
|
splitDeck :: Stack -> [Stack]
|
|
splitDeck = reverse . splitDeck' amountOfGameStacks
|
|
where splitDeck' :: Int -> Stack -> [Stack]
|
|
splitDeck' 0 cs = [cs]
|
|
splitDeck' n cs = let (stack,rest) = splitAt n cs
|
|
in showFirst stack : splitDeck' (n - 1) rest
|
|
|
|
-- The initial board consisting of a stack of yet-to-be-turned cards
|
|
-- and n stacks of increasingly large amount of cards (1, ..., n)
|
|
initBoard :: Board
|
|
initBoard = Board {
|
|
gameStacks = stacks,
|
|
endingStacks = replicate amountOfEndingStacks [],
|
|
pile = map showCard pile
|
|
}
|
|
where pile:stacks = splitDeck generateShuffledDeck
|
|
|
|
-- The initial state of the playboard, with a board and a cursor.
|
|
initGame :: Game
|
|
initGame = Game {
|
|
board = initBoard,
|
|
selector = initSelector
|
|
}
|
|
|
|
--------------------------- Change cards -----------------------------
|
|
|
|
-- Show the first of a stack of cards.
|
|
showFirst :: Stack -> Stack
|
|
showFirst [] = []
|
|
showFirst (c:cs) = showCard c : cs
|
|
|
|
-- Rotate the pile n times.
|
|
rotatePile :: Board -> Board
|
|
rotatePile b = b { pile = tail ++ head }
|
|
where (head,tail) = splitAt rotateStep $ pile b
|
|
|
|
-- Check if a card can be placed ontop of a gameStack.
|
|
canPlayOn :: Card -> Stack -> Bool
|
|
canPlayOn (_,King,_) [] = True
|
|
canPlayOn (t1,v1,_) ((t2,v2,_):cs) = differentColor && predValue
|
|
where differentColor = t1 /= t2 && fromEnum t1 + fromEnum t2 `elem` [1,2,4,5]
|
|
predValue = fromEnum v1 + 1 == fromEnum v2
|
|
canPlayOn _ _ = False
|
|
|
|
-- Check if a card can be played ontop of an EndingStack.
|
|
canFinishOn :: Card -> Stack -> Bool
|
|
canFinishOn (_,Ace,_) [] = True
|
|
canFinishOn (t1,v1,_) ((t2,v2,_):cs) = sameType && succValue
|
|
where sameType = t1 == t2
|
|
succValue = fromEnum v1 == fromEnum v2 + 1
|
|
canFinishOn _ _ = False
|
|
|
|
-- Move a card to a GameStack. Move all the cards below the given card
|
|
-- on the 'from' stack as well.
|
|
moveToGS :: Stack -> Int -> Stack -> (Stack,Stack)
|
|
moveToGS from index to
|
|
| canPlayOn (from !! index) to = (showFirst removed, added)
|
|
| otherwise = (from,to)
|
|
where (diff,removed) = splitAt (index + 1) from
|
|
added = diff ++ to
|
|
|
|
-- Move a card to an EndingStack. This can only be a single card at once.
|
|
moveToES :: Stack -> Stack -> (Stack,Stack)
|
|
moveToES from to
|
|
| canFinishOn (head from) to = (showFirst removed, added)
|
|
| otherwise = (from,to)
|
|
where (diff,removed) = splitAt 1 from
|
|
added = diff ++ to
|
|
|
|
------------------------------ Input ---------------------------------
|
|
|
|
-- Move the selector of the game. (Wrapper)
|
|
moveSelector :: Direction -> Game -> Game
|
|
moveSelector dir g@Game{ selector = s } = g{ selector = move dir s }
|
|
|
|
-- Toggle selector. (Wrapper)
|
|
toggleSelector :: Game -> Game
|
|
toggleSelector g@Game{ selector = s } = g{ selector = toggleSelection s }
|
|
|
|
-- Handle all the inputs necessary for patience.
|
|
handleInputs :: Event -> Game -> Game
|
|
handleInputs = composeInputHandler [
|
|
handleUp (moveSelector U),
|
|
handleDown (moveSelector D),
|
|
handleLeft (moveSelector L),
|
|
handleRight (moveSelector R),
|
|
|
|
handleSpace toggleSelector
|
|
]
|