module AfterEffect.MineExplosion where

import Data.WrapAround
import Animation
import Updating
import qualified Moving as M
import Graphics.Gloss.Data.Picture
import Graphics.Gloss.Data.Color
import Sound.ALUT
import Data.Maybe
import ResourceTracker
import GHC.Float
import Common

data MineExplosion =
  MineExplosion { center :: WrapPoint
                , timeRemaining :: Time
                , soundSource :: Maybe Source
                , wrapMap :: WrapMap
                , resourceTracker :: ResourceTracker
                , animClock :: Time
                }

new :: ResourceTracker -> WrapMap -> WrapPoint -> MineExplosion
new rt wmap center' =
  MineExplosion { center = center'
                , timeRemaining = 3.0
                , soundSource = Nothing
                , wrapMap = wmap
                , resourceTracker = rt
                , animClock = 0.0
                }

instance Animation MineExplosion where
  image self t =
    let dFrame = Color white (Scale 0.10 0.10 (Text "boom!")) in
    let rt = resourceTracker self in
    let at = animClock self in
    if at < 0.1 then fromMaybe dFrame $ getImage rt "mine-explosion.bmp"
    else Blank

instance M.Locatable MineExplosion where
  center = center

instance Transient MineExplosion where

  expired' self = if timeRemaining self <= 0.0
                    then Just []
                    else Nothing

instance InternallyUpdating MineExplosion where

  preUpdate self t = self { timeRemaining = timeRemaining self - t }

  postUpdate self t = self { animClock = animClock self + t }

instance Audible MineExplosion where

  processAudio self lcenter =
    if isNothing (soundSource self)
      then do self' <- initializeSoundSource self
              let (x, y) = vectorRelation
                                      (wrapMap self')
                                      (lcenter)
                                      (center self')
              let s = fromJust $ soundSource self'
              sourcePosition s $= (Vertex3 (double2Float x)
                                           (double2Float (-y))
                                           0)
              play [s]
              return self'
      else return self

  terminateAudio self =
    if isNothing (soundSource self)
      then return self
      else do stop [fromJust (soundSource self)]
              return self

initializeSoundSource self =
  do [source] <- genObjectNames 1
     buffer source $= getSound (resourceTracker self) "explosion.wav"
     sourceRelative source $= Listener
     referenceDistance source $= audioReferenceDistance
     rolloffFactor source $= audioRolloffFactor
     sourceGain source $= 0.5
     return self { soundSource = Just source }