#include "system.h"

#include "prototyp.h"

#include <assert.h>

#include "stratdef.h"

#include "bh_types.h"

#include "weapons.h"

#include "kshape.h"

#include "pvisible.h"

#include <stdio.h>

extern int GetLoadedShapeMSL(char const * shapename);

extern void DrawCable(VECTORCH *centrePtr, MATRIXCH *orientationPtr);

extern void AssignNewSBName(STRATEGYBLOCK *sbPtr);

extern int CloakingPhase;

struct GrapplingHookData

{

    int IsEmbedded;

    int IsEngaged;

    int Tightness;

    VECTORCH Position;

    MATRIXCH Orientation;

    int ShapeIndex;

    DISPLAYBLOCK *DispPtr;

}; 

static struct GrapplingHookData GrapplingHook;

void InitialiseGrapplingHook()

{

    GrapplingHook.IsEngaged = 0;

    GrapplingHook.IsEmbedded = 0;

    GrapplingHook.ShapeIndex = GetLoadedShapeMSL("spear");

    GrapplingHook.DispPtr = 0;

}

static DISPLAYBLOCK* CreateGrapplingHook()

{

    STRATEGYBLOCK* sbPtr = CreateActiveStrategyBlock(I_BehaviourGrapplingHook);

    if(!sbPtr)

        return NULL;

    DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock = CreateActiveObject();

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

    sbPtr->containingModule = ModuleFromPosition(&Global_VDB.VDB_World, NULL);

    if((NULL == dynPtr) || (NULL == dPtr) || (NULL == sbPtr->containingModule))

    {

        RemoveBehaviourStrategy(sbPtr);

        return NULL;

    }

    AssignNewSBName(sbPtr);

    dynPtr->PrevPosition = dynPtr->Position = Global_VDB.VDB_World;

    GrapplingHook.Orientation = Global_VDB.VDB_Mat;

    TransposeMatrixCH(&GrapplingHook.Orientation);

    dynPtr->OrientMat = GrapplingHook.Orientation;

    dynPtr->LinVelocity.vx = dynPtr->OrientMat.mat31;

    dynPtr->LinVelocity.vy = dynPtr->OrientMat.mat32;

    dynPtr->LinVelocity.vz = dynPtr->OrientMat.mat33;

    sbPtr->shapeIndex = GetLoadedShapeMSL("spear");

    dPtr->ObShape = sbPtr->shapeIndex;

    dPtr->ShapeData = mainshapelist[sbPtr->shapeIndex];

    dPtr->ObStrategyBlock = sbPtr;

    dPtr->ObWorld = dynPtr->Position;

    dPtr->ObEuler = dynPtr->OrientEuler;

    dPtr->ObMat = dynPtr->OrientMat;

    dPtr->extent.radius = 10;

    dPtr->extent.max_x = 10;

    dPtr->extent.max_y = 10;

    dPtr->extent.max_z = 10;

    dPtr->extent.min_x = -10;

    dPtr->extent.min_y = -10;

    dPtr->extent.min_z = -10;

    dPtr->ObFlags3 |= ObFlag3_DynamicModuleObject;

    return dPtr;

}

static void FireGrapplingHook()

{

    GrapplingHook.DispPtr = CreateGrapplingHook();

    if (GrapplingHook.DispPtr)

    {

        GrapplingHook.IsEngaged = 1;

        GrapplingHook.IsEmbedded = 0;

        GrapplingHook.Tightness = ONE_FIXED;

        Sound_Play(SID_GRAPPLE_THROW,"h");

    }

}

void DisengageGrapplingHook()

{

    GrapplingHook.IsEngaged = 0;

    GrapplingHook.IsEmbedded = 0;

    if (GrapplingHook.DispPtr)

    {

        RemoveBehaviourStrategy(GrapplingHook.DispPtr->ObStrategyBlock);

        GrapplingHook.DispPtr = NULL;

    }

}

void ActivateGrapplingHook()

{    

    GrapplingHook.IsEngaged ? DisengageGrapplingHook() : FireGrapplingHook();

}

void GrapplingHookBehaviour(STRATEGYBLOCK *sbPtr)

{

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    if (!GrapplingHook.IsEmbedded)

    {

        COLLISIONREPORT *reportPtr = dynPtr->CollisionReportPtr;

        if(reportPtr)

        {

            char stickWhereYouAre = 0;

            if (reportPtr->ObstacleSBPtr)

            {

                DISPLAYBLOCK *dispPtr = reportPtr->ObstacleSBPtr->DisplayBlock;

                if (dispPtr && dispPtr->Module && !dispPtr->ObMorphCtrl)

                    stickWhereYouAre=1;

            }

            else

            {

                stickWhereYouAre = 1;

            }

            if(stickWhereYouAre)

            {

                dynPtr->IsStatic = 1;

                dynPtr->PrevPosition = dynPtr->Position;

                GrapplingHook.Position = dynPtr->Position;

                GrapplingHook.IsEmbedded = 1;

                Sound_Play(SID_GRAPPLE_HIT_WALL,"d",&dynPtr->Position);

            return;

            }

            else

            {

                DisengageGrapplingHook();

                return;

            }

        }

    }

    else

    {

        GrapplingHook.Tightness -= NormalFrameTime*4;

        if (GrapplingHook.Tightness < 0)

            GrapplingHook.Tightness = 0;

    }

}

void HandleGrapplingHookForces()

{

    if (GrapplingHook.IsEmbedded)

    {

        DYNAMICSBLOCK *dynPtr = PlayerStatus.sbptr->DynPtr;

        VECTORCH direction = GrapplingHook.Position;

        int distance;

        direction.vx -= dynPtr->Position.vx;

        direction.vy -= dynPtr->Position.vy-1000;

        direction.vz -= dynPtr->Position.vz;

        distance = Approximate3dMagnitude(&direction);

        if (distance > 4096 + 1024)

        {

            Normalise(&direction);

            dynPtr->LinImpulse.vx += MUL_FIXED(direction.vx,NormalFrameTime);

            dynPtr->LinImpulse.vy += MUL_FIXED(direction.vy,NormalFrameTime);

            dynPtr->LinImpulse.vz += MUL_FIXED(direction.vz,NormalFrameTime);

        }

        else if (distance > 1024)

        {

            int s = MUL_FIXED((distance-1024)*16,NormalFrameTime);

            Normalise(&direction);

            dynPtr->LinImpulse.vx += MUL_FIXED(direction.vx,s);

            dynPtr->LinImpulse.vy += MUL_FIXED(direction.vy,s);

            dynPtr->LinImpulse.vz += MUL_FIXED(direction.vz,s);

            dynPtr->LinImpulse.vx -= MUL_FIXED(dynPtr->LinImpulse.vx,NormalFrameTime/2);

            dynPtr->LinImpulse.vy -= MUL_FIXED(dynPtr->LinImpulse.vy,NormalFrameTime/2);

            dynPtr->LinImpulse.vz -= MUL_FIXED(dynPtr->LinImpulse.vz,NormalFrameTime/2);

        }

        if (Approximate3dMagnitude(&dynPtr->LinImpulse) > ONE_FIXED)

        {

            Normalise(&dynPtr->LinImpulse);

        }

    }

}

void RenderGrapplingHook()

{

    if (GrapplingHook.IsEngaged && GrapplingHook.DispPtr)

    {

        VECTORCH cable[46];

        int i=1;

        {

            MATRIXCH mat = Global_VDB.VDB_Mat;

            TransposeMatrixCH(&mat);

            cable[0].vx = Global_VDB.VDB_World.vx-mat.mat31/128;

            cable[0].vy = Global_VDB.VDB_World.vy-mat.mat32/128+500;

            cable[0].vz = Global_VDB.VDB_World.vz-mat.mat33/128;

        }

        for (; i < 46; i++)

        {

            cable[i].vx = ((45-i)*cable[0].vx + (i)*GrapplingHook.DispPtr->ObStrategyBlock->DynPtr->Position.vx)/45;

            cable[i].vy = ((45-i)*cable[0].vy + (i)*GrapplingHook.DispPtr->ObStrategyBlock->DynPtr->Position.vy)/45;

            cable[i].vz = ((45-i)*cable[0].vz + (i)*GrapplingHook.DispPtr->ObStrategyBlock->DynPtr->Position.vz)/45;

            if (GrapplingHook.Tightness != 0)

            {

                int x = GetSin((302*i+CloakingPhase)&4095) / 256;

                int y = GetSin((502*i+200+CloakingPhase)&4095) / 256;

                int z = GetCos((302*i+100+CloakingPhase)&4095) / 256;

                int u = GetSin( ((4096*i)/45)&4095 );

                u = MUL_FIXED(MUL_FIXED(u,u),GrapplingHook.Tightness);

                cable[i].vx += MUL_FIXED(u,x);

                cable[i].vy += MUL_FIXED(u,y);

                cable[i].vz += MUL_FIXED(u,z);

            }

        }

        {

            MATRIXCH mat;

            VECTORCH dir = cable[45];

            dir.vx -= cable[0].vx;

            dir.vy -= cable[0].vy;

            dir.vz -= cable[0].vz;

            Normalise(&dir);

            MakeMatrixFromDirection(&dir,&mat);

            DrawCable(cable, &mat);

        }

    }

}

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

** Loading and Saving **

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

#include "savegame.h"

typedef struct grapple_save_block

{

    SAVE_BLOCK_STRATEGY_HEADER header;

    int IsEmbedded;

    int IsEngaged;

    int Tightness;

    VECTORCH Position;

    MATRIXCH Orientation;

//strategy block stuff

    DYNAMICSBLOCK dynamics;

} GRAPPLE_SAVE_BLOCK;

#define SAVELOAD_BLOCK block

#define SAVELOAD_BEHAV (&GrapplingHook)

void LoadStrategy_Grapple(SAVE_BLOCK_STRATEGY_HEADER* header)

{

    GRAPPLE_SAVE_BLOCK* block = (GRAPPLE_SAVE_BLOCK*) header;

    //check the size of the save block

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

        return;

    //create the grappling hook

    GrapplingHook.DispPtr = CreateGrapplingHook();

    if(!GrapplingHook.DispPtr)

        return;

    //copy suff from the save block

    COPYELEMENT_LOAD(IsEmbedded)

    COPYELEMENT_LOAD(IsEngaged)

    COPYELEMENT_LOAD(Tightness)

    COPYELEMENT_LOAD(Position)

    COPYELEMENT_LOAD(Orientation)

    *GrapplingHook.DispPtr->ObStrategyBlock->DynPtr = block->dynamics;

}

void SaveStrategy_Grapple(STRATEGYBLOCK* sbPtr)

{

    GRAPPLE_SAVE_BLOCK* block;

    GET_STRATEGY_SAVE_BLOCK(block,sbPtr);

    //copy stuff to the save block

    COPYELEMENT_SAVE(IsEmbedded)

    COPYELEMENT_SAVE(IsEngaged)

    COPYELEMENT_SAVE(Tightness)

    COPYELEMENT_SAVE(Position)

    COPYELEMENT_SAVE(Orientation)

    block->dynamics = *sbPtr->DynPtr;

    block->dynamics.CollisionReportPtr=0;

}