OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
Browse Source

Fix VaultNodeAccess

Adam Johnson 10 years ago
parent
a7fbdfd69a
commit
851b580121
3 changed files with 74 additions and 245 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      Sources/Plasma/PubUtilLib/plVault/Pch.h
  2. 263
      Sources/Plasma/PubUtilLib/plVault/plVaultNodeAccess.cpp
  3. 47
      Sources/Plasma/PubUtilLib/plVault/plVaultNodeAccess.h

1
Sources/Plasma/PubUtilLib/plVault/Pch.h
Unescape View File

@ -62,6 +62,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
// 'Old' system is full of compiler warnings at /W4, so just hide them // 'Old' system is full of compiler warnings at /W4, so just hide them
#pragma warning(push, 0) #pragma warning(push, 0)
#include <algorithm> #include <algorithm>
#include <memory>
#include <sstream> #include <sstream>
#include <unordered_map> #include <unordered_map>

263
Sources/Plasma/PubUtilLib/plVault/plVaultNodeAccess.cpp
Unescape View File

@ -48,37 +48,6 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include "Pch.h" #include "Pch.h"
#pragma hdrstop #pragma hdrstop
//============================================================================
// Volatile Vault Node Fields - be very careful when adding to this
//============================================================================
struct NodeTypeToVolatileField {
unsigned nodeType;
uint64_t volatileFields;
};
NodeTypeToVolatileField volatileFieldList[] = {
{plVault::kNodeType_PlayerInfo, VaultPlayerInfoNode::kOnline | VaultPlayerInfoNode::kAgeInstName | VaultPlayerInfoNode::kAgeInstUuid},
{0, 0}
};
//============================================================================
uint64_t GetNodeVolatileFields(NetVaultNode* node) {
uint64_t volatileFields = 0;
unsigned index = 0;
while (volatileFieldList[index].nodeType != 0) {
if (node->GetNodeType() == volatileFieldList[index].nodeType) {
volatileFields |= volatileFieldList[index].volatileFields;
break;
}
++index;
}
return volatileFields;
}
/***************************************************************************** /*****************************************************************************
* *
* VaultTextNoteNode * VaultTextNoteNode
@ -99,170 +68,66 @@ enum EAgeInfoFields {
#ifdef CLIENT #ifdef CLIENT
void VaultTextNoteNode::SetVisitInfo (const plAgeInfoStruct & info) { void VaultTextNoteNode::SetVisitInfo (const plAgeInfoStruct & info) {
plStringStream str;
ARRAY(wchar_t) buf;
for (unsigned i = 0; i < kNumAgeInfoFields; ++i) { for (unsigned i = 0; i < kNumAgeInfoFields; ++i) {
switch (i) { switch (i) {
case kAgeFilename: { case kAgeFilename:
wchar_t src[128]; str << info.GetAgeFilename();
StrToUnicode(src, info.GetAgeFilename(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break; break;
case kAgeInstName:
case kAgeInstName: { str << info.GetAgeInstanceName();
wchar_t src[128];
StrToUnicode(src, info.GetAgeInstanceName(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break; break;
case kAgeUserName:
case kAgeUserName: { str << info.GetAgeUserDefinedName();
wchar_t src[128];
StrToUnicode(src, info.GetAgeUserDefinedName(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break; break;
case kAgeDesc:
case kAgeDesc: { str << info.GetAgeDescription();
wchar_t src[128];
StrToUnicode(src, info.GetAgeDescription(), arrsize(src));
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break; break;
case kAgeInstGuid:
case kAgeInstGuid: { str << info.GetAgeInstanceGuid()->AsString();
plUUID guid = *info.GetAgeInstanceGuid();
wchar_t src[64];
wcsncpy(src, guid.AsString().ToWchar(), 64);
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break; break;
case kAgeLanguage:
case kAgeLanguage: { str << info.GetAgeLanguage();
wchar_t src[32];
StrPrintf(src, arrsize(src), L"%u", info.GetAgeLanguage());
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break; break;
case kAgeSequence:
case kAgeSequence: { str << info.GetAgeSequenceNumber();
wchar_t src[32];
StrPrintf(src, arrsize(src), L"%u", info.GetAgeSequenceNumber());
unsigned len = StrLen(src);
wchar_t * dst = buf.New(len);
memcpy(dst, src, len * sizeof(src[0]));
}
break; break;
DEFAULT_FATAL(i); DEFAULT_FATAL(i);
} }
wchar_t * sep = buf.New(1); str << "|";
*sep = L'|';
} }
wchar_t * term = buf.New(1); SetNoteText(str.GetString());
*term = 0;
SetNoteText(buf.Ptr());
} }
#endif #endif
//============================================================================ //============================================================================
#ifdef CLIENT #ifdef CLIENT
bool VaultTextNoteNode::GetVisitInfo (plAgeInfoStruct * info) { bool VaultTextNoteNode::GetVisitInfo (plAgeInfoStruct * info) {
std::vector<plString> toks = GetNoteText().Split("|");
hsAssert(toks.size() == kNumAgeInfoFields, "visit text note malformed--discarding");
if (toks.size() != kNumAgeInfoFields)
return false;
wchar_t * mem; if (!toks[kAgeFilename].IsEmpty())
const wchar_t * str = mem = wcsdup(GetNoteText()); info->SetAgeFilename(toks[kAgeFilename]);
if (!toks[kAgeInstName].IsEmpty())
for (unsigned i = 0; i < kNumAgeInfoFields; ++i) { info->SetAgeInstanceName(toks[kAgeInstName]);
if (!toks[kAgeUserName].IsEmpty())
wchar_t token[1024]; info->SetAgeUserDefinedName(toks[kAgeUserName]);
switch (i) { if (!toks[kAgeDesc].IsEmpty())
case kAgeFilename: { info->SetAgeDescription(toks[kAgeDesc]);
StrTokenize(&str, token, arrsize(token), L"|", 1); if (!toks[kAgeInstGuid].IsEmpty()) {
if (StrLen(token) > 0) { std::unique_ptr<plUUID> guid = std::make_unique<plUUID>(toks[kAgeInstGuid]);
char ansi[1024]; info->SetAgeInstanceGuid(guid.get());
StrToAnsi(ansi, token, arrsize(ansi));
info->SetAgeFilename(ansi);
}
}
break;
case kAgeInstName: {
StrTokenize(&str, token, arrsize(token), L"|", 1);
if (StrLen(token) > 0) {
char ansi[1024];
StrToAnsi(ansi, token, arrsize(ansi));
info->SetAgeInstanceName(ansi);
}
}
break;
case kAgeUserName: {
StrTokenize(&str, token, arrsize(token), L"|", 1);
if (StrLen(token) > 0) {
char ansi[1024];
StrToAnsi(ansi, token, arrsize(ansi));
info->SetAgeUserDefinedName(ansi);
}
}
break;
case kAgeDesc: {
StrTokenize(&str, token, arrsize(token), L"|", 1);
if (StrLen(token) > 0) {
char ansi[1024];
StrToAnsi(ansi, token, arrsize(ansi));
info->SetAgeDescription(ansi);
}
}
break;
case kAgeInstGuid: {
StrTokenize(&str, token, arrsize(token), L"|", 1);
if (StrLen(token) > 0) {
plUUID uuid(plString::FromWchar(token));
info->SetAgeInstanceGuid(&uuid);
}
}
break;
case kAgeLanguage: {
StrTokenize(&str, token, arrsize(token), L"|", 1);
if (StrLen(token) > 0) {
info->SetAgeLanguage(StrToUnsigned(token, nil, 10));
}
}
break;
case kAgeSequence: {
StrTokenize(&str, token, arrsize(token), L"|", 1);
if (StrLen(token) > 0) {
info->SetAgeSequenceNumber(StrToUnsigned(token, nil, 10));
}
}
break;
DEFAULT_FATAL(i);
}
} }
if (!toks[kAgeLanguage].IsEmpty())
free(mem); info->SetAgeLanguage(toks[kAgeLanguage].ToUInt());
if (!toks[kAgeSequence].IsEmpty())
info->SetAgeSequenceNumber(toks[kAgeSequence].ToUInt());
return true; return true;
} }
#endif #endif
@ -327,7 +192,7 @@ void VaultSDLNode::SetStateDataRecord (const plStateDataRecord * rec, unsigned w
//============================================================================ //============================================================================
#ifdef CLIENT #ifdef CLIENT
void VaultSDLNode::InitStateDataRecord (const wchar_t sdlRecName[], unsigned writeOptions) { void VaultSDLNode::InitStateDataRecord (const plString& sdlRecName, unsigned writeOptions) {
{ {
plStateDataRecord * rec = new plStateDataRecord; plStateDataRecord * rec = new plStateDataRecord;
bool exists = GetStateDataRecord(rec, 0); bool exists = GetStateDataRecord(rec, 0);
@ -336,9 +201,7 @@ void VaultSDLNode::InitStateDataRecord (const wchar_t sdlRecName[], unsigned wri
return; return;
} }
char aStr[MAX_PATH]; if (plStateDescriptor * des = plSDLMgr::GetInstance()->FindDescriptor(sdlRecName, plSDL::kLatestVersion)) {
StrToAnsi(aStr, sdlRecName, arrsize(aStr));
if (plStateDescriptor * des = plSDLMgr::GetInstance()->FindDescriptor(aStr, plSDL::kLatestVersion)) {
plStateDataRecord rec(des); plStateDataRecord rec(des);
rec.SetFromDefaults(false); rec.SetFromDefaults(false);
SetStateDataRecord(&rec, writeOptions|plSDL::kDontWriteDirtyFlag); SetStateDataRecord(&rec, writeOptions|plSDL::kDontWriteDirtyFlag);
@ -555,44 +418,17 @@ const class plUnifiedTime * VaultAgeInfoNode::GetAgeTime () const {
//============================================================================ //============================================================================
#ifdef CLIENT #ifdef CLIENT
void VaultAgeInfoNode::CopyFrom (const plAgeInfoStruct * info) { void VaultAgeInfoNode::CopyFrom (const plAgeInfoStruct * info) {
wchar_t str[MAX_PATH];
// age filename // age filename
if (info->HasAgeFilename()) { SetAgeFilename(info->HasAgeFilename() ? info->GetAgeFilename() : "");
StrToUnicode(str, info->GetAgeFilename(), arrsize(str));
SetAgeFilename(str);
}
else {
SetAgeFilename(nil);
}
// age instance name // age instance name
if (info->HasAgeInstanceName()) { SetAgeInstanceName(info->HasAgeInstanceName() ? info->GetAgeInstanceName() : "");
StrToUnicode(str, info->GetAgeInstanceName(), arrsize(str));
SetAgeInstanceName(str);
}
else {
SetAgeInstanceName(nil);
}
// age user-defined name // age user-defined name
if (info->HasAgeUserDefinedName()) { SetAgeUserDefinedName(info->HasAgeUserDefinedName() ? info->GetAgeUserDefinedName() : "");
StrToUnicode(str, info->GetAgeUserDefinedName(), arrsize(str));
SetAgeUserDefinedName(str);
}
else {
SetAgeUserDefinedName(nil);
}
// age description // age description
// TODO SetAgeDescription(info->HasAgeDescription() ? info->GetAgeDescription() : "");
if (info->HasAgeDescription()) {
// StrToUnicode(str, info->GetAgeDescription(), arrsize(str));
// SetAgeDescription(str);
}
else {
// SetAgeDescription(nil);
}
// age sequence number // age sequence number
SetAgeSequenceNumber(info->GetAgeSequenceNumber()); SetAgeSequenceNumber(info->GetAgeSequenceNumber());
@ -608,22 +444,17 @@ void VaultAgeInfoNode::CopyFrom (const plAgeInfoStruct * info) {
//============================================================================ //============================================================================
#ifdef CLIENT #ifdef CLIENT
void VaultAgeInfoNode::CopyTo (plAgeInfoStruct * info) const { void VaultAgeInfoNode::CopyTo (plAgeInfoStruct * info) const {
char str[MAX_PATH];
// age filename // age filename
StrToAnsi(str, GetAgeFilename(), arrsize(str)); info->SetAgeFilename(GetAgeFilename());
info->SetAgeFilename(str);
// age instance name // age instance name
StrToAnsi(str, GetAgeInstanceName(), arrsize(str)); info->SetAgeInstanceName(GetAgeInstanceName());
info->SetAgeInstanceName(str);
// age user-defined name // age user-defined name
StrToAnsi(str, GetAgeUserDefinedName(), arrsize(str)); info->SetAgeUserDefinedName(GetAgeUserDefinedName());
info->SetAgeUserDefinedName(str);
// age description // age description
// TODO info->SetAgeDescription(GetAgeDescription());
// age sequence number // age sequence number
info->SetAgeSequenceNumber(GetAgeSequenceNumber()); info->SetAgeSequenceNumber(GetAgeSequenceNumber());

47
Sources/Plasma/PubUtilLib/plVault/plVaultNodeAccess.h
Unescape View File

@ -64,11 +64,6 @@ struct plSpawnPointInfo;
typedef std::vector<plSpawnPointInfo> plSpawnPointVec; typedef std::vector<plSpawnPointInfo> plSpawnPointVec;
#endif #endif
//============================================================================
// Volatile Vault Node Fields
//============================================================================
uint64_t GetNodeVolatileFields(NetVaultNode* node);
//============================================================================ //============================================================================
// NetVaultNodeAccess // NetVaultNodeAccess
//============================================================================ //============================================================================
@ -83,22 +78,24 @@ private:
}; };
#define VNODE_ACCESSOR(type, name, basename) \ #define VNODE_ACCESSOR(type, name, basename) \
static const uint64_t k##name = NetVaultNode::k##basename; \
type Get##name () const { return base->Get##basename(); } \ type Get##name () const { return base->Get##basename(); } \
void Set##name (type v) { base->Set##basename(v); } void Set##name (type v) { base->Set##basename(v); }
#define VNODE_BLOB(name, basename) \ #define VNODE_BLOB(name, basename) \
static const uint64_t k##name = NetVaultNode::k##basename; \
const uint8_t * Get##name () const { return base->Get##basename(); } \ const uint8_t * Get##name () const { return base->Get##basename(); } \
size_t Get##name##Length () const { return base->Get##basename##Length(); } \ size_t Get##name##Length () const { return base->Get##basename##Length(); } \
void Set##name (const uint8_t data[], size_t length) { base->Set##basename(data, length); } void Set##name (const uint8_t data[], size_t length) { base->Set##basename(data, length); }
#define VNODE_STRING(name, basename) \
plString Get##name () const { return base->Get##basename(); } \
void Set##name (const plString& v) { base->Set##basename(v); }
//============================================================================ //============================================================================
// VaultPlayerNode // VaultPlayerNode
//============================================================================ //============================================================================
struct VaultPlayerNode : NetVaultNodeAccess { struct VaultPlayerNode : NetVaultNodeAccess {
VNODE_ACCESSOR(const wchar_t *, PlayerName, IString64_1); VNODE_STRING ( PlayerName, IString64_1);
VNODE_ACCESSOR(const wchar_t *, AvatarShapeName, String64_1); VNODE_STRING ( AvatarShapeName, String64_1);
VNODE_ACCESSOR(int32_t, Disabled, Int32_1); VNODE_ACCESSOR(int32_t, Disabled, Int32_1);
VNODE_ACCESSOR(int32_t, Explorer, Int32_2); // explorer = 1, visitor = 0 VNODE_ACCESSOR(int32_t, Explorer, Int32_2); // explorer = 1, visitor = 0
VNODE_ACCESSOR(uint32_t, OnlineTime, UInt32_1); VNODE_ACCESSOR(uint32_t, OnlineTime, UInt32_1);
@ -114,8 +111,8 @@ struct VaultPlayerNode : NetVaultNodeAccess {
//============================================================================ //============================================================================
struct VaultPlayerInfoNode : NetVaultNodeAccess { struct VaultPlayerInfoNode : NetVaultNodeAccess {
VNODE_ACCESSOR(uint32_t, PlayerId, UInt32_1); VNODE_ACCESSOR(uint32_t, PlayerId, UInt32_1);
VNODE_ACCESSOR(const wchar_t *, PlayerName, IString64_1); VNODE_STRING ( PlayerName, IString64_1);
VNODE_ACCESSOR(const wchar_t *, AgeInstName, String64_1); // name of age player is currently in VNODE_STRING ( AgeInstName, String64_1); // name of age player is currently in
VNODE_ACCESSOR(plUUID, AgeInstUuid, Uuid_1); // guid of age player is currently in VNODE_ACCESSOR(plUUID, AgeInstUuid, Uuid_1); // guid of age player is currently in
VNODE_ACCESSOR(int32_t, Online, Int32_1); // whether or not player is online VNODE_ACCESSOR(int32_t, Online, Int32_1); // whether or not player is online
VNODE_ACCESSOR(int32_t, CCRLevel, Int32_2); VNODE_ACCESSOR(int32_t, CCRLevel, Int32_2);
@ -129,7 +126,7 @@ struct VaultPlayerInfoNode : NetVaultNodeAccess {
//============================================================================ //============================================================================
struct VaultFolderNode : NetVaultNodeAccess { struct VaultFolderNode : NetVaultNodeAccess {
VNODE_ACCESSOR(int32_t, FolderType, Int32_1); VNODE_ACCESSOR(int32_t, FolderType, Int32_1);
VNODE_ACCESSOR(const wchar_t *, FolderName, String64_1); VNODE_STRING ( FolderName, String64_1);
VaultFolderNode (NetVaultNode * node) : NetVaultNodeAccess(node) { } VaultFolderNode (NetVaultNode * node) : NetVaultNodeAccess(node) { }
}; };
@ -154,8 +151,8 @@ struct VaultAgeInfoListNode : VaultFolderNode {
//============================================================================ //============================================================================
struct VaultChronicleNode : NetVaultNodeAccess { struct VaultChronicleNode : NetVaultNodeAccess {
VNODE_ACCESSOR(int32_t, EntryType, Int32_1); VNODE_ACCESSOR(int32_t, EntryType, Int32_1);
VNODE_ACCESSOR(const wchar_t *, EntryName, String64_1); VNODE_STRING ( EntryName, String64_1);
VNODE_ACCESSOR(const wchar_t *, EntryValue, Text_1); VNODE_STRING ( EntryValue, Text_1);
VaultChronicleNode (NetVaultNode * node) : NetVaultNodeAccess(node) { } VaultChronicleNode (NetVaultNode * node) : NetVaultNodeAccess(node) { }
}; };
@ -165,7 +162,7 @@ struct VaultChronicleNode : NetVaultNodeAccess {
// VaultSDLNode // VaultSDLNode
//============================================================================ //============================================================================
struct VaultSDLNode : NetVaultNodeAccess { struct VaultSDLNode : NetVaultNodeAccess {
VNODE_ACCESSOR(const wchar_t *, SDLName, String64_1); VNODE_STRING ( SDLName, String64_1);
VNODE_ACCESSOR(int32_t, SDLIdent, Int32_1); VNODE_ACCESSOR(int32_t, SDLIdent, Int32_1);
VNODE_BLOB ( SDLData, Blob_1); VNODE_BLOB ( SDLData, Blob_1);
@ -174,7 +171,7 @@ struct VaultSDLNode : NetVaultNodeAccess {
#ifdef CLIENT #ifdef CLIENT
bool GetStateDataRecord (class plStateDataRecord * out, unsigned readOptions = 0); bool GetStateDataRecord (class plStateDataRecord * out, unsigned readOptions = 0);
void SetStateDataRecord (const class plStateDataRecord * rec, unsigned writeOptions = 0); void SetStateDataRecord (const class plStateDataRecord * rec, unsigned writeOptions = 0);
void InitStateDataRecord (const wchar_t sdlRecName[], unsigned writeOptions = 0); void InitStateDataRecord (const plString& sdlRecName, unsigned writeOptions = 0);
#endif // def CLIENT #endif // def CLIENT
}; };
@ -206,7 +203,7 @@ struct VaultImageNode : NetVaultNodeAccess {
enum ImageTypes { kNone=0, kJPEG=1, kPNG=2 }; enum ImageTypes { kNone=0, kJPEG=1, kPNG=2 };
VNODE_ACCESSOR(int32_t, ImageType, Int32_1); VNODE_ACCESSOR(int32_t, ImageType, Int32_1);
VNODE_ACCESSOR(const wchar_t *, ImageTitle, String64_1); VNODE_STRING ( ImageTitle, String64_1);
VNODE_BLOB ( ImageData, Blob_1); VNODE_BLOB ( ImageData, Blob_1);
VaultImageNode (NetVaultNode * node) : NetVaultNodeAccess(node) { } VaultImageNode (NetVaultNode * node) : NetVaultNodeAccess(node) { }
@ -234,8 +231,8 @@ struct VaultCliImageNode : VaultImageNode {
struct VaultTextNoteNode : NetVaultNodeAccess { struct VaultTextNoteNode : NetVaultNodeAccess {
VNODE_ACCESSOR(int32_t, NoteType, Int32_1); VNODE_ACCESSOR(int32_t, NoteType, Int32_1);
VNODE_ACCESSOR(int32_t, NoteSubType, Int32_2); VNODE_ACCESSOR(int32_t, NoteSubType, Int32_2);
VNODE_ACCESSOR(const wchar_t *, NoteTitle, String64_1); VNODE_STRING ( NoteTitle, String64_1);
VNODE_ACCESSOR(const wchar_t *, NoteText, Text_1); VNODE_STRING ( NoteText, Text_1);
VaultTextNoteNode (NetVaultNode * node) : NetVaultNodeAccess(node) { } VaultTextNoteNode (NetVaultNode * node) : NetVaultNodeAccess(node) { }
@ -252,7 +249,7 @@ struct VaultTextNoteNode : NetVaultNodeAccess {
struct VaultAgeNode : NetVaultNodeAccess { struct VaultAgeNode : NetVaultNodeAccess {
VNODE_ACCESSOR(plUUID, AgeInstanceGuid, Uuid_1); VNODE_ACCESSOR(plUUID, AgeInstanceGuid, Uuid_1);
VNODE_ACCESSOR(plUUID, ParentAgeInstanceGuid, Uuid_2); VNODE_ACCESSOR(plUUID, ParentAgeInstanceGuid, Uuid_2);
VNODE_ACCESSOR(const wchar_t *, AgeName, String64_1); VNODE_STRING ( AgeName, String64_1);
VaultAgeNode (NetVaultNode * node) : NetVaultNodeAccess(node) { } VaultAgeNode (NetVaultNode * node) : NetVaultNodeAccess(node) { }
}; };
@ -261,12 +258,12 @@ struct VaultAgeNode : NetVaultNodeAccess {
// VaultAgeInfoNode // VaultAgeInfoNode
//============================================================================ //============================================================================
struct VaultAgeInfoNode : NetVaultNodeAccess { struct VaultAgeInfoNode : NetVaultNodeAccess {
VNODE_ACCESSOR(const wchar_t *, AgeFilename, String64_2); // "Garden" VNODE_STRING ( AgeFilename, String64_2); // "Garden"
VNODE_ACCESSOR(const wchar_t *, AgeInstanceName, String64_3); // "Eder Kemo" VNODE_STRING ( AgeInstanceName, String64_3); // "Eder Kemo"
VNODE_ACCESSOR(const wchar_t *, AgeUserDefinedName, String64_4); // "Joe's" VNODE_STRING ( AgeUserDefinedName, String64_4); // "Joe's"
VNODE_ACCESSOR(plUUID, AgeInstanceGuid, Uuid_1); // 6278b081-342a-4229-ac1b-a0b8a2658390 VNODE_ACCESSOR(plUUID, AgeInstanceGuid, Uuid_1); // 6278b081-342a-4229-ac1b-a0b8a2658390
VNODE_ACCESSOR(plUUID, ParentAgeInstanceGuid, Uuid_2); // 9192be7f-89ef-41bc-83db-79afe451e399 VNODE_ACCESSOR(plUUID, ParentAgeInstanceGuid, Uuid_2); // 9192be7f-89ef-41bc-83db-79afe451e399
VNODE_ACCESSOR(const wchar_t *, AgeDescription, Text_1); // "Stay out!" VNODE_STRING ( AgeDescription, Text_1); // "Stay out!"
VNODE_ACCESSOR(int32_t, AgeSequenceNumber, Int32_1); VNODE_ACCESSOR(int32_t, AgeSequenceNumber, Int32_1);
VNODE_ACCESSOR(int32_t, AgeLanguage, Int32_3); // The language of the client that made this age VNODE_ACCESSOR(int32_t, AgeLanguage, Int32_3); // The language of the client that made this age
VNODE_ACCESSOR(uint32_t, AgeId, UInt32_1); VNODE_ACCESSOR(uint32_t, AgeId, UInt32_1);
@ -299,7 +296,7 @@ struct VaultSystemNode : NetVaultNodeAccess {
// VaultMarkerGameNode // VaultMarkerGameNode
//============================================================================ //============================================================================
struct VaultMarkerGameNode : NetVaultNodeAccess { struct VaultMarkerGameNode : NetVaultNodeAccess {
VNODE_ACCESSOR(const wchar_t *, GameName, Text_1); VNODE_STRING ( GameName, Text_1);
VNODE_ACCESSOR(plUUID, GameGuid, Uuid_1); VNODE_ACCESSOR(plUUID, GameGuid, Uuid_1);
VaultMarkerGameNode (NetVaultNode * node) : NetVaultNodeAccess(node) { } VaultMarkerGameNode (NetVaultNode * node) : NetVaultNodeAccess(node) { }

Write Preview
Loading…
Cancel
Save