58 lines
2.2 KiB
Haskell
58 lines
2.2 KiB
Haskell
module Dodge.Item.Weapon.LaserPath
|
|
( reflectLaserAlong
|
|
) where
|
|
import Dodge.Data
|
|
import Dodge.Base.Wall
|
|
--import Dodge.Creature.HandPos
|
|
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])
|
|
{-# 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])
|
|
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
|
|
wlNormal = vNormal $ uncurry (-.-) $ swap (_wlLine wl)
|
|
wlNormal' = vNormal $ uncurry (-.-) (_wlLine wl)
|
|
normalDist wlnormal = magV (p -.- y) *.* normalizeV wlnormal
|
|
angleInc = piRange $ argV wlNormal - argV (x -.- y)
|
|
angleRef
|
|
| reflectExternal = angleInc
|
|
| otherwise = asin $ sin angleInc / phasev
|
|
piRange a'
|
|
| a' > pi = a' - 2 * pi
|
|
| a' > negate pi = a'
|
|
| otherwise = a' + 2 * pi
|
|
isEntering = not $ isLeftOf (x -.- y) (uncurry (-.-) (_wlLine wl))
|
|
angleInc' = piRange $ argV wlNormal' - argV (x -.- y)
|
|
angleRef'
|
|
| reflectInternal = angleInc'
|
|
| otherwise = asin $ phasev * sin angleInc'
|
|
reflectInternal = 1 < abs (phasev * sin angleInc')
|
|
reflectExternal = 1 < abs (sin angleInc / phasev)
|