mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-12-02 17:02:17 +00:00
1558 lines
39 KiB
C++
1558 lines
39 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 BFG Edition GPL Source Code
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|
|
|
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#pragma hdrstop
|
|
#include "precompiled.h"
|
|
|
|
|
|
#include "AAS_local.h"
|
|
#include "../Game_local.h" // for print and error
|
|
|
|
#define CACHETYPE_AREA 1
|
|
#define CACHETYPE_PORTAL 2
|
|
|
|
#define MAX_ROUTING_CACHE_MEMORY (2*1024*1024)
|
|
|
|
#define LEDGE_TRAVELTIME_PANALTY 250
|
|
|
|
/*
|
|
============
|
|
idRoutingCache::idRoutingCache
|
|
============
|
|
*/
|
|
idRoutingCache::idRoutingCache( int size )
|
|
{
|
|
areaNum = 0;
|
|
cluster = 0;
|
|
next = prev = NULL;
|
|
time_next = time_prev = NULL;
|
|
travelFlags = 0;
|
|
startTravelTime = 0;
|
|
type = 0;
|
|
this->size = size;
|
|
reachabilities = new( TAG_AAS ) byte[size];
|
|
memset( reachabilities, 0, size * sizeof( reachabilities[0] ) );
|
|
travelTimes = new( TAG_AAS ) unsigned short[size];
|
|
memset( travelTimes, 0, size * sizeof( travelTimes[0] ) );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idRoutingCache::~idRoutingCache
|
|
============
|
|
*/
|
|
idRoutingCache::~idRoutingCache()
|
|
{
|
|
delete [] reachabilities;
|
|
delete [] travelTimes;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idRoutingCache::Size
|
|
============
|
|
*/
|
|
int idRoutingCache::Size() const
|
|
{
|
|
return sizeof( idRoutingCache ) + size * sizeof( reachabilities[0] ) + size * sizeof( travelTimes[0] );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::AreaTravelTime
|
|
============
|
|
*/
|
|
unsigned short idAASLocal::AreaTravelTime( int areaNum, const idVec3& start, const idVec3& end ) const
|
|
{
|
|
float dist;
|
|
|
|
dist = ( end - start ).Length();
|
|
|
|
if( file->GetArea( areaNum ).travelFlags & TFL_CROUCH )
|
|
{
|
|
dist *= 100.0f / 100.0f;
|
|
}
|
|
else if( file->GetArea( areaNum ).travelFlags & TFL_WATER )
|
|
{
|
|
dist *= 100.0f / 150.0f;
|
|
}
|
|
else
|
|
{
|
|
dist *= 100.0f / 300.0f;
|
|
}
|
|
if( dist < 1.0f )
|
|
{
|
|
return 1;
|
|
}
|
|
return ( unsigned short ) idMath::Ftoi( dist );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::CalculateAreaTravelTimes
|
|
============
|
|
*/
|
|
void idAASLocal::CalculateAreaTravelTimes()
|
|
{
|
|
int n, i, j, numReach, numRevReach, t, maxt;
|
|
byte* bytePtr;
|
|
idReachability* reach, *rev_reach;
|
|
|
|
// get total memory for all area travel times
|
|
numAreaTravelTimes = 0;
|
|
for( n = 0; n < file->GetNumAreas(); n++ )
|
|
{
|
|
|
|
if( !( file->GetArea( n ).flags & ( AREA_REACHABLE_WALK | AREA_REACHABLE_FLY ) ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
numReach = 0;
|
|
for( reach = file->GetArea( n ).reach; reach; reach = reach->next )
|
|
{
|
|
numReach++;
|
|
}
|
|
|
|
numRevReach = 0;
|
|
for( rev_reach = file->GetArea( n ).rev_reach; rev_reach; rev_reach = rev_reach->rev_next )
|
|
{
|
|
numRevReach++;
|
|
}
|
|
numAreaTravelTimes += numReach * numRevReach;
|
|
}
|
|
|
|
areaTravelTimes = ( unsigned short* ) Mem_Alloc( numAreaTravelTimes * sizeof( unsigned short ), TAG_AAS );
|
|
bytePtr = ( byte* ) areaTravelTimes;
|
|
|
|
for( n = 0; n < file->GetNumAreas(); n++ )
|
|
{
|
|
|
|
if( !( file->GetArea( n ).flags & ( AREA_REACHABLE_WALK | AREA_REACHABLE_FLY ) ) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// for each reachability that starts in this area calculate the travel time
|
|
// towards all the reachabilities that lead towards this area
|
|
for( maxt = i = 0, reach = file->GetArea( n ).reach; reach; reach = reach->next, i++ )
|
|
{
|
|
assert( i < MAX_REACH_PER_AREA );
|
|
if( i >= MAX_REACH_PER_AREA )
|
|
{
|
|
gameLocal.Error( "i >= MAX_REACH_PER_AREA" );
|
|
}
|
|
reach->number = i;
|
|
reach->disableCount = 0;
|
|
reach->areaTravelTimes = ( unsigned short* ) bytePtr;
|
|
for( j = 0, rev_reach = file->GetArea( n ).rev_reach; rev_reach; rev_reach = rev_reach->rev_next, j++ )
|
|
{
|
|
t = AreaTravelTime( n, reach->start, rev_reach->end );
|
|
reach->areaTravelTimes[j] = t;
|
|
if( t > maxt )
|
|
{
|
|
maxt = t;
|
|
}
|
|
}
|
|
bytePtr += j * sizeof( unsigned short );
|
|
}
|
|
|
|
// if this area is a portal
|
|
if( file->GetArea( n ).cluster < 0 )
|
|
{
|
|
// set the maximum travel time through this portal
|
|
file->SetPortalMaxTravelTime( -file->GetArea( n ).cluster, maxt );
|
|
}
|
|
}
|
|
|
|
// RB: 64 bit fixes, changed unsigned int to ptrdiff_t
|
|
assert( ( ( ptrdiff_t ) bytePtr - ( ptrdiff_t ) areaTravelTimes ) <= numAreaTravelTimes * sizeof( unsigned short ) );
|
|
// RB end
|
|
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::DeleteAreaTravelTimes
|
|
============
|
|
*/
|
|
void idAASLocal::DeleteAreaTravelTimes()
|
|
{
|
|
Mem_Free( areaTravelTimes );
|
|
areaTravelTimes = NULL;
|
|
numAreaTravelTimes = 0;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::SetupRoutingCache
|
|
============
|
|
*/
|
|
void idAASLocal::SetupRoutingCache()
|
|
{
|
|
int i;
|
|
byte* bytePtr;
|
|
|
|
areaCacheIndexSize = 0;
|
|
for( i = 0; i < file->GetNumClusters(); i++ )
|
|
{
|
|
areaCacheIndexSize += file->GetCluster( i ).numReachableAreas;
|
|
}
|
|
areaCacheIndex = ( idRoutingCache*** ) Mem_ClearedAlloc( file->GetNumClusters() * sizeof( idRoutingCache** ) +
|
|
areaCacheIndexSize * sizeof( idRoutingCache* ), TAG_AAS );
|
|
bytePtr = ( ( byte* )areaCacheIndex ) + file->GetNumClusters() * sizeof( idRoutingCache** );
|
|
for( i = 0; i < file->GetNumClusters(); i++ )
|
|
{
|
|
areaCacheIndex[i] = ( idRoutingCache** ) bytePtr;
|
|
bytePtr += file->GetCluster( i ).numReachableAreas * sizeof( idRoutingCache* );
|
|
}
|
|
|
|
portalCacheIndexSize = file->GetNumAreas();
|
|
portalCacheIndex = ( idRoutingCache** ) Mem_ClearedAlloc( portalCacheIndexSize * sizeof( idRoutingCache* ), TAG_AAS );
|
|
|
|
areaUpdate = ( idRoutingUpdate* ) Mem_ClearedAlloc( file->GetNumAreas() * sizeof( idRoutingUpdate ), TAG_AAS );
|
|
portalUpdate = ( idRoutingUpdate* ) Mem_ClearedAlloc( ( file->GetNumPortals() + 1 ) * sizeof( idRoutingUpdate ), TAG_AAS );
|
|
|
|
goalAreaTravelTimes = ( unsigned short* ) Mem_ClearedAlloc( file->GetNumAreas() * sizeof( unsigned short ), TAG_AAS );
|
|
|
|
cacheListStart = cacheListEnd = NULL;
|
|
totalCacheMemory = 0;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::DeleteClusterCache
|
|
============
|
|
*/
|
|
void idAASLocal::DeleteClusterCache( int clusterNum )
|
|
{
|
|
int i;
|
|
idRoutingCache* cache;
|
|
|
|
for( i = 0; i < file->GetCluster( clusterNum ).numReachableAreas; i++ )
|
|
{
|
|
for( cache = areaCacheIndex[clusterNum][i]; cache; cache = areaCacheIndex[clusterNum][i] )
|
|
{
|
|
areaCacheIndex[clusterNum][i] = cache->next;
|
|
UnlinkCache( cache );
|
|
delete cache;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::DeletePortalCache
|
|
============
|
|
*/
|
|
void idAASLocal::DeletePortalCache()
|
|
{
|
|
int i;
|
|
idRoutingCache* cache;
|
|
|
|
for( i = 0; i < file->GetNumAreas(); i++ )
|
|
{
|
|
for( cache = portalCacheIndex[i]; cache; cache = portalCacheIndex[i] )
|
|
{
|
|
portalCacheIndex[i] = cache->next;
|
|
UnlinkCache( cache );
|
|
delete cache;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::ShutdownRoutingCache
|
|
============
|
|
*/
|
|
void idAASLocal::ShutdownRoutingCache()
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; i < file->GetNumClusters(); i++ )
|
|
{
|
|
DeleteClusterCache( i );
|
|
}
|
|
|
|
DeletePortalCache();
|
|
|
|
Mem_Free( areaCacheIndex );
|
|
areaCacheIndex = NULL;
|
|
areaCacheIndexSize = 0;
|
|
Mem_Free( portalCacheIndex );
|
|
portalCacheIndex = NULL;
|
|
portalCacheIndexSize = 0;
|
|
Mem_Free( areaUpdate );
|
|
areaUpdate = NULL;
|
|
Mem_Free( portalUpdate );
|
|
portalUpdate = NULL;
|
|
Mem_Free( goalAreaTravelTimes );
|
|
goalAreaTravelTimes = NULL;
|
|
|
|
cacheListStart = cacheListEnd = NULL;
|
|
totalCacheMemory = 0;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::SetupRouting
|
|
============
|
|
*/
|
|
bool idAASLocal::SetupRouting()
|
|
{
|
|
CalculateAreaTravelTimes();
|
|
SetupRoutingCache();
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::ShutdownRouting
|
|
============
|
|
*/
|
|
void idAASLocal::ShutdownRouting()
|
|
{
|
|
DeleteAreaTravelTimes();
|
|
ShutdownRoutingCache();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::RoutingStats
|
|
============
|
|
*/
|
|
void idAASLocal::RoutingStats() const
|
|
{
|
|
idRoutingCache* cache;
|
|
int numAreaCache, numPortalCache;
|
|
int totalAreaCacheMemory, totalPortalCacheMemory;
|
|
|
|
numAreaCache = numPortalCache = 0;
|
|
totalAreaCacheMemory = totalPortalCacheMemory = 0;
|
|
for( cache = cacheListStart; cache; cache = cache->time_next )
|
|
{
|
|
if( cache->type == CACHETYPE_AREA )
|
|
{
|
|
numAreaCache++;
|
|
totalAreaCacheMemory += sizeof( idRoutingCache ) + cache->size * ( sizeof( unsigned short ) + sizeof( byte ) );
|
|
}
|
|
else
|
|
{
|
|
numPortalCache++;
|
|
totalPortalCacheMemory += sizeof( idRoutingCache ) + cache->size * ( sizeof( unsigned short ) + sizeof( byte ) );
|
|
}
|
|
}
|
|
|
|
gameLocal.Printf( "%6d area cache (%d KB)\n", numAreaCache, totalAreaCacheMemory >> 10 );
|
|
gameLocal.Printf( "%6d portal cache (%d KB)\n", numPortalCache, totalPortalCacheMemory >> 10 );
|
|
gameLocal.Printf( "%6d total cache (%d KB)\n", numAreaCache + numPortalCache, totalCacheMemory >> 10 );
|
|
gameLocal.Printf( "%6d area travel times (%d KB)\n", numAreaTravelTimes, ( numAreaTravelTimes * sizeof( unsigned short ) ) >> 10 );
|
|
gameLocal.Printf( "%6d area cache entries (%d KB)\n", areaCacheIndexSize, ( areaCacheIndexSize * sizeof( idRoutingCache* ) ) >> 10 );
|
|
gameLocal.Printf( "%6d portal cache entries (%d KB)\n", portalCacheIndexSize, ( portalCacheIndexSize * sizeof( idRoutingCache* ) ) >> 10 );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::RemoveRoutingCacheUsingArea
|
|
============
|
|
*/
|
|
void idAASLocal::RemoveRoutingCacheUsingArea( int areaNum )
|
|
{
|
|
int clusterNum;
|
|
|
|
clusterNum = file->GetArea( areaNum ).cluster;
|
|
if( clusterNum > 0 )
|
|
{
|
|
// remove all the cache in the cluster the area is in
|
|
DeleteClusterCache( clusterNum );
|
|
}
|
|
else
|
|
{
|
|
// if this is a portal remove all cache in both the front and back cluster
|
|
DeleteClusterCache( file->GetPortal( -clusterNum ).clusters[0] );
|
|
DeleteClusterCache( file->GetPortal( -clusterNum ).clusters[1] );
|
|
}
|
|
DeletePortalCache();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::DisableArea
|
|
============
|
|
*/
|
|
void idAASLocal::DisableArea( int areaNum )
|
|
{
|
|
assert( areaNum > 0 && areaNum < file->GetNumAreas() );
|
|
|
|
if( file->GetArea( areaNum ).travelFlags & TFL_INVALID )
|
|
{
|
|
return;
|
|
}
|
|
|
|
file->SetAreaTravelFlag( areaNum, TFL_INVALID );
|
|
|
|
RemoveRoutingCacheUsingArea( areaNum );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::EnableArea
|
|
============
|
|
*/
|
|
void idAASLocal::EnableArea( int areaNum )
|
|
{
|
|
assert( areaNum > 0 && areaNum < file->GetNumAreas() );
|
|
|
|
if( !( file->GetArea( areaNum ).travelFlags & TFL_INVALID ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
file->RemoveAreaTravelFlag( areaNum, TFL_INVALID );
|
|
|
|
RemoveRoutingCacheUsingArea( areaNum );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::SetAreaState_r
|
|
============
|
|
*/
|
|
bool idAASLocal::SetAreaState_r( int nodeNum, const idBounds& bounds, const int areaContents, bool disabled )
|
|
{
|
|
int res;
|
|
const aasNode_t* node;
|
|
bool foundClusterPortal = false;
|
|
|
|
while( nodeNum != 0 )
|
|
{
|
|
if( nodeNum < 0 )
|
|
{
|
|
// if this area is a cluster portal
|
|
if( file->GetArea( -nodeNum ).contents & areaContents )
|
|
{
|
|
if( disabled )
|
|
{
|
|
DisableArea( -nodeNum );
|
|
}
|
|
else
|
|
{
|
|
EnableArea( -nodeNum );
|
|
}
|
|
foundClusterPortal |= true;
|
|
}
|
|
break;
|
|
}
|
|
node = &file->GetNode( nodeNum );
|
|
res = bounds.PlaneSide( file->GetPlane( node->planeNum ) );
|
|
if( res == PLANESIDE_BACK )
|
|
{
|
|
nodeNum = node->children[1];
|
|
}
|
|
else if( res == PLANESIDE_FRONT )
|
|
{
|
|
nodeNum = node->children[0];
|
|
}
|
|
else
|
|
{
|
|
foundClusterPortal |= SetAreaState_r( node->children[1], bounds, areaContents, disabled );
|
|
nodeNum = node->children[0];
|
|
}
|
|
}
|
|
|
|
return foundClusterPortal;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::SetAreaState
|
|
============
|
|
*/
|
|
bool idAASLocal::SetAreaState( const idBounds& bounds, const int areaContents, bool disabled )
|
|
{
|
|
idBounds expBounds;
|
|
|
|
if( !file )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
expBounds[0] = bounds[0] - file->GetSettings().boundingBoxes[0][1];
|
|
expBounds[1] = bounds[1] - file->GetSettings().boundingBoxes[0][0];
|
|
|
|
// find all areas within or touching the bounds with the given contents and disable/enable them for routing
|
|
return SetAreaState_r( 1, expBounds, areaContents, disabled );
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::GetBoundsAreas_r
|
|
============
|
|
*/
|
|
void idAASLocal::GetBoundsAreas_r( int nodeNum, const idBounds& bounds, idList<int>& areas ) const
|
|
{
|
|
int res;
|
|
const aasNode_t* node;
|
|
|
|
while( nodeNum != 0 )
|
|
{
|
|
if( nodeNum < 0 )
|
|
{
|
|
areas.Append( -nodeNum );
|
|
break;
|
|
}
|
|
node = &file->GetNode( nodeNum );
|
|
res = bounds.PlaneSide( file->GetPlane( node->planeNum ) );
|
|
if( res == PLANESIDE_BACK )
|
|
{
|
|
nodeNum = node->children[1];
|
|
}
|
|
else if( res == PLANESIDE_FRONT )
|
|
{
|
|
nodeNum = node->children[0];
|
|
}
|
|
else
|
|
{
|
|
GetBoundsAreas_r( node->children[1], bounds, areas );
|
|
nodeNum = node->children[0];
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::SetObstacleState
|
|
============
|
|
*/
|
|
void idAASLocal::SetObstacleState( const idRoutingObstacle* obstacle, bool enable )
|
|
{
|
|
int i;
|
|
const aasArea_t* area;
|
|
idReachability* reach, *rev_reach;
|
|
bool inside;
|
|
|
|
for( i = 0; i < obstacle->areas.Num(); i++ )
|
|
{
|
|
|
|
RemoveRoutingCacheUsingArea( obstacle->areas[i] );
|
|
|
|
area = &file->GetArea( obstacle->areas[i] );
|
|
|
|
for( rev_reach = area->rev_reach; rev_reach; rev_reach = rev_reach->rev_next )
|
|
{
|
|
|
|
if( rev_reach->travelType & TFL_INVALID )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
inside = false;
|
|
|
|
if( obstacle->bounds.ContainsPoint( rev_reach->end ) )
|
|
{
|
|
inside = true;
|
|
}
|
|
else
|
|
{
|
|
for( reach = area->reach; reach; reach = reach->next )
|
|
{
|
|
if( obstacle->bounds.LineIntersection( rev_reach->end, reach->start ) )
|
|
{
|
|
inside = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( inside )
|
|
{
|
|
if( enable )
|
|
{
|
|
rev_reach->disableCount--;
|
|
if( rev_reach->disableCount <= 0 )
|
|
{
|
|
rev_reach->travelType &= ~TFL_INVALID;
|
|
rev_reach->disableCount = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
rev_reach->travelType |= TFL_INVALID;
|
|
rev_reach->disableCount++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::AddObstacle
|
|
============
|
|
*/
|
|
aasHandle_t idAASLocal::AddObstacle( const idBounds& bounds )
|
|
{
|
|
idRoutingObstacle* obstacle;
|
|
|
|
if( !file )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
obstacle = new( TAG_AAS ) idRoutingObstacle;
|
|
obstacle->bounds[0] = bounds[0] - file->GetSettings().boundingBoxes[0][1];
|
|
obstacle->bounds[1] = bounds[1] - file->GetSettings().boundingBoxes[0][0];
|
|
GetBoundsAreas_r( 1, obstacle->bounds, obstacle->areas );
|
|
SetObstacleState( obstacle, true );
|
|
|
|
obstacleList.Append( obstacle );
|
|
return obstacleList.Num() - 1;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::RemoveObstacle
|
|
============
|
|
*/
|
|
void idAASLocal::RemoveObstacle( const aasHandle_t handle )
|
|
{
|
|
if( !file )
|
|
{
|
|
return;
|
|
}
|
|
if( ( handle >= 0 ) && ( handle < obstacleList.Num() ) )
|
|
{
|
|
SetObstacleState( obstacleList[handle], false );
|
|
|
|
delete obstacleList[handle];
|
|
obstacleList.RemoveIndex( handle );
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::RemoveAllObstacles
|
|
============
|
|
*/
|
|
void idAASLocal::RemoveAllObstacles()
|
|
{
|
|
int i;
|
|
|
|
if( !file )
|
|
{
|
|
return;
|
|
}
|
|
|
|
for( i = 0; i < obstacleList.Num(); i++ )
|
|
{
|
|
SetObstacleState( obstacleList[i], false );
|
|
delete obstacleList[i];
|
|
}
|
|
obstacleList.Clear();
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::LinkCache
|
|
|
|
link the cache in the cache list sorted from oldest to newest cache
|
|
============
|
|
*/
|
|
void idAASLocal::LinkCache( idRoutingCache* cache ) const
|
|
{
|
|
|
|
// if the cache is already linked
|
|
if( cache->time_next || cache->time_prev || cacheListStart == cache )
|
|
{
|
|
UnlinkCache( cache );
|
|
}
|
|
|
|
totalCacheMemory += cache->Size();
|
|
|
|
// add cache to the end of the list
|
|
cache->time_next = NULL;
|
|
cache->time_prev = cacheListEnd;
|
|
if( cacheListEnd )
|
|
{
|
|
cacheListEnd->time_next = cache;
|
|
}
|
|
cacheListEnd = cache;
|
|
if( !cacheListStart )
|
|
{
|
|
cacheListStart = cache;
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::UnlinkCache
|
|
============
|
|
*/
|
|
void idAASLocal::UnlinkCache( idRoutingCache* cache ) const
|
|
{
|
|
|
|
totalCacheMemory -= cache->Size();
|
|
|
|
// unlink the cache
|
|
if( cache->time_next )
|
|
{
|
|
cache->time_next->time_prev = cache->time_prev;
|
|
}
|
|
else
|
|
{
|
|
cacheListEnd = cache->time_prev;
|
|
}
|
|
if( cache->time_prev )
|
|
{
|
|
cache->time_prev->time_next = cache->time_next;
|
|
}
|
|
else
|
|
{
|
|
cacheListStart = cache->time_next;
|
|
}
|
|
cache->time_next = cache->time_prev = NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::DeleteOldestCache
|
|
============
|
|
*/
|
|
void idAASLocal::DeleteOldestCache() const
|
|
{
|
|
idRoutingCache* cache;
|
|
|
|
assert( cacheListStart );
|
|
|
|
// unlink the oldest cache
|
|
cache = cacheListStart;
|
|
UnlinkCache( cache );
|
|
|
|
// unlink the oldest cache from the area or portal cache index
|
|
if( cache->next )
|
|
{
|
|
cache->next->prev = cache->prev;
|
|
}
|
|
if( cache->prev )
|
|
{
|
|
cache->prev->next = cache->next;
|
|
}
|
|
else if( cache->type == CACHETYPE_AREA )
|
|
{
|
|
areaCacheIndex[cache->cluster][ClusterAreaNum( cache->cluster, cache->areaNum )] = cache->next;
|
|
}
|
|
else if( cache->type == CACHETYPE_PORTAL )
|
|
{
|
|
portalCacheIndex[cache->areaNum] = cache->next;
|
|
}
|
|
|
|
delete cache;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::GetAreaReachability
|
|
============
|
|
*/
|
|
idReachability* idAASLocal::GetAreaReachability( int areaNum, int reachabilityNum ) const
|
|
{
|
|
idReachability* reach;
|
|
|
|
for( reach = file->GetArea( areaNum ).reach; reach; reach = reach->next )
|
|
{
|
|
if( --reachabilityNum < 0 )
|
|
{
|
|
return reach;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::ClusterAreaNum
|
|
============
|
|
*/
|
|
ID_INLINE int idAASLocal::ClusterAreaNum( int clusterNum, int areaNum ) const
|
|
{
|
|
int side, areaCluster;
|
|
|
|
areaCluster = file->GetArea( areaNum ).cluster;
|
|
if( areaCluster > 0 )
|
|
{
|
|
return file->GetArea( areaNum ).clusterAreaNum;
|
|
}
|
|
else
|
|
{
|
|
side = file->GetPortal( -areaCluster ).clusters[0] != clusterNum;
|
|
return file->GetPortal( -areaCluster ).clusterAreaNum[side];
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::UpdateAreaRoutingCache
|
|
============
|
|
*/
|
|
void idAASLocal::UpdateAreaRoutingCache( idRoutingCache* areaCache ) const
|
|
{
|
|
int i, nextAreaNum, cluster, badTravelFlags, clusterAreaNum, numReachableAreas;
|
|
unsigned short t, startAreaTravelTimes[MAX_REACH_PER_AREA];
|
|
idRoutingUpdate* updateListStart, *updateListEnd, *curUpdate, *nextUpdate;
|
|
idReachability* reach;
|
|
const aasArea_t* nextArea;
|
|
|
|
// number of reachability areas within this cluster
|
|
numReachableAreas = file->GetCluster( areaCache->cluster ).numReachableAreas;
|
|
|
|
// number of the start area within the cluster
|
|
clusterAreaNum = ClusterAreaNum( areaCache->cluster, areaCache->areaNum );
|
|
if( clusterAreaNum >= numReachableAreas )
|
|
{
|
|
return;
|
|
}
|
|
|
|
areaCache->travelTimes[clusterAreaNum] = areaCache->startTravelTime;
|
|
badTravelFlags = ~areaCache->travelFlags;
|
|
memset( startAreaTravelTimes, 0, sizeof( startAreaTravelTimes ) );
|
|
|
|
// initialize first update
|
|
curUpdate = &areaUpdate[clusterAreaNum];
|
|
curUpdate->areaNum = areaCache->areaNum;
|
|
curUpdate->areaTravelTimes = startAreaTravelTimes;
|
|
curUpdate->tmpTravelTime = areaCache->startTravelTime;
|
|
curUpdate->next = NULL;
|
|
curUpdate->prev = NULL;
|
|
updateListStart = curUpdate;
|
|
updateListEnd = curUpdate;
|
|
|
|
// while there are updates in the list
|
|
while( updateListStart )
|
|
{
|
|
|
|
curUpdate = updateListStart;
|
|
if( curUpdate->next )
|
|
{
|
|
curUpdate->next->prev = NULL;
|
|
}
|
|
else
|
|
{
|
|
updateListEnd = NULL;
|
|
}
|
|
updateListStart = curUpdate->next;
|
|
|
|
curUpdate->isInList = false;
|
|
|
|
for( i = 0, reach = file->GetArea( curUpdate->areaNum ).rev_reach; reach; reach = reach->rev_next, i++ )
|
|
{
|
|
|
|
// if the reachability uses an undesired travel type
|
|
if( reach->travelType & badTravelFlags )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// next area the reversed reachability leads to
|
|
nextAreaNum = reach->fromAreaNum;
|
|
nextArea = &file->GetArea( nextAreaNum );
|
|
|
|
// if traveling through the next area requires an undesired travel flag
|
|
if( nextArea->travelFlags & badTravelFlags )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// get the cluster number of the area
|
|
cluster = nextArea->cluster;
|
|
// don't leave the cluster, however do flood into cluster portals
|
|
if( cluster > 0 && cluster != areaCache->cluster )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// get the number of the area in the cluster
|
|
clusterAreaNum = ClusterAreaNum( areaCache->cluster, nextAreaNum );
|
|
if( clusterAreaNum >= numReachableAreas )
|
|
{
|
|
continue; // should never happen
|
|
}
|
|
|
|
assert( clusterAreaNum < areaCache->size );
|
|
|
|
// time already travelled plus the traveltime through the current area
|
|
// plus the travel time of the reachability towards the next area
|
|
t = curUpdate->tmpTravelTime + curUpdate->areaTravelTimes[i] + reach->travelTime;
|
|
|
|
if( !areaCache->travelTimes[clusterAreaNum] || t < areaCache->travelTimes[clusterAreaNum] )
|
|
{
|
|
|
|
areaCache->travelTimes[clusterAreaNum] = t;
|
|
areaCache->reachabilities[clusterAreaNum] = reach->number; // reversed reachability used to get into this area
|
|
nextUpdate = &areaUpdate[clusterAreaNum];
|
|
nextUpdate->areaNum = nextAreaNum;
|
|
nextUpdate->tmpTravelTime = t;
|
|
nextUpdate->areaTravelTimes = reach->areaTravelTimes;
|
|
|
|
// if we are not allowed to fly
|
|
if( badTravelFlags & TFL_FLY )
|
|
{
|
|
// avoid areas near ledges
|
|
if( file->GetArea( nextAreaNum ).flags & AREA_LEDGE )
|
|
{
|
|
nextUpdate->tmpTravelTime += LEDGE_TRAVELTIME_PANALTY;
|
|
}
|
|
}
|
|
|
|
if( !nextUpdate->isInList )
|
|
{
|
|
nextUpdate->next = NULL;
|
|
nextUpdate->prev = updateListEnd;
|
|
if( updateListEnd )
|
|
{
|
|
updateListEnd->next = nextUpdate;
|
|
}
|
|
else
|
|
{
|
|
updateListStart = nextUpdate;
|
|
}
|
|
updateListEnd = nextUpdate;
|
|
nextUpdate->isInList = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::GetAreaRoutingCache
|
|
============
|
|
*/
|
|
idRoutingCache* idAASLocal::GetAreaRoutingCache( int clusterNum, int areaNum, int travelFlags ) const
|
|
{
|
|
int clusterAreaNum;
|
|
idRoutingCache* cache, *clusterCache;
|
|
|
|
// number of the area in the cluster
|
|
clusterAreaNum = ClusterAreaNum( clusterNum, areaNum );
|
|
// pointer to the cache for the area in the cluster
|
|
clusterCache = areaCacheIndex[clusterNum][clusterAreaNum];
|
|
// check if cache without undesired travel flags already exists
|
|
for( cache = clusterCache; cache; cache = cache->next )
|
|
{
|
|
if( cache->travelFlags == travelFlags )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
// if no cache found
|
|
if( !cache )
|
|
{
|
|
cache = new( TAG_AAS ) idRoutingCache( file->GetCluster( clusterNum ).numReachableAreas );
|
|
cache->type = CACHETYPE_AREA;
|
|
cache->cluster = clusterNum;
|
|
cache->areaNum = areaNum;
|
|
cache->startTravelTime = 1;
|
|
cache->travelFlags = travelFlags;
|
|
cache->prev = NULL;
|
|
cache->next = clusterCache;
|
|
if( clusterCache )
|
|
{
|
|
clusterCache->prev = cache;
|
|
}
|
|
areaCacheIndex[clusterNum][clusterAreaNum] = cache;
|
|
UpdateAreaRoutingCache( cache );
|
|
}
|
|
LinkCache( cache );
|
|
return cache;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::UpdatePortalRoutingCache
|
|
============
|
|
*/
|
|
void idAASLocal::UpdatePortalRoutingCache( idRoutingCache* portalCache ) const
|
|
{
|
|
int i, portalNum, clusterAreaNum;
|
|
unsigned short t;
|
|
const aasPortal_t* portal;
|
|
const aasCluster_t* cluster;
|
|
idRoutingCache* cache;
|
|
idRoutingUpdate* updateListStart, *updateListEnd, *curUpdate, *nextUpdate;
|
|
|
|
curUpdate = &portalUpdate[ file->GetNumPortals() ];
|
|
curUpdate->cluster = portalCache->cluster;
|
|
curUpdate->areaNum = portalCache->areaNum;
|
|
curUpdate->tmpTravelTime = portalCache->startTravelTime;
|
|
|
|
//put the area to start with in the current read list
|
|
curUpdate->next = NULL;
|
|
curUpdate->prev = NULL;
|
|
updateListStart = curUpdate;
|
|
updateListEnd = curUpdate;
|
|
|
|
// while there are updates in the current list
|
|
while( updateListStart )
|
|
{
|
|
|
|
curUpdate = updateListStart;
|
|
// remove the current update from the list
|
|
if( curUpdate->next )
|
|
{
|
|
curUpdate->next->prev = NULL;
|
|
}
|
|
else
|
|
{
|
|
updateListEnd = NULL;
|
|
}
|
|
updateListStart = curUpdate->next;
|
|
// current update is removed from the list
|
|
curUpdate->isInList = false;
|
|
|
|
cluster = &file->GetCluster( curUpdate->cluster );
|
|
cache = GetAreaRoutingCache( curUpdate->cluster, curUpdate->areaNum, portalCache->travelFlags );
|
|
|
|
// take all portals of the cluster
|
|
for( i = 0; i < cluster->numPortals; i++ )
|
|
{
|
|
portalNum = file->GetPortalIndex( cluster->firstPortal + i );
|
|
assert( portalNum < portalCache->size );
|
|
portal = &file->GetPortal( portalNum );
|
|
|
|
clusterAreaNum = ClusterAreaNum( curUpdate->cluster, portal->areaNum );
|
|
if( clusterAreaNum >= cluster->numReachableAreas )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
t = cache->travelTimes[clusterAreaNum];
|
|
if( t == 0 )
|
|
{
|
|
continue;
|
|
}
|
|
t += curUpdate->tmpTravelTime;
|
|
|
|
if( !portalCache->travelTimes[portalNum] || t < portalCache->travelTimes[portalNum] )
|
|
{
|
|
|
|
portalCache->travelTimes[portalNum] = t;
|
|
portalCache->reachabilities[portalNum] = cache->reachabilities[clusterAreaNum];
|
|
nextUpdate = &portalUpdate[portalNum];
|
|
if( portal->clusters[0] == curUpdate->cluster )
|
|
{
|
|
nextUpdate->cluster = portal->clusters[1];
|
|
}
|
|
else
|
|
{
|
|
nextUpdate->cluster = portal->clusters[0];
|
|
}
|
|
nextUpdate->areaNum = portal->areaNum;
|
|
// add travel time through the actual portal area for the next update
|
|
nextUpdate->tmpTravelTime = t + portal->maxAreaTravelTime;
|
|
|
|
if( !nextUpdate->isInList )
|
|
{
|
|
|
|
nextUpdate->next = NULL;
|
|
nextUpdate->prev = updateListEnd;
|
|
if( updateListEnd )
|
|
{
|
|
updateListEnd->next = nextUpdate;
|
|
}
|
|
else
|
|
{
|
|
updateListStart = nextUpdate;
|
|
}
|
|
updateListEnd = nextUpdate;
|
|
nextUpdate->isInList = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::GetPortalRoutingCache
|
|
============
|
|
*/
|
|
idRoutingCache* idAASLocal::GetPortalRoutingCache( int clusterNum, int areaNum, int travelFlags ) const
|
|
{
|
|
idRoutingCache* cache;
|
|
|
|
// check if cache without undesired travel flags already exists
|
|
for( cache = portalCacheIndex[areaNum]; cache; cache = cache->next )
|
|
{
|
|
if( cache->travelFlags == travelFlags )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
// if no cache found
|
|
if( !cache )
|
|
{
|
|
cache = new( TAG_AAS ) idRoutingCache( file->GetNumPortals() );
|
|
cache->type = CACHETYPE_PORTAL;
|
|
cache->cluster = clusterNum;
|
|
cache->areaNum = areaNum;
|
|
cache->startTravelTime = 1;
|
|
cache->travelFlags = travelFlags;
|
|
cache->prev = NULL;
|
|
cache->next = portalCacheIndex[areaNum];
|
|
if( portalCacheIndex[areaNum] )
|
|
{
|
|
portalCacheIndex[areaNum]->prev = cache;
|
|
}
|
|
portalCacheIndex[areaNum] = cache;
|
|
UpdatePortalRoutingCache( cache );
|
|
}
|
|
LinkCache( cache );
|
|
return cache;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::RouteToGoalArea
|
|
============
|
|
*/
|
|
bool idAASLocal::RouteToGoalArea( int areaNum, const idVec3 origin, int goalAreaNum, int travelFlags, int& travelTime, idReachability** reach ) const
|
|
{
|
|
int clusterNum, goalClusterNum, portalNum, i, clusterAreaNum;
|
|
unsigned short int t, bestTime;
|
|
const aasPortal_t* portal;
|
|
const aasCluster_t* cluster;
|
|
idRoutingCache* areaCache, *portalCache, *clusterCache;
|
|
idReachability* bestReach, *r, *nextr;
|
|
|
|
travelTime = 0;
|
|
*reach = NULL;
|
|
|
|
if( !file )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if( areaNum == goalAreaNum )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if( areaNum <= 0 || areaNum >= file->GetNumAreas() )
|
|
{
|
|
gameLocal.Printf( "RouteToGoalArea: areaNum %d out of range\n", areaNum );
|
|
return false;
|
|
}
|
|
if( goalAreaNum <= 0 || goalAreaNum >= file->GetNumAreas() )
|
|
{
|
|
gameLocal.Printf( "RouteToGoalArea: goalAreaNum %d out of range\n", goalAreaNum );
|
|
return false;
|
|
}
|
|
|
|
while( totalCacheMemory > MAX_ROUTING_CACHE_MEMORY )
|
|
{
|
|
DeleteOldestCache();
|
|
}
|
|
|
|
clusterNum = file->GetArea( areaNum ).cluster;
|
|
goalClusterNum = file->GetArea( goalAreaNum ).cluster;
|
|
|
|
// if the source area is a cluster portal, read directly from the portal cache
|
|
if( clusterNum < 0 )
|
|
{
|
|
// if the goal area is a portal
|
|
if( goalClusterNum < 0 )
|
|
{
|
|
// just assume the goal area is part of the front cluster
|
|
portal = &file->GetPortal( -goalClusterNum );
|
|
goalClusterNum = portal->clusters[0];
|
|
}
|
|
// get the portal routing cache
|
|
portalCache = GetPortalRoutingCache( goalClusterNum, goalAreaNum, travelFlags );
|
|
*reach = GetAreaReachability( areaNum, portalCache->reachabilities[-clusterNum] );
|
|
travelTime = portalCache->travelTimes[-clusterNum] + AreaTravelTime( areaNum, origin, ( *reach )->start );
|
|
return true;
|
|
}
|
|
|
|
bestTime = 0;
|
|
bestReach = NULL;
|
|
|
|
// check if the goal area is a portal of the source area cluster
|
|
if( goalClusterNum < 0 )
|
|
{
|
|
portal = &file->GetPortal( -goalClusterNum );
|
|
if( portal->clusters[0] == clusterNum || portal->clusters[1] == clusterNum )
|
|
{
|
|
goalClusterNum = clusterNum;
|
|
}
|
|
}
|
|
|
|
// if both areas are in the same cluster
|
|
if( clusterNum > 0 && goalClusterNum > 0 && clusterNum == goalClusterNum )
|
|
{
|
|
clusterCache = GetAreaRoutingCache( clusterNum, goalAreaNum, travelFlags );
|
|
clusterAreaNum = ClusterAreaNum( clusterNum, areaNum );
|
|
if( clusterCache->travelTimes[clusterAreaNum] )
|
|
{
|
|
bestReach = GetAreaReachability( areaNum, clusterCache->reachabilities[clusterAreaNum] );
|
|
bestTime = clusterCache->travelTimes[clusterAreaNum] + AreaTravelTime( areaNum, origin, bestReach->start );
|
|
}
|
|
else
|
|
{
|
|
clusterCache = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
clusterCache = NULL;
|
|
}
|
|
|
|
clusterNum = file->GetArea( areaNum ).cluster;
|
|
goalClusterNum = file->GetArea( goalAreaNum ).cluster;
|
|
|
|
// if the goal area is a portal
|
|
if( goalClusterNum < 0 )
|
|
{
|
|
// just assume the goal area is part of the front cluster
|
|
portal = &file->GetPortal( -goalClusterNum );
|
|
goalClusterNum = portal->clusters[0];
|
|
}
|
|
// get the portal routing cache
|
|
portalCache = GetPortalRoutingCache( goalClusterNum, goalAreaNum, travelFlags );
|
|
|
|
// the cluster the area is in
|
|
cluster = &file->GetCluster( clusterNum );
|
|
// current area inside the current cluster
|
|
clusterAreaNum = ClusterAreaNum( clusterNum, areaNum );
|
|
// if the area is not a reachable area
|
|
if( clusterAreaNum >= cluster->numReachableAreas )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// find the portal of the source area cluster leading towards the goal area
|
|
for( i = 0; i < cluster->numPortals; i++ )
|
|
{
|
|
portalNum = file->GetPortalIndex( cluster->firstPortal + i );
|
|
|
|
// if the goal area isn't reachable from the portal
|
|
if( !portalCache->travelTimes[portalNum] )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
portal = &file->GetPortal( portalNum );
|
|
// get the cache of the portal area
|
|
areaCache = GetAreaRoutingCache( clusterNum, portal->areaNum, travelFlags );
|
|
// if the portal is not reachable from this area
|
|
if( !areaCache->travelTimes[clusterAreaNum] )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
r = GetAreaReachability( areaNum, areaCache->reachabilities[clusterAreaNum] );
|
|
|
|
if( clusterCache )
|
|
{
|
|
// if the next reachability from the portal leads back into the cluster
|
|
nextr = GetAreaReachability( portal->areaNum, portalCache->reachabilities[portalNum] );
|
|
if( file->GetArea( nextr->toAreaNum ).cluster < 0 || file->GetArea( nextr->toAreaNum ).cluster == clusterNum )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
// the total travel time is the travel time from the portal area to the goal area
|
|
// plus the travel time from the source area towards the portal area
|
|
t = portalCache->travelTimes[portalNum] + areaCache->travelTimes[clusterAreaNum];
|
|
// NOTE: Should add the exact travel time through the portal area.
|
|
// However we add the largest travel time through the portal area.
|
|
// We cannot directly calculate the exact travel time through the portal area
|
|
// because the reachability used to travel into the portal area is not known.
|
|
t += portal->maxAreaTravelTime;
|
|
|
|
// if the time is better than the one already found
|
|
if( !bestTime || t < bestTime )
|
|
{
|
|
bestReach = r;
|
|
bestTime = t;
|
|
}
|
|
}
|
|
|
|
if( !bestReach )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
*reach = bestReach;
|
|
travelTime = bestTime;
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::TravelTimeToGoalArea
|
|
============
|
|
*/
|
|
int idAASLocal::TravelTimeToGoalArea( int areaNum, const idVec3& origin, int goalAreaNum, int travelFlags ) const
|
|
{
|
|
int travelTime;
|
|
idReachability* reach;
|
|
|
|
if( !file )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if( !RouteToGoalArea( areaNum, origin, goalAreaNum, travelFlags, travelTime, &reach ) )
|
|
{
|
|
return 0;
|
|
}
|
|
return travelTime;
|
|
}
|
|
|
|
/*
|
|
============
|
|
idAASLocal::FindNearestGoal
|
|
============
|
|
*/
|
|
bool idAASLocal::FindNearestGoal( aasGoal_t& goal, int areaNum, const idVec3 origin, const idVec3& target, int travelFlags, aasObstacle_t* obstacles, int numObstacles, idAASCallback& callback ) const
|
|
{
|
|
int i, j, k, badTravelFlags, nextAreaNum, bestAreaNum;
|
|
unsigned short t, bestTravelTime;
|
|
idRoutingUpdate* updateListStart, *updateListEnd, *curUpdate, *nextUpdate;
|
|
idReachability* reach;
|
|
const aasArea_t* nextArea;
|
|
idVec3 v1, v2, p;
|
|
float targetDist, dist;
|
|
|
|
if( file == NULL || areaNum <= 0 )
|
|
{
|
|
goal.areaNum = areaNum;
|
|
goal.origin = origin;
|
|
return false;
|
|
}
|
|
|
|
// if the first area is valid goal, just return the origin
|
|
if( callback.TestArea( this, areaNum ) )
|
|
{
|
|
goal.areaNum = areaNum;
|
|
goal.origin = origin;
|
|
return true;
|
|
}
|
|
|
|
// setup obstacles
|
|
for( k = 0; k < numObstacles; k++ )
|
|
{
|
|
obstacles[k].expAbsBounds[0] = obstacles[k].absBounds[0] - file->GetSettings().boundingBoxes[0][1];
|
|
obstacles[k].expAbsBounds[1] = obstacles[k].absBounds[1] - file->GetSettings().boundingBoxes[0][0];
|
|
}
|
|
|
|
badTravelFlags = ~travelFlags;
|
|
SIMDProcessor->Memset( goalAreaTravelTimes, 0, file->GetNumAreas() * sizeof( unsigned short ) );
|
|
|
|
targetDist = ( target - origin ).Length();
|
|
|
|
// initialize first update
|
|
curUpdate = &areaUpdate[areaNum];
|
|
curUpdate->areaNum = areaNum;
|
|
curUpdate->tmpTravelTime = 0;
|
|
curUpdate->start = origin;
|
|
curUpdate->next = NULL;
|
|
curUpdate->prev = NULL;
|
|
updateListStart = curUpdate;
|
|
updateListEnd = curUpdate;
|
|
|
|
bestTravelTime = 0;
|
|
bestAreaNum = 0;
|
|
|
|
// while there are updates in the list
|
|
while( updateListStart )
|
|
{
|
|
|
|
curUpdate = updateListStart;
|
|
if( curUpdate->next )
|
|
{
|
|
curUpdate->next->prev = NULL;
|
|
}
|
|
else
|
|
{
|
|
updateListEnd = NULL;
|
|
}
|
|
updateListStart = curUpdate->next;
|
|
|
|
curUpdate->isInList = false;
|
|
|
|
// if we already found a closer location
|
|
if( bestTravelTime && curUpdate->tmpTravelTime >= bestTravelTime )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for( i = 0, reach = file->GetArea( curUpdate->areaNum ).reach; reach; reach = reach->next, i++ )
|
|
{
|
|
|
|
// if the reachability uses an undesired travel type
|
|
if( reach->travelType & badTravelFlags )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// next area the reversed reachability leads to
|
|
nextAreaNum = reach->toAreaNum;
|
|
nextArea = &file->GetArea( nextAreaNum );
|
|
|
|
// if traveling through the next area requires an undesired travel flag
|
|
if( nextArea->travelFlags & badTravelFlags )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
t = curUpdate->tmpTravelTime +
|
|
AreaTravelTime( curUpdate->areaNum, curUpdate->start, reach->start ) +
|
|
reach->travelTime;
|
|
|
|
// project target origin onto movement vector through the area
|
|
v1 = reach->end - curUpdate->start;
|
|
v1.Normalize();
|
|
v2 = target - curUpdate->start;
|
|
p = curUpdate->start + ( v2 * v1 ) * v1;
|
|
|
|
// get the point on the path closest to the target
|
|
for( j = 0; j < 3; j++ )
|
|
{
|
|
if( ( p[j] > curUpdate->start[j] + 0.1f && p[j] > reach->end[j] + 0.1f ) ||
|
|
( p[j] < curUpdate->start[j] - 0.1f && p[j] < reach->end[j] - 0.1f ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if( j >= 3 )
|
|
{
|
|
dist = ( target - p ).Length();
|
|
}
|
|
else
|
|
{
|
|
dist = ( target - reach->end ).Length();
|
|
}
|
|
|
|
// avoid moving closer to the target
|
|
if( dist < targetDist )
|
|
{
|
|
t += ( targetDist - dist ) * 10;
|
|
}
|
|
|
|
// if we already found a closer location
|
|
if( bestTravelTime && t >= bestTravelTime )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// if this is not the best path towards the next area
|
|
if( goalAreaTravelTimes[nextAreaNum] && t >= goalAreaTravelTimes[nextAreaNum] )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// path may not go through any obstacles
|
|
for( k = 0; k < numObstacles; k++ )
|
|
{
|
|
// if the movement vector intersects the expanded obstacle bounds
|
|
if( obstacles[k].expAbsBounds.LineIntersection( curUpdate->start, reach->end ) )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if( k < numObstacles )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
goalAreaTravelTimes[nextAreaNum] = t;
|
|
nextUpdate = &areaUpdate[nextAreaNum];
|
|
nextUpdate->areaNum = nextAreaNum;
|
|
nextUpdate->tmpTravelTime = t;
|
|
nextUpdate->start = reach->end;
|
|
|
|
// if we are not allowed to fly
|
|
if( badTravelFlags & TFL_FLY )
|
|
{
|
|
// avoid areas near ledges
|
|
if( file->GetArea( nextAreaNum ).flags & AREA_LEDGE )
|
|
{
|
|
nextUpdate->tmpTravelTime += LEDGE_TRAVELTIME_PANALTY;
|
|
}
|
|
}
|
|
|
|
if( !nextUpdate->isInList )
|
|
{
|
|
nextUpdate->next = NULL;
|
|
nextUpdate->prev = updateListEnd;
|
|
if( updateListEnd )
|
|
{
|
|
updateListEnd->next = nextUpdate;
|
|
}
|
|
else
|
|
{
|
|
updateListStart = nextUpdate;
|
|
}
|
|
updateListEnd = nextUpdate;
|
|
nextUpdate->isInList = true;
|
|
}
|
|
|
|
// don't put goal near a ledge
|
|
if( !( nextArea->flags & AREA_LEDGE ) )
|
|
{
|
|
|
|
// add travel time through the area
|
|
t += AreaTravelTime( reach->toAreaNum, reach->end, nextArea->center );
|
|
|
|
if( !bestTravelTime || t < bestTravelTime )
|
|
{
|
|
// if the area is not visible to the target
|
|
if( callback.TestArea( this, reach->toAreaNum ) )
|
|
{
|
|
bestTravelTime = t;
|
|
bestAreaNum = reach->toAreaNum;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( bestAreaNum )
|
|
{
|
|
goal.areaNum = bestAreaNum;
|
|
goal.origin = AreaCenter( bestAreaNum );
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|