void TestStatPanel( const CCommand &args ) { int iPanelType; if( args.ArgC() < 2 ) { ConMsg( "Usage: teststatpanel < panel type > < optional record type >\n" ); ConMsg( "Usable panel types are %d to %d. Record types are %d to %d\n", TFSTAT_UNDEFINED + 1, TFSTAT_MAX - 1, RECORDBREAK_NONE+1, RECORDBREAK_MAX-1 ); return; } if ( statPanel ) { iPanelType = atoi( args.Arg( 1 ) ); int iRecordType = RECORDBREAK_BEST; if ( args.ArgC() >= 3 ) { iRecordType = atoi( args.Arg( 2 ) ); } if ( ( iPanelType <= TFSTAT_UNDEFINED ) || ( iPanelType >= TFSTAT_MAX ) || (iRecordType <= RECORDBREAK_NONE) || (iRecordType >= RECORDBREAK_MAX) ) { ConMsg( "Usage: teststatpanel < panel type > < optional record type >\n" ); ConMsg( "Usable panel types are %d to %d. Record types are %d to %d\n", TFSTAT_UNDEFINED + 1, TFSTAT_MAX - 1, RECORDBREAK_NONE+1, RECORDBREAK_MAX-1 ); return; } statPanel->TestStatPanel( (TFStatType_t) iPanelType, (RecordBreakType_t)iRecordType ); } }
void CClientState::FileRequested(const char *fileName, unsigned int transferID ) { ConMsg( "File '%s' requested from server %s.\n", fileName, m_NetChannel->GetAddress() ); if ( !cl_allowupload.GetBool() ) { ConMsg( "File uploading disabled.\n" ); m_NetChannel->DenyFile( fileName, transferID ); return; } // TODO check if file valid for uploading m_NetChannel->SendFile( fileName, transferID ); }
void CHLTVDemoRecorder::StartRecording( const char *filename, bool bContinuously ) { StopRecording(); // stop if we're already recording if ( !m_DemoFile.Open( filename, false ) ) { ConMsg ("StartRecording: couldn't open demo file %s.\n", filename ); return; } ConMsg ("Recording SourceTV demo to %s...\n", filename); demoheader_t *dh = &m_DemoFile.m_DemoHeader; // open demo header file containing sigondata Q_memset( dh, 0, sizeof(demoheader_t)); Q_strncpy( dh->demofilestamp, DEMO_HEADER_ID, sizeof(dh->demofilestamp) ); dh->demoprotocol = DEMO_PROTOCOL; dh->networkprotocol = PROTOCOL_VERSION; Q_strncpy( dh->mapname, hltv->GetMapName(), sizeof( dh->mapname ) ); char szGameDir[MAX_OSPATH]; Q_strncpy(szGameDir, com_gamedir, sizeof( szGameDir ) ); Q_FileBase ( szGameDir, dh->gamedirectory, sizeof( dh->gamedirectory ) ); Q_strncpy( dh->servername, host_name.GetString(), sizeof( dh->servername ) ); Q_strncpy( dh->clientname, "SourceTV Demo", sizeof( dh->servername ) ); // write demo file header info m_DemoFile.WriteDemoHeader(); dh->signonlength = WriteSignonData(); // demoheader will be written when demo is closed m_nFrameCount = 0; m_nStartTick = host_tickcount; // Demo playback should read this as an incoming message. // Write the client's realtime value out so we can synchronize the reads. m_DemoFile.WriteCmdHeader( dem_synctick, 0 ); m_bIsRecording = true; m_SequenceInfo = 1; m_nDeltaTick = -1; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CommentaryShowModelViewer( const CCommand &args ) { if ( args.ArgC() < 2 ) { ConMsg( "Usage: commentary_showmodelviewer <model name> <optional attached model name>\n" ); return; } CBaseViewport *pViewport = dynamic_cast<CBaseViewport *>( GetClientMode()->GetViewport() ); if ( pViewport ) { IViewPortPanel *pCommentaryPanel = pViewport->FindPanelByName( PANEL_COMMENTARY_MODELVIEWER ); if ( !pCommentaryPanel ) { pCommentaryPanel = pViewport->CreatePanelByName( PANEL_COMMENTARY_MODELVIEWER ); pViewport->AddNewPanel( pCommentaryPanel, "PANEL_COMMENTARY_MODELVIEWER" ); } if ( pCommentaryPanel ) { //((CCommentaryModelViewer*)pCommentaryPanel)->InvalidateLayout( false, true ); ((CCommentaryModelViewer*)pCommentaryPanel)->SetModel( args[1], args[2] ); pViewport->ShowPanel( pCommentaryPanel, true ); } } }
static inline void HLTV_CopyExitingEnt( CEntityReadInfo &u ) { if ( !u.m_bAsDelta ) // Should never happen on a full update. { Assert(0); // cl.validsequence = 0; ConMsg( "WARNING: CopyExitingEnt on full update.\n" ); u.m_UpdateType = Failed; // break out return; } CFrameSnapshot *pFromSnapshot = u.m_pFrom->GetSnapshot(); // get from snapshot const int ent = u.m_nOldEntity; CFrameSnapshot *pSnapshot = u.m_pTo->GetSnapshot(); // get to snapshot // copy ent handle, serial numbers & class info Assert( ent < pFromSnapshot->m_nNumEntities ); pSnapshot->m_pEntities[ent] = pFromSnapshot->m_pEntities[ent]; Assert( pSnapshot->m_pEntities[ent].m_pPackedData != INVALID_PACKED_ENTITY_HANDLE ); // increase PackedEntity reference counter PackedEntity *pEntity = framesnapshotmanager->GetPackedEntity( pSnapshot, ent ); Assert( pEntity ); pEntity->m_ReferenceCount++; Assert( u.m_pTo->last_entity <= ent ); // mark flags as received u.m_pTo->last_entity = ent; u.m_pTo->transmit_entity.Set( ent ); }
void CClientState::ConnectionClosing( const char * reason ) { // if connected, shut down host if ( m_nSignonState > SIGNONSTATE_NONE ) { ConMsg( "Disconnect: %s.\n", reason ); if ( !Q_stricmp( reason, INVALID_STEAM_TICKET ) ) { g_eSteamLoginFailure = STEAMLOGINFAILURE_BADTICKET; } else if ( !Q_stricmp( reason, INVALID_STEAM_LOGON ) ) { g_eSteamLoginFailure = STEAMLOGINFAILURE_NOSTEAMLOGIN; } else if ( !Q_stricmp( reason, INVALID_STEAM_LOGGED_IN_ELSEWHERE ) ) { g_eSteamLoginFailure = STEAMLOGINFAILURE_LOGGED_IN_ELSEWHERE; } else if ( !Q_stricmp( reason, INVALID_STEAM_VACBANSTATE ) ) { g_eSteamLoginFailure = STEAMLOGINFAILURE_VACBANNED; } else { g_eSteamLoginFailure = STEAMLOGINFAILURE_NONE; } COM_ExplainDisconnection( true, "Disconnect: %s.\n", reason ); SCR_EndLoadingPlaque(); Host_Disconnect(true); } }
bool CHLTVClientState::ProcessClassInfo( SVC_ClassInfo *msg ) { if ( !msg->m_bCreateOnClient ) { ConMsg("HLTV SendTable CRC differs from server.\n"); Disconnect(); return false; } #ifdef _HLTVTEST RecvTable_Term( false ); #endif // Create all of the send tables locally DataTable_CreateClientTablesFromServerTables(); // Now create all of the server classes locally, too DataTable_CreateClientClassInfosFromServerClasses( this ); LinkClasses(); // link server and client classes if ( !RecvTable_CreateDecoders( serverGameDLL->GetStandardSendProxies() ) ) // create receive table decoders { Host_EndGame( true, "CL_ParseClassInfo_EndClasses: CreateDecoders failed.\n" ); return false; } return true; }
void CHLTVDemoRecorder::StopRecording() { if ( !m_bIsRecording ) return; // Demo playback should read this as an incoming message. m_DemoFile.WriteCmdHeader( dem_stop, GetRecordingTick() ); // update demo header info m_DemoFile.m_DemoHeader.playback_ticks = GetRecordingTick(); m_DemoFile.m_DemoHeader.playback_time = host_state.interval_per_tick * GetRecordingTick(); m_DemoFile.m_DemoHeader.playback_frames = m_nFrameCount; // write updated version m_DemoFile.WriteDemoHeader(); m_DemoFile.Close(); m_bIsRecording = false; // clear writing data buffer if ( m_MessageData.GetBasePointer() ) { delete [] m_MessageData.GetBasePointer(); m_MessageData.StartWriting( NULL, 0 ); } ConMsg("Completed SourceTV demo \"%s\", recording time %.1f\n", m_DemoFile.m_szFileName, m_DemoFile.m_DemoHeader.playback_time ); }
void BaseProvider::ConsolePrint(const char *str) { #if SOURCE_ENGINE >= SE_ORANGEBOX ConMsg("%s", str); #else Msg("%s", str); #endif }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CNetworkStringTable::Dump( void ) { ConMsg( "Table %s\n", GetTableName() ); ConMsg( " %i/%i items\n", GetNumStrings(), GetMaxStrings() ); for ( int i = 0; i < GetNumStrings() ; i++ ) { ConMsg( " %i : %s\n", i, GetString( i ) ); } if ( m_pItemsClientSide ) { for ( int i = 0; i < (int)m_pItemsClientSide->Count() ; i++ ) { ConMsg( " %i : %s\n", i, m_pItemsClientSide->String( i ) ); } } ConMsg( "\n" ); }
bool CHLTVClientState::ProcessServerInfo(SVC_ServerInfo *msg ) { // Reset client state Clear(); // is server a HLTV proxy or demo file ? if ( !m_pHLTV->IsPlayingBack() ) { if ( !msg->m_bIsHLTV ) { ConMsg ( "Server (%s) is not a SourceTV proxy.\n", m_NetChannel->GetAddress() ); Disconnect(); return false; } } // tell HLTV relay to clear everything m_pHLTV->StartRelay(); // Process the message if ( !CBaseClientState::ProcessServerInfo( msg ) ) { Disconnect(); return false; } m_StringTableContainer = m_pHLTV->m_StringTables; Assert( m_StringTableContainer->GetNumTables() == 0); // must be empty #ifndef SHARED_NET_STRING_TABLES // relay uses normal string tables without a change history m_StringTableContainer->EnableRollback( false ); #endif // copy setting from HLTV client to HLTV server m_pHLTV->m_nGameServerMaxClients = m_nMaxClients; m_pHLTV->serverclasses = m_nServerClasses; m_pHLTV->serverclassbits = m_nServerClassBits; m_pHLTV->m_nPlayerSlot = m_nPlayerSlot; // copy other settings to HLTV server m_pHLTV->worldmapCRC = msg->m_nMapCRC; m_pHLTV->clientDllCRC = msg->m_nClientCRC; m_pHLTV->m_flTickInterval = msg->m_fTickInterval; host_state.interval_per_tick = msg->m_fTickInterval; Q_strncpy( m_pHLTV->m_szMapname, msg->m_szMapName, sizeof(m_pHLTV->m_szMapname) ); Q_strncpy( m_pHLTV->m_szSkyname, msg->m_szSkyName, sizeof(m_pHLTV->m_szSkyname) ); return true; }
void CHLTVClientState::RunFrame() { CBaseClientState::RunFrame(); if ( m_NetChannel && m_NetChannel->IsTimedOut() && IsConnected() ) { ConMsg ("\nSourceTV connection timed out.\n"); Disconnect(); return; } UpdateStats(); }
//----------------------------------------------------------------------------- // Purpose: // Input : DEMOACTION - // Output : char const //----------------------------------------------------------------------------- char const *CBaseDemoAction::NameForType( DEMOACTION actionType ) { int idx = (int)actionType; if ( idx < 0 || idx >= NUM_DEMO_ACTIONS ) { ConMsg( "ERROR: CBaseDemoAction::NameForType type %i out of range\n", idx ); return g_rgDemoTypeNames[ DEMO_ACTION_UNKNOWN ].name; } DemoActionDictionary *entry = &g_rgDemoTypeNames[ idx ]; Assert( entry->actiontype == actionType ); return entry->name; }
//----------------------------------------------------------------------------- // Purpose: // Input : DEMOACTION - // Output : char const //----------------------------------------------------------------------------- char const *CBaseDemoAction::NameForTimingType( DEMOACTIONTIMINGTYPE timingType ) { int idx = (int)timingType; if ( idx < 0 || idx >= NUM_TIMING_TYPES ) { ConMsg( "ERROR: CBaseDemoAction::NameForTimingType type %i out of range\n", idx ); return g_rgDemoTimingTypeNames[ ACTION_USES_NEITHER ].name; } DemoTimingTagDictionary *entry = &g_rgDemoTimingTypeNames[ idx ]; Assert( entry->timingtype == timingType ); return entry->name; }
bool CClientState::ProcessUserMessage(SVC_UserMessage *msg) { // buffer for incoming user message byte userdata[ MAX_USER_MSG_DATA ] = { 0 }; bf_read userMsg( "UserMessage(read)", userdata, sizeof( userdata ) ); msg->m_DataIn.ReadBits( userdata, msg->m_nLength ); userMsg.StartReading( userdata, Bits2Bytes( msg->m_nLength ) ); // dispatch message to client.dll if ( !g_ClientDLL->DispatchUserMessage( msg->m_nMsgType, userMsg ) ) { ConMsg( "Couldn't dispatch user message (%i)\n", msg->m_nMsgType ); return false; } return true; }
/* ==================== // if( r_drawtranslucentworld ) // { // bSaveDrawTranslucentWorld = r_drawtranslucentworld->GetBool(); // NOTE! : We use to set this to 0 for HDR. // r_drawtranslucentworld->SetValue( 0 ); // } // if( r_drawtranslucentrenderables ) R_TimeRefresh_f For program optimization ==================== */ void R_TimeRefresh_f (void) { int i; float start, stop, time; CViewSetup view; materials->Flush( true ); Q_memset(&view, 0, sizeof(view)); view.origin = MainViewOrigin(); view.angles[0] = 0; view.angles[1] = 0; view.angles[2] = 0; view.x = 0; view.y = 0; view.width = videomode->GetModeWidth(); view.height = videomode->GetModeHeight(); view.fov = 75; view.fovViewmodel = 75; view.m_flAspectRatio = 1.0f; view.zNear = 4; view.zFar = MAX_COORD_FLOAT; view.zNearViewmodel = 4; view.zFarViewmodel = MAX_COORD_FLOAT; int savedeveloper = developer.GetInt(); developer.SetValue( 0 ); start = Sys_FloatTime (); for (i=0 ; i<128 ; i++) { view.angles[1] = i/128.0*360.0; g_ClientDLL->RenderView( view, VIEW_CLEAR_COLOR, RENDERVIEW_DRAWVIEWMODEL | RENDERVIEW_DRAWHUD ); Shader_SwapBuffers(); } materials->Flush( true ); Shader_SwapBuffers(); stop = Sys_FloatTime (); time = stop-start; developer.SetValue( savedeveloper ); ConMsg ("%f seconds (%f fps)\n", time, 128/time); }
//----------------------------------------------------------------------------- // Purpose: // Input : actionType - //----------------------------------------------------------------------------- CBaseDemoAction *CBaseDemoAction::CreateDemoAction( DEMOACTION actionType ) { int idx = (int)actionType; if ( idx < 0 || idx >= NUM_DEMO_ACTIONS ) { Sys_Error( "CBaseDemoAction::AddFactory: Bogus factory type %i\n", idx ); return NULL; } DEMOACTIONFACTORY_FUNC pfn = g_rgDemoTypeNames[ idx ].func; if ( !pfn ) { ConMsg( "CBaseDemoAction::CreateDemoAction: Missing factory for %s\n", NameForType( actionType ) ); return NULL; } return (*pfn)(); }
//----------------------------------------------------------------------------- // Purpose: // Input : actionType - // *parent - // *action - // newaction - // Output : CBaseActionEditDialog //----------------------------------------------------------------------------- CBaseActionEditDialog *CBaseDemoAction::CreateActionEditor( DEMOACTION actionType, CDemoEditorPanel *parent, CBaseDemoAction *action, bool newaction ) { int idx = (int)actionType; if ( idx < 0 || idx >= NUM_DEMO_ACTIONS ) { Sys_Error( "CBaseDemoAction::AddFactory: Bogus factory type %i\n", idx ); return NULL; } DEMOACTIONEDIT_FUNC pfn = g_rgDemoTypeNames[ idx ].editfunc; if ( !pfn ) { ConMsg( "CBaseDemoAction::CreateActionEditor: Missing edit factory for %s\n", NameForType( actionType ) ); return NULL; } return (*pfn)( parent, action, newaction ); }
//----------------------------------------------------------------------------- // Computes the lightmap color at a particular point //----------------------------------------------------------------------------- static void ComputeLightmapColor( SurfaceHandle_t surfID, int ds, int dt, bool bUseLightStyles, Vector& c ) { msurfacelighting_t *pLighting = SurfaceLighting( surfID ); ColorRGBExp32* pLightmap = pLighting->m_pSamples; if( !pLightmap ) { static int messagecount = 0; if ( ++messagecount < 10 ) { // Stop spamming. I heard you already!!! ConMsg( "hit surface has no samples\n" ); } return; } int smax = ( pLighting->m_LightmapExtents[0] ) + 1; int tmax = ( pLighting->m_LightmapExtents[1] ) + 1; int offset = smax * tmax; if ( SurfHasBumpedLightmaps( surfID ) ) { offset *= ( NUM_BUMP_VECTS + 1 ); } pLightmap += dt * smax + ds; int nMaxMaps = bUseLightStyles ? MAXLIGHTMAPS : 1; for (int maps = 0 ; maps < nMaxMaps && pLighting->m_nStyles[maps] != 255 ; ++maps) { float scale = LightStyleValue( pLighting->m_nStyles[maps] ); c[0] += TexLightToLinear( pLightmap->r, pLightmap->exponent ) * scale; c[1] += TexLightToLinear( pLightmap->g, pLightmap->exponent ) * scale; c[2] += TexLightToLinear( pLightmap->b, pLightmap->exponent ) * scale; // Check version 32 in source safe for some debugging crap pLightmap += offset; } }
void CC_Mom_ZoneMark(const CCommand &args) { if (!mom_zone_edit.GetBool()) return; CBasePlayer *pPlayer = UTIL_GetLocalPlayer(); if (!pPlayer) return; int zonetype = -1; if (g_MapzoneEdit.GetBuildStage() >= BUILDSTAGE_END) { if (args.ArgC() > 1) { zonetype = g_MapzoneEdit.ShortNameToZoneType(args[1]); } else { zonetype = g_MapzoneEdit.ShortNameToZoneType(mom_zone_defzone.GetString()); } if (zonetype == MOMZONETYPE_START || zonetype == MOMZONETYPE_STOP) { // Count zones to make sure we don't create multiple instances. int startnum = 0; int endnum = 0; CBaseEntity *pEnt; pEnt = gEntList.FindEntityByClassname(NULL, "trigger_momentum_timer_start"); while (pEnt) { startnum++; pEnt = gEntList.FindEntityByClassname(pEnt, "trigger_momentum_timer_start"); } pEnt = gEntList.FindEntityByClassname(NULL, "trigger_momentum_timer_stop"); while (pEnt) { endnum++; pEnt = gEntList.FindEntityByClassname(pEnt, "trigger_momentum_timer_stop"); } DevMsg("Found %i starts and %i ends (previous)\n", startnum, endnum); if (!mom_zone_ignorewarning.GetBool() && startnum && endnum) { g_MapzoneEdit.SetBuildStage(BUILDSTAGE_NONE); ConMsg("Map already has a start and an end! Use mom_zone_defzone to set another type.\n"); return; } //The user is trying to make multiple starts? if (zonetype == MOMZONETYPE_START) { // Switch between start and end. zonetype = (startnum <= endnum) ? MOMZONETYPE_START : MOMZONETYPE_STOP; } //else the zonetype can be STOP, allowing for multiple stop triggers to be created } } trace_t tr; Vector vecFwd; AngleVectors(pPlayer->EyeAngles(), &vecFwd); UTIL_TraceLine(pPlayer->EyePosition(), pPlayer->EyePosition() + vecFwd * g_MapzoneEdit.GetZoom(), MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_NONE, &tr); g_MapzoneEdit.Build(&tr.endpos, zonetype); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CGameServer::DumpPrecacheStats( INetworkStringTable *table ) { if ( table == NULL ) { ConMsg( "Can only dump stats when active in a level\n" ); return; } CPrecacheItem *items = NULL; if ( table == m_pModelPrecacheTable ) { items = model_precache; } else if ( table == m_pGenericPrecacheTable ) { items = generic_precache; } else if ( table == m_pSoundPrecacheTable ) { items = sound_precache; } else if ( table == m_pDecalPrecacheTable ) { items = decal_precache; } if ( !items ) return; int count = table->GetNumStrings(); int maxcount = table->GetMaxStrings(); ConMsg( "\n" ); ConMsg( "Precache table %s: %i of %i slots used\n", table->GetTableName(), count, maxcount ); for ( int i = 0; i < count; i++ ) { char const *name = table->GetString( i ); CPrecacheItem *slot = &items[ i ]; int testLength; const CPrecacheUserData *p = ( const CPrecacheUserData * )table->GetStringUserData( i, &testLength ); ErrorIfNot( testLength == sizeof( *p ), ("CGameServer::DumpPrecacheStats: invalid CPrecacheUserData length (%d)", testLength) ); if ( !name || !slot || !p ) continue; ConMsg( "%03i: %s (%s): ", i, name, GetFlagString( p->flags ) ); if ( slot->GetReferenceCount() == 0 ) { ConMsg( " never used\n" ); } else { ConMsg( " %i refs, first %.2f mru %.2f\n", slot->GetReferenceCount(), slot->GetFirstReference(), slot->GetMostRecentReference() ); } } ConMsg( "\n" ); }
//----------------------------------------------------------------------------- // Host_Stats_f - prints out interesting stats about the server... //----------------------------------------------------------------------------- void Host_Stats_f (void) { char stats[512]; g_ServerRemoteAccess.GetStatsString(stats, sizeof(stats)); ConMsg("CPU In Out Uptime Users FPS Players\n%s\n", stats); }
void SetMaster_f( const CCommand &args ) { if ( IsUsingMasterLegacyMode() ) { master->SetMaster_Legacy_f( args ); return; } #ifndef NO_STEAM ISteamMasterServerUpdater *s = SteamMasterServerUpdater(); #else ISteamMasterServerUpdater *s = NULL; #endif if ( !s ) return; char szMasterAddress[128]; // IP:Port string of master const char *pszCmd = NULL; int count = args.ArgC(); // Usage help if ( count < 2 ) { ConMsg("Usage:\nsetmaster <add | remove | enable | disable> <IP:port>\n"); if ( s->GetNumMasterServers() == 0 ) { ConMsg("Current: None\n"); } else { ConMsg("Current:\n"); for ( int i=0; i < s->GetNumMasterServers(); i++ ) { char szAdr[512]; if ( s->GetMasterServerAddress( i, szAdr, sizeof( szAdr ) ) != 0 ) ConMsg( " %i: %s\n", i+1, szAdr ); } } return; } pszCmd = args[1]; if ( !pszCmd || !pszCmd[0] ) return; // Check for disabling... if ( !Q_stricmp( pszCmd, "disable") ) { g_bEnableMasterServerUpdater = false; } else if (!Q_stricmp( pszCmd, "enable") ) { g_bEnableMasterServerUpdater = true; } else if ( !Q_stricmp( pszCmd, "add" ) || !Q_stricmp( pszCmd, "remove" ) ) { // Figure out what they want to do. // build master address szMasterAddress[0] = 0; for ( int i= 2; i<count; i++ ) { Q_strcat( szMasterAddress, args[i], sizeof( szMasterAddress ) ); } if ( !Q_stricmp( pszCmd, "add" ) ) { if ( s->AddMasterServer( szMasterAddress ) ) { ConMsg ( "Adding master at %s\n", szMasterAddress ); } else { ConMsg ( "Master at %s already in list\n", szMasterAddress ); } // If we get here, masters are definitely being used. g_bEnableMasterServerUpdater = true; } else { // Find master server if ( !s->RemoveMasterServer( szMasterAddress ) ) { ConMsg( "Can't remove master %s, not in list\n", szMasterAddress ); } } } else { ConMsg( "Invalid setmaster command\n" ); } // Resend the rules just in case we added a new server. sv.SetMasterServerRulesDirty(); }
static SpewRetval_t _SpewMessage( SpewType_t spewType, const char *pGroupName, int nLevel, const Color *pColor, const tchar* pMsgFormat, va_list args ) { tchar pTempBuffer[5020]; assert( _tcslen( pMsgFormat ) < sizeof( pTempBuffer) ); // check that we won't artifically truncate the string /* Printf the file and line for warning + assert only... */ int len = 0; if ((spewType == SPEW_ASSERT) ) { len = _sntprintf( pTempBuffer, sizeof( pTempBuffer ) - 1, _T("%s (%d) : "), s_pFileName, s_Line ); } if ( len == -1 ) return SPEW_ABORT; /* Create the message.... */ int val= _vsntprintf( &pTempBuffer[len], sizeof( pTempBuffer ) - len - 1, pMsgFormat, args ); if ( val == -1 ) return SPEW_ABORT; len += val; assert( len * sizeof(*pMsgFormat) < sizeof(pTempBuffer) ); /* use normal assert here; to avoid recursion. */ // Add \n for warning and assert if ((spewType == SPEW_ASSERT) ) { len += _stprintf( &pTempBuffer[len], _T("\n") ); } assert( len < sizeof(pTempBuffer)/sizeof(pTempBuffer[0]) - 1 ); /* use normal assert here; to avoid recursion. */ assert( s_SpewOutputFunc ); /* direct it to the appropriate target(s) */ SpewRetval_t ret; assert( g_pSpewInfo == NULL ); SpewInfo_t spewInfo = { pColor, pGroupName, nLevel }; g_pSpewInfo = &spewInfo; ret = s_SpewOutputFunc( spewType, pTempBuffer ); g_pSpewInfo = NULL; switch (ret) { // Asserts put the break into the macro so it occurs in the right place case SPEW_DEBUGGER: if ( spewType != SPEW_ASSERT ) { DebuggerBreak(); } break; case SPEW_ABORT: // MessageBox(NULL,"Error in _SpewMessage","Error",MB_OK); ConMsg( _T("Exiting on SPEW_ABORT\n") ); exit(0); } return ret; }
//----------------------------------------------------------------------------- // Purpose: // Input : *value - // Output : int //----------------------------------------------------------------------------- int CNetworkStringTable::AddString( bool bIsServer, const char *string, int length /*= -1*/, const void *userdata /*= NULL*/ ) { bool bHasChanged; CNetworkStringTableItem *item; if ( !string ) { Assert( string ); ConMsg( "Warning: Can't add NULL string to table %s\n", GetTableName() ); return INVALID_STRING_INDEX; } #ifdef _DEBUG if ( m_bLocked ) { DevMsg("Warning! CNetworkStringTable::AddString: adding '%s' while locked.\n", string ); } #endif int i = m_pItems->Find( string ); if ( !bIsServer ) { if ( m_pItems->IsValidIndex( i ) && !m_pItemsClientSide ) { bIsServer = true; } } if ( !bIsServer && m_pItemsClientSide ) { i = m_pItemsClientSide->Find( string ); if ( !m_pItemsClientSide->IsValidIndex( i ) ) { // not in list yet, create it now if ( m_pItemsClientSide->Count() >= (unsigned int)GetMaxStrings() ) { // Too many strings, FIXME: Print warning message ConMsg( "Warning: Table %s is full, can't add %s\n", GetTableName(), string ); return INVALID_STRING_INDEX; } // create new item { MEM_ALLOC_CREDIT(); i = m_pItemsClientSide->Insert( string ); } item = &m_pItemsClientSide->Element( i ); // set changed ticks item->m_nTickChanged = m_nTickCount; #ifndef SHARED_NET_STRING_TABLES item->m_nTickCreated = m_nTickCount; if ( m_bChangeHistoryEnabled ) { item->EnableChangeHistory(); } #endif bHasChanged = true; } else { item = &m_pItemsClientSide->Element( i ); // item already exists bHasChanged = false; // not changed yet } if ( length > -1 ) { if ( item->SetUserData( m_nTickCount, length, userdata ) ) { bHasChanged = true; } } if ( bHasChanged && !m_bChangeHistoryEnabled ) { DataChanged( -i, item ); } // Negate i for returning to client i = -i; } else { // See if it's already there i = m_pItems->Find( string ); if ( !m_pItems->IsValidIndex( i ) ) { // not in list yet, create it now if ( m_pItems->Count() >= (unsigned int)GetMaxStrings() ) { // Too many strings, FIXME: Print warning message ConMsg( "Warning: Table %s is full, can't add %s\n", GetTableName(), string ); return INVALID_STRING_INDEX; } // create new item { MEM_ALLOC_CREDIT(); i = m_pItems->Insert( string ); } item = &m_pItems->Element( i ); // set changed ticks item->m_nTickChanged = m_nTickCount; #ifndef SHARED_NET_STRING_TABLES item->m_nTickCreated = m_nTickCount; if ( m_bChangeHistoryEnabled ) { item->EnableChangeHistory(); } #endif bHasChanged = true; } else { item = &m_pItems->Element( i ); // item already exists bHasChanged = false; // not changed yet } if ( length > -1 ) { if ( item->SetUserData( m_nTickCount, length, userdata ) ) { bHasChanged = true; } } if ( bHasChanged && !m_bChangeHistoryEnabled ) { DataChanged( i, item ); } } return i; }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void ConVar_PrintDescription( const ConCommandBase *pVar ) { bool bMin, bMax; float fMin, fMax; const char *pStr; assert( pVar ); Color clr; clr.SetColor( 255, 100, 100, 255 ); if ( !pVar->IsCommand() ) { ConVar *var = ( ConVar * )pVar; const ConVar_ServerBounded *pBounded = dynamic_cast<const ConVar_ServerBounded*>( var ); bMin = var->GetMin( fMin ); bMax = var->GetMax( fMax ); const char *value = NULL; char tempVal[ 32 ]; if ( pBounded || var->IsFlagSet( FCVAR_NEVER_AS_STRING ) ) { value = tempVal; int intVal = pBounded ? pBounded->GetInt() : var->GetInt(); float floatVal = pBounded ? pBounded->GetFloat() : var->GetFloat(); if ( fabs( (float)intVal - floatVal ) < 0.000001 ) { Q_snprintf( tempVal, sizeof( tempVal ), "%d", intVal ); } else { Q_snprintf( tempVal, sizeof( tempVal ), "%f", floatVal ); } } else { value = var->GetString(); } if ( value ) { ConColorMsg( clr, "\"%s\" = \"%s\"", var->GetName(), value ); if ( stricmp( value, var->GetDefault() ) ) { ConMsg( " ( def. \"%s\" )", var->GetDefault() ); } } if ( bMin ) { ConMsg( " min. %f", fMin ); } if ( bMax ) { ConMsg( " max. %f", fMax ); } ConMsg( "\n" ); // Handled virtualized cvars. if ( pBounded && fabs( pBounded->GetFloat() - var->GetFloat() ) > 0.0001f ) { ConColorMsg( clr, "** NOTE: The real value is %.3f but the server has temporarily restricted it to %.3f **\n", var->GetFloat(), pBounded->GetFloat() ); } } else { ConCommand *var = ( ConCommand * )pVar; ConColorMsg( clr, "\"%s\"\n", var->GetName() ); } ConVar_PrintFlags( pVar ); pStr = pVar->GetHelpText(); if ( pStr && pStr[0] ) { ConMsg( " - %s\n", pStr ); } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void ConVar_PrintFlags( const ConCommandBase *var ) { bool any = false; if ( var->IsFlagSet( FCVAR_GAMEDLL ) ) { ConMsg( " game" ); any = true; } if ( var->IsFlagSet( FCVAR_CLIENTDLL ) ) { ConMsg( " client" ); any = true; } if ( var->IsFlagSet( FCVAR_ARCHIVE ) ) { ConMsg( " archive" ); any = true; } if ( var->IsFlagSet( FCVAR_NOTIFY ) ) { ConMsg( " notify" ); any = true; } if ( var->IsFlagSet( FCVAR_SPONLY ) ) { ConMsg( " singleplayer" ); any = true; } if ( var->IsFlagSet( FCVAR_NOT_CONNECTED ) ) { ConMsg( " notconnected" ); any = true; } if ( var->IsFlagSet( FCVAR_CHEAT ) ) { ConMsg( " cheat" ); any = true; } if ( var->IsFlagSet( FCVAR_REPLICATED ) ) { ConMsg( " replicated" ); any = true; } if ( var->IsFlagSet( FCVAR_SERVER_CAN_EXECUTE ) ) { ConMsg( " server_can_execute" ); any = true; } if ( var->IsFlagSet( FCVAR_CLIENTCMD_CAN_EXECUTE ) ) { ConMsg( " clientcmd_can_execute" ); any = true; } if ( any ) { ConMsg( "\n" ); } }
void CGameClient::FileDenied(const char *fileName, unsigned int transferID ) { ConMsg( "Downloading file '%s' from client %s failed.\n", fileName, GetClientName() ); }
static int luasrc_ConMsg (lua_State *L) { ConMsg(luaL_checkstring(L, 1)); return 0; }