void CUISettings::SendSoundChange()
{
SUIArguments args;
args.AddArgument(m_pMusicVar->GetFVal());
args.AddArgument(m_pSFxVar->GetFVal());
args.AddArgument(m_pVideoVar->GetFVal());
m_pUIFunctions->SendEvent(SUIEvent(m_EventMap[EUIE_SoundSettingsChanged], args));
}
void CUISettings::SendResChange()
{
SUIArguments args;
args.AddArgument(m_pRXVar->GetIVal());
args.AddArgument(m_pRYVar->GetIVal());
args.AddArgument(m_pFSVar->GetIVal() != 0);
m_pUIFunctions->SendEvent(SUIEvent(m_EventMap[EUIE_ResolutionChanged], args));
}
// ui functions
void CUISettings::SendResolutions()
{
SUIArguments args;
for (TResolutions::iterator it = m_Resolutions.begin(); it != m_Resolutions.end(); ++it)
{
args.AddArgument(it->first);
args.AddArgument(it->second);
}
m_pUIFunctions->SendEvent(SUIEvent(m_EventMap[EUIE_OnGetResolutions], args));
}
void CUIMultiPlayer::PlayerLeaved(EntityId playerid, const string& name)
{
if (gEnv->pGame->GetIGameFramework()->GetClientActorId() == playerid)
return;
SUIArguments args;
args.AddArgument(playerid);
args.AddArgument(name);
m_pUIFunctions->SendEvent(SUIEvent(m_EventMap[EUIE_PlayerLeaved], args));
}
//--------------------------------------------------------------------------------------------
void CUIObjectives::MissionObjectiveStateChanged( const string& objectiveID, int state )
{
SMissionObjectiveInfo* pInfo = GetMissionObjectiveInfo( objectiveID );
if ( pInfo )
{
SUIArguments args;
args.AddArgument( objectiveID );
args.AddArgument( state );
NotifyUI( eUIOE_ObjectiveStateChanged, args );
}
}
void CUIMultiPlayer::PlayerKilled(EntityId playerid, EntityId shooterid)
{
SUIArguments args;
IEntity* pEntity = gEnv->pEntitySystem->GetEntity(playerid);
assert(pEntity);
IEntity* pShooterEntity = gEnv->pEntitySystem->GetEntity(shooterid);
assert(pShooterEntity);
args.AddArgument(playerid);
args.AddArgument(pEntity ? string(pEntity->GetName()) : string(UNDEF_ENTITY_NAME));
args.AddArgument(shooterid);
args.AddArgument(pShooterEntity ? string(pShooterEntity->GetName()) : string("undefined"));
m_pUIFunctions->SendEvent(SUIEvent(m_EventMap[EUIE_PlayerKilled], args));
}
void CFlashUIFromArrayNode::ProcessEvent( EFlowEvent event,SActivationInfo* pActInfo )
{
if (event == eFE_Activate && IsPortActive( pActInfo, eI_Array ))
{
SUIArguments args( GetPortString( pActInfo, eI_Array ).c_str());
ActivateOutput( pActInfo, eO_Count, args.GetArgCount());
SUIArguments leftOver;
int port = eO_Val1;
for (int i = 0; i < args.GetArgCount(); ++i)
{
string arg;
args.GetArg( i, arg );
if (port + i < eO_LeftOver)
{
ActivateOutput( pActInfo, port + i, arg );
}
else
{
leftOver.AddArgument( arg );
}
}
if (leftOver.GetArgCount() > 0)
{
ActivateOutput( pActInfo, eO_LeftOver, string( leftOver.GetAsString()));
}
}
}
//------------------------------------------------------------------------
void SUIElementLuaCallback::OnUIEventEx( IUIElement* pSender, const char* fscommand, const SUIArguments& args, void* pUserData )
{
SUIArguments luaArgs;
luaArgs.AddArgument(fscommand);
luaArgs.AddArguments(args);
NotifyEvent(SUILuaCallbackInfo<IUIElement>::CreateInfo(pSender, "OnUIEventEx"), luaArgs);
}
////////////////////////////////////////////////////////////////////////////
// ui functions
////////////////////////////////////////////////////////////////////////////
void CUISettings::SendResolutions()
{
SUIArguments resolutions;
for(int i = 0; i < m_Resolutions.size(); ++i)
{
string res;
res.Format("%i x %i", m_Resolutions[i].first, m_Resolutions[i].second);
m_eventSender.SendEvent<eUIE_OnGetResolutionItems>(res, (int)i);
resolutions.AddArgument(m_Resolutions[i].first);
resolutions.AddArgument(m_Resolutions[i].second);
}
m_eventSender.SendEvent<eUIE_OnGetResolutions>(resolutions);
}
void CUIObjectives::MissionObjectiveAdded( const string& objectiveID, int state )
{
if ( gEnv->IsEditor() )
{
UpdateObjectiveInfo();
}
SMissionObjectiveInfo* pInfo = GetMissionObjectiveInfo( objectiveID );
if ( pInfo )
{
SUIArguments args;
args.AddArgument( objectiveID );
args.AddArgument( pInfo->Name );
args.AddArgument( pInfo->Desc );
args.AddArgument( state );
NotifyUI( eUIOE_ObjectiveAdded, args );
}
}
// ---------------------------------------------------------------
void CFlashUIBaseNodeDynPorts::GetDynInput( SUIArguments &args, const SUIParameterDesc &desc, SActivationInfo* pActInfo, int port)
{
switch (desc.eType)
{
case SUIParameterDesc::eUIPT_Bool:
args.AddArgument( GetPortBool(pActInfo, port));
break;
case SUIParameterDesc::eUIPT_Int:
args.AddArgument( GetPortInt(pActInfo, port));
break;
case SUIParameterDesc::eUIPT_Float:
args.AddArgument( GetPortFloat(pActInfo, port));
break;
case SUIParameterDesc::eUIPT_String:
args.AddArgument( GetPortString(pActInfo, port));
break;
case SUIParameterDesc::eUIPT_WString:
args.AddArgument( GetPortString(pActInfo, port), eUIDT_WString );
break;
case SUIParameterDesc::eUIPT_Vec3:
args.AddArgument( GetPortVec3(pActInfo, port));
break;
default:
{
string val;
const TFlowInputData data = GetPortAny(pActInfo, port);
data.GetValueWithConversion(val);
args.AddArgument(val, eUIDT_Any);
}
break;
}
}
void CReadSendPacket::ReadGameServers(SPacket packet)
{
gEnv->pLog->Log(TITLE "Read game server info packet...");
Packet* p = new Packet((const unsigned char*)packet.data, packet.size);
p->decodeBlowfish(gClientEnv->bBlowFish);
/****************************Обязательный блок************************************/
EPacketType type = (EPacketType)p->readInt(); // Packet type
const char* version = p->readString(); // Packet version
/*********************************************************************************/
int serversCount = p->readInt();
for (int i = 0 ; i != serversCount; i++)
{
SGameServer Server; SUIArguments args;
Server.id = p->readInt(); // id сервера
Server.ip = p->readString(); // ip сервера
Server.port = p->readInt(); // Порт сервера
Server.serverName = p->readString(); // Название сервера
Server.currentPlayers = p->readInt(); // Онлайн на сервере
Server.maxPlayers = p->readInt(); // Максимальное кол-во игроков
Server.mapName = p->readString(); // Название карты
Server.gameRules = p->readString(); // Режим игры
if(Server.port)
{
char tmp[64];
sprintf(tmp, "%d/%d", Server.currentPlayers, Server.maxPlayers);
args.AddArgument(Server.id);
args.AddArgument(Server.ip);
args.AddArgument(Server.port);
args.AddArgument(Server.serverName);
args.AddArgument(tmp);
args.AddArgument((const char*)Server.mapName);
args.AddArgument((const char*)Server.gameRules);
args.AddArgument(gClientEnv->pPing->Ping(Server.ip));
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_GameServerInfo, args);
gClientEnv->pMasterServer->vServers.push_back(Server);
}
}
const char* endBlock = p->readString(); // Завершающий блок
if(strcmp(endBlock,EndBlock))
{
gEnv->pLog->LogWarning(TITLE "Game servers packet damaged!");
}
delete p;
}
//--------------------------------------------------------------------------------------------
void CUIObjectives::MissionObjectiveRemoved( const string& objectiveID )
{
SMissionObjectiveInfo* pInfo = GetMissionObjectiveInfo( objectiveID );
if ( pInfo )
{
SUIArguments args;
args.AddArgument( objectiveID );
NotifyUI( eUIOE_ObjectiveRemoved, args );
}
}
//------------------------------------------------------------------------
bool SUIToLuaConversationHelper::LuaArgsToUIArgs(IFunctionHandler* pH, int startIdx, SUIArguments &args)
{
for (int i = startIdx; i <= pH->GetParamCount(); ++i)
{
TUIData val;
if (!LuaArgToUIArg(pH, i, val))
{
return false;
}
args.AddArgument(val);
}
return true;
}
//------------------------------------------------------------------------
bool SUIToLuaConversationHelper::LuaTableToUIArgs(SmartScriptTable table, SUIArguments &args)
{
for (int i = 0; i <= table->Count(); ++i)
{
if (i == 0 && table->GetAtType(0) == svtNull)
continue; // if passing {arg1, arg2, arg3} to scriptbind first entry will be nil
TUIData val;
if (!SUIConvHelperTmpl::LuaArgToUIArgImpl(table, i, val))
return false;
args.AddArgument( val );
}
return true;
}
void CFlashUIEventNode::FlushNextEvent( SActivationInfo* pActInfo )
{
if (m_events.size() > 0)
{
const std::pair<SUIArguments, int> &data = m_events.get();
const SUIArguments & args = data.first;
bool bTriggerEvent = true;
const int checkValue = GetPortInt(pActInfo, eI_CheckPort);
if (checkValue >= 0)
{
bTriggerEvent = false;
CRY_ASSERT_MESSAGE(checkValue < args.GetArgCount(), "Port does not exist!" );
if (checkValue < args.GetArgCount())
{
string val = GetPortString(pActInfo, eI_CheckValue);
string compstr;
args.GetArg(checkValue).GetValueWithConversion(compstr);
bTriggerEvent = val == compstr;
}
}
if (bTriggerEvent)
{
int end = m_eventDesc.InputParams.Params.size();
string val;
int i = 0;
for (; i < end; ++i)
{
CRY_ASSERT_MESSAGE( i < args.GetArgCount(), "UIEvent received wrong number of arguments!" );
ActivateDynOutput( i < args.GetArgCount() ? args.GetArg(i) : TUIData(string("")), m_eventDesc.InputParams.Params[i], pActInfo, i + 2 );
}
if (m_eventDesc.InputParams.IsDynamic)
{
SUIArguments dynarg;
for (; i < args.GetArgCount(); ++i)
{
if (args.GetArg( i, val ))
dynarg.AddArgument( val );
}
ActivateOutput( pActInfo, end + eO_DynamicPorts, string( dynarg.GetAsString()));
}
ActivateOutput( pActInfo, eO_OnEvent, true );
ActivateOutput( pActInfo, eO_OnInstanceId, data.second );
}
m_events.pop();
}
}
void CUIManager::UpdatePickupMessage(bool bShow)
{
if (!gEnv->pFlashUI) return;
if (m_bPickupMsgVisible != bShow)
{
m_bPickupMsgVisible = bShow;
static IUIAction* pAction = gEnv->pFlashUI->GetUIAction("DisplayPickupText");
if (pAction)
{
SUIArguments args;
args.AddArgument(bShow ? string("@ui_pickup") : string(""));
gEnv->pFlashUI->GetUIActionManager()->StartAction(pAction, args);
}
}
}
void CFlashUIToArrayNode::ProcessEvent( EFlowEvent event, SActivationInfo* pActInfo )
{
if (event == eFE_Activate && IsPortActive( pActInfo, eI_Set ))
{
int count = GetPortInt( pActInfo, eI_Count );
int port = eI_Val1;
SUIArguments args;
for (int i = 0; i < count; ++i)
{
TFlowInputData data = GetPortAny( pActInfo, port + i );
string val;
data.GetValueWithConversion( val );
args.AddArgument( val );
}
ActivateOutput( pActInfo, eO_OnSet, true );
ActivateOutput( pActInfo, eO_ArgList, string( args.GetAsString()));
}
}
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo )
{
switch (event)
{
case eFE_Initialize:
break;
case eFE_Activate:
IGameFramework* pGameFramework = gEnv->pGame->GetIGameFramework();
if(IsPortActive(pActInfo, EIP_Cast))
{
// setup ray + optionally skip 1 entity
ray_hit rayHit;
static const float maxRayDist = 100.f;
const unsigned int flags = rwi_stop_at_pierceable|rwi_colltype_any;
IPhysicalEntity *skipList[1];
int skipCount = 0;
IEntity* skipEntity = gEnv->pEntitySystem->GetEntity(GetPortEntityId(pActInfo, EIP_SkipEntity));
if(skipEntity)
{
skipList[0] = skipEntity->GetPhysics();
skipCount = 1;
}
Vec3 rayPos = GetPortVec3(pActInfo, EIP_RayPos);
Vec3 rayDir = GetPortVec3(pActInfo, EIP_RayDir);
// Check if the ray hits an entity
if(gEnv->pSystem->GetIPhysicalWorld()->RayWorldIntersection(rayPos, rayDir * 100, ent_all, flags, &rayHit, 1, skipList, skipCount))
{
int type = rayHit.pCollider->GetiForeignData();
if (type == PHYS_FOREIGN_ID_ENTITY)
{
IEntity* pEntity = (IEntity*)rayHit.pCollider->GetForeignData(PHYS_FOREIGN_ID_ENTITY);
IEntityRenderProxy* pRenderProxy = pEntity ? (IEntityRenderProxy*)pEntity->GetProxy(ENTITY_PROXY_RENDER) : 0;
// Get the renderproxy, and use it to check if the material is a DynTex, and get the UIElement if so
if(pRenderProxy)
{
IRenderNode *pRenderNode = pRenderProxy->GetRenderNode();
IMaterial* pMaterial = pRenderProxy->GetRenderMaterial();
SEfResTexture* texture = 0;
if(pMaterial && pMaterial->GetShaderItem().m_pShaderResources)
texture= pMaterial->GetShaderItem().m_pShaderResources->GetTexture(EFTT_DIFFUSE);
IUIElement* pElement = texture ? gEnv->pFlashUI->GetUIElementByInstanceStr(texture->m_Name) : 0;
if(pElement && pRenderNode)
{
int m_dynTexGeomSlot = 0;
IStatObj* pObj = pRenderNode->GetEntityStatObj(m_dynTexGeomSlot);
// result
bool hasHit = false;
Vec2 uv0, uv1, uv2;
Vec3 p0, p1, p2;
Vec3 hitpos;
// calculate ray dir
CCamera cam = gEnv->pRenderer->GetCamera();
if (pEntity->GetSlotFlags(m_dynTexGeomSlot) & ENTITY_SLOT_RENDER_NEAREST)
{
ICVar *r_drawnearfov = gEnv->pConsole->GetCVar("r_DrawNearFoV");
assert(r_drawnearfov);
cam.SetFrustum(cam.GetViewSurfaceX(),cam.GetViewSurfaceZ(),DEG2RAD(r_drawnearfov->GetFVal()),cam.GetNearPlane(),cam.GetFarPlane(), cam.GetPixelAspectRatio());
}
Vec3 vPos0 = rayPos;
Vec3 vPos1 = rayPos + rayDir;
// translate into object space
const Matrix34 m = pEntity->GetWorldTM().GetInverted();
vPos0 = m * vPos0;
vPos1 = m * vPos1;
// walk through all sub objects
const int objCount = pObj->GetSubObjectCount();
for (int obj = 0; obj <= objCount && !hasHit; ++obj)
{
Vec3 vP0, vP1;
IStatObj* pSubObj = NULL;
if (obj == objCount)
{
vP0 = vPos0;
vP1 = vPos1;
pSubObj = pObj;
}
else
{
IStatObj::SSubObject* pSub = pObj->GetSubObject(obj);
const Matrix34 mm = pSub->tm.GetInverted();
vP0 = mm * vPos0;
vP1 = mm * vPos1;
pSubObj = pSub->pStatObj;
}
IRenderMesh* pMesh = pSubObj ? pSubObj->GetRenderMesh() : NULL;
if (pMesh)
{
const Ray ray(vP0, (vP1-vP0).GetNormalized() * maxRayDist);
hasHit = RayIntersectMesh(pMesh, pMaterial, pElement, ray, hitpos, p0, p1, p2, uv0, uv1, uv2);
}
}
// skip if not hit
if (!hasHit)
{
ActivateOutput(pActInfo, EOP_Failed, 1);
return;
}
// calculate vectors from hitpos to vertices p0, p1 and p2:
const Vec3 v0 = p0-hitpos;
const Vec3 v1 = p1-hitpos;
const Vec3 v2 = p2-hitpos;
// calculate factors
const float h = (p0-p1).Cross(p0-p2).GetLength();
const float f0 = v1.Cross(v2).GetLength() / h;
const float f1 = v2.Cross(v0).GetLength() / h;
const float f2 = v0.Cross(v1).GetLength() / h;
// find the uv corresponding to hitpos
Vec3 uv = uv0 * f0 + uv1 * f1 + uv2 * f2;
// translate to flash space
int x, y, width, height;
float aspect;
pElement->GetFlashPlayer()->GetViewport(x, y, width, height, aspect);
int iX = int_round(uv.x * (float)width);
int iY = int_round(uv.y * (float)height);
// call the function provided if it is present in the UIElement description
string funcName = GetPortString(pActInfo, EIP_CallFunction);
const SUIEventDesc* eventDesc = pElement->GetFunctionDesc(funcName);
if(eventDesc)
{
SUIArguments arg;
arg.AddArgument(iX);
arg.AddArgument(iY);
pElement->CallFunction(eventDesc->sName, arg);
}
ActivateOutput(pActInfo, EOP_Success, 1);
}
}
}
}
ActivateOutput(pActInfo, EOP_Failed, 1);
}
break;
}
}
void CPacketQueue::Thread()
{
gEnv->pLog->Log(TITLE "Send/Read packets thread started!");
while(!gEnv->pSystem->IsQuitting())
{
send_mutex.lock();
if(packetsInSendQueue>0)
{
//gEnv->pLog->Log("[CryMasterServer] Sending packet...");
SPacket packet;
std::vector <SPacket>::iterator it;
it = SendPackets.begin();
packet.addr = (*it).addr;
packet.data = (*it).data;
packet.size = (*it).size;
send(packet.addr,packet.data,packet.size,0);
SendPackets.erase(it);
packetsInSendQueue--;
}
send_mutex.unlock();
read_mutex.lock();
if(packetsInReadQueue>0)
{
//gEnv->pLog->Log("[CryMasterServer] Reding packet...");
SPacket Packet;
SPlayer Player;
std::vector <SPacket>::iterator it;
it = ReadPackets.begin();
Packet.addr = (*it).addr;
Packet.data = (*it).data;
Packet.size = (*it).size;
EPacketType packetType = gClientEnv->pRsp->GetPacketType(Packet);
switch (packetType)
{
case PACKET_IDENTIFICATION:
gEnv->pLog->Log(TITLE "Identification packet recived");
break;
case PACKET_ACCOUNT:
{
gEnv->pLog->Log(TITLE "Account info packet recived");
gClientEnv->masterPlayer = gClientEnv->pRsp->ReadAccountInfo(Packet);
SPlayer Player;
SUIArguments args;
Player = gClientEnv->masterPlayer;
if(Player.playerId != 0)
{
args.AddArgument(Player.nickname.c_str());
args.AddArgument(Player.level);
args.AddArgument(Player.money);
args.AddArgument(Player.xp);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_AccountInfoResived, args);
}
break;
}
case PACKET_MESSAGE:
{
SMessage Message = gClientEnv->pRsp->ReadMsg(Packet);
if(strcmp(Message.message,""))
{
switch (Message.area)
{
case CHAT_MESSAGE_GLOBAL:
{
gEnv->pLog->Log(TITLE "Global chat message recived");
SUIArguments args;
args.AddArgument(Message.message);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_MsgResived, args);
break;
}
case CHAT_MESSAGE_PRIVATE:
break;
case CHAT_MESSAGE_SYSTEM:
{
gClientEnv->serverResult = Message.message;
gEnv->pLog->Log(TITLE "System message recived [%s]", gClientEnv->serverResult.c_str());
break;
}
default:
break;
}
}
break;
}
case PACKET_REQUEST:
{
gEnv->pLog->Log(TITLE "Request packet recived");
SRequestPacket svRequest = gClientEnv->pRsp->ReadRequest(Packet);
if(!strcmp(svRequest.request,"RemoveGameServer"))
{
SUIArguments args;
args.AddArgument(svRequest.iParam);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_RemoveServer, args);
std::vector <SGameServer>::iterator it;
bool find = false;
// Delete game server
for(it = gClientEnv->pMasterServer->vServers.begin(); it!= gClientEnv->pMasterServer->vServers.end(); ++it)
{
if(it->id == svRequest.iParam)
{
find = true;
break;
}
}
if(find) gClientEnv->pMasterServer->vServers.erase(it);
}
break;
}
case PACKET_MS_INFO:
{
gEnv->pLog->Log(TITLE "Master server info packet recived");
gClientEnv->serverInfo = gClientEnv->pRsp->ReadMasterServerInfo(Packet);
if(gClientEnv->serverInfo.playersOnline)
{
SUIArguments args;
args.AddArgument(gClientEnv->serverInfo.playersOnline);
args.AddArgument(gClientEnv->serverInfo.gameServersOnline);
CMsEvents::GetInstance()->SendEvent(CMsEvents::eUIGE_ServerInfoResived, args);
}
break;
}
case PACKET_GAME_SERVERS:
{
gEnv->pLog->Log( TITLE "Game servers packet recived");
gClientEnv->pRsp->ReadGameServers(Packet);
break;
}
case PACKET_CONSOLE_COMMAND:
{
gEnv->pLog->Log(TITLE "Console command packet recieved");
gClientEnv->pRsp->ReadConsoleCommandPacket(Packet);
break;
}
default:
gEnv->pLog->Log( TITLE "Unknown packet recived...");
break;
}
ReadPackets.erase(it);
packetsInReadQueue--;
}
read_mutex.unlock();
CrySleep(1);
}
}
