|
|
|
/*==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 <Python.h>
|
|
|
|
#include "plgDispatch.h"
|
|
|
|
#include "hsResMgr.h"
|
|
|
|
#include "pyKey.h"
|
|
|
|
#pragma hdrstop
|
|
|
|
|
|
|
|
#include "cyMisc.h"
|
|
|
|
|
|
|
|
#include "plResMgr/plKeyFinder.h"
|
|
|
|
#include "pnKeyedObject/plKey.h"
|
|
|
|
#include "pnKeyedObject/plKeyImp.h"
|
|
|
|
#include "pnKeyedObject/plFixedKey.h"
|
|
|
|
#include "plMessage/plLinkToAgeMsg.h"
|
|
|
|
#include "plMessage/plConsoleMsg.h"
|
|
|
|
#include "plMessage/plAnimCmdMsg.h"
|
|
|
|
#include "plMessage/plExcludeRegionMsg.h"
|
|
|
|
#include "plMessage/plInputEventMsg.h"
|
|
|
|
#include "plMessage/plInputIfaceMgrMsg.h"
|
|
|
|
#include "pnMessage/plCmdIfaceModMsg.h"
|
|
|
|
#include "pnMessage/plAttachMsg.h"
|
|
|
|
#include "plMessage/plTimerCallbackMsg.h"
|
|
|
|
#include "plMessage/plNetVoiceListMsg.h"
|
|
|
|
#include "pnMessage/plClientMsg.h"
|
|
|
|
#include "pnMessage/plCameraMsg.h"
|
|
|
|
#include "pnTimer/plTimerCallbackManager.h"
|
|
|
|
#include "plVault/plVault.h"
|
|
|
|
#include "pnNetCommon/plCreatableUuid.h"
|
|
|
|
#include "plNetClient/plNetClientMgr.h"
|
|
|
|
#include "plNetClient/plNetLinkingMgr.h"
|
|
|
|
#include "plNetTransport/plNetTransport.h"
|
|
|
|
#include "plNetTransport/plNetTransportMember.h"
|
|
|
|
#include "plResMgr/plKeyFinder.h"
|
|
|
|
#include "plAvatar/plAvatarMgr.h"
|
|
|
|
#include "plAvatar/plMultistageBehMod.h"
|
|
|
|
#include "plAvatar/plAvBrainCritter.h"
|
|
|
|
#include "pyCritterBrain.h"
|
|
|
|
#include "cyPythonInterface.h"
|
|
|
|
#include "pySceneObject.h"
|
|
|
|
#include "pyPlayer.h"
|
|
|
|
#include "pyImage.h"
|
|
|
|
#include "pyDniCoordinates.h"
|
|
|
|
#include "pyDniInfoSource.h"
|
|
|
|
#include "pyColor.h"
|
|
|
|
#include "pyNetLinkingMgr.h"
|
|
|
|
#include "pyAgeInfoStruct.h"
|
|
|
|
#include "pyAgeLinkStruct.h"
|
|
|
|
#include "pyAlarm.h"
|
|
|
|
#include "pyGeometry3.h"
|
|
|
|
#include "pfMessage/pfKIMsg.h"
|
|
|
|
#include "plNetMessage/plNetMessage.h"
|
|
|
|
#include "pfCamera/plVirtualCamNeu.h"
|
|
|
|
#include "plPipeline/plDynamicEnvMap.h"
|
|
|
|
|
|
|
|
#include "pfGameGUIMgr/pfGameGUIMgr.h"
|
|
|
|
#include "pfGameGUIMgr/pfGUIDialogMod.h"
|
|
|
|
#include "pyGUIDialog.h"
|
|
|
|
#include "pnSceneObject/plSceneObject.h"
|
|
|
|
#include "pnSceneObject/plCoordinateInterface.h"
|
|
|
|
|
|
|
|
#include "plMessage/plCCRMsg.h"
|
|
|
|
#include "plAgeLoader/plAgeLoader.h"
|
|
|
|
|
|
|
|
#include "plResMgr/plLocalization.h"
|
|
|
|
#include "plGLight/plLightInfo.h"
|
|
|
|
|
|
|
|
#include "plInputCore/plAvatarInputInterface.h"
|
|
|
|
#include "plInputCore/plInputDevice.h"
|
|
|
|
|
|
|
|
#include "plVault/plAgeInfoSource.h"
|
|
|
|
|
|
|
|
#include "pfLocalizationMgr/pfLocalizationMgr.h"
|
|
|
|
#include "pnUtils/pnUtils.h"
|
|
|
|
|
|
|
|
//// Static Class Stuff //////////////////////////////////////////////////////
|
|
|
|
plPipeline* cyMisc::fPipeline = nil;
|
|
|
|
uint32_t cyMisc::fUniqueNumber = 0;
|
|
|
|
|
|
|
|
#ifdef PLASMA_EXTERNAL_RELEASE
|
|
|
|
uint32_t cyMisc::fPythonLoggingLevel = cyMisc::kErrorLevel;
|
|
|
|
#else
|
|
|
|
uint32_t cyMisc::fPythonLoggingLevel = cyMisc::kWarningLevel;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// static
|
|
|
|
void cyMisc::Update( double secs )
|
|
|
|
{
|
|
|
|
// only update once per 1/2 sec
|
|
|
|
static double lastUpdateTime = 0.0;
|
|
|
|
if ( secs-lastUpdateTime>=0.5 )
|
|
|
|
{
|
|
|
|
lastUpdateTime = secs;
|
|
|
|
pyAlarmMgr::GetInstance()->Update( secs );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Get/SetDebugPrintLevel
|
|
|
|
//
|
|
|
|
// PURPOSE : gets and sets the python debug print level
|
|
|
|
//
|
|
|
|
uint32_t cyMisc::GetPythonLoggingLevel()
|
|
|
|
{
|
|
|
|
return fPythonLoggingLevel;
|
|
|
|
}
|
|
|
|
void cyMisc::SetPythonLoggingLevel(uint32_t new_level)
|
|
|
|
{
|
|
|
|
fPythonLoggingLevel = new_level;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Console
|
|
|
|
// PARAMETERS : command - string of console commmand to execute
|
|
|
|
//
|
|
|
|
// PURPOSE : Execute a console command from a python script
|
|
|
|
//
|
|
|
|
void cyMisc::Console(const char* command)
|
|
|
|
{
|
|
|
|
if ( command != nil )
|
|
|
|
{
|
|
|
|
// create message to send to the console
|
|
|
|
plControlEventMsg* pMsg = new plControlEventMsg;
|
|
|
|
pMsg->SetBCastFlag(plMessage::kBCastByType);
|
|
|
|
pMsg->SetControlCode(B_CONTROL_CONSOLE_COMMAND);
|
|
|
|
pMsg->SetControlActivated(true);
|
|
|
|
pMsg->SetCmdString(command);
|
|
|
|
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::ConsoleNet(const char* command, bool netForce)
|
|
|
|
{
|
|
|
|
if ( command != nil )
|
|
|
|
{
|
|
|
|
// create message to send to the console
|
|
|
|
plControlEventMsg* pMsg = new plControlEventMsg;
|
|
|
|
pMsg->SetBCastFlag(plMessage::kBCastByType);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
if ( netForce )
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
pMsg->SetControlCode(B_CONTROL_CONSOLE_COMMAND);
|
|
|
|
pMsg->SetControlActivated(true);
|
|
|
|
pMsg->SetCmdString(command);
|
|
|
|
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : FindSceneObject
|
|
|
|
// PARAMETERS : name - string of name of the sceneobject
|
|
|
|
// : ageName - string of the name of the age to look in
|
|
|
|
//
|
|
|
|
// PURPOSE : Execute a console command from a python script,
|
|
|
|
// optionally propagate over the net
|
|
|
|
//
|
|
|
|
PyObject* cyMisc::FindSceneObject(const plString& name, const char* ageName)
|
|
|
|
{
|
|
|
|
// assume that we won't find the sceneobject (key is equal to nil)
|
|
|
|
plKey key=nil;
|
|
|
|
|
|
|
|
if ( !name.IsEmpty() )
|
|
|
|
{
|
|
|
|
const char* theAge = ageName;
|
|
|
|
if ( ageName[0] == 0 )
|
|
|
|
theAge = nil;
|
|
|
|
key=plKeyFinder::Instance().StupidSearch(theAge, "", plSceneObject::Index(), name, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( key == nil )
|
|
|
|
{
|
|
|
|
plString errmsg = plFormat("Sceneobject {} not found", name);
|
|
|
|
PyErr_SetString(PyExc_NameError, errmsg.c_str());
|
|
|
|
return nil; // return nil cause we errored
|
|
|
|
}
|
|
|
|
return pySceneObject::New(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::FindSceneObjects(const plString& name)
|
|
|
|
{
|
|
|
|
// assume that we won't find the sceneobject (key is equal to nil)
|
|
|
|
std::vector<plKey> keys;
|
|
|
|
|
|
|
|
if ( !name.IsNull() )
|
|
|
|
plKeyFinder::Instance().ReallyStupidSubstringSearch(name, plSceneObject::Index(), keys);
|
|
|
|
|
|
|
|
PyObject* result = PyList_New(keys.size());
|
|
|
|
for (size_t i=0; i < keys.size(); i++)
|
|
|
|
PyList_SET_ITEM(result, i, pySceneObject::New(keys[i]));
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
PyObject* cyMisc::FindActivator(const plString& name)
|
|
|
|
{
|
|
|
|
plKey key = nil;
|
|
|
|
if (!name.IsEmpty())
|
|
|
|
{
|
|
|
|
std::vector<plKey> keylist;
|
|
|
|
plKeyFinder::Instance().ReallyStupidActivatorSearch(name, keylist);
|
|
|
|
|
|
|
|
if (keylist.size() == 1)
|
|
|
|
key = keylist[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (key == nil)
|
|
|
|
{
|
|
|
|
PYTHON_RETURN_NONE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return pyKey::New(key);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : PopUpConsole
|
|
|
|
// PARAMETERS : command - string of console commmand to execute
|
|
|
|
//
|
|
|
|
// PURPOSE : Execute a console command from a python script
|
|
|
|
//
|
|
|
|
void cyMisc::PopUpConsole(const char* command)
|
|
|
|
{
|
|
|
|
if ( command != nil )
|
|
|
|
{
|
|
|
|
// create message to send to the console
|
|
|
|
plControlEventMsg* pMsg1 = new plControlEventMsg;
|
|
|
|
pMsg1->SetBCastFlag(plMessage::kBCastByType);
|
|
|
|
pMsg1->SetControlCode(B_SET_CONSOLE_MODE);
|
|
|
|
pMsg1->SetControlActivated(true);
|
|
|
|
plgDispatch::MsgSend( pMsg1 ); // whoosh... off it goes
|
|
|
|
// create message to send to the console
|
|
|
|
plControlEventMsg* pMsg2 = new plControlEventMsg;
|
|
|
|
pMsg2->SetBCastFlag(plMessage::kBCastByType);
|
|
|
|
pMsg2->SetControlCode(B_CONTROL_CONSOLE_COMMAND);
|
|
|
|
pMsg2->SetControlActivated(true);
|
|
|
|
pMsg2->SetCmdString(command);
|
|
|
|
plgDispatch::MsgSend( pMsg2 ); // whoosh... off it goes
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : TimerCallback
|
|
|
|
// PARAMETERS : command - string of console commmand to execute
|
|
|
|
//
|
|
|
|
// PURPOSE : Execute a console command from a python script
|
|
|
|
//
|
|
|
|
void cyMisc::TimerCallback(pyKey& selfkey, float time, uint32_t id)
|
|
|
|
{
|
|
|
|
// setup the message to come back to whoever the pyKey is pointing to
|
|
|
|
plTimerCallbackMsg* pTimerMsg = new plTimerCallbackMsg(selfkey.getKey(),id);
|
|
|
|
plgTimerCallbackMgr::NewTimer( time, pTimerMsg );
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : ClearTimerCallbacks
|
|
|
|
// PARAMETERS : key of object to clear callbacks to
|
|
|
|
//
|
|
|
|
// PURPOSE : clear timer callbacks to a certain key
|
|
|
|
//
|
|
|
|
void cyMisc::ClearTimerCallbacks(pyKey& selfkey)
|
|
|
|
{
|
|
|
|
plgTimerCallbackMgr::CancelCallbacksToKey(selfkey.getKey());
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : AttachObject
|
|
|
|
// PARAMETERS : child object
|
|
|
|
// : to be attached to parent object
|
|
|
|
//
|
|
|
|
// PURPOSE : Attach an object to another object, knowing only their pyKeys
|
|
|
|
//
|
|
|
|
void cyMisc::AttachObject(pyKey& ckey, pyKey& pkey, bool netForce)
|
|
|
|
{
|
|
|
|
plKey childKey = ckey.getKey();
|
|
|
|
plKey parentKey = pkey.getKey();
|
|
|
|
|
|
|
|
// make sure that there was a child ket
|
|
|
|
if ( childKey )
|
|
|
|
{
|
|
|
|
// create the attach message to attach the child
|
|
|
|
plAttachMsg* pMsg = new plAttachMsg(parentKey, childKey->GetObjectPtr(), plRefMsg::kOnRequest);
|
|
|
|
|
|
|
|
if (netForce) {
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
}
|
|
|
|
|
|
|
|
plgDispatch::MsgSend( pMsg );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void cyMisc::AttachObjectSO(pySceneObject& cobj, pySceneObject& pobj, bool netForce)
|
|
|
|
{
|
|
|
|
plKey childKey = cobj.getObjKey();
|
|
|
|
plKey parentKey = pobj.getObjKey();
|
|
|
|
|
|
|
|
// make sure that there was a child ket
|
|
|
|
if ( childKey )
|
|
|
|
{
|
|
|
|
// create the attach message to attach the child
|
|
|
|
plAttachMsg* pMsg = new plAttachMsg(parentKey, childKey->GetObjectPtr(), plRefMsg::kOnRequest);
|
|
|
|
|
|
|
|
if (netForce) {
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
}
|
|
|
|
|
|
|
|
plgDispatch::MsgSend( pMsg );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : DetachObject
|
|
|
|
// PARAMETERS : child object
|
|
|
|
// : to be attached to parent object
|
|
|
|
//
|
|
|
|
// PURPOSE : Attach an object to another object, knowing only their pyKeys
|
|
|
|
//
|
|
|
|
void cyMisc::DetachObject(pyKey& ckey, pyKey& pkey, bool netForce)
|
|
|
|
{
|
|
|
|
plKey childKey = ckey.getKey();
|
|
|
|
plKey parentKey = pkey.getKey();
|
|
|
|
|
|
|
|
// make sure that there was a child ket
|
|
|
|
if ( childKey )
|
|
|
|
{
|
|
|
|
// create the attach message to detach the child
|
|
|
|
plAttachMsg* pMsg = new plAttachMsg(parentKey, childKey->GetObjectPtr(), plRefMsg::kOnRemove);
|
|
|
|
|
|
|
|
if (netForce) {
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
}
|
|
|
|
|
|
|
|
plgDispatch::MsgSend( pMsg );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
void cyMisc::DetachObjectSO(pySceneObject& cobj, pySceneObject& pobj, bool netForce)
|
|
|
|
{
|
|
|
|
plKey childKey = cobj.getObjKey();
|
|
|
|
plKey parentKey = pobj.getObjKey();
|
|
|
|
|
|
|
|
// make sure that there was a child ket
|
|
|
|
if ( childKey )
|
|
|
|
{
|
|
|
|
// create the attach message to detach the child
|
|
|
|
plAttachMsg* pMsg = new plAttachMsg(parentKey, childKey->GetObjectPtr(), plRefMsg::kOnRemove);
|
|
|
|
|
|
|
|
if (netForce) {
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
}
|
|
|
|
|
|
|
|
plgDispatch::MsgSend( pMsg );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : LinkToAge
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : LinkToAge
|
|
|
|
//
|
|
|
|
// STATUS : Depreciated. Use plNetLinkingMgr or pyNetLinkingMgr instead.
|
|
|
|
//
|
|
|
|
|
|
|
|
//void cyMisc::LinkToAge(pyKey &selfkey, const char *AgeName,const char *SpawnPointName)
|
|
|
|
//{
|
|
|
|
// // find the Modifier that called us
|
|
|
|
// hsStatusMessage("PY: LinkToAge\n");
|
|
|
|
// // Ask the Modifier if it was Local or Network
|
|
|
|
// if (selfkey.WasLocalNotify())
|
|
|
|
// {
|
|
|
|
// hsStatusMessage("PY:LOCAL NOTIFY\n");
|
|
|
|
// plNetLinkingMgr::GetInstance()->LinkToPublicAge( AgeName, SpawnPointName );
|
|
|
|
// }
|
|
|
|
// else
|
|
|
|
// {
|
|
|
|
// hsStatusMessage("PY:REMOTE NOTIFY\n");
|
|
|
|
// }
|
|
|
|
//}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SetDirtySyncStateServer
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : set the Python modifier to be dirty and asked to be saved out
|
|
|
|
//
|
|
|
|
void cyMisc::SetDirtySyncState(pyKey &selfkey, const plString& SDLStateName, uint32_t sendFlags)
|
|
|
|
{
|
|
|
|
selfkey.DirtySynchState(SDLStateName, sendFlags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SetDirtySyncStateClients
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : set the Python modifier to be dirty and asked to be saved out
|
|
|
|
//
|
|
|
|
void cyMisc::SetDirtySyncStateWithClients(pyKey &selfkey, const plString& SDLStateName, uint32_t sendFlags)
|
|
|
|
{
|
|
|
|
selfkey.DirtySynchState(SDLStateName, sendFlags|plSynchedObject::kBCastToClients);
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : EnableControlKeyEvents & DisableControlKeyEvents
|
|
|
|
// PARAMETERS : none
|
|
|
|
//
|
|
|
|
// PURPOSE : register and unregister for control key events
|
|
|
|
//
|
|
|
|
void cyMisc::EnableControlKeyEvents(pyKey &selfkey)
|
|
|
|
{
|
|
|
|
selfkey.EnableControlKeyEvents();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::DisableControlKeyEvents(pyKey &selfkey)
|
|
|
|
{
|
|
|
|
selfkey.DisableControlKeyEvents();
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetClientName
|
|
|
|
// PARAMETERS : avatar key
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the net client (account) name of the player whose avatar
|
|
|
|
// key is provided.
|
|
|
|
//
|
|
|
|
bool cyMisc::WasLocallyNotified(pyKey &selfkey)
|
|
|
|
{
|
|
|
|
return selfkey.WasLocalNotify();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetClientName
|
|
|
|
// PARAMETERS : avatar key
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the net client (account) name of the player whose avatar
|
|
|
|
// key is provided.
|
|
|
|
//
|
|
|
|
plString cyMisc::GetClientName(pyKey &avKey)
|
|
|
|
{
|
|
|
|
return plNetClientMgr::GetInstance()->GetPlayerName(avKey.getKey());
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::GetAvatarKeyFromClientID(int clientID)
|
|
|
|
{
|
|
|
|
PyObject* keyObj = NULL;
|
|
|
|
|
|
|
|
if (clientID == plNetClientMgr::GetInstance()->GetPlayerID())
|
|
|
|
{
|
|
|
|
keyObj = pyKey::New(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
plNetTransportMember **members = nil;
|
|
|
|
plNetClientMgr::GetInstance()->TransportMgr().GetMemberListDistSorted( members );
|
|
|
|
|
|
|
|
if( members != nil)
|
|
|
|
{
|
|
|
|
for(int i = 0; i < plNetClientMgr::GetInstance()->TransportMgr().GetNumMembers(); i++ )
|
|
|
|
{
|
|
|
|
plNetTransportMember *mbr = members[ i ];
|
|
|
|
if( mbr != nil && mbr->GetAvatarKey() != nil && mbr->GetPlayerID() == clientID)
|
|
|
|
{
|
|
|
|
keyObj = pyKey::New(mbr->GetAvatarKey());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
delete [] members;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (keyObj)
|
|
|
|
return keyObj;
|
|
|
|
else
|
|
|
|
PYTHON_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int cyMisc::GetClientIDFromAvatarKey(pyKey& avatar)
|
|
|
|
{
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
if (plNetClientMgr::GetInstance()->GetLocalPlayerKey() == avatar.getKey())
|
|
|
|
{
|
|
|
|
return (plNetClientMgr::GetInstance()->GetPlayerID());
|
|
|
|
}
|
|
|
|
plNetTransportMember **members = nil;
|
|
|
|
plNetClientMgr::GetInstance()->TransportMgr().GetMemberListDistSorted( members );
|
|
|
|
if( members != nil)
|
|
|
|
{
|
|
|
|
for(int i = 0; i < plNetClientMgr::GetInstance()->TransportMgr().GetNumMembers(); i++ )
|
|
|
|
{
|
|
|
|
plNetTransportMember *mbr = members[ i ];
|
|
|
|
|
|
|
|
if( mbr != nil && mbr->GetAvatarKey() == avatar.getKey())
|
|
|
|
{
|
|
|
|
ret = mbr->GetPlayerID();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
delete [] members;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int cyMisc::GetLocalClientID()
|
|
|
|
{
|
|
|
|
return (plNetClientMgr::GetInstance()->GetPlayerID());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cyMisc::ValidateKey(pyKey& key)
|
|
|
|
{
|
|
|
|
plKey pKey = key.getKey();
|
|
|
|
|
|
|
|
if (pKey && pKey->ObjectIsLoaded())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetClientName
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the local net client (account) name
|
|
|
|
//
|
|
|
|
plString cyMisc::GetLocalClientName()
|
|
|
|
{
|
|
|
|
return plNetClientMgr::GetInstance()->GetPlayerName();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
|
|
// Get Current age information - DEPRECIATED. Use ptDniInfoSource() object instead
|
|
|
|
//
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetAgeName
|
|
|
|
// Function : GetAgeTime
|
|
|
|
// Function : GetAgeGuid
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the age name of the current age the local player is in
|
|
|
|
// : Return the current coordinates of the player within this age
|
|
|
|
// : Return the current time with the current age the player is in
|
|
|
|
// : Return the current guid of the instance of the age the player is in
|
|
|
|
//
|
|
|
|
|
|
|
|
const char * cyMisc::GetAgeName()
|
|
|
|
{
|
|
|
|
return NetCommGetAge()->ageDatasetName;
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::GetAgeInfo()
|
|
|
|
{
|
|
|
|
plNetLinkingMgr* nmgr = plNetLinkingMgr::GetInstance();
|
|
|
|
if (nmgr)
|
|
|
|
{
|
|
|
|
plAgeLinkStruct* als = nmgr->GetAgeLink();
|
|
|
|
if (als)
|
|
|
|
return pyAgeInfoStruct::New(als->GetAgeInfo());
|
|
|
|
}
|
|
|
|
PYTHON_RETURN_NONE; // return none, not nil (cause it isn't really an error... or is it?)
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
plString cyMisc::GetPrevAgeName()
|
|
|
|
{
|
|
|
|
plNetLinkingMgr* nmgr = plNetLinkingMgr::GetInstance();
|
|
|
|
if (nmgr)
|
|
|
|
{
|
|
|
|
plAgeLinkStruct* als = nmgr->GetPrevAgeLink();
|
|
|
|
if (als)
|
|
|
|
return als->GetAgeInfo()->GetAgeFilename();
|
|
|
|
}
|
|
|
|
return plString::Null;
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::GetPrevAgeInfo()
|
|
|
|
{
|
|
|
|
plNetLinkingMgr* nmgr = plNetLinkingMgr::GetInstance();
|
|
|
|
if (nmgr)
|
|
|
|
{
|
|
|
|
plAgeLinkStruct* als = nmgr->GetPrevAgeLink();
|
|
|
|
if (als)
|
|
|
|
return pyAgeInfoStruct::New(als->GetAgeInfo());
|
|
|
|
}
|
|
|
|
PYTHON_RETURN_NONE; // return none, not nil (cause it isn't really an error... or is it?)
|
|
|
|
}
|
|
|
|
|
|
|
|
// current time in current age
|
|
|
|
uint32_t cyMisc::GetAgeTime( void )
|
|
|
|
{
|
|
|
|
return VaultAgeGetAgeTime();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
time_t cyMisc::GetDniTime(void)
|
|
|
|
{
|
|
|
|
const plUnifiedTime utime = plNetClientMgr::GetInstance()->GetServerTime();
|
|
|
|
if ( utime.GetSecs() != 0)
|
|
|
|
return ConvertGMTtoDni(utime.GetSecs());
|
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
time_t cyMisc::GetServerTime(void)
|
|
|
|
{
|
|
|
|
const plUnifiedTime utime = plNetClientMgr::GetInstance()->GetServerTime();
|
|
|
|
return utime.GetSecs();
|
|
|
|
}
|
|
|
|
|
|
|
|
float cyMisc::GetAgeTimeOfDayPercent(void)
|
|
|
|
{
|
|
|
|
return plNetClientMgr::GetInstance()->GetCurrentAgeTimeOfDayPercent();
|
|
|
|
}
|
|
|
|
|
|
|
|
#define kMST (uint32_t)25200
|
|
|
|
#define kOneHour (uint32_t)3600
|
|
|
|
#define kOneDay (uint32_t)86400
|
|
|
|
|
|
|
|
time_t cyMisc::ConvertGMTtoDni(time_t gtime)
|
|
|
|
{
|
|
|
|
// convert to mountain time
|
|
|
|
time_t dtime = gtime - kMST;
|
|
|
|
plUnifiedTime utime = plUnifiedTime();
|
|
|
|
utime.SetSecs(dtime);
|
|
|
|
// check for daylight savings time in New Mexico and adjust
|
|
|
|
if ( utime.GetMonth() >= 3 && utime.GetMonth() <= 11 )
|
|
|
|
{
|
|
|
|
plUnifiedTime dstStart = plUnifiedTime();
|
|
|
|
dstStart.SetGMTime(utime.GetYear(),3,8,2,0,0);
|
|
|
|
// find first Sunday after (including) 3/8 (second Sunday of March)
|
|
|
|
int days_to_go = 7 - dstStart.GetDayOfWeek();
|
|
|
|
if (days_to_go == 7)
|
|
|
|
days_to_go = 0;
|
|
|
|
time_t dstStartSecs = dstStart.GetSecs() + days_to_go * kOneDay;
|
|
|
|
|
|
|
|
plUnifiedTime dstEnd = plUnifiedTime();
|
|
|
|
dstEnd.SetGMTime(utime.GetYear(),11,1,1,0,0);
|
|
|
|
// find first sunday after (including) 11/1 (first Sunday of November)
|
|
|
|
days_to_go = 7 - dstEnd.GetDayOfWeek();
|
|
|
|
if (days_to_go == 7)
|
|
|
|
days_to_go = 0;
|
|
|
|
time_t dstEndSecs = dstEnd.GetSecs() + days_to_go * kOneDay;
|
|
|
|
|
|
|
|
if ( dtime >= dstStartSecs && dtime < dstEndSecs )
|
|
|
|
// add hour for daylight savings time
|
|
|
|
dtime += kOneHour;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dtime;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : ExcludeRegionSet
|
|
|
|
// PARAMETERS : key - of the exclude region, ie. where to send the message
|
|
|
|
// state - what state of to set at:
|
|
|
|
// 0 = release
|
|
|
|
// 1 = clear
|
|
|
|
//
|
|
|
|
// PURPOSE : Sets the state of an exclude region
|
|
|
|
//
|
|
|
|
void cyMisc::ExcludeRegionSet(pyKey& sender, pyKey& exKey, uint16_t state)
|
|
|
|
{
|
|
|
|
plExcludeRegionMsg *msg = new plExcludeRegionMsg;
|
|
|
|
|
|
|
|
switch (state)
|
|
|
|
{
|
|
|
|
case kExRegClear:
|
|
|
|
msg->SetCmd(plExcludeRegionMsg::kClear);
|
|
|
|
break;
|
|
|
|
case kExRegRelease:
|
|
|
|
msg->SetCmd(plExcludeRegionMsg::kRelease);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
msg->SetSender(sender.getKey());
|
|
|
|
msg->AddReceiver(exKey.getKey());
|
|
|
|
plgDispatch::MsgSend( msg ); // whoosh... off it goes
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::ExcludeRegionSetNow(pyKey& sender, pyKey& exKey, uint16_t state)
|
|
|
|
{
|
|
|
|
plExcludeRegionMsg *msg = new plExcludeRegionMsg;
|
|
|
|
|
|
|
|
switch (state)
|
|
|
|
{
|
|
|
|
case kExRegClear:
|
|
|
|
msg->SetCmd(plExcludeRegionMsg::kClear);
|
|
|
|
break;
|
|
|
|
case kExRegRelease:
|
|
|
|
msg->SetCmd(plExcludeRegionMsg::kRelease);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
msg->SetSender(sender.getKey());
|
|
|
|
msg->AddReceiver(exKey.getKey());
|
|
|
|
msg->fSynchFlags = plSynchedObject::kSendImmediately;
|
|
|
|
plgDispatch::MsgSend( msg ); // whoosh... off it goes
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::FlashWindow()
|
|
|
|
{
|
|
|
|
plKey clientKey = hsgResMgr::ResMgr()->FindKey(kClient_KEY);
|
|
|
|
plClientMsg* pMsg = new plClientMsg(plClientMsg::kFlashWindow);
|
|
|
|
pMsg->Send(clientKey); // whoosh... off it goes
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "hsTimer.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetSeconds
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the nunber of seconds elapsed
|
|
|
|
//
|
|
|
|
double cyMisc::GetSeconds()
|
|
|
|
{
|
|
|
|
return hsTimer::GetSeconds();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetSysSeconds
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the number of system seconds elapsed
|
|
|
|
//
|
|
|
|
double cyMisc::GetSysSeconds()
|
|
|
|
{
|
|
|
|
return hsTimer::GetSysSeconds();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetDelSysSeconds
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the frame delta seconds
|
|
|
|
//
|
|
|
|
float cyMisc::GetDelSysSeconds()
|
|
|
|
{
|
|
|
|
return hsTimer::GetDelSysSeconds();
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : LoadDialog
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the frame delta seconds
|
|
|
|
//
|
|
|
|
void cyMisc::LoadDialog(const char* name)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
{
|
|
|
|
if ( !mgr->IsDialogLoaded(name) )
|
|
|
|
mgr->LoadDialog( name );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Load dialog and set the GUINotifyMsg receiver key
|
|
|
|
void cyMisc::LoadDialogK(const char* name, pyKey& rKey)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
{
|
|
|
|
// has the dialog been loaded yet?
|
|
|
|
if ( !mgr->IsDialogLoaded(name) )
|
|
|
|
// no then load and set handler
|
|
|
|
mgr->LoadDialog( name, rKey.getKey() );
|
|
|
|
else
|
|
|
|
// yes then just set the handler
|
|
|
|
mgr->SetDialogToNotify(name,rKey.getKey());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Load dialog and set the GUINotifyMsg receiver key
|
|
|
|
void cyMisc::LoadDialogKA(const char* name, pyKey& rKey, const char* ageName)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
{
|
|
|
|
// has the dialog been loaded yet?
|
|
|
|
if ( !mgr->IsDialogLoaded(name) )
|
|
|
|
// no then load and set handler
|
|
|
|
mgr->LoadDialog( name, rKey.getKey(), ageName );
|
|
|
|
else
|
|
|
|
// yes then just set the handler
|
|
|
|
mgr->SetDialogToNotify(name,rKey.getKey());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : UnLoadDialog
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : UnLoads the dialog by name
|
|
|
|
// : optionally sets the receiver key for the GUINotifyMsg
|
|
|
|
//
|
|
|
|
void cyMisc::UnloadDialog(const char* name)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
{
|
|
|
|
if ( mgr->IsDialogLoaded(name) )
|
|
|
|
mgr->UnloadDialog( name );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : IsDialogLoaded
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Test to see if a dialog is loaded (according to the dialog manager)
|
|
|
|
//
|
|
|
|
bool cyMisc::IsDialogLoaded(const char* name)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
return mgr->IsDialogLoaded(name);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : ShowDialog
|
|
|
|
// Function : HideDialog
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Show or Hide a dialog by name
|
|
|
|
//
|
|
|
|
void cyMisc::ShowDialog(const char* name)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
mgr->ShowDialog(name);
|
|
|
|
}
|
|
|
|
void cyMisc::HideDialog(const char* name)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
mgr->HideDialog(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetDialogFromTagID
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return the frame delta seconds
|
|
|
|
//
|
|
|
|
PyObject* cyMisc::GetDialogFromTagID(uint32_t tag)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
{
|
|
|
|
// get the owner dialog modifier pointer
|
|
|
|
pfGUIDialogMod* pdialog = mgr->GetDialogFromTag(tag);
|
|
|
|
if ( pdialog )
|
|
|
|
return pyGUIDialog::New(pdialog->GetKey());
|
|
|
|
}
|
|
|
|
|
|
|
|
plString errmsg = plFormat("GUIDialog TagID {} not found", tag);
|
|
|
|
PyErr_SetString(PyExc_KeyError, errmsg.c_str());
|
|
|
|
return nil; // return nil, cause we threw an error
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::GetDialogFromString(const char* name)
|
|
|
|
{
|
|
|
|
pfGameGUIMgr *mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if ( mgr )
|
|
|
|
{
|
|
|
|
// get the owner dialog modifier pointer
|
|
|
|
pfGUIDialogMod* pdialog = mgr->GetDialogFromString(name);
|
|
|
|
if ( pdialog )
|
|
|
|
return pyGUIDialog::New(pdialog->GetKey());
|
|
|
|
}
|
|
|
|
|
|
|
|
plString errmsg = plFormat("GUIDialog {} not found", name);
|
|
|
|
PyErr_SetString(PyExc_KeyError, errmsg.c_str());
|
|
|
|
return nil; // return nil, cause we threw an error
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : IsGUIModal
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns true if the GUI is currently modal (and therefore blocking input)
|
|
|
|
//
|
|
|
|
bool cyMisc::IsGUIModal()
|
|
|
|
{
|
|
|
|
pfGameGUIMgr* mgr = pfGameGUIMgr::GetInstance();
|
|
|
|
if (mgr)
|
|
|
|
return mgr->IsModalBlocking();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetLocalAvatar
|
|
|
|
// Function : GetLocalPlayer
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Return a pySceneobject of the local Avatar
|
|
|
|
// : Player - returns ptPlayer object
|
|
|
|
//
|
|
|
|
PyObject* cyMisc::GetLocalAvatar()
|
|
|
|
{
|
|
|
|
plSceneObject *so = plSceneObject::ConvertNoRef(plNetClientMgr::GetInstance()->GetLocalPlayer());
|
|
|
|
if ( so )
|
|
|
|
return pySceneObject::New(so->GetKey());
|
|
|
|
|
|
|
|
PyErr_SetString(PyExc_NameError, "Local avatar not found");
|
|
|
|
return nil; // returns nil, cause we threw an error
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::GetLocalPlayer()
|
|
|
|
{
|
|
|
|
return pyPlayer::New(plNetClientMgr::GetInstance()->GetLocalPlayerKey(),
|
|
|
|
plNetClientMgr::GetInstance()->GetPlayerName(),
|
|
|
|
plNetClientMgr::GetInstance()->GetPlayerID(),
|
|
|
|
0.0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetNPC
|
|
|
|
// PARAMETERS : npcID - is the ID of an NPC
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns a pySceneobject of an NPC
|
|
|
|
//
|
|
|
|
PyObject* cyMisc::GetNPC(int npcID)
|
|
|
|
{
|
|
|
|
plSceneObject *so = plSceneObject::ConvertNoRef(plNetClientMgr::GetInstance()->GetNPC(npcID));
|
|
|
|
if ( so )
|
|
|
|
return pySceneObject::New(so->GetKey());
|
|
|
|
|
|
|
|
char* errmsg = "NPC not found";
|
|
|
|
PyErr_SetString(PyExc_NameError, errmsg);
|
|
|
|
PYTHON_RETURN_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::GetNPCCount()
|
|
|
|
{
|
|
|
|
return PyInt_FromLong(plNetClientMgr::GetInstance()->NPCKeys().size());
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 1
|
|
|
|
#include "plStatusLog/plStatusLog.h"
|
|
|
|
//
|
|
|
|
// TEMP SCREEN PRINT CODE FOR NON-DBG TEXT DISPLAY
|
|
|
|
//
|
|
|
|
void cyMisc::PrintToScreen(const char* msg)
|
|
|
|
{
|
|
|
|
static plStatusLog* gStatusLog=nil;
|
|
|
|
if (gStatusLog==nil)
|
|
|
|
{
|
|
|
|
gStatusLog = plStatusLogMgr::GetInstance().CreateStatusLog( 32, "",
|
|
|
|
plStatusLog::kDontWriteFile | plStatusLog::kDeleteForMe | plStatusLog::kFilledBackground );
|
|
|
|
plStatusLogMgr::GetInstance().ToggleStatusLog(gStatusLog);
|
|
|
|
}
|
|
|
|
gStatusLog->AddLine(msg, plStatusLog::kBlue);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "plPipeline.h"
|
|
|
|
#include "plGImage/plMipmap.h"
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetPlayerList
|
|
|
|
// Function : GetPlayerListDistanceSorted
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Get a list of players (other than self) that are playing the game
|
|
|
|
// : optionally get it sorted by distance
|
|
|
|
//
|
|
|
|
// RETURNS : Python object list of pyPlayer s
|
|
|
|
//
|
|
|
|
std::vector<PyObject*> cyMisc::GetPlayerList()
|
|
|
|
{
|
|
|
|
std::vector<PyObject*> pyPL;
|
|
|
|
plNetClientMgr* nc=plNetClientMgr::GetInstance();
|
|
|
|
|
|
|
|
if (!nc) // only ever really happens if they try to call us in max... I hope
|
|
|
|
return pyPL;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
for( i = 0; i < nc->TransportMgr().GetNumMembers(); i++ )
|
|
|
|
{
|
|
|
|
plNetTransportMember *mbr = nc->TransportMgr().GetMember(i);
|
|
|
|
plKey avkey = mbr->GetAvatarKey();
|
|
|
|
if (avkey)
|
|
|
|
{
|
|
|
|
// only non-ignored people in list and not in ignore list
|
|
|
|
if ( !VaultAmIgnoringPlayer ( mbr->GetPlayerID()) )
|
|
|
|
{
|
|
|
|
PyObject* playerObj = pyPlayer::New(avkey, mbr->GetPlayerName().c_str(), mbr->GetPlayerID(), mbr->GetDistSq());
|
|
|
|
pyPlayer* player = pyPlayer::ConvertFrom(playerObj); // accesses internal pyPlayer object
|
|
|
|
|
|
|
|
// modifies playerObj
|
|
|
|
if ( mbr->IsCCR() )
|
|
|
|
player->SetCCRFlag(true);
|
|
|
|
if ( mbr->IsServer() )
|
|
|
|
player->SetServerFlag(true);
|
|
|
|
|
|
|
|
pyPL.push_back(playerObj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return pyPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<PyObject*> cyMisc::GetPlayerListDistanceSorted()
|
|
|
|
{
|
|
|
|
std::vector<PyObject*> pyPL;
|
|
|
|
|
|
|
|
// get the sorted member list from the Net transport manager
|
|
|
|
plNetTransportMember **members = nil;
|
|
|
|
plNetClientMgr::GetInstance()->TransportMgr().GetMemberListDistSorted( members );
|
|
|
|
if( members != nil )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for( i = 0; i < plNetClientMgr::GetInstance()->TransportMgr().GetNumMembers(); i++ )
|
|
|
|
{
|
|
|
|
plNetTransportMember *mbr = members[ i ];
|
|
|
|
plKey avkey = mbr->GetAvatarKey();
|
|
|
|
if (avkey)
|
|
|
|
{
|
|
|
|
// only non-ignored people in list and not in ignore list
|
|
|
|
if ( !VaultAmIgnoringPlayer ( mbr->GetPlayerID()) )
|
|
|
|
{
|
|
|
|
PyObject* playerObj = pyPlayer::New(avkey, mbr->GetPlayerName().c_str(), mbr->GetPlayerID(), mbr->GetDistSq());
|
|
|
|
pyPlayer* player = pyPlayer::ConvertFrom(playerObj); // accesses internal pyPlayer object
|
|
|
|
|
|
|
|
// modifies playerObj
|
|
|
|
if ( mbr->IsCCR() )
|
|
|
|
player->SetCCRFlag(true);
|
|
|
|
if ( mbr->IsServer() )
|
|
|
|
player->SetServerFlag(true);
|
|
|
|
|
|
|
|
pyPL.push_back(playerObj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
delete [] members;
|
|
|
|
}
|
|
|
|
return pyPL;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t cyMisc::GetMaxListenListSize()
|
|
|
|
{
|
|
|
|
return plNetListenList::kMaxListenListSize;
|
|
|
|
}
|
|
|
|
|
|
|
|
float cyMisc::GetMaxListenDistSq()
|
|
|
|
{
|
|
|
|
return plNetListenList::kMaxListenDistSq;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SendRTChat
|
|
|
|
// PARAMETERS : from - is a pyPlayer of the person who is sending this
|
|
|
|
// : tolist - is a python list object, if empty then broadcast message
|
|
|
|
// : message - text string to send to others
|
|
|
|
// : flags - the flags of destiny... whatever that means
|
|
|
|
//
|
|
|
|
// PURPOSE : To send a real time chat message to a particualr user, a list of users
|
|
|
|
// : or broadcast it to everyone (within hearing distance?)
|
|
|
|
//
|
|
|
|
// RETURNS : the flags that were sent with the message (may be modified)
|
|
|
|
//
|
|
|
|
uint32_t cyMisc::SendRTChat(const pyPlayer& from, const std::vector<pyPlayer*> & tolist, const plString& message, uint32_t flags)
|
|
|
|
{
|
|
|
|
// create the messge that will contain the chat message
|
|
|
|
pfKIMsg *msg = new pfKIMsg( pfKIMsg::kHACKChatMsg );
|
|
|
|
msg->SetString( message );
|
|
|
|
msg->SetUser( from.GetPlayerName(), from.GetPlayerID() );
|
|
|
|
msg->SetFlags( flags );
|
|
|
|
msg->SetBCastFlag(plMessage::kNetPropagate | plMessage::kNetForce);
|
|
|
|
msg->SetBCastFlag(plMessage::kLocalPropagate, 0);
|
|
|
|
|
|
|
|
// this goes to everybody on the shard
|
|
|
|
if (flags & pfKIMsg::kGlobalMsg)
|
|
|
|
msg->SetBCastFlag(plMessage::kCCRSendToAllPlayers);
|
|
|
|
// allow inter-age routing of this msg
|
|
|
|
if (flags & pfKIMsg::kInterAgeMsg)
|
|
|
|
msg->SetBCastFlag( plMessage::kNetAllowInterAge );
|
|
|
|
|
|
|
|
// add net rcvrs to msg
|
|
|
|
for ( auto it = tolist.begin(); it != tolist.end(); ++it )
|
|
|
|
{
|
|
|
|
pyPlayer* to = *it;
|
|
|
|
if ( !VaultAmIgnoringPlayer( to->GetPlayerID() ) )
|
|
|
|
msg->AddNetReceiver(to->GetPlayerID());
|
|
|
|
}
|
|
|
|
|
|
|
|
msg->Send();
|
|
|
|
return flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SendKIMessage
|
|
|
|
// PARAMETERS : command - the command type
|
|
|
|
// : value - extra value
|
|
|
|
//
|
|
|
|
// PURPOSE : Send message to the KI, to tell it things to do
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
void cyMisc::SendKIMessage(uint32_t command, float value)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
pfKIMsg *msg = new pfKIMsg( (uint8_t)command );
|
|
|
|
|
|
|
|
// check to see if the value makes any sense
|
|
|
|
if ( command == pfKIMsg::kSetChatFadeDelay )
|
|
|
|
{
|
|
|
|
msg->SetDelay(value);
|
|
|
|
}
|
|
|
|
else if ( command == pfKIMsg::kSetTextChatAdminMode )
|
|
|
|
{
|
|
|
|
msg->SetFlags( value==1.0f ? pfKIMsg::kAdminMsg : 0 );
|
|
|
|
}
|
|
|
|
// send it off
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SendKIMessageS
|
|
|
|
// PARAMETERS : command - the command type
|
|
|
|
// : value - extra value as a string
|
|
|
|
//
|
|
|
|
// PURPOSE : Send message to the KI, to tell it things to do
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
void cyMisc::SendKIMessageS(uint32_t command, const wchar_t* value)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
pfKIMsg *msg = new pfKIMsg( (uint8_t)command );
|
|
|
|
|
|
|
|
msg->SetString( plString::FromWchar( value ) );
|
|
|
|
|
|
|
|
// send it off
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SendKIMessageI
|
|
|
|
// PARAMETERS : command - the command type
|
|
|
|
// : value - extra value as an int32_t
|
|
|
|
//
|
|
|
|
// PURPOSE : Send message to the KI, to tell it things to do
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
void cyMisc::SendKIMessageI(uint32_t command, int32_t value)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
pfKIMsg *msg = new pfKIMsg( (uint8_t)command );
|
|
|
|
|
|
|
|
msg->SetIntValue(value);
|
|
|
|
|
|
|
|
// send it off
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SendKIMessageIReply
|
|
|
|
// PARAMETERS : command - the command type
|
|
|
|
// : value - extra value as an int32_t
|
|
|
|
//
|
|
|
|
// PURPOSE : Send message to the KI, to tell it things to do
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
void cyMisc::SendKIGZMarkerMsg(int32_t markerNumber, pyKey& sender)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
pfKIMsg *msg = new pfKIMsg( pfKIMsg::kGZInRange );
|
|
|
|
|
|
|
|
msg->SetIntValue(markerNumber);
|
|
|
|
msg->SetSender(sender.getKey());
|
|
|
|
|
|
|
|
// send it off
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SendKIRegisterImagerMsg(const char* imagerName, pyKey& sender)
|
|
|
|
{
|
|
|
|
pfKIMsg *msg = new pfKIMsg(pfKIMsg::kRegisterImager);
|
|
|
|
|
|
|
|
msg->SetString(imagerName);
|
|
|
|
msg->SetSender(sender.getKey());
|
|
|
|
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : YesNoDialog
|
|
|
|
// PARAMETERS : sender - who set this and will get the notify
|
|
|
|
// : message - message to put up in YesNo dialog
|
|
|
|
//
|
|
|
|
// PURPOSE : Put up Yes/No dialog
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
|
|
|
|
void cyMisc::YesNoDialog(pyKey& sender, const char* thestring)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
pfKIMsg *msg = new pfKIMsg( pfKIMsg::kYesNoDialog );
|
|
|
|
|
|
|
|
msg->SetSender(sender.getKey());
|
|
|
|
msg->SetString(thestring);
|
|
|
|
// send it off
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::YesNoDialog(pyKey& sender, std::wstring thestring)
|
|
|
|
{
|
|
|
|
char *temp = hsWStringToString(thestring.c_str());
|
|
|
|
YesNoDialog(sender,temp);
|
|
|
|
delete [] temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : RateIt
|
|
|
|
// PARAMETERS : chonicleName - where to store the rating
|
|
|
|
// : thestring - the message in the RateIt dialog
|
|
|
|
// : onceFlag - flag to tell whether this is a onetime thing or ask everytime
|
|
|
|
//
|
|
|
|
// PURPOSE : Send message to the KI to tell it to ask the user to Rate something
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
void cyMisc::RateIt(const char* chronicleName, const char* thestring, bool onceFlag)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
pfKIMsg *msg = new pfKIMsg( pfKIMsg::kRateIt );
|
|
|
|
|
|
|
|
msg->SetUser(chronicleName,0);
|
|
|
|
msg->SetString(thestring);
|
|
|
|
msg->SetIntValue(onceFlag);
|
|
|
|
// send it off
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SetPrivateChatList
|
|
|
|
// PARAMETERS : key - who's joining
|
|
|
|
//
|
|
|
|
// PURPOSE : Lock the local avatar into private vox messaging, and / or add new memebers to his chat list
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
|
|
|
|
void cyMisc::SetPrivateChatList(const std::vector<pyPlayer*> & tolist)
|
|
|
|
{
|
|
|
|
if (tolist.size() > 0)
|
|
|
|
{
|
|
|
|
plNetVoiceListMsg* pMsg = new plNetVoiceListMsg(plNetVoiceListMsg::kForcedListenerMode);
|
|
|
|
for (int i=0 ; i<tolist.size() ; i++ )
|
|
|
|
pMsg->GetClientList()->Append(tolist[i]->GetPlayerID());
|
|
|
|
|
|
|
|
plKey k = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
|
|
|
|
pMsg->SetRemovedKey(k);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : ClearPrivateChatList
|
|
|
|
// PARAMETERS : key - who's leaving
|
|
|
|
//
|
|
|
|
// PURPOSE : Remove the local avatar from private vox messaging, and / or clear memebers from his chat list
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
void cyMisc::ClearPrivateChatList(pyKey& member)
|
|
|
|
{
|
|
|
|
plNetVoiceListMsg* pMsg = new plNetVoiceListMsg(plNetVoiceListMsg::kDistanceMode);
|
|
|
|
plKey k = member.getKey();
|
|
|
|
pMsg->SetRemovedKey(k);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : ClearCameraStack
|
|
|
|
// PURPOSE : clear the camera stack
|
|
|
|
//
|
|
|
|
// RETURNS : nothing
|
|
|
|
//
|
|
|
|
|
|
|
|
void cyMisc::ClearCameraStack()
|
|
|
|
{
|
|
|
|
plVirtualCam1::Instance()->ClearStack();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cyMisc::IsFirstPerson()
|
|
|
|
{
|
|
|
|
return (plVirtualCam1::Instance()->Is1stPersonCamera()!=0);
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SendPetitionToCCR
|
|
|
|
// PARAMETERS : message - message to send to the CCR ("please help me!")
|
|
|
|
//
|
|
|
|
// PURPOSE : Send a petition to the CCR for help or questions
|
|
|
|
//
|
|
|
|
void cyMisc::SendPetitionToCCR(const char* message)
|
|
|
|
{
|
|
|
|
SendPetitionToCCRI(message,plNetCommon::PetitionTypes::kGeneralHelp,nil);
|
|
|
|
}
|
|
|
|
void cyMisc::SendPetitionToCCRI(const char* message, uint8_t reason,const char* title)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
plCCRPetitionMsg *msg = new plCCRPetitionMsg();
|
|
|
|
msg->SetNote(message);
|
|
|
|
msg->SetType(reason);
|
|
|
|
if (title)
|
|
|
|
msg->SetTitle(title);
|
|
|
|
// send it off
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : SendChatToCCR
|
|
|
|
// PARAMETERS : message - message to send to the CCR ("please help me!")
|
|
|
|
//
|
|
|
|
// PURPOSE : Send a chat message to the CCR for help or questions
|
|
|
|
//
|
|
|
|
void cyMisc::SendChatToCCR(const char* message,int32_t CCRPlayerID)
|
|
|
|
{
|
|
|
|
// create the mesage to send
|
|
|
|
plCCRCommunicationMsg *msg = new plCCRCommunicationMsg();
|
|
|
|
msg->SetMessage(message);
|
|
|
|
msg->SetType(plCCRCommunicationMsg::kReturnChatMsg);
|
|
|
|
msg->SetBCastFlag(plMessage::kNetAllowInterAge);
|
|
|
|
msg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
msg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
msg->SetBCastFlag(plMessage::kLocalPropagate,0);
|
|
|
|
msg->AddNetReceiver( CCRPlayerID );
|
|
|
|
msg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetNumRemotePlayers
|
|
|
|
//
|
|
|
|
// PURPOSE : return the number of remote players connected
|
|
|
|
//
|
|
|
|
int cyMisc::GetNumRemotePlayers()
|
|
|
|
{
|
|
|
|
return plNetClientMgr::GetInstance()->RemotePlayerKeys().size();
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Paging functions
|
|
|
|
// PARAMETERS : nodeName - name of the page to load
|
|
|
|
//
|
|
|
|
// PURPOSE : page in, hold or out a particular node
|
|
|
|
//
|
|
|
|
|
|
|
|
void cyMisc::PageInNodes(const std::vector<std::string> & nodeNames, const char* age, bool netForce)
|
|
|
|
{
|
|
|
|
if (hsgResMgr::ResMgr())
|
|
|
|
{
|
|
|
|
plSynchEnabler ps(false); // disable dirty tracking while paging in
|
|
|
|
plClientMsg* msg = new plClientMsg(plClientMsg::kLoadRoom);
|
|
|
|
plKey clientKey = hsgResMgr::ResMgr()->FindKey(kClient_KEY);
|
|
|
|
msg->AddReceiver(clientKey);
|
|
|
|
|
|
|
|
if (netForce) {
|
|
|
|
msg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
msg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
}
|
|
|
|
|
|
|
|
int numNames = nodeNames.size();
|
|
|
|
for (int i = 0; i < numNames; i++)
|
|
|
|
msg->AddRoomLoc(plKeyFinder::Instance().FindLocation(age ? age : NetCommGetAge()->ageDatasetName, nodeNames[i].c_str()));
|
|
|
|
|
|
|
|
msg->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::PageOutNode(const char* nodeName, bool netForce)
|
|
|
|
{
|
|
|
|
if ( hsgResMgr::ResMgr() )
|
|
|
|
{
|
|
|
|
plSynchEnabler ps(false); // disable dirty tracking while paging out
|
|
|
|
plClientMsg* pMsg1 = new plClientMsg(plClientMsg::kUnloadRoom);
|
|
|
|
plKey clientKey = hsgResMgr::ResMgr()->FindKey( kClient_KEY );
|
|
|
|
pMsg1->AddReceiver( clientKey );
|
|
|
|
pMsg1->AddRoomLoc(plKeyFinder::Instance().FindLocation("", nodeName));
|
|
|
|
|
|
|
|
if (netForce) {
|
|
|
|
pMsg1->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg1->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
}
|
|
|
|
plgDispatch::MsgSend(pMsg1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#include "plAvatar/plArmatureMod.h"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : LimitAvatarLOD
|
|
|
|
// PARAMETERS : LODlimit - number of to limit the LOD to
|
|
|
|
//
|
|
|
|
// PURPOSE : sets the avatar LOD limit
|
|
|
|
//
|
|
|
|
void cyMisc::LimitAvatarLOD(int LODlimit)
|
|
|
|
{
|
|
|
|
if(LODlimit >= 0 && LODlimit <= 2)
|
|
|
|
plArmatureLODMod::fMinLOD = LODlimit;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#include "plPipeline/plFogEnvironment.h"
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Set fog default functions
|
|
|
|
// PARAMETERS : floats - the parameters
|
|
|
|
//
|
|
|
|
// PURPOSE : sets the fog defaults
|
|
|
|
//
|
|
|
|
void cyMisc::FogSetDefColor(pyColor& color)
|
|
|
|
{
|
|
|
|
if ( fPipeline )
|
|
|
|
{
|
|
|
|
hsColorRGBA hcolor = color.getColor();
|
|
|
|
hcolor.a = 1.0f; // make sure that alpha is 1
|
|
|
|
plFogEnvironment env = fPipeline->GetDefaultFogEnviron();
|
|
|
|
env.SetColor( hcolor );
|
|
|
|
fPipeline->SetDefaultFogEnviron( &env );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::FogSetDefLinear(float start, float end, float density)
|
|
|
|
{
|
|
|
|
if ( fPipeline )
|
|
|
|
{
|
|
|
|
plFogEnvironment env = fPipeline->GetDefaultFogEnviron();
|
|
|
|
env.Set( start, end, density );
|
|
|
|
fPipeline->SetDefaultFogEnviron( &env );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::FogSetDefExp(float end, float density)
|
|
|
|
{
|
|
|
|
if ( fPipeline )
|
|
|
|
{
|
|
|
|
plFogEnvironment env = fPipeline->GetDefaultFogEnviron();
|
|
|
|
env.SetExp( plFogEnvironment::kExpFog, end, density );
|
|
|
|
fPipeline->SetDefaultFogEnviron( &env );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::FogSetDefExp2(float end, float density)
|
|
|
|
{
|
|
|
|
if ( fPipeline )
|
|
|
|
{
|
|
|
|
plFogEnvironment env = fPipeline->GetDefaultFogEnviron();
|
|
|
|
env.SetExp( plFogEnvironment::kExp2Fog, end, density );
|
|
|
|
fPipeline->SetDefaultFogEnviron( &env );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void cyMisc::SetClearColor(float red, float green, float blue)
|
|
|
|
{
|
|
|
|
// do this command via the console to keep the maxplugins from barfing
|
|
|
|
plString command = plFormat("Graphics.Renderer.SetClearColor {f} {f} {f}", red, green, blue);
|
|
|
|
|
|
|
|
// create message to send to the console
|
|
|
|
plControlEventMsg* pMsg = new plControlEventMsg;
|
|
|
|
pMsg->SetBCastFlag(plMessage::kBCastByType);
|
|
|
|
pMsg->SetControlCode(B_CONTROL_CONSOLE_COMMAND);
|
|
|
|
pMsg->SetControlActivated(true);
|
|
|
|
pMsg->SetCmdString(command.c_str());
|
|
|
|
plgDispatch::MsgSend( pMsg ); // whoosh... off it goes
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Enable / disable cursor fade for avatar
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : turns avatar fade out on / off
|
|
|
|
//
|
|
|
|
|
|
|
|
void cyMisc::EnableAvatarCursorFade()
|
|
|
|
{
|
|
|
|
plNetClientMgr* nmgr = plNetClientMgr::GetInstance();
|
|
|
|
if (nmgr)
|
|
|
|
{
|
|
|
|
plIfaceFadeAvatarMsg* iMsg = new plIfaceFadeAvatarMsg;
|
|
|
|
iMsg->SetSubjectKey(nmgr->GetLocalPlayerKey());
|
|
|
|
iMsg->SetBCastFlag(plMessage::kBCastByExactType);
|
|
|
|
iMsg->SetBCastFlag(plMessage::kNetPropagate, false);
|
|
|
|
iMsg->Enable();
|
|
|
|
iMsg->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::DisableAvatarCursorFade()
|
|
|
|
{
|
|
|
|
plNetClientMgr* nmgr = plNetClientMgr::GetInstance();
|
|
|
|
if (nmgr)
|
|
|
|
{
|
|
|
|
plIfaceFadeAvatarMsg* iMsg = new plIfaceFadeAvatarMsg;
|
|
|
|
iMsg->SetSubjectKey(nmgr->GetLocalPlayerKey());
|
|
|
|
iMsg->SetBCastFlag(plMessage::kBCastByExactType);
|
|
|
|
iMsg->SetBCastFlag(plMessage::kNetPropagate, false);
|
|
|
|
iMsg->Disable();
|
|
|
|
iMsg->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::FadeLocalPlayer(bool fade)
|
|
|
|
{
|
|
|
|
plNetClientMgr* nmgr = plNetClientMgr::GetInstance();
|
|
|
|
if (nmgr)
|
|
|
|
{
|
|
|
|
plCameraTargetFadeMsg* pMsg = new plCameraTargetFadeMsg;
|
|
|
|
pMsg->SetFadeOut(fade);
|
|
|
|
pMsg->SetSubjectKey(nmgr->GetLocalPlayerKey());
|
|
|
|
pMsg->SetBCastFlag(plMessage::kBCastByExactType);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate, false);
|
|
|
|
pMsg->AddReceiver(nmgr->GetLocalPlayerKey());
|
|
|
|
plgDispatch::MsgSend(pMsg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : offer linking book functions
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : manage offering public (pedestal) books
|
|
|
|
//
|
|
|
|
|
|
|
|
void cyMisc::EnableOfferBookMode(pyKey& selfkey, const char* ageFilename, const char* ageInstanceName)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kSetOfferBookMode);
|
|
|
|
pMsg->SetSender(selfkey.getKey());
|
|
|
|
pMsg->SetAgeFileName(ageFilename);
|
|
|
|
pMsg->SetAgeName(ageInstanceName);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::DisableOfferBookMode()
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kClearOfferBookMode);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::NotifyOffererPublicLinkCompleted(uint32_t offerer)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kNotifyOfferCompleted, plNetClientMgr::GetInstance()->GetPlayerID());
|
|
|
|
pMsg->SetSender(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
|
|
|
|
if (offerer != plNetClientMgr::GetInstance()->GetPlayerID())
|
|
|
|
{
|
|
|
|
pMsg->SetBCastFlag( plMessage::kNetPropagate );
|
|
|
|
pMsg->SetBCastFlag( plMessage::kNetForce );
|
|
|
|
pMsg->SetBCastFlag( plMessage::kLocalPropagate, 0 );
|
|
|
|
pMsg->AddNetReceiver( offerer );
|
|
|
|
}
|
|
|
|
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::NotifyOffererPublicLinkRejected(uint32_t offerer)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kNotifyOfferRejected);
|
|
|
|
pMsg->SetSender(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
|
|
|
|
if (offerer != plNetClientMgr::GetInstance()->GetPlayerID())
|
|
|
|
{
|
|
|
|
pMsg->SetBCastFlag( plMessage::kNetPropagate );
|
|
|
|
pMsg->SetBCastFlag( plMessage::kNetForce );
|
|
|
|
pMsg->SetBCastFlag( plMessage::kLocalPropagate, 0 );
|
|
|
|
pMsg->AddNetReceiver( offerer );
|
|
|
|
}
|
|
|
|
|
|
|
|
pMsg->Send();
|
|
|
|
ToggleAvatarClickability(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::NotifyOffererPublicLinkAccepted(uint32_t offerer)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kNotifyOfferAccepted);
|
|
|
|
pMsg->SetSender(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
|
|
|
|
if (offerer != plNetClientMgr::GetInstance()->GetPlayerID())
|
|
|
|
{
|
|
|
|
pMsg->SetBCastFlag( plMessage::kNetPropagate );
|
|
|
|
pMsg->SetBCastFlag( plMessage::kNetForce );
|
|
|
|
pMsg->SetBCastFlag( plMessage::kLocalPropagate, 0 );
|
|
|
|
pMsg->AddNetReceiver( offerer );
|
|
|
|
}
|
|
|
|
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::ToggleAvatarClickability(bool on)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = 0;
|
|
|
|
if (on)
|
|
|
|
pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kGUIEnableAvatarClickable);
|
|
|
|
else
|
|
|
|
pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kGUIDisableAvatarClickable);
|
|
|
|
plKey k = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
|
|
|
|
pMsg->SetAvKey(k);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
pMsg->Send();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SetShareSpawnPoint(const char* spawnPoint)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kSetShareSpawnPoint);
|
|
|
|
plKey k = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
|
|
|
|
pMsg->SetSender(k);
|
|
|
|
pMsg->SetSpawnPoint(spawnPoint);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SetShareAgeInstanceGuid(const plUUID& guid)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* pMsg = new plInputIfaceMgrMsg(plInputIfaceMgrMsg::kSetShareAgeInstanceGuid);
|
|
|
|
plKey k = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
|
|
|
|
pMsg->SetSender(k);
|
|
|
|
pMsg->SetAgeInstanceGuid(guid);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetCCRAwayStatus
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns current status of CCR dept
|
|
|
|
//
|
|
|
|
bool cyMisc::IsCCRAwayStatus()
|
|
|
|
{
|
|
|
|
return !VaultGetCCRStatus();
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : AmCCR
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns true if local player is a CCR
|
|
|
|
//
|
|
|
|
bool cyMisc::AmCCR()
|
|
|
|
{
|
|
|
|
if ( plNetClientApp::GetInstance() )
|
|
|
|
return plNetClientApp::GetInstance()->AmCCR();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : AcceptInviteInGame
|
|
|
|
// PARAMETERS : Friend's Name, Invite Key
|
|
|
|
//
|
|
|
|
// PURPOSE : Send's a VaultTask to the server to perform the invite
|
|
|
|
//
|
|
|
|
void cyMisc::AcceptInviteInGame(const char* friendName, const char* inviteKey)
|
|
|
|
{
|
|
|
|
hsAssert(false, "eric, implement me");
|
|
|
|
#if 0
|
|
|
|
plNetClientMgr* nc = plNetClientMgr::GetInstance();
|
|
|
|
if (nc)
|
|
|
|
{
|
|
|
|
plNetMsgVaultTask msg;
|
|
|
|
msg.SetNetProtocol(kNetProtocolCli2Auth);
|
|
|
|
msg.SetTopic(plNetCommon::VaultTasks::kFriendInvite);
|
|
|
|
msg.GetArgs()->AddString(plNetCommon::VaultTaskArgs::kFriendName,friendName);
|
|
|
|
msg.GetArgs()->AddString(plNetCommon::VaultTaskArgs::kInviteKey,inviteKey);
|
|
|
|
nc->SendMsg(&msg);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetLanguage
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns the current language the game is in
|
|
|
|
//
|
|
|
|
int cyMisc::GetLanguage()
|
|
|
|
{
|
|
|
|
return int(plLocalization::GetLanguage());
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : UsingUnicode
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns true if the current language uses Unicode (like Japanese)
|
|
|
|
//
|
|
|
|
bool cyMisc::UsingUnicode()
|
|
|
|
{
|
|
|
|
return plLocalization::UsingUnicode();
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// particle system management
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
#include "plMessage/plParticleUpdateMsg.h"
|
|
|
|
#include "plParticleSystem/plParticleSystem.h"
|
|
|
|
#include "plParticleSystem/plParticleEffect.h"
|
|
|
|
void cyMisc::TransferParticlesToKey(pyKey& fromKey, pyKey& toKey, int numParticles)
|
|
|
|
{
|
|
|
|
plKey frKey = fromKey.getKey();
|
|
|
|
plSceneObject* so = plSceneObject::ConvertNoRef(toKey.getKey()->ObjectIsLoaded());
|
|
|
|
if (so == nil)
|
|
|
|
return;
|
|
|
|
|
|
|
|
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
|
|
|
|
|
|
|
|
plParticleTransferMsg* pMsg = new plParticleTransferMsg(nil, avMod->GetKey(), 0, frKey, numParticles);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SetParticleDissentPoint(float x, float y, float z, pyKey& particles)
|
|
|
|
{
|
|
|
|
plKey frKey = particles.getKey();
|
|
|
|
plSceneObject* pObj = plSceneObject::ConvertNoRef(particles.getKey()->ObjectIsLoaded());
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
const plParticleSystem *sys = plParticleSystem::ConvertNoRef(pObj->GetModifierByType(plParticleSystem::Index()));
|
|
|
|
if (sys == nil)
|
|
|
|
{
|
|
|
|
const plModifier* pArm = pObj->GetModifierByType(plArmatureMod::Index());
|
|
|
|
if (pArm)
|
|
|
|
{
|
|
|
|
// it's the avatar
|
|
|
|
const plArmatureMod* pCArm = (const plArmatureMod*)pArm;
|
|
|
|
plArmatureMod* pNonConstArm = const_cast<plArmatureMod*>(pCArm);
|
|
|
|
pObj = pNonConstArm->GetFollowerParticleSystemSO();
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
sys = plParticleSystem::ConvertNoRef(pObj->GetModifierByType(plParticleSystem::Index()));
|
|
|
|
|
|
|
|
}
|
|
|
|
if (sys == nil)
|
|
|
|
return;
|
|
|
|
|
|
|
|
}
|
|
|
|
plParticleEffect *flock = sys->GetEffect(plParticleFlockEffect::Index());
|
|
|
|
if (flock)
|
|
|
|
{
|
|
|
|
(new plParticleFlockMsg(nil, flock->GetKey(), 0, plParticleFlockMsg::kFlockCmdSetDissentPoint, x, y, z))->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SetParticleOffset(float x, float y, float z, pyKey& particles)
|
|
|
|
{
|
|
|
|
plKey frKey = particles.getKey();
|
|
|
|
plSceneObject* pObj = plSceneObject::ConvertNoRef(particles.getKey()->ObjectIsLoaded());
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
const plParticleSystem *sys = plParticleSystem::ConvertNoRef(pObj->GetModifierByType(plParticleSystem::Index()));
|
|
|
|
if (sys == nil)
|
|
|
|
{
|
|
|
|
const plModifier* pArm = pObj->GetModifierByType(plArmatureMod::Index());
|
|
|
|
if (pArm)
|
|
|
|
{
|
|
|
|
// it's the avatar
|
|
|
|
const plArmatureMod* pCArm = (const plArmatureMod*)pArm;
|
|
|
|
plArmatureMod* pNonConstArm = const_cast<plArmatureMod*>(pCArm);
|
|
|
|
pObj = pNonConstArm->GetFollowerParticleSystemSO();
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
sys = plParticleSystem::ConvertNoRef(pObj->GetModifierByType(plParticleSystem::Index()));
|
|
|
|
|
|
|
|
}
|
|
|
|
if (sys == nil)
|
|
|
|
return;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
plParticleEffect *flock = sys->GetEffect(plParticleFlockEffect::Index());
|
|
|
|
if (flock)
|
|
|
|
{
|
|
|
|
(new plParticleFlockMsg(nil, flock->GetKey(), 0, plParticleFlockMsg::kFlockCmdSetOffset, x, y, z))->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::KillParticles(float time, float pct, pyKey& particles)
|
|
|
|
{
|
|
|
|
plKey frKey = particles.getKey();
|
|
|
|
plSceneObject* pObj = plSceneObject::ConvertNoRef(particles.getKey()->ObjectIsLoaded());
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
const plParticleSystem *sys = plParticleSystem::ConvertNoRef(pObj->GetModifierByType(plParticleSystem::Index()));
|
|
|
|
if (sys == nil)
|
|
|
|
{
|
|
|
|
const plModifier* pArm = pObj->GetModifierByType(plArmatureMod::Index());
|
|
|
|
if (pArm)
|
|
|
|
{
|
|
|
|
// it's the avatar
|
|
|
|
const plArmatureMod* pCArm = (const plArmatureMod*)pArm;
|
|
|
|
plArmatureMod* pNonConstArm = const_cast<plArmatureMod*>(pCArm);
|
|
|
|
pObj = pNonConstArm->GetFollowerParticleSystemSO();
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
else
|
|
|
|
sys = plParticleSystem::ConvertNoRef(pObj->GetModifierByType(plParticleSystem::Index()));
|
|
|
|
|
|
|
|
}
|
|
|
|
if (sys == nil)
|
|
|
|
return;
|
|
|
|
|
|
|
|
}
|
|
|
|
plParticleEffect *flock = sys->GetEffect(plParticleFlockEffect::Index());
|
|
|
|
if (flock)
|
|
|
|
{
|
|
|
|
plParticleKillMsg* pMsg = new plParticleKillMsg(nil, frKey, 0, pct, time, plParticleKillMsg::kParticleKillPercentage | plParticleKillMsg::kParticleKillImmortalOnly);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kPropagateToChildren);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int cyMisc::GetNumParticles(pyKey& host)
|
|
|
|
{
|
|
|
|
plSceneObject* pObj = plSceneObject::ConvertNoRef(host.getKey()->ObjectIsLoaded());
|
|
|
|
if (!pObj)
|
|
|
|
return 0;
|
|
|
|
const plModifier* pArm = pObj->GetModifierByType(plArmatureMod::Index());
|
|
|
|
if (pArm)
|
|
|
|
{
|
|
|
|
// it's the avatar
|
|
|
|
const plArmatureMod* pCArm = (const plArmatureMod*)pArm;
|
|
|
|
plArmatureMod* pNonConstArm = const_cast<plArmatureMod*>(pCArm);
|
|
|
|
pObj = pNonConstArm->GetFollowerParticleSystemSO();
|
|
|
|
if (!pObj)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
const plModifier* pPart = pObj->GetModifierByType(plParticleSystem::Index());
|
|
|
|
if (!pPart)
|
|
|
|
return 0;
|
|
|
|
return ((const plParticleSystem*)pPart)->GetNumValidParticles(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void cyMisc::SetLightColorValue(pyKey& light, const plString& lightName, float r, float g, float b, float a)
|
|
|
|
{
|
|
|
|
// lightName is the name of the light object attached to the light that we want to talk to
|
|
|
|
// for the bug lights, this would be "RTOmni-BugLightTest"
|
|
|
|
plSceneObject* pObj = plSceneObject::ConvertNoRef(light.getKey()->ObjectIsLoaded());
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
|
|
|
|
plObjInterface* pIface = pObj->GetGenericInterface(plLightInfo::Index());
|
|
|
|
if (pIface)
|
|
|
|
{
|
|
|
|
// we are a light ourselves... are we the one they are looking for?
|
|
|
|
if (lightName != pObj->GetKeyName())
|
|
|
|
pIface = nil; // not the one they want, check our children
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!pIface)
|
|
|
|
{
|
|
|
|
// recurse through our children...
|
|
|
|
for (int i = 0; i < pObj->GetCoordinateInterface()->GetNumChildren(); i++)
|
|
|
|
{
|
|
|
|
const plSceneObject* child = pObj->GetCoordinateInterface()->GetChild(i)->GetOwner();
|
|
|
|
if (child)
|
|
|
|
{
|
|
|
|
pIface = child->GetGenericInterface(plLightInfo::Index());
|
|
|
|
if (pIface)
|
|
|
|
{
|
|
|
|
// found a child... is it the one we want?
|
|
|
|
if (lightName != child->GetKeyName())
|
|
|
|
pIface = nil; // not the child we want, keep looking
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pIface)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pIface)
|
|
|
|
{
|
|
|
|
plLightInfo* pLight = (plLightInfo*)pIface;
|
|
|
|
hsColorRGBA c;
|
|
|
|
c.Set(r,g,b,a);
|
|
|
|
pLight->SetDiffuse(c);
|
|
|
|
pLight->SetDiffuse(c);
|
|
|
|
pLight->SetSpecular(c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "pnMessage/plEnableMsg.h"
|
|
|
|
void cyMisc::SetLightAnimationOn(pyKey& light, const plString& lightName, bool start)
|
|
|
|
{
|
|
|
|
// lightName is the name of the light object attached to the light that we want to talk to
|
|
|
|
// for the bug lights, this would be "RTOmni-BugLightTest"
|
|
|
|
plSceneObject* pObj = plSceneObject::ConvertNoRef(light.getKey()->ObjectIsLoaded());
|
|
|
|
if (!pObj)
|
|
|
|
return;
|
|
|
|
|
|
|
|
plObjInterface* pIface = pObj->GetGenericInterface(plLightInfo::Index());
|
|
|
|
if (pIface)
|
|
|
|
{
|
|
|
|
// we are a light ourselves... are we the one they are looking for?
|
|
|
|
if (lightName != pObj->GetKeyName())
|
|
|
|
pIface = nil; // not the one they want, check our children
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!pIface)
|
|
|
|
{
|
|
|
|
// recurse through our children...
|
|
|
|
for (int i = 0; i < pObj->GetCoordinateInterface()->GetNumChildren(); i++)
|
|
|
|
{
|
|
|
|
const plSceneObject* child = pObj->GetCoordinateInterface()->GetChild(i)->GetOwner();
|
|
|
|
if (child)
|
|
|
|
{
|
|
|
|
pIface = child->GetGenericInterface(plLightInfo::Index());
|
|
|
|
if (pIface)
|
|
|
|
{
|
|
|
|
// found a child... is it the one we want?
|
|
|
|
if (lightName != child->GetKeyName())
|
|
|
|
pIface = nil; // not the child we want, keep looking
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pIface)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (pIface)
|
|
|
|
{
|
|
|
|
plEnableMsg* enableMsg = new plEnableMsg;
|
|
|
|
enableMsg->AddReceiver(pIface->GetKey());
|
|
|
|
enableMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
enableMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
|
|
|
|
plAnimCmdMsg* animMsg = new plAnimCmdMsg;
|
|
|
|
animMsg->AddReceiver(pIface->GetOwnerKey());
|
|
|
|
animMsg->SetBCastFlag(plMessage::kPropagateToModifiers);
|
|
|
|
animMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
animMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
|
|
|
|
if (start)
|
|
|
|
{
|
|
|
|
enableMsg->SetCmd(plEnableMsg::kEnable);
|
|
|
|
animMsg->SetCmd(plAnimCmdMsg::kContinue);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
enableMsg->SetCmd(plEnableMsg::kDisable);
|
|
|
|
animMsg->SetCmd(plAnimCmdMsg::kStop);
|
|
|
|
animMsg->SetCmd(plAnimCmdMsg::kGoToBegin);
|
|
|
|
}
|
|
|
|
|
|
|
|
enableMsg->Send();
|
|
|
|
animMsg->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : RegisterForControlEventMessages
|
|
|
|
// PARAMETERS : switch on or off, registrant
|
|
|
|
//
|
|
|
|
// PURPOSE : let you get control event messages at will (for pseudo-GUI's like the psnl bookshelf or clft imager)
|
|
|
|
|
|
|
|
void cyMisc::RegisterForControlEventMessages(bool on, pyKey& k)
|
|
|
|
{
|
|
|
|
plCmdIfaceModMsg* pMsg = new plCmdIfaceModMsg;
|
|
|
|
pMsg->SetSender(k.getKey());
|
|
|
|
if (on)
|
|
|
|
pMsg->SetCmd(plCmdIfaceModMsg::kAdd);
|
|
|
|
else
|
|
|
|
pMsg->SetCmd(plCmdIfaceModMsg::kRemove);
|
|
|
|
pMsg->SetBCastFlag(plMessage::kBCastByExactType);
|
|
|
|
pMsg->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : RequestLOSScreen
|
|
|
|
// PARAMETERS : lots...
|
|
|
|
//
|
|
|
|
// PURPOSE : To request an LOS from a point on the screen
|
|
|
|
//
|
|
|
|
#include "plMessage/plLOSRequestMsg.h"
|
|
|
|
bool cyMisc::RequestLOSScreen(pyKey &selfkey, int32_t ID, float xPos, float yPos, float distance, int what, int reportType)
|
|
|
|
{
|
|
|
|
plPipeline* pipe = selfkey.GetPipeline();
|
|
|
|
if (pipe)
|
|
|
|
{
|
|
|
|
int32_t x=(int32_t) ( xPos * pipe->Width() );
|
|
|
|
int32_t y=(int32_t) ( yPos * pipe->Height() );
|
|
|
|
|
|
|
|
hsPoint3 endPos, startPos;
|
|
|
|
|
|
|
|
pipe->ScreenToWorldPoint( 1,0, &x, &y, distance, 0, &endPos );
|
|
|
|
startPos = pipe->GetViewPositionWorld();
|
|
|
|
|
|
|
|
// move the start pos out a little to avoid backing up against physical objects...
|
|
|
|
hsVector3 view(endPos - startPos);
|
|
|
|
view.Normalize();
|
|
|
|
startPos = startPos + (view * 1.5f);
|
|
|
|
|
|
|
|
plLOSRequestMsg* pMsg = nil;
|
|
|
|
switch (what)
|
|
|
|
{
|
|
|
|
case kClickables:
|
|
|
|
pMsg = new plLOSRequestMsg( selfkey.getKey(), startPos, endPos, plSimDefs::kLOSDBUIItems, plLOSRequestMsg::kTestClosest );
|
|
|
|
pMsg->SetCullDB(plSimDefs::kLOSDBUIBlockers);
|
|
|
|
break;
|
|
|
|
case kCameraBlockers:
|
|
|
|
pMsg = new plLOSRequestMsg( selfkey.getKey(), startPos, endPos, plSimDefs::kLOSDBCameraBlockers, plLOSRequestMsg::kTestClosest );
|
|
|
|
break;
|
|
|
|
case kCustom:
|
|
|
|
pMsg = new plLOSRequestMsg( selfkey.getKey(), startPos, endPos, plSimDefs::kLOSDBCustom, plLOSRequestMsg::kTestClosest );
|
|
|
|
break;
|
|
|
|
case kShootable:
|
|
|
|
pMsg = new plLOSRequestMsg( selfkey.getKey(), startPos, endPos, plSimDefs::kLOSDBShootableItems, plLOSRequestMsg::kTestClosest );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( pMsg )
|
|
|
|
{
|
|
|
|
pMsg->SetReportType( (plLOSRequestMsg::ReportType)reportType );
|
|
|
|
|
|
|
|
pMsg->SetRequestID( ID );
|
|
|
|
|
|
|
|
plgDispatch::MsgSend( pMsg );
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : CheckVisLOS,CheckVisLOSFromCursor
|
|
|
|
// PARAMETERS : StartPoint, EndPoint
|
|
|
|
//
|
|
|
|
// PURPOSE : Check is there is something visible in the path from StartPoint to EndPoint
|
|
|
|
//
|
|
|
|
#include "plDrawable/plVisLOSMgr.h"
|
|
|
|
PyObject* cyMisc::CheckVisLOS(pyPoint3 startPoint, pyPoint3 endPoint)
|
|
|
|
{
|
|
|
|
if (plVisLOSMgr::Instance())
|
|
|
|
{
|
|
|
|
plVisHit hit;
|
|
|
|
if( plVisLOSMgr::Instance()->Check(startPoint.fPoint,endPoint.fPoint,hit) )
|
|
|
|
{
|
|
|
|
return pyPoint3::New(hit.fPos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
PYTHON_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::CheckVisLOSFromCursor()
|
|
|
|
{
|
|
|
|
if (plVisLOSMgr::Instance())
|
|
|
|
{
|
|
|
|
plVisHit hit;
|
|
|
|
if( plVisLOSMgr::Instance()->CursorCheck(hit) )
|
|
|
|
{
|
|
|
|
return pyPoint3::New(hit.fPos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
PYTHON_RETURN_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : IsSinglePlayerMode
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns whether the game is in Single Player mode
|
|
|
|
//
|
|
|
|
bool cyMisc::IsSinglePlayerMode()
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : IsDemoMode
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns whether the game is in Single Player mode
|
|
|
|
//
|
|
|
|
bool cyMisc::IsDemoMode()
|
|
|
|
{
|
|
|
|
plNetClientApp* nc = plNetClientApp::GetInstance();
|
|
|
|
if (nc)
|
|
|
|
return nc->InDemoMode();
|
|
|
|
// if we couldn't find the net client app, maybe it was because we are single player mode
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : IsInternalRelease
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns true if we are running an internal build
|
|
|
|
//
|
|
|
|
bool cyMisc::IsInternalRelease()
|
|
|
|
{
|
|
|
|
#ifdef PLASMA_EXTERNAL_RELEASE
|
|
|
|
return false;
|
|
|
|
#else
|
|
|
|
return true;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : IsEnterChatModeKeyBound
|
|
|
|
// PARAMETERS :
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns whether the EnterChatMode is bound to a key
|
|
|
|
//
|
|
|
|
bool cyMisc::IsEnterChatModeKeyBound()
|
|
|
|
{
|
|
|
|
plAvatarInputInterface* aii = plAvatarInputInterface::GetInstance();
|
|
|
|
if (aii)
|
|
|
|
return aii->IsEnterChatModeBound();
|
|
|
|
// if we couldn't find the net client app, maybe it was because we are single player mode
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : ShootBulletFromScreen
|
|
|
|
// PARAMETERS : lots...
|
|
|
|
//
|
|
|
|
// PURPOSE : Shoots from screen coordinates, a bullet and makes a mark on objects that know about bullet holes
|
|
|
|
//
|
|
|
|
#include "plMessage/plBulletMsg.h"
|
|
|
|
void cyMisc::ShootBulletFromScreen(pyKey &selfkey, float xPos, float yPos, float radius, float range)
|
|
|
|
{
|
|
|
|
plPipeline* pipe = selfkey.GetPipeline();
|
|
|
|
if (pipe)
|
|
|
|
{
|
|
|
|
int32_t x=(int32_t) ( xPos * pipe->Width() );
|
|
|
|
int32_t y=(int32_t) ( yPos * pipe->Height() );
|
|
|
|
|
|
|
|
hsPoint3 endPos, startPos;
|
|
|
|
|
|
|
|
pipe->ScreenToWorldPoint( 1,0, &x, &y, range, 0, &endPos );
|
|
|
|
startPos = pipe->GetViewPositionWorld();
|
|
|
|
|
|
|
|
// move the start pos out a little to avoid backing up against physical objects...
|
|
|
|
hsVector3 view(endPos - startPos);
|
|
|
|
view.Normalize();
|
|
|
|
startPos = startPos + (view * 1.5f);
|
|
|
|
|
|
|
|
plBulletMsg* bull = new plBulletMsg( selfkey.getKey(), nil, nil );
|
|
|
|
bull->FireShot(startPos, view, radius, range);
|
|
|
|
bull->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : ShootBulletFromObject
|
|
|
|
// PARAMETERS : lots...
|
|
|
|
//
|
|
|
|
// PURPOSE : Shoots from an object, a bullet and makes a mark on objects that know about bullet holes
|
|
|
|
//
|
|
|
|
void cyMisc::ShootBulletFromObject(pyKey &selfkey, pySceneObject* sobj, float radius, float range)
|
|
|
|
{
|
|
|
|
plSceneObject* so = plSceneObject::ConvertNoRef(sobj->getObjKey()->ObjectIsLoaded());
|
|
|
|
if( so )
|
|
|
|
{
|
|
|
|
// find the direction
|
|
|
|
|
|
|
|
hsMatrix44 l2w = so->GetLocalToWorld();
|
|
|
|
hsVector3 dir(-l2w.fMap[0][0], -l2w.fMap[1][0], -l2w.fMap[2][0]);
|
|
|
|
dir.Normalize();
|
|
|
|
hsPoint3 pos = l2w.GetTranslate();
|
|
|
|
|
|
|
|
plBulletMsg* bull = new plBulletMsg(selfkey.getKey(), nil, nil);
|
|
|
|
bull->FireShot(pos, dir, radius, range);
|
|
|
|
|
|
|
|
bull->Send();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
class NetClientCommCallback : public plNetClientComm::Callback
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum Contexts
|
|
|
|
{
|
|
|
|
kInvalid,
|
|
|
|
kGetPublicAgeList,
|
|
|
|
kCreatePublicAge,
|
|
|
|
kRemovePublicAge,
|
|
|
|
};
|
|
|
|
|
|
|
|
PyObject * fPyObject;
|
|
|
|
NetClientCommCallback( PyObject * pyObject )
|
|
|
|
: fPyObject( pyObject )
|
|
|
|
{
|
|
|
|
Py_XINCREF( fPyObject );
|
|
|
|
}
|
|
|
|
~NetClientCommCallback()
|
|
|
|
{
|
|
|
|
Py_XDECREF( fPyObject );
|
|
|
|
}
|
|
|
|
void OperationStarted( uint32_t context )
|
|
|
|
{}
|
|
|
|
void OperationComplete( uint32_t context, int resultCode )
|
|
|
|
{
|
|
|
|
if ( !fPyObject )
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
PyObject* func = nil;
|
|
|
|
|
|
|
|
switch ( context )
|
|
|
|
{
|
|
|
|
case kGetPublicAgeList:
|
|
|
|
// Call the callback.
|
|
|
|
func = PyObject_GetAttrString( fPyObject, "gotPublicAgeList" );
|
|
|
|
if ( func )
|
|
|
|
{
|
|
|
|
if ( PyCallable_Check(func)>0 )
|
|
|
|
{
|
|
|
|
plCreatableStream * ageInfoStream = plCreatableStream::ConvertNoRef( fCbArgs.GetItem( 0 ) );
|
|
|
|
plCreatableStream * nPlayersStream = plCreatableStream::ConvertNoRef( fCbArgs.GetItem( 1 ) );
|
|
|
|
|
|
|
|
if ( ageInfoStream && nPlayersStream )
|
|
|
|
{
|
|
|
|
uint16_t nAgeInfoEntries;
|
|
|
|
ageInfoStream->GetStream()->ReadLE( &nAgeInfoEntries );
|
|
|
|
|
|
|
|
uint16_t nPlayerCountEntries;
|
|
|
|
nPlayersStream->GetStream()->ReadLE( &nPlayerCountEntries );
|
|
|
|
|
|
|
|
hsAssert( nAgeInfoEntries==nPlayerCountEntries, "huh?" );
|
|
|
|
|
|
|
|
// convert callback args to a list of tuple(ageInfo,nPlayers)
|
|
|
|
PyObject* pyEL = PyList_New(nAgeInfoEntries);
|
|
|
|
|
|
|
|
for ( int i=0; i<nAgeInfoEntries; i++ )
|
|
|
|
{
|
|
|
|
plAgeInfoStruct ageInfo;
|
|
|
|
uint32_t nPlayers;
|
|
|
|
ageInfo.Read( ageInfoStream->GetStream(), nil );
|
|
|
|
nPlayersStream->GetStream()->ReadLE( &nPlayers );
|
|
|
|
PyObject* t = PyTuple_New(2);
|
|
|
|
PyTuple_SetItem(t, 0, pyAgeInfoStruct::New(&ageInfo));
|
|
|
|
PyTuple_SetItem(t, 1, PyLong_FromUnsignedLong(nPlayers));
|
|
|
|
PyList_SetItem(pyEL, i, t); // steals the ref
|
|
|
|
}
|
|
|
|
PyObject* retVal = PyObject_CallMethod(fPyObject, "gotPublicAgeList", "O", pyEL);
|
|
|
|
Py_XDECREF(retVal);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case kCreatePublicAge:
|
|
|
|
// Call the callback.
|
|
|
|
func = PyObject_GetAttrString( fPyObject, "publicAgeCreated" );
|
|
|
|
if ( func )
|
|
|
|
{
|
|
|
|
if ( PyCallable_Check(func)>0 )
|
|
|
|
{
|
|
|
|
plAgeInfoStruct * ageInfo = plAgeInfoStruct::ConvertNoRef( fCbArgs.GetItem( 0 ) );
|
|
|
|
|
|
|
|
if ( ageInfo )
|
|
|
|
{
|
|
|
|
PyObject* ageInfoObj = pyAgeInfoStruct::New(ageInfo);
|
|
|
|
PyObject* retVal = PyObject_CallMethod(fPyObject, "publicAgeCreated", "O", ageInfoObj);
|
|
|
|
Py_XDECREF(retVal);
|
|
|
|
Py_DECREF(ageInfoObj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case kRemovePublicAge:
|
|
|
|
// Call the callback.
|
|
|
|
func = PyObject_GetAttrString( fPyObject, "publicAgeRemoved" );
|
|
|
|
if ( func )
|
|
|
|
{
|
|
|
|
if ( PyCallable_Check(func)>0 )
|
|
|
|
{
|
|
|
|
plCreatableUuid * guid = plCreatableUuid::ConvertNoRef( fCbArgs.GetItem( 0 ) );
|
|
|
|
|
|
|
|
if ( guid )
|
|
|
|
{
|
|
|
|
PyObject* retVal = PyObject_CallMethod(fPyObject, "publicAgeRemoved", "s", guid->AsString().c_str());
|
|
|
|
Py_XDECREF(retVal);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
delete this;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetPublicAgeList
|
|
|
|
// PARAMETERS : ageName, callback object
|
|
|
|
//
|
|
|
|
// PURPOSE : Get the list of public ages for the given age name.
|
|
|
|
//
|
|
|
|
void cyMisc::GetPublicAgeList( const char * ageName, PyObject * cbObject )
|
|
|
|
{
|
|
|
|
if (cbObject)
|
|
|
|
Py_XINCREF(cbObject);
|
|
|
|
NetCommGetPublicAgeList(
|
|
|
|
ageName,
|
|
|
|
cbObject,
|
|
|
|
plNetCommReplyMsg::kParamTypePython
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : CreatePublicAge
|
|
|
|
// PARAMETERS : ageInfo, callback object
|
|
|
|
//
|
|
|
|
// PURPOSE : Add a public age to the list of available ones.
|
|
|
|
//
|
|
|
|
void cyMisc::CreatePublicAge( pyAgeInfoStruct * ageInfo, PyObject * cbObject )
|
|
|
|
{
|
|
|
|
VaultSetOwnedAgePublicAndWait(ageInfo->GetAgeInfo(), true);
|
|
|
|
// TODO: make the callback here
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : RemovePublicAge
|
|
|
|
// PARAMETERS : ageInstanceGuid, callback object
|
|
|
|
//
|
|
|
|
// PURPOSE : Remove a public age from the list of available ones.
|
|
|
|
//
|
|
|
|
void cyMisc::RemovePublicAge( const char * ageInstanceGuid, PyObject * cbObject/*=nil */)
|
|
|
|
{
|
|
|
|
plAgeInfoStruct info;
|
|
|
|
plUUID uuid(ageInstanceGuid);
|
|
|
|
info.SetAgeInstanceGuid(&uuid);
|
|
|
|
VaultSetOwnedAgePublicAndWait(&info, false);
|
|
|
|
// TODO: make the callback here
|
|
|
|
}
|
|
|
|
|
|
|
|
int cyMisc::GetKILevel()
|
|
|
|
{
|
|
|
|
int result = pfKIMsg::kNanoKI;
|
|
|
|
|
|
|
|
if (hsRef<RelVaultNode> rvn = VaultFindChronicleEntry(pfKIMsg::kChronicleKILevel)) {
|
|
|
|
VaultChronicleNode chron(rvn);
|
|
|
|
result = chron.GetEntryValue().ToInt();
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// the following are for recording and rebuilding the camera stack
|
|
|
|
|
|
|
|
#include "pfCamera/plCameraModifier.h"
|
|
|
|
|
|
|
|
int cyMisc::GetNumCameras()
|
|
|
|
{
|
|
|
|
return (plVirtualCam1::Instance()->GetNumCameras());
|
|
|
|
}
|
|
|
|
|
|
|
|
plString cyMisc::GetCameraNumber(int number)
|
|
|
|
{
|
|
|
|
plCameraModifier1* pCam = plVirtualCam1::Instance()->GetCameraNumber(number-1);
|
|
|
|
if (pCam && pCam->GetTarget())
|
|
|
|
{
|
|
|
|
plString ret = pCam->GetTarget()->GetKeyName();
|
|
|
|
plString log = plFormat("saving camera named {} to chronicle\n", ret);
|
|
|
|
plVirtualCam1::Instance()->AddMsgToLog(log.c_str());
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
plVirtualCam1::Instance()->AddMsgToLog("sending empty to camera chronicle\n");
|
|
|
|
return "empty";
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::RebuildCameraStack(const plString& name, const char* ageName)
|
|
|
|
{
|
|
|
|
plKey key=nil;
|
|
|
|
plString str = plFormat("attempting to restore camera named {} from chronicle\n", name);
|
|
|
|
plVirtualCam1::Instance()->AddMsgToLog(str.c_str());
|
|
|
|
|
|
|
|
if (name.Compare("empty") == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ( !name.IsEmpty() )
|
|
|
|
{
|
|
|
|
key=plKeyFinder::Instance().StupidSearch("", "", plSceneObject::Index(), name, false);
|
|
|
|
}
|
|
|
|
if ( key == nil )
|
|
|
|
{
|
|
|
|
// try and use this new hack method to find it
|
|
|
|
if (!plVirtualCam1::Instance()->RestoreFromName(name))
|
|
|
|
{
|
|
|
|
// give up and force built in 3rd person
|
|
|
|
plVirtualCam1::Instance()->PushThirdPerson();
|
|
|
|
plString errmsg = plFormat("Sceneobject {} not found", name);
|
|
|
|
PyErr_SetString(PyExc_NameError, errmsg.c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// now we have the scene object, look for it's camera modifier
|
|
|
|
const plCameraModifier1* pMod = nil;
|
|
|
|
plSceneObject* pObj = plSceneObject::ConvertNoRef(key->ObjectIsLoaded());
|
|
|
|
if (pObj)
|
|
|
|
{
|
|
|
|
for (int i = 1; i < pObj->GetNumModifiers(); i++)
|
|
|
|
{
|
|
|
|
pMod = plCameraModifier1::ConvertNoRef(pObj->GetModifier(i));
|
|
|
|
if (pMod)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (pMod)
|
|
|
|
{
|
|
|
|
plVirtualCam1::Instance()->RebuildStack(pMod->GetKey());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
plVirtualCam1::Instance()->PushThirdPerson();
|
|
|
|
plString errmsg = plFormat("Sceneobject {} has no camera modifier", name);
|
|
|
|
PyErr_SetString(PyExc_NameError, errmsg.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::PyClearCameraStack()
|
|
|
|
{
|
|
|
|
plVirtualCam1::Instance()->ClearStack();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::RecenterCamera()
|
|
|
|
{
|
|
|
|
plCameraMsg* pCam = new plCameraMsg;
|
|
|
|
pCam->SetBCastFlag(plMessage::kBCastByExactType);
|
|
|
|
pCam->SetCmd(plCameraMsg::kResetPanning);
|
|
|
|
pCam->Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
#include "plMessage/plTransitionMsg.h"
|
|
|
|
|
|
|
|
void cyMisc::FadeIn(float lenTime, bool holdFlag, bool noSound)
|
|
|
|
{
|
|
|
|
plTransitionMsg *msg = new plTransitionMsg( noSound ? plTransitionMsg::kFadeInNoSound : plTransitionMsg::kFadeIn, lenTime, holdFlag );
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::FadeOut(float lenTime, bool holdFlag, bool noSound)
|
|
|
|
{
|
|
|
|
plTransitionMsg *msg = new plTransitionMsg( noSound ? plTransitionMsg::kFadeOutNoSound : plTransitionMsg::kFadeOut, lenTime, holdFlag );
|
|
|
|
plgDispatch::MsgSend( msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SetClickability(bool b)
|
|
|
|
{
|
|
|
|
plInputIfaceMgrMsg* msg = new plInputIfaceMgrMsg(b ? plInputIfaceMgrMsg::kEnableClickables : plInputIfaceMgrMsg::kDisableClickables );
|
|
|
|
plgDispatch::MsgSend(msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Debug build only: Assert if condition is false.
|
|
|
|
//
|
|
|
|
// PURPOSE : debugging
|
|
|
|
//
|
|
|
|
void cyMisc::DebugAssert( bool cond, const char * msg )
|
|
|
|
{
|
|
|
|
hsAssert( cond, msg );
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::DebugPrint(const plString& msg, uint32_t level)
|
|
|
|
{
|
|
|
|
if (level < fPythonLoggingLevel)
|
|
|
|
return;
|
|
|
|
plStatusLog* log = plStatusLogMgr::GetInstance().FindLog("python.log", false);
|
|
|
|
if (!log)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (level) {
|
|
|
|
case kDebugDump:
|
|
|
|
log->AddLine(msg.c_str(), plStatusLog::kGreen);
|
|
|
|
break;
|
|
|
|
case kWarningLevel:
|
|
|
|
log->AddLine(msg.c_str(), plStatusLog::kYellow);
|
|
|
|
break;
|
|
|
|
case kAssertLevel:
|
|
|
|
hsAssert(false, msg.c_str());
|
|
|
|
// ... fall thru to the actual log-print
|
|
|
|
case kErrorLevel:
|
|
|
|
log->AddLine(msg.c_str(), plStatusLog::kRed);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
log->AddLine(msg.c_str(), plStatusLog::kWhite);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Set a python object to be called back after a certain amount of time.
|
|
|
|
//
|
|
|
|
// PURPOSE : script can trigger itself over time w/o having to specify it in the dataset.
|
|
|
|
//
|
|
|
|
void cyMisc::SetAlarm( float secs, PyObject * cb, uint32_t cbContext )
|
|
|
|
{
|
|
|
|
pyAlarmMgr::GetInstance()->SetAlarm( secs, cb, cbContext );
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Save Screen Shot
|
|
|
|
//
|
|
|
|
// PURPOSE : captures the screen and saves it as a jpeg
|
|
|
|
//
|
|
|
|
#include "plGImage/plJPEG.h"
|
|
|
|
void cyMisc::SaveScreenShot(const char* fileName, int x, int y, int quality)
|
|
|
|
{
|
|
|
|
if ( cyMisc::GetPipeline() )
|
|
|
|
{
|
|
|
|
if (quality <= 0 || quality > 100)
|
|
|
|
quality = 75;
|
|
|
|
|
|
|
|
plMipmap mipmap;
|
|
|
|
cyMisc::GetPipeline()->CaptureScreen( &mipmap, false, x, y );
|
|
|
|
|
|
|
|
plJPEG::Instance().SetWriteQuality( quality );
|
|
|
|
plJPEG::Instance().WriteToFile( fileName, &mipmap );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Start a screen capture
|
|
|
|
//
|
|
|
|
// PURPOSE : This starts a screen capture in motion. It will be capture on the next
|
|
|
|
// update and a plCaptureRenderMsg when its ready
|
|
|
|
//
|
|
|
|
#include "plPipeline/plCaptureRender.h"
|
|
|
|
void cyMisc::StartScreenCapture(pyKey& selfkey)
|
|
|
|
{
|
|
|
|
cyMisc::StartScreenCaptureWH(selfkey, 800, 600);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::StartScreenCaptureWH(pyKey& selfkey, uint16_t width, uint16_t height)
|
|
|
|
{
|
|
|
|
plCaptureRender::Capture(selfkey.getKey(), width, height);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#include "plAvatar/plAvatarClothing.h"
|
|
|
|
void cyMisc::WearMaintainerSuit(pyKey& key, bool wear)
|
|
|
|
{
|
|
|
|
// run on all machines, but only affects us if we call it on our local guy (who props it to others himself)
|
|
|
|
if (key.getKey() != plNetClientMgr::GetInstance()->GetLocalPlayerKey())
|
|
|
|
return;
|
|
|
|
|
|
|
|
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
|
|
|
|
|
|
|
|
if (avMod)
|
|
|
|
{
|
|
|
|
if (wear)
|
|
|
|
avMod->GetClothingOutfit()->WearMaintainerOutfit();
|
|
|
|
else
|
|
|
|
avMod->GetClothingOutfit()->RemoveMaintainerOutfit();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::WearDefaultClothing(pyKey& key)
|
|
|
|
{
|
|
|
|
if (key.getKey() != plNetClientMgr::GetInstance()->GetLocalPlayerKey())
|
|
|
|
return;
|
|
|
|
|
|
|
|
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
|
|
|
|
|
|
|
|
if (avMod)
|
|
|
|
{
|
|
|
|
avMod->GetClothingOutfit()->WearDefaultClothing();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::WearDefaultClothingType(pyKey& key, uint32_t type)
|
|
|
|
{
|
|
|
|
if (key.getKey() != plNetClientMgr::GetInstance()->GetLocalPlayerKey())
|
|
|
|
return;
|
|
|
|
|
|
|
|
plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
|
|
|
|
|
|
|
|
if (avMod)
|
|
|
|
{
|
|
|
|
avMod->GetClothingOutfit()->WearDefaultClothingType(type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : Fake link to object
|
|
|
|
//
|
|
|
|
// PURPOSE : takes an avatar key and an object key and fake-links the avatar
|
|
|
|
// to that object's position. appears to be a link to other players
|
|
|
|
//
|
|
|
|
|
|
|
|
void cyMisc::FakeLinkToObject(pyKey& avatar, pyKey& object)
|
|
|
|
{
|
|
|
|
plPseudoLinkEffectMsg* msg = new plPseudoLinkEffectMsg;
|
|
|
|
msg->fAvatarKey = avatar.getKey();
|
|
|
|
msg->fLinkObjKey = object.getKey();
|
|
|
|
plgDispatch::MsgSend(msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::FakeLinkToObjectNamed(const plString& name)
|
|
|
|
{
|
|
|
|
plKey key = nil;
|
|
|
|
if ( !name.IsEmpty() )
|
|
|
|
{
|
|
|
|
key = plKeyFinder::Instance().StupidSearch("", "", plSceneObject::Index(), name, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!key)
|
|
|
|
return;
|
|
|
|
plPseudoLinkEffectMsg* msg = new plPseudoLinkEffectMsg;
|
|
|
|
msg->fAvatarKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
|
|
|
|
msg->fLinkObjKey = key;
|
|
|
|
plgDispatch::MsgSend(msg);
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::LoadAvatarModel(const char* modelName, pyKey& spawnPoint, const char* userStr)
|
|
|
|
{
|
|
|
|
plKey SpawnedKey = plAvatarMgr::GetInstance()->LoadAvatar(modelName, "", false, spawnPoint.getKey(), nil, userStr);
|
|
|
|
return pyKey::New(SpawnedKey);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::UnLoadAvatarModel(pyKey& avatar)
|
|
|
|
{
|
|
|
|
plAvatarMgr::GetInstance()->UnLoadAvatar(avatar.getKey(), false, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::ForceCursorHidden()
|
|
|
|
{
|
|
|
|
plMouseDevice::HideCursor(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::ForceCursorShown()
|
|
|
|
{
|
|
|
|
plMouseDevice::ShowCursor(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// Function : GetLocalizedString
|
|
|
|
//
|
|
|
|
// PURPOSE : Returns the specified localized string with the parameters
|
|
|
|
// properly replaced (the list is a list of unicode strings) Name
|
|
|
|
// is in "Age.Set.Name" format
|
|
|
|
//
|
|
|
|
plString cyMisc::GetLocalizedString(plString name, const std::vector<plString> & arguments)
|
|
|
|
{
|
|
|
|
if (pfLocalizationMgr::InstanceValid())
|
|
|
|
return pfLocalizationMgr::Instance().GetString(name, arguments);
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::EnablePlanarReflections(bool enable)
|
|
|
|
{
|
|
|
|
plDynamicCamMap::SetEnabled(enable);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::GetSupportedDisplayModes(std::vector<plDisplayMode> *res)
|
|
|
|
{
|
|
|
|
fPipeline->GetSupportedDisplayModes(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
int cyMisc::GetDesktopWidth()
|
|
|
|
{
|
|
|
|
return fPipeline->GetDesktopWidth();
|
|
|
|
}
|
|
|
|
|
|
|
|
int cyMisc::GetDesktopHeight()
|
|
|
|
{
|
|
|
|
return fPipeline->GetDesktopHeight();
|
|
|
|
}
|
|
|
|
|
|
|
|
int cyMisc::GetDesktopColorDepth()
|
|
|
|
{
|
|
|
|
return fPipeline->GetDesktopColorDepth();
|
|
|
|
}
|
|
|
|
|
|
|
|
PipelineParams *cyMisc::GetDefaultDisplayParams()
|
|
|
|
{
|
|
|
|
return fPipeline->GetDefaultParams();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SetGraphicsOptions(int Width, int Height, int ColorDepth, bool Windowed, int NumAASamples, int MaxAnisotropicSamples, bool VSync)
|
|
|
|
{
|
|
|
|
// This has to send a message to plClient because python is loaded in the max plugins
|
|
|
|
|
|
|
|
plKey clientKey = hsgResMgr::ResMgr()->FindKey( kClient_KEY );
|
|
|
|
plClientMsg* clientMsg = new plClientMsg(plClientMsg::kResetGraphicsDevice);
|
|
|
|
clientMsg->AddReceiver(clientKey);
|
|
|
|
//clientMsg->SetBCastFlag(plMessage::kBCastByType);
|
|
|
|
clientMsg->fGraphicsSettings.fWidth = Width;
|
|
|
|
clientMsg->fGraphicsSettings.fHeight = Height;
|
|
|
|
clientMsg->fGraphicsSettings.fColorDepth = ColorDepth;
|
|
|
|
clientMsg->fGraphicsSettings.fWindowed = Windowed;
|
|
|
|
clientMsg->fGraphicsSettings.fNumAASamples = NumAASamples;
|
|
|
|
clientMsg->fGraphicsSettings.fMaxAnisoSamples = MaxAnisotropicSamples;
|
|
|
|
clientMsg->fGraphicsSettings.fVSync = VSync;
|
|
|
|
clientMsg->Send();
|
|
|
|
|
|
|
|
//plClient::GetInstance()->ResetDisplayDevice(Width, Height, ColorDepth, Windowed, NumAASamples, MaxAnisotropicSamples);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cyMisc::DumpLogs(const std::wstring & folder)
|
|
|
|
{
|
|
|
|
char* temp = hsWStringToString(folder.c_str());
|
|
|
|
bool retVal = plStatusLogMgr::GetInstance().DumpLogs(temp);
|
|
|
|
delete [] temp;
|
|
|
|
return retVal;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cyMisc::FileExists(const plFileName & filename)
|
|
|
|
{
|
|
|
|
return plFileInfo(filename).Exists();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool cyMisc::CreateDir(const plFileName & directory)
|
|
|
|
{
|
|
|
|
return plFileSystem::CreateDir(directory, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
plFileName cyMisc::GetUserPath()
|
|
|
|
{
|
|
|
|
return plFileSystem::GetUserDataPath();
|
|
|
|
}
|
|
|
|
|
|
|
|
plFileName cyMisc::GetInitPath()
|
|
|
|
{
|
|
|
|
return plFileSystem::GetInitPath();
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SetBehaviorNetFlags(pyKey & behKey, bool netForce, bool netProp)
|
|
|
|
{
|
|
|
|
if (plMultistageBehMod * behMod = plMultistageBehMod::ConvertNoRef(behKey.getKey()->ObjectIsLoaded()))
|
|
|
|
{
|
|
|
|
behMod->SetNetForce(netForce);
|
|
|
|
behMod->SetNetProp(netProp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::SendFriendInvite(const plString& email, const plString& toName)
|
|
|
|
{
|
|
|
|
if (hsRef<RelVaultNode> pNode = VaultGetPlayerNode())
|
|
|
|
{
|
|
|
|
VaultPlayerNode player(pNode);
|
|
|
|
plUUID inviteUuid = player.GetInviteUuid();
|
|
|
|
|
|
|
|
// If we don't have an invite UUID set then make a new one
|
|
|
|
if (inviteUuid.IsNull())
|
|
|
|
{
|
|
|
|
inviteUuid = plUUID::Generate();
|
|
|
|
player.SetInviteUuid(inviteUuid);
|
|
|
|
}
|
|
|
|
|
|
|
|
NetCommSendFriendInvite(email, toName, inviteUuid);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::PyGuidGenerate()
|
|
|
|
{
|
|
|
|
plUUID newGuid = plUUID::Generate();
|
|
|
|
|
|
|
|
return PyString_FromString(newGuid.AsString().c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::GetAIAvatarsByModelName(const char* name)
|
|
|
|
{
|
|
|
|
plAvatarMgr::plArmatureModPtrVec armVec;
|
|
|
|
plAvatarMgr::GetInstance()->FindAllAvatarsByModelName(name, armVec);
|
|
|
|
|
|
|
|
PyObject* avList = PyList_New(0);
|
|
|
|
|
|
|
|
for (plAvatarMgr::plArmatureModPtrVec::iterator it = armVec.begin(); it != armVec.end(); ++it)
|
|
|
|
{
|
|
|
|
plArmatureMod* armMod = (*it);
|
|
|
|
plAvBrainCritter* critterBrain = plAvBrainCritter::ConvertNoRef(armMod->FindBrainByClass(plAvBrainCritter::Index()));
|
|
|
|
if (critterBrain)
|
|
|
|
{
|
|
|
|
PyObject* tuple = PyTuple_New(2);
|
|
|
|
PyTuple_SetItem(tuple, 0, pyCritterBrain::New(critterBrain));
|
|
|
|
PyTuple_SetItem(tuple, 1, PyString_FromPlString(armMod->GetUserStr()));
|
|
|
|
|
|
|
|
PyList_Append(avList, tuple);
|
|
|
|
Py_DECREF(tuple);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return avList;
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::ForceVaultNodeUpdate(unsigned nodeId)
|
|
|
|
{
|
|
|
|
VaultFetchNodesAndWait(&nodeId, 1, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cyMisc::VaultDownload(unsigned nodeId)
|
|
|
|
{
|
|
|
|
VaultDownloadAndWait(
|
|
|
|
"PyVaultDownload",
|
|
|
|
nodeId,
|
|
|
|
nil,
|
|
|
|
nil
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::CloneKey(pyKey* object, bool loading) {
|
|
|
|
|
|
|
|
plKey obj = object->getKey();
|
|
|
|
plUoid uoid = obj->GetUoid();
|
|
|
|
|
|
|
|
plLoadCloneMsg* cloneMsg;
|
|
|
|
if (uoid.IsClone())
|
|
|
|
cloneMsg = new plLoadCloneMsg(obj, plNetClientMgr::GetInstance()->GetKey(), 0, loading);
|
|
|
|
else
|
|
|
|
cloneMsg = new plLoadCloneMsg(uoid, plNetClientMgr::GetInstance()->GetKey(), 0);
|
|
|
|
|
|
|
|
cloneMsg->SetBCastFlag(plMessage::kNetPropagate);
|
|
|
|
cloneMsg->SetBCastFlag(plMessage::kNetForce);
|
|
|
|
cloneMsg->Send();
|
|
|
|
|
|
|
|
return pyKey::New(cloneMsg->GetCloneKey());
|
|
|
|
}
|
|
|
|
|
|
|
|
PyObject* cyMisc::FindClones(pyKey* object) {
|
|
|
|
plKey obj = object->getKey();
|
|
|
|
plUoid uoid = obj->GetUoid();
|
|
|
|
|
|
|
|
plKeyImp* imp = ((plKeyImp*)obj);
|
|
|
|
uint32_t cloneNum = imp->GetNumClones();
|
|
|
|
PyObject* keyList = PyList_New(cloneNum);
|
|
|
|
|
|
|
|
for (int i=0; i < cloneNum; i++) {
|
|
|
|
PyObject* key = pyKey::New(imp->GetCloneByIdx(i));
|
|
|
|
PyList_SET_ITEM(keyList, i, key);
|
|
|
|
}
|
|
|
|
|
|
|
|
return keyList;
|
|
|
|
}
|