#include "system.h"

#include "stratdef.h"

#include "bh_types.h"

#include "weapons.h"

#include "switchdoor.h"

#include "savegame.h"

#include <assert.h>

#include <stdlib.h>

extern void UpdateMorphing(MORPHCTRL *mcptr);

/*---------------------Patrick 12/3/97-------------------------

  Initialisation of a switch door....

  NB asumes that all switch doors start in a 'closed' state

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

void InitialiseSwitchDoor(void* bhdata, STRATEGYBLOCK* sbPtr)

{

    /* create a switch door data block */

    SWITCH_DOOR_BEHAV_BLOCK *switchDoorBehaviourPtr = malloc(sizeof(SWITCH_DOOR_BEHAV_BLOCK));

    if (!switchDoorBehaviourPtr)

    {

        RemoveBehaviourStrategy(sbPtr);

        return;

    }

    switchDoorBehaviourPtr->myBehaviourType = I_BehaviourSwitchDoor;

    sbPtr->dataptr = (void *)switchDoorBehaviourPtr;    

    /* cast the tools data for access */

    SWITCH_DOOR_TOOLS_TEMPLATE *switchDoorToolsData = (SWITCH_DOOR_TOOLS_TEMPLATE *)bhdata;    

    /* Set up a new Morph Control */

    MORPHFRAME *morphFrame = malloc(sizeof(MORPHFRAME));

    if (!morphFrame)

    {

        RemoveBehaviourStrategy(sbPtr);

        return;

    }

    morphFrame->mf_shape1 = switchDoorToolsData->shapeOpen;

    morphFrame->mf_shape2 = switchDoorToolsData->shapeClosed;

    MORPHHEADER *morphHeader = malloc(sizeof(MORPHHEADER));

    if (!morphHeader)

    {

        free(morphFrame);

        RemoveBehaviourStrategy(sbPtr);

        return;

    }

    morphHeader->mph_numframes = 1;

    morphHeader->mph_maxframes = ONE_FIXED;

    morphHeader->mph_frames = morphFrame;

    MORPHCTRL *morphCtrl = malloc(sizeof(MORPHCTRL));

    if (!morphCtrl)

    {

        free(morphFrame);

        free(morphHeader);

        RemoveBehaviourStrategy(sbPtr);

        return;

    }

    morphCtrl->ObMorphCurrFrame = 0;

    morphCtrl->ObMorphFlags = 0;

    morphCtrl->ObMorphSpeed = 0;

    morphCtrl->ObMorphHeader = morphHeader;

    switchDoorBehaviourPtr->morfControl = sbPtr->morphctrl = morphCtrl;

    /* set up my module, and it's morph controls */

    COPY_NAME(sbPtr->SBname, switchDoorToolsData->nameID);

    {

        extern SCENEMODULE MainScene;

        MREF mref = switchDoorToolsData->myModule;

        ConvertModuleNameToPointer(&mref, MainScene.sm_marray);

        assert(mref.mref_ptr);

        assert(mref.mref_ptr->m_mapptr);

        mref.mref_ptr->m_sbptr = sbPtr;

        sbPtr->moptr = mref.mref_ptr;

    }

    sbPtr->moptr->m_flags &= ~m_flag_open;    

    /* set up some other behaviour block stuff */

    COPY_NAME(switchDoorBehaviourPtr->linkedDoorName, switchDoorToolsData->linkedDoorName);

    switchDoorBehaviourPtr->doorState = I_door_closed;

    switchDoorBehaviourPtr->linkedDoorPtr = NULL;

    switchDoorBehaviourPtr->requestOpen = 0;

    switchDoorBehaviourPtr->requestClose = 0;

    switchDoorBehaviourPtr->openTimer = 0;

    switchDoorBehaviourPtr->SoundHandle = SOUND_NOACTIVEINDEX;

    CloseDoor(sbPtr->morphctrl, DOOR_CLOSEFASTSPEED);    

    {

        // Work out the door sound pitch

        int maxX = mainshapelist[morphFrame->mf_shape2]->shapemaxx;

        int maxY = mainshapelist[morphFrame->mf_shape2]->shapemaxy;

        int maxZ = mainshapelist[morphFrame->mf_shape2]->shapemaxz;

        int doorSize = maxX + maxY + maxZ;

        if (doorSize < 3000)

            doorSize = 3000;

        else if (doorSize > 8000)

            doorSize = 8000;

        doorSize = (3000 - doorSize) >> 4;

        switchDoorBehaviourPtr->doorType = doorSize; 

    }

}

int AnythingInMyModule(MODULE* my_mod)

{

    // simple overlap test

    // this used within level - find objects in module

    // all will have sbs

    int i = 0;

    int max_x = my_mod->m_maxx + my_mod->m_world.vx;

    int min_x = my_mod->m_minx + my_mod->m_world.vx;

    int max_y = my_mod->m_maxy + my_mod->m_world.vy;

    int min_y = my_mod->m_miny + my_mod->m_world.vy;

    int max_z = my_mod->m_maxz + my_mod->m_world.vz;

    int min_z = my_mod->m_minz + my_mod->m_world.vz;

    for(; i < NumActiveStBlocks; i++)

    {

        STRATEGYBLOCK *sbptr = ActiveStBlockList[i];

        DYNAMICSBLOCK *dynptr = sbptr->DynPtr;

        if(dynptr)

        {

            VECTORCH obj_world = dynptr->Position;

            if((obj_world.vx < max_x) && (obj_world.vx > min_x)

            && (obj_world.vz < max_z) && (obj_world.vz > min_z)

            && (obj_world.vy < max_y) && (obj_world.vy > min_y))

            {

                CauseDamageToObject(sbptr, &damage_profiles[FALLINGDAMAGE], (100 * NormalFrameTime), NULL);

                return sbptr->DamageBlock.Indestructable;

            }

        }

    }

return 0;

}

/*---------------------Patrick 13/3/97-------------------------

  Switch door behaviour function.

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

void SwitchDoorBehaviour(STRATEGYBLOCK* sbPtr)

{

    int linkedDoorIsClosed = 1;

     assert(sbPtr);

    SWITCH_DOOR_BEHAV_BLOCK *doorBehaviour = (SWITCH_DOOR_BEHAV_BLOCK*)sbPtr->dataptr;

    assert(doorBehaviour);

    MORPHCTRL *mCtrl = doorBehaviour->morfControl;

    assert(mCtrl);

    MODULE *mPtr = sbPtr->moptr;

    assert(mPtr);

    /* update morphing.... */

    UpdateMorphing(mCtrl);

     /* get state of linked door: if there isn't a linked door, 'linkeddoorisclosed' 

     remains true so that there is no obstruction to operation of this door.

     NB can't use 'GetState' here, as it returns true only if the door is fully open

     (used by the NPC's).  Here, we need to determine if the door is closed (which is 

     not the same as !open) */

    if(doorBehaviour->linkedDoorPtr)

    {

        if(((SWITCH_DOOR_BEHAV_BLOCK *)doorBehaviour->linkedDoorPtr->dataptr)->doorState != I_door_closed)

                linkedDoorIsClosed = 0;

     }

     switch(doorBehaviour->doorState)

    {

        case I_door_opening:

        {    

            /* assert(linkedDoorIsClosed);    */

            /* check if we've got a close request */

            if(doorBehaviour->requestClose && !AnythingInMyModule(sbPtr->moptr)) 

            {

                if(sbPtr->DisplayBlock)

                    CloseDoor(mCtrl, DOOR_CLOSESLOWSPEED);

                else

                    CloseDoor(mCtrl, DOOR_CLOSEFASTSPEED);

                doorBehaviour->doorState = I_door_closing;

            }

            else if(mCtrl->ObMorphFlags & mph_flag_finished) 

            {

                /* already opening, so just allow the door to continue... */

                //door has finished opening

                doorBehaviour->doorState = I_door_open;

                doorBehaviour->openTimer = DOOR_FAROPENTIME;

                if (doorBehaviour->SoundHandle != SOUND_NOACTIVEINDEX)

                {

                    Sound_Play(SID_DOOREND, "dp", &mPtr->m_world,doorBehaviour->doorType);

                        Sound_Stop(doorBehaviour->SoundHandle);

                }

            }

        }

        break;

        case I_door_closing:

        {

            /* assert(linkedDoorIsClosed);    */

            /* check if we've got an open request, or anything has jumped in */

            if(doorBehaviour->requestOpen || AnythingInMyModule(sbPtr->moptr))

            {

                //have to start opening again

                if(sbPtr->DisplayBlock)

                    OpenDoor(mCtrl, DOOR_OPENSLOWSPEED);

                else

                    OpenDoor(mCtrl, DOOR_OPENFASTSPEED);

                doorBehaviour->doorState = I_door_opening;

                Sound_Play(SID_DOORSTART, "dp", &mPtr->m_world, doorBehaviour->doorType);

                 Sound_Play(SID_DOORMID, "delp", &mPtr->m_world, &doorBehaviour->SoundHandle, doorBehaviour->doorType);

            }

            else if(mCtrl->ObMorphFlags & mph_flag_finished)

            {

                /* check if we've finished closing */

                doorBehaviour->doorState = I_door_closed;

                mPtr->m_flags &= ~m_flag_open;

                if (doorBehaviour->SoundHandle!=SOUND_NOACTIVEINDEX)

                {

                    Sound_Play(SID_DOOREND,"dp",&mPtr->m_world,doorBehaviour->doorType);

                        Sound_Stop(doorBehaviour->SoundHandle);

                }

            }

        }

        break;

        case I_door_open:

        {

            /* assert(linkedDoorIsClosed);    */        

            /*if we've got a close request , set the open timer to 0 

                so the door will start closing*/

            if(doorBehaviour->requestClose)

                doorBehaviour->openTimer = 0;

            /* check our timer to see if it's time to close*/

            if(doorBehaviour->openTimer <= 0)

            {

                /* make sure there's nothing inside the door module before closing */

                if(!AnythingInMyModule(sbPtr->moptr))

                {

                    if(sbPtr->DisplayBlock)

                        CloseDoor(mCtrl, DOOR_CLOSESLOWSPEED);

                    else

                        CloseDoor(mCtrl, DOOR_CLOSEFASTSPEED);

                    doorBehaviour->doorState = I_door_closing;

                    doorBehaviour->openTimer = 0;

                    Sound_Play(SID_DOORSTART, "dp", &mPtr->m_world, doorBehaviour->doorType);

                     Sound_Play(SID_DOORMID, "delp", &mPtr->m_world, &doorBehaviour->SoundHandle, doorBehaviour->doorType);

                }

            }

            else

            {

                doorBehaviour->openTimer -= NormalFrameTime;

            }

        }

        break;

        case I_door_closed:

        {

            if(doorBehaviour->requestOpen && linkedDoorIsClosed)

            {

                /* just open the door */

                if(sbPtr->DisplayBlock)

                    OpenDoor(mCtrl, DOOR_OPENSLOWSPEED);

                else

                    OpenDoor(mCtrl, DOOR_OPENFASTSPEED);

                doorBehaviour->doorState = I_door_opening;

                mPtr->m_flags |= m_flag_open;

                Sound_Play(SID_DOORSTART,"dp",&mPtr->m_world,doorBehaviour->doorType);

                 Sound_Play(SID_DOORMID,"delp",&mPtr->m_world,&doorBehaviour->SoundHandle,doorBehaviour->doorType);

            }

        }

    }

    /* must reset this every frame */

    doorBehaviour->requestOpen = 0;

    doorBehaviour->requestClose = 0;

}

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

** Loading and Saving **

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

typedef struct switch_door_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    DOOR_STATES doorState;

    int openTimer;

    unsigned int requestOpen :1;

    unsigned int requestClose :1;

    //from the morph control

    int ObMorphCurrFrame;

    int ObMorphFlags;

    int ObMorphSpeed;

} SWITCH_DOOR_SAVE_BLOCK;

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV doorbhv

void LoadStrategy_SwitchDoor(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    SWITCH_DOOR_SAVE_BLOCK* block = (SWITCH_DOOR_SAVE_BLOCK*) header; 

    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_BehaviourSwitchDoor)

        return;

    SWITCH_DOOR_BEHAV_BLOCK *doorbhv = (SWITCH_DOOR_BEHAV_BLOCK*)sbPtr->dataptr;

    COPYELEMENT_LOAD(doorState)

    COPYELEMENT_LOAD(openTimer)

    COPYELEMENT_LOAD(requestOpen)

    COPYELEMENT_LOAD(requestClose)

    doorbhv->morfControl->ObMorphCurrFrame = block->ObMorphCurrFrame;

    doorbhv->morfControl->ObMorphFlags = block->ObMorphFlags;

    doorbhv->morfControl->ObMorphSpeed = block->ObMorphSpeed;

    Load_SoundState(&doorbhv->SoundHandle);

}

void SaveStrategy_SwitchDoor(STRATEGYBLOCK* sbPtr)

{

    SWITCH_DOOR_SAVE_BLOCK *block;

    SWITCH_DOOR_BEHAV_BLOCK *doorbhv = (SWITCH_DOOR_BEHAV_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    COPYELEMENT_SAVE(doorState)

    COPYELEMENT_SAVE(openTimer)

    COPYELEMENT_SAVE(requestOpen)

    COPYELEMENT_SAVE(requestClose)

    block->ObMorphCurrFrame = doorbhv->morfControl->ObMorphCurrFrame;

    block->ObMorphFlags = doorbhv->morfControl->ObMorphFlags;

    block->ObMorphSpeed = doorbhv->morfControl->ObMorphSpeed;

    Save_SoundState(&doorbhv->SoundHandle);

}