nyuuzyou/wikis huggingface dataset:
UTIL ImpactTrace

UTIL_ImpactTrace is a UTIL provided in the Source code for doing decals and impact effects (such as flecks) at the end of a UTIL TraceLine trace.
== Usage ==
//------------------------------------------------------------------------------
// Purpose : Creates both an decal and any associated impact effects (such
//			 as flecks) for the given iDamageType and the trace's end position
// Input :
// Output :
//------------------------------------------------------------------------------
void UTIL_ImpactTrace( trace_t *pTrace, int iDamageType, char *pCustomImpactName )
{
	CBaseEntity *pEntity = pTrace->m_pEnt;
	// Is the entity valid, is the surface sky?
	if ( !pEntity || !UTIL_IsValidEntity( pEntity ) || (pTrace->surface.flags & SURF_SKY) )
		return;
	if ( pTrace->fraction == 1.0 )
		return;
	pEntity->ImpactTrace( pTrace, iDamageType, pCustomImpactName );
}
== Examples ==
//In this example, the Custom impact type is left off.
UTIL_ImpactTrace( &tr, DMG_BULLET );
UTIL_ImpactTrace( &tr, nDamageType, "AirboatGunImpact" );
UTIL_ImpactTrace( &tr, nDamageType, "HelicopterImpact" );
if ( pEntity->GetTeamNumber() == GetTeamNumber() )
{
	if ( !friendlyfire.GetBool() )
		UTIL_ImpactTrace( &tr, iDamageType );
}
Category:Programming
Category:UTIL
UTIL IsLowViolence

UTIL_IsLowViolence is a legacy UTIL provided to check Violence settings.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: These convars are no longer necessary -- the engine is the final arbiter of
// violence settings -- but they're here for legacy support and for testing low 
// violence when the engine is in normal violence mode. 
// Input : int - color | The color of the blood to check against.
// Output :
//-----------------------------------------------------------------------------
bool UTIL_IsLowViolence( void )
{
	if ( !violence_hblood.GetBool() || !violence_ablood.GetBool() || !violence_hgibs.GetBool() || !violence_agibs.GetBool() )
		return true;
	return engine->IsLowViolence();
}
static ConVar	violence_hblood( "violence_hblood","1", 0, "Draw human blood" );
static ConVar	violence_hgibs( "violence_hgibs","1", 0, "Show human gib entities" );
static ConVar	violence_ablood( "violence_ablood","1", 0, "Draw alien blood" );
static ConVar	violence_agibs( "violence_agibs","1", 0, "Show alien gib entities" );
== Examples ==
//Checks to see if the game is in LowViolence mode.
//If it is, it doesn't play sounds. If it's not
//In low violence mode, then it plays some sounds.
if ( !UTIL_IsLowViolence() )
{
	RemoveSpawnFlags( SF_NPC_GAG );
	MoanSound( envZombieMoanIgnited, ARRAYSIZE( envZombieMoanIgnited ) );
	if ( m_pMoanSound )
	{
		ENVELOPE_CONTROLLER.SoundChangePitch( m_pMoanSound, 120, 1.0 );
		ENVELOPE_CONTROLLER.SoundChangeVolume( m_pMoanSound, 1, 1.0 );
	}
}
Category:Programming
Category:UTIL
UTIL MuzzleFlash

UTIL_MuzzleFlash is a UTIL provided in the Source code for muzzle flashes. However it is only called once in the code by CNPC_Assassin. Since the npc_assasin was never included in Half-Life 2, this function may be outdated.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Make a muzzle flash appear
// Input : &origin - position of the muzzle flash
//			&angles - angles of the fire direction
//			scale - scale of the muzzle flash
//			type - type of muzzle flash
//-----------------------------------------------------------------------------
void UTIL_MuzzleFlash( const Vector &origin, const QAngle &angles, int scale, int type )
{
	CPASFilter filter( origin );
	te->MuzzleFlash( filter, 0.0f, origin, angles, scale, type );
}
== Examples ==
Vector	muzzlePos;
QAngle	muzzleAngle;
GetAttachment( handName, muzzlePos, muzzleAngle );
UTIL_MuzzleFlash( muzzlePos, muzzleAngle, 0.5f, 1 );
Category:Programming
Category:UTIL
UTIL ParticleTracer

Category:UTIL
UTIL_ParticleTracer is a UTIL provided in the Source code for dispatching bullet tracer effects with the Orange Box particle system. It works by setting control points 0 and 1, where 0 is where the tracer starts and point 1 is where the tracer ends. The particle effect should implement the Move Particles Between 2 Control Points initializer. 
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Make a tracer using a particle effect
//-----------------------------------------------------------------------------
void UTIL_ParticleTracer( const char *pszTracerEffectName, const Vector &vecStart, const Vector &vecEnd, 
				 int iEntIndex, int iAttachment, bool bWhiz )
{
	int iParticleIndex = GetParticleSystemIndex( pszTracerEffectName );
	UTIL_Tracer( vecStart, vecEnd, iEntIndex, iAttachment, 0, bWhiz, "ParticleTracer", iParticleIndex );
}
== Examples ==
You can override the default tracer in basecombatweapon_shared.cpp by replacing the switch statement around line 749:
UTIL_ParticleTracer("tracer_bullet", vNewSrc, tr.endpos, entindex(), iAttachment, iTracerType == TRACER_LINE_AND_WHIZ);
UTIL PlayerByIndex

This function will return a CBasePlayer pointer to an entity based on the networked entity index which is passed in as a first parameter. The edict indices in the range 1 to gpGlobals->maxClients are reserved for players; all networked, non-player entities will be assigned to an index higher than gpGlobals->maxClients.
== Usage ==
CBasePlayer *UTIL_PlayerByIndex( int entindex );
== Examples ==
The following code can be used to safely iterate all player entities:
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
	CBasePlayer *pPlayer = UTIL_PlayerByIndex(i);
	if (!pPlayer || !pPlayer->IsPlayer())
		continue;
	[...]
}
Category:Programming
Category:UTIL
UTIL PlayerDecalTrace

UTIL_PlayerDecalTrace is a UTIL provided in the Source code for creating Player sprays.
== Usage ==
/*
==============
UTIL_PlayerDecalTrace
A player is trying to apply his custom decal for the spray can.
Tell connected clients to display it, or use the default spray can decal
if the custom can't be loaded.
==============
*/
void UTIL_PlayerDecalTrace( trace_t *pTrace, int playernum )
{
	if (pTrace->fraction == 1.0)
		return;
	CBroadcastRecipientFilter filter;
	te->PlayerDecal( filter, 0.0,
		&pTrace->endpos, playernum, pTrace->m_pEnt->entindex() );
}
== Examples ==
CBasePlayer *pPlayer = ToBasePlayer( GetOwnerEntity() );
if ( pPlayer )
{
 	int playernum = pPlayer->entindex();
	
	Vector forward;
	trace_t	tr;	
	AngleVectors( GetAbsAngles(), &forward );
	UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + forward * 128, 
		MASK_SOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, & tr);
	UTIL_PlayerDecalTrace( &tr, playernum );
}
Category:Programming
Category:UTIL
UTIL Remove

UTIL_Remove is a UTIL provided in the Source SDK code for removing ("killing") objects. UTIL_Remove marks an object for deletion on the next frame, instead of the current one. Removing objects on the current frame can cause null pointers which will cause the game to crash, so UTIL_Remove is included to prevent this.
==Usage==
void UTIL_Remove( IServerNetworkable *oldObj );
==Examples==
UTIL_Remove( this );
CBaseFire *pEffect = m_hEffect;
if ( pEffect != NULL )
{
	UTIL_Remove( pEffect );
 m_hEffect = NULL;
}
==See also==
* UTIL_RemoveImmediate
* UTIL_EnableRemoveImmediate
* UTIL_DisableRemoveImmediate
Category:Programming
Category:UTIL
UTIL ReplaceKeyBindings

is a UTIL function that looks up key bindings (marked with %<command>%) for commands and replaces them with the key bound to them, in string.
==Declaration==
void UTIL_ReplaceKeyBindings( const wchar_t *inbuf, int inbufsizebytes, OUT_Z_BYTECAP(outbufsizebytes) wchar_t *outbuf, int outbufsizebytes );
==Examples==
Category:Programming
Category:UTIL
UTIL SafeName

UTIL_SafeName is a UTIL provided in the source code for scanning player names, and replacing characters that VGUI won't display properly.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Scans player names and replaces characters that vgui won't
// display properly
// Input : *oldName - player name to be fixed up
// Output : *char - static buffer with the safe name
//-----------------------------------------------------------------------------
const char * UTIL_SafeName( const char *oldName )
== Examples ==
UTIL_SafeName( gr->GetPlayerName(iPlayerIndex) )
Category:Programming
Category:UTIL
UTIL SayText

is a wrapper UTIL function for that sends a message to a player.
==Declaration==
void UTIL_SayText( const char *pText, CBasePlayer *pToPlayer );
==Examples==
/* Sent message to the player that executed `say_self`. */
CON_COMMAND( say_self, "Sends message to self in chat" )
{
 UTIL_SayText( args, ToBasePlayer( UTIL_GetCommandClientIndex() ) );
}
Category:Programming
Category:UTIL
UTIL SayText2Filter

is a UTIL function that sends a quadradic message to a player if they pass a filter. The message consists of a format string with up to four parameters usable.
==Declaration==
void UTIL_SayText2Filter( IRecipientFilter& filter, CBasePlayer *pEntity, bool bChat, const char *msg_name, const char *param1, const char *param2, const char *param3, const char *param4 );
* msg_name - Name of the format string.
* param1 - Format string parameter.
* param2 - Format string parameter.
* param3 - Format string parameter.
* param4 - Format string parameter.
==Examples==
Category:Programming
Category:UTIL
UTIL SayTextAll

A UTIL wrapper function for UTIL_SayTextFilter that sends a message to all players.
==Usage==
void UTIL_SayTextAll( const char *pText, CBasePlayer *pPlayer, bool bChat )
==Examples==
Tells everyone in chat that the server will restart in sv_restart_server_delay (not defined for concisement reasons) seconds.
 char *pszNotifyRestartText = "";
 V_snprintf( pszNotifyRestartText, sizeof(pszNotifyRestartText), "This server will restart in %f seconds.", sv_restart_server_delay.GetFloat() );
 UTIL_SayTextAll( pszNotifyRestartText, UTIL_GetCommandClientIndex(), true );
A message that emits to all players' console output.
UTIL_SayTextAll( "I'm a console message that is sent to everyone!", UTIL_GetCommandClient(), false );
Category:UTIL
UTIL SayTextFilter

is a UTIL function that sends a message to players that match a filter. This function is the base function for the other UTIL_SayText functions.
==Declaration==
void UTIL_SayTextFilter( IRecipientFilter& filter, const char *pText, CBasePlayer *pPlayer, bool bChat );
==Example==
The code tells all players visible from an entity that it can see them.
 // Collect all visible players
 CRecipientFilter MyFilter;
 MyFilter.AddRecipientsByPVS( GetAbsOrigin() );
 MyFilter.MakeReliable();
 // Tell visible players that I can see them
 CBasePlayer *pPlayer = UTIL_GetCommandClient();
 if ( pPlayer )
 {
 char *pszCanSeeMsg = "";
 V_snprintf( pszCanSeeMsg, sizeof(pszCanSeeMsg), "%s can see you!", pPlayer->GetPlayerName() );
 UTIL_SayTextFilter( MyFilter, pszCanSeeMsg, UTIL_GetCommandClient() );
 }
Category:Programming
Category:UTIL
UTIL ScreenFade

UTIL_ScreenFade is a UTIL provided to fade a player's screen to a specified color.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Fade an entity (player) screen to a specified color.
// Input : *pEntity - Entity to tell to screen fade on.
// Input : &color - Color to fade to
// Input : fadeTime - Time it takes to fade
// Input : fadeHold - Time the fade holds for
// Input : flags - Fade in, Fade Out, Fade_Modulate (don't blend), Fade_StayOut, Fade_Purge (Replaces others)
// Output : 
//-----------------------------------------------------------------------------
void UTIL_ScreenFade( CBaseEntity *pEntity, const color32 &color, float fadeTime, float fadeHold, int flags )
{
	ScreenFade_t	fade;
	UTIL_ScreenFadeBuild( fade, color, fadeTime, fadeHold, flags );
	UTIL_ScreenFadeWrite( fade, pEntity );
}
Fade Flags
#define FFADE_IN			0x0001		// Just here so we don't pass 0 into the function
#define FFADE_OUT			0x0002		// Fade out (not in)
#define FFADE_MODULATE			0x0004		// Modulate (don't blend)
#define FFADE_STAYOUT			0x0008		// ignores the duration, stays faded out until new ScreenFade message received
#define FFADE_PURGE			0x0010		// Purges all other fades, replacing them with this one
== Examples ==
color32_s clr = { 0,0,0,255 };
UTIL_ScreenFade( pPlayer, clr, 0.3, 0, FFADE_IN | FFADE_PURGE );
color32 black = { 0, 0, 0, 255 };
UTIL_ScreenFade( pPlayer, black, 0.1f, 0.0f, (FFADE_OUT|FFADE_STAYOUT) );
// Red damage indicator
color32 red = { 128, 0, 0, 128 };
UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );
Category:Programming
Category:UTIL
UTIL ScreenFadeAll

UTIL_ScreenFadeAll is a UTIL provided to fade all players screens to a specified color.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Fade all player's screens to a specified color.
// Input : &color - Color to fade to
// Input : fadeTime - Time it takes to fade
// Input : fadeHold - Time the fade holds for
// Input : flags - Fade in, Fade Out, Fade_Modulate (don't blend), Fade_StayOut, Fade_Purge (Replaces others)
// Output : 
//-----------------------------------------------------------------------------
void UTIL_ScreenFadeAll( const color32 &color, float fadeTime, float fadeHold, int flags )
{
	int			i;
	ScreenFade_t	fade;
	UTIL_ScreenFadeBuild( fade, color, fadeTime, fadeHold, flags );
	for ( i = 1; i <= gpGlobals->maxClients; i++ )
	{
		CBaseEntity *pPlayer = UTIL_PlayerByIndex( i );
	
		UTIL_ScreenFadeWrite( fade, pPlayer );
	}
}
Fade Flags
#define FFADE_IN			0x0001		// Just here so we don't pass 0 into the function
#define FFADE_OUT			0x0002		// Fade out (not in)
#define FFADE_MODULATE			0x0004		// Modulate (don't blend)
#define FFADE_STAYOUT			0x0008		// ignores the duration, stays faded out until new ScreenFade message received
#define FFADE_PURGE			0x0010		// Purges all other fades, replacing them with this one
== Examples ==
UTIL_ScreenFadeAll( m_clrRender, Duration(), HoldTime(), FFADE_OUT );
UTIL_ScreenFadeAll( m_clrRender, Duration(), HoldTime(), fadeFlags|FFADE_PURGE );
Category:Programming
Category:UTIL
UTIL ScreenShake

UTIL_ScreenShake is a UTIL provided in the Source code for shaking the player's screen, or controller.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Shake the screen of all clients within radius.
//			radius == 0, shake all clients
// Input : center - Center of screen shake, radius is measured from here.
//			amplitude - Amplitude of shake
//			frequency - 
//			duration - duration of shake in seconds.
//			radius - Radius of effect, 0 shakes all clients.
//			command - One of the following values:
//				SHAKE_START - starts the screen shake for all players within the radius
//				SHAKE_STOP - stops the screen shake for all players within the radius
//				SHAKE_AMPLITUDE - modifies the amplitude of the screen shake
//									for all players within the radius
//				SHAKE_FREQUENCY - modifies the frequency of the screen shake
//									for all players within the radius
// //OTHERS MAY APPLY (See ShakeCommand_t values below)
//			bAirShake - if this is false, then it will only shake players standing on the ground.
//-----------------------------------------------------------------------------
void UTIL_ScreenShake( const Vector ¢er, float amplitude, float frequency, float duration, float radius, ShakeCommand_t eCommand, bool bAirShake )
ShakeCommand_t values
SHAKE_START = 0,		// Starts the screen shake for all players within the radius.
SHAKE_STOP,				// Stops the screen shake for all players within the radius.
SHAKE_AMPLITUDE,		// Modifies the amplitude of an active screen shake for all players within the radius.
SHAKE_FREQUENCY,		// Modifies the frequency of an active screen shake for all players within the radius.
SHAKE_START_RUMBLEONLY,	// Starts a shake effect that only rumbles the controller, no screen effect.
SHAKE_START_NORUMBLE,	// Starts a shake that does NOT rumble the controller.
== Examples ==
UTIL_ScreenShake( GetAbsOrigin(), 25.0, 150.0, 1.0, 750, SHAKE_START );
//This example takes the player, punches his view
//pushes him back, and then shakes his screen while
//making it red. It's from NPC_Hunter::MeleeAttack
if ( pPlayer != NULL && !(pPlayer->GetFlags() & FL_GODMODE ) )
{
	pPlayer->ViewPunch( qaViewPunch );
	pPlayer->VelocityPunch( vecVelocityPunch );
	
	// Shake the screen
	UTIL_ScreenShake( pPlayer->GetAbsOrigin(), 100.0, 1.5, 1.0, 2, SHAKE_START );
	// Red damage indicator
	color32 red = { 128, 0, 0, 128 };
	UTIL_ScreenFade( pPlayer, red, 1.0f, 0.1f, FFADE_IN );
}
Category:Programming
Category:UTIL
UTIL ScreenShakeObject

UTIL_ScreenShakeObject is a UTIL provided in the Source code for shaking objects. It will also shake all players on, or near it.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Shake the screen of all clients within radius.
//			radius == 0, shake all clients
// Input : pEnt - Entity to shake
// Input : center - Center of screen shake, radius is measured from here.
//			amplitude - Amplitude of shake
//			frequency - 
//			duration - duration of shake in seconds.
//			radius - Radius of effect, 0 shakes all clients.
//			command - One of the following values:
//				SHAKE_START - starts the screen shake for all players within the radius
//				SHAKE_STOP - stops the screen shake for all players within the radius
//				SHAKE_AMPLITUDE - modifies the amplitude of the screen shake
//									for all players within the radius
//				SHAKE_FREQUENCY - modifies the frequency of the screen shake
//									for all players within the radius
// //OTHERS MAY APPLY (See ShakeCommand_t values below)
//			bAirShake - if this is false, then it will only shake players standing on the ground.
//-----------------------------------------------------------------------------
void UTIL_ScreenShakeObject( CBaseEntity *pEnt, const Vector ¢er, float amplitude, 
 float frequency, float duration, float radius, ShakeCommand_t eCommand, bool bAirShake )
ShakeCommand_t values
SHAKE_START = 0,		// Starts the screen shake for all players within the radius.
SHAKE_STOP,				// Stops the screen shake for all players within the radius.
SHAKE_AMPLITUDE,		// Modifies the amplitude of an active screen shake for all players within the radius.
SHAKE_FREQUENCY,		// Modifies the frequency of an active screen shake for all players within the radius.
SHAKE_START_RUMBLEONLY,	// Starts a shake effect that only rumbles the controller, no screen effect.
SHAKE_START_NORUMBLE,	// Starts a shake that does NOT rumble the controller.
== Examples ==
//This example checks if it's time to 'shake' the gun on the Airboat again
//And if so, shakes the entire airboat, like the gun was causing
//the frame to take forces from firing.
if ( gpGlobals->curtime >= m_flNextGunShakeTime )
{
 //WorldSpaceCenter() gets the center of the object.
	UTIL_ScreenShakeObject( this, WorldSpaceCenter(), 0.2, 250.0, CANNON_SHAKE_INTERVAL, 250, SHAKE_START );
	m_flNextGunShakeTime = gpGlobals->curtime + 0.5 * CANNON_SHAKE_INTERVAL; 
}
Category:Programming
Category:UTIL
UTIL SetModel

UTIL_SetModel is a UTIL function provided in the Source engine to set the model of an entity.
Appears to be largely obsolete and replaced by SetModel, which sets the model for the entity it is called on, and not another entity.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Change another entity's model
// Input : *pEntity - Entity to set the model on
// Input : *pModelName - model name as string
// Output : 
//-----------------------------------------------------------------------------
void UTIL_SetModel( CBaseEntity *pEntity, const char *pModelName )
== Examples ==
UTIL_SetModel( this, STRING( GetModelName() ) );
CEnvQuadraticBeam *CreateQuadraticBeam( const char *pSpriteName, const Vector &start, const Vector &control, const Vector &end, float width, CBaseEntity *pOwner )
{
	CEnvQuadraticBeam *pBeam = (CEnvQuadraticBeam *)CBaseEntity::Create( "env_quadraticbeam", start, vec3_angle, pOwner );
	UTIL_SetModel( pBeam, pSpriteName );
	pBeam->SetSpline( control, end );
	pBeam->SetScrollRate( 0.0 );
	pBeam->SetWidth(width);
	return pBeam;
}
Category:Programming
Category:UTIL
UTIL ShouldShowBlood

UTIL_ShouldShowBlood is a UTIL provided in the Source code that returns if blood should be shown, depending on the game's violence setting. 
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : int - color | The color of the blood to check against.
// Output :
//-----------------------------------------------------------------------------
bool UTIL_ShouldShowBlood( int color )
{
	if ( color != DONT_BLEED )
	{
		if ( color == BLOOD_COLOR_RED )
		{
			return violence_hblood.GetBool();
		}
		else
		{
			return violence_ablood.GetBool();
		}
	}
	return false;
}
static ConVar	violence_hblood( "violence_hblood","1", 0, "Draw human blood" );
static ConVar	violence_ablood( "violence_ablood","1", 0, "Draw alien blood" );
== Examples ==
//This simply checks the blood color of pHurt
//If their blood is set as DONT_BLEED, it returns false, and skips
//this function. Otherwise it will check the violence convars
//And decide if it should make the blood or not.
if ( UTIL_ShouldShowBlood(pHurt->BloodColor()) )
{
	// Hit an NPC. Bleed them!
	Vector vecBloodPos;
	switch ( BloodOrigin )
	{
		case HUNTER_BLOOD_LEFT_FOOT:
		{
			if ( GetAttachment( "blood_left", vecBloodPos ) )
			{
				SpawnBlood( vecBloodPos, g_vecAttackDir, pHurt->BloodColor(), min( iDamage, 30 ) );
			}
			
			break;
		}
	}
}
//This example just checks the violence convar for BLOOD_COLOR_YELLOW
//which is violence_ablood.
if ( UTIL_ShouldShowBlood( BLOOD_COLOR_YELLOW ) )
Category:Programming
Category:UTIL
UTIL Smoke

UTIL_Smoke is a UTIL provided in the Source code for creating smoke. This appears to be a hardcoded particle smoke, so it may be wiser to use a Particle System based smoke instead.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Creates smoke at the origin of specified scale at specified framerate
// 
// Input : &origin - Worldspace vector to emit smoke from
// scale - Scale of the smoke particles
// framerate - framerate of playback 
// Output : 
//-----------------------------------------------------------------------------
void UTIL_Smoke( const Vector &origin, const float scale, const float framerate )
== Examples ==
void CNPC_Stalker::DoSmokeEffect( const Vector &position )
{
	if ( gpGlobals->curtime > m_nextSmokeTime )
	{
		m_nextSmokeTime = gpGlobals->curtime + 0.5;
		UTIL_Smoke(position, random->RandomInt(5, 10), 10);
	}
}
// --------------------------------------
// Smoke or bubbles effect
// --------------------------------------
//If we're in water, we create bubbles
if (UTIL_PointContents ( GetAbsOrigin() ) & MASK_WATER)
{
	UTIL_Bubbles(GetAbsOrigin()-Vector(3,3,3),GetAbsOrigin()+Vector(3,3,3),10);
}
//Otherwise, just create some smoke
else 
{
	UTIL_Smoke(GetAbsOrigin(), random->RandomInt(5, 10), 10);
}
Category:Programming
Category:UTIL