OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-17 10:52:46 +00:00
Code Releases Activity

Obliterate hsBool

Browse Source
This commit is contained in:
Adam Johnson
2012-07-11 01:28:00 -04:00
parent 5f78b33db4
commit a709e17069
1041 changed files with 7889 additions and 8070 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Sources/Plasma/NucleusLib/pnNetCommon/plNetApp.h
View File

@ -107,7 +107,7 @@ public:
virtual void Shutdown() {}
void SetFlagsBit(int b, hsBool on=true) { fFlagsVec.SetBit(b, on); }
void SetFlagsBit(int b, bool on=true) { fFlagsVec.SetBit(b, on); }
bool GetFlagsBit(int b) const { return fFlagsVec.IsBitSet(b) ? true : false; }
static bool StaticWarningMsg(const char* fmt, ...);
@ -184,9 +184,9 @@ public:
virtual float GetCurrentAgeTimeOfDayPercent() const { hsAssert(false, "stub"); return 0.; }
virtual bool ObjectInLocalAge(const plSynchedObject* obj) const { hsAssert(false, "stub"); return false; }
virtual uint8_t GetJoinOrder() const { hsAssert(false, "stub"); return 0; }
virtual hsBool IsRemotePlayerKey(const plKey p, int* idx=nil) { hsAssert(false, "stub"); return false; }
virtual bool IsRemotePlayerKey(const plKey p, int* idx=nil) { hsAssert(false, "stub"); return false; }
virtual plKey GetLocalPlayerKey() const { hsAssert(false, "stub"); return nil; }
virtual plSynchedObject* GetLocalPlayer(hsBool forceLoad=false) const { hsAssert(false, "stub"); return nil; }
virtual plSynchedObject* GetLocalPlayer(bool forceLoad=false) const { hsAssert(false, "stub"); return nil; }
virtual plNetGroupId SelectNetGroup(plSynchedObject* objIn, plKey groupKey) { hsAssert(false, "stub"); return plNetGroup::kNetGroupUnknown; }
virtual int IsLocallyOwned(const plSynchedObject* obj) const { hsAssert(false, "stub"); return 0; }
virtual int IsLocallyOwned(const plUoid&) const { hsAssert(false, "stub"); return 0; }

8
Sources/Plasma/NucleusLib/pnNetCommon/plNetGroup.h
View File

@ -64,15 +64,15 @@ public:
plNetGroupId(const plLocation& id, const uint8_t flags) : fId(id), fFlags(flags) { }
plNetGroupId(const plLocation& id) : fId(id), fFlags(0) { }
hsBool IsConstant() { return (fFlags & kNetGroupConstant) != 0; }
void SetConstant(hsBool constantGroup) { fFlags &= constantGroup ? kNetGroupConstant : 0; }
bool IsConstant() { return (fFlags & kNetGroupConstant) != 0; }
void SetConstant(bool constantGroup) { fFlags &= constantGroup ? kNetGroupConstant : 0; }
plLocation& Room() { return fId; }
const char* GetDesc() const { return fDesc.c_str(); }
void SetDesc(const char* c) { fDesc = c; }
hsBool operator==(const plNetGroupId& netGroup) const { return fId == netGroup.fId; }
hsBool operator!=(const plNetGroupId& netGroup) const { return fId != netGroup.fId; }
bool operator==(const plNetGroupId& netGroup) const { return fId == netGroup.fId; }
bool operator!=(const plNetGroupId& netGroup) const { return fId != netGroup.fId; }
bool operator<(const plNetGroupId& netGroup) const { return fId < netGroup.fId; }
// read and write to hsStream

4
Sources/Plasma/NucleusLib/pnNetCommon/plNetSharedState.cpp
View File

@ -87,7 +87,7 @@ void plNetSharedState::Read(hsStream* stream)
plMsgStdStringHelper::Peek(fName, stream);
int32_t num=stream->ReadLE32();
fServerMayDelete = stream->Readbool();
fServerMayDelete = stream->ReadBool();
fVars.reserve(num);
int i;
@ -105,7 +105,7 @@ void plNetSharedState::Write(hsStream* stream)
int32_t num=GetNumVars();
stream->WriteLE32(num);
stream->Writebool(fServerMayDelete);
stream->WriteBool(fServerMayDelete);
int i;
for(i=0;i<num;i++)
{

12
Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.cpp
View File

@ -54,7 +54,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
// statics
plSynchedObject* plSynchedObject::fStaticSynchedObj=nil;
std::vector<plSynchedObject::StateDefn> plSynchedObject::fDirtyStates;
std::vector<hsBool> plSynchedObject::fSynchStateStack;
std::vector<bool> plSynchedObject::fSynchStateStack;
plSynchedObject::plSynchedObject() :
fSynchFlags(0),
@ -77,7 +77,7 @@ plSynchedObject::~plSynchedObject()
#endif
}
hsBool plSynchedObject::MsgReceive(plMessage* msg)
bool plSynchedObject::MsgReceive(plMessage* msg)
{
plSetNetGroupIDMsg* setNetGroupID = plSetNetGroupIDMsg::ConvertNoRef(msg);
if (setNetGroupID)
@ -141,7 +141,7 @@ uint8_t plSynchedObject::RegisterSynchedValue(plSynchedValueBase* v)
return (uint8_t)idx;
}
hsBool plSynchedObject::RemoveSynchedValue(plSynchedValueBase* v)
bool plSynchedObject::RemoveSynchedValue(plSynchedValueBase* v)
{
int i;
for(i=0;i<GetNumSynchedValues(); i++)
@ -203,7 +203,7 @@ void plSynchedObject::SendSDLStateMsg(const char* SDLStateName, uint32_t synchFl
// Tell an object to send an sdl state update.
// The request will get queued (returns true)
//
hsBool plSynchedObject::DirtySynchState(const char* SDLStateName, uint32_t synchFlags /*SendSDLStateFlags*/)
bool plSynchedObject::DirtySynchState(const char* SDLStateName, uint32_t synchFlags /*SendSDLStateFlags*/)
{
if (!IOKToDirty(SDLStateName))
{
@ -397,11 +397,11 @@ void plSynchedObject::Write(hsStream* stream, hsResMgr* mgr)
//
// static
//
hsBool plSynchedObject::PopSynchDisabled()
bool plSynchedObject::PopSynchDisabled()
{
if (fSynchStateStack.size())
{
hsBool ret=fSynchStateStack.back();
bool ret=fSynchStateStack.back();
fSynchStateStack.pop_back();
return ret;
}

16
Sources/Plasma/NucleusLib/pnNetCommon/plSynchedObject.h
View File

@ -107,7 +107,7 @@ private:
plNetGroupId fNetGroup;
static std::vector<hsBool> fSynchStateStack;
static std::vector<bool> fSynchStateStack;
static plSynchedObject* fStaticSynchedObj; // static which temporarily holds address of each object's synchMgr
static std::vector<StateDefn> fDirtyStates;
@ -124,7 +124,7 @@ public:
CLASSNAME_REGISTER( plSynchedObject );
GETINTERFACE_ANY( plSynchedObject, hsKeyedObject);
virtual hsBool MsgReceive(plMessage* msg);
virtual bool MsgReceive(plMessage* msg);
// getters
int GetSynchFlags() const { return fSynchFlags; }
@ -137,15 +137,15 @@ public:
virtual void SetNetGroup(plNetGroupId netGroup) { fNetGroup = netGroup; }
plNetGroupId SelectNetGroup(plKey groupKey);
virtual hsBool DirtySynchState(const char* sdlName, uint32_t sendFlags);
virtual bool DirtySynchState(const char* sdlName, uint32_t sendFlags);
void SendSDLStateMsg(const char* SDLStateName, uint32_t synchFlags); // don't use, only for net code
void ClearSynchFlagsBit(uint32_t f) { fSynchFlags &= ~f; }
// static
static hsBool GetSynchDisabled() { return fSynchStateStack.size() ? fSynchStateStack.back() : true; }
static void PushSynchDisabled(hsBool b) { fSynchStateStack.push_back(b); }
static hsBool PopSynchDisabled();
static bool GetSynchDisabled() { return fSynchStateStack.size() ? fSynchStateStack.back() : true; }
static void PushSynchDisabled(bool b) { fSynchStateStack.push_back(b); }
static bool PopSynchDisabled();
static plSynchedObject* GetStaticSynchedObject() { return fStaticSynchedObj; }
static int32_t GetNumDirtyStates() { return fDirtyStates.size(); }
static plSynchedObject::StateDefn* GetDirtyState(int32_t i) { return &fDirtyStates[i]; }
@ -212,7 +212,7 @@ public:
plSynchedValueBase* GetSynchedValue(int i) const;
uint8_t RegisterSynchedValue(plSynchedValueBase* v);
hsBool RemoveSynchedValue(plSynchedValueBase* v); // handles SVFriends too
bool RemoveSynchedValue(plSynchedValueBase* v); // handles SVFriends too
void RegisterSynchedValueFriend(plSynchedValueBase* v);
#endif
@ -230,7 +230,7 @@ public:
class plSynchEnabler
{
public:
plSynchEnabler(hsBool enable) { plSynchedObject::PushSynchDisabled(!enable); }
plSynchEnabler(bool enable) { plSynchedObject::PushSynchDisabled(!enable); }
~plSynchEnabler() { plSynchedObject::PopSynchDisabled(); }
};

24
Sources/Plasma/NucleusLib/pnNetCommon/plSynchedValue.cpp
View File

@ -61,7 +61,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
//
// baseclass save/load methods for various types
//
hsBitVector plSynchedValueBase::ISaveOrLoad(hsBitVector& v, hsBool32 save, hsStream* stream, hsResMgr* mgr)
hsBitVector plSynchedValueBase::ISaveOrLoad(hsBitVector& v, bool32 save, hsStream* stream, hsResMgr* mgr)
{
if (save)
v.Write(stream);
@ -70,28 +70,28 @@ hsBitVector plSynchedValueBase::ISaveOrLoad(hsBitVector& v, hsBool32 save, hsStr
return v;
}
float plSynchedValueBase::ISaveOrLoad(float v, hsBool32 save, hsStream* stream, hsResMgr* mgr)
float plSynchedValueBase::ISaveOrLoad(float v, bool32 save, hsStream* stream, hsResMgr* mgr)
ISaveOrLoadSimpleType();
double plSynchedValueBase::ISaveOrLoad(double v, hsBool32 save, hsStream* stream, hsResMgr* mgr)
double plSynchedValueBase::ISaveOrLoad(double v, bool32 save, hsStream* stream, hsResMgr* mgr)
ISaveOrLoadSimpleType();
int32_t plSynchedValueBase::ISaveOrLoad(int32_t v, hsBool32 save, hsStream* stream, hsResMgr* mgr)
int32_t plSynchedValueBase::ISaveOrLoad(int32_t v, bool32 save, hsStream* stream, hsResMgr* mgr)
ISaveOrLoadSimpleType();
uint32_t plSynchedValueBase::ISaveOrLoad(uint32_t v, hsBool32 save, hsStream* stream, hsResMgr* mgr)
uint32_t plSynchedValueBase::ISaveOrLoad(uint32_t v, bool32 save, hsStream* stream, hsResMgr* mgr)
ISaveOrLoadSimpleType();
int plSynchedValueBase::ISaveOrLoad(int v, hsBool32 save, hsStream* stream, hsResMgr* mgr)
int plSynchedValueBase::ISaveOrLoad(int v, bool32 save, hsStream* stream, hsResMgr* mgr)
ISaveOrLoadSimpleType();
bool plSynchedValueBase::ISaveOrLoad(bool v, hsBool32 save, hsStream* stream, hsResMgr* mgr)
bool plSynchedValueBase::ISaveOrLoad(bool v, bool32 save, hsStream* stream, hsResMgr* mgr)
ISaveOrLoadSimpleType();
//
// save or load a key. return the key.
//
const plKey plSynchedValueBase::ISaveOrLoad(const plKey key, hsBool32 save, hsStream* stream, hsResMgr* mgr)
const plKey plSynchedValueBase::ISaveOrLoad(const plKey key, bool32 save, hsStream* stream, hsResMgr* mgr)
{
if (save)
{
@ -134,24 +134,24 @@ const plKey plSynchedValueBase::ISaveOrLoad(const plKey key, hsBool32 save, hsSt
return nil;
}
hsKeyedObject* plSynchedValueBase::ISaveOrLoad(hsKeyedObject* obj, hsBool32 save, hsStream* stream, hsResMgr* mgr)
hsKeyedObject* plSynchedValueBase::ISaveOrLoad(hsKeyedObject* obj, bool32 save, hsStream* stream, hsResMgr* mgr)
{
plKey key = obj ? obj->GetKey() : nil;
key = ISaveOrLoad(key, save, stream, mgr);
return key ? key->ObjectIsLoaded() : nil;
}
plSceneNode* plSynchedValueBase::ISaveOrLoad(plSceneNode* obj, hsBool32 save, hsStream* stream, hsResMgr* mgr)
plSceneNode* plSynchedValueBase::ISaveOrLoad(plSceneNode* obj, bool32 save, hsStream* stream, hsResMgr* mgr)
{
// return plSceneNode::ConvertNoRef(ISaveOrLoad(hsKeyedObject::ConvertNoRef(obj), save, stream, mgr));
hsAssert(false, "SceneNode synchedValues currently not implemented");
return nil;
}
plSceneObject* plSynchedValueBase::ISaveOrLoad(plSceneObject* obj, hsBool32 save, hsStream* stream, hsResMgr* mgr)
plSceneObject* plSynchedValueBase::ISaveOrLoad(plSceneObject* obj, bool32 save, hsStream* stream, hsResMgr* mgr)
{ return plSceneObject::ConvertNoRef(ISaveOrLoad(hsKeyedObject::ConvertNoRef(obj), save, stream, mgr)); }
plCoordinateInterface* plSynchedValueBase::ISaveOrLoad(const plCoordinateInterface* cInt, hsBool32 save, hsStream* stream, hsResMgr* mgr)
plCoordinateInterface* plSynchedValueBase::ISaveOrLoad(const plCoordinateInterface* cInt, bool32 save, hsStream* stream, hsResMgr* mgr)
{
plSceneObject* obj = ISaveOrLoad(cInt ? cInt->fOwner : nil, save, stream, mgr);
return obj ? obj->fCoordinateInterface : nil;

48
Sources/Plasma/NucleusLib/pnNetCommon/plSynchedValue.h
View File

@ -93,27 +93,27 @@ protected:
fSynchedObjectAddrOffset=-1;
}
hsBool32 IOKToDirty()
bool32 IOKToDirty()
{
if (fFlags & (kDontDirty | kValueIsDirty))
return false;
return GetSynchedObject() ? GetSynchedObject()->IOKToDirty() : false;
}
virtual void ISaveOrLoad(hsBool32 save, hsStream* stream, hsResMgr* mgr) = 0;
virtual void ISaveOrLoad(bool32 save, hsStream* stream, hsResMgr* mgr) = 0;
// save/load methods for different types
const plKey ISaveOrLoad(const plKey key, hsBool32 save, hsStream* stream, hsResMgr* mgr);
hsKeyedObject* ISaveOrLoad(hsKeyedObject* obj, hsBool32 save, hsStream* stream, hsResMgr* mgr);
plSceneNode* ISaveOrLoad(plSceneNode* obj, hsBool32 save, hsStream* stream, hsResMgr* mgr);
plSceneObject* ISaveOrLoad(plSceneObject* obj, hsBool32 save, hsStream* stream, hsResMgr* mgr);
int32_t ISaveOrLoad(int32_t v, hsBool32 save, hsStream* stream, hsResMgr* mgr);
uint32_t ISaveOrLoad(uint32_t v, hsBool32 save, hsStream* stream, hsResMgr* mgr);
bool ISaveOrLoad(bool v, hsBool32 save, hsStream* stream, hsResMgr* mgr);
int ISaveOrLoad(int v, hsBool32 save, hsStream* stream, hsResMgr* mgr); // or hsBool32
float ISaveOrLoad(float v, hsBool32 save, hsStream* stream, hsResMgr* mgr);
double ISaveOrLoad(double v, hsBool32 save, hsStream* stream, hsResMgr* mgr);
hsBitVector ISaveOrLoad(hsBitVector& v, hsBool32 save, hsStream* stream, hsResMgr* mgr);
plCoordinateInterface* ISaveOrLoad(const plCoordinateInterface* cInt, hsBool32 save, hsStream* stream, hsResMgr* mgr);
const plKey ISaveOrLoad(const plKey key, bool32 save, hsStream* stream, hsResMgr* mgr);
hsKeyedObject* ISaveOrLoad(hsKeyedObject* obj, bool32 save, hsStream* stream, hsResMgr* mgr);
plSceneNode* ISaveOrLoad(plSceneNode* obj, bool32 save, hsStream* stream, hsResMgr* mgr);
plSceneObject* ISaveOrLoad(plSceneObject* obj, bool32 save, hsStream* stream, hsResMgr* mgr);
int32_t ISaveOrLoad(int32_t v, bool32 save, hsStream* stream, hsResMgr* mgr);
uint32_t ISaveOrLoad(uint32_t v, bool32 save, hsStream* stream, hsResMgr* mgr);
bool ISaveOrLoad(bool v, bool32 save, hsStream* stream, hsResMgr* mgr);
int ISaveOrLoad(int v, bool32 save, hsStream* stream, hsResMgr* mgr); // or bool32
float ISaveOrLoad(float v, bool32 save, hsStream* stream, hsResMgr* mgr);
double ISaveOrLoad(double v, bool32 save, hsStream* stream, hsResMgr* mgr);
hsBitVector ISaveOrLoad(hsBitVector& v, bool32 save, hsStream* stream, hsResMgr* mgr);
plCoordinateInterface* ISaveOrLoad(const plCoordinateInterface* cInt, bool32 save, hsStream* stream, hsResMgr* mgr);
public:
plSynchedValueBase() { IConstruct(); }
virtual ~plSynchedValueBase() {}
@ -164,7 +164,7 @@ class plSynchedValue : public plSynchedValueBase
protected:
T fValue;
void ISaveOrLoad(hsBool32 save, hsStream* stream, hsResMgr* mgr)
void ISaveOrLoad(bool32 save, hsStream* stream, hsResMgr* mgr)
{ fValue=(T)plSynchedValueBase::ISaveOrLoad(fValue, save, stream, mgr); } // default method
public:
@ -179,8 +179,8 @@ public:
T* operator &() { return &fValue; }
// equality
hsBool32 operator==(const T& other) const { return fValue==(T)other; }
hsBool32 operator!=(const T& other) const { return !(*this == other); }
bool32 operator==(const T& other) const { return fValue==(T)other; }
bool32 operator!=(const T& other) const { return !(*this == other); }
// other operators
T operator++() { DirtyIfNecessary(); return ++fValue; }
@ -226,9 +226,9 @@ public:
const T& GetValue() const { return fValue; }
// for hsBitVector
hsBool32 IsBitSet(uint32_t which) const { return fValue.IsBitSet(which); }
hsBool32 SetBit(uint32_t which, hsBool32 on = true)
{ hsBool32 bitSet = IsBitSet(which);
bool32 IsBitSet(uint32_t which) const { return fValue.IsBitSet(which); }
bool32 SetBit(uint32_t which, bool32 on = true)
{ bool32 bitSet = IsBitSet(which);
if ( (on && !bitSet) || (!on && bitSet) )
DirtyIfNecessary();
return fValue.SetBit(which, on);
@ -236,9 +236,9 @@ public:
void Read(hsStream* s) { fValue.Read(s); }
void Write(hsStream* s) const { fValue.Write(s); }
void Clear() { DirtyIfNecessary(); fValue.Clear(); }
hsBool32 ClearBit(uint32_t which) { if (fValue.IsBitSet(which)) DirtyIfNecessary(); return fValue.ClearBit(which); }
bool32 ClearBit(uint32_t which) { if (fValue.IsBitSet(which)) DirtyIfNecessary(); return fValue.ClearBit(which); }
void Reset() { if (fValue.GetSize()!=0) DirtyIfNecessary(); fValue.Reset(); }
hsBool32 ToggleBit(uint32_t which) { DirtyIfNecessary(); return fValue.ToggleBit(which); }
bool32 ToggleBit(uint32_t which) { DirtyIfNecessary(); return fValue.ToggleBit(which); }
uint32_t GetSize() { return fValue.GetSize(); }
};
@ -297,7 +297,7 @@ class plSynchedTArray : public plSynchedValueBase
private:
hsTArray<T> fValueList;
void ISaveOrLoad(hsBool32 save, hsStream* stream, hsResMgr* mgr);
void ISaveOrLoad(bool32 save, hsStream* stream, hsResMgr* mgr);
public:
enum { kMissingIndex = hsTArray<T>::kMissingIndex };
plSynchedTArray() {}
@ -333,7 +333,7 @@ public:
// inlines
//
template <class T> inline
void plSynchedTArray<T>::ISaveOrLoad(hsBool32 save, hsStream* stream, hsResMgr* mgr)
void plSynchedTArray<T>::ISaveOrLoad(bool32 save, hsStream* stream, hsResMgr* mgr)
{
if (save)
{