NOXREF void Netchan_UpdateProgress(netchan_t *chan) { NOXREFCHECK; fragbuf_t *p; int c = 0; int total = 0; int i; float bestpercent = 0.0f; float percent; char sz[1024]; char *in; char *out; int len = 0; scr_downloading.value = -1.0f; gDownloadFile[0] = 0; if (net_drawslider.value != 1.0f) { if (!chan->incomingbufs[FRAG_FILE_STREAM]) return; } for (i = MAX_STREAMS - 1; i >= 0; i--) { if (chan->incomingbufs[i]) { p = chan->incomingbufs[i]; total = FRAG_GETCOUNT(p->bufferid); while (p) { c++; p = p->next; } if (total) { percent = (float)c * 100.0f / (float)total; if (percent > bestpercent) bestpercent = percent; } p = chan->incomingbufs[i]; if (i == FRAG_FILE_STREAM) { in = (char *)p->frag_message.data; out = sz; while (*in) { *out++ = *in++; len++; if (len > 128) break; } *out = '\0'; if (Q_strlen(sz) > 0 && (*sz != '!' || !Q_strncmp(sz, "!ModuleC.dll", 11))) { Q_strncpy(gDownloadFile, sz, 255); gDownloadFile[255] = 0; } } } else if (chan->fragbufs[i]) { if (chan->fragbufcount[i]) { percent = (float)chan->fragbufs[i]->bufferid * 100.0f / (float)chan->fragbufcount[i]; if (percent > bestpercent) bestpercent = percent; } } } scr_downloading.value = bestpercent; }
/* =============== Cmd_StuffCmds_f Adds command line parameters as script statements Commands lead with a +, and continue until a - or another + quake +prog jctest.qp +cmd amlev1 quake -nosound +cmd amlev1 =============== */ void Cmd_StuffCmds_f (void) { int i, j; int s; char *text, *build, c; if (Cmd_Argc () != 1) { Con_Printf ("stuffcmds : execute command line parameters\n"); return; } // build the combined string to parse from s = 0; for (i=1 ; i<com_argc ; i++) { if (!com_argv[i]) continue; // NEXTSTEP nulls out -NXHost s += Q_strlen (com_argv[i]) + 1; } if (!s) return; text = Z_Malloc (s+1); text[0] = 0; for (i=1 ; i<com_argc ; i++) { if (!com_argv[i]) continue; // NEXTSTEP nulls out -NXHost Q_strcat (text,com_argv[i]); if (i != com_argc-1) Q_strcat (text, " "); } // pull out the commands build = Z_Malloc (s+1); build[0] = 0; for (i=0 ; i<s-1 ; i++) { if (text[i] == '+') { i++; for (j=i ; (text[j] != '+') && (text[j] != '-') && (text[j] != 0) ; j++) ; c = text[j]; text[j] = 0; Q_strcat (build, text+i); Q_strcat (build, "\n"); text[j] = c; i = j-1; } } if (build[0]) Cbuf_InsertText (build); Z_Free (text); Z_Free (build); }
/* <4e74> ../engine/cmd.c:271 */ void Cmd_StuffCmds_f(void) { int i; int s; char *build; if (Cmd_Argc() != 1) { Con_Printf("stuffcmds : execute command line parameters\n"); return; } if (com_argc <= 1) { return; } // Get total length for the command line parameters s = 0; for (i = 1; i < com_argc; i++) { if (com_argv[i]) { s += Q_strlen(com_argv[i]) + 1; } } if (s == 0) { return; } // Create buffer able to get all arguments build = (char *)Z_Malloc(s + com_argc * 2); build[0] = 0; // Iterate thru arguments searching for ones starting with + for (i = 1; i < com_argc; i++) { if (com_argv[i] && com_argv[i][0] == '+') { // Add command or cvar Q_strcat(build, &com_argv[i][1]); // Then add all following parameters till we meet argument with + or -, which means next command/cvar/parameter i++; while (com_argv[i] && com_argv[i][0] != '+' && com_argv[i][0] != '-') { Q_strcat(build, " "); Q_strcat(build, com_argv[i]); i++; } // End up with new line which split commands for command processor Q_strcat(build, "\n"); i--; } } if (build[0] != 0) { Cbuf_InsertText(build); } // Free buffers Z_Free(build); }
void CTFHLTVDirector::CreateShotFromEvent( CHLTVGameEvent *event ) { // show event at least for 2 more seconds after it occured const char *name = event->m_Event->GetName(); int thera = RandomFloat()>0.5?20:-20; if ( !Q_strcmp( "teamplay_point_startcapture", name ) || !Q_strcmp( "teamplay_point_captured", name ) || !Q_strcmp( "teamplay_capture_blocked", name ) ) { CBaseEntity *pCapturePoint = GetCapturePointByIndex( event->m_Event->GetInt( "cp" ) ); int iCameraIndex = -1; float flClosest = 99999.9f; if ( pCapturePoint ) { // Does it have an associated viewpoint? for ( int i = 0; i<m_nNumFixedCameras; i++ ) { CBaseEntity *pCamera = m_pFixedCameras[ i ]; if ( pCamera ) { byte pvs[MAX_MAP_CLUSTERS/8]; int clusterIndex = engine->GetClusterForOrigin( pCamera->GetAbsOrigin() ); engine->GetPVSForCluster( clusterIndex, sizeof(pvs), pvs ); bool bCameraInPVS = engine->CheckOriginInPVS( pCapturePoint->GetAbsOrigin(), pvs, sizeof( pvs ) ); if ( bCameraInPVS == true ) { float flDistance = (pCapturePoint->GetAbsOrigin() - pCamera->GetAbsOrigin()).Length(); if ( flDistance <= flClosest ) { iCameraIndex = i; flClosest = flDistance; } } } } } CBasePlayer *pPlayer = NULL; if ( !Q_strcmp( "teamplay_point_captured", name ) ) { const char *pszCappers = event->m_Event->GetString("cappers"); int nLength = Q_strlen(pszCappers); if ( nLength > 0 ) { int iRandomCapper = pszCappers[ RandomInt(0,nLength-1) ]; pPlayer = UTIL_PlayerByIndex( iRandomCapper ); } } else if ( !Q_strcmp( "teamplay_capture_blocked", name ) ) { int iBlocker = event->m_Event->GetInt("blocker"); pPlayer = UTIL_PlayerByIndex( iBlocker ); } if ( pPlayer ) { if ( iCameraIndex >= 0 && RandomFloat() > 0.66f ) { StartFixedCameraShot( iCameraIndex, pPlayer->entindex() ); } else if ( pCapturePoint ) { StartChaseCameraShot( pPlayer->entindex(), pCapturePoint->entindex(), 96, 20, thera, false ); } else { StartChaseCameraShot( pPlayer->entindex(), 0, 96, 20, 0, false ); } } else if ( iCameraIndex >= 0 && pCapturePoint ) { // no player known for this event StartFixedCameraShot( iCameraIndex, pCapturePoint->entindex() ); } // shot 2 seconds after event m_nNextShotTick = min( m_nNextShotTick, (event->m_Tick+TIME_TO_TICKS(1.0)) ); } else if ( !Q_strcmp( "object_destroyed", name ) ) { CBasePlayer *attacker = UTIL_PlayerByUserId( event->m_Event->GetInt("attacker") ); if ( attacker ) { int iObjectIndex = event->m_Event->GetInt("index"); StartChaseCameraShot( attacker->entindex(), iObjectIndex, 96, 20, thera, false ); } } else if ( !Q_strcmp( "ctf_flag_captured", name ) ) { CBasePlayer *capper = UTIL_PlayerByUserId( event->m_Event->GetInt("capper") ); if ( capper ) { StartChaseCameraShot( capper->entindex(), 0, 96, 20, 0, false ); } } else if ( !Q_strcmp( "teamplay_flag_event", name ) ) { StartChaseCameraShot( event->m_Event->GetInt("player"), 0, 96, 20, 0, false ); } else { // let baseclass create a shot BaseClass::CreateShotFromEvent( event ); } }
// Load the bot profile database void BotProfileManager::Init(const char *filename, unsigned int *checksum) { static const char *BotDifficultyName[] = { "EASY", "NORMAL", "HARD", "EXPERT", nullptr }; int dataLength; char *dataPointer = (char *)LOAD_FILE_FOR_ME(const_cast<char *>(filename), &dataLength); char *dataFile = dataPointer; if (!dataFile) { if (AreBotsAllowed()) { CONSOLE_ECHO("WARNING: Cannot access bot profile database '%s'\n", filename); } return; } // compute simple checksum if (checksum) { *checksum = ComputeSimpleChecksum((const unsigned char *)dataPointer, dataLength); } // keep list of templates used for inheritance BotProfileList templateList; BotProfile defaultProfile; // Parse the BotProfile.db into BotProfile instances while (true) { dataFile = SharedParse(dataFile); if (!dataFile) break; char *token = SharedGetToken(); bool isDefault = (!Q_stricmp(token, "Default")); bool isTemplate = (!Q_stricmp(token, "Template")); bool isCustomSkin = (!Q_stricmp(token, "Skin")); if (isCustomSkin) { const int BufLen = 64; char skinName[BufLen]; // get skin name dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected skin name\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); Q_snprintf(skinName, BufLen, "%s", token); // get attribute name dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected 'Model'\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); if (Q_stricmp(token, "Model") != 0) { CONSOLE_ECHO("Error parsing %s - expected 'Model'\n", filename); FREE_FILE(dataPointer); return; } // eat '=' dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected '='\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); if (Q_strcmp(token, "=") != 0) { CONSOLE_ECHO("Error parsing %s - expected '='\n", filename); FREE_FILE(dataPointer); return; } // get attribute value dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected attribute value\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); const char *decoratedName = GetDecoratedSkinName(skinName, filename); bool skinExists = GetCustomSkinIndex(decoratedName) > 0; if (m_nextSkin < NumCustomSkins && !skinExists) { // decorate the name m_skins[m_nextSkin] = CloneString(decoratedName); // construct the model filename m_skinModelnames[m_nextSkin] = CloneString(token); m_skinFilenames[m_nextSkin] = new char[Q_strlen(token) * 2 + Q_strlen("models/player//.mdl") + 1]; Q_sprintf(m_skinFilenames[m_nextSkin], "models/player/%s/%s.mdl", token, token); m_nextSkin++; } // eat 'End' dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected 'End'\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); if (Q_strcmp(token, "End") != 0) { CONSOLE_ECHO("Error parsing %s - expected 'End'\n", filename); FREE_FILE(dataPointer); return; } // it's just a custom skin - no need to do inheritance on a bot profile, etc. continue; } // encountered a new profile BotProfile *profile; if (isDefault) { profile = &defaultProfile; } else { profile = new BotProfile; // always inherit from Default *profile = defaultProfile; } // do inheritance in order of appearance if (!isTemplate && !isDefault) { const BotProfile *inherit = nullptr; // template names are separated by "+" while (true) { char *c = Q_strchr(token, '+'); if (c) *c = '\0'; // find the given template name for (auto templates : templateList) { if (!Q_stricmp(templates->GetName(), token)) { inherit = templates; break; } } if (!inherit) { CONSOLE_ECHO("Error parsing '%s' - invalid template reference '%s'\n", filename, token); FREE_FILE(dataPointer); return; } // inherit the data profile->Inherit(inherit, &defaultProfile); if (c == nullptr) break; token = c + 1; } } // get name of this profile if (!isDefault) { dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing '%s' - expected name\n", filename); FREE_FILE(dataPointer); return; } profile->m_name = CloneString(SharedGetToken()); #ifdef REGAMEDLL_FIXES if (RANDOM_LONG(0, 2) == 2) #else // HACK HACK // Until we have a generalized means of storing bot preferences, we're going to hardcode the bot's // preference towards silencers based on his name. if (profile->m_name[0] % 2) #endif { profile->m_prefersSilencer = true; } } // read attributes for this profile bool isFirstWeaponPref = true; while (true) { // get next token dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected 'End'\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); // check for End delimiter if (!Q_stricmp(token, "End")) break; // found attribute name - keep it char attributeName[64]; Q_strcpy(attributeName, token); // eat '=' dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected '='\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); if (Q_strcmp(token, "=") != 0) { CONSOLE_ECHO("Error parsing %s - expected '='\n", filename); FREE_FILE(dataPointer); return; } // get attribute value dataFile = SharedParse(dataFile); if (!dataFile) { CONSOLE_ECHO("Error parsing %s - expected attribute value\n", filename); FREE_FILE(dataPointer); return; } token = SharedGetToken(); // store value in appropriate attribute if (!Q_stricmp("Aggression", attributeName)) { profile->m_aggression = Q_atof(token) / 100.0f; } else if (!Q_stricmp("Skill", attributeName)) { profile->m_skill = Q_atof(token) / 100.0f; } else if (!Q_stricmp("Skin", attributeName)) { profile->m_skin = Q_atoi(token); if (profile->m_skin == 0) { // Q_atoi() failed - try to look up a custom skin by name profile->m_skin = GetCustomSkinIndex(token, filename); } } else if (!Q_stricmp("Teamwork", attributeName)) { profile->m_teamwork = Q_atof(token) / 100.0f; } else if (!Q_stricmp("Cost", attributeName)) { profile->m_cost = Q_atoi(token); } else if (!Q_stricmp("VoicePitch", attributeName)) { profile->m_voicePitch = Q_atoi(token); } else if (!Q_stricmp("VoiceBank", attributeName)) { profile->m_voiceBank = FindVoiceBankIndex(token); } else if (!Q_stricmp("WeaponPreference", attributeName)) { // weapon preferences override parent prefs if (isFirstWeaponPref) { isFirstWeaponPref = false; profile->m_weaponPreferenceCount = 0; } if (!Q_stricmp(token, "none")) { profile->m_weaponPreferenceCount = 0; } else { if (profile->m_weaponPreferenceCount < BotProfile::MAX_WEAPON_PREFS) { profile->m_weaponPreference[profile->m_weaponPreferenceCount++] = AliasToWeaponID(token); } } } else if (!Q_stricmp("ReactionTime", attributeName)) { profile->m_reactionTime = Q_atof(token); #ifndef GAMEUI_EXPORTS // subtract off latency due to "think" update rate. // In GameUI, we don't really care. profile->m_reactionTime -= g_flBotFullThinkInterval; #endif } else if (!Q_stricmp("AttackDelay", attributeName)) { profile->m_attackDelay = Q_atof(token); } else if (!Q_stricmp("Difficulty", attributeName)) { // override inheritance profile->m_difficultyFlags = 0; // parse bit flags while (true) { char *c = Q_strchr(token, '+'); if (c) *c = '\0'; for (int i = 0; i < NUM_DIFFICULTY_LEVELS; i++) { if (!Q_stricmp(BotDifficultyName[i], token)) profile->m_difficultyFlags |= (1<<i); } if (c == nullptr) break; token = c + 1; } } else if (!Q_stricmp("Team", attributeName)) { if (!Q_stricmp(token, "T")) { profile->m_teams = BOT_TEAM_T; } else if (!Q_stricmp(token, "CT")) { profile->m_teams = BOT_TEAM_CT; } else { profile->m_teams = BOT_TEAM_ANY; } } else { CONSOLE_ECHO("Error parsing %s - unknown attribute '%s'\n", filename, attributeName); } } if (!isDefault) { if (isTemplate) { // add to template list templateList.push_back(profile); } else { // add profile to the master list m_profileList.push_back(profile); } } } FREE_FILE(dataPointer); // free the templates for (auto templates : templateList) delete templates; templateList.clear(); }
void CSDKPlayerClassInfo::Parse( KeyValues *pKeyValuesData, const char *szWeaponName ) { BaseClass::Parse( pKeyValuesData, szWeaponName ); m_iTeam= pKeyValuesData->GetInt( "team", TEAM_UNASSIGNED ); // Figure out what team can have this player class m_iTeam = TEAM_UNASSIGNED; //Tony; don't check for teams unless we're using teams. You could do a free for all, but class / character based game if you wanted. #ifdef SDK_USE_TEAMS const char *pTeam = pKeyValuesData->GetString( "team", NULL ); if ( pTeam ) { if ( Q_stricmp( pTeam, "BLUE" ) == 0 ) { m_iTeam = SDK_TEAM_BLUE; } else if ( Q_stricmp( pTeam, "RED" ) == 0 ) { m_iTeam = SDK_TEAM_RED; } else { Assert( false ); } } else { Assert( false ); } #endif const char *pszPrimaryWeapon = pKeyValuesData->GetString( "primaryweapon", NULL ); m_iPrimaryWeapon = AliasToWeaponID( pszPrimaryWeapon ); Assert( m_iPrimaryWeapon != WEAPON_NONE ); // require player to have a primary weapon const char *pszSecondaryWeapon = pKeyValuesData->GetString( "secondaryweapon", NULL ); if ( pszSecondaryWeapon ) { m_iSecondaryWeapon = AliasToWeaponID( pszSecondaryWeapon ); // Assert( m_iSecondaryWeapon != WEAPON_NONE ); } else m_iSecondaryWeapon = WEAPON_NONE; const char *pszMeleeWeapon = pKeyValuesData->GetString( "meleeweapon", NULL ); if ( pszMeleeWeapon ) { m_iMeleeWeapon = AliasToWeaponID( pszMeleeWeapon ); // Assert( m_iMeleeWeapon != WEAPON_NONE ); } else m_iMeleeWeapon = WEAPON_NONE; m_iNumGrensType1 = pKeyValuesData->GetInt( "numgrens", 0 ); if ( m_iNumGrensType1 > 0 ) { const char *pszGrenType1 = pKeyValuesData->GetString( "grenadetype", NULL ); m_iGrenType1 = AliasToWeaponID( pszGrenType1 ); // Assert( m_iGrenType1 != WEAPON_NONE ); } m_iNumGrensType2 = pKeyValuesData->GetInt( "numgrens2", 0 ); if ( m_iNumGrensType2 > 0 ) { const char *pszGrenType2 = pKeyValuesData->GetString( "grenadetype2", NULL ); m_iGrenType2 = AliasToWeaponID( pszGrenType2 ); // Assert( m_iGrenType2 != WEAPON_NONE ); } Q_strncpy( m_szLimitCvar, pKeyValuesData->GetString( "limitcvar", "!! Missing limit cvar on Player Class" ), sizeof(m_szLimitCvar) ); Assert( Q_strlen( m_szLimitCvar ) > 0 && "Every class must specify a limitcvar" ); // HUD player status health images (when the player is hurt) Q_strncpy( m_szClassImage, pKeyValuesData->GetString( "classimage", "white" ), sizeof( m_szClassImage ) ); Q_strncpy( m_szClassImageBG, pKeyValuesData->GetString( "classimagebg", "white" ), sizeof( m_szClassImageBG ) ); m_flRunSpeed = pKeyValuesData->GetFloat( "RunSpeed", SDK_DEFAULT_PLAYER_RUNSPEED ); m_flSprintSpeed = pKeyValuesData->GetFloat( "SprintSpeed", SDK_DEFAULT_PLAYER_RUNSPEED ); m_flProneSpeed = pKeyValuesData->GetFloat( "ProneSpeed", SDK_DEFAULT_PLAYER_RUNSPEED ); m_iArmor = pKeyValuesData->GetInt( "armor", 0 ); }
void Con_SetInputText( const char *inputText ) { if( host.type != HOST_DEDICATED ) return; SetWindowText( s_wcd.hwndInputLine, inputText ); SendMessage( s_wcd.hwndInputLine, EM_SETSEL, Q_strlen( inputText ), -1 ); }
/* ================ main ================ */ int main (int c, char **v) { double time, oldtime, newtime; extern void (*dos_error_func)(char *, ...); static char cwd[1024]; printf ("Quake v%4.2f\n", VERSION); // make sure there's an FPU signal(SIGNOFP, Sys_NoFPUExceptionHandler); signal(SIGABRT, Sys_DefaultExceptionHandler); signal(SIGALRM, Sys_DefaultExceptionHandler); signal(SIGKILL, Sys_DefaultExceptionHandler); signal(SIGQUIT, Sys_DefaultExceptionHandler); signal(SIGINT, Sys_DefaultExceptionHandler); if (fptest_temp >= 0.0) fptest_temp += 0.1; COM_InitArgv (c, v); quakeparms.argc = com_argc; quakeparms.argv = com_argv; dos_error_func = Sys_Error; Sys_DetectWin95 (); Sys_PageInProgram (); Sys_GetMemory (); atexit (Sys_AtExit); // in case we crash getwd (cwd); if (cwd[Q_strlen(cwd)-1] == '/') cwd[Q_strlen(cwd)-1] = 0; quakeparms.basedir = cwd; //"f:/quake"; isDedicated = (COM_CheckParm ("-dedicated") != 0); Sys_Init (); if (!isDedicated) dos_registerintr(9, TrapKey); //Sys_InitStackCheck (); Host_Init(&quakeparms); //Sys_StackCheck (); //Con_Printf ("Top of stack: 0x%x\n", &time); oldtime = Sys_FloatTime (); while (1) { newtime = Sys_FloatTime (); time = newtime - oldtime; if (cls.state == ca_dedicated && (time<sys_ticrate.value)) continue; Host_Frame (time); //Sys_StackCheck (); oldtime = newtime; } }
/* =============== R_ShowTextures Draw all the images to the screen, on top of whatever was there. This is used to test for texture thrashing. =============== */ void R_ShowTextures( void ) { gltexture_t *image; float x, y, w, h; int i, j, k, base_w, base_h; int total, start, end; rgba_t color = { 192, 192, 192, 255 }; int charHeight, numTries = 0; static qboolean showHelp = true; string shortname; if( !gl_showtextures->integer ) return; if( showHelp ) { CL_CenterPrint( "use '<-' and '->' keys to view all the textures", 0.25f ); showHelp = false; } pglClear( GL_COLOR_BUFFER_BIT ); pglFinish(); base_w = 8; base_h = 6; rebuild_page: total = base_w * base_h; start = total * (gl_showtextures->integer - 1); end = total * gl_showtextures->integer; if( end > MAX_TEXTURES ) end = MAX_TEXTURES; w = glState.width / (float)base_w; h = glState.height / (float)base_h; Con_DrawStringLen( NULL, NULL, &charHeight ); for( i = j = 0; i < MAX_TEXTURES; i++ ) { image = R_GetTexture( i ); if( j == start ) break; // found start if( pglIsTexture( image->texnum )) j++; } if( i == MAX_TEXTURES && gl_showtextures->integer != 1 ) { // bad case, rewind to one and try again Cvar_SetFloat( "r_showtextures", max( 1, gl_showtextures->integer - 1 )); if( ++numTries < 2 ) goto rebuild_page; // to prevent infinite loop } for( k = 0; i < MAX_TEXTURES; i++ ) { if( j == end ) break; // page is full image = R_GetTexture( i ); if( !pglIsTexture( image->texnum )) continue; x = k % base_w * w; y = k / base_w * h; pglColor4f( 1.0f, 1.0f, 1.0f, 1.0f ); GL_Bind( XASH_TEXTURE0, i ); // NOTE: don't use image->texnum here, because skybox has a 'wrong' indexes if(( image->flags & TF_DEPTHMAP ) && !( image->flags & TF_NOCOMPARE )) pglTexParameteri( image->target, GL_TEXTURE_COMPARE_MODE_ARB, GL_NONE ); pglBegin( GL_QUADS ); pglTexCoord2f( 0, 0 ); pglVertex2f( x, y ); if( image->flags & TF_TEXTURE_RECTANGLE ) pglTexCoord2f( image->width, 0 ); else pglTexCoord2f( 1, 0 ); pglVertex2f( x + w, y ); if( image->flags & TF_TEXTURE_RECTANGLE ) pglTexCoord2f( image->width, image->height ); else pglTexCoord2f( 1, 1 ); pglVertex2f( x + w, y + h ); if( image->flags & TF_TEXTURE_RECTANGLE ) pglTexCoord2f( 0, image->height ); else pglTexCoord2f( 0, 1 ); pglVertex2f( x, y + h ); pglEnd(); if(( image->flags & TF_DEPTHMAP ) && !( image->flags & TF_NOCOMPARE )) pglTexParameteri( image->target, GL_TEXTURE_COMPARE_MODE_ARB, GL_COMPARE_R_TO_TEXTURE_ARB ); FS_FileBase( image->name, shortname ); if( Q_strlen( shortname ) > 18 ) { // cutoff too long names, it looks ugly shortname[16] = '.'; shortname[17] = '.'; shortname[18] = '\0'; } Con_DrawString( x + 1, y + h - charHeight, shortname, color ); j++, k++; } CL_DrawCenterPrint (); pglFinish(); }
/* ================ Sys_Print print into window console ================ */ void Sys_Print( const char *pMsg ) { const char *msg; char buffer[32768]; char logbuf[32768]; char *b = buffer; char *c = logbuf; int i = 0; if( host.type == HOST_NORMAL ) Con_Print( pMsg ); #ifdef _WIN32 // if the message is REALLY long, use just the last portion of it if( Q_strlen( pMsg ) > sizeof( buffer ) - 1 ) msg = pMsg + Q_strlen( pMsg ) - sizeof( buffer ) + 1; else msg = pMsg; // copy into an intermediate buffer while( msg[i] && (( b - buffer ) < sizeof( buffer ) - 1 )) { if( msg[i] == '\n' && msg[i+1] == '\r' ) { b[0] = '\r'; b[1] = '\n'; c[0] = '\n'; b += 2, c++; i++; } else if( msg[i] == '\r' ) { b[0] = '\r'; b[1] = '\n'; b += 2; } else if( msg[i] == '\n' ) { b[0] = '\r'; b[1] = '\n'; c[0] = '\n'; b += 2, c++; } else if( msg[i] == '\35' || msg[i] == '\36' || msg[i] == '\37' ) { i++; // skip console pseudo graph } else if( IsColorString( &msg[i] )) { i++; // skip color prefix } else { *b = *c = msg[i]; b++, c++; } i++; } *b = *c = 0; // cutoff garbage Sys_PrintLog( logbuf ); Con_WinPrint( buffer ); #else Sys_PrintLog( pMsg ); #endif if( host.rd.target ) { if(( Q_strlen( pMsg ) + Q_strlen( host.rd.buffer )) > ( host.rd.buffersize - 1 )) { if( host.rd.flush ) { host.rd.flush( host.rd.address, host.rd.target, host.rd.buffer ); *host.rd.buffer = 0; } } Q_strcat( host.rd.buffer, pMsg ); return; } }
int SEditModelRender::MaterialPicker( char ***szMat ) { int mx, my; #ifdef SOURCE_2006 vgui::input()->GetCursorPos( mx, my ); #else vgui::input()->GetCursorPosition( mx, my ); #endif Vector ray; const CViewSetup *pViewSetup = view->GetPlayerViewSetup(); float ratio =engine->GetScreenAspectRatio( #ifdef SWARM_DLL pViewSetup->width, pViewSetup->height #endif ); ratio = ( 1.0f / ratio ) * (4.0f/3.0f); float flFov = ScaleFOVByWidthRatio( pViewSetup->fov, ratio ); ScreenToWorld( mx, my, flFov, pViewSetup->origin, pViewSetup->angles, ray ); Vector start = pViewSetup->origin; Vector end = start + ray * MAX_TRACE_LENGTH; trace_t tr; C_BaseEntity *pIgnore = input->CAM_IsThirdPerson() ? NULL : C_BasePlayer::GetLocalPlayer(); UTIL_TraceLine( start, end, MASK_SOLID, pIgnore, COLLISION_GROUP_NONE, &tr ); if ( !tr.DidHit() ) return 0; int numMaterials = 0; IMaterial **MatList = NULL; studiohdr_t *pSHdr = NULL; if ( tr.DidHitWorld() ) { if ( tr.hitbox == 0 ) { Vector dummy; IMaterial *pMat = engine->TraceLineMaterialAndLighting( start, end, dummy, dummy ); if ( pMat ) { numMaterials = 1; MatList = new IMaterial*[1]; MatList[0] = pMat; } } else { ICollideable *prop = staticpropmgr->GetStaticPropByIndex( tr.hitbox - 1 ); if ( prop ) { IClientRenderable *pRenderProp = prop->GetIClientUnknown()->GetClientRenderable(); if ( pRenderProp ) { const model_t *pModel = pRenderProp->GetModel(); if ( pModel ) pSHdr = modelinfo->GetStudiomodel( pModel ); } } } } else if ( tr.m_pEnt ) { const model_t *pModel = tr.m_pEnt->GetModel(); if ( pModel ) pSHdr = modelinfo->GetStudiomodel( pModel ); } if ( pSHdr ) { Assert( !numMaterials && !MatList ); numMaterials = pSHdr->numtextures; const int numPaths = pSHdr->numcdtextures; if ( numMaterials ) { CUtlVector< IMaterial* >hValidMaterials; for ( int i = 0; i < numMaterials; i++ ) { mstudiotexture_t *pStudioTex = pSHdr->pTexture( i ); const char *matName = pStudioTex->pszName(); for ( int p = 0; p < numPaths; p++ ) { char tmpPath[MAX_PATH]; Q_snprintf( tmpPath, MAX_PATH, "%s%s\0", pSHdr->pCdtexture( p ), matName ); Q_FixSlashes( tmpPath ); IMaterial *pTempMat = materials->FindMaterial( tmpPath, TEXTURE_GROUP_MODEL ); if ( !IsErrorMaterial( pTempMat ) ) { hValidMaterials.AddToTail( pTempMat ); break; } } } numMaterials = hValidMaterials.Count(); if ( numMaterials ) { MatList = new IMaterial*[ numMaterials ]; for ( int i = 0; i < numMaterials; i++ ) MatList[i] = hValidMaterials[i]; } hValidMaterials.Purge(); } } *szMat = new char*[ numMaterials ]; int iTotalLength = 0; for ( int i = 0; i < numMaterials; i++ ) iTotalLength += Q_strlen( MatList[i]->GetName() ) + 1; **szMat = new char[ iTotalLength ]; int curpos = 0; for ( int i = 0; i < numMaterials; i++ ) { const char *pszName = MatList[i]->GetName(); int curLength = Q_strlen( pszName ) + 1; (*szMat)[ i ] = **szMat + curpos; Q_strcpy( (*szMat)[ i ], pszName ); curpos += curLength; } if ( MatList ) delete [] MatList; return numMaterials; }
/* <36ace2> ../cstrike/dlls/bot/cs_bot_manager.cpp:484 */ void CCSBotManager::__MAKE_VHOOK(ServerCommand)(const char *pcmd) { if (!m_bServerActive || !UTIL_IsGame("czero")) return; char buffer[400]; const char *msg = CMD_ARGV(1); if (FStrEq(pcmd, "bot_about")) { Q_sprintf(buffer, "\n--------------------------------------------------------------------------\nThe Official Counter-Strike Bot V%d.%02d\nCreated by Michael S. Booth\nWeb: www.turtlerockstudios.com\\csbot\nE-mail: [email protected]\n--------------------------------------------------------------------------\n\n", CSBOT_VERSION_MAJOR, CSBOT_VERSION_MINOR); CONSOLE_ECHO(buffer); HintMessageToAllPlayers(buffer); } else if (FStrEq(pcmd, "bot_add")) { BotAddCommand(BOT_TEAM_ANY); } else if (FStrEq(pcmd, "bot_add_t")) { BotAddCommand(BOT_TEAM_T); } else if (FStrEq(pcmd, "bot_add_ct")) { BotAddCommand(BOT_TEAM_CT); } else if (FStrEq(pcmd, "bot_kill")) { bool killThemAll; if (CMD_ARGC() == 1 || FStrEq(msg, "all")) killThemAll = true; else killThemAll = false; for (int iIndex = 1; iIndex <= gpGlobals->maxClients; iIndex++) { CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex(iIndex); if (pPlayer == NULL) continue; if (FNullEnt(pPlayer->pev)) continue; const char *name = STRING(pPlayer->pev->netname); if (FStrEq(name, "")) continue; if (pPlayer->IsBot()) { if (killThemAll || FStrEq(name, msg)) { pPlayer->TakeDamage(pPlayer->pev, pPlayer->pev, 9999.9f, DMG_CRUSH); } } } } else if (FStrEq(pcmd, "bot_kick")) { bool kickThemAll; if (CMD_ARGC() == 1 || FStrEq(msg, "all")) kickThemAll = true; else kickThemAll = false; for (int iIndex = 1; iIndex <= gpGlobals->maxClients; iIndex++) { CBasePlayer *pPlayer = (CBasePlayer *)UTIL_PlayerByIndex(iIndex); if (pPlayer == NULL) continue; if (FNullEnt(pPlayer->pev)) continue; const char *name = STRING(pPlayer->pev->netname); if (FStrEq(name, "")) continue; if (pPlayer->IsBot()) { if (kickThemAll || FStrEq(name, msg)) { SERVER_COMMAND(UTIL_VarArgs("kick \"%s\"\n", name)); CVAR_SET_FLOAT("bot_quota", cv_bot_quota.value - 1); } } } if (kickThemAll || cv_bot_quota.value < 0.0f) { CVAR_SET_FLOAT("bot_quota", 0); } } else if (FStrEq(pcmd, "bot_knives_only")) { CVAR_SET_FLOAT("bot_allow_pistols", 0); CVAR_SET_FLOAT("bot_allow_shotguns", 0); CVAR_SET_FLOAT("bot_allow_sub_machine_guns", 0); CVAR_SET_FLOAT("bot_allow_rifles", 0); CVAR_SET_FLOAT("bot_allow_machine_guns", 0); CVAR_SET_FLOAT("bot_allow_grenades", 0); CVAR_SET_FLOAT("bot_allow_snipers", 0); CVAR_SET_FLOAT("bot_allow_shield", 0); } else if (FStrEq(pcmd, "bot_pistols_only")) { CVAR_SET_FLOAT("bot_allow_pistols", 1); CVAR_SET_FLOAT("bot_allow_shotguns", 0); CVAR_SET_FLOAT("bot_allow_sub_machine_guns", 0); CVAR_SET_FLOAT("bot_allow_rifles", 0); CVAR_SET_FLOAT("bot_allow_machine_guns", 0); CVAR_SET_FLOAT("bot_allow_grenades", 0); CVAR_SET_FLOAT("bot_allow_snipers", 0); CVAR_SET_FLOAT("bot_allow_shield", 0); } else if (FStrEq(pcmd, "bot_snipers_only")) { CVAR_SET_FLOAT("bot_allow_pistols", 1); CVAR_SET_FLOAT("bot_allow_shotguns", 0); CVAR_SET_FLOAT("bot_allow_sub_machine_guns", 0); CVAR_SET_FLOAT("bot_allow_rifles", 0); CVAR_SET_FLOAT("bot_allow_machine_guns", 0); CVAR_SET_FLOAT("bot_allow_grenades", 0); CVAR_SET_FLOAT("bot_allow_snipers", 1); CVAR_SET_FLOAT("bot_allow_shield", 0); } else if (FStrEq(pcmd, "bot_all_weapons")) { CVAR_SET_FLOAT("bot_allow_pistols", 1); CVAR_SET_FLOAT("bot_allow_shotguns", 1); CVAR_SET_FLOAT("bot_allow_sub_machine_guns", 1); CVAR_SET_FLOAT("bot_allow_rifles", 1); CVAR_SET_FLOAT("bot_allow_machine_guns", 1); CVAR_SET_FLOAT("bot_allow_grenades", 1); CVAR_SET_FLOAT("bot_allow_snipers", 1); CVAR_SET_FLOAT("bot_allow_shield", 1); } else if (FStrEq(pcmd, "entity_dump")) { PrintAllEntities(); } else if (FStrEq(pcmd, "bot_nav_delete")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_DELETE; } else if (FStrEq(pcmd, "bot_nav_split")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_SPLIT; } else if (FStrEq(pcmd, "bot_nav_merge")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_MERGE; } else if (FStrEq(pcmd, "bot_nav_mark")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_MARK; } else if (FStrEq(pcmd, "bot_nav_begin_area")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_BEGIN_AREA; } else if (FStrEq(pcmd, "bot_nav_end_area")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_END_AREA; } else if (FStrEq(pcmd, "bot_nav_connect")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_CONNECT; } else if (FStrEq(pcmd, "bot_nav_disconnect")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_DISCONNECT; } else if (FStrEq(pcmd, "bot_nav_splice")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_SPLICE; } else if (FStrEq(pcmd, "bot_nav_crouch")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_CROUCH; } else if (FStrEq(pcmd, "bot_nav_jump")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_JUMP; } else if (FStrEq(pcmd, "bot_nav_precise")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_PRECISE; } else if (FStrEq(pcmd, "bot_nav_no_jump")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_ATTRIB_NO_JUMP; } else if (FStrEq(pcmd, "bot_nav_analyze")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_isAnalysisRequested) = true; } else if (FStrEq(pcmd, "bot_nav_strip")) { StripNavigationAreas();// TODO: reverse me } else if (FStrEq(pcmd, "bot_nav_save")) { GET_GAME_DIR(buffer); buffer[ Q_strlen(buffer) ] = '\\'; Q_strcat(buffer, CBotManager::GetNavMapFilename()); if (SaveNavigationMap(buffer))// TODO: reverse me CONSOLE_ECHO("Navigation map '%s' saved.\n", buffer); else CONSOLE_ECHO("ERROR: Cannot save navigation map '%s'.\n", buffer); } else if (FStrEq(pcmd, "bot_nav_load")) { ValidateMapData(); } else if (FStrEq(pcmd, "bot_nav_use_place")) { if (CMD_ARGC() == 1) { int i = 0; const BotPhraseList *placeList = TheBotPhrases->GetPlaceList(); for (BotPhraseList::const_iterator iter = placeList->begin(); iter != placeList->end(); ++iter, i++) { if ((*iter)->GetID() == GetNavPlace()) CONSOLE_ECHO("--> %-26s", (*iter)->GetName()); else CONSOLE_ECHO("%-30s", (*iter)->GetName()); if (!(i % 3)) CONSOLE_ECHO("\n"); } CONSOLE_ECHO("\n"); } else { const BotPhraseList *placeList = TheBotPhrases->GetPlaceList(); const BotPhrase *found = NULL; bool isAmbiguous = false; for (BotPhraseList::const_iterator iter = placeList->begin(); iter != placeList->end(); ++iter) { if (!Q_strnicmp((*iter)->GetName(), msg, Q_strlen(msg))) { if (!Q_strcmp((*iter)->GetName(), msg)) { found = (*iter); break; } if (found != NULL) isAmbiguous = true; else found = (*iter); } } if (isAmbiguous) { CONSOLE_ECHO("Ambiguous\n"); return; } if (found != NULL) { CONSOLE_ECHO("Current place set to '%s'\n", found->GetName()); m_navPlace = found->GetID(); } } } else if (FStrEq(pcmd, "bot_nav_toggle_place_mode")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_TOGGLE_PLACE_MODE; } else if (FStrEq(pcmd, "bot_nav_place_floodfill")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_PLACE_FLOODFILL; } else if (FStrEq(pcmd, "bot_nav_place_pick")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_PLACE_PICK; } else if (FStrEq(pcmd, "bot_nav_toggle_place_painting")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_TOGGLE_PLACE_PAINTING; } else if (FStrEq(pcmd, "bot_goto_mark")) { // tell the first bot we find to go to our marked area CNavArea *area = GetMarkedArea();// TODO: reverse me if (area != NULL) { CBaseEntity *pEntity = NULL; while ((pEntity = UTIL_FindEntityByClassname(pEntity, "player")) != NULL) { if (!pEntity->IsPlayer()) continue; if ((pEntity->pev->flags & FL_DORMANT) == FL_DORMANT) continue; CBasePlayer *playerOrBot = GetClassPtr((CBasePlayer *)pEntity->pev); if (playerOrBot->IsBot()) { CCSBot *bot = reinterpret_cast<CCSBot *>(playerOrBot); bot->MoveTo(&area->m_center, FASTEST_ROUTE);// TODO: reverse me return; } } } } else if (FStrEq(pcmd, "bot_memory_usage")) { CONSOLE_ECHO("Memory usage:\n"); CONSOLE_ECHO(" %d bytes per bot\b", sizeof(CCSBot)); CONSOLE_ECHO(" %d Navigation Areas @ %d bytes each = %d bytes\n", TheNavAreaGrid.GetNavAreaCount(), sizeof(CNavArea), TheNavAreaGrid.GetNavAreaCount() * sizeof(CNavArea)); CONSOLE_ECHO(" %d Hiding Spots @ %d bytes each = %d bytes\n", TheHidingSpotList.size(), sizeof(HidingSpot), sizeof(HidingSpot) * TheHidingSpotList.size()); unsigned int encounterMem = 0; for (NavAreaList::iterator iter = TheNavAreaList.begin(); iter != TheNavAreaList.end(); ++iter) { CNavArea *area = (*iter); for (SpotEncounterList::iterator siter = area->m_spotEncounterList.begin(); siter != area->m_spotEncounterList.end(); ++siter) { // TODO: Fix me, this is crashed in HOOK_GAMEDLL SpotEncounter se = (*siter); encounterMem += sizeof(SpotEncounter); encounterMem += sizeof(SpotOrder) * se.spotList.size(); } } CONSOLE_ECHO(" Encounter Spot data = %d bytes\n", encounterMem); } else if (FStrEq(pcmd, "bot_nav_mark_unnamed")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_MARK_UNNAMED; } else if (FStrEq(pcmd, "bot_nav_warp")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_WARP_TO_MARK; } else if (FStrEq(pcmd, "bot_nav_corner_select")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_SELECT_CORNER; } else if (FStrEq(pcmd, "bot_nav_corner_raise")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_RAISE_CORNER; } else if (FStrEq(pcmd, "bot_nav_corner_lower")) { IMPLEMENT_ARRAY_CLASS(CCSBotManager, m_editCmd) = EDIT_LOWER_CORNER; } else if (FStrEq(pcmd, "bot_nav_check_consistency")) { if (CMD_ARGC() != 2) { CONSOLE_ECHO("usage: bot_nav_check_consistency <filename>\n"); return; } SanityCheckNavigationMap(msg);// TODO: reverse me } }
void TokenChannels_t::Tokenize( const char *string ) { SetDefaultChannels(); if ( !string || !*string ) return; if ( Q_strlen( string ) > 128 ) { iActiveChannels = 1; bHasAnyValues = true; bReady = true; bChannelAsValue[0] = true; } while ( *string == ' ' ) string++; const bool bNormalize = string && (*string == 'n' || *string == 'N' ); if ( bNormalize ) string++; while ( *string == ' ' ) string++; char localString[ MAX_OPERATION_C ]; Q_snprintf( localString, sizeof(localString), "%s\0", string ); char *MakeUpper = localString; while( MakeUpper && *MakeUpper ) { if ( *MakeUpper == 'e' ) *MakeUpper = 'E'; else if ( *MakeUpper == 'p' ) *MakeUpper = 'P'; else if ( *MakeUpper == 'i' ) *MakeUpper = 'I'; MakeUpper++; } const char *stringtest = localString; while (stringtest && *stringtest) { if ( ISSTRING_LITERAL( localString, stringtest ) || ISSTRING_VALUE( localString, stringtest ) ) bHasAnyValues = true; stringtest++; } char *cleanupReader = localString; while ( *cleanupReader ) { if ( !ISSTRING_VALUE( localString, cleanupReader ) && *cleanupReader != ' ' && !ISSTRING_OPERATOR( cleanupReader ) && GetChannelNumFromChar( cleanupReader ) < 0 && !ISSTRING_LITERAL( localString, cleanupReader ) && !ISCHAR_BRACKET( *cleanupReader ) && *cleanupReader != '$' ) { SnipCharFromString( cleanupReader ); //cleanupReader--; } cleanupReader++; } char cleanupString[MAX_OPERATION_C]; cleanupReader = cleanupString; Q_strcpy( cleanupString, localString ); Q_memset( localString, 0, sizeof( localString ) ); #define STEST_VALUE 0 #define STEST_OPERATOR 1 #define STEST_BRACKET_OPEN 2 #define STEST_BRACKET_CLOSE 3 #define STEST_BRACKET( x ) ( x == STEST_BRACKET_OPEN || x == STEST_BRACKET_CLOSE ) while( *cleanupReader ) { if ( *cleanupReader == ' ' ) { const char *searchfront = cleanupReader; const char *searchback = cleanupReader; int priorToSpace = -1; int afterSpace = -1; while ( searchfront >= cleanupString ) { if ( ISSTRING_VALUE( cleanupString, searchfront ) || ISSTRING_LITERAL( cleanupString, searchfront ) || *searchfront == '$' ) priorToSpace = STEST_VALUE; else if ( ISSTRING_OPERATOR( searchfront ) ) priorToSpace = STEST_OPERATOR; else if ( ISCHAR_BOPEN( *searchfront ) ) priorToSpace = STEST_BRACKET_OPEN; else if ( ISCHAR_BCLOSE( *searchfront ) ) priorToSpace = STEST_BRACKET_CLOSE; else if ( GetChannelNumFromChar( searchfront ) >= 0 ) break; if ( priorToSpace >= 0 ) break; searchfront--; } while ( *searchback ) { if ( ISSTRING_VALUE( cleanupString, searchback ) || ISSTRING_LITERAL( cleanupString, searchback ) || *searchback == '$' ) afterSpace = STEST_VALUE; else if ( ISSTRING_OPERATOR( searchback ) ) afterSpace = STEST_OPERATOR; else if ( ISCHAR_BOPEN( *searchback ) ) afterSpace = STEST_BRACKET_OPEN; else if ( ISCHAR_BCLOSE( *searchback ) ) afterSpace = STEST_BRACKET_CLOSE; else if ( GetChannelNumFromChar( searchback ) >= 0 ) break; if ( afterSpace >= 0 ) break; searchback++; } // 1 * ( 2 + 1 ) ( 3 ) + 1 // 1 ( 10 ) 0 if ( ( !STEST_BRACKET(priorToSpace) && !STEST_BRACKET(afterSpace) && priorToSpace != afterSpace && priorToSpace >= 0 && afterSpace >= 0) || priorToSpace == STEST_BRACKET_OPEN || afterSpace == STEST_BRACKET_CLOSE || (STEST_BRACKET(priorToSpace) && afterSpace == STEST_OPERATOR ) || //!STEST_BRACKET(afterSpace)) || (STEST_BRACKET(afterSpace) && priorToSpace == STEST_OPERATOR ) //!STEST_BRACKET(priorToSpace)) ) { SnipCharFromString( cleanupReader ); cleanupReader--; } } cleanupReader++; } Q_strcpy( localString, cleanupString ); char *GlobalExpression = localString; while( *GlobalExpression ) { if ( *GlobalExpression == '$' ) { *GlobalExpression = '\0'; GlobalExpression++; while ( *GlobalExpression == ' ' ) GlobalExpression++; char *SetEnd = GlobalExpression; while ( *SetEnd ) { if ( *SetEnd == '$' ) *SetEnd = '\0'; SetEnd++; } break; } GlobalExpression++; } #if 0 cleanupReader = localString; while( *cleanupReader ) { if ( ISCHAR_BRACKET( *cleanupReader ) ) SnipCharFromString( cleanupReader ); cleanupReader++; } #endif iActiveChannels = 0; if ( !bHasAnyValues && bAllowChars ) { int slotWrite = 0; const char *walk = localString; while (walk && *walk && slotWrite < 4) { if ( GetChannelNumFromChar( walk ) >= 0 ) { bChannelAsValue[ slotWrite ] = false; cChannel[ slotWrite ] = *walk; slotWrite++; iActiveChannels++; } walk++; } } else { SimpleTokenize _tokens; _tokens.Tokenize( localString ); //CCommand args; //args.Tokenize( localString ); for ( int i = 0; i < min( _tokens.Count(), 4 ); i++ ) //for ( int i = 0; i < min( args.ArgC(), 4 ); i++ ) { const char *token = _tokens.GetToken( i ); //const char *token = args[i]; if ( GetChannelNumFromChar( token ) >= 0 && bAllowChars ) { bChannelAsValue[ i ] = false; cChannel[ i ] = *token; } else { bChannelAsValue[ i ] = true; const bool bDoGlExp = (GlobalExpression && *GlobalExpression); char tmp[ MAX_OPERATION_C ]; char *target = tmp; if ( bDoGlExp ) { *target = '('; target++; } Q_strcpy( target, token ); if ( bDoGlExp ) { Q_strcat( tmp, ")", MAX_OPERATION_C ); Q_strcat( tmp, GlobalExpression, MAX_OPERATION_C ); } flValue[ i ] = PerformSolve( tmp ); } iActiveChannels++; } } bReady = !!iActiveChannels; Assert( iActiveChannels >= 0 && iActiveChannels <= 4 ); iChannelDepth = 0; for ( int i = 0; i < iActiveChannels; i++ ) if ( bChannelAsValue[ i ] ) bHasAnyValues = true; for ( int i = 0; i < iActiveChannels; i++ ) { iChannel[ i ] = 0; if ( bChannelAsValue[i] ) continue; iChannel[ i ] = GetChannelNumFromChar( &cChannel[i] ); int num = iChannel[ i ] + 1; iChannelDepth = max( num, iChannelDepth ); } // manual normalize if ( bNormalize ) { float flVec[4]; Q_memset( flVec, 0, sizeof(flVec) ); for ( int i = 0; i < iActiveChannels; i++ ) if ( bChannelAsValue[ i ] ) flVec[ i ] = flValue[ i ]; double vecSize = 0; for ( int i = 0; i < 4; i++ ) vecSize += Sqr( flVec[i] ); if ( vecSize == 0 ) vecSize = 1; vecSize = FastSqrt( vecSize ); vecSize = 1.0f / vecSize; for ( int i = 0; i < 4; i++ ) if ( bChannelAsValue[ i ] ) flValue[ i ] *= vecSize; } }
void CUtlString::Set( const char *pValue ) { Assert( !m_Storage.IsReadOnly() ); int nLen = pValue ? Q_strlen(pValue) + 1 : 0; m_Storage.Set( pValue, nLen ); }
bool CSmokeStack::KeyValue( const char *szKeyName, const char *szValue ) { if( stricmp( szKeyName, "Wind" ) == 0 ) { sscanf( szValue, "%f %f %f", &m_vWind.GetForModify().x, &m_vWind.GetForModify().y, &m_vWind.GetForModify().z ); return true; } else if( stricmp( szKeyName, "WindAngle" ) == 0 ) { m_WindAngle = atoi( szValue ); RecalcWindVector(); return true; } else if( stricmp( szKeyName, "WindSpeed" ) == 0 ) { m_WindSpeed = atoi( szValue ); RecalcWindVector(); return true; } else if ( stricmp( szKeyName, "SmokeMaterial" ) == 0 ) { // Make sure we have a vmt extension. if ( Q_stristr( szValue, ".vmt" ) ) { m_strMaterialModel = AllocPooledString( szValue ); } else { char str[512]; Q_snprintf( str, sizeof( str ), "%s.vmt", szValue ); m_strMaterialModel = AllocPooledString( str ); } const char *pName = STRING( m_strMaterialModel ); char szStrippedName[512]; m_iMaterialModel = PrecacheModel( pName ); Q_StripExtension( pName, szStrippedName, Q_strlen(pName)+1 ); int iLength = Q_strlen( szStrippedName ); szStrippedName[iLength-1] = '\0'; int iCount = 1; char str[512]; Q_snprintf( str, sizeof( str ), "%s%d.vmt", szStrippedName, iCount ); while ( filesystem->FileExists( UTIL_VarArgs( "materials/%s", str ) ) ) { PrecacheModel( str ); iCount++; Q_snprintf( str, sizeof( str ), "%s%d.vmt", szStrippedName, iCount ); } return true; } else { return BaseClass::KeyValue( szKeyName, szValue ); } }
bool CCommand::Tokenize( const char *pCommand, characterset_t *pBreakSet ) { Reset(); if ( !pCommand ) return false; // Use default break set if ( !pBreakSet ) { pBreakSet = &s_BreakSet; } // Copy the current command into a temp buffer // NOTE: This is here to avoid the pointers returned by DequeueNextCommand // to become invalid by calling AddText. Is there a way we can avoid the memcpy? int nLen = Q_strlen( pCommand ); if ( nLen >= COMMAND_MAX_LENGTH - 1 ) { Warning( "CCommand::Tokenize: Encountered command which overflows the tokenizer buffer.. Skipping!\n" ); return false; } memcpy( m_pArgSBuffer, pCommand, nLen + 1 ); // Parse the current command into the current command buffer CUtlBuffer bufParse( m_pArgSBuffer, nLen, CUtlBuffer::TEXT_BUFFER | CUtlBuffer::READ_ONLY ); int nArgvBufferSize = 0; while ( bufParse.IsValid() && ( m_nArgc < COMMAND_MAX_ARGC ) ) { char *pArgvBuf = &m_pArgvBuffer[nArgvBufferSize]; int nMaxLen = COMMAND_MAX_LENGTH - nArgvBufferSize; int nStartGet = bufParse.TellGet(); int nSize = bufParse.ParseToken( pBreakSet, pArgvBuf, nMaxLen ); if ( nSize < 0 ) break; // Check for overflow condition if ( nMaxLen == nSize ) { Reset(); return false; } if ( m_nArgc == 1 ) { // Deal with the case where the arguments were quoted m_nArgv0Size = bufParse.TellGet(); bool bFoundEndQuote = m_pArgSBuffer[m_nArgv0Size-1] == '\"'; if ( bFoundEndQuote ) { --m_nArgv0Size; } m_nArgv0Size -= nSize; Assert( m_nArgv0Size != 0 ); // The StartGet check is to handle this case: "foo"bar // which will parse into 2 different args. ArgS should point to bar. bool bFoundStartQuote = ( m_nArgv0Size > nStartGet ) && ( m_pArgSBuffer[m_nArgv0Size-1] == '\"' ); Assert( bFoundEndQuote == bFoundStartQuote ); if ( bFoundStartQuote ) { --m_nArgv0Size; } } m_ppArgv[ m_nArgc++ ] = pArgvBuf; if( m_nArgc >= COMMAND_MAX_ARGC ) { Warning( "CCommand::Tokenize: Encountered command which overflows the argument buffer.. Clamped!\n" ); } nArgvBufferSize += nSize + 1; Assert( nArgvBufferSize <= COMMAND_MAX_LENGTH ); } return true; }
void Host_Say(qboolean teamonly) { client_t *client; client_t *save; int j; char *p; char text[64]; qboolean fromServer = false; if (cmd_source == src_command) { if (cls.state == ca_dedicated) { fromServer = true; teamonly = false; } else { Cmd_ForwardToServer (); return; } } if (Cmd_Argc () < 2) return; save = host_client; p = Cmd_Args(); // remove quotes if present if (*p == '"') { p++; p[Q_strlen(p)-1] = 0; } // turn on color set 1 if (!fromServer) sprintf (text, "%c%s: ", 1, save->name); //sprintf (text, "%s: ", save->name); else sprintf (text, "%c<%s> ", 1, hostname.string); //sprintf (text, "<%s> ", hostname.string); j = sizeof(text) - 2 - Q_strlen(text); // -2 for /n and null terminator if (Q_strlen(p) > j) p[j] = 0; strcat (text, p); strcat (text, "\n"); for (j = 0, client = svs.clients; j < svs.maxclients; j++, client++) { if (!client || !client->active || !client->spawned) continue; if (teamplay.value && teamonly && client->edict->v.team != save->edict->v.team) continue; host_client = client; SV_ClientPrintf("%s", text); } host_client = save; Sys_Printf("%s", &text[1]); }
void CheckLiblistForFallbackDir(const char *pGameDir, bool bLanguage, const char *pLanguage, bool bLowViolenceBuild_) { char szTemp[512]; FileHandle_t hFile; Q_snprintf(szTemp, sizeof(szTemp) - 1, "%s/liblist.gam", pGameDir); COM_FixSlashes(szTemp); g_pFileSystem->GetLocalCopy(szTemp); if (Q_stricmp(com_gamedir, pGameDir)) { Q_snprintf(szTemp, 511, "../%s/liblist.gam", pGameDir); COM_FixSlashes(szTemp); hFile = FS_Open(szTemp, "rt"); } else hFile = FS_Open("liblist.gam", "rt"); if (!hFile) return; if (FS_EndOfFile(hFile)) { FS_Close(hFile); return; } char szFallback[128]; char szLine[512]; char *end; char *start; int bytesToCopy; while (1) { szLine[0] = 0; FS_ReadLine(szLine, sizeof(szLine) - 1, hFile); szLine[511] = 0; if (!Q_strnicmp(szLine, "fallback_dir", Q_strlen("fallback_dir"))) { start = Q_strchr(szLine, '"'); if (!start) { FS_Close(hFile); return; } end = Q_strchr(start + 1, '"'); if (!end) { FS_Close(hFile); return; } bytesToCopy = (int)(end - start) - 1; if (bytesToCopy > sizeof(szFallback) - 2) { FS_Close(hFile); return; } if (bytesToCopy > 0) break; } if (FS_EndOfFile(hFile)) { FS_Close(hFile); return; } } Q_strncpy(szFallback, start + 1, bytesToCopy); szFallback[bytesToCopy] = 0; if (!Q_stricmp(pGameDir, szFallback) ) { FS_Close(hFile); return; } if (bLowViolenceBuild) { Q_snprintf(szTemp, 511, "%s/%s_lv", GetBaseDirectory(), szFallback); szTemp[511] = 0; COM_FixSlashes(szTemp); g_pFileSystem->AddSearchPathNoWrite(szTemp, "GAME_FALLBACK"); } if (BEnableAddonsFolder()) { Q_snprintf(szTemp, 511, "%s/%s_addon", GetBaseDirectory(), szFallback); szTemp[511] = 0; COM_FixSlashes(szTemp); g_pFileSystem->AddSearchPathNoWrite(szTemp, "GAME_FALLBACK"); } if (bLanguage && pLanguage) { char baseDir[4096]; char *tempPtr; Q_snprintf(szTemp, 511, "%s/%s_%s", GetBaseDirectory(), szFallback, pLanguage); szTemp[511] = 0; COM_FixSlashes(szTemp); g_pFileSystem->AddSearchPath(szTemp, "GAME_FALLBACK"); if (!COM_CheckParm("-steam")) { Q_strncpy(baseDir, GetBaseDirectory(), sizeof(baseDir) - 1); baseDir[sizeof(baseDir) - 1] = 0; tempPtr = Q_strstr(baseDir, "\\game"); if (tempPtr) { *tempPtr = 0; Q_snprintf(szTemp, 511, "%s\\localization\\%s_%s", baseDir, szFallback, pLanguage); szTemp[511] = 0; COM_FixSlashes(szTemp); g_pFileSystem->AddSearchPath(szTemp, "GAME_FALLBACK"); } } } if (BEnabledHDAddon()) { Q_snprintf(szTemp, 511, "%s/%s_hd", GetBaseDirectory(), szFallback); szTemp[511] = 0; COM_FixSlashes(szTemp); g_pFileSystem->AddSearchPathNoWrite(szTemp, "GAME_FALLBACK"); } Q_snprintf(szTemp, 511, "%s/%s", GetBaseDirectory(), szFallback); szTemp[511] = 0; COM_FixSlashes(szTemp); g_pFileSystem->AddSearchPath(szTemp, "GAME_FALLBACK"); if (Q_stricmp(szFallback, "valve")) { const int BufLen = 128; char *szFileName = new char[BufLen]; Q_snprintf(szFileName, BufLen - 1, "Resource/%s_%%language%%.txt", szFallback); szFileName[BufLen - 1] = 0; g_fallbackLocalizationFiles.AddToTail(szFileName); CheckLiblistForFallbackDir(szFallback, bLanguage, pLanguage, bLowViolenceBuild); } FS_Close(hFile); }
void CASW_Location::LoadFromKeyValues( KeyValues *pKeys, CUniformRandomStream* pStream) { m_iXPos = pKeys->GetInt( "x" ); m_iYPos = pKeys->GetInt( "y" ); Q_strcpy( m_szMapName, "random" ); m_iMinDifficulty = pKeys->GetInt( "MinDifficulty", 1 ); m_iMaxDifficulty = pKeys->GetInt( "MaxDifficulty", 100 ); m_iCompanyIndex = pKeys->GetInt( "Company", 0 ); m_bIsMissionOptional = !!pKeys->GetInt( "Optional", 1 ); m_iLocationID = pKeys->GetInt( "ID", -1 ); m_pszCustomMission = TileGenCopyString( pKeys->GetString( "CustomMission" ) ); m_szStoryScene = TileGenCopyString( pKeys->GetString( "StoryScene" ) ) ? TileGenCopyString( pKeys->GetString( "StoryScene" ) ) : "spaceport_crashsite"; m_szImageName = TileGenCopyString( pKeys->GetString( "ImageName" ) ) ? TileGenCopyString( pKeys->GetString( "ImageName" ) ) : "swarm/MissionPics/PlantMissionpic.vmt"; if ( m_pszCustomMission ) { Q_FixSlashes( m_pszCustomMission ); } // pick a difficulty between the bounds m_iDifficulty = pStream->RandomInt( m_iMinDifficulty, m_iMaxDifficulty ); if ( m_pszCustomMission && m_pszCustomMission[0] ) { m_pMissionKV = m_pLocationGrid->GetMissionData( m_pszCustomMission ); } if ( m_pMissionKV ) { // Make a copy so we can modify it m_pMissionKV = m_pMissionKV->MakeCopy(); // Fill out mission settings from the mission grid data so it gets into the .layout file if ( GetMissionSettings() ) { GetMissionSettings()->SetInt( "Difficulty", m_iDifficulty ); const char *pMissionName = m_pszCustomMission; if ( Q_strnicmp( m_pszCustomMission, "tilegen/new_missions/", Q_strlen( "tilegen/new_missions/" ) ) == 0 ) { pMissionName += Q_strlen( "tilegen/new_missions/" ); } GetMissionSettings()->SetString( "Filename", m_pszCustomMission + Q_strlen( "tilegen/new_missions/" ) ); GetMissionSettings()->SetInt( "GridLocationID", m_iLocationID ); } } // if mission doesn't have a valid ID then find one if ( m_iLocationID == -1 ) { m_iLocationID = LocationGrid()->GetFreeLocationID(); } KeyValues *pRewards = pKeys->FindKey( "Rewards" ); if ( pRewards ) { for ( KeyValues *pRewardKey = pRewards->GetFirstSubKey(); pRewardKey; pRewardKey = pRewardKey->GetNextKey() ) { CASW_Reward *pReward = new CASW_Reward(); if ( pReward->LoadFromKeyValues( pRewardKey, m_iDifficulty ) ) { m_Rewards.AddToTail( pReward ); } else { delete pReward; } } } else { // TODO: Create some default rewards? } }
int FileSystem_SetGameDirectory(const char *pDefaultDir, const char *pGameDir) { char temp[512]; char language[256]; const char *pchLang; g_pFileSystem->RemoveAllSearchPaths(); language[0] = 0; if (!bLowViolenceBuild) { if (CRehldsPlatformHolder::get()->SteamApps() && GetGameAppID() == 70) { bLowViolenceBuild = CRehldsPlatformHolder::get()->SteamApps()->BIsLowViolence(); } } pchLang = CRehldsPlatformHolder::get()->SteamApps() ? CRehldsPlatformHolder::get()->SteamApps()->GetCurrentGameLanguage() : NULL; Q_strncpy(language, pchLang ? pchLang : "english", ARRAYSIZE(language)); #ifdef REHLDS_CHECKS language[ARRAYSIZE(language) - 1] = 0; #endif if (!g_bIsDedicatedServer && !IsGameSubscribed(pGameDir)) return 0; CRehldsPlatformHolder::get()->SteamAPI_SetBreakpadAppID(GetGameAppID()); bool bEnableHDPack = BEnabledHDAddon(); bool bLanguage = (Q_strlen(language) != 0 && Q_stricmp(language, "english")) ? true : false; if (!pGameDir) pGameDir = pDefaultDir; if (pGameDir) { if (bLowViolenceBuild) { Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_lv", GetBaseDirectory(), pGameDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "GAME"); } if (BEnableAddonsFolder()) { Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_addon", GetBaseDirectory(), pGameDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "GAME"); } if (bLanguage) { Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_%s", GetBaseDirectory(), pGameDir, language); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "GAME"); if (!COM_CheckParm("-steam")) { char baseDir[MAX_PATH]; Q_strncpy(baseDir, GetBaseDirectory(), sizeof(baseDir) - 1); baseDir[sizeof(baseDir) - 1] = 0; char* tempPtr = Q_strstr(baseDir, "\\game"); if (tempPtr) { *tempPtr = 0; Q_snprintf(temp, 511, "%s\\localization\\%s_%s", baseDir, pGameDir, language); temp[511] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "GAME"); } } } if (bEnableHDPack) { Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_hd", GetBaseDirectory(), pGameDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "GAME"); } Q_snprintf(temp, 511, "%s/%s", GetBaseDirectory(), pGameDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPath(temp, "GAME"); g_pFileSystem->AddSearchPath(temp, "GAMECONFIG"); Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_downloads", GetBaseDirectory(), pGameDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPath(temp, "GAMEDOWNLOAD"); CheckLiblistForFallbackDir(pGameDir, bLanguage, language, bLowViolenceBuild); } if (bLanguage) { if (bLowViolenceBuild) { Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_lv", GetBaseDirectory(), pDefaultDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "DEFAULTGAME"); } if (BEnableAddonsFolder()) { Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_addon", GetBaseDirectory(), pDefaultDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "DEFAULTGAME"); } Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_%s", GetBaseDirectory(), pDefaultDir, language); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "DEFAULTGAME"); if (!COM_CheckParm("-steam")) { char baseDir[MAX_PATH]; Q_strncpy(baseDir, GetBaseDirectory(), sizeof(baseDir) - 1); baseDir[sizeof(baseDir) - 1] = 0; char* tempPtr = Q_strstr(baseDir, "\\game"); if (tempPtr) { *tempPtr = 0; Q_snprintf(temp, sizeof(temp) - 1, "%s\\localization\\%s_%s", baseDir, pDefaultDir, language); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "DEFAULTGAME"); } } } if (bEnableHDPack) { Q_snprintf(temp, sizeof(temp) - 1, "%s/%s_hd", GetBaseDirectory(), pDefaultDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "DEFAULTGAME"); } Q_snprintf(temp, sizeof(temp) - 1, "%s", GetBaseDirectory()); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPath(temp, "BASE"); Q_snprintf(temp, sizeof(temp) - 1, "%s/%s", GetBaseDirectory(), pDefaultDir); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPathNoWrite(temp, "DEFAULTGAME"); Q_snprintf(temp, sizeof(temp) - 1, "%s/platform", GetBaseDirectory()); temp[sizeof(temp) - 1] = 0; COM_FixSlashes(temp); g_pFileSystem->AddSearchPath(temp, "PLATFORM"); return 1; }
static void _Datagram_SearchForHosts (qboolean xmit) { int ret; int n; int i; struct qsockaddr readaddr; struct qsockaddr myaddr; int control; dfunc.GetSocketAddr (dfunc.controlSock, &myaddr); if (xmit) { SZ_Clear(&net_message); // save space for the header, filled in later MSG_WriteLong(&net_message, 0); MSG_WriteByte(&net_message, CCREQ_SERVER_INFO); MSG_WriteString(&net_message, "QUAKE"); MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION); *((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK)); dfunc.Broadcast(dfunc.controlSock, net_message.data, net_message.cursize); SZ_Clear(&net_message); } while ((ret = dfunc.Read (dfunc.controlSock, net_message.data, net_message.maxsize, &readaddr)) > 0) { if (ret < sizeof(int)) continue; net_message.cursize = ret; // don't answer our own query if (dfunc.AddrCompare(&readaddr, &myaddr) >= 0) continue; // is the cache full? if (hostCacheCount == HOSTCACHESIZE) continue; MSG_BeginReading (); control = BigLong(*((int *)net_message.data)); MSG_ReadLong(); if (control == -1) continue; if ((control & (~NETFLAG_LENGTH_MASK)) != NETFLAG_CTL) continue; if ((control & NETFLAG_LENGTH_MASK) != ret) continue; if (MSG_ReadByte() != CCREP_SERVER_INFO) continue; dfunc.GetAddrFromName(MSG_ReadString(), &readaddr); // search the cache for this server for (n = 0; n < hostCacheCount; n++) if (dfunc.AddrCompare(&readaddr, &hostcache[n].addr) == 0) break; // is it already there? if (n < hostCacheCount) continue; // add it hostCacheCount++; Q_strcpy(hostcache[n].name, MSG_ReadString()); Q_strcpy(hostcache[n].map, MSG_ReadString()); hostcache[n].users = MSG_ReadByte(); hostcache[n].maxusers = MSG_ReadByte(); if (MSG_ReadByte() != NET_PROTOCOL_VERSION) { Q_strcpy(hostcache[n].cname, hostcache[n].name); hostcache[n].cname[14] = 0; Q_strcpy(hostcache[n].name, "*"); Q_strcat(hostcache[n].name, hostcache[n].cname); } Q_memcpy(&hostcache[n].addr, &readaddr, sizeof(struct qsockaddr)); hostcache[n].driver = net_driverlevel; hostcache[n].ldriver = net_landriverlevel; Q_strcpy(hostcache[n].cname, dfunc.AddrToString(&readaddr)); // check for a name conflict for (i = 0; i < hostCacheCount; i++) { if (i == n) continue; if (Q_strcasecmp (hostcache[n].name, hostcache[i].name) == 0) { i = Q_strlen(hostcache[n].name); if (i < 15 && hostcache[n].name[i-1] > '8') { hostcache[n].name[i] = '0'; hostcache[n].name[i+1] = 0; } else hostcache[n].name[i-1]++; i = -1; } } } }
bool StudioModel::LoadModel( const char *pModelName ) { MDLCACHE_CRITICAL_SECTION_( g_pMDLCache ); if (!pModelName) return 0; // In the case of restore, m_pModelName == modelname if (m_pModelName != pModelName) { // Copy over the model name; we'll need it later... if (m_pModelName) { delete[] m_pModelName; } m_pModelName = new char[Q_strlen(pModelName) + 1]; strcpy( m_pModelName, pModelName ); } m_MDLHandle = g_pMDLCache->FindMDL( pModelName ); // allocate a pool for a studiohdr cache if (m_pStudioHdr != NULL) { delete m_pStudioHdr; } m_pStudioHdr = new CStudioHdr( g_pMDLCache->GetStudioHdr( m_MDLHandle ), g_pMDLCache ); // manadatory to access correct verts SetCurrentModel(); m_pPhysics = LoadPhysics( m_MDLHandle ); // Copy over all of the hitboxes; we may add and remove elements m_HitboxSets.RemoveAll(); CStudioHdr *pStudioHdr = GetStudioHdr(); int i; for ( int s = 0; s < pStudioHdr->numhitboxsets(); s++ ) { mstudiohitboxset_t *set = pStudioHdr->pHitboxSet( s ); if ( !set ) continue; m_HitboxSets.AddToTail(); for ( i = 0; i < set->numhitboxes; ++i ) { mstudiobbox_t *pHit = set->pHitbox(i); int nIndex = m_HitboxSets[ s ].AddToTail( ); m_HitboxSets[s][nIndex] = *pHit; } // Set the name hbsetname_s *n = &m_HitboxSetNames[ m_HitboxSetNames.AddToTail() ]; strcpy( n->name, set->pszName() ); } // Copy over all of the surface props; we may change them... for ( i = 0; i < pStudioHdr->numbones(); ++i ) { mstudiobone_t* pBone = pStudioHdr->pBone(i); CUtlSymbol prop( pBone->pszSurfaceProp() ); m_SurfaceProps.AddToTail( prop ); } m_physPreviewBone = -1; bool forceOpaque = (pStudioHdr->flags() & STUDIOHDR_FLAGS_FORCE_OPAQUE) != 0; bool vertexLit = false; m_bIsTransparent = false; m_bHasProxy = false; studiohwdata_t *pHardwareData = g_pMDLCache->GetHardwareData( m_MDLHandle ); if ( !pHardwareData ) { Assert( 0 ); return false; } for( int lodID = pHardwareData->m_RootLOD; lodID < pHardwareData->m_NumLODs; lodID++ ) { studioloddata_t *pLODData = &pHardwareData->m_pLODs[lodID]; for ( i = 0; i < pLODData->numMaterials; ++i ) { if (pLODData->ppMaterials[i]->IsVertexLit()) { vertexLit = true; } if ((!forceOpaque) && pLODData->ppMaterials[i]->IsTranslucent()) { m_bIsTransparent = true; //Msg("Translucent material %s for model %s\n", pLODData->ppMaterials[i]->GetName(), pStudioHdr->name ); } if (pLODData->ppMaterials[i]->HasProxy()) { m_bHasProxy = true; } } } return true; }
//----------------------------------------------------------------------------- // Purpose: determine the class name of the weapon that got a kill //----------------------------------------------------------------------------- const char *CSDKGameRules::GetKillingWeaponName( const CTakeDamageInfo &info, CSDKPlayer *pVictim, int *iWeaponID ) { CBaseEntity *pInflictor = info.GetInflictor(); CBaseEntity *pKiller = info.GetAttacker(); CBasePlayer *pScorer = SDKGameRules()->GetDeathScorer( pKiller, pInflictor, pVictim ); const char *killer_weapon_name = "world"; *iWeaponID = SDK_WEAPON_NONE; if ( pScorer && pInflictor && ( pInflictor == pScorer ) ) { // If the inflictor is the killer, then it must be their current weapon doing the damage if ( pScorer->GetActiveWeapon() ) { killer_weapon_name = pScorer->GetActiveWeapon()->GetClassname(); if ( pScorer->IsPlayer() ) { *iWeaponID = ToSDKPlayer(pScorer)->GetActiveSDKWeapon()->GetWeaponID(); } } } else if ( pInflictor ) { killer_weapon_name = STRING( pInflictor->m_iClassname ); CWeaponSDKBase *pWeapon = dynamic_cast< CWeaponSDKBase * >( pInflictor ); if ( pWeapon ) { *iWeaponID = pWeapon->GetWeaponID(); } else { CBaseGrenadeProjectile *pBaseGrenade = dynamic_cast<CBaseGrenadeProjectile*>( pInflictor ); if ( pBaseGrenade ) { *iWeaponID = pBaseGrenade->GetWeaponID(); } } } // strip certain prefixes from inflictor's classname const char *prefix[] = { "weapon_", "NPC_", "func_" }; for ( int i = 0; i< ARRAYSIZE( prefix ); i++ ) { // if prefix matches, advance the string pointer past the prefix int len = Q_strlen( prefix[i] ); if ( strncmp( killer_weapon_name, prefix[i], len ) == 0 ) { killer_weapon_name += len; break; } } // grenade projectiles need to be translated to 'grenade' if ( 0 == Q_strcmp( killer_weapon_name, "grenade_projectile" ) ) { killer_weapon_name = "grenade"; } return killer_weapon_name; }
void CL_ParseServerMessage (void) { int cmd; int i; // // if recording demos, copy the message out // if (cl_shownet.value == 1) Con_Printf ("%i ",net_message.cursize); else if (cl_shownet.value == 2) Con_Printf ("------------------\n"); cl.onground = false; // unless the server says otherwise // // parse the message // MSG_BeginReading (); while (1) { if (msg_badread) Host_Error ("CL_ParseServerMessage: Bad server message"); cmd = MSG_ReadByte (); if (cmd == -1) { SHOWNET("END OF MESSAGE"); return; // end of message } // if the high bit of the command byte is set, it is a fast update if (cmd & 128) { SHOWNET("fast update"); CL_ParseUpdate (cmd&127); continue; } SHOWNET(svc_strings[cmd]); // other commands switch (cmd) { default: Host_Error ("CL_ParseServerMessage: Illegible server message\n"); break; case svc_nop: // Con_Printf ("svc_nop\n"); break; case svc_time: cl.mtime[1] = cl.mtime[0]; cl.mtime[0] = MSG_ReadFloat (); break; case svc_clientdata: i = MSG_ReadShort (); CL_ParseClientdata (i); break; case svc_version: i = MSG_ReadLong (); if (i != PROTOCOL_VERSION) Host_Error ("CL_ParseServerMessage: Server is protocol %i instead of %i\n", i, PROTOCOL_VERSION); break; case svc_disconnect: Host_EndGame ("Server disconnected\n"); case svc_print: Con_Printf ("%s", MSG_ReadString ()); break; case svc_centerprint: SCR_CenterPrint (MSG_ReadString ()); break; case svc_stufftext: Cbuf_AddText (MSG_ReadString ()); break; case svc_damage: V_ParseDamage (); break; case svc_serverinfo: CL_ParseServerInfo (); vid.recalc_refdef = true; // leave intermission full screen break; case svc_setangle: for (i=0 ; i<3 ; i++) cl.viewangles[i] = MSG_ReadAngle (); break; case svc_setview: cl.viewentity = MSG_ReadShort (); break; case svc_lightstyle: i = MSG_ReadByte (); if (i >= MAX_LIGHTSTYLES) Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES"); Q_strcpy (cl_lightstyle[i].map, MSG_ReadString()); cl_lightstyle[i].length = Q_strlen(cl_lightstyle[i].map); break; case svc_sound: CL_ParseStartSoundPacket(); break; case svc_stopsound: i = MSG_ReadShort(); S_StopSound(i>>3, i&7); break; case svc_updatename: Sbar_Changed (); i = MSG_ReadByte (); if (i >= cl.maxclients) Host_Error ("CL_ParseServerMessage: svc_updatename > MAX_SCOREBOARD"); strcpy (cl.scores[i].name, MSG_ReadString ()); break; case svc_updatefrags: Sbar_Changed (); i = MSG_ReadByte (); if (i >= cl.maxclients) Host_Error ("CL_ParseServerMessage: svc_updatefrags > MAX_SCOREBOARD"); cl.scores[i].frags = MSG_ReadShort (); break; case svc_updatecolors: Sbar_Changed (); i = MSG_ReadByte (); if (i >= cl.maxclients) Host_Error ("CL_ParseServerMessage: svc_updatecolors > MAX_SCOREBOARD"); cl.scores[i].colors = MSG_ReadByte (); CL_NewTranslation (i); break; case svc_particle: R_ParseParticleEffect (); break; case svc_spawnbaseline: i = MSG_ReadShort (); // must use CL_EntityNum() to force cl.num_entities up CL_ParseBaseline (CL_EntityNum(i)); break; case svc_spawnstatic: CL_ParseStatic (); break; case svc_temp_entity: CL_ParseTEnt (); break; case svc_setpause: { cl.paused = MSG_ReadByte (); if (cl.paused) { CDAudio_Pause (); #ifdef _WIN32 VID_HandlePause (true); #endif } else { CDAudio_Resume (); #ifdef _WIN32 VID_HandlePause (false); #endif } } break; case svc_signonnum: i = MSG_ReadByte (); if (i <= cls.signon) Host_Error ("Received signon %i when at %i", i, cls.signon); cls.signon = i; CL_SignonReply (); break; case svc_killedmonster: cl.stats[STAT_MONSTERS]++; break; case svc_foundsecret: cl.stats[STAT_SECRETS]++; break; case svc_updatestat: i = MSG_ReadByte (); if (i < 0 || i >= MAX_CL_STATS) Sys_Error ("svc_updatestat: %i is invalid", i); cl.stats[i] = MSG_ReadLong ();; break; case svc_spawnstaticsound: CL_ParseStaticSound (); break; case svc_cdtrack: cl.cdtrack = MSG_ReadByte (); cl.looptrack = MSG_ReadByte (); if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) ) CDAudio_Play ((byte)cls.forcetrack, true); else CDAudio_Play ((byte)cl.cdtrack, true); break; case svc_intermission: cl.intermission = 1; cl.completed_time = (int) cl.time; vid.recalc_refdef = true; // go to full screen break; case svc_finale: cl.intermission = 2; cl.completed_time = (int) cl.time; vid.recalc_refdef = true; // go to full screen SCR_CenterPrint (MSG_ReadString ()); break; case svc_cutscene: cl.intermission = 3; cl.completed_time = (int) cl.time; vid.recalc_refdef = true; // go to full screen SCR_CenterPrint (MSG_ReadString ()); break; case svc_sellscreen: Cmd_ExecuteString2 ("help", src_command); break; } } }
/* ================ FS_Init ================ */ void CFileSystem::Init() { mpLowLevelFileSystem->Init(); tStringList dirs; bool hasDefaultDir = false; int i; // Init memory fs_mempool = Mem_AllocPool( "FileSystem Pool" ); // add a path separator to the end of the basedir if it lacks one if( fs_basedir[0] && fs_basedir[Q_strlen(fs_basedir) - 1] != '/' && fs_basedir[Q_strlen(fs_basedir) - 1] != '\\' ) Q_strncat( fs_basedir, "/", sizeof( fs_basedir )); fs_searchpaths = NULL; mpConsole->AddCommand("fs_rescan", FS_Rescan_f, "rescan filesystem search pathes"); mpConsole->AddCommand("fs_path", FS_Path_f, "show filesystem search pathes"); mpConsole->AddCommand("fs_clearpaths", FS_ClearPaths_f, "clear filesystem search pathes"); // ignore commandlineoption "-game" for other stuff if( host.type == HOST_NORMAL || host.type == HOST_DEDICATED ) { stringlistinit( &dirs ); listdirectory( &dirs, "./" ); stringlistsort( &dirs ); SI.numgames = 0; if( !Sys_GetParmFromCmdLine( "-game", gs_basedir )) Q_strcpy( gs_basedir, SI.ModuleName ); // default dir if( FS_CheckNastyPath( gs_basedir, true )) { DevMsg( D_ERROR, "FS_Init: invalid game directory \"%s\"\n", gs_basedir ); Q_strcpy( gs_basedir, SI.ModuleName ); // default dir }; // validate directories for( i = 0; i < dirs.numstrings; i++ ) { if( !Q_stricmp( SI.ModuleName, dirs.strings[i] )) hasDefaultDir = true; if( !Q_stricmp( gs_basedir, dirs.strings[i] )) break; } if( i == dirs.numstrings ) { DevMsg( D_INFO, "FS_Init: game directory \"%s\" not exist\n", gs_basedir ); if(hasDefaultDir) Q_strncpy( gs_basedir, SI.ModuleName, sizeof( gs_basedir )); // default dir }; // build list of game directories here FS_AddGameDirectory( "./", 0 ); for( i = 0; i < dirs.numstrings; i++ ) { if(!mpLowLevelFileSystem->SysFolderExists( dirs.strings[i] ) || (!Q_stricmp( dirs.strings[i], ".." ) && !fs_ext_path )) continue; if( !SI.games[SI.numgames] ) SI.games[SI.numgames] = (gameinfo_t *)Mem_Alloc( fs_mempool, sizeof( gameinfo_t )); if( FS_ParseGameInfo( dirs.strings[i], SI.games[SI.numgames] )) SI.numgames++; // added }; stringlistfreecontents( &dirs ); }; MsgDev( D_NOTE, "FS_Init: done\n" ); };
void CHL2MP_Player::SetPlayerModel( void ) { const char *szModelName = NULL; const char *pszCurrentModelName = modelinfo->GetModelName( GetModel()); szModelName = engine->GetClientConVarValue( engine->IndexOfEdict( edict() ), "cl_playermodel" ); if ( ValidatePlayerModel( szModelName ) == false ) { char szReturnString[512]; if ( ValidatePlayerModel( pszCurrentModelName ) == false ) { pszCurrentModelName = "models/Combine_Soldier.mdl"; } Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", pszCurrentModelName ); engine->ClientCommand ( edict(), szReturnString ); szModelName = pszCurrentModelName; } if ( GetTeamNumber() == TEAM_COMBINE ) { int nHeads = ARRAYSIZE( g_ppszRandomCombineModels ); g_iLastCombineModel = ( g_iLastCombineModel + 1 ) % nHeads; szModelName = g_ppszRandomCombineModels[g_iLastCombineModel]; m_iModelType = TEAM_COMBINE; } else if ( GetTeamNumber() == TEAM_REBELS ) { int nHeads = ARRAYSIZE( g_ppszRandomCitizenModels ); g_iLastCitizenModel = ( g_iLastCitizenModel + 1 ) % nHeads; szModelName = g_ppszRandomCitizenModels[g_iLastCitizenModel]; m_iModelType = TEAM_REBELS; } else { if ( Q_strlen( szModelName ) == 0 ) { szModelName = g_ppszRandomCitizenModels[0]; } if ( Q_stristr( szModelName, "models/human") ) { m_iModelType = TEAM_REBELS; } else { m_iModelType = TEAM_COMBINE; } } int modelIndex = modelinfo->GetModelIndex( szModelName ); if ( modelIndex == -1 ) { szModelName = "models/Combine_Soldier.mdl"; m_iModelType = TEAM_COMBINE; char szReturnString[512]; Q_snprintf( szReturnString, sizeof (szReturnString ), "cl_playermodel %s\n", szModelName ); engine->ClientCommand ( edict(), szReturnString ); } SetModel( szModelName ); SetupPlayerSoundsByModel( szModelName ); m_flNextModelChangeTime = gpGlobals->curtime + MODEL_CHANGE_INTERVAL; }
/* <4b17> ../engine/cmd.c:1301 */ void Cmd_CmdList_f(void) { cmd_function_t *cmd; int iCmds; int iArgs; const char *partial, *arg1; int ipLen; char szTemp[MAX_PATH]; FileHandle_t f; FileHandle_t fp; qboolean bLogging; iCmds = 0; partial = NULL; f = NULL; fp = NULL; bLogging = FALSE; iArgs = Cmd_Argc(); if (iArgs > 1) { arg1 = Cmd_Argv(1); if (!Q_stricmp(arg1, "?")) { Con_Printf("CmdList : List all commands\nCmdList [Partial] : List commands starting with 'Partial'\nCmdList log [Partial] : Logs commands to file \"cmdlist.txt\" in the gamedir.\n"); return; } if (!Q_stricmp(arg1, "log")) { // Open log int i; for (i = 0; i < 100; i++) { Q_snprintf(szTemp, ARRAYSIZE(szTemp) - 1, "cmdlist%02d.txt", i); szTemp[ARRAYSIZE(szTemp) - 1] = 0; fp = FS_Open(szTemp, "r"); if (!fp) { break; } FS_Close(fp); } if (i >= 100) { Con_Printf("Can't cmdlist! Too many existing cmdlist output files in the gamedir!\n"); return; } f = FS_Open(szTemp, "wt"); if (!f) { Con_Printf("Couldn't open \"%s\" for writing!\n", szTemp); return; } bLogging = TRUE; // Get next argument into partial, if present if (iArgs >= 2) { partial = Cmd_Argv(2); ipLen = Q_strlen(partial); } } else { partial = arg1; ipLen = Q_strlen(partial); } } // Print commands Con_Printf("Command List\n--------------\n"); for (cmd = cmd_functions; cmd; cmd = cmd->next) { if (partial && Q_strnicmp(cmd->name, partial, ipLen)) { continue; } Con_Printf("%s\n", cmd->name); if (bLogging) { FS_FPrintf(f, "%s\n", cmd->name); } iCmds++; } if (partial && *partial) { Con_Printf("--------------\n%3i Commands for [%s]\nCmdList ? for syntax\n", iCmds, partial); } else { Con_Printf("--------------\n%3i Total Commands\nCmdList ? for syntax\n", iCmds); } // Close log if (bLogging) { FS_Close(f); Con_Printf("cmdlist logged to %s\n", szTemp); } }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CTFWinPanel::FireGameEvent( IGameEvent * event ) { const char *pEventName = event->GetName(); if ( Q_strcmp( "teamplay_round_start", pEventName ) == 0 ) { m_bShouldBeVisible = false; } else if ( Q_strcmp( "teamplay_game_over", pEventName ) == 0 ) { m_bShouldBeVisible = false; } else if ( Q_strcmp( "tf_game_over", pEventName ) == 0 ) { m_bShouldBeVisible = false; } else if ( Q_strcmp( "teamplay_win_panel", pEventName ) == 0 ) { if ( !g_PR ) return; int iWinningTeam = event->GetInt( "winning_team" ); int iWinReason = event->GetInt( "winreason" ); int iFlagCapLimit = event->GetInt( "flagcaplimit" ); bool bRoundComplete = (bool) event->GetInt( "round_complete" ); int iRoundsRemaining = event->GetInt( "rounds_remaining" ); LoadControlSettings( "resource/UI/WinPanel.res" ); InvalidateLayout( false, true ); SetDialogVariable( "WinningTeamLabel", "" ); SetDialogVariable( "AdvancingTeamLabel", "" ); SetDialogVariable( "WinReasonLabel", "" ); SetDialogVariable( "DetailsLabel", "" ); vgui::ImagePanel *pImagePanelBG = dynamic_cast<vgui::ImagePanel *>( FindChildByName("WinPanelBG") ); Assert( pImagePanelBG ); if ( !pImagePanelBG ) return; // set the appropriate background image and label text const char *pTeamLabel = NULL; const char *pTopPlayersLabel = NULL; const wchar_t *pLocalizedTeamName = NULL; // this is an area defense, but not a round win, if this was a successful defend until time limit but not a complete round bool bIsAreaDefense = ( ( WINREASON_DEFEND_UNTIL_TIME_LIMIT == iWinReason ) && !bRoundComplete ); switch ( iWinningTeam ) { case TF_TEAM_BLUE: pImagePanelBG->SetImage( "../hud/winpanel_blue_bg_main.vmt" ); pTeamLabel = ( bRoundComplete ? "#Winpanel_BlueWins" : ( bIsAreaDefense ? "#Winpanel_BlueDefends" : "#Winpanel_BlueAdvances" ) ); pTopPlayersLabel = "#Winpanel_BlueMVPs"; pLocalizedTeamName = g_pVGuiLocalize->Find( "TF_BlueTeam_Name" ); break; case TF_TEAM_RED: pImagePanelBG->SetImage( "../hud/winpanel_red_bg_main.vmt" ); pTeamLabel = ( bRoundComplete ? "#Winpanel_RedWins" : ( bIsAreaDefense ? "#Winpanel_RedDefends" : "#Winpanel_RedAdvances" ) ); pTopPlayersLabel = "#Winpanel_RedMVPs"; pLocalizedTeamName = g_pVGuiLocalize->Find( "TF_RedTeam_Name" ); break; case TEAM_UNASSIGNED: // stalemate pImagePanelBG->SetImage( "../hud/winpanel_black_bg_main.vmt" ); pTeamLabel = "#Winpanel_Stalemate"; pTopPlayersLabel = "#Winpanel_TopPlayers"; break; default: Assert( false ); break; } SetDialogVariable( bRoundComplete ? "WinningTeamLabel" : "AdvancingTeamLabel", g_pVGuiLocalize->Find( pTeamLabel ) ); SetDialogVariable( "TopPlayersLabel", g_pVGuiLocalize->Find( pTopPlayersLabel ) ); wchar_t wzWinReason[256]=L""; switch ( iWinReason ) { case WINREASON_ALL_POINTS_CAPTURED: g_pVGuiLocalize->ConstructString( wzWinReason, sizeof( wzWinReason ), g_pVGuiLocalize->Find( "#Winreason_AllPointsCaptured" ), 1, pLocalizedTeamName ); break; case WINREASON_FLAG_CAPTURE_LIMIT: { wchar_t wzFlagCaptureLimit[16]; _snwprintf( wzFlagCaptureLimit, ARRAYSIZE( wzFlagCaptureLimit), L"%i", iFlagCapLimit ); g_pVGuiLocalize->ConstructString( wzWinReason, sizeof( wzWinReason ), g_pVGuiLocalize->Find( "#Winreason_FlagCaptureLimit" ), 2, pLocalizedTeamName, wzFlagCaptureLimit ); } break; case WINREASON_OPPONENTS_DEAD: g_pVGuiLocalize->ConstructString( wzWinReason, sizeof( wzWinReason ), g_pVGuiLocalize->Find( "#Winreason_OpponentsDead" ), 1, pLocalizedTeamName ); break; case WINREASON_DEFEND_UNTIL_TIME_LIMIT: g_pVGuiLocalize->ConstructString( wzWinReason, sizeof( wzWinReason ), g_pVGuiLocalize->Find( "#Winreason_DefendedUntilTimeLimit" ), 1, pLocalizedTeamName ); break; case WINREASON_STALEMATE: g_pVGuiLocalize->ConstructString( wzWinReason, sizeof( wzWinReason ), g_pVGuiLocalize->Find( "#Winreason_Stalemate" ), 0 ); break; default: Assert( false ); break; } SetDialogVariable( "WinReasonLabel", wzWinReason ); if ( !bRoundComplete && ( WINREASON_STALEMATE != iWinReason ) ) { // if this was a mini-round, show # of capture points remaining wchar_t wzNumCapturesRemaining[16]; wchar_t wzCapturesRemainingMsg[256]=L""; _snwprintf( wzNumCapturesRemaining, ARRAYSIZE( wzNumCapturesRemaining ), L"%i", iRoundsRemaining ); g_pVGuiLocalize->ConstructString( wzCapturesRemainingMsg, sizeof( wzCapturesRemainingMsg ), g_pVGuiLocalize->Find( 1 == iRoundsRemaining ? "#Winpanel_CapturePointRemaining" : "Winpanel_CapturePointsRemaining" ), 1, wzNumCapturesRemaining ); SetDialogVariable( "DetailsLabel", wzCapturesRemainingMsg ); } else if ( ( WINREASON_ALL_POINTS_CAPTURED == iWinReason ) || ( WINREASON_FLAG_CAPTURE_LIMIT == iWinReason ) ) { // if this was a full round that ended with point capture or flag capture, show the winning cappers const char *pCappers = event->GetString( "cappers" ); int iCappers = Q_strlen( pCappers ); if ( iCappers > 0 ) { char szPlayerNames[256]=""; wchar_t wzPlayerNames[256]=L""; wchar_t wzCapMsg[512]=L""; for ( int i = 0; i < iCappers; i++ ) { Q_strncat( szPlayerNames, g_PR->GetPlayerName( (int) pCappers[i] ), ARRAYSIZE( szPlayerNames ) ); if ( i < iCappers - 1 ) { Q_strncat( szPlayerNames, ", ", ARRAYSIZE( szPlayerNames ) ); } } g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerNames, wzPlayerNames, sizeof( wzPlayerNames ) ); g_pVGuiLocalize->ConstructString( wzCapMsg, sizeof( wzCapMsg ), g_pVGuiLocalize->Find( "#Winpanel_WinningCapture" ), 1, wzPlayerNames ); SetDialogVariable( "DetailsLabel", wzCapMsg ); } } // get the current & previous team scores int iBlueTeamPrevScore = event->GetInt( "blue_score_prev", 0 ); int iRedTeamPrevScore = event->GetInt( "red_score_prev", 0 ); m_iBlueTeamScore = event->GetInt( "blue_score", 0 ); m_iRedTeamScore = event->GetInt( "red_score", 0 ); if ( m_pTeamScorePanel ) { if ( bRoundComplete ) { // set the previous team scores in scoreboard m_pTeamScorePanel->SetDialogVariable( "blueteamscore", iBlueTeamPrevScore ); m_pTeamScorePanel->SetDialogVariable( "redteamscore", iRedTeamPrevScore ); if ( ( m_iBlueTeamScore != iBlueTeamPrevScore ) || ( m_iRedTeamScore != iRedTeamPrevScore ) ) { // if the new scores are different, set ourselves to update the scoreboard to the new values after a short delay, so players // see the scores tick up m_flTimeUpdateTeamScore = gpGlobals->curtime + 2.0f; } } // only show team scores if round is complete m_pTeamScorePanel->SetVisible( bRoundComplete ); } C_TF_PlayerResource *tf_PR = dynamic_cast<C_TF_PlayerResource *>( g_PR ); if ( !tf_PR ) return; // look for the top 3 players sent in the event for ( int i = 1; i <= 3; i++ ) { bool bShow = false; char szPlayerIndexVal[64]="", szPlayerScoreVal[64]=""; // get player index and round points from the event Q_snprintf( szPlayerIndexVal, ARRAYSIZE( szPlayerIndexVal ), "player_%d", i ); Q_snprintf( szPlayerScoreVal, ARRAYSIZE( szPlayerScoreVal ), "player_%d_points", i ); int iPlayerIndex = event->GetInt( szPlayerIndexVal, 0 ); int iRoundScore = event->GetInt( szPlayerScoreVal, 0 ); // round score of 0 means no player to show for that position (not enough players, or didn't score any points that round) if ( iRoundScore > 0 ) bShow = true; #if !defined( _X360 ) CAvatarImagePanel *pPlayerAvatar = dynamic_cast<CAvatarImagePanel *>( FindChildByName( CFmtStr( "Player%dAvatar", i ) ) ); if ( pPlayerAvatar ) { if ( bShow ) { CBasePlayer *pPlayer = UTIL_PlayerByIndex( iPlayerIndex ); pPlayerAvatar->SetPlayer( pPlayer ); } pPlayerAvatar->SetVisible( bShow ); } #endif vgui::Label *pPlayerName = dynamic_cast<Label *>( FindChildByName( CFmtStr( "Player%dName", i ) ) ); vgui::Label *pPlayerClass = dynamic_cast<Label *>( FindChildByName( CFmtStr( "Player%dClass", i ) ) ); vgui::Label *pPlayerScore = dynamic_cast<Label *>( FindChildByName( CFmtStr( "Player%dScore", i ) ) ); if ( !pPlayerName || !pPlayerClass || !pPlayerScore ) return; if ( bShow ) { // set the player labels to team color Color clr = g_PR->GetTeamColor( g_PR->GetTeam( iPlayerIndex ) ); pPlayerName->SetFgColor( clr ); pPlayerClass->SetFgColor( clr ); pPlayerScore->SetFgColor( clr ); // set label contents pPlayerName->SetText( g_PR->GetPlayerName( iPlayerIndex ) ); pPlayerClass->SetText( g_aPlayerClassNames[tf_PR->GetPlayerClass( iPlayerIndex )] ); pPlayerScore->SetText( CFmtStr( "%d", iRoundScore ) ); } // show or hide labels for this player position pPlayerName->SetVisible( bShow ); pPlayerClass->SetVisible( bShow ); pPlayerScore->SetVisible( bShow ); } m_bShouldBeVisible = true; MoveToFront(); } }
/* <4c38> ../engine/cmd.c:510 */ char *CopyString(char *in) { char *out = (char *)Z_Malloc(Q_strlen(in) + 1); Q_strcpy(out, in); return out; }
qboolean Netchan_CopyFileFragments(netchan_t *chan) { fragbuf_t *p; int nsize; unsigned char *buffer; int pos; signed int cursize; char filename[MAX_PATH]; char compressor[32]; fragbuf_s *n; qboolean bCompressed; unsigned int uncompressedSize; if (!chan->incomingready[FRAG_FILE_STREAM]) return FALSE; p = chan->incomingbufs[FRAG_FILE_STREAM]; if (!p) { Con_Printf("%s: Called with no fragments readied\n", __func__); chan->incomingready[FRAG_FILE_STREAM] = FALSE; return FALSE; } bCompressed = FALSE; SZ_Clear(&net_message); MSG_BeginReading(); SZ_Write(&net_message, p->frag_message.data, p->frag_message.cursize); Q_strncpy(filename, MSG_ReadString(), sizeof(filename) - 1); filename[sizeof(filename) - 1] = 0; Q_strncpy(compressor, MSG_ReadString(), sizeof(compressor) - 1); compressor[sizeof(compressor) - 1] = 0; if (!Q_stricmp(compressor, "bz2")) bCompressed = TRUE; uncompressedSize = (unsigned int)MSG_ReadLong(); #ifdef REHLDS_FIXES // TODO: this condition is invalid for server->client // TODO: add console message for client // TODO: add client name to message if (uncompressedSize > 1024 * 64) { Con_Printf("Received too large file (size=%u)\nFlushing input queue\n", uncompressedSize); Netchan_FlushIncoming(chan, 1); return FALSE; } #endif if (Q_strlen(filename) <= 0) { Con_Printf("File fragment received with no filename\nFlushing input queue\n"); Netchan_FlushIncoming(chan, 1); return FALSE; } if (Q_strstr(filename, "..")) { Con_Printf("File fragment received with relative path, ignoring\n"); Netchan_FlushIncoming(chan, 1); return FALSE; } if (filename[0] != '!' && !IsSafeFileToDownload(filename)) { Con_Printf("File fragment received with bad path, ignoring\n"); Netchan_FlushIncoming(chan, 1); return FALSE; } // This prohibits to write files to FS on server if (g_pcls.state == ca_dedicated && filename[0] != '!') { Con_Printf("File fragment received with bad path, ignoring (2)\n"); Netchan_FlushIncoming(chan, 1); return FALSE; } Q_strncpy(chan->incomingfilename, filename, MAX_PATH - 1); chan->incomingfilename[MAX_PATH - 1] = 0; if (filename[0] != '!' && FS_FileExists(filename)) { Con_Printf("Can't download %s, already exists\n", filename); Netchan_FlushIncoming(chan, 1); return TRUE; } nsize = 0; while (p) { nsize += p->frag_message.cursize; if (p == chan->incomingbufs[FRAG_FILE_STREAM]) nsize -= msg_readcount; p = p->next; } buffer = (unsigned char*)Mem_ZeroMalloc(nsize + 1); if (!buffer) { Con_Printf("Buffer allocation failed on %i bytes\n", nsize + 1); Netchan_FlushIncoming(chan, 1); return FALSE; } p = chan->incomingbufs[FRAG_FILE_STREAM]; pos = 0; while (p) { n = p->next; cursize = p->frag_message.cursize; // First message has the file name, don't write that into the data stream, just write the rest of the actual data if (p == chan->incomingbufs[FRAG_FILE_STREAM]) { // Copy it in cursize -= msg_readcount; Q_memcpy(&buffer[pos], &p->frag_message.data[msg_readcount], cursize); p->frag_message.cursize = cursize; } else { Q_memcpy(&buffer[pos], p->frag_message.data, cursize); } pos += p->frag_message.cursize; Mem_Free(p); p = n; } if (bCompressed) { unsigned char* uncompressedBuffer = (unsigned char*)Mem_Malloc(uncompressedSize); Con_DPrintf("Decompressing file %s (%d -> %d)\n", filename, nsize, uncompressedSize); BZ2_bzBuffToBuffDecompress((char*)uncompressedBuffer, &uncompressedSize, (char*)buffer, nsize, 1, 0); Mem_Free(buffer); pos = uncompressedSize; buffer = uncompressedBuffer; } if (filename[0] == '!') { if (chan->tempbuffer) { Con_DPrintf("Netchan_CopyFragments: Freeing holdover tempbuffer\n"); Mem_Free(chan->tempbuffer); } chan->tempbuffer = buffer; chan->tempbuffersize = pos; } else { char filedir[MAX_PATH]; char *pszFileName; FileHandle_t handle; #ifdef REHLDS_CHECKS Q_strncpy(filedir, filename, sizeof(filedir) - 1); filedir[sizeof(filedir) - 1] = 0; #else Q_strncpy(filedir, filename, sizeof(filedir)); #endif // REHLDS_CHECKS COM_FixSlashes(filedir); pszFileName = Q_strrchr(filedir, '\\'); if (pszFileName) { *pszFileName = 0; #ifdef REHLDS_FIXES FS_CreateDirHierarchy(filedir, "GAMEDOWNLOAD"); #endif } #ifndef REHLDS_FIXES FS_CreateDirHierarchy(filedir, "GAMEDOWNLOAD"); #endif handle = FS_OpenPathID(filename, "wb", "GAMEDOWNLOAD"); if (!handle) { Con_Printf("File open failed %s\n", filename); Netchan_FlushIncoming(chan, 1); #ifdef REHLDS_FIXES Mem_Free(buffer); #endif return FALSE; } Sys_Printf("COM_WriteFile: %s\n", filename); FS_Write(buffer, pos, 1, handle); FS_Close(handle); Mem_Free(buffer); } SZ_Clear(&net_message); chan->incomingbufs[FRAG_FILE_STREAM] = nullptr; chan->incomingready[FRAG_FILE_STREAM] = FALSE; msg_readcount = 0; return TRUE; }