325 lines
10 KiB
Haskell
325 lines
10 KiB
Haskell
module MainGame.MindMap where
|
|
|
|
import Affection as A
|
|
|
|
import Linear hiding (E(..))
|
|
|
|
import qualified Data.Map.Strict as Map
|
|
import Data.Matrix as M
|
|
import qualified Data.Set as S
|
|
import qualified Data.Text as T
|
|
import Data.List as L
|
|
import Data.Ecstasy as E
|
|
import Data.Maybe
|
|
|
|
import Control.Monad (when)
|
|
|
|
import NanoVG hiding (V2(..))
|
|
|
|
import SDL hiding (E(..))
|
|
|
|
import Foreign.C.Types
|
|
|
|
-- internal imports
|
|
|
|
import Types
|
|
|
|
import MainGame.WorldMap (checkBoundsCollision2)
|
|
|
|
updateMind :: Double -> Affection UserData ()
|
|
updateMind dt = do
|
|
ud <- getAffection
|
|
let direction :: V2 Double -> Direction -> Direction
|
|
direction vel'@(V2 vr _) rot' = if sqrt (vel' `dot` vel') > 0
|
|
then
|
|
let xuu =
|
|
acos ((vel' `dot` V2 0 1) /
|
|
sqrt (vel' `dot` vel')) / pi * 180
|
|
xu = if vr < 0 then 360 - xuu else xuu
|
|
d
|
|
| xu < 22.5 = NE
|
|
| xu > 22.5 && xu < 67.5 = E
|
|
| xu > 67.5 && xu < 112.5 = SE
|
|
| xu > 112.5 && xu < 157.5 = S
|
|
| xu > 157.5 && xu < 202.5 = SW
|
|
| xu > 202.5 && xu < 247.5 = W
|
|
| xu > 247.5 && xu < 292.5 = NW
|
|
| xu > 292.5 && xu < 337.5 = N
|
|
| xu > 337.5 = NE
|
|
| otherwise = NE
|
|
in d
|
|
else rot'
|
|
(nws, _) <- liftIO $ yieldSystemT (worldState ud) $ do
|
|
emap allEnts $ do
|
|
with anim
|
|
with mmpos
|
|
stat <- query anim
|
|
let an = assetAnimations ud Map.! asId stat
|
|
ntime = asElapsedTime stat + dt
|
|
nstate = if ntime > fromIntegral (asCurrentFrame stat) *
|
|
(animDuration an / fromIntegral (length $ animSprites an))
|
|
then
|
|
let nframe = asCurrentFrame stat + 1
|
|
in case animPlay an of
|
|
APLoop ->
|
|
let (nnframe, nntime) =
|
|
if nframe >= length (animSprites an)
|
|
then (0, 0)
|
|
else (nframe, ntime)
|
|
in stat
|
|
{ asCurrentFrame = nnframe
|
|
, asElapsedTime = nntime
|
|
}
|
|
APOnce ->
|
|
let nnframe = if nframe >= length (animSprites an)
|
|
then nframe - 1
|
|
else nframe
|
|
in stat
|
|
{ asCurrentFrame = nnframe
|
|
, asElapsedTime = ntime
|
|
}
|
|
else
|
|
stat
|
|
{ asElapsedTime = ntime
|
|
}
|
|
return $ unchanged
|
|
{ anim = Set nstate
|
|
}
|
|
emap allEnts $ do
|
|
with player
|
|
with mmvel
|
|
with mmpos
|
|
with mmrot
|
|
with anim
|
|
pos'@(V2 pr pc) <- query mmpos
|
|
vel' <- query vel
|
|
rot' <- query rot
|
|
stat <- query anim
|
|
let npos = pos' + fmap (* dt) vel'
|
|
dpos@(V2 dpr dpc) = npos - pos'
|
|
aId = asId stat
|
|
nstat = case aiName aId of
|
|
"walking"
|
|
| sqrt (colldpos `dot` colldpos) > 0 ->
|
|
stat
|
|
{ asId = aId
|
|
{ aiDirection = direction vel' rot'
|
|
}
|
|
}
|
|
| otherwise ->
|
|
stat
|
|
{ asId = aId
|
|
{ aiDirection = direction vel' rot'
|
|
, aiName = "standing"
|
|
}
|
|
, asCurrentFrame = 0
|
|
}
|
|
"standing"
|
|
| sqrt (colldpos `dot` colldpos) > 0 ->
|
|
stat
|
|
{ asId = aId
|
|
{ aiDirection = direction vel' rot'
|
|
, aiName = "walking"
|
|
}
|
|
, asCurrentFrame = 0
|
|
}
|
|
| otherwise ->
|
|
stat
|
|
{ asId = aId
|
|
{ aiDirection = direction vel' rot'
|
|
}
|
|
}
|
|
x -> error ("unknown animation name" ++ x)
|
|
len = sqrt (dpos `dot` dpos)
|
|
lll = (,)
|
|
<$> (
|
|
if dpr < 0
|
|
then [(floor dpr :: Int) .. 0]
|
|
else [0 .. (ceiling dpr :: Int)])
|
|
<*> (
|
|
if dpc < 0
|
|
then [(floor dpc :: Int) .. 0]
|
|
else [0 .. (ceiling dpc :: Int)])
|
|
colldpos = dpos * Prelude.foldl
|
|
(\acc a -> let ret = checkBoundsCollision2 pos' npos dt acc a
|
|
in A.log A.Verbose (show ret) ret)
|
|
(V2 1 1)
|
|
(
|
|
concatMap
|
|
(\(dr, dc) ->
|
|
let bs = fromMaybe [] (imgObstacle <$> M.safeGet
|
|
(fromIntegral $ floor pr + dr)
|
|
(fromIntegral $ floor pc + dc)
|
|
(mmImgMat (stateData ud)))
|
|
in Prelude.map (\(Boundaries (minr, minc) (maxr, maxc))->
|
|
Boundaries
|
|
(minr + fromIntegral dr, minc + fromIntegral dc)
|
|
(maxr + fromIntegral dr, maxc + fromIntegral dc)
|
|
) bs
|
|
)
|
|
lll -- (A.log A.Verbose (show lll ++ " " ++ show len) lll)
|
|
)
|
|
ent = unchanged
|
|
{ mmpos = Set $ pos' + colldpos
|
|
, rot = Set (direction vel' rot')
|
|
, anim = Set nstat
|
|
}
|
|
return ent
|
|
putAffection ud
|
|
{ worldState = nws
|
|
}
|
|
|
|
drawMind :: Affection UserData ()
|
|
drawMind = do
|
|
ud <- getAffection
|
|
let ctx = nano ud
|
|
dt <- getDelta
|
|
(_, (playerPos, posanims)) <- liftIO $ yieldSystemT (worldState ud) $ do
|
|
pc <- fmap head $ efor allEnts $ do
|
|
with player
|
|
with mmpos
|
|
query mmpos
|
|
posanims <- efor allEnts $ do
|
|
with anim
|
|
with mmpos
|
|
stat <- query anim
|
|
pos' <- query mmpos
|
|
return (pos', stat)
|
|
return (pc, posanims)
|
|
let V2 pr pc = playerPos
|
|
mat = mmImgMat (stateData ud)
|
|
cols = fromIntegral (ncols mat)
|
|
rows = fromIntegral (nrows mat)
|
|
tileWidth = 64 :: Double
|
|
tileHeight = 32 :: Double
|
|
x = realToFrac $ 640 + ((1 - pc) + (1 - pr)) * (tileWidth / 2)
|
|
y = realToFrac $ 360 + ((1 - pr) - (1 - pc)) * (tileHeight / 2)
|
|
partposanims = M.fromList
|
|
(nrows $ mapMat $ stateData ud)
|
|
(ncols $ mapMat $ stateData ud)
|
|
((reverse . fst)
|
|
(Prelude.foldl
|
|
(\(done, proc) coord ->
|
|
let (ndone, nproc) = processList proc coord
|
|
in (ndone : done, nproc)
|
|
)
|
|
([], posanims)
|
|
((,)
|
|
<$> [1 .. (nrows $ mapMat $ stateData ud)]
|
|
<*> [1 .. (ncols $ mapMat $ stateData ud)]
|
|
)
|
|
)
|
|
)
|
|
processList
|
|
:: [(V2 Double, AnimState)]
|
|
-> (Int, Int)
|
|
-> ([(V2 Double, AnimState)], [(V2 Double, AnimState)])
|
|
processList list coord@(r, c) =
|
|
let delimiter (V2 nr nc, _) =
|
|
floor nr == r && floor nc == c
|
|
in L.partition delimiter list
|
|
liftIO $ do -- draw floor
|
|
beginPath ctx
|
|
moveTo ctx (x + realToFrac tileWidth / 2) y
|
|
lineTo ctx
|
|
(x + cols * (realToFrac tileWidth / 2))
|
|
(y - (realToFrac tileHeight / 2) * (cols - 1))
|
|
lineTo ctx
|
|
(x + (realToFrac tileWidth / 2) * (cols + rows - 1))
|
|
(y + (rows - cols) * (realToFrac tileHeight / 2))
|
|
lineTo ctx
|
|
(x + (realToFrac tileWidth / 2) * rows)
|
|
(y + (realToFrac tileHeight / 2) * (rows - 1))
|
|
closePath ctx
|
|
fillColor ctx (rgb 255 255 255)
|
|
fill ctx
|
|
mapM_ (\(i, ls) -> mapM_
|
|
(\(j, t) -> drawTile ud ctx (partposanims M.! (i, j)) pr pc i j t)
|
|
(reverse $ zip [1..] ls))
|
|
(zip [1..] (toLists mat))
|
|
fontSize ctx 20
|
|
fontFace ctx (assetFonts ud Map.! FontBedstead)
|
|
textAlign ctx (S.fromList [AlignCenter,AlignTop])
|
|
fillColor ctx (rgb 255 128 0)
|
|
textBox ctx 0 0 200 ("FPS: " `T.append` T.pack (Prelude.take 5 $ show (1/dt)))
|
|
|
|
drawTile
|
|
:: UserData
|
|
-> Context
|
|
-> [(V2 Double, AnimState)]
|
|
-> Double
|
|
-> Double
|
|
-> Int
|
|
-> Int
|
|
-> Maybe ImgId
|
|
-> IO ()
|
|
drawTile ud ctx posanims pr pc row col img =
|
|
when ((realToFrac x > -tileWidth && realToFrac y > -tileHeight) &&
|
|
((realToFrac x :: Double) < 1280 &&
|
|
(realToFrac (y - (74 - (realToFrac tileHeight :: CFloat))) :: Double) < 720)) $
|
|
do
|
|
let (bef, beh) = L.partition delimiter sorted
|
|
save ctx
|
|
mapM_ drawAnim beh
|
|
when (isJust img) drawImage
|
|
mapM_ drawAnim bef
|
|
restore ctx
|
|
where
|
|
delimiter (V2 nr nc, _) =
|
|
all delimit mb
|
|
where
|
|
delimit b
|
|
| nnr > fst (matmin b) && nnr < fst (matmax b) =
|
|
nnc < snd (matmin b)
|
|
| nnc > snd (matmin b) && nnc < snd (matmax b) =
|
|
nnr > fst (matmax b)
|
|
| otherwise =
|
|
True
|
|
nnr = nr - fromIntegral (floor nr)
|
|
nnc = nc - fromIntegral (floor nc)
|
|
-- any (\m -> nr < fromIntegral (floor nr :: Int) + m) maxrs &&
|
|
-- any (\m -> nc > fromIntegral (floor nc :: Int) + m) mincs
|
|
ai = assetImages ud
|
|
anims = assetAnimations ud
|
|
tileWidth = 64 :: Double
|
|
tileHeight = 32 :: Double
|
|
sorted = sortOn (\(V2 sr sc, _) -> sc + sr * fromIntegral col) posanims
|
|
minrs = Prelude.map (fst . matmin) mb
|
|
maxrs = Prelude.map (fst . matmax) mb
|
|
mincs = Prelude.map (snd . matmin) mb
|
|
maxcs = Prelude.map (snd . matmax) mb
|
|
x = realToFrac $ 640 + ((fromIntegral col - pc) +
|
|
(fromIntegral row - pr)) * (tileWidth / 2) :: CFloat
|
|
y = realToFrac $ 360 - (tileHeight / 2) + ((fromIntegral row - pr) -
|
|
(fromIntegral col - pc)) * (tileHeight / 2) :: CFloat
|
|
dist = distance (V2 (fromIntegral row) (fromIntegral col))
|
|
(V2 (realToFrac pr - 1) (realToFrac pc)) / 4
|
|
fact =
|
|
if (pr <= fromIntegral row + minimum maxrs &&
|
|
pc >= fromIntegral col + maximum mincs) &&
|
|
isWall (fromJust img)
|
|
then min 1 dist
|
|
else 1
|
|
mb = imgObstacle img
|
|
drawAnim (V2 nr nc, as) = do
|
|
let ax = realToFrac $ 640 + ((nc - pc) + (nr - pr)) * 32
|
|
ay = realToFrac $ 360 + ((nr - pr) - (nc - pc)) * 16
|
|
a = anims Map.! asId as
|
|
beginPath ctx
|
|
paint <- imagePattern ctx (ax - 32) (ay - 58) 64 74 0
|
|
(animSprites a !! asCurrentFrame as) 1
|
|
rect ctx (ax - 32) (ay - 58) 64 74
|
|
fillPaint ctx paint
|
|
fill ctx
|
|
drawImage = do
|
|
beginPath ctx
|
|
paint <- imagePattern
|
|
ctx x (y - (74 - realToFrac tileHeight))
|
|
(realToFrac tileWidth) 74
|
|
0
|
|
(ai Map.! fromJust img)
|
|
fact
|
|
rect ctx x (y - (74 - realToFrac tileHeight)) (realToFrac tileWidth) 74
|
|
fillPaint ctx paint
|
|
fill ctx
|