#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "bh_types.h"

#include <assert.h>

#include "pldghost.h"

#include "pfarlocs.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;

static void FindVisibleModules(VMODULE *vptr, int flag)

{

    while(!vptr->end_module)

    {

        MODULE *mptr = NULL;

        /* Add this module to the visible array */

        if(vptr->vmod_mref.mref_ptr)

        {

            mptr = vptr->vmod_mref.mref_ptr;

            ModuleCurrVisArray[mptr->m_index] = flag;

        }

        /* VMODULE instructions */

        switch(vptr->vmod_instr)

        {

            case vmodi_null:

                vptr++;

            break;

            case vmodi_bra_vc:

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

                /* Branch to this vptr */

                /* else vptr++; */

                if(mptr)

                {

                    if(mptr->m_flags & m_flag_open)

                        vptr++;

                    else

                        vptr = vptr->vmod_data.vmodidata_ptr;

                }

        }

    }

}

DISPLAYBLOCK * AllocateNewObject(const int shapeIndex)

{

    DISPLAYBLOCK *dptr = CreateActiveObject();

    if(dptr)

    {

        dptr->ObShape = shapeIndex;

        struct shapeheader* sptr = mainshapelist[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 = NULL;

            if(vptr->vmod_mref.mref_ptr)

            {

                mptr = vptr->vmod_mref.mref_ptr;

                if (mptr == target)

                    return 1;

            }

            /* VMODULE instructions */

            switch(vptr->vmod_instr)

            {

                case vmodi_null:

                    vptr++;

                break;

                case vmodi_bra_vc:

                    /* NYD */

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

                    /* Branch to this vptr */

                    if(mptr)

                    {

                        if(mptr->m_flags & m_flag_open)

                            vptr++;

                        else

                            vptr = vptr->vmod_data.vmodidata_ptr;

                    }

                    /* else vptr++; */

            }

        }

        return 0;

    }

}

void ModuleHandler()

{

    int i;

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

        ModuleCurrVisArray[i] = 0;

    /* handle dynamic module objects */

    {

        int numberOfObjects = NumActiveBlocks;

           while (numberOfObjects--)

        {

            DISPLAYBLOCK* objectPtr = ActiveBlockList[numberOfObjects];

            if(objectPtr->ObFlags3 & ObFlag3_DynamicModuleObject)

            {

                STRATEGYBLOCK *sbPtr = objectPtr->ObStrategyBlock;

                sbPtr->containingModule = ModuleFromPosition(&objectPtr->ObWorld, sbPtr->containingModule);

                if (sbPtr->containingModule && ModuleIsPhysical(sbPtr->containingModule))

                {

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

                    if(sbPtr->containingModule->m_vmptr)

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

                }

            }

        }

    }

    /*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;

            }

        }

    }

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

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

        FindVisibleModules(PlayerStatus.sbptr->containingModule->m_vmptr, 2);

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

    {

        /* handle AIMODULE visibility stuff */

        if (ModuleCurrVisArray[i] == 2)

        {

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

            if (aiModulePtr)

            {

                MODULE **modulelistPtr = aiModulePtr->m_module_ptrs;

                while(*modulelistPtr)

                {

                    int index = (*modulelistPtr)->m_index;

                    if (!ModuleCurrVisArray[index])

                        ModuleCurrVisArray[index] = 1;

                    modulelistPtr++;

                }

            }

        }

    }

    render_sky = 0;

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

    {

        MODULE *mptr = MainScene.sm_marray[i];

        if(ModuleCurrVisArray[i])

        {

            /* 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) && (2 == ModuleCurrVisArray[mptr->m_index]))

                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] == 2)

        return 1;

    while(!vPtr->end_module)

    {

        MODULE *mptr = NULL;

        /* consider this module */

        if(vPtr->vmod_mref.mref_ptr)

        {

            mptr = vPtr->vmod_mref.mref_ptr;

            if(ModuleCurrVisArray[mptr->m_index] == 2)

            {

                if(vPtr->vmod_instr == vmodi_bra_vc)

                {

                    if (mptr->m_flags & m_flag_open)

                        return 1;

                }

                else

                    return 1;

            }

        }

        /* VMODULE instructions */

        switch(vPtr->vmod_instr)

        {

            case vmodi_null:

                vPtr++;

            break;

            case vmodi_bra_vc:

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

                /* Branch to this vPtr */

                /* else vPtr++; */

                if(mptr)

                {

                    if(mptr->m_flags & m_flag_open)

                        vPtr++;

                    else

                        vPtr = vPtr->vmod_data.vmodidata_ptr;

                }

        }

    }

return 0;

}

int CompareName(char *name1, char *name2)

{

    int i = 4;

    for(; i; i--)

    {

        if(*name1++ != *name2++)

            return 0;

    }

return 1;

}

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 VMODIDATA.vmodidata_label names to VMODIDATA.vmodidata_ptr

void ConvertVModuleNameToPointer(VMODIDATA *vmodidata_ptr, VMODULE *v_array_ptr)

{

    int StillSearching = 1;

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

    if(CompareName((char *)&vmodidata_ptr->vmodidata_label, "null"))

    {

        vmodidata_ptr->vmodidata_ptr = 0;

        return;

    }

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

    while(!v_array_ptr->end_module && StillSearching)

    {

        if(CompareName((char *)&vmodidata_ptr->vmodidata_label, (char *)&v_array_ptr->vmod_name))

        {

            /*

                printf("  found name ");

                PrintName(&v_array_ptr->vmod_name);

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

            */

            vmodidata_ptr->vmodidata_ptr = v_array_ptr;

            StillSearching = 0;

        }

        v_array_ptr++;

    }

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

    if(StillSearching)

    {

        if(v_array_ptr->end_module)

            vmodidata_ptr->vmodidata_ptr = v_array_ptr;

        else

            vmodidata_ptr->vmodidata_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.

*/

void PreprocessVMODIDATA(VMODULE *v_ptr)

{

    VMODULE *v_array_ptr = v_ptr;

    while(!v_ptr->end_module)

    {

        if(!(v_ptr->vmod_flags & vm_flag_gotptrs))

        {

            switch(v_ptr->vmod_instr)

            {

                case vmodi_null:

                break;

                case vmodi_bra_vc:

                    ConvertVModuleNameToPointer(&v_ptr->vmod_data, v_array_ptr);

            }

            v_ptr->vmod_flags |= vm_flag_gotptrs;

        }

        v_ptr++;

    }

}

// Convert MREF name to MREF pointer

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

{

    int StillSearching = 1;

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

    if(CompareName((char *)&mref_ptr->mref_name, "null"))

    {

        mref_ptr->mref_ptr = 0;

        return;

    }

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

    while(*m_array_ptr && StillSearching)

    {

        MODULE *m_ptr = *m_array_ptr;

        if(CompareName((char *)&mref_ptr->mref_name, (char *)&m_ptr->m_name))

        {

            /*

                printf("  found name ");

                PrintName(&m_ptr->m_name);

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

            */

            mref_ptr->mref_ptr = m_ptr;

            StillSearching = 0;

        }

        m_array_ptr++;

    }

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

    if(StillSearching)

        mref_ptr->mref_ptr = 0;

}

/*

 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;

    MODULE **m_array = m_array_ptr;

    ModuleArraySize = 0;

    //printf("PreprocessModuleArray %u\n", m_array_ptr);

    while(*m_array)

    {

        /* Get the module pointer */

        MODULE *m_ptr = *m_array;

        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_flags & m_flag_gotptrs)) 

        {

            if(m_ptr->m_vmptr) 

            {

                /* Convert VMODIDATA names to pointers */

                PreprocessVMODIDATA(m_ptr->m_vmptr);

                /* Convert MREF names to pointers */

                /*

                v_ptr = m_ptr->m_vmptr;

                while(!v_ptr->end_module)

                {

                    ConvertModuleNameToPointer(&v_ptr->vmod_mref, m_array_ptr);

                    v_ptr++;

                }

                */

            }

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

            m_ptr->m_flags |= m_flag_gotptrs;

        }

        /* Next module array entry */

        m_array++;

    }

    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()

{

    MODULE ** m_arrayPtr = MainScene.sm_marray;

    int i = 0;

    while (*m_arrayPtr)

    {

        MODULE * this_mod = *m_arrayPtr++;

        if(this_mod->m_mapptr)

            free(this_mod->m_mapptr);

        if(this_mod->name)

            free(this_mod->name);

        if(this_mod->m_vmptr)

            free(this_mod->m_vmptr);

        if(this_mod->m_lightarray)

            free(this_mod->m_lightarray);

    }

    if(MainScene.sm_module)

        free(MainScene.sm_module);

    if(MainScene.sm_marray)

        free(MainScene.sm_marray);

    MainScene.sm_module = NULL;

    MainScene.sm_marray = NULL;

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

    {

        AIMODULE* aim = &AIModuleArray[i];

        if(aim->m_link_ptrs) 

            free(aim->m_link_ptrs);

        if(aim->m_module_ptrs)

            free(aim->m_module_ptrs);

        if(aim->m_waypoints)

        {

            WAYPOINT_HEADER* wh = aim->m_waypoints;

            int j = 0;

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

            {

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

                if(wv->first_link)

                    free(wv->first_link);    

            }

            if(wh->first_waypoint)

                free(wh->first_waypoint);

            free(wh);

          }

    }

    free(AIModuleArray);

    AIModuleArray = NULL;

    free(ModuleCurrVisArray);

    ModuleCurrVisArray = NULL;

}