218ca90543
Source code release, imported from: https://www.gamefront.com/games/aliens-vs-predator-3/file/avp-gold-complete-source-code All text files were converted to Unix format.
1131 lines
19 KiB
C
1131 lines
19 KiB
C
#include "3dc.h"
|
|
|
|
#include "inline.h"
|
|
#include "module.h"
|
|
#include "stratdef.h"
|
|
#include "bh_types.h"
|
|
#include "pvisible.h"
|
|
#include "pfarlocs.h"
|
|
#include "avpview.h"
|
|
#include "ourasert.h"
|
|
#include "pldghost.h"
|
|
|
|
#if SupportModules
|
|
|
|
/* imported externs */
|
|
|
|
extern SCENE Global_Scene;
|
|
extern int NumActiveBlocks;
|
|
extern DISPLAYBLOCK *ActiveBlockList[];
|
|
extern DISPLAYBLOCK *dptr_last;
|
|
extern unsigned char KeyASCII;
|
|
|
|
/**** Protos ****/
|
|
|
|
void FindVisibleModules(VMODULE *vptr,int flag);
|
|
|
|
/**** Statics ****/
|
|
|
|
static MODULE **Global_ModuleArrayPtr;
|
|
|
|
void AllNewModuleHandler(void)
|
|
{
|
|
{
|
|
int i;
|
|
SCENEMODULE *smptr;
|
|
smptr = Global_ModulePtr[Global_Scene];
|
|
Global_ModuleArrayPtr = smptr->sm_marray;
|
|
|
|
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)
|
|
if (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(AvP.Network!=I_No_Network && AvP.NetworkAIServer)
|
|
{
|
|
/* go through the strategy blocks looking for players*/
|
|
int sbIndex;
|
|
for(sbIndex=0;sbIndex<NumActiveStBlocks;sbIndex++)
|
|
{
|
|
STRATEGYBLOCK *playerSbPtr = ActiveStBlockList[sbIndex];
|
|
NETGHOSTDATABLOCK *ghostData;
|
|
if(playerSbPtr->I_SBtype!=I_BehaviourNetGhost) continue;
|
|
ghostData = (NETGHOSTDATABLOCK *)playerSbPtr->SBdataptr;
|
|
|
|
if(ghostData->type==I_BehaviourAlienPlayer ||
|
|
ghostData->type==I_BehaviourMarinePlayer ||
|
|
ghostData->type==I_BehaviourPredatorPlayer)
|
|
{
|
|
int sbIndex2;
|
|
//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=0;sbIndex2<NumActiveStBlocks;sbIndex2++)
|
|
{
|
|
STRATEGYBLOCK *alienSbPtr = ActiveStBlockList[sbIndex2];
|
|
/*Is it an alien?*/
|
|
if(alienSbPtr->I_SBtype!=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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
/* handle player visibilities */
|
|
{
|
|
extern MODULE * playerPherModule;
|
|
playerPherModule = (ModuleFromPosition(&(Global_VDB_Ptr->VDB_World), playerPherModule));
|
|
|
|
if(!playerPherModule)
|
|
{
|
|
playerPherModule = (ModuleFromPosition(&(Player->ObWorld), playerPherModule));
|
|
}
|
|
|
|
if (playerPherModule)
|
|
{
|
|
ModuleCurrVisArray[playerPherModule->m_index] = 2;
|
|
if(playerPherModule->m_vmptr) FindVisibleModules(playerPherModule->m_vmptr,2);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* handle AIMODULE visibility stuff */
|
|
{
|
|
int i;
|
|
for(i = 0; i < ModuleArraySize; i++)
|
|
{
|
|
if (ModuleCurrVisArray[i] == 2)
|
|
{
|
|
AIMODULE *aiModulePtr = Global_ModuleArrayPtr[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++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/* update active block list */
|
|
{
|
|
int i;
|
|
|
|
for(i = 0; i < ModuleArraySize; i++)
|
|
{
|
|
MODULE *mptr = Global_ModuleArrayPtr[i];
|
|
|
|
if(ModuleCurrVisArray[i])
|
|
{
|
|
if(mptr->m_dptr == 0 && ((mptr->m_flags & m_flag_dormant) == 0))
|
|
{
|
|
AllocateModuleObject(mptr);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if(mptr->m_dptr) DeallocateModuleObject(mptr);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* call Patrick's code */
|
|
DoObjectVisibilities();
|
|
}
|
|
|
|
|
|
void FindVisibleModules(VMODULE *vptr,int flag)
|
|
{
|
|
while(vptr->vmod_type != vmtype_term)
|
|
{
|
|
MODULE *mptr;
|
|
|
|
/* 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;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int ThisObjectIsInAModuleVisibleFromCurrentlyVisibleModules(STRATEGYBLOCK *sbPtr)
|
|
{
|
|
VMODULE *vPtr;
|
|
|
|
GLOBALASSERT(sbPtr);
|
|
GLOBALASSERT(sbPtr->containingModule);
|
|
|
|
vPtr = sbPtr->containingModule->m_vmptr;
|
|
GLOBALASSERT(vPtr);
|
|
|
|
if(ModuleCurrVisArray[sbPtr->containingModule->m_index] == 2)
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
while(vPtr->vmod_type != vmtype_term)
|
|
{
|
|
MODULE *mptr;
|
|
|
|
/* 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;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ModuleFunctions(MODULE *mptr, MFUNCTION mf)
|
|
{
|
|
switch(mf)
|
|
{
|
|
case mfun_null:
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
void AllocateModuleObject(MODULE *mptr)
|
|
{
|
|
|
|
DISPLAYBLOCK *dptr;
|
|
MODULEMAPBLOCK *mapblockptr;
|
|
STRATEGYBLOCK *sb = 0;
|
|
|
|
#if SupportMorphing
|
|
MORPHCTRL *mc;
|
|
#endif
|
|
|
|
dptr_last = 0;
|
|
|
|
mptr->m_dptr = 0;
|
|
|
|
if(mptr == 0) return; /* Whoops! */
|
|
|
|
if(mptr->m_mapptr == 0) return; /* Not all modules have maps */
|
|
|
|
|
|
dptr = CreateActiveObject();
|
|
|
|
|
|
if(dptr) {
|
|
|
|
|
|
/* Tell the module we exist */
|
|
|
|
mptr->m_dptr = dptr;
|
|
|
|
/* Tell the object who its module is */
|
|
|
|
dptr->ObMyModule = mptr;
|
|
|
|
/* Get the strategy block, if it exists */
|
|
|
|
if(mptr->m_sbptr) sb = mptr->m_sbptr;
|
|
|
|
/* If there is a STRATEGYBLOCK, tell it we exist */
|
|
|
|
if(sb) {
|
|
|
|
dptr->ObStrategyBlock = sb;
|
|
sb->SBdptr = dptr;
|
|
|
|
}
|
|
|
|
|
|
/* Read the map */
|
|
|
|
mapblockptr = mptr->m_mapptr;
|
|
|
|
dptr->ObShape = mapblockptr->MapShape;
|
|
|
|
|
|
|
|
CopyLocation(&mapblockptr->MapWorld, &dptr->ObWorld);
|
|
CopyEuler(&mapblockptr->MapEuler, &dptr->ObEuler);
|
|
|
|
dptr->ObFlags = mapblockptr->MapFlags;
|
|
dptr->ObFlags2 = mapblockptr->MapFlags2;
|
|
dptr->ObFlags3 = mapblockptr->MapFlags3;
|
|
|
|
|
|
|
|
|
|
#if SupportMorphing
|
|
|
|
/* If there is a strategy block, see if it has a MORPHCTRL structure */
|
|
|
|
if(sb) {
|
|
|
|
if(sb->SBmorphctrl) {
|
|
|
|
/* Pass MORPHCTRL to dptr */
|
|
|
|
dptr->ObMorphCtrl = sb->SBmorphctrl;
|
|
|
|
/* Copy the morph pointer from the map to the dptr */
|
|
|
|
mc = dptr->ObMorphCtrl;
|
|
|
|
mc->ObMorphHeader = mapblockptr->MapMorphHeader;
|
|
|
|
/* OLD TEST - These values are now set elsewhere */
|
|
#if 0
|
|
if(mc->ObMorphHeader) {
|
|
mc->ObMorphCurrFrame = 0;
|
|
mc->ObMorphFlags = mph_flag_play/* | mph_flag_noloop | mph_flag_reverse*/;
|
|
mc->ObMorphSpeed = ONE_FIXED;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* Support Morphing */
|
|
|
|
|
|
#if InterfaceEngine
|
|
dbptr->o_chunk = mapblockptr->o_chunk;
|
|
#endif
|
|
|
|
dptr->ObLightType = LightType_PerVertex;
|
|
dptr->ObFlags |= ObFlag_MultLSrc;
|
|
|
|
|
|
if(mapblockptr->MapVDBData)
|
|
MapSetVDB(dptr, mapblockptr->MapVDBData);
|
|
|
|
dptr->ObLightType = mapblockptr->MapLightType;
|
|
|
|
|
|
MapBlockInit(dptr);
|
|
|
|
/* 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... */
|
|
{
|
|
extern MATRIXCH IdentityMatrix;
|
|
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!=0; i--) {
|
|
|
|
/* Make sure the light is flagged correctly */
|
|
|
|
lptr_array->LightFlags |= LFlag_WasNotAllocated;
|
|
|
|
/* Add the light */
|
|
|
|
AddLightBlock(dptr, lptr_array);
|
|
|
|
/* Next light from the array */
|
|
|
|
lptr_array++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
As with shared points, extra item data for prelighting is also
|
|
copied from the module to the display block.
|
|
|
|
WARNING:
|
|
|
|
Allocation and deallocation of this pointer is the responsibility
|
|
of the user!
|
|
|
|
*/
|
|
|
|
dptr->ObEIDPtr = mptr->m_extraitemdata;
|
|
|
|
/* Added Name to DISPLAYBLOCK */
|
|
|
|
#if SupportWindows95
|
|
dptr->name = mptr->name;
|
|
#endif
|
|
|
|
MapPostProcessing(dptr);
|
|
|
|
|
|
ModuleObjectJustAllocated(mptr); /* Project Function */
|
|
|
|
/* Bug Fix */
|
|
|
|
if (dptr->ObStrategyBlock) {
|
|
|
|
STRATEGYBLOCK *sbptr=dptr->ObStrategyBlock;
|
|
|
|
if (sbptr->I_SBtype==I_BehaviourSimpleAnimation) {
|
|
|
|
SIMPLE_ANIM_BEHAV_BLOCK *sanimbhv;
|
|
|
|
sanimbhv = (SIMPLE_ANIM_BEHAV_BLOCK*)(sbptr->SBdataptr);
|
|
|
|
GLOBALASSERT(sanimbhv->bhvr_type == I_BehaviourSimpleAnimation);
|
|
GLOBALASSERT (dptr == sbptr->SBdptr);
|
|
|
|
if(!dptr->ObTxAnimCtrlBlks) {
|
|
dptr->ObTxAnimCtrlBlks = sanimbhv->tacbSimple;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
dptr_last = dptr;
|
|
|
|
}
|
|
|
|
|
|
void DeallocateModuleObject(MODULE *mptr)
|
|
|
|
{
|
|
|
|
DISPLAYBLOCK *dptr;
|
|
STRATEGYBLOCK *sb;
|
|
|
|
|
|
if(mptr->m_dptr) {
|
|
|
|
ModuleObjectAboutToBeDeallocated(mptr); /* Project Function */
|
|
|
|
dptr = mptr->m_dptr;
|
|
|
|
DestroyActiveObject(dptr);
|
|
|
|
/* Clear module reference to dptr */
|
|
|
|
mptr->m_dptr = 0;
|
|
|
|
/* If there is a STRATEGYBLOCK, clear that reference too */
|
|
|
|
if(mptr->m_sbptr) {
|
|
|
|
sb = mptr->m_sbptr;
|
|
sb->SBdptr = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
The Module Preprocessor
|
|
|
|
Pass the array of pointers to modules.
|
|
This function creates module indices and converts names into pointers.
|
|
|
|
*/
|
|
|
|
/*
|
|
temp patch to match current chunk
|
|
loader configuration
|
|
*/
|
|
|
|
void PreprocessAllModules(void)
|
|
{
|
|
|
|
SCENEMODULE **sm_array_ptr;
|
|
SCENEMODULE *sm_ptr;
|
|
|
|
|
|
if(Global_ModulePtr == 0) return;
|
|
|
|
sm_array_ptr = Global_ModulePtr;
|
|
|
|
while(*sm_array_ptr)
|
|
{
|
|
sm_ptr = *sm_array_ptr;
|
|
|
|
PreprocessModuleArray(sm_ptr->sm_marray);
|
|
|
|
sm_array_ptr++;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
A special function to deallocate the module visibility arrays
|
|
|
|
*/
|
|
|
|
void DeallocateModuleVisArrays(void)
|
|
|
|
{
|
|
|
|
if(ModuleCurrVisArray) {
|
|
|
|
DeallocateMem(ModuleCurrVisArray);
|
|
ModuleCurrVisArray = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
Allocate the two arrays used to keep track of module visibility from
|
|
frame to frame. The function uses the global scene variable to access the
|
|
appropriate SCENEMODULE and find out how many modules are present. It also
|
|
deallocates the previous arrays if they exist.
|
|
|
|
*/
|
|
|
|
int GetModuleVisArrays(void)
|
|
|
|
{
|
|
|
|
SCENEMODULE *sm_ptr;
|
|
MODULE **m_array_ptr;
|
|
MODULE *m_ptr;
|
|
int index, i;
|
|
|
|
|
|
if(Global_ModulePtr == 0) return No;
|
|
|
|
DeallocateModuleVisArrays();
|
|
|
|
sm_ptr = Global_ModulePtr[Global_Scene];
|
|
|
|
m_array_ptr = sm_ptr->sm_marray;
|
|
index = smallint;
|
|
|
|
while(*m_array_ptr) {
|
|
|
|
m_ptr = *m_array_ptr++;
|
|
if(m_ptr->m_index > index) index = m_ptr->m_index;
|
|
|
|
}
|
|
|
|
ModuleArraySize = index + 1;
|
|
|
|
|
|
ModuleCurrVisArray = AllocateMem(ModuleArraySize);
|
|
|
|
if(ModuleCurrVisArray)
|
|
{
|
|
|
|
for(i = 0; i < ModuleArraySize; i++)
|
|
{
|
|
|
|
ModuleCurrVisArray[i] = 0;
|
|
}
|
|
|
|
#if 0
|
|
textprint("visibility arrays ok, size %d\n", ModuleArraySize);
|
|
#endif
|
|
|
|
return Yes;
|
|
|
|
}
|
|
|
|
else return No;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define ppma_print No
|
|
|
|
|
|
#if 1
|
|
|
|
|
|
void PreprocessModuleArray(MODULE **m_array_ptr)
|
|
{
|
|
MODULE **m_array = m_array_ptr;
|
|
MODULE *m_ptr;
|
|
int index;
|
|
|
|
|
|
#if ppma_print
|
|
textprint("PreprocessModuleArray %u\n", m_array_ptr);
|
|
#endif
|
|
|
|
|
|
index = 0;
|
|
|
|
while(*m_array) {
|
|
|
|
/* Get the module pointer */
|
|
|
|
m_ptr = *m_array;
|
|
|
|
|
|
/* Assign the module an index */
|
|
|
|
m_ptr->m_index = index++;
|
|
|
|
|
|
#if ppma_print
|
|
textprint("\nModule %u, ", m_ptr);
|
|
PrintName(&m_ptr->m_name);
|
|
textprint(", index %d\n", m_ptr->m_index);
|
|
textprint(" (vptr = ");
|
|
PrintName(&m_ptr->m_vptr.mref_name);
|
|
textprint(")\n");
|
|
#endif
|
|
|
|
|
|
/* Convert module references from names to pointers */
|
|
|
|
if(!(m_ptr->m_flags & m_flag_gotptrs)) {
|
|
|
|
#if 0
|
|
/* Vertical Pointer */
|
|
|
|
ConvertModuleNameToPointer(&m_ptr->m_vptr, m_array_ptr);
|
|
|
|
|
|
/* Extent Pointer */
|
|
|
|
ConvertModuleNameToPointer(&m_ptr->m_ext, m_array_ptr);
|
|
|
|
|
|
/* Function Pointer */
|
|
|
|
ConvertModuleNameToPointer(&m_ptr->m_funref, m_array_ptr);
|
|
|
|
|
|
// Hack by John to make the m_link pointers work
|
|
|
|
if (m_ptr->m_link_ptrs)
|
|
{
|
|
MREF * m_link_ptr = m_ptr->m_link_ptrs;
|
|
|
|
while (m_link_ptr->mref_ptr)
|
|
{
|
|
ConvertModuleNameToPointer(m_link_ptr++, m_array_ptr);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
/* VMODULE Array */
|
|
|
|
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->vmod_type != vmtype_term) {
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
/* Calculate module extents */
|
|
|
|
//I'll set the extents and world position in the loaders -Richard.
|
|
//GetModuleMapData(m_ptr);
|
|
|
|
|
|
/* Next module array entry */
|
|
|
|
m_array++;
|
|
|
|
}
|
|
|
|
/*WaitForReturn();*/
|
|
|
|
}
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
|
|
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->vmod_type != vmtype_term) {
|
|
|
|
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);
|
|
break;
|
|
|
|
}
|
|
|
|
v_ptr->vmod_flags |= vm_flag_gotptrs;
|
|
|
|
}
|
|
|
|
v_ptr++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
Convert MREF name to MREF pointer
|
|
|
|
*/
|
|
|
|
|
|
#define cmntp_print No
|
|
|
|
|
|
void ConvertModuleNameToPointer(MREF *mref_ptr, MODULE **m_array_ptr)
|
|
|
|
{
|
|
|
|
MODULE *m_ptr;
|
|
int StillSearching;
|
|
|
|
|
|
#if cmntp_print
|
|
textprint("ConvertModuleNameToPointer\n");
|
|
#endif
|
|
|
|
|
|
/* Set "null" names to null pointers */
|
|
|
|
if(CompareName((char *)&mref_ptr->mref_name, "null")) {
|
|
|
|
#if cmntp_print
|
|
textprint("making ptr null\n");
|
|
#endif
|
|
|
|
mref_ptr->mref_ptr = 0;
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
/* Search for the module with the same name */
|
|
|
|
#if cmntp_print
|
|
textprint("Searching for name...\n");
|
|
#endif
|
|
|
|
StillSearching = Yes;
|
|
|
|
while(*m_array_ptr && StillSearching) {
|
|
|
|
m_ptr = *m_array_ptr;
|
|
|
|
if(CompareName((char *)&mref_ptr->mref_name, (char *)&m_ptr->m_name)) {
|
|
|
|
#if cmntp_print
|
|
textprint(" found name ");
|
|
PrintName(&m_ptr->m_name);
|
|
textprint(", ptr %u\n", m_ptr);
|
|
#endif
|
|
|
|
mref_ptr->mref_ptr = m_ptr;
|
|
StillSearching = No;
|
|
|
|
}
|
|
|
|
m_array_ptr++;
|
|
|
|
}
|
|
|
|
|
|
/* If the name was not found, make this a null pointer */
|
|
|
|
if(StillSearching) mref_ptr->mref_ptr = 0;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
Convert VMODIDATA.vmodidata_label names to VMODIDATA.vmodidata_ptr
|
|
|
|
*/
|
|
|
|
|
|
#define cvmntp_print No
|
|
|
|
|
|
void ConvertVModuleNameToPointer(VMODIDATA *vmodidata_ptr, VMODULE *v_array_ptr)
|
|
|
|
{
|
|
|
|
int StillSearching;
|
|
|
|
|
|
#if cvmntp_print
|
|
textprint("ConvertVModuleNameToPointer\n");
|
|
#endif
|
|
|
|
|
|
/* Set "null" names to null pointers */
|
|
|
|
if(CompareName((char *)&vmodidata_ptr->vmodidata_label, "null")) {
|
|
|
|
#if cvmntp_print
|
|
textprint(" making vmodidata_ptr null\n");
|
|
#endif
|
|
|
|
vmodidata_ptr->vmodidata_ptr = 0;
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
/* Search for the VMODULE with the same name */
|
|
|
|
#if cvmntp_print
|
|
textprint(" Searching for name...\n");
|
|
#endif
|
|
|
|
StillSearching = Yes;
|
|
|
|
while((v_array_ptr->vmod_type != vmtype_term) && StillSearching) {
|
|
|
|
if(CompareName((char *)&vmodidata_ptr->vmodidata_label, (char *)&v_array_ptr->vmod_name)) {
|
|
|
|
#if cmntp_print
|
|
textprint(" found name ");
|
|
PrintName(&v_array_ptr->vmod_name);
|
|
textprint(", ptr %u\n", v_array_ptr);
|
|
#endif
|
|
|
|
vmodidata_ptr->vmodidata_ptr = v_array_ptr;
|
|
StillSearching = No;
|
|
|
|
}
|
|
|
|
v_array_ptr++;
|
|
|
|
}
|
|
|
|
|
|
/* If the name was not found, make this a null pointer */
|
|
|
|
if(StillSearching)
|
|
{
|
|
if(v_array_ptr->vmod_type == vmtype_term)
|
|
{
|
|
vmodidata_ptr->vmodidata_ptr = v_array_ptr;
|
|
}
|
|
else
|
|
{
|
|
vmodidata_ptr->vmodidata_ptr = 0;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int CompareName(char *name1, char *name2)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
for(i = 4; i!=0; i--) {
|
|
|
|
if(*name1++ != *name2++) return No;
|
|
|
|
}
|
|
|
|
return Yes;
|
|
|
|
}
|
|
|
|
|
|
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;
|
|
textprint(m_name);
|
|
|
|
}
|
|
|
|
|
|
int IsModuleVisibleFromModule(MODULE *source, MODULE *target) {
|
|
|
|
VMODULE *vptr;
|
|
MODULE *mptr;
|
|
int gotit;
|
|
|
|
vptr=source->m_vmptr;
|
|
gotit=0;
|
|
|
|
if ((source==NULL)||(target==NULL)) return(0);
|
|
if (source==target) return(1);
|
|
|
|
while(! ((vptr->vmod_type == vmtype_term)||(gotit)) ) {
|
|
|
|
/* Add this module to the visible array */
|
|
|
|
if(vptr->vmod_mref.mref_ptr) {
|
|
|
|
mptr = vptr->vmod_mref.mref_ptr;
|
|
|
|
if (mptr==target) gotit=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++; */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return(gotit);
|
|
|
|
}
|
|
|
|
int IsAIModuleVisibleFromAIModule(AIMODULE *source,AIMODULE *target) {
|
|
|
|
if ((source==NULL)||(target==NULL)) return(0);
|
|
if (source==target) return(1);
|
|
|
|
{
|
|
MODULE **targetModulelistPtr;
|
|
MODULE **sourceModulelistPtr = source->m_module_ptrs;
|
|
while(*sourceModulelistPtr) {
|
|
|
|
targetModulelistPtr=target->m_module_ptrs;
|
|
while(*targetModulelistPtr) {
|
|
if (IsModuleVisibleFromModule(*sourceModulelistPtr,*targetModulelistPtr)) {
|
|
return(1);
|
|
}
|
|
targetModulelistPtr++;
|
|
}
|
|
sourceModulelistPtr++;
|
|
}
|
|
}
|
|
|
|
return(0);
|
|
}
|
|
|
|
#endif
|
|
|
|
|