/*------------------------Patrick 14/1/97-----------------------------

  This source file contains all the functions for the object visibility 

  management system     (which controls visibility for aliens, objects,

  pickups, autoguns, etc....)

  It also contains initialisation and behaviour functions for 

  inanimate objects (like chairs, weapons, etc...).

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

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#include <assert.h>

#include "system.h"

#include "stratdef.h"

#include "bh_types.h"

#include "npc_alien.h"

#include "npc_xenoborg.h"

#include "npc_queen.h"

#include "npc_marine.h"

#include "npc_facehugger.h"

#include "debris.h"

#include "placedhierarchy.h"

#include "lighting.h"

#include "npc_dummy.h"

#include "platformlift.h"

#include "bh_light.h"

#include "weapons.h"

#include "npc_sentrygun.h"

#include "corpse.h"

#include "pfarlocs.h"

#include "pldghost.h"

#include "generator.h"

size_t ModuleArraySize = 0;

extern int GlobalFrameCounter;

extern SCENEMODULE MainScene;

extern SECTION * GetNamedHierarchyFromLibrary(const char * rif_name, const char * hier_name);

/* this is a default map used in visibility management 

NB If you use this, you MUST set the shapeIndex field appropriately*/

#define ModuleFromPositionTolerance 50

static int WorldPointIsInModule_WithTolerance(MODULE* thisModule, VECTORCH* thisPoint)

{               

    VECTORCH localpoint = *thisPoint;

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

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

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

    return

    (

        (localpoint.vx <= thisModule->m_maxx + ModuleFromPositionTolerance)

        &&

        (localpoint.vx >= thisModule->m_minx - ModuleFromPositionTolerance)

        &&

        (localpoint.vy <= thisModule->m_maxy + ModuleFromPositionTolerance)

        &&

        (localpoint.vy >= thisModule->m_miny - ModuleFromPositionTolerance)

        &&

        (localpoint.vz <= thisModule->m_maxz + ModuleFromPositionTolerance)

        &&

        (localpoint.vz >= thisModule->m_minz - ModuleFromPositionTolerance)

    );

}

static int WorldPointIsInModule(MODULE* thisModule, VECTORCH* thisPoint)

{               

    VECTORCH localpoint = *thisPoint;

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

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

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

    return

    (

        (localpoint.vx <= thisModule->m_maxx)

        &&

        (localpoint.vx >= thisModule->m_minx)

        &&

        (localpoint.vy <= thisModule->m_maxy)

        &&

        (localpoint.vy >= thisModule->m_miny)

        &&

        (localpoint.vz <= thisModule->m_maxz)

        &&

        (localpoint.vz >= thisModule->m_minz)

    );

}

/*------------------------Patrick 14/1/97-----------------------------

  This function returns the module in which a given world-space 

  position is located.  A starting point for the search may also be

  passed, so that the following search pattern is used:

  1. is the location in the indicated starting module.

  2. is the location in any of the starting module's visible-links.

  3. finally, all modules in the environment are searched until

     a containing module is found.

  If no module is found, a null module pointer is returned.

  NB only 'physical' modules are returned, ie infinite and

  terminator modules are ignored.

  The function is designed to be used for objects which move over small

  distances, and for which a recently containing module is known (eg 

  avp aliens).... so that the first stage of the search will be successful

  in the majority of cases, and the third stage rarely used.  

  Note that the fn returns the first module which contains the given 

  point, so problems may arise if the point exists in more than one 

  module. This should be ok for environments like avp, where v-linking 

  is not used.

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

static MODULE* ModuleFromPosition_WithTolerance(VECTORCH *position, MODULE* startingModule)

{

    if(startingModule && ModuleIsPhysical(startingModule))

    {

        /* first test for the most trivial, and most likely case */

        if(WorldPointIsInModule_WithTolerance(startingModule, position)) 

            return startingModule;

        /* now test visible-linked modules (If there are any) */

        {

            VMODULE *vlPtr = startingModule->m_vmptr;

            if(vlPtr)

            {

                while(!vlPtr->end_module)

                {

                    MODULE *mPtr = vlPtr->vmod_mref.mref_ptr;

                    if(mPtr && ModuleIsPhysical(mPtr) && WorldPointIsInModule_WithTolerance(mPtr, position)) 

                    {

                        return mPtr;

                    }

                    vlPtr++;

                }

            }

        }

    }

    /* either there is no starting module; the starting module is not physical;

    we are not in the starting module and it has no visibility-linked modules;

    or we haven't found a module yet: so search the entire module list */

    {

        int moduleCounter = ModuleArraySize;

        MODULE **moduleListPointer = MainScene.sm_marray;

        while(moduleCounter-- > 0)

        {

            MODULE *thisModule = *moduleListPointer++;

            if(ModuleIsPhysical(thisModule) && WorldPointIsInModule_WithTolerance(thisModule, position)) 

                return thisModule;

        }

    }

/* couldn't find a module */

return NULL;

}

MODULE* ModuleFromPosition(VECTORCH *position, MODULE* startingModule)

{

    if((NULL != startingModule) && ModuleIsPhysical(startingModule))

    {

        /* first test for the most trivial, and most likely case */

        if(WorldPointIsInModule(startingModule, position)) 

            return startingModule;

        /* now test visible-linked modules (If there are any) */

        {

            VMODULE *vlPtr = startingModule->m_vmptr;

            if(NULL != vlPtr)

            {

                while(!vlPtr->end_module)

                {

                    MODULE *mPtr = vlPtr->vmod_mref.mref_ptr;

                    if((NULL != mPtr) && ModuleIsPhysical(mPtr) && WorldPointIsInModule(mPtr, position))

                            return mPtr;

                    vlPtr++;

                }

            }

        }

    }

    /* either there is no starting module; the starting module is not physical;

    we are not in the starting module and it has no visibility-linked modules;

    or we haven't found a module yet: so search the entire module list */

    {

        int moduleCounter = ModuleArraySize;

        MODULE **moduleListPointer = MainScene.sm_marray;

        while(moduleCounter-- > 0)

        {

            MODULE *thisModule = *moduleListPointer++;

            if(ModuleIsPhysical(thisModule) && WorldPointIsInModule(thisModule, position))

                    return thisModule;

        }

    }

/* couldn't find a module */

/*Try with slightly larger module bounding boxes*/

return ModuleFromPosition_WithTolerance(position, startingModule);

}