609 lines
15 KiB
C++
609 lines
15 KiB
C++
/*
|
|
** 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/>.
|
|
*/
|
|
|
|
/******************************************************************************
|
|
*
|
|
* FILE
|
|
* $Archive: /Commando/Code/Commando/WOLJoinGame.cpp $
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* PROGRAMMER
|
|
* $Author: Denzil_l $
|
|
*
|
|
* VERSION INFO
|
|
* $Revision: 18 $
|
|
* $Modtime: 1/17/02 11:43a $
|
|
*
|
|
******************************************************************************/
|
|
|
|
#include "WOLJoinGame.h"
|
|
#include "DlgWOLWait.h"
|
|
#include "DlgMessageBox.h"
|
|
#include "DlgMPConnect.h"
|
|
#include "Nat.h"
|
|
#include "Natter.h"
|
|
#include "FirewallWait.h"
|
|
#include "CNetwork.h"
|
|
#include "WOLGameInfo.h"
|
|
#include <WWOnline\WOLSession.h>
|
|
#include <WWOnline\WOLProduct.h>
|
|
#include <WWOnline\WOLChannel.h>
|
|
#include "String_IDs.h"
|
|
#include <WWTranslateDB\TranslateDB.h>
|
|
#include <WWDebug\WWDebug.h>
|
|
|
|
using namespace WWOnline;
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::JoinTheGame
|
|
*
|
|
* DESCRIPTION
|
|
* Join the specified game.
|
|
*
|
|
* INPUTS
|
|
* GameName - Name of the game to join
|
|
* Password - Game password
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
void WOLJoinGame::JoinTheGame(const wchar_t* gameName, const wchar_t* password, bool allowTeamSelect)
|
|
{
|
|
WWASSERT(gameName != NULL && "Invalid parameter");
|
|
|
|
if (gameName)
|
|
{
|
|
// Create the object to handle the game joining process.
|
|
WOLJoinGame* joinGame = new WOLJoinGame;
|
|
WWASSERT(joinGame && "WOLJoinGame failed to instantiate");
|
|
|
|
if (joinGame)
|
|
{
|
|
if (joinGame->FinalizeCreate())
|
|
{
|
|
// Start the join game process
|
|
if (joinGame->Join(gameName, password, allowTeamSelect))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// This will delete the WOLJoinGame object
|
|
joinGame->Release_Ref();
|
|
}
|
|
|
|
// If we got here then the join failed. Show a dialog telling the user
|
|
// that we were unable to join the requested game.
|
|
WideStringClass message(255, true);
|
|
message.Format(TRANSLATE(IDS_GAME_JOINCHANNEL), gameName);
|
|
DlgMsgBox::DoDialog(TRANSLATE(IDS_WOL_ERROR), message);
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::WOLJoinGame
|
|
*
|
|
* DESCRIPTION
|
|
* Default constructor
|
|
*
|
|
* INPUTS
|
|
* NONE
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
WOLJoinGame::WOLJoinGame() :
|
|
mJoinState(IDLE_STATE),
|
|
mAllowTeamSelect(true),
|
|
mTeamChoice(-1),
|
|
mClanID(0)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Instantiated\n"));
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::~WOLJoinGame
|
|
*
|
|
* DESCRIPTION
|
|
* Destructor
|
|
*
|
|
* INPUTS
|
|
* NONE
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
WOLJoinGame::~WOLJoinGame()
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Destroyed\n"));
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::FinalizeCreate
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* INPUTS
|
|
* NONE
|
|
*
|
|
* RESULT
|
|
* True if successful
|
|
*
|
|
******************************************************************************/
|
|
|
|
bool WOLJoinGame::FinalizeCreate(void)
|
|
{
|
|
mWOLSession = Session::GetInstance(false);
|
|
return mWOLSession.IsValid();
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::CreateGameFromChannel
|
|
*
|
|
* DESCRIPTION
|
|
* Create a game data instance from a WWOnline game channel.
|
|
*
|
|
* INPUTS
|
|
* Channel - Game channel to create game data instance from.
|
|
*
|
|
* RESULT
|
|
* Game - Instance to game.
|
|
*
|
|
******************************************************************************/
|
|
|
|
cGameData* WOLJoinGame::CreateGameFromChannel(const RefPtr<ChannelData>& channel)
|
|
{
|
|
WWASSERT(channel.IsValid() && "Invalid paramter");
|
|
WWDEBUG_SAY(("WOLJoinGame: Create game from channel '%S'\n", (const WCHAR*)channel->GetName()));
|
|
|
|
// Extract game information from the channel
|
|
WOLGameInfo gameInfo(channel);
|
|
|
|
if (gameInfo.IsDataValid() == false)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Create an instance of the correct type.
|
|
cGameData* theGame = cGameData::Create_Game_Of_Type((cGameData::GameTypeEnum)gameInfo.GameType());
|
|
|
|
if (theGame)
|
|
{
|
|
// The game owner is the name of the channel
|
|
const WideStringClass& channelName = channel->GetName();
|
|
theGame->Set_Owner(const_cast<WideStringClass&>(channelName));
|
|
|
|
if (gameInfo.IsPassworded())
|
|
{
|
|
theGame->Set_Password(mPassword);
|
|
}
|
|
|
|
theGame->Import_Tier_1_Data(gameInfo);
|
|
}
|
|
|
|
return theGame;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::Join
|
|
*
|
|
* DESCRIPTION
|
|
* The steps to join a game successfully are as follows:
|
|
*
|
|
* 1) Join the game channel.
|
|
* 2) Allow user to select his team.
|
|
* 3) Receive team selection choice.
|
|
* 4) Create an instance of the game.
|
|
* 5) Perform firewall negotiation
|
|
* 6) Connect to the server.
|
|
*
|
|
* INPUTS
|
|
* Name - Name of game channel (This is usually the same as the hosts name).
|
|
* Password - Password to enter game; NULL if not passworded.
|
|
* AllowSelect - True if user is allowed to select their team.
|
|
*
|
|
* RESULT
|
|
* True if join request is successful.
|
|
*
|
|
******************************************************************************/
|
|
|
|
bool WOLJoinGame::Join(const wchar_t* gameName, const wchar_t* password, bool allowTeamSelect)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Joining game channel '%S' Password: '%S'\n", gameName, password));
|
|
|
|
mAllowTeamSelect = allowTeamSelect;
|
|
|
|
mGameName = gameName;
|
|
mPassword = password;
|
|
|
|
//---------------------------------------------------------------------------
|
|
// First we need to join the channel
|
|
//---------------------------------------------------------------------------
|
|
RefPtr<Product> product = Product::Current();
|
|
WWASSERT(product.IsValid());
|
|
|
|
if (!product.IsValid())
|
|
{
|
|
WWDEBUG_SAY(("ERROR: WWOnline product not initialized.\n"));
|
|
return false;
|
|
}
|
|
|
|
int gameType = product->GetGameCode();
|
|
|
|
RefPtr<WaitCondition> wait = mWOLSession->JoinChannel(gameName, password, gameType);
|
|
|
|
if (!wait.IsValid())
|
|
{
|
|
WWDEBUG_SAY(("ERROR: Couldn't create JoinChannellWait\n"));
|
|
return false;
|
|
}
|
|
|
|
// Tell the firewall code that we are connecting as a client.
|
|
WOLNATInterface.Set_Server(false);
|
|
|
|
// Listen for channel events. We will use this to obtain the channel
|
|
Observer<ChannelEvent>::NotifyMe(*mWOLSession);
|
|
|
|
// Generate message for user to see while we are attempting to join the channel.
|
|
WideStringClass message(255, true);
|
|
message.Format(TRANSLATE(IDS_GAME_JOINCHANNEL), gameName);
|
|
|
|
mJoinState = JOINING_STATE;
|
|
return DlgWOLWait::DoDialog((const WCHAR*)message, wait, this);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::ProceedWithConnection
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* INPUTS
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
void WOLJoinGame::ProceedWithConnection(int teamChoice)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Proceeding with connection\n"));
|
|
|
|
bool success = StartServerConnect();
|
|
|
|
// If the connection is underway then wait for it to complete.
|
|
if (success)
|
|
{
|
|
mTeamChoice = teamChoice;
|
|
return;
|
|
}
|
|
|
|
// An error has occured while attempting to connect.
|
|
DlgMsgBox::DoDialog(IDS_WOL_ERROR, IDS_MP_UNABLE_CONNECT_TO_SERVER);
|
|
|
|
Leave();
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::Leave
|
|
*
|
|
* DESCRIPTION
|
|
*
|
|
* INPUTS
|
|
*
|
|
* RESULT
|
|
*
|
|
******************************************************************************/
|
|
|
|
void WOLJoinGame::Leave(void)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Leaving channel\n"));
|
|
|
|
// If the user elected to leave the game or we encountered an error starting
|
|
// the connection then leave the channel.
|
|
RefPtr<WaitCondition> wait = mWOLSession->LeaveChannel();
|
|
DlgWOLWait::DoDialog(IDS_GAME_LEAVECHANNEL, wait);
|
|
|
|
// This will delete the WOLJoinGame object
|
|
Release_Ref();
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::StartServerConnect
|
|
*
|
|
* DESCRIPTION
|
|
* Start server connection negotiation
|
|
*
|
|
* INPUTS
|
|
* NONE
|
|
*
|
|
* RESULT
|
|
* True if negotiation successfully started.
|
|
*
|
|
******************************************************************************/
|
|
|
|
bool WOLJoinGame::StartServerConnect(void)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Start server connect\n"));
|
|
|
|
// If the channel is NOT valid then bad things have happened.
|
|
if (!mTheChannel.IsValid())
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: ERROR channel not valid when connecting to host\n"));
|
|
WWASSERT(mTheChannel.IsValid() && "Bad channel connecting to host");
|
|
return false;
|
|
}
|
|
|
|
// Verify that the user can join this game.
|
|
WOLGameInfo gameInfo(mTheChannel);
|
|
RefPtr<UserData> user = mWOLSession->GetCurrentUser();
|
|
|
|
if (gameInfo.CanUserJoin(user) == false)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: ERROR - User cannot join this game\n"));
|
|
return false;
|
|
}
|
|
|
|
// If we are playing a clan game then we need the users clan ID in order to join.
|
|
if (gameInfo.IsClanGame())
|
|
{
|
|
mClanID = user->GetSquadID();
|
|
}
|
|
|
|
// Delete any existing game.
|
|
if (PTheGameData)
|
|
{
|
|
delete PTheGameData;
|
|
PTheGameData = NULL;
|
|
}
|
|
|
|
// Create a new game from the channel
|
|
cGameData* theGame = CreateGameFromChannel(mTheChannel);
|
|
WWASSERT(theGame && "WOLJoinGame failed to create cGameData");
|
|
|
|
if (theGame == NULL)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: ERROR failed to create cGameData\n"));
|
|
return false;
|
|
}
|
|
|
|
// Assign the new game instance
|
|
PTheGameData = theGame;
|
|
|
|
// We are done with the channel
|
|
mTheChannel.Release();
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Wait for the firewall negotiation. Will send DlgWOLWaitEvent when complete.
|
|
//---------------------------------------------------------------------------
|
|
RefPtr<WaitCondition> wait = FirewallConnectWait::Create();
|
|
|
|
if (!wait.IsValid())
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: ERROR couldn't create FireWallWait\n"));
|
|
return false;
|
|
}
|
|
|
|
mJoinState = FIREWALL_STATE;
|
|
return DlgWOLWait::DoDialog(TRANSLATE (IDS_MENU_CONNECTING), wait, this);
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::ConnectToServer
|
|
*
|
|
* DESCRIPTION
|
|
* Establish connection to game server.
|
|
*
|
|
* INPUTS
|
|
* NONE
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
void WOLJoinGame::ConnectToServer(void)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Connect to server\n"));
|
|
|
|
// Start the client
|
|
unsigned short my_port = FirewallHelper.Get_Client_Bind_Port();
|
|
cNetwork::Init_Client(my_port);
|
|
|
|
// Display the "connecting" dialog.
|
|
// Note: This dialog will close automatically when the connection has been
|
|
// successfully completed.
|
|
DlgMPConnect::DoDialog(mTeamChoice, mClanID);
|
|
|
|
// Our job is done. (This will delete the WOLJoinGame object)
|
|
Release_Ref();
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::HandleNotification(ChannelEvent)
|
|
*
|
|
* DESCRIPTION
|
|
* Handle channel events. Of particular interest during a join is the
|
|
* channel data event. This event tells us that there is information
|
|
* available from the channel encoded in the topic and exinfo fields that
|
|
* we can use to create the game from.
|
|
*
|
|
* INPUTS
|
|
* ChannelEvent
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
void WOLJoinGame::HandleNotification(ChannelEvent& event)
|
|
{
|
|
// The channel data is always updated immediately after a channel is joined.
|
|
// Therefore use this event to start the creation of the game we are joining.
|
|
if (event.GetStatus() == ChannelNewData)
|
|
{
|
|
// Get the channel that is the subject of this event.
|
|
const RefPtr<ChannelData>& channel = event.Subject();
|
|
WWASSERT(channel.IsValid());
|
|
|
|
// If the name of this channel is the name of the game we are joining
|
|
// then create the game from this channel.
|
|
const WideStringClass& channelName = channel->GetName();
|
|
|
|
if (channelName.Compare_No_Case(mGameName) == 0)
|
|
{
|
|
WWDEBUG_SAY(("WOLJoinGame: Joined game channel '%S'\n", (const WCHAR*)channelName));
|
|
|
|
// Keep a reference to the channel so we can create the game from it latter
|
|
mTheChannel = channel;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::HandleNotification(DlgWOLWaitEvent)
|
|
*
|
|
* DESCRIPTION
|
|
* Handle result of channel join and firewall negotiation. If everything
|
|
* went okay then proceed with connecting to the game server. Otherwise
|
|
* tell the user what went wrong.
|
|
*
|
|
* INPUTS
|
|
* Event - Result event from joining WOL game wait condition.
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
void WOLJoinGame::HandleNotification(DlgWOLWaitEvent& event)
|
|
{
|
|
// If the wait condition completed with success.
|
|
if (event.Result() == WaitCondition::ConditionMet)
|
|
{
|
|
if (JOINING_STATE == mJoinState)
|
|
{
|
|
mJoinState = IDLE_STATE;
|
|
|
|
// If we just joined the channel we need to present the user with
|
|
// the team selection dialog. This dialog will allow them to view
|
|
// the current teams and / or change their team.
|
|
if (mAllowTeamSelect)
|
|
{
|
|
// DlgMPTeamSelect will send a signal indicating if the user has opted
|
|
// to continue with the game or to back out. See ReceiveSignal()
|
|
DlgMPTeamSelect::DoDialog(*this);
|
|
}
|
|
else
|
|
{
|
|
ProceedWithConnection(-1);
|
|
}
|
|
}
|
|
else if (FIREWALL_STATE == mJoinState)
|
|
{
|
|
// If we have finished the firewall negotiation then proceed with
|
|
// the server connection.
|
|
mJoinState = IDLE_STATE;
|
|
ConnectToServer();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If the wait condition failed then report the reason for the failure and
|
|
// leave the channel.
|
|
const WideStringClass& text = event.Subject()->GetResultText();
|
|
WWDEBUG_SAY(("WOLJoinGame: Wait failed - %S\n", (const WCHAR*)text));
|
|
|
|
DlgMsgBox::DoDialog(TRANSLATE(IDS_WOL_ERROR), text);
|
|
|
|
Leave();
|
|
}
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* NAME
|
|
* WOLJoinGame::ReceiveSignal(MPChooseTeamSignal)
|
|
*
|
|
* DESCRIPTION
|
|
* The team selection dialog will send a signal indicating the users choice
|
|
* regarding his team preference.
|
|
*
|
|
* INPUTS
|
|
* Signal
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
******************************************************************************/
|
|
|
|
void WOLJoinGame::ReceiveSignal(MPChooseTeamSignal& signal)
|
|
{
|
|
// If the user wants to proceed then connect to the server othewise leave
|
|
// the game channel.
|
|
if (signal.GetItemA() == true)
|
|
{
|
|
ProceedWithConnection(signal.GetItemB());
|
|
}
|
|
else
|
|
{
|
|
Leave();
|
|
}
|
|
}
|