tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Commando/cnetwork.cpp

1668 lines
48 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Renegade source code.
2025-02-27 16:39:46 +00:00
/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** Confidential - Westwood Studios ***
***********************************************************************************************
* *
* Project Name : Commando *
* *
* $Archive:: /Commando/Code/Commando/cnetwork.cpp $*
* *
* $Author:: Byon_g $*
* *
* $Modtime:: 3/29/02 5:02p $*
* *
* $Revision:: 152 $*
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#include "cnetwork.h"
#include <shellapi.h>
#include <stdio.h>
#include "specialbuilds.h"
#include "langmode.h"
#include "wolgmode.h"
#include "playermanager.h"
#include "textdisplay.h"
#include "gameobjmanager.h"
#include "multihud.h"
#include "WWAudio.H"
#include "useroptions.h"
#include "devoptions.h"
#include "translatedb.h"
#include "string_ids.h"
#include "msgstatlistgroup.h"
#include "wwprofile.h"
#include "gametype.h"
#include "crc.h"
#include "render2d.h"
#include "wwmemlog.h"
#include "svrgoodbyeevent.h"
#include "gameoptionsevent.h"
#include "evictionevent.h"
#include "changeteamevent.h"
#include "clientcontrol.h"
#include "serverfps.h"
#include "sbbomanager.h"
#include "clientgoodbyeevent.h"
//#include "helptext.h"
#include "natter.h"
#include "vistable.h"
#include "gameinitmgr.h"
#include "dlgmessagebox.h"
#include "apppacketstats.h"
#include "clientfps.h"
#include "gamechanlist.h"
#include "packetmgr.h"
#include "clientpingmanager.h"
#include "bandwidthgraph.h"
#include "buildnum.h"
#include "messagewindow.h"
#include "wwmemlog.h"
#include "consolemode.h"
#include "slavemaster.h"
#include "gamedataupdateevent.h"
#include "gamespyadmin.h"
#include "demosupport.h"
#include "serversettings.h"
#include "dlgmpconnectionrefused.h"
#include "Resource.h"
#include <WWUI\DialogMgr.h>
#include "ffactory.h"
#include "realcrc.h"
extern bool g_is_loading;
//
// Networking cNetwork statics
//
char cNetwork::MessageToSend[];
char cNetwork::Command[];
int cNetwork::ExeKey = 0;
int cNetwork::ExeCRC = 0;
int cNetwork::StringsCRC = 0;
char cNetwork::ClientString[];
char cNetwork::ClientEnumerationString[];
CombatNetworkReceiverInstanceClass * cNetwork::NetworkReceiver = NULL;
GameCombatNetworkHandlerClass cNetwork::NetHandler;
int cNetwork::Fps = 0;
int cNetwork::ThinkCount = 0;
cMsgStatList * cNetwork::PClientStatList = NULL;
cMsgStatListGroup * cNetwork::PServerStatListGroup = NULL;
cConnection * cNetwork::PClientConnection = NULL;
cConnection * cNetwork::PServerConnection = NULL;
CombatNetworkReceiver * cNetwork::Receiver = NULL;
float cNetwork::GraphingY;
float cNetwork::BandwidthBarLength = 0;
//int cNetwork::BandwidthScaler = 28800;
int cNetwork::BandwidthScaler = 50000;
bool cNetwork::HaveDoneTeamChangeDialog = false;
bool cNetwork::HaveDoneMotdDialog = false;
VisTableClass * cNetwork::VisTable = NULL;
bool cNetwork::LastServerConnectionStateBad = false;
bool cNetwork::SensibleUpdates = true;
//-----------------------------------------------------------------------------
void cNetwork::Init_Client(unsigned short my_port)
{
WWMEMLOG(MEM_NETWORK);
#ifndef FREEDEDICATEDSERVER
WWDEBUG_SAY(("cNetwork::Init_Client\n"));
if (PClientConnection != NULL) {
Cleanup_Client();
}
PClientStatList = new cMsgStatList;
WWASSERT(PClientStatList != NULL);
//PClientStatList->Init(MESSAGE_COUNT);
PClientStatList->Init(1);
for (int i = 0; i < PClientStatList->Get_Num_Stats(); i++) {
//PClientStatList->Set_Name(i, Message_Type_Translation(i));
/*
char message_trans[200];
strcpy(message_trans, Message_Type_Translation(i));
PClientStatList->Set_Name(i, &message_trans[8]);
*/
PClientStatList->Set_Name(i, "message");
}
WWASSERT(PClientConnection == NULL);
PClientConnection = new cConnection;
WWASSERT(PClientConnection != NULL);
CombatManager::Set_I_Am_Client(true);
PClientConnection->Install_Accept_Handler(Accept_Handler);
PClientConnection->Install_Refusal_Handler(Refusal_Handler);
PClientConnection->Install_Client_Broken_Connection_Handler(Client_Broken_Connection_Handler);
PClientConnection->Install_Client_Packet_Handler(Client_Packet_Handler);
if (cGameSpyAdmin::Is_Gamespy_Game()) {
WWASSERT(PTheGameData != NULL);
The_Game()->Set_Password(cGameSpyAdmin::Get_Password_Attempt());
}
ULONG bbo = 0;
//if (IS_SOLOPLAY || GameModeManager::Find("LAN")->Is_Active()) {
if (IS_SOLOPLAY ||
(GameModeManager::Find("LAN")->Is_Active() && !cGameSpyAdmin::Is_Gamespy_Game())) {
bbo = cBandwidth::Get_Bandwidth_Bps_From_Type(BANDWIDTH_LANT1);
WWASSERT(bbo > 0);
cBandwidthGraph::Set_Scale(200000);
HaveDoneTeamChangeDialog = false;
} else {
//WWASSERT(GameModeManager::Find("WOL")->Is_Active());
bbo = cBandwidth::Get_Bandwidth_Bps_From_Type((BANDWIDTH_TYPE_ENUM)cUserOptions::Get_Bandwidth_Type());
//bbo = cUserOptions::BandwidthBps.Get();
WWASSERT(bbo > 0);
int bw_scale = (bbo * 2) / 10;
bw_scale = (bw_scale / 1000) * 1000;
cBandwidthGraph::Set_Scale(bw_scale);
if (GameModeManager::Find("WOL")->Is_Active()) {
HaveDoneTeamChangeDialog = true;
}
}
PClientConnection->Set_Bandwidth_Budget_Out(bbo);
BOOL is_flow_control_enabled = !IS_SOLOPLAY;
PClientConnection->Enable_Flow_Control(is_flow_control_enabled);
WWASSERT(PTheGameData != NULL);
PClientConnection->Init_As_Client(
The_Game()->Get_Ip_Address(), The_Game()->Get_Port(), my_port);
//
// This packet resurfaces on the server in Application_Acceptance_Handler
//
cPacket packet;
packet.Add_Wide_Terminated_String(cNetInterface::Get_Nickname());
packet.Add_Wide_Terminated_String(The_Game()->Get_Password(), true);
packet.Add(ExeKey);
packet.Add(bbo); // note, this field is consumed by wwnet
PClientConnection->Connect_Cs(packet);
packet.Flush();
/*
if (I_Am_Only_Client()) {
ServerFps.Init();
}
*/
HaveDoneMotdDialog = false;
if (I_Am_Only_Client())
{
cAppPacketStats::Reset();
}
LastServerConnectionStateBad = false;
cClientPingManager::Init();
#endif // !FREEDEDICATEDSERVER
}
//-----------------------------------------------------------------------------
void cNetwork::Cleanup_Client(void)
{
WWMEMLOG(MEM_NETWORK);
#ifndef FREEDEDICATEDSERVER
WWDEBUG_SAY(("cNetwork::Cleanup_Client\n"));
if (I_Am_Client()) {
if (PClientConnection->Is_Established()) { // i.e we did have a connection
cClientGoodbyeEvent * p_event = new cClientGoodbyeEvent;
p_event->Init();
Flush();
}
delete PClientConnection;
PClientConnection = NULL;
}
CombatManager::Set_I_Am_Client(false);
delete PClientStatList;
PClientStatList = NULL;
delete PClientControl;
PClientControl = NULL;
delete PClientFps;
PClientFps = NULL;
#endif // !FREEDEDICATEDSERVER
}
//-----------------------------------------------------------------------------
void cNetwork::Accept_Handler(void)
{
WWMEMLOG(MEM_NETWORK);
#ifndef FREEDEDICATEDSERVER
WWDEBUG_SAY(("cNetwork::Accept_Handler\n"));
WWASSERT(I_Am_Client());
CombatManager::Set_My_Id(Get_My_Id());
NetworkObjectMgrClass::Init_New_Client_ID(Get_My_Id());
if (I_Am_Only_Client()) {
//
// Create C->S mirrored client control object
//
WWASSERT(PClientControl == NULL);
PClientControl = new CClientControl;
PClientControl->Init();
//
// Create C->S mirrored client fps object
//
WWASSERT(PClientFps == NULL);
PClientFps = new CClientFps;
PClientFps->Init();
}
if (!I_Am_Server()) {
if (GameModeManager::Find("LAN")->Is_Active()) {
PLC->Accept_Actions();
} else {
GameModeClass* gameMode = GameModeManager::Find("WOL");
if (gameMode && gameMode->Is_Active()) {
WolGameModeClass* wolGame = static_cast<WolGameModeClass*>(gameMode);
WWASSERT(wolGame);
wolGame->Accept_Actions();
}
}
}
#endif // !FREEDEDICATEDSERVER
}
//-----------------------------------------------------------------------------
void cNetwork::Refusal_Handler(REFUSAL_CODE refusal_code)
{
#ifndef FREEDEDICATEDSERVER
WWDEBUG_SAY(("cNetwork::Refusal_Handler\n"));
// Close connecting dialog as neccessary.
DialogBaseClass* dialog = DialogMgrClass::Find_Dialog(IDD_MULTIPLAY_CONNECTING);
if (dialog != NULL) {
// Sending 1 as the parameter tells the dialog that it is being closed
// as a result of a refusal from the server.
dialog->On_Command(IDCANCEL, 0, 1);
}
// Verify refusal code is within valid range
WWASSERT(REFUSAL_CLIENT_ACCEPTED <= refusal_code && REFUSAL_BY_APPLICATION >= refusal_code);
WWASSERT(I_Am_Client());
if (GameModeManager::Find("LAN")->Is_Active()) {
PLC->Refusal_Actions();
} else {
GameModeClass* gameMode = GameModeManager::Find("WOL");
if (gameMode && gameMode->Is_Active()) {
WolGameModeClass* wolGame = static_cast<WolGameModeClass*>(gameMode);
WWASSERT(wolGame);
wolGame->Refusal_Actions();
}
}
//
// The server refused our connection request! At this stage this
// is fatal. Later on we would have to re-init the connection etc.
//
static const unsigned long _refusalStrings[] = {
IDS_MP_CONNECTION_REFUSED_GAME_FULL, // REFUSAL_GAME_FULL
IDS_MP_PASSWORD_WRONG, // REFUSAL_BAD_PASSWORD
IDS_MENU_VERSION_MISMATCH, // REFUSAL_VERSION_MISMATCH
IDS_MP_CONNECTION_REFUSED_BY_APPLICATION, // REFUSAL_PLAYER_EXISTS
IDS_MP_CONNECTION_REFUSED_BY_APPLICATION // REFUSAL_BY_APPLICATION
};
const unsigned long refusalMsg = _refusalStrings[refusal_code - 1];
if (cGameSpyAdmin::Is_Gamespy_Game()) {
if (refusal_code == REFUSAL_VERSION_MISMATCH) {
WideStringClass tval;
tval.Format(L"%s...%s", TRANSLATE(IDS_MP_CONNECTION_REFUSED_BY_APPLICATION),
TRANSLATE(IDS_MENU_VERSION_MISMATCH));
DlgMPConnectionRefused::DoDialog(tval, false);
} else {
DlgMPConnectionRefused::DoDialog(TRANSLATE(refusalMsg), false);
}
} else {
DlgMsgBox::DoDialog(TRANSLATE (IDS_MENU_SERVER_MESSAGE_TITLE), TRANSLATE(refusalMsg));
}
//
// N.B. We cannot destroy the connection from inside this callback.
//
#endif // !FREEDEDICATEDSERVER
}
//-----------------------------------------------------------------------------
int cNetwork::Get_Data_Files_CRC(void)
{
#define UNINITIALLIZED_CRC 0x4592abf1
static int crc = UNINITIALLIZED_CRC;
if ( crc == UNINITIALLIZED_CRC ) {
char * filelist[] = {
"jgo`fqv+aag", //"objects.ddb",
"dwhjw+lkl", //"armor.ini",
"gjk`v+lkl", //"bones.ini",
"vpwcdf``cc`fqv+lkl", //"surfaceeffects.ini",
"fdh`wdv+lkl", //"cameras.ini",
"fZkjaZhbZi5+r6a", //"c_nod_mg_l0.w3d",
"fZkjaZwnZi5+r6a", //"c_nod_rk_l0.w3d",
"fZkjaZciZi5+r6a", //"c_nod_fl_l0.w3d",
"fZkjaZ`kZi5+r6a", //"c_nod_en_l0.w3d",
"fZkjaZhbjZi5+r6a", //"c_nod_mgo_l0.w3d",
"fZkjaZwnjZi5+r6a", //"c_nod_rko_l0.w3d",
"fZkjaZfm`hqZi5+r6a", //"c_nod_chemt_l0.w3d",
"fZkjaZvklu`wZi5+r6a", //"c_nod_sniper_l0.w3d",
"fZkjaZwvjiaZi5+r6a", //"c_nod_rsold_l0.w3d",
"fZkjaZvqiqmZi5+r6a", //"c_nod_stlth_l0.w3d",
"fZkjaZvdnpZi5+r6a", //"c_nod_saku_l0.w3d",
"fZkjaZvdnp7Zi5+r6a", //"c_nod_saku2_l0.w3d",
"fZkjaZwdsZi5+r6a", //"c_nod_rav_l0.w3d",
"fZkjaZhwdsZi5+r6a", //"c_nod_mrav_l0.w3d",
"fZkjaZhaZi5+r6a", //"c_nod_mdz_l0.w3d",
"fZkjaZha7Zi5+r6a", //"c_nod_mdz2_l0.w3d",
"fZkjaZqfZi5+r6a", //"c_nod_tc_l0.w3d",
"fZkjaZhpqdkqZi5+r6a", //"c_nod_mutant_l0.w3d",
"fZkjaZhviaZi5+r6a", //"c_nod_msld_l0.w3d",
"fZkjaZvvjiaZi5+r6a", //"c_nod_ssold_l0.w3d",
"fZkjaZu`qhZi5+r6a", //"c_nod_petm_l0.w3d",
"fZkjaZndk`Zi5+r6a", //"c_nod_kane_l0.w3d",
"fZbalZhbZi5+r6a", //"c_gdi_mg_l0.w3d",
"fZbalZwnZi5+r6a", //"c_gdi_rk_l0.w3d",
"fZbalZbwZi5+r6a", //"c_gdi_gr_l0.w3d",
"fZbalZ`kZi5+r6a", //"c_gdi_en_l0.w3d",
"fZbalZhbjZi5+r6a", //"c_gdi_mgo_l0.w3d",
"fZbalZwnjZi5+r6a", //"c_gdi_rko_l0.w3d",
"fZbalZv|aZi5+r6a", //"c_gdi_syd_l0.w3d",
"fZbalZa`daZi5+r6a", //"c_gdi_dead_l0.w3d",
"fZbalZbpkZi5+r6a", //"c_gdi_gun_l0.w3d",
"fZbalZuqfmZi5+r6a", //"c_gdi_ptch_l0.w3d",
"fZmdsjfZi5+r6a", //"c_havoc_l0.w3d",
"fZmdsjfkZi5+r6a", //"c_havocn_l0.w3d",
"fZmdsjfrZi5+r6a", //"c_havocw_l0.w3d",
"fZmdsjfaZi5+r6a", //"c_havocd_l0.w3d",
"fZbalZv|aZi5+r6a", //"c_gdi_syd_l0.w3d",
"fZbalZv|a7Zi5+r6a", //"c_gdi_syd2_l0.w3d",
"fZbalZhjglZi5+r6a", //"c_gdi_mobi_l0.w3d",
"fZbalZmjqrZi5+r6a", //"c_gdi_hotw_l0.w3d",
"fZbalZiqZi5+r6a", //"c_gdi_lt_l0.w3d",
"fZkjaZu`qwZi5+r6a", //"c_nod_petr_l0.w3d",
"fZijbdkZi5+r6a", //"c_logan_l0.w3d",
"fZbalZijfn`Zi5+r6a", //"c_gdi_locke_l0.w3d",
"sZkjaZgpbb|+r6a", //"v_nod_buggy.w3d",
"sZkjaZdufZh+r6a", //"v_nod_apc_m.w3d",
"sZkjaZdwqiw|+r6a", //"v_nod_artlry.w3d",
"sZkjaZcidh`+r6a", //"v_nod_flame.w3d",
"sZkjaZiqdkn+r6a", //"v_nod_ltank.w3d",
"sZkjaZvqiqm+r6a", //"v_nod_stlth.w3d",
"sZkjaZqwkvuqZh+r6a", //"v_nod_trnspt_m.w3d",
"sZkjaZdudfm`Zh+r6a", //"v_nod_apache_m.w3d",
"sZfmdh`i`jk+r6a", //"v_chameleon.w3d",
"sZbalZmphs``+r6a", //"v_gdi_humvee.w3d",
"sZbalZdufZh+r6a", //"v_gdi_apc_m.w3d",
"sZbalZhwiv+r6a", //"v_gdi_mrls.w3d",
"sZbalZh`aqkn+r6a", //"v_gdi_medtnk.w3d",
"sZbalZhdhhqm+r6a", //"v_gdi_mammth.w3d",
"sZulfnpu54+r6a", //"v_pickup01.w3d",
"sZv`adk54+r6a", //"v_sedan01.w3d",
"sZbalZjwfdZh+r6a", //"v_gdi_orca_m.w3d",
"sZbalZqwkvuqZh+r6a", //"v_gdi_trnspt_m.w3d",
};
#define NUM_CRC_FILES (sizeof( filelist ) / sizeof( filelist[0] ) )
crc = 0;
for ( int i = 0; i < NUM_CRC_FILES; i++ ) {
StringClass name = filelist[i];
// Obfuscate name
char * n = &name[0];
while ( *n ) *n++ ^= 0x5;
// Debug_Say(( " \"%s\",\n", name ));
FileClass * file = _TheFileFactory->Get_File( name );
if ( file && file->Is_Available() ) {
int size = file->Size();
file->Open();
while ( size > 0 ) {
unsigned char buffer[ 4096 ];
int amount = min( (int)size, (int)sizeof(buffer) );
amount = file->Read( buffer, amount );
crc = CRC_Memory( buffer, amount, crc );
size -= amount;
}
file->Close();
} else {
// Debug_Say(( "******%s not found\n", name ));
}
}
}
return crc;
}
//-----------------------------------------------------------------------------
void cNetwork::Compute_Exe_Key(void)
{
WWDEBUG_SAY(("cNetwork::Compute_Exe_Key\n"));
char exe_filename[500];
int succeeded = 0;
succeeded = ::GetModuleFileName(NULL, exe_filename, sizeof(exe_filename));
WWASSERT(succeeded);
StringClass key_string;
StringClass string;
StringClass build_string;
//
// 11/07/01
// We now match only on build number.
//
string.Format("RENEGADE %u", BuildInfoClass::Get_Build_Number());
WWDEBUG_SAY(("File id string: %s\n", string));
key_string += string;
key_string += " ";
ExeCRC = CRCEngine()(string, strlen(string));
//
// TSS 09/07/01
// N.B. Do not require scripts to be in sync any more, since they do not run on the client.
// Furthermore we would have to match the correct scripts target (d/p/r) and
// also handle the registry flag that forces scriptsd.dll.
//
//
// TSS102401
// We cannot match on exact strings.tdb because foreign language versions
// are different files. Instead, match on filename and internal version number.
//
//cMiscUtil::Get_File_Id_String("Data\\strings.tdb", string);
string.Format("strings.tdb %u", TranslateDBClass::Get_Version_Number());
WWDEBUG_SAY(("File id string: %s\n", string));
key_string += string;
key_string += " ";
StringsCRC = CRCEngine()(string, strlen(string));
//
// TSS102401 - we can't match always.dbs either.
// always.dbs will not match among foreign language version for numerous reasons.
//
//
// Use the crc of the keystring as the key
//
ExeKey = CRCEngine()(key_string, strlen(key_string));
//
// Include data file crc
//
int data_file_crc = Get_Data_Files_CRC();
ExeKey ^= data_file_crc;
}
//-----------------------------------------------------------------------------
void cNetwork::Onetime_Init(void)
{
WWMEMLOG(MEM_NETWORK);
WWDEBUG_SAY(("cNetwork::Onetime_Init\n"));
Compute_Exe_Key();
NetworkReceiver = new CombatNetworkReceiverInstanceClass;
Set_Receiver(NetworkReceiver);
CombatManager::Set_Combat_Network_Handler(&NetHandler);
//Clear_Help_Text();
}
//-----------------------------------------------------------------------------
void cNetwork::Onetime_Shutdown(void)
{
WWDEBUG_SAY(("cNetwork::Onetime_Shutdown\n"));
Set_Receiver(NULL);
delete NetworkReceiver;
#if 0
UINT comp_bytes = cConnection::Get_Total_Compressed_Bytes_Sent();
UINT uncomp_bytes = cConnection::Get_Total_Uncompressed_Bytes_Sent();
Debug_Say(("\n"));
Debug_Say(("TotalCompressedBytesSent = %d\n", comp_bytes));
Debug_Say(("Without compression = %d\n", uncomp_bytes));
if (uncomp_bytes > 0) {
Debug_Say(("Compressed/Uncompressed = %-5.2f\n\n",
comp_bytes / (float) uncomp_bytes));
}
#endif // 0
#pragma message("(TSS) This packet ref count assert very occasionally fails.")
//WWASSERT(cPacket::Get_Ref_Count() == 0);
REF_PTR_RELEASE(VisTable);
cGameChannelList::Remove_All();//TSS092201 added
//
// These are only printed once. So only run one game on a test run.
//
cAppPacketStats::Dump_Diagnostics();
}
//-----------------------------------------------------------------------------
void cNetwork::Init_Server(void)
{
WWMEMLOG(MEM_NETWORK);
WWDEBUG_SAY(("cNetwork::Init_Server\n"));
#ifndef BETACLIENT
NetworkObjectClass::Set_Is_Server(true);
PServerStatListGroup = new cMsgStatListGroup;
WWASSERT(PServerStatListGroup != NULL);
//PServerStatListGroup->Init(The_Game()->Get_Max_Players(), MESSAGE_COUNT);
WWASSERT(PTheGameData != NULL);
PServerStatListGroup->Init(The_Game()->Get_Max_Players(), 1);
/*
for (int message_type = 0; message_type < MESSAGE_COUNT; message_type++) {
char message_trans[200];
strcpy(message_trans, Message_Type_Translation(message_type));
PServerStatListGroup->Set_Name(message_type, &message_trans[8]);
}
*/
WWASSERT(PServerConnection == NULL);
PServerConnection = new cConnection;
WWASSERT(PServerConnection != NULL);
CombatManager::Set_I_Am_Server(true);
PServerConnection->Install_Server_Broken_Connection_Handler(Server_Broken_Connection_Handler);
PServerConnection->Install_Eviction_Handler(Eviction_Handler);
PServerConnection->Install_Conn_Handler(Connection_Handler);
PServerConnection->Install_Application_Acceptance_Handler(Application_Acceptance_Handler);
PServerConnection->Install_Server_Packet_Handler(Server_Packet_Handler);
//if (IS_SOLOPLAY || GameModeManager::Find("LAN")->Is_Active()) {
if (IS_SOLOPLAY ||
(GameModeManager::Find("LAN")->Is_Active() && !cGameSpyAdmin::Is_Gamespy_Game())) {
ULONG bbo = cBandwidth::Get_Bandwidth_Bps_From_Type(BANDWIDTH_LANT1);
WWASSERT(bbo > 0);
PServerConnection->Set_Bandwidth_Budget_Out(bbo);
cBandwidthGraph::Set_Scale(200000);
} else {
//WWASSERT(GameModeManager::Find("WOL")->Is_Active());
WWASSERT(cUserOptions::BandwidthBps.Get() > 0);
unsigned long bw = cBandwidth::Get_Bandwidth_Bps_From_Type((BANDWIDTH_TYPE_ENUM)cUserOptions::Get_Bandwidth_Type());
/*
** Only use a portion of the bandwidth based on how many slave servers there are.
*/
if (The_Game()->IsDedicated.Get() && !SlaveMaster.Am_I_Slave()) {
if (cUserOptions::Get_Bandwidth_Type() == BANDWIDTH_AUTO) {
if (ServerSettingsClass::Get_Master_Bandwidth() == 0 || ServerSettingsClass::Get_Master_Bandwidth() == 0xffffffff) {
int num_slaves = SlaveMaster.Get_Num_Enabled_Slaves();
if (num_slaves) {
bw = bw / (num_slaves+1);
}
}
}
}
PServerConnection->Set_Bandwidth_Budget_Out(bw);
//PServerConnection->Set_Bandwidth_Budget_Out(cUserOptions::BandwidthBps.Get());
int bw_scale = (cUserOptions::BandwidthBps.Get() * 2) / 10;
bw_scale = (bw_scale / 1000) * 1000;
cBandwidthGraph::Set_Scale(bw_scale);
}
double max_acceptable_packetloss_pc = 10;
PServerConnection->Set_Max_Acceptable_Packetloss_Pc(max_acceptable_packetloss_pc);
BOOL is_flow_control_enabled = !IS_SOLOPLAY;
PServerConnection->Enable_Flow_Control(is_flow_control_enabled);
WWASSERT(PTheGameData != NULL);
PServerConnection->Init_As_Server(
The_Game()->Get_Port(),
The_Game()->Get_Max_Players(),
The_Game()->IsDedicated.Get(),
ntohl(The_Game()->Get_Ip_Address()));
//
// Create teams
//
//if (The_Game()->Is_Team_Game()) {
for (int team_num = 0; team_num < MAX_TEAMS; team_num++) {
cTeam * p_team = new cTeam;
p_team->Init(team_num);
}
//}
cSbboManager::Reset();
cAppPacketStats::Reset();
#endif // not BETACLIENT
}
//-----------------------------------------------------------------------------
void cNetwork::Cleanup_Server(void)
{
WWDEBUG_SAY(("cNetwork::Cleanup_Server\n"));
if (I_Am_Server()) {
delete PServerConnection;
PServerConnection = NULL;
}
CombatManager::Set_I_Am_Server(false);
delete PServerStatListGroup;
PServerStatListGroup = NULL;
NetworkObjectClass::Set_Is_Server(false);
}
//-----------------------------------------------------------------------------
enum {
CHUNKID_PLAYERMANAGER = 9876543,
};
//-----------------------------------------------------------------------------
bool cNetwork::Save(ChunkSaveClass & csave)
{
csave.Begin_Chunk(CHUNKID_PLAYERMANAGER);
cPlayerManager::Save(csave);
csave.End_Chunk();
return true;
}
//-----------------------------------------------------------------------------
bool cNetwork::Load(ChunkLoadClass &cload)
{
while (cload.Open_Chunk()) {
switch(cload.Cur_Chunk_ID()) {
case CHUNKID_PLAYERMANAGER:
//cPlayerManager::Remove_All();
cPlayerManager::Load(cload);
break;
default:
Debug_Say(( "Unrecognized cNetwork chunkID\n" ));
break;
}
cload.Close_Chunk();
}
return true;
}
//-----------------------------------------------------------------------------
void cNetwork::Update_Fps(void)
{
static DWORD last_time_ms = 0;
static int frame_count = 0;
DWORD time_now_ms = TIMEGETTIME();
// Handle timer resetting.
if (time_now_ms < last_time_ms) {
last_time_ms = time_now_ms;
}
frame_count++;
DWORD time_interval = time_now_ms - last_time_ms;
if (time_interval > 1000) {
Fps = (int) (frame_count * 1000 / (float) time_interval + 0.5f);
last_time_ms = time_now_ms;
frame_count = 0;
// Needed for release mode too. ST - 1/23/2002 11:02PM
//#ifdef WWDEBUG
if (I_Am_Server()) {
WWASSERT(cServerFps::Get_Instance() != NULL);
cServerFps::Get_Instance()->Set_Fps(Fps);
}
//#endif // WWDEBUG
if (I_Am_Client() && PClientFps != NULL) {
PClientFps->Set_Fps(Fps);
}
}
}
void cNetwork::Connection_Status_Change_Feedback(void)
{
static unsigned long _last_print = TIMEGETTIME();
static bool _last_print_bad = false;
static unsigned long _print_good_soon = 0;
unsigned long time = TIMEGETTIME();
const WCHAR *string = NULL;
if (LastServerConnectionStateBad) {
if (_last_print_bad && time - _last_print < 4000) {
return;
}
string = TRANSLATE (IDS_MENU_CONNECTION_INTERRUPTED);
_last_print_bad = true;
} else {
/*
** Wait 2 secs after connection restore before printing message.
*/
if (_last_print_bad && _print_good_soon == 0) {
_print_good_soon = time;
return;
}
if (!_last_print_bad) {
return;
}
if (time - _print_good_soon < 2000) {
return;
}
string = TRANSLATE (IDS_MENU_CONNECTION_RESTORED);
_last_print_bad = false;
}
_last_print = time;
WideStringClass widestring(string, true);
if (CombatManager::Get_Message_Window() != NULL) {
//
// Display the message...
//
CombatManager::Get_Message_Window ()->Add_Message (widestring);
}
//
// Write it to the logfile
//
StringClass temp_string;
widestring.Convert_To(temp_string);
WWDEBUG_SAY(("\n***%s\n", temp_string.Peek_Buffer()));
}
//-----------------------------------------------------------------------------
void cNetwork::Update(void)
{
WWPROFILE( "cNetwork::Update" );
WWMEMLOG(MEM_GAMEDATA);
bool flush_packets = false;
ThinkCount++;
//
// Coding bugs may result in this function being called recursively.
// Detect and assert!
//
static int recursion_level = 0;
recursion_level++;
WWASSERT(recursion_level == 1);
Update_Fps();
#ifdef WWDEBUG
//
// Watch out for unexpected slow frames. They may interrupt networking.
//
static DWORD last_time_ms = TIMEGETTIME();
DWORD time_now_ms = TIMEGETTIME();
if (time_now_ms - last_time_ms > 2000) {
Debug_Say(("\n***cNetwork::Update: warning, think # %d was slow (%u ms)\n\n",
ThinkCount,
time_now_ms - last_time_ms));
}
last_time_ms = time_now_ms;
#endif // WWDEBUG
if (I_Am_Server()) {
if (I_Am_Client()) {
WWPROFILE( "Client Send" );
PClientConnection->Service_Send();
if (PClientConnection->Is_Bad_Connection() != LastServerConnectionStateBad) {
LastServerConnectionStateBad = PClientConnection->Is_Bad_Connection();
//Connection_Status_Change_Feedback();
}
Connection_Status_Change_Feedback();
}
// { WWPROFILE("GameSpy_QnR");
// GameSpyQnR.Think();
// }
WWPROFILE( "Server Read" );
PServerConnection->Service_Read();
if (!g_is_loading) {
WWPROFILE( "Shared CS Think" );
Shared_Client_And_Server_Think();
}
if (I_Am_Client() && !g_is_loading) {
WWPROFILE( "Client_Think" );
if (Client_Think()) {
flush_packets = true;
}
}
if (!g_is_loading) {
WWPROFILE( "Server_Think" );
if (Server_Think()) {
flush_packets = true;
} else {
// Server only sends packets in response to server think, not client think.
flush_packets = false;
}
}
{
WWPROFILE( "Server Send" );
PServerConnection->Service_Send();
}
if (I_Am_Client()) {
WWPROFILE( "Client Read" );
PClientConnection->Service_Read();
}
} else if (I_Am_Client()) {
{
WWPROFILE( "Client Read" );
PClientConnection->Service_Read();
}
if (PClientConnection->Is_Bad_Connection() != LastServerConnectionStateBad) {
LastServerConnectionStateBad = PClientConnection->Is_Bad_Connection();
Connection_Status_Change_Feedback();
}
if (!g_is_loading) {
WWPROFILE( "Shared CS Think" );
Shared_Client_And_Server_Think();
}
if (!g_is_loading) {
WWPROFILE( "Client_Think" );
if (Client_Think()) {
flush_packets = true;
}
}
{
WWPROFILE( "Client Send" );
if (PClientConnection != NULL) {
PClientConnection->Service_Send();
}
}
}
DEMO_SECURITY_CHECK;
NetworkObjectMgrClass::Delete_Pending();
if (flush_packets) {
PacketManager.Flush(true);
}
recursion_level--;
WWASSERT(recursion_level == 0);
}
//-----------------------------------------------------------------------------
void cNetwork::Client_Send_Packet(cPacket & packet, int mode)
{
#ifndef FREEDEDICATEDSERVER
WWASSERT(I_Am_Client());
if (cNetwork::PClientConnection->Is_Established()) {
PClientConnection->Send_Packet_To_Individual(packet, 0, mode);
/*
BYTE message_type = packet.Peek_Message_Type();
PClientStatList->Increment_Num_Msg_Sent(message_type);
PClientStatList->Increment_Num_Byte_Sent(message_type, packet.Get_Compressed_Size_Bytes());
*/
} else {
WWDEBUG_SAY(("cNetwork::Client_Send_Packet: warning: Connection not yet established.\n"));
//TSS2001 XXX DIE;
}
#endif // !FREEDEDICATEDSERVER
}
//-----------------------------------------------------------------------------
void cNetwork::Server_Send_Packet(cPacket & packet, int mode, int recipient)
{
#ifndef BETACLIENT
WWASSERT(I_Am_Server());
WWASSERT(PServerConnection->Is_Established());
if (recipient == ALL) {
//
// We cannot just send to all rhosts because that includes anyone
// browsing the server settings, whereas here we wish to send to the
// ingame players.
//
//PServerConnection->Send_Packet_To_All(*p_packet, mode);
SLNode<cPlayer> * objnode;
for (objnode = cPlayerManager::Get_Player_Object_List()->Head();
objnode; objnode = objnode->Next()) {
cPlayer * p_player = objnode->Data();
WWASSERT(p_player != NULL);
//if (p_player->Is_Human()) {
if (p_player->Get_Is_Active().Is_True() &&
p_player->Is_Human() &&
p_player->Get_Is_In_Game().Is_True()) {
int client_id = p_player->Get_Id();
PServerConnection->Send_Packet_To_Individual(
packet, client_id, mode);
/*
BYTE message_type = packet.Peek_Message_Type();
PServerStatListGroup->Increment_Num_Msg_Sent(client_id - 1, message_type);
PServerStatListGroup->Increment_Num_Byte_Sent(client_id - 1, message_type, packet.Get_Compressed_Size_Bytes());
*/
}
}
} else {
PServerConnection->Send_Packet_To_Individual(packet, recipient, mode);
/*
BYTE message_type = packet.Peek_Message_Type();
PServerStatListGroup->Increment_Num_Msg_Sent(recipient - 1, message_type);
PServerStatListGroup->Increment_Num_Byte_Sent(recipient - 1, message_type, packet.Get_Compressed_Size_Bytes());
*/
}
#endif // not BETACLIENT
}
//-----------------------------------------------------------------------------
void cNetwork::Server_Send_Packet_To_All_Connected(cPacket & packet, int mode)
{
#ifndef BETACLIENT
//
// Traverse the rhost list here in the application level, so that
// we can record message stats.
//
WWASSERT(I_Am_Server());
WWASSERT(PServerConnection->Is_Established());
//BYTE message_type = packet.Peek_Message_Type();
for (int rhost_id = PServerConnection->Get_Min_RHost(); rhost_id <= PServerConnection->Get_Max_RHost(); rhost_id++) {
if (Get_Server_Rhost(rhost_id) != NULL) {
PServerConnection->Send_Packet_To_Individual(packet, rhost_id, mode);
/*
PServerStatListGroup->Increment_Num_Msg_Sent(rhost_id - 1, message_type);
PServerStatListGroup->Increment_Num_Byte_Sent(rhost_id - 1, message_type, packet.Get_Compressed_Size_Bytes());
*/
}
}
#endif // not BETACLIENT
}
//-----------------------------------------------------------------------------
LPCSTR cNetwork::Get_Client_Enumeration_String(void)
{
WWASSERT(I_Am_Server());
WWASSERT(PServerConnection->Is_Established());
char temp_str[10];
strcpy(ClientEnumerationString, "");
for (int rhost_id = PServerConnection->Get_Min_RHost(); rhost_id <= PServerConnection->Get_Max_RHost(); rhost_id++) {
if (Get_Server_Rhost(rhost_id) != NULL) {
strcat(ClientEnumerationString, itoa(rhost_id, temp_str, 10));
strcat(ClientEnumerationString, " ");
}
if (strlen(ClientEnumerationString) > 20) {
strcpy(ClientEnumerationString, "many");
break;
}
}
return ClientEnumerationString;
}
//-----------------------------------------------------------------------------
cRemoteHost * cNetwork::Get_Server_Rhost(int client_id)
{
WWASSERT(I_Am_Server());
return PServerConnection->Get_Remote_Host(client_id);
}
//-----------------------------------------------------------------------------
cRemoteHost * cNetwork::Get_Client_Rhost(void)
{
WWASSERT(I_Am_Client());
return PClientConnection->Get_Remote_Host(SERVER_RHOST_ID);
}
//-----------------------------------------------------------------------------
float cNetwork::Get_Server_Rhost_Threshold_Priority(int client_id)
{
WWASSERT(I_Am_Server());
WWASSERT(Get_Server_Rhost(client_id) != NULL);
return Get_Server_Rhost(client_id)->Get_Threshold_Priority();
}
//-----------------------------------------------------------------------------
float cNetwork::Get_Client_Rhost_Threshold_Priority(void)
{
WWASSERT(I_Am_Client());
WWASSERT(Get_Client_Rhost() != NULL);
return Get_Client_Rhost()->Get_Threshold_Priority();
}
//-----------------------------------------------------------------------------
int cNetwork::Get_My_Id(void)
{
WWASSERT(I_Am_Client());
return PClientConnection->Get_Local_Id();
}
//-----------------------------------------------------------------------------
LPCSTR cNetwork::Get_Client_String(int recipient)
{
//WWASSERT(I_Am_Server());
if (recipient > 0) {
WWASSERT(PServerConnection->Is_Established());
if (recipient == ALL) {
sprintf(ClientString, "all %d clients (%s)",
PServerConnection->Get_Num_RHosts(),
Get_Client_Enumeration_String());
} else {
sprintf(ClientString, "client %d", recipient);
}
} else {
sprintf(ClientString, "server");
}
//
// Note: This WWASSERT would catch the overwrite AFTER it has happened...
//
WWASSERT(strlen(ClientString) < sizeof(ClientString));
return(ClientString);
}
//-----------------------------------------------------------------------------
void cNetwork::Server_Broken_Connection_Handler(int broken_rhost_id)
{
WWASSERT(broken_rhost_id >= 0);
//
// The net lib calls this when a reliable packet fails after
// many attempts. The connection data has already been destroyed.
//
WWDEBUG_SAY(("\n***Connection to client %d broken \n\n", broken_rhost_id));
WideStringClass widestring;
widestring.Format(
L"%s %d\n",
TRANSLATION(IDS_MP_CONNECTION_TO_CLIENT_BROKEN),
broken_rhost_id);
WWASSERT(CombatManager::Get_Message_Window () != NULL);
//Get_Text_Display()->Print_System(widestring);
//
// Display the message...
//
CombatManager::Get_Message_Window ()->Add_Message (widestring);
Vector3 color(1.0f, 1.0f, 0.0f);
ConsoleBox.Add_Message(&widestring, &color);
WWAudioClass::Get_Instance()->Create_Instant_Sound("Broken_Connection", Matrix3D(1));
cNetwork::Cleanup_After_Client(broken_rhost_id);
}
//-----------------------------------------------------------------------------
void cNetwork::Client_Broken_Connection_Handler(void)
{
//
// The net lib calls this when a reliable packet fails after
// many attempts. The connection data has already been destroyed.
//
WWASSERT(Get_Text_Display() != NULL);
WWASSERT(PClientConnection != NULL);
/**/
if (PClientConnection->Have_Id()) {
//cHelpText::Set(TRANSLATION(IDS_MP_CONNECTION_TO_SERVER_BROKEN));
DlgMsgBox::DoDialog(L"", TRANSLATION(IDS_MP_CONNECTION_TO_SERVER_BROKEN));
} else {
//cHelpText::Set(TRANSLATION(IDS_MP_UNABLE_CONNECT_TO_SERVER));
}
//TSS090401
//
// The client needs to quit back to the game list
//
extern bool g_client_quit;
g_client_quit = true;
//WWAudioClass::Get_Instance()->Create_Instant_Sound("Broken_Connection", Matrix3D(1));
/**/
/*
WWDEBUG_SAY(("Connection to server broken.\n"));
if (PClientConnection->Have_Id()) {
DlgMPConnectionRefused::DoDialog(TRANSLATION(IDS_MP_CONNECTION_TO_SERVER_BROKEN), true);
} else {
extern bool g_client_quit;
g_client_quit = true;
}
*/
}
//-----------------------------------------------------------------------------
void cNetwork::Process_Eviction_Sc(cPacket & packet)
{
WWDEBUG_SAY(("cNetwork::Process_Eviction_Sc\n"));
WWAudioClass::Get_Instance()->Create_Instant_Sound("Evicted_By_Server", Matrix3D(1));
WWASSERT(I_Am_Client());
UINT min_bps;
packet.Get(min_bps);//naughty... type conversion
float max_packetloss;
packet.Get(max_packetloss);
//UINT sustainable_bps = (UINT) packet.Get();
WWDEBUG_SAY(("\n* You were evicted from the server for inadequate bandwidth performance.\n"
"* This server requires packetloss of less than %5.2f %%, and a minimum\n"
"* sustainable bandwidth of %d bps.\n", max_packetloss, min_bps));
//
// At this stage, just signal to close down. This is
// a convenience during development
//
DIE;
}
//-----------------------------------------------------------------------------
void cNetwork::Eviction_Handler(int evicted_rhost_id)
{
WWMEMLOG(MEM_NETWORK);
WWDEBUG_SAY(("cNetwork::Eviction_Handler\n"));
WWASSERT(evicted_rhost_id >= 0);
WWASSERT(I_Am_Server());
//Send_Eviction_Sc(evicted_rhost_id);
cEvictionEvent * p_event = new cEvictionEvent;
p_event->Init(evicted_rhost_id, EVICTION_POOR_BANDWIDTH);
cNetwork::Flush();
//WWAudioClass::Get_Instance()->Create_Instant_Sound("Broken_Connection", Matrix3D(1));
}
//-----------------------------------------------------------------------------
bool cNetwork::I_Am_God(void)
{
bool i_am_god = false;
if (I_Am_Client()) {
cPlayer * p_player = cPlayerManager::Find_Player(Get_My_Id());
if (p_player != NULL && p_player->Invulnerable.Is_True()) {
i_am_god = true;
}
}
return i_am_god;
}
//-----------------------------------------------------------------------------
cPlayer * cNetwork::Get_My_Player_Object(void)
{
cPlayer * p_me = NULL;
if (I_Am_Client()) {
p_me = cPlayerManager::Find_Player(Get_My_Id());
}
return p_me;
}
//-----------------------------------------------------------------------------
int cNetwork::Get_My_Team_Number(void)
{
cPlayer * p_me = Get_My_Player_Object();
WWASSERT(p_me != NULL);
return p_me->Get_Player_Type();
}
//-----------------------------------------------------------------------------
Vector3 cNetwork::Get_My_Color(void)
{
cPlayer * p_me = cPlayerManager::Find_Player(Get_My_Id());
WWASSERT(p_me != NULL);
return p_me->Get_Color();
}
//-----------------------------------------------------------------------------
int cNetwork::Show_Welcome_Message(WideStringClass & name)
{
int show = false;
if (!IS_MISSION && (name == cNetInterface::Get_Nickname())) {
show = true;
}
return show;
}
//---------------------------------------------------------------------------
float cNetwork::Get_Distance_Priority(Vector3 & pos1, Vector3 & pos2)
{
Vector3 gap = pos2 - pos1;
float d = gap.Length();
WWASSERT(PTheGameData != NULL);
float max_distance = The_Game()->Get_Maximum_World_Distance();
WWASSERT(max_distance > 0);
float range1 = max_distance / 25.0f;
float range2 = max_distance / 5.0f;
float range3 = max_distance + 1;
float priority;
if (d < range1) {
priority = (float) ((range1 - d) / range1 * 0.499 + 0.50);
} else if (d < range2) {
priority = (float) ((range2 - d) / (range2 - range1) * 0.40 + 0.10);
} else if (d < range3) {
priority = (float) ((range3 - d) / (range3 - range2) * 0.10 + 0.00);
} else {
//WWASSERT(0);
static bool already_warned = false;
if (!already_warned) {
Debug_Say(("Someone went outside the world box! (possibly numerous times)\n"));
already_warned = true;
}
priority = 0;
}
WWASSERT(priority > -WWMATH_EPSILON && priority < 1 + WWMATH_EPSILON);
return(priority);
}
//-----------------------------------------------------------------------------
void cNetwork::Shell_Command(LPCSTR command)
{
WWASSERT(command != NULL);
HINSTANCE hinst = ShellExecute(NULL, NULL, command, NULL, "", SW_SHOW);
if ((int) hinst <= 32) {
WWDEBUG_SAY(("Error: ShellExecute failed.\n"));
}
}
//-----------------------------------------------------------------------------
REFUSAL_CODE cNetwork::Application_Acceptance_Handler(cPacket & packet)
{
#ifndef BETACLIENT
WWDEBUG_SAY(("cNetwork::Application_Acceptance_Handler\n"));
WWASSERT(I_Am_Server());
//
// Get player name
// This is not supposed to be empty, but if for whatever reason it it, we should
// just refuse, rather than crash.
//
WideStringClass player_name(0, true);
//packet.Get_Wide_Terminated_String(player_name.Get_Buffer(256), 256);
packet.Get_Wide_Terminated_String(player_name.Get_Buffer(256), 256, true);
if (player_name.Get_Length() == 0) {
return REFUSAL_VERSION_MISMATCH;
}
// Get the clients password
WideStringClass password(0, true);
packet.Get_Wide_Terminated_String(password.Get_Buffer(256), 256, true);
// Get clients exe version
int client_exe_key = packet.Get(client_exe_key);
// Make sure the clients password matches the games password.
WWASSERT(PTheGameData != NULL);
if (The_Game()->IsPassworded.Is_True() && password.Compare(The_Game()->Get_Password()) != 0) {
return REFUSAL_BAD_PASSWORD;
}
// Make sure the exe versions match
if (client_exe_key != cNetwork::Get_Exe_Key()) {
return REFUSAL_VERSION_MISMATCH;
}
// Make sure we haven't exceeded our max player limit
if (cPlayerManager::Count() >= The_Game()->Get_Max_Players()) {
return REFUSAL_GAME_FULL;
}
//
// TSS100501
//
// Make sure the player is not already in the game
//GAMESPY
//if (cPlayerManager::Find_Player(player_name)) {
if (!cGameSpyAdmin::Is_Gamespy_Game() &&
cPlayerManager::Find_Player(player_name)) {
return REFUSAL_PLAYER_EXISTS;
}
#endif // not BETACLIENT
return REFUSAL_CLIENT_ACCEPTED;
}
//-----------------------------------------------------------------------------
void cNetwork::Connection_Handler(int new_rhost_id)
{
WWMEMLOG(MEM_NETWORK);
#ifndef BETACLIENT
WWDEBUG_SAY(("cNetwork::Connection_Handler\n"));
WWASSERT(new_rhost_id >= 0);
WWASSERT(I_Am_Server());
WWASSERT(Receiver != NULL);
/*
//
// Tell the new guy about all the teams. He needs this early in case he
// needs to choose a team
//
SLNode<cTeam> * team_node;
cTeam * p_team;
for (team_node = cTeamManager::Get_Team_Object_List()->Head(); team_node; team_node = team_node->Next()) {
p_team = team_node->Data();
WWASSERT(p_team != NULL);
Send_Server_New_Team(p_team, new_rhost_id);
}
*/
//TSS2001 - normal update mechanism won't catch this in time.
//
// Tell the new guy about all the teams. He needs this early in case he
// needs to choose a team
//
if (!cNetwork::I_Am_Client() || new_rhost_id != cNetwork::Get_My_Id()) {
for (
SLNode<cTeam> * team_node = cTeamManager::Get_Team_Object_List()->Head();
team_node;
team_node = team_node->Next()) {
cTeam * p_team = team_node->Data();
WWASSERT(p_team != NULL);
Send_Object_Update(p_team, new_rhost_id);
}
}
//
// Next, send info about any remaining game options. This is only those
// options that he doesn't pick up from the channel listing.
//
//Send_Server_Game_Options(new_rhost_id);
cGameOptionsEvent * p_event = new cGameOptionsEvent;
p_event->Init(new_rhost_id);
Send_Object_Update(p_event, new_rhost_id);
#endif // not BETACLIENT
}
//-----------------------------------------------------------------------------
void cNetwork::Set_Desired_Frame_Sleep_Ms(int b)
{
WWASSERT(b >= 0);
#ifdef WWDEBUG
cDevOptions::DesiredFrameSleepMs.Set(b);
#endif //WWDEBUG
}
//-----------------------------------------------------------------------------
void cNetwork::Set_Simulated_Packet_Loss_Pc(int b)
{
WWASSERT(b >= 0);
if (PClientConnection != NULL) {
PClientConnection->Set_Packet_Loss(b);
}
if (PServerConnection != NULL) {
PServerConnection->Set_Packet_Loss(b);
}
//SimulatedPacketLossPc = b;
#ifdef WWDEBUG
cDevOptions::SimulatedPacketLossPc.Set(b);
#endif //WWDEBUG
}
//-----------------------------------------------------------------------------
void cNetwork::Set_Simulated_Packet_Duplication_Pc(int b)
{
WWASSERT(b >= 0);
if (PClientConnection != NULL) {
PClientConnection->Set_Packet_Duplication(b);
}
if (PServerConnection != NULL) {
PServerConnection->Set_Packet_Duplication(b);
}
//SimulatedPacketDuplicationPc = b;
#ifdef WWDEBUG
cDevOptions::SimulatedPacketDuplicationPc.Set(b);
#endif
}
//-----------------------------------------------------------------------------
void cNetwork::Set_Simulated_Latency_Range_Ms(int lower, int upper)
{
WWASSERT(lower >= 0);
WWASSERT(upper >= 0);
WWASSERT(lower <= upper);
if (PClientConnection != NULL) {
PClientConnection->Set_Packet_Latency_Range(lower, upper);
}
if (PServerConnection != NULL) {
PServerConnection->Set_Packet_Latency_Range(lower, upper);
}
//SimulatedLatencyRangeMsLower = lower;
//SimulatedLatencyRangeMsUpper = upper;
#ifdef WWDEBUG
cDevOptions::SimulatedLatencyRangeMsLower.Set(lower);
cDevOptions::SimulatedLatencyRangeMsUpper.Set(upper);
#endif
}
//-----------------------------------------------------------------------------
void cNetwork::Set_Spam_Count(int spam_count)
{
WWASSERT(spam_count >= 0);
//SpamCount = spam_count;
#ifdef WWDEBUG
cDevOptions::SpamCount.Set(spam_count);
#endif
}
//-----------------------------------------------------------------------------
void cNetwork::Get_Simulated_Latency_Range_Ms(int & lower, int & upper)
{
#ifdef WWDEBUG
lower = cDevOptions::SimulatedLatencyRangeMsLower.Get();
upper = cDevOptions::SimulatedLatencyRangeMsUpper.Get();
#endif
}
//-----------------------------------------------------------------------------
void
cNetwork::Flush(void)
{
WWDEBUG_SAY(("cNetwork::Flush\n"));
const bool is_urgent = true;
//if (GameModeManager::Find ("Combat")->Is_Active() && Receiver != NULL) {
if (Receiver != NULL) {
if (I_Am_Server()) {
Receiver->Server_Update_Dynamic_Objects(is_urgent);
}
if (I_Am_Client()) {
Receiver->Client_Update_Dynamic_Objects(is_urgent);
}
}
if (I_Am_Server()) {
PServerConnection->Service_Send(is_urgent);
}
if (I_Am_Client()) {
PClientConnection->Service_Send(is_urgent);
}
PacketManager.Flush(true);
}
void cNetwork::SwitchTeam(int newTeam)
{
cPlayer* player = cPlayerManager::Find_Player(Get_My_Id());
if (player) {
int team = player->Get_Player_Type();
if (newTeam != team) {
cChangeTeamEvent* event = new cChangeTeamEvent;
event->Init();
}
}
}
//-----------------------------------------------------------------------------
void cNetwork::Enable_Waiting_Players(void)
{
SLNode<cPlayer> * objnode;
for (objnode = cPlayerManager::Get_Player_Object_List()->Head() ; objnode != NULL ; objnode = objnode->Next()) {
cPlayer * p_player = objnode->Data();
WWASSERT(p_player != NULL);
if (p_player->Is_Human() && p_player->Get_Is_Waiting_For_Intermission().Is_True()) {
p_player->Set_Is_In_Game(true);
p_player->Set_Is_Waiting_For_Intermission(false);
if (cNetwork::PServerConnection) {
cNetwork::PServerConnection->Set_Rhost_Is_In_Game(p_player->Get_Id(), true);
}
cGameDataUpdateEvent * p_event = new cGameDataUpdateEvent();
p_event->Init(p_player->Get_Id());
}
}
}
Reference in a new issue Copy permalink