2005-03-09 01:31:56 +00:00
//======== (C) Copyright 2002 Charles G. Cleveland All rights reserved. =========
//
// The copyright to the contents herein is the property of Charles G. Cleveland.
// The contents may be used and/or copied only with the written permission of
// Charles G. Cleveland, or in accordance with the terms and conditions stipulated in
// the agreement/contract under which the contents have been supplied.
//
// Purpose:
//
// $Workfile: AvHSharedUtil.cpp $
// $Date: 2002/11/12 22:39:25 $
//
//-------------------------------------------------------------------------------
// $Log: AvHSharedUtil.cpp,v $
// Revision 1.33 2002/11/12 22:39:25 Flayra
// - Logging changes for Psychostats compatibility
//
// Revision 1.32 2002/10/24 21:42:32 Flayra
// - Don't give waypoint to selected troops when scanning
//
// Revision 1.31 2002/10/19 21:19:49 Flayra
// - Debugging info for linux
//
// Revision 1.30 2002/10/16 01:07:26 Flayra
// - Added official sizes that HL supports (ugh)
// - Added utility function for drawing range of ghost building, but it's unused
//
// Revision 1.29 2002/10/03 19:07:40 Flayra
// - Hives can never be blocked by func_resources
//
// Revision 1.28 2002/09/25 20:50:58 Flayra
// - Allow small items to be built on entities (health can be dropped right on players)
//
// Revision 1.27 2002/09/23 22:31:40 Flayra
// - Updated team 0 colors so dictation can be read in readyroom
// - Draw range for prototype lab, observatory and sensory chamber
// - Alien building rings
// - Don't allow non-resource buildings built too close to func_resources
// - Added heavy armor and jetpacks
//
// Revision 1.26 2002/09/09 20:06:43 Flayra
// - New observatory artwork
//
// Revision 1.25 2002/08/31 18:01:03 Flayra
// - Work at VALVe
//
// Revision 1.24 2002/08/16 02:47:06 Flayra
// - Fixed bug where not all the entities were iterated through
// - Support for ring-drawing (but not for all entities)
//
// Revision 1.23 2002/08/09 00:51:11 Flayra
// - Cleaned up useless special casing of tracetangible, fixed some problems where buildings could be built on players
//
// Revision 1.22 2002/08/02 21:50:05 Flayra
// - Made more general, by detecting all entities, not just players
//
// Revision 1.21 2002/07/24 18:45:43 Flayra
// - Linux and scripting changes
//
// Revision 1.20 2002/07/23 17:26:49 Flayra
// - Siege don't require a nearby turret factory, only add built buildings for range detection, build problems on client (point contents failing on rough surfaces)
//
// Revision 1.19 2002/07/08 17:17:44 Flayra
// - Reworked colors, moved functions into server util
//
// Revision 1.18 2002/07/01 21:46:39 Flayra
// - Added support for generic building ranges, fixed morphing problems
//
// Revision 1.17 2002/06/25 18:18:00 Flayra
// - Renamed buildings, better is-area-free detection
//
// Revision 1.16 2002/06/03 16:58:13 Flayra
// - Renamed weapons factory and armory, hive is now a buildable
//
// Revision 1.15 2002/05/28 18:13:43 Flayra
// - Changed "entity blocked by whatever" message to be logged for PR/screenshot purposes
//
// Revision 1.14 2002/05/23 02:33:20 Flayra
// - Post-crash checkin. Restored @Backup from around 4/16. Contains changes for last four weeks of development.
//
//===============================================================================
# ifdef AVH_SERVER
2005-04-01 03:04:57 +00:00
# include "dlls/extdll.h"
# include "dlls/util.h"
2005-03-09 01:31:56 +00:00
# include "types.h"
# endif
# ifdef AVH_CLIENT
# include "cl_dll/hud.h"
# include "cl_dll/cl_util.h"
# endif
# include "mod/AvHSharedUtil.h"
# include "mod/AvHSelectionHelper.h"
# include "mod/AvHConstants.h"
# ifdef AVH_SERVER
# include "mod/AvHPlayer.h"
# include "mod/AvHServerUtil.h"
# include "mod/AvHEntities.h"
# include "mod/AvHWeldable.h"
# include "mod/AvHGamerules.h"
# include "dlls/cfuncwall.h"
//#include "common/com_model.h"
//int NS_PointContents(const hull_t *hull, int num, float p[3]);
# endif
# include "pm_shared/pm_defs.h"
# include "pm_shared/pm_shared.h"
# ifdef AVH_CLIENT
# include "pm_shared/pm_debug.h"
//extern DebugPointListType gTriDebugLocations;
//extern DebugPointListType gSquareDebugLocations;
# endif
# include "util/MathUtil.h"
# include "util/STLUtil.h"
# include "common/vector_util.h"
# ifdef AVH_CLIENT
# include "cl_dll/eventscripts.h"
# include "common/r_efx.h"
# include "common/event_api.h"
# include "common/event_args.h"
# include "cl_dll/in_defs.h"
# endif
# include "common/com_model.h"
# include "mod/AvHSpecials.h"
# include "mod/AvHMarineEquipmentConstants.h"
# include "dlls/turretconst.h"
# include "mod/AvHMarineWeaponConstants.h"
# include "mod/AvHHulls.h"
# include "mod/AvHAlienEquipmentConstants.h"
# include "mod/CollisionUtil.h"
/*
bool NS_BoxesOverlap ( float origin1 [ 3 ] , float size1 [ 3 ] , float origin2 [ 3 ] , float size2 [ 3 ] ) ;
int NS_PointContents ( const hull_t * hull , int num , float p [ 3 ] ) ;
int NS_BoxContents ( const hull_t * hull , int num , float mins [ 3 ] , float maxs [ 3 ] ) ;
int NS_GetValveHull ( int inHull ) ;
void NS_TraceLine ( const hull_t * hull , float srcPoint [ 3 ] , float dstPoint [ 3 ] , trace_t * trace ) ;
*/
# include <time.h>
extern playermove_t * pmove ;
vec3_t AvHSHUGetRealLocation ( const vec3_t & inLocation , const vec3_t & inMinBox , const vec3_t & inMaxBox ) ;
vec3_t gPMDebugPoint ;
int kTeamColors [ iNumberOfTeamColors ] [ 3 ] =
{
{ 255 , 255 , 255 } , // White (default)
// { 125, 165, 210 }, // Blue (marine 1)
{ 0 , 153 , 255 } , // Blue (marine 1)
// { 255, 170, 0 }, // HL orange (alien 1)
{ 255 , 160 , 0 } , // HL orange (alien 1)
{ 145 , 215 , 140 } , // Green (marine 2)
{ 200 , 90 , 70 } , // Red (alien 2)
{ 255 , 255 , 255 } // White (spectator)
} ;
float kFTeamColors [ iNumberOfTeamColors ] [ 3 ] =
{
{ kTeamColors [ 0 ] [ 0 ] / 255.0f , kTeamColors [ 0 ] [ 1 ] / 255.0f , kTeamColors [ 0 ] [ 2 ] / 255.0f } ,
{ kTeamColors [ 1 ] [ 0 ] / 255.0f , kTeamColors [ 1 ] [ 1 ] / 255.0f , kTeamColors [ 1 ] [ 2 ] / 255.0f } ,
{ kTeamColors [ 2 ] [ 0 ] / 255.0f , kTeamColors [ 2 ] [ 1 ] / 255.0f , kTeamColors [ 2 ] [ 2 ] / 255.0f } ,
{ kTeamColors [ 3 ] [ 0 ] / 255.0f , kTeamColors [ 3 ] [ 1 ] / 255.0f , kTeamColors [ 3 ] [ 2 ] / 255.0f } ,
{ kTeamColors [ 4 ] [ 0 ] / 255.0f , kTeamColors [ 4 ] [ 1 ] / 255.0f , kTeamColors [ 4 ] [ 2 ] / 255.0f } ,
{ kTeamColors [ 5 ] [ 0 ] / 255.0f , kTeamColors [ 5 ] [ 1 ] / 255.0f , kTeamColors [ 5 ] [ 2 ] / 255.0f }
} ;
// Official allowed sizes
// {0, 0, 0 } { 0, 0, 0 } 0x0x0
// { -16, -16, -18 } { 16, 16, 18 } 32x32x36
// { -16, -16, -36 } { 16, 16, 36 } 32x32x72
// { -32, -32, -32 } { 32, 32, 32 } 64x64x64
//#define kBuilding1MinSize Vector(-14.33, -14.84, 0.02)
////#define kBuilding1MaxSize Vector(21.61, 14.86, 66.9686)
//#define kBuilding1MaxSize Vector(14.33, 14.86, 66.9686)
//
//#define kBuilding2MinSize Vector(-25.0, -25.0, 0.02)
//#define kBuilding2MaxSize Vector(25.0, 25.0, 66.9686)
# define kResourceMinSize Vector(-16.0, -16.0, 0.0)
# define kResourceMaxSize Vector(16.0, 16.0, 66.9486)
// Tried 100, 110, still jitters. Shrink tower down a bit?
# define kAlienResourceMinSize Vector(-16.0, -16.0, 0.0)
# define kAlienResourceMaxSize Vector(16.0, 16.0, 80.7443)
//physent_t* AvHSUGetEntity(int inPhysIndex)
//{
// physent_t* theTarget = NULL;
// int i = 0;
//
// if(inPhysIndex > 0)
// {
// #ifdef AVH_CLIENT
// gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
//
// // Store off the old count
// //gEngfuncs.pEventAPI->EV_PushPMStates();
//
// // Now add in all of the players.
// gEngfuncs.pEventAPI->EV_SetSolidPlayers (-1);
//
// for (i = 0; i < MAX_PHYSENTS; i++)
// //for (i = 0; i < pmove->numphysent; i++)
// {
// physent_t* thePotentialCandidate = gEngfuncs.pEventAPI->EV_GetPhysent(i);
// if ( thePotentialCandidate && (thePotentialCandidate->info == inPhysIndex))
// {
// theTarget = &pmove->physents[i];
// break;
// }
// }
//
// //gEngfuncs.pEventAPI->EV_PopPMStates();
// #endif
//
// // Check phys entities on server
// #ifdef AVH_SERVER
// for (i = 0; i < MAX_PHYSENTS; i++)
// //for (i = 0; i < pmove->numphysent; i++)
// {
// if ( pmove->physents[i].info == inPhysIndex )
// {
// theTarget = &pmove->physents[i];
// break;
// }
// }
//
// //CBaseEntity* theEntityHit = CBaseEntity::Instance(tr.pHit);
// #endif
// }
//
// return theTarget;
//}
const char * AvHSHUGetClassNameFromUser3 ( AvHUser3 inUser3 )
{
const char * theClassName = " " ;
switch ( inUser3 )
{
case AVH_USER3_MARINE_PLAYER :
theClassName = " soldier " ;
break ;
case AVH_USER3_COMMANDER_PLAYER :
theClassName = " commander " ;
break ;
case AVH_USER3_ALIEN_PLAYER1 :
theClassName = " skulk " ;
break ;
case AVH_USER3_ALIEN_PLAYER2 :
theClassName = " gorge " ;
break ;
case AVH_USER3_ALIEN_PLAYER3 :
theClassName = " lerk " ;
break ;
case AVH_USER3_ALIEN_PLAYER4 :
theClassName = " fade " ;
break ;
case AVH_USER3_ALIEN_PLAYER5 :
theClassName = " onos " ;
break ;
case AVH_USER3_ALIEN_EMBRYO :
theClassName = " gestate " ;
break ;
}
return theClassName ;
}
// Pass in -1 to get all entities with a non-zero iuser3
void AvHSHUGetEntities ( int inUser3 , EntityListType & outEntities )
{
# ifdef AVH_SERVER
FOR_ALL_BASEENTITIES ( ) ;
if ( ( theBaseEntity - > pev - > iuser3 = = inUser3 ) | | ( ( inUser3 = = - 1 ) & & ( theBaseEntity - > pev - > iuser3 > 0 ) ) )
{
outEntities . push_back ( theBaseEntity - > entindex ( ) ) ;
}
END_FOR_ALL_BASEENTITIES ( ) ;
# endif
# ifdef AVH_CLIENT
gEngfuncs . pEventAPI - > EV_SetUpPlayerPrediction ( false , true ) ;
// Store off the old count
gEngfuncs . pEventAPI - > EV_PushPMStates ( ) ;
// Now add in all of the players.
gEngfuncs . pEventAPI - > EV_SetSolidPlayers ( - 1 ) ;
physent_t * theEntity = NULL ;
int theNumEnts = pmove - > numphysent ;
for ( int i = 0 ; i < theNumEnts ; i + + )
{
theEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( i ) ;
if ( ( theEntity - > iuser3 = = inUser3 ) | | ( ( inUser3 = = - 1 ) & & ( theEntity - > iuser3 > 0 ) ) )
{
outEntities . push_back ( i ) ;
}
}
gEngfuncs . pEventAPI - > EV_PopPMStates ( ) ;
# endif
}
bool AvHSHUGetEntityLocation ( int inEntity , vec3_t & outLocation )
{
bool theSuccess = false ;
# ifdef AVH_SERVER
edict_t * pEdict = g_engfuncs . pfnPEntityOfEntIndex ( inEntity ) ;
if ( pEdict & & ! pEdict - > free )
{
CBaseEntity * theEntity = CBaseEntity : : Instance ( pEdict ) ;
if ( theEntity )
{
outLocation = AvHSHUGetRealLocation ( theEntity - > pev - > origin , theEntity - > pev - > mins , theEntity - > pev - > maxs ) ;
theSuccess = true ;
}
}
# endif
# ifdef AVH_CLIENT
gEngfuncs . pEventAPI - > EV_SetUpPlayerPrediction ( false , true ) ;
// Store off the old count
gEngfuncs . pEventAPI - > EV_PushPMStates ( ) ;
// Now add in all of the players.
gEngfuncs . pEventAPI - > EV_SetSolidPlayers ( - 1 ) ;
physent_t * theEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( inEntity ) ;
gEngfuncs . pEventAPI - > EV_PopPMStates ( ) ;
if ( theEntity )
{
outLocation = AvHSHUGetRealLocation ( theEntity - > origin , theEntity - > mins , theEntity - > maxs ) ;
theSuccess = true ;
}
# endif
return theSuccess ;
}
bool AvHSHUGetEntityIUser3 ( int inEntity , AvHUser3 & outIUser3 )
{
bool theSuccess = false ;
# ifdef AVH_SERVER
edict_t * pEdict = g_engfuncs . pfnPEntityOfEntIndex ( inEntity ) ;
if ( pEdict & & ! pEdict - > free )
{
CBaseEntity * theEntity = CBaseEntity : : Instance ( pEdict ) ;
if ( theEntity )
{
outIUser3 = ( AvHUser3 ) theEntity - > pev - > iuser3 ;
theSuccess = true ;
}
}
# endif
# ifdef AVH_CLIENT
// Store off the old count
gEngfuncs . pEventAPI - > EV_PushPMStates ( ) ;
// Now add in all of the players.
gEngfuncs . pEventAPI - > EV_SetSolidPlayers ( - 1 ) ;
physent_t * theEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( inEntity ) ;
if ( theEntity )
{
outIUser3 = ( AvHUser3 ) theEntity - > iuser3 ;
theSuccess = true ;
}
gEngfuncs . pEventAPI - > EV_PopPMStates ( ) ;
# endif
return theSuccess ;
}
bool AvHSHUGetEntityIUser4 ( int inEntity , int & outIUser4 )
{
bool theSuccess = false ;
# ifdef AVH_SERVER
edict_t * pEdict = g_engfuncs . pfnPEntityOfEntIndex ( inEntity ) ;
if ( pEdict & & ! pEdict - > free )
{
CBaseEntity * theEntity = CBaseEntity : : Instance ( pEdict ) ;
if ( theEntity )
{
outIUser4 = theEntity - > pev - > iuser4 ;
theSuccess = true ;
}
}
# endif
# ifdef AVH_CLIENT
physent_t * theEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( inEntity ) ;
if ( theEntity )
{
outIUser4 = theEntity - > iuser4 ;
theSuccess = true ;
}
# endif
return theSuccess ;
}
vec3_t AvHSHUGetRealLocation ( const vec3_t & inLocation , const vec3_t & inMinBox , const vec3_t & inMaxBox )
{
vec3_t outLocation ;
VectorCopy ( inLocation , outLocation ) ;
if ( ( outLocation . x = = outLocation . y ) & & ( outLocation . y = = outLocation . z ) & & ( outLocation . z = = 0.0f ) )
{
outLocation . x = ( inMinBox . x + inMaxBox . x ) / 2.0f ;
outLocation . y = ( inMinBox . y + inMaxBox . y ) / 2.0f ;
outLocation . z = ( inMinBox . z + inMaxBox . z ) / 2.0f ;
}
return outLocation ;
}
// Returns range of user3, whatever that means. Returns -1 for no meaningful range.
int AvHSHUGetDrawRangeForUser3 ( AvHUser3 inUser3 )
{
int theRange = - 1 ;
switch ( inUser3 )
{
case AVH_USER3_COMMANDER_STATION :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kCommandStationBuildDistance ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_FUNC_RESOURCE :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kResourceTowerBuildDistanceTolerance ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_TURRET_FACTORY :
case AVH_USER3_ADVANCED_TURRET_FACTORY :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kTurretFactoryBuildDistance ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_ARMORY :
case AVH_USER3_ADVANCED_ARMORY :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kArmoryBuildDistance ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_TURRET :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kTurretRange ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_SIEGETURRET :
// TODO: Figure out a way to return minimum range also?
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kSiegeTurretRange ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_PROTOTYPE_LAB :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kArmorDropRange ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_OBSERVATORY :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kObservatoryXYDetectionRadius ) ;
2005-03-09 01:31:56 +00:00
break ;
case AVH_USER3_SENSORY_CHAMBER :
2005-04-01 03:04:57 +00:00
theRange = BALANCE_VAR ( kSensoryChamberRange ) ;
2005-03-09 01:31:56 +00:00
break ;
}
return theRange ;
}
int AvHSHUGetDrawRangeForMessageID ( AvHMessageID inMessageID )
{
AvHUser3 theUser3 = AVH_USER3_NONE ;
switch ( inMessageID )
{
case BUILD_COMMANDSTATION :
theUser3 = AVH_USER3_COMMANDER_STATION ;
break ;
case BUILD_TURRET :
theUser3 = AVH_USER3_TURRET ;
break ;
case BUILD_SIEGE :
theUser3 = AVH_USER3_SIEGETURRET ;
break ;
case BUILD_OBSERVATORY :
theUser3 = AVH_USER3_OBSERVATORY ;
break ;
case BUILD_TURRET_FACTORY :
theUser3 = AVH_USER3_TURRET_FACTORY ;
break ;
case BUILD_PROTOTYPE_LAB :
theUser3 = AVH_USER3_PROTOTYPE_LAB ;
break ;
case BUILD_ARMORY :
theUser3 = AVH_USER3_ARMORY ;
break ;
}
return AvHSHUGetDrawRangeForUser3 ( theUser3 ) ;
}
// Specify whether we draw rings for this entity or not, and draw them at different sizes for aesthetics. The scalar might go away when the
// artwork all has the correct bounding boxes.
bool AvHSHUGetDrawRingsForUser3 ( AvHUser3 inUser3 , float & outScalar )
{
bool theDrawRings = false ;
float theScalar = 1.0f ;
switch ( inUser3 )
{
case AVH_USER3_MARINE_PLAYER :
theScalar = .9f ;
theDrawRings = true ;
break ;
case AVH_USER3_RESTOWER :
theScalar = 1.6f ;
theDrawRings = true ;
break ;
case AVH_USER3_INFANTRYPORTAL :
theScalar = 1.3f ;
theDrawRings = true ;
break ;
case AVH_USER3_ARMORY :
case AVH_USER3_ADVANCED_ARMORY :
theScalar = 1.35f ;
theDrawRings = true ;
break ;
case AVH_USER3_COMMANDER_STATION :
theScalar = 1.4f ;
theDrawRings = true ;
break ;
case AVH_USER3_PHASEGATE :
theScalar = 2.0f ;
theDrawRings = true ;
break ;
case AVH_USER3_OBSERVATORY :
theScalar = .9f ;
theDrawRings = true ;
break ;
case AVH_USER3_TURRET_FACTORY :
case AVH_USER3_ADVANCED_TURRET_FACTORY :
theScalar = 1.6f ;
theDrawRings = true ;
break ;
case AVH_USER3_TURRET :
theScalar = .7f ;
theDrawRings = true ;
break ;
case AVH_USER3_NUKEPLANT :
theScalar = 1.5f ;
theDrawRings = true ;
break ;
case AVH_USER3_ARMSLAB :
case AVH_USER3_PROTOTYPE_LAB :
case AVH_USER3_CHEMLAB :
case AVH_USER3_MEDLAB :
case AVH_USER3_SIEGETURRET :
theScalar = 1.3f ;
theDrawRings = true ;
break ;
// Alien buildings
case AVH_USER3_DEFENSE_CHAMBER :
case AVH_USER3_OFFENSE_CHAMBER :
case AVH_USER3_MOVEMENT_CHAMBER :
case AVH_USER3_SENSORY_CHAMBER :
case AVH_USER3_ALIENRESTOWER :
theScalar = 1.3f ;
theDrawRings = true ;
break ;
case AVH_USER3_ALIEN_PLAYER1 :
theScalar = .6f ;
theDrawRings = true ;
break ;
case AVH_USER3_ALIEN_PLAYER2 :
theScalar = 1.0f ;
theDrawRings = true ;
break ;
case AVH_USER3_ALIEN_PLAYER3 :
theScalar = 1.0 ;
theDrawRings = true ;
break ;
case AVH_USER3_ALIEN_PLAYER4 :
theScalar = 1.3f ;
theDrawRings = true ;
break ;
case AVH_USER3_ALIEN_PLAYER5 :
theScalar = 1.2f ;
theDrawRings = true ;
break ;
}
if ( theDrawRings )
{
outScalar = theScalar ;
}
return theDrawRings ;
}
bool AvHSHUGetBuildRegions ( AvHMessageID inMessageID , EntityListType & outEntities , IntList & outRanges , float & outZAdjustment , bool & outSnapToLocation )
{
bool theFoundTech = false ;
typedef vector < AvHUser3 > User3ListType ;
User3ListType theUser3s ;
outZAdjustment = 0.0f ;
outSnapToLocation = false ;
switch ( inMessageID )
{
case BUILD_RESOURCES :
case ALIEN_BUILD_RESOURCES :
theUser3s . push_back ( AVH_USER3_FUNC_RESOURCE ) ;
outZAdjustment = ( kFuncResourceMaxSize . z - kFuncResourceMinSize . z ) ;
outSnapToLocation = true ;
break ;
case BUILD_INFANTRYPORTAL :
theUser3s . push_back ( AVH_USER3_COMMANDER_STATION ) ;
break ;
case BUILD_TURRET :
theUser3s . push_back ( AVH_USER3_TURRET_FACTORY ) ;
theUser3s . push_back ( AVH_USER3_ADVANCED_TURRET_FACTORY ) ;
break ;
case BUILD_SIEGE :
theUser3s . push_back ( AVH_USER3_ADVANCED_TURRET_FACTORY ) ;
break ;
case BUILD_MINES :
case BUILD_WELDER :
case BUILD_SHOTGUN :
theUser3s . push_back ( AVH_USER3_ARMORY ) ;
theUser3s . push_back ( AVH_USER3_ADVANCED_ARMORY ) ;
break ;
case BUILD_HMG :
case BUILD_GRENADE_GUN :
theUser3s . push_back ( AVH_USER3_ADVANCED_ARMORY ) ;
break ;
case BUILD_HEAVY :
case BUILD_JETPACK :
theUser3s . push_back ( AVH_USER3_PROTOTYPE_LAB ) ;
break ;
}
if ( theUser3s . size ( ) > 0 )
{
for ( User3ListType : : iterator theUser3Iter = theUser3s . begin ( ) ; theUser3Iter ! = theUser3s . end ( ) ; theUser3Iter + + )
{
EntityListType theEntities ;
AvHSHUGetEntities ( * theUser3Iter , theEntities ) ;
for ( EntityListType : : iterator theEntityIter = theEntities . begin ( ) ; theEntityIter ! = theEntities . end ( ) ; theEntityIter + + )
{
// Only add buildings that are fully built
int theIuser4 = 0 ;
if ( AvHSHUGetEntityIUser4 ( * theEntityIter , theIuser4 ) )
{
if ( ! GetHasUpgrade ( theIuser4 , MASK_BUILDABLE ) )
{
outEntities . push_back ( * theEntityIter ) ;
outRanges . push_back ( AvHSHUGetDrawRangeForUser3 ( * theUser3Iter ) ) ;
}
}
}
}
theFoundTech = true ;
}
return theFoundTech ;
}
// tankefugl: 0000291 -- allows listed structures to be dropped on resource towers
bool AvHSHUGetIsDroppableOnRTs ( AvHMessageID inMessageID )
{
switch ( inMessageID )
{
case BUILD_HEALTH :
case BUILD_AMMO :
case BUILD_MINES :
case BUILD_WELDER :
case BUILD_SHOTGUN :
case BUILD_HMG :
case BUILD_GRENADE_GUN :
case BUILD_CAT :
case BUILD_HEAVY :
case BUILD_JETPACK :
case BUILD_RESOURCES :
case ALIEN_BUILD_RESOURCES :
case ALIEN_BUILD_HIVE :
return true ;
default :
return false ;
}
}
// :tankefugl
bool AvHSHUGetIsMarineStructure ( AvHMessageID inMessageID )
{
switch ( inMessageID )
{
case BUILD_INFANTRYPORTAL :
case BUILD_RESOURCES :
case BUILD_TURRET_FACTORY :
case BUILD_ARMSLAB :
case BUILD_PROTOTYPE_LAB :
case BUILD_ARMORY :
case BUILD_NUKE_PLANT :
case BUILD_OBSERVATORY :
case BUILD_PHASEGATE :
case BUILD_TURRET :
case BUILD_SIEGE :
case BUILD_COMMANDSTATION :
return true ;
default :
return false ;
}
}
bool AvHSHUGetIsMarineStructure ( AvHUser3 inUser3 )
{
switch ( inUser3 )
{
case AVH_USER3_COMMANDER_STATION :
case AVH_USER3_TURRET_FACTORY :
case AVH_USER3_ARMORY :
case AVH_USER3_ADVANCED_ARMORY :
case AVH_USER3_ARMSLAB :
case AVH_USER3_PROTOTYPE_LAB :
case AVH_USER3_OBSERVATORY :
case AVH_USER3_CHEMLAB :
case AVH_USER3_MEDLAB :
case AVH_USER3_NUKEPLANT :
case AVH_USER3_TURRET :
case AVH_USER3_SIEGETURRET :
case AVH_USER3_RESTOWER :
case AVH_USER3_INFANTRYPORTAL :
case AVH_USER3_PHASEGATE :
case AVH_USER3_ADVANCED_TURRET_FACTORY :
return true ;
default :
return false ;
}
}
void AvHSHUGetMinBuildRadiusViolations ( AvHMessageID inMessageID , vec3_t & inLocation , EntityListType & outViolations )
{
// Enforce a minimum build radius for marine structures.
if ( AvHSHUGetIsMarineStructure ( inMessageID ) )
{
EntityListType theEntities ;
AvHSHUGetEntities ( - 1 , theEntities ) ;
vec3_t theMinSize , theMaxSize ;
AvHSHUGetSizeForTech ( inMessageID , theMinSize , theMaxSize ) ;
float theMaxRadius1 = max ( - min ( theMinSize . x , theMinSize . y ) , max ( theMaxSize . x , theMaxSize . y ) ) ;
for ( EntityListType : : iterator theIter = theEntities . begin ( ) ; theIter ! = theEntities . end ( ) ; theIter + + )
{
AvHUser3 theUser3 ;
AvHSHUGetEntityIUser3 ( * theIter , theUser3 ) ;
bool theEntityCouldBlock = AvHSHUGetIsMarineStructure ( theUser3 ) ;
if ( inMessageID ! = BUILD_RESOURCES )
{
theEntityCouldBlock | = ( theUser3 = = AVH_USER3_FUNC_RESOURCE ) ;
}
bool theEntityIsSolid = false ;
# ifdef AVH_SERVER
edict_t * theEntity = INDEXENT ( * theIter ) ;
if ( theEntity )
theEntityIsSolid = ( theEntity - > v . solid = = SOLID_BBOX ) ;
# endif
# ifdef AVH_CLIENT
physent_t * theEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( * theIter ) ;
if ( theEntity )
theEntityIsSolid = ( theEntity - > solid = = SOLID_BBOX ) ;
# endif
// joev: 0000291
// It's possible to place "on" marines if you're offset a little from center. This code and
// associated changes below and in AvHHudRender.cpp is to enforce a build distance around players
// in the same way as buildings to prevent this exploit.
if ( theUser3 = = AVH_USER3_MARINE_PLAYER )
{
theEntityIsSolid = true ;
theEntityCouldBlock = true ;
}
if ( theEntityCouldBlock & & theEntityIsSolid )
{
AvHSHUGetSizeForUser3 ( theUser3 , theMinSize , theMaxSize ) ;
float theMaxRadius2 = max ( max ( theMinSize . x , theMaxSize . x ) , max ( theMinSize . y , theMaxSize . y ) ) ;
vec3_t theLocation ;
if ( AvHSHUGetEntityLocation ( * theIter , theLocation ) )
{
vec3_t theXYInLocation = inLocation ;
vec3_t theXYTheLocation = theLocation ;
theXYInLocation . z = 0 ;
theXYTheLocation . z = 0 ;
float theDistance = VectorDistance ( ( float * ) & theXYInLocation , ( float * ) & theXYTheLocation ) ;
// joev: 0000291
// It's possible to place "on" marines if you're offset a little from center. This code and
// associated changes above and in AvHHudRender.cpp is to enforce a build distance around players
// in the same way as buildings to prevent this exploit.
float theMinMarineBuildDistance ;
if ( theUser3 = = AVH_USER3_MARINE_PLAYER ) {
2005-04-01 03:04:57 +00:00
theMinMarineBuildDistance = BALANCE_VAR ( kMinMarinePlayerBuildDistance ) ;
2005-03-09 01:31:56 +00:00
}
else
{
2005-04-01 03:04:57 +00:00
theMinMarineBuildDistance = BALANCE_VAR ( kMinMarineBuildDistance ) ;
2005-03-09 01:31:56 +00:00
}
// :joev
if ( theDistance < theMinMarineBuildDistance + theMaxRadius1 + theMaxRadius2 )
{
outViolations . push_back ( * theIter ) ;
}
}
}
}
}
}
bool AvHSHUGetAreSpecialBuildingRequirementsMet ( AvHMessageID inMessageID , vec3_t & inLocation )
{
bool theRequirementsMet = false ;
EntityListType theEntities ;
IntList theDistanceRequirements ;
float theZAdjustment = 0.0f ;
bool theSnapToLocation = false ;
if ( inMessageID = = ALIEN_BUILD_HIVE )
{
// Look for inactive hives within radius
EntityListType theEntities ;
// Look for a unoccupied hive spot within range
AvHSHUGetEntities ( AVH_USER3_HIVE , theEntities ) ;
for ( EntityListType : : iterator theIter = theEntities . begin ( ) ; theIter ! = theEntities . end ( ) ; theIter + + )
{
vec3_t theLocation ;
if ( AvHSHUGetEntityLocation ( * theIter , theLocation ) )
{
// Set z's equal to check 2D distance only
inLocation . z = theLocation . z ;
float theDistance = VectorDistance ( ( float * ) & inLocation , ( float * ) & theLocation ) ;
if ( theDistance < = kHiveXYDistanceTolerance )
{
// Make sure this hive isn't already active
# ifdef AVH_SERVER
CBaseEntity * theEntity = AvHSUGetEntityFromIndex ( * theIter ) ;
ASSERT ( theEntity ) ;
if ( theEntity - > pev - > team = = 0 )
{
# endif
theRequirementsMet = true ;
inLocation = theLocation ;
# ifdef AVH_SERVER
}
# endif
break ;
}
}
}
}
else if ( AvHSHUGetBuildRegions ( inMessageID , theEntities , theDistanceRequirements , theZAdjustment , theSnapToLocation ) )
{
ASSERT ( theEntities . size ( ) = = theDistanceRequirements . size ( ) ) ;
vec3_t theBestLocation ;
int i = 0 ;
float theClosestDistance = kMaxMapDimension ;
for ( EntityListType : : iterator theIter = theEntities . begin ( ) ; theIter ! = theEntities . end ( ) ; theIter + + , i + + )
{
vec3_t theLocation ;
if ( AvHSHUGetEntityLocation ( * theIter , theLocation ) )
{
// Only check xy distance
vec3_t theXYInLocation = inLocation ;
vec3_t theXYTheLocation = theLocation ;
theXYInLocation . z = 0 ;
theXYTheLocation . z = 0 ;
float theDistance = VectorDistance ( ( float * ) & theXYInLocation , ( float * ) & theXYTheLocation ) ;
int theDistanceRequirement = theDistanceRequirements [ i ] ;
if ( ( theDistance < = theDistanceRequirement ) | | ( theDistanceRequirement = = - 1 ) )
{
// Pick the closest one, in case there are multiples in range
if ( theDistance < theClosestDistance )
{
theClosestDistance = theDistance ;
VectorCopy ( theLocation , theBestLocation ) ;
theRequirementsMet = true ;
}
}
}
}
if ( theRequirementsMet & & theSnapToLocation )
{
inLocation = theBestLocation ;
inLocation . z + = theZAdjustment ;
}
}
else
{
theRequirementsMet = true ;
}
EntityListType theBuildRadiusViolations ;
AvHSHUGetMinBuildRadiusViolations ( inMessageID , inLocation , theBuildRadiusViolations ) ;
if ( theBuildRadiusViolations . size ( ) > 0 )
{
theRequirementsMet = false ;
}
// Anti-llama/newbie tactic: don't allow non-resource buildings to be placed such that they block access to nozzles
// Make sure generic building isn't being placed on top of resource nozzles
// tankefugl: 0000291
// allow equipment, rts and hives to be dropped around nodes
if ( AvHSHUGetIsDroppableOnRTs ( inMessageID ) = = false )
{
// :tankefugl
// If building is too close to an empty nozzle, don't allow it
float theResourceBuildingRadius , theTotalMinRadius ;
vec3_t theMinSize , theMaxSize , theMinRadius , theFlattenedInLocation , theLocation ;
theFlattenedInLocation [ 0 ] = inLocation [ 0 ] ;
theFlattenedInLocation [ 1 ] = inLocation [ 1 ] ;
theFlattenedInLocation [ 2 ] = 0 ;
theResourceBuildingRadius = 60 ;
EntityListType theEntities ;
AvHSHUGetEntities ( AVH_USER3_FUNC_RESOURCE , theEntities ) ;
if ( AvHSHUGetSizeForTech ( inMessageID , theMinSize , theMaxSize ) )
{
EntityListType : : iterator end = theEntities . end ( ) ;
for ( EntityListType : : iterator current = theEntities . begin ( ) ; current < end ; + + current )
{
if ( AvHSHUGetEntityLocation ( * current , theLocation ) )
{
//flatten to 2 dimensions
theLocation [ 2 ] = 0 ;
//space = radius of both buildings combined
theTotalMinRadius = theResourceBuildingRadius ;
theTotalMinRadius + = max ( - min ( theMinSize . x , theMinSize . y ) , max ( theMaxSize . x , theMaxSize . y ) ) ;
if ( VectorDistance ( ( float * ) & theFlattenedInLocation , ( float * ) & theLocation ) < theTotalMinRadius )
{
theRequirementsMet = false ;
break ;
}
}
}
}
}
return theRequirementsMet ;
}
bool AvHSHUGetBuildTechClassName ( AvHMessageID inMessageID , char * & outClassName )
{
bool theSuccess = true ;
switch ( inMessageID )
{
// Buildings
case BUILD_RESOURCES :
outClassName = kwsResourceTower ;
break ;
//case BUILD_REINFORCEMENTS:
// outClassName = kwsInfantryPortal;
// break;
case BUILD_INFANTRYPORTAL :
outClassName = kwsInfantryPortal ;
break ;
case BUILD_COMMANDSTATION :
outClassName = kwsTeamCommand ;
break ;
case BUILD_TURRET_FACTORY :
outClassName = kwsTurretFactory ;
break ;
case BUILD_ARMSLAB :
outClassName = kwsArmsLab ;
break ;
case BUILD_PROTOTYPE_LAB :
outClassName = kwsPrototypeLab ;
break ;
case BUILD_ARMORY :
outClassName = kwsArmory ;
break ;
case ARMORY_UPGRADE :
outClassName = kwsAdvancedArmory ;
break ;
case BUILD_NUKE_PLANT :
outClassName = kwsNukePlant ;
break ;
case BUILD_OBSERVATORY :
outClassName = kwsObservatory ;
break ;
case BUILD_SCAN :
outClassName = kwsScan ;
break ;
case BUILD_PHASEGATE :
outClassName = kwsPhaseGate ;
break ;
case BUILD_TURRET :
outClassName = kwsDeployedTurret ;
break ;
case BUILD_SIEGE :
outClassName = kwsSiegeTurret ;
break ;
// Equipment
case BUILD_HEALTH :
outClassName = kwsHealth ;
break ;
case BUILD_CAT :
outClassName = kwsCatalyst ;
break ;
case BUILD_JETPACK :
outClassName = kwsJetpack ;
break ;
case BUILD_HEAVY :
outClassName = kwsHeavyArmor ;
break ;
case BUILD_AMMO :
outClassName = kwsGenericAmmo ;
break ;
case BUILD_WELDER :
outClassName = kwsWelder ;
break ;
case BUILD_MINES :
outClassName = kwsMine ;
break ;
case BUILD_SHOTGUN :
outClassName = kwsShotGun ;
break ;
case BUILD_HMG :
outClassName = kwsHeavyMachineGun ;
break ;
case BUILD_NUKE :
outClassName = kwsNuke ;
break ;
case BUILD_GRENADE_GUN :
outClassName = kwsGrenadeGun ;
break ;
//case BUILD_MEDKIT:
// break;
case ALIEN_BUILD_RESOURCES :
outClassName = kwsAlienResourceTower ;
break ;
case ALIEN_BUILD_OFFENSE_CHAMBER :
outClassName = kwsOffenseChamber ;
break ;
case ALIEN_BUILD_DEFENSE_CHAMBER :
outClassName = kwsDefenseChamber ;
break ;
case ALIEN_BUILD_SENSORY_CHAMBER :
outClassName = kwsSensoryChamber ;
break ;
case ALIEN_BUILD_MOVEMENT_CHAMBER :
outClassName = kwsMovementChamber ;
break ;
case ALIEN_BUILD_HIVE :
outClassName = kesTeamHive ;
break ;
default :
theSuccess = false ;
break ;
}
return theSuccess ;
}
bool AvHSHUGetResearchTechName ( AvHMessageID inResearchID , char * & outResearchTechName )
{
bool theSuccess = true ;
switch ( inResearchID )
{
case RESEARCH_ELECTRICAL :
outResearchTechName = " research_electrical " ;
break ;
case RESEARCH_ARMOR_ONE :
outResearchTechName = " research_armorl1 " ;
break ;
case RESEARCH_ARMOR_TWO :
outResearchTechName = " research_armorl2 " ;
break ;
case RESEARCH_ARMOR_THREE :
outResearchTechName = " research_armorl3 " ;
break ;
case RESEARCH_WEAPONS_ONE :
outResearchTechName = " research_weaponsl1 " ;
break ;
case RESEARCH_WEAPONS_TWO :
outResearchTechName = " research_weaponsl2 " ;
break ;
case RESEARCH_WEAPONS_THREE :
outResearchTechName = " research_weaponsl3 " ;
break ;
case ARMORY_UPGRADE :
outResearchTechName = " research_advarmory " ;
break ;
case TURRET_FACTORY_UPGRADE :
outResearchTechName = " research_advturretfactory " ;
break ;
case RESEARCH_JETPACKS :
outResearchTechName = " research_jetpacks " ;
break ;
case RESEARCH_HEAVYARMOR :
outResearchTechName = " research_heavyarmor " ;
break ;
case RESEARCH_DISTRESSBEACON :
outResearchTechName = " research_distressbeacon " ;
break ;
case RESEARCH_HEALTH :
outResearchTechName = " research_health " ;
break ;
case RESEARCH_CATALYSTS :
outResearchTechName = " research_catalysts " ;
break ;
case MESSAGE_CANCEL :
outResearchTechName = " research_cancel " ;
break ;
case RESEARCH_MOTIONTRACK :
outResearchTechName = " research_motiontracking " ;
break ;
case RESEARCH_PHASETECH :
outResearchTechName = " research_phasetech " ;
break ;
case RESEARCH_GRENADES :
outResearchTechName = " research_grenades " ;
break ;
default :
theSuccess = false ;
break ;
}
return theSuccess ;
}
bool AvHSHUGetCenterPositionForGroup ( int inGroupNumber , float * inPlayerOrigin , float * outCenterPosition )
{
bool theSuccess = false ;
vec3_t thePosition ;
float theX , theY ;
# ifdef AVH_CLIENT
theSuccess = gHUD . GetCenterPositionForGroup ( inGroupNumber , thePosition ) ;
theX = thePosition [ 0 ] ;
theY = thePosition [ 1 ] ;
# endif
# ifdef AVH_SERVER
// Loop through players, find the closest player to inPlayerOrigin, to see which player is being predicted. Is there a better way?
AvHPlayer * theClosestPlayer = NULL ;
float theClosestDistance = 10000 ;
FOR_ALL_ENTITIES ( kAvHPlayerClassName , AvHPlayer * )
float theDistance = VectorDistance ( theEntity - > pev - > origin , inPlayerOrigin ) ;
if ( theDistance < theClosestDistance )
{
theClosestPlayer = theEntity ;
theClosestDistance = theDistance ;
}
END_FOR_ALL_ENTITIES ( kAvHPlayerClassName )
if ( theClosestPlayer )
{
theSuccess = theClosestPlayer - > GetCenterPositionForGroup ( inGroupNumber , theX , theY ) ;
}
# endif
if ( theSuccess )
{
outCenterPosition [ 0 ] = theX ;
outCenterPosition [ 1 ] = theY ;
}
return theSuccess ;
}
bool AvHSHUGetIsBuilding ( AvHMessageID inMessageID )
{
bool theIsBuilding = false ;
switch ( inMessageID )
{
// Buildings
case BUILD_RESOURCES :
case BUILD_INFANTRYPORTAL :
case BUILD_COMMANDSTATION :
case BUILD_TURRET_FACTORY :
case BUILD_ARMSLAB :
case BUILD_PROTOTYPE_LAB :
case BUILD_ARMORY :
case BUILD_NUKE_PLANT :
case BUILD_OBSERVATORY :
case BUILD_PHASEGATE :
case BUILD_TURRET :
case BUILD_SIEGE :
// Alien buildings
case ALIEN_BUILD_OFFENSE_CHAMBER :
case ALIEN_BUILD_DEFENSE_CHAMBER :
case ALIEN_BUILD_SENSORY_CHAMBER :
case ALIEN_BUILD_MOVEMENT_CHAMBER :
case ALIEN_BUILD_HIVE :
theIsBuilding = true ;
break ;
}
return theIsBuilding ;
}
bool AvHSHUGetIsBuildTech ( AvHMessageID inMessageID )
{
bool theIsBuildTech = false ;
switch ( inMessageID )
{
// Buildings
case BUILD_RESOURCES :
case BUILD_INFANTRYPORTAL :
case BUILD_COMMANDSTATION :
case BUILD_TURRET_FACTORY :
case BUILD_ARMSLAB :
case BUILD_PROTOTYPE_LAB :
case BUILD_ARMORY :
//case UPGRADE_ADVANCED_WEAPON_FACTORY:
case BUILD_NUKE_PLANT :
case BUILD_OBSERVATORY :
case BUILD_SCAN :
case BUILD_PHASEGATE :
case BUILD_TURRET :
case BUILD_SIEGE :
case BUILD_HEAVY :
case BUILD_JETPACK :
// Equipment
case BUILD_AMMO :
case BUILD_HEALTH :
case BUILD_CAT :
case BUILD_WELDER :
case BUILD_MINES :
case BUILD_SHOTGUN :
case BUILD_HMG :
case BUILD_NUKE :
case BUILD_GRENADE_GUN :
//case BUILD_MEDKIT:
//case BUILD_STIMPACK:
// Alien buildings
case ALIEN_BUILD_OFFENSE_CHAMBER :
case ALIEN_BUILD_DEFENSE_CHAMBER :
case ALIEN_BUILD_SENSORY_CHAMBER :
case ALIEN_BUILD_MOVEMENT_CHAMBER :
theIsBuildTech = true ;
break ;
}
return theIsBuildTech ;
}
bool AvHSHUGetIsWeaponFocusable ( AvHWeaponID inWeaponID )
{
bool theIsFocusable = false ;
switch ( inWeaponID )
{
case AVH_WEAPON_BITE :
case AVH_WEAPON_SPIT :
case AVH_WEAPON_BITE2 :
case AVH_WEAPON_SWIPE :
case AVH_WEAPON_CLAWS :
theIsFocusable = true ;
break ;
}
return theIsFocusable ;
}
bool AvHSHUGetDoesTechCostEnergy ( AvHMessageID inMessageID )
{
bool theTechCostsEnergy = false ;
switch ( inMessageID )
{
case BUILD_SCAN :
theTechCostsEnergy = true ;
break ;
}
return theTechCostsEnergy ;
}
bool AvHSHUGetIsCombatModeTech ( AvHMessageID inMessageID )
{
bool theIsCombatModeTech = false ;
switch ( inMessageID )
{
case BUILD_SHOTGUN :
case BUILD_GRENADE_GUN :
case BUILD_HMG :
case BUILD_WELDER :
case BUILD_MINES :
case BUILD_JETPACK :
case BUILD_HEAVY :
case BUILD_SCAN :
theIsCombatModeTech = true ;
break ;
}
return theIsCombatModeTech ;
}
bool AvHSHUGetIsResearchTech ( AvHMessageID inMessageID )
{
bool theIsResearchTech = false ;
switch ( inMessageID )
{
case RESEARCH_ELECTRICAL :
case RESEARCH_ARMOR_ONE :
case RESEARCH_ARMOR_TWO :
case RESEARCH_ARMOR_THREE :
case RESEARCH_WEAPONS_ONE :
case RESEARCH_WEAPONS_TWO :
case RESEARCH_WEAPONS_THREE :
case TURRET_FACTORY_UPGRADE :
case RESEARCH_JETPACKS :
case RESEARCH_HEAVYARMOR :
case RESEARCH_DISTRESSBEACON :
case RESEARCH_HEALTH :
case RESEARCH_CATALYSTS :
case MESSAGE_CANCEL :
case RESEARCH_MOTIONTRACK :
case RESEARCH_PHASETECH :
case RESEARCH_GRENADES :
case RESOURCE_UPGRADE :
case ARMORY_UPGRADE :
theIsResearchTech = true ;
break ;
}
return theIsResearchTech ;
}
//Here's TFC's code that checks whether a player's allowed to build a sentry
//or not.
//I can't remember if there was any good reason why we used
//UTIL_FindEntitiesInSphere()
//instead of UTIL_EntitiesInBox().
//
////=========================================================================
//// Returns 0 if the area around obj is safe to build in
//int CBaseEntity::CheckArea( CBaseEntity *pIgnore )
//{
// TraceResult tr;
// Vector vecOrg = pev->origin;
//
// // Check the origin
// int iContents = UTIL_PointContents(vecOrg);
// if ( iContents != CONTENT_EMPTY && iContents != CONTENT_WATER )
// return CAREA_BLOCKED;
//
// Vector vecIgnoreOrg = pIgnore->pev->origin;
// // Get the player's origin irrelevant of crouching
// if ( pIgnore->pev->flags & FL_DUCKING )
// {
// vecIgnoreOrg = vecIgnoreOrg + (VEC_DUCK_HULL_MIN -
// VEC_HULL_MIN);
// }
// // Trace a hull
// UTIL_TraceHull( vecIgnoreOrg, pev->origin, ignore_monsters,
// large_hull, edict(), &tr );
// CBaseEntity *pEntity = CBaseEntity::Instance(tr.pHit);
// if (tr.flFraction != 1 || tr.fAllSolid == 1)
// return CAREA_BLOCKED;
//
// // Check for solid entities in the area
// CBaseEntity *pEnt = NULL;
// while ( (pEnt = UTIL_FindEntityInSphere( pEnt, pev->origin, 48 )) !=
// NULL )
// {
// // If it's not the engineer, and its a solid entity, fail
// if (pEnt != pIgnore && pEnt != this && pEnt->pev->solid >
// SOLID_TRIGGER)
// return CAREA_BLOCKED;
// }
//
// // Cycle through all the Nobuild zones in the map and make sure this
// isn't in one of them
// CBaseEntity *pNoBuild = UTIL_FindEntityByClassname( NULL,
// "func_nobuild" );
// while ( pNoBuild )
// {
// // Check to see if we're building in this zone
// if ( vecOrg.x >= pNoBuild->pev->mins.x && vecOrg.y >=
// pNoBuild->pev->mins.y && vecOrg.z >= pNoBuild->pev->mins.z &&
// vecOrg.x <= pNoBuild->pev->maxs.x &&
// vecOrg.y <= pNoBuild->pev->maxs.y && vecOrg.z <= pNoBuild->pev->maxs.z )
// return CAREA_NOBUILD;
//
// pNoBuild = UTIL_FindEntityByClassname( pNoBuild,
// "func_nobuild" );
// }
//
// // Check below
// UTIL_TraceLine( vecOrg, vecOrg + Vector(0,0,-64),
// dont_ignore_monsters, edict(), &tr );
// if ( tr.flFraction == 1.0 )
// return CAREA_BLOCKED;
//
// return CAREA_CLEAR;
//}
//bool AvHSHUGetIsEnoughRoom(const vec3_t& inCenter, const vec3_t& inMin, const vec3_t& inMax)
//{
// bool theEnoughRoom = false;
//
// // Do a traceline from center to center + min
// // Hit nothing?
// // Do a traceline from center to center + max
// // Hit nothing?
// // Success
// theEnoughRoom = true;
//
// return theEnoughRoom;
//}
bool AvHSHUGetIsGroupMessage ( AvHMessageID inMessageID )
{
bool theIsGroupMessage = false ;
switch ( inMessageID )
{
case GROUP_CREATE_1 :
case GROUP_CREATE_2 :
case GROUP_CREATE_3 :
case GROUP_CREATE_4 :
case GROUP_CREATE_5 :
case GROUP_SELECT_1 :
case GROUP_SELECT_2 :
case GROUP_SELECT_3 :
case GROUP_SELECT_4 :
case GROUP_SELECT_5 :
theIsGroupMessage = true ;
}
return theIsGroupMessage ;
}
bool AvHSHUGetSizeForTech ( AvHMessageID inMessageID , Vector & outMinSize , Vector & outMaxSize , bool inGetSizeToPlace )
{
bool theSuccess = false ;
// Onos-sized
//const int theOnosHeightNeededToSpawn = HULL3_MAXZ - HULL3_MINZ + kRespawnFudgeFactorHeight;
//const int theOnosWidthNeededToSpawn = HULL3_MAXY - HULL3_MINY + kRespawnFudgeFactorHeight;
// Marine-sized
const int theMarineHeightNeededToSpawn = HULL0_MAXZ - HULL0_MINZ + kRespawnFudgeFactorHeight ;
switch ( inMessageID )
{
case BUILD_INFANTRYPORTAL :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 14.49 ) ;
// Make sure there is room above it for players to spawn
if ( inGetSizeToPlace )
{
outMaxSize . z + = theMarineHeightNeededToSpawn ;
}
theSuccess = true ;
break ;
case BUILD_PHASEGATE :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 14.49 ) ;
// Make sure there is remove above it for players to spawn
if ( inGetSizeToPlace )
{
//outMinSize.x = outMinSize.y = -theOnosWidthNeededToSpawn;
//outMaxSize.x = outMaxSize.y = theOnosWidthNeededToSpawn;
//outMaxSize.z += theOnosHeightNeededToSpawn;
outMaxSize . z + = theMarineHeightNeededToSpawn ;
}
theSuccess = true ;
break ;
case BUILD_RESOURCES :
outMinSize = kResourceMinSize ;
outMaxSize = kResourceMaxSize ;
theSuccess = true ;
break ;
case ALIEN_BUILD_RESOURCES :
outMinSize = kAlienResourceMinSize ;
outMaxSize = kAlienResourceMaxSize ;
theSuccess = true ;
break ;
default :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 66.9486 ) ;
theSuccess = true ;
break ;
case BUILD_TURRET :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 42.0 ) ;
theSuccess = true ;
break ;
case ALIEN_BUILD_OFFENSE_CHAMBER :
case ALIEN_BUILD_DEFENSE_CHAMBER :
case ALIEN_BUILD_SENSORY_CHAMBER :
case ALIEN_BUILD_MOVEMENT_CHAMBER :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 44.0 ) ;
theSuccess = true ;
break ;
case BUILD_COMMANDSTATION :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 70.34 ) ;
theSuccess = true ;
break ;
case BUILD_TURRET_FACTORY :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
//outMaxSize = Vector(16.0, 16.0, 55.68);
outMaxSize = Vector ( 16.0 , 16.0 , 62.1931 ) ;
theSuccess = true ;
break ;
case BUILD_ARMORY :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 62.1931 ) ;
theSuccess = true ;
break ;
case BUILD_PROTOTYPE_LAB :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 67.7443 ) ;
theSuccess = true ;
break ;
case BUILD_OBSERVATORY :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 80.7443 ) ;
theSuccess = true ;
break ;
case BUILD_SIEGE :
outMinSize = Vector ( - 16 , - 16 , 0 ) ;
outMaxSize = Vector ( 16.0 , 16.0 , 62.1931 /*50.6678*/ ) ;
theSuccess = true ;
break ;
case BUILD_HEALTH :
outMinSize = kHealthMinSize ;
outMaxSize = kHealthMaxSize ;
theSuccess = true ;
break ;
case BUILD_CAT :
outMinSize = kCatalystMinSize ;
outMaxSize = kCatalystMaxSize ;
theSuccess = true ;
break ;
case BUILD_HEAVY :
outMinSize = kHeavyMinSize ;
outMaxSize = kHeavyMaxSize ;
theSuccess = true ;
break ;
case BUILD_JETPACK :
outMinSize = kJetpackMinSize ;
outMaxSize = kJetpackMaxSize ;
theSuccess = true ;
break ;
case BUILD_AMMO :
outMinSize = kAmmoMinSize ;
outMaxSize = kAmmoMaxSize ;
theSuccess = true ;
break ;
case BUILD_MINES :
outMinSize = kWeaponMinSize ;
outMaxSize = Vector ( 16 , 16 , 40 ) ;
theSuccess = true ;
break ;
case BUILD_SHOTGUN :
case BUILD_HMG :
case BUILD_WELDER :
case BUILD_NUKE :
case BUILD_GRENADE_GUN :
outMinSize = kWeaponMinSize ;
outMaxSize = kWeaponMaxSize ;
theSuccess = true ;
break ;
case ALIEN_BUILD_HIVE :
outMinSize = kHiveMinSize ;
outMaxSize = kHiveMaxSize ;
theSuccess = true ;
break ;
}
return theSuccess ;
}
bool AvHSHUGetSizeForPlayerUser3 ( AvHUser3 inUser3 , Vector & outMinSize , Vector & outMaxSize , bool inDucking )
{
bool theSuccess = false ;
// Now set size
switch ( inUser3 )
{
case AVH_USER3_NONE :
case AVH_USER3_MARINE_PLAYER :
case AVH_USER3_COMMANDER_PLAYER :
case AVH_USER3_ALIEN_PLAYER4 :
// Get simple case working first
if ( inDucking )
{
outMinSize = HULL1_MIN ;
outMaxSize = HULL1_MAX ;
}
else
{
outMinSize = HULL0_MIN ;
outMaxSize = HULL0_MAX ;
}
theSuccess = true ;
break ;
case AVH_USER3_ALIEN_PLAYER1 :
case AVH_USER3_ALIEN_PLAYER2 :
case AVH_USER3_ALIEN_PLAYER3 :
case AVH_USER3_ALIEN_EMBRYO :
outMinSize = HULL1_MIN ;
outMaxSize = HULL1_MAX ;
theSuccess = true ;
break ;
case AVH_USER3_ALIEN_PLAYER5 :
if ( inDucking )
{
outMinSize = HULL0_MIN ;
outMaxSize = HULL0_MAX ;
}
else
{
outMinSize = HULL3_MIN ;
outMaxSize = HULL3_MAX ;
}
theSuccess = true ;
break ;
}
return theSuccess ;
}
bool AvHSHUGetSizeForUser3 ( AvHUser3 inUser3 , Vector & outMinSize , Vector & outMaxSize )
{
bool theSuccess = false ;
// If it's a player, get max size he can be (assuming he's not ducking)
theSuccess = AvHSHUGetSizeForPlayerUser3 ( inUser3 , outMinSize , outMaxSize , false ) ;
if ( ! theSuccess )
{
AvHMessageID theMessageID = MESSAGE_NULL ;
// Convert it to a AvHMessageID if possible
if ( AvHSHUUser3ToMessageID ( inUser3 , theMessageID ) )
{
theSuccess = AvHSHUGetSizeForTech ( theMessageID , outMinSize , outMaxSize ) ;
}
}
return theSuccess ;
}
bool AvHSHUUser3ToMessageID ( AvHUser3 inUser3 , AvHMessageID & outMessageID )
{
AvHMessageID theMessageID = MESSAGE_NULL ;
bool theSuccess = false ;
switch ( inUser3 )
{
case AVH_USER3_FUNC_RESOURCE :
case AVH_USER3_RESTOWER :
theMessageID = BUILD_RESOURCES ;
break ;
case AVH_USER3_COMMANDER_STATION :
theMessageID = BUILD_COMMANDSTATION ;
break ;
case AVH_USER3_TURRET_FACTORY :
case AVH_USER3_ADVANCED_TURRET_FACTORY :
theMessageID = BUILD_TURRET_FACTORY ;
break ;
case AVH_USER3_ARMORY :
case AVH_USER3_ADVANCED_ARMORY :
theMessageID = BUILD_ARMORY ;
break ;
case AVH_USER3_ARMSLAB :
theMessageID = BUILD_ARMSLAB ;
break ;
case AVH_USER3_PROTOTYPE_LAB :
theMessageID = BUILD_PROTOTYPE_LAB ;
break ;
case AVH_USER3_OBSERVATORY :
theMessageID = BUILD_OBSERVATORY ;
break ;
case AVH_USER3_TURRET :
theMessageID = BUILD_TURRET ;
break ;
case AVH_USER3_SIEGETURRET :
theMessageID = BUILD_SIEGE ;
break ;
case AVH_USER3_INFANTRYPORTAL :
theMessageID = BUILD_INFANTRYPORTAL ;
break ;
case AVH_USER3_PHASEGATE :
theMessageID = BUILD_PHASEGATE ;
break ;
case AVH_USER3_HEAVY :
theMessageID = BUILD_HEAVY ;
break ;
case AVH_USER3_JETPACK :
theMessageID = BUILD_JETPACK ;
break ;
case AVH_USER3_DEFENSE_CHAMBER :
theMessageID = ALIEN_BUILD_DEFENSE_CHAMBER ;
break ;
case AVH_USER3_MOVEMENT_CHAMBER :
theMessageID = ALIEN_BUILD_MOVEMENT_CHAMBER ;
break ;
case AVH_USER3_OFFENSE_CHAMBER :
theMessageID = ALIEN_BUILD_OFFENSE_CHAMBER ;
break ;
case AVH_USER3_SENSORY_CHAMBER :
theMessageID = ALIEN_BUILD_SENSORY_CHAMBER ;
break ;
case AVH_USER3_ALIENRESTOWER :
theMessageID = ALIEN_BUILD_RESOURCES ;
break ;
case AVH_USER3_HIVE :
theMessageID = ALIEN_BUILD_HIVE ;
break ;
case AVH_USER3_ALIEN_PLAYER1 :
theMessageID = ALIEN_LIFEFORM_ONE ;
break ;
case AVH_USER3_ALIEN_PLAYER2 :
theMessageID = ALIEN_LIFEFORM_TWO ;
break ;
case AVH_USER3_ALIEN_PLAYER3 :
theMessageID = ALIEN_LIFEFORM_THREE ;
break ;
case AVH_USER3_ALIEN_PLAYER4 :
theMessageID = ALIEN_LIFEFORM_FOUR ;
break ;
case AVH_USER3_ALIEN_PLAYER5 :
theMessageID = ALIEN_LIFEFORM_FIVE ;
break ;
}
if ( theMessageID ! = MESSAGE_NULL )
{
outMessageID = theMessageID ;
theSuccess = true ;
}
return theSuccess ;
}
bool AvHSHUMessageIDToUser3 ( AvHMessageID inMessageID , AvHUser3 & outUser3 )
{
bool theSuccess = false ;
AvHUser3 theUser3 = AVH_USER3_NONE ;
switch ( inMessageID )
{
case BUILD_RESOURCES :
theUser3 = AVH_USER3_RESTOWER ;
break ;
case BUILD_COMMANDSTATION :
theUser3 = AVH_USER3_COMMANDER_STATION ;
break ;
case BUILD_TURRET_FACTORY :
theUser3 = AVH_USER3_TURRET_FACTORY ;
break ;
case TURRET_FACTORY_UPGRADE :
theUser3 = AVH_USER3_ADVANCED_TURRET_FACTORY ;
break ;
case BUILD_ARMORY :
theUser3 = AVH_USER3_ARMORY ;
break ;
case ARMORY_UPGRADE :
theUser3 = AVH_USER3_ADVANCED_ARMORY ;
break ;
case BUILD_ARMSLAB :
theUser3 = AVH_USER3_ARMSLAB ;
break ;
case BUILD_PROTOTYPE_LAB :
theUser3 = AVH_USER3_PROTOTYPE_LAB ;
break ;
case BUILD_OBSERVATORY :
theUser3 = AVH_USER3_OBSERVATORY ;
break ;
case BUILD_TURRET :
theUser3 = AVH_USER3_TURRET ;
break ;
case BUILD_SIEGE :
theUser3 = AVH_USER3_SIEGETURRET ;
break ;
case BUILD_INFANTRYPORTAL :
theUser3 = AVH_USER3_INFANTRYPORTAL ;
break ;
case BUILD_PHASEGATE :
theUser3 = AVH_USER3_PHASEGATE ;
break ;
case BUILD_HEAVY :
theUser3 = AVH_USER3_HEAVY ;
break ;
case BUILD_JETPACK :
theUser3 = AVH_USER3_JETPACK ;
break ;
// Menus
case MENU_BUILD :
theUser3 = AVH_USER3_MENU_BUILD ;
break ;
case MENU_BUILD_ADVANCED :
theUser3 = AVH_USER3_MENU_BUILD_ADVANCED ;
break ;
case MENU_ASSIST :
theUser3 = AVH_USER3_MENU_ASSIST ;
break ;
case MENU_EQUIP :
theUser3 = AVH_USER3_MENU_EQUIP ;
break ;
// Weapons
case BUILD_MINES :
theUser3 = AVH_USER3_MINE ;
break ;
// Lifeforms
case ALIEN_LIFEFORM_ONE :
theUser3 = AVH_USER3_ALIEN_PLAYER1 ;
break ;
case ALIEN_LIFEFORM_TWO :
theUser3 = AVH_USER3_ALIEN_PLAYER2 ;
break ;
case ALIEN_LIFEFORM_THREE :
theUser3 = AVH_USER3_ALIEN_PLAYER3 ;
break ;
case ALIEN_LIFEFORM_FOUR :
theUser3 = AVH_USER3_ALIEN_PLAYER4 ;
break ;
case ALIEN_LIFEFORM_FIVE :
theUser3 = AVH_USER3_ALIEN_PLAYER5 ;
break ;
}
if ( theUser3 ! = AVH_USER3_NONE )
{
outUser3 = theUser3 ;
theSuccess = true ;
}
return theSuccess ;
}
float AvHSHUGetTime ( )
{
float theTime = 0 ;
# ifdef AVH_SERVER
theTime = gpGlobals - > time ;
# else
theTime = gEngfuncs . GetClientTime ( ) ;
# endif
return theTime ;
}
// Note, all these models must be precached already
char * AvHSHUGetBuildTechModelName ( AvHMessageID inMessageID )
{
char * theModelName = NULL ;
switch ( inMessageID )
{
case BUILD_RESOURCES :
theModelName = kResourceTowerModel ;
break ;
//case BUILD_REINFORCEMENTS:
// theModelName = kInfantryPortalModel;
// break;
case BUILD_INFANTRYPORTAL :
theModelName = kInfantryPortalModel ;
break ;
case BUILD_COMMANDSTATION :
theModelName = kCommandStationModel ;
break ;
case BUILD_TURRET_FACTORY :
theModelName = kTurretFactoryModel ;
break ;
case BUILD_ARMSLAB :
theModelName = kArmsLabModel ;
break ;
case BUILD_PROTOTYPE_LAB :
theModelName = kPrototypeLabModel ;
break ;
case BUILD_ARMORY :
theModelName = kArmoryModel ;
break ;
case ARMORY_UPGRADE :
theModelName = kAdvancedWeaponFactoryModel ;
break ;
case BUILD_OBSERVATORY :
theModelName = kObservatoryModel ;
break ;
case BUILD_SCAN :
theModelName = kScanModel ;
break ;
case BUILD_PHASEGATE :
theModelName = kPhaseGateModel ;
break ;
case BUILD_TURRET :
theModelName = kDeployedTurretModel ;
break ;
case BUILD_NUKE :
theModelName = kNukeModel ;
break ;
case BUILD_SIEGE :
theModelName = kSiegeTurretModel ;
//theModelName = kDeployedTurretModel;
break ;
case BUILD_CAT :
theModelName = kCatalystModel ;
break ;
case BUILD_HEALTH :
theModelName = kHealthModel ;
break ;
case BUILD_HEAVY :
theModelName = kHeavyModel ;
break ;
case BUILD_JETPACK :
theModelName = kJetpackModel ;
break ;
case BUILD_AMMO :
theModelName = kAmmoModel ;
break ;
case BUILD_WELDER :
theModelName = kWelderWModel ;
break ;
case BUILD_MINES :
theModelName = kTripmineW2Model ;
break ;
case BUILD_SHOTGUN :
theModelName = kSGWModel ;
break ;
case BUILD_HMG :
theModelName = kHMGWModel ;
break ;
case BUILD_GRENADE_GUN :
theModelName = kGGWModel ;
break ;
// Alien buildings
case ALIEN_BUILD_HIVE :
theModelName = kHiveModel ;
break ;
case ALIEN_BUILD_RESOURCES :
theModelName = kAlienResourceTowerModel ;
break ;
case ALIEN_BUILD_OFFENSE_CHAMBER :
theModelName = kOffenseChamberModel ;
break ;
case ALIEN_BUILD_DEFENSE_CHAMBER :
theModelName = kDefenseChamberModel ;
break ;
case ALIEN_BUILD_SENSORY_CHAMBER :
theModelName = kSensoryChamberModel ;
break ;
case ALIEN_BUILD_MOVEMENT_CHAMBER :
theModelName = kMovementChamberModel ;
break ;
}
return theModelName ;
}
bool AvHSHUGetBuildTechRange ( AvHMessageID inMessageID , float & outRange )
{
bool theSuccess = false ;
// switch(inMessageID)
// {
// case BUILD_CAMERA:
// outRange = kResourceTowerSightRange;
// theSuccess = true;
// break;
// case BUILD_PHASEGATE:
// break;
// case BUILD_TURRET:
// outRange = TURRET_RANGE;
// theSuccess = true;
// break;
// case BUILD_SIEGE:
// outRange = kSiegeTurretMaxRange;
// theSuccess = true;
// break;
// }
return theSuccess ;
}
bool AvHSHUTraceLineIsAreaFree ( Vector & inStart , Vector & inEnd , edict_t * inIgnoreEntity , bool inIgnorePlayers )
{
bool theAreaIsFree = true ;
# ifdef AVH_SERVER
TraceResult theTR ;
bool theIsDone = false ;
// Do tracelines between the corners, to make sure there's no geometry inside the box
int theNumIters = 0 ;
IGNORE_MONSTERS theIgnoreMonsters = dont_ignore_monsters ;
if ( inIgnorePlayers )
{
theIgnoreMonsters = ignore_monsters ;
}
while ( ! theIsDone )
{
UTIL_TraceLine ( inStart , inEnd , theIgnoreMonsters , inIgnoreEntity , & theTR ) ;
if ( theTR . flFraction ! = 1.0f )
{
CBaseEntity * theEntity = CBaseEntity : : Instance ( ENT ( theTR . pHit ) ) ;
if ( theEntity & & ( theEntity - > pev - > solid ! = SOLID_BBOX ) & & ( theEntity - > pev - > solid ! = SOLID_SLIDEBOX ) & & ( theEntity - > pev - > solid ! = SOLID_BSP ) & & ( inIgnorePlayers ! = ! ! theEntity - > IsPlayer ( ) ) )
{
VectorCopy ( theTR . vecEndPos , inStart ) ;
}
else
{
theIsDone = true ;
theAreaIsFree = false ;
}
}
else
{
theIsDone = true ;
}
if ( theNumIters + + > 50 )
{
theIsDone = true ;
theAreaIsFree = false ;
}
}
# endif
// int theIndex;
// vec3_t theEndLocation;
// AvHTeamNumber theTeam;
// bool thePlayerHit;
// int theUserThree;
// int theUserFour;
//
// if(AvHSHUTraceTangible(inStart, inEnd, theIndex, theEndLocation, theTeam, thePlayerHit, theUserThree, theUserFour))
// {
// if(theIndex >= 0)
// {
// theAreaIsFree = false;
// }
// }
return theAreaIsFree ;
}
float AvHTraceLineAgainstWorld ( Vector & vecStart , Vector & vecEnd )
{
# ifdef AVH_SERVER
TraceResult tr ;
UTIL_TraceLine ( vecStart , vecEnd , ignore_monsters , dont_ignore_glass , NULL , & tr ) ;
return tr . flFraction ;
# endif
# ifdef AVH_CLIENT
// This may not be the most efficient way, but it seems to get the job done.
float theFraction = 1 ;
for ( int i = 0 ; i < kMaxEntities & & theFraction > 0 ; + + i )
{
cl_entity_t * theEntity = gEngfuncs . GetEntityByIndex ( i ) ;
if ( theEntity ! = NULL & & theEntity - > model ! = NULL & & theEntity - > model - > type = = mod_brush )
{
vec3_t localStart ;
vec3_t localEnd ;
// Translate the start and end into the model's frame of reference.
VectorSubtract ( vecStart , theEntity - > origin , localStart ) ;
VectorSubtract ( vecEnd , theEntity - > origin , localEnd ) ;
// Rotate the start and end into the model's frame of reference.
if ( theEntity - > angles [ 0 ] | |
theEntity - > angles [ 1 ] | |
theEntity - > angles [ 2 ] )
{
vec3_t forward ;
vec3_t right ;
vec3_t up ;
AngleVectors ( theEntity - > angles , forward , right , up ) ;
vec3_t temp ;
VectorCopy ( localStart , temp ) ;
localStart [ 0 ] = DotProduct ( temp , forward ) ;
localStart [ 1 ] = - DotProduct ( temp , right ) ;
localStart [ 2 ] = DotProduct ( temp , up ) ;
VectorCopy ( localEnd , temp ) ;
localEnd [ 0 ] = DotProduct ( temp , forward ) ;
localEnd [ 1 ] = - DotProduct ( temp , right ) ;
localEnd [ 2 ] = DotProduct ( temp , up ) ;
}
trace_t tr ;
NS_TraceLine ( & theEntity - > model - > hulls [ 0 ] , localStart , localEnd , & tr ) ;
if ( tr . fraction < theFraction )
{
theFraction = tr . fraction ;
}
}
}
return theFraction ;
# endif
}
bool AvHSHUGetCanBeBuiltOnPlayers ( AvHMessageID inMessageID )
{
bool theCanBeBuiltOnPlayers = false ;
switch ( inMessageID )
{
case ALIEN_BUILD_HIVE :
case BUILD_SCAN :
case BUILD_AMMO :
case BUILD_HEALTH :
case BUILD_CAT :
case BUILD_MINES :
case BUILD_WELDER :
case BUILD_SHOTGUN :
case BUILD_HMG :
case BUILD_GRENADE_GUN :
case BUILD_HEAVY :
case BUILD_JETPACK :
theCanBeBuiltOnPlayers = true ;
break ;
}
return theCanBeBuiltOnPlayers ;
}
bool AvHSHUGetIsSiteValidForBuild ( AvHMessageID inMessageID , Vector * inLocation , int inIgnoredEntityIndex )
{
//TODO: - check entity returned by client side commander trace for drop validity before we ever get this far
bool theSuccess = false ;
// Check that there's enough room for building
vec3_t theMinSize , theMaxSize ;
if ( AvHSHUGetSizeForTech ( inMessageID , theMinSize , theMaxSize , true ) )
{
// If it's a build with special placement requirements, check that here (this could modify the location also)
if ( AvHSHUGetAreSpecialBuildingRequirementsMet ( inMessageID , * inLocation ) )
{
// Assume mappers place hives correctly (it's such a showstopper if aliens can't create a hive because it's too close to a wall)
// KGP 4/28/04 - add res towers to hives for the same reason -- if a mapper didn't give room, it's a showstopper.
bool theIgnorePlayers = AvHSHUGetCanBeBuiltOnPlayers ( inMessageID ) ;
float theSlopeTangent = theIgnorePlayers ? kMaxEquipmentDropSlope : kMaxBuildingDropSlope ;
bool theSkipDropCheck = false ;
switch ( inMessageID )
{
case BUILD_RESOURCES :
theSkipDropCheck = true ;
break ;
case ALIEN_BUILD_RESOURCES :
theSkipDropCheck = true ;
break ;
case ALIEN_BUILD_HIVE :
theSkipDropCheck = true ;
break ;
}
if ( theSkipDropCheck | | AvHSHUGetCanDropItem ( * inLocation , theMinSize , theMaxSize , theSlopeTangent , inIgnoredEntityIndex , theIgnorePlayers ) )
{
//TODO: - better check for entity below drop, since it's often off center.
// Check to make sure building isn't being created on top of another building
vec3_t thePositionBelowBuild = * inLocation ;
thePositionBelowBuild . z = - kMaxMapDimension ;
int theIndex ;
vec3_t theEndLocation ;
AvHTeamNumber theTeam ;
bool thePlayerHit ;
int theUserThree ;
int theUserFour ;
// Don't allow building on any entities, except allow resource towers on top of func_resources
//TODO : use full list instead of physents, which isn't accounting for items the commander can't see
bool theHitSomething = AvHSHUTraceTangible ( * inLocation , thePositionBelowBuild , theIndex , theEndLocation , theTeam , thePlayerHit , theUserThree , theUserFour ) ;
//res building case
if ( inMessageID = = BUILD_RESOURCES | | inMessageID = = ALIEN_BUILD_RESOURCES )
{
# ifdef AVH_SERVER //on server, return false if occupied
FOR_ALL_ENTITIES ( kesFuncResource , AvHFuncResource * )
if ( ! theEntity - > GetIsOccupied ( ) ) // open for use
{
if ( VectorDistance ( theEntity - > pev - > origin , * inLocation ) < 20 ) //small enough that we don't check the wrong nozzle
{
theSuccess = ( ! theHitSomething | | theIndex < = 0 | | theUserThree = = AVH_USER3_FUNC_RESOURCE ) ;
break ;
}
}
END_FOR_ALL_ENTITIES ( kesFuncResource )
# else //on client the occupied function isn't available
theSuccess = ( ! theHitSomething | | theIndex < = 0 | | theUserThree = = AVH_USER3_FUNC_RESOURCE ) ;
# endif
}
else if ( inMessageID = = ALIEN_BUILD_HIVE )
{
theSuccess = true ;
//theSuccess = ( !theHitSomething || ( *inLocation[2] - theEndLocation[2] > 40.0f ) );
//#ifdef AVH_SERVER
// ALERT(at_console, "theHitSomething=%d theSuccess=%d\n", theHitSomething, theSuccess);
// ALERT(at_console, "%f\n", *inLocation[2] - theEndLocation[2]);
// ALERT(at_console, "{%f, %f, %f} : { %f, %f, %f }\n",
// inLocation[0], inLocation[1], inLocation[2],
// theEndLocation[0], theEndLocation[1], theEndLocation[2]);
//#endif
}
else if ( ! theHitSomething | | ( theIgnorePlayers & & thePlayerHit ) | | theIndex < = 0 )
{
// THEN it's a legal build spot and the building shows up green.
theSuccess = true ;
}
}
}
}
return theSuccess ;
}
int AvHSHUGetPointContents ( vec3_t inPoint )
{
int thePointContents = 0 ;
# ifdef AVH_SERVER
thePointContents = UTIL_PointContents ( inPoint ) ;
# endif
# ifdef AVH_CLIENT
gEngfuncs . pEventAPI - > EV_SetUpPlayerPrediction ( false , true ) ;
gEngfuncs . pEventAPI - > EV_PushPMStates ( ) ;
gEngfuncs . pEventAPI - > EV_SetSolidPlayers ( - 1 ) ;
gEngfuncs . pEventAPI - > EV_SetTraceHull ( 2 ) ;
thePointContents = gEngfuncs . PM_PointContents ( inPoint , NULL ) ;
gEngfuncs . pEventAPI - > EV_PopPMStates ( ) ;
# endif
return thePointContents ;
}
/*
* Check to see if the build or item is overlapping the world .
*/
bool AvHSHUGetIsVolumeContentNonsolid ( vec3_t inCenter , Vector & inMinSize , Vector & inMaxSize , edict_t * inIgnoreEntity , bool inIgnorePlayers )
{
float theMins [ 3 ] , theMaxs [ 3 ] ;
VectorAdd ( inCenter , inMinSize , theMins ) ;
VectorAdd ( inCenter , inMaxSize , theMaxs ) ;
bool theIsNonsolid = true ; //innocent until proven guilty
extern playermove_t * pmove ;
if ( pmove ! = NULL & & pmove - > physents [ 0 ] . model ! = NULL )
{
const hull_t * theHull = & pmove - > physents [ 0 ] . model - > hulls [ NS_GetValveHull ( 2 ) ] ;
int theContents = NS_BoxContents ( theHull , theHull - > firstclipnode , theMins , theMaxs ) ;
theIsNonsolid = ( theContents ! = CONTENT_SOLID ) ;
}
else //fallback if we're just starting a round
{
int theContents = AvHSHUGetPointContents ( inCenter ) ;
if ( theContents ! = CONTENT_SOLID )
{
//trace between each corner pair once looking for obstructions - 28 total comparisons
const static int MIN = 0 ;
const static int MAX = 1 ;
const static int NUM_CORNERS = 8 ;
int theIndex ;
Vector theCorners [ NUM_CORNERS ] ;
for ( int XPos = MIN ; XPos < = MAX ; + + XPos )
{
for ( int YPos = MIN ; YPos < = MAX ; + + YPos )
{
for ( int ZPos = MIN ; ZPos < = MAX ; + + ZPos )
{
theIndex = XPos + YPos * 2 + ZPos * 4 ;
theCorners [ theIndex ] . x = inCenter . x + ( ( XPos = = MIN ) ? inMinSize . x : inMaxSize . x ) ;
theCorners [ theIndex ] . y = inCenter . y + ( ( YPos = = MIN ) ? inMinSize . y : inMaxSize . y ) ;
theCorners [ theIndex ] . z = inCenter . z + ( ( ZPos = = MIN ) ? inMinSize . z : inMaxSize . z ) ;
}
}
}
for ( int startCorner = 0 ; startCorner < NUM_CORNERS ; + + startCorner )
{
for ( int endCorner = startCorner + 1 ; endCorner < NUM_CORNERS ; + + endCorner )
{
if ( ! AvHSHUTraceLineIsAreaFree ( theCorners [ startCorner ] , theCorners [ endCorner ] , inIgnoreEntity , inIgnorePlayers ) )
{
theIsNonsolid = false ;
break ;
}
}
if ( ! theIsNonsolid )
{
break ;
}
}
}
else
{
theIsNonsolid = false ;
}
}
return theIsNonsolid ;
}
bool AvHSHUGetIsAreaFree ( vec3_t inCenter , Vector & inMinSize , Vector & inMaxSize , edict_t * inIgnoreEntity , bool inIgnorePlayers )
{
bool theAreaIsFree = AvHSHUGetIsVolumeContentNonsolid ( inCenter , inMinSize , inMaxSize , inIgnoreEntity , inIgnorePlayers ) ;
if ( theAreaIsFree )
{
theAreaIsFree = ! AvHSHUGetEntitiesBlocking ( inCenter , inMinSize , inMaxSize , inIgnoreEntity , inIgnorePlayers ) ;
}
return theAreaIsFree ;
}
bool AvHSHUGetEntitiesBlocking ( Vector & inOrigin , Vector & inMinSize , Vector & inMaxSize , edict_t * inIgnoreEntity , bool inIgnorePlayers )
{
bool theEntBlocking = false ;
typedef vector < pair < int , Vector > > PhysEntListType ;
PhysEntListType theEntList ;
const int kSearchRadius = 800 ;
// Populate phys ent list
# ifdef AVH_SERVER
CBaseEntity * theEntity = NULL ;
while ( ( theEntity = UTIL_FindEntityInSphere ( theEntity , inOrigin , kSearchRadius ) ) ! = NULL )
{
// If entity is visible non-world object, add it
if ( ( theEntity - > pev - > team ! = TEAM_IND ) & & ( theEntity - > pev - > solid ! = SOLID_NOT & & theEntity - > pev - > solid ! = SOLID_TRIGGER ) )
{
AvHPlayer * thePlayer = dynamic_cast < AvHPlayer * > ( theEntity ) ;
if ( theEntity - > edict ( ) ! = inIgnoreEntity & & ! ( thePlayer ! = NULL & & inIgnorePlayers ) )
{
theEntList . push_back ( make_pair ( theEntity - > pev - > iuser3 , theEntity - > pev - > origin ) ) ;
}
}
}
# endif
# ifdef AVH_CLIENT
// Haven't implemented this, so depend on it not being passed in
ASSERT ( inIgnoreEntity = = NULL ) ;
for ( int i = 0 ; i < pmove - > numphysent ; i + + )
{
physent_t * thePhysEnt = pmove - > physents + i ;
if ( ( thePhysEnt - > team ! = TEAM_IND ) & & ( thePhysEnt - > solid ! = SOLID_NOT & & thePhysEnt - > solid ! = SOLID_TRIGGER ) )
{
theEntList . push_back ( make_pair ( thePhysEnt - > iuser3 , thePhysEnt - > origin ) ) ;
}
}
# endif
Vector theAbsMax ;
VectorAdd ( inOrigin , inMaxSize , theAbsMax ) ;
Vector theAbsMin ;
VectorAdd ( inOrigin , inMinSize , theAbsMin ) ;
Vector theOrigin1 ;
VectorAdd ( theAbsMax , theAbsMin , theOrigin1 ) ;
theOrigin1 = theOrigin1 * .5f ;
Vector theSize1 ;
VectorSubtract ( theAbsMax , theAbsMin , theSize1 ) ;
theSize1 = theSize1 * .5f ;
// Do collision on list, making sure none are too close to inOrigin
for ( PhysEntListType : : iterator theIter = theEntList . begin ( ) ; theIter ! = theEntList . end ( ) ; theIter + + )
{
// Get size for tech
Vector theMinSize , theMaxSize ;
if ( AvHSHUGetSizeForUser3 ( AvHUser3 ( theIter - > first ) , theMinSize , theMaxSize ) )
{
Vector theEntOrigin = theIter - > second ;
Vector theAbsMax ;
VectorAdd ( theEntOrigin , theMaxSize , theAbsMax ) ;
Vector theAbsMin ;
VectorAdd ( theEntOrigin , inMinSize , theAbsMin ) ;
Vector theOrigin2 ;
VectorAdd ( theAbsMax , theAbsMin , theOrigin2 ) ;
theOrigin2 = theOrigin2 * .5f ;
Vector theSize2 ;
VectorSubtract ( theAbsMax , theAbsMin , theSize2 ) ;
theSize2 = theSize2 * .5f ;
// Do simple box collision here
if ( NS_BoxesOverlap ( ( float * ) theOrigin1 , ( float * ) theSize1 , ( float * ) theOrigin2 , ( float * ) theSize2 ) )
{
theEntBlocking = true ;
break ;
}
}
}
return theEntBlocking ;
}
void AvHSHUMakeViewFriendlyKillerName ( string & ioKillerName )
{
string theOutputName = ioKillerName ;
2005-04-01 03:04:57 +00:00
int theStrLen = ( int ) ioKillerName . length ( ) ;
2005-03-09 01:31:56 +00:00
if ( ! strncmp ( ioKillerName . c_str ( ) , " weapon_ " , 7 ) )
{
theOutputName = ioKillerName . substr ( 7 ) ;
}
else if ( ! strncmp ( ioKillerName . c_str ( ) , " monster_ " , 8 ) )
{
theOutputName = ioKillerName . substr ( 8 ) ;
}
else if ( ! strncmp ( ioKillerName . c_str ( ) , " func_ " , 5 ) )
{
theOutputName = ioKillerName . substr ( 5 ) ;
}
ioKillerName = theOutputName ;
}
bool AvHSHUGetCanDropItem ( vec3_t & ioCenter , Vector & inMinSize , Vector & inMaxSize , float inMaxSlopeTangent , int inIgnoreIndex , bool inIgnorePlayers )
{
float theMaxXWidth = max ( - inMinSize [ 0 ] , inMaxSize [ 0 ] ) ;
float theMaxYWidth = max ( - inMinSize [ 1 ] , inMaxSize [ 1 ] ) ;
float theRadius = sqrt ( theMaxXWidth * theMaxXWidth + theMaxYWidth * theMaxYWidth ) ;
float theHeight = inMaxSize [ 2 ] - inMinSize [ 2 ] ;
//adjust origin to be base
float theOrigin [ 3 ] = { ioCenter [ 0 ] , ioCenter [ 1 ] , ioCenter [ 2 ] + inMinSize [ 2 ] } ;
CollisionChecker Checker ( pmove , kHLPointHullIndex , CollisionChecker : : HULL_TYPE_ALL , inIgnorePlayers , CollisionChecker : : IGNORE_NONE , inIgnoreIndex ) ;
bool theCanDropItem = ( Checker . GetContentsInCylinder ( theOrigin , theRadius , theHeight ) ! = CONTENTS_SOLID ) ;
if ( ! theCanDropItem ) //can't place it -- can we drop it?
{
float theMaxDropHeight = theRadius * inMaxSlopeTangent ;
float theDropOrigin [ 3 ] = { theOrigin [ 0 ] , theOrigin [ 1 ] , theOrigin [ 2 ] + theMaxDropHeight } ;
theCanDropItem = ( Checker . GetContentsInCylinder ( theDropOrigin , theRadius , theHeight ) ! = CONTENTS_SOLID ) ;
if ( theCanDropItem ) //can drop it -- get as low to ground as possible for drop
{
float theBestDropHeight = theMaxDropHeight ;
float theShiftFraction = 1.0f ;
for ( float theShiftAdjust = 0.5f ; theShiftAdjust > 0.05f ; theShiftAdjust / = 2 )
{
theShiftFraction + = theShiftAdjust * ( theCanDropItem ? - 1 : 1 ) ; //try lower if last was a success
theDropOrigin [ 2 ] = theMaxDropHeight ;
theDropOrigin [ 2 ] * = theShiftFraction ;
theDropOrigin [ 2 ] + = theOrigin [ 2 ] ;
theCanDropItem = ( Checker . GetContentsInCylinder ( theDropOrigin , theRadius , theHeight ) ! = CONTENTS_SOLID ) ;
if ( theCanDropItem )
{
theBestDropHeight = theShiftFraction ;
theBestDropHeight * = theMaxDropHeight ;
}
}
//adjust center to best position
ioCenter [ 2 ] + = theBestDropHeight ;
theCanDropItem = true ;
}
}
return theCanDropItem ;
}
bool AvHSHUTraceAndGetIsSiteValidForBuild ( AvHMessageID inMessageID , const Vector & inPointOfView , const Vector & inNormRay , Vector * outLocation )
{
bool theSuccess = false ;
// TODO: Check if area is within the mapextents
int theUser3 ;
bool theTraceSuccess = AvHSHUTraceTangible ( inPointOfView , inNormRay , & theUser3 , outLocation ) ;
// tankefugl: 0000291
// ignore trace for scans (removed due to cost being paid when drop failed)
//if (inMessageID == BUILD_SCAN)
//{
// theSuccess = true;
//}
//else
// :tankefugl
if ( theTraceSuccess )
{
// tankefugl: 0000291
if ( ( inMessageID = = BUILD_SCAN ) | | ( AvHSHUGetIsSiteValidForBuild ( inMessageID , outLocation ) ) )
// :tankefugl
{
theSuccess = true ;
}
}
return theSuccess ;
}
# ifdef AVH_CLIENT
bool AvHSHUGetEntityAtRay ( const Vector & inPointOfView , const Vector & inNormRay , int & outEntIndex )
{
bool theSuccess = false ;
// Offset starting position a little so we don't select ourselves
Vector theStartPosition ;
VectorMA ( inPointOfView , kSelectionStartRange , inNormRay , theStartPosition ) ;
Vector theEndPos ;
VectorMA ( inPointOfView , kSelectionEndRange , inNormRay , theEndPos ) ;
gEngfuncs . pEventAPI - > EV_SetUpPlayerPrediction ( false , true ) ;
// Store off the old count
gEngfuncs . pEventAPI - > EV_PushPMStates ( ) ;
// Now add in all of the players.
int theNumPlayers = gEngfuncs . GetMaxClients ( ) ;
gEngfuncs . pEventAPI - > EV_SetSolidPlayers ( - 1 ) ;
bool theDone = false ;
int theEntityIndex = - 1 ;
vec3_t theNewStartPos ;
AvHSHUGetFirstNonSolidPoint ( theStartPosition , theEndPos , theNewStartPos ) ;
VectorCopy ( theNewStartPos , theStartPosition ) ;
do
{
pmtrace_t tr ;
gEngfuncs . pEventAPI - > EV_SetTraceHull ( 2 ) ;
gEngfuncs . pEventAPI - > EV_PlayerTrace ( theStartPosition , theEndPos , PM_NORMAL , theEntityIndex , & tr ) ;
physent_t * pEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( tr . ent ) ;
theEntityIndex = gEngfuncs . pEventAPI - > EV_IndexFromTrace ( & tr ) ;
if ( pEntity )
{
int theUser3 = pEntity - > iuser3 ;
if ( theEntityIndex > 0 )
{
outEntIndex = theEntityIndex ;
theSuccess = true ;
theDone = true ;
}
}
if ( ( tr . fraction > = ( 1.0f - kFloatTolerance ) ) | | ( tr . fraction < kFloatTolerance ) )
{
theDone = true ;
}
else
{
VectorCopy ( tr . endpos , theStartPosition ) ;
}
} while ( ! theDone ) ;
gEngfuncs . pEventAPI - > EV_PopPMStates ( ) ;
return theSuccess ;
}
# endif
# ifdef AVH_SERVER
bool AvHSHUGetEntityAtRay ( const Vector & inPointOfView , const Vector & inNormRay , int & outEntIndex )
{
TraceResult tr ;
Vector theStartPos ;
Vector theEndPos ;
bool theSuccess = false ;
bool theDone = false ;
VectorMA ( inPointOfView , kSelectionStartRange , inNormRay , theStartPos ) ;
VectorMA ( inPointOfView , kSelectionEndRange , inNormRay , theEndPos ) ;
CBaseEntity * theEntityHit = NULL ;
edict_t * theEdictToIgnore = NULL ;
vec3_t theNewStartPos ;
AvHSHUGetFirstNonSolidPoint ( theStartPos , theEndPos , theNewStartPos ) ;
VectorCopy ( theNewStartPos , theStartPos ) ;
do
{
UTIL_TraceLine ( theStartPos , theEndPos , dont_ignore_monsters , ignore_glass , theEdictToIgnore , & tr ) ;
theEntityHit = CBaseEntity : : Instance ( tr . pHit ) ;
if ( theEntityHit )
{
if ( theEntityHit - > entindex ( ) > 0 )
{
outEntIndex = theEntityHit - > entindex ( ) ;
theSuccess = true ;
theDone = true ;
}
}
if ( ( tr . flFraction > ( 1.0f - kFloatTolerance ) ) | | ( tr . flFraction < kFloatTolerance ) )
{
theDone = true ;
}
else
{
if ( theEntityHit )
{
theEdictToIgnore = ENT ( theEntityHit - > pev ) ;
}
VectorCopy ( tr . vecEndPos , theStartPos ) ;
}
} while ( ! theDone ) ;
return theSuccess ;
}
# endif
const AvHMapExtents & AvHSHUGetMapExtents ( )
{
# ifdef AVH_CLIENT
const AvHMapExtents & theMapExtents = gHUD . GetMapExtents ( ) ;
# endif
# ifdef AVH_SERVER
const AvHMapExtents & theMapExtents = GetGameRules ( ) - > GetMapExtents ( ) ;
# endif
return theMapExtents ;
}
# ifdef AVH_CLIENT
bool AvHSUClientTraceTangible ( const vec3_t & inStartPos , const vec3_t & inEndPos , int & outIndex , vec3_t & outLocation , AvHTeamNumber & outTeamNumber , bool & outPlayerWasHit , int & outUserThree , int & outUserFour )
{
physent_t * theEntity = NULL ;
vec3_t theStartPos ;
vec3_t theEndPos ;
int theFoundEntity = - 1 ;
bool theSuccess = false ;
bool theDone = false ;
VectorCopy ( inStartPos , theStartPos ) ;
VectorCopy ( inEndPos , theEndPos ) ;
vec3_t theNormal ;
VectorSubtract ( inEndPos , inStartPos , theNormal ) ;
VectorNormalize ( theNormal ) ;
outIndex = - 1 ;
gEngfuncs . pEventAPI - > EV_SetUpPlayerPrediction ( false , true ) ;
// Store off the old count
gEngfuncs . pEventAPI - > EV_PushPMStates ( ) ;
// Now add in all of the players.
int theNumPlayers = gEngfuncs . GetMaxClients ( ) ;
gEngfuncs . pEventAPI - > EV_SetSolidPlayers ( - 1 ) ;
vec3_t theNewStartPos ;
AvHSHUGetFirstNonSolidPoint ( theStartPos , theEndPos , theNewStartPos ) ;
VectorCopy ( theNewStartPos , theStartPos ) ;
do
{
pmtrace_t tr ;
gEngfuncs . pEventAPI - > EV_SetTraceHull ( 2 ) ;
gEngfuncs . pEventAPI - > EV_PlayerTrace ( theStartPos , theEndPos , PM_NORMAL /*PM_GLASS_IGNORE*/ , theFoundEntity , & tr ) ;
physent_t * pEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( tr . ent ) ;
theFoundEntity = gEngfuncs . pEventAPI - > EV_IndexFromTrace ( & tr ) ;
if ( pEntity )
{
if ( pEntity - > iuser3 ! = AVH_USER3_NONE )
{
VectorCopy ( tr . endpos , outLocation ) ;
outIndex = theFoundEntity ;
theEntity = pEntity ;
outUserThree = pEntity - > iuser3 ;
outUserFour = pEntity - > iuser4 ;
outTeamNumber = ( AvHTeamNumber ) ( pEntity - > team ) ;
if ( pEntity - > player )
{
outPlayerWasHit = true ;
}
theSuccess = true ;
theDone = true ;
}
}
if ( tr . fraction > = ( 1.0f - kFloatTolerance ) )
{
theDone = true ;
}
else
{
vec3_t theDiff = theNormal * kHitOffsetAmount ;
float theLength = sqrt ( theDiff . x * theDiff . x + theDiff . y * theDiff . y + theDiff . z * theDiff . z ) ;
if ( theLength > kFloatTolerance )
{
VectorAdd ( tr . endpos , theDiff , theStartPos ) ;
}
else
{
theDone = true ;
}
// Offset a bit so we don't hit again
//VectorMA(tr.endpos, kHitOffsetAmount, theNormal, theStartPos);
}
} while ( ! theDone ) ;
gEngfuncs . pEventAPI - > EV_PopPMStates ( ) ;
// If we didn't hit any special targets, see if it's a valid area to build or be ordered to
if ( ! theSuccess )
{
WaypointReturnCode theReturnCode = WAYPOINT_SUCCESS ;
theSuccess = AvHSHUClientTraceWaypoint ( inStartPos , inEndPos , & outLocation , & theReturnCode ) ;
bool theWaypointTooSteep = ( theReturnCode = = WAYPOINT_TOOSTEEP ) ;
if ( theSuccess | | theWaypointTooSteep )
{
outUserThree = AVH_USER3_WAYPOINT ;
outPlayerWasHit = false ;
outIndex = - 1 ;
outTeamNumber = TEAM_IND ;
theSuccess = true ;
}
// Treat too steep as success, but mark it as nobuild
if ( theWaypointTooSteep )
{
outUserThree = AVH_USER3_NOBUILD ;
}
}
return theSuccess ;
}
# endif
# ifdef AVH_SERVER
bool AvHSUServerTraceTangible ( const vec3_t & inStartPos , const vec3_t & inEndPos , int & outIndex , vec3_t & outLocation , AvHTeamNumber & outTeamNumber , bool & outPlayerWasHit , int & outUserThree , int & outUserFour )
{
bool theSuccess = false ;
bool theDone = false ;
edict_t * theEdictToIgnore = NULL ;
vec3_t theStartPos ;
vec3_t theEndPos ;
VectorCopy ( inStartPos , theStartPos ) ;
VectorCopy ( inEndPos , theEndPos ) ;
vec3_t theNormal ;
VectorSubtract ( inEndPos , inStartPos , theNormal ) ;
VectorNormalize ( theNormal ) ;
// vec3_t theNewStartPos;
// AvHSHUGetFirstNonSolidPoint(theStartPos, theEndPos, theNewStartPos);
// VectorCopy(theNewStartPos, theStartPos);
do
{
TraceResult tr ;
UTIL_TraceLine ( theStartPos , theEndPos , dont_ignore_monsters , theEdictToIgnore , & tr ) ;
CBaseEntity * theEntityHit = NULL ;
// Return the entity in special way
if ( tr . flFraction < 1 & & tr . pHit )
{
theEntityHit = CBaseEntity : : Instance ( tr . pHit ) ;
AvHPlayer * thePlayer = dynamic_cast < AvHPlayer * > ( theEntityHit ) ;
AvHWeldable * theWeldable = dynamic_cast < AvHWeldable * > ( theEntityHit ) ;
AvHBasePlayerWeapon * theWeapon = dynamic_cast < AvHBasePlayerWeapon * > ( theEntityHit ) ;
if ( AvHSUGetIsDebugging ( ) )
{
// Create an entity where the trace hit
Vector theAngles ( 0 , 0 , 0 ) ;
CBaseEntity * pEnt = CBaseEntity : : Create ( kwsDebugEntity , tr . vecEndPos , theAngles ) ;
ASSERT ( pEnt ) ;
pEnt - > pev - > movetype = MOVETYPE_FLY ;
pEnt - > pev - > solid = SOLID_NOT ;
}
if ( theEntityHit & & ( theEntityHit - > pev - > iuser3 ! = AVH_USER3_NONE ) )
{
// Don't hit seethroughs
if ( theEntityHit - > pev - > iuser3 ! = AVH_USER3_ALPHA )
{
outIndex = ENTINDEX ( tr . pHit ) ;
VectorCopy ( tr . vecEndPos , outLocation ) ;
outTeamNumber = ( AvHTeamNumber ) theEntityHit - > pev - > team ;
outUserThree = theEntityHit - > pev - > iuser3 ;
outUserFour = theEntityHit - > pev - > iuser4 ;
if ( thePlayer )
{
outPlayerWasHit = true ;
}
theSuccess = true ;
theDone = true ;
}
}
theEdictToIgnore = theEntityHit - > edict ( ) ;
}
if ( ( tr . flFraction > = ( 1.0f - kFloatTolerance ) ) | | ( tr . flFraction < kFloatTolerance ) )
{
theDone = true ;
}
else
{
vec3_t theDiff = theNormal * kHitOffsetAmount ;
float theLength = sqrt ( theDiff . x * theDiff . x + theDiff . y * theDiff . y + theDiff . z * theDiff . z ) ;
if ( theLength > kFloatTolerance )
{
VectorAdd ( theStartPos , theDiff , theStartPos ) ;
}
else
{
theDone = true ;
}
// Offset a bit so we don't hit again
//VectorMA(tr.vecEndPos, kHitOffsetAmount, theNormal, theStartPos);
}
} while ( ! theDone ) ;
if ( ! theSuccess )
{
WaypointReturnCode theReturnCode = WAYPOINT_SUCCESS ;
theSuccess = AvHSHUServerTraceWaypoint ( inStartPos , inEndPos , & outLocation , & theReturnCode ) ;
bool theWaypointTooSteep = ( theReturnCode = = WAYPOINT_TOOSTEEP ) ;
if ( theSuccess | | theWaypointTooSteep )
{
outUserThree = AVH_USER3_WAYPOINT ;
outPlayerWasHit = false ;
outIndex = - 1 ;
outTeamNumber = TEAM_IND ;
theSuccess = true ;
}
// Treat too steep as success, but mark it as nobuild
if ( theWaypointTooSteep )
{
outUserThree = AVH_USER3_NOBUILD ;
}
}
return theSuccess ;
}
# endif
# ifdef AVH_CLIENT
bool AvHSHUClientTraceWaypoint ( const vec3_t & inStartPos , const vec3_t & inEndPos , vec3_t * outLocation , WaypointReturnCode * outReturnCode )
{
vec3_t theStartPos ;
vec3_t theEndPos ;
int theFoundEntity = - 1 ;
int theEntityToIgnore = - 1 ;
bool theDone = false ;
bool theLegalToBuild = false ;
VectorCopy ( inStartPos , theStartPos ) ;
VectorCopy ( inEndPos , theEndPos ) ;
vec3_t theNormal ;
VectorSubtract ( inEndPos , inStartPos , theNormal ) ;
VectorNormalize ( theNormal ) ;
int theNumPlayers = gEngfuncs . GetMaxClients ( ) ;
pmtrace_t tr ;
//DebugPoint theDebugPoint(theStartPos[0], theStartPos[1], theStartPos[2]);
//gSquareDebugLocations.push_back(theDebugPoint);
gEngfuncs . pEventAPI - > EV_SetUpPlayerPrediction ( false , true ) ;
gEngfuncs . pEventAPI - > EV_PushPMStates ( ) ;
gEngfuncs . pEventAPI - > EV_SetSolidPlayers ( - 1 ) ;
gEngfuncs . pEventAPI - > EV_SetTraceHull ( 2 ) ;
vec3_t theNewStartPos ;
AvHSHUGetFirstNonSolidPoint ( theStartPos , theEndPos , theNewStartPos ) ;
VectorCopy ( theNewStartPos , theStartPos ) ;
do
{
gEngfuncs . pEventAPI - > EV_PlayerTrace ( theStartPos , theEndPos , PM_NORMAL /*PM_GLASS_IGNORE*/ , theEntityToIgnore , & tr ) ;
physent_t * pEntity = gEngfuncs . pEventAPI - > EV_GetPhysent ( tr . ent ) ;
theFoundEntity = gEngfuncs . pEventAPI - > EV_IndexFromTrace ( & tr ) ;
// Trace until we hit a worldbrush or non-seethrough
if ( ! pEntity | | ( pEntity - > iuser3 ! = AVH_USER3_ALPHA ) )
{
// If entity is a "no waypoint" entity we can't build here and we're done
if ( pEntity & & ( pEntity - > iuser3 = = AVH_USER3_NOBUILD ) )
{
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_NOBUILD ;
}
theDone = true ;
}
else
{
// else if texture is NOBUILD, we're done
const char * theTextureHitCStr = gEngfuncs . pEventAPI - > EV_TraceTexture ( theFoundEntity , tr . endpos , theEndPos ) ;
if ( theTextureHitCStr & & ( LowercaseString ( theTextureHitCStr ) = = LowercaseString ( kNoBuildTexture ) ) )
{
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_NOBUILD ;
}
theDone = true ;
}
else if ( theTextureHitCStr & & ( LowercaseString ( theTextureHitCStr ) = = LowercaseString ( kSeeThroughTexture ) ) )
{
// Not valid, but allow it to pass through
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_SEETHROUGH ;
}
}
else
{
// Trace texture sometimes seems to miss entities that the start point lies within. Don't count
// the trace texture if it found the texture of the next entity below it
// else if surface is more flat than vertical
if ( tr . plane . normal [ 2 ] > = 0.7f )
{
// and if surface isn't under water, lava, in the sky, etc.
int thePointContents = gEngfuncs . PM_PointContents ( tr . endpos , NULL ) ;
if ( thePointContents = = CONTENTS_EMPTY )
{
// and if there's enough room to build
// we can build here, and we're done
theLegalToBuild = true ;
theDone = true ;
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_SUCCESS ;
}
}
else
{
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_CONTENTSFULL ;
theDone = true ;
}
}
}
else
{
if ( outReturnCode )
{
if ( theTextureHitCStr )
{
* outReturnCode = WAYPOINT_TOOSTEEP ;
}
else
{
* outReturnCode = WAYPOINT_ENTITYHIT ;
}
theDone = true ;
}
}
}
}
}
if ( theFoundEntity ! = 0 )
{
theEntityToIgnore = theFoundEntity ;
}
if ( ( ( tr . fraction > = ( 1.0f - kFloatTolerance ) ) | | ( tr . fraction = = 0.0f ) ) /*&& !tr.startsolid && !tr.allsolid*/ )
{
theDone = true ;
}
else
{
vec3_t theDiff = theNormal * kHitOffsetAmount ;
float theLength = sqrt ( theDiff . x * theDiff . x + theDiff . y * theDiff . y + theDiff . z * theDiff . z ) ;
if ( theLength > kFloatTolerance )
{
VectorAdd ( tr . endpos , theDiff , theStartPos ) ;
}
else
{
theDone = true ;
}
// Offset a bit so we don't hit again
//VectorMA(tr.endpos, kHitOffsetAmount, theNormal, theStartPos);
}
} while ( ! theDone ) ;
gEngfuncs . pEventAPI - > EV_PopPMStates ( ) ;
// Always set end location to show where invalid position is
* outLocation = tr . endpos ;
return theLegalToBuild ;
}
# endif
# ifdef AVH_CLIENT
void AvHSHUClientGetFirstNonSolidPoint ( const vec3_t & inStartPos , const vec3_t & inEndPos , vec3_t & outNonSolidPoint )
{
vec3_t theStartPos ;
vec3_t theEndPos ;
VectorCopy ( inStartPos , theStartPos ) ;
VectorCopy ( inStartPos , outNonSolidPoint ) ;
VectorCopy ( inEndPos , theEndPos ) ;
pmtrace_t tr ;
gEngfuncs . pEventAPI - > EV_PlayerTrace ( theStartPos , theEndPos , PM_NORMAL , - 1 , & tr ) ;
// Put this workaround in because a bug in EV_PlayerTrace means that when it starts solid, tr.fraction isn't returned (but it is in UTIL_TraceLine)
if ( ( tr . startsolid ) & & ( tr . fraction = = 0.0f ) )
{
int theFoundEntity = - 1 ;
bool theDone = false ;
vec3_t theStartToEnd ;
VectorSubtract ( inEndPos , inStartPos , theStartToEnd ) ;
gEngfuncs . pEventAPI - > EV_SetTraceHull ( 2 ) ;
float theIncrement = 10.0f / theStartToEnd . Length ( ) ;
float theT = 0.0f ;
int theNumIterations = 0 ;
do
{
theStartPos = inStartPos + theT * theStartToEnd ;
gEngfuncs . pEventAPI - > EV_PlayerTrace ( theStartPos , theEndPos , PM_WORLD_ONLY , - 1 , & tr ) ;
theNumIterations + + ;
// If start point is solid, bisect area and move start point 1/2 between current start and current end
if ( tr . startsolid )
{
theT + = theIncrement ;
}
// else if start point isn't solid, bisect area and move start point back towards original start point
else
{
theDone = true ;
}
} while ( ! theDone & & ( theNumIterations < 200 ) ) ;
// Always set end location to show where invalid position is
if ( ! theDone )
{
outNonSolidPoint = inStartPos ;
}
else
{
outNonSolidPoint = theStartPos ;
}
}
}
# endif
# ifdef AVH_SERVER
void AvHSHUServerGetFirstNonSolidPoint ( const vec3_t & inStartPos , const vec3_t & inEndPos , vec3_t & outNonSolidPoint )
{
vec3_t theStartPos ;
vec3_t theEndPos ;
VectorCopy ( inStartPos , theStartPos ) ;
VectorCopy ( inStartPos , outNonSolidPoint ) ;
VectorCopy ( inEndPos , theEndPos ) ;
TraceResult tr ;
UTIL_TraceLine ( theStartPos , theEndPos , ignore_monsters , NULL , & tr ) ;
bool theDone = false ;
// Put this workaround in because a bug in EV_PlayerTrace means that when it starts solid, tr.fraction isn't returned (but it is in UTIL_TraceLine)
if ( ( tr . fStartSolid ) | | ( tr . flFraction = = 0.0f ) )
{
int theFoundEntity = - 1 ;
vec3_t theStartToEnd ;
VectorSubtract ( inEndPos , inStartPos , theStartToEnd ) ;
float theIncrement = 10.0f / theStartToEnd . Length ( ) ;
float theT = 0.0f ;
int theNumIterations = 0 ;
int thePointContents = 0 ;
do
{
theStartPos = inStartPos + theT * theStartToEnd ;
thePointContents = UTIL_PointContents ( theStartPos ) ;
theNumIterations + + ;
// If start point is solid, bisect area and move start point 1/2 between current start and current end
if ( ( thePointContents = = CONTENTS_SOLID ) | | ( thePointContents = = CONTENTS_SKY ) )
{
theT + = theIncrement ;
}
// else if start point isn't solid, bisect area and move start point back towards original start point
else
{
theDone = true ;
}
} while ( ! theDone & & ( theNumIterations < 200 ) ) ;
// Always set end location to show where invalid position is
outNonSolidPoint = theStartPos ;
}
else
{
VectorCopy ( tr . vecEndPos , outNonSolidPoint ) ;
theDone = true ;
}
if ( ! theDone )
{
// When we don't hit anything, return start point
VectorCopy ( inStartPos , outNonSolidPoint ) ;
}
VectorCopy ( outNonSolidPoint , gPMDebugPoint ) ;
}
# endif
void AvHSHUGetFirstNonSolidPoint ( float * inStartPos , float * inEndPos , float * outNonSolidPoint )
{
vec3_t theStartPos ;
vec3_t theEndPos ;
VectorCopy ( inStartPos , theStartPos ) ;
VectorCopy ( inEndPos , theEndPos ) ;
vec3_t theNonSolidPoint ;
AvHSHUGetFirstNonSolidPoint ( theStartPos , theEndPos , theNonSolidPoint ) ;
VectorCopy ( theNonSolidPoint , outNonSolidPoint ) ;
}
void AvHSHUGetFirstNonSolidPoint ( const vec3_t & inStartPos , const vec3_t & inEndPos , vec3_t & outNonSolidPoint )
{
# ifdef AVH_CLIENT
AvHSHUClientGetFirstNonSolidPoint ( inStartPos , inEndPos , outNonSolidPoint ) ;
//extern DebugPointListType gSquareDebugLocations;
//DebugPoint theDebugPoint(outNonSolidPoint[0], outNonSolidPoint[1], outNonSolidPoint[2]);
//gSquareDebugLocations.push_back(theDebugPoint);
# endif
# ifdef AVH_SERVER
AvHSHUServerGetFirstNonSolidPoint ( inStartPos , inEndPos , outNonSolidPoint ) ;
# endif
}
# ifdef AVH_SERVER
bool AvHSHUServerTraceWaypoint ( const vec3_t & inStartPos , const vec3_t & inEndPos , vec3_t * outLocation , WaypointReturnCode * outReturnCode )
{
bool theLegalToBuild = false ;
bool theDone = false ;
edict_t * theEdictToIgnore = NULL ;
TraceResult tr ;
vec3_t theStartPos ;
vec3_t theEndPos ;
VectorCopy ( inStartPos , theStartPos ) ;
VectorCopy ( inEndPos , theEndPos ) ;
vec3_t theNormal ;
VectorSubtract ( inEndPos , inStartPos , theNormal ) ;
VectorNormalize ( theNormal ) ;
vec3_t theNewStartPos ;
AvHSHUGetFirstNonSolidPoint ( theStartPos , theEndPos , theNewStartPos ) ;
VectorCopy ( theNewStartPos , theStartPos ) ;
do
{
UTIL_TraceLine ( theStartPos , theEndPos , dont_ignore_monsters , theEdictToIgnore , & tr ) ;
// Trace until we hit a worldbrush or non-seethrough
CBaseEntity * theEntityHit = CBaseEntity : : Instance ( tr . pHit ) ;
CWorld * theWorld = dynamic_cast < CWorld * > ( theEntityHit ) ;
bool theHitSeethrough = ( theEntityHit - > pev - > iuser3 = = AVH_USER3_ALPHA ) ;
if ( ! theHitSeethrough )
{
// If entity is a "no waypoint" entity we can't build here and we're done
if ( theEntityHit & & ( theEntityHit - > pev - > iuser3 = = AVH_USER3_NOBUILD ) )
{
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_NOBUILD ;
}
theDone = true ;
}
else
{
edict_t * theEdict = ENT ( theEntityHit - > pev ) ;
const char * theTextureHitCStr = TRACE_TEXTURE ( theEdict , tr . vecEndPos , theEndPos ) ;
if ( theTextureHitCStr & & ( LowercaseString ( theTextureHitCStr ) = = LowercaseString ( kNoBuildTexture ) ) )
{
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_NOBUILD ;
}
theDone = true ;
}
else if ( theTextureHitCStr & & ( LowercaseString ( theTextureHitCStr ) = = LowercaseString ( kSeeThroughTexture ) ) )
{
// Do nothing, but allow it to pass through
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_SEETHROUGH ;
}
}
else
{
// else if surface is more flat than vertical
if ( tr . vecPlaneNormal . z > = .7f )
{
// and if surface isn't under water, lava, sky
int thePointContents = UTIL_PointContents ( tr . vecEndPos ) ;
if ( thePointContents = = CONTENTS_EMPTY )
{
// and if there's enough room to build
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_SUCCESS ;
}
// we can build here, and we're done
theLegalToBuild = true ;
theDone = true ;
}
else
{
if ( outReturnCode )
{
* outReturnCode = WAYPOINT_CONTENTSFULL ;
}
}
}
else
{
if ( theTextureHitCStr )
{
* outReturnCode = WAYPOINT_TOOSTEEP ;
}
else
{
* outReturnCode = WAYPOINT_ENTITYHIT ;
}
theDone = true ;
}
}
}
if ( ! theWorld )
{
theEdictToIgnore = theEntityHit - > edict ( ) ;
}
if ( ( ( tr . flFraction > = ( 1.0f - kFloatTolerance ) ) | | ( tr . flFraction < kFloatTolerance ) ) /*&& !tr.fStartSolid && !tr.fAllSolid*/ )
{
theDone = true ;
}
else
{
vec3_t theDiff = theNormal * kHitOffsetAmount ;
float theLength = sqrt ( theDiff . x * theDiff . x + theDiff . y * theDiff . y + theDiff . z * theDiff . z ) ;
if ( theLength > kFloatTolerance )
{
//VectorAdd(tr.vecEndPos, theDiff, theStartPos);
VectorAdd ( theStartPos , theDiff , theStartPos ) ;
}
else
{
theDone = true ;
}
// Offset a bit so we don't hit again
//VectorMA(tr.vecEndPos, kHitOffsetAmount, theNormal, theStartPos);
}
}
else
{
theEdictToIgnore = theEntityHit - > edict ( ) ;
if ( tr . vecEndPos = = theStartPos )
{
vec3_t theDiff = theNormal * kHitOffsetAmount ;
float theLength = sqrt ( theDiff . x * theDiff . x + theDiff . y * theDiff . y + theDiff . z * theDiff . z ) ;
if ( theLength > kFloatTolerance )
{
//VectorAdd(tr.vecEndPos, theDiff, theStartPos);
VectorAdd ( theStartPos , theDiff , theStartPos ) ;
}
}
else
{
VectorCopy ( tr . vecEndPos , theStartPos ) ;
}
// vec3_t theEntityPosition = AvHSHUGetRealLocation(theEntityHit->pev->origin, theEntityHit->pev->mins, theEntityHit->pev->maxs);
// //VectorCopy(theEntityPosition, theStartPos);
// theStartPos[2] = theEntityPosition[2];
}
} while ( ! theDone ) ;
// Always set end location to show where invalid position is
* outLocation = tr . vecEndPos ;
return theLegalToBuild ;
}
# endif
bool AvHSHUTraceTangible ( const vec3_t & inStartPos , const vec3_t & inEndPos , int & outIndex , vec3_t & outLocation , AvHTeamNumber & outTeamNumber , bool & outPlayerWasHit , int & outUserThree , int & outUserFour )
{
bool theSuccess = false ;
outPlayerWasHit = false ;
outUserThree = 0 ;
outUserFour = 0 ;
// On client, set up players for prediction and do a PM_TraceLine
# ifdef AVH_CLIENT
theSuccess = AvHSUClientTraceTangible ( inStartPos , inEndPos , outIndex , outLocation , outTeamNumber , outPlayerWasHit , outUserThree , outUserFour ) ;
# endif
// On the server, do a UTIL_TraceLine
# ifdef AVH_SERVER
theSuccess = AvHSUServerTraceTangible ( inStartPos , inEndPos , outIndex , outLocation , outTeamNumber , outPlayerWasHit , outUserThree , outUserFour ) ;
# endif
return theSuccess ;
}
bool AvHSHUTraceTangible ( const Vector & inPointOfView , const Vector & inNormRay , int * outUserThree , vec3_t * outLocation , AvHTeamNumber * outTeamNumber , bool * outPlayerWasHit )
{
bool theSuccess = false ;
vec3_t theTraceStart ;
vec3_t theTraceEnd ;
vec3_t theFoundLocation ;
int theFoundIndex = - 1 ;
int theUserThree = 0 ;
int theUserFour = 0 ;
AvHTeamNumber theTeamOfThingHit ;
bool thePlayerHit = false ;
// Offset a little so we don't hit the commander
VectorMA ( inPointOfView , kSelectionStartRange , inNormRay , theTraceStart ) ;
VectorMA ( inPointOfView , kSelectionEndRange , inNormRay , theTraceEnd ) ;
if ( ! outUserThree )
outUserThree = & theUserThree ;
if ( ! outLocation )
outLocation = & theFoundLocation ;
if ( ! outTeamNumber )
outTeamNumber = & theTeamOfThingHit ;
if ( ! outPlayerWasHit )
outPlayerWasHit = & thePlayerHit ;
theSuccess = AvHSHUTraceTangible ( theTraceStart , theTraceEnd , theFoundIndex , * outLocation , * outTeamNumber , * outPlayerWasHit , * outUserThree , theUserFour ) ;
return theSuccess ;
}
bool AvHSHUTraceVerticalTangible ( float inX , float inY , float inZ , int & outUserThree , float & outHeight )
{
bool theSuccess = false ;
// Create a start pos above
vec3_t theStartPos ( inX , inY , inZ - 100.0f ) ;
//vec3_t theEndPos(inX, inY, inZ - 800.0f/*-4096.0f*/);
vec3_t theEndPos ( inX , inY , ( float ) kWorldMinimumZ ) ;
// #ifdef AVH_CLIENT
// extern DebugPointListType gTriDebugLocations;
// bool theDrawDebug = true;//(rand() % 100 == 0);
//
// if(theDrawDebug)
// {
// DebugPoint thePoint;
// thePoint.x = theStartPos.x;
// thePoint.y = theStartPos.y;
// thePoint.z = theStartPos.z;
// gTriDebugLocations.push_back(thePoint);
//
// thePoint.z = theEndPos.z;
// gTriDebugLocations.push_back(thePoint);
// }
//
// #endif
int theIndex ;
vec3_t theEndLocation ;
AvHTeamNumber theTeam ;
bool thePlayerHit ;
int theUserFour ;
theSuccess = AvHSHUTraceTangible ( theStartPos , theEndPos , theIndex , theEndLocation , theTeam , thePlayerHit , outUserThree , theUserFour ) ;
if ( theSuccess )
{
outHeight = theEndLocation . z ;
ASSERT ( outHeight < = inZ ) ;
}
return theSuccess ;
}
const char * AvHSHUGetCommonSoundName ( bool inIsAlien , WeaponHUDSound inHUDSound )
{
const char * theSoundName = NULL ;
switch ( inHUDSound )
{
case WEAPON_SOUND_HUD_ON :
theSoundName = inIsAlien ? " common/wpn_hudon-a.wav " : " common/wpn_hudon.wav " ;
break ;
case WEAPON_SOUND_HUD_OFF :
theSoundName = inIsAlien ? " common/wpn_hudoff-a.wav " : " common/wpn_hudoff.wav " ;
break ;
case WEAPON_SOUND_MOVE_SELECT :
theSoundName = inIsAlien ? " common/wpn_moveselect-a.wav " : " common/wpn_moveselect.wav " ;
break ;
case WEAPON_SOUND_SELECT :
theSoundName = inIsAlien ? " common/wpn_select-a.wav " : " common/wpn_select.wav " ;
break ;
case WEAPON_SOUND_DENYSELECT :
theSoundName = inIsAlien ? " common/wpn_denyselect-a.wav " : " common/wpn_denyselect.wav " ;
break ;
}
return theSoundName ;
}
// Values for fuser1: 0-1 means it's building. 2-3 means it's researching (see kResearchFuser1Base), 3-4 is "energy" (returns both building and researching)
const float kResearchFuser1Base = 2.0f ;
const float kEnergyFuser1Base = 3.0f ;
void AvHSHUGetBuildResearchState ( int inUser3 , int inUser4 , float inFuser1 , bool & outIsBuilding , bool & outIsResearching , float & outNormalizedPercentage )
{
outIsBuilding = outIsResearching = false ;
float theStatus = ( inFuser1 / kNormalizationNetworkFactor ) ;
if ( ( GetHasUpgrade ( inUser4 , MASK_BUILDABLE ) | | ( inUser3 = = AVH_USER3_WELD ) ) & & ! GetHasUpgrade ( inUser4 , MASK_RECYCLING ) )
{
if ( ( theStatus > = 0.0f ) & & ( theStatus < = 1.0f ) )
{
outNormalizedPercentage = theStatus ;
outIsBuilding = true ;
}
if ( inUser3 = = AVH_USER3_WELD )
{
if ( outNormalizedPercentage = = - 1 )
{
outIsBuilding = outIsResearching = false ;
}
}
}
else
{
if ( ( theStatus > kResearchFuser1Base ) & & ( theStatus < = ( 1.0f + kResearchFuser1Base ) ) )
{
outNormalizedPercentage = theStatus - kResearchFuser1Base ;
outIsResearching = true ;
}
else if ( ( theStatus > kEnergyFuser1Base ) & & ( theStatus < = ( 1.0f + kEnergyFuser1Base ) ) )
{
// Set "energy"
outNormalizedPercentage = theStatus - kEnergyFuser1Base ;
outIsBuilding = outIsResearching = true ;
}
else
{
outNormalizedPercentage = 1.0f ;
}
}
}
void AvHSHUSetEnergyState ( int inUser3 , float & outFuser1 , float inNormalizedPercentage )
{
outFuser1 = ( kEnergyFuser1Base + inNormalizedPercentage ) * kNormalizationNetworkFactor ;
}
void AvHSHUSetBuildResearchState ( int inUser3 , int inUser4 , float & outFuser1 , bool inTrueBuildOrFalseResearch , float inNormalizedPercentage )
{
//ASSERT(GetHasUpgrade(inUser4, MASK_BUILDABLE) /*|| GetHasUpgrade(inUser4, MASK_SELECTABLE)*/ || (inUser3 == AVH_USER3_WELD));
if ( inNormalizedPercentage ! = - 1 )
{
inNormalizedPercentage = min ( inNormalizedPercentage , 1.0f ) ;
inNormalizedPercentage = max ( inNormalizedPercentage , 0.0f ) ;
}
// Build
if ( inTrueBuildOrFalseResearch )
{
//ASSERT(GetHasUpgrade(inUser4, MASK_BUILDABLE) || (inUser3 == AVH_USER3_WELD));
outFuser1 = inNormalizedPercentage * kNormalizationNetworkFactor ;
}
// Research
else
{
outFuser1 = ( kResearchFuser1Base + inNormalizedPercentage ) * kNormalizationNetworkFactor ;
}
}
string AvHSHUBuildExecutableScriptName ( const string & inScriptName , const string & inCurrentMapName )
{
string theExecutableScriptName = string ( getModDirectory ( ) ) + string ( " / " ) + kScriptsDirectory + string ( " / " ) + inCurrentMapName + string ( " / " ) + inScriptName ;
return theExecutableScriptName ;
}
string AvHSHUGetTimeDateString ( )
{
string theTimeDateString ( " <date unknown> " ) ;
time_t theTimeThingie = time ( ( time_t * ) NULL ) ;
struct tm * theTime = localtime ( & theTimeThingie ) ;
if ( theTime )
{
// 04/22/03, 16:59:12
char theBuffer [ 512 ] ;
sprintf ( theBuffer , " %.2d/%.2d/%.2d, %.2d:%.2d:%.2d " , ( theTime - > tm_mon + 1 ) , theTime - > tm_mday , ( theTime - > tm_year - 100 ) , theTime - > tm_hour , theTime - > tm_min , theTime - > tm_sec ) ;
theTimeDateString = theBuffer ;
}
return theTimeDateString ;
}
bool AvHSHUGetNameOfLocation ( const AvHBaseInfoLocationListType & inLocations , vec3_t inLocation , string & outLocation )
{
bool theSuccess = false ;
// Look at our current position, and see if we lie within of the map locations
for ( AvHBaseInfoLocationListType : : const_iterator theIter = inLocations . begin ( ) ; theIter ! = inLocations . end ( ) ; theIter + + )
{
if ( theIter - > GetIsPointInRegion ( inLocation ) )
{
outLocation = theIter - > GetLocationName ( ) ;
theSuccess = true ;
break ;
}
}
return theSuccess ;
}
// Also check AvHSUGetAlwaysPlayAlert to make sure some alerts are always triggered
bool AvHSHUGetForceHUDSound ( AvHHUDSound inHUDSound )
{
bool theForceSound = false ;
switch ( inHUDSound )
{
case HUD_SOUND_ALIEN_HIVE_COMPLETE :
case HUD_SOUND_ALIEN_HIVE_DYING :
case HUD_SOUND_ALIEN_HIVE_ATTACK :
case HUD_SOUND_MARINE_CCUNDERATTACK :
case HUD_SOUND_SQUAD1 :
case HUD_SOUND_SQUAD2 :
case HUD_SOUND_SQUAD3 :
case HUD_SOUND_SQUAD4 :
case HUD_SOUND_SQUAD5 :
theForceSound = true ;
break ;
}
return theForceSound ;
}
