Initial Commit of CyanWorlds.com Engine Open Source Client/Plugin

MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/NucleusLib/pnKeyedObject/plUoid.cpp

@@ -0,0 +1,268 @@
+/*==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==*/
+#include "plUoid.h"
+#include "hsStream.h"
+#include "hsUtils.h"
+
+//// plLocation //////////////////////////////////////////////////////////////
+
+const plLocation plLocation::kGlobalFixedLoc(plLocation::kGlobalFixedLocIdx);
+const plLocation plLocation::kLocalStartLoc(plLocation::kLocalLocStartIdx);
+const plLocation plLocation::kLocalEndLoc(plLocation::kLocalLocEndIdx);
+const plLocation plLocation::kNormalStartLoc(plLocation::kNormalLocStartIdx);
+const plLocation plLocation::kGlobalServerLoc(plLocation::kGlobalServerLocIdx, plLocation::kReserved);
+const plLocation plLocation::kInvalidLoc;
+
+plLocation::plLocation(const plLocation& toCopyFrom)
+{
+	*this = toCopyFrom;
+}
+
+void plLocation::Read(hsStream* s)
+{
+	s->LogReadSwap(&fSequenceNumber, "Location Sequence Number");
+	s->LogReadSwap(&fFlags, "Location Flags");
+}
+
+void plLocation::Write(hsStream* s) const
+{
+	s->WriteSwap(fSequenceNumber);
+	s->WriteSwap(fFlags);
+}
+
+plLocation& plLocation::operator=(const plLocation& rhs)
+{
+	fSequenceNumber = rhs.fSequenceNumber;
+	fFlags = rhs.fFlags;
+	return *this;
+}
+
+hsBool plLocation::operator==(const plLocation& u) const
+{
+	// Ignore the itinerant flag when comparing, because
+	return (fSequenceNumber == u.fSequenceNumber) && ((fFlags & ~kItinerant) == (u.fFlags & ~kItinerant));
+}
+
+void plLocation::Set(UInt32 seqNum)
+{
+	fSequenceNumber = seqNum;
+}
+
+void plLocation::Invalidate()
+{
+	fSequenceNumber = kInvalidLocIdx;
+	fFlags = 0; // Set to kInvalid?
+}
+
+hsBool plLocation::IsValid() const
+{
+	return (fSequenceNumber == kInvalidLocIdx) ? false : true;
+}
+
+hsBool plLocation::IsReserved() const
+{
+	return hsCheckBits(fFlags, kReserved);
+}
+
+hsBool plLocation::IsItinerant() const
+{
+	return hsCheckBits(fFlags, kItinerant);
+}
+
+hsBool plLocation::IsVirtual() const
+{
+	// This returns whether the location is "virtual", i.e. isn't a true room per se. Like fixed keys
+	if (fSequenceNumber == kGlobalFixedLocIdx)
+		return true;
+
+	return false;
+}
+
+// THIS SHOULD BE FOR DEBUGGING ONLY <hint hint>
+char* plLocation::StringIze(char* str)  const // Format to displayable string
+{
+	sprintf(str, "S0x%xF0x%x", fSequenceNumber, int(fFlags));
+	return str;
+}
+
+plLocation plLocation::MakeReserved(UInt32 number)
+{
+	return plLocation(kReservedLocAvailableStart + number, kReserved);
+}
+
+plLocation plLocation::MakeNormal(UInt32 number)
+{
+	return plLocation(kNormalLocStartIdx + number);
+}
+
+//// plUoid //////////////////////////////////////////////////////////////////
+
+plUoid::plUoid(const plLocation& location, UInt16 classType, const char* objectName, const plLoadMask& m)
+{
+	fObjectName = nil;
+	Invalidate();
+
+	fLocation = location;
+	fClassType = classType;
+	fObjectName = hsStrcpy(objectName);
+	fLoadMask = m;
+	fClonePlayerID = 0;
+}
+
+plUoid::plUoid(const plUoid& src)
+{
+	fObjectName = nil;
+	Invalidate();
+	*this = src;
+}
+
+plUoid::~plUoid()
+{
+	Invalidate();
+}
+
+void plUoid::Read(hsStream* s)
+{
+	hsAssert(fObjectName == nil, "Reading over an old uoid? You're just asking for trouble, aren't you?");
+
+	// first read contents flags
+	UInt8 contents = s->ReadByte();
+
+	fLocation.Read(s);
+
+	// conditional loadmask read
+	if (contents & kHasLoadMask)
+		fLoadMask.Read(s);
+	else
+		fLoadMask.SetAlways();
+
+	s->LogReadSwap(&fClassType, "ClassType");
+	s->LogReadSwap(&fObjectID, "ObjectID");
+	s->LogSubStreamPushDesc("ObjectName");
+	fObjectName = s->LogReadSafeString();
+
+	// conditional cloneIDs read
+	if (contents & kHasCloneIDs)
+	{		
+		s->LogReadSwap( &fCloneID ,"CloneID");
+		UInt16 dummy;
+		s->LogReadSwap(&dummy, "dummy"); // To avoid breaking format
+		s->LogReadSwap( &fClonePlayerID ,"ClonePlayerID");
+	}
+	else
+	{
+		fCloneID = 0;
+		fClonePlayerID = 0;
+	}
+}
+
+void plUoid::Write(hsStream* s) const
+{
+	// first write contents byte
+	UInt8 contents = IsClone() ? kHasCloneIDs : 0;
+	if (fLoadMask.IsUsed())
+		contents |= kHasLoadMask;
+	s->WriteByte(contents);
+
+	fLocation.Write(s);
+
+	// conditional loadmask write
+	if (contents & kHasLoadMask)
+		fLoadMask.Write(s);
+
+	s->WriteSwap( fClassType );
+	s->WriteSwap( fObjectID );
+	s->WriteSafeString( fObjectName );
+
+	// conditional cloneIDs write
+	if (contents & kHasCloneIDs)
+	{
+		s->WriteSwap(fCloneID);
+		UInt16 dummy = 0;
+		s->WriteSwap(dummy); // to avoid breaking format
+		s->WriteSwap(fClonePlayerID);
+	}
+}
+
+void plUoid::Invalidate()
+{
+	fObjectID = 0;
+	fCloneID = 0;
+	fClonePlayerID = 0;
+	fClassType = 0;
+	if (fObjectName)
+		delete [] fObjectName;
+	fObjectName = nil;
+	fLocation.Invalidate();
+	fLoadMask = plLoadMask::kAlways;
+
+}
+
+hsBool plUoid::IsValid() const
+{
+	if (!fLocation.IsValid() || fObjectName == nil)
+		return false;
+
+	return true;
+}
+
+hsBool plUoid::operator==(const plUoid& u) const
+{
+	return	fLocation == u.fLocation
+			&& fLoadMask == u.fLoadMask
+			&& fClassType == u.fClassType
+			&& hsStrEQ(fObjectName, u.fObjectName)
+			&& fObjectID == u.fObjectID
+			&& fCloneID == u.fCloneID
+			&& fClonePlayerID == u.fClonePlayerID;
+}
+
+plUoid& plUoid::operator=(const plUoid& rhs)
+{
+	fObjectID = rhs.fObjectID;
+	fCloneID = rhs.fCloneID;
+	fClonePlayerID = rhs.fClonePlayerID;
+	fClassType = rhs.fClassType;
+	if (fObjectName)
+		delete [] fObjectName;
+	fObjectName = hsStrcpy(rhs.fObjectName);
+	fLocation = rhs.fLocation;
+	fLoadMask = rhs.fLoadMask;
+
+	return *this;
+}
+
+// THIS SHOULD BE FOR DEBUGGING ONLY <hint hint>
+char* plUoid::StringIze(char* str) const // Format to displayable string
+{
+	sprintf(str, "(0x%x:0x%x:%s:C:[%lu,%lu])", 
+		fLocation.GetSequenceNumber(), 
+		int(fLocation.GetFlags()), 
+		fObjectName, 
+		GetClonePlayerID(), 
+		GetCloneID());
+	return str;
+}