Refactor, try to limit dependencies

src/Dodge/Item/Weapon/LaserPath.hs

@@ -1,56 +1,62 @@
-module Dodge.Item.Weapon.LaserPath 
-    ( reflectLaserAlong
-    ) where
-import Dodge.Data
+module Dodge.Item.Weapon.LaserPath (
+    reflectLaserAlong,
+) where
+
+import Data.Bifunctor
+import Data.Tuple
 import Dodge.Base.Wall
---import Dodge.Creature.HandPos
+import Dodge.Data.World
 import Dodge.WorldEvent
 import Geometry
 
---import Data.Maybe
---import Data.List
-import Data.Bifunctor
-import Data.Tuple
---import Streaming
---import qualified Streaming.Prelude as S
-
 -- this needs to be tested with both reflections and refractions
-reflectLaserAlong :: Float -> Point2 -> Point2 -> World 
-    -> (Maybe (Point2,Either Creature Wall),[Point2])
+reflectLaserAlong ::
+    Float ->
+    Point2 ->
+    Point2 ->
+    World ->
+    (Maybe (Point2, Either Creature Wall), [Point2])
 {-# INLINE reflectLaserAlong #-}
 reflectLaserAlong phasev sp ep w = case thingHitFilt (const True) _wlUnshadowed sp ep w of
-    Just (p,Right wl) 
-        | _wlReflect wl -> second (p:) $ reflectLaserAlong phasev 
-            (p +.+ unitVectorAtAngle (reflDirWall sp p wl))
-            (p +.+ dist p ep *.* unitVectorAtAngle (reflDirWall sp p wl)) 
-            w
-        | wlIsSeeThrough wl -> second (p:) $ reflectLaserAlong phasev 
-            (p +.+ normalizeV (refract phasev sp ep wl p))
-            (refract phasev sp ep wl p) 
-            w
-        | otherwise -> (Just (p,Right wl), [p])
-    Just (p,obj) -> (Just (p,obj), [p])
+    Just (p, Right wl)
+        | _wlReflect wl ->
+            second (p :) $
+                reflectLaserAlong
+                    phasev
+                    (p +.+ unitVectorAtAngle (reflDirWall sp p wl))
+                    (p +.+ dist p ep *.* unitVectorAtAngle (reflDirWall sp p wl))
+                    w
+        | wlIsSeeThrough wl ->
+            second (p :) $
+                reflectLaserAlong
+                    phasev
+                    (p +.+ normalizeV (refract phasev sp ep wl p))
+                    (refract phasev sp ep wl p)
+                    w
+        | otherwise -> (Just (p, Right wl), [p])
+    Just (p, obj) -> (Just (p, obj), [p])
     Nothing -> (Nothing, [ep])
+
 refract :: Float -> Point2 -> Point2 -> Wall -> Point2 -> Point2
 {-# INLINE refract #-}
-refract phasev x y wl p 
-    | isEntering = p +.+ rotateV angleRef  (normalDist wlNormal)
-    | otherwise  = p +.+ rotateV angleRef' (normalDist wlNormal')
-  where 
+refract phasev x y wl p
+    | isEntering = p +.+ rotateV angleRef (normalDist wlNormal)
+    | otherwise = p +.+ rotateV angleRef' (normalDist wlNormal')
+  where
     wlNormal = vNormal $ uncurry (-.-) $ swap (_wlLine wl)
     wlNormal' = vNormal $ uncurry (-.-) (_wlLine wl)
-    normalDist wlnormal  = magV (p -.- y) *.* normalizeV wlnormal
+    normalDist wlnormal = magV (p -.- y) *.* normalizeV wlnormal
     angleInc = piRange $ argV wlNormal - argV (x -.- y)
-    angleRef 
+    angleRef
         | reflectExternal = angleInc
         | otherwise = asin $ sin angleInc / phasev
-    piRange a' 
+    piRange a'
         | a' > pi = a' - 2 * pi
         | a' > negate pi = a'
-        | otherwise  = a' + 2 * pi
+        | otherwise = a' + 2 * pi
     isEntering = not $ isLeftOf (x -.- y) (uncurry (-.-) (_wlLine wl))
     angleInc' = piRange $ argV wlNormal' - argV (x -.- y)
-    angleRef' 
+    angleRef'
         | reflectInternal = angleInc'
         | otherwise = asin $ phasev * sin angleInc'
     reflectInternal = 1 < abs (phasev * sin angleInc')