#include "npc_common.h"

#include "game_statistics.h"

#include "npc_facehugger.h"

#include "psndplat.h"

#include "hud.h"

#include <stdlib.h>

extern int deathFadeLevel;

extern int RealFrameTime;

extern void FadeDownScreen(int brightness, int colour);

enum HuggerSubSequences

{

    HSS_Stand = 0,

    HSS_Run,

    HSS_Dies,

    HSS_Jump,

    HSS_Attack,

    HSS_DieOnFire,

    HSS_Floats

};

#define HUGGER_STATE_PRINT    0

extern void AssignNewSBName(STRATEGYBLOCK *sbPtr);

static int make_new_facehugger(STRATEGYBLOCK* sbPtr, FACEHUGGER_NEAR_BHSTATE starting_state)

{

    sbPtr->dataptr = malloc(sizeof(FACEHUGGER_STATUS_BLOCK));

    if(NULL == sbPtr->dataptr)

    {                       

        RemoveBehaviourStrategy(sbPtr);

        return 0;

    }

    sbPtr->maintainVisibility = 1;

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

    FACEHUGGER_STATUS_BLOCK *new_facehugger = (FACEHUGGER_STATUS_BLOCK *)sbPtr->dataptr;

    new_facehugger->HModelController.Deltas = NULL;

    new_facehugger->HModelController.Root_Section = NULL;

    new_facehugger->HModelController.section_data = NULL;

    new_facehugger->nearBehaviourState = starting_state;

    new_facehugger->stateTimer = 0;

    new_facehugger->CurveRadius = 0;

    new_facehugger->CurveLength = 0;

    new_facehugger->CurveTimeOut = 0;

    new_facehugger->soundHandle_fire = SOUND_NOACTIVEINDEX;

    {

    int i = 0;

    for(; i < SB_NAME_LENGTH; i++)

        new_facehugger->death_target_ID[i] = 0;

    }

    COPY_NAME(new_facehugger->Target_SBname, Null_Name);

    new_facehugger->death_target_sbptr = NULL;

    new_facehugger->death_target_request = 0;

    new_facehugger->Target = NULL;

    NPC_InitMovementData(&new_facehugger->moveData);

    {

        const NPC_DATA *NpcData = &NpcDataList[I_NPC_FaceHugger];

        sbPtr->DamageBlock = NpcData->StartingStats;

        sbPtr->DamageBlock.Health = NpcData->StartingStats.Health << ONE_FIXED_SHIFT;

        sbPtr->DamageBlock.Armour = NpcData->StartingStats.Armour << ONE_FIXED_SHIFT;

    }

    SECTION *root_section = GetNamedHierarchyFromLibrary("hnpchugger", "Template");

    if ((NULL == root_section) || (NULL == sbPtr->containingModule))

    {

        RemoveBehaviourStrategy(sbPtr);

        return 0;

    }

    Create_HModel(&new_facehugger->HModelController, root_section);

    InitHModelSequence(&new_facehugger->HModelController, 0, 0, ONE_FIXED);

    ProveHModel_Far(&new_facehugger->HModelController, sbPtr);

    return 1;

}

static void PlotFaceHugger(STRATEGYBLOCK *sbPtr) 

{

    extern void DisplayFacehuggerOnHud(DISPLAYBLOCK *dbPtr);

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    assert(sbPtr->DisplayBlock);    

    {

        VECTORCH x,y,z;

        x.vx = -Global_VDB.VDB_Mat.mat11;

        x.vy = -Global_VDB.VDB_Mat.mat21;

        x.vz = -Global_VDB.VDB_Mat.mat31;

        y.vx = -Global_VDB.VDB_Mat.mat13;

        y.vy = -Global_VDB.VDB_Mat.mat23;

        y.vz = -Global_VDB.VDB_Mat.mat33;

        z.vx = -Global_VDB.VDB_Mat.mat12;

        z.vy = -Global_VDB.VDB_Mat.mat22;

        z.vz = -Global_VDB.VDB_Mat.mat32;

        Normalise(&x);

        Normalise(&y);

        Normalise(&z);

        dynPtr->OrientMat.mat11 = x.vx;

        dynPtr->OrientMat.mat12 = x.vy;

        dynPtr->OrientMat.mat13 = x.vz;

        dynPtr->OrientMat.mat21 = y.vx;

        dynPtr->OrientMat.mat22 = y.vy;

        dynPtr->OrientMat.mat23 = y.vz;

        dynPtr->OrientMat.mat31 = z.vx;

        dynPtr->OrientMat.mat32 = z.vy;

        dynPtr->OrientMat.mat33 = z.vz;

    }

    /* set position */

    dynPtr->Position.vx = 0;

    dynPtr->Position.vz = FACEHUGGER_ATTACKZOFFSET / 4;

    dynPtr->Position.vy = FACEHUGGER_ATTACKYOFFSET;

    {

        MATRIXCH myMat = Global_VDB.VDB_Mat;

        TransposeMatrixCH(&myMat);

        RotateVector(&dynPtr->Position, &myMat);    

    }

    dynPtr->Position.vx += Global_VDB.VDB_World.vx;

    dynPtr->Position.vy += Global_VDB.VDB_World.vy;

    dynPtr->Position.vz += Global_VDB.VDB_World.vz;

    sbPtr->DisplayBlock->ObFlags &= ~ObFlag_NotVis;

    sbPtr->DisplayBlock->ObWorld = dynPtr->Position;

    sbPtr->DisplayBlock->ObMat = dynPtr->OrientMat;

    ProveHModel(sbPtr->DisplayBlock->HModelControlBlock, sbPtr->DisplayBlock);

    DoHModel(sbPtr->DisplayBlock);

    sbPtr->DisplayBlock->ObFlags |= ObFlag_NotVis;

    if(deathFadeLevel > ONE_FIXED/2)

    {

        deathFadeLevel -= RealFrameTime / 8;

        //FadeDownScreen(deathFadeLevel, 0);

    }

}

void InitFacehuggerBehaviour(void* bhdata, STRATEGYBLOCK *sbPtr)

{

    TOOLS_DATA_FACEHUGGER *toolsData = (TOOLS_DATA_FACEHUGGER *)bhdata; 

    int i;

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

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

    sbPtr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_DEFAULT);

    if(sbPtr->DynPtr)

    {

        DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

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

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

        TransposeMatrixCH(&dynPtr->OrientMat);              

        dynPtr->Mass = 3;

        dynPtr->ToppleForce = TOPPLE_FORCE_ALIEN;

        if(make_new_facehugger(sbPtr, (toolsData->startInactive ? FHNS_Floating : FHNS_Approach)))

        {

            FACEHUGGER_STATUS_BLOCK *facehuggerStatus = (FACEHUGGER_STATUS_BLOCK *)sbPtr->dataptr;

            if (toolsData->startInactive)

            {

                InitHModelTweening(&facehuggerStatus->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Floats, (ONE_FIXED << 1),
1);

                sbPtr->DynPtr->GravityOn = 0;

            }

            else

            {

                InitHModelTweening(&facehuggerStatus->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Stand, ONE_FIXED, 0);

                facehuggerStatus->HModelController.Playing = 0; // don't show up on motion tracker

            }

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

                facehuggerStatus->death_target_ID[i] = toolsData->death_target_ID[i];

            facehuggerStatus->death_target_request = toolsData->death_target_request;

        }

    }

    else

    {

        RemoveBehaviourStrategy(sbPtr);

    }

}

static void Execute_FHNS_Approach(STRATEGYBLOCK *sbPtr)

{

    FACEHUGGER_STATUS_BLOCK *fhugStatusPointer = (FACEHUGGER_STATUS_BLOCK *)(sbPtr->dataptr);    

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    /* do climb on walls, etc */

    dynPtr->UseStandardGravity = 1;

    /* If you think I'm going to let facehuggers climb on walls for *

     * ONE SECOND, you are INSANE, Jack!!! */

    VECTORCH targetPos = fhugStatusPointer->Target->DynPtr->Position;

    /* translate target into hugger local space */

    {

        MATRIXCH toLocalSpaceMatrix = dynPtr->OrientMat;

        TransposeMatrixCH(&toLocalSpaceMatrix);

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

        targetPos.vy -= dynPtr->Position.vy;

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

        RotateVector(&targetPos, &toLocalSpaceMatrix);

    }

    /* Fix vy. */

    targetPos.vy = 0;

    /* tracking movement */

    if (dynPtr->IsInContactWithFloor)

    {

        int distanceToTarget = Magnitude(&targetPos);

        if (fhugStatusPointer->CurveTimeOut <= 0)

        {

            fhugStatusPointer->CurveLength = distanceToTarget;

            fhugStatusPointer->CurveRadius = ((FastRandom()&16383)-8192)*2;

            fhugStatusPointer->CurveTimeOut= ONE_FIXED * 3;

        }

        else

        {

            fhugStatusPointer->CurveTimeOut -= NormalFrameTime;

        }

        int offset = MUL_FIXED(fhugStatusPointer->CurveRadius, GetCos((1024 * distanceToTarget / fhugStatusPointer->CurveLength) & 4095));

        dynPtr->LinVelocity.vx = 

            WideMulNarrowDiv(FACEHUGGER_NEAR_SPEED, targetPos.vx, distanceToTarget)

            -WideMulNarrowDiv(offset, targetPos.vz, distanceToTarget);

        dynPtr->LinVelocity.vz = 

            WideMulNarrowDiv(FACEHUGGER_NEAR_SPEED, targetPos.vz, distanceToTarget)

            +

            WideMulNarrowDiv(offset, targetPos.vx, distanceToTarget);

        RotateVector(&dynPtr->LinVelocity, &dynPtr->OrientMat);

        /* align to velocity */

        NPCOrientateToVector(sbPtr, &dynPtr->LinVelocity, NPC_TURNRATE);

        //if(!DynamicObjectIsMoving(&fhugStatusPointer->Target->DynPtr))

        {

            /* should we jump at the player? */

            int distanceToTarget = VectorDistance(&dynPtr->Position, &fhugStatusPointer->Target->DynPtr->Position);

            if(distanceToTarget <= FACEHUGGER_JUMPDISTANCE)

            {

                fhugStatusPointer->nearBehaviourState = FHNS_AboutToJump;

                fhugStatusPointer->stateTimer = 0;

                return;

            }

        }

    }

    {

        STRATEGYBLOCK *destructableObject;

        NPC_OBSTRUCTIONREPORT obstruction;

        NPC_IsObstructed(sbPtr, &fhugStatusPointer->moveData, &obstruction, &destructableObject);

        if(obstruction.environment)

        {

            /* go to avoidance */

            NPC_InitMovementData(&fhugStatusPointer->moveData);

            NPCGetAvoidanceDirection(sbPtr, &fhugStatusPointer->moveData.avoidanceDirn, &obstruction);

            fhugStatusPointer->nearBehaviourState = FHNS_Avoidance;

            fhugStatusPointer->stateTimer = NPC_AVOIDTIME;

            /* no sequence change required */

            return;

        }

        else if(obstruction.destructableObject)

        {

            assert(destructableObject);

            CauseDamageToObject(destructableObject, &TemplateAmmo[AMMO_NPC_OBSTACLE_CLEAR].MaxDamage, ONE_FIXED, NULL);

        }

    }

    {

        VECTORCH velocityDirection = dynPtr->LinVelocity;

        Normalise(&velocityDirection);

        if(NPC_CannotReachTarget(&fhugStatusPointer->moveData, &targetPos, &velocityDirection))

        {

            /* go to avoidance */

            NPC_OBSTRUCTIONREPORT obstruction = {1,0,0,0};

            NPC_InitMovementData(&fhugStatusPointer->moveData);

            NPCGetAvoidanceDirection(sbPtr, &fhugStatusPointer->moveData.avoidanceDirn, &obstruction);

            fhugStatusPointer->nearBehaviourState = FHNS_Avoidance;

            fhugStatusPointer->stateTimer = NPC_AVOIDTIME;

            /* no sequence change required */

        }

    }

}

static void FHugApplyPounceImpulse(STRATEGYBLOCK *sbPtr)

{

    VECTORCH pounceVector, targetPoint;

    FACEHUGGER_STATUS_BLOCK *fhugStatusPointer = (FACEHUGGER_STATUS_BLOCK *)(sbPtr->dataptr);    

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    if (fhugStatusPointer->Target)

        GetTargetingPointOfObject(fhugStatusPointer->Target->DisplayBlock, &targetPoint);

    int dist = VectorDistance(&dynPtr->Position, &targetPoint);

    /* Apply a correction based on range. */

    targetPoint.vy -= (dist >> 3);

    pounceVector.vx = targetPoint.vx - dynPtr->Position.vx;

    pounceVector.vy = targetPoint.vy - dynPtr->Position.vy;

    pounceVector.vz = targetPoint.vz - dynPtr->Position.vz;

    Normalise(&pounceVector);

    /* Must jump at least a little bit upwards. */

    if (pounceVector.vy > -10000)

        pounceVector.vy = -10000;

    pounceVector.vx = MUL_FIXED(FACEHUGGER_JUMP_SPEED, pounceVector.vx);

    pounceVector.vy = MUL_FIXED(FACEHUGGER_JUMP_SPEED, pounceVector.vy);

    pounceVector.vz = MUL_FIXED(FACEHUGGER_JUMP_SPEED, pounceVector.vz);

    sbPtr->DynPtr->LinImpulse = pounceVector;

}

static void Execute_FHNS_Jumping(STRATEGYBLOCK *sbPtr)

{

    FACEHUGGER_STATUS_BLOCK *fhugStatusPointer = (FACEHUGGER_STATUS_BLOCK *)(sbPtr->dataptr);    

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    /* don't climb on walls, etc */

    dynPtr->UseStandardGravity = 1;

    /* Firstly, are we actually pouncing yet? */

    /* NearStateTimer is a status flag. */

    if (fhugStatusPointer->stateTimer != 2)

    {

        /* Still tweening? */

        if (fhugStatusPointer->HModelController.keyframe_flags)

        {

            /* We have the flag. */

            fhugStatusPointer->HModelController.Playing = 0;

            fhugStatusPointer->stateTimer = 1;

        }

        if (fhugStatusPointer->stateTimer == 1)

        {

            /* We've finished!  Are we facing right? */

            VECTORCH orientationDirn = { 0,0,0 };

            if (fhugStatusPointer->Target)

            {

                orientationDirn.vx = fhugStatusPointer->Target->DynPtr->Position.vx - dynPtr->Position.vx;

                orientationDirn.vz = fhugStatusPointer->Target->DynPtr->Position.vz - dynPtr->Position.vz;

            }

            if (!NPCOrientateToVector(sbPtr, &orientationDirn, NPC_TURNRATE << 2))

            {

                /* Still not right!  Wait for proper facing. */

                fhugStatusPointer->HModelController.Playing = 0;

                return;

            }

            else

            {

                /* Okay, pounce! */

                FHugApplyPounceImpulse(sbPtr);

                fhugStatusPointer->HModelController.Playing = 1;

                fhugStatusPointer->stateTimer = 2;

            }

        }

    }

    else if(dynPtr->CollisionReportPtr)

    {

        /* We must be in the jump.  Can't break out of this until we hit something. */

        COLLISIONREPORT *reportPtr = dynPtr->CollisionReportPtr;

        fhugStatusPointer->nearBehaviourState = FHNS_Approach;

        fhugStatusPointer->stateTimer = fhugStatusPointer->CurveTimeOut = 0;

        do

        {

            STRATEGYBLOCK *hitSbPtr = reportPtr->ObstacleSBPtr;

            /* You know what?  Just did! What? */

            if (hitSbPtr && hitSbPtr->DisplayBlock && (hitSbPtr->DisplayBlock == fhugStatusPointer->Target->DisplayBlock))

            {

                /* Got him, My Precious, we've Got Him! */

                /* Test for attach, or merely bite? */

                fhugStatusPointer->nearBehaviourState = FHNS_Attached;

                fhugStatusPointer->stateTimer = FACEHUGGER_NEARATTACKTIME;

                InitHModelTweening(&fhugStatusPointer->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Attack, ONE_FIXED, 1);

                dynPtr->DynamicsType = DYN_TYPE_NO_COLLISIONS;     /* turn off collisons */    

                dynPtr->GravityOn = sbPtr->maintainVisibility = 0; /* turn off visibility support- be carefull! */

                sbPtr->DisplayBlock->ObFlags |= ObFlag_NotVis; /* Make not vis */

                if (hitSbPtr->DisplayBlock == PlayerStatus.DisplayBlock) 

                {

                    deathFadeLevel = ONE_FIXED;

                    Sound_Play(SID_FACEHUGGERSLAP, "h");

                }

                break;

            }

            reportPtr = reportPtr->NextCollisionReportPtr;

        } while (reportPtr);

    }

}

static int TargetFilter(STRATEGYBLOCK *candidate)

{

    switch (candidate->type)

    {

        case I_BehaviourMarinePlayer:

        case I_BehaviourPredatorPlayer:

        case I_BehaviourPredator:

        case I_BehaviourMarine:

            return 1;

        case I_BehaviourNetGhost:

        {

            NETGHOSTDATABLOCK *dataptr = candidate->dataptr;

            switch (dataptr->type)

            {

                case I_BehaviourMarinePlayer:

                case I_BehaviourPredatorPlayer:

                    return 1;

                default:

                    return 0;

            }

        }

        default:

            return 0;

    }

}

static STRATEGYBLOCK *GetNewTarget(VECTORCH *facehuggerpos)

{

    int i,neardist = ONE_FIXED;

    STRATEGYBLOCK *nearest = NULL;

    MODULE *dmod = ModuleFromPosition(facehuggerpos, PlayerStatus.sbptr->containingModule);

    //MODULE *dmod = ModuleFromPosition(facehuggerpos, NULL);

    assert(dmod);

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

    {

        STRATEGYBLOCK *candidate = ActiveStBlockList[i];

        if (TargetFilter(candidate)) 

        {

            VECTORCH offset;

            offset.vx = facehuggerpos->vx - candidate->DynPtr->Position.vx;

            offset.vy = facehuggerpos->vy - candidate->DynPtr->Position.vy;

            offset.vz = facehuggerpos->vz - candidate->DynPtr->Position.vz;

            int dist = Approximate3dMagnitude(&offset);

            /* Preferentially ignore predators? */

            if (candidate->type == I_BehaviourPredator) 

                dist <<= 2;

            if ((dist < neardist) && !NPC_IsDead(candidate) && IsModuleVisibleFromModule(dmod, candidate->containingModule)) 

            {

                nearest = candidate;

                neardist = dist;

            }

        }

    }

return nearest;

}

void FacehuggerBehaviour(STRATEGYBLOCK *sbPtr)

{

    FACEHUGGER_STATUS_BLOCK *facehuggerStatusPointer = (FACEHUGGER_STATUS_BLOCK *)(sbPtr->dataptr);    

    /* set velocity to zero */

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

    if(FHNS_Dying == facehuggerStatusPointer->nearBehaviourState)

    {

        #if HUGGER_STATE_PRINT

            printf("Hugger Dying...\n");

        #endif

        facehuggerStatusPointer->stateTimer -= NormalFrameTime;

        if(sbPtr->DisplayBlock)

        {

            sbPtr->DisplayBlock->SpecialFXFlags |= SFXFLAG_MELTINGINTOGROUND;

            sbPtr->DisplayBlock->ObFlags2 = facehuggerStatusPointer->stateTimer / 2;

        }

        sbPtr->please_destroy_me = (facehuggerStatusPointer->stateTimer <= 0);

        return;

    }

    else if(NULL == sbPtr->DisplayBlock)

    {

        return; // No far behaviour for facehuggers

    }

    if (sbPtr->DamageBlock.IsOnFire)

    {

        facehuggerStatusPointer->Target = NULL;

        facehuggerStatusPointer->nearBehaviourState = FHNS_Avoidance;

        CauseDamageToObject(sbPtr, &damage_profiles[FIREDAMAGE], NormalFrameTime, NULL);

        if (facehuggerStatusPointer->soundHandle_fire != SOUND_NOACTIVEINDEX)

            Sound_Update3d(facehuggerStatusPointer->soundHandle_fire, &sbPtr->DynPtr->Position);

        else

             Sound_Play(SID_FIRE, "dle", &sbPtr->DynPtr->Position, &facehuggerStatusPointer->soundHandle_fire);

    }

    else

    {

        if (facehuggerStatusPointer->soundHandle_fire != SOUND_NOACTIVEINDEX)

            Sound_Stop(facehuggerStatusPointer->soundHandle_fire);

        if(NULL != facehuggerStatusPointer->Target)

        {

            if (NPC_IsDead(facehuggerStatusPointer->Target) || !NAME_ISEQUAL(facehuggerStatusPointer->Target->SBname,
facehuggerStatusPointer->Target_SBname))

            {

                if(FHNS_Attached == facehuggerStatusPointer->nearBehaviourState)

                {

                    InitHModelTweening(&facehuggerStatusPointer->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Dies,
FACEHUGGER_DYINGTIME >> 3, 1);

                    sbPtr->DynPtr->GravityOn = 1;

                    facehuggerStatusPointer->nearBehaviourState = FHNS_Dying;

                    facehuggerStatusPointer->HModelController.Looped = 0;

                    facehuggerStatusPointer->HModelController.LoopAfterTweening = 0;

                    facehuggerStatusPointer->stateTimer = FACEHUGGER_DYINGTIME;

                    //facehuggerStatusPointer->Target = NULL;

                }

                else

                {

                    facehuggerStatusPointer->Target = NULL;

                    facehuggerStatusPointer->stateTimer = 0;

                    facehuggerStatusPointer->nearBehaviourState = FHNS_Wait;

                }

            }

        }

        else

        {

            facehuggerStatusPointer->Target = GetNewTarget(&sbPtr->DynPtr->Position);

            if (NULL != facehuggerStatusPointer->Target)

            {

                COPY_NAME(facehuggerStatusPointer->Target_SBname, facehuggerStatusPointer->Target->SBname);

                facehuggerStatusPointer->nearBehaviourState = FHNS_Approach;

            }

            else

            {

                facehuggerStatusPointer->stateTimer = 0;

                facehuggerStatusPointer->nearBehaviourState = FHNS_Wait;

            }

        }

    }

    #if DEBUG

    if(sbPtr->maintainVisibility)

        assert(ModuleCurrVisArray[sbPtr->containingModule->m_index]);

    #endif

    switch(facehuggerStatusPointer->nearBehaviourState)

    {

        case FHNS_Approach:

        {

            #if HUGGER_STATE_PRINT

                printf("Hugger Approaching...\n");

            #endif

            if(HSS_Run != facehuggerStatusPointer->HModelController.Sub_Sequence)

                InitHModelTweening(&facehuggerStatusPointer->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Run, (ONE_FIXED*2)/3,
1);

            Execute_FHNS_Approach(sbPtr);

        }

        break;

        case FHNS_Attached:

        {

            #if HUGGER_STATE_PRINT

                printf("Hugger Attacking...\n");

            #endif

            if (facehuggerStatusPointer->Target == PlayerStatus.sbptr)

            {

                PlayerStatus.sbptr->DamageBlock.Indestructable = 0; // there's no escape

                PlayerStatus.FirstPersonView = 1;

                PlotFaceHugger(sbPtr);

            }

            facehuggerStatusPointer->stateTimer -= NormalFrameTime;

            if(facehuggerStatusPointer->stateTimer <= 0)

            {

                facehuggerStatusPointer->stateTimer = FACEHUGGER_NEARATTACKTIME;

                CauseDamageToObject(facehuggerStatusPointer->Target, &TemplateAmmo[AMMO_FACEHUGGER].MaxDamage, ONE_FIXED, NULL);

            }

        }

        break;

        case FHNS_Jumping:

        {

            #if HUGGER_STATE_PRINT

                printf("Hugger Jumping...\n");

            #endif

            Execute_FHNS_Jumping(sbPtr);

        }

        break;

        case FHNS_AboutToJump:

        {

            #if HUGGER_STATE_PRINT

                printf("Hugger AboutToJump...\n");

            #endif

            /* Should still be playing Walk. */

            DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

            /* don't climb on walls, etc */

            dynPtr->UseStandardGravity = 1;

            /* Orientate to target. */

            VECTORCH orientationDirn;

            orientationDirn.vx = facehuggerStatusPointer->Target->DynPtr->Position.vx - dynPtr->Position.vx;

            orientationDirn.vy = 0;

            orientationDirn.vz = facehuggerStatusPointer->Target->DynPtr->Position.vz - dynPtr->Position.vz;

            if (NPCOrientateToVector(sbPtr, &orientationDirn, NPC_TURNRATE))

            {

                /* Okay, pounce! */

                int distanceToTarget = VectorDistance(&dynPtr->Position, &facehuggerStatusPointer->Target->DynPtr->Position);

                if((distanceToTarget <= FACEHUGGER_JUMPDISTANCE) && dynPtr->IsInContactWithFloor)

                {

                    InitHModelTweening(&facehuggerStatusPointer->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Jump, ONE_FIXED, 1);

                    facehuggerStatusPointer->HModelController.LoopAfterTweening = 0;

                    facehuggerStatusPointer->CurveTimeOut = 0;

                    facehuggerStatusPointer->HModelController.Looped = 0;

                    facehuggerStatusPointer->nearBehaviourState = FHNS_Jumping;

                }

                else

                {

                    /* Return to approach. */

                    NPC_InitMovementData(&facehuggerStatusPointer->moveData);

                    facehuggerStatusPointer->nearBehaviourState = FHNS_Approach;

                    /* no sequence change required */

                }

                facehuggerStatusPointer->stateTimer = 0;

            }

        }

        break;

        case FHNS_Wait:

        {

            #if HUGGER_STATE_PRINT

                printf("Hugger Waiting...\n");

            #endif

            if (facehuggerStatusPointer->Target)

            {

                NPC_InitMovementData(&facehuggerStatusPointer->moveData);

                facehuggerStatusPointer->nearBehaviourState = FHNS_Approach;

                facehuggerStatusPointer->stateTimer = 0;

                facehuggerStatusPointer->CurveTimeOut = 0;

            }

            else if(HSS_Stand != facehuggerStatusPointer->HModelController.Sub_Sequence)

            {

                InitHModelTweening(&facehuggerStatusPointer->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Stand, ONE_FIXED, 0);

                facehuggerStatusPointer->HModelController.Playing = 0; // don't show up on motion tracker

            }

        }

        break;

        case FHNS_Avoidance:

        {

            #if HUGGER_STATE_PRINT

                printf("Hugger Avoiding...\n");

            #endif

            int terminateState = 0;

            assert((facehuggerStatusPointer->moveData.avoidanceDirn.vx !=0)

            ||

            (facehuggerStatusPointer->moveData.avoidanceDirn.vy != 0)

            ||

            (facehuggerStatusPointer->moveData.avoidanceDirn.vz != 0));

            NPCSetVelocity(sbPtr, &facehuggerStatusPointer->moveData.avoidanceDirn, FACEHUGGER_NEAR_SPEED);

            /* next, decrement state timer */

            facehuggerStatusPointer->stateTimer -= NormalFrameTime;

            if(facehuggerStatusPointer->stateTimer <= 0)

                terminateState = 1;

            /* and check for an impeding collision */

            {

                STRATEGYBLOCK *destructableObject = NULL;

                NPC_OBSTRUCTIONREPORT obstruction;

                NPC_IsObstructed(sbPtr, &facehuggerStatusPointer->moveData, &obstruction, &destructableObject);

                if(obstruction.anySingleObstruction)

                    terminateState = 1;

            }

            if(terminateState)

            {

                if(facehuggerStatusPointer->Target)

                {

                    /* switch to approach */

                    NPC_InitMovementData(&facehuggerStatusPointer->moveData);

                    facehuggerStatusPointer->nearBehaviourState = FHNS_Approach;

                    facehuggerStatusPointer->stateTimer = 0;

                    /* no sequence change required */

                }

                else if (!sbPtr->DamageBlock.IsOnFire)

                {

                    /* switch to wait */

                    NPC_InitMovementData(&facehuggerStatusPointer->moveData);

                    facehuggerStatusPointer->nearBehaviourState = FHNS_Wait;          

                    facehuggerStatusPointer->stateTimer = 0;

                    /* no sequence change required */

                }

            }

        }

        break;

        case FHNS_Floating:

        {

            #if HUGGER_STATE_PRINT

                printf("Hugger Floating...\n");

            #endif

            DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

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

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

            dynPtr->GravityOn = 0;

            /* Just float there... */

        }

        default:

        break;

    }

}

void CreateFacehuggerBot(VECTORCH *Position)

{

    STRATEGYBLOCK* sbPtr = CreateActiveStrategyBlock(I_BehaviourFaceHugger);

    if(!sbPtr)

    {

        GADGET_NewOnScreenMessage("FAILED TO CREATE BOT: SB CREATION FAILURE");

        return;

    }

    sbPtr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_DEFAULT);

    if(sbPtr->DynPtr)

    {

        DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

        AssignNewSBName(sbPtr);

        dynPtr->PrevPosition = dynPtr->Position = *Position;

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

        TransposeMatrixCH(&dynPtr->OrientMat);

        dynPtr->Mass = 3;

        dynPtr->ToppleForce = TOPPLE_FORCE_ALIEN;

        make_new_facehugger(sbPtr, FHNS_Wait);

    }

    else

    {

        RemoveBehaviourStrategy(sbPtr);

        GADGET_NewOnScreenMessage("FAILED TO CREATE BOT: DYNBLOCK CREATION FAILURE");

    }

}

void CastFacehuggerBot()

{

    #define BOTRANGE 3000

    VECTORCH position;

    position = PlayerStatus.sbptr->DynPtr->Position;

    position.vx += MUL_FIXED(PlayerStatus.sbptr->DynPtr->OrientMat.mat31, BOTRANGE);

    position.vy += MUL_FIXED(PlayerStatus.sbptr->DynPtr->OrientMat.mat32, BOTRANGE);

    position.vz += MUL_FIXED(PlayerStatus.sbptr->DynPtr->OrientMat.mat33, BOTRANGE);

    CreateFacehuggerBot(&position);

}

void MakeFacehuggerNear(STRATEGYBLOCK *sbPtr)

{

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    FACEHUGGER_STATUS_BLOCK *facehuggerStatusPointer = (FACEHUGGER_STATUS_BLOCK *)(sbPtr->dataptr);    

    DISPLAYBLOCK *dPtr = CreateActiveObject();

    if(dPtr == NULL)

        return; /* cannot create displayblock, so leave far */

    sbPtr->DisplayBlock = dPtr;

    dPtr->ObStrategyBlock = sbPtr;

    /* need to initialise positional information in the new display block */ 

    dPtr->ObWorld = dynPtr->Position;

    dPtr->ObEuler = dynPtr->OrientEuler;

    dPtr->ObMat = dynPtr->OrientMat;

    facehuggerStatusPointer->stateTimer = 0;

    facehuggerStatusPointer->CurveRadius = 0;

    facehuggerStatusPointer->CurveLength = 0;

    facehuggerStatusPointer->CurveTimeOut = 0;

    facehuggerStatusPointer->Target = NULL;

       /* state and sequence init */

    dPtr->HModelControlBlock = &facehuggerStatusPointer->HModelController;

       switch(facehuggerStatusPointer->nearBehaviourState)

    {

        case FHNS_Floating:

        case FHNS_Dying:

        break;

        default:

        {

            NPC_InitMovementData(&facehuggerStatusPointer->moveData);

            facehuggerStatusPointer->nearBehaviourState = facehuggerStatusPointer->Target ? FHNS_Approach : FHNS_Wait;

        }

    }

    ProveHModel(dPtr->HModelControlBlock, dPtr);

}

void MakeFacehuggerFar(STRATEGYBLOCK *sbPtr)

{

    FACEHUGGER_STATUS_BLOCK *facehuggerStatusPointer = (FACEHUGGER_STATUS_BLOCK *)(sbPtr->dataptr);    

    if (facehuggerStatusPointer->soundHandle_fire != SOUND_NOACTIVEINDEX)

        Sound_Stop(facehuggerStatusPointer->soundHandle_fire);

    DestroyActiveObject(&sbPtr->DisplayBlock);

    facehuggerStatusPointer->Target = NULL;

    facehuggerStatusPointer->stateTimer = 0;

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

    if(sbPtr->DamageBlock.IsOnFire)

    {

        facehuggerStatusPointer->nearBehaviourState = FHNS_Dying;

    }

    else

    {

        facehuggerStatusPointer->nearBehaviourState = FHNS_Wait;

        InitHModelTweening(&facehuggerStatusPointer->HModelController, (ONE_FIXED>>3), (int)HMSQT_Hugger, (int)HSS_Stand, ONE_FIXED, 0);

        facehuggerStatusPointer->HModelController.Playing = 0; // don't show up on motion tracker

    }

}

void FacehuggerIsDamaged(STRATEGYBLOCK *sbPtr, const DAMAGE_PROFILE *damage, VECTORCH *incoming)

{

    FACEHUGGER_STATUS_BLOCK *facehuggerStatusPointer = (FACEHUGGER_STATUS_BLOCK *)(sbPtr->dataptr);    

    switch(facehuggerStatusPointer->nearBehaviourState)

    {

        case FHNS_Dying:

        return;

        case FHNS_Floating:

        {

            facehuggerStatusPointer->nearBehaviourState = FHNS_Approach;

            sbPtr->DynPtr->GravityOn = 1;

        } // no break;

        default:

        if (sbPtr->DamageBlock.Health <= 0)

        {

            DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

            switch(damage->Id)