115 lines
3 KiB
Haskell
115 lines
3 KiB
Haskell
module PatienceRenderer
|
|
( render
|
|
, getWindow
|
|
) where
|
|
|
|
import CardDeck
|
|
import PatienceBoard
|
|
import Selector
|
|
|
|
import CardRenderer
|
|
import PNGRenderer
|
|
import SelectorRenderer
|
|
|
|
import InputHandler
|
|
|
|
import Graphics.Gloss(
|
|
Display(..)
|
|
, green
|
|
, play
|
|
)
|
|
|
|
----------------------------- Constants ------------------------------
|
|
|
|
-- Distance between cards that are on top of each other
|
|
cardDistance :: Float
|
|
cardDistance = 20
|
|
|
|
-- Distance between neighbouring stacks
|
|
stackDistance :: Float
|
|
stackDistance = 10
|
|
|
|
-- Distance between different zones of the board
|
|
zoneDistance :: Float
|
|
zoneDistance = 25
|
|
|
|
-- X axis render difference for EndingStacks
|
|
esXDiff :: Float
|
|
esXDiff = fromIntegral esX * cardDistance
|
|
where cardDistance = cardWidth + stackDistance
|
|
(esX, _) = endingStacksCoord
|
|
|
|
-- Y axis render difference for EndingStacks
|
|
esYDiff :: Float
|
|
esYDiff = fromIntegral esY * (zoneDistance + cardHeight)
|
|
where (_, esY) = endingStacksCoord
|
|
|
|
-- X axis render difference for Pile
|
|
pileXDiff :: Float
|
|
pileXDiff = 0
|
|
|
|
-- Y axis render difference for Pile
|
|
pileYDiff :: Float
|
|
pileYDiff = esYDiff
|
|
|
|
----------------------------------------------------------------------
|
|
|
|
-- Render the GameStacks zone.
|
|
renderGS :: Board -> Picture
|
|
renderGS = renderStacks stackDistance (negate cardDistance) . gameStacks
|
|
|
|
-- Render the EndingStacks zone.
|
|
renderES :: Board -> Picture
|
|
renderES = renderStacks stackDistance 0 . endingStacks
|
|
|
|
-- Render the Pile zone.
|
|
renderPile :: Board -> Picture
|
|
renderPile = renderStack 0 . pile
|
|
|
|
-- Get the diff based on a coordinate because different 'zones' have
|
|
-- different offsets.
|
|
getDiff :: Coordinate -> (Float, Float)
|
|
getDiff coord
|
|
| isInEnding coord = (width, esYDiff)
|
|
| isInPile coord = (pileXDiff, pileYDiff)
|
|
| otherwise = (width, cardDistance)
|
|
where width = cardWidth + stackDistance
|
|
|
|
-- The board consists of three parts:
|
|
-- the gamestacks, the endingstacks and the pile.
|
|
-- Pile is located at (0,1).
|
|
-- EndingStacks are located at (n,1) - see calculations.
|
|
-- GameStacks are located at (0,0).
|
|
renderBoard :: Board -> Picture
|
|
renderBoard board = compose [
|
|
pile,
|
|
endingStacks,
|
|
gameStacks
|
|
]
|
|
where pile = translate pileXDiff pileYDiff $ renderPile board
|
|
endingStacks = translate esXDiff esYDiff $ renderES board
|
|
gameStacks = renderGS board
|
|
|
|
-- Render the PatienceGameSelector.
|
|
renderPSelector :: Selector -> Picture
|
|
renderPSelector ps = compose [
|
|
selector,
|
|
selected
|
|
]
|
|
where selector = renderSelector xd1 yd1 ps
|
|
selected = renderSelected xd2 yd2 ps
|
|
(xd1, yd1) = getDiff (position ps)
|
|
(xd2, yd2) = getDiff $ getSelected ps
|
|
|
|
-- Render the patience game.
|
|
render :: Game -> Picture
|
|
render game = translate centerX centerY $ compose [
|
|
renderBoard $ board game,
|
|
renderPSelector $ selector game
|
|
]
|
|
where centerX = negate $ (cardWidth + stackDistance) * (fromIntegral amountOfGameStacks - 1) / 2
|
|
centerY = 0
|
|
|
|
-- The default window to play patience.
|
|
getWindow :: Display
|
|
getWindow = InWindow "Patience" (1200,800) (50,50)
|