CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plNetMessage/plNetMessage.h

/*==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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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==*/
#ifndef plNetMessage_h_inc
#define plNetMessage_h_inc

#include "hsUtils.h"
#include "hsTypes.h"
#include "hsStlUtils.h"
#include "hsStream.h"
#include "hsBitVector.h"
#include "hsTemplates.h"
#include "plGeneric.h"
#include "../pnNetCommon/plNetServers.h"
#include "../pnNetCommon/plNetGroup.h"
#include "../pnFactory/plCreatable.h"
#include "../pnFactory/plFactory.h"
#include "../plUnifiedTime/plClientUnifiedTime.h"
#include "../plNetCommon/plNetServerSessionInfo.h"
#include "../plNetCommon/plNetCommon.h"
#include "../plNetCommon/plNetCommonHelpers.h"
#include "../plNetCommon/plNetCommonConstants.h"

#include "../plStreamLogger/plStreamLogger.h"

#include "plNetMsgHelpers.h"

#include "../pnNetBase/pnNetBase.h"

#include <sstream>

class plMessage;
class plUUID;


////////////////////////////////////////////////////////////////////

//
// Base class for application network messages.
// These become the data in a plNetCommonMessage when sent over the network.
//
class plNetCommonMessage;
class plKey;

class plNetMessage : public plCreatable
{	
	friend class plNetServerMsgPlsRoutableMsg;

	UInt32 fFlags;		// indicates what is present in the message, always transmitted 
	plUnifiedTime fTimeSent;	// time msg was sent (in sender's unified timeSpace), always transmitted to and from the client
	double fTimeRecvd;		// time msg was recvd (in rcvrs timeSpace), never transmitted 
	UInt32 fBytesRead;		// amount of data we've already read, never transmitted 
	UInt32 fContext;		// set by sender, included in reply. Only written if kHasContext flag set
	UInt32 fTransactionID;	// set by originator, included in reply. Only written if kHasTransactionID flag set
	UInt32 fPlayerID;		// set by originator. Only written if kHasPlayerID flag set
	plUUID fAcctUUID;		// set by sender (app level). Only written if kHasAcctUUID flag set
	const plNetCommonMessage* fNetCoreMsg;	// not sent, set by the receiver
	UInt32 fPeekStatus;		// not sent. set on PeekBuffer, cleared on PokeBuffer
	UInt8	fProtocolVerMajor;	// conditionally sent
	UInt8	fProtocolVerMinor;	// conditionally sent
    ENetProtocol fNetProtocol;  // the server this msg should be sent to. this value is not sent over wire.

	enum ContentFlags
	{
		kNetMsgFlags,
		kNetMsgTimeSent,
		kNetMsgContext,
		kNetMsgTransactionID,
		kNetMsgPlayerID,
		kNetMsgVersion,
	};

protected:	
	virtual int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	virtual int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);

	void IWriteClassIndex(hsStream* stream);
	void IReadClassIndex(hsStream* stream);

	bool IPeeked() const { return fPeekStatus==kFullyPeeked;}
	void ISetPeekStatus(UInt32 s) { fPeekStatus=s;	}

public:
	typedef UInt16 plStrLen;
	static const UInt8 kVerMajor, kVerMinor;	// version of the networking code

	typedef UInt16 ClassIndexType;		// the type returned by plCreatable::ClassIndex()
	enum
	{
		kMaxNameLen=32
	};
	enum BitVectorFlags		// indicates what is present in the message, always transmitted
	{
		kHasTimeSent		= 0x1,		// means fTimeSent need sending
		kHasGameMsgRcvrs	= 0x2,		// means that this is a direct (not bcast) game msg
		kEchoBackToSender	= 0x4,		// if broadcasting, echo packet back to sender
		kRequestP2P			= 0x8,		// sent to gameServer on joinReq
		kAllowTimeOut		= 0x10,		// sent to gameServer on joinReq (if release code)
		kIndirectMember		= 0x20,		// sent to client on joinAck if he is behind a firewall
		// This flag is used when the servers are firewalled and NAT'ed
		// It tells a game or lobby server to ask the lookup for an external address
		kPublicIPClient		= 0x40,		// set on a client coming from a public IP
		kHasContext			= 0x80,		// whether or not to write fContext field
		// Used with StartProcess server msgs. Whether or not the ServerAgent
		// must first ask the vault for a game state associated with the
		// game about to be instanced.
		kAskVaultForGameState	=0x100,
		kHasTransactionID	= 0x200,	// whether or not to write fTransactionID field
		kNewSDLState		= 0x400,	// set by client on first state packet sent, may not be necessary anymore
		kInitialAgeStateRequest = 0x800,// initial request for the age state
		kHasPlayerID		= 0x1000,	// is fPlayerID set
		kUseRelevanceRegions= 0x2000,	// if players use relevance regions are used, this will be filtered by region, currently set on avatar physics and control msgs
		kHasAcctUUID		= 0x4000,	// is fAcctUUID set
		kInterAgeRouting	= 0x8000,	// give to pls for routing.
		kHasVersion			= 0x10000,	// if version is set
		kIsSystemMessage	= 0x20000,
		kNeedsReliableSend	= 0x40000,
		kRouteToAllPlayers	= 0x80000,	// send this message to all online players.
	};
	enum PeekOptions		// options for partial peeking
	{
		kSkipStream			= 1<<0,	// means we should not read the actual stream, just the stream info
		kBaseClassOnly		= 1<<1,	// only peek or poke the baseclass info
		kPartialPeekMask	= kSkipStream | kBaseClassOnly,
		// plNetServerMsgWithRoutingInfo derived classes need to check this
		// in their PeekBuffer methods.
		kJustRoutingInfo	= 1<<2,
		kDontClearBuffer	= 1<<3,
		// don't call base class peek/poke. plNetMsgOmnibus/plNetMsgVault uses this.
		kDEAD_NoBaseClass	= 1<<4,
		// don't worry about compressing/uncompressing things. used by plNetMsgStreamHelper, and plNetMsgOmnibus.
		kDontCompress		= 1<<5,
		kWantVersion		= 1<<6,
		kFullyPeeked		= 0xffffffff	// default fPeekStatus, set if not partial peeking
	};
	enum CompressionType	// currently only used for plNetMsgStreams
	{
		kCompressionNone,		// not compressed
		kCompressionFailed,		// failed to compress
		kCompressionZlib,		// zlib compressed
		kCompressionDont		// don't compress
	};

	CLASSNAME_REGISTER( plNetMessage );
	GETINTERFACE_ANY( plNetMessage, plCreatable );

	// plCreatable
	void Read(hsStream* s, hsResMgr* mgr);
	void Write(hsStream* s, hsResMgr* mgr);

	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

	// ctor
	plNetMessage();
	virtual ~plNetMessage();

	static plNetMessage* CreateAndRead(const plNetCommonMessage*, plStreamLogger::EventList* el = nil);
	static plNetMessage* Create(const plNetCommonMessage*);
	int PokeBuffer(char* buf, int bufLen, UInt32 peekOptions=0);			// put msg in buffer
	int PeekBuffer(const char* buf, int bufLen, UInt32 peekOptions=0, bool forcePeek=false, plStreamLogger::EventList* el = nil);	// get msg out of buffer
	bool NeedsReliableSend() const { return IsBitSet(kNeedsReliableSend); }
	bool IsSystemMessage() const { return IsBitSet(kIsSystemMessage); 	}
	virtual void ValidatePoke() const;
	virtual void ValidatePeek() const;
	virtual bool NeedsBroadcast() const { return false; }			// should game server broadcast this message to other clients?
	virtual int ValidationSchemeID() const { return 1; }

	// getters
	int GetPackSize();
	const plUnifiedTime& GetTimeSent() const { return fTimeSent; }
	bool GetHasTimeSent() const { return IsBitSet(kHasTimeSent); }
	double GetTimeReceived() const { return fTimeRecvd; }
	bool IsBitSet(int b) const { return (fFlags & b) != 0; }
	const plNetCommonMessage* GetNetCoreMsg() const { return fNetCoreMsg; }
	UInt32 GetNetCoreMsgLen() const;
	bool GetHasContext() const { return IsBitSet(kHasContext);}
	UInt32 GetContext() const { return fContext;}
	bool GetHasTransactionID() const { return IsBitSet(kHasTransactionID);}
	UInt32 GetTransactionID() const { return fTransactionID;}
	bool GetHasPlayerID() const { return IsBitSet(kHasPlayerID);}
	UInt32 GetPlayerID() const { hsAssert(GetHasPlayerID(), "uninit playerID"); return fPlayerID; }
	UInt32 JustGetPlayerID() const { return fPlayerID; }
	bool GetHasAcctUUID() const { return IsBitSet(kHasAcctUUID); }
	const plUUID * GetAcctUUID() const { return &fAcctUUID; }
	UInt8 GetVersionMajor() const { return fProtocolVerMajor;	}
	UInt8 GetVersionMinor() const { return fProtocolVerMinor;	}
    ENetProtocol GetNetProtocol () const { return fNetProtocol; }

	// setters
	void SetTimeSent(const plUnifiedTime& t) { fTimeSent=t;SetHasTimeSent(true); }
	void SetHasTimeSent(bool value) { SetBit( kHasTimeSent, value ); }
	void SetTimeReceived(double t) { fTimeRecvd=t; }
	void SetBit(int b, bool on=true) { if (on) fFlags |= b; else fFlags &= ~b; }
	void SetNetCoreMsg(const plNetCommonMessage* ncmsg) { fNetCoreMsg=ncmsg; }
	void SetHasContext(bool value) { SetBit(kHasContext,value);}
	void SetContext(UInt32 value) { fContext=value; SetHasContext(true);}
	void SetHasTransactionID(bool value) { SetBit(kHasTransactionID,value);}
	void SetTransactionID(UInt32 value) { fTransactionID=value; SetHasTransactionID(true);}
	void SetHasPlayerID(bool value) { SetBit(kHasPlayerID,value);}
	void SetPlayerID(UInt32 value) { fPlayerID=value; SetHasPlayerID(true);}
	void SetHasAcctUUID( bool v ) { SetBit( kHasAcctUUID,v ); }
	void SetAcctUUID(const plUUID * v ) { fAcctUUID.CopyFrom(v); SetHasAcctUUID(true); }
	void SetVersion(UInt8 maj=kVerMajor, UInt8 min=kVerMinor) { SetBit(kHasVersion); fProtocolVerMajor=maj; fProtocolVerMinor=min;	}
    void SetNetProtocol (ENetProtocol v ) { fNetProtocol = v; }

	// init fContext, fTransactionID, etc. if needed.
	void InitReplyFieldsFrom(plNetMessage * msg);

	// debug
	virtual std::string AsStdString() const
	{
		char * delim = "";

		std::stringstream ss;
		if ( GetHasPlayerID() )
		{
			ss << delim << "p:" << GetPlayerID();
			delim = ",";
		}
		if ( GetHasTransactionID() )
		{
			ss << delim << "x:" << GetTransactionID();
			delim = ",";
		}
		if ( GetHasAcctUUID() )
		{
			ss << delim << "a:" << GetAcctUUID()->AsStdString();
			delim = ",";
		}
		if ( IsBitSet(kHasVersion) )
		{
			ss << delim << "v:" << (int)fProtocolVerMajor << "." << (int)fProtocolVerMinor;
			delim = ",";
		}

		return ss.str().c_str();
	}
};

// 
// for msgs which only go from the gameserver to the client
//
class plNetMsgServerToClient : public plNetMessage
{
public:
	plNetMsgServerToClient() { SetBit(kIsSystemMessage|kNeedsReliableSend);	}

	CLASSNAME_REGISTER( plNetMsgServerToClient );
	GETINTERFACE_ANY( plNetMsgServerToClient, plNetMessage );
};

////////////////////////////////////////////////////////////////////
// Stream msg - abstract base class built with plNetMsgStreamHelper
//
class plNetMsgStream : public plNetMessage
{
protected:
	plNetMsgStreamHelper fStreamHelper;

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	CLASSNAME_REGISTER( plNetMsgStream );
	GETINTERFACE_ANY_AUX(plNetMsgStream,plNetMessage,plNetMsgStreamHelper,fStreamHelper)

	plNetMsgStreamHelper* StreamInfo() { return &fStreamHelper; }
	const plNetMsgStreamHelper* StreamInfo() const { return &fStreamHelper; }
};

//
// Object info msg - abstract base class built with plNetMsgObjectHelper
//
class plNetMsgObject : public plNetMessage
{
private:
	enum ContentFlags
	{
		kNetMsgObjectHelper,
	};
protected:
	plNetMsgObjectHelper fObjectHelper;
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	CLASSNAME_REGISTER( plNetMsgObject );
	GETINTERFACE_ANY_AUX(plNetMsgObject,plNetMessage,plNetMsgObjectHelper,fObjectHelper)

	plNetMsgObjectHelper* ObjectInfo() { return &fObjectHelper; }
	const plNetMsgObjectHelper* ObjectInfo() const { return &fObjectHelper; }

	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

	// debug
	std::string AsStdString() const
	{
		std::string s;
		char tmp[256];
		xtl::format(s,"object=%s, %s",fObjectHelper.GetUoid().StringIze(tmp), plNetMessage::AsStdString().c_str());
		return s;
	}

};

//
// abstract baseclass which has both object and stream info
//
class plNetMsgStreamedObject : public plNetMsgObject
{
private:
	enum ContentFlags
	{
		kStreamHelper
	};
protected:
	plNetMsgStreamHelper fStreamHelper;

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgStreamedObject() {}
	~plNetMsgStreamedObject() {}

	CLASSNAME_REGISTER( plNetMsgStreamedObject );
	GETINTERFACE_ANY_AUX(plNetMsgStreamedObject,plNetMsgObject,plNetMsgStreamHelper,fStreamHelper)

	plNetMsgStreamHelper* StreamInfo() { return &fStreamHelper; }
	const plNetMsgStreamHelper* StreamInfo() const { return &fStreamHelper; }

	//virtuals
	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

};

//
// New SaveState system
//
class plNetMsgSDLState : public plNetMsgStreamedObject
{
private:
	enum ContentFlags
	{
		kSDLStateStream,
		kSDLIsInitialState,
		kSDLPersist,
		kSDLAvatarState,
	};

	void ISetDescName() const;
	bool	fIsInitialState;

protected:
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);

	bool fPersistOnServer;
	bool fIsAvatarState;
	mutable std::string fDescName;		// for debugging output only, not read/written
public:
	CLASSNAME_REGISTER( plNetMsgSDLState );
	GETINTERFACE_ANY(plNetMsgSDLState, plNetMsgStreamedObject);

	plNetMsgSDLState() : fIsInitialState(0), fPersistOnServer(true), fIsAvatarState(false) { SetBit(kNeedsReliableSend); }

	bool PersistOnServer() const { return fPersistOnServer != 0; }
	void SetPersistOnServer(bool b) { fPersistOnServer = b; }

	bool IsAvatarState() const { return fIsAvatarState != 0; }
	void SetIsAvatarState(bool b) { fIsAvatarState = b; }
	
	// debug
	std::string AsStdString() const;
	bool IsInitialState() const {return fIsInitialState!=0; }
	void SetIsInitialState( bool v ) { fIsInitialState=v; }

	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);
};

//
// New SaveState system
//
class plNetMsgSDLStateBCast : public plNetMsgSDLState
{
protected:	
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:	
	CLASSNAME_REGISTER( plNetMsgSDLStateBCast );
	GETINTERFACE_ANY(plNetMsgSDLStateBCast, plNetMsgSDLState);

	// virtuals 
	bool NeedsBroadcast() const { return true; }

	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);
};

//
//  Object state request msg
//
class plNetMsgObjStateRequest : public plNetMsgObject
{
public:
	plNetMsgObjStateRequest() { SetBit(kIsSystemMessage|kNeedsReliableSend); 	}

	CLASSNAME_REGISTER( plNetMsgObjStateRequest );
	GETINTERFACE_ANY( plNetMsgObjStateRequest, plNetMsgObject );
};


//
// abstract message class which contains a list of rooms
//
class plNetMsgRoomsList : public plNetMessage
{
protected:
	std::vector<plLocation> fRooms;	
	std::vector<char*> fRoomNames;		// for debug usage only

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgRoomsList() {}
	~plNetMsgRoomsList();

	CLASSNAME_REGISTER( plNetMsgRoomsList );
	GETINTERFACE_ANY( plNetMsgRoomsList, plNetMessage );

	void AddRoom(plKey rmKey);
	void AddRoomLocation(plLocation loc, const char* rmName);
	int FindRoomLocation(plLocation loc);

	int GetNumRooms() const { return fRooms.size(); }
	plLocation GetRoomLoc(int i) const { return fRooms[i]; }
	const char* GetRoomName(int i) const { return fRoomNames[i]; }		// debug
};

//
// Game msg - wraps a plMessage.
//
class hsResMgr;

class plNetMsgGameMessage: public plNetMsgStream
{
protected:
	plClientUnifiedTime fDeliveryTime;	// for future timestamping

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgGameMessage() { SetBit(kNeedsReliableSend); 	}

	CLASSNAME_REGISTER( plNetMsgGameMessage );
	GETINTERFACE_ANY( plNetMsgGameMessage, plNetMsgStream );
	enum ContentsFlags
	{
		kNetGameMsgDeliveryTime,
		kNetGameMsgGameMsg,
	};
	plClientUnifiedTime& GetDeliveryTime() { return fDeliveryTime; }
	void SetDeliveryTime(plClientUnifiedTime& ut) { fDeliveryTime=ut; }

	plMessage* GetContainedMsg(hsResMgr* resmgr = nil);

	// virtuals
	bool NeedsBroadcast() const { return true; }
	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

	// debug
	std::string AsStdString() const
	{
		std::string s;
		const char* noc=plFactory::GetTheFactory()->GetNameOfClass(StreamInfo()->GetStreamType());
		xtl::format(s,"%s %s",plNetMsgStream::AsStdString().c_str(), noc ? noc : "?");
		return s;
	}
};

//
// special game msg for loading clones/avatars
//
class plNetMsgLoadClone : public plNetMsgGameMessage
{
private:
	enum ContentFlags
	{
		kObjectHelper,
		kIsPlayer,
		kIsLoading,
		kIsInitialState,
	};
protected:
	bool fIsPlayer;
	bool fIsLoading;
	bool fIsInitialState;
	plNetMsgObjectHelper fObjectHelper;

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);	
public:

	CLASSNAME_REGISTER( plNetMsgLoadClone );
	GETINTERFACE_ANY_AUX(plNetMsgLoadClone, plNetMsgGameMessage,plNetMsgObjectHelper,fObjectHelper)

	plNetMsgLoadClone() : fIsPlayer(true),fIsLoading(true),fIsInitialState(false) {}

	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

	plNetMsgObjectHelper* ObjectInfo() { return &fObjectHelper; }
	const plNetMsgObjectHelper* ObjectInfo() const { return &fObjectHelper; }

	bool GetIsPlayer() const	{ return fIsPlayer!=0;	}
	bool GetIsLoading() const	{ return fIsLoading!=0;	}
	bool GetIsInitialState() const { return fIsInitialState!=0; }

	void SetIsPlayer(bool p)	{ fIsPlayer=p;	}
	void SetIsLoading(bool p)	{ fIsLoading=p;	}
	void SetIsInitialState(bool p) {fIsInitialState=p; }


	// debug
	std::string AsStdString() const
	{
		std::string s;
		char tmp[256];
		xtl::format(s,"object=%s initial=%d, %s",fObjectHelper.GetUoid().StringIze(tmp), fIsInitialState,
			plNetMsgGameMessage::AsStdString().c_str());
		return s;
	}
};

//
// special msg when a player is paged in/out
//
class plNetMsgPlayerPage : public plNetMessage
{
protected:
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);	
public:
	plUoid	fUoid;
	bool fUnload;

	plNetMsgPlayerPage() : fUnload(false) { SetBit(kNeedsReliableSend); }
	plNetMsgPlayerPage(plUoid uoid, hsBool unload) : fUoid(uoid),	fUnload(unload) { }

	CLASSNAME_REGISTER( plNetMsgPlayerPage );
	GETINTERFACE_ANY( plNetMsgPlayerPage, plNetMessage);
};

//
// a game message that takes a list of other clients as receivers
//
class plNetMsgGameMessageDirected : public plNetMsgGameMessage
{
private:
	enum ContentFlags
	{
		kRecievers,
	};
protected:
	plNetMsgReceiversListHelper fReceivers;

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);	
public:
	CLASSNAME_REGISTER( plNetMsgGameMessageDirected );
	GETINTERFACE_ANY_AUX(plNetMsgGameMessageDirected,plNetMsgGameMessage,
		plNetMsgReceiversListHelper,fReceivers)

	plNetMsgReceiversListHelper* Receivers() { return &fReceivers; }	

	// virtuals
	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);
};

//
// Message when a room is paged in/out
//
class plNetMsgPagingRoom : public plNetMsgRoomsList
{
public:
	enum PageFlags
	{
		kPagingOut=0x1,		// else paging in
		kResetList=0x2,		// server should reset his existing list before using this msg
		kRequestState=0x4,	// also want current room state sent to me
		kFinalRoomInAge=0x8	// done paging in the age
	};
protected:
	UInt8 fPageFlags;

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgPagingRoom() : fPageFlags(0) { SetBit(kIsSystemMessage|kNeedsReliableSend); }
	~plNetMsgPagingRoom() {}

	CLASSNAME_REGISTER( plNetMsgPagingRoom );
	GETINTERFACE_ANY( plNetMsgPagingRoom, plNetMsgRoomsList );

	void SetPageFlags(UInt8 f) { fPageFlags=f; }
	UInt8 GetPageFlags() const { return fPageFlags; }
	
	void SetPagingOut(hsBool b) { if (b) fPageFlags |= kPagingOut; else fPageFlags&=~kPagingOut; }
	hsBool GetPagingOut() const { return (fPageFlags & kPagingOut) != 0; }

	void SetResetList(hsBool b) { if (b) fPageFlags |= kResetList; else fPageFlags &=~kResetList; }
	hsBool GetResetList() const { return (fPageFlags & kResetList) != 0; }

	void SetRequestingState(hsBool b) { if (b) fPageFlags |= kRequestState; else fPageFlags &=~kRequestState; }
	hsBool GetRequestingState() const { return (fPageFlags & kRequestState) != 0; }	

	// debug
	std::string AsStdString() const
	{
		std::string s;
		xtl::format(s,"pageFlags:%02X, paging %s, requestingState:%s, resetting=%d",fPageFlags,
			(fPageFlags&kPagingOut)?"out":"in", (fPageFlags&kRequestState)?"yes":"no",
			(fPageFlags & kResetList)!=0);
		return s;
	}
};

//
// Client requests game state update by rooms.
// an empty rooms list means ALL rooms I have loaded.
//
class plNetMsgGameStateRequest : public plNetMsgRoomsList
{
public:
	plNetMsgGameStateRequest() { SetBit(kIsSystemMessage|kNeedsReliableSend); }

	CLASSNAME_REGISTER( plNetMsgGameStateRequest );
	GETINTERFACE_ANY( plNetMsgGameStateRequest, plNetMsgRoomsList );	
};

//
// sent by game server to change clients ownership of a netGroup
//
class plNetMsgGroupOwner: public plNetMsgServerToClient
{
public:
	class GroupInfo
	{
	public:
		plNetGroupId fGroupID;
		bool fOwnIt;	// else not the owner

		void Read(hsStream* s) { fGroupID.Read(s); s->LogReadSwap(&fOwnIt,"GroupOwner OwnIt"); }
		void Write(hsStream* s) { fGroupID.Write(s); s->WriteSwap(fOwnIt); }

      GroupInfo() : fGroupID(plNetGroup::kNetGroupUnknown), fOwnIt(false) {}
		GroupInfo(plNetGroupId gID, hsBool o) : fGroupID(gID),fOwnIt(o) {}
	};
protected:
	std::vector<GroupInfo> fGroups;	

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	CLASSNAME_REGISTER( plNetMsgGroupOwner );
	GETINTERFACE_ANY( plNetMsgGroupOwner, plNetMsgServerToClient );

	// getters
	int GetNumGroups() const { return fGroups.size(); }
	GroupInfo GetGroupInfo(int i) const { return fGroups[i]; }

	// setters
	void AddGroupInfo(GroupInfo gi) { fGroups.push_back(gi); }
	void ClearGroupInfo() { fGroups.clear(); }

	bool IsOwner() { return fGroups[0].fOwnIt; }
};

//
// voice recording buffer
//
class plNetMsgVoice: public plNetMessage
{
private:
	enum ContentFlags
	{
		kDead_FrameSize,
		kReceivers,
		kVoiceFlags,
		kVoiceData
	};
protected:
	UInt8 fFlags;		// voice flags
	UInt8 fNumFrames; // number of frames encoded
	std::string fVoiceData;

	plNetMsgReceiversListHelper fReceivers;
 
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgVoice(): fFlags(0), fNumFrames(0) {  }
	~plNetMsgVoice() {}

	CLASSNAME_REGISTER( plNetMsgVoice );
	GETINTERFACE_ANY_AUX(plNetMsgVoice,plNetMessage,plNetMsgReceiversListHelper,fReceivers)
		
	void SetFlag(int f) { fFlags |= f; }
	int GetFlags() { return fFlags;  }
	
	void SetNumFrames(UInt8 f) { fNumFrames = f; }
	UInt8 GetNumFrames() const { return fNumFrames; }
	
	void SetVoiceData(char *data, int len );
	int GetVoiceDataLen() const { return fVoiceData.length(); }
	const char *GetVoiceData() const;
	
	plNetMsgReceiversListHelper* Receivers() { return &fReceivers; }

	// virtuals
	bool NeedsBroadcast() const { return true; }

	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

	// debug
	std::string AsStdString() const
	{
		std::string s;
		xtl::format(s,"len=%d",fVoiceData.size());
		return s;
	}
};

//
// base class for dealing with plNetSharedState
//
class plNetSharedState;
class plNetMsgSharedState : public plNetMsgStreamedObject
{
private:
	enum ContentFlags
	{
		kLockRequest,
	};
protected:
	bool fLockRequest;

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgSharedState() : fLockRequest(false) {}
	~plNetMsgSharedState() {}

	CLASSNAME_REGISTER( plNetMsgSharedState );
	GETINTERFACE_ANY(plNetMsgSharedState, plNetMsgStreamedObject);

	void CopySharedState(plNetSharedState* ss);

	void SetLockRequest(hsBool b) { fLockRequest=b; }
	hsBool GetLockRequest() const { return fLockRequest; }	

	void ReadVersion(hsStream* s, hsResMgr* mgr);
	void WriteVersion(hsStream* s, hsResMgr* mgr);

	// debug
	std::string AsStdString() const
	{
		std::string s;
		xtl::format(s,"lockReq=%d, %s",fLockRequest, plNetMsgStreamedObject::AsStdString().c_str());
		return s;
	}
};

//
// attempt to lock/unlock and set generic shared state on server.
// lock attempts will generate server reply messages confirming or denying the action.
//
class plNetMsgTestAndSet : public plNetMsgSharedState
{
public:
	plNetMsgTestAndSet() { SetBit(kNeedsReliableSend); }

	CLASSNAME_REGISTER( plNetMsgTestAndSet );
	GETINTERFACE_ANY(plNetMsgTestAndSet, plNetMsgSharedState);
};

//
// provides a way to query sharedState on the server
//
class plNetMsgGetSharedState : public plNetMsgObject
{
protected:
	char fSharedStateName[kMaxNameLen];

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgGetSharedState()  { *fSharedStateName=0; SetBit(kNeedsReliableSend); }
	~plNetMsgGetSharedState() {}

	CLASSNAME_REGISTER( plNetMsgGetSharedState );
	GETINTERFACE_ANY( plNetMsgGetSharedState, plNetMsgObject );

	void SetSharedStateName(char* n) { if (n) hsStrncpy(fSharedStateName, n, kMaxNameLen); }
	char* GetSharedStateName() { return fSharedStateName; }
};

//
// msg which sets the update frequency for a group of objects on the server
//
class plNetMsgObjectUpdateFilter : public plNetMessage
{
protected:
	plNetMsgObjectListHelper fObjectListHelper;
	float fMaxUpdateFreq;	// in secs

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgObjectUpdateFilter() : fMaxUpdateFreq(-1) {}
	~plNetMsgObjectUpdateFilter() {}

	CLASSNAME_REGISTER( plNetMsgObjectUpdateFilter );
	GETINTERFACE_ANY_AUX(plNetMsgObjectUpdateFilter,plNetMessage,plNetMsgObjectListHelper,fObjectListHelper)

	plNetMsgObjectListHelper* ObjectListInfo() { return &fObjectListHelper; }

	void SetMaxUpdateFreq(float f) { fMaxUpdateFreq=f; }
	float GetMaxUpdateFreq() const { return fMaxUpdateFreq; }
};

//
// Client wants a list of all members in the session
//
class plNetMsgMembersListReq : public plNetMessage
{
public:
	plNetMsgMembersListReq() { SetBit(kIsSystemMessage|kNeedsReliableSend); }

	CLASSNAME_REGISTER( plNetMsgMembersListReq );
	GETINTERFACE_ANY( plNetMsgMembersListReq, plNetMessage );
};

//
// Server returns a list of all members in the session
//
class plNetMsgMembersList : public plNetMsgServerToClient
{
protected:
	plNetMsgMemberListHelper fMemberListHelper;
protected:
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	CLASSNAME_REGISTER( plNetMsgMembersList );
	GETINTERFACE_ANY_AUX(plNetMsgMembersList,plNetMsgServerToClient,plNetMsgMemberListHelper,fMemberListHelper)

	plNetMsgMemberListHelper* MemberListInfo() { return &fMemberListHelper; }
};

//
// server tells client to add or remove a session member
//
class plNetMsgMemberUpdate : public plNetMsgServerToClient
{
protected:
	plNetMsgMemberInfoHelper fMemberInfo;
	bool fAddMember;		// else remove member
protected:
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	CLASSNAME_REGISTER( plNetMsgMemberUpdate );
	GETINTERFACE_ANY_AUX(plNetMsgMemberUpdate,plNetMsgServerToClient,plNetMsgMemberInfoHelper,fMemberInfo)

	bool AddingMember() { return fAddMember; }
	void SetAddingMember(bool b) { fAddMember=b; }

	plNetMsgMemberInfoHelper* MemberInfo() { return &fMemberInfo; }
	bool NeedsBroadcast() const { return true; }	// send to all clients
};


//
// ListenList updater msgs.  For voice-broadcasting purposes.
// Contains a list of other players which I am [not] listening to.
// Sent client-client or client-server.
//
class plNetMsgListenListUpdate : public plNetMessage
{
private:
	plNetMsgReceiversListHelper fReceivers;		// used by server, the players we're listening to 
	bool fAdding;							// else removing

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgListenListUpdate() : fAdding(false) {}
	~plNetMsgListenListUpdate() {}

	CLASSNAME_REGISTER( plNetMsgListenListUpdate );
	GETINTERFACE_ANY_AUX(plNetMsgListenListUpdate,plNetMessage,plNetMsgReceiversListHelper,fReceivers)
	
	plNetMsgReceiversListHelper* Receivers() { return &fReceivers; }
	
	bool GetAdding() const { return fAdding;	}
	void SetAdding(bool a) { fAdding=a;	}
			
	// virtuals
	bool NeedsBroadcast() const { return true; }		// use rcvrs list
};


///////////////////////////////////////////////////////////////////
class plNetMsgInitialAgeStateSent : public plNetMsgServerToClient
{
	UInt32	fNumInitialSDLStates;
	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgInitialAgeStateSent():fNumInitialSDLStates(0){}
	CLASSNAME_REGISTER( plNetMsgInitialAgeStateSent );
	GETINTERFACE_ANY( plNetMsgInitialAgeStateSent, plNetMsgServerToClient);
	void SetNumInitialSDLStates( UInt32 n ) { fNumInitialSDLStates=n; }
	UInt32 GetNumInitialSDLStates() const { return fNumInitialSDLStates; }
};

//
// msg which sets the update frequency for a group of objects on the server
//
class plNetMsgRelevanceRegions : public plNetMessage
{
protected:
	hsBitVector fRegionsImIn;
	hsBitVector fRegionsICareAbout;

	int IPokeBuffer(hsStream* stream, UInt32 peekOptions=0);
	int IPeekBuffer(hsStream* stream, UInt32 peekOptions=0);
public:
	plNetMsgRelevanceRegions() { SetBit(kNeedsReliableSend); }
	~plNetMsgRelevanceRegions() {}

	CLASSNAME_REGISTER( plNetMsgRelevanceRegions );
	GETINTERFACE_ANY(plNetMsgRelevanceRegions, plNetMessage)

	void SetRegionsICareAbout(const hsBitVector& r) { fRegionsICareAbout=r; }
	void SetRegionsImIn(const hsBitVector& r)		{ fRegionsImIn=r; }

	const hsBitVector& GetRegionsICareAbout() const { return fRegionsICareAbout;	}
	const hsBitVector& GetRegionsImIn() const		{ return fRegionsImIn;	}

	std::string AsStdString() const
	{
		std::string s;
		std::string b1, b2;
		int i;
		for(i=0;i<fRegionsImIn.GetNumBitVectors(); i++)
			b1 += xtl::format("0x%x ", fRegionsImIn.GetBitVector(i)).c_str();
		for(i=0;i<fRegionsICareAbout.GetNumBitVectors(); i++)
			b2 += xtl::format("0x%x ", fRegionsICareAbout.GetBitVector(i)).c_str();
		xtl::format( s, "rgnsImIn:%s, rgnsICareAbout:%s, %s",
			b1.c_str(), b2.c_str(), plNetMessage::AsStdString().c_str() );
		return s;
	}
};

#endif	// plNetMessage_h_inc
////////////////////////////////////////////////////////////////////
// End.