void CSmartMine::FullSerialize( TSerialize ser )
{
uint32 targetCount = m_trackedEntities.size();
ser.Value( "MineEnabled", m_enabled );
ser.Value( "MineFaction", m_factionId );
ser.Value( "MineTargetCount", targetCount );
CryFixedStringT<16> targetName;
if (ser.IsReading())
{
m_trackedEntities.clear();
for(uint32 i = 0; i < targetCount; ++i)
{
m_trackedEntities.push_back();
targetName.Format( "MineTarget_%d", i );
ser.Value( targetName.c_str(), m_trackedEntities[i] );
}
}
else
{
for(uint32 i = 0; i < targetCount; ++i)
{
targetName.Format( "MineTarget_%d", i );
ser.Value( targetName.c_str(), m_trackedEntities[i] );
}
}
StateMachineSerializeBehavior( SStateEventSerialize( ser ) );
}
void CDLCManager::OnDLCRemoved(const char* sDLCRootFolder)
{
//clear all the data
for( int iDLC = 0; iDLC < MAX_DLC_COUNT; iDLC++ )
{
if( IsDLCLoaded( iDLC ) )
{
if( strcmpi( m_dlcContents[iDLC].root.c_str(), sDLCRootFolder ) == 0 )
{
m_loadedDLCs &= ~BIT(iDLC);
m_allowedDLCs &= ~BIT(iDLC);
//close the paks
CryFixedStringT<ICryPak::g_nMaxPath> path;
path.Format("%s/dlcLevelExtras.pak", sDLCRootFolder);
CryLog( "DLC: Closing %s", path.c_str() );
gEnv->pCryPak->ClosePack( path.c_str() );
path.Format("%s/dlcData.pak", sDLCRootFolder);
CryLog( "DLC: Closing %s", path.c_str() );
gEnv->pCryPak->ClosePack( path.c_str() );
}
}
}
}
bool SUnlock::GetUnlockDisplayString( EUnlockType type, const char* name, CryFixedStringT<32>& outStr )
{
// TODO: Setup Playlist unlocks and any others
bool retval = false;
switch( type )
{
case eUT_Weapon:
{
const CItemSharedParams* pItemShared = g_pGame->GetGameSharedParametersStorage()->GetItemSharedParameters( name, false );
if( pItemShared )
{
outStr.Format( pItemShared->params.display_name.c_str() );
retval = true;
}
break;
}
case eUT_CreateCustomClass:
{
CEquipmentLoadout *pEquipmentLoadout = g_pGame->GetEquipmentLoadout();
if( pEquipmentLoadout )
{
const char* packageName = pEquipmentLoadout->GetPackageDisplayFromName( name );
if( packageName )
{
outStr.Format( CHUDUtils::LocalizeString(packageName) );
retval = true;
}
}
break;
}
case eUT_Attachment:
{
const char* pAttachmentName = strstr(name, ".");
if( pAttachmentName && pAttachmentName[0] )
{
CEquipmentLoadout* pEquipmentLoadout = g_pGame->GetEquipmentLoadout();
if( pEquipmentLoadout )
{
if( const CEquipmentLoadout::SEquipmentItem *pUnlockItem = pEquipmentLoadout->GetItemByName( pAttachmentName+1 ) )
{
outStr.Format( pUnlockItem->m_displayName.c_str() );
retval = true;
}
}
}
break;
}
}
return retval;
}
void CGameStats::Report()
{
if(!m_serverReport)
return;
int playerCount = m_playerMap.size();
if (CGameServerNub * pServerNub = CCryAction::GetCryAction()->GetGameServerNub())
playerCount = pServerNub->GetPlayerCount();
//All server reporting is done here
m_serverReport->SetReportParams(playerCount,m_teamMap.size());
m_serverReport->SetServerValue("gamemode",m_playing?"game":"pre-game");
CryFixedStringT<32> timeleft("-");
if(IGameRulesSystem* pGR = gEnv->pGame->GetIGameFramework()->GetIGameRulesSystem())
{
IGameRules *pR = pGR->GetCurrentGameRules();
if(pR && pR->IsTimeLimited() && m_playing)
{
timeleft.Format("%.0f",pR->GetRemainingGameTime());
}
}
m_serverReport->SetServerValue("timeleft",timeleft);
CryFixedStringT<256> tempStr;
m_serverReport->SetServerValue("numplayers",tempStr.Format("%d",playerCount));
int i=0;
string mode;
for(PlayerStatsMap::const_iterator it=m_playerMap.begin();it!=m_playerMap.end();++it)
{
static string value;
m_serverReport->SetPlayerValue(i, "player", it->second.name);
value.Format("%d",it->second.rank);
m_serverReport->SetPlayerValue(i, "rank", value);
value.Format("%d",it->second.team?it->second.team:(it->second.spectator?0:1));
m_serverReport->SetPlayerValue(i, "team", value);
for (std::map<string, int>::const_iterator sit=it->second.scores.begin(); sit!=it->second.scores.end(); ++sit)
m_serverReport->SetPlayerValue(i, sit->first, tempStr.Format("%d",sit->second));
++i;
}
while (i < playerCount)
{
m_serverReport->SetPlayerValue(i, "player", "<connecting>");
++i;
}
}
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();
}
}
bool CModInfoManager::LoadMod(const char* modName)
{
CryFixedStringT<256> command;
command.Format("g_loadMod %s", modName);
gEnv->pConsole->ExecuteString(command.c_str());
return true;
}
//------------------------------------------------------------------------
int CScriptBind_Item::GetUsableText(IFunctionHandler *pH)
{
CItem *pItem = GetItem(pH);
if (!pItem)
return pH->EndFunction();
CryFixedWStringT<64> localizedString;
CryFixedStringT<64> finalString;
CryFixedStringT<64> tempString;
tempString.Format("@ui_item_pickup %s", pItem->GetSharedItemParams()->params.display_name.c_str());
localizedString = CHUDUtils::LocalizeStringW(tempString.c_str());
finalString.Format("%ls", localizedString.c_str());
return pH->EndFunction(finalString.c_str());
}
void CAntiCheatManager::ParseAntiCheatConfig(const char * filename)
{
CCryFile file;
CryFixedStringT<128> realFileName;
realFileName.Format("%s/%s", PathUtil::GetGameFolder().c_str(), filename);
if (file.Open( realFileName.c_str(), "rb", ICryPak::FOPEN_HINT_QUIET | ICryPak::FOPEN_ONDISK ))
{
const size_t fileSize = file.GetLength();
char* pBuffer = new char [fileSize];
file.ReadRaw(pBuffer, fileSize);
XmlNodeRef xmlData = gEnv->pSystem->LoadXmlFromBuffer(pBuffer, fileSize);
SAFE_DELETE_ARRAY(pBuffer);
if(xmlData)
{
CryLog("Parsing Anti-Cheat Configuration...");
ParseAntiCheatConfig(xmlData);
}
else
{
CryLog("Unable to parse Anti-Cheat Configuration");
}
}
else
{
CryLog("Unable to load '%s'", realFileName.c_str());
}
}
void CView::CreateAudioListener()
{
if (m_pAudioListener == NULL)
{
SEntitySpawnParams oEntitySpawnParams;
oEntitySpawnParams.sName = "SoundListener";
oEntitySpawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("SoundListener");
m_pAudioListener = gEnv->pEntitySystem->SpawnEntity(oEntitySpawnParams, true);
if (m_pAudioListener != NULL)
{
m_pAudioListener->SetFlagsExtended(m_pAudioListener->GetFlagsExtended() | ENTITY_FLAG_EXTENDED_AUDIO_LISTENER);
gEnv->pEntitySystem->AddEntityEventListener(m_pAudioListener->GetId(), ENTITY_EVENT_DONE, this);
CryFixedStringT<64> sTemp;
sTemp.Format("SoundListener(%d)", static_cast<int>(m_pAudioListener->GetId()));
m_pAudioListener->SetName(sTemp.c_str());
IEntityAudioProxyPtr pIEntityAudioProxy = crycomponent_cast<IEntityAudioProxyPtr>(m_pAudioListener->CreateProxy(ENTITY_PROXY_AUDIO));
CRY_ASSERT(pIEntityAudioProxy.get());
}
else
{
CryFatalError("<Sound>: audio listener creation failed in CView ctor!");
}
}
}
int DesignerWarningFunc(const char * message)
{
if (g_pGameCVars->designer_warning_enabled && (!gEnv->IsDedicated()))
{
GameWarning("!DESIGNER WARNING\n%s", message);
}
// kept because autotests gather all designer warnings out of logs with this form
CryLogAlways("---DESIGNER_WARNING: %s", message);
CryLogAlways("----------------------------------------");
#if ENABLE_FEATURE_TESTER
// If feature testing is in progress, write each designer warning out as a failed feature test
CFeatureTester * featureTester = CFeatureTester::GetInstance();
if (featureTester)
{
CAutoTester * autoTestResultWriter = featureTester->GetAutoTesterIfActive();
if (autoTestResultWriter)
{
CryFixedStringT<32> warningName;
warningName.Format("DesignerWarning%04u", s_numDesignerWarningsHit);
autoTestResultWriter->AddSimpleTestCase("DesignerWarnings", warningName.c_str(), 0.1f, message);
}
}
#endif
s_numDesignerWarningsHit++;
return 0;
}
void CView::CreateAudioListener()
{
if (m_pAudioListener == nullptr)
{
SEntitySpawnParams oEntitySpawnParams;
oEntitySpawnParams.sName = "AudioListener";
oEntitySpawnParams.pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass("AudioListener");
m_pAudioListener = gEnv->pEntitySystem->SpawnEntity(oEntitySpawnParams, true);
if (m_pAudioListener != nullptr)
{
// We don't want the audio listener to serialize as the entity gets completely removed and recreated during save/load!
m_pAudioListener->SetFlags(m_pAudioListener->GetFlags() | (ENTITY_FLAG_TRIGGER_AREAS | ENTITY_FLAG_NO_SAVE));
m_pAudioListener->SetFlagsExtended(m_pAudioListener->GetFlagsExtended() | ENTITY_FLAG_EXTENDED_AUDIO_LISTENER);
gEnv->pEntitySystem->AddEntityEventListener(m_pAudioListener->GetId(), ENTITY_EVENT_DONE, this);
CryFixedStringT<64> sTemp;
sTemp.Format("AudioListener(%d)", static_cast<int>(m_pAudioListener->GetId()));
m_pAudioListener->SetName(sTemp.c_str());
IEntityAudioProxyPtr pIEntityAudioProxy = crycomponent_cast<IEntityAudioProxyPtr>(m_pAudioListener->CreateProxy(ENTITY_PROXY_AUDIO));
CRY_ASSERT(pIEntityAudioProxy.get());
}
else
{
CryFatalError("<Audio>: Audio listener creation failed in CView::CreateAudioListener!");
}
}
else
{
m_pAudioListener->SetFlagsExtended(m_pAudioListener->GetFlagsExtended() | ENTITY_FLAG_EXTENDED_AUDIO_LISTENER);
m_pAudioListener->InvalidateTM(ENTITY_XFORM_POS);
}
}
void CItemComponent::GetSharedParameters(XmlNodeRef rootParams)
{
// Parameters get stored under a combination of the class name and the section name for the parameters.
CryFixedStringT<256> sharedName;
sharedName.Format("item::%s::%s", GetEntity()->GetClass()->GetName(), "itemBase");
ISharedParamsManager* pSharedParamsManager = gEnv->pGameFramework->GetISharedParamsManager();
CRY_ASSERT(pSharedParamsManager);
m_itemBaseParameter = CastSharedParamsPtr<SItemBaseParameter>(pSharedParamsManager->Get(sharedName));
// If no parameter set exists we should attempt to create and register one.
if (!m_itemBaseParameter)
{
SItemBaseParameter sharedParams;
// Load in the base item shared parameters.
XmlNodeRef itemBaseParams = rootParams->findChild("itemBase");
if (itemBaseParams)
sharedParams.Read(itemBaseParams);
// Register a new set of parameters and retrieve a shared pointer to them.
m_itemBaseParameter = CastSharedParamsPtr<SItemBaseParameter>(pSharedParamsManager->Register(sharedName, sharedParams));
}
// Double check the shared parameter.
CRY_ASSERT(m_itemBaseParameter.get());
}
CryFixedStringT<64> CPickAndThrowProxy::GetSharedParamsName() const
{
const char* szEntityClassName = m_player.GetEntityClassName();
CryFixedStringT<64> sharedParamsName;
sharedParamsName.Format("%s_%s", SPnTProxyParams::s_typeInfo.GetName(), szEntityClassName);
return sharedParamsName;
}
/*static*/
void CGameBrowser::LocaliseInGamePresenceString(CryFixedStringT<MAX_PRESENCE_STRING_SIZE> &out, const char* stringId, const int32 gameModeId, const int32 mapId)
{
#if USE_CRYLOBBY_GAMESPY
out.Format("%s:%d:%d", stringId, gameModeId, mapId);
#else
out = CHUDUtils::LocalizeString("@mp_rp_gameplay", GetGameModeStringFromId(gameModeId), GetMapStringFromId(mapId));
#endif
}
//------------------------------------------------------------------------
bool CVehicleDamageBehaviorEffect::Init(IVehicle *pVehicle, const CVehicleParams &table)
{
m_pVehicle = pVehicle;
m_pDamageEffect = NULL;
m_slot = -1;
CVehicleParams effectParams = table.findChild("Effect");
if(!effectParams)
{
return false;
}
string effectName = effectParams.getAttr("effect");
CryFixedStringT<256> sharedParamsName;
sharedParamsName.Format("%s::DamageBehaviorEffect::%s", pVehicle->GetEntity()->GetClass()->GetName(), effectName.c_str());
ISharedParamsManager *pSharedParamsManager = CCryAction::GetCryAction()->GetISharedParamsManager();
CRY_ASSERT(pSharedParamsManager);
m_pSharedParams = CastSharedParamsPtr<SSharedParams>(pSharedParamsManager->Get(sharedParamsName));
if(!m_pSharedParams)
{
SSharedParams sharedParams;
sharedParams.effectName = effectName;
sharedParams.damageRatioMin = 1.0f;
sharedParams.updateFromHelper = false;
table.getAttr("damageRatioMin", sharedParams.damageRatioMin);
sharedParams.disableAfterExplosion = false;
effectParams.getAttr("disableAfterExplosion", sharedParams.disableAfterExplosion);
effectParams.getAttr("updateFromHelper", sharedParams.updateFromHelper);
m_pSharedParams = CastSharedParamsPtr<SSharedParams>(pSharedParamsManager->Register(sharedParamsName, sharedParams));
}
CRY_ASSERT(m_pSharedParams.get());
return true;
}
string STransition::GetDescription() const
{
CryFixedStringT<256> sResult;
sResult.Format("signal=%s\ttype=%s\tspeed=%s\tdir=%+3.1f\tarrdir=%+3.1f\ttargtdir=%+3.1f\tjukeAngle=%+3.1f",
animGraphSignal.c_str(),
MovementTransitionsDebug::GetTransitionTypeName(transitionType),
MovementTransitionsDebug::GetPseudoSpeedName(pseudoSpeed),
RAD2DEG(desiredTravelAngle),
RAD2DEG(desiredArrivalAngle),
RAD2DEG(desiredTargetTravelAngle),
RAD2DEG(desiredJukeAngle)
);
return sResult;
}
//------------------------------------------------------------------------
bool CPlaylistActivityTracker::CreatedGame( ILevelRotation::TExtInfoId playlistId, uint32 variantId )
{
bool success = false;
//ensure service is initialised
if(! AnyActiveRequestsOfType( eRTT_AnnounceCreateGame ) )
{
//construct the http request
CryFixedStringT<MAX_CONTENT> httpParams;
httpParams.Format( "?platform=1&playlist=%d&variant=%d", playlistId, variantId );
success = UploadData( "playlist/game_created/", httpParams.c_str(), 1024, eRTT_AnnounceCreateGame );
}
return success;
}
void
CFlowInspectorDefault::DrawLabel( float col,float row,const ColorF& color,float glow,const char* szText,float fScale ) const
{
const float ColumnSize = COL_SIZE;
const float RowSize = ROW_SIZE;
CryFixedStringT<128> msg;
msg.Format("%s", szText ? szText : "No message");
if (glow > 0.1f)
{
ColorF glowColor (color[0],color[1],color[2],glow);
m_pRenderer->Draw2dLabel( (float)(ColumnSize*col+1),(float)(BASE_Y+RowSize*row+1), fScale*1.2f, &glowColor[0],false,"%s", msg.c_str() );
}
ColorF tmp (color);
m_pRenderer->Draw2dLabel( (float)(ColumnSize*col),(float)(BASE_Y+RowSize*row), fScale*1.2f, &tmp[0], false,"%s", msg.c_str() );
}
//------------------------------------------------------------------------
bool CPlaylistActivityTracker::RequestCurrentActivity( PlayListActivityCallback callback )
{
bool success = false;
// Don't start another request if we're already waiting on one
if( ! AnyActiveRequestsOfType( eRTT_RequestActivity ) )
{
CryFixedStringT<MAX_CONTENT> httpParams;
httpParams.Format( "?platform=1");
success = UploadData( "playlist/all_playlist_activity/", httpParams.c_str(), 4096, eRTT_RequestActivity );
m_currentActivityCallback = callback;
}
return success;
}
void CNetLerper::AddNewPoint(const Vec3& inPos, const Vec3& inVel, const Vec3& entityPos, EntityId standingOn)
{
CRY_ASSERT(m_settings);
m_desired.pos = inPos;
m_desired.worldPos = inPos;
m_standingOn = standingOn;
if (IEntity* pGroundEntity = gEnv->pEntitySystem->GetEntity(standingOn))
{
m_desired.worldPos = pGroundEntity->GetWorldTM() * inPos;
}
// Run the desired velocity at slightly below the real velocity
// helps to smooth the lerping since there is large granularity in
// the network quantisation of the velocity
m_desired.vel = inVel * 0.9f;
#if SNAP_ERROR_LOGGING
if (m_snapErrorInProgress)
{
if ((m_pPlayer != NULL) && (!m_pPlayer->IsDead()))
{
CryFixedStringT<128> buffer;
buffer.Format("[netlerper] prediction error ended for [%s] after %fs", m_pPlayer->GetEntity()->GetName(), m_clock);
#if ENABLE_STATOSCOPE
if(gEnv->pStatoscope)
{
gEnv->pStatoscope->AddUserMarker("NetLerper", buffer.c_str());
}
#endif // ENABLE_STATOSCOPE
CryLog(buffer.c_str());
m_snapErrorInProgress = false;
}
}
#endif // SNAP_ERROR_LOGGING
// Zero clock and re calibrate the lerp error
m_clock = 0.f;
m_lerpedError = entityPos - m_desired.worldPos;
m_lerpedPos = m_desired.worldPos;
m_enabled = true;
}
void InitialiseScreenResolutions()
{
#if !defined(CONSOLE)
CryFixedStringT<16> format;
SDispFormat *formats = NULL;
int numFormats = gEnv->pRenderer->EnumDisplayFormats(NULL);
if(numFormats)
{
formats = new SDispFormat[numFormats];
gEnv->pRenderer->EnumDisplayFormats(formats);
}
int lastWidth, lastHeight;
lastHeight = lastWidth = -1;
for(int i = 0; i < numFormats; ++i)
{
if(HasResolution(formats[i].m_Width, formats[i].m_Height))
{
continue;
}
if(formats[i].m_Width < 800)
continue;
format.Format("%i X %i", formats[i].m_Width, formats[i].m_Height);
SScreenResolution resolution(formats[i].m_Width, formats[i].m_Height, formats[i].m_BPP, format.c_str());
s_ScreenResolutions.push_back(resolution);
lastHeight = formats[i].m_Height;
lastWidth = formats[i].m_Width;
}
if(formats)
delete[] formats;
#endif
}
bool CDLCManager::VerifyCRCs(const XmlNodeRef &crcNode, const char* sDLCRootFolder)
{
bool success = true;
CryFixedStringT<ICryPak::g_nMaxPath> path;
int numFiles = crcNode->getChildCount();
XmlString fileName;
uint32 storedCrc;
for (int i=0; i<numFiles; ++i)
{
XmlNodeRef fileNode = crcNode->getChild(i);
if (fileNode->getAttr("name", fileName) &&
fileNode->getAttr("crc", storedCrc))
{
bool useCryFile = false;
#if defined(WIN32) || defined(WIN64)
path.Format("%s/%s", sDLCRootFolder, fileName.c_str());
useCryFile = true;
#else
CryWarning( VALIDATOR_MODULE_GAME, VALIDATOR_ERROR, "No Platform defined in DLCManager" );
#endif
CryLog( "CRC: Checking CRC of %s", path.c_str() );
success = gEnv->pCryPak->OpenPack( path.c_str() );
if( !success )
{
CryLog( "CRC: Failed to open pack" );
}
uint32 computedCrc = gEnv->pCryPak->ComputeCachedPakCDR_CRC( path.c_str(), useCryFile );
if (computedCrc != storedCrc)
{
CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CRC on file %s (%u) does not match stored value (%u)", path.c_str(), computedCrc, storedCrc);
success = false;
}
gEnv->pCryPak->ClosePack( path.c_str() );
}
}
return success;
}
void CNetLerper::LogSnapError()
{
#if SNAP_ERROR_LOGGING
if (!m_snapErrorInProgress)
{
if ((m_pPlayer != NULL) && (!m_pPlayer->IsDead()))
{
CryFixedStringT<128> buffer;
buffer.Format("[netlerper] prediction error started for [%s]", m_pPlayer->GetEntity()->GetName());
#if ENABLE_STATOSCOPE
if(gEnv->pStatoscope)
{
gEnv->pStatoscope->AddUserMarker("NetLerper", buffer.c_str());
}
#endif // ENABLE_STATOSCOPE
CryLog(buffer.c_str());
m_snapErrorInProgress = true;
}
}
#endif // SNAP_ERROR_LOGGING
}
int CScriptBind_Boids::GetUsableMessage(IFunctionHandler *pH, SmartScriptTable flockEntity)
{
CFlock* flock = GetFlock(flockEntity);
IActor* pActor = g_pGame->GetIGameFramework()->GetClientActor();
if (pActor)
{
CPlayer* pPlayer = static_cast<CPlayer*>(pActor);
CryFixedStringT<64> finalString;
CryFixedStringT<64> tempString;
if (pPlayer && !pPlayer->IsInPickAndThrowMode() && flock != NULL)
{
SBoidContext bc;
flock->GetBoidSettings(bc);
tempString.Format("@ui_boid_pickup %s", bc.pickableMessage);
finalString = CHUDUtils::LocalizeString(tempString.c_str());
}
return pH->EndFunction(finalString.c_str());
}
return pH->EndFunction();
}
//------------------------------------------------------------------------
int CScriptBind_Game::CacheResource(IFunctionHandler *pH, const char* whoIsRequesting, const char* resourceName, int resourceType, int resourceFlags)
{
//Only cache in pure game mode
if (gEnv->IsEditor())
return pH->EndFunction();
CGameCache& gameCache = g_pGame->GetGameCache();
switch(resourceType)
{
case eGCRT_Texture:
{
gameCache.CacheTexture(resourceName, resourceFlags);
LogLuaCacheResource(whoIsRequesting, "Texture", resourceName, resourceFlags);
}
break;
case eGCRT_TextureDeferredCubemap:
{
//Some magic strings ops Copy&Pasted from ScriptBind_Entity::ParseLightProperties
const char* specularCubemap = resourceName;
if (specularCubemap && strlen(specularCubemap) > 0)
{
CryFixedStringT<256> sSpecularName(specularCubemap);
int strIndex = sSpecularName.find("_diff");
if(strIndex >= 0)
{
sSpecularName = sSpecularName.substr(0, strIndex) + sSpecularName.substr(strIndex + 5, sSpecularName.length());
specularCubemap = sSpecularName.c_str();
}
CryFixedStringT<256> diffuseCubemap;
diffuseCubemap.Format("%s%s%s.%s", PathUtil::AddSlash(PathUtil::GetPath(specularCubemap).c_str()).c_str(),
PathUtil::GetFileName(specularCubemap).c_str(), "_diff", PathUtil::GetExt(specularCubemap));
// '\\' in filename causing texture duplication
string specularCubemapUnix = PathUtil::ToUnixPath(specularCubemap);
string diffuseCubemapUnix = PathUtil::ToUnixPath(diffuseCubemap.c_str());
gameCache.CacheTexture(specularCubemapUnix.c_str(), resourceFlags);
gameCache.CacheTexture(diffuseCubemapUnix.c_str(), resourceFlags);
LogLuaCacheResource(whoIsRequesting, "CubeMap Specular", specularCubemapUnix.c_str(), resourceFlags);
LogLuaCacheResource(whoIsRequesting, "CubeMap Diffuse", diffuseCubemapUnix.c_str(), resourceFlags);
}
}
break;
case eGCRT_StaticObject:
{
gameCache.CacheGeometry(resourceName);
LogLuaCacheResource(whoIsRequesting, "Static Object", resourceName, resourceFlags);
}
break;
case eGCRT_Material:
{
gameCache.CacheMaterial(resourceName);
LogLuaCacheResource(whoIsRequesting, "Material", resourceName, resourceFlags);
}
break;
}
return pH->EndFunction();
}
void COptionsManager::ResetDefaults(const char* option)
{
if(!m_pPlayerProfileManager)
return;
const char* user = m_pPlayerProfileManager->GetCurrentUser();
IPlayerProfile *pProfile = m_pPlayerProfileManager->GetCurrentProfile(user);
if(!pProfile)
return;
XmlNodeRef root = GetISystem()->LoadXmlFile("libs/config/profiles/default/attributes.xml");
bool resetAll = (option==NULL);
bool detectHardware = false;
for (int i = 0; i < root->getChildCount(); ++i)
{
XmlNodeRef enumNameNode = root->getChild(i);
const char *name = enumNameNode->getAttr("name");
const char *value = enumNameNode->getAttr("value");
if(name && value)
{
const char* attribCVar = "";
bool bWriteToCfg = false;
const bool bIsOption = IsOption(name, attribCVar, bWriteToCfg);
if(bIsOption)
{
if(!resetAll && strcmp(attribCVar,option))
continue;
if(!strcmp(attribCVar, "sys_spec_Shadows"))
{
detectHardware = true;
}
if(!strcmp(attribCVar, "hud_colorLine"))
{
CryFixedStringT<32> color;
color.Format("%d", g_pGameCVars->hud_colorLine);
SetCrysisProfileColor(color.c_str());
}
if(!strcmp(attribCVar,"pb_client"))
{
if(atoi(value)==0)
{
m_pbEnabled = false;
gEnv->pConsole->ExecuteString("net_pb_cl_enable false");
}
else
{
m_pbEnabled = true;
gEnv->pConsole->ExecuteString("net_pb_cl_enable true");
}
}
else if(!strcmp(attribCVar, "g_difficultyLevel"))
{
SetDifficulty(value);
}
else
{
ICVar *pCVar = gEnv->pConsole->GetCVar(attribCVar);
if(pCVar)
{
pCVar->Set(value);
}
}
if(!resetAll)
break;
}
}
}
if(detectHardware)
AutoDetectHardware("");
}
void CDownloadableResource::StartDownloading()
{
if (m_state==k_notStarted)
{
if (m_port==0)
{
GameWarning("Error tried to start downloading on unconfigured CDownloadableResource");
m_state=k_failedInternalError;
}
else
{
STCPServiceDataPtr pTransaction(NULL);
m_pService=gEnv->pNetwork->GetLobby()->GetLobbyService()->GetTCPService(m_server,m_port);
if (m_pService)
{
static const int MAX_HEADER_SIZE=300;
CryFixedStringT<MAX_HEADER_SIZE> httpHeader;
// For HTTP 1.0.
/*httpHeader.Format(
"GET /%s%s HTTP/1.0\n"
"\n",
m_urlPrefix.c_str(),
m_url.c_str());*/
// For HTTP 1.1. Needed to download data from servers that are "multi-homed"
httpHeader.Format(
"GET /%s%s HTTP/1.1\n"
"Host: %s:%d\n"
"\n",
m_urlPrefix.c_str(),
m_url.c_str(),
m_server.c_str(),
m_port);
pTransaction=new STCPServiceData();
if (pTransaction)
{
int len=httpHeader.length();
pTransaction->length=len;
pTransaction->pData=new char[len];
if (pTransaction->pData)
{
memcpy(pTransaction->pData,httpHeader.c_str(),len);
pTransaction->tcpServReplyCb=ReceiveDataCallback;
pTransaction->pUserArg=this; // do ref counting manually for callback data
this->AddRef();
#if DOWNLOAD_MGR_DBG
m_downloadStarted=gEnv->pTimer->GetAsyncCurTime();
#endif
m_state=k_awaitingHTTPResponse;
if (!m_pService->UploadData(pTransaction))
{
this->Release();
pTransaction=NULL;
}
}
else
{
pTransaction=NULL;
}
}
}
if (!pTransaction)
{
m_state=k_failedInternalError;
}
}
}
}
//-------------------------------------------------------------------------
// Process a search result.
void CGameBrowser::MatchmakingSessionSearchCallback(CryLobbyTaskID taskID, ECryLobbyError error, SCrySessionSearchResult* session, void* arg)
{
#ifdef USE_C2_FRONTEND
CFlashFrontEnd *menu = g_pGame->GetFlashMenu();
CMPMenuHub *mpMenuHub = menu ? menu->GetMPMenu() : NULL;
CGameBrowser* pGameBrowser = (CGameBrowser*) arg;
if (error == eCLE_SuccessContinue || error == eCLE_Success)
{
if(session && mpMenuHub != NULL && GameLobbyData::IsCompatibleVersion(GameLobbyData::GetSearchResultsData(session, LID_MATCHDATA_VERSION)))
{
CUIServerList::SServerInfo si;
si.m_hostName = session->m_data.m_name;
CRY_TODO(20, 5, 2010, "In the case where too many servers have been filtered out, start a new search query and merge the results with the existing ones");
int requiredDLCs = GameLobbyData::GetSearchResultsData(session, LID_MATCHDATA_REQUIRED_DLCS);
CryLog("Found server (%s), num data (%d): with DLC version %d", si.m_hostName.c_str(), session->m_data.m_numData, requiredDLCs);
if (g_pGameCVars->g_ignoreDLCRequirements || CDLCManager::MeetsDLCRequirements(requiredDLCs, g_pGame->GetDLCManager()->GetSquadCommonDLCs()) || pGameBrowser->m_bFavouriteIdSearch)
{
si.m_numPlayers = session->m_numFilledSlots;
si.m_maxPlayers = session->m_data.m_numPublicSlots;
si.m_gameTypeName = GameLobbyData::GetGameRulesFromHash(GameLobbyData::GetSearchResultsData(session, LID_MATCHDATA_GAMEMODE));
si.m_gameTypeDisplayName = si.m_gameTypeName.c_str();
si.m_mapName = GameLobbyData::GetMapFromHash(GameLobbyData::GetSearchResultsData(session, LID_MATCHDATA_MAP));
si.m_mapDisplayName = PathUtil::GetFileName(si.m_mapName.c_str()).c_str();
si.m_friends = (session->m_numFriends>0);
si.m_reqPassword = session->m_flags&eCSSRF_RequirePassword;
uint32 variantId = GameLobbyData::GetSearchResultsData(session, LID_MATCHDATA_VARIANT);
CPlaylistManager *pPlaylistManager = g_pGame->GetPlaylistManager();
if (pPlaylistManager)
{
const SGameVariant* pVariant = pPlaylistManager->GetVariant(variantId);
if (pVariant)
{
si.m_gameVariantName = pVariant->m_name.c_str();
si.m_gameVariantDisplayName = CHUDUtils::LocalizeString(pVariant->m_localName.c_str());
}
}
// Get more readable map name and game type
if (ILocalizationManager* pLocMgr = gEnv->pSystem->GetLocalizationManager())
{
si.m_mapDisplayName = CHUDUtils::LocalizeString(g_pGame->GetMappedLevelName(si.m_mapDisplayName.c_str()));
CryFixedStringT<64> tmpString;
tmpString.Format("ui_rules_%s", si.m_gameTypeName.c_str());
SLocalizedInfoGame outInfo;
if (pLocMgr->GetLocalizedInfoByKey(tmpString.c_str(), outInfo))
{
wstring wcharstr = outInfo.swTranslatedText;
CryStringUtils::WStrToUTF8(wcharstr, si.m_gameTypeDisplayName);
}
}
#if USE_CRYLOBBY_GAMESPY
int numData = session->m_data.m_numData;
for (int i=0; i<numData; ++i)
{
SCryLobbyUserData& pUserData = session->m_data.m_data[i];
if (pUserData.m_id == LID_MATCHDATA_FAVOURITE_ID)
{
CRY_ASSERT(pUserData.m_type == eCLUDT_Int32);
if (pUserData.m_type == eCLUDT_Int32)
{
si.m_sessionFavouriteKeyId = pUserData.m_int32;
}
}
else if ((pUserData.m_id == LID_MATCHDATA_REGION))
{
CRY_ASSERT(pUserData.m_type == eCLUDT_Int32);
if (pUserData.m_type == eCLUDT_Int32)
{
si.m_region = pUserData.m_int32;
}
}
else if ((pUserData.m_id == LID_MATCHDATA_OFFICIAL))
{
CRY_ASSERT(pUserData.m_type == eCLUDT_Int32);
if (pUserData.m_type == eCLUDT_Int32)
{
si.m_official = (pUserData.m_int32!=0);
}
}
}
#endif
// FIXME :
// Make server id unique in some other way....
si.m_serverId = (int)session->m_id.get(); // for lack of unique ids deref the pointer location of the server. This is the id that gets sent to flash...
si.m_sessionId = session->m_id;
si.m_ping = session->m_ping;
if (pGameBrowser->m_bFavouriteIdSearch)
{
#if IMPLEMENT_PC_BLADES
if (si.m_sessionFavouriteKeyId != INVALID_SESSION_FAVOURITE_ID)
{
for (uint32 i = 0; i < pGameBrowser->m_currentSearchFavouriteIdIndex; ++i)
{
if (si.m_sessionFavouriteKeyId == pGameBrowser->m_searchFavouriteIds[i])
{
g_pGame->GetGameServerLists()->ServerFound(si, pGameBrowser->m_currentFavouriteIdSearchType, si.m_sessionFavouriteKeyId);
// Invalidate any current search favourite ids, as it has been found
pGameBrowser->m_searchFavouriteIds[i] = INVALID_SESSION_FAVOURITE_ID;
break;
}
}
}
#endif
}
else
{
mpMenuHub->AddServer(si);
}
}
}
}
else if (error != eCLE_SuccessUnreachable)
{
CryLogAlways("CGameBrowser search for sessions error %d", (int)error);
CGameLobby::ShowErrorDialog(error, NULL, NULL, NULL);
}
if ((error != eCLE_SuccessContinue) && (error != eCLE_SuccessUnreachable))
{
CryLogAlways("CCGameBrowser::MatchmakingSessionSearchCallback DONE");
pGameBrowser->FinishedSearch(true, !pGameBrowser->m_bFavouriteIdSearch); // FavouriteId might start another search after this one has finished
}
#endif //#ifdef USE_C2_FRONTEND
}
//-----------------------------------------------------------------------
void CSpectacularKill::ReadXmlData( const IItemParamsNode* pRootNode)
{
CRY_ASSERT(pRootNode);
ISharedParamsManager* pSharedParamsManager = gEnv->pGame->GetIGameFramework()->GetISharedParamsManager();
CRY_ASSERT(pSharedParamsManager);
// If we change the SharedParamsManager to accept CRCs on its interface we could compute this once and store
// the name's CRC32 instead of constructing it here each time this method is invoked (it shouldn't be invoked
// too often, though)
const char* szEntityClassName = m_pOwner->GetEntityClassName();
CryFixedStringT<64> sharedParamsName;
sharedParamsName.Format("%s_%s", SSharedSpectacularParams::s_typeInfo.GetName(), szEntityClassName);
ISharedParamsConstPtr pSharedParams = pSharedParamsManager->Get(sharedParamsName);
if (pSharedParams)
{
m_pParams = CastSharedParamsPtr<SSharedSpectacularParams>(pSharedParams);
return;
}
m_pParams.reset();
const IItemParamsNode* pParams = pRootNode->GetChild("SpectacularKill");
if (pParams)
{
SSharedSpectacularParams newParams;
const int childCount = pParams->GetChildCount();
newParams.paramsList.reserve(childCount);
for (int i = 0; i < childCount; ++i)
{
const IItemParamsNode* pTargetParams = pParams->GetChild(i);
CRY_ASSERT(pTargetParams);
IEntityClass* pTargetClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(pTargetParams->GetName());
if (pTargetClass)
{
SSpectacularKillParams targetParams;
const IItemParamsNode* pChildParamsNode = pTargetParams->GetChild("Params");
const IItemParamsNode* pChildAnimsNode = pTargetParams->GetChild("Anims");
targetParams.pEnemyClass = pTargetClass;
if(pChildParamsNode)
{
pChildParamsNode->GetAttribute("impulseScale", targetParams.impulseScale);
const char* szImpulseBone = pChildParamsNode->GetAttributeSafe("impulseBone");
ICharacterInstance* pCharacter = m_pOwner->GetEntity()->GetCharacter(0);
targetParams.impulseBone = pCharacter ? pCharacter->GetIDefaultSkeleton().GetJointIDByName(szImpulseBone) : -1;
}
if(pChildAnimsNode)
{
const int animCount = pChildAnimsNode->GetChildCount();
targetParams.animations.reserve(animCount);
for(int j = 0; j < animCount; j++)
{
const IItemParamsNode* pAnimNode = pChildAnimsNode->GetChild(j);
if(pAnimNode)
{
SSpectacularKillAnimation newAnimation;
newAnimation.victimAnimation = pAnimNode->GetAttributeSafe("victimAnimation");
newAnimation.killerAnimation = pAnimNode->GetAttributeSafe("killerAnimation");
pAnimNode->GetAttribute("optimalDist", newAnimation.optimalDist);
if (pAnimNode->GetAttribute("targetToKillerAngle", newAnimation.targetToKillerAngle))
newAnimation.targetToKillerAngle = DEG2RAD(newAnimation.targetToKillerAngle);
if (pAnimNode->GetAttribute("targetToKillerAngleRange", newAnimation.targetToKillerMinDot))
newAnimation.targetToKillerMinDot = cos_tpl(DEG2RAD(newAnimation.targetToKillerMinDot) / 2.0f);
pAnimNode->GetAttribute("obstacleCheckStartOffset", newAnimation.vKillerObstacleCheckOffset);
pAnimNode->GetAttribute("obstacleCheckLength", newAnimation.fObstacleCheckLength);
targetParams.animations.push_back(newAnimation);
}
}
}
CRY_ASSERT_MESSAGE(targetParams.animations.size() > 0, string().Format("No Animations defined for %s spectacular kill", pTargetClass->GetName()));
newParams.paramsList.push_back(targetParams);
}
#ifdef SPECTACULAR_KILL_DEBUG
else
{
GameWarning("spectacular Kill: Couldn't find entity of class '%s', skipping", pTargetParams->GetName());
}
#endif
}
m_pParams = CastSharedParamsPtr<SSharedSpectacularParams>(pSharedParamsManager->Register(sharedParamsName, newParams));
}
}
const char* CFlowGraphModuleManager::GetCallerNodeName(const char* moduleName) const
{
static CryFixedStringT<64> temp;
temp.Format("Module:Call_%s", moduleName);
return temp.c_str();
}
