void CALifeSwitchManager::add_online(CSE_ALifeDynamicObject *object, bool update_registries)
{
START_PROFILE("ALife/switch/add_online")
VERIFY ((ai().game_graph().vertex(object->m_tGraphID)->level_id() == graph().level().level_id()));
object->m_bOnline = true;
NET_Packet tNetPacket;
CSE_Abstract *l_tpAbstract = smart_cast<CSE_Abstract*>(object);
server().entity_Destroy (l_tpAbstract);
object->s_flags.or (M_SPAWN_UPDATE);
ClientID clientID;
clientID.set (server().GetServerClient() ? server().GetServerClient()->ID.value() : 0);
server().Process_spawn (tNetPacket,clientID,FALSE,l_tpAbstract);
object->s_flags.and (u16(-1) ^ M_SPAWN_UPDATE);
R_ASSERT3 (!object->used_ai_locations() || ai().level_graph().valid_vertex_id(object->m_tNodeID),"Invalid vertex for object ",object->name_replace());
#ifdef DEBUG
if (psAI_Flags.test(aiALife))
Msg ("[LSS] Spawning object [%s][%s][%d]",object->name_replace(),*object->s_name,object->ID);
#endif
object->add_online (update_registries);
STOP_PROFILE
}
void WeaponUsageStatistic::Send_Check_Respond()
{
if (!OnServer()) return;
NET_Packet P;
string1024 STrue, SFalse;
for (u32 i=0; i<m_Requests.size(); i++)
{
Bullet_Check_Array& BChA_Request = m_Requests[i];
if (BChA_Request.Requests.empty()) continue;
Bullet_Check_Respond_True* pSTrue = (Bullet_Check_Respond_True*) STrue;
u32* pSFalse = (u32*) SFalse;
//-----------------------------------------------------
u32 NumFalse = 0;
u32 NumTrue = 0;
u32 j=0;
while (j<BChA_Request.Requests.size())
{
Bullet_Check_Request& curBChR = BChA_Request.Requests[j];
if (!curBChR.Processed)
{
j++;
continue;
}
else
{
if (curBChR.Result)
{
pSTrue->BulletID = curBChR.BulletID;
pSTrue->BoneID = curBChR.BoneID;
pSTrue++;
// HitChecksRespondedTrue++;
NumTrue++;
}
else
{
*(pSFalse++) = curBChR.BulletID;
// HitChecksRespondedFalse++;
NumFalse++;
};
// HitChecksResponded++;
//-----------------------------------------------------
*(BChA_Request.Requests.begin()+j) = BChA_Request.Requests.back();
BChA_Request.Requests.pop_back();
}
}
//-----------------------------------------------------
P.w_begin(M_BULLET_CHECK_RESPOND);
// Msg("%d-%d || %d-%d", NumFalse, BChA_Request.NumFalse, NumTrue, BChA_Request.NumTrue);
P.w_u8(BChA_Request.NumFalse); BChA_Request.NumFalse = 0;
P.w_u8(BChA_Request.NumTrue); BChA_Request.NumTrue = 0;
if ((char*)pSFalse != (char*)SFalse) P.w(SFalse, u32((char*)pSFalse-(char*)SFalse));
if ((char*)pSTrue != (char*)STrue) P.w(STrue, u32((char*)pSTrue-(char*)STrue));
//-----------------------------------------------------
ClientID ClID; ClID.set(BChA_Request.SenderID);
if(Level().Server) Level().Server->SendTo(ClID, P);
};
}
void xrGameSpyServer::OnCDKey_ReValidation (int LocalID, int hint, char* challenge)
{
ClientID ID; ID.set(u32(LocalID));
xrGameSpyClientData* CL = (xrGameSpyClientData*) ID_to_client(ID);
if (!CL) return;
strcpy_s(CL->m_pChallengeString, challenge);
CL->m_iCDKeyReauthHint = hint;
//--------- Send Respond ---------------------------------------------
NET_Packet P;
P.w_begin (M_GAMESPY_CDKEY_VALIDATION_CHALLENGE);
P.w_u8(1);
P.w_stringZ(CL->m_pChallengeString);
SendTo(CL->ID, P);
}
void add_online_impl (CSE_ALifeDynamicObject *object, const bool &update_registries)
{
NET_Packet tNetPacket;
ClientID clientID;
clientID.set (object->alife().server().GetServerClient() ? object->alife().server().GetServerClient()->ID.value() : 0);
ALife::OBJECT_IT I = object->children.begin();
ALife::OBJECT_IT E = object->children.end();
for ( ; I != E; ++I) {
// this was for the car only
// if (*I == ai().alife().graph().actor()->ID)
// continue;
//
CSE_ALifeDynamicObject *l_tpALifeDynamicObject = ai().alife().objects().object(*I);
CSE_ALifeInventoryItem *l_tpALifeInventoryItem = smart_cast<CSE_ALifeInventoryItem*>(l_tpALifeDynamicObject);
R_ASSERT2 (l_tpALifeInventoryItem,"Non inventory item object has parent?!");
l_tpALifeInventoryItem->base()->s_flags.or(M_SPAWN_UPDATE);
CSE_Abstract *l_tpAbstract = smart_cast<CSE_Abstract*>(l_tpALifeInventoryItem);
object->alife().server().entity_Destroy(l_tpAbstract);
#ifdef DEBUG
// if (psAI_Flags.test(aiALife))
// Msg ("[LSS] Spawning item [%s][%s][%d]",l_tpALifeInventoryItem->base()->name_replace(),*l_tpALifeInventoryItem->base()->s_name,l_tpALifeDynamicObject->ID);
Msg (
"[LSS][%d] Going online [%d][%s][%d] with parent [%d][%s] on '%s'",
Device.dwFrame,
Device.dwTimeGlobal,
l_tpALifeInventoryItem->base()->name_replace(),
l_tpALifeInventoryItem->base()->ID,
object->ID,
object->name_replace(),
"*SERVER*"
);
#endif
// R_ASSERT3 (ai().level_graph().valid_vertex_id(l_tpALifeDynamicObject->m_tNodeID),"Invalid vertex for object ",l_tpALifeInventoryItem->name_replace());
l_tpALifeDynamicObject->o_Position = object->o_Position;
l_tpALifeDynamicObject->m_tNodeID = object->m_tNodeID;
object->alife().server().Process_spawn (tNetPacket,clientID,FALSE,l_tpALifeInventoryItem->base());
l_tpALifeDynamicObject->s_flags.and (u16(-1) ^ M_SPAWN_UPDATE);
l_tpALifeDynamicObject->m_bOnline = true;
}
if (!update_registries)
return;
object->alife().scheduled().remove (object);
object->alife().graph().remove (object,object->m_tGraphID,false);
}
void xrGameSpyServer::OnCDKey_Validation (int LocalID, int res, char* errormsg)
{
ClientID ID; ID.set(u32(LocalID));
xrGameSpyClientData* CL = (xrGameSpyClientData*) ID_to_client(ID);
if (0 != res)
{
CL->m_bCDKeyAuth = true;
#ifndef MASTER_GOLD
Msg("xrGS::CDKey: Validation successful - <%s>", errormsg);
#endif // #ifndef MASTER_GOLD
Check_GameSpy_CDKey_Success(CL);
}
else
{
Msg ("CDKey: Validation failed - <%s>", errormsg);
SendConnectResult (CL, u8(res), u8(1), errormsg);
}
};
void xrServer::OnCL_Disconnected (IClient* CL)
{
//csPlayers.Enter ();
// Game config (all, info includes deleted player now, excludes at the next cl-update)
NET_Packet P;
P.B.count = 0;
P.w_clientID(CL->ID);
xrClientData* xrCData = (xrClientData*)(CL);
VERIFY(xrCData);
if (!xrCData->ps)
return;
P.w_stringZ(xrCData->ps->getName());
P.w_u16(xrCData->ps->GameID);
P.r_pos = 0;
ClientID clientID;
clientID.set(0);
game->AddDelayedEvent(P,GAME_EVENT_PLAYER_DISCONNECTED, 0, clientID);
//
xrS_entities::iterator I=entities.begin(),E=entities.end();
if (GetClientsCount()>1 && !CL->flags.bLocal)
{
// Migrate entities
for (; I!=E; ++I)
{
CSE_Abstract* entity = I->second;
if (entity->owner == CL) PerformMigration (entity,(xrClientData*)CL,SelectBestClientToMigrateTo(entity,TRUE));
}
} else {
// Destroy entities
while (!entities.empty()) {
CSE_Abstract* entity = entities.begin()->second;
entity_Destroy (entity);
}
}
//csPlayers.Leave ();
Server_Client_Check(CL);
}
void UITeamState::AddPlayer(ClientID const & clientId)
{
game_cl_GameState::PLAYERS_MAP & playersMap = Game().players;
game_cl_GameState::PLAYERS_MAP::iterator pi = playersMap.find(clientId);
VERIFY(pi != playersMap.end());
/*if (pi == playersMap.end())
{
Msg("--- Player not found by ClientID = 0x%08x", clientId.value());
return;
}*/
game_PlayerState *ps = pi->second;
VERIFY(ps);
/*if (!ps)
{
return;
}*/
// if player not in my team...
if (Game().IsPlayerInTeam(ps, myTeam) == false)
{
return;
}
#ifdef DEBUG
Msg("--- UITeamState: adding player (ClientID = 0x%08x) to %d team (0x%08x)", clientId.value(), myTeam, this);
#endif // #ifdef DEBUG
UIPlayerItem* tempPlayerItem = xr_new<UIPlayerItem>(static_cast<ETeam>(ps->team),
clientId,
this,
m_teamPanels);
VERIFY2(tempPlayerItem, make_string("failed to create player with ClientID = 0x%08x", clientId.value()).c_str());
TScrollPanels::size_type panel_index = GetNeedScrollPanelIndex();
VERIFY(panel_index < m_scroll_panels.size());
m_scroll_panels[panel_index].first->AddWindow(tempPlayerItem, false);
VERIFY2(mainUiXml, "main UI XML not initialized");
XML_NODE* tempRoot = mainUiXml->GetLocalRoot();
mainUiXml->SetLocalRoot(teamXmlNode);
if (clientId == Game().local_svdpnid)
{
tempPlayerItem->Init(*mainUiXml, "local_player_item", 0);
} else
{
tempPlayerItem->Init(*mainUiXml, "player_item", 0);
}
mainUiXml->SetLocalRoot(tempRoot);
myPlayers.insert(std::make_pair(clientId, TPlayerItem(tempPlayerItem, panel_index)));
}
void xrServer::Perform_destroy (CSE_Abstract* object, u32 mode)
{
R_ASSERT (object);
R_ASSERT (object->ID_Parent == 0xffff);
#ifdef DEBUG
# ifdef SLOW_VERIFY_ENTITIES
verify_entities ();
# endif
#endif
while (!object->children.empty()) {
CSE_Abstract *child = game->get_entity_from_eid(object->children.back());
R_ASSERT2 (child, make_string("child registered but not found [%d]",object->children.back()));
// Msg ("SLS-CLEAR : REJECT [%s][%s] FROM [%s][%s]",child->name(),child->name_replace(),object->name(),object->name_replace());
Perform_reject (child,object,2*NET_Latency);
#ifdef DEBUG
# ifdef SLOW_VERIFY_ENTITIES
verify_entities ();
# endif
#endif
Perform_destroy (child,mode);
}
// Msg ("SLS-CLEAR : DESTROY [%s][%s]",object->name(),object->name_replace());
u16 object_id = object->ID;
entity_Destroy (object);
#ifdef DEBUG
# ifdef SLOW_VERIFY_ENTITIES
verify_entities ();
# endif
#endif
NET_Packet P;
P.w_begin (M_EVENT);
P.w_u32 (Device.dwTimeGlobal - 2*NET_Latency);
P.w_u16 (GE_DESTROY);
P.w_u16 (object_id);
ClientID clientID;
clientID.setBroadcast ();
SendBroadcast (clientID,P,mode);
}
void CSE_ALifeInventoryBox::add_online (const bool &update_registries)
{
CSE_ALifeDynamicObjectVisual *object = (this);
NET_Packet tNetPacket;
ClientID clientID;
clientID.set (object->alife().server().GetServerClient() ? object->alife().server().GetServerClient()->ID.value() : 0);
ALife::OBJECT_IT I = object->children.begin();
ALife::OBJECT_IT E = object->children.end();
for ( ; I != E; ++I) {
CSE_ALifeDynamicObject *l_tpALifeDynamicObject = ai().alife().objects().object(*I);
CSE_ALifeInventoryItem *l_tpALifeInventoryItem = smart_cast<CSE_ALifeInventoryItem*>(l_tpALifeDynamicObject);
R_ASSERT2 (l_tpALifeInventoryItem,"Non inventory item object has parent?!");
l_tpALifeInventoryItem->base()->s_flags.or(M_SPAWN_UPDATE);
CSE_Abstract *l_tpAbstract = smart_cast<CSE_Abstract*>(l_tpALifeInventoryItem);
object->alife().server().entity_Destroy(l_tpAbstract);
#ifdef DEBUG
// if (psAI_Flags.test(aiALife))
// Msg ("[LSS] Spawning item [%s][%s][%d]",l_tpALifeInventoryItem->base()->name_replace(),*l_tpALifeInventoryItem->base()->s_name,l_tpALifeDynamicObject->ID);
Msg (
"[LSS][%d] Going online [%d][%s][%d] with parent [%d][%s] on '%s'",
Device.dwFrame,
Device.dwTimeGlobal,
l_tpALifeInventoryItem->base()->name_replace(),
l_tpALifeInventoryItem->base()->ID,
ID,
name_replace(),
"*SERVER*"
);
#endif
l_tpALifeDynamicObject->o_Position = object->o_Position;
l_tpALifeDynamicObject->m_tNodeID = object->m_tNodeID;
object->alife().server().Process_spawn (tNetPacket,clientID,FALSE,l_tpALifeInventoryItem->base());
l_tpALifeDynamicObject->s_flags.and (u16(-1) ^ M_SPAWN_UPDATE);
l_tpALifeDynamicObject->m_bOnline = true;
}
CSE_ALifeDynamicObjectVisual::add_online(update_registries);
}
void xrServer::OnCL_Connected (IClient* _CL)
{
xrClientData* CL = (xrClientData*)_CL;
CL->net_Accepted = TRUE;
/// Server_Client_Check(CL);
csPlayers.Enter ();
Export_game_type(CL);
Perform_game_export();
SendConnectionData(CL);
//
NET_Packet P;
P.B.count = 0;
P.w_clientID(CL->ID);
P.r_pos = 0;
ClientID clientID;clientID.set (0);
game->AddDelayedEvent (P,GAME_EVENT_PLAYER_CONNECTED, 0, clientID);
csPlayers.Leave ();
game->ProcessDelayedEvent ();
}
void clientdata_proxy::make_config_dump(ClientID const & admin_id, ClientID const & cheater_id)
{
m_admin_id = admin_id;
m_chearer_id = cheater_id;
xrClientData* tmp_cheater = static_cast<xrClientData*>(
Level().Server->GetClientByID(m_chearer_id));
if (!tmp_cheater)
{
Msg("! ERROR: SV: client [%u] not found ...", cheater_id.value());
return;
}
if (m_ft_server->is_receiving_active(cheater_id))
{
Msg("! Receiving from client [%u] already active, please try later", cheater_id.value());
return;
}
m_cheater_digest = tmp_cheater->m_cdkey_digest;
m_cheater_name = tmp_cheater->ps ? tmp_cheater->ps->getName() : "unknown";
NET_Packet ssr_packet;
ssr_packet.w_begin (M_GAMEMESSAGE);
ssr_packet.w_u32 (GAME_EVENT_MAKE_DATA);
ssr_packet.w_u8 (e_configs_request); //make screenshot
//alligning size to GAME_EVENT_PLAYER_KILLED message size
ssr_packet.w_u16 (u16(Random.randI(2))); //food for thought for crackers :)
ssr_packet.w_u16 (u16(Random.randI(2)));
ssr_packet.w_u16 (u16(Random.randI(2)));
ssr_packet.w_u8 (u8(Random.randI(2)));
Level().Server->SecureSendTo (tmp_cheater, ssr_packet, net_flags(TRUE, TRUE));
file_transfer::receiving_state_callback_t receiving_cb =
fastdelegate::MakeDelegate(this, &clientdata_proxy::download_config_callback);
if (my_proxy_mem_file.size())
my_proxy_mem_file.clear();
m_first_receive = true;
m_receiver = m_ft_server->start_receive_file(my_proxy_mem_file, m_chearer_id, receiving_cb);
}
void xrServer::Update ()
{
NET_Packet Packet;
u32 position;
csPlayers.Enter ();
VERIFY (verify_entities());
// game update
game->ProcessDelayedEvent();
game->Update ();
// spawn queue
u32 svT = Device.TimerAsync();
while (!(q_respawn.empty() || (svT<q_respawn.begin()->timestamp)))
{
// get
svs_respawn R = *q_respawn.begin();
q_respawn.erase (q_respawn.begin());
//
CSE_Abstract* E = ID_to_entity(R.phantom);
E->Spawn_Write (Packet,FALSE);
u16 ID;
Packet.r_begin (ID); R_ASSERT(M_SPAWN==ID);
ClientID clientID; clientID.set(0xffff);
Process_spawn (Packet,clientID);
}
//
for (u32 client=0; client<net_Players.size(); ++client)
{
// Initialize process and check for available bandwidth
xrClientData* Client = (xrClientData*) net_Players [client];
if (!Client->net_Ready) continue;
if (!HasBandwidth(Client)
#ifdef DEBUG
&& !g_sv_SendUpdate
#endif
) continue;
// Send relevant entities to client
// CSE_Abstract* Base = Client->owner;
u16 PacketType = M_UPDATE;
Packet.w_begin (PacketType);
// GameUpdate
++(Client->game_replicate_id);
u32 g_it = (Client->game_replicate_id % client_Count());
// u32 g_id = net_Players[g_it]->ID;
ClientID g_id = net_Players[g_it]->ID;
game->net_Export_Update (Packet,Client->ID,g_id);
// if (!Client->flags.bLocal)
game->net_Export_GameTime(Packet);
if (!Client->flags.bLocal || client_Count() == 1)
{
#ifdef DEBUG
if (g_Dump_Update_Write) Msg("---- UPDATE_Write to %s --- ", *(Client->Name));
#endif // Entities
NET_Packet tmpPacket;
xrS_entities::iterator I=entities.begin(),E=entities.end();
for (; I!=E; ++I)
{
CSE_Abstract& Test = *(I->second);
if (0==Test.owner) continue; // Phantom(?)
if (!Test.net_Ready) continue;
if (Test.owner == Client && Client->flags.bLocal) continue; // Can't be relevant
if (Test.s_flags.is(M_SPAWN_OBJECT_PHANTOM)) continue; // Surely: phantom
tmpPacket.B.count = 0;
// write specific data
{
tmpPacket.w_u16 (Test.ID );
tmpPacket.w_chunk_open8 (position );
Test.UPDATE_Write (tmpPacket );
#ifdef DEBUG
if (g_Dump_Update_Write) Msg("* %s : %d", Test.name(), u32(tmpPacket.w_tell()-position)-sizeof(u8));
#endif
tmpPacket.w_chunk_close8 (position );
if (Packet.B.count + tmpPacket.B.count < NET_PacketSizeLimit)
{
Packet.w(tmpPacket.B.data, tmpPacket.B.count);
}
else
{
if (Packet.B.count > 2)
{
// if (!Client->flags.bLocal)
// Msg ("- Server Update[%d] to Client : %d", PacketType, Packet.B.count);
SendTo (Client->ID,Packet,net_flags(FALSE,TRUE));
}
PacketType = M_UPDATE_OBJECTS;
Packet.w_begin(PacketType);
}
}
}
#ifdef DEBUG
if (g_Dump_Update_Write) Msg("----------------------- ");
#endif
};
if (Packet.B.count > 2)
{
// if (!Client->flags.bLocal)
// Msg ("- Server Update[%d] to Client : %d", PacketType, Packet.B.count);
SendTo (Client->ID,Packet,net_flags(FALSE,TRUE));
}
}
#ifdef DEBUG
g_sv_SendUpdate = 0;
#endif
if (game->sv_force_sync) Perform_game_export();
VERIFY (verify_entities());
//-----------------------------------------------------
//Remove any of long time disconnected players
for (u32 DI = 0; DI<net_Players_disconnected.size(); DI++)
{
IClient* CL = net_Players_disconnected[DI];
if (CL->dwTime_LastUpdate+g_sv_Client_Reconnect_Time*60000<Device.dwTimeGlobal)
client_Destroy(CL);
}
//-----------------------------------------------------
csPlayers.Leave ();
}
void xrServer::SLS_Default ()
{
if (game->custom_sls_default()) {
game->sls_default ();
return;
}
#ifdef USE_DESIGNER_KEY
bool _designer = !!strstr(Core.Params,"-designer");
CSE_ALifeCreatureActor *_actor = 0;
#endif
string256 fn_spawn;
if (FS.exist(fn_spawn, "$level$", "level.spawn")) {
IReader* SP = FS.r_open(fn_spawn);
NET_Packet P;
u32 S_id;
for (IReader *S = SP->open_chunk_iterator(S_id); S; S = SP->open_chunk_iterator(S_id,S)) {
P.B.count = S->length();
S->r (P.B.data,P.B.count);
u16 ID;
P.r_begin (ID);
R_ASSERT (M_SPAWN==ID);
ClientID clientID;clientID.set(0);
#ifdef USE_DESIGNER_KEY
CSE_Abstract *entity =
#endif
Process_spawn(P,clientID);
#ifdef USE_DESIGNER_KEY
if (_designer) {
CSE_ALifeCreatureActor *actor = smart_cast<CSE_ALifeCreatureActor*>(entity);
if (actor)
_actor = actor;
}
#endif
}
FS.r_close (SP);
}
#ifdef USE_DESIGNER_KEY
if (!_designer)
return;
if (_actor)
return;
_actor = smart_cast<CSE_ALifeCreatureActor*>(entity_Create("actor"));
_actor->o_Position = Fvector().set(0.f,0.f,0.f);
_actor->set_name_replace("designer");
_actor->s_flags.flags |= M_SPAWN_OBJECT_ASPLAYER;
NET_Packet packet;
packet.w_begin (M_SPAWN);
_actor->Spawn_Write (packet,TRUE);
u16 id;
packet.r_begin (id);
R_ASSERT (id == M_SPAWN);
ClientID clientID;
clientID.set (0);
Process_spawn (packet,clientID);
#endif
}
void game_sv_GameState::OnEvent (NET_Packet &tNetPacket, u16 type, u32 time, ClientID sender )
{
switch (type)
{
case GAME_EVENT_PLAYER_CONNECTED:
{
ClientID ID;
tNetPacket.r_clientID(ID);
OnPlayerConnect(ID);
}break;
case GAME_EVENT_PLAYER_DISCONNECTED:
{
ClientID ID;
tNetPacket.r_clientID(ID);
string1024 PlayerName;
tNetPacket.r_stringZ(PlayerName);
u16 GameID = tNetPacket.r_u16();
OnPlayerDisconnect(ID, PlayerName, GameID);
}break;
case GAME_EVENT_PLAYER_KILLED:
{
}break ;
case GAME_EVENT_ON_HIT:
{
u16 id_dest = tNetPacket.r_u16();
u16 id_src = tNetPacket.r_u16();
CSE_Abstract* e_src = get_entity_from_eid (id_src );
if(!e_src) // && !IsGameTypeSingle() added by andy because of Phantom does not have server entity
{
if( IsGameTypeSingle() ) break;
game_PlayerState* ps = get_eid(id_src);
if (!ps) break;
id_src = ps->GameID;
}
OnHit(id_src, id_dest, tNetPacket);
m_server->SendBroadcast (BroadcastCID,tNetPacket,net_flags(TRUE,TRUE));
}break;
case GAME_EVENT_CREATE_CLIENT:
{
IClient* CL = (IClient*)m_server->ID_to_client(sender);
VERIFY2(CL, "bad create client message GAME_EVENT_CREATE_CLIENT");
if ( CL == NULL ) { break; }
CL->flags.bConnected = TRUE;
m_server->AttachNewClient (CL);
}break;
case GAME_EVENT_PLAYER_AUTH:
{
IClient* CL = m_server->ID_to_client (sender);
m_server->OnBuildVersionRespond(CL, tNetPacket);
}break;
case GAME_EVENT_CREATE_PLAYER_STATE:
{
xrClientData* CL = m_server->ID_to_client(sender);
R_ASSERT2(CL,
make_string("M_CREATE_PLAYER_STATE: client 0x%08x not found",
sender.value()
).c_str()
);
CL->ps = createPlayerState(&tNetPacket);
CL->ps->m_online_time = Level().timeServer();
CL->ps->DeathTime = Device.dwTimeGlobal;
if (psNET_direct_connect) //IsGameTypeSingle())
break;
if (Level().IsDemoPlay())
break;
if (g_dedicated_server && (CL == m_server->GetServerClient()))
break;
CheckNewPlayer(CL);
}break;
default:
{
string16 tmp;
R_ASSERT3 (0,"Game Event not implemented!!!", itoa(type, tmp, 10));
};
};
}
void xrServer::Process_event (NET_Packet& P, ClientID sender)
{
# ifdef SLOW_VERIFY_ENTITIES
VERIFY (verify_entities());
# endif
u32 timestamp;
u16 type;
u16 destination;
u32 MODE = net_flags(TRUE,TRUE);
// correct timestamp with server-unique-time (note: direct message correction)
P.r_u32 (timestamp );
// read generic info
P.r_u16 (type );
P.r_u16 (destination);
CSE_Abstract* receiver = game->get_entity_from_eid (destination);
if (receiver)
{
R_ASSERT(receiver->owner);
receiver->OnEvent (P,type,timestamp,sender);
};
switch (type)
{
case GE_GAME_EVENT:
{
u16 game_event_type;
P.r_u16(game_event_type);
game->AddDelayedEvent(P,game_event_type,timestamp,sender);
}break;
case GE_INFO_TRANSFER:
case GE_WPN_STATE_CHANGE:
case GE_ZONE_STATE_CHANGE:
case GE_ACTOR_JUMPING:
case GEG_PLAYER_PLAY_HEADSHOT_PARTICLE:
case GEG_PLAYER_ATTACH_HOLDER:
case GEG_PLAYER_DETACH_HOLDER:
case GEG_PLAYER_ITEM2SLOT:
case GEG_PLAYER_ITEM2BELT:
case GEG_PLAYER_ITEM2RUCK:
case GE_GRENADE_EXPLODE:
{
SendBroadcast (BroadcastCID,P,MODE);
}break;
case GEG_PLAYER_ACTIVATEARTEFACT:
{
Process_event_activate (P,sender,timestamp,destination,P.r_u16(), true);
break;
};
case GE_INV_ACTION:
{
xrClientData* CL = ID_to_client(sender);
if (CL) CL->net_Ready = TRUE;
if (SV_Client) SendTo(SV_Client->ID, P, net_flags(TRUE, TRUE));
}break;
case GE_RESPAWN:
{
CSE_Abstract* E = receiver;
if (E)
{
R_ASSERT (E->s_flags.is(M_SPAWN_OBJECT_PHANTOM));
svs_respawn R;
R.timestamp = timestamp + E->RespawnTime*1000;
R.phantom = destination;
q_respawn.insert (R);
}
}
break;
case GE_TRADE_BUY:
case GE_OWNERSHIP_TAKE:
{
Process_event_ownership (P,sender,timestamp,destination);
VERIFY (verify_entities());
}break;
case GE_OWNERSHIP_TAKE_MP_FORCED:
{
Process_event_ownership (P,sender,timestamp,destination,TRUE);
VERIFY (verify_entities());
}break;
case GE_TRADE_SELL:
case GE_OWNERSHIP_REJECT:
case GE_LAUNCH_ROCKET:
{
Process_event_reject (P,sender,timestamp,destination,P.r_u16());
VERIFY (verify_entities());
}break;
case GE_DESTROY:
{
Process_event_destroy (P,sender,timestamp,destination, NULL);
VERIFY (verify_entities());
}
break;
case GE_TRANSFER_AMMO:
{
u16 id_entity;
P.r_u16 (id_entity);
CSE_Abstract* e_parent = receiver; // кто забирает (для своих нужд)
CSE_Abstract* e_entity = game->get_entity_from_eid (id_entity); // кто отдает
if (!e_entity) break;
if (0xffff != e_entity->ID_Parent) break; // this item already taken
xrClientData* c_parent = e_parent->owner;
xrClientData* c_from = ID_to_client (sender);
R_ASSERT (c_from == c_parent); // assure client ownership of event
// Signal to everyone (including sender)
SendBroadcast (BroadcastCID,P,MODE);
// Perfrom real destroy
entity_Destroy (e_entity );
VERIFY (verify_entities());
}
break;
case GE_HIT:
case GE_HIT_STATISTIC:
{
P.r_pos -=2;
if (type == GE_HIT_STATISTIC)
{
P.B.count -= 4;
P.w_u32(sender.value());
};
game->AddDelayedEvent(P,GAME_EVENT_ON_HIT, 0, ClientID() );
} break;
case GE_ASSIGN_KILLER: {
u16 id_src;
P.r_u16 (id_src);
CSE_Abstract *e_dest = receiver; // кто умер
// this is possible when hit event is sent before destroy event
if (!e_dest)
break;
CSE_ALifeCreatureAbstract *creature = smart_cast<CSE_ALifeCreatureAbstract*>(e_dest);
if (creature)
creature->set_killer_id( id_src );
// Msg ("[%d][%s] killed [%d][%s]",id_src,id_src==u16(-1) ? "UNKNOWN" : game->get_entity_from_eid(id_src)->name_replace(),id_dest,e_dest->name_replace());
break;
}
case GE_CHANGE_VISUAL:
{
CSE_Visual* visual = smart_cast<CSE_Visual*>(receiver); VERIFY(visual);
string256 tmp;
P.r_stringZ (tmp);
visual->set_visual (tmp);
}break;
case GE_DIE:
{
// Parse message
u16 id_dest = destination, id_src;
P.r_u16 (id_src);
xrClientData *l_pC = ID_to_client(sender);
VERIFY (game && l_pC);
#ifndef MASTER_GOLD
if ((game->Type() != eGameIDSingle) && l_pC && l_pC->owner)
{
Msg ("* [%2d] killed by [%2d] - sended by [%s:%2d]", id_dest, id_src, game->get_option_s(*l_pC->name,"name","Player"), l_pC->owner->ID);
}
#endif // #ifndef MASTER_GOLD
CSE_Abstract* e_dest = receiver; // кто умер
// this is possible when hit event is sent before destroy event
if (!e_dest)
break;
#ifndef MASTER_GOLD
if (game->Type() != eGameIDSingle)
Msg ("* [%2d] is [%s:%s]", id_dest, *e_dest->s_name, e_dest->name_replace());
#endif // #ifndef MASTER_GOLD
CSE_Abstract* e_src = game->get_entity_from_eid (id_src ); // кто убил
if (!e_src) {
xrClientData* C = (xrClientData*) game->get_client(id_src);
if (C) e_src = C->owner;
};
VERIFY (e_src);
if (!e_src)
{
Msg("! ERROR: SV: src killer not exist.");
return;
}
// R_ASSERT2 (e_dest && e_src, "Killer or/and being killed are offline or not exist at all :(");
#ifndef MASTER_GOLD
if (game->Type() != eGameIDSingle)
Msg ("* [%2d] is [%s:%s]", id_src, *e_src->s_name, e_src->name_replace());
#endif // #ifndef MASTER_GOLD
game->on_death (e_dest,e_src);
xrClientData* c_src = e_src->owner; // клиент, чей юнит убил
if (c_src->owner->ID == id_src) {
// Main unit
P.w_begin (M_EVENT);
P.w_u32 (timestamp);
P.w_u16 (type);
P.w_u16 (destination);
P.w_u16 (id_src);
P.w_clientID (c_src->ID);
}
SendBroadcast (BroadcastCID,P,MODE);
//////////////////////////////////////////////////////////////////////////
//
if (game->Type() == eGameIDSingle) {
P.w_begin (M_EVENT);
P.w_u32 (timestamp);
P.w_u16 (GE_KILL_SOMEONE);
P.w_u16 (id_src);
P.w_u16 (destination);
SendTo (c_src->ID, P, net_flags(TRUE, TRUE));
}
//////////////////////////////////////////////////////////////////////////
VERIFY (verify_entities());
}
break;
case GE_ADDON_ATTACH:
case GE_ADDON_DETACH:
case GE_CHANGE_POS:
{
SendTo(SV_Client->ID, P, net_flags(TRUE, TRUE));
}break;
case GE_INSTALL_UPGRADE:
{
shared_str upgrade_id;
P.r_stringZ ( upgrade_id );
CSE_ALifeInventoryItem* iitem = smart_cast<CSE_ALifeInventoryItem*>( receiver );
if ( !iitem )
{
break;
}
iitem->add_upgrade ( upgrade_id );
}break;
case GEG_PLAYER_DISABLE_SPRINT:
case GEG_PLAYER_WEAPON_HIDE_STATE:
{
SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
# ifdef SLOW_VERIFY_ENTITIES
VERIFY (verify_entities());
# endif
}break;
case GEG_PLAYER_ACTIVATE_SLOT:
case GEG_PLAYER_ITEM_EAT:
{
SendTo(SV_Client->ID, P, net_flags(TRUE, TRUE));
# ifdef SLOW_VERIFY_ENTITIES
VERIFY (verify_entities());
# endif
}break;
case GEG_PLAYER_ITEM_SELL:
{
game->OnPlayer_Sell_Item(sender, P);
}break;
case GE_TELEPORT_OBJECT:
{
game->teleport_object (P,destination);
}break;
case GE_ADD_RESTRICTION:
{
game->add_restriction (P,destination);
}break;
case GE_REMOVE_RESTRICTION:
{
game->remove_restriction(P,destination);
}break;
case GE_REMOVE_ALL_RESTRICTIONS:
{
game->remove_all_restrictions(P,destination);
}break;
case GE_MONEY:
{
CSE_Abstract *e_dest = receiver;
CSE_ALifeTraderAbstract* pTa = smart_cast<CSE_ALifeTraderAbstract*>(e_dest);
pTa->m_dwMoney = P.r_u32();
}break;
case GE_FREEZE_OBJECT:
break;
default:
R_ASSERT2 (0,"Game Event not implemented!!!");
break;
}
}
void CUIKickPlayer::Update()
{
CUIDialogWnd::Update();
if (m_prev_upd_time > Device.dwTimeContinual - 1000) return;
m_prev_upd_time = Device.dwTimeContinual;
#if 1
const game_cl_GameState::PLAYERS_MAP& items = Game().players;
#else
ClientID cid;
//.init
static bool b_inited = false;
if(!b_inited)
{
for(u32 e=0; e<15; ++e)
{
game_PlayerState* ps = new game_PlayerState();
strcpy_s (ps->name, _names[e]);
g_ps.push_back (ps);
}
for(u32 _i=0; _i<3; ++_i)
{
game_cl_GameState::PLAYERS_MAP& items1 = (_i==0)?test_map1:(_i==1)?test_map2:test_map3;
u32* vn = (_i==0)?ids1:(_i==1)?ids2:ids3;
for(u32 i=0; i<szs[_i]; ++i)
{
cid.set (_i*500 + i);
items1[cid] = g_ps[vn[i]];
}
}
b_inited = true;
}
static int iiii = 0;
const game_cl_GameState::PLAYERS_MAP& items = (iiii==0)?test_map1:(iiii==1)?test_map2:test_map3;
#endif
game_cl_GameState::PLAYERS_MAP_CIT I = items.begin();
game_cl_GameState::PLAYERS_MAP_CIT E = items.end();
bool bNeedRefresh = false;
bool bHasSelected = false;
xr_vector<game_PlayerState*>::iterator fit;//, fite;
for( ; I != E; ++I)
{
game_PlayerState* pI = I->second;
if( m_selected_item_text.size() && !stricmp(pI->name, m_selected_item_text.c_str()) )
bHasSelected = true;
fit = std::find(m_current_set.begin(), m_current_set.end(), pI);
if(fit==m_current_set.end())
bNeedRefresh = true;
else if( stricmp( (*fit)->name, pI->name) )
bNeedRefresh = true;
}
if(m_current_set.size() != items.size())
bNeedRefresh = true;
if(bNeedRefresh)
{
I = items.begin();
m_ui_players_list->Clear ();
m_current_set.clear ();
for ( ; I!=E; ++I)
{
game_PlayerState* p = I->second;
m_current_set.push_back (p);
m_ui_players_list->AddItem (p->name);
}
if( bHasSelected )
m_ui_players_list->SetSelectedText(m_selected_item_text.c_str());
}
}
u32 xrServer::OnMessage (NET_Packet& P, ClientID sender) // Non-Zero means broadcasting with "flags" as returned
{
if (g_pGameLevel && Level().IsDemoSave()) Level().Demo_StoreServerData(P.B.data, P.B.count);
u16 type;
P.r_begin (type);
csPlayers.Enter ();
VERIFY (verify_entities());
xrClientData* CL = ID_to_client(sender);
switch (type)
{
case M_UPDATE:
{
Process_update (P,sender); // No broadcast
VERIFY (verify_entities());
}break;
case M_SPAWN:
{
// R_ASSERT(CL->flags.bLocal);
if (CL->flags.bLocal)
Process_spawn (P,sender);
VERIFY (verify_entities());
}break;
case M_EVENT:
{
Process_event (P,sender);
VERIFY (verify_entities());
}break;
case M_EVENT_PACK:
{
NET_Packet tmpP;
while (!P.r_eof())
{
tmpP.B.count = P.r_u8();
P.r (&tmpP.B.data, tmpP.B.count);
OnMessage (tmpP, sender);
};
}break;
case M_CL_UPDATE:
{
xrClientData* CL = ID_to_client (sender);
if (!CL) break;
CL->net_Ready = TRUE;
if (!CL->net_PassUpdates)
break;
//-------------------------------------------------------------------
u32 ClientPing = CL->stats.getPing();
P.w_seek(P.r_tell()+2, &ClientPing, 4);
//-------------------------------------------------------------------
if (SV_Client)
SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
VERIFY (verify_entities());
}break;
case M_MOVE_PLAYERS_RESPOND:
{
xrClientData* CL = ID_to_client (sender);
if (!CL) break;
CL->net_Ready = TRUE;
CL->net_PassUpdates = TRUE;
}break;
//-------------------------------------------------------------------
case M_CL_PING_CHALLENGE:
{
P.r_u32();
u32 id = sender.value();
P.w_seek( P.r_tell(), &(id), 4);
if (SV_Client) SendTo (SV_Client->ID, P, net_flags(FALSE));
}break;
case M_CL_PING_CHALLENGE_RESPOND:
{
P.r_u32();
u32 id = P.r_u32();
ClientID clientID; clientID.set(id);
u32 clLastPing = P.r_u32();
xrClientData* pCL = ID_to_client(clientID);
pCL->ps->Rping = u16(clLastPing);
SendTo (clientID, P, net_flags(FALSE));
}break;
//-------------------------------------------------------------------
case M_CL_INPUT:
{
xrClientData* CL = ID_to_client (sender);
if (CL) CL->net_Ready = TRUE;
if (SV_Client) SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
VERIFY (verify_entities());
}break;
case M_GAMEMESSAGE:
{
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
VERIFY (verify_entities());
}break;
case M_CLIENTREADY:
{
xrClientData* CL = ID_to_client(sender);
if (CL)
{
CL->net_Ready = TRUE;
CL->ps->DeathTime = Device.dwTimeGlobal;
game->OnPlayerConnectFinished(sender);
};
game->signal_Syncronize ();
VERIFY (verify_entities());
}break;
case M_SWITCH_DISTANCE:
{
game->switch_distance (P,sender);
VERIFY (verify_entities());
}break;
case M_CHANGE_LEVEL:
{
if (game->change_level(P,sender)){
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
}
VERIFY (verify_entities());
}break;
case M_SAVE_GAME:
{
game->save_game (P,sender);
VERIFY (verify_entities());
}break;
case M_LOAD_GAME:
{
game->load_game (P,sender);
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
VERIFY (verify_entities());
}break;
case M_RELOAD_GAME:
{
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
VERIFY (verify_entities());
}break;
case M_SAVE_PACKET:
{
Process_save (P,sender);
VERIFY (verify_entities());
}break;
case M_CLIENT_REQUEST_CONNECTION_DATA:
{
xrClientData* CL = ID_to_client (sender);
OnCL_Connected (CL);
}break;
case M_CHAT_MESSAGE:
{
xrClientData *l_pC = ID_to_client(sender);
OnChatMessage (&P, l_pC);
}break;
case M_CHANGE_LEVEL_GAME:
{
ClientID CID; CID.set (0xffffffff);
SendBroadcast (CID,P,net_flags(TRUE,TRUE));
}break;
case M_CL_AUTH:
{
game->AddDelayedEvent (P,GAME_EVENT_PLAYER_AUTH, 0, sender);
}break;
case M_PAUSE_GAME:
{
ClientID clientID;clientID.setBroadcast();
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
}break;
case M_STATISTIC_UPDATE:
{
ClientID clientID;clientID.setBroadcast();
if (SV_Client)
SendBroadcast (SV_Client->ID,P,net_flags(TRUE,TRUE));
else
SendBroadcast (clientID,P,net_flags(TRUE,TRUE));
}break;
case M_STATISTIC_UPDATE_RESPOND:
{
if (SV_Client) SendTo (SV_Client->ID, P, net_flags(TRUE, TRUE));
}break;
case M_PLAYER_FIRE:
{
if (game)
game->OnPlayerFire(sender, P);
}break;
}
VERIFY (verify_entities());
csPlayers.Leave ();
return IPureServer::OnMessage(P, sender);
}
