//--------------------------------------------------------- // Debug support //--------------------------------------------------------- void CBasePresence::DebugUserSetContext( const CCommand &args ) { if ( args.ArgC() == 3 ) { UserSetContext( 0, atoi( args.Arg( 1 ) ), atoi( args.Arg( 2 ) ) ); } else { Warning( "user_context <context id> <context value>\n" ); } }
//------------------------------------------------------------------------------ // Applies keyvalues to the entity by hammer ID. //------------------------------------------------------------------------------ void CC_Ent_Keyvalue( const CCommand &args ) { // Must have an odd number of arguments. if ( ( args.ArgC() < 4 ) || ( args.ArgC() & 1 ) ) { Msg( "Format: ent_keyvalue <entity id> \"key1\" \"value1\" \"key2\" \"value2\" ... \"keyN\" \"valueN\"\n" ); return; } CBasePlayer *pPlayer = ToBasePlayer( UTIL_GetCommandClient() ); CBaseEntity *pEnt; if ( FStrEq( args[1], "" ) || FStrEq( args[1], "!picker" ) ) { if (!pPlayer) return; extern CBaseEntity *FindPickerEntity( CBasePlayer *pPlayer ); pEnt = FindPickerEntity( pPlayer ); if ( !pEnt ) { ClientPrint( pPlayer, HUD_PRINTCONSOLE, "No entity in front of player.\n" ); return; } } else if ( FStrEq( args[1], "!self" ) || FStrEq( args[1], "!caller" ) || FStrEq( args[1], "!activator" ) ) { if (!pPlayer) return; pEnt = pPlayer; } else { int nID = atoi( args[1] ); pEnt = g_ServerTools.FindEntityByHammerID( nID ); if ( !pEnt ) { Msg( "Entity ID %d not found.\n", nID ); return; } } int nArg = 2; while ( nArg < args.ArgC() ) { const char *pszKey = args[ nArg ]; const char *pszValue = args[ nArg + 1 ]; nArg += 2; g_ServerTools.SetKeyValue( pEnt, pszKey, pszValue ); } }
void sourcelua_concmd(const CCommand &command) { int args = command.ArgC(); if(args >= 2) { const char *cmd = command.Arg(1); if(strcmp(cmd, "version") == 0) { CONMSG("SourceLua v%s\n", SOURCELUA_VERSION); CONMSG(" - %s\n", LUAJIT_VERSION); CONMSG(" - %s\n", LUA_VERSION); } } }
void CBasePresence::DebugUserSetProperty( const CCommand &args ) { if ( args.ArgC() == 3 ) { int value = atoi( args.Arg( 2 ) ); UserSetProperty( XBX_GetPrimaryUserId(), strtoul( args.Arg( 1 ), NULL, 0 ), sizeof(int), &value ); } else { Warning( "user_property <property id> <property value>\n" ); } }
// con command for loading a savegame void ASW_LoadCampaignGame_cc( const CCommand &args ) { if ( args.ArgC() < 3 ) { Msg("Usage: ASW_LoadCampaign [SaveName] [SP|MP]\n" ); return; } // Use an arg to detect MP (would be better to check maxplayers here, but we can't?) bool bMulti = (!Q_strnicmp( args[2], "MP", 2 )); ASW_LaunchSaveGame(args[1], bMulti, args.ArgC() == 4); // if 2nd parameter specified, do a changelevel instead of launching a new }
object execute_server_command(tuple args, dict kwargs) { std::string szCommand; ConCommand* pCommand; prepare_command(args, kwargs, &pCommand, &szCommand); CCommand c; if (!c.Tokenize(szCommand.c_str())) BOOST_RAISE_EXCEPTION(PyExc_ValueError, "Failed to tokenize '%s'.", szCommand.c_str()) pCommand->Dispatch(c); return object(); }
void Hook_ExecDispatchPre() #endif { #if SOURCE_ENGINE <= SE_DARKMESSIAH CCommand cmd; #endif const char *arg = cmd.Arg(1); if (!g_bServerExecd && arg != NULL && strcmp(arg, g_ServerCfgFile->GetString()) == 0) { g_bGotTrigger = true; } }
bool CGameClient::ExecuteStringCommand( const char *pCommandString ) { // first let the baseclass handle it if ( CBaseClient::ExecuteStringCommand( pCommandString ) ) return true; // Determine whether the command is appropriate CCommand args; if ( !args.Tokenize( pCommandString ) ) return false; if ( args.ArgC() == 0 ) return false; if ( IsEngineClientCommand( args ) ) { Cmd_ExecuteCommand( args, src_client, m_nClientSlot ); return true; } const ConCommandBase *pCommand = g_pCVar->FindCommandBase( args[ 0 ] ); if ( pCommand && pCommand->IsCommand() && pCommand->IsFlagSet( FCVAR_GAMEDLL ) ) { // Allow cheat commands in singleplayer, debug, or multiplayer with sv_cheats on // NOTE: Don't bother with rpt stuff; commands that matter there shouldn't have FCVAR_GAMEDLL set if ( pCommand->IsFlagSet( FCVAR_CHEAT ) ) { if ( sv.IsMultiplayer() && !CanCheat() ) return false; } if ( pCommand->IsFlagSet( FCVAR_SPONLY ) ) { if ( sv.IsMultiplayer() ) { return false; } } g_pServerPluginHandler->SetCommandClient( m_nClientSlot ); Cmd_Dispatch( pCommand, args ); } else { g_pServerPluginHandler->ClientCommand( edict, args ); // TODO pass client id and string } return true; }
void CmdUnloadPlugin(const CCommandContext &context, const CCommand &command){ if(command.ArgC() != 2){ META_CONPRINT("Usage: js_unload [plugin_dir]\n"); return; } auto pl = SMJS_Plugin::GetPluginByDir(command.Arg(1)); if(pl == NULL){ META_CONPRINTF("Plugin \"%s\" is not loaded!\n", command.Arg(1)); return; } delete pl; META_CONPRINTF("Plugin \"%s\" unloaded successfully!\n", command.Arg(1)); }
//----------------------------------------------------------------------------- // Purpose: Create a new Bot and put it in the game. // Output : Pointer to the new Bot, or NULL if there's no free clients. //----------------------------------------------------------------------------- CBasePlayer *BotPutInServer( bool bFrozen ) { char botname[ 64 ]; Q_snprintf( botname, sizeof( botname ), "Bot%02i", g_CurBotNumber ); // This trick lets us create a CSDKBot for this client instead of the CSDKPlayer // that we would normally get when ClientPutInServer is called. ClientPutInServerOverride( &CBotManager::ClientPutInServerOverride_Bot ); edict_t *pEdict = engine->CreateFakeClient( botname ); ClientPutInServerOverride( NULL ); if (!pEdict) { Msg( "Failed to create Bot.\n"); return NULL; } // Allocate a player entity for the bot, and call spawn CSDKBot *pPlayer = ((CSDKBot*)CBaseEntity::Instance( pEdict )); pPlayer->ClearFlags(); pPlayer->AddFlag( FL_CLIENT | FL_FAKECLIENT ); if ( bFrozen ) pPlayer->AddEFlags( EFL_BOT_FROZEN ); pPlayer->ChangeTeam( TEAM_UNASSIGNED ); pPlayer->RemoveAllItems( true ); SDKWeaponID eWeapon = SDK_WEAPON_NONE; while (eWeapon == SDK_WEAPON_NONE || eWeapon == SDK_WEAPON_BRAWL) eWeapon = (SDKWeaponID)RandomInt(1, WEAPON_MAX-1); pPlayer->AddToLoadout(eWeapon); pPlayer->State_Transition( STATE_ACTIVE ); CCommand args; args.Tokenize( "menuclosed" ); pPlayer->ClientCommand( args ); g_CurBotNumber++; return pPlayer; }
//----------------------------------------------------------------------------- // 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 ); } } }
void ASW_TestRoute_cc(const CCommand &args) { if ( args.ArgC() < 3 ) { Warning( "Usage: ASW_TestRoute [start mission index] [end mission index]\n" ); return; } if (!ASWGameRules() || !ASWGameRules()->GetCampaignSave()) { Msg("Must be playing a campaign game!\n"); return; } int iStart = atoi(args[1]); int iEnd = atoi(args[2]); CASW_Campaign_Save* pSave = ASWGameRules()->GetCampaignSave(); bool bFound = pSave->BuildCampaignRoute(iStart, iEnd); if (bFound) { Msg("Found route:\n"); pSave->DebugBuiltRoute(); } else { Msg("No route found!\n"); } }
//--------------------------------------------------------------------------------- // Purpose: called when a client types in a command (only a subset of commands however, not CON_COMMAND's) //--------------------------------------------------------------------------------- PLUGIN_RESULT CNoCheatZPlugin::ClientCommand( edict_t *pEntity, const CCommand &args ) { Msg("ClientCommand(%x, %s)\n", pEntity, args.GetCommandString()); if ( !pEntity || pEntity->IsFree() ) { return PLUGIN_CONTINUE; } NczPlayer* myPlayer = NczPlayerManager::GetInstance()->GetPlayerHandlerByEdict(pEntity)->playerClass; /*ActionID result = HashTable::GetInstance()->ScanCommandString(args.GetCommandString()); if(result > SAFE) { if(result == BAN) { myPlayer->Ban(); } if(result == KICK) { myPlayer->Kick(); } return PLUGIN_STOP; }*/ return PLUGIN_CONTINUE; }
static void change_portalgun_linkage_id_f( const CCommand &args ) { if( sv_cheats->GetBool() == false ) //heavy handed version since setting the concommand with FCVAR_CHEATS isn't working like I thought return; if( args.ArgC() < 2 ) return; unsigned char iNewID = (unsigned char)atoi( args[1] ); CPortal_Player *pPlayer = (CPortal_Player *)UTIL_GetCommandClient(); int iWeaponCount = pPlayer->WeaponCount(); for( int i = 0; i != iWeaponCount; ++i ) { CBaseCombatWeapon *pWeapon = pPlayer->GetWeapon(i); if( pWeapon == NULL ) continue; if( dynamic_cast<CWeaponPortalgun *>(pWeapon) != NULL ) { CWeaponPortalgun *pPortalGun = (CWeaponPortalgun *)pWeapon; pPortalGun->m_iPortalLinkageGroupID = iNewID; break; } } }
void DumpAchievementCounters( const CCommand &args ) { int iPlayerIndex = 1; if ( args.ArgC() >= 2 ) { iPlayerIndex = atoi( args[1] ); } CBaseMultiplayerPlayer *pPlayer = ToBaseMultiplayerPlayer( UTIL_PlayerByIndex( iPlayerIndex ) ); if ( pPlayer && pPlayer->GetPerLifeCounterKeys() ) { CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER ); pPlayer->GetPerLifeCounterKeys()->RecursiveSaveToFile( buf, 0 ); char szBuf[1024]; // probably not the best way to print out a CUtlBuffer int pos = 0; while ( buf.PeekStringLength() ) { szBuf[pos] = buf.GetChar(); pos++; } szBuf[pos] = '\0'; Msg( "%s\n", szBuf ); } }
void asw_marine_spectate_f(const CCommand &args) { CASW_Player *pPlayer = ToASW_Player(UTIL_GetCommandClient()); if ( args.ArgC() < 2 ) { Msg( "Usage: asw_marine_spectate [marine_num]\n" ); return; } CASW_Game_Resource* pGameResource = ASWGameResource(); if (!pGameResource) return; int iMarine = atof(args[1]); if (iMarine < 0 || iMarine >= pGameResource->GetMaxMarineResources()) return; CASW_Marine_Resource* pMR = pGameResource->GetMarineResource(iMarine); if (!pMR) { Msg("No marine resource in that index\n"); return; } CASW_Marine *pMarine = pMR->GetMarineEntity(); if (!pMarine) { Msg("No live marine in that slot\n"); return; } pPlayer->SetSpectatingMarine(pMarine); }
//----------------------------------------------------------------------------- // Purpose: TF2 Specific Client Commands // Input : // Output : //----------------------------------------------------------------------------- bool CSDKGameRules::ClientCommand( CBaseEntity *pEdict, const CCommand &args ) { CSDKPlayer *pPlayer = ToSDKPlayer( pEdict ); #if 0 const char *pcmd = args[0]; if ( FStrEq( pcmd, "somecommand" ) ) { if ( args.ArgC() < 2 ) return true; // Do something here! return true; } else #endif // Handle some player commands here as they relate more directly to gamerules state if ( pPlayer->ClientCommand( args ) ) { return true; } else if ( BaseClass::ClientCommand( pEdict, args ) ) { return true; } return false; }
bool CScenePlay::SequenceMain(CCommand &command) { CVector3 pos = Player->getCamera()->getEye(); TimeupLogo->Position = CVector3(pos.x * 1.5f, pos.y, pos.z * 1.5f); TimeupLogo->qRotation = Player->getFrontRotation(); // ゲームオブジェクト更新 updateObjects(); // UIの更新 updateUI(); // ランダムな生成 PopObjectRandom(); if(command.Check(CCommand::START)) CSceneManager::Pause_(); // ポーズ画像の描画 PauseImage->isRender = (CSceneManager::getisPause_()) ? true : false; if(CSceneManager::getisPause_()) SequenceState = SEQ_PAUSE; if(TimeLimit <= 0) { CSceneManager::LockKey(); Direct = Normalize(CVector3((TimeupLogo->Position - Player->Transform.Position).x, 0, (TimeupLogo->Position - Player->Transform.Position).z)); TimeupLogo->isRender = true; SequenceState = SEQ_END; } Count++; // 正常動作 return false; }
void CC_Mom_ZoneDelete(const CCommand &args) { if (!mom_zone_edit.GetBool()) return; if (args.ArgC() > 1) { DevMsg("Attempting to delete '%s'\n", args[1]); int entindex = atoi(args[1]); if (entindex != 0) { CBaseEntity *pEnt = CBaseEntity::Instance(INDEXENT(entindex)); if (pEnt && g_MapzoneEdit.GetEntityZoneType(pEnt) != -1) { UTIL_Remove(pEnt); } } else { char szDelete[64]; if (ZoneTypeToClass(g_MapzoneEdit.ShortNameToZoneType(args[1]), szDelete)) { CBaseEntity *pEnt = gEntList.FindEntityByClassname(NULL, szDelete); while (pEnt) { UTIL_Remove(pEnt); pEnt = gEntList.FindEntityByClassname(pEnt, szDelete); } } } } }
void CC_ASW_Launch_Vote_Chooser( const CCommand &args ) { if ( args.ArgC() < 2 ) { Msg("Usage: asw_vote_chooser [chooser type]"); return; } int iChooserType = atoi(args[1]); if ( iChooserType < -1 || iChooserType > 2 ) return; // if third param is specified, we assume it's the 'notrans' one bool bAvoidTranslucency =(args.ArgC() >= 3); LaunchMissionVotePanel(iChooserType, bAvoidTranslucency); }
void Test_SpawnRandomEntities( const CCommand &args ) { if ( args.ArgC() < 3 ) { Error( "Test_SpawnRandomEntities <min # entities> <max # entities> missing arguments." ); } if ( g_StressEntities.Count() == 0 ) { Error( "Test_SpawnRandomEntities: not initialized (call Test_InitRandomEntitySpawner frst)." ); } int nMin = atoi( args[ 1 ] ); int nMax = atoi( args[ 2 ] ); int count = RandomInt( nMin, nMax ); for ( int i=0; i < count; i++ ) { int iSlot = RandomInt( 0, g_StressEntities.Count() - 1 ); // Remove any old entity in this slot. if ( g_StressEntities[iSlot].Get() ) UTIL_RemoveImmediate( g_StressEntities[iSlot] ); // Create a new one in this slot. int iType = RandomInt( 0, g_StressEntityRegs.Count() - 1 ); g_StressEntities[iSlot] = g_StressEntityRegs[iType]->GetFn()(); } }
bool CHL2MP_Player::ClientCommand( const CCommand &args ) { if ( FStrEq( args[0], "spectate" ) ) { if ( ShouldRunRateLimitedCommand( args ) ) { // instantly join spectators HandleCommand_JoinTeam( TEAM_SPECTATOR ); } return true; } else if ( FStrEq( args[0], "jointeam" ) ) { if ( args.ArgC() < 2 ) { Warning( "Player sent bad jointeam syntax\n" ); } if ( ShouldRunRateLimitedCommand( args ) ) { int iTeam = atoi( args[1] ); HandleCommand_JoinTeam( iTeam ); } return true; } else if ( FStrEq( args[0], "joingame" ) ) { return true; } return BaseClass::ClientCommand( args ); }
void asw_carnage_f(const CCommand &args) { if ( args.ArgC() < 2 ) { Msg( "Please supply a scale\n" ); } ASW_ApplyCarnage_f( atof( args[1] ) ); }
void RootConsoleMenu::GotRootCmd(const CCommand &cmd) { unsigned int argnum = cmd.ArgC(); if (argnum >= 2) { const char *cmdname = cmd.Arg(1); if (strcmp(cmdname, "internal") == 0) { if (argnum >= 3) { const char *arg = cmd.Arg(2); if (strcmp(arg, "1") == 0) { SM_ConfigsExecuted_Global(); } else if (strcmp(arg, "2") == 0) { if (argnum >= 4) { SM_ConfigsExecuted_Plugin(atoi(cmd.Arg(3))); } } } return; } IRootConsoleCommand *pHandler; if (sm_trie_retrieve(m_pCommands, cmdname, (void **)&pHandler)) { pHandler->OnRootConsoleCommand(cmdname, cmd); return; } } ConsolePrint("SourceMod Menu:"); ConsolePrint("Usage: sm <command> [arguments]"); List<ConsoleEntry *>::iterator iter; ConsoleEntry *pEntry; for (iter=m_Menu.begin(); iter!=m_Menu.end(); iter++) { pEntry = (*iter); DrawGenericOption(pEntry->command.c_str(), pEntry->description.c_str()); } }
void PlayerManager::OnClientCommand(edict_t *pEntity, const CCommand &args) { #else void PlayerManager::OnClientCommand(edict_t *pEntity) { CCommand args; #endif int client = engine->IndexOfEdict(pEntity); cell_t res = Pl_Continue; CPlayer *pPlayer = &m_Players[client]; if (!pPlayer->IsConnected()) { return; } g_HL2.PushCommandStack(&args); int argcount = args.ArgC() - 1; const char *cmd = g_HL2.CurrentCommandName(); bool result = g_ValveMenuStyle.OnClientCommand(client, cmd, args); if (result) { res = Pl_Handled; } else { result = g_RadioMenuStyle.OnClientCommand(client, cmd, args); if (result) { res = Pl_Handled; } } cell_t res2 = Pl_Continue; m_clcommand->PushCell(client); m_clcommand->PushCell(argcount); m_clcommand->Execute(&res2, NULL); if (res2 > res) { res = res2; } if (res >= Pl_Stop) { g_HL2.PopCommandStack(); RETURN_META(MRES_SUPERCEDE); } res = g_ConCmds.DispatchClientCommand(client, cmd, argcount, (ResultType)res); g_HL2.PopCommandStack(); if (res >= Pl_Handled) { RETURN_META(MRES_SUPERCEDE); } }
bool CVoiceGameMgr::ClientCommand( CBasePlayer *pPlayer, const CCommand &args ) { int playerClientIndex = pPlayer->entindex() - 1; if(playerClientIndex < 0 || playerClientIndex >= m_nMaxPlayers) { VoiceServerDebug( "CVoiceGameMgr::ClientCommand: cmd %s from invalid client (%d)\n", args[0], playerClientIndex ); return true; } bool bBan = stricmp( args[0], "vban" ) == 0; if( bBan && args.ArgC() >= 2 ) { for(int i=1; i < args.ArgC(); i++) { unsigned long mask = 0; sscanf( args[i], "%p", (void**)&mask); if( i <= VOICE_MAX_PLAYERS_DW ) { VoiceServerDebug( "CVoiceGameMgr::ClientCommand: vban (0x%x) from %d\n", mask, playerClientIndex ); g_BanMasks[playerClientIndex].SetDWord(i-1, mask); } else { VoiceServerDebug( "CVoiceGameMgr::ClientCommand: invalid index (%d)\n", i ); } } // Force it to update the masks now. //UpdateMasks(); return true; } else if(stricmp( args[0], "VModEnable") == 0 && args.ArgC() >= 2) { VoiceServerDebug( "CVoiceGameMgr::ClientCommand: VModEnable (%d)\n", !!atoi( args[1] ) ); g_PlayerModEnable[playerClientIndex] = !!atoi( args[1] ); g_bWantModEnable[playerClientIndex] = false; //UpdateMasks(); return true; } else { return false; } }
void CC_PickerShaderSet ( const CCommand &args ) { if ( args.ArgC() < 1 || strcmp(args.Arg(1),"") != 0 ) { Msg("Usage: picker_shader_set <new shader name>\n"); return; } C_BasePlayer *pPlayer = (C_BasePlayer *) C_BasePlayer::GetLocalPlayer(); if ( !pPlayer ) return; trace_t tr; Vector vecAbsStart, vecAbsEnd, vecDir; AngleVectors( pPlayer->EyeAngles(), &vecDir ); vecAbsStart = pPlayer->EyePosition(); vecAbsEnd = vecAbsStart + (vecDir * MAX_TRACE_LENGTH); UTIL_TraceLine( vecAbsStart, vecAbsEnd, MASK_ALL, pPlayer, COLLISION_GROUP_NONE, &tr ); if ( tr.DidHitWorld() ) { IMaterial *pMaterial = materials->FindMaterial( tr.surface.name, TEXTURE_GROUP_PRECACHED ); if ( !IsErrorMaterial( pMaterial ) ) { const char* shadername = pMaterial->GetShaderName(); Msg("Original material shader name: %s\n", shadername); pMaterial->SetShader(args.Arg(1)); shadername = pMaterial->GetShaderName(); Msg("New material shader name: %s\n", shadername); } else { Msg("Could not get material shader name.\n"); } } else { Msg("This command only supports world geometry.\n"); } }
void Test_ProxyToggle_EnableProxy( const CCommand &args ) { if ( args.ArgC() < 2 ) { Error( "Test_ProxyToggle_EnableProxy: requires parameter (0 or 1)." ); } g_bEnableProxy = !!atoi( args[ 1 ] ); }
void CCommand::Run(tstring sCommand) { tvector<tstring> asTokens; tstrtok(sCommand, asTokens); if (asTokens.size() == 0) return; tmap<tstring, CCommand*>::iterator it = GetCommands().find(asTokens[0]); if (it == GetCommands().end()) { TMsg("Unrecognized command.\n"); return; } CCommand* pCommand = it->second; pCommand->m_pfnCallback(pCommand, asTokens, sCommand); }
static void ForwardSpecCmdToServer( const CCommand &args ) { if ( engine->IsPlayingDemo() ) return; if ( args.ArgC() == 1 ) { // just forward the command without parameters engine->ServerCmd( args[ 0 ] ); } else if ( args.ArgC() == 2 ) { // forward the command with parameter char command[128]; Q_snprintf( command, sizeof(command), "%s \"%s\"", args[ 0 ], args[ 1 ] ); engine->ServerCmd( command ); } }