1dot13/source
1
0
Fork 0
mirror of https://github.com/1dot13/source.git synced 2026-07-22 13:40:22 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
226992e00bb7ea8fefdd49589be337d5da5ef978
source/TileEngine/Map Edgepoints.cpp
T

1899 lines
64 KiB
C++
Raw Blame History

#ifdef PRECOMPILEDHEADERS
#include "TileEngine All.h"
#else
#include <memory.h>
#include "Map Edgepoints.h"
#include "pathai.h"
#include "ai.h"
#include "Map Information.h"
#include "renderworld.h"
#include "Isometric Utils.h"
#include "debug.h"
#include "Random.h"
#include "strategic.h"
#include "Animation Control.h"
#include "Render Fun.h"
#include "strategicmap.h"
#include "environment.h"
#include "worldman.h"
#endif
//forward declarations of common classes to eliminate includes
class OBJECTTYPE;
class SOLDIERTYPE;
//dynamic arrays that contain the valid gridno's for each edge
INT16 *gps1stNorthEdgepointArray = NULL;
INT16 *gps1stEastEdgepointArray = NULL;
INT16 *gps1stSouthEdgepointArray = NULL;
INT16 *gps1stWestEdgepointArray = NULL;
//contains the size for each array
UINT16 gus1stNorthEdgepointArraySize = 0;
UINT16 gus1stEastEdgepointArraySize = 0;
UINT16 gus1stSouthEdgepointArraySize = 0;
UINT16 gus1stWestEdgepointArraySize = 0;
//contains the index value for the first array index of the second row of each edgepoint array.
//Because each edgepoint side has two rows, the outside most row is calculated first, then the inside row.
//For purposes of AI, it may become necessary to avoid this.
UINT16 gus1stNorthEdgepointMiddleIndex = 0;
UINT16 gus1stEastEdgepointMiddleIndex = 0;
UINT16 gus1stSouthEdgepointMiddleIndex = 0;
UINT16 gus1stWestEdgepointMiddleIndex = 0;
//dynamic arrays that contain the valid gridno's for each edge
INT16 *gps2ndNorthEdgepointArray = NULL;
INT16 *gps2ndEastEdgepointArray = NULL;
INT16 *gps2ndSouthEdgepointArray = NULL;
INT16 *gps2ndWestEdgepointArray = NULL;
//contains the size for each array
UINT16 gus2ndNorthEdgepointArraySize = 0;
UINT16 gus2ndEastEdgepointArraySize = 0;
UINT16 gus2ndSouthEdgepointArraySize = 0;
UINT16 gus2ndWestEdgepointArraySize = 0;
//contains the index value for the first array index of the second row of each edgepoint array.
//Because each edgepoint side has two rows, the outside most row is calculated first, then the inside row.
//For purposes of AI, it may become necessary to avoid this.
UINT16 gus2ndNorthEdgepointMiddleIndex = 0;
UINT16 gus2ndEastEdgepointMiddleIndex = 0;
UINT16 gus2ndSouthEdgepointMiddleIndex = 0;
UINT16 gus2ndWestEdgepointMiddleIndex = 0;
BOOLEAN gfEdgepointsExist = FALSE;
BOOLEAN gfGeneratingMapEdgepoints = FALSE;
INT16 gsTLGridNo = 13286;
INT16 gsTRGridNo = 1043;
INT16 gsBLGridNo = 24878;
INT16 gsBRGridNo = 12635;
BOOLEAN VerifyEdgepoint( SOLDIERTYPE *pSoldier, INT16 sEdgepoint );
BOOLEAN EdgepointsClose( SOLDIERTYPE *pSoldier, INT16 sEdgepoint1, INT16 sEdgepoint2 );
extern UINT8 gubTacticalDirection;
void TrashMapEdgepoints()
{
//Primary edgepoints
if( gps1stNorthEdgepointArray )
MemFree( gps1stNorthEdgepointArray );
if( gps1stEastEdgepointArray )
MemFree( gps1stEastEdgepointArray );
if( gps1stSouthEdgepointArray )
MemFree( gps1stSouthEdgepointArray );
if( gps1stWestEdgepointArray )
MemFree( gps1stWestEdgepointArray );
gps1stNorthEdgepointArray = NULL;
gps1stEastEdgepointArray = NULL;
gps1stSouthEdgepointArray = NULL;
gps1stWestEdgepointArray = NULL;
gus1stNorthEdgepointArraySize = 0;
gus1stEastEdgepointArraySize = 0;
gus1stSouthEdgepointArraySize = 0;
gus1stWestEdgepointArraySize = 0;
gus1stNorthEdgepointMiddleIndex = 0;
gus1stEastEdgepointMiddleIndex = 0;
gus1stSouthEdgepointMiddleIndex = 0;
gus1stWestEdgepointMiddleIndex = 0;
//Secondary edgepoints
if( gps2ndNorthEdgepointArray )
MemFree( gps2ndNorthEdgepointArray );
if( gps2ndEastEdgepointArray )
MemFree( gps2ndEastEdgepointArray );
if( gps2ndSouthEdgepointArray )
MemFree( gps2ndSouthEdgepointArray );
if( gps2ndWestEdgepointArray )
MemFree( gps2ndWestEdgepointArray );
gps2ndNorthEdgepointArray = NULL;
gps2ndEastEdgepointArray = NULL;
gps2ndSouthEdgepointArray = NULL;
gps2ndWestEdgepointArray = NULL;
gus2ndNorthEdgepointArraySize = 0;
gus2ndEastEdgepointArraySize = 0;
gus2ndSouthEdgepointArraySize = 0;
gus2ndWestEdgepointArraySize = 0;
gus2ndNorthEdgepointMiddleIndex = 0;
gus2ndEastEdgepointMiddleIndex = 0;
gus2ndSouthEdgepointMiddleIndex = 0;
gus2ndWestEdgepointMiddleIndex = 0;
}
//This final step eliminates some edgepoints which actually don't path directly to the edge of the map.
//Cases would include an area that is close to the edge, but a fence blocks it from direct access to the edge
//of the map.
void ValidateEdgepoints()
{
INT32 i;
UINT16 usValidEdgepoints;
SOLDIERTYPE Soldier;
Soldier.bTeam = 1;
//north
usValidEdgepoints = 0;
for( i = 0; i < gus1stNorthEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps1stNorthEdgepointArray[ i ] ) )
{
gps1stNorthEdgepointArray[ usValidEdgepoints ] = gps1stNorthEdgepointArray[ i ];
if( i == gus1stNorthEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus1stNorthEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus1stNorthEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus1stNorthEdgepointMiddleIndex++;
}
}
gus1stNorthEdgepointArraySize = usValidEdgepoints;
//East
usValidEdgepoints = 0;
for( i = 0; i < gus1stEastEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps1stEastEdgepointArray[ i ] ) )
{
gps1stEastEdgepointArray[ usValidEdgepoints ] = gps1stEastEdgepointArray[ i ];
if( i == gus1stEastEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus1stEastEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus1stEastEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus1stEastEdgepointMiddleIndex++;
}
}
gus1stEastEdgepointArraySize = usValidEdgepoints;
//South
usValidEdgepoints = 0;
for( i = 0; i < gus1stSouthEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps1stSouthEdgepointArray[ i ] ) )
{
gps1stSouthEdgepointArray[ usValidEdgepoints ] = gps1stSouthEdgepointArray[ i ];
if( i == gus1stSouthEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus1stSouthEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus1stSouthEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus1stSouthEdgepointMiddleIndex++;
}
}
gus1stSouthEdgepointArraySize = usValidEdgepoints;
//West
usValidEdgepoints = 0;
for( i = 0; i < gus1stWestEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps1stWestEdgepointArray[ i ] ) )
{
gps1stWestEdgepointArray[ usValidEdgepoints ] = gps1stWestEdgepointArray[ i ];
if( i == gus1stWestEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus1stWestEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus1stWestEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus1stWestEdgepointMiddleIndex++;
}
}
gus1stWestEdgepointArraySize = usValidEdgepoints;
//north
usValidEdgepoints = 0;
for( i = 0; i < gus2ndNorthEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps2ndNorthEdgepointArray[ i ] ) )
{
gps2ndNorthEdgepointArray[ usValidEdgepoints ] = gps2ndNorthEdgepointArray[ i ];
if( i == gus2ndNorthEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus2ndNorthEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus2ndNorthEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus2ndNorthEdgepointMiddleIndex++;
}
}
gus2ndNorthEdgepointArraySize = usValidEdgepoints;
//East
usValidEdgepoints = 0;
for( i = 0; i < gus2ndEastEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps2ndEastEdgepointArray[ i ] ) )
{
gps2ndEastEdgepointArray[ usValidEdgepoints ] = gps2ndEastEdgepointArray[ i ];
if( i == gus2ndEastEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus2ndEastEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus2ndEastEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus2ndEastEdgepointMiddleIndex++;
}
}
gus2ndEastEdgepointArraySize = usValidEdgepoints;
//South
usValidEdgepoints = 0;
for( i = 0; i < gus2ndSouthEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps2ndSouthEdgepointArray[ i ] ) )
{
gps2ndSouthEdgepointArray[ usValidEdgepoints ] = gps2ndSouthEdgepointArray[ i ];
if( i == gus2ndSouthEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus2ndSouthEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus2ndSouthEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus2ndSouthEdgepointMiddleIndex++;
}
}
gus2ndSouthEdgepointArraySize = usValidEdgepoints;
//West
usValidEdgepoints = 0;
for( i = 0; i < gus2ndWestEdgepointArraySize; i++ )
{
if( VerifyEdgepoint( &Soldier, gps2ndWestEdgepointArray[ i ] ) )
{
gps2ndWestEdgepointArray[ usValidEdgepoints ] = gps2ndWestEdgepointArray[ i ];
if( i == gus2ndWestEdgepointMiddleIndex )
{ //adjust the middle index to the new one.
gus2ndWestEdgepointMiddleIndex = usValidEdgepoints;
}
usValidEdgepoints++;
}
else if( i == gus2ndWestEdgepointMiddleIndex )
{ //increment the middle index because it's edgepoint is no longer valid.
gus2ndWestEdgepointMiddleIndex++;
}
}
gus2ndWestEdgepointArraySize = usValidEdgepoints;
}
void CompactEdgepointArray( INT16 **psArray, UINT16 *pusMiddleIndex, UINT16 *pusArraySize )
{
INT32 i;
UINT16 usArraySize, usValidIndex = 0;
usArraySize = *pusArraySize;
for( i = 0; i < usArraySize; i++ )
{
if( (*psArray)[ i ] == -1 )
{
(*pusArraySize)--;
if( i < *pusMiddleIndex )
{
(*pusMiddleIndex)--;
}
}
else
{
if( usValidIndex != i )
{
(*psArray)[ usValidIndex ] = (*psArray)[ i ];
}
usValidIndex++;
}
}
*psArray = (INT16*)MemRealloc( *psArray, *pusArraySize * sizeof( INT16) );
Assert( *psArray );
}
void InternallyClassifyEdgepoints( SOLDIERTYPE *pSoldier, INT16 sGridNo,
INT16 **psArray1, UINT16 *pusMiddleIndex1, UINT16 *pusArraySize1,
INT16 **psArray2, UINT16 *pusMiddleIndex2, UINT16 *pusArraySize2 )
{
INT32 i;
UINT16 us1stBenchmarkID, us2ndBenchmarkID;
us1stBenchmarkID = us2ndBenchmarkID = 0xffff;
if( !(*psArray2) )
{
*psArray2 = (INT16*)MemAlloc( sizeof( INT16 ) * 400 );
}
for( i = 0; i < *pusArraySize1; i++ )
{
if( sGridNo == (*psArray1)[ i ] )
{
if( i < *pusMiddleIndex1 )
{ //in the first half of the array
us1stBenchmarkID = (UINT16)i;
//find the second benchmark
for( i = *pusMiddleIndex1; i < *pusArraySize1; i++ )
{
if( EdgepointsClose( pSoldier, (*psArray1)[ us1stBenchmarkID ], (*psArray1)[ i ] ) )
{
us2ndBenchmarkID = (UINT16)i;
break;
}
}
}
else
{ //in the second half of the array
us2ndBenchmarkID = (UINT16)i;
//find the first benchmark
for( i = 0; i < *pusMiddleIndex1; i++ )
{
if( EdgepointsClose( pSoldier, (*psArray1)[ us2ndBenchmarkID ], (*psArray1)[ i ] ) )
{
us1stBenchmarkID = (UINT16)i;
break;
}
}
}
break;
}
}
//Now we have found the two benchmarks, so go in both directions for each one to determine which entrypoints
//are going to be used in the primary array. All rejections will be positioned in the secondary array for
//use for isolated entry when tactically traversing.
if( us1stBenchmarkID != 0xffff )
{
for( i = us1stBenchmarkID; i > 0; i-- )
{
if( !EdgepointsClose( pSoldier, (*psArray1)[ i ], (*psArray1)[ i-1 ] ) )
{ //All edgepoints from index 0 to i-1 are rejected.
while( i )
{
i--;
(*psArray2)[ *pusArraySize2 ] = (*psArray1)[ i ];
(*pusMiddleIndex2)++;
(*pusArraySize2)++;
(*psArray1)[ i ] = -1;
}
break;
}
}
for( i = us1stBenchmarkID; i < *pusMiddleIndex1 - 1; i++ )
{
if( !EdgepointsClose( pSoldier, (*psArray1)[ i ], (*psArray1)[ i+1 ] ) )
{ //All edgepoints from index i+1 to 1st middle index are rejected.
while( i < *pusMiddleIndex1 - 1 )
{
i++;
(*psArray2)[ *pusArraySize2 ] = (*psArray1)[ i ];
(*pusMiddleIndex2)++;
(*pusArraySize2)++;
(*psArray1)[ i ] = -1;
}
break;
}
}
}
if( us2ndBenchmarkID != 0xffff )
{
for( i = us2ndBenchmarkID; i > *pusMiddleIndex1; i-- )
{
if( !EdgepointsClose( pSoldier, (*psArray1)[ i ], (*psArray1)[ i-1 ] ) )
{ //All edgepoints from 1st middle index to i-1 are rejected.
while( i > *pusMiddleIndex1 )
{
i--;
(*psArray2)[ *pusArraySize2 ] = (*psArray1)[ i ];
(*pusArraySize2)++;
(*psArray1)[ i ] = -1;
}
break;
}
}
for( i = us2ndBenchmarkID; i < *pusArraySize1 - 1; i++ )
{
if( !EdgepointsClose( pSoldier, (*psArray1)[ i ], (*psArray1)[ i+1 ] ) )
{ //All edgepoints from index 0 to i-1 are rejected.
while( i < *pusArraySize1 - 1 )
{
i++;
(*psArray2)[ (*pusArraySize2) ] = (*psArray1)[ i ];
(*pusArraySize2)++;
(*psArray1)[ i ] = -1;
}
break;
}
}
}
//Now compact the primary array, because some edgepoints have been removed.
CompactEdgepointArray( psArray1, pusMiddleIndex1, pusArraySize1 );
(*psArray2) = (INT16*)MemRealloc( (*psArray2), *pusArraySize2 * sizeof( INT16 ) );
}
void ClassifyEdgepoints()
{
SOLDIERTYPE Soldier;
INT16 sGridNo = -1;
Soldier.bTeam = 1;
//north
if( gMapInformation.sNorthGridNo != -1 )
{
sGridNo = FindNearestEdgepointOnSpecifiedEdge( gMapInformation.sNorthGridNo, NORTH_EDGEPOINT_SEARCH );
if( sGridNo != NOWHERE )
{
InternallyClassifyEdgepoints( &Soldier, sGridNo,
&gps1stNorthEdgepointArray, &gus1stNorthEdgepointMiddleIndex, &gus1stNorthEdgepointArraySize,
&gps2ndNorthEdgepointArray, &gus2ndNorthEdgepointMiddleIndex, &gus2ndNorthEdgepointArraySize );
}
}
//east
if( gMapInformation.sEastGridNo != -1 )
{
sGridNo = FindNearestEdgepointOnSpecifiedEdge( gMapInformation.sEastGridNo, EAST_EDGEPOINT_SEARCH );
if( sGridNo != NOWHERE )
{
InternallyClassifyEdgepoints( &Soldier, sGridNo,
&gps1stEastEdgepointArray, &gus1stEastEdgepointMiddleIndex, &gus1stEastEdgepointArraySize,
&gps2ndEastEdgepointArray, &gus2ndEastEdgepointMiddleIndex, &gus2ndEastEdgepointArraySize );
}
}
//south
if( gMapInformation.sSouthGridNo != -1 )
{
sGridNo = FindNearestEdgepointOnSpecifiedEdge( gMapInformation.sSouthGridNo, SOUTH_EDGEPOINT_SEARCH );
if( sGridNo != NOWHERE )
{
InternallyClassifyEdgepoints( &Soldier, sGridNo,
&gps1stSouthEdgepointArray, &gus1stSouthEdgepointMiddleIndex, &gus1stSouthEdgepointArraySize,
&gps2ndSouthEdgepointArray, &gus2ndSouthEdgepointMiddleIndex, &gus2ndSouthEdgepointArraySize );
}
}
//west
if( gMapInformation.sWestGridNo != -1 )
{
sGridNo = FindNearestEdgepointOnSpecifiedEdge( gMapInformation.sWestGridNo, WEST_EDGEPOINT_SEARCH );
if( sGridNo != NOWHERE )
{
InternallyClassifyEdgepoints( &Soldier, sGridNo,
&gps1stWestEdgepointArray, &gus1stWestEdgepointMiddleIndex, &gus1stWestEdgepointArraySize,
&gps2ndWestEdgepointArray, &gus2ndWestEdgepointMiddleIndex, &gus2ndWestEdgepointArraySize );
}
}
}
void GenerateMapEdgepoints()
{
INT32 i=-1;
INT16 sGridNo=-1;
INT16 sVGridNo[400];
//Get rid of the current edgepoint lists.
TrashMapEdgepoints();
gfGeneratingMapEdgepoints = TRUE;
if( gMapInformation.sNorthGridNo != -1 )
sGridNo = gMapInformation.sNorthGridNo;
else if( gMapInformation.sEastGridNo != -1 )
sGridNo = gMapInformation.sEastGridNo;
else if( gMapInformation.sSouthGridNo != -1 )
sGridNo = gMapInformation.sSouthGridNo;
else if( gMapInformation.sWestGridNo != -1 )
sGridNo = gMapInformation.sWestGridNo;
else if( gMapInformation.sCenterGridNo != -1 )
sGridNo = gMapInformation.sCenterGridNo;
else
return;
GlobalReachableTest( sGridNo );
//Calculate the north edges
if( gMapInformation.sNorthGridNo != -1 )
{
//1st row
sGridNo = gsTLGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stNorthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsTRGridNo )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stNorthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stNorthEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus1stNorthEdgepointMiddleIndex = gus1stNorthEdgepointArraySize;
sGridNo = gsTLGridNo + 161;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stNorthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsTRGridNo + 161 )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stNorthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stNorthEdgepointArraySize++ ] = sGridNo;
}
if( gus1stNorthEdgepointArraySize )
{
//Allocate and copy over the valid gridnos.
gps1stNorthEdgepointArray = (INT16*)MemAlloc( gus1stNorthEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus1stNorthEdgepointArraySize; i++ )
gps1stNorthEdgepointArray[ i ] = sVGridNo[ i ];
}
}
//Calculate the east edges
if( gMapInformation.sEastGridNo != -1 )
{
//1st row
sGridNo = gsTRGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stEastEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBRGridNo )
{
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stEastEdgepointArraySize++ ] = sGridNo;
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stEastEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus1stEastEdgepointMiddleIndex = gus1stEastEdgepointArraySize;
sGridNo = gsTRGridNo + 159;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stEastEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBRGridNo + 159 )
{
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stEastEdgepointArraySize++ ] = sGridNo;
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stEastEdgepointArraySize++ ] = sGridNo;
}
if( gus1stEastEdgepointArraySize )
{ //Allocate and copy over the valid gridnos.
gps1stEastEdgepointArray = (INT16*)MemAlloc( gus1stEastEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus1stEastEdgepointArraySize; i++ )
gps1stEastEdgepointArray[ i ] = sVGridNo[ i ];
}
}
//Calculate the south edges
if( gMapInformation.sSouthGridNo != -1 )
{
//1st row
sGridNo = gsBLGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stSouthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsBRGridNo )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stSouthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stSouthEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus1stSouthEdgepointMiddleIndex = gus1stSouthEdgepointArraySize;
sGridNo = gsBLGridNo - 161;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stSouthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsBRGridNo - 161 )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stSouthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stSouthEdgepointArraySize++ ] = sGridNo;
}
if( gus1stSouthEdgepointArraySize )
{ //Allocate and copy over the valid gridnos.
gps1stSouthEdgepointArray = (INT16*)MemAlloc( gus1stSouthEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus1stSouthEdgepointArraySize; i++ )
gps1stSouthEdgepointArray[ i ] = sVGridNo[ i ];
}
}
//Calculate the west edges
if( gMapInformation.sWestGridNo != -1 )
{
//1st row
sGridNo = gsTLGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stWestEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBLGridNo )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stWestEdgepointArraySize++ ] = sGridNo;
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stWestEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus1stWestEdgepointMiddleIndex = gus1stWestEdgepointArraySize;
sGridNo = gsTLGridNo - 159;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stWestEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBLGridNo - 159 )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stWestEdgepointArraySize++ ] = sGridNo;
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus1stWestEdgepointArraySize++ ] = sGridNo;
}
if( gus1stWestEdgepointArraySize )
{ //Allocate and copy over the valid gridnos.
gps1stWestEdgepointArray = (INT16*)MemAlloc( gus1stWestEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus1stWestEdgepointArraySize; i++ )
gps1stWestEdgepointArray[ i ] = sVGridNo[ i ];
}
}
//CHECK FOR ISOLATED EDGEPOINTS (but only if the entrypoint is ISOLATED!!!)
if( gMapInformation.sIsolatedGridNo != -1 && !(gpWorldLevelData[ gMapInformation.sIsolatedGridNo ].uiFlags & MAPELEMENT_REACHABLE) )
{
GlobalReachableTest( gMapInformation.sIsolatedGridNo );
if( gMapInformation.sNorthGridNo != -1 )
{
//1st row
sGridNo = gsTLGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndNorthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsTRGridNo )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndNorthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndNorthEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus2ndNorthEdgepointMiddleIndex = gus2ndNorthEdgepointArraySize;
sGridNo = gsTLGridNo + 161;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndNorthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsTRGridNo + 161 )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndNorthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndNorthEdgepointArraySize++ ] = sGridNo;
}
if( gus2ndNorthEdgepointArraySize )
{
//Allocate and copy over the valid gridnos.
gps2ndNorthEdgepointArray = (INT16*)MemAlloc( gus2ndNorthEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus2ndNorthEdgepointArraySize; i++ )
gps2ndNorthEdgepointArray[ i ] = sVGridNo[ i ];
}
}
//Calculate the east edges
if( gMapInformation.sEastGridNo != -1 )
{
//1st row
sGridNo = gsTRGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndEastEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBRGridNo )
{
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndEastEdgepointArraySize++ ] = sGridNo;
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndEastEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus2ndEastEdgepointMiddleIndex = gus2ndEastEdgepointArraySize;
sGridNo = gsTRGridNo + 159;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndEastEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBRGridNo + 159 )
{
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndEastEdgepointArraySize++ ] = sGridNo;
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndEastEdgepointArraySize++ ] = sGridNo;
}
if( gus2ndEastEdgepointArraySize )
{ //Allocate and copy over the valid gridnos.
gps2ndEastEdgepointArray = (INT16*)MemAlloc( gus2ndEastEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus2ndEastEdgepointArraySize; i++ )
gps2ndEastEdgepointArray[ i ] = sVGridNo[ i ];
}
}
//Calculate the south edges
if( gMapInformation.sSouthGridNo != -1 )
{
//1st row
sGridNo = gsBLGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndSouthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsBRGridNo )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndSouthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndSouthEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus2ndSouthEdgepointMiddleIndex = gus2ndSouthEdgepointArraySize;
sGridNo = gsBLGridNo - 161;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndSouthEdgepointArraySize++ ] = sGridNo;
while( sGridNo > gsBRGridNo - 161 )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndSouthEdgepointArraySize++ ] = sGridNo;
sGridNo -= 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndSouthEdgepointArraySize++ ] = sGridNo;
}
if( gus2ndSouthEdgepointArraySize )
{ //Allocate and copy over the valid gridnos.
gps2ndSouthEdgepointArray = (INT16*)MemAlloc( gus2ndSouthEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus2ndSouthEdgepointArraySize; i++ )
gps2ndSouthEdgepointArray[ i ] = sVGridNo[ i ];
}
}
//Calculate the west edges
if( gMapInformation.sWestGridNo != -1 )
{
//1st row
sGridNo = gsTLGridNo;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndWestEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBLGridNo )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndWestEdgepointArraySize++ ] = sGridNo;
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndWestEdgepointArraySize++ ] = sGridNo;
}
//2nd row
gus2ndWestEdgepointMiddleIndex = gus2ndWestEdgepointArraySize;
sGridNo = gsTLGridNo - 159;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndWestEdgepointArraySize++ ] = sGridNo;
while( sGridNo < gsBLGridNo - 159 )
{
sGridNo++;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndWestEdgepointArraySize++ ] = sGridNo;
sGridNo += 160;
if( gpWorldLevelData[ sGridNo ].uiFlags & MAPELEMENT_REACHABLE &&
(!gubWorldRoomInfo[ sGridNo ] || gfBasement) )
sVGridNo[ gus2ndWestEdgepointArraySize++ ] = sGridNo;
}
if( gus2ndWestEdgepointArraySize )
{ //Allocate and copy over the valid gridnos.
gps2ndWestEdgepointArray = (INT16*)MemAlloc( gus2ndWestEdgepointArraySize * sizeof( INT16) );
for( i = 0; i < gus2ndWestEdgepointArraySize; i++ )
gps2ndWestEdgepointArray[ i ] = sVGridNo[ i ];
}
}
}
//Eliminates any edgepoints not accessible to the edge of the world. This is done to the primary edgepoints
ValidateEdgepoints();
//Second step is to process the primary edgepoints and determine if any of the edgepoints aren't accessible from
//the associated entrypoint. These edgepoints that are rejected are placed in the secondary list.
if( gMapInformation.sIsolatedGridNo != -1 )
{ //only if there is an isolated gridno in the map. There is a flaw in the design of this system. The classification
//process will automatically assign areas to be isolated if there is an obstacle between one normal edgepoint and another
//causing a 5 tile connection check to fail. So, all maps with isolated edgepoints will need to be checked manually to
//make sure there are no obstacles causing this to happen (except for obstacles between normal areas and the isolated area)
//Good thing most maps don't have isolated sections. This is one expensive function to call! Maybe 200MI!
ClassifyEdgepoints();
}
gfGeneratingMapEdgepoints = FALSE;
}
void SaveMapEdgepoints( HWFILE fp )
{
//1st priority edgepoints -- for common entry -- tactical placement gui uses only these points.
FileWrite( fp, &gus1stNorthEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus1stNorthEdgepointMiddleIndex, 2, NULL );
if( gus1stNorthEdgepointArraySize )
FileWrite( fp, gps1stNorthEdgepointArray, gus1stNorthEdgepointArraySize * sizeof( INT16 ), NULL );
FileWrite( fp, &gus1stEastEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus1stEastEdgepointMiddleIndex, 2, NULL );
if( gus1stEastEdgepointArraySize )
FileWrite( fp, gps1stEastEdgepointArray, gus1stEastEdgepointArraySize * sizeof( INT16 ), NULL );
FileWrite( fp, &gus1stSouthEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus1stSouthEdgepointMiddleIndex, 2, NULL );
if( gus1stSouthEdgepointArraySize )
FileWrite( fp, gps1stSouthEdgepointArray, gus1stSouthEdgepointArraySize * sizeof( INT16 ), NULL );
FileWrite( fp, &gus1stWestEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus1stWestEdgepointMiddleIndex, 2, NULL );
if( gus1stWestEdgepointArraySize )
FileWrite( fp, gps1stWestEdgepointArray, gus1stWestEdgepointArraySize * sizeof( INT16 ), NULL );
//2nd priority edgepoints -- for isolated areas. Okay to be zero
FileWrite( fp, &gus2ndNorthEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus2ndNorthEdgepointMiddleIndex, 2, NULL );
if( gus2ndNorthEdgepointArraySize )
FileWrite( fp, gps2ndNorthEdgepointArray, gus2ndNorthEdgepointArraySize * sizeof( INT16 ), NULL );
FileWrite( fp, &gus2ndEastEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus2ndEastEdgepointMiddleIndex, 2, NULL );
if( gus2ndEastEdgepointArraySize )
FileWrite( fp, gps2ndEastEdgepointArray, gus2ndEastEdgepointArraySize * sizeof( INT16 ), NULL );
FileWrite( fp, &gus2ndSouthEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus2ndSouthEdgepointMiddleIndex, 2, NULL );
if( gus2ndSouthEdgepointArraySize )
FileWrite( fp, gps2ndSouthEdgepointArray, gus2ndSouthEdgepointArraySize * sizeof( INT16 ), NULL );
FileWrite( fp, &gus2ndWestEdgepointArraySize, 2, NULL );
FileWrite( fp, &gus2ndWestEdgepointMiddleIndex, 2, NULL );
if( gus2ndWestEdgepointArraySize )
FileWrite( fp, gps2ndWestEdgepointArray, gus2ndWestEdgepointArraySize * sizeof( INT16 ), NULL );
}
void OldLoadMapEdgepoints( INT8 **hBuffer )
{
LOADDATA( &gus1stNorthEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stNorthEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stNorthEdgepointArraySize )
{
gps1stNorthEdgepointArray = (INT16*)MemAlloc( gus1stNorthEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stNorthEdgepointArray );
LOADDATA( gps1stNorthEdgepointArray, *hBuffer, gus1stNorthEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus1stEastEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stEastEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stEastEdgepointArraySize )
{
gps1stEastEdgepointArray = (INT16*)MemAlloc( gus1stEastEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stEastEdgepointArray );
LOADDATA( gps1stEastEdgepointArray, *hBuffer, gus1stEastEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus1stSouthEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stSouthEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stSouthEdgepointArraySize )
{
gps1stSouthEdgepointArray = (INT16*)MemAlloc( gus1stSouthEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stSouthEdgepointArray );
LOADDATA( gps1stSouthEdgepointArray, *hBuffer, gus1stSouthEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus1stWestEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stWestEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stWestEdgepointArraySize )
{
gps1stWestEdgepointArray = (INT16*)MemAlloc( gus1stWestEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stWestEdgepointArray );
LOADDATA( gps1stWestEdgepointArray, *hBuffer, gus1stWestEdgepointArraySize * sizeof( INT16 ) );
}
}
BOOLEAN LoadMapEdgepoints( INT8 **hBuffer )
{
TrashMapEdgepoints();
if( gMapInformation.ubMapVersion < 17 )
{ //To prevent invalidation of older maps, which only used one layer of edgepoints, and a UINT8 for
//containing the size, we will preserve that paradigm, then kill the loaded edgepoints and
//regenerate them.
OldLoadMapEdgepoints( hBuffer );
TrashMapEdgepoints();
return FALSE;
}
LOADDATA( &gus1stNorthEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stNorthEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stNorthEdgepointArraySize )
{
gps1stNorthEdgepointArray = (INT16*)MemAlloc( gus1stNorthEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stNorthEdgepointArray );
LOADDATA( gps1stNorthEdgepointArray, *hBuffer, gus1stNorthEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus1stEastEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stEastEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stEastEdgepointArraySize )
{
gps1stEastEdgepointArray = (INT16*)MemAlloc( gus1stEastEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stEastEdgepointArray );
LOADDATA( gps1stEastEdgepointArray, *hBuffer, gus1stEastEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus1stSouthEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stSouthEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stSouthEdgepointArraySize )
{
gps1stSouthEdgepointArray = (INT16*)MemAlloc( gus1stSouthEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stSouthEdgepointArray );
LOADDATA( gps1stSouthEdgepointArray, *hBuffer, gus1stSouthEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus1stWestEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus1stWestEdgepointMiddleIndex, *hBuffer, 2 );
if( gus1stWestEdgepointArraySize )
{
gps1stWestEdgepointArray = (INT16*)MemAlloc( gus1stWestEdgepointArraySize * sizeof( INT16 ) );
Assert( gps1stWestEdgepointArray );
LOADDATA( gps1stWestEdgepointArray, *hBuffer, gus1stWestEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus2ndNorthEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus2ndNorthEdgepointMiddleIndex, *hBuffer, 2 );
if( gus2ndNorthEdgepointArraySize )
{
gps2ndNorthEdgepointArray = (INT16*)MemAlloc( gus2ndNorthEdgepointArraySize * sizeof( INT16 ) );
Assert( gps2ndNorthEdgepointArray );
LOADDATA( gps2ndNorthEdgepointArray, *hBuffer, gus2ndNorthEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus2ndEastEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus2ndEastEdgepointMiddleIndex, *hBuffer, 2 );
if( gus2ndEastEdgepointArraySize )
{
gps2ndEastEdgepointArray = (INT16*)MemAlloc( gus2ndEastEdgepointArraySize * sizeof( INT16 ) );
Assert( gps2ndEastEdgepointArray );
LOADDATA( gps2ndEastEdgepointArray, *hBuffer, gus2ndEastEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus2ndSouthEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus2ndSouthEdgepointMiddleIndex, *hBuffer, 2 );
if( gus2ndSouthEdgepointArraySize )
{
gps2ndSouthEdgepointArray = (INT16*)MemAlloc( gus2ndSouthEdgepointArraySize * sizeof( INT16 ) );
Assert( gps2ndSouthEdgepointArray );
LOADDATA( gps2ndSouthEdgepointArray, *hBuffer, gus2ndSouthEdgepointArraySize * sizeof( INT16 ) );
}
LOADDATA( &gus2ndWestEdgepointArraySize, *hBuffer, 2 );
LOADDATA( &gus2ndWestEdgepointMiddleIndex, *hBuffer, 2 );
if( gus2ndWestEdgepointArraySize )
{
gps2ndWestEdgepointArray = (INT16*)MemAlloc( gus2ndWestEdgepointArraySize * sizeof( INT16 ) );
Assert( gps2ndWestEdgepointArray );
LOADDATA( gps2ndWestEdgepointArray, *hBuffer, gus2ndWestEdgepointArraySize * sizeof( INT16 ) );
}
if( gMapInformation.ubMapVersion < 22 )
{ //regenerate them.
TrashMapEdgepoints();
return FALSE;
}
return TRUE;
}
UINT16 ChooseMapEdgepoint( UINT8 ubStrategicInsertionCode )
{
INT16 *psArray=NULL;
UINT16 usArraySize=0;
static INT32 randomVal=0;
//First validate and get access to the correct array based on strategic direction.
//We will use the selected array to choose insertion gridno's.
switch( ubStrategicInsertionCode )
{
case INSERTION_CODE_NORTH:
psArray = gps1stNorthEdgepointArray;
usArraySize = gus1stNorthEdgepointArraySize;
break;
case INSERTION_CODE_EAST:
psArray = gps1stEastEdgepointArray;
usArraySize = gus1stEastEdgepointArraySize;
break;
case INSERTION_CODE_SOUTH:
psArray = gps1stSouthEdgepointArray;
usArraySize = gus1stSouthEdgepointArraySize;
break;
case INSERTION_CODE_WEST:
psArray = gps1stWestEdgepointArray;
usArraySize = gus1stWestEdgepointArraySize;
break;
default:
AssertMsg( 0, "ChooseMapEdgepoints: Failed to pass a valid strategic insertion code." );
break;
}
if( !usArraySize )
{
return NOWHERE;
}
return psArray[ Random( usArraySize ) ];
}
void ChooseMapEdgepoints( MAPEDGEPOINTINFO *pMapEdgepointInfo, UINT8 ubStrategicInsertionCode, UINT8 ubNumDesiredPoints )
{
INT16 *psArray=NULL;
UINT16 usArraySize=0;
INT32 i=-1;
UINT16 usSlots, usCurrSlot;
INT16 *psTempArray = NULL;
AssertMsg( ubNumDesiredPoints > 0 && ubNumDesiredPoints <= 32,
String( "ChooseMapEdgepoints: Desired points = %d, valid range is 1-32", ubNumDesiredPoints ) );
//First validate and get access to the correct array based on strategic direction.
//We will use the selected array to choose insertion gridno's.
switch( ubStrategicInsertionCode )
{
case INSERTION_CODE_NORTH:
psArray = gps1stNorthEdgepointArray;
usArraySize = gus1stNorthEdgepointArraySize;
break;
case INSERTION_CODE_EAST:
psArray = gps1stEastEdgepointArray;
usArraySize = gus1stEastEdgepointArraySize;
break;
case INSERTION_CODE_SOUTH:
psArray = gps1stSouthEdgepointArray;
usArraySize = gus1stSouthEdgepointArraySize;
break;
case INSERTION_CODE_WEST:
psArray = gps1stWestEdgepointArray;
usArraySize = gus1stWestEdgepointArraySize;
break;
default:
AssertMsg( 0, "ChooseMapEdgepoints: Failed to pass a valid strategic insertion code." );
break;
}
pMapEdgepointInfo->ubStrategicInsertionCode = ubStrategicInsertionCode;
#ifdef JA2BETAVERSION
if( !psArray || !usArraySize )
{
if( gMapInformation.sNorthGridNo == -1 && gMapInformation.sEastGridNo == -1 &&
gMapInformation.sSouthGridNo == -1 && gMapInformation.sWestGridNo == -1 &&
gMapInformation.sCenterGridNo == -1 )
{
if( gbWorldSectorZ )
{
AssertMsg( 0,
String( "Map %c%d_b%d(_a) doesn't have ANY entry points which means that it is impossible to generate map edgepoints. (LC : 1)",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
}
else
{
AssertMsg( 0,
String( "Map %c%d(_a) doesn't have ANY entry points which means that it is impossible to generate map edgepoints. (LC : 1)",
gWorldSectorY + 'A' - 1, gWorldSectorX ) );
}
}
else switch( ubStrategicInsertionCode )
{
case INSERTION_CODE_NORTH:
AssertMsg( 0, "This map doesn't have any north mapedgepoints. Possibly because there is no north entry point. (LC : 1)" );
break;
case INSERTION_CODE_EAST:
AssertMsg( 0, "This map doesn't have any east mapedgepoints. Possibly because there is no east entry point. (LC : 1)" );
break;
case INSERTION_CODE_SOUTH:
AssertMsg( 0, "This map doesn't have any south mapedgepoints. Possibly because there is no south entry point. (LC : 1)" );
break;
case INSERTION_CODE_WEST:
AssertMsg( 0, "This map doesn't have any west mapedgepoints. Possibly because there is no west entry point. NOTE: Teleportation always uses the west entrypoint. Some maps shouldn't have west entrypoints. (LC : 1)" );
break;
}
}
#endif
if( !usArraySize )
{
pMapEdgepointInfo->ubNumPoints = 0;
return;
}
// JA2 Gold: don't place people in the water.
// If any of the waypoints is on a water spot, we're going to have to remove it
psTempArray = (INT16 *) MemAlloc( sizeof(INT16) * usArraySize );
memcpy(psTempArray, psArray, sizeof(INT16) * usArraySize );
psArray = psTempArray;
for (i = 0; i < usArraySize; i++)
{
if (TERRAIN_IS_HIGH_WATER( GetTerrainType(psArray[ i ]) ) )
{
if (i == usArraySize - 1)
{
// just axe it and we're done.
psArray[ i ] = 0;
usArraySize--;
break;
}
else
{
// replace this element in the array with the LAST element in the array, then decrement
// the array size
psArray[ i ] = psArray[usArraySize-1];
usArraySize--;
// we're going to have to check the array element we just copied into this spot, too
i--;
}
}
}
if( ubNumDesiredPoints >= usArraySize )
{ //We don't have enough points for everyone, return them all.
pMapEdgepointInfo->ubNumPoints = (UINT8)usArraySize;
for( i = 0; i < usArraySize; i++ )
pMapEdgepointInfo->sGridNo[i] = psArray[i];
// JA2Gold: free the temp array
MemFree(psTempArray);
return;
}
//We have more points, so choose them randomly.
usSlots = usArraySize;
usCurrSlot = 0;
pMapEdgepointInfo->ubNumPoints = ubNumDesiredPoints;
for( i = 0; i < usArraySize; i++ )
{
if( Random( usSlots ) < ubNumDesiredPoints )
{
pMapEdgepointInfo->sGridNo[ usCurrSlot++ ] = psArray[ i ];
ubNumDesiredPoints--;
}
usSlots--;
}
// JA2Gold: free the temp array
MemFree(psTempArray);
}
INT16 *gpReservedGridNos = NULL;
INT16 gsReservedIndex = 0;
void BeginMapEdgepointSearch()
{
INT16 sGridNo;
//Create the reserved list
AssertMsg( !gpReservedGridNos, "Attempting to BeginMapEdgepointSearch that has already been created." );
gpReservedGridNos = (INT16*)MemAlloc( 20 * sizeof( INT16 ) );
Assert( gpReservedGridNos );
gsReservedIndex = 0;
if( gMapInformation.sNorthGridNo != -1 )
sGridNo = gMapInformation.sNorthGridNo;
else if( gMapInformation.sEastGridNo != -1 )
sGridNo = gMapInformation.sEastGridNo;
else if( gMapInformation.sSouthGridNo != -1 )
sGridNo = gMapInformation.sSouthGridNo;
else if( gMapInformation.sWestGridNo != -1 )
sGridNo = gMapInformation.sWestGridNo;
else
return;
GlobalReachableTest( sGridNo );
//Now, we have the path values calculated. Now, we can check for closest edgepoints.
}
void EndMapEdgepointSearch()
{
AssertMsg( gpReservedGridNos, "Attempting to EndMapEdgepointSearch that has already been removed." );
MemFree( gpReservedGridNos );
gpReservedGridNos = NULL;
gsReservedIndex = 0;
}
//THIS CODE ISN'T RECOMMENDED FOR TIME CRITICAL AREAS.
INT16 SearchForClosestPrimaryMapEdgepoint( INT16 sGridNo, UINT8 ubInsertionCode )
{
INT32 i, iDirectionLoop;
INT16 *psArray=NULL;
INT16 sRadius, sDistance, sDirection, sOriginalGridNo;
UINT16 usArraySize=0;
BOOLEAN fReserved;
if( gsReservedIndex >= 20 )
{ //Everything is reserved.
AssertMsg( 0, "All closest map edgepoints have been reserved. We should only have 20 soldiers maximum...");
}
switch( ubInsertionCode )
{
case INSERTION_CODE_NORTH:
psArray = gps1stNorthEdgepointArray;
usArraySize = gus1stNorthEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any north mapedgepoints. LC:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
case INSERTION_CODE_EAST:
psArray = gps1stEastEdgepointArray;
usArraySize = gus1stEastEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any east mapedgepoints. LC:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
case INSERTION_CODE_SOUTH:
psArray = gps1stSouthEdgepointArray;
usArraySize = gus1stSouthEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any south mapedgepoints. LC:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
case INSERTION_CODE_WEST:
psArray = gps1stWestEdgepointArray;
usArraySize = gus1stWestEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any west mapedgepoints. LC:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
}
if( !usArraySize )
{
return NOWHERE;
}
//Check the initial gridno, to see if it is available and an edgepoint.
fReserved = FALSE;
for( i = 0; i < gsReservedIndex; i++ )
{
if( gpReservedGridNos[ i ] == sGridNo )
{
fReserved = TRUE;
break;
}
}
if( !fReserved )
{ //Not reserved, so see if we can find this gridno in the edgepoint array.
for( i = 0 ; i < usArraySize; i++ )
{
if( psArray[ i ] == sGridNo )
{ //Yes, the gridno is in the edgepoint array.
gpReservedGridNos[ gsReservedIndex ] = sGridNo;
gsReservedIndex++;
return sGridNo;
}
}
}
//spiral outwards, until we find an unreserved mapedgepoint.
//
// 09 08 07 06
// 10 01 00 05
// 11 02 03 04
// 12 13 14 15 ..
sRadius = 1;
sDirection = WORLD_COLS;
sOriginalGridNo = sGridNo;
while( sRadius < (INT16)(gbWorldSectorZ ? 30 : 10) )
{
sGridNo = sOriginalGridNo + (-1 - WORLD_COLS)*sRadius; //start at the TOP-LEFT gridno
for( iDirectionLoop = 0; iDirectionLoop < 4; iDirectionLoop++ )
{
switch( iDirectionLoop )
{
case 0: sDirection = WORLD_COLS; break;
case 1: sDirection = 1; break;
case 2: sDirection = -WORLD_COLS; break;
case 3: sDirection = -1; break;
}
sDistance = sRadius * 2;
while( sDistance-- )
{
sGridNo += sDirection;
if( sGridNo < 0 || sGridNo >= WORLD_MAX )
continue;
//Check the gridno, to see if it is available and an edgepoint.
fReserved = FALSE;
for( i = 0; i < gsReservedIndex; i++ )
{
if( gpReservedGridNos[ i ] == sGridNo )
{
fReserved = TRUE;
break;
}
}
if( !fReserved )
{ //Not reserved, so see if we can find this gridno in the edgepoint array.
for( i = 0 ; i < usArraySize; i++ )
{
if( psArray[ i ] == sGridNo )
{ //Yes, the gridno is in the edgepoint array.
gpReservedGridNos[ gsReservedIndex ] = sGridNo;
gsReservedIndex++;
return sGridNo;
}
}
}
}
}
sRadius++;
}
return NOWHERE ;
}
INT16 SearchForClosestSecondaryMapEdgepoint( INT16 sGridNo, UINT8 ubInsertionCode )
{
INT32 i, iDirectionLoop;
INT16 *psArray=NULL;
INT16 sRadius, sDistance, sDirection, sOriginalGridNo;
UINT16 usArraySize=0;
BOOLEAN fReserved;
if( gsReservedIndex >= 20 )
{ //Everything is reserved.
AssertMsg( 0, "All closest map edgepoints have been reserved. We should only have 20 soldiers maximum...");
}
switch( ubInsertionCode )
{
case INSERTION_CODE_NORTH:
psArray = gps2ndNorthEdgepointArray;
usArraySize = gus2ndNorthEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any isolated north mapedgepoints. KM:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
case INSERTION_CODE_EAST:
psArray = gps2ndEastEdgepointArray;
usArraySize = gus2ndEastEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any isolated east mapedgepoints. KM:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
case INSERTION_CODE_SOUTH:
psArray = gps2ndSouthEdgepointArray;
usArraySize = gus2ndSouthEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any isolated south mapedgepoints. KM:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
case INSERTION_CODE_WEST:
psArray = gps2ndWestEdgepointArray;
usArraySize = gus2ndWestEdgepointArraySize;
if( !usArraySize )
AssertMsg( 0, String( "Sector %c%d level %d doesn't have any isolated west mapedgepoints. KM:1",
gWorldSectorY + 'A' - 1, gWorldSectorX, gbWorldSectorZ ) );
break;
}
if( !usArraySize )
{
return NOWHERE;
}
//Check the initial gridno, to see if it is available and an edgepoint.
fReserved = FALSE;
for( i = 0; i < gsReservedIndex; i++ )
{
if( gpReservedGridNos[ i ] == sGridNo )
{
fReserved = TRUE;
break;
}
}
if( !fReserved )
{ //Not reserved, so see if we can find this gridno in the edgepoint array.
for( i = 0 ; i < usArraySize; i++ )
{
if( psArray[ i ] == sGridNo )
{ //Yes, the gridno is in the edgepoint array.
gpReservedGridNos[ gsReservedIndex ] = sGridNo;
gsReservedIndex++;
return sGridNo;
}
}
}
//spiral outwards, until we find an unreserved mapedgepoint.
//
// 09 08 07 06
// 10 01 00 05
// 11 02 03 04
// 12 13 14 15 ..
sRadius = 1;
sDirection = WORLD_COLS;
sOriginalGridNo = sGridNo;
while( sRadius < (INT16)(gbWorldSectorZ ? 30 : 10) )
{
sGridNo = sOriginalGridNo + (-1 - WORLD_COLS)*sRadius; //start at the TOP-LEFT gridno
for( iDirectionLoop = 0; iDirectionLoop < 4; iDirectionLoop++ )
{
switch( iDirectionLoop )
{
case 0: sDirection = WORLD_COLS; break;
case 1: sDirection = 1; break;
case 2: sDirection = -WORLD_COLS; break;
case 3: sDirection = -1; break;
}
sDistance = sRadius * 2;
while( sDistance-- )
{
sGridNo += sDirection;
if( sGridNo < 0 || sGridNo >= WORLD_MAX )
continue;
//Check the gridno, to see if it is available and an edgepoint.
fReserved = FALSE;
for( i = 0; i < gsReservedIndex; i++ )
{
if( gpReservedGridNos[ i ] == sGridNo )
{
fReserved = TRUE;
break;
}
}
if( !fReserved )
{ //Not reserved, so see if we can find this gridno in the edgepoint array.
for( i = 0 ; i < usArraySize; i++ )
{
if( psArray[ i ] == sGridNo )
{ //Yes, the gridno is in the edgepoint array.
gpReservedGridNos[ gsReservedIndex ] = sGridNo;
gsReservedIndex++;
return sGridNo;
}
}
}
}
}
sRadius++;
}
return NOWHERE ;
}
#define EDGE_OF_MAP_SEARCH 5
BOOLEAN VerifyEdgepoint( SOLDIERTYPE * pSoldier, INT16 sEdgepoint )
{
INT32 iSearchRange;
INT16 sMaxLeft, sMaxRight, sMaxUp, sMaxDown, sXOffset, sYOffset;
INT16 sGridNo;
INT8 bDirection;
pSoldier->sGridNo = sEdgepoint;
iSearchRange = EDGE_OF_MAP_SEARCH;
// determine maximum horizontal limits
sMaxLeft = min( iSearchRange, (pSoldier->sGridNo % MAXCOL));
//NumMessage("sMaxLeft = ",sMaxLeft);
sMaxRight = min( iSearchRange, MAXCOL - ((pSoldier->sGridNo % MAXCOL) + 1));
//NumMessage("sMaxRight = ",sMaxRight);
// determine maximum vertical limits
sMaxUp = min( iSearchRange, (pSoldier->sGridNo / MAXROW));
//NumMessage("sMaxUp = ",sMaxUp);
sMaxDown = min( iSearchRange, MAXROW - ((pSoldier->sGridNo / MAXROW) + 1));
// Call FindBestPath to set flags in all locations that we can
// walk into within range. We have to set some things up first...
// set the distance limit of the square region
gubNPCDistLimit = EDGE_OF_MAP_SEARCH;
// reset the "reachable" flags in the region we're looking at
for (sYOffset = -sMaxUp; sYOffset <= sMaxDown; sYOffset++)
{
for (sXOffset = -sMaxLeft; sXOffset <= sMaxRight; sXOffset++)
{
sGridNo = sEdgepoint + sXOffset + (MAXCOL * sYOffset);
gpWorldLevelData[sGridNo].uiFlags &= ~(MAPELEMENT_REACHABLE);
}
}
FindBestPath( pSoldier, NOWHERE, pSoldier->pathing.bLevel, WALKING, COPYREACHABLE, PATH_THROUGH_PEOPLE );
// Turn off the "reachable" flag for the current location
// so we don't consider it
//gpWorldLevelData[sEdgepoint].uiFlags &= ~(MAPELEMENT_REACHABLE);
// SET UP DOUBLE-LOOP TO STEP THROUGH POTENTIAL GRID #s
for (sYOffset = -sMaxUp; sYOffset <= sMaxDown; sYOffset++)
{
for (sXOffset = -sMaxLeft; sXOffset <= sMaxRight; sXOffset++)
{
// calculate the next potential gridno
sGridNo = sEdgepoint + sXOffset + (MAXCOL * sYOffset);
if (!(gpWorldLevelData[sGridNo].uiFlags & MAPELEMENT_REACHABLE))
{
continue;
}
if (GridNoOnEdgeOfMap( sGridNo, &bDirection ) )
{
// ok!
return TRUE;
}
}
}
// no spots right on edge of map within 5 tiles
return FALSE;
}
BOOLEAN EdgepointsClose( SOLDIERTYPE *pSoldier, INT16 sEdgepoint1, INT16 sEdgepoint2 )
{
INT32 iSearchRange;
INT16 sMaxLeft, sMaxRight, sMaxUp, sMaxDown, sXOffset, sYOffset;
INT16 sGridNo;
pSoldier->sGridNo = sEdgepoint1;
if( gWorldSectorX == 14 && gWorldSectorY == 9 && !gbWorldSectorZ )
{ //BRUTAL CODE -- special case map.
iSearchRange = 250;
}
else
{
iSearchRange = EDGE_OF_MAP_SEARCH;
}
// determine maximum horizontal limits
sMaxLeft = min( iSearchRange, (pSoldier->sGridNo % MAXCOL));
//NumMessage("sMaxLeft = ",sMaxLeft);
sMaxRight = min( iSearchRange, MAXCOL - ((pSoldier->sGridNo % MAXCOL) + 1));
//NumMessage("sMaxRight = ",sMaxRight);
// determine maximum vertical limits
sMaxUp = min( iSearchRange, (pSoldier->sGridNo / MAXROW));
//NumMessage("sMaxUp = ",sMaxUp);
sMaxDown = min( iSearchRange, MAXROW - ((pSoldier->sGridNo / MAXROW) + 1));
// Call FindBestPath to set flags in all locations that we can
// walk into within range. We have to set some things up first...
// set the distance limit of the square region
gubNPCDistLimit = (UINT8)iSearchRange;
// reset the "reachable" flags in the region we're looking at
for (sYOffset = -sMaxUp; sYOffset <= sMaxDown; sYOffset++)
{
for (sXOffset = -sMaxLeft; sXOffset <= sMaxRight; sXOffset++)
{
sGridNo = sEdgepoint1 + sXOffset + (MAXCOL * sYOffset);
gpWorldLevelData[sGridNo].uiFlags &= ~(MAPELEMENT_REACHABLE);
}
}
if( FindBestPath( pSoldier, sEdgepoint2, pSoldier->pathing.bLevel, WALKING, COPYREACHABLE, PATH_THROUGH_PEOPLE ) )
{
return TRUE;
}
return FALSE;
}
UINT8 CalcMapEdgepointClassInsertionCode( INT16 sGridNo )
{
SOLDIERTYPE Soldier;
INT32 iLoop;
INT16 *psEdgepointArray1, *psEdgepointArray2;
INT32 iEdgepointArraySize1, iEdgepointArraySize2;
INT16 sClosestSpot1 = NOWHERE, sClosestDist1 = 0x7FFF, sTempDist;
INT16 sClosestSpot2 = NOWHERE, sClosestDist2 = 0x7FFF;
BOOLEAN fPrimaryValid = FALSE, fSecondaryValid = FALSE;
Soldier.bTeam = 1;
Soldier.sGridNo = sGridNo;
if( gMapInformation.sIsolatedGridNo == -1 )
{ //If the map has no isolated area, then all edgepoints are primary.
return INSERTION_CODE_PRIMARY_EDGEINDEX;
}
switch( gubTacticalDirection )
{
case NORTH:
psEdgepointArray1 = gps1stNorthEdgepointArray;
iEdgepointArraySize1 = gus1stNorthEdgepointArraySize;
psEdgepointArray2 = gps2ndNorthEdgepointArray;
iEdgepointArraySize2 = gus2ndNorthEdgepointArraySize;
break;
case EAST:
psEdgepointArray1 = gps1stEastEdgepointArray;
iEdgepointArraySize1 = gus1stEastEdgepointArraySize;
psEdgepointArray2 = gps2ndEastEdgepointArray;
iEdgepointArraySize2 = gus2ndEastEdgepointArraySize;
break;
case SOUTH:
psEdgepointArray1 = gps1stSouthEdgepointArray;
iEdgepointArraySize1 = gus1stSouthEdgepointArraySize;
psEdgepointArray2 = gps2ndSouthEdgepointArray;
iEdgepointArraySize2 = gus2ndSouthEdgepointArraySize;
break;
case WEST:
psEdgepointArray1 = gps1stWestEdgepointArray;
iEdgepointArraySize1 = gus1stWestEdgepointArraySize;
psEdgepointArray2 = gps2ndWestEdgepointArray;
iEdgepointArraySize2 = gus2ndWestEdgepointArraySize;
break;
default:
// WTF???
return INSERTION_CODE_PRIMARY_EDGEINDEX;
}
// Do a 2D search to find the closest map edgepoint and
// try to create a path there
for ( iLoop = 0; iLoop < iEdgepointArraySize1; iLoop++ )
{
sTempDist = PythSpacesAway( sGridNo, psEdgepointArray1[ iLoop ] );
if ( sTempDist < sClosestDist1 )
{
sClosestDist1 = sTempDist;
sClosestSpot1 = psEdgepointArray1[ iLoop ];
}
}
for ( iLoop = 0; iLoop < iEdgepointArraySize2; iLoop++ )
{
sTempDist = PythSpacesAway( sGridNo, psEdgepointArray2[ iLoop ] );
if ( sTempDist < sClosestDist2 )
{
sClosestDist2 = sTempDist;
sClosestSpot2 = psEdgepointArray2[ iLoop ];
}
}
// set the distance limit of the square region
gubNPCDistLimit = 15;
if( !sClosestDist1 || FindBestPath( &Soldier, sClosestSpot1, 0, WALKING, NO_COPYROUTE, PATH_THROUGH_PEOPLE ) )
{
fPrimaryValid = TRUE;
}
if( !sClosestDist2 || FindBestPath( &Soldier, sClosestSpot2, 0, WALKING, NO_COPYROUTE, PATH_THROUGH_PEOPLE ) )
{
fSecondaryValid = TRUE;
}
if( fPrimaryValid == fSecondaryValid )
{
if( sClosestDist2 < sClosestDist1 )
{
return INSERTION_CODE_SECONDARY_EDGEINDEX;
}
return INSERTION_CODE_PRIMARY_EDGEINDEX;
}
if( fPrimaryValid )
{
return INSERTION_CODE_PRIMARY_EDGEINDEX;
}
return INSERTION_CODE_SECONDARY_EDGEINDEX;
}
#ifdef JA2BETAVERSION
#include "worldman.h"
#include "message.h"
void ShowMapEdgepoints()
{
INT32 i, usIllegal1 = 0, usIllegal2 = 0;
for( i = 0 ; i < gus1stNorthEdgepointArraySize; i++ )
{
if( gps1stNorthEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps1stNorthEdgepointArray[ i ], FIRSTPOINTERS5 );
}
else
{
usIllegal1++;
}
}
for( i = 0 ; i < gus1stEastEdgepointArraySize; i++ )
{
if( gps1stEastEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps1stEastEdgepointArray[ i ], FIRSTPOINTERS5 );
}
else
{
usIllegal1++;
}
}
for( i = 0 ; i < gus1stSouthEdgepointArraySize; i++ )
{
if( gps1stSouthEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps1stSouthEdgepointArray[ i ], FIRSTPOINTERS5 );
}
else
{
usIllegal1++;
}
}
for( i = 0 ; i < gus1stWestEdgepointArraySize; i++ )
{
if( gps1stWestEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps1stWestEdgepointArray[ i ], FIRSTPOINTERS5 );
}
else
{
usIllegal1++;
}
}
for( i = 0 ; i < gus2ndNorthEdgepointArraySize; i++ )
{
if( gps2ndNorthEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps2ndNorthEdgepointArray[ i ], FIRSTPOINTERS6 );
}
else
{
usIllegal2++;
}
}
for( i = 0 ; i < gus2ndEastEdgepointArraySize; i++ )
{
if( gps2ndEastEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps2ndEastEdgepointArray[ i ], FIRSTPOINTERS6 );
}
else
{
usIllegal2++;
}
}
for( i = 0 ; i < gus2ndSouthEdgepointArraySize; i++ )
{
if( gps2ndSouthEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps2ndSouthEdgepointArray[ i ], FIRSTPOINTERS6 );
}
else
{
usIllegal2++;
}
}
for( i = 0 ; i < gus2ndWestEdgepointArraySize; i++ )
{
if( gps2ndWestEdgepointArray[ i ] != -1 )
{
AddTopmostToTail( gps2ndWestEdgepointArray[ i ], FIRSTPOINTERS6 );
}
else
{
usIllegal2++;
}
}
if( !usIllegal1 && !usIllegal2 )
{
ScreenMsg( 0, MSG_TESTVERSION, L"Showing display of map edgepoints" );
}
else
{
ScreenMsg( 0, MSG_TESTVERSION, L"Showing display of map edgepoints (%d illegal primary, %d illegal secondary)" );
}
ScreenMsg( 0, MSG_TESTVERSION, L"N:%d:%d E:%d:%d S:%d:%d W:%d:%d",
gus1stNorthEdgepointArraySize, gus2ndNorthEdgepointArraySize,
gus1stEastEdgepointArraySize, gus2ndEastEdgepointArraySize,
gus1stSouthEdgepointArraySize, gus2ndSouthEdgepointArraySize,
gus1stWestEdgepointArraySize, gus2ndWestEdgepointArraySize );
}
void HideMapEdgepoints()
{
INT32 i;
ScreenMsg( 0, MSG_TESTVERSION, L"Removing display of map edgepoints" );
for( i = 0 ; i < gus1stNorthEdgepointArraySize; i++ )
{
if( gps1stNorthEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps1stNorthEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
for( i = 0 ; i < gus1stEastEdgepointArraySize; i++ )
{
if( gps1stEastEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps1stEastEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
for( i = 0 ; i < gus1stSouthEdgepointArraySize; i++ )
{
if( gps1stSouthEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps1stSouthEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
for( i = 0 ; i < gus1stWestEdgepointArraySize; i++ )
{
if( gps1stWestEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps1stWestEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
for( i = 0 ; i < gus2ndNorthEdgepointArraySize; i++ )
{
if( gps2ndNorthEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps2ndNorthEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
for( i = 0 ; i < gus2ndEastEdgepointArraySize; i++ )
{
if( gps2ndEastEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps2ndEastEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
for( i = 0 ; i < gus2ndSouthEdgepointArraySize; i++ )
{
if( gps2ndSouthEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps2ndSouthEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
for( i = 0 ; i < gus2ndWestEdgepointArraySize; i++ )
{
if( gps2ndWestEdgepointArray[ i ] != -1 )
{
RemoveAllTopmostsOfTypeRange( gps2ndWestEdgepointArray[ i ], FIRSTPOINTERS, FIRSTPOINTERS );
}
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink