CMaterialEffectsCVars::CMaterialEffectsCVars()
{
assert (s_pThis == 0);
s_pThis = this;
REGISTER_CVAR(mfx_ParticleImpactThresh, 2.0f, VF_CHEAT, "Impact threshold for particle effects. Default: 2.0" );
REGISTER_CVAR(mfx_SoundImpactThresh, 1.5f, VF_CHEAT, "Impact threshold for sound effects. Default: 1.5" );
REGISTER_CVAR(mfx_RaisedSoundImpactThresh, 3.5f, VF_CHEAT, "Impact threshold for sound effects if we're rolling. Default: 3.5" );
REGISTER_CVAR(mfx_Debug, 0, 0, "Turns on MaterialEffects debug messages. 1=Collisions, 2=Breakage, 3=Both" );
REGISTER_CVAR(mfx_DebugVisual, 0, 0, "Turns on/off visual debugging for MFX system");
mfx_DebugVisualFilter = REGISTER_STRING("mfx_DebugVisualFilter","",VF_CHEAT,"");
REGISTER_CVAR(mfx_DebugFlowGraphFX, 0, 0, "Turns on Material FlowGraph FX manager debug messages." );
REGISTER_CVAR(mfx_Enable, 1, VF_CHEAT, "Enables MaterialEffects." );
REGISTER_CVAR(mfx_pfx_minScale, .5f, 0, "Min scale (when particle is close)");
REGISTER_CVAR(mfx_pfx_maxScale, 1.5f, 0, "Max scale (when particle is far)");
REGISTER_CVAR(mfx_pfx_maxDist, 35.0f, 0, "Max dist (how far away before scale is clamped)");
REGISTER_CVAR(mfx_Timeout, 0.01f, 0, "Timeout (in seconds) to avoid playing effects too often");
REGISTER_CVAR(mfx_EnableFGEffects, 1, VF_CHEAT, "Enabled Flowgraph based Material effects. Default: On" );
REGISTER_CVAR(mfx_EnableAttachedEffects, 1, VF_CHEAT, "Enable attached effects (characters, entities...)");
REGISTER_CVAR(mfx_SerializeFGEffects, 1, VF_CHEAT, "Serialize Flowgraph based effects. Default: On" );
//FlowGraph HUD effects
REGISTER_COMMAND("mfx_ReloadFGEffects", FGEffectsReload, 0, "Reload MaterialEffect's FlowGraphs");
//Reload Excel Spreadsheet
REGISTER_COMMAND("mfx_Reload", MFXReload, 0, "Reload MFX Spreadsheet");
}
void RegisterCommands()
{
REGISTER_COMMAND( "mn_reload", MN_ReloadAll, VF_CHEAT, "Reloads animation databases" );
REGISTER_COMMAND( "mn_listAssets", MN_ListAssets, VF_CHEAT, "Lists all the currently referenced animation assets" );
REGISTER_COMMAND( "mn_DebugAI", MN_DebugAI, VF_CHEAT, "" );
REGISTER_CVAR3("mn_LogToFile", mn_logToFile, 0, VF_CHEAT, "Dumps all mann event logging to the file" );
}
SForceFeedbackSystemCVars::SForceFeedbackSystemCVars()
{
REGISTER_CVAR(ffs_debug, 0, 0, "Turns on/off force feedback system debug." );
REGISTER_COMMAND("ffs_PlayEffect", FFSPlayEffect, 0, "Play force feedback effect, passed by name as first parameter");
REGISTER_COMMAND("ffs_StopAllEffects", FFSStopAllEffects, 0, "Stop force feedback effect, passed by name as first parameter");
REGISTER_COMMAND("ffs_Reload", FFSReload, 0, "Reload force feedback system data");
}
CDownloadMgr::CDownloadMgr() :
CGameMechanismBase("DownloadMgr")
{
#if DOWNLOAD_MGR_DBG
REGISTER_COMMAND(k_dlm_list, (ConsoleCommandFunc)DbgList, 0, "Lists all the resources the download mgr knows about and their state");
REGISTER_COMMAND(k_dlm_cat, (ConsoleCommandFunc)DbgCat, 0, "Outputs the specified resource as text to the console");
REGISTER_COMMAND(k_dlm_purge, (ConsoleCommandFunc)DbgPurge, 0, "Removes any downloaded data for the specified resource");
#endif
}
//---------------------------------------
CAreaAnnouncer::CAreaAnnouncer()
{
REGISTER_CVAR(aa_peopleNeeded, aa_peopleNeeded, VF_NULL, "Number of people needed to play area announcement");
REGISTER_CVAR(aa_enabled, aa_enabled, VF_NULL, "Stops area announcements being played or updated");
#if !defined(_RELEASE)
REGISTER_CVAR(aa_debug, aa_debug, VF_NULL, "Enable/Disables Area announcer debug messages");
REGISTER_COMMAND("aa_play", CmdPlay, VF_CHEAT, "play area announcement");
REGISTER_COMMAND("aa_reload", CmdReload, VF_CHEAT, "Init area announcement");
#endif
}
void SCVars::InitCVars(IConsole *pConsole)
{
EVarFlags nullOrCheatFlag = VF_NULL;
#ifdef RELEASE
nullOrCheatFlag = VF_CHEAT;
#endif
REGISTER_CVAR(mono_exceptionsTriggerMessageBoxes, 1, VF_NULL, "If true, exceptions will trigger a message box to appear");
REGISTER_CVAR(mono_exceptionsTriggerFatalErrors, 0, VF_NULL, "If true, exceptions will trigger a fatal error");
REGISTER_CVAR(mono_realtimeScripting, 1, nullOrCheatFlag, "Enables / Disables Realtime Scripting functionality. (Editor-only)");
REGISTER_CVAR(mono_realtimeScriptingDebug, 0, nullOrCheatFlag, "Toggles on realtime scripting debug, useful for finding serialization bugs");
REGISTER_CVAR(mono_realtimeScriptingDetectChanges, 1, nullOrCheatFlag, "Toggles whether realtime scripting should automatically reload scripts when any *.cs file is modified in the scripts directory.");
REGISTER_CVAR(mono_softBreakpoints, 1, VF_REQUIRE_APP_RESTART, "[Performance Warning] Enables / Disables soft breakpoints, preventing managed null reference exceptions causing crashes in unmanaged code. \n Not supported along with -DEBUG command line option");
REGISTER_CVAR(mono_generateMdbIfPdbIsPresent, 1, VF_NULL, "Toggles on mono debug database (.mdb) generation, if a pdb file is present");
REGISTER_CVAR(mono_compileScripts, 1, nullOrCheatFlag, "Determines whether source files found in the Scripts directory will be compiled and loaded");
REGISTER_CVAR(mono_scriptDirectory, "", nullOrCheatFlag, "If set, CryMono will attempt to load its script files (e.g. *.cs) from this directory. Full path only.");
REGISTER_CVAR(mono_entityDeleteExtensionOnNetworkBindFailure, 1, nullOrCheatFlag, "If set, the game object extension will delete itself if IGameObject::BindToNetwork returns false in the IGameObjectExtension::Init function");
REGISTER_CVAR(mono_log, 0, VF_CHEAT, "");
REGISTER_COMMAND("mono_reload", CmdReload, nullOrCheatFlag, "[Realtime Scripting] Reloads / recompiles all scripts");
}
CGameTokenSystem::CGameTokenSystem()
{
CGameToken::g_pGameTokenSystem = this;
m_pScriptBind = new CScriptBind_GameToken(this);
m_pGameTokensMap = new GameTokensMap();
#ifdef _GAMETOKENSDEBUGINFO
m_debugHistory.resize( DBG_HISTORYSIZE );
ClearDebugHistory();
REGISTER_CVAR2("gt_show", &CGameTokenSystem::m_CVarShowDebugInfo, 0, 0, "Show Game Tokens debug info. 1=screen and log, 2=screen only, 3=log only");
REGISTER_CVAR2("gt_showPosX", &CGameTokenSystem::m_CVarPosX, 0, 0, "Defines the starting column in screen for game tokens debug info");
REGISTER_CVAR2("gt_showPosY", &CGameTokenSystem::m_CVarPosY, 0, 0, "Defines the starting line in screen for game tokens debug info");
REGISTER_CVAR2("gt_showLines", &CGameTokenSystem::m_CVarNumHistoricLines, DBG_HISTORYSIZE, 0, "How many lines is used by the historic list");
m_pCVarFilter = REGISTER_STRING("gt_showFilter", NULL, VF_NULL, "In the historic list only shows game tokens that include the filter string" );
REGISTER_COMMAND( "gt_AddToDebugList", AddGameTokenToDebugList, VF_CHEAT,"Adds a game token by name to the list of game tokens to be shown on screen" );
REGISTER_COMMAND( "gt_RemoveFromDebugList", RemoveGameTokenFromDebugList, VF_CHEAT,"Removes a game token by name from the list of game tokens to be shown on screen" );
#endif
}
CGameLocalizationManager::CGameLocalizationManager()
{
LoadLocalizationData();
gEnv->pSystem->GetISystemEventDispatcher()->RegisterListener(this);
#if !defined(_RELEASE)
REGISTER_COMMAND("LocalizationDumpLoadedTags", LocalizationDumpLoadedTags, VF_NULL, "Dump out into about the loaded localization tags");
#endif //#if !defined(_RELEASE)
}
OSpit::OSpit(MohawkEngine_Riven *vm) :
RivenStack(vm, kStackOspit) {
REGISTER_COMMAND(OSpit, xorollcredittime);
REGISTER_COMMAND(OSpit, xbookclick);
REGISTER_COMMAND(OSpit, xooffice30_closebook);
REGISTER_COMMAND(OSpit, xobedroom5_closedrawer);
REGISTER_COMMAND(OSpit, xogehnopenbook);
REGISTER_COMMAND(OSpit, xogehnbookprevpage);
REGISTER_COMMAND(OSpit, xogehnbooknextpage);
REGISTER_COMMAND(OSpit, xgwatch);
}
PSpit::PSpit(MohawkEngine_Riven *vm) :
DomeSpit(vm, kStackPspit, "psliders.25", "psliderbg.25") {
REGISTER_COMMAND(PSpit, xpisland990_elevcombo);
REGISTER_COMMAND(PSpit, xpscpbtn);
REGISTER_COMMAND(PSpit, xpisland290_domecheck);
REGISTER_COMMAND(PSpit, xpisland25_opencard);
REGISTER_COMMAND(PSpit, xpisland25_resetsliders);
REGISTER_COMMAND(PSpit, xpisland25_slidermd);
REGISTER_COMMAND(PSpit, xpisland25_slidermw);
}
CFeatureTestMgr::CFeatureTestMgr()
: m_runningTestIndex(),
m_pRunningTest(),
m_pAutoTester(),
m_running(),
m_pendingRunAll(),
m_pendingQuickload(),
m_pendingLevelReload(),
m_hasQuickloaded(),
m_timeWaitedForScheduled(0.0f),
m_waiting(false),
m_timeoutScheduled(0.0f),
m_testManifestWritten(false)
{
IConsole* pConsole = GetISystem()->GetIConsole();
if (pConsole)
{
REGISTER_COMMAND("ft_map_runAll", CmdMapRunAll, VF_CHEAT, "FEATURE TESTER: Run all enabled map feature tests");
REGISTER_COMMAND("ft_map_forceRun", CmdMapForceRun, VF_CHEAT, "FEATURE TESTER: Force run of the provided test (even if it's not ready)");
pConsole->RegisterAutoComplete("ft_map_forceRun", &s_featureTestMgrArgumentAutoComplete);
}
}
//-----------------------------------------------------------------------------------------------------
ScreenLayoutManager::ScreenLayoutManager( )
: m_flags(eSLO_Default)
, m_modelViewMatrix(IDENTITY)
, m_projectionMatrix(IDENTITY)
{
assert(!s_inst);
s_inst = this;
REGISTER_COMMAND("HUD_setCustomSafeArea",SetSafeArea,VF_CHEAT,"Set a custom safe area 0->1 is proportion or, >1 is an ID.");
m_curSafeAreaID = eHSAID_default;
UpdateHUDCanvasSize();
}
void SCVars::InitCVars(IConsole *pConsole)
{
REGISTER_CVAR(mono_exceptionsTriggerMessageBoxes, 1, VF_NULL, "If true, exceptions will trigger a message box to appear");
REGISTER_CVAR(mono_exceptionsTriggerFatalErrors, 0, VF_NULL, "If true, exceptions will trigger a fatal error");
REGISTER_CVAR(mono_realtimeScripting, 1, VF_NULL, "Enables / Disables Realtime Scripting functionality. (Editor-only)");
#ifndef RELEASE
REGISTER_CVAR(mono_realtimeScriptingDebug, 1, VF_NULL, "Toggles on realtime scripting debug, useful for finding serialization bugs");
#endif
REGISTER_CVAR(mono_realtimeScriptingDetectChanges, 1, VF_NULL, "Toggles whether realtime scripting should automatically reload scripts when any *.cs file is modified in the scripts directory.");
REGISTER_COMMAND("mono_reload", CmdReload, VF_NULL, "[Realtime Scripting] Reloads / recompiles all scripts");
REGISTER_CVAR(mono_softBreakpoints, 1, VF_REQUIRE_APP_RESTART, "[Performance Warning] Enables / Disables soft breakpoints, preventing managed null reference exceptions causing crashes in unmanaged code. \n Not supported along with -DEBUG command line option");
}
//===============================
void InjectModule::Initialize(shared_ptr<Game> pGame)
{
if (!pGame) return;
m_pGame = pGame;
shared_ptr<CommandHandler> pCmdHandler = pGame->GetCommandHandler();
//Register commands to the command handler.
if (pCmdHandler) {
BEGIN_REGISTER_COMMANDS(pCmdHandler);
REGISTER_COMMAND(InjectCmd);
END_REGISTER_COMMANDS();
}
}
bool CEditorGame::Init(ISystem *pSystem,IGameToEditorInterface *pGameToEditorInterface)
{
assert(pSystem);
SSystemInitParams startupParams;
startupParams.bEditor = true;
startupParams.pSystem = pSystem;
startupParams.bExecuteCommandLine=false; // in editor we do it later - after other things are initialized
m_pGameStartup = CreateGameStartup();
m_pGame = m_pGameStartup->Init(startupParams);
if (!m_pGame)
{
return false;
}
IGameFramework* pGameFramework = m_pGame->GetIGameFramework();
if ( pGameFramework != NULL )
{
pGameFramework->InitEditor( pGameToEditorInterface );
}
InitUIEnums(pGameToEditorInterface);
gEnv->bServer = true;
gEnv->bMultiplayer = false;
#if !defined(XENON) && !defined(PS3) && !defined(GRINGO)
gEnv->SetIsClient(true);
#endif
m_bUsingMultiplayerGameRules = false;
s_pEditorGameMode = REGISTER_INT( "net_gamemode", 0, 0, "Should editor connect a new client?");
s_pEditorGameMode->SetOnChangeCallback(&OnChangeEditorMode);
SetGameMode(false);
REGISTER_COMMAND( "net_reseteditorclient", ResetClient, 0, "Resets player and gamerules!" );
ConfigureNetContext(true);
return true;
}
//-------------------------------------------------------------------------
void CGameRulesStandardState::PostInit()
{
REGISTER_COMMAND("g_setgamestate", CmdSetState, VF_NULL, "Force game state (0=Reset, 1=PreGame, 2=InGame, 3=PostGame");
// Gather list of initially connecting clients to wait for before starting
if (CGameLobby* pGameLobby = g_pGame->GetGameLobby())
{
const SSessionNames &sessionNames = pGameLobby->GetSessionNames();
const int numPlayers = sessionNames.Size();
for (int i = 0; i < numPlayers; ++ i)
{
const int channelId = (int)sessionNames.m_sessionNames[i].m_conId.m_uid;
m_initialChannelIds.push_back(channelId);
CryLog("CGameRulesStandardState::PostInit(), Initial player channels, adding %d)", channelId);
}
}
}
bool CEditorGame::Init(ISystem *pSystem,IGameToEditorInterface *pGameToEditorInterface)
{
assert(pSystem);
SSystemInitParams startupParams;
FillSystemInitParams(startupParams, pSystem);
m_pGameStartup = CreateGameStartup();
m_pGame = m_pGameStartup->Init(startupParams);
if (!m_pGame)
{
return false;
}
InitUIEnums(pGameToEditorInterface);
m_pGame->GetIGameFramework()->InitEditor(pGameToEditorInterface);
m_pEquipmentSystemInterface = new CEquipmentSystemInterface(this, pGameToEditorInterface);
gEnv->bServer = true;
gEnv->bMultiplayer = false;
#if !defined(CONSOLE)
gEnv->SetIsClient(true);
#endif
m_bUsingMultiplayerGameRules = (g_pGameCVars->g_multiplayerDefault != 0);
if (IConsole* pConsole = gEnv->pConsole)
s_pEditorGameMode = REGISTER_INT_CB("net_gamemode", 0, VF_NULL, "Should editor connect a new client?", &OnChangeEditorMode);
SetGameMode(false);
REGISTER_COMMAND( "net_reseteditorclient", ResetClient, VF_NULL, "Resets player and gamerules!" );
ConfigureNetContext(true);
g_pGame->OnEditorGameInitComplete();
return true;
}
static void init()
{
REGISTER_COMMAND("test1", api::cmdflag::ALL, ([](api::cmdinfo_t info)
{
api::parser p("sd+", info);
api::send_pipe_msg(info.caller, "start");
for(int i = 0; i < p.size(); i++)
{
api::send_pipe_msg(info.caller, p[i]);
}
}));
bool ok = INVOKE_COMMANDS(api::pipe::LOG, api::cmdflag::CONFIG, " : \"echo tttt\" test1 t 1 2 3 4 5 6 7 8 9");
api::send_pipe_msgf(api::pipe::STDOUT, "%d", ok);
api::send_pipe_msg(api::pipe::STDOUT, "test {00FFFF} {FFFFFF}{000000}test");
//pawn::log << "hello" << 0 << ' ' << "world\n!!!!!" << std::endl;
}
/**
* Register DMM console commands with
* the Doom3 engine.
*/
void register_console_commands() {
#ifdef DMM_DETAIL
CONSOLE_PRINTF(CINFO "Registering console commands ...\n");
#endif
int i = 0;
while (dmm_cmds[i].cmdName) {
#ifdef DMM_DETAIL
CONSOLE_PRINTF(CINFO " Registering command: \"%s\"\n", dmm_cmds[i].cmdName);
#endif
REGISTER_COMMAND(dmm_cmds[i].cmdName, dmm_cmds[i].function, dmm_cmds[i].flags,
dmm_cmds[i].description, dmm_cmds[i].argCompletion);
++i;
}
#ifdef DMM_DETAIL
CONSOLE_PRINTF(CINFO "Attempted to register %i command%s.\n", i, GRAMMAR_PLURAL(i));
#endif
}
CCodeCheckpointDebugMgr::CCodeCheckpointDebugMgr()
:REGISTER_GAME_MECHANISM(CCodeCheckpointDebugMgr),m_timeSinceLastRun(0)
{
m_debug_ccoverage = 0;
m_debug_ccoverage_rate = 0.05f;
m_debug_ccoverage_maxlines = 10;
m_debug_ccoverage_filter_maxcount = 0;
m_debug_ccoverage_filter_mincount = 0;
REGISTER_COMMAND("ft_debug_checkpoint_search", CmdCodeCheckPointSearch, VF_CHEAT, "FEATURE TESTER: Search for code checkpoints that have been encountered by substring");
REGISTER_CVAR2("ft_debug_ccoverage", &m_debug_ccoverage, m_debug_ccoverage, VF_CHEAT, "FEATURE TESTER: Turn on debug drawing of code checkpoints. 1 = watched checkpoints only. 2 = unwatched only. 3 = both with watched higher priority. 4 = both equal prioirity");
REGISTER_CVAR2("ft_debug_ccoverage_rate", &m_debug_ccoverage_rate, m_debug_ccoverage_rate, VF_CHEAT, "FEATURE TESTER: Max number of code checkpoints to output");
REGISTER_CVAR2("ft_debug_ccoverage_maxlines", &m_debug_ccoverage_maxlines, m_debug_ccoverage_maxlines, VF_CHEAT, "FEATURE TESTER: Max number of code checkpoints to output");
REGISTER_CVAR2("ft_debug_ccoverage_filter_maxcount", &m_debug_ccoverage_filter_maxcount, m_debug_ccoverage_filter_maxcount, VF_CHEAT, "FEATURE TEST: Only print out checkpoints with less than this number of hits");
REGISTER_CVAR2("ft_debug_ccoverage_filter_mincount", &m_debug_ccoverage_filter_mincount, m_debug_ccoverage_filter_mincount, VF_CHEAT, "FEATURE TEST: Only print out checkpoints with more than this number of hit");
string filePath = PathUtil::Make( "../USER", "CodeCheckpointList.txt" );
ReadFile(filePath.c_str());
}
static void init_tcl(Tcl_Interp *interp)
{
char cwd[1024];
char *scriptdir;
/*
installation of tcl commands
*/
/* in cells.c */
REGISTER_COMMAND("cellsystem", tclcommand_cellsystem);
/* in integrate.c */
REGISTER_COMMAND("invalidate_system", tclcommand_invalidate_system);
REGISTER_COMMAND("integrate", tclcommand_integrate);
/* in global.c */
REGISTER_COMMAND("setmd", tclcommand_setmd);
/* in grid.c */
REGISTER_COMMAND("change_volume", tclcommand_change_volume);
/* in global.c */
REGISTER_COMMAND("code_info", tclcommand_code_info);
/* in interaction_data.c */
REGISTER_COMMAND("inter",tclcommand_inter);
/* in particle_data.c */
REGISTER_COMMAND("part",tclcommand_part);
/* in file binaryfile.c */
REGISTER_COMMAND("writemd", tclcommand_writemd);
REGISTER_COMMAND("readmd", tclcommand_readmd);
/* in file statistics.c */
REGISTER_COMMAND("analyze", tclcommand_analyze);
/* in file polymer.c */
REGISTER_COMMAND("polymer", tclcommand_polymer);
REGISTER_COMMAND("counterions", tclcommand_counterions);
REGISTER_COMMAND("salt", tclcommand_salt);
REGISTER_COMMAND("velocities", tclcommand_velocities);
REGISTER_COMMAND("maxwell_velocities", tclcommand_maxwell_velocities);
REGISTER_COMMAND("crosslink", tclcommand_crosslink);
REGISTER_COMMAND("diamond", tclcommand_diamond);
REGISTER_COMMAND("icosaeder", tclcommand_icosaeder);
/* in file imd.c */
REGISTER_COMMAND("imd", tclcommand_imd);
/* in file random.c */
REGISTER_COMMAND("t_random", tclcommand_t_random);
REGISTER_COMMAND("bit_random", tclcommand_bit_random);
/* in file blockfile_tcl.c */
REGISTER_COMMAND("blockfile", tclcommand_blockfile);
/* in constraint.c */
REGISTER_COMMAND("constraint", tclcommand_constraint);
/* in uwerr.c */
REGISTER_COMMAND("uwerr", tclcommand_uwerr);
/* in nemd.c */
REGISTER_COMMAND("nemd", tclcommand_nemd);
/* in thermostat.c */
REGISTER_COMMAND("thermostat", tclcommand_thermostat);
/* in bin.c */
REGISTER_COMMAND("bin", tclcommand_bin);
/* in lb.c */
REGISTER_COMMAND("lbfluid", tclcommand_lbfluid);
REGISTER_COMMAND("lbnode", tclcommand_lbnode);
REGISTER_COMMAND("lbboundary", tclcommand_lbboundary);
/* in utils.h */
REGISTER_COMMAND("replacestdchannel", tclcommand_replacestdchannel);
/* in iccp3m.h */
#ifdef ELECTROSTATICS
#ifdef ELP3M
REGISTER_COMMAND("iccp3m", tclcommand_iccp3m);
#endif
#endif
/* in adresso.h */
REGISTER_COMMAND("adress", tclcommand_adress);
#ifdef ADRESS
/** #ifdef THERMODYNAMIC_FORCE */
REGISTER_COMMAND("thermodynamic_force", tclcommand_thermodynamic_force);
/** #endif */
REGISTER_COMMAND("update_adress_weights", tclcommand_update_adress_weights);
#endif
#ifdef METADYNAMICS
/* in metadynamics.c */
REGISTER_COMMAND("metadynamics", tclcommand_metadynamics);
#endif
#ifdef LB_GPU
/* in lbgpu_cfile.c */
REGISTER_COMMAND("lbnode_exf", tclcommand_lbnode_extforce_gpu);
REGISTER_COMMAND("lbprint", tclcommand_lbprint_gpu);
#endif
#ifdef CUDA
REGISTER_COMMAND("cuda", tclcommand_cuda);
#endif
/* evaluate the Tcl initialization script */
scriptdir = getenv("ESPRESSO_SCRIPTS");
if (!scriptdir)
scriptdir = get_default_scriptsdir();
fprintf(stderr,"%d: Script directory: %s\n", this_node, scriptdir);
if ((getcwd(cwd, 1024) == NULL) || (chdir(scriptdir) != 0)) {
fprintf(stderr,
"\n\ncould not change to script dir %s, please check ESPRESSO_SCRIPTS.\n\n\n",
scriptdir);
exit(-1);
}
if (Tcl_EvalFile(interp, "init.tcl") == TCL_ERROR) {
fprintf(stderr, "\n\nerror in initialization script: %s\n\n\n",
Tcl_GetStringResult(interp));
exit(-1);
}
if (chdir(cwd) != 0) {
fprintf(stderr,
"\n\ncould not change back to execution dir %s ????\n\n\n",
cwd);
exit(-1);
}
}
ASpit::ASpit(MohawkEngine_Riven *vm) :
RivenStack(vm, kStackAspit) {
REGISTER_COMMAND(ASpit, xastartupbtnhide);
REGISTER_COMMAND(ASpit, xasetupcomplete);
REGISTER_COMMAND(ASpit, xaatrusopenbook);
REGISTER_COMMAND(ASpit, xaatrusbookback);
REGISTER_COMMAND(ASpit, xaatrusbookprevpage);
REGISTER_COMMAND(ASpit, xaatrusbooknextpage);
REGISTER_COMMAND(ASpit, xacathopenbook);
REGISTER_COMMAND(ASpit, xacathbookback);
REGISTER_COMMAND(ASpit, xacathbookprevpage);
REGISTER_COMMAND(ASpit, xacathbooknextpage);
REGISTER_COMMAND(ASpit, xtrapbookback);
REGISTER_COMMAND(ASpit, xatrapbookclose);
REGISTER_COMMAND(ASpit, xatrapbookopen);
REGISTER_COMMAND(ASpit, xarestoregame);
REGISTER_COMMAND(ASpit, xadisablemenureturn);
REGISTER_COMMAND(ASpit, xaenablemenureturn);
REGISTER_COMMAND(ASpit, xalaunchbrowser);
REGISTER_COMMAND(ASpit, xadisablemenuintro);
REGISTER_COMMAND(ASpit, xaenablemenuintro);
REGISTER_COMMAND(ASpit, xademoquit);
REGISTER_COMMAND(ASpit, xaexittomain);
}
IGameRef CGameStartup::Init(SSystemInitParams &startupParams)
{
MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Game startup initialisation");
#if defined(CVARS_WHITELIST)
startupParams.pCVarsWhitelist = &g_CVarsWhiteList;
#endif // defined(CVARS_WHITELIST)
startupParams.pGameStartup = this;
if (!InitFramework(startupParams))
{
return 0;
}
InlineInitializationProcessing("CGameStartup::Init");
LOADING_TIME_PROFILE_SECTION(m_pFramework->GetISystem());
ISystem* pSystem = m_pFramework->GetISystem();
startupParams.pSystem = pSystem;
const ICmdLineArg* pSvBind = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "sv_bind");
IConsole* pConsole = pSystem->GetIConsole();
if ((pSvBind != NULL) && (pConsole != NULL))
{
string command = pSvBind->GetName() + string(" ") + pSvBind->GetValue();
pConsole->ExecuteString(command.c_str(), true, false);
}
#if defined(ENABLE_STATS_AGENT)
const ICmdLineArg *pPipeArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"lt_pipename");
CStatsAgent::CreatePipe( pPipeArg );
#endif
REGISTER_COMMAND("g_loadMod", CGameStartupStatic::RequestLoadMod,VF_NULL,"");
REGISTER_COMMAND("g_unloadMod", CGameStartupStatic::RequestUnloadMod, VF_NULL, "");
// load the appropriate game/mod
#if !defined(_RELEASE)
const ICmdLineArg *pModArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"MOD");
#else
const ICmdLineArg *pModArg = NULL;
#endif // !defined(_RELEASE)
InlineInitializationProcessing("CGameStartup::Init LoadLocalizationData");
IGameRef pOut;
if (pModArg && (*pModArg->GetValue() != 0) && (pSystem->IsMODValid(pModArg->GetValue())))
{
const char* pModName = pModArg->GetValue();
assert(pModName);
pOut = Reset(pModName);
}
else
{
pOut = Reset(GAME_NAME);
}
if (!m_pFramework->CompleteInit())
{
pOut->Shutdown();
return 0;
}
InlineInitializationProcessing("CGameStartup::Init FrameworkCompleteInit");
// should be after init game (should be executed even if there is no game)
if(startupParams.bExecuteCommandLine)
pSystem->ExecuteCommandLine();
pSystem->GetISystemEventDispatcher()->RegisterListener(this);
// Creates and starts the realtime update system listener.
if (pSystem->IsDevMode())
{
CGameRealtimeRemoteUpdateListener::GetGameRealtimeRemoteUpdateListener().Enable(true);
}
GCOV_FLUSH;
if (ISystem *pSystem = gEnv ? GetISystem() : NULL)
{
pSystem->RegisterErrorObserver(&m_errorObsever);
pSystem->RegisterWindowMessageHandler(this);
}
else
{
CryLogAlways("failed to find ISystem to register error observer");
assert(0);
}
InlineInitializationProcessing("CGameStartup::Init End");
#if defined(CRY_UNIT_TESTING)
// Register All unit tests of this module.
#if defined(_LIB)
if(gEnv->pSystem)
{
CryUnitTest::Test *pTest = CryUnitTest::Test::m_pFirst;
for (; pTest != 0; pTest = pTest->m_pNext)
{
CryUnitTest::IUnitTestManager *pTestManager = gEnv->pSystem->GetITestSystem()->GetIUnitTestManager();
if (pTestManager)
{
pTest->m_unitTestInfo.module = "StaticBinary";
pTestManager->CreateTest( pTest->m_unitTestInfo );
}
}
}
#endif
// run unit tests
CryUnitTest::IUnitTestManager *pTestManager = (gEnv && gEnv->pSystem) ? gEnv->pSystem->GetITestSystem()->GetIUnitTestManager() : NULL;
if (pTestManager)
{
const ICmdLineArg* pSkipUnitTest = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "skip_unit_tests");
if(pSkipUnitTest == NULL)
{
const ICmdLineArg* pUseUnitTestExcelReporter = gEnv->pSystem->GetICmdLine()->FindArg(eCLAT_Pre, "use_unit_test_excel_reporter");
if(pUseUnitTestExcelReporter)
{
gEnv->pSystem->GetITestSystem()->GetIUnitTestManager()->RunAllTests(CryUnitTest::ExcelReporter);
}
else // default is the minimal reporter
{
gEnv->pSystem->GetITestSystem()->GetIUnitTestManager()->RunAllTests(CryUnitTest::MinimalReporter);
}
}
}
#endif // CRY_UNIT_TESTING
assert(gEnv);
PREFAST_ASSUME(gEnv);
GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_RANDOM_SEED, (UINT_PTR)gEnv->pTimer->GetAsyncTime().GetMicroSecondsAsInt64(), 0);
return pOut;
}
static void register_tcl_commands(Tcl_Interp* interp) {
/* in cells.cpp */
REGISTER_COMMAND("sort_particles", tclcommand_sort_particles);
REGISTER_COMMAND("cellsystem", tclcommand_cellsystem);
/* in integrate.cpp */
REGISTER_COMMAND("invalidate_system", tclcommand_invalidate_system);
REGISTER_COMMAND("integrate", tclcommand_integrate);
/* in global.cpp */
REGISTER_COMMAND("setmd", tclcommand_setmd);
/* in grid.cpp */
REGISTER_COMMAND("change_volume", tclcommand_change_volume);
/* in config_tcl.cpp */
REGISTER_COMMAND("code_info", tclcommand_code_info);
/* in interaction_data.cpp */
REGISTER_COMMAND("inter",tclcommand_inter);
/* in particle_data.cpp */
REGISTER_COMMAND("part",tclcommand_part);
/* in file binaryfile.cpp */
REGISTER_COMMAND("writemd", tclcommand_writemd);
REGISTER_COMMAND("readmd", tclcommand_readmd);
/* in file statistics.cpp */
REGISTER_COMMAND("analyze", tclcommand_analyze);
/* in file polymer.cpp */
REGISTER_COMMAND("polymer", tclcommand_polymer);
REGISTER_COMMAND("counterions", tclcommand_counterions);
REGISTER_COMMAND("salt", tclcommand_salt);
REGISTER_COMMAND("velocities", tclcommand_velocities);
REGISTER_COMMAND("maxwell_velocities", tclcommand_maxwell_velocities);
REGISTER_COMMAND("crosslink", tclcommand_crosslink);
REGISTER_COMMAND("diamond", tclcommand_diamond);
REGISTER_COMMAND("icosaeder", tclcommand_icosaeder);
/* in file imd.cpp */
REGISTER_COMMAND("imd", tclcommand_imd);
/* in file random.cpp */
REGISTER_COMMAND("t_random", tclcommand_t_random);
REGISTER_COMMAND("bit_random", tclcommand_bit_random);
/* in file blockfile_tcl.cpp */
REGISTER_COMMAND("blockfile", tclcommand_blockfile);
/* in constraint.cpp */
REGISTER_COMMAND("constraint", tclcommand_constraint);
/* in external_potential.hpp */
REGISTER_COMMAND("external_potential", tclcommand_external_potential);
/* in uwerr.c */
REGISTER_COMMAND("uwerr", tclcommand_uwerr);
/* in nemd.cpp */
REGISTER_COMMAND("nemd", tclcommand_nemd);
/* in thermostat.cpp */
REGISTER_COMMAND("thermostat", tclcommand_thermostat);
/* in bin.cpp */
REGISTER_COMMAND("bin", tclcommand_bin);
/* in ghmc.cpp */
REGISTER_COMMAND("ghmc", tclcommand_ghmc);
REGISTER_COMMAND("save_state", tclcommand_save_state);
REGISTER_COMMAND("load_state", tclcommand_load_state);
/* in lb.cpp */
REGISTER_COMMAND("lbfluid", tclcommand_lbfluid);
REGISTER_COMMAND("lbnode", tclcommand_lbnode);
REGISTER_COMMAND("lbboundary", tclcommand_lbboundary);
/* here */
REGISTER_COMMAND("replacestdchannel", tclcommand_replacestdchannel);
/* in iccp3m.hpp */
REGISTER_COMMAND("observable", tclcommand_observable);
/* in statistics_obsrvable.hpp */
REGISTER_COMMAND("correlation", tclcommand_correlation);
/* in statistics_correlation.hpp */
#ifdef ELECTROSTATICS
#ifdef P3M
REGISTER_COMMAND("iccp3m", tclcommand_iccp3m);
#endif
REGISTER_COMMAND("efield_caps", tclcommand_print_efield_capacitors);
#endif
#ifdef METADYNAMICS
/* in metadynamics.cpp */
REGISTER_COMMAND("metadynamics", tclcommand_metadynamics);
#endif
#ifdef LB_GPU
/* in lbgpu_cfile.cpp */
REGISTER_COMMAND("lbnode_extforce", tclcommand_lbnode_extforce_gpu);
#endif
#ifdef CUDA
REGISTER_COMMAND("cuda", tclcommand_cuda);
#endif
/* from collision.cpp */
#ifdef COLLISION_DETECTION
REGISTER_COMMAND("on_collision", tclcommand_on_collision);
#endif
#ifdef CATALYTIC_REACTIONS
REGISTER_COMMAND("reaction", tclcommand_reaction);
#endif
REGISTER_COMMAND("kill_particle_motion", tclcommand_kill_particle_motion);
REGISTER_COMMAND("kill_particle_forces", tclcommand_kill_particle_forces);
REGISTER_COMMAND("system_CMS", tclcommand_system_CMS);
REGISTER_COMMAND("system_CMS_velocity", tclcommand_system_CMS_velocity);
REGISTER_COMMAND("galilei_transform", tclcommand_galilei_transform);
REGISTER_COMMAND("time_integration", tclcommand_time_integration);
REGISTER_COMMAND("electrokinetics", tclcommand_electrokinetics);
#ifdef CUDA
REGISTER_COMMAND("harmonic_well", tclcommand_HarmonicWell);
#endif
}
BSpit::BSpit(MohawkEngine_Riven *vm) :
DomeSpit(vm, kStackBspit, "bSliders.190", "bSliderBG.190") {
REGISTER_COMMAND(BSpit, xblabopenbook);
REGISTER_COMMAND(BSpit, xblabbookprevpage);
REGISTER_COMMAND(BSpit, xblabbooknextpage);
REGISTER_COMMAND(BSpit, xsoundplug);
REGISTER_COMMAND(BSpit, xbchangeboiler);
REGISTER_COMMAND(BSpit, xbupdateboiler);
REGISTER_COMMAND(BSpit, xbsettrap);
REGISTER_COMMAND(BSpit, xbcheckcatch);
REGISTER_COMMAND(BSpit, xbait);
REGISTER_COMMAND(BSpit, xbfreeytram);
REGISTER_COMMAND(BSpit, xbaitplate);
REGISTER_COMMAND(BSpit, xbisland190_opencard);
REGISTER_COMMAND(BSpit, xbisland190_resetsliders);
REGISTER_COMMAND(BSpit, xbisland190_slidermd);
REGISTER_COMMAND(BSpit, xbisland190_slidermw);
REGISTER_COMMAND(BSpit, xbscpbtn);
REGISTER_COMMAND(BSpit, xbisland_domecheck);
REGISTER_COMMAND(BSpit, xvalvecontrol);
REGISTER_COMMAND(BSpit, xbchipper);
}
void CScriptbind_Console::RegisterCommand(mono::string cmd, mono::string desc, EVarFlags flags)
{
REGISTER_COMMAND(ToCryString(cmd), OnMonoCmd, flags, ToCryString(desc));
}
void CVar::Init( struct IConsole *pConsole )
{
assert(gEnv->pConsole);
PREFAST_ASSUME(gEnv->pConsole);
REGISTER_COMMAND("es_dump_entities", (ConsoleCommandFunc)DumpEntities, 0, "Dumps current entities and their states!");
REGISTER_COMMAND("es_dump_entity_classes_in_use", (ConsoleCommandFunc)DumpEntityClassesInUse, 0, "Dumps all used entity classes");
REGISTER_COMMAND("es_compile_area_grid", (ConsoleCommandFunc)CompileAreaGrid, 0, "Trigger a recompile of the area grid");
REGISTER_COMMAND("es_dump_bookmarks", (ConsoleCommandFunc)DumpEntityBookmarks, 0, "Dumps information about all bookmarked entities");
REGISTER_COMMAND("es_AudioListenerOffset", (ConsoleCommandFunc)SetAudioListenerOffsets, 0,
"Sets by how much the audio listener offsets its position and rotation in regards to its entity.\n"
"Usage: es_AudioListenerOffset PosX PosY PosZ RotX RotY RotZ\n");
REGISTER_CVAR( es_SortUpdatesByClass, 0, 0, "Sort entity updates by class (possible optimization)" );
pDebug = REGISTER_INT("es_debug",0,VF_CHEAT,
"Enable entity debugging info\n"
"Usage: es_debug [0/1]\n"
"Default is 0 (on).");
pCharacterIK = REGISTER_INT("p_CharacterIK",1,VF_CHEAT,
"Toggles character IK.\n"
"Usage: p_characterik [0/1]\n"
"Default is 1 (on). Set to 0 to disable inverse kinematics.");
pEntityBBoxes = REGISTER_INT("es_bboxes",0,VF_CHEAT,
"Toggles entity bounding boxes.\n"
"Usage: es_bboxes [0/1]\n"
"Default is 0 (off). Set to 1 to display bounding boxes.");
pEntityHelpers = REGISTER_INT("es_helpers",0,VF_CHEAT,
"Toggles helpers.\n"
"Usage: es_helpers [0/1]\n"
"Default is 0 (off). Set to 1 to display entity helpers.");
pProfileEntities = REGISTER_INT("es_profileentities",0,VF_CHEAT,
"Usage: es_profileentities 1,2,3\n"
"Default is 0 (off).");
/* pUpdateInvisibleCharacter = REGISTER_INT("es_UpdateInvisibleCharacter",0,VF_CHEAT,
"Usage: \n"
"Default is 0 (off).");
pUpdateBonePositions = REGISTER_INT("es_UpdateBonePositions",1,VF_CHEAT,
"Usage: \n"
"Default is 1 (on).");
*/ pUpdateScript = REGISTER_INT("es_UpdateScript",1,VF_CHEAT,
"Usage: es_UpdateScript [0/1]\n"
"Default is 1 (on).");
pUpdatePhysics = REGISTER_INT("es_UpdatePhysics",1,VF_CHEAT,
"Toggles updating of entity physics.\n"
"Usage: es_UpdatePhysics [0/1]\n"
"Default is 1 (on). Set to 0 to prevent entity physics from updating.");
pUpdateAI = REGISTER_INT("es_UpdateAI",1,VF_CHEAT,
"Toggles updating of AI entities.\n"
"Usage: es_UpdateAI [0/1]\n"
"Default is 1 (on). Set to 0 to prevent AI entities from updating.");
pUpdateEntities = REGISTER_INT("es_UpdateEntities",1,VF_CHEAT,
"Toggles entity updating.\n"
"Usage: es_UpdateEntities [0/1]\n"
"Default is 1 (on). Set to 0 to prevent all entities from updating.");
pUpdateCollision= REGISTER_INT("es_UpdateCollision",1,VF_CHEAT,
"Toggles updating of entity collisions.\n"
"Usage: es_UpdateCollision [0/1]\n"
"Default is 1 (on). Set to 0 to disable entity collision updating.");
pUpdateContainer= REGISTER_INT("es_UpdateContainer",1,VF_CHEAT,
"Usage: es_UpdateContainer [0/1]\n"
"Default is 1 (on).");
pUpdateTimer = REGISTER_INT("es_UpdateTimer",1,VF_CHEAT,
"Usage: es_UpdateTimer [0/1]\n"
"Default is 1 (on).");
pUpdateCollisionScript = REGISTER_INT("es_UpdateCollisionScript",1,VF_CHEAT,
"Usage: es_UpdateCollisionScript [0/1]\n"
"Default is 1 (on).");
pVisCheckForUpdate = REGISTER_INT("es_VisCheckForUpdate",1,VF_CHEAT,
"Usage: es_VisCheckForUpdate [0/1]\n"
"Default is 1 (on).");
pMinImpulseVel = REGISTER_FLOAT("es_MinImpulseVel",0.0f,VF_CHEAT,
"Usage: es_MinImpulseVel 0.0");
pImpulseScale = REGISTER_FLOAT("es_ImpulseScale",0.0f,VF_CHEAT,
"Usage: es_ImpulseScale 0.0");
pMaxImpulseAdjMass = REGISTER_FLOAT("es_MaxImpulseAdjMass",2000.0f,VF_CHEAT,
"Usage: es_MaxImpulseAdjMass 2000.0");
pDebrisLifetimeScale = REGISTER_FLOAT("es_DebrisLifetimeScale",1.0f,0,
"Usage: es_DebrisLifetimeScale 1.0");
pSplashThreshold = REGISTER_FLOAT("es_SplashThreshold",1.0f,VF_CHEAT,
"minimum instantaneous water resistance that is detected as a splash"
"Usage: es_SplashThreshold 200.0");
pSplashTimeout = REGISTER_FLOAT("es_SplashTimeout",3.0f,VF_CHEAT,
"minimum time interval between consecutive splashes"
"Usage: es_SplashTimeout 3.0");
pHitCharacters = REGISTER_INT("es_HitCharacters",1,0,
"specifies whether alive characters are affected by bullet hits (0 or 1)");
pHitDeadBodies = REGISTER_INT("es_HitDeadBodies",1,0,
"specifies whether dead bodies are affected by bullet hits (0 or 1)");
pCharZOffsetSpeed = REGISTER_FLOAT("es_CharZOffsetSpeed",2.0f,VF_DUMPTODISK,
"sets the character Z-offset change speed (in m/s), used for IK");
pNotSeenTimeout = REGISTER_INT("es_not_seen_timeout", 30, VF_DUMPTODISK,
"number of seconds after which to cleanup temporary render buffers in entity");
pDebugNotSeenTimeout = REGISTER_INT("es_debug_not_seen_timeout", 0, VF_DUMPTODISK,
"if true, log messages when entities undergo not seen timeout");
pEnableFullScriptSave = REGISTER_INT("es_enable_full_script_save",0,
VF_DUMPTODISK,"Enable (experimental) full script save functionality");
pLogCollisions = REGISTER_INT("es_log_collisions",0,0,"Enables collision events logging" );
REGISTER_CVAR(es_DebugTimers,0,VF_CHEAT,
"This is for profiling and debugging (for game coders and level designer)\n"
"By enabling this you get a lot of console printouts that show all entities that receive OnTimer\n"
"events - it's good to minimize the call count. Certain entities might require this feature and\n"
"using less active entities can often be defined by the level designer.\n"
"Usage: es_DebugTimers 0/1");
REGISTER_CVAR(es_DebugFindEntity,0,VF_CHEAT,"" );
REGISTER_CVAR(es_DebugEvents,0,VF_CHEAT,"Enables logging of entity events" );
REGISTER_CVAR(es_DisableTriggers,0,0,"Disable enter/leave events for proximity and area triggers");
REGISTER_CVAR(es_DrawProximityTriggers,0,0,
"Shows Proximity Triggers.\n"
"Usage: es_DrawProximityTriggers [0-255]. The parameter sets the transparency (alpha) level.\n"
"Value 1 will be changed to 70.\n"
"Default is 0 (off)\n");
REGISTER_CVAR(es_DebugEntityUsage,0,0,
"Draws information to the screen to show how entities are being used, per class, including total, active and hidden counts and memory usage"
"\nUsage: es_DebugEntityUsage update_rate"
"\nupdate_rate - Time in ms to refresh memory usage calculation or 0 to disable");
REGISTER_CVAR(es_DebugEntityUsageFilter,"",0,"Filter entity usage debugging to classes which have this string in their name");
REGISTER_CVAR(es_EnablePoolUse,-1,0,
"Force toggle the use of entity pools on/off.\n"
"Usage: es_EnablePoolUse 1\n"
"Default is -1, or normal behavior. 0 forces system off. 1 forces system on.");
REGISTER_CVAR(es_DebugPool,0,0,"Enable debug drawing of entity pools");
REGISTER_CVAR(es_TestPoolSignatures,0,VF_CHEAT,"Enable signature testing on entity classes the first time they're prepared from an entity pool");
REGISTER_CVAR(es_DebugPoolFilter,"",0,"Filter entity pool debugging for just this pool and draw more info about it");
REGISTER_CVAR(es_LayerSaveLoadSerialization, 0, VF_CHEAT,
"Switches layer entity serialization: \n"
"0 - serialize all \n"
"1 - automatically ignore entities on disabled layers \n"
"2 - only ignore entities on non-save layers.");
REGISTER_CVAR(es_LayerDebugInfo, 0, VF_CHEAT,
"Render debug info on active layers: \n"
"0 - inactive \n"
"1 - active brush layers \n"
"2 - all layer info \n"
"3 - all layer and all layer pak info");
REGISTER_CVAR(es_SaveLoadUseLUANoSaveFlag, 0, VF_CHEAT, "Save&Load optimization : use lua flag to not serialize entities, for example rigid bodies.");
REGISTER_CVAR(es_ClearPoolBookmarksOnLayerUnload, 1, VF_CHEAT, "Clear pool bookmarks when a layer is unloaded (saves memory and makes smaller saves)");
pUpdateType = REGISTER_INT_CB("es_updateType", CComponentEventDistributer::EEventUpdatePolicy_UseDistributer, VF_CHEAT, "Defines how we update type for the entities", OnUpdateTypeChange);
pDrawAreas = REGISTER_INT("es_DrawAreas",0,VF_CHEAT,"Enables drawing of Areas" );
pDrawAreaGrid = REGISTER_INT("es_DrawAreaGrid",0,VF_CHEAT,"Enables drawing of Area Grid" );
pDrawAreaDebug = REGISTER_INT("es_DrawAreaDebug",0,VF_CHEAT,"Enables debug drawing of Areas, set 2 for log details" );
pDrawAudioProxyZRay = REGISTER_INT("es_DrawAudioProxyZRay",0,VF_CHEAT,"Enables drawing of Z ray on check for Z visibility" );
REGISTER_CVAR(es_UsePhysVisibilityChecks, 1, 0,
"Activates physics quality degradation and forceful sleeping for invisible and faraway entities" );
REGISTER_CVAR(es_MaxPhysDist, 300.0f, 0,
"Physical entities farther from the camera than this are forcefully deactivated" );
REGISTER_CVAR(es_MaxPhysDistCloth, 300.0f, 0,
"Cloth entities farther from the camera than this are forcefully deactivated" );
REGISTER_CVAR(es_MaxPhysDistInvisible, 40.0f, 0,
"Invisible physical entities farther from the camera than this are forcefully deactivated" );
REGISTER_CVAR(es_FarPhysTimeout, 4.0f, 0,
"Timeout for faraway physics forceful deactivation" );
pMotionBlur = gEnv->pConsole->GetCVar("r_MotionBlur");
pSysSpecLight = gEnv->pConsole->GetCVar("sys_spec_light");
if (pSysSpecLight && gEnv->IsEditor())
pSysSpecLight->SetOnChangeCallback( OnSysSpecLightChange );
REGISTER_CVAR(es_debugEntityLifetime,0,0,
"Debug entities creation and deletion time" );
REGISTER_COMMAND("es_debugAnim", (ConsoleCommandFunc)EnableDebugAnimText, 0, "Debug entity animation (toggle on off)");
REGISTER_CVAR(es_EntityUpdatePosDelta, 0.1f, 0,
"Indicates the position delta by which an entity must move before the AreaManager updates position relevant data.\n"
"Default: 0.1 (10 cm)");
REGISTER_CVAR(es_debugDrawEntityIDs, 0, VF_CHEAT,
"Displays the EntityId of all entities.\n"
"Default is 0 (off), any other number enables it.\n"
"Note: es_debug must be set to 1 also (or else the EntityId won't be displayed)");
}
IGameRef CGameStartup::Init(SSystemInitParams &startupParams)
{
MEMSTAT_CONTEXT(EMemStatContextTypes::MSC_Other, 0, "Game startup initialization");
LOADING("game_startup");
if (!InitFramework(startupParams))
{
return 0;
}
// Configuration for this game
ICVar *pCVar = gEnv->pConsole->GetCVar("ai_CompatibilityMode");
if (pCVar)
pCVar->Set("crysis");
LOADING_TIME_PROFILE_SECTION(m_pFramework->GetISystem());
ISystem* pSystem = m_pFramework->GetISystem();
IConsole* pConsole = gEnv->pConsole;
startupParams.pSystem = pSystem;
#if defined(ENABLE_STATS_AGENT)
const ICmdLineArg *pPipeArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"lt_pipename");
CStatsAgent::CreatePipe( pPipeArg );
#endif
PluginManager::InitPluginManager(startupParams);
PluginManager::InitPluginsBeforeFramework();
REGISTER_COMMAND("g_loadMod", RequestLoadMod,VF_NULL,"");
// load the appropriate game/mod
const ICmdLineArg *pModArg = pSystem->GetICmdLine()->FindArg(eCLAT_Pre,"MOD");
IGameRef pOut;
if (pModArg && (*pModArg->GetValue() != 0) && (pSystem->IsMODValid(pModArg->GetValue())))
{
const char* pModName = pModArg->GetValue();
assert(pModName);
pOut = Reset(pModName);
}
else
{
pOut = Reset(GAME_NAME);
}
// Load all localized strings.
LoadLocalizationData();
if (!m_pFramework->CompleteInit())
{
pOut->Shutdown();
return 0;
}
LOADING_DONE;
// should be after init game (should be executed even if there is no game)
if(startupParams.bExecuteCommandLine)
pSystem->ExecuteCommandLine();
pSystem->GetISystemEventDispatcher()->RegisterListener( &g_system_event_listener_game );
// Creates and starts the realtime update system listener.
if (pSystem->IsDevMode())
{
CGameRealtimeRemoteUpdateListener::GetGameRealtimeRemoteUpdateListener().Enable(true);
}
GCOV_FLUSH;
if (gEnv && GetISystem())
{
}
else
{
CryLogAlways("failed to find ISystem to register error observer");
assert(0);
}
PluginManager::InitPluginsLast();
return pOut;
}
void CGameAIRecorderCVars::RegisterCommands()
{
REGISTER_COMMAND("comment", CmdAIRecorderAddComment, 0, "Add a comment to the AI Recorder");
}
//------------------------------------------------------------------------
CVehicleCVars::CVehicleCVars()
{
assert (s_pThis == 0);
s_pThis = this;
IConsole *pConsole = gEnv->pConsole;
assert(pConsole);
#if ENABLE_VEHICLE_DEBUG
// debug draw
REGISTER_STRING("v_debugVehicle", "", 0, "Vehicle entity name to use for debugging output");
REGISTER_CVAR_CB(v_draw_components, 0, VF_DUMPTODISK, "Enables/disables display of components and their damage count", OnDebugDrawVarChanged);
REGISTER_CVAR_CB(v_draw_helpers, 0, 0, "Enables/disables display of vehicle helpers", OnDebugDrawVarChanged);
REGISTER_CVAR_CB(v_draw_seats, 0, 0, "Enables/disables display of seat positions", OnDebugDrawVarChanged);
REGISTER_CVAR(v_draw_tm, 0, 0, "Enables/disables drawing of local part matrices");
REGISTER_CVAR(v_draw_passengers, 0, VF_CHEAT, "draw passenger TMs set by VehicleSeat");
REGISTER_CVAR(v_debugdraw, 0, VF_DUMPTODISK,
"Displays vehicle status info on HUD\n"
"Values:\n"
"1: common stuff\n"
"2: vehicle particles\n"
"3: parts\n"
"4: views\n"
"6: parts + partIds\n"
"7: parts + transformations and bboxes\n"
"8: component damage\n"
"10: vehicle editor");
REGISTER_CVAR(v_debug_mem, 0, 0, "display memory statistic for vehicles");
REGISTER_CVAR_CB(v_debugView, 0, VF_CHEAT|VF_DUMPTODISK, "Activate a 360 degree rotating third person camera instead of the camera usually available on the vehicle class", OnDebugViewVarChanged);
REGISTER_CVAR(v_debugViewDetach, 0, VF_CHEAT|VF_DUMPTODISK, "Freeze vehicle camera position, (1) fixed rotation, (2) track the vehicle");
REGISTER_CVAR(v_debugViewAbove, 0, VF_CHEAT|VF_DUMPTODISK, "Debug camera, looking down on vehicle");
REGISTER_CVAR(v_debugViewAboveH, 10.f, VF_CHEAT|VF_DUMPTODISK, "Debug camera, looking down on vehicle, height ");
REGISTER_CVAR(v_debugCollisionDamage, 0, VF_CHEAT, "Enable debug output for vehicle collisions");
REGISTER_CVAR(v_debug_flip_over, 0, VF_CHEAT, "flip over the current vehicle that the player is driving");
REGISTER_CVAR(v_debug_reorient, 0, VF_CHEAT, "reset the orientation of the vehicle that the player is driving so that it is upright again");
REGISTER_COMMAND("v_dump_classes", CVehicleSystem::DumpClasses, 0, "Outputs a list of vehicle classes in use");
#endif
// dev vars
REGISTER_CVAR(v_lights, 2, 0, "Controls vehicle lights.\n"
"0: disable all lights\n"
"1: enable lights only for local player\n"
"2: enable all lights");
REGISTER_CVAR(v_lights_enable_always, 0, VF_CHEAT, "Vehicle lights are always on (debugging)");
REGISTER_CVAR(v_autoDisable, 1, VF_CHEAT, "Enables/disables vehicle autodisabling");
REGISTER_CVAR(v_set_passenger_tm, 1, VF_CHEAT, "enable/disable passenger entity tm update");
REGISTER_CVAR(v_disable_hull, 0, 0, "Disable hull proxies");
REGISTER_CVAR(v_treadUpdateTime, 0, 0, "delta time for tread UV update, 0 means always update");
REGISTER_CVAR(v_show_all, 0, VF_CHEAT, "");
REGISTER_CVAR(v_transitionAnimations, 1, VF_CHEAT, "Enables enter/exit transition animations for vehicles");
REGISTER_CVAR(v_playerTransitions, 1, VF_CHEAT, "Enables enter/exit transition animations for vehicles");
REGISTER_CVAR(v_ragdollPassengers, 0, VF_CHEAT, "Forces vehicle passenger to detach and ragdoll when they die inside of a vehicle");
REGISTER_CVAR(v_goliathMode, 0, VF_CHEAT, "Makes all vehicles invincible");
REGISTER_CVAR(v_enableMannequin, 1, VF_CHEAT, "Enables enter/exit transition animations for vehicles");
// #AfroStalin . This fix physics lags in multiplayer. Use this dll in GameServer and Clients.
REGISTER_CVAR(v_serverControlled, 0, VF_CHEAT|VF_REQUIRE_LEVEL_RELOAD, "Makes the vehicles server authoritative, clients only send inputs to the server who then drives the vehicles");
//
REGISTER_CVAR(v_clientPredict, 1, VF_CHEAT, "Enable client-side prediction on vehicle movement");
REGISTER_CVAR(v_clientPredictSmoothing, 1, VF_CHEAT, "Enable client-side prediction smoothing on vehicle movement");
REGISTER_CVAR(v_testClientPredict, 0, VF_CHEAT, "Test client-side prediction on a listen server with no clients, the value represents the number of frames to rewind and replay");
REGISTER_CVAR(v_clientPredictSmoothingConst, 8.0f, VF_CHEAT, "The amount of smoothing to use, lower values result in smoothing looking movement but more lag behind the true position");
REGISTER_CVAR(v_clientPredictAdditionalTime, 0.033f, VF_CHEAT, "Additional time offset to calibrate client prediction, will be added to ping and p_net_interp cvar");
REGISTER_CVAR(v_clientPredictMaxTime, 0.5f, VF_CHEAT, "The maximum time the client can predict ahead of the server position (should be roughly equal to the maximum ping we expect in the real world)");
// for tweaking
REGISTER_CVAR(v_slipSlopeFront, 0.f, VF_CHEAT, "coefficient for slip friction slope calculation (front wheels)");
REGISTER_CVAR(v_slipSlopeRear, 0.f, VF_CHEAT, "coefficient for slip friction slope calculation (rear wheels)");
REGISTER_CVAR(v_slipFrictionModFront, 0.f, VF_CHEAT, "if non-zero, used as slip friction modifier (front wheels)");
REGISTER_CVAR(v_slipFrictionModRear, 0.f, VF_CHEAT, "if non-zero, used as slip friction modifier (rear wheels)");
REGISTER_CVAR(v_FlippedExplosionTimeToExplode, 20.f, VF_CHEAT, "The number of seconds to wait after a vehicle is flipped to attempt exploding");
REGISTER_CVAR(v_FlippedExplosionPlayerMinDistance, 25.f, VF_CHEAT, "If a player is within this distance then don't explode yet");
REGISTER_CVAR(v_FlippedExplosionRetryTimeMS, 10000, VF_CHEAT, "If a nearby player blocked explosion then try again after this time period");
REGISTER_COMMAND("v_reload_system", "VehicleSystem.ReloadVehicleSystem()", 0, "Reloads VehicleSystem script");
REGISTER_COMMAND("v_exit_player", CmdExitPlayer, VF_CHEAT, "Makes the local player exit his current vehicle.");
REGISTER_CVAR(v_disableEntry, 0, 0, "Don't allow players to enter vehicles");
REGISTER_CVAR(v_vehicle_quality, 4, 0, "Geometry/Physics quality (1-lowspec, 4-highspec)");
REGISTER_CVAR_CB(v_driverControlledMountedGuns, 1, VF_CHEAT, "Specifies if the driver can control the vehicles mounted gun when driving without gunner.", OnDriverControlledGunsChanged);
REGISTER_CVAR(v_independentMountedGuns, 1, 0, "Whether mounted gunners operate their turret independently from the parent vehicle");
REGISTER_CVAR(v_debugSuspensionIK, 0, 0, "Debug draw the suspension ik");
}
