#include "system.h"

#include "stratdef.h"

#include "bh_types.h"

#include "pheromon.h"

#include "bh_far.h"

#include "pfarlocs.h"

#include "dynamics.h"

#include "pvisible.h"

#include "bh_ais.h"

#include "net.h"

#include <stdio.h>

#include <assert.h>

//static int entryPointFailures = 0;

/* Patrick 2/7/97:

This function turns the npc around (in y) a random amount: this is used to

turn the npc around if it reaches an impasse in the environment, and the

orientation is used to select a target module for wandering behaviour */

void FarNpc_FlipAround(STRATEGYBLOCK *sbPtr)

{

    assert(sbPtr);

     /* get the dynamics block */

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    assert(dynPtr);

    dynPtr->OrientEuler.EulerY += (1024 + FastRandom() % 1024);

    dynPtr->OrientEuler.EulerY &= wrap360;

}

AIMODULE *FarNPC_GetTargetAIModuleForRetreat(STRATEGYBLOCK *sbPtr)

{

    extern unsigned int PlayerSmell;

    AIMODULE* targetModule = NULL;

    unsigned int targetSmell = PlayerSmell + 1;    /* should be higher than any smell anywhere this frame */

    unsigned int targetNumAdj = 0;

    assert(sbPtr);

    if(sbPtr->containingModule == NULL)

        return NULL;

    AIMODULE **AdjModuleRefPtr = sbPtr->containingModule->m_aimodule->m_link_ptrs;

    /* check that there is a list of adjacent modules, and that it is not

    empty (ie points to zero) */

    if(AdjModuleRefPtr)

    {

        while(*AdjModuleRefPtr != 0)

        {

            /* get the index */

            int AdjModuleIndex = (*AdjModuleRefPtr)->m_index;

            int AdjModuleSmell = PherPl_ReadBuf[AdjModuleIndex];

            int AdjModuleNumAdjacencies = NumAdjacentModules((*AdjModuleRefPtr));

            /* if this adjacent module's smell value is lower than

            the current 'highest smell' record the new module as the

            target.  If they're equal, tie-break on number of adjacencies*/

            if( (!targetModule) ||

                (AdjModuleSmell < targetSmell)||

                ((AdjModuleSmell == targetSmell) && (AdjModuleNumAdjacencies > targetNumAdj)))

            {

                targetSmell = PherPl_ReadBuf[AdjModuleIndex];

                targetModule = *AdjModuleRefPtr;

                targetNumAdj = NumAdjacentModules((*AdjModuleRefPtr));

            }

            /* next adjacent module reference pointer */

            AdjModuleRefPtr++;

        }

    }

return targetModule;

}

void LocateFarNPCInAIModule(STRATEGYBLOCK *sbPtr, AIMODULE *targetModule)

{

    VECTORCH newPosition;

    MODULE *renderModule;

    int targetLocInx;

    /* now: a few tests for npc's that are generated... (aliens and marines) */

/*

    switch(sbPtr->type)

    {

        case I_BehaviourAlien:

        case I_BehaviourMarine:

        {

            //if(ModuleCurrVisArray[(*(targetModule->m_module_ptrs))->m_index])

            if (AIModuleIsVisible(targetModule)) 

            {

                if(NumGeneratorNPCsVisible() >= MAX_VISIBLEGENERATORNPCS)

                    return;

            }

        }

        default:

        break;

    }

*/

    /* now move the npc to it's target... */

    int noOfAuxLocs = FALLP_AuxLocs[(targetModule->m_index)].numLocations;

    VECTORCH *auxLocsList = FALLP_AuxLocs[(targetModule->m_index)].locationsList;  

    /* find the entry point for the target */

    assert(sbPtr->containingModule);

    FARENTRYPOINT *targetEntryPoint = GetAIModuleEP(targetModule,(sbPtr->containingModule->m_aimodule));

    assert(targetEntryPoint);

    /* if it's visible, use the entry point.

    if it's not visible, use an auxilary location. If there aren't any auxilary

    locations, use the entry point. */

    //if(ModuleCurrVisArray[(*(targetModule->m_module_ptrs))->m_index])

    if (AIModuleIsVisible(targetModule)) 

    {

        newPosition = targetEntryPoint->position;

        targetLocInx = -1;

       }

    else

    {

           /* pick an auxilary location: if there aren't any, use the entry point */

        if(noOfAuxLocs)

        {

               targetLocInx = FastRandom() % noOfAuxLocs;

               newPosition = auxLocsList[targetLocInx];

               /* move up 1/2 npc height, plus a bit more(100). this only applies

               to auxilary locations, not eps */            

            if(SinglePlayer != AvP.PlayMode)

            {

                //Multiplayer game

                //send this new position to the other players

                AddNetMsg_FarAlienPosition(sbPtr, targetModule->m_index, targetLocInx, 0);

            }

           }

        else

        {

            newPosition = targetEntryPoint->position;

            if(SinglePlayer != AvP.PlayMode)

            {

                //Multiplayer game

                //send this new position to the other players

                AddNetMsg_FarAlienPosition(sbPtr, targetModule->m_index, sbPtr->containingModule->m_aimodule->m_index, 1);

            }

        }

       }

    {

        VECTORCH temp_Pos;

        temp_Pos.vx = newPosition.vx+targetModule->m_world.vx;

        temp_Pos.vy = newPosition.vy+targetModule->m_world.vy;

        temp_Pos.vz = newPosition.vz+targetModule->m_world.vz;

        renderModule = ModuleFromPosition(&temp_Pos, sbPtr->containingModule);

        if (renderModule == NULL)

            return;

    }

       /* now set the alien's new position and current module. 

       NB this is world position + alien height in y + a little extra in y to make sure */

    {

        DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

        assert(dynPtr);

        dynPtr->Position = newPosition;

        dynPtr->Position.vx += targetModule->m_world.vx;

        dynPtr->Position.vy += targetModule->m_world.vy;

        dynPtr->Position.vz += targetModule->m_world.vz;

        dynPtr->PrevPosition = dynPtr->Position;

           dynPtr->OrientEuler.EulerX = dynPtr->OrientEuler.EulerZ = 0;

           {

            VECTORCH vec; 

            vec.vx = targetModule->m_world.vx - sbPtr->containingModule->m_world.vx;

            vec.vz = targetModule->m_world.vz - sbPtr->containingModule->m_world.vz;

            vec.vy = 0;

            Normalise(&vec);

               dynPtr->OrientEuler.EulerY = ArcTan(vec.vx, vec.vz);

        }

    }

    /* finally, update the alien's module */

    sbPtr->containingModule = renderModule;    

    #if UseLocalAssert   

    {

        VECTORCH localCoords;

        MODULE *thisModule = sbPtr->containingModule;

        assert(thisModule);

        localCoords = sbPtr->DynPtr->Position;

        localCoords.vx -= thisModule->m_world.vx;

        localCoords.vy -= thisModule->m_world.vy;

        localCoords.vz -= thisModule->m_world.vz;

        if(!PointIsInModule(thisModule, &localCoords))

        {

            //printf("FAR ALIEN MODULE CONTAINMENT FAILURE \n");

            printf("Alien containment failure: alien is in %s, position is %d,%d,%d:\nModule extents are: %d:%d, %d:%d, %d:%d",

                thisModule->name,localCoords.vx,localCoords.vy,localCoords.vz,

                thisModule->m_maxx,thisModule->m_minx,thisModule->m_maxy,thisModule->m_miny,

                thisModule->m_maxz,thisModule->m_minz);

            assert(1==0);

        }  

    }

    #endif

}

/*--------------------Patrick 10/12/96----------------------

  This function returns the status of a passed target 

  module that an NPC might want to move to.

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

NPC_TARGETMODULESTATUS GetTargetAIModuleStatus(STRATEGYBLOCK *sbPtr, AIMODULE *targetModule, int alien)

{

    /* first check for entry point from current module */

    {

        FARENTRYPOINT *targetEntryPoint = GetAIModuleEP(targetModule, sbPtr->containingModule->m_aimodule);

        if((NULL == targetEntryPoint) || (!alien && targetEntryPoint->alien_only))

            return NPCTM_NoEntryPoint;

    }

    MODULE *renderModule = *(targetModule->m_module_ptrs);

    MODULEDOORTYPE doorStatus = ModuleIsADoor(renderModule);

    switch(doorStatus)

    {

        case MDT_ProxDoor:

        {    

             if(GetState(renderModule->m_sbptr)) 

                 return NPCTM_ProxDoorOpen;

            else

                return NPCTM_ProxDoorNotOpen;

        }

        break;

        case MDT_LiftDoor:

        {    

             if(GetState(renderModule->m_sbptr)) 

                 return NPCTM_LiftDoorOpen;

            else

                return NPCTM_LiftDoorNotOpen;

        }

        break;

        case MDT_SecurityDoor:

        {

             if(GetState(renderModule->m_sbptr)) 

                 return NPCTM_SecurityDoorOpen;

            else

                return NPCTM_SecurityDoorNotOpen;

        }

        break;

        default:

        {

            assert(doorStatus==MDT_NotADoor);

        }

    }

    /* now check for lift */

    if(sbPtr->type == I_BehaviourLift)

        return NPCTM_LiftTeleport;

    /* check for air duct */

    if(renderModule->m_flags & MODULEFLAG_AIRDUCT)

        return NPCTM_AirDuct;

/* at this point, we know it's a room (or stairs) ... */

return NPCTM_NormalRoom;         

}

/* Patrick 1/7/97-----------------------------------------

  A suit of functions for general far NPC use which return a 

  target module for hunting, wandering, and retreating

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

AIMODULE *FarNPC_GetTargetAIModuleForHunt(STRATEGYBLOCK *sbPtr, int alien)

{

    unsigned int highestSmell = 0;

    AIMODULE* targetModule = NULL;

    AIMODULE **AdjModuleRefPtr = sbPtr->containingModule->m_aimodule->m_link_ptrs;

    /* check that there is a list of adjacent modules, and that it is not

    empty (ie points to zero) */

    if(AdjModuleRefPtr)    

    {

        while(*AdjModuleRefPtr != 0)

        {

            /* get the index */

            int AdjModuleIndex = (*AdjModuleRefPtr)->m_index;

            if (CheckAdjacencyValidity((*AdjModuleRefPtr), sbPtr->containingModule->m_aimodule, alien))

            {

                /* if this adjacent module's smell value is higher than

                the current 'highest smell' record the new module as the

                target. */

                if(PherPl_ReadBuf[AdjModuleIndex] > highestSmell)

                {                        

                    highestSmell = PherPl_ReadBuf[AdjModuleIndex];

                    targetModule = *AdjModuleRefPtr;                            

                }

            }

            /* next adjacent module reference pointer */

            AdjModuleRefPtr++;

        }

    }

    /* Consider my module being the target. */

    if (PherPl_ReadBuf[sbPtr->containingModule->m_aimodule->m_index] > highestSmell)

        return sbPtr->containingModule->m_aimodule;

    else

        return targetModule;

}

/* Patrick 2/7/96: this function returns a module for wandering to */

AIMODULE *FarNPC_GetTargetAIModuleForWander(STRATEGYBLOCK *sbPtr, AIMODULE *exception, int alien)

{

    AIMODULE* targetModule = NULL;

    int bestDirn = -100000;    /* lower than the lowest */

    VECTORCH npcDirn;

    /* some checks */

    if(!sbPtr)

        return NULL;    

    DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr;

    if(!dynPtr)

        return NULL;    

    /* get npc 2d directional vector */

    npcDirn.vx = GetSin(dynPtr->OrientEuler.EulerY);

    npcDirn.vz = GetCos(dynPtr->OrientEuler.EulerY);

    npcDirn.vy = 0;

    Normalise(&npcDirn);

    /* init adjacent module pointer */

    AIMODULE **AdjModuleRefPtr = sbPtr->containingModule->m_aimodule->m_link_ptrs;

    /* check that there is a list of adjacent modules, and that it is not

    empty (ie points to zero) */

    if(AdjModuleRefPtr)    

    {

        while(*AdjModuleRefPtr != 0)

        {

            AIMODULE *nextAdjModule = *AdjModuleRefPtr;

            VECTORCH moduleDirn;    

            if (CheckAdjacencyValidity((*AdjModuleRefPtr), sbPtr->containingModule->m_aimodule,alien))

            {

                moduleDirn.vx = nextAdjModule->m_world.vx - sbPtr->containingModule->m_world.vx;

                moduleDirn.vz = nextAdjModule->m_world.vz - sbPtr->containingModule->m_world.vz;

                moduleDirn.vy = 0;

                Normalise(&moduleDirn);

                int thisDirn = DotProduct(&npcDirn,&moduleDirn);

                if( (thisDirn > bestDirn) && (exception != nextAdjModule))

                {

                    targetModule = nextAdjModule;

                    bestDirn = thisDirn;

                }

            }

            AdjModuleRefPtr++;

        }

    }

return targetModule;

}