You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

695 lines
18 KiB

/*==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==*/
//////////////////////////////////////////////////////////////////////
//
// pyVault - a wrapper class to provide interface to the plVault
//
//////////////////////////////////////////////////////////////////////
#ifdef BUILDING_PYPLASMA
# error "pyVault is not compatible with pyPlasma.pyd. Use BUILDING_PYPLASMA macro to ifdef out unwanted headers."
#endif
#include "pyVault.h"
#include "pyVaultNode.h"
#include "pyVaultAgeInfoNode.h"
#include "pyVaultAgeInfoListNode.h"
#include "pyVaultAgeLinkNode.h"
#include "pyVaultFolderNode.h"
#include "pyVaultPlayerInfoListNode.h"
#include "pyVaultPlayerInfoNode.h"
#include "pyVaultChronicleNode.h"
#include "pyVaultTextNoteNode.h"
#include "pyNetLinkingMgr.h"
#include "pyAgeInfoStruct.h"
#include "pyAgeLinkStruct.h"
#include "pySDL.h"
#include "../pnKeyedObject/plKey.h"
#include "cyPythonInterface.h"
#include "../plVault/plVault.h"
#include "../pnNetCommon/plNetApp.h"
#include "../plNetClient/plNetClientMgr.h"
#include "../plNetClient/plNetLinkingMgr.h"
#include "../plNetClientComm/plNetClientComm.h"
#include "../plMessage/plVaultNotifyMsg.h"
#include "../plSDL/plSDL.h"
//============================================================================
static PyObject * GetFolder (unsigned folderType) {
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnFldr = rvnPlr->GetChildFolderNodeIncRef(folderType, 1)) {
result = pyVaultFolderNode::New(rvnFldr);
rvnFldr->DecRef();
}
rvnPlr->DecRef();
}
return result;
}
//============================================================================
static PyObject * GetPlayerInfoList (unsigned folderType) {
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnFldr = rvnPlr->GetChildPlayerInfoListNodeIncRef(folderType, 1)) {
result = pyVaultPlayerInfoListNode::New(rvnFldr);
rvnFldr->DecRef();
}
rvnPlr->DecRef();
}
return result;
}
//============================================================================
static PyObject * GetAgeInfoList (unsigned folderType) {
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnFldr = rvnPlr->GetChildAgeInfoListNodeIncRef(folderType, 1)) {
result = pyVaultAgeInfoListNode::New(rvnFldr);
rvnFldr->DecRef();
}
rvnPlr->DecRef();
}
return result;
}
//////////////////////////////////////////////////
PyObject* pyVault::GetPlayerInfo( void )
{
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnPlrInfo = rvnPlr->GetChildNodeIncRef(plVault::kNodeType_PlayerInfo, 1)) {
result = pyVaultPlayerInfoNode::New(rvnPlrInfo);
rvnPlrInfo->DecRef();
}
rvnPlr->DecRef();
}
// just return an empty node
if (!result)
result = pyVaultPlayerInfoNode::New(nil);
return result;
}
PyObject* pyVault::GetAvatarOutfitFolder( void )
{
PyObject * result = GetFolder(plVault::kAvatarOutfitFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetAvatarClosetFolder( void )
{
PyObject * result = GetFolder(plVault::kAvatarClosetFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetChronicleFolder( void )
{
PyObject * result = GetFolder(plVault::kChronicleFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetInbox( void )
{
PyObject * result = GetFolder(plVault::kInboxFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetAgeJournalsFolder( void )
{
PyObject * result = GetFolder(plVault::kAgeJournalsFolder);
// just return an empty node
if (!result)
result = pyVaultFolderNode::New(nil);
return result;
}
// finds the stats for the players vault
// ...such as how many pictures, notes and markers they have
PyObject* pyVault::GetKIUsage(void)
{
UInt32 pictures = 0;
UInt32 notes = 0;
UInt32 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->nodeType == plVault::kNodeType_Image)
++pictures;
else if (rvn->nodeType == plVault::kNodeType_TextNote)
++notes;
else if (rvn->nodeType == 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;
}
PyObject* pyVault::GetIgnoreListFolder( void )
{
PyObject * result = GetPlayerInfoList(plVault::kIgnoreListFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetBuddyListFolder( void )
{
PyObject * result = GetPlayerInfoList(plVault::kBuddyListFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetPeopleIKnowAboutFolder( void )
{
PyObject * result = GetPlayerInfoList(plVault::kPeopleIKnowAboutFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
/////////
PyObject* pyVault::GetLinkToMyNeighborhood() const
{
plAgeInfoStruct info;
info.SetAgeFilename(kNeighborhoodAgeFilename);
if (RelVaultNode * rvn = VaultGetOwnedAgeLinkIncRef(&info)) {
PyObject * result = pyVaultAgeLinkNode::New(rvn);
rvn->DecRef();
return result;
}
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetLinkToCity() const
{
plAgeInfoStruct info;
info.SetAgeFilename(kCityAgeFilename);
if (RelVaultNode * rvn = VaultGetOwnedAgeLinkIncRef(&info)) {
PyObject * result = pyVaultAgeLinkNode::New(rvn);
rvn->DecRef();
return result;
}
PYTHON_RETURN_NONE;
}
// Owned ages
PyObject* pyVault::GetOwnedAgeLink( const pyAgeInfoStruct & info )
{
if (RelVaultNode * rvnLink = VaultGetOwnedAgeLinkIncRef(info.GetAgeInfo())) {
PyObject * result = pyVaultAgeLinkNode::New(rvnLink);
rvnLink->DecRef();
return result;
}
// just return a None object
PYTHON_RETURN_NONE;
}
// Visit ages
PyObject* pyVault::GetVisitAgeLink( const pyAgeInfoStruct & info)
{
if (RelVaultNode * rvnLink = VaultGetVisitAgeLinkIncRef(info.GetAgeInfo())) {
PyObject * result = pyVaultAgeLinkNode::New(rvnLink);
rvnLink->DecRef();
return result;
}
// just return a None object
PYTHON_RETURN_NONE;
}
///////////////
// Chronicle
PyObject* pyVault::FindChronicleEntry( const char * entryName )
{
wchar wEntryName[kMaxVaultNodeStringLength];
StrToUnicode(wEntryName, entryName, arrsize(wEntryName));
if (RelVaultNode * rvn = VaultFindChronicleEntryIncRef(wEntryName)) {
PyObject * result = pyVaultChronicleNode::New(rvn);
rvn->DecRef();
return result;
}
// just return a None object
PYTHON_RETURN_NONE;
}
void pyVault::AddChronicleEntry( const char * name, UInt32 type, const char * value )
{
wchar * wEntryName = StrDupToUnicode(name);
wchar * wEntryValue = StrDupToUnicode(value);
VaultAddChronicleEntryAndWait(wEntryName, type, wEntryValue);
FREE(wEntryName);
FREE(wEntryValue);
}
void pyVault::SendToDevice( pyVaultNode& node, const char * deviceName )
{
if (!node.GetNode())
return;
wchar wDevName[256];
StrToUnicode(wDevName, deviceName, arrsize(wDevName));
VaultPublishNode(node.GetNode()->nodeId, wDevName);
}
PyObject* pyVault::GetAgesICanVisitFolder(void)
{
PyObject * result = GetAgeInfoList(plVault::kAgesICanVisitFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetAgesIOwnFolder(void)
{
PyObject * result = GetAgeInfoList(plVault::kAgesIOwnFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetInviteFolder(void)
{
PyObject * result = GetFolder(plVault::kPlayerInviteFolder);
// if good then return py object
if (result)
return result;
// otherwise return a None object
PYTHON_RETURN_NONE;
}
PyObject* pyVault::GetPsnlAgeSDL() const
{
PyObject * result = nil;
NetVaultNode * templateNode = NEWZERO(NetVaultNode);
templateNode->IncRef();
if (RelVaultNode * rvnFldr = VaultGetAgesIOwnFolderIncRef()) {
templateNode->fieldFlags = 0;
templateNode->SetNodeType(plVault::kNodeType_AgeInfo);
VaultAgeInfoNode ageInfo(templateNode);
wchar str[MAX_PATH];
StrToUnicode(str, kPersonalAgeFilename, arrsize(str));
ageInfo.SetAgeFilename(str);
if (RelVaultNode * rvnInfo = rvnFldr->GetChildNodeIncRef(templateNode, 2)) {
templateNode->fieldFlags = 0;
templateNode->SetNodeType(plVault::kNodeType_SDL);
if (RelVaultNode * rvnSdl = rvnInfo->GetChildNodeIncRef(templateNode, 1)) {
VaultSDLNode sdl(rvnSdl);
plStateDataRecord * rec = NEWZERO(plStateDataRecord);
if (sdl.GetStateDataRecord(rec, plSDL::kKeepDirty))
result = pySDLStateDataRecord::New(rec);
else
DEL(rec);
rvnSdl->DecRef();
}
rvnInfo->DecRef();
}
rvnFldr->DecRef();
}
templateNode->DecRef();
if (!result)
PYTHON_RETURN_NONE;
return result;
}
void pyVault::UpdatePsnlAgeSDL( pySDLStateDataRecord & pyrec )
{
plStateDataRecord * rec = pyrec.GetRec();
if ( !rec )
return;
NetVaultNode * templateNode = NEWZERO(NetVaultNode);
templateNode->IncRef();
if (RelVaultNode * rvnFldr = VaultGetAgesIOwnFolderIncRef()) {
templateNode->fieldFlags = 0;
templateNode->SetNodeType(plVault::kNodeType_AgeInfo);
VaultAgeInfoNode ageInfo(templateNode);
wchar str[MAX_PATH];
StrToUnicode(str, kPersonalAgeFilename, arrsize(str));
ageInfo.SetAgeFilename(str);
if (RelVaultNode * rvnInfo = rvnFldr->GetChildNodeIncRef(templateNode, 2)) {
templateNode->fieldFlags = 0;
templateNode->SetNodeType(plVault::kNodeType_SDL);
if (RelVaultNode * rvnSdl = rvnInfo->GetChildNodeIncRef(templateNode, 1)) {
VaultSDLNode sdl(rvnSdl);
sdl.SetStateDataRecord(rec, plSDL::kDirtyOnly | plSDL::kTimeStampOnRead);
rvnSdl->DecRef();
}
rvnInfo->DecRef();
}
rvnFldr->DecRef();
}
templateNode->DecRef();
}
bool pyVault::InMyPersonalAge( void ) const
{
return VaultAmInMyPersonalAge();
}
bool pyVault::InMyNeighborhoodAge( void ) const
{
return VaultAmInMyNeighborhoodAge();
}
bool pyVault::AmOwnerOfCurrentAge() const
{
return VaultAmOwnerOfCurrentAge();
}
bool pyVault::AmCzarOfCurrentAge() const
{
return VaultAmCzarOfCurrentAge();
}
bool pyVault::AmAgeOwner( const pyAgeInfoStruct * ageInfo )
{
if (!ageInfo->GetAgeInfo())
return false;
Uuid ageInstId = *ageInfo->GetAgeInfo()->GetAgeInstanceGuid();
return VaultAmOwnerOfAge(ageInstId);
}
bool pyVault::AmAgeCzar( const pyAgeInfoStruct * ageInfo )
{
if (!ageInfo->GetAgeInfo())
return false;
Uuid ageInstId = *ageInfo->GetAgeInfo()->GetAgeInstanceGuid();
return VaultAmCzarOfAge(ageInstId);
}
void pyVault::RegisterMTStation( const char * stationName, const char * backLinkSpawnPtObjName )
{
wchar wStationName[256];
wchar wSpawnPt[256];
StrToUnicode(wStationName, stationName, arrsize(wStationName));
StrToUnicode(wSpawnPt, backLinkSpawnPtObjName, arrsize(wSpawnPt));
VaultRegisterMTStationAndWait( wStationName, wSpawnPt);
}
void pyVault::RegisterOwnedAge( const pyAgeLinkStruct & link )
{
VaultRegisterOwnedAgeAndWait(link.GetAgeLink());
}
void pyVault::UnRegisterOwnedAge( const char * ageFilename )
{
plAgeInfoStruct info;
info.SetAgeFilename(ageFilename);
VaultUnregisterOwnedAgeAndWait(&info);
}
void pyVault::RegisterVisitAge( const pyAgeLinkStruct & link )
{
VaultRegisterVisitAgeAndWait(link.GetAgeLink());
}
void pyVault::UnRegisterVisitAge( const char * guidstr )
{
Uuid uuid;
GuidFromString(guidstr, &uuid);
plAgeInfoStruct info;
info.SetAgeInstanceGuid(&plUUID(uuid));
VaultUnregisterVisitAgeAndWait(&info);
}
void pyVault::InvitePlayerToAge( const pyAgeLinkStruct & link, UInt32 playerID )
{
ENetError error;
NetVaultNode * templateNode = NEWZERO(NetVaultNode);
templateNode->IncRef();
templateNode->SetNodeType(plVault::kNodeType_TextNote);
VaultTextNoteNode visitAcc(templateNode);
visitAcc.SetNoteType(plVault::kNoteType_Visit);
visitAcc.SetVisitInfo(*link.GetAgeLink()->GetAgeInfo());
if (RelVaultNode * rvn = VaultCreateNodeAndWaitIncRef(templateNode, &error)) {
VaultSendNode(rvn, playerID);
rvn->DecRef();
}
templateNode->DecRef();
}
void pyVault::UnInvitePlayerToAge( const char * str, UInt32 playerID )
{
plAgeInfoStruct info;
info.SetAgeInstanceGuid(&plUUID(str));
if (RelVaultNode * rvnLink = VaultGetOwnedAgeLinkIncRef(&info)) {
if (RelVaultNode * rvnInfo = rvnLink->GetChildNodeIncRef(plVault::kNodeType_AgeInfo, 1)) {
VaultAgeInfoNode ageInfo(rvnInfo);
ageInfo.CopyTo(&info);
rvnInfo->DecRef();
}
rvnLink->DecRef();
}
ENetError error;
NetVaultNode * templateNode = NEWZERO(NetVaultNode);
templateNode->IncRef();
templateNode->SetNodeType(plVault::kNodeType_TextNote);
VaultTextNoteNode visitAcc(templateNode);
visitAcc.SetNoteType(plVault::kNoteType_UnVisit);
visitAcc.SetVisitInfo(info);
if (RelVaultNode * rvn = VaultCreateNodeAndWaitIncRef(templateNode, &error)) {
VaultSendNode(rvn, playerID);
rvn->DecRef();
}
templateNode->DecRef();
}
void pyVault::OfferLinkToPlayer( const pyAgeLinkStruct & link, UInt32 playerID )
{
hsAssert(false, "eric, port me");
}
void pyVault::CreateNeighborhood()
{
plNetClientMgr * nc = plNetClientMgr::GetInstance();
// Unregister old hood
plAgeInfoStruct info;
info.SetAgeFilename(kNeighborhoodAgeFilename);
VaultUnregisterOwnedAgeAndWait(&info);
// Register new hood
plAgeLinkStruct link;
link.GetAgeInfo()->SetAgeFilename(kNeighborhoodAgeFilename);
link.GetAgeInfo()->SetAgeInstanceName(kNeighborhoodAgeInstanceName);
std::string title;
std::string desc;
unsigned nameLen = StrLen(nc->GetPlayerName());
if (nc->GetPlayerName()[nameLen - 1] == 's' || nc->GetPlayerName()[nameLen - 1] == 'S')
{
xtl::format( title, "%s'", nc->GetPlayerName() );
xtl::format( desc, "%s' %s", nc->GetPlayerName(), link.GetAgeInfo()->GetAgeInstanceName() );
}
else
{
xtl::format( title, "%s's", nc->GetPlayerName() );
xtl::format( desc, "%s's %s", nc->GetPlayerName(), link.GetAgeInfo()->GetAgeInstanceName() );
}
link.GetAgeInfo()->SetAgeInstanceGuid(&plUUID(GuidGenerate()));
link.GetAgeInfo()->SetAgeUserDefinedName( title.c_str() );
link.GetAgeInfo()->SetAgeDescription( desc.c_str() );
VaultRegisterOwnedAgeAndWait(&link);
}
bool pyVault::SetAgePublic( const pyAgeInfoStruct * ageInfo, bool makePublic )
{
return VaultSetOwnedAgePublicAndWait(ageInfo->GetAgeInfo(), makePublic);
}
PyObject* pyVault::GetGlobalInbox( void )
{
PyObject * result = nil;
if (RelVaultNode * rvnGlobalInbox = VaultGetGlobalInboxIncRef()) {
result = pyVaultFolderNode::New(rvnGlobalInbox);
rvnGlobalInbox->DecRef();
return result;
}
PYTHON_RETURN_NONE;
}
/////////////////////////////////////////////////////////////
PyObject* pyVault::FindNode( pyVaultNode* templateNode ) const
{
// See if we already have a matching node locally
if (RelVaultNode * rvn = VaultGetNodeIncRef(templateNode->GetNode())) {
PyObject * result = pyVaultNode::New(rvn);
rvn->DecRef();
return result;
}
// See if a matching node exists on the server
ARRAY(unsigned) nodeIds;
VaultFindNodesAndWait(templateNode->GetNode(), &nodeIds);
if (nodeIds.Count()) {
// Only fetch the first matching node since this function returns a single node
VaultFetchNodesAndWait(&nodeIds[0], 1);
// If we fetched it successfully then it'll be in our local node cache now
if (RelVaultNode * rvn = VaultGetNodeIncRef(nodeIds[0])) {
PyObject * result = pyVaultNode::New(rvn);
rvn->DecRef();
return result;
}
}
PYTHON_RETURN_NONE;
}