/*------------------------Patrick 13/12/96-----------------------------

  Source file for FAR AI alien module locations, as used by far alien

  behaviours....

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

#include "system.h"

#include "prototyp.h"

#include "stratdef.h"

#include "dynamics.h"

#include "pfarlocs.h"

#include <stdlib.h>

#include <assert.h>

/* external global variables used in this file */

extern int ModuleArraySize;

extern int memoryInitialisationFailure;

/* globals for this file */

FARENTRYPOINTSHEADER *FALLP_EntryPoints = NULL;

FARLOCATIONSHEADER *FALLP_AuxLocs = NULL;

int AIModuleArraySize = 0;

AIMODULE *AIModuleArray = NULL;

/* static globals for this file */

static FARVALIDATEDLOCATION *auxLocsGrid = NULL;

static int FL_TotalNumAuxLocs = 0;

static VECTORCH    *FL_AuxData = NULL;

/* a define for logging location data */

#define logFarLocData    0

#if logFarLocData

static FILE *logfile;

#endif

#define logFarLocPositions    0

#if logFarLocPositions

static FILE *logfile2;

#endif

/*------------------ Patrick 3/12/96 ----------------------

  This function determines whether an x/z position lies

  within the x/z projection of a polygon.

  NB is not entirely accurate for concave polygons.

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

static int IsXZinPoly(VECTORCH* location, struct ColPolyTag *polygonData)

{

    int x = location->vx;

    int z = location->vz;

    int xa,za,xb,zb;

    int intersections = 0;

    int intersectMinz, intersectMaxz;

    int linesToTest;

    int nextLine;

    linesToTest = polygonData->NumberOfVertices;

    if(linesToTest == 3)

    {

        xa = polygonData->PolyPoint[2].vx;

        za = polygonData->PolyPoint[2].vz;

    }

    else

    {

        assert(linesToTest == 4);

        xa = polygonData->PolyPoint[3].vx;

        za = polygonData->PolyPoint[3].vz;

    }

    nextLine = 0;

    while(nextLine < linesToTest)

    {

        /* copy last first point to next last point (?) */

        xb = xa;

        zb = za;

        /* get next first point */

        xa = polygonData->PolyPoint[nextLine].vx;

        za = polygonData->PolyPoint[nextLine].vz;

        if(((x >= xb) && (x <= xa)) || ((x < xb) && (x >= xa)))

        {

              /* intesection ! */

            intersections++;

            if(!(intersections < 4))

                return 0;

            {

                int zPosn;

                if(xb == xa)

                    zPosn = za;

                else

                    zPosn = zb + WideMulNarrowDiv((za-zb),(x-xb),(xa-xb));

                if(intersections == 1)

                    intersectMinz = intersectMaxz = zPosn;

                else

                {

                    if(zPosn < intersectMinz)

                        intersectMinz = zPosn;

                    else if(zPosn > intersectMaxz)

                        intersectMaxz = zPosn;

                }

            }

        }

      nextLine++;

    }

    if(intersections == 0)

        return 0;

    if(intersections == 1)

        return (z == intersectMinz);    

    else 

        return ((z >= intersectMinz)&&(z <= intersectMaxz));

}

/*----------------------Patrick 1/12/96--------------------------

  Given an x/z position for the shape, this function returns a 

  height value, by examining upwards facing polygons....

  To validate the height, there must also be a downwards facing

  polgon above the upwards facing polygon (so that we know that

  the location iiiiis inside the shape): if there is no up &

  down polygon, the location is invalidated, and an error code

  returned (either no up poly, no down poly, no up-or-down poly)

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

static void GetFarLocHeight(FARVALIDATEDLOCATION *location, MODULE *thisModule)

{

    int heightOfUpPoly = thisModule->m_maxy; /* init to lowest module extent */

    int heightOfDownPoly = thisModule->m_miny; /* init to heighest module extent */

    int polyCounter    = SetupPolygonAccessFromShapeIndex(thisModule->m_mapptr->MapShape);

    int upPolyFound = 0;

    int downPolyFound = 0;

    struct ColPolyTag polygonData;

    /* loop through the item list, then ... */

    while(polyCounter > 0)

    {

        {

            int *itemPtr = *(ItemArrayPtr++);

            PolyheaderPtr = (POLYHEADER *) itemPtr;

        }

        GetPolygonVertices(&polygonData);

        GetPolygonNormal(&polygonData);

        /* first test if poly is vertical */

        if((polygonData.PolyNormal.vy > FAR_MIN_INCLINE)||(polygonData.PolyNormal.vy < -FAR_MIN_INCLINE))

        {

        int XZcontainment = IsXZinPoly(&(location->position), &polygonData);

            if(XZcontainment)

            {                

                if(polygonData.PolyNormal.vy > 0) /* downwards facing */

                {

                    downPolyFound++;

                    {

                        /* find height of this poly: height of lowest vertex */

                        int tmpHeight = polygonData.PolyPoint[0].vy;

                        if(polygonData.PolyPoint[1].vy > tmpHeight)

                            tmpHeight = polygonData.PolyPoint[1].vy;

                        if(polygonData.PolyPoint[2].vy > tmpHeight)

                            tmpHeight = polygonData.PolyPoint[2].vy;

                        if(polygonData.NumberOfVertices == 4)

                        {

                            if(polygonData.PolyPoint[3].vy > tmpHeight)

                                tmpHeight = polygonData.PolyPoint[2].vy;

                        }

                        /* record height of lowest downward facing poly */

                        if(tmpHeight > heightOfDownPoly)

                            heightOfDownPoly = tmpHeight;                        

                    }

                }

                else /* upwards facing */

                {

                    upPolyFound++;

                    {

                        /* find height of this poly: height of highest vertex */

                        int tmpHeight = polygonData.PolyPoint[0].vy;

                        if(polygonData.PolyPoint[1].vy < tmpHeight)

                                tmpHeight = polygonData.PolyPoint[1].vy;

                        if(polygonData.PolyPoint[2].vy < tmpHeight)

                                tmpHeight = polygonData.PolyPoint[2].vy;

                        if(polygonData.NumberOfVertices == 4)

                        {

                            if(polygonData.PolyPoint[3].vy < tmpHeight)

                                tmpHeight = polygonData.PolyPoint[2].vy;

                        }

                        /* record height of heighest upward facing poly */

                        if(tmpHeight < heightOfUpPoly)

                            heightOfUpPoly = tmpHeight;                        

                    }

                }

            }

        }

    polyCounter--;

    }

    /* if up & down polys exist check their heights:

    if there is not enough clearance bewteen the lowest down poly and the heighest up poly, 

    invalidate the location.*/

    if((upPolyFound != 0) && (downPolyFound != 0))

    {

        int minclearance = FAR_BB_HEIGHT;

        if(thisModule->m_flags & MODULEFLAG_AIRDUCT)

            minclearance >>= 1;

        if((heightOfUpPoly-heightOfDownPoly) >= minclearance)

        {

            //position the aux location slightly above the polygon

            location->position.vy = heightOfUpPoly - 10;

        }

        else

            location->valid = 0;

    }

    else

        location->valid = 0;

}

/*--------------------Patrick 4/12/96--------------------

  This function checks a potential location for impinging

  downward or sideways facing polygons (ie ceiling or floor).  

  This is done using a bounding box containment test.  If 

  the test fails, it invalidates the location.

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

static int farbbox_maxx;

static int farbbox_minx;

static int farbbox_maxy;

static int farbbox_miny;

static int farbbox_maxz;

static int farbbox_minz;

static struct ColPolyTag farbbox_polygonData;

/*--------------------Patrick 5/12/96----------------------------------

 This does a bounding box extent test for a polygon.

 NB returns false if the poly definitely isn't in the bbox, and returns 

 true if the poly is in the bbox, and for unresolved cases.

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

static int FarBoxContainsPolygon()

{

    if(farbbox_polygonData.NumberOfVertices == 3)

    {

        if(    (farbbox_polygonData.PolyPoint[0].vy<=farbbox_miny)&&

            (farbbox_polygonData.PolyPoint[1].vy<=farbbox_miny)&&

            (farbbox_polygonData.PolyPoint[2].vy<=farbbox_miny))    return 0;

        if(    (farbbox_polygonData.PolyPoint[0].vx<=farbbox_minx)&&

            (farbbox_polygonData.PolyPoint[1].vx<=farbbox_minx)&&

            (farbbox_polygonData.PolyPoint[2].vx<=farbbox_minx))    return 0;    

        if( (farbbox_polygonData.PolyPoint[0].vz<=farbbox_minz)&&

            (farbbox_polygonData.PolyPoint[1].vz<=farbbox_minz)&&

            (farbbox_polygonData.PolyPoint[2].vz<=farbbox_minz))    return 0;

        if( (farbbox_polygonData.PolyPoint[0].vz>=farbbox_maxz)&&

            (farbbox_polygonData.PolyPoint[1].vz>=farbbox_maxz)&&

            (farbbox_polygonData.PolyPoint[2].vz>=farbbox_maxz))    return 0;

        if( (farbbox_polygonData.PolyPoint[0].vx>=farbbox_maxx)&&

            (farbbox_polygonData.PolyPoint[1].vx>=farbbox_maxx)&&

            (farbbox_polygonData.PolyPoint[2].vx>=farbbox_maxx))    return 0;

        if( (farbbox_polygonData.PolyPoint[0].vy>=farbbox_maxy)&&

            (farbbox_polygonData.PolyPoint[1].vy>=farbbox_maxy)&&

            (farbbox_polygonData.PolyPoint[2].vy>=farbbox_maxy))    return 0;

    }

    else

    {

        if(    (farbbox_polygonData.PolyPoint[0].vy<=farbbox_miny)&&

            (farbbox_polygonData.PolyPoint[1].vy<=farbbox_miny)&&

            (farbbox_polygonData.PolyPoint[2].vy<=farbbox_miny)&&

            (farbbox_polygonData.PolyPoint[3].vy<=farbbox_miny))    return 0;

        if(    (farbbox_polygonData.PolyPoint[0].vx<=farbbox_minx)&&

            (farbbox_polygonData.PolyPoint[1].vx<=farbbox_minx)&&

            (farbbox_polygonData.PolyPoint[2].vx<=farbbox_minx)&&

            (farbbox_polygonData.PolyPoint[3].vx<=farbbox_minx))    return 0;    

        if( (farbbox_polygonData.PolyPoint[0].vz<=farbbox_minz)&&

            (farbbox_polygonData.PolyPoint[1].vz<=farbbox_minz)&&

            (farbbox_polygonData.PolyPoint[2].vz<=farbbox_minz)&&

            (farbbox_polygonData.PolyPoint[3].vz<=farbbox_minz))    return 0;

        if( (farbbox_polygonData.PolyPoint[0].vz>=farbbox_maxz)&&

            (farbbox_polygonData.PolyPoint[1].vz>=farbbox_maxz)&&

            (farbbox_polygonData.PolyPoint[2].vz>=farbbox_maxz)&&

            (farbbox_polygonData.PolyPoint[3].vz>=farbbox_maxz))    return 0;

        if( (farbbox_polygonData.PolyPoint[0].vx>=farbbox_maxx)&&

            (farbbox_polygonData.PolyPoint[1].vx>=farbbox_maxx)&&

            (farbbox_polygonData.PolyPoint[2].vx>=farbbox_maxx)&&

            (farbbox_polygonData.PolyPoint[3].vx>=farbbox_maxx))    return 0;

        if( (farbbox_polygonData.PolyPoint[0].vy>=farbbox_maxy)&&

            (farbbox_polygonData.PolyPoint[1].vy>=farbbox_maxy)&&

            (farbbox_polygonData.PolyPoint[2].vy>=farbbox_maxy)&&

            (farbbox_polygonData.PolyPoint[3].vy>=farbbox_maxy))    return 0;

    }    

    return 1;

}

static void FarLocVolumeTest(FARVALIDATEDLOCATION *location, MODULE *thisModule)

{

    int polyCounter;

    int containmentFailure = 0;

    assert(location->valid);

    /* the location is provided as an x,y,z:

    the x and z indicate the centre, and the y indicates the bottom.

    translate these into bounding box extents.... */

    /* 10/7/97: this test has been modified: the bbox is moved up slightly, and any

    impinging ploygon invalidates the location */

    farbbox_maxx = location->position.vx + (FAR_BB_WIDTH>>1);

    farbbox_minx = location->position.vx - (FAR_BB_WIDTH>>1);

    farbbox_maxz = location->position.vz + (FAR_BB_WIDTH>>1);

    farbbox_minz = location->position.vz - (FAR_BB_WIDTH>>1);

    farbbox_maxy = location->position.vy - 10;

    /* patrick 4/7/97: a little adittion for airducts: npc should be crouched in them */

    if(thisModule->m_flags & MODULEFLAG_AIRDUCT)

        farbbox_miny = location->position.vy - (FAR_BB_HEIGHT >> 1) - 10;    

    else

        farbbox_miny = location->position.vy - FAR_BB_HEIGHT - 10;

    /* now just run through the polygons in the shape. If a polygon is 

    inside (actually, not definitely outside) the bbox, invalidate the location */        

     polyCounter = SetupPolygonAccessFromShapeIndex(thisModule->m_mapptr->MapShape);

    while((polyCounter > 0) && (!containmentFailure))

    {

        {

            int *itemPtr = *(ItemArrayPtr++);

            PolyheaderPtr = (POLYHEADER *) itemPtr;

        }

        GetPolygonVertices(&farbbox_polygonData);

        containmentFailure = FarBoxContainsPolygon();                    

        polyCounter--;

    }

    /* so, if there    has been a containmentFailure, invalidate the location */

    if(containmentFailure)

        location->valid = 0;

}

/*--------------------- Patrick 26/11/96 --------------------------

  This function attempts to construct a series of valid 

  auxilary locations inside the module (provided it has entry points)    

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

static void BuildFM_AuxilaryLocs(MODULE *thisModule)

{

    int gridStartX, gridStartZ, gridExtentX, gridExtentZ, XIndex, ZIndex;

    int NumLocsValid = 0;

    int NumLocsHeightFailed = 0;

    int NumLocsVolFailed = 0;

    int ThisModuleIndex;

    AIMODULE* aimodule = thisModule->m_aimodule;

    /* get the module index */

    assert(aimodule);

    ThisModuleIndex = aimodule->m_index;

    assert(ThisModuleIndex >= 0);

    assert(ThisModuleIndex < ModuleArraySize);    

    gridStartX = thisModule->m_minx + (FAR_BB_WIDTH>>1);

    gridStartZ = thisModule->m_minz + (FAR_BB_WIDTH>>1);

    gridExtentX = thisModule->m_maxx - thisModule->m_minx - FAR_BB_WIDTH;

    gridExtentZ = thisModule->m_maxz - thisModule->m_minz - FAR_BB_WIDTH;

    if(gridExtentX<=0 || gridExtentZ<=0)

    {

        //module is too narrow for auxilary locations

        return;

    }

    assert(gridStartX > thisModule->m_minx);

    /* step through each grid (index) location */

    for(XIndex = FAR_GRID_SIZE; XIndex > 0; XIndex--)

    {

        for(ZIndex = FAR_GRID_SIZE; ZIndex > 0; ZIndex--)

        {

            int locationsIndex = (XIndex-1)*FAR_GRID_SIZE + (ZIndex-1);

            auxLocsGrid[locationsIndex].position.vx = gridStartX + (gridExtentX*(XIndex-1))/(FAR_GRID_SIZE-1);

            auxLocsGrid[locationsIndex].position.vz = gridStartZ + (gridExtentZ*(ZIndex-1))/(FAR_GRID_SIZE-1);

            auxLocsGrid[locationsIndex].position.vy = 0;

            auxLocsGrid[locationsIndex].valid = 1; /* validated by default */

            /* get the floor height for this location.

            If no valid height is found, the location is set to

            minx,minz,miny, ie. outside of the grid, and abandoned */

            GetFarLocHeight(&auxLocsGrid[locationsIndex], thisModule);

            /* if there's a valid floor height, check the volume around the location

            for impinging polygons.  If volume is impinged, the location is set to 

            minx,minz,miny, ie. outside of the grid, and abandoned */

            if(auxLocsGrid[locationsIndex].valid)

            {

                FarLocVolumeTest(&auxLocsGrid[locationsIndex], thisModule); 

                if(auxLocsGrid[locationsIndex].valid)

                {

                    auxLocsGrid[locationsIndex].position.vx += thisModule->m_world.vx;

                    auxLocsGrid[locationsIndex].position.vy += thisModule->m_world.vy;

                    auxLocsGrid[locationsIndex].position.vz += thisModule->m_world.vz;

                    auxLocsGrid[locationsIndex].position.vx -= aimodule->m_world.vx;

                    auxLocsGrid[locationsIndex].position.vy -= aimodule->m_world.vy;

                    auxLocsGrid[locationsIndex].position.vz -= aimodule->m_world.vz;

                    NumLocsValid++;

                }

                else

                {

                    NumLocsVolFailed++;

                }

            }

            else

                NumLocsHeightFailed++;

        }

    }

    #if logFarLocData

    fprintf(logfile, "Num valid locs: %d \n", NumLocsValid);

    fprintf(logfile, "Num Height failed: %d \n", NumLocsHeightFailed);

    fprintf(logfile, "Num Vol failed: %d \n \n", NumLocsVolFailed);

    #endif

    /* now have a full list of locations.... 

    Those that are zero are invalid: hopefully some have survived */

    assert((NumLocsHeightFailed+NumLocsVolFailed+NumLocsValid) == (FAR_GRID_SIZE*FAR_GRID_SIZE));

    /* If there are any valid locations remaining, store them in the locations list */

    if(NumLocsValid > 0) 

    {

        /* Build a final and definitive list of valid locations for the module:

        look at the number of valid locations. If there are more than the maximum 

        number, take a reasonably distributed sample. Otherwise just put them all in.

        NB this wil be a list of Local Space coordinates.

        */               

        if(NumLocsValid > FAR_MAX_LOCS) 

        {

            VECTORCH *destinationPtr;

            int locationsIndex = 0;

            int numTaken = 0;

            int numFound = 0;

            int nextToTake = 0; 

            /* fill out the header (space is preallocated) */

            destinationPtr = &FALLP_AuxLocs[ThisModuleIndex].locationsList[FALLP_AuxLocs[ThisModuleIndex].numLocations];

            FALLP_AuxLocs[ThisModuleIndex].numLocations += FAR_MAX_LOCS;

            nextToTake = NumLocsValid / FAR_MAX_LOCS;                    

            while(numTaken < FAR_MAX_LOCS)

            {

                assert(nextToTake <= NumLocsValid);

                assert(locationsIndex < (FAR_GRID_SIZE*FAR_GRID_SIZE));            

                while(auxLocsGrid[locationsIndex].valid == 0)

                    locationsIndex++;

                assert(locationsIndex < (FAR_GRID_SIZE*FAR_GRID_SIZE));            

                numFound++;

                assert(numFound <= NumLocsValid);

                if(numFound == nextToTake)

                {

                    *destinationPtr++ = auxLocsGrid[locationsIndex].position;

                    numTaken++;

                    /* calc index of the next one to take */

                    nextToTake = ((numTaken + 1) * NumLocsValid) / FAR_MAX_LOCS;

                }

            /* move to next location */

            locationsIndex++;

            }

        }

        else

        {    

            VECTORCH *destinationPtr;

            int locationsIndex;

            int checkCount = 0; 

            /* fill out the header (space is preallocated) */

            destinationPtr = &FALLP_AuxLocs[ThisModuleIndex].locationsList[FALLP_AuxLocs[ThisModuleIndex].numLocations];

            FALLP_AuxLocs[ThisModuleIndex].numLocations += NumLocsValid;

            /* fill up the list with what we've got */

            locationsIndex = (FAR_GRID_SIZE*FAR_GRID_SIZE) - 1;

            do

            {

                if(auxLocsGrid[locationsIndex].valid)

                {

                    /* found a valid location: copy it into the list */

                    *(destinationPtr++) = auxLocsGrid[locationsIndex].position;

                    checkCount++;

                }            

            } while(locationsIndex--);

            assert(checkCount == NumLocsValid);

        }

        #if logFarLocData

        {

            /* log the final list */

            VECTORCH *tmpPtr;

            int tmpCounter;

            fprintf(logfile, "Locations list: \n");

            tmpCounter = FALLP_AuxLocs[ThisModuleIndex].numLocations;

            tmpPtr = FALLP_AuxLocs[ThisModuleIndex].locationsList;

            while(tmpCounter > 0)

            {

                fprintf(logfile, "%d %d %d \n", tmpPtr->vx, tmpPtr->vz, tmpPtr->vy);

                tmpPtr++;

                tmpCounter--;    

            }

            fprintf(logfile,"\n");

        }

        #endif

    }

    #if logFarLocData

    else

    {

        /* No valid locations */

        {

            /* log an error */

            fprintf(logfile,"All auxilary locations FAILED \n");

        }

    }                                    

    #endif    

}

/*-----------------------Patrick 20/12/96---------------------------

Returns TRUE if a module is a physical part of the environment,

ie is not infinite or a terminator, etc...

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

int ModuleIsPhysical(MODULE* target)

{

    if(target->m_flags & m_flag_infinite)

        return 0;

    return !target->end_module;

}

int AIModuleIsPhysical(AIMODULE* target)

{

    return (NULL != target) ? (target->m_module_ptrs != NULL) : 0;

}

/*-----------------------Patrick 20/12/96---------------------------

Takes 2 modules, and returns TRUE if the centre of the target module

is within the bounding box of the source;

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

int ModuleInModule(MODULE* source, MODULE* target)

{

    if(target->m_world.vx < (source->m_world.vx + source->m_minx)) return 0;

    if(target->m_world.vx > (source->m_world.vx + source->m_maxx)) return 0;

    if(target->m_world.vy < (source->m_world.vy + source->m_miny)) return 0;

    if(target->m_world.vy > (source->m_world.vy + source->m_maxy)) return 0;

    if(target->m_world.vz < (source->m_world.vz + source->m_minz)) return 0;

    if(target->m_world.vz > (source->m_world.vz + source->m_maxz)) return 0;

return 1;

}

/*-----------------------Patrick 20/12/96---------------------------

Returns the number of entries in a given module's adjacency list

If there is no adjacency list, return 0.

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

int NumAdjacentModules(AIMODULE* target)

{

    AIMODULE **AdjAIModulePtr = (target->m_link_ptrs);

    int counter = 0;

    if(AdjAIModulePtr)    

    {

        while(*AdjAIModulePtr)

        {

            counter++;

            AdjAIModulePtr++;

        }

    }

    else

        return 0;

return counter;

}

/* allocates and initialises primitive data areas */

static void InitFarLocDataAreas(MODULE **moduleList, int numModules)

{

    int moduleCounter;

    /* first, the lists of data headers */    

    assert(numModules > 0);

    FALLP_AuxLocs = malloc(numModules*sizeof(FARLOCATIONSHEADER));

    if(!FALLP_AuxLocs) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    FL_TotalNumAuxLocs = 0;

    FL_AuxData = NULL;

    /* work out the number of adjacent modules/auxilary locations for each module, and add them up */

    for(moduleCounter=0; moduleCounter < numModules; moduleCounter++)

    {

        int thisModuleIndex;

        MODULE *thisModule = moduleList[moduleCounter]; 

        assert(thisModule);

        thisModuleIndex = thisModule->m_index;

        assert(thisModuleIndex >= 0);

        assert(thisModuleIndex < ModuleArraySize);

        if(ModuleIsPhysical(thisModule))

        {

            FL_TotalNumAuxLocs += FAR_MAX_LOCS;

        }    

    }

    /* allocate base data areas */

    assert(FL_TotalNumAuxLocs > 0);

    FL_AuxData = malloc(FL_TotalNumAuxLocs * sizeof(VECTORCH));;

    if(!FL_AuxData) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    /* init header lists */

    {

        VECTORCH *auxDataPtr = FL_AuxData;

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

        {

            AIMODULE* thisAIModule = &AIModuleArray[moduleCounter]; 

            int thisModuleIndex = thisAIModule->m_index;

            /* NB these pointers and indexes have been validated above */

            FALLP_AuxLocs[thisModuleIndex].numLocations = 0;

            FALLP_AuxLocs[thisModuleIndex].locationsList = NULL;

            {

                MODULE** modulearray = thisAIModule->m_module_ptrs;

                if(modulearray)

                {

                    FALLP_AuxLocs[thisModuleIndex].locationsList = auxDataPtr;

                    while(*modulearray)

                    {

                        modulearray++;

                        auxDataPtr += FAR_MAX_LOCS;

                    }

                }

            }

        }

        /* we can now validate this process... */

        assert(auxDataPtr == (FL_AuxData+FL_TotalNumAuxLocs));    

    }

}

/*----------------------Patrick 16/12/96------------------------

  This function builds a list of entry points and auxilary

  locations for    each module.

  NB this cannot be called until the module system has been 

  initialised for this environment.

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

void BuildFarModuleLocs()

{

    extern SCENEMODULE MainScene;

    /* now get a pointer to the list of modules in this environment. */ 

    int moduleCounter;

    assert(ModuleArraySize);

    #if logFarLocData

    logfile = fopen("E:/3DC/FARLOCS.TXT","w");

    fprintf(logfile, "MODULE FAR LOCATIONS DATA \n");

    fprintf(logfile, "LevelName: %s \n", LevelName);

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

    fprintf(logfile, "number of modules: %d \n", ModuleArraySize);

    fprintf(logfile, "grid size: %d \n", FAR_GRID_SIZE);

    fprintf(logfile, "max locs stored per module: %d \n \n", FAR_MAX_LOCS);

    fprintf(logfile, "alien box height: %d \n", FAR_BB_HEIGHT);

    fprintf(logfile, "alien box width: %d \n", FAR_BB_WIDTH);

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

    #endif

    /* allocate some temporary work spaces..*/

    auxLocsGrid = malloc(FAR_GRID_SIZE*FAR_GRID_SIZE*sizeof(FARVALIDATEDLOCATION));

    if(!auxLocsGrid) 

    {

        memoryInitialisationFailure = 1;

        return;

    }

    /* Initialise the entry point list and auxilary location list.

    NB entry points are are pre-allocated, since they are evaluated in pairs.*/

    InitFarLocDataAreas(MainScene.sm_marray, ModuleArraySize);

    #if logFarLocData

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

    fprintf(logfile, "STARTING ENTRY POINTS.... \n");

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

    #endif

    /* Now go through the module list, and calculate entry points. This step should

    be done before auxilary locations, to be absolutely sure everything works out */

    #if logFarLocData

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

    fprintf(logfile, "STARTING AUXILARY LOCATIONS.... \n");

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

    #endif

    /* now go thro' each module calculating auxilary locations */

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

    {

        int ThisModuleIndex;    

        MODULE *thisModule = MainScene.sm_marray[moduleCounter]; 

         /* get a pointer to the next module, and it's index */

        assert(thisModule);

        ThisModuleIndex = thisModule->m_index;

        assert(ThisModuleIndex >= 0);

        assert(ThisModuleIndex < ModuleArraySize);

        #if logFarLocData

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

        fprintf(logfile, "Module Index: %d \n", ThisModuleIndex);

        fprintf(logfile, "Module X range: %d %d \n", thisModule->m_minx, thisModule->m_maxx);

        fprintf(logfile, "Module Z range: %d %d \n \n", thisModule->m_minz, thisModule->m_maxz);

        #endif

        /* check for entry points into this module if there    aren't any,

        don't bother with auxilary locations */

        if(thisModule->m_aimodule)

            BuildFM_AuxilaryLocs(thisModule);

        /*

        else

        {    

            #if logFarLocData

            fprintf(logfile, "NO AUXILARY LOCS COMPUTED: NO EPS \n \n");

            #endif

        } 

        */ 

    }

    /* deallocate the temporary work spaces */

    if (auxLocsGrid)

        free(auxLocsGrid);

    #if logFarLocData

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

    fprintf(logfile, "FINISHED ! \n");

    //fprintf(logfile, "NUM INFINITE MODULES/TERMINATORS: %d \n", numInfiniteModules);

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

    fclose(logfile);

    #endif

    #if logFarLocPositions && 0 //this log will need to updated for the ai modules.

    logfile2 = fopen("D:/PATRICK/FARLOCS2.TXT","w");

    fprintf(logfile2, "MODULE EPs AND AUXILARY LOCATIONS \n");

    fprintf(logfile2, "LeveName: %s \n", LevelName);

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

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

    {

        int i;

        fprintf(logfile2, "MODULE INDEX: %d \n",moduleCounter);

        fprintf(logfile2, "  EPs: \n");

        for(i=0; i < FALLP_EntryPoints[moduleCounter].numEntryPoints; i++)

        {

            VECTORCH posn = (FALLP_EntryPoints[moduleCounter].entryPointsList)[i].position;

            int index = (FALLP_EntryPoints[moduleCounter].entryPointsList)[i].donorIndex; 

            fprintf(logfile2, "  %d %d %d FROM %d \n", posn.vx, posn.vy, posn.vz, index);

        }

        fprintf(logfile2, "  AUX: \n");

        for(i=0; i < FALLP_AuxLocs[moduleCounter].numLocations; i++)

        {

            VECTORCH posn = (FALLP_AuxLocs[moduleCounter].locationsList)[i];

            fprintf(logfile2, "  %d %d %d \n", posn.vx, posn.vy, posn.vz);

        }

        fprintf(logfile2, "\n");

    }

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

    fprintf(logfile2, "END \n ");

    fclose(logfile2);

    #endif

}

/*-----------------------Patrick 28/11/96---------------------------

This function deallocates the location lists for each module,

and must be called at some point before the environment re-load

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

void KillFarModuleLocs()

{    

    /* don't do this for a net game */

    //in fact do do it in net game

    //if(AvP.Network != I_No_Network)    return;

    assert(ModuleArraySize);

    assert(AIModuleArraySize);

    assert(FALLP_EntryPoints);

    assert(FALLP_AuxLocs);

    assert(FL_TotalNumAuxLocs>0);

    assert(FL_AuxData);

    /* deallocate the base data area in one go, and re-init globals */

    if (FL_AuxData)

        free(FL_AuxData);

    FL_TotalNumAuxLocs = 0;

    FL_AuxData = NULL;

    /* deallocate the list headers, and re-init globals */

    if (FALLP_AuxLocs)

        free(FALLP_AuxLocs);

    FALLP_AuxLocs = NULL;

    if (FALLP_EntryPoints) 

    {

        int i = 0;

        for(; i < AIModuleArraySize; i++)

        {

            if(FALLP_EntryPoints[i].entryPointsList)

            {

                free(FALLP_EntryPoints[i].entryPointsList);

            }

        }

    free(FALLP_EntryPoints);

    }

    FALLP_EntryPoints = NULL;