nyuuzyou/wikis huggingface dataset:
UTIL BloodDrips

UTIL_BloodDrips is a UTIL provided in the Source code for creating drips of blood. It appears to support directions other than down. It supports anywhere between 1-255 as an amount.
If the color is BLOOD_COLOR_MECH (3), it will create sparks and smoke puffs instead of blood drips!
If the color is BLOOD_COLOR_RED (1) or others, it will call UTIL_BloodImpact with the same settings.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : Vector &origin | Where the blood drip should emit from
// Input : Vector &direction | Direction they should drip
// Input : int - Color | BLOOD_COLOR_MECH has a certain usage. Otherwise, it calls UTIL_BloodImpact.
// Input : int - Amount | Amount of drips(?) - TODO: Test this
// Output : 
//-----------------------------------------------------------------------------
void UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount )
== Examples ==
int i;
Vector vecSpot;
Vector vecDir;
//Create 4 random spots of blood drips
for ( i = 0 ; i < 4; i++ )
{
 //Gets the center of an object in world-space coordinates
	vecSpot = WorldSpaceCenter();
	vecSpot.x += random->RandomFloat( -12, 12 ); 
	vecSpot.y += random->RandomFloat( -12, 12 ); 
	vecSpot.z += random->RandomFloat( -4, 16 ); 
	UTIL_BloodDrips( vecSpot, vec3_origin, BLOOD_COLOR_YELLOW, 50 );
}
Category:Programming
Category:UTIL
UTIL BloodImpact

UTIL_BloodImpact is a UTIL provided in the Source code for creating a "bloodimpact" effect. 
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : Vector - &pos | Position to create the Blood Impact at.
// Input : Vector - &dir | Direction to create the Blood Impact in.
// Input : int - bloodColor | Type of blood to create. 
// Input : int - Amount | Amount of blood impacts to create
// Output : 
//-----------------------------------------------------------------------------
void UTIL_BloodImpact( const Vector &pos, const Vector &dir, int color, int amount )
== Examples ==
//Create 4 different BloodImpact effects, slightly offset from each other. (+/- 12)
for ( int i = 0 ; i < 4 ; i++ )
{
 // Get the center of the object in world-space coordinates
	Vector vecSpot = WorldSpaceCenter();
 //Modify it a bit
	vecSpot.x += random->RandomFloat( -12, 12 ); 
	vecSpot.y += random->RandomFloat( -12, 12 ); 
	vecSpot.z += random->RandomFloat( -4, 16 );
	vecDir.x = random->RandomFloat(-1, 1);
	vecDir.y = random->RandomFloat(-1, 1);
	vecDir.z = 0;
	VectorNormalize( vecDir );
	UTIL_BloodImpact( vecSpot, vecDir, BloodColor(), 1 );
}
Category:Programming
Category:UTIL
UTIL BloodSpray

UTIL_BloodSpray is a UTIL provided in the Source code for creating a "bloodspray" effect. 
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : Vector - &pos | Position to create the Blood Impact at.
// Input : Vector - &dir | Direction to create the Blood Impact in.
// Input : int - color | Type of blood to create. 
// Input : int - Amount | Amount of blood impacts to create
// Input : int - flags | Part of the data for DispatchEvent
// Output : 
//-----------------------------------------------------------------------------
void UTIL_BloodSpray( const Vector &pos, const Vector &dir, int color, int amount, int flags )
== Flags ==
const int FX_BLOODSPRAY_DROPS	= 0x01;
const int FX_BLOODSPRAY_GORE	= 0x02;
const int FX_BLOODSPRAY_CLOUD	= 0x04;
const int FX_BLOODSPRAY_ALL	= 0xFF;
== Examples ==
UTIL_BloodSpray( vecOrigin, vecDir, BLOOD_COLOR_RED, 4, FX_BLOODSPRAY_ALL );
//This example creates a blood spray from an attachment point.
//This is seen in npc_hunters.
//Line 4322 in npc_hunter.cpp for more details!
Vector vecOrigin;
Vector vecDir;
// spray blood from the attachment point
bool bGotAttachment = false;
if ( pEvent->options )
{
	QAngle angDir;
	if ( GetAttachment( pEvent->options, vecOrigin, angDir ) )
	{
		bGotAttachment = true;
		AngleVectors( angDir, &vecDir, NULL, NULL );
	}
}
// fall back to our center, tracing forward
if ( !bGotAttachment )
{	
	vecOrigin = WorldSpaceCenter();
	GetVectors( &vecDir, NULL, NULL );
}
UTIL_BloodSpray( vecOrigin, vecDir, BLOOD_COLOR_RED, 4, FX_BLOODSPRAY_ALL );
//Create some blood decals on the world infront of our blood spray
for ( int i = 0 ; i < 3 ; i++ )
{
	Vector vecTraceDir = vecDir;
	vecTraceDir.x += random->RandomFloat( -0.1, 0.1 );
	vecTraceDir.y += random->RandomFloat( -0.1, 0.1 );
	vecTraceDir.z += random->RandomFloat( -0.1, 0.1 );
	trace_t tr;
	AI_TraceLine( vecOrigin, vecOrigin + ( vecTraceDir * 192.0f ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
	if ( tr.fraction != 1.0 )
	{
		UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_RED );
	}
}
UTIL_BloodSpray( vecBloodPos, Vector(0,0,-1), GetEnemy()->BloodColor(), 8, FX_BLOODSPRAY_ALL );
Category:Programming
Category:UTIL
UTIL BubbleTrail

is a UTIL provided in the Source code for a trail of bubbles.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : Vector &from | Where the bubble trail should emit from 
// Input : Vector &to | Where the bubble trail should go
// Input : int - count | How many bubbles
// Output : 
//-----------------------------------------------------------------------------
void UTIL_BubbleTrail( const Vector& from, const Vector& to, int count );
== Examples ==
//-----------------------------------------------------------------------------
// Think every 0.1 seconds to make bubbles if we're flying through water.
//-----------------------------------------------------------------------------
void CHunterFlechette::BubbleThink()
{
//What this does is think every 0.1 seconds, and checks if the Flechette is in water.
//If it's not in the water, it exits the function and checks again in 0.1s.
//If it is in the water, then it creates a bubble trail every 0.1s.
 //SetNextThink having two params has something to do with SetContextThink. 
	SetNextThink( gpGlobals->curtime + 0.1f, s_szHunterFlechetteBubbles );
 
 //If it's not in the water, just check again in 0.1s.
	if ( GetWaterLevel() == 0 )
		return;
 //Create a bubble trail, starting at the Origin-Velocity, so
 //the origin - 0.1 it's velocity, or behind the Flechette
 //The bubbles will head towards it's actual origin, like they were pulled
 //forward by it's movement through the water.
	UTIL_BubbleTrail( GetAbsOrigin() - GetAbsVelocity() * 0.1f, GetAbsOrigin(), 5 );
}
Category:Programming
Category:UTIL
UTIL Bubbles

UTIL_Bubbles is a UTIL provided in the Source code for creating bubbles spread out within a cubic volume. 
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Creates bubbles spaced throughout the mins/maxes given.
// 
// Input : &mins | Vector of the Mins of the box to create
// Input : &maxs | Vector of the Maxs of the box to create
// Input : count | Number of bubbles
// Output :
//-----------------------------------------------------------------------------
void UTIL_Bubbles( const Vector& mins, const Vector& maxs, int count )
{
	Vector mid = (mins + maxs) * 0.5;
	float flHeight = UTIL_WaterLevel( mid, mid.z, mid.z + 1024 );
	flHeight = flHeight - mins.z;
	CPASFilter filter( mid );
	te->Bubbles( filter, 0.0,
		&mins, &maxs, flHeight, g_sModelIndexBubbles, count, 8.0 );
}
== Examples ==
//pHurt->GetAbsOrigin()+ Vector( -32.0f, -32.0f, -32.0f)
//Gets the Origin of pHurt, and then goes 32 units down, 32 behind, and 32 to the right.
//pHurt->GetAbsOrigin()+ Vector( 32.0f, 32.0f, 32.0f )
//Gets the Origin of pHurt, and then goes 32 units up, 32 forwards, and 32 to the left.
//These combine form a 64x64x64 box around pHurt's origin.
//random->RandomInt( 16, 32 ) returns a random Int between 16 and 32 for amount of bubbles to create.
UTIL_Bubbles( pHurt->GetAbsOrigin()+Vector(-32.0f,-32.0f,-32.0f), pHurt->GetAbsOrigin()+Vector(32.0f,32.0f,0.0f), random->RandomInt( 16, 32 ) );
//This example creates bubbles around the end of a Traceline from a Stalker beam attack.
//bInWater is defined elsewhere.
if (bInWater)
{
	UTIL_Bubbles(tr.endpos-Vector(3,3,3),tr.endpos+Vector(3,3,3),10);
}
Category:Programming
Category:UTIL
UTIL CheckBottom

is a UTIL function that determines if an entity is on the bottom. returns false if any part of the bottom of the entity is off an edge that is not a staircase; otherwise the function returns true.
==Function Declaration==
// Returns false if any part of the bottom of the entity is off an edge that
// is not a staircase.
bool UTIL_CheckBottom( CBaseEntity *pEntity, ITraceFilter *pTraceFilter, float flStepSize );
Category:Programming
Category:UTIL
UTIL EntitiesAlongRay

This is a UTIL function that when supplied a Ray_t will return an integer indicating the number of entities encountered along the ray, then will enumerate and place them into an array. 
You can either specify an array, and the size of the array, and a mask for which encountered entities will be included in the array, or you can simply supply a Ray_t and a pointer to an instance of the CFlaggedEntitiesEnum class.
== Usage ==
int UTIL_EntitiesAlongRay( const Ray_t &ray, CFlaggedEntitiesEnum *pEnum )
int UTIL_EntitiesAlongRay( CBaseEntity **pList, int listMax, const Ray_t &ray, int flagMask )
== Examples ==
int nCount = UTIL_EntitiesAlongRay( list, 1024, ray, FL_NPC | FL_CLIENT );
for ( int i = 0; i < nCount; i++ )
{
	if ( !IsAttractiveTarget( list[i] ) )
		continue;
	VectorSubtract( list[i]->WorldSpaceCenter(), vecStartPoint, vecDelta );
	distance = VectorNormalize( vecDelta );
	flDot = DotProduct( vecDelta, vecVelDir );
			
	if ( flDot > flMaxDot )
	{
		if ( distance < flBestDist )
		{
			pBestTarget = list[i];
			flBestDist = distance;
		}
	}
}
Category:Programming
Category:UTIL
UTIL EntitiesInBox

UTIL_EntitiesInBox is a UTIL provided in the Source code for finding entities within a specified box. It takes an Entity List, Mins, Maxes, and flags, returning a count of entities, as well as a list of the entities.
==Usage==
//-----------------------------------------------------------------------------
// Purpose: Returns the number of entities in the box, plus an array of pointers to the entities.
// 
// Input : CBaseEntity - *pList | A pointer to an array, the function will store a pointer to the Entities it finds in this array.
// Input : int - listMax | Maximum number of entities to return
// Input : Vector - &mins | The mins of a box to check. World space coordinate.
// Input : Vector - &maxs | The maxs of a box to check. World space coordinate.
// Input : int - flagmask | 
// Output : *pList
// Output : int - Returns the amount of entities it finds
//-----------------------------------------------------------------------------
inline int UTIL_EntitiesInBox( CBaseEntity **pList, int listMax, const Vector &mins, const Vector &maxs, int flagMask )
//-----------------------------------------------------------------------------
// Purpose: Returns the number of entities in the box.
// 
// Input : Vector - &mins | The mins of a box to check. World space coordinate.
// Input : Vector - &maxs | The maxs of a box to check. World space coordinate.
// Input : CFlaggedEntitiesEnum *pEnum | TODO
// Output : int - Returns the amount of entities it finds
//-----------------------------------------------------------------------------
int UTIL_EntitiesInBox( const Vector &mins, const Vector &maxs, CFlaggedEntitiesEnum *pEnum );
flagmask is avaible in const.h, lines 97-132
== Examples ==
//Create an array of CBaseEntity pointers
CBaseEntity*	pList[20];
//Put the pointers in the pList, and get how many entities there are
int count = UTIL_EntitiesInBox( pList, 20, spawnOrigin + NAI_Hull::Mins( HULL_MEDIUM ), spawnOrigin + NAI_Hull::Maxs( HULL_MEDIUM ), 0 );
//Iterate over all the possible targets
for ( int i = 0; i < count; i++ )
{
 //If the particular entity's movetype isn't MOVETYPE_VPHYSICS, skip the rest of this loop, and go to the next entity
	if ( pList[i]->GetMoveType() != MOVETYPE_VPHYSICS )
		continue;
	if ( PhysGetEntityMass( pList[i] ) > ANTLION_MAKER_BLOCKED_MASS )
	{
		bBlocked = true;
		iNumBlocked++;
		pBlocker = pList[i];
		if ( pTestHint == pNode )
		{
			bChosenHintBlocked = true;
		}
		break;
	}
}
//This uses the overloaded function, and only returns the number of entities.
CBaseEntity *entityList[64];
Vector range(ROLLERMINE_WAKEUP_DIST,ROLLERMINE_WAKEUP_DIST,64);
int boxCount = UTIL_EntitiesInBox( entityList, ARRAYSIZE(entityList), GetAbsOrigin()-range, GetAbsOrigin()+range, FL_NPC );
Category:Programming
Category:UTIL
UTIL EntitiesInSphere

UTIL_EntitiesInSphere is a UTIL provided in the Source code for finding entities within a specified sphere. It takes an entity list, a max amount of entities to find, the center of the sphere, a radius and a flagmask.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Returns the number of entities in the sphere, plus an array of pointers to the entities.
// 
// Input : CBaseEntity - *pList | A pointer to an array, the function will store a pointer to the Entities it finds in this array.
// Input : int - listMax | Maximum number of entities to return
// Input : Vector - ¢er | Center of the Sphere to check from
// Input : float - radius | radius of the sphere to check in
// Input : int - flagmask | 
// Output : *pList
// Output : int - Returns the amount of entities it finds
//-----------------------------------------------------------------------------
inline int UTIL_EntitiesInSphere( CBaseEntity **pList, int listMax, const Vector ¢er, float radius, int flagMask )
//-----------------------------------------------------------------------------
// Purpose: Returns the number of entities in the sphere.
// 
// Input : Vector - &mins | The mins of a box to check. World space coordinate.
// Input : Vector - &maxs | The maxs of a box to check. World space coordinate.
// Input : CFlaggedEntitiesEnum *pEnum | TODO
// Output : int - Returns the amount of entities it finds
//-----------------------------------------------------------------------------
int UTIL_EntitiesInSphere( const Vector ¢er, float radius, CFlaggedEntitiesEnum *pEnum );
flagmask is avaible in const.h, lines 97-132
== Examples ==
//What this does, is look through entities in a sphere, and then
//checks to see if they are valid, and if they are
//adds them to a second list of valid entities.
//Create an array of CBaseEntity pointers
CBaseEntity *ppEnts[256];
//Get the center of the object
Vector vecCenter = WorldSpaceCenter();
float flRadius = 500.0f;
vecCenter.z -= flRadius * 0.8f;
int nEntCount = UTIL_EntitiesInSphere( ppEnts, 256, vecCenter, flRadius, 0 );
CBaseEntity *ppCandidates[256];
int nCandidateCount = 0;
int i;
for ( i = 0; i < nEntCount; i++ )
{
 //Look through the entities it found
	if ( ppEnts[i] == NULL )
		continue;
	// Zap metal or flesh things.
	if ( !IsValidZapTarget( ppEnts[i] ) )
		continue;
 //Add them to the new, valid only, Canidate list.
	ppCandidates[ nCandidateCount++ ] = ppEnts[i];
}
//This example defines a variable named RALLY_SEARCH_ENTS, as a clear
//and easy way to see what it is instead of just writing '30' into
//both spots.
const int RALLY_SEARCH_ENTS	= 30;
CBaseEntity *pEntities[RALLY_SEARCH_ENTS];
int iNumEntities = UTIL_EntitiesInSphere( pEntities, RALLY_SEARCH_ENTS, vecCenter, flRadius, 0 )
Category:Programming
Category:UTIL
UTIL FunctionFromName

is a UTIL function that returns the function pointer, from a data map, that has a matching function name (the key).
==Function Declaration==
//-----------------------------------------------------------------------------
// Purpose: Search the datamap for a function named pName
//			This is used to save/restore function pointers (convert text back to pointer)
// Input : *pName - name of the member function
//-----------------------------------------------------------------------------
inputfunc_t *UTIL_FunctionFromName( datamap_t *pMap, const char *pName );
Category:Programming
Category:UTIL
UTIL FunctionToName

is a UTIL function that searches for the function name of a matching function pointer, as a C-string, from a data map.
==Function Declaration==
//-----------------------------------------------------------------------------
// Purpose: Search this datamap for the name of this member function
//			This is used to save/restore function pointers (convert pointer to text)
// Input : *function - pointer to member function
// Output : const char * - function name
//-----------------------------------------------------------------------------
extern const char *UTIL_FunctionToName( datamap_t *pMap, inputfunc_t *function );
Category:Programming
Category:UTIL
UTIL GetDebugColorForRelationship

UTIL_GetDebugColorForRelationship is a UTIL provided in the Source code for getting the color of the relationship between AI units.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Fills in color for debug purposes based on a relationship
// Input : nRelationship - relationship to test
//			*pR, *pG, *pB - colors to fill
//-----------------------------------------------------------------------------
void UTIL_GetDebugColorForRelationship( int nRelationship, int &r, int &g, int &b )
Will return one of the following RGB values:
* R=0, G=255, B=0 //Like
* R=0, G=0, B=255 //Neutral
* R=255, G=0, B=0 //Hate
* R=255, G=255, B=0 //Fear
* R=255, G=255, B=255 //Default
== Examples ==
// Show the relationships to entities around us
int r = 0;
int g = 0;
int b = 0;
int	nRelationship;
CAI_BaseNPC **ppAIs = g_AI_Manager.AccessAIs();
// Rate all NPCs
for ( int i = 0; i < g_AI_Manager.NumAIs(); i++ )
{
	if ( ppAIs[i] == NULL || ppAIs[i] == this )
		continue;
	
	// Get our relation to the target
	nRelationship = IRelationType( ppAIs[i] );
	// Get the color for the arrow
	UTIL_GetDebugColorForRelationship( nRelationship, r, g, b );
	// Draw an arrow
	NDebugOverlay::HorzArrow( GetAbsOrigin(), ppAIs[i]->GetAbsOrigin(), 16, r, g, b, 64, true, 0.0f );
}
Category:Programming
Category:UTIL
UTIL GetLocalPlayer

is a UTIL provided in the Source code for finding the local player. If it is a single player game, it returns the local player. Otherwise, it returns NULL.
See: GetLocalPlayer for Multiplayer games.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Returns the local player if in Single player, otherwise NULL.
// 
// Input : 
// Output : CBasePlayer*
//-----------------------------------------------------------------------------
UTIL_GetLocalPlayer()
== Examples ==
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if ( pPlayer )
{
 //Do something
}
Vector vecPlayerCenter = UTIL_GetLocalPlayer()->WorldSpaceCenter();
Category:Programming
Category:UTIL
UTIL GetModDir

is a UTIL function that retrieves the mod (or game) directory name for the active game (ie. "hl2", "csgo", or "tf"), by storing the game directory path in lpszTextOut and then culls the entire directory path, leaving only the directory name. This function returns false if the length of the game directory path is longer than nSize, otherwise it will return true.
==Usage==
/* lpszTextOut - The input C-style string to be written to.
 nSize - String length. */
bool UTIL_GetModDir( char *lpszTextOut, unsigned int nSize );
==Example==
Get mod directory and store it.
char pGameDir[1024];
UTIL_GetModDir( pGameDir, 1024 );
Category:Programming
Category:UTIL
UTIL HudHintText

UTIL_HudHintText is a UTIL provided to trigger Instructional hud-hints.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Display instructional hud-hints to the specified entity (player)
// Input : *pEntity - Entity to tell to send the hud-hint to
// Input : pMessage - HudHint message to Send
// Output : 
//-----------------------------------------------------------------------------
void UTIL_HudHintText( CBaseEntity *pEntity, const char *pMessage )
== Examples ==
//-----------------------------------------------------------------------------
// Purpose: Show people how to drive!
//-----------------------------------------------------------------------------
void CPropJeep::InputShowHudHint( inputdata_t &inputdata )
{
	CBaseServerVehicle *pServerVehicle = dynamic_cast<CBaseServerVehicle *>(GetServerVehicle());
	if ( pServerVehicle )
	{
		if( pServerVehicle->GetPassenger( VEHICLE_ROLE_DRIVER ) )
		{
			UTIL_HudHintText( m_hPlayer, "#Valve_Hint_JeepKeys" );
			m_iNumberOfEntries++;
		}
	}
}
// The first few time we get into the airboat, print the airboat help
if ( m_iNumberOfEntries < hud_airboathint_numentries.GetInt() && !m_bExitAnimOn )
{
	UTIL_HudHintText( m_hPlayer, "#Valve_Hint_BoatKeys" );
	m_iNumberOfEntries++;
}
Category:Programming
Category:UTIL
UTIL HudMessage

UTIL_HudMessage is a UTIL provided to send a message to a specific player. It is only used for debugging purposes.
See also: UTIL_HudMessageAll
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Calls UTIL_HudMessage for every player
// Input : pToPlayer - CBasePlayer that will be used as a filter for CRecipientFilter.
// Input : hudtextparmas_t - Text Parameters, size, location, color, etc. 
// Input : pMessage - Message to send
// Output : 
//-----------------------------------------------------------------------------
void UTIL_HudMessage( CBasePlayer *pToPlayer, const hudtextparms_t &textparms, const char *pMessage )
== Examples ==
// If we're in singleplayer, show the message to the player.
if ( gpGlobals->maxClients == 1 )
{
	CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
	UTIL_HudMessage( pPlayer, m_textParms, MessageGet() );
}
//Show the message to the player that triggered us.
else if ( pActivator && pActivator->IsNetClient() )
{
	UTIL_HudMessage( ToBasePlayer( pActivator ), m_textParms, MessageGet() );
}
Category:Programming
Category:UTIL
UTIL HudMessageAll

UTIL_HudMessageAll is a UTIL provided to send a message to all player's HUDs. It is only used for debugging purposes.
See also: UTIL_HudMessage
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Calls UTIL_HudMessage for every player
// Input : hudtextparmas_t - Text Parameters, size, location, color, etc. 
// Input : pMessage - Message to send
// Output : 
//-----------------------------------------------------------------------------
void UTIL_HudMessageAll( const hudtextparms_t &textparms, const char *pMessage )
== Examples ==
// ----------------------------------------------------------
// Skip AI if its been disabled or networks haven't been
// loaded, and put a warning message on the screen
//
// Don't do this if the convar wants it hidden
// ----------------------------------------------------------
if ( (CAI_BaseNPC::m_nDebugBits & bits_debugDisableAI || !g_pAINetworkManager->NetworksLoaded()) )
{
	if ( gpGlobals->curtime >= g_AINextDisabledMessageTime && !IsInCommentaryMode() )
	{
		g_AINextDisabledMessageTime = gpGlobals->curtime + 0.5f;
		hudtextparms_s tTextParam;
		tTextParam.x			= 0.7;
		tTextParam.y			= 0.65;
		tTextParam.effect		= 0;
		tTextParam.r1			= 255;
		tTextParam.g1			= 255;
		tTextParam.b1			= 255;
		tTextParam.a1			= 255;
		tTextParam.r2			= 255;
		tTextParam.g2			= 255;
		tTextParam.b2			= 255;
		tTextParam.a2			= 255;
		tTextParam.fadeinTime	= 0;
		tTextParam.fadeoutTime	= 0;
		tTextParam.holdTime		= 0.6;
		tTextParam.fxTime		= 0;
		tTextParam.channel		= 1;
		UTIL_HudMessageAll( tTextParam, "A.I. Disabled...\n" );
	}
	SetActivity( ACT_IDLE );
	return false;
}
Category:Programming
Category:UTIL