PyObject * pyVaultNodeRef::GetSaver () { if (!fParent || !fChild) return 0; RelVaultNode * saver = nil; if (RelVaultNode * child = VaultGetNodeIncRef(fChild->GetNodeId())) { if (unsigned saverId = child->GetRefOwnerId(fParent->GetNodeId())) { // Find the player info node representing the saver NetVaultNode * templateNode = new NetVaultNode; templateNode->IncRef(); templateNode->SetNodeType(plVault::kNodeType_PlayerInfo); VaultPlayerInfoNode access(templateNode); access.SetPlayerId(saverId); saver = VaultGetNodeIncRef(templateNode); if (!saver) { ARRAY(unsigned) nodeIds; VaultFindNodesAndWait(templateNode, &nodeIds); if (nodeIds.Count() > 0) { VaultFetchNodesAndWait(nodeIds.Ptr(), nodeIds.Count()); saver = VaultGetNodeIncRef(nodeIds[0]); } } templateNode->DecRef(); } child->DecRef(); } if (!saver) PYTHON_RETURN_NONE; PyObject * result = pyVaultPlayerInfoNode::New(saver); saver->DecRef(); return result; }
PyObject* pyVaultNode::AddNode(pyVaultNode* pynode, PyObject* cbObject, uint32_t cbContext) { pyVaultNodeOperationCallback * cb = new pyVaultNodeOperationCallback(cbObject); if ( fNode && pynode && pynode->GetNode() ) { // Hack the callbacks until vault notification is in place cb->VaultOperationStarted(cbContext); int hsResult = hsOK; if ( !pynode->GetID() ) { // Block here until node is created and fetched =( ASSERT(pynode->GetNode()->GetNodeType()); ENetError result; RelVaultNode * newNode = VaultCreateNodeAndWaitIncRef( pynode->GetNode(), &result ); if (newNode) { newNode->Ref(); pynode->fNode->UnRef(); pynode->fNode = newNode; } else { hsResult = hsFail; } } PyObject* nodeRef = cb->fPyNodeRef = pyVaultNodeRef::New(fNode, pynode->fNode); Py_INCREF(nodeRef); // The callback steals the ref, according to Eric... cb->SetNode(pynode->fNode); VaultAddChildNode(fNode->GetNodeId(), pynode->fNode->GetNodeId(), NetCommGetPlayer()->playerInt, (FVaultAddChildNodeCallback)_AddNodeCallback, cb ); // Evil undocumented functionality that some fool // decided to use in xKI.py. Really??? return nodeRef; } else { // manually make the callback cb->VaultOperationStarted( cbContext ); cb->VaultOperationComplete(hsFail); } // just return a None object PYTHON_RETURN_NONE; }
plUUID pyAgeVault::GetAgeGuid( void ) { RelVaultNode * rvn = VaultGetAgeInfoNodeIncRef(); if (rvn) { VaultAgeInfoNode ageInfo(rvn); plUUID uuid = ageInfo.GetAgeInstanceGuid(); rvn->UnRef(); return uuid; } return kNilUuid; }
// override the equals to operator bool pyVaultNode::operator==(const pyVaultNode &vaultNode) const { RelVaultNode* ours = GetNode(); RelVaultNode* theirs = vaultNode.GetNode(); if (ours == nil && theirs == nil) return true; if (ours == nil || theirs == nil) return false; if (ours->GetNodeId() == theirs->GetNodeId()) return true; return ours->Matches(theirs); }
PyObject* pyAgeVault::GetAgeDevicesFolder( void ) { RelVaultNode * rvn = VaultGetAgeDevicesFolderIncRef(); if (rvn) { PyObject * result = pyVaultFolderNode::New(rvn); rvn->UnRef(); return result; } // just return a None object PYTHON_RETURN_NONE; }
PyObject* pyAgeVault::GetAgeInfo() { RelVaultNode * rvn = VaultGetAgeInfoNodeIncRef(); if (rvn) { PyObject * result = pyVaultAgeInfoNode::New(rvn); rvn->UnRef(); return result; } // just return a None object PYTHON_RETURN_NONE; }
PyObject* pyAgeVault::GetSubAgeLink( const pyAgeInfoStruct & info ) { RelVaultNode * rvn = VaultFindAgeSubAgeLinkIncRef(info.GetAgeInfo()); if (rvn) { PyObject * result = pyVaultAgeLinkNode::New(rvn); rvn->UnRef(); return result; } // just return a None object PYTHON_RETURN_NONE; }
PyObject* pyAgeVault::GetPeopleIKnowAboutFolder( void ) { RelVaultNode * rvn = VaultGetAgePeopleIKnowAboutFolderIncRef(); if (rvn) { PyObject * result = pyVaultFolderNode::New(rvn); rvn->DecRef(); return result; } // just return a None object PYTHON_RETURN_NONE; }
const char* pyAgeVault::GetAgeGuid( void ) { RelVaultNode * rvn = VaultGetAgeInfoNodeIncRef(); if (rvn) { VaultAgeInfoNode ageInfo(rvn); GuidToString(ageInfo.ageInstUuid, fAgeGuid, arrsize(fAgeGuid)); rvn->DecRef(); } else { fAgeGuid[0] = 0; } return fAgeGuid; }
PyObject* pyAgeVault::FindNode( pyVaultNode* templateNode ) const { if (RelVaultNode * rvn = VaultGetAgeNodeIncRef()) { RelVaultNode * find = rvn->GetChildNodeIncRef(templateNode->fNode, 1); rvn->UnRef(); if (find) { PyObject * result = pyVaultNode::New(find); find->UnRef(); return result; } } PYTHON_RETURN_NONE; }
//================================================================== // class RelVaultNode : public plVaultFolderNode // bool pyVaultPlayerInfoListNode::HasPlayer( uint32_t playerID ) { if (!fNode) return false; NetVaultNode * templateNode = NEWZERO(NetVaultNode); templateNode->IncRef(); templateNode->SetNodeType(plVault::kNodeType_PlayerInfo); VaultPlayerInfoNode access(templateNode); access.SetPlayerId(playerID); RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1); if (rvn) rvn->DecRef(); templateNode->DecRef(); return (rvn != nil); }
PyObject * pyVaultNode::GetNode2( uint32_t nodeID ) const { PyObject * result = nil; if ( fNode ) { RelVaultNode * templateNode = new RelVaultNode; templateNode->Ref(); templateNode->SetNodeId(nodeID); if (RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1)) { result = pyVaultNodeRef::New(fNode, rvn); rvn->UnRef(); } templateNode->UnRef(); } if (result) return result; PYTHON_RETURN_NONE; }
bool plNetLinkingMgr::IProcessVaultNotifyMsg(plVaultNotifyMsg* msg) { // No deferred link? Bye bye. if (fDeferredLink == nil) return false; plAgeLinkStruct* cur = GetAgeLink(); RelVaultNode* cVaultLink = nil; switch (msg->GetType()) { case plVaultNotifyMsg::kRegisteredChildAgeLink: case plVaultNotifyMsg::kRegisteredOwnedAge: case plVaultNotifyMsg::kRegisteredSubAgeLink: cVaultLink = VaultGetNodeIncRef(msg->GetArgs()->GetInt(plNetCommon::VaultTaskArgs::kAgeLinkNode)); break; default: return false; } if (cVaultLink != nil) { // This is something that Cyan does... >.< // It's very useful though... VaultAgeLinkNode accLink(cVaultLink); accLink.CopyTo(cur); if (RelVaultNode* rvnInfo = cVaultLink->GetChildNodeIncRef(plVault::kNodeType_AgeInfo, 1)) { VaultAgeInfoNode accInfo(rvnInfo); accInfo.CopyTo(cur->GetAgeInfo()); rvnInfo->DecRef(); } IDoLink(fDeferredLink); fDeferredLink = nil; return true; cVaultLink->DecRef(); } return false; }
PyObject* pyVaultNode::GetCreatorNode( void ) { PyObject * result = nil; if (fNode) { RelVaultNode * templateNode = new RelVaultNode; templateNode->Ref(); templateNode->SetNodeType(plVault::kNodeType_PlayerInfo); VaultPlayerInfoNode plrInfo(templateNode); plrInfo.SetPlayerId(fNode->GetCreatorId()); if (RelVaultNode * rvn = VaultGetNodeIncRef(templateNode)) { result = pyVaultPlayerInfoNode::New(rvn); rvn->UnRef(); } templateNode->UnRef(); } if (result) return result; // just return a None object PYTHON_RETURN_NONE; }
PyObject * pyVaultNode::GetChildNode (unsigned nodeId) { if (!fNode) PYTHON_RETURN_NONE; RelVaultNode * templateNode = new RelVaultNode; templateNode->Ref(); templateNode->SetNodeId(nodeId); RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1); templateNode->UnRef(); if (rvn) { PyObject * result = pyVaultNode::New(rvn); rvn->UnRef(); return result; } PYTHON_RETURN_NONE; }
void plNetLinkingMgr::IPostProcessLink( void ) { // Grab some useful things... plAgeLinkStruct* link = GetAgeLink(); plAgeInfoStruct* info = link->GetAgeInfo(); bool city = (info->GetAgeFilename().CompareI(kCityAgeFilename) == 0); bool hood = (info->GetAgeFilename().CompareI(kNeighborhoodAgeFilename) == 0); bool psnl = (info->GetAgeFilename().CompareI(kPersonalAgeFilename) == 0); // Update our online status if (RelVaultNode* rvnInfo = VaultGetPlayerInfoNodeIncRef()) { VaultPlayerInfoNode accInfo(rvnInfo); wchar_t ageInstName[MAX_PATH]; plUUID ageInstGuid = *info->GetAgeInstanceGuid(); StrToUnicode(ageInstName, info->GetAgeInstanceName(), arrsize(ageInstName)); accInfo.SetAgeInstName(ageInstName); accInfo.SetAgeInstUuid(ageInstGuid); accInfo.SetOnline(true); rvnInfo->DecRef(); } switch (link->GetLinkingRules()) { case plNetCommon::LinkingRules::kOwnedBook: { // SPECIAL CASE: City: Every player ever created would be in the list; avoid that. if (city) break; { // Ensure we're in the AgeOwners folder RelVaultNode* fldr = VaultGetAgeAgeOwnersFolderIncRef(); RelVaultNode* info = VaultGetPlayerInfoNodeIncRef(); if (fldr && info) if (!fldr->IsParentOf(info->GetNodeId(), 1)) VaultAddChildNode( fldr->GetNodeId(), info->GetNodeId(), NetCommGetPlayer()->playerInt, nil, nil ); if (fldr) fldr->DecRef(); if (info) info->DecRef(); } } break; case plNetCommon::LinkingRules::kVisitBook: { // SPECIAL CASE: City: Every player ever created would be in the list; avoid that. if (city) break; { // Ensure we're in the CanVisit folder RelVaultNode* fldr = VaultGetAgeCanVisitFolderIncRef(); RelVaultNode* info = VaultGetPlayerInfoNodeIncRef(); if (fldr && info) if (!fldr->IsParentOf(info->GetNodeId(), 1)) VaultAddChildNode( fldr->GetNodeId(), info->GetNodeId(), NetCommGetPlayer()->playerInt, nil, nil ); if (fldr) fldr->DecRef(); if (info) info->DecRef(); } } break; case plNetCommon::LinkingRules::kSubAgeBook: { // Register the previous age as a sub age of the current one so that we can link back to that instance plAgeLinkStruct subAgeLink; VaultAgeFindOrCreateSubAgeLink(GetPrevAgeLink()->GetAgeInfo(), &subAgeLink, NetCommGetAge()->ageInstId); } break; } }
// finds the stats for the players vault // ...such as how many pictures, notes and markers they have PyObject* pyVault::GetKIUsage(void) { uint32_t pictures = 0; uint32_t notes = 0; uint32_t markerGames = 0; for (;;) { RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef(); if (!rvnPlr) break; for (;;) { RelVaultNode * rvnAgeJrnlz = rvnPlr->GetChildFolderNodeIncRef(plVault::kAgeJournalsFolder, 1); if (!rvnAgeJrnlz) break; // Get child nodes up to two levels deep ARRAY(RelVaultNode*) nodeArr; rvnAgeJrnlz->GetChildNodesIncRef(2, &nodeArr); RelVaultNode ** cur = nodeArr.Ptr(); RelVaultNode ** end = nodeArr.Term(); for (; cur != end; ++cur) { RelVaultNode * rvn = *cur; if (rvn->GetNodeType() == plVault::kNodeType_Image) ++pictures; else if (rvn->GetNodeType() == plVault::kNodeType_TextNote) ++notes; else if (rvn->GetNodeType() == plVault::kNodeType_MarkerGame) ++markerGames; rvn->DecRef(); } rvnAgeJrnlz->DecRef(); break; } rvnPlr->DecRef(); break; } // create the tuple of usage numbers PyObject* retVal = PyTuple_New(4); PyTuple_SetItem(retVal, 0, PyLong_FromUnsignedLong(pictures)); PyTuple_SetItem(retVal, 1, PyLong_FromUnsignedLong(notes)); PyTuple_SetItem(retVal, 2, PyLong_FromUnsignedLong(markerGames)); return retVal; }