#include "system.h"

#include "stratdef.h"

#include "weapons.h"

#include "platformlift.h"

#include "pldghost.h"

#include "bh_types.h"

#include <stdlib.h>

#include <assert.h>

static void SquashingSomething_for_sure(DYNAMICSBLOCK *dynPtr)

{

    struct collisionreport *nextReport = dynPtr->CollisionReportPtr;

    while(nextReport)

    {

        STRATEGYBLOCK *sbPtr = nextReport->ObstacleSBPtr;

        if(NULL != sbPtr)

        {

            sbPtr->DamageBlock.Indestructable = 0;

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

        }

        nextReport = nextReport->NextCollisionReportPtr;

    }

}

static void SquashingSomething(DYNAMICSBLOCK *dynPtr)

{

    struct collisionreport *nextReport = dynPtr->CollisionReportPtr;

    /* walk the collision report list, looking for collisions against objects */

    while(nextReport)

    {

        STRATEGYBLOCK *sbPtr = nextReport->ObstacleSBPtr;

        if(NULL != sbPtr)

        {

            if(nextReport->ObstacleNormal.vy < -46340)

            {

                /* squish! */

                sbPtr->DamageBlock.Indestructable = 0;

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

            }

            else if (nextReport->ObstacleNormal.vy > 46340)

            {

                DYNAMICSBLOCK *objDynPtr = sbPtr->DynPtr;

                if (objDynPtr && (objDynPtr->LinImpulse.vy < PLATFORMLIFT_SPEED))

                    objDynPtr->LinImpulse.vy += PLATFORMLIFT_SPEED;

            }

        }

        nextReport = nextReport->NextCollisionReportPtr;

    } 

}

static int PlayerIsNearOtherTerminal(STRATEGYBLOCK *sbPtr)

{

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    assert(platformliftdata->state == PLBS_AtRest);

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    int averageHeight = (platformliftdata->upHeight + platformliftdata->downHeight)/2;

    if(dynPtr->Position.vy > averageHeight)

    {

        if (PlayerStatus.sbptr->DynPtr->Position.vy < averageHeight)

            return 1;

    }

    else if (PlayerStatus.sbptr->DynPtr->Position.vy > averageHeight)

    {

        return 1;

    }

return 0;

}

static int ActivatedByPlayer(DYNAMICSBLOCK *dynPtr)

{

        struct collisionreport *nextReport = dynPtr->CollisionReportPtr;

        /* walk the collision report list, looking for collisions against objects */

        while(nextReport)

        {

        //printf("collision with %p\n",nextReport->ObstacleSBPtr);

        if(nextReport->ObstacleSBPtr == PlayerStatus.sbptr)

            return 1;

        nextReport = nextReport->NextCollisionReportPtr;

        }

return 0;

}

static int PLiftIsNearerUpThanDown(STRATEGYBLOCK *sbPtr)

{

    assert(sbPtr);

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    assert(sbPtr->DynPtr);

    int upDist = sbPtr->DynPtr->Position.vy - platformliftdata->upHeight;

    int downDist = platformliftdata->downHeight - sbPtr->DynPtr->Position.vy;

return (upDist < downDist);

}

/* returns 1 if the player or a remote player is within 5 m of the other end of the lift track...*/

static int NetPlayerAtOtherTerminal(STRATEGYBLOCK *sbPtr)

{

    int sbIndex = 0;

    VECTORCH otherTerminal;

    assert(sbPtr);

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    assert(platformliftdata);

    assert(platformliftdata->state == PLBS_AtRest);

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    assert(dynPtr);

    if(PLiftIsNearerUpThanDown(sbPtr))

    {

        otherTerminal = dynPtr->Position;

        otherTerminal.vy = platformliftdata->downHeight;

    }

    else

    {

        otherTerminal = dynPtr->Position;

        otherTerminal.vy = platformliftdata->upHeight;    

    }

    while(sbIndex < NumActiveStBlocks)

    {

        STRATEGYBLOCK *sbPtr = ActiveStBlockList[sbIndex++];

        if(sbPtr->type == I_BehaviourNetGhost)

        {

            NETGHOSTDATABLOCK *ghostData =     ghostData = (NETGHOSTDATABLOCK *)sbPtr->dataptr;

            assert(ghostData);

            switch(ghostData->type)

            {

                case I_BehaviourMarinePlayer:

                case I_BehaviourAlienPlayer:

                case I_BehaviourPredatorPlayer:

                {

                    /* remote player */

                    assert(sbPtr->DynPtr);

                    if(VectorDistance(&(sbPtr->DynPtr->Position),&(otherTerminal)) < 5000)

                        return 1;

                }

                default:

                break;

            }

        }

        else if(sbPtr == PlayerStatus.sbptr)

        {

            /* local player */

            assert(sbPtr->DynPtr);

            if(VectorDistance(&sbPtr->DynPtr->Position, &otherTerminal) < 5000)

                return 1;

        }

    }

return 0;

}

static void StopPlatformLift(STRATEGYBLOCK *sbPtr)

{

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    sbPtr->DynPtr->Displacement.vx = sbPtr->DynPtr->Displacement.vy = sbPtr->DynPtr->Displacement.vz = 0;

    platformliftdata->state = PLBS_AtRest;

    /* just to stop drift... */

    /*

    if(PLiftIsNearerUpThanDown(sbPtr))

        sbPtr->DynPtr->Position.vy = platformliftdata->upHeight;

    else

        sbPtr->DynPtr->Position.vy = platformliftdata->downHeight;

    */

    platformliftdata->netMsgCount = PLATFORMLIFT_NUMNETMESSAGES;

    //stop sound if the lift has any

    if(platformliftdata->sound)

        Stop_Track_Sound(platformliftdata->sound);

    //start end sound if lift has any

    if(platformliftdata->end_sound)

        Start_Track_Sound(platformliftdata->end_sound,&sbPtr->DynPtr->Position);

    if (platformliftdata->OneUse)

        platformliftdata->Enabled = 0;

}

static void SendPlatformLiftUp(STRATEGYBLOCK *sbPtr)

{

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    platformliftdata->state = PLBS_GoingUp;

    sbPtr->DynPtr->Displacement.vx = sbPtr->DynPtr->Displacement.vz = 0;

    platformliftdata->netMsgCount = PLATFORMLIFT_NUMNETMESSAGES;

    sbPtr->DynPtr->Displacement.vy = -MUL_FIXED(PLATFORMLIFT_SPEED, NormalFrameTime);

    {

        int d = platformliftdata->upHeight - sbPtr->DynPtr->Position.vy;

         if (d > sbPtr->DynPtr->Displacement.vy)

             sbPtr->DynPtr->Displacement.vy = d;

    }

}

static void SendPlatformLiftDown(STRATEGYBLOCK *sbPtr)

{

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    platformliftdata->state = PLBS_GoingDown;

    sbPtr->DynPtr->Displacement.vx = sbPtr->DynPtr->Displacement.vz = 0;

    platformliftdata->netMsgCount = PLATFORMLIFT_NUMNETMESSAGES;

    sbPtr->DynPtr->Displacement.vy = MUL_FIXED(PLATFORMLIFT_SPEED, NormalFrameTime);

    int d = platformliftdata->downHeight - sbPtr->DynPtr->Position.vy;

    if (d < sbPtr->DynPtr->Displacement.vy)

        sbPtr->DynPtr->Displacement.vy = d;

}

static int LiftDoorClosed(STRATEGYBLOCK *sbPtr)

{

    int i;

    for(i = 0; i < NumActiveStBlocks; i++)

    {

        STRATEGYBLOCK *candidate = ActiveStBlockList[i];

        if((NULL != candidate->DisplayBlock) && (I_BehaviourProximityDoor== candidate->type))

        {

            #define DOOR_OPENDISTANCE  (3000)

            PROXDOOR_BEHAV_BLOCK *doorbhv = (PROXDOOR_BEHAV_BLOCK*)candidate->dataptr;

            MODULE *mptr = candidate->moptr;

            int maxY = mptr->m_world.vy + mptr->m_maxy;

            int minY = mptr->m_world.vy + mptr->m_miny;

            int maxX = mptr->m_world.vx + DOOR_OPENDISTANCE;

            int minX = mptr->m_world.vx - DOOR_OPENDISTANCE;

            int maxZ = mptr->m_world.vz + DOOR_OPENDISTANCE;

            int minZ = mptr->m_world.vz - DOOR_OPENDISTANCE;

            DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

            if ((dynPtr->Position.vy > minY && dynPtr->Position.vy < maxY)

            &&

            (dynPtr->Position.vx > minX && dynPtr->Position.vx < maxX)

            &&

            (dynPtr->Position.vz > minZ && dynPtr->Position.vz < maxZ))

            {

                return (I_door_closed == doorbhv->door_state);

            }

        }

    }

return 1;

}

/*------------------------------Patrick 2/4/97-----------------------------------

  State change functions: these are alos used by network message processing fns

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

void ActivatePlatformLift(STRATEGYBLOCK *sbPtr)

{

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    assert(platformliftdata);

    platformliftdata->state = PLBS_Activating;

    platformliftdata->activationDelayTimer = PLATFORMLIFT_ACTIVATIONTIME;

    platformliftdata->netMsgCount = PLATFORMLIFT_NUMNETMESSAGES;

}

void PlatformLiftBehaviour(STRATEGYBLOCK *sbPtr)

{

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    switch(platformliftdata->state)

    {

        case PLBS_AtRest:

        {

            switch(AvP.PlayMode)

            {

                case NetworkHost:

                {

                    if(platformliftdata->Enabled)

                    {

                        if(NetPlayerAtOtherTerminal(sbPtr))

                        {

                            ActivatePlatformLift(sbPtr);

                        }

                        else if(sbPtr->DisplayBlock)

                        {

                            /* check for activation by this player*/

                            if(ActivatedByPlayer(dynPtr))

                                ActivatePlatformLift(sbPtr);

                        }

                    }

                }

                break;

                case NetworkPeer:

                {

                    if(ActivatedByPlayer(dynPtr))

                        AddNetMsg_RequestPlatformLiftActivate(sbPtr);

                }

                break;

                default:

                {

                    /* single player */

                    if (platformliftdata->Enabled && (NULL != sbPtr->DisplayBlock))

                    {

                        /* check for activation */

                        if(ActivatedByPlayer(dynPtr) || PlayerIsNearOtherTerminal(sbPtr))

                        {

                            ActivatePlatformLift(sbPtr);

                        }

                    }

                }

            }

            //printf("Platform state: at rest\n");

        }

        break;

        case PLBS_Activating:

        {

            if(NetworkPeer != AvP.PlayMode)

            {

if(LiftDoorClosed(sbPtr))

                if(platformliftdata->activationDelayTimer > 0)

                    platformliftdata->activationDelayTimer -= NormalFrameTime;

                if(platformliftdata->activationDelayTimer <= 0)

                {

                    //play start sound if the lift has any

                    if(platformliftdata->start_sound)

                        Start_Track_Sound(platformliftdata->start_sound,&sbPtr->DynPtr->Position);

                    platformliftdata->activationDelayTimer = 0;

                    if(dynPtr->Position.vy > ((platformliftdata->upHeight+platformliftdata->downHeight) / 2))

                        SendPlatformLiftUp(sbPtr);

                    else

                        SendPlatformLiftDown(sbPtr);

                }

            }

            //printf("Platform state: activating\n");

            //printf("Platform timer: %d\n",platformliftdata->activationDelayTimer);

        }

        break;    

        case PLBS_GoingUp:

        {

            if(dynPtr->Position.vy <= platformliftdata->upHeight)

            {

                StopPlatformLift(sbPtr);

            }

            else

            {

                sbPtr->DynPtr->Displacement.vy = -MUL_FIXED(PLATFORMLIFT_SPEED, NormalFrameTime);

                {

                    int d = platformliftdata->upHeight - sbPtr->DynPtr->Position.vy;

                     if (d > sbPtr->DynPtr->Displacement.vy)

                         sbPtr->DynPtr->Displacement.vy = d;

                }

                if(dynPtr->Position.vy == dynPtr->PrevPosition.vy)

                {

                    if(NetworkPeer != AvP.PlayMode)

                        SquashingSomething_for_sure(dynPtr);

                }

            }

            //printf("Platform state: going up\n");

        }

        break; 

        case PLBS_GoingDown:

        {

            if(dynPtr->Position.vy >= platformliftdata->downHeight)

            {

                StopPlatformLift(sbPtr);

            }

            else 

            {

                sbPtr->DynPtr->Displacement.vy = MUL_FIXED(PLATFORMLIFT_SPEED, NormalFrameTime);

                {

                    int d = platformliftdata->downHeight - sbPtr->DynPtr->Position.vy;

                     if (d < sbPtr->DynPtr->Displacement.vy)

                         sbPtr->DynPtr->Displacement.vy = d;

                }

                if(NetworkPeer != AvP.PlayMode)

                    SquashingSomething(dynPtr);

            }

            //printf("Platform state: going down\n");

        }

        break; 

        default:

        assert(1==0);

    }

    //update sound

    switch(platformliftdata->state)

    {

        case PLBS_GoingUp:

        case PLBS_GoingDown:

        {

            int mainSoundShouldBePlaying = 1;

            MovePlatformLift(sbPtr);

            //the main sound should be started if there is no start sound , or the start sound has

            //almost finished

            if(platformliftdata->start_sound && platformliftdata->start_sound->playing)

            {

                Update_Track_Sound(platformliftdata->start_sound,&dynPtr->Position);

                mainSoundShouldBePlaying = 0;

            }

            if(platformliftdata->sound)

            {

                if(platformliftdata->sound->playing)

                {

                    Update_Track_Sound(platformliftdata->sound, &dynPtr->Position);

                }

                else if(mainSoundShouldBePlaying)

                {

                    Start_Track_Sound(platformliftdata->sound, &sbPtr->DynPtr->Position);

                }

            }

        }

        default:

        break;

    }

    //printf("Platform pos: %d / %d / %d\n",platformliftdata->upHeight,dynPtr->Position.vy,platformliftdata->downHeight);

    /* send state messages in net game */

    if(NetworkHost == AvP.PlayMode)

    {

        if(platformliftdata->netMsgCount > 0)

        {

            /* don't send at rest messages: peers detect end of movement locally. */

            if(platformliftdata->state != PLBS_AtRest) 

                AddNetMsg_PlatformLiftState(sbPtr);

            platformliftdata->netMsgCount--;

        }

    }

}

void InitialisePlatformLift(void* bhdata, STRATEGYBLOCK *sbPtr)

{

    PLATFORMLIFT_TOOLS_TEMPLATE *toolsData = (PLATFORMLIFT_TOOLS_TEMPLATE *)bhdata;

    /* create, initialise and attach a data block */

    PLATFORMLIFT_BEHAVIOUR_BLOCK* platformliftdata = malloc(sizeof(PLATFORMLIFT_BEHAVIOUR_BLOCK));

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_STATIC);

    if((NULL == platformliftdata) || (NULL == dynPtr))

    {

        RemoveBehaviourStrategy(sbPtr);

        return;

    }

    sbPtr->dataptr = platformliftdata; 

    platformliftdata->homePosition = toolsData->position;

    platformliftdata->activationDelayTimer = 0;

    platformliftdata->state = PLBS_AtRest;

    platformliftdata->netMsgCount = 0;

    if(toolsData->travel < 0)

    {

        platformliftdata->upHeight = platformliftdata->homePosition.vy + toolsData->travel;

        platformliftdata->downHeight = platformliftdata->homePosition.vy;

    }

    else

    {

        platformliftdata->upHeight = platformliftdata->homePosition.vy;

        platformliftdata->downHeight = platformliftdata->homePosition.vy + toolsData->travel;

    }

    assert(platformliftdata->upHeight < platformliftdata->downHeight);

    platformliftdata->sound = toolsData->sound;

    platformliftdata->start_sound = toolsData->start_sound;

    platformliftdata->end_sound = toolsData->end_sound;

    platformliftdata->Enabled = toolsData->Enabled;

    platformliftdata->OneUse = toolsData->OneUse;

    dynPtr->GravityOn = 0;

    //dynPtr->StopOnCollision = 1;

    dynPtr->IsStatic = 0;

    dynPtr->OnlyCollideWithObjects = 1;

    dynPtr->UseDisplacement = 1;

    dynPtr->PrevPosition = dynPtr->Position = toolsData->position;

    dynPtr->LinVelocity.vx = dynPtr->LinVelocity.vy = dynPtr->LinVelocity.vz = 0;

    dynPtr->OrientEuler = toolsData->orientation;

    CreateEulerMatrix(&dynPtr->OrientEuler, &dynPtr->OrientMat);

    TransposeMatrixCH(&dynPtr->OrientMat);      

    {

    int i;

    for(i=0; i < SB_NAME_LENGTH; i++)

        sbPtr->SBname[i] = toolsData->nameID[i];

    }

    sbPtr->maintainVisibility = 1;

    sbPtr->containingModule = ModuleFromPosition(&sbPtr->DynPtr->Position, NULL);

    if(NULL == sbPtr->containingModule)

    {

        //printf("no valid containing module for platforlift\n");

        RemoveBehaviourStrategy(sbPtr);

    }

}

void NetworkPeerChangePlatformLiftState(STRATEGYBLOCK* sbPtr,PLATFORMLIFT_STATES new_state)

{

    assert(sbPtr);

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK *)sbPtr->dataptr;

    assert(platformliftdata);

    assert(sbPtr->DynPtr);

    //check to see if this is a new state , and change any sound playing as necessary

    switch(new_state)

    {

        case PLBS_Activating:

            /*

            ignore this state change , since only the host does anything while the lift is

            activating , and this will prevent the lift from stopping at the ends correctly

            */

        return;

        case PLBS_GoingUp:

        case PLBS_GoingDown:

            switch(platformliftdata->state)

            {

                case PLBS_GoingUp:

                case PLBS_GoingDown:

                break;

                default:

                {

                    //platform lift has started moving

                    if(platformliftdata->start_sound)

                        Start_Track_Sound(platformliftdata->start_sound,&sbPtr->DynPtr->Position);

                }

            }

        default:

        break;

    }

    platformliftdata->state = new_state;

}

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

** Loading and Saving **

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

#include "savegame.h"

typedef struct platform_lift_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    DYNAMICSBLOCK dynamics;

    int activationDelayTimer;

    PLATFORMLIFT_STATES    state;

    int Enabled; 

    int OneUse; //if set ,lift becomes disabled after changing position once

} PLATFORM_LIFT_SAVE_BLOCK;

//defines for load/save macros

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV platformliftdata

void LoadStrategy_PlatformLift(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    PLATFORM_LIFT_SAVE_BLOCK* block = (PLATFORM_LIFT_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_BehaviourPlatform)

        return;

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK*)sbPtr->dataptr;

    //start copying stuff

    COPYELEMENT_LOAD(activationDelayTimer)

    COPYELEMENT_LOAD(state)

    COPYELEMENT_LOAD(Enabled)

    COPYELEMENT_LOAD(OneUse)

    *sbPtr->DynPtr = block->dynamics;

}

void SaveStrategy_PlatformLift(STRATEGYBLOCK* sbPtr)

{

    PLATFORM_LIFT_SAVE_BLOCK *block;

    PLATFORMLIFT_BEHAVIOUR_BLOCK *platformliftdata = (PLATFORMLIFT_BEHAVIOUR_BLOCK*)sbPtr->dataptr;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    COPYELEMENT_SAVE(activationDelayTimer)

    COPYELEMENT_SAVE(state)

    COPYELEMENT_SAVE(Enabled)

    COPYELEMENT_SAVE(OneUse)

    block->dynamics = *sbPtr->DynPtr;

    block->dynamics.CollisionReportPtr = 0;

}