//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======// // // Purpose: // // $Workfile: $ // $NoKeywords: $ //===========================================================================// #include "cbase.h" #include #include "hud.h" #include "itextmessage.h" #include "materialsystem/imaterial.h" #include "materialsystem/itexture.h" #include "materialsystem/imaterialsystem.h" #include "imovehelper.h" #include "checksum_crc.h" #include "decals.h" #include "iefx.h" #include "view_scene.h" #include "filesystem.h" #include "model_types.h" #include "engine/IEngineTrace.h" #include "engine/ivmodelinfo.h" #include "c_te_effect_dispatch.h" #include #include #include #include "view.h" #include "ixboxsystem.h" #include #include #include "vgui_int.h" #include "cdll_client_int.h" #include "c_cs_playerresource.h" #include "c_cs_player.h" #include "cs_gamerules.h" #include "weapon_c4.h" // memdbgon must be the last include file in a .cpp file!!! #include "tier0/memdbgon.h" //----------------------------------------------------------------------------- // ConVars //----------------------------------------------------------------------------- #ifdef _DEBUG ConVar r_FadeProps( "r_FadeProps", "1" ); #endif bool g_MakingDevShots = false; extern ConVar cl_leveloverview; //----------------------------------------------------------------------------- // Purpose: Performs a var args printf into a static return buffer // Input : *format - // ... - // Output : char //----------------------------------------------------------------------------- char *VarArgs( const char *format, ... ) { va_list argptr; static char string[1024]; va_start (argptr, format); Q_vsnprintf (string, sizeof( string ), format,argptr); va_end (argptr); return string; } //----------------------------------------------------------------------------- // Purpose: Returns true if the entity index corresponds to a player slot // Input : index - // Output : bool //----------------------------------------------------------------------------- bool IsPlayerIndex( int index ) { return ( index >= 1 && index <= gpGlobals->maxClients ) ? true : false; } int GetLocalPlayerIndex( void ) { C_BasePlayer * player = C_BasePlayer::GetLocalPlayer(); if ( player ) return player->entindex(); else return 0; // game not started yet } bool IsLocalPlayerSpectator( void ) { C_BasePlayer * player = C_BasePlayer::GetLocalPlayer(); if ( player ) return player->IsObserver(); else return false; // game not started yet } int GetSpectatorMode( void ) { C_BasePlayer * player = C_BasePlayer::GetLocalPlayer(); if ( player ) return player->GetObserverMode(); else return OBS_MODE_NONE; // game not started yet } int GetSpectatorTarget( void ) { C_BasePlayer * player = C_BasePlayer::GetLocalPlayer(); if ( player ) { CBaseEntity * target = player->GetObserverTarget(); if ( target ) return target->entindex(); else return 0; } else { return 0; // game not started yet } } // this is meant to be called on a bot character // note: This is quite similar to CCSPlayer::CanControlBot. This is here since calling into the CCSPlayer was unrealistic in some code paths // TODO: Fix this so it ACTUALLY calls CanControlBot, there are bugs otherwise (and will be more) do to them being different functions bool CanControlSpectatedTarget( void ) { C_CSPlayer * player = ( C_CSPlayer* )C_BasePlayer::GetLocalPlayer(); if ( !player || ( player->GetPendingTeamNumber() != player->GetTeamNumber() ) ) return false; C_CSPlayer * target = dynamic_cast(player->GetObserverTarget()); if ( !target ) return false; if ( !target->IsAlive() ) return false; if ( !target->IsOtherSameTeam( GetLocalPlayerTeam() ) || target->IsOtherEnemy( player ) ) return false; C_CS_PlayerResource *pCSPR = ( C_CS_PlayerResource* )GameResources(); int entIndex = target->entindex(); bool targetIsFakePlayer = pCSPR->IsFakePlayer( entIndex ); if ( !targetIsFakePlayer ) return false; AssertMsg(pCSPR, "Expected PlayerResources to exsist"); AssertMsg(entIndex > 0 && entIndex <= MAX_PLAYERS, "Bad entity index for player"); // need to duplicate some of the checks that CanControlBot already does so they match up.... // Can't control a bot that is setting a bomb const CC4 *pC4 = dynamic_cast( target->GetActiveWeapon() ); if ( pC4 && pC4->m_bStartedArming ) return false; if ( CSGameRules() && CSGameRules()->IsRoundOver() ) return false; if ( CSGameRules() && CSGameRules()->IsFreezePeriod() ) return false; return true; } bool CanSeeSpectatorOnlyTools( void ) { C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( !pPlayer ) return false; if ( pPlayer->IsHLTV() ) return true; if ( pPlayer->IsSpectator() ) { if ( sv_competitive_official_5v5.GetBool() ) return true; if ( CSGameRules() && CSGameRules()->IsQueuedMatchmaking() ) return true; } return false; } bool CanToggleXRayView( void ) { C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( !pPlayer ) return false; if ( CanSeeSpectatorOnlyTools() ) return true; return false; } int GetLocalPlayerTeam( void ) { C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer(); if ( pPlayer ) return pPlayer->GetTeamNumber(); else return TEAM_UNASSIGNED; } //----------------------------------------------------------------------------- // Purpose: Convert angles to -180 t 180 range // Input : angles - //----------------------------------------------------------------------------- void NormalizeAngles( QAngle& angles ) { int i; // Normalize angles to -180 to 180 range for ( i = 0; i < 3; i++ ) { if ( angles[i] > 180.0 ) { angles[i] -= 360.0; } else if ( angles[i] < -180.0 ) { angles[i] += 360.0; } } } //----------------------------------------------------------------------------- // Purpose: Interpolate Euler angles using quaternions to avoid singularities // Input : start - // end - // output - // frac - //----------------------------------------------------------------------------- void InterpolateAngles( const QAngle& start, const QAngle& end, QAngle& output, float frac ) { Quaternion src, dest; // Convert to quaternions AngleQuaternion( start, src ); AngleQuaternion( end, dest ); Quaternion result; // Slerp QuaternionSlerp( src, dest, frac, result ); // Convert to euler QuaternionAngles( result, output ); } //----------------------------------------------------------------------------- // Purpose: Simple linear interpolation // Input : frac - // src - // dest - // output - //----------------------------------------------------------------------------- void InterpolateVector( float frac, const Vector& src, const Vector& dest, Vector& output ) { int i; for ( i = 0; i < 3; i++ ) { output[ i ] = src[ i ] + frac * ( dest[ i ] - src[ i ] ); } } client_textmessage_t *TextMessageGet( const char *pName ) { return engine->TextMessageGet( pName ); } //----------------------------------------------------------------------------- // Purpose: ScreenHeight returns the height of the screen, in pixels // Output : int //----------------------------------------------------------------------------- int ScreenHeight( void ) { int w, h; GetHudSize( w, h ); return h; } //----------------------------------------------------------------------------- // Purpose: ScreenWidth returns the width of the screen, in pixels // Output : int //----------------------------------------------------------------------------- int ScreenWidth( void ) { int w, h; GetHudSize( w, h ); return w; } //----------------------------------------------------------------------------- // Purpose: Return the difference between two angles // Input : destAngle - // srcAngle - // Output : float //----------------------------------------------------------------------------- float UTIL_AngleDiff( float destAngle, float srcAngle ) { float delta; delta = destAngle - srcAngle; if ( destAngle > srcAngle ) { while ( delta >= 180 ) delta -= 360; } else { while ( delta <= -180 ) delta += 360; } return delta; } 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 ); int bubbles = modelinfo->GetModelIndex( "sprites/bubble.vmt" ); te->Bubbles( filter, 0.0, &mins, &maxs, flHeight, bubbles, count, 8.0 ); } void UTIL_ScreenShake( const Vector ¢er, float amplitude, float frequency, float duration, float radius, ShakeCommand_t eCommand, bool bAirShake ) { // Nothing for now } char TEXTURETYPE_Find( trace_t *ptr ) { surfacedata_t *psurfaceData = physprops->GetSurfaceData( ptr->surface.surfaceProps ); return psurfaceData->game.material; } //----------------------------------------------------------------------------- // Purpose: Make a tracer effect //----------------------------------------------------------------------------- void UTIL_Tracer( const Vector &vecStart, const Vector &vecEnd, int iEntIndex, int iAttachment, float flVelocity, bool bWhiz, char *pCustomTracerName ) { CEffectData data; data.m_vStart = vecStart; data.m_vOrigin = vecEnd; data.m_hEntity = ClientEntityList().EntIndexToHandle( iEntIndex ); data.m_flScale = flVelocity; // Flags if ( bWhiz ) { data.m_fFlags |= TRACER_FLAG_WHIZ; } if ( iAttachment != TRACER_DONT_USE_ATTACHMENT ) { data.m_fFlags |= TRACER_FLAG_USEATTACHMENT; // Stomp the start, since it's not going to be used anyway data.m_vStart[0] = iAttachment; } // Fire it off if ( pCustomTracerName ) { DispatchEffect( pCustomTracerName, data ); } else { DispatchEffect( "Tracer", data ); } } // Tried to include this in the actual trace function, but ran into // linker issues. Just dropped it here instead. Michael Dorgan static bool HasValidDirection(trace_t *pTrace) { if(pTrace->fraction <= 0.0001f) { // Ok, there is a very, very strong chance our vectors are out of wack // Add a direct check against the actual start and end points to be sure. if( VectorsAreEqual( pTrace->startpos, pTrace->endpos, 0.0001f ) ) { return false; } } return true; } //------------------------------------------------------------------------------ // 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 ) { C_BaseEntity *pEntity = pTrace->m_pEnt; // Is the entity valid, is the surface sky? if ( !pEntity || (pTrace->surface.flags & SURF_SKY) ) return; if (pTrace->fraction >= 1.0f) return; // Very, very, very close range shots cause all sorts of issues with normal and correct // decal orientation. Just skip them to prevent heartache. if ( !HasValidDirection(pTrace) ) return; // don't decal nodraw surfaces if ( pTrace->surface.flags & SURF_NODRAW ) return; pEntity->ImpactTrace( pTrace, iDamageType, pCustomImpactName ); } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- int UTIL_PrecacheDecal( const char *name, bool preload ) { return effects->Draw_DecalIndexFromName( (char*)name ); } extern int g_sModelIndexSmoke; void UTIL_Smoke( const Vector &origin, const float scale, const float framerate ) { CPVSFilter filter( origin ); te->Smoke( filter, 0.0f, &origin, g_sModelIndexSmoke, scale, framerate ); } void UTIL_SetOrigin( C_BaseEntity *entity, const Vector &vecOrigin ) { entity->SetLocalOrigin( vecOrigin ); } //#define PRECACHE_OTHER_ONCE // UNDONE: Do we need this to avoid doing too much of this? Measure startup times and see #if PRECACHE_OTHER_ONCE #include "utlsymbol.h" class CPrecacheOtherList : public CAutoServerSystem { public: virtual void LevelInitPreEntity(); virtual void LevelShutdownPostEntity(); bool AddOrMarkPrecached( const char *pClassname ); private: CUtlSymbolTable m_list; }; void CPrecacheOtherList::LevelInitPreEntity() { m_list.RemoveAll(); } void CPrecacheOtherList::LevelShutdownPostEntity() { m_list.RemoveAll(); } //----------------------------------------------------------------------------- // Purpose: mark or add // Input : *pEntity - // Output : Returns true on success, false on failure. //----------------------------------------------------------------------------- bool CPrecacheOtherList::AddOrMarkPrecached( const char *pClassname ) { CUtlSymbol sym = m_list.Find( pClassname ); if ( sym.IsValid() ) return false; m_list.AddString( pClassname ); return true; } CPrecacheOtherList g_PrecacheOtherList; #endif void UTIL_PrecacheOther( const char *szClassname ) { #if PRECACHE_OTHER_ONCE // already done this one?, if not, mark as done if ( !g_PrecacheOtherList.AddOrMarkPrecached( szClassname ) ) return; #endif // Client should only do this once entities are coming down from server!!! // Assert( engine->IsConnected() ); C_BaseEntity *pEntity = CreateEntityByName( szClassname ); if ( !pEntity ) { Warning( "NULL Ent in UTIL_PrecacheOther\n" ); return; } if (pEntity) { pEntity->Precache( ); } // Bye bye UTIL_Remove( pEntity ); } static csurface_t g_NullSurface = { "**empty**", 0 }; //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void UTIL_SetTrace(trace_t& trace, const Ray_t& ray, C_BaseEntity *ent, float fraction, int hitgroup, unsigned int contents, const Vector& normal, float intercept ) { trace.startsolid = (fraction == 0.0f); trace.fraction = fraction; VectorCopy( ray.m_Start, trace.startpos ); VectorMA( ray.m_Start, fraction, ray.m_Delta, trace.endpos ); VectorCopy( normal, trace.plane.normal ); trace.plane.dist = intercept; trace.m_pEnt = C_BaseEntity::Instance( ent ); trace.hitgroup = hitgroup; trace.surface = g_NullSurface; trace.contents = contents; } //----------------------------------------------------------------------------- // Purpose: Get the x & y positions of a world position in screenspace // Returns true if it's onscreen //----------------------------------------------------------------------------- bool GetVectorInScreenSpace( Vector pos, int& iX, int& iY, Vector *vecOffset ) { Vector screen; // Apply the offset, if one was specified if ( vecOffset != NULL ) pos += *vecOffset; // Transform to screen space int x, y, screenWidth, screenHeight; int insetX, insetY; VGui_GetEngineRenderBounds( GET_ACTIVE_SPLITSCREEN_SLOT(), x, y, screenWidth, screenHeight, insetX, insetY ); // Transform to screen space int iFacing = ScreenTransform( pos, screen ); iX = 0.5 * screen[0] * screenWidth; iY = -0.5 * screen[1] * screenHeight; iX += 0.5 * screenWidth; iY += 0.5 * screenHeight; iX += insetX; iY += insetY; // Make sure the player's facing it if ( iFacing ) { // We're actually facing away from the Target. Stomp the screen position. iX = -640; iY = -640; return false; } return true; } //----------------------------------------------------------------------------- // Purpose: Get the x & y positions of an entity in screenspace // Returns true if it's onscreen //----------------------------------------------------------------------------- bool GetTargetInScreenSpace( C_BaseEntity *pTargetEntity, int& iX, int& iY, Vector *vecOffset ) { return GetVectorInScreenSpace( pTargetEntity->WorldSpaceCenter(), iX, iY, vecOffset ); } //----------------------------------------------------------------------------- // Purpose: // Input : *player - // msg_dest - // *msg_name - // *param1 - // *param2 - // *param3 - // *param4 - //----------------------------------------------------------------------------- void ClientPrint( C_BasePlayer *player, int msg_dest, const char *msg_name, const char *param1 /*= NULL*/, const char *param2 /*= NULL*/, const char *param3 /*= NULL*/, const char *param4 /*= NULL*/ ) { } //----------------------------------------------------------------------------- // Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted // Input : **pList - // listMax - // &mins - // &maxs - // flagMask - // Output : int //----------------------------------------------------------------------------- int UTIL_EntitiesInBox( C_BaseEntity **pList, int listMax, const Vector &mins, const Vector &maxs, int flagMask, int partitionMask ) { CFlaggedEntitiesEnum boxEnum( pList, listMax, flagMask ); ::partition->EnumerateElementsInBox( partitionMask, mins, maxs, false, &boxEnum ); return boxEnum.GetCount(); } //----------------------------------------------------------------------------- // Purpose: Pass in an array of pointers and an array size, it fills the array and returns the number inserted // Input : **pList - // listMax - // ¢er - // radius - // flagMask - // Output : int //----------------------------------------------------------------------------- int UTIL_EntitiesInSphere( C_BaseEntity **pList, int listMax, const Vector ¢er, float radius, int flagMask, int partitionMask ) { CFlaggedEntitiesEnum sphereEnum( pList, listMax, flagMask ); ::partition->EnumerateElementsInSphere( partitionMask, center, radius, false, &sphereEnum ); return sphereEnum.GetCount(); } int UTIL_RenderablesInBox( C_BaseEntity** pList, int listMax, const Vector &mins, const Vector &maxs ) { return g_pClientLeafSystem->GetEntitiesInBox( pList, listMax, mins, maxs ); } CEntitySphereQuery::CEntitySphereQuery( const Vector ¢er, float radius, int flagMask, int partitionMask ) { m_listIndex = 0; m_listCount = UTIL_EntitiesInSphere( m_pList, ARRAYSIZE(m_pList), center, radius, flagMask, partitionMask ); } CBaseEntity *CEntitySphereQuery::GetCurrentEntity() { if ( m_listIndex < m_listCount ) return m_pList[m_listIndex]; return NULL; } //----------------------------------------------------------------------------- // Purpose: // Input : font - // *str - // Output : int //----------------------------------------------------------------------------- int UTIL_ComputeStringWidth( vgui::HFont& font, const char *str ) { float pixels = 0; char *p = (char *)str; char *pAfter = p + 1; char *pBefore = "\0"; while ( *p ) { #ifdef OSX float wide, abcA, abcC; vgui::surface()->GetKernedCharWidth( font, *p, *pBefore, *pAfter, wide, abcA, abcC ); pixels += wide; #else pixels += vgui::surface()->GetCharacterWidth( font, *p ); #endif pBefore = p; p++; if ( *p ) pAfter = p + 1; else pAfter = "\0"; } return (int)ceil(pixels); } //----------------------------------------------------------------------------- // Purpose: // Input : font - // *str - // Output : int //----------------------------------------------------------------------------- int UTIL_ComputeStringWidth( vgui::HFont& font, const wchar_t *str ) { float pixels = 0; wchar_t *p = (wchar_t *)str; wchar_t *pAfter = p + 1; wchar_t *pBefore = L"\0"; while ( *p ) { #ifdef OSX float wide, abcA, abcC; vgui::surface()->GetKernedCharWidth( font, *p, *pBefore, *pAfter, wide, abcA, abcC ); pixels += wide; #else pixels += vgui::surface()->GetCharacterWidth( font, *p ); #endif pBefore = p; p++; if ( *p ) pAfter = p + 1; else pAfter = L"\0"; } return (int)ceil(pixels); } //----------------------------------------------------------------------------- // Purpose: Scans player names //Passes the player name to be checked in a KeyValues pointer //with the keyname "name" // - replaces '&' with '&&' so they will draw in the scoreboard // - replaces '#' at the start of the name with '*' //----------------------------------------------------------------------------- void UTIL_MakeSafeName( const char *oldName, char *newName, int newNameBufSize ) { int newpos = 0; for( const char *p=oldName; *p != 0 && newpos < newNameBufSize-1; p++ ) { //check for a '#' char at the beginning if( p == oldName && *p == '#' ) { newName[newpos] = '*'; newpos++; } else if( *p == '%' ) { // remove % chars newName[newpos] = '*'; newpos++; } else if( *p == '&' ) { //insert another & after this one if ( newpos+2 < newNameBufSize ) { newName[newpos] = '&'; newName[newpos+1] = '&'; newpos+=2; } } else { newName[newpos] = *p; newpos++; } } newName[newpos] = 0; } //----------------------------------------------------------------------------- // 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 ) { static char safeName[ MAX_PLAYER_NAME_LENGTH * 2 + 1 ]; UTIL_MakeSafeName( oldName, safeName, sizeof( safeName ) ); return safeName; } //----------------------------------------------------------------------------- // Purpose: Looks up key bindings for commands and replaces them in string. // %% will get replaced with its bound control, e.g. %attack2% // Input buffer sizes are in bytes rather than unicode character count // for consistency with other APIs. If inbufsizebytes is 0 a NULL-terminated // input buffer is assumed, or you can pass the size of the input buffer if // not NULL-terminated. //----------------------------------------------------------------------------- void UTIL_ReplaceKeyBindings( const wchar_t *inbuf, int inbufsizebytes, wchar_t *outbuf, int outbufsizebytes ) { if ( !inbuf || !inbuf[0] ) return; ASSERT_LOCAL_PLAYER_RESOLVABLE(); int nSlot = GET_ACTIVE_SPLITSCREEN_SLOT(); // copy to a new buf if there are vars outbuf[0]=0; int pos = 0; const wchar_t *inbufend = NULL; if ( inbufsizebytes > 0 ) { inbufend = inbuf + ( inbufsizebytes / 2 ); } while( inbuf != inbufend && *inbuf != 0 ) { // check for variables if ( *inbuf == '%' ) { ++inbuf; const wchar_t *end = wcschr( inbuf, '%' ); if ( end && ( end != inbuf ) ) // make sure we handle %% in the string, which should be treated in the output as % { wchar_t token[64]; wcsncpy( token, inbuf, end - inbuf ); token[end - inbuf] = 0; inbuf += end - inbuf; // lookup key names char binding[64]; g_pVGuiLocalize->ConvertUnicodeToANSI( token, binding, sizeof(binding) ); const char *key = engine->Key_LookupBindingEx( *binding == '+' ? binding + 1 : binding, nSlot ); //!! change some key names into better names char friendlyName[64]; bool bAddBrackets = false; if ( IsGameConsole() ) { if ( !key || !key[0] ) { Q_snprintf( friendlyName, sizeof(friendlyName), "%s", binding ); bAddBrackets = true; } else { Q_snprintf( friendlyName, sizeof(friendlyName), "#GameUI_KeyNames_%s", key ); Q_strupr( friendlyName ); } } else { if ( !key || !key[0] ) { Q_snprintf( friendlyName, sizeof(friendlyName), "%s", binding ); } else { Q_snprintf( friendlyName, sizeof(friendlyName), "%s", key ); Q_strupr( friendlyName ); } } wchar_t *locName = g_pVGuiLocalize->Find( friendlyName ); if ( !locName || wcslen(locName) <= 0) { g_pVGuiLocalize->ConvertANSIToUnicode( friendlyName, token, sizeof(token) ); outbuf[pos] = '\0'; wcscat( outbuf, token ); pos += wcslen(token); } else { outbuf[pos] = '\0'; if ( bAddBrackets ) { wcscat( outbuf, L"[" ); pos += 1; } wcscat( outbuf, locName ); pos += wcslen(locName); if ( bAddBrackets ) { wcscat( outbuf, L"]" ); pos += 1; } } } else { outbuf[pos] = *inbuf; ++pos; } } else { outbuf[pos] = *inbuf; ++pos; } ++inbuf; } outbuf[pos] = '\0'; } //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void UTIL_SetControlStringWithKeybindings( vgui::EditablePanel *panel, const char *controlName, const char *str ) { if ( !panel || !controlName || !str ) return; const wchar_t *unicodeStr = g_pVGuiLocalize->Find( str ); if ( unicodeStr ) { wchar_t buf[512]; UTIL_ReplaceKeyBindings( unicodeStr, 0, buf, sizeof( buf ) ); panel->SetControlString( controlName, buf ); } else { panel->SetControlString( controlName, str ); } } //----------------------------------------------------------------------------- // Purpose: // Input : *filename - // *pLength - // Output : byte //----------------------------------------------------------------------------- byte *UTIL_LoadFileForMe( const char *filename, int *pLength ) { byte *buffer; FileHandle_t file; file = filesystem->Open( filename, "rb", "GAME" ); if ( FILESYSTEM_INVALID_HANDLE == file ) { if ( pLength ) *pLength = 0; return NULL; } int size = filesystem->Size( file ); buffer = new byte[ size + 1 ]; if ( !buffer ) { Warning( "UTIL_LoadFileForMe: Couldn't allocate buffer of size %i for file %s\n", size + 1, filename ); filesystem->Close( file ); return NULL; } filesystem->Read( buffer, size, file ); filesystem->Close( file ); // Ensure null terminator buffer[ size ] =0; if ( pLength ) { *pLength = size; } return buffer; } //----------------------------------------------------------------------------- // Purpose: // Input : *buffer - //----------------------------------------------------------------------------- void UTIL_FreeFile( byte *buffer ) { delete[] buffer; } //----------------------------------------------------------------------------- // Compute distance fade //----------------------------------------------------------------------------- static unsigned char ComputeDistanceFade( C_BaseEntity *pEntity, float flMinDist, float flMaxDist ) { if ((flMinDist <= 0) && (flMaxDist <= 0)) return 255; if( flMinDist > flMaxDist ) { V_swap( flMinDist, flMaxDist ); } // If a negative value is provided for the min fade distance, then base it off the max. if( flMinDist < 0 ) { flMinDist = flMaxDist - 400; if( flMinDist < 0 ) { flMinDist = 0; } } flMinDist *= flMinDist; flMaxDist *= flMaxDist; float flCurrentDistanceSq = CurrentViewOrigin().DistToSqr( pEntity->WorldSpaceCenter() ); C_BasePlayer *pLocal = C_BasePlayer::GetLocalPlayer(); if ( pLocal ) { float flDistFactor = pLocal->GetFOVDistanceAdjustFactor(); flCurrentDistanceSq *= flDistFactor * flDistFactor; } // If I'm inside the minimum range than don't resort to alpha trickery if ( flCurrentDistanceSq <= flMinDist ) return 255; if ( flCurrentDistanceSq >= flMaxDist ) return 0; // NOTE: Because of the if-checks above, flMinDist != flMinDist here float flFalloffFactor = 255.0f / (flMaxDist - flMinDist); int nAlpha = flFalloffFactor * (flMaxDist - flCurrentDistanceSq); return clamp( nAlpha, 0, 255 ); } //----------------------------------------------------------------------------- // Compute fade amount //----------------------------------------------------------------------------- unsigned char UTIL_ComputeEntityFade( C_BaseEntity *pEntity, float flMinDist, float flMaxDist, float flFadeScale ) { unsigned char nAlpha = 255; // If we're taking devshots, don't fade props at all if ( g_MakingDevShots || cl_leveloverview.GetInt() != 0 || input->CAM_IsThirdPersonOverview() ) return 255; #ifdef _DEBUG if ( r_FadeProps.GetBool() ) #endif { nAlpha = ComputeDistanceFade( pEntity, flMinDist, flMaxDist ); // NOTE: This computation for the center + radius is invalid! // The center of the sphere is at the center of the OBB, which is not necessarily // at the render origin. But it should be close enough. Vector vecMins, vecMaxs; pEntity->GetRenderBounds( vecMins, vecMaxs ); float flRadius = vecMins.DistTo( vecMaxs ) * 0.5f; Vector vecAbsCenter; if ( modelinfo->GetModelType( pEntity->GetModel() ) == mod_brush ) { Vector vecRenderMins, vecRenderMaxs; pEntity->GetRenderBoundsWorldspace( vecRenderMins, vecRenderMaxs ); VectorAdd( vecRenderMins, vecRenderMaxs, vecAbsCenter ); vecAbsCenter *= 0.5f; } else { vecAbsCenter = pEntity->GetRenderOrigin(); } unsigned char nGlobalAlpha = modelinfo->ComputeLevelScreenFade( vecAbsCenter, flRadius, flFadeScale ); unsigned char nDistAlpha; if ( !engine->IsLevelMainMenuBackground() ) { nDistAlpha = modelinfo->ComputeViewScreenFade( vecAbsCenter, flRadius, flFadeScale ); } else { nDistAlpha = 255; } if ( nDistAlpha < nGlobalAlpha ) { nGlobalAlpha = nDistAlpha; } if ( nGlobalAlpha < nAlpha ) { nAlpha = nGlobalAlpha; } } return nAlpha; } //----------------------------------------------------------------------------- // Purpose: Given a vector, clamps the scalar axes to MAX_COORD_FLOAT ranges from worldsize.h // Input : *pVecPos - //----------------------------------------------------------------------------- void UTIL_BoundToWorldSize( Vector *pVecPos ) { Assert( pVecPos ); for ( int i = 0; i < 3; ++i ) { (*pVecPos)[ i ] = clamp( (*pVecPos)[ i ], MIN_COORD_FLOAT, MAX_COORD_FLOAT ); } } #ifdef _GAMECONSOLE #define MAP_KEY_FILE_DIR "cfg" #else #define MAP_KEY_FILE_DIR "media" #endif //----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- C_BasePlayer* UTIL_PlayerByUserId( int userID ) { for (int i = 1; i<=gpGlobals->maxClients; i++ ) { C_BasePlayer *pPlayer = UTIL_PlayerByIndex( i ); if ( !pPlayer ) continue; if ( pPlayer->GetUserID() == userID ) { return pPlayer; } } return NULL; } C_BaseEntity* UTIL_EntityFromUserMessageEHandle( long nEncodedEHandle ) { int nEntity, nSerialNum; if( nEncodedEHandle == INVALID_NETWORKED_EHANDLE_VALUE ) return NULL; nEntity = nEncodedEHandle & ((1 << MAX_EDICT_BITS) - 1); nSerialNum = nEncodedEHandle >> MAX_EDICT_BITS; EHANDLE hEntity( nEntity, nSerialNum ); return hEntity.Get(); } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void UTIL_ApproachTarget( float target, float increaseSpeed, float decreaseSpeed, float *val ) { if ( *val < target ) { *val += gpGlobals->frametime*increaseSpeed; *val = MIN( *val, target ); } else if ( *val > target ) { *val -= gpGlobals->frametime*decreaseSpeed; *val = MAX( *val, target ); } } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- void UTIL_ApproachTarget( const Vector &target, float increaseSpeed, float decreaseSpeed, Vector *val ) { UTIL_ApproachTarget( target.x, increaseSpeed, decreaseSpeed, &val->x ); UTIL_ApproachTarget( target.y, increaseSpeed, decreaseSpeed, &val->y ); UTIL_ApproachTarget( target.z, increaseSpeed, decreaseSpeed, &val->z ); } //----------------------------------------------------------------------------- // Purpose: Returns the filename to count map loads in //----------------------------------------------------------------------------- bool UTIL_GetMapLoadCountFileName( int iController, const char *pszFilePrependName, char *pszBuffer, int iBuflen ) { if ( IsX360() ) { #ifdef _X360 if ( iController < 0 || iController >= XUSER_MAX_COUNT ) return false; int iSlot = -1; for ( unsigned int k = 0; k < XBX_GetNumGameUsers(); ++ k ) { if ( XBX_GetUserId( k ) == iController ) { iSlot = k; if ( XBX_GetUserIsGuest( k ) ) return false; } } if ( iSlot < 0 ) return false; DWORD nStorageDevice = XBX_GetStorageDeviceId( iController ); if ( !XBX_DescribeStorageDevice( nStorageDevice ) ) return false; #endif } #ifdef _X360 if ( IsX360() ) { XBX_MakeStorageContainerRoot( iController, XBX_USER_SETTINGS_CONTAINER_DRIVE, pszBuffer, iBuflen ); int nLen = strlen( pszBuffer ); Q_snprintf( pszBuffer + nLen, iBuflen - nLen, ":/%s", pszFilePrependName ); } else #endif { Q_snprintf( pszBuffer, iBuflen, "%s/%s", MAP_KEY_FILE_DIR, pszFilePrependName ); } return true; } #ifdef TF_CLIENT_DLL #define MAP_KEY_FILE "viewed.res" #else #define MAP_KEY_FILE "mapkeys.res" #endif void UTIL_IncrementMapKey( const char *pszCustomKey ) { #ifdef _X360 // TODO: controller-specific code required return; #endif int iController = -1; if ( !pszCustomKey ) return; char szFilename[ _MAX_PATH ]; if ( !UTIL_GetMapLoadCountFileName( iController, MAP_KEY_FILE, szFilename, _MAX_PATH ) ) return; int iCount = 1; KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE ); if ( kvMapLoadFile ) { kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" ); char mapname[MAX_MAP_NAME]; Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) ); Q_strlower( mapname ); // Increment existing, or add a new one KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname ); if ( pMapKey ) { iCount = pMapKey->GetInt( pszCustomKey, 0 ) + 1; pMapKey->SetInt( pszCustomKey, iCount ); } else { KeyValues *pNewKey = new KeyValues( mapname ); if ( pNewKey ) { pNewKey->SetString( pszCustomKey, "1" ); kvMapLoadFile->AddSubKey( pNewKey ); } } // Write it out // force create this directory incase it doesn't exist filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD"); CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER ); kvMapLoadFile->RecursiveSaveToFile( buf, 0 ); g_pFullFileSystem->WriteFile( szFilename, "MOD", buf ); kvMapLoadFile->deleteThis(); } #ifdef _X360 if ( xboxsystem ) { xboxsystem->FinishContainerWrites( iController ); } #endif } int UTIL_GetMapKeyCount( const char *pszCustomKey ) { #ifdef _X360 // TODO: controller-specific code required return 0; #endif int iController = -1; if ( !pszCustomKey ) return 0; char szFilename[ _MAX_PATH ]; if ( !UTIL_GetMapLoadCountFileName( iController, MAP_KEY_FILE, szFilename, _MAX_PATH ) ) return 0; int iCount = 0; KeyValues *kvMapLoadFile = new KeyValues( MAP_KEY_FILE ); if ( kvMapLoadFile ) { // create an empty file if none exists if ( !g_pFullFileSystem->FileExists( szFilename, "MOD" ) ) { // force create this directory incase it doesn't exist filesystem->CreateDirHierarchy( MAP_KEY_FILE_DIR, "MOD"); CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER ); g_pFullFileSystem->WriteFile( szFilename, "MOD", buf ); } kvMapLoadFile->LoadFromFile( g_pFullFileSystem, szFilename, "MOD" ); char mapname[MAX_MAP_NAME]; Q_FileBase( engine->GetLevelName(), mapname, sizeof( mapname) ); Q_strlower( mapname ); KeyValues *pMapKey = kvMapLoadFile->FindKey( mapname ); if ( pMapKey ) { iCount = pMapKey->GetInt( pszCustomKey ); } kvMapLoadFile->deleteThis(); } return iCount; } bool UTIL_HasLoadedAnyMap() { #ifdef _X360 // TODO: controller-specific code required return 0; #endif int iController = -1; char szFilename[ _MAX_PATH ]; if ( !UTIL_GetMapLoadCountFileName( iController, MAP_KEY_FILE, szFilename, _MAX_PATH ) ) return false; return g_pFullFileSystem->FileExists( szFilename, "MOD" ); } wchar_t *UTIL_GetLocalizedKeyString( const char *command, const char *fmt, const wchar_t *arg1, const wchar_t *arg2, const wchar_t *arg3 ) { static wchar_t useString[4][256]; static int index = 0; index = index + 1; if ( index > 3 ) index = 0; const char *lowercaseKey = engine->Key_LookupBinding( command ); if ( !lowercaseKey ) { lowercaseKey = ""; } char szKey[64]; V_strncpy( szKey, lowercaseKey, sizeof( szKey ) ); for ( char *tmp = szKey; *tmp; ++tmp ) { *tmp = toupper( *tmp ); } wchar_t wszKey[64]; g_pVGuiLocalize->ConvertANSIToUnicode( szKey, wszKey, sizeof(wszKey) ); int argCount = 1; if ( arg1 ) { ++argCount; if ( arg2 ) { ++argCount; if ( arg3 ) { ++argCount; } } } g_pVGuiLocalize->ConstructString( useString[index], sizeof( useString[index] ), g_pVGuiLocalize->Find( fmt ), argCount, wszKey, arg1, arg2, arg3 ); return useString[index]; } void UTIL_GetClientStatusText( char *buffer, int nSize ) { if ( !buffer || nSize==0 ) {return;} buffer[0] = 0; #if defined ( CSTRIKE15 ) extern float g_flReadyToCheckForPCBootInvite; bool bStartupFinished = g_flReadyToCheckForPCBootInvite && ( ( Plat_FloatTime() - g_flReadyToCheckForPCBootInvite ) > 1.5f ); if ( bStartupFinished ) Q_snprintf( buffer, nSize, "+" ); if ( nSize <= 2 ) return; C_CS_PlayerResource *pCSPR = ( C_CS_PlayerResource* )GameResources(); if (pCSPR) { Q_snprintf( buffer, nSize, "%sPlayers: ", ( bStartupFinished ? "+" : "" ) ); for ( int i = 1; i <= MAX_PLAYERS; i++ ) { if ( pCSPR->IsConnected(i) ) { const char *name = pCSPR->GetPlayerName(i); if (name && name[0]) { V_strncat( buffer, name, nSize ); V_strncat( buffer, ", ", nSize ); } } } buffer[nSize-1]=0; } #endif } void UTIL_ClearTrace( trace_t &trace ) { memset( &trace, 0, sizeof(trace)); trace.fraction = 1.f; trace.fractionleftsolid = 0; trace.surface = g_NullSurface; } //----------------------------------------------------------------------------- // Also in cdll so linked libs can extern it //----------------------------------------------------------------------------- bool UTIL_IsDedicatedServer( void ) { return false; }