#include "system.h"

#include "stratdef.h"

#include "bh_types.h"

#include "npc_marine.h"

#include "weapons.h"

#include "los.h"

#include "paintball.h"

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <assert.h>

#include "pldghost.h"

extern int ObjectShouldAppearOnMotionTracker(STRATEGYBLOCK *sbPtr);

/*

 Foley and Van Dam 2d distance function

 WARNING! Returns distance x 3

 Here is the F & VD distance function:

 x + z + (max(x,z) * 2)

 ----------------------

          3

*/

static int FandVD_Distance_2d(const VECTOR2D *v0, const VECTOR2D *v1)

{

    int dx = abs(v1->vx - v0->vx);

    int dy = abs(v1->vy - v0->vy);

    if(dx > dy)

        return (dx + dy + (dx* 2));

    else

        return (dx + dy + (dy* 2));

}

/*

 Foley and Van Dam 3d distance function

 WARNING! Returns distance x 9

 For a 3d version, calculate (f(f(x,y), y*3))/9

*/

static int FandVD_Distance_3d(const VECTORCH *v0, const VECTORCH *v1)

{

    int dz = abs((v1->vz - v0->vz) * 3);

    int dxy = FandVD_Distance_2d((VECTOR2D *) v0, (VECTOR2D *) v1);

    if(dxy > dz)

        return (dxy + dz + (dxy * 2));

    else

        return (dxy + dz + (dz * 2));

}

extern SCREENDESCRIPTORBLOCK ScreenDescriptorBlock;

int CalculateFiringSolution(VECTORCH* firing_pos, VECTORCH* target_pos, VECTORCH* target_vel, int projectile_speed, VECTORCH* solution)

{

    VECTORCH rotated_solution;

    MATRIXCH mat;

    assert(target_vel);

    //get a normalised vector from start to destination

    VECTORCH normal = *target_pos; //normal from firer to target

    normal.vx -= firing_pos->vx;

    normal.vy -= firing_pos->vy;

    normal.vz -= firing_pos->vz;

    if(!normal.vx && !normal.vy && !normal.vz)

        return 0;

    Approximate3dMagnitude(&normal);

    Normalise(&normal);

    //calculate a matrix that will rotate the normal to the zaxis

    {

        //normal will be the third row

        VECTORCH row1,row2;

        if(normal.vx > 30000 || normal.vx < -30000 || normal.vy > 30000 || normal.vy < -30000)

        {

            row1.vx = -normal.vy;

            row1.vy = normal.vx;

            row1.vz = 0;

        }

        else 

        {

            row1.vx = -normal.vz;

            row1.vy = 0;

            row1.vz = normal.vx;

        }

        Normalise(&row1);

        CrossProduct(&normal,&row1,&row2);

        mat.mat11 = row1.vx;

        mat.mat21 = row1.vy;

        mat.mat31 = row1.vz;

        mat.mat12 = row2.vx;

        mat.mat22 = row2.vy;

        mat.mat32 = row2.vz;

        mat.mat13 = normal.vx;

        mat.mat23 = normal.vy;

        mat.mat33 = normal.vz;

    }

    //apply the rotation to the velocity

    VECTORCH rotated_vel = *target_vel;

    RotateVector(&rotated_vel,&mat);

    //is the target moving too fast?

    if(rotated_vel.vz >= projectile_speed || -rotated_vel.vz >= projectile_speed)

            return 0;

    //the x and y components of the rotated solution should match the rotated velocity

    //(scale down by projectile speed , because we want a normalised direction)

    rotated_solution.vx = DIV_FIXED(rotated_vel.vx, projectile_speed);

    rotated_solution.vy = DIV_FIXED(rotated_vel.vy, projectile_speed);

    //z=1-(x*x+y*y)

    {

        //not sure we have a fixed point square root

        float x = (float)rotated_solution.vx;

        float y = (float)rotated_solution.vy;

        float z_squared = 65536.0*65536.0-(x*x+y*y);

        if(z_squared < 0)

        {

            //target moving too fast to hit

            return 0;

        }

        rotated_solution.vz = (int)sqrt(z_squared);

    }

    //finally need to rotated solution back

    *solution = rotated_solution;

    TransposeMatrixCH(&mat);

    RotateVector(solution, &mat);

    //normalise solution to be on the safe side

    Normalise(solution);

return 1;

}

void SmartTarget_GetCofM(DISPLAYBLOCK *target, VECTORCH *viewSpaceOutput) 

{

    AVP_BEHAVIOUR_TYPE targetType;

    /* Get smartgun aiming point. */

    if (target->HModelControlBlock == NULL || target->HModelControlBlock->section_data == NULL)

    {

        *viewSpaceOutput = target->ObView;

        return;

    }

    /* Must be a hierarchy. */

    switch(target->ObStrategyBlock->type)

    {

        case I_BehaviourNetGhost:

        {

            NETGHOSTDATABLOCK *dataptr = target->ObStrategyBlock->dataptr;

            targetType = dataptr->type;

        }

        break;

        default:

            targetType = target->ObStrategyBlock->type;

    }

    /* Now, switch case on targetType. */

    switch (targetType)

    {

        case I_BehaviourMarine:

        case I_BehaviourMarinePlayer:

        case I_BehaviourPredator:

        case I_BehaviourPredatorPlayer:

        case I_BehaviourAlien:

        case I_BehaviourAlienPlayer:

        {

            SECTION_DATA *targetsection = GetThisSectionData(target->HModelControlBlock->section_data, "chest");

            if (targetsection == NULL)

                targetsection = target->HModelControlBlock->section_data;

            if (targetsection->flags & section_data_view_init)

                *viewSpaceOutput = targetsection->View_Offset;

            else

                *viewSpaceOutput = target->ObView; /* Whoops. */

        return;

        }

        default:

        {

            /* General case. */

            if (target->HModelControlBlock->section_data->flags & section_data_view_init)

                *viewSpaceOutput = target->HModelControlBlock->section_data->View_Offset;

            else

                *viewSpaceOutput = target->ObView; /* Whoops. */

        }

    }

}

static int SmartTarget_TargetFilter(STRATEGYBLOCK *candidate)

{

    /* KJL 11:56:33 14/10/98 - the Predator's Shoulder cannon can only track objects when used in the correct

    vision mode, e.g. you can only target marines when in infrared mode */

    switch(PlayerStatus.SelectedWeapon->WeaponIDNumber)

    {

        case WEAPON_PRED_SHOULDERCANNON:

        case WEAPON_PRED_DISC:

        {

            switch (PlayerStatus.VisionMode)

            {

                case VISION_MODE_PRED_SEEALIENS:

                {

                    switch(candidate->type)

                    {

                        case I_BehaviourAlien:

                        case I_BehaviourXenoborg:

                        case I_BehaviourFaceHugger:

                        case I_BehaviourQueenAlien:

                            return !NPC_IsDead(candidate);

                        case I_BehaviourNetGhost:

                        {

                            NETGHOSTDATABLOCK *ghostDataPtr = (NETGHOSTDATABLOCK *)candidate->dataptr;

                            return (ghostDataPtr->type == I_BehaviourAlienPlayer || ghostDataPtr->type == I_BehaviourAlien);

                        }

                        default:

                        return 0;

                    }

                }

                case VISION_MODE_PRED_THERMAL:

                {

                    switch(candidate->type)

                    {

                        case I_BehaviourMarine:

                        {

                            MARINE_STATUS_BLOCK *marineStatusPointer = (MARINE_STATUS_BLOCK *)(candidate->dataptr);

                            return marineStatusPointer->My_Weapon->Android ? 0 : !NPC_IsDead(candidate);

                        }

                        case I_BehaviourNetGhost:

                        {

                            NETGHOSTDATABLOCK *ghostDataPtr = (NETGHOSTDATABLOCK *)candidate->dataptr;

                            return (ghostDataPtr->type == I_BehaviourMarinePlayer || ghostDataPtr->type == I_BehaviourMarine);

                        }

                        default:

                        return 0;

                    }

                }

                case VISION_MODE_PRED_SEEPREDTECH:

                {

                    switch(candidate->type)

                    {

                        case I_BehaviourPredator:

                            return !NPC_IsDead(candidate);

                        case I_BehaviourNetGhost:

                        {

                            NETGHOSTDATABLOCK *ghostDataPtr = (NETGHOSTDATABLOCK *)candidate->dataptr;

                            switch(ghostDataPtr->type)

                            {

                                case I_BehaviourPredator:

                                case I_BehaviourPredatorPlayer:

                                {

                                    /* Check for game type? */

                                    switch (netGameData.gameType)

                                    {

                                        case NGT_Coop:

                                        case NGT_CoopDeathmatch:

                                        case NGT_LastManStanding:

                                            return 0;

                                        //case NGT_Individual:

                                        //case NGT_PredatorTag:

                                        //    return 1;

                                        default:

                                            return 1;

                                    }

                                }

                                default:

                                return 0;

                            }

                        }

                        case I_BehaviourFrisbee:

                        case I_BehaviourGrenade:

                        case I_BehaviourFragmentationGrenade:

                        return 1;

                        case I_BehaviourProximityGrenade:

                            return DynamicObjectIsMoving(candidate->DynPtr);

                        default:

                        return 0;

                    }

                }

                default:

                return 0;

            }

        }

        case WEAPON_SMARTGUN:

        {

            switch (candidate->type)

            {

                //case I_BehaviourMarine:

                case I_BehaviourMarinePlayer:

                    return 0;

                default:

                    return ObjectShouldAppearOnMotionTracker(candidate);

        /*

                case I_BehaviourAlien:

                case I_BehaviourPredator:

                case I_BehaviourQueenAlien:

                case I_BehaviourFaceHugger:

                case I_BehaviourXenoborg:

                    return !NPC_IsDead(candidate);

                case I_BehaviourNetGhost:

                {

                    NETGHOSTDATABLOCK *ghostDataPtr = (NETGHOSTDATABLOCK *)candidate->dataptr;

                    // Don't target marines if Friendly Fire is disabled.

                    //if (netGameData.disableFriendlyFire && (netGameData.gameType == NGT_CoopDeathmatch || netGameData.gameType == NGT_Coop))

                    switch (ghostDataPtr->type)

                    {

                        case I_BehaviourPredatorPlayer:

                        case I_BehaviourAlienPlayer:

                        case I_BehaviourAlien:

                            return 1;

                        default:

                            return 0;

                    }

                }

                default:

                    return 0;

        */

            }

        }

        break;

        default:

        return 0;

    }

}

#define SMART_TRACKABLE_TARGETS 100

#define SMART_TARGETING_RANGE 1000000

extern struct KObject VisibleObjects[maxobjects];

extern int numVisObjs;

DISPLAYBLOCK *SmartTarget_GetNewTarget()

{

    int a=0,b,c;

    int numberOfObjects = numVisObjs;

    DISPLAYBLOCK *track_array[SMART_TRACKABLE_TARGETS] = { NULL };

    while (numberOfObjects--)

    {

        DISPLAYBLOCK* objectPtr = VisibleObjects[numberOfObjects].DispPtr;

        STRATEGYBLOCK* sbPtr = objectPtr->ObStrategyBlock;

        if (sbPtr && sbPtr->DynPtr)

        {

            VECTORCH viewPos;

            /* Arc reject. */

            SmartTarget_GetCofM(objectPtr, &viewPos);

            if (viewPos.vz > 0)

            {

                if (SmartTarget_TargetFilter(sbPtr))

                {

                    if (a < SMART_TRACKABLE_TARGETS)

                    {

                        track_array[a] = objectPtr;

                        a++;

                    }

                }

            }

        }

    }

    /* Now, filter the track array. */

    b = a;

    c = a;

    while (b--)

    {

        int notFar = -1;

        int nearestObjectDist = SMART_TARGETING_RANGE;

        DISPLAYBLOCK *nearestObjectPtr = NULL;

        a = c;

        while (a)

        {

            DISPLAYBLOCK* objectPtr = track_array[--a];

            if (objectPtr)

            {

                /* calc distance to player - no parallel strat support yet */

                /* 2d vector from player to object */

                int dist = FandVD_Distance_3d(&objectPtr->ObWorld, &PlayerStatus.DisplayBlock->ObWorld);

                if (dist < nearestObjectDist)

                {

                    nearestObjectDist = dist;

                    nearestObjectPtr = objectPtr;

                    notFar = a;

                }

            }

        }

        if (nearestObjectPtr)

        {

            assert(notFar != -1);

            if (IsThisObjectVisibleFromThisPosition_WithIgnore(track_array[notFar], PlayerStatus.DisplayBlock, &(Global_VDB.VDB_World)))

                return track_array[notFar]; /* Valid. */

            else

                track_array[notFar] = NULL; /* Remove from list. */

        }

    }

return NULL;

}

int SmartTargetSightX, SmartTargetSightY;

DISPLAYBLOCK *SmartTarget_Object;

int SmartTarget(int speed, int projectile_speed)

{

    DISPLAYBLOCK *trackedObject = SmartTarget_GetNewTarget();    

    int targetX = ScreenDescriptorBlock.SDB_Width >> 1;

    int targetY = ScreenDescriptorBlock.SDB_Height >> 1;

    SmartTarget_Object = NULL;

    /* If there is a valid near object which isn't so close as to cause a division by zero */

    if (trackedObject && (trackedObject->ObView.vz != 0))

    {

        VECTORCH targetView;

        /* Set targetView. */

        SmartTarget_GetCofM(trackedObject, &targetView);

        if(projectile_speed)

        {

            //get a firing solution so that projectile should hit if target maintains curremt velocity

            if(trackedObject->ObStrategyBlock)

            {

                if(trackedObject->ObStrategyBlock->DynPtr)

                {

                    DYNAMICSBLOCK *dynPtr = trackedObject->ObStrategyBlock->DynPtr;

                    if(dynPtr->LinVelocity.vx || dynPtr->LinVelocity.vy || dynPtr->LinVelocity.vz)

                    {

                        VECTORCH velocity = dynPtr->LinVelocity;

                        VECTORCH zero = {0,0,0};

                        VECTORCH solution;

                        //rotate velocity into view space

                        RotateVector(&velocity, &Global_VDB.VDB_Mat);

                        if(CalculateFiringSolution(&zero, &targetView, &velocity, projectile_speed, &solution))

                            targetView = solution;

                    }

                }

            }

        }

        if (targetView.vz > 0)

        {

            int screenX = WideMulNarrowDiv(targetView.vx, Global_VDB.VDB_ProjX, targetView.vz);

            int screenY = WideMulNarrowDiv(targetView.vy*4, Global_VDB.VDB_ProjY, targetView.vz*3);

            int maxRangeX = (ScreenDescriptorBlock.SDB_Width * 14) / 32;  /* gives nearly 90% of screen */

            if ((screenX > -maxRangeX) && (screenX < maxRangeX))

            {

                int maxRangeY = (ScreenDescriptorBlock.SDB_Height * 14) / 32; /* gives nearly 90% of screen */

                if ((screenY > -maxRangeY) && (screenY < maxRangeY))

                {

                    targetX += screenX;

                    targetY += screenY;

                    SmartTarget_Object = trackedObject;

                    //printf("Tracking object %p \n", trackedObject);

                }

            }

        }

    }

    if (speed)

    {

        int targetingSpeed = NormalFrameTime * speed;

        /* KJL 14:08:50 09/20/96 - the targeting is FRI, but care has to be taken

           at very low frame rates to ensure that the sight doesn't jump about

           all over the place. */

        if (targetingSpeed > 65536)

            targetingSpeed = 65536;

        int dx = MUL_FIXED( ((targetX << 16) - SmartTargetSightX), targetingSpeed );

        int dy = MUL_FIXED( ((targetY << 16) - SmartTargetSightY), targetingSpeed );

        /* If the x-coord difference between the sight and the target is small,

           just move the sight so that it has the same x-coord as the target.

           This stops the sight from hovering a pixel away from where it should be */

        if (dx > 16384 || dx < -16384)

            SmartTargetSightX += dx;

        else

            SmartTargetSightX = targetX << 16;

        /* Similarly for the y-coord */

        if (dy > 16384 || dy < -16384)

            SmartTargetSightY += dy;

        else

            SmartTargetSightY = targetY << 16;

    }

    else

    {

        SmartTargetSightX = targetX << 16;

        SmartTargetSightY = targetY << 16;

    }

return SmartTarget_Object != NULL;

}

void GetTargetingPointOfObject(DISPLAYBLOCK *objectPtr, VECTORCH *targetPtr)

{

    /* try to look at the centre of the object */

    if (objectPtr->HModelControlBlock)

    {

          ProveHModel(objectPtr->HModelControlBlock, objectPtr);

        SECTION_DATA *firstSectionPtr = objectPtr->HModelControlBlock->section_data;

          assert(firstSectionPtr);

        assert(firstSectionPtr->flags&section_data_initialised);

        /* look for the object's torso in preference */

        SECTION_DATA *targetSectionPtr = GetThisSectionData(objectPtr->HModelControlBlock->section_data, "chest");

        if (targetSectionPtr)

        {

            assert(targetSectionPtr->flags & section_data_initialised);

            *targetPtr = targetSectionPtr->World_Offset;

        }

        else /* just use the top of the hierarchy then */

        {

            *targetPtr = firstSectionPtr->World_Offset;

        }

    }

    else

    {

        *targetPtr = objectPtr->ObWorld;

    }

}

void GetTargetingPointOfObject_Far(STRATEGYBLOCK *sbPtr, VECTORCH *targetPtr)

{

    /* Can we use the near one?  This is a more general shell. */

    if (sbPtr->DisplayBlock)

    {

        GetTargetingPointOfObject(sbPtr->DisplayBlock,targetPtr);

    }

    else if(sbPtr->DynPtr)

    {

        *targetPtr = sbPtr->DynPtr->Position;

        targetPtr->vy -= 500; /* Just to be on the safe side. */

    }

    #if DEBUG

    else

    {

        /* Aw, gawd! I don't know! There's NO position for this! */

        assert(0);

    }

    #endif

}