CWE-ou-minkata/Sources/Plasma/FeatureLib/pfGameMgr/pfGameMgr.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, 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/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
/*****************************************************************************
*
*   $/Plasma20/Sources/Plasma/FeatureLib/pfGameMgr/pfGameMgr.cpp
*   
***/

#include "Pch.h"
#pragma hdrstop


/*****************************************************************************
*
*   Local types
*
***/

//============================================================================
// pfGameCli factory
//============================================================================
struct Factory : THashKeyVal<Uuid> {

	HASHLINK(Factory)	link;
	const GameTypeReg &	reg;

	Factory (const GameTypeReg & reg);
	Factory& operator= (const Factory &);	// not impl
};

//============================================================================
// pfGameCli internal state
//============================================================================
struct IGameCli : THashKeyVal<unsigned> {

	HASHLINK(IGameCli)	link;
	pfGameCli *			gameCli;
	Factory *			factory;
	plKey				receiver;
	unsigned			playerCount;
	
	IGameCli (
		pfGameCli *	gameCli,
		unsigned	gameId,
		plKey		receiver
	);

	void Recv				(GameMsgHeader * msg, void * param);
	void RecvPlayerJoined	(const Srv2Cli_Game_PlayerJoined & msg, void * param);
	void RecvPlayerLeft		(const Srv2Cli_Game_PlayerLeft & msg, void * param);
	void RecvInviteFailed	(const Srv2Cli_Game_InviteFailed & msg, void * param);
	void RecvOwnerChange	(const Srv2Cli_Game_OwnerChange & msg, void * param);
};

//============================================================================
// Transaction states
//============================================================================
struct TransState : THashKeyVal<unsigned> {

	HASHLINK(TransState)	link;
	void *					param;
	TransState (unsigned transId, void * param);
};
struct JoinTransState {

	plKey receiver;
	JoinTransState (plKey receiver)
	:	receiver(receiver)
	{ }
};

//============================================================================
// IGameMgr
//============================================================================
struct IGameMgr {

	pfGameCli * CreateGameCli (const Uuid & gameTypeId, unsigned gameId, plKey receiver);

	void Recv				(GameMsgHeader * msg);
	void RecvGameInstance	(const Srv2Cli_GameMgr_GameInstance & msg, void * param);
	void RecvInviteReceived	(const Srv2Cli_GameMgr_InviteReceived & msg, void * param);
	void RecvInviteRevoked	(const Srv2Cli_GameMgr_InviteRevoked & msg, void * param);

	static void StaticRecv (GameMsgHeader * msg);
};


/*****************************************************************************
*
*   Local data
*
***/

static HASHTABLEDECL(TransState, THashKeyVal<unsigned>, link)	s_trans;
static HASHTABLEDECL(IGameCli, THashKeyVal<unsigned>, link)		s_games;
static HASHTABLEDECL(Factory, THashKeyVal<Uuid>, link)			s_factories;

static long				s_transId;
static ARRAYOBJ(plKey)	s_receivers;


/*****************************************************************************
*
*   Local functions
*
***/

//============================================================================
static void ShutdownFactories () {

	while (Factory * factory = s_factories.Head())
		DEL(factory);
}

//============================================================================
AUTO_INIT_FUNC (SetGameMgrMsgHandler) {

	NetCliGameSetRecvGameMgrMsgHandler(IGameMgr::StaticRecv);
	atexit(ShutdownFactories);
}

//============================================================================
static inline unsigned INextTransId () {

	unsigned transId = AtomicAdd(&s_transId, 1);
	while (!transId)
		transId = AtomicAdd(&s_transId, 1);
	return transId;
}


/*****************************************************************************
*
*   IGameMgr
*
***/

//============================================================================
pfGameCli * IGameMgr::CreateGameCli (const Uuid & gameTypeId, unsigned gameId, plKey receiver) {
	
	if (Factory * factory = s_factories.Find(gameTypeId)) {
		pfGameCli * gameCli = factory->reg.create(gameId, receiver);
		gameCli->internal->factory = factory;
		return gameCli;
	}
	
	return nil;
}

//============================================================================
void IGameMgr::RecvGameInstance (const Srv2Cli_GameMgr_GameInstance & msg, void * param) {

	JoinTransState * state = (JoinTransState *)param;

	pfGameCli *	cli = nil;
	IGameCli *	internal = nil;
	if (msg.result == kGameJoinSuccess) {
		if (nil == (internal = s_games.Find(msg.newGameId)))
			cli = CreateGameCli(msg.gameTypeId, msg.newGameId, state->receiver);
		else
			cli = internal->gameCli;
	}

	DEL(state);
}

//============================================================================
void IGameMgr::RecvInviteReceived (const Srv2Cli_GameMgr_InviteReceived & msg, void * param) {
	pfGameMgrMsg * gameMgrMsg = NEWZERO(pfGameMgrMsg);
	gameMgrMsg->Set(msg);
	for (unsigned i = 0; i < s_receivers.Count(); ++i)
		gameMgrMsg->AddReceiver(s_receivers[i]);
	gameMgrMsg->Send();
}

//============================================================================
void IGameMgr::RecvInviteRevoked (const Srv2Cli_GameMgr_InviteRevoked & msg, void * param) {
	pfGameMgrMsg * gameMgrMsg = NEWZERO(pfGameMgrMsg);
	gameMgrMsg->Set(msg);
	for (unsigned i = 0; i < s_receivers.Count(); ++i)
		gameMgrMsg->AddReceiver(s_receivers[i]);
	gameMgrMsg->Send();
}

//============================================================================
void IGameMgr::Recv (GameMsgHeader * msg) {

	// Look for transaction state associated with this message	
	void * param;
	if (TransState * trans = s_trans.Find(msg->transId)) {
		param		= trans->param;
		DEL(trans);
	}
	else {
		param		= nil;
	}

	// If the message has a receiver gameId specified, then
	// hand it off to that game client for dispatch.
	if (unsigned gameId = msg->recvGameId) {
		if (IGameCli * node = s_games.Find(gameId)) {
			node->Recv(msg, param);
		}
		return;
	}
	
	// The message was meant for the game manager (that's us); dispatch it.
	#define DISPATCH(a) case kSrv2Cli_GameMgr_##a: {						\
		const Srv2Cli_GameMgr_##a & m = *(const Srv2Cli_GameMgr_##a *)msg;	\
		Recv##a(m, param);													\
	}																		\
	break;																	//
	switch (msg->messageId) {
		DISPATCH(GameInstance);
		DISPATCH(InviteReceived);
		DISPATCH(InviteRevoked);
		DEFAULT_FATAL(msg->messageId);
	}
	#undef DISPATCH
}

//============================================================================
void IGameMgr::StaticRecv (GameMsgHeader * msg) {

	pfGameMgr::GetInstance()->internal->Recv(msg);
}


/*****************************************************************************
*
*	pfGameMgrMsg
*
***/

//============================================================================
pfGameMgrMsg::pfGameMgrMsg () {

	netMsg = nil;
}

//============================================================================
pfGameMgrMsg::~pfGameMgrMsg () {

	FREE(netMsg);
}

//============================================================================
void pfGameMgrMsg::Set (const GameMsgHeader & msg) {

	netMsg = (GameMsgHeader *)ALLOC(msg.messageBytes);
	MemCopy(netMsg, &msg, msg.messageBytes);
}


/*****************************************************************************
*
*	pfGameCliMsg
*
***/

//============================================================================
pfGameCliMsg::pfGameCliMsg () {

	gameCli	= nil;
	netMsg	= nil;
}

//============================================================================
pfGameCliMsg::~pfGameCliMsg () {

	FREE(netMsg);
}

//============================================================================
void pfGameCliMsg::Set (pfGameCli * cli, const GameMsgHeader & msg) {

	netMsg = (GameMsgHeader *)ALLOC(msg.messageBytes);
	MemCopy(netMsg, &msg, msg.messageBytes);
	gameCli		= cli;
}

/*****************************************************************************
*
*   pfGameMgr
*
***/

//============================================================================
pfGameMgr::pfGameMgr () {
}

//============================================================================
pfGameMgr * pfGameMgr::GetInstance () {

	static pfGameMgr s_instance;
	return &s_instance;
}

//============================================================================
void pfGameMgr::GetGameIds (ARRAY(unsigned) * arr) const {

	for (IGameCli * node = s_games.Head(); node; node = s_games.Next(node))
		arr->Add(node->GetValue());
}

//============================================================================
pfGameCli * pfGameMgr::GetGameCli (unsigned gameId) const {

	if (IGameCli * node = s_games.Find(gameId))
		return node->gameCli;
	return nil;
}

//============================================================================
const wchar * pfGameMgr::GetGameNameByTypeId (const Uuid & gameTypeId) const {

	if (Factory * factory = s_factories.Find(gameTypeId))
		return factory->reg.name;
	return nil;
}

//============================================================================
void pfGameMgr::RemoveReceiver (plKey receiver) {

	for (unsigned i = 0; i < s_receivers.Count(); ++i) {
		if (s_receivers[i] == receiver) {
			s_receivers.DeleteUnordered(i);
			break;
		}
	}
}

//============================================================================
void pfGameMgr::AddReceiver (plKey receiver) {

	RemoveReceiver(receiver);
	s_receivers.Add(receiver);
}

//============================================================================
void pfGameMgr::JoinGame (
	plKey			receiver,
	unsigned		gameId
) {
	Cli2Srv_GameMgr_JoinGame msg;
	ZERO(msg);
	
	msg.messageId		= kCli2Srv_GameMgr_JoinGame;
	msg.recvGameId		= 0;			// send to GameMgr on server
	msg.newGameId		= gameId;		// the GameSrv we wish to join

	// Don't send "common game" message fields	
	unsigned msgBytes
		= sizeof(msg)
		- sizeof(msg.gameTypeId)
		- sizeof(msg.createDataBytes)
		- sizeof(msg.createData);
		
	msg.messageBytes	= msgBytes;

	GameMgrSend(&msg, NEWZERO(JoinTransState)(receiver));
}

//============================================================================
void pfGameMgr::CreateGame (
	plKey			receiver,
	const Uuid &	gameTypeId,
	unsigned		createOptions,
	unsigned		initBytes,
	const void *	initData
) {
	Cli2Srv_GameMgr_CreateGame * msg;

	unsigned msgBytes
		= sizeof(*msg)
		- sizeof(msg->createData)
		+ initBytes;
		
	msg = (Cli2Srv_GameMgr_CreateGame *)_alloca(msgBytes);
		
	msg->messageId			= kCli2Srv_GameMgr_CreateGame;
	msg->recvGameId			= 0;			// send to GameMgr on server
	msg->gameTypeId			= gameTypeId;	// The type of game we wish to create
	msg->createOptions		= createOptions;
	msg->messageBytes		= msgBytes;
	msg->createDataBytes	= initBytes;
	MemCopy(msg->createData, initData, initBytes);

	GameMgrSend(msg, NEWZERO(JoinTransState)(receiver));
}

//============================================================================
void pfGameMgr::JoinCommonGame (
	plKey			receiver,
	const Uuid &	gameTypeId,
	unsigned		gameNumber,
	unsigned		initBytes,
	const void *	initData
) {
	Cli2Srv_GameMgr_JoinGame * msg;

	unsigned msgBytes
		= sizeof(*msg)
		- sizeof(msg->createData)
		+ initBytes;
		
	msg = (Cli2Srv_GameMgr_JoinGame *)_alloca(msgBytes);
		
	msg->messageId			= kCli2Srv_GameMgr_JoinGame;
	msg->recvGameId			= 0;			// send to GameMgr on server
	msg->gameTypeId			= gameTypeId;	// the type of common game we with to join
	msg->newGameId			= gameNumber;	// the "table number" of th common game we wish to join
	msg->createOptions		= kGameJoinCommon;
	msg->messageBytes		= msgBytes;
	msg->createDataBytes	= initBytes;
	MemCopy(msg->createData, initData, initBytes);

	GameMgrSend(msg, NEWZERO(JoinTransState)(receiver));
}


/*****************************************************************************
*
*   pfGameCli
*
***/

//============================================================================
pfGameCli::pfGameCli (
	unsigned	gameId,
	plKey		receiver
) {
	internal = NEWZERO(IGameCli)(this, gameId, receiver);
}

//============================================================================
pfGameCli::~pfGameCli () {

	DEL(internal);
}

//============================================================================
unsigned pfGameCli::GetGameId () const {

	return internal->GetValue();
}

//============================================================================
const Uuid & pfGameCli::GetGameTypeId () const {

	return internal->factory->GetValue();
}

//============================================================================
const wchar * pfGameCli::GetName () const {

	return internal->factory->reg.name;
}

//============================================================================
plKey pfGameCli::GetReceiver () const {

	return internal->receiver;
}

//============================================================================
unsigned pfGameCli::GetPlayerCount () const {

	return internal->playerCount;
}

//============================================================================
void pfGameCli::InvitePlayer (unsigned playerId) {

	Cli2Srv_Game_Invite msg;
	msg.messageId		= kCli2Srv_Game_Invite;
	msg.recvGameId		= GetGameId();	// send to GameSrv on server
	msg.playerId		= playerId;
	msg.messageBytes	= sizeof(msg);

	GameMgrSend(&msg);
}

//============================================================================
void pfGameCli::UninvitePlayer (unsigned playerId) {

	Cli2Srv_Game_Uninvite msg;
	msg.messageId		= kCli2Srv_Game_Uninvite;
	msg.recvGameId		= GetGameId();	// send to GameSrv on server
	msg.playerId		= playerId;
	msg.messageBytes	= sizeof(msg);

	GameMgrSend(&msg);
}

//============================================================================
void pfGameCli::LeaveGame () {
	
	Cli2Srv_Game_LeaveGame msg;
	msg.messageId		= kCli2Srv_Game_LeaveGame;
	msg.recvGameId		= GetGameId();	// send to GameSrv on server
	msg.messageBytes	= sizeof(msg);

	GameMgrSend(&msg);
}


/*****************************************************************************
*
*   IGameCli
*
***/

//============================================================================
IGameCli::IGameCli (
	pfGameCli *	gameCli,
	unsigned	gameId,
	plKey		receiver
) :	THashKeyVal<unsigned>(gameId)
,	gameCli(gameCli)
,	receiver(receiver)
{
	s_games.Add(this);
}

//============================================================================
void IGameCli::Recv (GameMsgHeader * msg, void * param) {

	#define DISPATCH(a)	case kSrv2Cli_Game_##a: {						\
		const Srv2Cli_Game_##a & m = *(const Srv2Cli_Game_##a *)msg;	\
		Recv##a(m, param);												\
	}																	\
	break;
	switch (msg->messageId) {
		DISPATCH(PlayerJoined);
		DISPATCH(PlayerLeft);
		DISPATCH(InviteFailed);
		DISPATCH(OwnerChange);
		default:
			gameCli->Recv(msg, param);
	}
	#undef DISPATCH
}

//============================================================================
void IGameCli::RecvPlayerJoined (const Srv2Cli_Game_PlayerJoined & msg, void * param) {
	++playerCount;
	gameCli->OnPlayerJoined(msg);
}

//============================================================================
void IGameCli::RecvPlayerLeft (const Srv2Cli_Game_PlayerLeft & msg, void * param) {
	--playerCount;
	gameCli->OnPlayerLeft(msg);
}

//============================================================================
void IGameCli::RecvInviteFailed (const Srv2Cli_Game_InviteFailed & msg, void * param) {
	gameCli->OnInviteFailed(msg);
}

//============================================================================
void IGameCli::RecvOwnerChange (const Srv2Cli_Game_OwnerChange & msg, void * param) {
	gameCli->OnOwnerChange(msg);
}


/*****************************************************************************
*
*   Factory
*
***/

//============================================================================
Factory::Factory (const GameTypeReg & reg)
:	reg(reg)
,	THashKeyVal<Uuid>(reg.typeId)
{
	s_factories.Add(this);
}


/*****************************************************************************
*
*   TransState
*
***/

//============================================================================
TransState::TransState (unsigned transId, void * param)
:	THashKeyVal<unsigned>(transId)
,	param(param)
{
	s_trans.Add(this);
}


/*****************************************************************************
*
*   Module functions
*
***/

//============================================================================
void GameMgrRegisterGameType (const GameTypeReg & reg) {

	(void)NEWZERO(Factory)(reg);
}

//============================================================================
void GameMgrSend (GameMsgHeader * msg, void * param) {

	if (param) {
		msg->transId = INextTransId();
		(void)NEW(TransState)(msg->transId, param);
	}
	else {
		msg->transId = 0;
	}

	NetCliGameSendGameMgrMsg(msg);
}