module Projectile.Mine ( Mine(..)
                            , new
                            ) where

import Combat
import Animation
import Updating
import Graphics.Gloss.Data.Picture
import Graphics.Gloss.Data.Color
import Data.WrapAround
import qualified Moving as M
import ResourceTracker
import Data.Maybe
import qualified AfterEffect.MineExplosion as MineExplosion
import AfterEffect
import Common

detRadius = 100.0
punch = 1.0

data Mine =
  Mine { center :: WrapPoint
       , impacted :: Bool
       , clock :: Time
       , resourceTracker :: ResourceTracker
       , wrapMap :: WrapMap
       }

-- angle is radians
new :: ResourceTracker -> WrapMap -> WrapPoint -> Mine
new rt wmap center' =
  Mine { center = center'
       , impacted = False
       , clock = 0.0
       , resourceTracker = rt
       , wrapMap = wmap
       }

instance Animation Mine where

  image self _ =
    -- assumes t >= 0
    let t = clock self in
    let adjt = let a = t * 0.1 in
               let b = fromIntegral (truncate a) in
               let c = a - b in
               c * 10.0 in
    c adjt
    where c x | x <= 0.1 = plit
              | x > 5 && x <= 5.1 = plit
              | otherwise = p
          p = fromMaybe
                (Scale 0.20 0.20
                  (Color white
                    (Text "Error! Missing image!")))
                (getImage rt "mine.bmp")
          plit = fromMaybe
                   (Scale 0.20 0.20
                     (Color white
                       (Text "Error! Missing image!")))
                 (getImage rt "mine-lit.bmp")
          rt = resourceTracker self

  -- image self t = let r = fromInteger (ceiling (clock self)) - clock self in
  --                          Color (c r)
  --                                  (Rotate 45.0
  --                                     (Circle 2.0))
  --   where c x | x < 0.10 = red
  --             | x < 0.20 = yellow
  --             | x < 0.30 = red
  --             | x < 0.40 = yellow
  --             | x < 0.50 = red
  --             | x < 0.60 = yellow
  --             | x < 0.70 = red
  --             | x < 0.80 = yellow
  --             | x < 0.90 = red
  --             | otherwise = yellow

instance M.Colliding Mine where

  collisionRadius _ = detRadius

instance M.Moving Mine where

  velocity _ = (0.0, 0.0)

instance M.Locatable Mine where

  center self = Projectile.Mine.center self

instance SimpleTransient Mine where

  expired self = impacted self

instance InternallyUpdating Mine where

  preUpdate self t = self { clock = clock self + t }

  postUpdate self _ = self

instance Damaging Mine where

  damageEnergy _ = punch

instance Transient Mine where

  expired' self = if impacted self
                     then Just [mE]
                     else Nothing
    where mE = AfterEffect $ MineExplosion.new rt wmap center'
          rt = resourceTracker self
          wmap = wrapMap self
          center' = center self

instance Damageable Mine where

  inflictDamage self d = self { impacted = d > 0 }