You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

327 lines
10 KiB

/*==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==*/
#ifndef PL_NET_MSG_HELPERS_inc
#define PL_NET_MSG_HELPERS_inc
//
// These are not messages per se, but helper classes which are used
// in to avoid multiple derivation by net messages.
//
#include "hsTypes.h"
#include "hsUtils.h"
#include "hsStream.h"
#include "hsStlUtils.h"
#include "pnNetCommon/pnNetCommon.h"
#include "pnFactory/plCreatable.h"
#include "pnKeyedObject/plUoid.h"
#include "pnKeyedObject/plKey.h"
#include "plUnifiedTime/plUnifiedTime.h"
#include "plNetCommon/plClientGuid.h"
#include <algorithm>
class plKey;
class hsStream;
////////////////////////////////////////////////////////////////////
// plNetMsgStreamableHelper
// Will peek/poke anything derived from hsStreamable
class plNetMsgStreamableHelper : public plCreatable
{
hsStreamable * fObject;
public:
plNetMsgStreamableHelper():fObject(nil){}
plNetMsgStreamableHelper(hsStreamable * object):fObject(object){}
plNetMsgStreamableHelper & operator =(hsStreamable * value);
operator hsStreamable *() const { return fObject;}
operator const hsStreamable *() const { return fObject;}
CLASSNAME_REGISTER( plNetMsgStreamableHelper );
GETINTERFACE_ANY(plNetMsgStreamableHelper, plCreatable);
void SetObject(hsStreamable * object) { fObject=object;}
hsStreamable * GetObject() const { return fObject;}
int Poke(hsStream* stream, UInt32 peekOptions=0);
int Peek(hsStream* stream, UInt32 peekOptions=0);
};
////////////////////////////////////////////////////////////////////
// plNetMsgCreatableHelper
// Will peek/poke anything derived from plCreatable.
// Will create the object upon read if it hasn't been set by SetObject().
// When helper goes away, object will be unref-ed if it was created by
// the helper, so if you GetObject() and want to keep it longer than the
// lifetime of the helper, ref it.
class plNetMsgCreatableHelper : public plCreatable
{
plCreatable * fCreatable;
bool fWeCreatedIt;
public:
plNetMsgCreatableHelper(plCreatable * object = nil);
~plNetMsgCreatableHelper();
plNetMsgCreatableHelper & operator =(plCreatable * value);
operator plCreatable*();
operator const plCreatable*();
CLASSNAME_REGISTER( plNetMsgCreatableHelper );
GETINTERFACE_ANY(plNetMsgCreatableHelper, plCreatable);
void SetObject(plCreatable * object);
plCreatable * GetObject();
int Poke(hsStream* stream, UInt32 peekOptions=0);
int Peek(hsStream* stream, UInt32 peekOptions=0);
};
////////////////////////////////////////////////////////////////////
//
// Net msg helper class for a stream buffer of some type (saveState, voice, plMessage...)
//
class plNetMsgStreamHelper : public plCreatable
{
private:
enum ContentsFlags
{
kUncompressedSize,
kStreamBuf,
kStreamLen,
kCompressionType,
};
protected:
UInt32 fUncompressedSize;
Int16 fStreamType; // set to creatable type, not read/written, gleaned from creatable stream
UInt8* fStreamBuf;
UInt32 fStreamLen;
UInt8 fCompressionType; // see plNetMessage::CompressionType
UInt32 fCompressionThreshold; // NOT WRITTEN
void IAllocStream(UInt32 len);
public:
enum { kDefaultCompressionThreshold = 255 }; // bytes
plNetMsgStreamHelper();
virtual ~plNetMsgStreamHelper() { delete [] fStreamBuf; }
CLASSNAME_REGISTER( plNetMsgStreamHelper );
GETINTERFACE_ANY(plNetMsgStreamHelper, plCreatable);
virtual int Poke(hsStream* stream, UInt32 peekOptions=0);
virtual int Peek(hsStream* stream, UInt32 peekOptions=0);
// creatable ops
virtual void Read(hsStream* s, hsResMgr* mgr) { Peek(s); }
virtual void Write(hsStream* s, hsResMgr* mgr) { Poke(s); }
void ReadVersion(hsStream* s, hsResMgr* mgr);
void WriteVersion(hsStream* s, hsResMgr* mgr);
void Clear();
// copiers
void CopyFrom(const plNetMsgStreamHelper* other);
void CopyStream(hsStream* ssStream); // copies to fStream
void CopyStream(Int32 len, const void* buf); // copies to fStream
// setters
void SetCompressionType(UInt8 t) { fCompressionType=t; }
void SetStreamLen(UInt32 l) { fStreamLen=l; }
void SetStreamBuf(UInt8* b) { fStreamBuf=b; }
void SetUncompressedSize(UInt32 s) { fUncompressedSize=s; }
// Getters
UInt8 GetCompressionType() const { return fCompressionType; }
Int16 GetStreamType() const { return fStreamType; }
UInt32 GetStreamLen() const { return fStreamLen; }
UInt8* GetStreamBuf() const { return fStreamBuf; }
UInt32 GetUncompressedSize() const { return fUncompressedSize; }
bool Compress(int offset=2 /* skip 2 bytes as creatable index */ );
bool Uncompress(int offset=2 /* skip 2 bytes as creatable index */ );
bool IsCompressed() const;
bool IsCompressable() const;
UInt32 GetCompressionThreshold() const { return fCompressionThreshold; }
void SetCompressionThreshold( UInt32 v ) { fCompressionThreshold=v; }
};
//
// Contains info about a scene object
//
class plNetMsgObjectHelper : public plCreatable
{
private:
enum ContentFlags
{
kObjHelperUoid,
};
protected:
// string names for debug purposes only
plUoid fUoid;
// update operator()= fxn when adding new members
public:
plNetMsgObjectHelper() {}
plNetMsgObjectHelper(const plKey key) { SetFromKey(key); }
virtual ~plNetMsgObjectHelper() { }
CLASSNAME_REGISTER( plNetMsgObjectHelper );
GETINTERFACE_ANY(plNetMsgObjectHelper, plCreatable);
virtual int Poke(hsStream* stream, UInt32 peekOptions=0);
virtual int Peek(hsStream* stream, UInt32 peekOptions=0);
plNetMsgObjectHelper & operator =(const plNetMsgObjectHelper & other);
// setters
hsBool SetFromKey(const plKey &key);
void SetUoid(const plUoid &u) { fUoid=u; }
// getters
const char* GetObjectName() const { return fUoid.GetObjectName(); }
UInt32 GetPageID() const { return fUoid.GetLocation().GetSequenceNumber(); }
const plUoid& GetUoid() const { return fUoid; }
void ReadVersion(hsStream* s, hsResMgr* mgr);
void WriteVersion(hsStream* s, hsResMgr* mgr);
};
//
// Contains a list of info about scene objects.
//
class plNetMsgObjectListHelper : public plCreatable
{
protected:
std::vector<plNetMsgObjectHelper*> fObjects;
public:
plNetMsgObjectListHelper() {}
virtual ~plNetMsgObjectListHelper();
CLASSNAME_REGISTER( plNetMsgObjectListHelper );
GETINTERFACE_ANY(plNetMsgObjectListHelper, plCreatable);
virtual int Poke(hsStream* stream, UInt32 peekOptions=0);
virtual int Peek(hsStream* stream, UInt32 peekOptions=0);
void Reset();
int GetNumObjects() const { return fObjects.size(); }
plNetMsgObjectHelper* GetObject(int i) { return fObjects[i]; }
void AddObject(plKey key) { fObjects.push_back(TRACKED_NEW plNetMsgObjectHelper(key)); }
};
//
// Contains a info about a net member.
//
class plNetMsgMemberInfoHelper : public plCreatable
{
protected:
UInt32 fFlags;
plUoid fAvatarUoid;
plClientGuid fClientGuid;
public:
plNetMsgMemberInfoHelper();
CLASSNAME_REGISTER( plNetMsgMemberInfoHelper );
GETINTERFACE_ANY( plNetMsgMemberInfoHelper, plCreatable);
virtual int Poke(hsStream* stream, UInt32 peekOptions=0);
virtual int Peek(hsStream* stream, UInt32 peekOptions=0);
const plClientGuid * GetClientGuid() const { return &fClientGuid; }
plClientGuid * GetClientGuid() { return &fClientGuid; }
UInt32 GetFlags() const { return fFlags; }
plUoid GetAvatarUoid() const { return fAvatarUoid; }
void SetFlags(UInt32 v) { fFlags=v; }
void SetAvatarUoid(plUoid u) { fAvatarUoid=u; }
};
//
// Contains a info about a list of net members.
// This is sent from server to client.
//
class plNetMsgMemberListHelper : public plCreatable
{
public:
typedef std::vector<plNetMsgMemberInfoHelper*> MemberInfoHelperVec;
struct MatchesPlayerID
{
UInt32 fID;
MatchesPlayerID( UInt32 id ): fID( id ){}
bool operator()( const plNetMsgMemberInfoHelper * mbr ) const
{
return ( mbr && mbr->GetClientGuid()->GetPlayerID()==fID );
}
};
protected:
MemberInfoHelperVec fMembers;
public:
plNetMsgMemberListHelper() {}
virtual ~plNetMsgMemberListHelper();
CLASSNAME_REGISTER( plNetMsgMemberListHelper );
GETINTERFACE_ANY( plNetMsgMemberListHelper, plCreatable);
virtual int Poke(hsStream* stream, UInt32 peekOptions=0);
virtual int Peek(hsStream* stream, UInt32 peekOptions=0);
int GetNumMembers() const { return fMembers.size(); }
const plNetMsgMemberInfoHelper* GetMember(int i) const { return fMembers[i]; }
void AddMember(plNetMsgMemberInfoHelper* a) { fMembers.push_back(a); }
const MemberInfoHelperVec * GetMembers() const { return &fMembers;}
};
/////////////////////////////////////////////////////////////////
//
// Contains a list of other players (members).
// This is commonly used to route p2p msgs to groups of players.
// Sent client to server.
//
class plNetMsgReceiversListHelper : public plCreatable
{
protected:
std::vector<UInt32> fPlayerIDList;
public:
plNetMsgReceiversListHelper() {}
virtual ~plNetMsgReceiversListHelper() {}
CLASSNAME_REGISTER( plNetMsgReceiversListHelper );
GETINTERFACE_ANY( plNetMsgReceiversListHelper, plCreatable);
virtual int Poke(hsStream* stream, UInt32 peekOptions=0);
virtual int Peek(hsStream* stream, UInt32 peekOptions=0);
void Clear() { fPlayerIDList.clear(); }
int GetNumReceivers() const { return fPlayerIDList.size(); }
UInt32 GetReceiverPlayerID(int i) const { return fPlayerIDList[i]; }
void AddReceiverPlayerID(UInt32 a) { fPlayerIDList.push_back(a); }
bool RemoveReceiverPlayerID(UInt32 n); // returns true if found and removed
};
#endif // PL_NET_MSG__HELPERS_inc