Refactor

src/Dodge/LevelGen/Block.hs

@@ -1,5 +1,5 @@
-{-
-Creation, update and descruction of destructible walls.
+{- |
+Creation, update and destruction of destructible walls.
  -}
 module Dodge.LevelGen.Block where
 import Dodge.Data
@@ -26,17 +26,18 @@ updateBlocks w = (\w' -> seq (_wallsZone w') w') $ flip (foldr removeFromZone) d
     removeFromZone :: Wall -> World -> World
     removeFromZone bl = over (wallsZone . ix x . ix y) (IM.delete (_wlID bl))
       where 
-        (x,y) = zoneOfPoint $ pHalf (fst $ _wlLine bl) (snd $ _wlLine bl)
+        (x,y) = zoneOfPoint $ uncurry pHalf (_wlLine bl)
     deadPanes = filter blockIsDead (IM.elems $ _walls w)
     deadBlocks = nubBy ((==) `on` _blIDs) deadPanes
     blockIsDead wl = case wl ^? blHP of 
         Just x  -> x <= 0
         Nothing -> False
-
+{- | Destroy a block.
+Plays destruction sound and sets to be displayed other walls that were shadowed by this wall. -}
 killBlock :: Wall -> World -> World
-killBlock bl w =  f bl .  flip (foldr unshadow) (_blShadows bl) $ w
+killBlock bl w =  f bl . flip (foldr unshadow) (_blShadows bl) $ w
   where
-    f bl@(Block {_blDegrades = (x:xs)}) = degradeBlock bl . hitSound bl
+    f bl@Block{_blDegrades = (x:xs)} = degradeBlock bl . hitSound bl
     f bl          = hitSound' bl
     pos = fst $ _wlLine bl
     hitSound bl 
@@ -50,7 +51,7 @@ killBlock bl w =  f bl .  flip (foldr unshadow) (_blShadows bl) $ w
     unshadow :: Int -> World -> World
     unshadow bid w = case w ^? walls . ix bid of 
         Just b -> 
-            let (x,y) = zoneOfPoint $ pHalf (fst $ _wlLine b) (snd $ _wlLine b)
+            let (x,y) = zoneOfPoint $ uncurry pHalf (_wlLine b)
             in w & wallsZone . ix x . ix y . ix bid . blVisible %~ const True
                  & walls . ix bid . blVisible %~ const True
         Nothing -> w
@@ -97,33 +98,34 @@ addBlock (p:ps) hp col isSeeThrough degradability w
     | hp <= 0 && null degradability = w
     | hp <= 0 = addBlock (p:ps) (head degradability + hp) col isSeeThrough (tail degradability) w
     | otherwise = w  
-            & wallsZone %~ flip (IM.foldr wallInZone) panes
-            & walls     %~ IM.union panes
+        & wallsZone %~ flip (IM.foldr wallInZone) panes
+        & walls     %~ IM.union panes
   where 
     lines = zip (p:ps) (ps ++ [p])
     i = newKey $ _walls w
     is = [i.. i + length lines-1]
-    panes = IM.fromList $ zip is 
-              $ zipWith (\j (a,b) -> Block { _wlLine = (a,b)
-                                           , _wlID = j
-                                           , _wlColor = col
-                                           , _wlSeen = False
-                                           , _blIDs = is
-                                           , _blHP = hp
-                                           , _wlIsSeeThrough = isSeeThrough
-                                           , _blVisible = True
-                                           , _blShadows = []
-                                           , _blDegrades = degradability
-                                           }
-                         ) is lines
+    panes = IM.fromList $ zip is $ zipWith 
+        (\j (a,b) -> Block 
+            { _wlLine = (a,b)
+            , _wlID = j
+            , _wlColor = col
+            , _wlSeen = False
+            , _blIDs = is
+            , _blHP = hp
+            , _wlIsSeeThrough = isSeeThrough
+            , _blVisible = True
+            , _blShadows = []
+            , _blDegrades = degradability
+            }
+        ) is lines
     wallInZone wl 
-        | dist (fst $ _wlLine wl) (snd $ _wlLine wl) <= 2*zoneSize 
-                      = insertIMInZone x y wlid wl
+        | uncurry dist (_wlLine wl) <= 2*zoneSize 
+            = insertIMInZone x y wlid wl
         | otherwise = flip (foldr (\(a,b) -> insertIMInZone a b wlid wl)) ips
       where 
-        (x,y) = zoneOfPoint $ pHalf (fst $ _wlLine wl) (snd $ _wlLine wl)
+        (x,y) = zoneOfPoint $ uncurry pHalf (_wlLine wl)
         wlid  = _wlID wl
-        ips = map zoneOfPoint $ divideLine (2*zoneSize) (fst $ _wlLine wl) (snd $ _wlLine wl)
+        ips = map zoneOfPoint $ uncurry (divideLine (2*zoneSize)) (_wlLine wl)
         
 putBlock :: [Point2] -> Int -> Color -> Bool -> [Int] -> World -> World
 putBlock (p:ps) i c b is w = foldr (uncurry removePathsCrossing) wWithBlock pairs