//
// Copyright(C) 2014-2015 Samuel Villarreal
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// DESCRIPTION:
//      Animal Script Object Classes
//

#include "scripts/animations.txt"

#include "scripts/bosses/BP_longhunter.txt"
#include "scripts/bosses/BP_mantis.txt"
#include "scripts/bosses/BP_trex.txt"
#include "scripts/bosses/BP_campainger.txt"
#include "scripts/bosses/BP_hummer.txt"

/*
==============================================================
GenericAnimal
==============================================================
*/

class GenericAnimal : ScriptObject
{
    kActor @self;
    float m_deathFreezeTime;
    
    GenericAnimal(kActor @actor)
    {
        @self = actor;
        m_deathFreezeTime = 0;
    }
    
    ~GenericAnimal()
    {
    }
    
    /*
    ==============================================================
    OnTick
    ==============================================================
    */
    
    void OnTick(void)
    {
        if((self.Flags() & AF_DEAD) != 0)
        {
            if(m_deathFreezeTime > 0)
            {
                m_deathFreezeTime -= GAME_DELTA_TIME;
                
                if(m_deathFreezeTime <= 0)
                {
                    Game.SpawnFx("fx/freeze_explosion.kfx", self.Origin(), self.SectorIndex());
                    self.Remove();
                }
            }
        }
    }
    
    /*
    ==============================================================
    OnDamage
    ==============================================================
    */
    
    void OnDamage(kActor @instigator, kDictMem @damageDef, const int damage)
    {
        bool bValue;
        
        if(damageDef is null)
        {
            return;
        }
        
        if(damageDef.GetBool("bAccelerator", bValue) && bValue == true)
        {
            self.AnimState().flags |= (ANF_PAUSED|ANF_NOINTERRUPT);
            m_deathFreezeTime = 3.0f;
            self.RunFxEvent("Enemy_Freeze");
            Game.SpawnFx("fx/freeze_start.kfx", self.Origin(), self.SectorIndex());
        }
    }
    
    /*
    ==============================================================
    OnSpawn
    ==============================================================
    */
    
    void OnSpawn(void)
    {		
        self.Flags() |= AF_DEAD;
    }
};

/*
==============================================================
TurokAnimal
==============================================================
*/

class TurokAnimal : ScriptObject
{
    kActor @self;
    float thresholdTime;
    float turnOffset;
    
    TurokAnimal(kActor @actor)
    {
        @self = actor;
        thresholdTime = 0.0f;
    }
    
    ~TurokAnimal()
    {
    }
    
    /*
    ==============================================================
    CheckSight
    ==============================================================
    */
    
    bool CheckSight(void)
    {     
        float fov = self.GetTurnYaw(Player.Actor().Origin());      
        return (Math::Fabs(fov) <= 45.0f && self.CanSee(Player.Actor()));
    }
    
    /*
    ==============================================================
    OnTick
    ==============================================================
    */
    
    void OnTick(void)
    {
        if(thresholdTime > 0.0f)
        {
            thresholdTime -= GAME_DELTA_TIME;
            
            kAngle an = -Player.Actor().Yaw() + Math::pi - turnOffset;
            
            float x = self.Origin().x + (Math::Sin(an) * 307.2f);
            float y = self.Origin().y + (Math::Cos(an) * 307.2f);
            
            kAngle newYaw = self.GetAvoidanceAngle(kVec3(x, y, self.Origin().z), 1.0f);
            
            self.Yaw() = (newYaw - self.Yaw()) * 0.05f + self.Yaw();
            
            if(thresholdTime <= 0.0f)
            {
                self.AnimState().Blend(anim_aiStanding, 4.0f, 8.0f, ANF_LOOP|ANF_ROOTMOTION);
            }
        }
        else
        {
            if((PlayLoop.Ticks() & 0x1F) != 0)
            {
                return;
            }
            
            if(self.Origin().DistanceSq(Player.Actor().Origin()) >= 262144.0f)
            {
                return;
            }
            
            if(CheckSight())
            {
                thresholdTime = (100.0f * Math::RandFloat()) * 0.02f + 5.0f;
                self.AnimState().Blend(anim_aiRunning, 4.0f, 8.0f, ANF_LOOP|ANF_ROOTMOTION);
            }
        }
    }
    
    /*
    ==============================================================
    OnDamage
    ==============================================================
    */
    
    void OnDamage(kActor @instigator, kDictMem @damageDef, const int damage)
    {
        kActor @item = ActorFactory.Spawn("Health_Small",
                                          self.Origin().x,
                                          self.Origin().y,
                                          self.Origin().z + 32.0f,
                                          0, self.SectorIndex());
                                          
        item.Gravity() = 0.5f;
        item.BounceDamp() = 0.5f;
        item.ClipFlags() = (CF_DROPOFF|CF_CLIPEDGES|CF_NOCLIPACTORS|CF_COLLIDEFLOORS|CF_COLLIDEHEIGHT);
        item.Velocity().x = Math::RandCFloat() * 4.096f;
        item.Velocity().y = Math::RandCFloat() * 4.096f;
        item.Velocity().z = 4.096f + (Math::RandFloat() * 4.096f);
        
        item.RunFxEvent("Item_Spawn");
    }
    
    /*
    ==============================================================
    OnDeath
    ==============================================================
    */
    
    void OnDeath(kActor @killer, kDictMem @damageDef)
    {
        kVec3 org = self.Origin();
        org.z += 51.2f;
        
        self.PlaySound("sounds/shaders/generic_3_energy_pickup.ksnd");
        Game.SpawnFx("fx/generic_260.kfx", org, self.SectorIndex());
        
        self.MarkPersistentBit(false);
        self.Remove();
    }
    
    /*
    ==============================================================
    OnSpawn
    ==============================================================
    */
    
    void OnSpawn(void)
    {
        if((Math::RandByte() & 0x3) != 0)
        {
            turnOffset = 0.7854f;
        }
    }
    
    /*
    ==============================================================
    OnRestore
    ==============================================================
    */
    
    void OnRestore(void)
    {
        self.Remove();
    }
};

/*
==============================================================
TurokFish
==============================================================
*/

class TurokFish : ScriptObject
{
    kActor @self;
    kVec3 spawnOrigin;
    float thresholdTime;
    
    TurokFish(kActor @actor)
    {
        @self = actor;
        thresholdTime = 0.0f;
    }
    
    ~TurokFish()
    {
    }
    
    /*
    ==============================================================
    CheckSight
    ==============================================================
    */
    
    bool CheckSight(void)
    {     
        float fov = self.GetTurnYaw(Player.Actor().Origin());      
        return (Math::Fabs(fov) <= 45.0f && self.CanSee(Player.Actor()));
    }
    
    /*
    ==============================================================
    OnTick
    ==============================================================
    */
    
    void OnTick(void)
    {
        if(thresholdTime > 0.0f)
        {
            thresholdTime -= GAME_DELTA_TIME;
            
            kAngle an = Player.Actor().Yaw() + Math::pi;
            
            float x = self.Origin().x + (Math::Sin(an) * 614.4f);
            float y = self.Origin().y + (Math::Cos(an) * 614.4f);
            
            an = self.Yaw() + self.GetTurnYaw(kVec3(x, y, self.Origin().z));
            self.Yaw() = (an - self.Yaw()) * 0.035f + self.Yaw();
            
            if(thresholdTime <= 0.0f)
            {
                self.AnimState().Blend(anim_aiSwim1, Math::RandRange(2.0f, 8.0f), 10.0f, ANF_LOOP|ANF_ROOTMOTION);
            }
        }
        else
        {
            kAngle newYaw = self.GetAvoidanceAngle(spawnOrigin, 4.0f);
            
            self.Yaw() = (newYaw - self.Yaw()) * 0.01f + self.Yaw();
            
            if((self.AnimState().flags & ANF_BLEND) != 0)
            {
                return;
            }
            
            if((PlayLoop.Ticks() & 0x1FF) != 0)
            {
                return;
            }
            
            if(self.Origin().DistanceSq(Player.Actor().Origin()) >= 262144.0f)
            {
                return;
            }
                
            if(CheckSight())
            {
                thresholdTime = (100.0f * Math::RandFloat()) * 0.02f + 5.0f;
                self.AnimState().Blend(anim_aiSwim6, 6.0f, 10.0f, ANF_LOOP|ANF_ROOTMOTION);
            }
        }
    }
    
    /*
    ==============================================================
    OnBeginLevel
    ==============================================================
    */
    
    void OnBeginLevel(void)
    {
        float fh = self.FloorHeight();
        
        self.AnimState().Set(anim_aiSwim1, Math::RandRange(2.0f, 8.0f), ANF_LOOP|ANF_ROOTMOTION);
        spawnOrigin = self.Origin();
        
        self.Origin().z = (self.GetWaterHeight() - fh) * Math::RandRange(0.2f, 0.8f) + fh;
    }
    
    /*
    ==============================================================
    OnSpawn
    ==============================================================
    */
    
    void OnSpawn(void)
    {
    }
};

/*
==============================================================
TurokAnimalRaptor
==============================================================
*/

class TurokAnimalRaptor : ScriptObject
{
    kActor @self;
    float thresholdTime;
    float turnOffset;
	float randYaw;
    
    TurokAnimalRaptor(kActor @actor)
    {
        @self = actor;
        thresholdTime = 0.0f;
    }
    
    ~TurokAnimalRaptor()
    {
    }
    
    /*
    ==============================================================
    OnTick
    ==============================================================
    */
    
    void OnTick(void)
    {
        if (thresholdTime > 0.0f)
        {
            thresholdTime -= GAME_DELTA_TIME;
            
            kAngle an = -randYaw + Math::pi - turnOffset;
            
            float x = self.Origin().x + (Math::Sin(an) * 307.2f);
            float y = self.Origin().y + (Math::Cos(an) * 307.2f);
            
            kAngle newYaw = self.GetAvoidanceAngle(kVec3(x, y, self.Origin().z), 1.0f);
            
            self.Yaw() = (newYaw - self.Yaw()) * 0.05f + self.Yaw();
            
            if (thresholdTime <= 0.0f)
            {
                self.AnimState().Blend(anim_aiStanding, 4.0f, 8.0f, ANF_LOOP|ANF_ROOTMOTION);
            }
        }
        else
        {
            if ((PlayLoop.Ticks() & 0xFF) != 0)
            {
                return;
            }
            
            if (self.Origin().DistanceSq(Player.Actor().Origin()) >= 1000000.0f)
            {
                return;
            }
			
			randYaw = Math::RandMax(360);
			thresholdTime = (100.0f * Math::RandFloat()) * 0.02f + 5.0f;
			self.AnimState().Blend(anim_aiWalking, 4.0f, 8.0f, ANF_LOOP|ANF_ROOTMOTION);
        }
    }
    
    /*
    ==============================================================
    OnDeath
    ==============================================================
    */
    // void OnDeath(kActor @killer, kDictMem @damageDef)
    // {
        // self.MarkPersistentBit(false);
    // }
    
    /*
    ==============================================================
    OnSpawn
    ==============================================================
    */
    void OnSpawn(void)
    {
		self.Flags() |= AF_INVINCIBLE;

        if ((Math::RandByte() & 0x3) != 0)
        {
            turnOffset = 0.7854f;
        }
    }
    
    /*
    ==============================================================
    OnRestore
    ==============================================================
    */
    void OnRestore(void)
    {
        // self.Remove();
    }
};
