#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "bh_types.h"

#include "pheromon.h"

#include "pfarlocs.h"

#include "pldghost.h"

#include <stdlib.h>

#include <assert.h>

static uint32_t *Pher_Player1;

static uint32_t *Pher_Player2;

extern int CheckAdjacencyValidity(AIMODULE *target,AIMODULE *source,int alien);

/* these pointers indicate the current read from and write to

buffers for the player and ai pheromone systems */

uint32_t *PherPl_ReadBuf;

uint32_t *PherPl_WriteBuf;

#if SUPER_PHEROMONE_SYSTEM

static uint32_t *Pher_Aliens1;

static uint32_t *Pher_Aliens2;

uint32_t *PherAls_ReadBuf;

uint32_t *PherAls_WriteBuf;

/* Marine pheromones: a pathfinding system only. */

static uint32_t *Pher_Marines1;

static uint32_t *Pher_Marines2;

uint32_t *PherMars_ReadBuf;

uint32_t *PherMars_WriteBuf;

#endif

/* This global is used to store    the current player phermone intensity */

unsigned int PlayerSmell;

/* this define enables diagnostic text 'dump' for pheromone system */

#define logPheromoneDiagnostics 0

#if logPheromoneDiagnostics

static void LogPlayerPherValues();

static void LogModuleAdjacencies();

int printModAdj = 1;

#endif

void InitPheromoneSystem()

{

    int i;

    /* allocate the pheromone buffers */

    Pher_Player1 = malloc((AIModuleArraySize + 1) * sizeof(uint32_t));

    Pher_Player2 = malloc((AIModuleArraySize + 1) * sizeof(uint32_t));

    if(!Pher_Player1 || !Pher_Player2) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    #if SUPER_PHEROMONE_SYSTEM

    Pher_Aliens1 = calloc(AIModuleArraySize + 1, sizeof(uint32_t));

    if(!Pher_Aliens1) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    Pher_Aliens2 = calloc(AIModuleArraySize + 1, sizeof(uint32_t));

    if(!Pher_Aliens2) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    Pher_Marines1 = calloc(AIModuleArraySize + 1, sizeof(uint32_t));

    if(!Pher_Marines1) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    Pher_Marines2 = calloc(AIModuleArraySize + 1, sizeof(uint32_t));

    if(!Pher_Marines2) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    #endif

    /* init the player phermone system */

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

        Pher_Player1[i] = Pher_Player2[i] = 1;

    PherPl_ReadBuf = &Pher_Player1[0]; 

    PherPl_WriteBuf = &Pher_Player2[0]; 

    PlayerSmell = 3;

    #if SUPER_PHEROMONE_SYSTEM

    PherAls_ReadBuf = &Pher_Aliens1[0]; 

    PherAls_WriteBuf = &Pher_Aliens2[0]; 

    PherMars_ReadBuf = &Pher_Marines1[0]; 

    PherMars_WriteBuf = &Pher_Marines2[0]; 

    #endif

    #if logPheromoneDiagnostics

    printModAdj = 1;

    #endif

}

/*----------------------Patrick 14/3/96--------------------------- 

End of level clean up for pheromone system

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

void CleanUpPheromoneSystem()

{

    #if 1

    if (Pher_Player1 != NULL)

    {

        free(Pher_Player1); 

        Pher_Player1 = NULL;

    }

    if (Pher_Player2 != NULL)

    {

        free(Pher_Player2);

        Pher_Player2 = NULL;

    }

    PherPl_ReadBuf = NULL;

    PherPl_WriteBuf = NULL;

    #endif

    #if SUPER_PHEROMONE_SYSTEM

    if (Pher_Aliens1 != NULL)

    {

        free(Pher_Aliens1);

        Pher_Aliens1 = NULL;

    }

    if (Pher_Aliens2 != NULL)

    {

        free(Pher_Aliens2);

        Pher_Aliens2 = NULL;

    }

    if (Pher_Marines1 != NULL)

    {

        free(Pher_Marines1);

        Pher_Marines1 = NULL;

    }

    if (Pher_Marines2 != NULL)

    {

        free(Pher_Marines2);

        Pher_Marines2 = NULL;

    }

    PherAls_ReadBuf = NULL;

    PherAls_WriteBuf = NULL;

    PherMars_ReadBuf = NULL;

    PherMars_WriteBuf = NULL;

    #endif

}

int AIModuleAdmitsPheromones(AIMODULE *targetModule)

{

    switch(AIModuleIsADoor(targetModule))

    {

        case MDT_ProxDoor:

        {

            /* Go thru UNLOCKED proxdoors... */

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

            PROXDOOR_BEHAV_BLOCK *pdbblk = ((PROXDOOR_BEHAV_BLOCK *)renderModule->m_sbptr->dataptr);

            return !(pdbblk->door_locked);

        }

        case MDT_LiftDoor:

        case MDT_SecurityDoor:

             assert(targetModule->m_module_ptrs);

             assert(*(targetModule->m_module_ptrs));

             return GetState((*(targetModule->m_module_ptrs))->m_sbptr);

        //case MDT_NotADoor: assert(0);

        default:

            return 1;

    }

}

#if SUPER_PHEROMONE_SYSTEM

void AddPheromones(AIMODULE *targetModule)

{

    PherAls_WriteBuf[targetModule->m_index] += 3;

}

void MaintainMarineTargetZone(AIMODULE *targetModule)

{

    PherMars_WriteBuf[targetModule->m_index] += 3;

}

#endif

/*----------------------Patrick 12/11/96--------------------------- 

Updates the player pheromone system:

this is used by the NPC far behaviour for hunting the player.

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

void PlayerPheromoneSystem()

{

    int moduleCounter = 0;

    #if logPheromoneDiagnostics    

        if(printModAdj)

        {

            printModAdj = 0;

            LogModuleAdjacencies();

        }

    #endif

    /* get a pointer to the global array of pointers to the modules

    in the environment (interfaces'r'us).  */

    AIMODULE *ModuleListPointer = AIModuleArray;

    /* go through each module in the environment  */    

    for(; moduleCounter < AIModuleArraySize; moduleCounter++)

    {

        /* get a pointer to the next current module */

        AIMODULE *ThisModulePtr = &ModuleListPointer[moduleCounter]; 

        assert(ThisModulePtr);

        /* get it's index */

        int ThisModuleIndex = ThisModulePtr->m_index;

        assert(ThisModuleIndex >= 0);

        assert(ThisModuleIndex < AIModuleArraySize);

        /* !!!!!!!!!!!!!!!!!!!!!

        check for closed non-traversable door module here if detected, do not update its smell.

        Actually, no: allow smell to pass thro' non-openable doors. Otherwise AIs that can open

        doors will choose not to 

        !!!!!!!!!!!!!!!!!!!!!!!!*/

        /* CDF 4/12/97: Actually, yes.  AIs CAN'T open security doors, fool! */

        /* check for universal module: don't want to update this! */

        if(AIModuleIsPhysical(ThisModulePtr))

        {

            if (AIModuleAdmitsPheromones(ThisModulePtr))

            {

                /* get a pointer to the list of physically adjacent modules

                and traverse them */

                AIMODULE **AdjModuleRefPtr = ThisModulePtr->m_link_ptrs;

                if(AdjModuleRefPtr)    /* check that there is a list of adjacent modules */

                {

                    while(*AdjModuleRefPtr != 0)

                    {

                        /* get the index */

                        int AdjModuleIndex = (*AdjModuleRefPtr)->m_index;

                        /* if adjacent module's previous smell is greater than

                        the current module's new smell (so far), then update

                        the current module's newq smell */

                        if(PherPl_ReadBuf[AdjModuleIndex] > PherPl_WriteBuf[ThisModuleIndex])

                            PherPl_WriteBuf[ThisModuleIndex] = (PherPl_ReadBuf[AdjModuleIndex] - 1);

                        #if SUPER_PHEROMONE_SYSTEM

                        if(PherAls_ReadBuf[AdjModuleIndex] > PherAls_WriteBuf[ThisModuleIndex])

                            PherAls_WriteBuf[ThisModuleIndex] = (PherAls_ReadBuf[AdjModuleIndex] - 1);

                        if (CheckAdjacencyValidity((*AdjModuleRefPtr), ThisModulePtr, 0))

                        {

                            if(PherMars_ReadBuf[AdjModuleIndex] > PherMars_WriteBuf[ThisModuleIndex])

                            {

                                PherMars_WriteBuf[ThisModuleIndex] = (PherMars_ReadBuf[AdjModuleIndex] - 1);

                            }

                        }

                        #endif

                        /* next adjacent module reference pointer */

                        AdjModuleRefPtr++;

                    }

                }

            }

            #if SUPER_PHEROMONE_SYSTEM

            /* Decay pheromones. */

            if (PherAls_WriteBuf[ThisModuleIndex] > 0)

                PherAls_WriteBuf[ThisModuleIndex]--;

            if (PherMars_WriteBuf[ThisModuleIndex] > 0)

                PherMars_WriteBuf[ThisModuleIndex]--;

            #endif

        }

    }

    switch(AvP.PlayMode)

    {

    case NetworkHost:

    case Skirmish:

        /*If in a network game add pheromon's for other players*/

        {

            /* go through the strategy blocks looking for players*/

            int sbIndex = 0;

            for(; sbIndex < NumActiveStBlocks; sbIndex++)

            {

                STRATEGYBLOCK *playerSbPtr = ActiveStBlockList[sbIndex];

                if(playerSbPtr->type != I_BehaviourNetGhost)

                    continue;

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

                if(ghostData->type == I_BehaviourMarinePlayer || ghostData->type == I_BehaviourPredatorPlayer)

                {

                    /*this is another player*/

                    if(playerSbPtr->containingModule)

                    {

                        PherPl_WriteBuf[playerSbPtr->containingModule->m_aimodule->m_index] = PlayerSmell;

                        AddPheromones(playerSbPtr->containingModule->m_aimodule);

                    }

                }

            }

        }

    default:

    break;

    }

    /* That completed, find which module the player is in, set it's smell to the

    current player smell value, and update the player smell for the next frame */

    if(PlayerStatus.sbptr->containingModule)

    {

        //the player must be alive to leave pheromones 

        //(mainly relevant in coop games)

        if(PlayerStatus.Alive)

        {

            PherPl_WriteBuf[PlayerStatus.sbptr->containingModule->m_aimodule->m_index] = PlayerSmell;

/*

            if(PlayerStatus.sbptr->containingModule->name)

            {

printf("Player Module: %d '%s'\n", PlayerStatus.sbptr->containingModule->m_index, PlayerStatus.sbptr->containingModule->name);

printf("Player Module Coords: %d %d %d\n", PlayerStatus.sbptr->containingModule->m_world.vx,
PlayerStatus.sbptr->containingModule->m_world.vy, PlayerStatus.sbptr->containingModule->m_world.vz);

            }

*/

        }

    }

    PlayerSmell++;

    #if SUPER_PHEROMONE_SYSTEM

    /* Note that marines should add pheromones at the AI level... */

    {

        uint32_t *tempBufPointer = PherAls_ReadBuf;

        PherAls_ReadBuf = PherAls_WriteBuf;

        PherAls_WriteBuf= tempBufPointer;

      }

    /* As should the pathfinding system. */

    {

        uint32_t *tempBufPointer = PherMars_ReadBuf;

        PherMars_ReadBuf = PherMars_WriteBuf;

        PherMars_WriteBuf= tempBufPointer;

      }

    #endif

    /* swap the read and write buffers:

       behaviours access most recent data thro' the read buffer */

    {

        uint32_t *tempBufPointer = PherPl_ReadBuf;

        PherPl_ReadBuf = PherPl_WriteBuf;

        PherPl_WriteBuf    = tempBufPointer;

      }

    #if logPheromoneDiagnostics

    LogPlayerPherValues();

    #endif

}

#if logPheromoneDiagnostics 

/* write out a list of module ajacencies */

static void LogModuleAdjacencies()

{

    extern SCENEMODULE MainScene;

    assert(0);

    /* This function does not use AI modules yet! */

    FILE *logFile;

    int i;

    MODULE **ModuleListPointer = MainScene.sm_marray;

    MODULE *ThisModulePtr;

    int ThisModuleIndex;    

    MREF *AdjModuleRefPtr;

    int AdjModuleIndex;

    logFile = fopen("avp/modadj.txt","w");

    if(logFile)

    {

        assert(ModuleArraySize);

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

        {

            ThisModulePtr = ModuleListPointer[i]; 

            assert(ThisModulePtr);

            /* get it's index */

            ThisModuleIndex = ThisModulePtr->m_index;

            assert(ThisModuleIndex >= 0);

            assert(ThisModuleIndex < ModuleArraySize);

            //fprintf(logFile, "Module %d Adjoing modules: ", ThisModuleIndex);

            /* get a pointer to the list of physically adjacent modules

            and traverse them */

            AdjModuleRefPtr = ThisModulePtr->m_link_ptrs;

            if(AdjModuleRefPtr == 0)

            {

                //fprintf(logFile, " None/n");

            }

            else

            {

                while(AdjModuleRefPtr->mref_ptr != 0)

                {

                    /* get the index */

                    AdjModuleIndex = (AdjModuleRefPtr->mref_ptr)->m_index;

                    //fprintf(logFile, " %d,", AdjModuleIndex);

                    /* next adjacent module reference pointer */

                    AdjModuleRefPtr++;

                }

                //fprintf(logFile, "\n");

            }

        }

        fclose(logFile);

    }

    /* also, initialise pheromone value file */

    logFile = fopen("D:/PATRICK/MODPPHER.TXT","w");

    if(logFile) 

    {

        fprintf(logFile, "PLAYER PHEROMONE VALUES \n");

        fclose(logFile);

    }

}

/* Log the player pheromone values */

static void LogPlayerPherValues()

{

    int i;

    FILE *logFile = fopen("D:/PATRICK/MODPPHER.TXT","a");

    if (!logFile) return;

    fprintf(logFile, "\n ***************************** \n");

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

    {

        if(i % 7 == 0)

            fprintf(logFile, "\n");

        fprintf(logFile, "%5d", PherPl_ReadBuf[i]);    

    }

fclose(logFile);

}

#endif