#include "system.h"

#include "stratdef.h"

#include "bh_deathvol.h"

#include "dynamics.h"

#include "weapons.h"

#include <assert.h>

#include "equipmnt.h"

#include <stdlib.h>

extern int NumActiveBlocks;

extern DISPLAYBLOCK* ActiveBlockList[];

void DeathVolumeBehaveInit(void* bhdata,STRATEGYBLOCK* sbptr)

{

    assert(sbptr);

    assert(bhdata);

    DEATH_VOLUME_BEHAV_BLOCK* dv_bhv = malloc(sizeof(DEATH_VOLUME_BEHAV_BLOCK));

    if(dv_bhv)

    {

        sbptr->dataptr = dv_bhv;

        dv_bhv->bhvr_type = I_BehaviourDeathVolume;

        DEATH_VOLUME_TOOLS_TEMPLATE* dv_tt = (DEATH_VOLUME_TOOLS_TEMPLATE*)bhdata;

        //copy stuff from tools template

        COPY_NAME(sbptr->SBname, dv_tt->nameID);

        dv_bhv->volume_min = dv_tt->volume_min;

        dv_bhv->volume_max = dv_tt->volume_max;

        dv_bhv->damage_per_second = dv_tt->damage_per_second;

        dv_bhv->active = dv_tt->active;

        dv_bhv->collision_required = dv_tt->collision_required;

    }

    else

    {

        RemoveBehaviourStrategy(sbptr);

    }

}

void DeathVolumeBehaveFun(STRATEGYBLOCK* vol_sbptr)

{

     assert(vol_sbptr);

    DEATH_VOLUME_BEHAV_BLOCK* dv_bhv = (DEATH_VOLUME_BEHAV_BLOCK*)vol_sbptr->dataptr;

    assert((dv_bhv->bhvr_type == I_BehaviourDeathVolume));

    if(dv_bhv->active)

    {

        int miny,maxy;

        int i=0;

        for(; i < NumActiveBlocks; i++)

        {

            //search for objects that have has a collision this frame

            //(or all objects if collisions aren't required)

            DISPLAYBLOCK* dptr = ActiveBlockList[i];

            STRATEGYBLOCK* sbPtr = ActiveBlockList[i]->ObStrategyBlock;

            if(!sbPtr || !sbPtr->DynPtr)

                continue;

            DYNAMICSBLOCK* dynPtr = sbPtr->DynPtr;

            if(dv_bhv->collision_required)

            {

                if(!dynPtr->CollisionReportPtr)

                    continue;

            }

            //is the object within the death volume?

            //check a vertical line against the death volume's bounding box

            //first check the object's centre x and centre z values against the volume

            if(dptr->ObWorld.vx < dv_bhv->volume_min.vx)

                continue;

            if(dptr->ObWorld.vx > dv_bhv->volume_max.vx)

                continue;

            if(dptr->ObWorld.vz < dv_bhv->volume_min.vz)

                continue;

            if(dptr->ObWorld.vz > dv_bhv->volume_max.vz)

                continue;

            //now check  the object's vertical extents for overlap with the death volume bounding box

            miny = dptr->ObWorld.vy + dptr->extent.min_y;

            maxy = dptr->ObWorld.vy + dptr->extent.max_y;

            if(max(miny, dv_bhv->volume_min.vy) > min(maxy, dv_bhv->volume_max.vy))

                continue;

            /*

            if(dynPtr->Position.vx > dv_bhv->volume_min.vx &&

               dynPtr->Position.vx < dv_bhv->volume_max.vx &&

               dynPtr->Position.vz > dv_bhv->volume_min.vz &&

               dynPtr->Position.vz < dv_bhv->volume_max.vz &&

               dynPtr->Position.vy > dv_bhv->volume_min.vy &&

               dynPtr->Position.vy < dv_bhv->volume_max.vy)

            */

            {

                //finally see if the object is one of the types that can be harmed by the death volume

                switch(sbPtr->type)

                {

                    case I_BehaviourAlien:

                    case I_BehaviourMarine:

                    case I_BehaviourMarinePlayer:

                    case I_BehaviourPredatorPlayer:

                    case I_BehaviourAlienPlayer: 

                    case I_BehaviourPredator:

                    case I_BehaviourFaceHugger:

                    case I_BehaviourXenoborg:

                    case I_BehaviourQueenAlien:

                    {

                        extern int myNetworkKillerId;

                        extern int AVPDPNetID;

                        //this is a neutral source of damage (for cooperative multiplayer games)

                        myNetworkKillerId = 0;

                        if(dv_bhv->damage_per_second)

                        {

                            VECTORCH direction = {0, -ONE_FIXED, 0};

                            DAMAGE_PROFILE damage = {0,0,1,0,0,0,0,0,0,0,0,AMMO_NONE};

                            damage.Penetrative = dv_bhv->damage_per_second;

                            CauseDamageToObject(sbPtr, &damage, NormalFrameTime, &direction);

                        }

                        else

                        {

                            //kill the creature/player

                            VECTORCH direction = {0, -ONE_FIXED, 0};

                            CauseDamageToObject(sbPtr, &damage_profiles[CERTAINDEATH], ONE_FIXED, &direction);

                        }

                        //reset network killer id

                        myNetworkKillerId = AVPDPNetID;

                    }

                    default:

                    break;

                }

            }

        }

    }

}

/*--------------------**

** Loading and Saving **

**--------------------*/

#include "savegame.h"

typedef struct death_volume_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    int active;

} DEATH_VOLUME_SAVE_BLOCK;

void LoadStrategy_DeathVolume(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    DEATH_VOLUME_SAVE_BLOCK* block = (DEATH_VOLUME_SAVE_BLOCK*) header; 

    //check the size of the save block

    if(header->size != sizeof(*block))

        return;

    //find the existing strategy block

    STRATEGYBLOCK* sbPtr = FindSBWithName(header->SBname);

    if(!sbPtr)

        return;

    //make sure the strategy found is of the right type

    if(sbPtr->type != I_BehaviourDeathVolume)

        return;

    DEATH_VOLUME_BEHAV_BLOCK* dv_bhv = (DEATH_VOLUME_BEHAV_BLOCK*)sbPtr->dataptr;

    //start copying stuff

     dv_bhv->active = block->active;

}

void SaveStrategy_DeathVolume(STRATEGYBLOCK* sbPtr)

{

    DEATH_VOLUME_SAVE_BLOCK *block;

    DEATH_VOLUME_BEHAV_BLOCK* dv_bhv = (DEATH_VOLUME_BEHAV_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //start copying stuff

     block->active = dv_bhv->active;

}