CBasicEventListener::EAction CBasicEventListener::OnSysKeyDown(HWND hWn, WPARAM wParam, LPARAM lParam)
{
if (wParam != VK_RETURN && wParam != VK_F4)
{
return eA_None;
}
else
{
if (wParam == VK_RETURN && (lParam & (1<<29)) != 0)
{
if (gEnv && gEnv->pRenderer)
{
ICVar *pVar = gEnv->pConsole->GetCVar("r_Fullscreen");
if (pVar)
{
if(IPlayerProfileManager *pPlayerProfileManager = gEnv->pGame->GetIGameFramework()->GetIPlayerProfileManager())
{
if(const char *pCurrentUser = pPlayerProfileManager->GetCurrentUser())
{
int fullscreen = pVar->GetIVal();
pVar->Set((int)(fullscreen == 0));
IPlayerProfileManager::EProfileOperationResult result;
pPlayerProfileManager->SaveProfile(pCurrentUser, result, ePR_Options);
}
}
}
}
}
// let the F4 pass through to default handler (it will send an WM_CLOSE)
}
return eA_Default;
}
void CGameStartup::HandleResizeForVOIP(WPARAM wparam)
{
if(gEnv->pConsole)
{
ICVar * pVOIPCvar = gEnv->pConsole->GetCVar("net_blaze_voip_enable");
if(pVOIPCvar)
{
if(wparam == SIZE_RESTORED || wparam == SIZE_MAXIMIZED)
{
int currentVal = pVOIPCvar->GetIVal();
if(m_nVOIPWasActive == -1)
{
m_nVOIPWasActive = currentVal;
}
if(m_nVOIPWasActive != currentVal)
{
pVOIPCvar->Set(m_nVOIPWasActive);
}
CryLog("[VOIP] Game maximized or restored, VOIP was set to %d, saved value %d - now restored", currentVal, m_nVOIPWasActive);
}
else if(wparam == SIZE_MINIMIZED)
{
m_nVOIPWasActive = pVOIPCvar->GetIVal();
pVOIPCvar->Set(0);
CryLog("[VOIP] Game minimized, VOIP was set to %d, setting to 0 while minimized", m_nVOIPWasActive);
}
}
}
}
void CStereoZoom::PrintDebugOutput()
{
ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoScreenDist");
float dist;
if ( pICVar != NULL)
{
dist = pICVar->GetFVal();
}
else
{
dist = -10.f;
}
pICVar = gEnv->pConsole->GetCVar("r_StereoEyeDist");
float eyedist;
if ( pICVar != NULL)
{
eyedist = pICVar->GetFVal();
}
else
{
eyedist = -10.f;
}
IRenderer* pRenderer = gEnv->pRenderer;
static float color[4] = {1,1,1,1};
float y=50.f, step1=15.f, step2=20.f, size1=1.3f, size2=1.5f;
pRenderer->Draw2dLabel(5.0f, y , size2, color, false, "Current PlaneDist: %f", dist);
pRenderer->Draw2dLabel(5.0f, y += step1, size2, color, false, "Current EyeDist : %f", eyedist);
}
//------------------------------------------------------------------------
// override values with console player profile defaults
void CPlayerProfile::LoadGamerProfileDefaults()
{
ICVar* pSysSpec = gEnv->pConsole->GetCVar("sys_spec");
if (pSysSpec && !(pSysSpec->GetFlags() & VF_WASINCONFIG))
{
gEnv->pSystem->AutoDetectSpec(true);
}
IPlatformOS::SUserProfileVariant preference;
IPlatformOS::TUserName userName = GetName();
unsigned int user;
if(gEnv->pSystem->GetPlatformOS()->UserIsSignedIn(userName, user) && user != IPlatformOS::Unknown_User)
{
if(gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_CONTROLLER_INVERT_Y, preference))
{
TFlowInputData value(preference.GetInt());
SetAttribute("InvertY", value);
}
if(gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_CONTROLLER_SENSITIVITY, preference))
{
TFlowInputData value(preference.GetFloat());
SetAttribute("Sensitivity", value);
}
if(gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_GAME_DIFFICULTY, preference))
{
TFlowInputData value(preference.GetInt());
SetAttribute("SP/Difficulty", value);
}
if(gEnv->pSystem->GetPlatformOS()->GetUserProfilePreference(user, IPlatformOS::EUPP_AIM_ASSIST, preference))
{
TFlowInputData value(preference.GetInt());
SetAttribute("AimAssistance", value);
}
}
}
//--------------------------------------------------------------------------------------------------
// Name: CBreakableGlassSystem
// Desc: Constructor
//--------------------------------------------------------------------------------------------------
CBreakableGlassSystem::CBreakableGlassSystem()
: m_enabled(false)
{
// Add physics callback
if (IPhysicalWorld* pPhysWorld = gEnv->pPhysicalWorld)
{
const float listenerPriority = 2001.0f;
pPhysWorld->AddEventClient(EventPhysCollision::id, &CBreakableGlassSystem::HandleImpact, 1, listenerPriority);
}
// Hook up debug cvars
if (m_pGlassCVars = new SBreakableGlassCVars())
{
#ifdef GLASS_DEBUG_MODE
// Rendering
REGISTER_CVAR2("g_glassSystem_draw", &m_pGlassCVars->m_draw, 1, VF_CHEAT, "Toggles drawing of glass nodes");
REGISTER_CVAR2("g_glassSystem_drawWireframe", &m_pGlassCVars->m_drawWireframe, 0, VF_CHEAT, "Toggles drawing of glass node wireframe");
REGISTER_CVAR2("g_glassSystem_drawDebugData", &m_pGlassCVars->m_drawDebugData, 0, VF_CHEAT, "Toggles drawing of glass node break/impact data");
REGISTER_CVAR2("g_glassSystem_drawFragData", &m_pGlassCVars->m_drawFragData, 0, VF_CHEAT, "Toggles drawing of glass physicalized fragment data");
// Impact decals
REGISTER_CVAR2("g_glassSystem_decalAlwaysRebuild", &m_pGlassCVars->m_decalAlwaysRebuild, 0, VF_CHEAT, "Forces decals to rebuild every frame, allowing real-time tweaking.");
REGISTER_CVAR2("g_glassSystem_decalScale", &m_pGlassCVars->m_decalScale, 2.5f, VF_CHEAT, "Scale of procedural impact decals on glass");
REGISTER_CVAR2("g_glassSystem_decalMinRadius", &m_pGlassCVars->m_decalMinRadius, 0.25f, VF_CHEAT, "Minimum size of decal around impact");
REGISTER_CVAR2("g_glassSystem_decalMaxRadius", &m_pGlassCVars->m_decalMaxRadius, 1.25f, VF_CHEAT, "Maximum size of decal around impact");
REGISTER_CVAR2("g_glassSystem_decalRandChance", &m_pGlassCVars->m_decalRandChance, 0.67f, VF_CHEAT, "Chance for a decal to randomly be scaled up");
REGISTER_CVAR2("g_glassSystem_decalRandScale", &m_pGlassCVars->m_decalRandScale, 1.6f, VF_CHEAT, "Scale of decal if selected randomly");
REGISTER_CVAR2("g_glassSystem_decalMinImpactSpeed", &m_pGlassCVars->m_minImpactSpeed, 400.0f, VF_CHEAT, "Minimum speed for an impact to use the bullet decal");
// Physicalized fragments
REGISTER_CVAR2("g_glassSystem_fragImpulseScale", &m_pGlassCVars->m_fragImpulseScale, 5.0f, VF_CHEAT, "Scales impulse applied to fragments when physicalized");
REGISTER_CVAR2("g_glassSystem_fragAngImpulseScale", &m_pGlassCVars->m_fragAngImpulseScale, 0.1f, VF_CHEAT, "Scales *angular* impulse applied to fragments when physicalized");
REGISTER_CVAR2("g_glassSystem_fragImpulseDampen", &m_pGlassCVars->m_fragImpulseDampen, 0.3f, VF_CHEAT, "Dampens impulse applied to non-directly impacted fragments");
REGISTER_CVAR2("g_glassSystem_fragAngImpulseDampen", &m_pGlassCVars->m_fragAngImpulseDampen, 0.4f, VF_CHEAT, "Dampens *angular* impulse applied to non-directly impacted fragments");
REGISTER_CVAR2("g_glassSystem_fragSpread", &m_pGlassCVars->m_fragSpread, 1.5f, VF_CHEAT, "Spread velocity to apply to impacted fragments");
REGISTER_CVAR2("g_glassSystem_fragMaxSpeed", &m_pGlassCVars->m_fragMaxSpeed, 4.0f, VF_CHEAT, "Maximum speed to apply to physicalized fragments");
// Impact breaks
REGISTER_CVAR2("g_glassSystem_impactSplitMinRadius", &m_pGlassCVars->m_impactSplitMinRadius, 0.05f, VF_CHEAT, "Minimum radius for split around impact");
REGISTER_CVAR2("g_glassSystem_impactSplitRandMin", &m_pGlassCVars->m_impactSplitRandMin, 0.5f, VF_CHEAT, "Minimum radius variation for split around impact");
REGISTER_CVAR2("g_glassSystem_impactSplitRandMax", &m_pGlassCVars->m_impactSplitRandMax, 1.5f, VF_CHEAT, "Maximum radius variation for split around impact");
REGISTER_CVAR2("g_glassSystem_impactEdgeFadeScale", &m_pGlassCVars->m_impactEdgeFadeScale, 2.0f, VF_CHEAT, "Scales radial crack fade distance");
// Particle effects
REGISTER_CVAR2("g_glassSystem_particleFXEnable", &m_pGlassCVars->m_particleFXEnable, 1, VF_CHEAT, "Toggles particle effects being played when fragments are broken");
REGISTER_CVAR2("g_glassSystem_particleFXUseColours", &m_pGlassCVars->m_particleFXUseColours, 0, VF_CHEAT, "Toggles particle effects being coloured to match the glass");
REGISTER_CVAR2("g_glassSystem_particleFXScale", &m_pGlassCVars->m_particleFXScale, 0.25f, VF_CHEAT, "Scales the glass particle effects spawned");
#endif // GLASS_DEBUG_MODE
}
// Add callback for system enabled cvar
IConsole* pConsole = gEnv->pConsole;
ICVar* pSysEnabledCvar = pConsole ? pConsole->GetCVar("g_glassSystemEnable") : NULL;
if (pSysEnabledCvar)
{
m_enabled = (pSysEnabledCvar->GetIVal() != 0);
pSysEnabledCvar->SetOnChangeCallback(OnEnabledCVarChange);
}
}//-------------------------------------------------------------------------------------------------
void CGameStats::SubmitServerStats()
{
SStatsTrackHelper hlp(this);
string mode;
if(IEntity* pGRE = gEnv->pGame->GetIGameFramework()->GetIGameRulesSystem()->GetCurrentGameRulesEntity())
{
mode = pGRE->GetClass()->GetName();
}
else
mode = gEnv->pConsole->GetCVar("sv_gamerules")->GetString();
char strProductVersion[256];
gEnv->pSystem->GetProductVersion().ToString(strProductVersion);
string name;
ICVar* pName = gEnv->pConsole->GetCVar("sv_servername");
if(pName)
name = pName->GetString();
if(name.empty())
name = gEnv->pNetwork->GetHostName();
string levelname;
GetLevelName(levelname);
hlp.ServerValue("mapname",levelname);
hlp.ServerValue("gametype",mode);
hlp.ServerValue("hostname",name);
hlp.ServerValue("gamever",strProductVersion);
}
void CGameStats::ReportGame()
{
string mode;
if(IEntity* pGRE = gEnv->pGame->GetIGameFramework()->GetIGameRulesSystem()->GetCurrentGameRulesEntity())
{
mode = pGRE->GetClass()->GetName();
}
else
mode = gEnv->pConsole->GetCVar("sv_gamerules")->GetString();
string name;
ICVar* pName = gEnv->pConsole->GetCVar("sv_servername");
if(pName)
name = pName->GetString();
string timelimit;
static ICVar* pVar = gEnv->pConsole->GetCVar("g_timelimit");
timelimit = pVar?pVar->GetString():"0";
if(m_serverReport)
{
string levelname;
if(GetLevelName(levelname))
m_serverReport->SetServerValue("mapname",levelname.c_str());
m_serverReport->SetServerValue("gametype",mode);
m_serverReport->SetServerValue("timelimit",pVar?pVar->GetString():"0");
}
Report();
}
void CLuaRemoteDebug::ReceiveVersion(CSerializationHelper &buffer)
{
buffer.Read(m_clientVersion);
if (m_clientVersion != LUA_REMOTE_DEBUG_HOST_VERSION)
{
CryLogAlways("Warning: Lua remote debug client connected with version %d, host is version %d", m_clientVersion, LUA_REMOTE_DEBUG_HOST_VERSION);
}
else
{
CryLog("Lua remote debug client connected with version: %d, host is version: %d", m_clientVersion, LUA_REMOTE_DEBUG_HOST_VERSION);
}
SendVersion();
SendGameFolder();
// Make sure the debugger is enabled when the remote debugger connects
ICVar* pCvar = gEnv->pConsole->GetCVar("lua_debugger");
if (pCvar)
{
pCvar->Set(1);
}
// Send Lua state to newly connected debugger
if (m_bExecutionStopped && m_pHaltedLuaDebug)
{
SendLuaState(m_pHaltedLuaDebug);
SendVariables();
}
if (m_bBinaryLuaDetected)
{
SendBinaryFileDetected();
}
}
void CRevertibleConfigLoader::RevertCVarChanges()
{
if (!m_savedCVars.empty())
{
CryLog ("Need to undo %" PRISIZE_T " %s...", m_savedCVars.size(), (m_savedCVars.size() == 1) ? "variable" : "variables");
IConsole * pConsole = gEnv->pConsole;
CryFixedStringT<128> cmd;
//Revert the saved cvars in reverse order to handle duplicate settings of the same cvar (which shouldn't be done but people ignore warnings)
for (int n = m_savedCVars.size()-1; n >= 0; --n)
{
ICVar * var = gEnv->pConsole->GetCVar(m_savedCVars[n].m_name);
if (var && var->GetType() == CVAR_STRING && strlen(m_savedCVars[n].m_value) == 0)
{
var->Set(m_savedCVars[n].m_value);
}
else
{
cmd.Format("%s %s", m_savedCVars[n].m_name, m_savedCVars[n].m_value);
}
pConsole->ExecuteString(cmd.c_str(), true);
}
m_cvarsTextBlock.EmptyWithoutFreeing();
m_savedCVars.clear();
}
}
CFlowConvoyNode::CFlowConvoyNode( SActivationInfo * pActInfo )
{
m_distanceOnPath = 0;
m_bFirstUpdate = true;
m_bXAxisFwd = false;
m_speed = 0.0f;
m_desiredSpeed = 0.0f;
m_ShiftTime = 0.0f;
m_splitSpeed = 0;
m_coachIndex = -1;
m_splitCoachIndex = 0;
m_loopCount = 0;
m_loopTotal = 0;
m_offConvoyStartTime=0.f;
m_splitDistanceOnPath=0;
m_hornSoundID=INVALID_SOUNDID;
m_engineStartSoundID=INVALID_SOUNDID;
m_startBreakSoundShifted=0;
pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true );
if (gFlowConvoyNodes.empty())
gEnv->pPhysicalWorld->AddEventClient(EventPhysPostStep::id, OnPhysicsPostStep_static, 0);
gFlowConvoyNodes.push_back(this);
ICVar* pICVar = gEnv->pConsole->GetCVar("es_UsePhysVisibilityChecks");
if(pICVar) //prevent distance problem between coaches
pICVar->Set(0);
m_processNode = false;
m_atEndOfPath = false;
}
virtual void OnSystemEvent( ESystemEvent event,UINT_PTR wparam,UINT_PTR lparam )
{
switch (event)
{
case ESYSTEM_EVENT_RANDOM_SEED:
g_random_generator.seed((uint32)wparam);
break;
case ESYSTEM_EVENT_CHANGE_FOCUS:
{
CGameStartup::AllowAccessibilityShortcutKeys(wparam==0);
}
break;
case ESYSTEM_EVENT_LEVEL_LOAD_START:
{
// workaround for needed for Crysis - to reset cvar set in level.cfg
ICVar *pCVar = gEnv->pConsole->GetCVar("r_EyeAdaptationBase"); assert(pCVar);
float fOldVal = pCVar->GetFVal();
if(fOldVal!=EYEADAPTIONBASEDEFAULT)
{
CryLog("r_EyeAdaptationBase was reset to default");
pCVar->Set(EYEADAPTIONBASEDEFAULT); // set to default value
}
}
break;
case ESYSTEM_EVENT_LEVEL_POST_UNLOAD:
STLALLOCATOR_CLEANUP;
break;
}
}
void CStereoZoom::SetStereoEyeDistCVAR(float eyeDist)
{
ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoEyeDist");
if ( pICVar != NULL)
{
pICVar->Set(eyeDist);
}
}
void CStereoZoom::SetStereoPlaneDistCVAR(float planeDist)
{
ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoScreenDist");
if ( pICVar != NULL)
{
pICVar->Set(planeDist);
}
}
////////////////////////////////////////////////////////////////////////////
// ui events
///////////////////////////////////////////////////////////////////////////////////////////////////////////
void CUIGameEvents::OnLoadLevel( const char* mapname, bool isServer, const char* gamerules )
{
if (gEnv->IsEditor()) return;
ICVar* pGameRulesVar = gEnv->pConsole->GetCVar("sv_GameRules");
if (pGameRulesVar) pGameRulesVar->Set( gamerules );
m_pGameFramework->ExecuteCommandNextFrame(string().Format("map %s%s", mapname, isServer ? " s" : ""));
if ( m_pGameFramework->IsGamePaused() )
m_pGameFramework->PauseGame(false, true);
}
void CUIMultiPlayer::LoadProfile(IPlayerProfile* pProfile)
{
pProfile->GetAttribute( "mp_username", m_LocalPlayerName);
pProfile->GetAttribute( "mp_server", m_ServerName);
// override if setup in system cfg
ICVar* pServerVar = gEnv->pConsole->GetCVar("cl_serveraddr");
if (pServerVar && pServerVar->GetString() != "")
m_ServerName = pServerVar->GetString();
}
bool CStereoZoom::IsStereoEnabled() const
{
ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoMode");
if ( pICVar != NULL)
{
return pICVar->GetIVal() != 0;
}
return false;
}
void CStereoZoom::RememberCurrentPlaneDistance()
{
ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoScreenDist");
if ( pICVar != NULL)
{
m_distanceOfPlaneBeforeChanging = pICVar->GetFVal();
}
else
{
m_distanceOfPlaneBeforeChanging = 10.f;
}
}
void CStereoZoom::RememberCurrentEyeDistance()
{
ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoEyeDist");
if ( pICVar != NULL)
{
m_distanceOfEyesBeforeChanging = pICVar->GetFVal();
}
else
{
m_distanceOfEyesBeforeChanging = 0.06f;
}
}
//--------------------------------------------------------------------------------------------------
// Name: ~CBreakableGlassSystem
// Desc: Destructor
//--------------------------------------------------------------------------------------------------
CBreakableGlassSystem::~CBreakableGlassSystem()
{
// Release all nodes and data
ResetAll();
#ifdef GLASS_DEBUG_MODE
// Remove debug cvars after all nodes that could be using them
if (IConsole* pConsole = gEnv->pConsole)
{
pConsole->UnregisterVariable("g_glassSystem_draw");
pConsole->UnregisterVariable("g_glassSystem_drawWireframe");
pConsole->UnregisterVariable("g_glassSystem_drawDebugData");
pConsole->UnregisterVariable("g_glassSystem_drawFragData");
pConsole->UnregisterVariable("g_glassSystem_decalAlwaysRebuild");
pConsole->UnregisterVariable("g_glassSystem_decalScale");
pConsole->UnregisterVariable("g_glassSystem_decalMinRadius");
pConsole->UnregisterVariable("g_glassSystem_decalMaxRadius");
pConsole->UnregisterVariable("g_glassSystem_decalRandChance");
pConsole->UnregisterVariable("g_glassSystem_decalRandScale");
pConsole->UnregisterVariable("g_glassSystem_decalMinImpactSpeed");
pConsole->UnregisterVariable("g_glassSystem_fragImpulseScale");
pConsole->UnregisterVariable("g_glassSystem_fragAngImpulseScale");
pConsole->UnregisterVariable("g_glassSystem_fragImpulseDampen");
pConsole->UnregisterVariable("g_glassSystem_fragAngImpulseDampen");
pConsole->UnregisterVariable("g_glassSystem_fragSpread");
pConsole->UnregisterVariable("g_glassSystem_fragMaxSpeed");
pConsole->UnregisterVariable("g_glassSystem_particleFXEnable");
pConsole->UnregisterVariable("g_glassSystem_particleFXUseColours");
pConsole->UnregisterVariable("g_glassSystem_particleFXScale");
}
#endif // GLASS_DEBUG_MODE
SAFE_DELETE(m_pGlassCVars);
// Remove system enabled cvar callback
IConsole* pConsole = gEnv->pConsole;
ICVar* pSysEnabledCVar = pConsole ? pConsole->GetCVar("g_glassSystemEnable") : NULL;
if (pSysEnabledCVar)
{
pSysEnabledCVar->SetOnChangeCallback(NULL);
}
// Remove physics callback
if (IPhysicalWorld* pPhysWorld = gEnv->pPhysicalWorld)
{
pPhysWorld->RemoveEventClient(EventPhysCollision::id, &CBreakableGlassSystem::HandleImpact, 1);
}
}//-------------------------------------------------------------------------------------------------
void CGameStats::ReportSession()
{
if(!m_serverReport)
return;
string name;
ICVar* pName = gEnv->pConsole->GetCVar("sv_servername");
if(pName)
name = pName->GetString();
if(name.empty())
name = gEnv->pNetwork->GetHostName();
CCryAction::GetCryAction()->OnActionEvent(SActionEvent(eAE_serverName, 0, name));
if(gEnv->pConsole->GetCVar("sv_lanonly")->GetIVal())//we're on LAN so report our name
{
string ip = gEnv->pNetwork->GetHostName();
ip += ":";
ip += gEnv->pConsole->GetCVar("sv_port")->GetString();
CCryAction::GetCryAction()->OnActionEvent(SActionEvent(eAE_serverIp, 0, ip));
}
if(m_serverReport)
{
m_serverReport->SetServerValue("hostname",name);
m_serverReport->SetServerValue("hostport",gEnv->pConsole->GetCVar("sv_port")->GetString());
char strProductVersion[256];
gEnv->pSystem->GetProductVersion().ToString(strProductVersion);
m_serverReport->SetServerValue("gamever", strProductVersion);
m_serverReport->SetServerValue("maxplayers",gEnv->pConsole->GetCVar("sv_maxplayers")->GetString());
ICVar* pFF = gEnv->pConsole->GetCVar("g_friendlyfireratio");
m_serverReport->SetServerValue("friendlyfire",pFF?((pFF->GetFVal()!=0)?"1":"0"):0);
m_serverReport->SetServerValue("dx10",CCryAction::GetCryAction()->GetGameContext()->HasContextFlag(eGSF_ImmersiveMultiplayer)?"1":"0");
}
ReportGame();
if((CCryAction::GetCryAction()->GetILevelSystem()->IsLevelLoaded() && CCryAction::GetCryAction()->IsGameStarted()) || m_startReportNeeded)//otherwise, OnLoadingStart will report it
{
if(m_serverReport && !m_reportStarted)//report now
{
m_serverReport->StartReporting(gEnv->pGame->GetIGameFramework()->GetServerNetNub(), m_pListener);
m_reportStarted = true;
}
m_startReportNeeded = false;
}
m_startReportNeeded = !m_reportStarted;
}
//--------------------------------------------------------------------------------------------------
// Name: SetPostEffectCVarCallbacks
// Desc: Sets Post effect CVar callbacks for testing and tweaking post effect values
//--------------------------------------------------------------------------------------------------
void GameSDKCGameEffectsSystem::SetPostEffectCVarCallbacks()
{
#if DEBUG_GAME_FX_SYSTEM
ICVar* postEffectCvar = NULL;
const char postEffectNames[][64] = { "g_postEffect.FilterGrain_Amount",
"g_postEffect.FilterRadialBlurring_Amount",
"g_postEffect.FilterRadialBlurring_ScreenPosX",
"g_postEffect.FilterRadialBlurring_ScreenPosY",
"g_postEffect.FilterRadialBlurring_Radius",
"g_postEffect.Global_User_ColorC",
"g_postEffect.Global_User_ColorM",
"g_postEffect.Global_User_ColorY",
"g_postEffect.Global_User_ColorK",
"g_postEffect.Global_User_Brightness",
"g_postEffect.Global_User_Contrast",
"g_postEffect.Global_User_Saturation",
"g_postEffect.Global_User_ColorHue",
"g_postEffect.HUD3D_Interference",
"g_postEffect.HUD3D_FOV"};
int postEffectNameCount = sizeof(postEffectNames)/sizeof(*postEffectNames);
if(postEffectNameCount > 0)
{
// Calc name offset
const char* postEffectName = postEffectNames[0];
s_postEffectCVarNameOffset = 0;
while((*postEffectName) != 0)
{
s_postEffectCVarNameOffset++;
if((*postEffectName) == '.')
{
break;
}
postEffectName++;
}
// Set callback functions
for(int i=0; i<postEffectNameCount; i++)
{
postEffectCvar = gEnv->pConsole->GetCVar(postEffectNames[i]);
if(postEffectCvar)
{
postEffectCvar->SetOnChangeCallback(PostEffectCVarCallback);
}
}
}
#endif
}//-------------------------------------------------------------------------------------------------
int CGameStartup::Update(bool haveFocus, unsigned int updateFlags)
{
#if defined(JOBMANAGER_SUPPORT_PROFILING)
gEnv->GetJobManager()->SetFrameStartTime(gEnv->pTimer->GetAsyncTime());
#endif
int returnCode = 0;
if (gEnv->pConsole)
{
#if CRY_PLATFORM_WINDOWS
if(gEnv && gEnv->pRenderer && gEnv->pRenderer->GetHWND())
{
bool focus = (::GetFocus() == gEnv->pRenderer->GetHWND());
static bool focused = focus;
if (focus != focused)
{
if (GetISystem()->GetISystemEventDispatcher())
{
GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_CHANGE_FOCUS, focus, 0);
}
focused = focus;
}
}
#endif
}
if (m_pGame)
{
returnCode = m_pGame->Update(haveFocus, updateFlags);
}
if (!m_fullScreenCVarSetup && gEnv->pConsole)
{
ICVar *pVar = gEnv->pConsole->GetCVar("r_Fullscreen");
if (pVar)
{
pVar->SetOnChangeCallback(FullScreenCVarChanged);
m_fullScreenCVarSetup = true;
}
}
#if ENABLE_AUTO_TESTER
s_autoTesterSingleton.Update();
#endif
return returnCode;
}
void CUIHUD3D::InitEventSystem()
{
assert(gEnv->pSystem);
if (gEnv->pSystem)
gEnv->pSystem->GetISystemEventDispatcher()->RegisterListener( this );
if(gEnv->pFlashUI)
gEnv->pFlashUI->RegisterModule(this, "CUIHUD3D");
m_Offsets.push_back( SHudOffset(1.2f, 1.4f, -0.2f) );
m_Offsets.push_back( SHudOffset(1.33f, 1.3f, -0.1f) );
m_Offsets.push_back( SHudOffset(1.6f, 1.1f, -0.1f) );
m_Offsets.push_back( SHudOffset(1.77f, 1.0f, 0.0f) );
ICVar* pShowHudVar = gEnv->pConsole->GetCVar("hud_hide");
if (pShowHudVar)
pShowHudVar->SetOnChangeCallback( &OnVisCVarChange );
}
SCreateChannelResult CGameClientNub::CreateChannel(INetChannel* pChannel, const char* pRequest)
{
if (pRequest && !gEnv->pNetwork->IsRebroadcasterEnabled())
{
GameWarning("CGameClientNub::CreateChannel: pRequest is non-null, it should not be");
CRY_ASSERT(false);
SCreateChannelResult res(eDC_GameError);
cry_strcpy(res.errorMsg, "CGameClientNub::CreateChannel: pRequest is non-null, it should not be");
return res;
}
if (m_pClientChannel)
{
if (gEnv->pNetwork->IsRebroadcasterEnabled())
{
// A client channel has already been set up so this must be a rebroadcaster (peer to peer) channel
pChannel->SetPeer(m_pGameContext->GetNetContext());
SCreateChannelResult res(reinterpret_cast<IGameChannel*>(pChannel));
return res;
}
else
{
GameWarning("CGameClientNub::CreateChannel: m_pClientChannel is non-null, it should not be");
CRY_ASSERT(false);
SCreateChannelResult res(eDC_GameError);
cry_strcpy(res.errorMsg, "CGameClientNub::CreateChannel: m_pClientChannel is non-null, it should not be");
return res;
}
}
if (CCryAction::GetCryAction()->IsGameSessionMigrating())
{
pChannel->SetMigratingChannel(true);
}
m_pClientChannel = new CGameClientChannel(pChannel, m_pGameContext, this);
ICVar* pPass = gEnv->pConsole->GetCVar("sv_password");
if (pPass && gEnv->bMultiplayer)
pChannel->SetPassword(pPass->GetString());
return SCreateChannelResult(m_pClientChannel);
}
void COptionsManager::SetAntiAliasingMode(const char* params)
{
if(params)
{
if(g_pGame->GetMenu())
{
CFlashMenuObject::FSAAMode mode = g_pGame->GetMenu()->GetFSAAMode(params);
if(mode.samples == 0)
{
gEnv->pConsole->ExecuteString("r_fsaa 0");
gEnv->pConsole->ExecuteString("r_fsaa_samples 0");
gEnv->pConsole->ExecuteString("r_fsaa_quality 0");
}
else
{
gEnv->pConsole->ExecuteString("r_fsaa 1");
CryFixedStringT<32> command = "r_fsaa_samples ";
char buffer[16];
itoa(mode.samples, buffer, 10);
command.append(buffer);
gEnv->pConsole->ExecuteString(command.c_str());
command = "r_fsaa_quality ";
itoa(mode.quality, buffer, 10);
command.append(buffer);
gEnv->pConsole->ExecuteString(command.c_str());
// FSAA requires HDR mode on, to get consistent menu settings we switch sys_spec_shading to 3 or 4
// search for #LABEL_FSAA_HDR
{
bool bHDREnabled = gEnv->pRenderer->EF_Query(EFQ_HDRModeEnabled)!=0;
if(!bHDREnabled) // no HDR so we either have sys_spec_Shading in 1 or 2 or user
{ // (it cannot be the machine is not capable of HDR as we have a list of FSAA modes)
ICVar *pSpecShading = gEnv->pConsole->GetCVar("sys_spec_Shading"); assert(pSpecShading);
if(pSpecShading)
pSpecShading->Set(3); // starting with mode 3 we have HDR on
}
}
}
}
}
}
CFlowConvoyNode::~CFlowConvoyNode()
{
for (size_t i=0; i<gFlowConvoyNodes.size(); ++i)
{
if (gFlowConvoyNodes[i] == this)
{
gFlowConvoyNodes.erase(gFlowConvoyNodes.begin() + i);
break;
}
}
if (gFlowConvoyNodes.empty())
{
gEnv->pPhysicalWorld->RemoveEventClient(EventPhysPostStep::id, OnPhysicsPostStep_static, 0);
stl::free_container(gFlowConvoyNodes);
}
ICVar* pICVar = gEnv->pConsole->GetCVar("es_UsePhysVisibilityChecks");
if(pICVar)
pICVar->Set(1);
}
void CWorldState::Init()
{
if( gEnv->bServer && !gEnv->IsEditor())
{
CryLog("CWorldState::Init()");
pPak = gEnv->pCryPak;
pLevel = gEnv->pGame->GetIGameFramework()->GetILevelSystem()->GetCurrentLevel();
ICVar* pName = gEnv->pConsole->GetCVar("sv_servername");
worldStateXml==NULL;
if (pLevel)
szSavePath = pLevel->GetLevelInfo()->GetPath();
if(pName)
serverName = pName->GetString();
szSaveFile = PathUtil::Make(szSavePath.c_str(), serverName, ".xml");
ReadWorldStateFile((char*)serverName);
}
}
void COptionsManager::UpdateToProfile()
{
std::map<string,SOptionEntry>::const_iterator it = m_profileOptions.begin();
std::map<string,SOptionEntry>::const_iterator end = m_profileOptions.end();
for(;it!=end;++it)
{
const SOptionEntry& entry = it->second;
if(!strcmp(it->first.c_str(),"pb_client"))
{
SaveValueToProfile(entry.name.c_str(), m_pbEnabled?1:0);
}
else if(!strcmp(it->first.c_str(), "fsaa_mode"))
{
string value("");
if(g_pGame->GetMenu())
{
if(gEnv->pConsole->GetCVar("r_FSAA")->GetIVal())
{
int samples = gEnv->pConsole->GetCVar("r_FSAA_samples")->GetIVal();
int quality = gEnv->pConsole->GetCVar("r_FSAA_quality")->GetIVal();
value = g_pGame->GetMenu()->GetFSAAMode(samples, quality);
}
}
SaveValueToProfile(entry.name.c_str(), value);
}
else
{
ICVar *pCVAR = gEnv->pConsole->GetCVar(it->first);
if(pCVAR)
{
string value(pCVAR->GetString());
SaveValueToProfile(entry.name.c_str(), value);
}
}
}
SaveProfile();
}
bool CTweakMetadataCVAR::ChangeValue(bool bIncrement) {
// Get delta
double fDelta = m_fDelta;
if (!bIncrement) fDelta *= -1.0;
// Get and check CVAR
ICVar *cVar = GetCVar();
if (!cVar) return false;
// Deal with appropriate type
switch (cVar->GetType()) {
case CVAR_INT:
cVar->Set( (int) (cVar->GetIVal() + fDelta) );
break;
case CVAR_FLOAT:
cVar->Set( (float) (cVar->GetFVal() + fDelta) );
break;
default:;
// Strings are non-obvious
// Might also be a non-exisitent variable
}
return true;
}
void CGameStateRecorder::OnRecordedGameplayEvent(IEntity *pEntity, const GameplayEvent &event, int currentFrame, bool bRecording)
{
EntityId id;
m_currentFrame = currentFrame;
int demo_forceGameState = 0;
if(!bRecording)
{
ICVar *pVar = gEnv->pConsole->GetCVar( "demo_force_game_state" );
if(pVar)
demo_forceGameState = pVar->GetIVal();
}
if(!pEntity || !(id = pEntity->GetId()))
return;
if(m_IgnoredEvents.size())
if(event.event == m_IgnoredEvents[0])
{
m_IgnoredEvents.erase(m_IgnoredEvents.begin());
return;
}
TGameStates::iterator itActor = m_GameStates.find(id);
if(itActor == m_GameStates.end())
{
m_GameStates.insert(std::make_pair(id,SActorGameState()));
itActor = m_GameStates.find(id);
}
if(itActor == m_GameStates.end())
{
GameWarning("TimeDemo:GameState: actor %s not found in records",pEntity->GetName());
return;
}
SActorGameState& gstate = itActor->second;
switch(event.event)
{
case eGE_HealthChanged:
{
gstate.health = event.value;
if(!m_bRecording)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
if(m_bLogWarning)
{
if(CHECK_MISMATCH(pActor->GetHealth(), gstate.health,10))
{
if(!gstate.bHealthDifferent)
{
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - HEALTH mismatch (%d, %d)",m_currentFrame,pEntity->GetName(), static_cast<int>(pActor->GetHealth()), static_cast<int>(gstate.health));
gstate.bHealthDifferent = true;
}
}
else
gstate.bHealthDifferent = false;
}
if( demo_forceGameState)
pActor->SetHealth(gstate.health);
}
}
}
break;
case eGE_WeaponFireModeChanged:
{
TItemName sel = (event.description);
if(sel)
{
TItemContainer& Items = gstate.Items;
TItemContainer::iterator iti = Items.find(sel);
uint8 recFireModeIdx = uint8(event.value);
if(iti != Items.end())
iti->second.fireMode = recFireModeIdx;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor && pActor->GetInventory())
{
IItem* pItem = pActor->GetInventory()->GetItemByName(sel);
CWeapon* pWeapon;
if(pItem && (pWeapon = (CWeapon*)(pItem->GetIWeapon())))
{
int fireModeIdx = pWeapon->GetCurrentFireMode();
if(m_bLogWarning)
{
CheckDifference(recFireModeIdx,fireModeIdx,"TimeDemo:GameState: Frame %d - Actor %s - FIRE MODE mismatch for weapon %s (rec:%d, cur:%d)",pEntity,pItem->GetEntity() ? pItem->GetEntity()->GetName() : "(null)");
}
if(demo_forceGameState==2 && fireModeIdx!= recFireModeIdx)
pWeapon->SetCurrentFireMode(recFireModeIdx);
}
}
}
}
break;
case eGE_WeaponReload:
{
const char* ammoType = event.description;
TAmmoContainer& ammoMags = gstate.AmmoMags;
TAmmoContainer::iterator it = ammoMags.find(ammoType);
if(it!=ammoMags.end())
{
it->second -= (uint16)event.value;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
{
IEntityClass* pAmmoClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoType);
if(pAmmoClass)
{
if(m_bLogWarning)
CheckDifference(it->second,pInventory->GetAmmoCount(pAmmoClass),"TimeDemo:GameState: Frame %d - Actor %s - WEAPON RELOAD, ammo count mismatch for ammo class %s (rec:%d, cur:%d)",pEntity,ammoType);
if(demo_forceGameState == 2)
pInventory->SetAmmoCount(pAmmoClass,it->second);
}
}
}
}
}
}
break;
case eGE_ItemSelected:
{
TItemName itemName = event.description;
gstate.itemSelected = itemName;
if(itemName)
{
if( !bRecording && (event.value > 0 || demo_forceGameState==2)) // EVENT.VALUE > 0 means initialization
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor && pActor->GetInventory())
{
IItem* pItem = pActor->GetInventory()->GetItemByName(itemName);
if(pItem)
pActor->SelectItem(pItem->GetEntityId(),false);
}
}
}
if(m_bLogWarning)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
IItem* pItem = pActor->GetCurrentItem();
const char* curItemName= pItem && pItem->GetEntity() ? pItem->GetEntity()->GetName(): NULL;
CheckDifferenceString(itemName,curItemName,"TimeDemo:GameState: Frame %d - Actor %s - SELECTED ITEM mismatch (rec:%s, cur:%s)",pEntity);
}
}
break;
}
break;
case eGE_ItemExchanged:
{
// prevent unwanted record/play mismatch error with current item during item exchanging
// two unneeded game events are sent (selecting fists)
m_IgnoredEvents.push_back(eGE_ItemSelected);
m_IgnoredEvents.push_back(eGE_ItemSelected);
}
break;
case eGE_ItemPickedUp:
{
TItemName sel = (TItemName)event.description;
// gstate.itemSelected = sel;
TItemContainer& Items = gstate.Items;
TItemContainer::iterator it = Items.find(sel);
if(it == Items.end())
{
Items.insert(std::make_pair(sel,SItemProperties()));
it = Items.find(sel);
}
if(it != Items.end())
{
it->second.count++;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor && !m_bRecording)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
// just check if the item is the inventory
if(m_bLogWarning && !pInventory->GetItemByName(sel))
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - Recorded PICKED UP ITEM class '%s' not found in current inventory",m_currentFrame,pEntity->GetName(),sel);
if(demo_forceGameState == 2)
{
IEntity* pItemEntity = gEnv->pEntitySystem->FindEntityByName(sel);
if(pItemEntity)
pInventory->AddItem(pItemEntity->GetId());
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - PICKED UP ITEM entity %s not found in level",m_currentFrame,pEntity->GetName(),sel);
}
}
}
}
else if(m_bLogWarning)
{
if(!sel)
sel = "(null)";
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - PICKED UP ITEM %s not found in recorded inventory",m_currentFrame,pEntity->GetName(),sel);
}
}
break;
case eGE_AmmoPickedUp:
{
uint16 ammoCount = (uint16)(event.value);
TItemName sel = (TItemName)event.description;
TAmmoContainer& Ammo = gstate.AmmoMags;
TAmmoContainer::iterator it = Ammo.find(sel);
if(it == Ammo.end())
Ammo.insert(std::make_pair(sel,ammoCount));
else
it->second = ammoCount;
if( !m_bRecording)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(m_bLogWarning)
CheckDifference(ammoCount,pInventory->GetAmmoCount(pClass),"TimeDemo:GameState: Frame %d - Actor %s - AMMO PICKEDUP: count mismatch for ammo class %s (rec:%d, cur:%d)", pEntity,sel);
if(demo_forceGameState == 2)
pInventory->SetAmmoCount(pClass,ammoCount);
}
}
}
}
break;
case eGE_AccessoryPickedUp:
{
TItemName sel = (TItemName)event.description;
// gstate.itemSelected = sel;
TAccessoryContainer& Accessories = gstate.Accessories;
TAccessoryContainer::iterator it = Accessories.find(sel);
if(it == Accessories.end())
{
Accessories.insert(std::make_pair(sel,1));
}
else
it->second++;
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(m_bLogWarning && !pInventory->HasAccessory(pClass))
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - ACCESSORY PICKEDUP %s not found in current inventory", m_currentFrame, pEntity->GetName(),sel ? sel:"(null)");
if(demo_forceGameState == 2 && pClass)
pInventory->AddAccessory(pClass);// doesn't actually add it if it's there already
}
}
}
break;
case eGE_ItemDropped:
{
TItemName sel = (TItemName)event.description;
//gstate.itemSelected = sel;
TItemContainer& Items = gstate.Items;
TItemContainer::iterator it = Items.find(sel);
if(it != Items.end())
{
it->second.count--;
if(it->second.count<=0)
Items.erase(it);
if(demo_forceGameState == 2)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(pClass)
{
EntityId itemId = pInventory->GetItemByClass(pClass);
if(itemId)
pInventory->RemoveItem(itemId);
}
}
}
}
}
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - ITEM DROPPED, wrong item selected (%s)",m_currentFrame,pEntity->GetName(),sel);
}
break;
case eGE_AmmoCount:
{
TItemContainer& Items = gstate.Items;
TItemName itemClassDesc = event.description;
TItemContainer::iterator it = Items.find(itemClassDesc);
if(it != Items.end())
{
SItemProperties& item = it->second;
const char* ammoClassDesc = (const char*)(event.extra);
if(ammoClassDesc)
{
string szAmmoClassDesc(ammoClassDesc);
bool bAmmoMag = IsAmmoGrenade(ammoClassDesc);
TAmmoContainer& itemAmmo = bAmmoMag ? gstate.AmmoMags : item.Ammo;
if(itemAmmo.find(szAmmoClassDesc)==itemAmmo.end())
itemAmmo.insert(std::make_pair(szAmmoClassDesc,int(event.value)));
else
itemAmmo[szAmmoClassDesc] = (uint16)event.value;
if(!bRecording && (m_bLogWarning || demo_forceGameState==2))
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
IItem* pItem = pInventory->GetItemByName(itemClassDesc);
if(pItem)
{
CWeapon* pWeapon = (CWeapon*)(pItem->GetIWeapon());
if(pWeapon)
{
IEntityClass* pAmmoClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(ammoClassDesc);
if(pAmmoClass)
{
if(m_bLogWarning)
{
int curAmmoCount = (bAmmoMag ? pInventory->GetAmmoCount(pAmmoClass) :
pWeapon->GetAmmoCount(pAmmoClass));
CheckDifference( int(event.value),curAmmoCount,"TimeDemo:GameState: Frame %d - Actor %s - AMMO COUNT mismatch for ammo class %s (rec:%d, cur:%d)",pEntity,ammoClassDesc);
}
if(demo_forceGameState==2)
pWeapon->SetAmmoCount(pAmmoClass,int(event.value));
}
}
}
}
}
}
}
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - AMMO COUNT null ammoClass descriptor",m_currentFrame,pEntity->GetName());
}
else
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - AMMO COUNT wrong item selected (%s)",m_currentFrame,pEntity->GetName(),itemClassDesc);
}
break;
case eGE_AttachedAccessory:
{
// always force attachment of accessory to the current weapon
// kind of a workaround, the HUD weapon modifier menu is spawned during timedemo playback
// but it doesn't use recorded input events
if(!bRecording)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
CInventory* pInventory = (CInventory*)(pActor->GetInventory());
if(pInventory)
{
const char* sel = event.description;
IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(sel);
if(!sel)
sel = "(null)";
if(!pInventory->HasAccessory(pClass))
{
if(m_bLogWarning)
GameWarning("TimeDemo:GameState: Frame %d - Actor %s - ATTACHED ACCESSORY %s not found in current inventory", m_currentFrame,pEntity->GetName(),sel);
}
else
{
CItem* pCurrentItem = (CItem*)(pActor->GetCurrentItem());
if(pCurrentItem)
pCurrentItem->SwitchAccessory(sel);
}
}
}
}
}
break;
case eGE_EntityGrabbed:
{
if(demo_forceGameState==2)
{
TItemName itemName = event.description;
if(itemName)
{
IEntity * pGrabbedEntity = gEnv->pEntitySystem->FindEntityByName(itemName);
if(pGrabbedEntity)
{
CActor *pActor = (CActor*)(gEnv->pGame->GetIGameFramework()->GetIActorSystem()->GetActor(id));
if(pActor)
{
IItem* pItem = GetItemOfName(pActor,itemName);
if(!pItem)
{
// it's a pickable entity, won't end up in the inventory
//(otherwise it would be managed by eGE_ItemPickedUp)
COffHand* pOffHand = static_cast<COffHand*>(pActor->GetWeaponByClass(CItem::sOffHandClass));
if(pOffHand && !pOffHand->GetPreHeldEntityId())
pOffHand->ForcePickUp(pGrabbedEntity->GetId());
}
}
}
}
}
}
break;
default:
break;
}
}
