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.
503 lines
15 KiB
503 lines
15 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/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
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 "pyVNodeMgr.h" |
|
#include "../plVault/plVaultCallback.h" |
|
#include "../plVault/plVaultInitTasks.h" |
|
#include "../pfPython/pyVaultNode.h" |
|
#include "../pfPython/pyVaultFolderNode.h" |
|
#include "../pyNetClientComm/pyNetClientComm.h" |
|
#include "../plNetMessage/plNetMessage.h" |
|
#include "../plStatusLog/plStatusLog.h" |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
class pyVaultOperationCallback : public plVaultOperationCallback |
|
{ |
|
public: |
|
PyObject * fPyObject; |
|
pyVaultOperationCallback( PyObject * pyObject ) |
|
: fPyObject( pyObject ) |
|
{ |
|
Py_XINCREF( fPyObject ); |
|
} |
|
~pyVaultOperationCallback() |
|
{ |
|
Py_XDECREF( fPyObject ); |
|
} |
|
void VaultOperationStarted( UInt32 context ) |
|
{ |
|
if ( fPyObject ) |
|
{ |
|
// Do callback |
|
PyObject* func = PyObject_GetAttrString( fPyObject, "operationStarted" ); |
|
if ( func ) |
|
{ |
|
if ( PyCallable_Check(func)>0 ) |
|
{ |
|
PyObject* retVal = PyObject_CallMethod(fPyObject, "operationStarted", "l", context); |
|
Py_XDECREF(retVal); |
|
} |
|
} |
|
} |
|
} |
|
void VaultOperationComplete( UInt32 context, int resultCode ) |
|
{ |
|
if ( fPyObject ) |
|
{ |
|
// Pass args. |
|
// PyObject* pyArgs = PyObject_GetAttrString( fPyObject, "fCbArgs" ); |
|
// if ( pyArgs ) |
|
// { |
|
// dict pyDict = dict(); |
|
// std::map<UInt16,plCreatable*> args; |
|
// fCbArgs.GetItems( args ); |
|
// for ( std::map<UInt16,plCreatable*>::iterator ii=args.begin(); ii!=args.end(); ++ii ) |
|
// { |
|
// UInt16 key = ii->first; |
|
// plCreatable* arg = ii->second; |
|
// plCreatableGenericValue * genValue = plCreatableGenericValue::ConvertNoRef( arg ); |
|
// if ( genValue ) |
|
// { |
|
// plGenericType & value = genValue->Value(); |
|
// switch ( value.GetType() ) |
|
// { |
|
// case plGenericType::kInt: |
|
// pyDict[key] = (int)value; |
|
// break; |
|
// case plGenericType::kUInt: |
|
// pyDict[key] = (unsigned int)value; |
|
// break; |
|
// case plGenericType::kFloat: |
|
// pyDict[key] = (float)value; |
|
// break; |
|
// case plGenericType::kDouble: |
|
// pyDict[key] = (double)value; |
|
// break; |
|
// case plGenericType::kBool: |
|
// pyDict[key] = (bool)value; |
|
// break; |
|
// case plGenericType::kChar: |
|
// pyDict[key] = (char)value; |
|
// break; |
|
// case plGenericType::kString: |
|
// pyDict[key] = (const char *)value; |
|
// break; |
|
// case plGenericType::kAny: |
|
// break; |
|
// case plGenericType::kNone: |
|
// break; |
|
// } |
|
// } |
|
// } |
|
// PyObject_SetAttrString( fPyObject, "fCbArgs", pyDict.ptr() ); |
|
// } |
|
// Do callback |
|
PyObject* func = PyObject_GetAttrString( fPyObject, "operationComplete" ); |
|
if ( func ) |
|
{ |
|
if ( PyCallable_Check(func)>0 ) |
|
{ |
|
PyObject* retVal = PyObject_CallMethod(fPyObject, "operationComplete", "li", context, resultCode); |
|
Py_XDECREF(retVal); |
|
} |
|
} |
|
} |
|
delete this; |
|
} |
|
}; |
|
|
|
|
|
class pyVaultCallback : public plVaultStubbedCallback |
|
{ |
|
public: |
|
PyObject * fPyObject; |
|
pyVaultCallback( PyObject * pyObject ) |
|
: fPyObject( pyObject ) |
|
{ |
|
Py_XINCREF( fPyObject ); |
|
} |
|
~pyVaultCallback() |
|
{ |
|
Py_XDECREF( fPyObject ); |
|
} |
|
}; |
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
int pyVNodeMgr::VaultMsgHandler::HandleMessage( plNetMessage* msg ) |
|
{ |
|
plNetMsgVault * vaultMsg = plNetMsgVault::ConvertNoRef( msg ); |
|
|
|
if ( vaultMsg ) |
|
{ |
|
plNetCoreMessage * ncmsg = (plNetCoreMessage*)msg->GetNetCoreMsg(); |
|
msg->PeekBuffer( ncmsg->GetData(), ncmsg->GetLen() ); |
|
fMyVNodeMgr->GetStatusLog()->AddLineF( "\t%s", msg->AsStdString().c_str() ); |
|
plVault::ProcessMsg( vaultMsg ); |
|
return plNetClientComm::kOK_MsgConsumed; |
|
} |
|
|
|
return hsFail; |
|
} |
|
|
|
|
|
// pyVNodeMgr ---------------------------------------------- |
|
pyVNodeMgr::pyVNodeMgr( PyObject* thaComm ) |
|
{ |
|
if (!pyNetClientComm::Check(thaComm)) |
|
{ |
|
fMyCommObj = NULL; |
|
return; // screwed! |
|
} |
|
|
|
fMsgHandler.setMgr(this); |
|
|
|
fMyCommObj = thaComm; |
|
Py_INCREF(fMyCommObj); |
|
fMyComm = pyNetClientComm::ConvertFrom(fMyCommObj); |
|
fMyComm->GetNetClientComm()->AddMsgHandlerForType( plNetMsgVault::Index(), &fMsgHandler ); |
|
plVNodeMgr::SetStatusLog( fMyComm->GetNetClientComm()->GetLog(), false ); |
|
} |
|
|
|
// ~pyVNodeMgr ---------------------------------------------- |
|
pyVNodeMgr::~pyVNodeMgr() |
|
{ |
|
fMyComm->GetNetClientComm()->RemoveMsgHandler( &fMsgHandler ); |
|
Py_DECREF(fMyCommObj); |
|
} |
|
|
|
void pyVNodeMgr::setMyComm(PyObject* thaComm) |
|
{ |
|
if (fMyComm) |
|
{ |
|
fMyComm->GetNetClientComm()->RemoveMsgHandler(&fMsgHandler); |
|
Py_DECREF(fMyCommObj); |
|
fMyCommObj = NULL; |
|
fMyComm = NULL; |
|
} |
|
if (!pyNetClientComm::Check(thaComm)) |
|
return; // screwed! |
|
|
|
fMyCommObj = thaComm; |
|
Py_INCREF(fMyCommObj); |
|
fMyComm = pyNetClientComm::ConvertFrom(fMyCommObj); |
|
fMyComm->GetNetClientComm()->AddMsgHandlerForType(plNetMsgVault::Index(), &fMsgHandler); |
|
plVNodeMgr::SetStatusLog(fMyComm->GetNetClientComm()->GetLog(), false); |
|
} |
|
|
|
// IAmOnline ---------------------------------------------- |
|
bool pyVNodeMgr::IAmOnline() const |
|
{ |
|
return true; |
|
} |
|
|
|
// IIsThisMe ---------------------------------------------- |
|
bool pyVNodeMgr::IIsThisMe( plVaultPlayerInfoNode* node ) const |
|
{ |
|
return ( fMyComm->GetNetClientComm()->GetPlayerID()==node->GetPlayerID() ); |
|
} |
|
|
|
// IIsThisMe ---------------------------------------------- |
|
bool pyVNodeMgr::IIsThisMe( plVaultPlayerNode * node ) const |
|
{ |
|
return ( fMyComm->GetNetClientComm()->GetPlayerID()==node->GetID() ); |
|
} |
|
|
|
// ISendNetMsg ---------------------------------------------- |
|
int pyVNodeMgr::ISendNetMsg( plNetMsgVault* msg, UInt32 sendFlags/*=0 */) |
|
{ |
|
return fMyComm->GetNetClientComm()->SendMsg( msg, sendFlags ); |
|
} |
|
|
|
// IGetPlayerID ---------------------------------------------- |
|
UInt32 pyVNodeMgr::IGetPlayerID() const |
|
{ |
|
return fMyComm->GetNetClientComm()->GetPlayerID(); |
|
} |
|
|
|
// Update ---------------------------------------------- |
|
int pyVNodeMgr::Update( double secs ) |
|
{ |
|
return plVNodeMgr::Update( secs ); |
|
} |
|
|
|
// Startup ---------------------------------------------- |
|
void pyVNodeMgr::Startup() |
|
{ |
|
plVNodeMgr::Startup(); |
|
} |
|
|
|
// Shutdown ---------------------------------------------- |
|
void pyVNodeMgr::Shutdown() |
|
{ |
|
plVNodeMgr::Shutdown(); |
|
} |
|
|
|
|
|
// IsConnected ---------------------------------------------- |
|
bool pyVNodeMgr::IsConnected() |
|
{ |
|
return plVNodeMgr::IsConnected(); |
|
} |
|
|
|
// Disconnect ---------------------------------------------- |
|
void pyVNodeMgr::Disconnect( PyObject* cb/*=nil*/, UInt32 cbContext/*=0 */) |
|
{ |
|
// disconnect from allplayers and globalsdl folders |
|
plVaultNodeRef * out; |
|
plVaultNode * root = plVNodeMgr::GetRootNode(); |
|
if ( root ) |
|
{ |
|
plVaultFolderNode tmpGlobalSDL; |
|
tmpGlobalSDL.SetFolderType( plVault::kAllAgeGlobalSDLNodesFolder ); |
|
if ( root->FindNode( &tmpGlobalSDL, out ) ) |
|
root->RemoveNode( out->GetChildID() ); |
|
plVaultFolderNode tmpAllPlayers; |
|
tmpAllPlayers.SetFolderType( plVault::kAllPlayersFolder ); |
|
if ( root->FindNode( &tmpAllPlayers, out ) ) |
|
root->RemoveNode( out->GetChildID() ); |
|
} |
|
plVNodeMgr::Disconnect( new pyVaultOperationCallback( cb ), cbContext ); |
|
} |
|
|
|
// Connect ---------------------------------------------- |
|
void pyVNodeMgr::Connect( int childFetchLevel/*=plVault::kFetchAllChildren*/, PyObject* cb/*=nil*/, UInt32 cbContext/*=0 */) |
|
{ |
|
plVNodeMgr::Connect( childFetchLevel, new pyVaultOperationCallback( cb ), cbContext ); |
|
} |
|
|
|
// FetchNode ---------------------------------------------- |
|
bool pyVNodeMgr::FetchNode( UInt32 nodeID, |
|
int childFetchLevel/*=plVault::kFetchAllChildren*/, |
|
PyObject* cb/*=nil*/, |
|
UInt32 cbContext/*=0 */) |
|
{ |
|
return plVNodeMgr::FetchNode( nodeID, childFetchLevel, new pyVaultOperationCallback( cb ), cbContext ); |
|
} |
|
|
|
// GetRootNode ---------------------------------------------- |
|
PyObject* pyVNodeMgr::GetRootNode() const |
|
{ |
|
return pyVaultNode::New( plVNodeMgr::GetRootNode() ); |
|
} |
|
|
|
// GetClientID ---------------------------------------------- |
|
UInt32 pyVNodeMgr::GetClientID() const |
|
{ |
|
return plVNodeMgr::GetClientID(); |
|
} |
|
|
|
// GetNode ---------------------------------------------- |
|
PyObject* pyVNodeMgr::GetNode( UInt32 id ) const |
|
{ |
|
plVaultNode * tmp; |
|
if ( plVNodeMgr::GetNode( id, tmp ) ) |
|
return pyVaultNode::New( tmp ); |
|
PYTHON_RETURN_NONE; |
|
} |
|
|
|
// FindNode ---------------------------------------------- |
|
PyObject* pyVNodeMgr::FindNode( pyVaultNode* templateNode ) const |
|
{ |
|
plVaultNode * node; |
|
if ( plVNodeMgr::FindNode( templateNode->GetNode(), node ) ) |
|
return pyVaultNode::New( node ); |
|
PYTHON_RETURN_NONE; |
|
} |
|
|
|
// EnableCallbacks ---------------------------------------------- |
|
bool pyVNodeMgr::EnableCallbacks( bool b ) |
|
{ |
|
return plVNodeMgr::EnableCallbacks( b ); |
|
} |
|
|
|
// AddCallback ---------------------------------------------- |
|
void pyVNodeMgr::AddCallback( PyObject* cb ) |
|
{ |
|
pyVaultCallback * pycb = new pyVaultCallback( cb ); |
|
fPyCallbacks.push_back( pycb ); |
|
plVNodeMgr::AddCallback( pycb ); |
|
} |
|
|
|
// RemoveCallback ---------------------------------------------- |
|
void pyVNodeMgr::RemoveCallback( PyObject* cb ) |
|
{ |
|
PyCallbackVec tmp; |
|
for ( int i=0; i<fPyCallbacks.size(); i++ ) |
|
{ |
|
if ( fPyCallbacks[i]->fPyObject==cb ) |
|
tmp.push_back( fPyCallbacks[i] ); |
|
} |
|
for ( int i=0; i<tmp.size(); i++ ) |
|
{ |
|
PyCallbackVec::iterator it = std::find( fPyCallbacks.begin(), fPyCallbacks.end(), tmp[i] ); |
|
if ( it!=fPyCallbacks.end() ) |
|
fPyCallbacks.erase( it ); |
|
plVNodeMgr::RemoveCallback( tmp[i] ); |
|
delete tmp[i]; |
|
} |
|
} |
|
|
|
// CreateNode ---------------------------------------------- |
|
PyObject* pyVNodeMgr::CreateNode( int nodeType, bool persistent ) |
|
{ |
|
plVaultNode * node = plVNodeMgr::CreateNode( nodeType, persistent?kNewPersistentNodeOptions( this ):kNilNodeOptions() ); |
|
if ( node ) |
|
return pyVaultNode::New( node ); |
|
PYTHON_RETURN_NONE; |
|
} |
|
|
|
// Dump ---------------------------------------------- |
|
void pyVNodeMgr::Dump() const |
|
{ |
|
plVNodeMgr::Dump(); |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////// |
|
|
|
pyPlayerVNodeMgr::pyPlayerVNodeMgr( PyObject* thaComm ) |
|
: pyVNodeMgr( thaComm ) |
|
{} |
|
|
|
// IAmSuperUser ---------------------------------------------- |
|
bool pyPlayerVNodeMgr::IAmSuperUser( void ) const |
|
{ |
|
return false; |
|
} |
|
|
|
// IFillOutConnectFields ---------------------------------------------- |
|
void pyPlayerVNodeMgr::IFillOutConnectFields( plNetMsgVault* msg ) const |
|
{ |
|
msg->GetArgs()->AddInt( plVault::kArg_NodeMgrType, plVault::kNodeType_VNodeMgrPlayer ); |
|
msg->GetArgs()->AddInt( plVault::kArg_NodeMgrID, fMyComm->GetNetClientComm()->GetPlayerID() ); |
|
} |
|
|
|
// IGetNodeInitializationTask ---------------------------------------------- |
|
plVNodeInitTask * pyPlayerVNodeMgr::IGetNodeInitializationTask( plVaultNode * node ) |
|
{ |
|
if ( plVaultPlayerNode::ConvertNoRef( node ) ) |
|
return new plVaultPlayerInitializationTask( this, node, true ); |
|
return nil; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////// |
|
|
|
pyAgeVNodeMgr::pyAgeVNodeMgr( PyObject* thaComm ) |
|
: pyVNodeMgr( thaComm ) |
|
{} |
|
|
|
// IAmSuperUser ---------------------------------------------- |
|
bool pyAgeVNodeMgr::IAmSuperUser( void ) const |
|
{ |
|
return false; |
|
} |
|
|
|
// IFillOutConnectFields ---------------------------------------------- |
|
void pyAgeVNodeMgr::IFillOutConnectFields( plNetMsgVault* msg ) const |
|
{ |
|
msg->GetArgs()->AddInt( plVault::kArg_NodeMgrType, plVault::kNodeType_VNodeMgrAge ); |
|
msg->GetArgs()->AddString( plVault::kArg_NodeMgrAgeInstanceName, fAgeFilename.c_str() ); |
|
msg->GetArgs()->AddItem( plVault::kArg_NodeMgrAgeGuid, &fAgeInstanceGuid ); |
|
} |
|
|
|
// IGetNodeInitializationTask ---------------------------------------------- |
|
plVNodeInitTask * pyAgeVNodeMgr::IGetNodeInitializationTask( plVaultNode * node ) |
|
{ |
|
if ( plVaultAgeNode::ConvertNoRef( node ) ) |
|
return new plVaultAgeInitializationTask( this, node, nil, true ); |
|
if ( plVaultAgeInfoNode::ConvertNoRef( node ) ) |
|
return new plVaultAgeInfoInitializationTask( this, node ); |
|
return nil; |
|
} |
|
|
|
// SetAgeInfo ---------------------------------------------- |
|
void pyAgeVNodeMgr::SetAgeInfo( const char * ageFilename, const char * ageInstanceGuid ) |
|
{ |
|
fAgeFilename = ageFilename; |
|
fAgeInstanceGuid.FromString( ageInstanceGuid ); |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////////// |
|
|
|
pyAdminVNodeMgr::pyAdminVNodeMgr( PyObject* thaComm ) |
|
: pyVNodeMgr( thaComm ) |
|
, fWantGlobalSDL( true ) |
|
, fWantAllPlayers( false ) |
|
{} |
|
|
|
// IAmSuperUser ---------------------------------------------- |
|
bool pyAdminVNodeMgr::IAmSuperUser( void ) const |
|
{ |
|
return true; |
|
} |
|
|
|
// IFillOutConnectFields ---------------------------------------------- |
|
void pyAdminVNodeMgr::IFillOutConnectFields( plNetMsgVault* msg ) const |
|
{ |
|
msg->GetArgs()->AddInt( plVault::kArg_NodeMgrType, plVault::kNodeType_VNodeMgrAdmin ); |
|
msg->GetArgs()->AddInt( plVault::kArg_NodeMgrID, fMyComm->GetNetClientComm()->GetPlayerID() ); |
|
} |
|
|
|
// IGetNodeInitializationTask ---------------------------------------------- |
|
plVNodeInitTask * pyAdminVNodeMgr::IGetNodeInitializationTask( plVaultNode * node ) |
|
{ |
|
if ( plVaultAdminNode::ConvertNoRef( node ) ) |
|
return new plVaultAdminInitializationTask( this, node, fWantGlobalSDL, fWantAllPlayers ); |
|
return nil; |
|
} |
|
|
|
// GetGlobalInbox ---------------------------------------------- |
|
PyObject * pyAdminVNodeMgr::GetGlobalInbox() const |
|
{ |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kGlobalInboxFolder ); |
|
plVaultNode * node; |
|
if ( plVNodeMgr::FindNode( &tmp, node ) ) |
|
{ |
|
return pyVaultFolderNode::New( plVaultFolderNode::ConvertNoRef( node ) ); |
|
} |
|
PYTHON_RETURN_NONE; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
// End.
|
|
|