CWE-ou-minkata/Sources/Plasma/PubUtilLib/plNetTransport/plNetTransport.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==*/
#pragma warning(disable: 4786)  

#include "hsTimer.h"
#include "plNetTransport.h"
#include "plNetTransportMember.h"
#include "plNetMessage/plNetMessage.h"
#include "plNetClient/plNetClientMgr.h"
#include <algorithm>

plNetTransport::~plNetTransport()
{
	ClearMembers();
}

//
// add a member to the master list if not already there
//
int plNetTransport::AddMember(plNetTransportMember* mbr)
{
	if (FindMember(mbr)==-1)
	{
		fMembers.push_back(mbr);
		hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Adding member %s", mbr->AsStdString().c_str()) );
		plNetClientMgr::GetInstance()->GetListenList()->AddMember(mbr);
		plNetClientMgr::GetInstance()->GetTalkList()->AddMember(mbr);
		DumpState();
		return fMembers.size()-1;
	}
	return -1;
}

void plNetTransport::IUnSubscribeToAllChannelGrps(plNetTransportMember* mbr)
{
	int i;
	for( i=mbr->GetNumSubscriptions()-1; i>=0 ; i-- )
	{
		int chan=mbr->GetSubscription(i);
		hsBool ok=UnSubscribeToChannelGrp(mbr, chan);
		hsAssert(ok, "can't find supposed subscription to remove");
	} // for	         
}

void plNetTransport::IRemoveMember(plNetTransportMember* mbr)
{
	if (!mbr)
		return;

	hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Removing member %s", mbr->AsStdString().c_str()) );

//	plNetClientMgr::GetInstance()->GetNetCore()->RemovePeer(mbr->GetPeerID());
	plNetClientMgr::GetInstance()->GetTalkList()->RemoveMember(mbr);
	plNetClientMgr::GetInstance()->GetListenList()->RemoveMember(mbr);

	// remove member from subscription lists
	IUnSubscribeToAllChannelGrps(mbr);

	plMembersList::iterator it=std::find(fMembers.begin(),fMembers.end(),mbr);

	// remove member from master list
	fMembers.erase(it);

	hsLogEntry( plNetClientMgr::GetInstance()->DebugMsg("Done Removing member %s", mbr->AsStdString().c_str()) );
	DumpState();
	
	delete mbr;
}

//
// remove member from master list, and all subscription channels.
// return true on success.
//
hsBool plNetTransport::RemoveMember(int idx)
{
	if (idx>=0)
	{
		plNetTransportMember* mbr=GetMember(idx);
		IRemoveMember(mbr);
		return true;
	}
	return false;
}

//
// remove member from master list, and all subscription channels.
// return true on success.
//
hsBool plNetTransport::RemoveMember(plNetTransportMember* mbr)
{
	IRemoveMember(mbr);
	return true;
}

//
// return array index or -1
//
int plNetTransport::FindMember(const plNetTransportMember* mbr) 
{
	plMembersList::iterator it = std::find(fMembers.begin(), fMembers.end(), mbr);
	return (it==fMembers.end()) ? -1 : (it-fMembers.begin());
}


//
// add this member to the given channel grp
//
void plNetTransport::SubscribeToChannelGrp(plNetTransportMember* mbr, int channel)
{
//	hsAssert(FindMember(mbr) != -1, "must add member before subscribing to channel");
	if (mbr->AddSubscription(channel))
	{
		hsAssert(channel<fChannelGroups.size(), "invalid channel index");
		fChannelGroups[channel].push_back(mbr);
	}
}

//
// Remove the subscription to the given channel grp for a member.
//
hsBool plNetTransport::UnSubscribeToChannelGrp(plNetTransportMember* mbr, int chan)
{
	hsAssert(chan>=0 && chan<fChannelGroups.size(), "invalid channel idx");
	plMembersList* mList = &fChannelGroups[chan];
	plMembersList::iterator it=std::find(mList->begin(), mList->end(), mbr);
	if (it != mList->end())
	{
		mList->erase(it);
		hsBool ret=mbr->RemoveSubscription(chan);
		hsAssert(ret, "error removing subscription");
		return true;
	}
	return false;
}

//
// copy list of members channelGrp subscriptions
//
void plNetTransport::GetSubscriptions(plNetTransportMember* mbr, std::vector<int>* channels) const
{
	mbr->CopySubscriptions(channels);
}


//
// Send Msg to all members in the given channelGrp.
// Here's where multicasting would be used.
// Returns neg number (NetCore::RetCode) on send error, 1, if not sent, and 0 if sent
//
int plNetTransport::SendMsg(int chan, plNetMessage* netMsg) const
{
	NetCommSendMsg(netMsg);
	return hsOK;
	
	plNetClientMgr* nc=plNetClientMgr::GetInstance();
	int ret=1; // didn't send

	if (chan < fChannelGroups.size())
	{
		const plMembersList* mList = &fChannelGroups[chan];
				
		// does this msg have a list of receivers
		plNetMsgReceiversListHelper* rl = plNetMsgReceiversListHelper::ConvertNoRef(netMsg);

#if 0				
		// send msg to all subscribers to this channel
		int size=mList->size();
		for( int i=0 ; i<size; i++  )
		{
            hsAssert(false, "eric, port me");

			plNetTransportMember* tm=(*mList)[i];
			hsAssert(tm, "nil mbr in sendMsg");
//			int peerID=tm->GetPeerID();
//			hsAssert(peerID>=0, "queing message to invalid peer");

//			if ((ncRet=nc->GetNetClientComm().SendMsg(netMsg, peerID, sendFlags, msgSize)) != plNetCore::kNetOK)

            NetCommSendMsg(netMsg);
			if (rl)
			{
				hsBool ok=rl->RemoveReceiverPlayerID(tm->GetPlayerID());
				hsAssert(ok, "couldn't find rcvr to remove?");
			}
			ret=0; // sent ok	
		} // for      
#endif

		// if there are rcvrs left that we couldn't send to, send via server
		if (rl && rl->GetNumReceivers())
		{			
//			if ((ncRet=nc->GetNetClientComm().SendMsg(netMsg, nc->GetServerPeerID(), sendFlags, msgSize)) != plNetCore::kNetOK)
            NetCommSendMsg(netMsg);
            ret=0;	// sent
		}
	}
	else
	{
		hsStatusMessage("EMPTY TRANSPORT GROUP\n");
	}
	return ret;
}


void plNetTransport::ClearMembers()
{
	int i;
	for( i=0 ;i<GetNumMembers() ;i++  )
	{
		plNetTransportMember* mbr = GetMember(i);
		hsAssert(mbr, "nil member?");
		IUnSubscribeToAllChannelGrps(mbr);
		delete mbr;
	} // for	     
	
	fMembers.clear();
}


//
// return array index or -1
//
int plNetTransport::FindMember(UInt32 playerID) const
{
	int i;
	for( i=0 ;i<GetNumMembers() ;i++  )
	{
		plNetTransportMember* mbr = GetMember(i);
		if (mbr->GetPlayerID()==playerID)
			return i;
	}
	return -1;
}

//
// return array index or -1
//
int plNetTransport::FindMember(const plKey avKey) const
{
	int i;
	for( i=0 ;i<GetNumMembers() ;i++  )
	{
		plNetTransportMember* mbr = GetMember(i);
		if (mbr->GetAvatarKey()==avKey)
			return i;
	}
	return -1;
}

//
// clear channel and unsubscribe all members to that channel
//
void plNetTransport::ClearChannelGrp(int channel)
{
	const plMembersList* mList = &fChannelGroups[channel];
	int i, size=mList->size();
	for( i=0 ; i<size; i++  )
	{
		plNetTransportMember* tm=(*mList)[i];
		hsBool ok=tm->RemoveSubscription(channel);
		hsAssert(ok, "error removing subscription");
	}

	fChannelGroups[channel].clear();
}

void plNetTransport::DumpState()
{
	plNetClientMgr* nc=plNetClientMgr::GetInstance();
	
	hsLogEntry( nc->DebugMsg("-------------------\n") );
	hsLogEntry( nc->DebugMsg("Num Channels=%d\n", fChannelGroups.size()) );

	int i;
	for(i=0;i<fChannelGroups.size();i++)
	{
		plMembersList* mList = &fChannelGroups[i];
		hsLogEntry( nc->DebugMsg("\tChannel %d, num mbrs=%d\n", i, mList->size()) );
		int j;
		for(j=0; j<mList->size();j++)
		{
			plNetTransportMember * mbr = (*mList)[j];
			hsLogEntry( nc->DebugMsg("\t\tMbr %s\n",(*mList)[j]->AsStdString().c_str()) );
		}
	}

	nc->DebugMsg("Num Mbrs=%d\n", GetNumMembers());
	for(i=0;i<GetNumMembers();i++)
	{
		plNetTransportMember * mbr = GetMember(i);
		hsLogEntry (nc->DebugMsg("\tMbr %d, name=%s, plyrID=%lu, subs=%d", 
			i,mbr->AsStdString().c_str(),mbr->GetPlayerID(),mbr->GetNumSubscriptions()) );
		int j;
		for(j=0;j<mbr->GetNumSubscriptions();j++)
		{
			hsLogEntry( nc->DebugMsg("\t\tSub %d, chan=%d\n", j, mbr->GetSubscription(j)) );
		}
	}
	hsLogEntry( nc->DebugMsg("\n") );
}

void plNetTransport::SetNumChannels(int n)
{
	if (n>fChannelGroups.size())
		fChannelGroups.resize(n);
}


int compare( const void* arg1, const void *arg2 )
{
	plNetTransportMember** m1 = (plNetTransportMember**)arg1;
	plNetTransportMember** m2 = (plNetTransportMember**)arg2;
	float d1=m1 ? (*m1)->GetDistSq() : hsScalarMax;
	float d2=m2 ? (*m2)->GetDistSq() : hsScalarMax;
	return (int)(d1-d2);
}

//
// create a members list sorted by dist.
// caller must delete this when done
//
void plNetTransport::GetMemberListDistSorted(plNetTransportMember**& listIn) const
{
	// copy members list
	listIn = TRACKED_NEW plNetTransportMember* [fMembers.size()];
	int i;
	for (i=0; i<fMembers.size(); i++)
			listIn[i]=fMembers[i];

	// sort members list
	qsort(listIn, fMembers.size(), sizeof(plNetTransportMember*), compare);
}