Code cleanup

src/Main.hs

@@ -15,6 +15,10 @@ import Data.Fixed (mod')
 -- * Ik heb de functie isKey hernoemd naar isSpecialKey en ik heb   *
 -- * een extra functie isKey aangemaakt zodat ik ook andere letters *
 -- * van het toetsenbord als input kan gebruiken.                   *
+-- * 3.                                                             *
+-- * Ik heb een functie cardCoord geschreven om niet steeds een     * 
+-- * te moeten gebruiken als ik een coördinaat van een kaart wil    *
+-- * opvragen.
 -- ******************************************************************
 
 -- Geeft de richting van een zet aan.
@@ -108,7 +112,7 @@ match (_, c1, _) (_, c2, _) = c1 == c2
 -- Wanneer een kaart gevonden is, wordt deze teruggegeven. Anders wordt
 -- een error teruggegeven.
 find :: Coordinate -> [Card] -> Card
-find c0 cards = head $ filter ((c0 ==).firstOfThree) cards
+find coord = head.filter ((coord ==).cardCoord)
 
 -- Geef een permutatie van een gegeven lijst terug.
 -- Hint: Kijk zeker eens naar de System.Random en 
@@ -123,26 +127,26 @@ generateColors n = map (generateColor.fromIntegral.(div 360 n *)) [1..n]
 
 -- Genereer een lijst van n kaarten (n/2 kleurenparen).
 generateShuffledCards :: Int -> [Card]
-generateShuffledCards n = map (\(x,y) -> (x,y,Hidden)) $ zip (genCoords n) colors
+generateShuffledCards n = zipWith (\x y -> (x,y,Hidden)) (genCoords n) colors
     where colors      = shuffleList $ colorsOnce ++ colorsOnce
           colorsOnce  = generateColors (n `div` 2)
-          genCoords n = take n [ (x,y) | x <- [0..(width - 1)], y <- [0..(height - 1)] ]
+          genCoords n = take n [(x,y) | x <- [0..(width-1)], y <- [0..(height-1)]]
 
 -- Controleer of een positie op het spelbord een kaart bevat.
 hasCard :: Coordinate -> Bool
-hasCard c0 = any ((c0 ==).firstOfThree) $ cards initBoard
+hasCard coord = any ((coord ==).cardCoord) $ cards initBoard
 
 -- Controleer of de selector vanaf een gegeven locatie in een 
 -- gegeven richting kan bewegen.
 canMove :: Coordinate -> Direction -> Bool
-canMove (w, h) (dw, dh) = hasCard $ (w + dw, h + dh)
+canMove (w, h) (wDiff, hDiff) = hasCard (w + wDiff, h + hDiff)
 
 -- Beweeg de selector in een gegeven richting.
 move :: Board -> Direction -> Board
-move board (dw, dh)
-    | canMove (selector board) (dw, dh) = board { selector = new }
-    | otherwise                         = board
-    where new = (\(w,h) -> (dw + w, dh + h)) $ selector board
+move board (wDiff, hDiff)
+    | canMove (selector board) (wDiff, hDiff) = board {selector = new}
+    | otherwise                               = board
+    where new = (\(w,h) -> (w + wDiff, h + hDiff)) $ selector board
 
 -- Verander de status van een kaart op een gegeven positie 
 -- wanneer de posities overeenkomen.
@@ -167,33 +171,33 @@ hideCard target = map (changeCard target Hidden)
 -- als deze nog niet eerder werd omgedraaid.
 flipCard :: Coordinate -> Board -> Board
 flipCard target board
-    | target `elem` (map firstOfThree (turned board)) = board           -- Al in selectie?
-    | any (\(c,_,s) -> c == target && s == Shown) (cards board) = board -- Al omgedraaid?
+    | target `elem` (map cardCoord (turned board)) = board -- Al in selectie?
+    | any targetEq (cards board) = board                   -- Al omgedraaid?
     | otherwise  = board {
         cards    = newCards                -- Toon de kaart in de lijst van kaarten.
         , turned = flipped ++ turned board -- Voeg toe aan 'omgedraaide kaarten'.
     }
-    where newCards = showCard target $ cards board
-          flipped  = filter ((target ==).firstOfThree) newCards
+    where targetEq (coord,_,status) = (coord,status)  == (target,Shown)
+          newCards                  = showCard target $ cards board
+          flipped                   = filter ((target ==).cardCoord) newCards
 
 -- Reset de laatste omgedraaide kaarten terug naar de `Hidden` status.
 resetTurned :: Board -> Board
 resetTurned board@Board{ turned = []   } = board
 resetTurned board@Board{ turned = x:xs } = resetTurned board {
-    cards    = hideCard (firstOfThree x) (cards board)
+    cards    = hideCard (cardCoord x) (cards board)
     , turned = xs
     }
 
 -- Bereken het volgende bord op basis van de omgedraaide kaarten.
 -- Hint: We hebben de drie gevallen voor deze functie al voorzien.
--- TODO Klopt deze functionaliteit?
 nextBoard :: Board -> Board 
 nextBoard b@Board{ turned = [] }       = flipCard (selector b) b
 nextBoard b@Board{ turned = [c1] }     = flipCard (selector b) b
 nextBoard b@Board{ turned = [c1, c2] } 
-    | secondOfThree c1 == secondOfThree c2 = b { turned = [] } -- Paar gevonden
-    | otherwise                            = resetTurned b
-    where secondOfThree (_,x,_) = x
+    | cardColor c1 == cardColor c2 = b { turned = [] } -- Paar gevonden
+    | otherwise                    = resetTurned b
+    where cardColor (_,x,_) = x
 
 -- Zet een positie op het bord om naar een positie op het scherm.
 -- Hint: hou zeker rekening met het coordinatensysteem van Gloss.
@@ -201,14 +205,15 @@ nextBoard b@Board{ turned = [c1, c2] }
 -- Linksonderaan is (0,0) voor Card.Coordinate,
 -- (-(x/2),-(y/2)) voor as van lengte x en y in Gloss.
 convert :: Int -> Int -> Float
-convert location axis = car + inset + fromIntegral scaling / 2
-    where car   = (-(fromIntegral axis / 2.0) + fromIntegral location) * fromIntegral scaling
-          inset = fromIntegral ((-(axis `div` 2) + location) * cardInset)
+convert location axis = scale + inset + f scaling / 2
+    where scale       = ( -(f axis / 2.0) + f location) * f scaling
+          inset       = f $ ( -(axis `div` 2) + location ) * cardInset
+          f           = fromIntegral
 
 -- Render een vierkant met een gegeven kleur en grootte.
 renderColoredSquare :: Int -> Color -> Picture
-renderColoredSquare size c = color c $ rectangleSolid x x
-    where x = fromIntegral size
+renderColoredSquare size c = color c $ rectangleSolid fSize fSize
+    where fSize = fromIntegral size
 
 -- Render de selector.
 renderSelector :: Coordinate -> Picture
@@ -229,7 +234,7 @@ renderCards = pictures . map renderCard
 -- Render het speelveld.
 render :: Board -> Picture
 render board = pictures [
-    renderSelector $ selector board -- Render de selector eerst zodat het op een kader lijkt.
+    renderSelector $ selector board -- Render selector eerst voor kader effect.
     , renderCards $ cards board
     ]
 
@@ -306,5 +311,5 @@ step _ b = b
 
 -- Haal het eerste element uit een drietupel, bijvoorbeeld om de
 -- coördinaten uit een kaart-object te halen.
-firstOfThree :: (a,b,c) -> a
-firstOfThree (a,_,_) = a
+cardCoord :: (a,b,c) -> a
+cardCoord (a,_,_) = a