jediacademy/code/game/g_ref.cpp

402 lines
8.7 KiB
C++
Raw Normal View History

2013-04-04 22:35:38 +00:00
// Reference tag utility functions
// leave this line at the top for all g_xxxx.cpp files...
#include "g_headers.h"
#include "g_local.h"
#include "g_functions.h"
#include "g_nav.h"
extern int delayedShutDown;
#define TAG_GENERIC_NAME "__WORLD__" //If a designer chooses this name, cut a finger off as an example to the others
typedef vector < reference_tag_t * > refTag_v;
typedef map < string, reference_tag_t * > refTag_m;
typedef struct tagOwner_s
{
refTag_v tags;
refTag_m tagMap;
} tagOwner_t;
typedef map < string, tagOwner_t * > refTagOwner_m;
refTagOwner_m refTagOwnerMap;
/*
-------------------------
TAG_ShowTags
-------------------------
*/
void TAG_ShowTags( int flags )
{
refTagOwner_m::iterator rtoi;
STL_ITERATE( rtoi, refTagOwnerMap )
{
refTag_v::iterator rti;
STL_ITERATE( rti, (((*rtoi).second)->tags) )
{
if ( (*rti)->flags & RTF_NAVGOAL )
{
if ( gi.inPVS( g_entities[0].currentOrigin, (*rti)->origin ) )
CG_DrawNode( (*rti)->origin, NODE_NAVGOAL );
}
}
}
}
/*
-------------------------
TAG_Init
-------------------------
*/
void TAG_Init( void )
{
refTagOwner_m::iterator rtoi;
//Delete all owners
for ( rtoi = refTagOwnerMap.begin(); rtoi != refTagOwnerMap.end(); rtoi++ )
{
if ( (*rtoi).second == NULL )
{
assert( 0 ); //FIXME: This is not good
continue;
}
refTag_v::iterator rti;
//Delete all tags within the owner's scope
for ( rti = ((*rtoi).second)->tags.begin(); rti != ((*rtoi).second)->tags.end(); rti++ )
{
if ( (*rti) == NULL )
{
assert( 0 ); //FIXME: Bad bad
continue;
}
//Free it
delete (*rti);
}
//Clear the containers
((*rtoi).second)->tags.clear();
((*rtoi).second)->tagMap.clear();
//Delete the owner
delete ((*rtoi).second);
}
//Clear the container
refTagOwnerMap.clear();
}
/*
-------------------------
TAG_FindOwner
-------------------------
*/
tagOwner_t *TAG_FindOwner( const char *owner )
{
refTagOwner_m::iterator rtoi;
rtoi = refTagOwnerMap.find( owner );
if ( rtoi == refTagOwnerMap.end() )
return NULL;
return (*rtoi).second;
}
/*
-------------------------
TAG_Find
-------------------------
*/
reference_tag_t *TAG_Find( const char *owner, const char *name )
{
tagOwner_t *tagOwner;
tagOwner = VALIDSTRING( owner ) ? TAG_FindOwner( owner ) : TAG_FindOwner( TAG_GENERIC_NAME );
//Not found...
if ( tagOwner == NULL )
{
tagOwner = TAG_FindOwner( TAG_GENERIC_NAME );
if ( tagOwner == NULL )
return NULL;
}
refTag_m::iterator rti;
rti = tagOwner->tagMap.find( name );
if ( rti == tagOwner->tagMap.end() )
{
//Try the generic owner instead
tagOwner = TAG_FindOwner( TAG_GENERIC_NAME );
if ( tagOwner == NULL )
return NULL;
char tempName[ MAX_REFNAME ];
Q_strncpyz( (char *) tempName, name, MAX_REFNAME );
strlwr( (char *) tempName ); //NOTENOTE: For case insensitive searches on a map
rti = tagOwner->tagMap.find( tempName );
if ( rti == tagOwner->tagMap.end() )
return NULL;
}
return (*rti).second;
}
/*
-------------------------
TAG_Add
-------------------------
*/
reference_tag_t *TAG_Add( const char *name, const char *owner, vec3_t origin, vec3_t angles, int radius, int flags )
{
reference_tag_t *tag = new reference_tag_t;
VALIDATEP( tag );
//Copy the information
VectorCopy( origin, tag->origin );
VectorCopy( angles, tag->angles );
tag->radius = radius;
tag->flags = flags;
if ( VALIDSTRING( name ) == false )
{
//gi.Error("Nameless ref_tag found at (%i %i %i)", (int)origin[0], (int)origin[1], (int)origin[2]);
gi.Printf(S_COLOR_RED"ERROR: Nameless ref_tag found at (%i %i %i)\n", (int)origin[0], (int)origin[1], (int)origin[2]);
delayedShutDown = level.time + 100;
return NULL;
}
//Copy the name
Q_strncpyz( (char *) tag->name, name, MAX_REFNAME );
strlwr( (char *) tag->name ); //NOTENOTE: For case insensitive searches on a map
//Make sure this tag's name isn't alread in use
if ( TAG_Find( owner, name ) )
{
delayedShutDown = level.time + 100;
gi.Printf(S_COLOR_RED"ERROR: Duplicate tag name \"%s\"\n", name );
return NULL;
}
//Attempt to add this to the owner's list
if ( VALIDSTRING( owner ) == false )
{
//If the owner isn't found, use the generic world name
owner = TAG_GENERIC_NAME;
}
tagOwner_t *tagOwner = TAG_FindOwner( owner );
//If the owner is valid, add this tag to it
if VALID( tagOwner )
{
tagOwner->tags.insert( tagOwner->tags.end(), tag );
tagOwner->tagMap[ (char*) &tag->name ] = tag;
}
else
{
//Create a new owner list
tagOwner_t *tagOwner = new tagOwner_t;
VALIDATEP( tagOwner );
//Insert the information
tagOwner->tags.insert( tagOwner->tags.end(), tag );
tagOwner->tagMap[ (char *) tag->name ] = tag;
//Map it
refTagOwnerMap[ owner ] = tagOwner;
}
return tag;
}
/*
-------------------------
TAG_GetOrigin
-------------------------
*/
int TAG_GetOrigin( const char *owner, const char *name, vec3_t origin )
{
reference_tag_t *tag = TAG_Find( owner, name );
if (!tag)
{
VectorClear(origin);
return false;
}
VALIDATEB( tag );
VectorCopy( tag->origin, origin );
return true;
}
/*
-------------------------
TAG_GetOrigin2
Had to get rid of that damn assert for dev
-------------------------
*/
int TAG_GetOrigin2( const char *owner, const char *name, vec3_t origin )
{
reference_tag_t *tag = TAG_Find( owner, name );
if( tag == NULL )
{
return qfalse;
}
VectorCopy( tag->origin, origin );
return qtrue;
}
/*
-------------------------
TAG_GetAngles
-------------------------
*/
int TAG_GetAngles( const char *owner, const char *name, vec3_t angles )
{
reference_tag_t *tag = TAG_Find( owner, name );
VALIDATEB( tag );
VectorCopy( tag->angles, angles );
return true;
}
/*
-------------------------
TAG_GetRadius
-------------------------
*/
int TAG_GetRadius( const char *owner, const char *name )
{
reference_tag_t *tag = TAG_Find( owner, name );
VALIDATEB( tag );
return tag->radius;
}
/*
-------------------------
TAG_GetFlags
-------------------------
*/
int TAG_GetFlags( const char *owner, const char *name )
{
reference_tag_t *tag = TAG_Find( owner, name );
VALIDATEB( tag );
return tag->flags;
}
/*
==============================================================================
Spawn functions
==============================================================================
*/
/*QUAKED ref_tag (0.5 0.5 1) (-8 -8 -8) (8 8 8)
Reference tags which can be positioned throughout the level.
These tags can later be refered to by the scripting system
so that their origins and angles can be referred to.
If you set angles on the tag, these will be retained.
If you target a ref_tag at an entity, that will set the ref_tag's
angles toward that entity.
If you set the ref_tag's ownername to the ownername of an entity,
it makes that entity is the owner of the ref_tag. This means
that the owner, and only the owner, may refer to that tag.
Tags may not have the same name as another tag with the same
owner. However, tags with different owners may have the same
name as one another. In this way, scripts can generically
refer to tags by name, and their owners will automatically
specifiy which tag is being referred to.
targetname - the name of this tag
ownername - the owner of this tag
target - use to point the tag at something for angles
*/
void ref_link ( gentity_t *ent )
{
reference_tag_t *tag;
if ( ent->target )
{
//TODO: Find the target and set our angles to that direction
gentity_t *target = G_Find( NULL, FOFS(targetname), ent->target );
vec3_t dir;
if ( target )
{
//Find the direction to the target
VectorSubtract( target->s.origin, ent->s.origin, dir );
VectorNormalize( dir );
vectoangles( dir, ent->s.angles );
//FIXME: Does pitch get flipped?
}
else
{
gi.Printf( S_COLOR_RED"ERROR: ref_tag (%s) has invalid target (%s)", ent->targetname, ent->target );
}
}
//Add the tag
tag = TAG_Add( ent->targetname, ent->ownername, ent->s.origin, ent->s.angles, 16, 0 );
//Delete immediately, cannot be refered to as an entity again
//NOTE: this means if you wanted to link them in a chain for, say, a path, you can't
G_FreeEntity( ent );
}
void SP_reference_tag ( gentity_t *ent )
{
if ( ent->target )
{
//Init cannot occur until all entities have been spawned
ent->e_ThinkFunc = thinkF_ref_link;
ent->nextthink = level.time + START_TIME_LINK_ENTS;
}
else
{
ref_link( ent );
}
}