rpgnetobject.h

五行MMORPG引擎系统V1.0

//RPGNetObject.h
/*/////////////////////////////////////////////////////////////////

   李亦
	[e-mail] 4040719
	2006-7-16
/*/////////////////////////////////////////////////////////////////
#ifndef _RPGNETOBJECT_H_
#define _RPGNETOBJECT_H_

#ifdef TGE_RPG


#ifndef _SIMBASE_H_
#include "console/simBase.h"
#endif
#ifndef _MMATH_H_
#include "math/mMath.h"
#endif


//-----------------------------------------------------------------------------
class NetConnection;
class NetObject;

//-----------------------------------------------------------------------------

struct CameraScopeQuery
{
   NetObject *camera;       ///< Pointer to the viewing object.
   Point3F pos;             ///< Position in world space
   Point3F orientation;     ///< Viewing vector in world space
   F32 fov;                 ///< Viewing angle/2
   F32 sinFov;              ///< sin(fov/2);
   F32 cosFov;              ///< cos(fov/2);
   F32 visibleDistance;     ///< Visible distance.
};

struct GhostInfo;




/// @nosubgrouping
class NetObject: public SimObject
{
   typedef SimObject Parent;

   // The Ghost Manager needs read/write access
   friend class  NetConnection;
   friend class  GhostConnection;
   friend class  EventConnection;
   friend struct GhostInfo;
   friend class  ProcessList;

   // Not the best way to do this, but the event needs access to mNetFlags
   friend class GhostAlwaysObjectEvent;

private:


   U32 mDirtyMaskBits;

   /// @name Dirty List
   ///
   /// Whenever a NetObject becomes "dirty", we add it to the dirty list.
   /// We also remove ourselves on the destructor.
   ///
   /// This is done so that when we want to send updates (in NetConnection),
   /// it's very fast to find the objects that need to be updated.
   /// @{

   /// Static pointer to the head of the dirty NetObject list.
   static NetObject *mDirtyList;

   /// Next item in the dirty list...
   NetObject *mPrevDirtyList;

   /// Previous item in the dirty list...
   NetObject *mNextDirtyList;

   /// @}


// TGE_RPG 调整NetFlags访问protected -> public
public:
   enum NetFlags
   {
      IsGhost           =  BIT(1),   ///< This is a ghost.
      ScopeAlways       =  BIT(6),  ///< Object always ghosts to clients.
      ScopeLocal        =  BIT(7),  ///< Ghost only to local client.
      Ghostable         =  BIT(8),  ///< Set if this object CAN ghost.
      MaxNetFlagBit     =  15
   };

protected:
   SimObjectPtr<NetObject> mServerObject;


   BitSet32		mNetFlags;             ///< Flag values from NetFlags
   U32			mNetIndex;             ///< The index of this ghost in the GhostManager on the server.

   GhostInfo	*mFirstObjectRef;      ///< Head of a linked list storing GhostInfos referencing this NetObject.

public:
   NetObject();
   ~NetObject();


   /// @name Miscellaneous
   /// @{
   static void initPersistFields();
   static void collapseDirtyList();
   bool onAdd();
   void onRemove();
   /// @}


	//适用于RPG模式
   void GSetMaskBits(U32 orMask);

	//保留GameBase系列的兼容性
	void setMaskBits(U32 orMask){orMask;}
   void clearMaskBits(U32 orMask);



   void setScopeAlways();
   void clearScopeAlways();

   /// This returns a value which is used to prioritize which objects need to be updated.
   ///
   /// In NetObject, our returned priority is 0.1 * updateSkips, so that less recently
   /// updated objects are more likely to be updated.
   ///
   /// In subclasses, this can be adjusted. For instance, ShapeBase provides priority
   /// based on proximity to the camera.
   ///
   /// @param  focusObject    Information from a previous call to onCameraScopeQuery.
   /// @param  updateMask     Current update mask.
   /// @param  updateSkips    Number of ticks we haven't been updated for.
   /// @returns A floating point value indicating priority. These are typically < 5.0.
   virtual F32 getUpdatePriority(CameraScopeQuery *focusObject, U32 updateMask, S32 updateSkips);

   /// Instructs this object to pack its state for transfer over the network.
   ///
   /// @param   conn    Net connection being used
   /// @param   mask    Mask indicating fields to transmit.
   /// @param   stream  Bitstream to pack data to
   ///
   /// @returns Any bits which were not dealt with. The value is stored by the networking
   ///          system. Don't set bits you weren't passed.
   virtual U32  packUpdate(NetConnection * conn, U32 mask, BitStream *stream);

   /// Instructs this object to read state data previously packed with packUpdate.
   ///
   /// @param   conn    Net connection being used
   /// @param   stream  stream to read from
   virtual void unpackUpdate(NetConnection * conn, BitStream *stream);

   /// Queries the object about information used to determine scope.
   ///
   /// Something that is 'in scope' is somehow interesting to the client.
   ///
   /// If we are a NetConnection's scope object, it calls this method to determine
   /// how things should be scoped; basically, we tell it our field of view with camInfo,
   /// and have the opportunity to manually mark items as "in scope" as we see fit.
   ///
   /// By default, we just mark all ghostable objects as in scope.
   ///
   /// @param   cr         Net connection requesting scope information.
   /// @param   camInfo    Information about what this object can see.
   virtual void onCameraScopeQuery(NetConnection *cr, CameraScopeQuery *camInfo);

   /// Get the ghost index of this object.
   U32 getNetIndex() { return mNetIndex; }

   bool isServerObject() const;  ///< Is this a server object?
   bool isClientObject() const;  ///< Is this a client object?

   bool isGhost() const;         ///< Is this is a ghost?
   bool isScopeLocal() const;    ///< Should this object only be visible to the client which created it?
   bool isScopeable() const;     ///< Is this object subject to scoping?
   bool isGhostable() const;     ///< Is this object ghostable?
   bool isGhostAlways() const;   ///< Should this object always be ghosted?


   DECLARE_CONOBJECT(NetObject);
};

//-----------------------------------------------------------------------------

inline bool NetObject::isGhost() const
{
#ifdef TGE_RPGCLIENT2 ///TGE_RPGClient2
	return true;
#else
   return mNetFlags.test(IsGhost);
#endif
}

inline bool NetObject::isClientObject() const
{
#ifdef TGE_RPGCLIENT2 ///TGE_RPGClient2
	return true;
#else
   return mNetFlags.test(IsGhost);
#endif
}

inline bool NetObject::isServerObject() const
{
#ifdef TGE_RPGCLIENT2 ///TGE_RPGClient2
	return true; //返回true，以实现Server逻辑
#else
   return !mNetFlags.test(IsGhost);
#endif
}




inline bool NetObject::isScopeLocal() const
{
   return mNetFlags.test(ScopeLocal);
}

inline bool NetObject::isScopeable() const
{
   return mNetFlags.test(Ghostable) && !mNetFlags.test(ScopeAlways);
}

inline bool NetObject::isGhostable() const
{
   return mNetFlags.test(Ghostable);
}

inline bool NetObject::isGhostAlways() const
{
   AssertFatal(mNetFlags.test(Ghostable) || mNetFlags.test(ScopeAlways) == false,
               "That's strange, a ScopeAlways non-ghostable object?  Something wrong here");
   return mNetFlags.test(Ghostable) && mNetFlags.test(ScopeAlways);
}

#endif //#ifdef TGE_RPG
#endif //_RPGNETOBJECT_H_