#include "system.h"

#include "stratdef.h"

#include "bh_types.h"

#include "pldghost.h"

#include "pfarlocs.h"

#include <assert.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

SCENEMODULE MainScene;

const MATRIXCH IdentityMatrix =

{

ONE_FIXED, 0, 0,

0, ONE_FIXED, 0,

0, 0, ONE_FIXED

};

extern int ModuleArraySize;

extern int NumActiveBlocks;

extern DISPLAYBLOCK *ActiveBlockList[];

extern int render_sky;

unsigned char *ModuleCurrVisArray;

void FindVisibleModules(VMODULE *vptr, int flag)

{

    while(!vptr->end_module)

    {

        MODULE *mptr = vptr->vmod_mref.mref_ptr;

        if(NULL != mptr)

        {

            if(!ModuleCurrVisArray[mptr->m_index])

                ModuleCurrVisArray[mptr->m_index] = flag;

            // If the door/viewport is closed...

            if((NULL != vptr->vmod_data) && !(mptr->m_flags & m_flag_open))

            {

                // Branch to this vptr

                vptr = vptr->vmod_data->vmodidata_ptr;

                continue;

            }

            // else vptr++;

        }

        vptr++;

    }

}

DISPLAYBLOCK * AllocateNewObject(const int shapeIndex)

{

    DISPLAYBLOCK *dptr = CreateActiveObject();

    if(dptr)

    {

        struct shapeheader* sptr = mainshapelist[shapeIndex];

        dptr->ObShape = shapeIndex;

        dptr->ShapeData = sptr;

        dptr->extent.radius = sptr->shaperadius;

        dptr->extent.max_x = sptr->shapemaxx;

        dptr->extent.min_x = sptr->shapeminx;

        dptr->extent.max_y = sptr->shapemaxy;

        dptr->extent.min_y = sptr->shapeminy;

        dptr->extent.max_z = sptr->shapemaxz;

        dptr->extent.min_z = sptr->shapeminz;

        dptr->ObMat = IdentityMatrix;

    }

return dptr;

}

static void AllocateModuleObject(MODULE *mptr)

{

    DISPLAYBLOCK *dptr = CreateActiveObject();

    if(dptr)

    {

        mptr->m_dptr = dptr;

        dptr->Module = mptr;

        if(mptr->m_sbptr)

        {

            dptr->ObStrategyBlock = mptr->m_sbptr;

            mptr->m_sbptr->DisplayBlock = dptr;

            if(mptr->m_sbptr->morphctrl)

                dptr->ObMorphCtrl = mptr->m_sbptr->morphctrl;

        }

        MODULEMAPBLOCK *mapblockptr = mptr->m_mapptr;

        dptr->ObShape = mapblockptr->MapShape;

        dptr->ObWorld = mapblockptr->MapWorld;

        dptr->ObEuler = mapblockptr->MapEuler;

        dptr->ObFlags  = mapblockptr->MapFlags;

        dptr->ObFlags2 = mapblockptr->MapFlags2;

        dptr->ObFlags3 = mapblockptr->MapFlags3;

        struct shapeheader* sptr = mainshapelist[dptr->ObShape];

        dptr->ShapeData = sptr;

        dptr->extent.radius = sptr->shaperadius;

        dptr->extent.max_x = sptr->shapemaxx;

        dptr->extent.min_x = sptr->shapeminx;

        dptr->extent.max_y = sptr->shapemaxy;

        dptr->extent.min_y = sptr->shapeminy;

        dptr->extent.max_z = sptr->shapemaxz;

        dptr->extent.min_z = sptr->shapeminz;

        /*

        KJL 14:15:34 04/19/97 - their used to be lots of maths here

        to calculate orientation, but in AvP all modules are aligned to

        the world space axes...

        */

        dptr->ObMat = IdentityMatrix;

        /*

        Module lights

        There is an option for a pointer to an array of lights in a module

        structure. These lights are transferred to the display block and

        flagged as "LFlag_WasNotAllocated" so that "DeallocateLightBlock()"

        knows to ignore them.

        The number of lights in the array is "m_numlights" and the pointer

        is called "m_lightarray".

        The addition of non-allocated does not need to be a module specific

        option.

        Non-allocated lights can co-exist peacefully with the other lights.

        */

        if(mptr->m_numlights && mptr->m_lightarray) 

        {

            LIGHTBLOCK *lptr_array = mptr->m_lightarray;

            int i;

            for(i = mptr->m_numlights; i; i--) 

            {

                /* Make sure the light is flagged correctly */

                lptr_array->LightFlags |= LFlag_WasNotAllocated;

                AddLightBlock(dptr, lptr_array);

                /* Next light from the array */

                lptr_array++;

            }

        }

        /* Bug Fix */ // for what??

/*

        if (dptr->ObStrategyBlock) 

        {

            STRATEGYBLOCK *sbptr = dptr->ObStrategyBlock;

            if (sbptr->type == I_BehaviourSimpleAnimation) 

            {

                SIMPLE_ANIM_BEHAV_BLOCK *sanimbhv = (SIMPLE_ANIM_BEHAV_BLOCK*)(sbptr->dataptr);

                assert(sanimbhv->bhvr_type == I_BehaviourSimpleAnimation);

                assert (dptr == sbptr->DisplayBlock);

                if(!dptr->ObTxAnimCtrlBlks)    

                    dptr->ObTxAnimCtrlBlks = sanimbhv->tacbSimple;

            }

        }

*/

    }

}

int IsModuleVisibleFromModule(MODULE *source, MODULE *target)

{

    if ((source == NULL) || (target == NULL))

        return 0;

    else if (source == target)

        return 1;

    else

    {

        VMODULE *vptr = source->m_vmptr;

        while(!vptr->end_module)

        {

            /* Add this module to the visible array */

            MODULE *mptr = vptr->vmod_mref.mref_ptr;

            if(NULL != mptr)

            {

                if (mptr == target)

                    return 1;

                else if((NULL != vptr->vmod_data) && !(mptr->m_flags & m_flag_open))

                {

                    vptr = vptr->vmod_data->vmodidata_ptr;

                    continue;

                }

            }

            vptr++;

        }

        return 0;

    }

}

void ModuleHandler()

{

    int i;

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

        ModuleCurrVisArray[i] = 0;

    /*If this is an network game , and this machine is the ai server , then need to check if

      there are any aliens near to other players*/

    if(NetworkHost == AvP.PlayMode)

    {

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

        int sbIndex;

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

        {

            STRATEGYBLOCK *playerSbPtr = ActiveStBlockList[sbIndex];

            if(playerSbPtr->type != I_BehaviourNetGhost)

                continue;

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

            switch(ghostData->type)

            {

                case I_BehaviourAlienPlayer:

                case I_BehaviourMarinePlayer:

                case I_BehaviourPredatorPlayer:

                {

                    int sbIndex2 = 0;

                    //found one of the players

                    if(!playerSbPtr->containingModule)

                        continue;

                    /*now search through the strategy blocks , to see if any aliens are

                    visible from the player's location*/

                    for(; sbIndex2 < NumActiveStBlocks; sbIndex2++)

                    {

                        STRATEGYBLOCK *alienSbPtr = ActiveStBlockList[sbIndex2];

                        /*Is it an alien?*/

                        if(alienSbPtr->type != I_BehaviourAlien)

                            continue;

                        if(!alienSbPtr->containingModule)

                            continue;

                        if(IsModuleVisibleFromModule(playerSbPtr->containingModule, alienSbPtr->containingModule))

                        {

                            /*The player can see the alien , so link in all modules that the player can see*/

                            if (ModuleIsPhysical(playerSbPtr->containingModule))

                            {

                                ModuleCurrVisArray[playerSbPtr->containingModule->m_index] = 1;

                                if(playerSbPtr->containingModule->m_vmptr)

                                    FindVisibleModules(playerSbPtr->containingModule->m_vmptr, 1);

                            }

                            /* Since all modules visible by this player have now been linked,

                            don't need to check for any more aliens for this player */

                            break;

                        }

                    }

                }

                default:

                break;

            }

        }

    }

    //static void FindVisibleModulesForPlayer()

    {

        int flag = 3;

        VMODULE *vptr = PlayerStatus.sbptr->containingModule->m_vmptr;

        ModuleCurrVisArray[PlayerStatus.sbptr->containingModule->m_index] = 2;

        if(NULL != vptr)

        {

            while(!vptr->end_module)

            {

                MODULE *mptr = vptr->vmod_mref.mref_ptr;

                if(NULL != mptr)

                {

                    ModuleCurrVisArray[mptr->m_index] = flag++;

                    // If the door/viewport is closed...

                    if((NULL != vptr->vmod_data) && !(mptr->m_flags & m_flag_open))

                    {

                        // Branch to this vptr

                        vptr = vptr->vmod_data->vmodidata_ptr;

                        continue;

                    }

                    // else vptr++;

                {

                    AIMODULE *aiModulePtr = MainScene.sm_marray[mptr->m_index]->m_aimodule;

                    if(NULL != aiModulePtr)

                    {

                        MODULE **modulelistPtr = aiModulePtr->m_module_ptrs;

                        while(*modulelistPtr)

                        {

                            int index = (*modulelistPtr)->m_index;

                            if (!ModuleCurrVisArray[index])

                                ModuleCurrVisArray[index] = 1;

                            modulelistPtr++;

                        }

                    }

                }

                }

                vptr++;

            }

        }

    }

    render_sky = 0;

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

    {

        MODULE *mptr = MainScene.sm_marray[i];

        if(ModuleCurrVisArray[i] > 1)

        {

            /* mptr->m_mapptr Not all modules have maps */

            if(!mptr->m_dptr && !(mptr->m_flags & m_flag_dormant) && mptr->m_mapptr)

            {

                AllocateModuleObject(mptr);

            }

            if((mptr->m_flags & MODULEFLAG_SKY) && (ModuleCurrVisArray[mptr->m_index] > 1))

                render_sky = 1;

        }

        else if(mptr->m_dptr)

        {

            DestroyActiveObject(&mptr->m_dptr);

            if(mptr->m_sbptr) 

                mptr->m_sbptr->DisplayBlock = NULL;

        }

    }

}

int ThisObjectIsInAModuleVisibleFromCurrentlyVisibleModules(STRATEGYBLOCK *sbPtr)

{

    assert(sbPtr);

    assert(sbPtr->containingModule);

    VMODULE *vPtr = sbPtr->containingModule->m_vmptr;

    assert(vPtr);

    if(ModuleCurrVisArray[sbPtr->containingModule->m_index] > 1)

        return 1;

    while(!vPtr->end_module)

    {

        /* consider this module */

        MODULE *mptr = vPtr->vmod_mref.mref_ptr;

        if(NULL != mptr)

        {

            if(ModuleCurrVisArray[mptr->m_index] > 1)

            {

                if(NULL != vPtr->vmod_data)

                {

                    if (mptr->m_flags & m_flag_open)

                        return 1;

                }

                else

                    return 1;

            }

            if((NULL != vPtr->vmod_data) && !(mptr->m_flags & m_flag_open))

            {

                /* If the door/viewport is closed... */

                /* Branch to this vPtr */

                /* else vPtr++; */

                vPtr = vPtr->vmod_data->vmodidata_ptr;

                continue;

            }

        }

        vPtr++;

    }

return 0;

}

static void PrintName(char *name)

{

    char m_name[5];

    m_name[0] = name[0];

    m_name[1] = name[1];

    m_name[2] = name[2];

    m_name[3] = name[3];

    m_name[4] = '\0';

    printf("%s",m_name);

}

// Convert MREF name to MREF pointer

void ConvertModuleNameToPointer(MREF *mref_ptr, MODULE **m_array_ptr)

{

    /* Set "null" names to null pointers */

    if(!strncmp(mref_ptr->mref_name, "null", 4))

    {

        mref_ptr->mref_ptr = NULL;

        return;

    }

    /* Search for the module with the same name */

    while(*m_array_ptr)

    {

        MODULE *m_ptr = *m_array_ptr++;

        if(!strncmp(mref_ptr->mref_name, m_ptr->m_name, 5))

        {

            /*

                printf("  found name ");

                PrintName(&m_ptr->m_name);

                printf(", ptr %u\n", m_ptr);

            */

            mref_ptr->mref_ptr = m_ptr;

            return;

        }

    }

    /* If the name was not found, make this a null pointer */

    mref_ptr->mref_ptr = NULL;

}

// Convert VMODIDATA.vmodidata_label names to VMODIDATA.vmodidata_ptr

static void ConvertVModuleNameToPointer(VMODIDATA *vmodidata_ptr, VMODULE *v_array_ptr)

{

    /* Set "null" names to null pointers */

    if(!strncmp(vmodidata_ptr->vmodidata_label, "null", 4))

    {

        vmodidata_ptr->vmodidata_ptr = NULL;

        return;

    }

    while(!v_array_ptr->end_module)

    {

        if(!strncmp(vmodidata_ptr->vmodidata_label, v_array_ptr->vmod_name, 4))

        {

            /*

                printf("  found name ");

                PrintName(&v_array_ptr->vmod_name);

                printf(", ptr %u\n", v_array_ptr);

            */

            vmodidata_ptr->vmodidata_ptr = v_array_ptr;

            return;

        }

        v_array_ptr++;

    }

    vmodidata_ptr->vmodidata_ptr = v_array_ptr->end_module ? v_array_ptr : NULL;

}

/*

 VMODIDATA is the data associated with VMODI, the VMODULE instruction. Some

 of the data items are names which need to be converted to pointers.

*/

static void PreprocessVMODIDATA(VMODULE *v_ptr)

{

    #define vm_flag_gotptrs    0x00000001      /* VMODULE references have been converted from names to pointers */

    VMODULE *v_array_ptr = v_ptr;

    while(!v_ptr->end_module)

    {

        if((NULL != v_ptr->vmod_data) && !(v_ptr->vmod_flags & vm_flag_gotptrs))

        {

            ConvertVModuleNameToPointer(v_ptr->vmod_data, v_array_ptr);

            v_ptr->vmod_flags |= vm_flag_gotptrs;

        }

        v_ptr++;

    }

}

/*

 The Module Preprocessor

 Pass the array of pointers to modules.

 This function creates module indices and converts names into pointers.

*/

void PreprocessModuleArray()

{

    MODULE **m_array_ptr = MainScene.sm_marray;

    ModuleArraySize = 0;

    #define m_flag_gotptrs                  0x00000002      /* Module references have been converted from names to pointers */

    while(*m_array_ptr)

    {

        MODULE *m_ptr = *m_array_ptr;

        m_ptr->m_index = ModuleArraySize++;

        /*

            printf("\nModule %u, ", m_ptr);

            PrintName(&m_ptr->m_name);

            printf(", index %d\n", m_ptr->m_index);

            printf("  (vptr = ");

            PrintName(&m_ptr->m_vptr.mref_name);

            printf(")\n");

        */

        /* Convert module references from names to pointers */

        if(m_ptr->m_vmptr && !(m_ptr->m_flags & m_flag_gotptrs))

        {

            /* Convert VMODIDATA names to pointers */

            PreprocessVMODIDATA(m_ptr->m_vmptr);

            /* Tell the module that its names are now pointers */

            m_ptr->m_flags |= m_flag_gotptrs;

        }

        m_array_ptr++;

    }

    ModuleCurrVisArray = malloc(ModuleArraySize);

    if (NULL == ModuleCurrVisArray)

    {

        printf("GetModuleVisArrays() failed\n");

    }

    else

    {

        int i;

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

            ModuleCurrVisArray[i] = 0;

    }

    //printf("visibility arrays ok, size %d\n", ModuleArraySize);

}

int IsAIModuleVisibleFromAIModule(AIMODULE *source, AIMODULE *target)

{

    if ((source == NULL) || (target == NULL))

        return 0;

    else if (source == target)

        return 1;

    else

    {

        MODULE **sourceModulelistPtr = source->m_module_ptrs;

        while(*sourceModulelistPtr) 

        {

            MODULE **targetModulelistPtr = target->m_module_ptrs;

            while(*targetModulelistPtr) 

            {

                if (IsModuleVisibleFromModule(*sourceModulelistPtr,*targetModulelistPtr)) 

                    return 1;

                targetModulelistPtr++;

            }

            sourceModulelistPtr++;

        }

        return 0;

    }

}

void DeallocateModules()

{

    int i = 0;

    if(NULL != MainScene.sm_marray)

    {

        MODULE **m_arrayPtr = MainScene.sm_marray;

        while (*m_arrayPtr)

        {

            MODULE * this_mod = *m_arrayPtr++;

            free(this_mod->m_mapptr);

            free(this_mod->name);

            if(NULL != this_mod->m_vmptr)

            {

                VMODULE *temp = this_mod->m_vmptr;

                while(!temp->end_module)

                {

                    free(temp->vmod_data);

                    temp++;

                }

                free(this_mod->m_vmptr);

            }

            free(this_mod->m_lightarray);

        }

        free(MainScene.sm_marray);

        MainScene.sm_marray = NULL;

    }

    free(MainScene.sm_module);

    MainScene.sm_module = NULL;

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

    {

        AIMODULE* aim = &AIModuleArray[i];

        WAYPOINT_HEADER* wh = aim->m_waypoints;

        free(aim->m_link_ptrs);

        free(aim->m_module_ptrs);

        if(NULL != wh)

        {

            int j = 0;

            for(; j < wh->num_waypoints; j++)

            {

                WAYPOINT_VOLUME* wv = &wh->first_waypoint[j];

                free(wv->first_link);    

            }

            free(wh->first_waypoint);

            free(wh);

          }

    }

    free(AIModuleArray);

    AIModuleArray = NULL;

    free(ModuleCurrVisArray);

    ModuleCurrVisArray = NULL;

}