OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
104 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: 745d8c675f
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '745d8c675f'
${ noResults }
CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/cyMiscGlue3.cpp

762 lines
27 KiB
Raw Blame History

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "cyMisc.h"
#include "pyGlueHelpers.h"
#include "pyKey.h"
#include "pySceneObject.h"
#include <python.h>
PYTHON_GLOBAL_METHOD_DEFINITION(PtSendPetitionToCCR, args, "Params: message,reason=0,title=\"\"\nSends a petition with a message to the CCR group")
{
char* message;
unsigned char reason = 0;
char* title = nil;
if (!PyArg_ParseTuple(args, "s|bs", &message, &reason, &title))
{
PyErr_SetString(PyExc_TypeError, "PtSendPetitionToCCR expects a string, and an optional unsigned 8-bit int and optional string");
PYTHON_RETURN_ERROR;
}
cyMisc::SendPetitionToCCRI(message, reason, title);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtSendChatToCCR, args, "Params: message,CCRPlayerID\nSends a chat message to a CCR that has contacted this player")
{
char* message;
long CCRPlayerID;
if (!PyArg_ParseTuple(args, "sl", &message, &CCRPlayerID))
{
PyErr_SetString(PyExc_TypeError, "PtSendChatToCCR expects a string and a long");
PYTHON_RETURN_ERROR;
}
cyMisc::SendChatToCCR(message, CCRPlayerID);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetPythonLoggingLevel, "Returns the current level of python logging")
{
return PyLong_FromUnsignedLong(cyMisc::GetPythonLoggingLevel());
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtSetPythonLoggingLevel, args, "Params: level\nSets the current level of python logging")
{
unsigned long level;
if (!PyArg_ParseTuple(args, "l", &level))
{
PyErr_SetString(PyExc_TypeError, "PtSetPythonLoggingLevel expects an unsigned long");
PYTHON_RETURN_ERROR;
}
cyMisc::SetPythonLoggingLevel(level);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtConsole, args, "Params: command\nThis will execute 'command' as if it were typed into the Plasma console.")
{
char* command;
if (!PyArg_ParseTuple(args, "s", &command))
{
PyErr_SetString(PyExc_TypeError, "PtConsole expects a string");
PYTHON_RETURN_ERROR;
}
cyMisc::Console(command);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtConsoleNet, args, "Params: command,netForce\nThis will execute 'command' on the console, over the network, on all clients.\n"
"If 'netForce' is true then force command to be sent over the network.")
{
char* command;
char netForce;
if (!PyArg_ParseTuple(args, "sb", &command, &netForce))
{
PyErr_SetString(PyExc_TypeError, "PtConsoleNet expects a string and a boolean");
PYTHON_RETURN_ERROR;
}
cyMisc::ConsoleNet(command, netForce != 0);
PYTHON_RETURN_NONE;
}
#if 1
// TEMP
PYTHON_GLOBAL_METHOD_DEFINITION(PtPrintToScreen, args, "Params: message\nPrints 'message' to the status log, for debug only.")
{
char* message;
if (!PyArg_ParseTuple(args, "s", &message))
{
PyErr_SetString(PyExc_TypeError, "PtPrintToScreen expects a string");
PYTHON_RETURN_ERROR;
}
cyMisc::PrintToScreen(message);
PYTHON_RETURN_NONE;
}
#endif
PYTHON_GLOBAL_METHOD_DEFINITION(PtAtTimeCallback, args, "Params: selfkey,time,id\nThis will create a timer callback that will call OnTimer when complete\n"
"- 'selfkey' is the ptKey of the PythonFile component\n"
"- 'time' is how much time from now (in seconds) to call back\n"
"- 'id' is an integer id that will be returned in the OnTimer call")
{
PyObject* keyObj = NULL;
float time;
unsigned long id;
if (!PyArg_ParseTuple(args, "Ofl", &keyObj, &time, &id))
{
PyErr_SetString(PyExc_TypeError, "PtAtTimeCallback expects a ptKey, a float, and an unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtAtTimeCallback expects a ptKey, a float, and an unsigned long");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::TimerCallback(*key, time, id);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtClearTimerCallbacks, args, "Params: key\nThis will remove timer callbacks to the specified key")
{
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtClearTimerCallbacks expects a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtClearTimerCallbacks expects a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::ClearTimerCallbacks(*key);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtFindSceneobject, args, "Params: name,ageName\nThis will try to find a sceneobject based on its name and what age its in\n"
"- it will return a ptSceneObject if found"
"- if not found then a NameError exception will happen")
{
char* name;
char* ageName;
if (!PyArg_ParseTuple(args, "ss", &name, &ageName))
{
PyErr_SetString(PyExc_TypeError, "PtFindSceneobject expects two strings");
PYTHON_RETURN_ERROR;
}
return cyMisc::FindSceneObject(name, ageName);
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtFindActivator, args, "Params: name\nThis will try to find an activator based on its name\n"
"- it will return a ptKey if found"
"- it will return None if not found")
{
char* name;
if (!PyArg_ParseTuple(args, "s", &name))
{
PyErr_SetString(PyExc_TypeError, "PtFindActivator expects a string");
PYTHON_RETURN_ERROR;
}
return cyMisc::FindActivator(name);
}
PYTHON_BASIC_GLOBAL_METHOD_DEFINITION(PtClearCameraStack, cyMisc::ClearCameraStack, "Clears the camera stack")
PYTHON_GLOBAL_METHOD_DEFINITION(PtWasLocallyNotified, args, "Params: selfKey\nReturns 1 if the last notify was local or 0 if the notify originated on the network")
{
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtWasLocallyNotified expects a ptKey");
PYTHON_RETURN_NONE;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtWasLocallyNotified expects a ptKey");
PYTHON_RETURN_NONE;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
PYTHON_RETURN_BOOL(cyMisc::WasLocallyNotified(*key));
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtAttachObject, args, "Params: child,parent\nAttach child to parent based on ptKey or ptSceneobject\n"
"- childKey is the ptKey or ptSceneobject of the one being attached\n"
"- parentKey is the ptKey or ptSceneobject of the one being attached to\n"
"(both arguments must be ptKeys or ptSceneobjects, you cannot mix types)")
{
PyObject* childObj = NULL;
PyObject* parentObj = NULL;
if (!PyArg_ParseTuple(args, "OO", &childObj, &parentObj))
{
PyErr_SetString(PyExc_TypeError, "PtAttachObject expects either two ptKeys or two ptSceneobjects");
PYTHON_RETURN_ERROR;
}
if ((pyKey::Check(childObj)) && (pyKey::Check(parentObj)))
{
pyKey* child = pyKey::ConvertFrom(childObj);
pyKey* parent = pyKey::ConvertFrom(parentObj);
cyMisc::AttachObject(*child, *parent);
}
else if ((pySceneObject::Check(childObj)) && (pySceneObject::Check(parentObj)))
{
pySceneObject* child = pySceneObject::ConvertFrom(childObj);
pySceneObject* parent = pySceneObject::ConvertFrom(parentObj);
cyMisc::AttachObjectSO(*child, *parent);
}
else
{
PyErr_SetString(PyExc_TypeError, "PtAttachObject expects either two ptKeys or two ptSceneobjects");
PYTHON_RETURN_ERROR;
}
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtDetachObject, args, "Params: child,parent\nDetach child from parent based on ptKey or ptSceneobject\n"
"- child is the ptKey or ptSceneobject of the one being detached\n"
"- parent is the ptKey or ptSceneobject of the one being detached from\n"
"(both arguments must be ptKeys or ptSceneobjects, you cannot mix types)")
{
PyObject* childObj = NULL;
PyObject* parentObj = NULL;
if (!PyArg_ParseTuple(args, "OO", &childObj, &parentObj))
{
PyErr_SetString(PyExc_TypeError, "PtDetachObject expects either two ptKeys or two ptSceneobjects");
PYTHON_RETURN_ERROR;
}
if ((pyKey::Check(childObj)) && (pyKey::Check(parentObj)))
{
pyKey* child = pyKey::ConvertFrom(childObj);
pyKey* parent = pyKey::ConvertFrom(parentObj);
cyMisc::DetachObject(*child, *parent);
}
else if ((pySceneObject::Check(childObj)) && (pySceneObject::Check(parentObj)))
{
pySceneObject* child = pySceneObject::ConvertFrom(childObj);
pySceneObject* parent = pySceneObject::ConvertFrom(parentObj);
cyMisc::DetachObjectSO(*child, *parent);
}
else
{
PyErr_SetString(PyExc_TypeError, "PtDetachObject expects either two ptKeys or two ptSceneobjects");
PYTHON_RETURN_ERROR;
}
PYTHON_RETURN_NONE;
}
/*PYTHON_GLOBAL_METHOD_DEFINITION(PtLinkToAge, args, "Params: selfKey,ageName,spawnPointName\nDEPRECIATED: Links you to the specified age and spawnpoint")
{
PyObject* keyObj = NULL;
char* ageName;
char* spawnPointName;
if (!PyArg_ParseTuple(args, "Oss", &keyObj, &ageName, &spawnPointName))
{
PyErr_SetString(PyExc_TypeError, "PtLinkToAge expects a ptKey, and two strings");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtLinkToAge expects a ptKey, and two strings");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::LinkToAge(*key, ageName, spawnPointName);
PYTHON_RETURN_NONE;
}*/
PYTHON_GLOBAL_METHOD_DEFINITION(PtDirtySynchState, args, "Params: selfKey,SDLStateName,flags\nDO NOT USE - handled by ptSDL")
{
PyObject* keyObj = NULL;
char* SDLStateName;
unsigned long flags;
if (!PyArg_ParseTuple(args, "Osl", &keyObj, &SDLStateName, &flags))
{
PyErr_SetString(PyExc_TypeError, "PtDirtySynchState expects a ptKey, a string, and an unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtDirtySynchState expects a ptKey, a string, and an unsigned long");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::SetDirtySyncState(*key, SDLStateName, flags);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtDirtySynchClients, args, "Params: selfKey,SDLStateName,flags\nDO NOT USE - handled by ptSDL")
{
PyObject* keyObj = NULL;
char* SDLStateName;
unsigned long flags;
if (!PyArg_ParseTuple(args, "Osl", &keyObj, &SDLStateName, &flags))
{
PyErr_SetString(PyExc_TypeError, "PtDirtySynchClients expects a ptKey, a string, and an unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtDirtySynchClients expects a ptKey, a string, and an unsigned long");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::SetDirtySyncStateWithClients(*key, SDLStateName, flags);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtEnableControlKeyEvents, args, "Params: selfKey\nEnable control key events to call OnControlKeyEvent(controlKey,activateFlag)")
{
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtEnableControlKeyEvents expects a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtEnableControlKeyEvents expects a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::EnableControlKeyEvents(*key);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtDisableControlKeyEvents, args, "Params: selfKey\nDisable the control key events from calling OnControlKeyEvent")
{
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtDisableControlKeyEvents expects a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtDisableControlKeyEvents expects a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::DisableControlKeyEvents(*key);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_GLOBAL_METHOD_DEFINITION(PtEnableAvatarCursorFade, cyMisc::EnableAvatarCursorFade, "Enable the avatar cursor fade")
PYTHON_BASIC_GLOBAL_METHOD_DEFINITION(PtDisableAvatarCursorFade, cyMisc::DisableAvatarCursorFade, "Disable the avatar cursor fade")
PYTHON_GLOBAL_METHOD_DEFINITION(PtFadeLocalAvatar, args, "Params: fade\nFade (or unfade) the local avatar")
{
char fade;
if (!PyArg_ParseTuple(args, "b", &fade))
{
PyErr_SetString(PyExc_TypeError, "PtFadeLocalAvatar expects a boolean");
PYTHON_RETURN_ERROR;
}
cyMisc::FadeLocalPlayer(fade != 0);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtSetOfferBookMode, args, "Params: selfkey,ageFilename,ageInstanceName\nPut us into the offer book interface")
{
PyObject* keyObj = NULL;
char* ageFilename;
char* ageInstanceName;
if (!PyArg_ParseTuple(args, "Oss", &keyObj, &ageFilename, &ageInstanceName))
{
PyErr_SetString(PyExc_TypeError, "PtSetOfferBookMode expects a ptKey, and two strings");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtSetOfferBookMode expects a ptKey, and two strings");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::EnableOfferBookMode(*key, ageFilename, ageInstanceName);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtSetShareSpawnPoint, args, "Params: spawnPoint\nThis sets the desired spawn point for the receiver to link to")
{
char* spawnPoint;
if (!PyArg_ParseTuple(args, "s", &spawnPoint))
{
PyErr_SetString(PyExc_TypeError, "PtSetShareSpawnPoint expects a string");
PYTHON_RETURN_ERROR;
}
cyMisc::SetShareSpawnPoint(spawnPoint);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtSetShareAgeInstanceGuid, args, "Params: instanceGuid\nThis sets the desired age instance guid for the receiver to link to")
{
char* guidStr;
if (!PyArg_ParseTuple(args, "s", &guidStr))
{
PyErr_SetString(PyExc_TypeError, "PtSetShareAgeInstanceGuid expects a string");
PYTHON_RETURN_ERROR;
}
Uuid guid;
if (!GuidFromString(guidStr, &guid))
{
PyErr_SetString(PyExc_TypeError, "PtSetShareAgeInstanceGuid string parameter is not a guid string");
PYTHON_RETURN_ERROR;
}
cyMisc::SetShareAgeInstanceGuid(guid);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtNotifyOffererLinkAccepted, args, "Params: offerer\nTell the offerer that we accepted the link offer")
{
unsigned long offerer;
if (!PyArg_ParseTuple(args, "l", &offerer))
{
PyErr_SetString(PyExc_TypeError, "PtNotifyOffererLinkAccepted expects an unsigned long");
PYTHON_RETURN_ERROR;
}
cyMisc::NotifyOffererPublicLinkAccepted(offerer);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtNotifyOffererLinkRejected, args, "Params: offerer\nTell the offerer that we rejected the link offer")
{
unsigned long offerer;
if (!PyArg_ParseTuple(args, "l", &offerer))
{
PyErr_SetString(PyExc_TypeError, "PtNotifyOffererLinkRejected expects an unsigned long");
PYTHON_RETURN_ERROR;
}
cyMisc::NotifyOffererPublicLinkRejected(offerer);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtNotifyOffererLinkCompleted, args, "Params: offerer\nTell the offerer that we completed the link")
{
unsigned long offerer;
if (!PyArg_ParseTuple(args, "l", &offerer))
{
PyErr_SetString(PyExc_TypeError, "PtNotifyOffererLinkCompleted expects an unsigned long");
PYTHON_RETURN_ERROR;
}
cyMisc::NotifyOffererPublicLinkCompleted(offerer);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_GLOBAL_METHOD_DEFINITION(PtClearOfferBookMode, cyMisc::DisableOfferBookMode, "Cancel the offer book interface")
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetLocalClientID, "Returns our local client ID number")
{
return PyInt_FromLong(cyMisc::GetLocalClientID());
}
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtIsCCRAway, "Returns current status of CCR dept")
{
PYTHON_RETURN_BOOL(cyMisc::IsCCRAwayStatus());
}
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtAmCCR, "Returns true if local player is a CCR")
{
PYTHON_RETURN_BOOL(cyMisc::AmCCR());
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtToggleAvatarClickability, args, "Params: on\nTurns on and off our avatar's clickability")
{
char on;
if (!PyArg_ParseTuple(args, "b", &on))
{
PyErr_SetString(PyExc_TypeError, "PtToggleAvatarClickability expects a boolean");
PYTHON_RETURN_ERROR;
}
cyMisc::ToggleAvatarClickability(on != 0);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtTransferParticlesToObject, args, "Params: objFrom, objTo, num\nTransfers num particles from objFrom to objTo")
{
PyObject* objFrom = NULL;
PyObject* objTo = NULL;
int num;
if (!PyArg_ParseTuple(args, "OOi", &objFrom, &objTo, &num))
{
PyErr_SetString(PyExc_TypeError, "PtTransferParticlesToObject expects two ptKeys and an int");
PYTHON_RETURN_ERROR;
}
if ((!pyKey::Check(objFrom)) || (!pyKey::Check(objTo)))
{
PyErr_SetString(PyExc_TypeError, "PtTransferParticlesToObject expects two ptKeys and an int");
PYTHON_RETURN_ERROR;
}
pyKey* from = pyKey::ConvertFrom(objFrom);
pyKey* to = pyKey::ConvertFrom(objTo);
cyMisc::TransferParticlesToKey(*from, *to, num);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtSetParticleDissentPoint, args, "Params: x, y, z, particlesys\nSets the dissent point of the particlesys to x,y,z")
{
float x,y,z;
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "fffO", &x, &y, &z, &keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtSetParticleDissentPoint expects three floats and a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtSetParticleDissentPoint expects three floats and a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::SetParticleDissentPoint(x, y, z, *key);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtGetControlEvents, args, "Params: on, key\nRegisters or unregisters for control event messages")
{
char on;
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "bO", &on, &keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtGetControlEvents expects a boolean and a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtGetControlEvents expects a boolean and a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::RegisterForControlEventMessages(on != 0, *key);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetLanguage, "Returns the current language as a PtLanguage enum")
{
return PyInt_FromLong(cyMisc::GetLanguage());
}
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtUsingUnicode, "Returns true if the current language is a unicode language (like Japanese)")
{
PYTHON_RETURN_BOOL(cyMisc::UsingUnicode());
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtFakeLinkAvatarToObject, args, "Params: avatar,object\nPseudo-links avatar to object within the same age\n")
{
PyObject* avatarObj = NULL;
PyObject* objectObj = NULL;
if (!PyArg_ParseTuple(args, "OO", &avatarObj, &objectObj))
{
PyErr_SetString(PyExc_TypeError, "PtFakeLinkAvatarToObject expects two ptKeys");
PYTHON_RETURN_ERROR;
}
if ((!pyKey::Check(avatarObj)) || (!pyKey::Check(objectObj)))
{
PyErr_SetString(PyExc_TypeError, "PtFakeLinkAvatarToObject expects two ptKeys");
PYTHON_RETURN_ERROR;
}
pyKey* avatar = pyKey::ConvertFrom(avatarObj);
pyKey* object = pyKey::ConvertFrom(objectObj);
cyMisc::FakeLinkToObject(*avatar, *object);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtWearDefaultClothingType, args, "Params: key,type\nForces the avatar to wear the default clothing of the specified type")
{
PyObject* keyObj = NULL;
unsigned long type;
if (!PyArg_ParseTuple(args, "Ol", &keyObj, &type))
{
PyErr_SetString(PyExc_TypeError, "PtWearDefaultClothingType expects a ptKey and an unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "PtWearDefaultClothingType expects a ptKey and an unsigned long");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
cyMisc::WearDefaultClothingType(*key, type);
PYTHON_RETURN_NONE;
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtFileExists, args, "Params: filename\nReturns true if the specified file exists")
{
PyObject* filenameObj;
if (!PyArg_ParseTuple(args, "O", &filenameObj))
{
PyErr_SetString(PyExc_TypeError, "PtFileExists expects a string");
PYTHON_RETURN_ERROR;
}
if (PyUnicode_Check(filenameObj))
{
int strLen = PyUnicode_GetSize(filenameObj);
wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
PyUnicode_AsWideChar((PyUnicodeObject*)filenameObj, text, strLen);
text[strLen] = L'\0';
bool retVal = cyMisc::FileExists(text);
delete [] text;
PYTHON_RETURN_BOOL(retVal);
}
else if (PyString_Check(filenameObj))
{
// we'll allow this, just in case something goes weird
char* text = PyString_AsString(filenameObj);
wchar_t* wText = hsStringToWString(text);
bool retVal = cyMisc::FileExists(wText);
delete [] wText;
PYTHON_RETURN_BOOL(retVal);
}
else
{
PyErr_SetString(PyExc_TypeError, "PtFileExists expects a string");
PYTHON_RETURN_ERROR;
}
}
PYTHON_GLOBAL_METHOD_DEFINITION(PtCreateDir, args, "Params: directory\nCreates the directory and all parent folders. Returns false on failure")
{
PyObject* directoryObj;
if (!PyArg_ParseTuple(args, "O", &directoryObj))
{
PyErr_SetString(PyExc_TypeError, "PtCreateDir expects a string");
PYTHON_RETURN_ERROR;
}
if (PyUnicode_Check(directoryObj))
{
int strLen = PyUnicode_GetSize(directoryObj);
wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
PyUnicode_AsWideChar((PyUnicodeObject*)directoryObj, text, strLen);
text[strLen] = L'\0';
bool retVal = cyMisc::CreateDir(text);
delete [] text;
PYTHON_RETURN_BOOL(retVal);
}
else if (PyString_Check(directoryObj))
{
// we'll allow this, just in case something goes weird
char* text = PyString_AsString(directoryObj);
wchar_t* wText = hsStringToWString(text);
bool retVal = cyMisc::CreateDir(wText);
delete [] wText;
PYTHON_RETURN_BOOL(retVal);
}
else
{
PyErr_SetString(PyExc_TypeError, "PtCreateDir expects a string");
PYTHON_RETURN_ERROR;
}
}
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetUserPath, "Returns the unicode path to the client's root user directory. Do NOT convert to a standard string.")
{
std::wstring val = cyMisc::GetUserPath();
return PyUnicode_FromWideChar(val.c_str(), val.length());
}
PYTHON_GLOBAL_METHOD_DEFINITION_NOARGS(PtGetInitPath, "Returns the unicode path to the client's init directory. Do NOT convert to a standard string.")
{
std::wstring val = cyMisc::GetInitPath();
return PyUnicode_FromWideChar(val.c_str(), val.length());
}
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaMethods - the python method definitions
//
void cyMisc::AddPlasmaMethods3(std::vector<PyMethodDef> &methods)
{
PYTHON_GLOBAL_METHOD(methods, PtSendPetitionToCCR);
PYTHON_GLOBAL_METHOD(methods, PtSendChatToCCR);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetPythonLoggingLevel);
PYTHON_GLOBAL_METHOD(methods, PtSetPythonLoggingLevel);
PYTHON_GLOBAL_METHOD(methods, PtConsole);
PYTHON_GLOBAL_METHOD(methods, PtConsoleNet);
#if 1
// TEMP
PYTHON_GLOBAL_METHOD(methods, PtPrintToScreen);
#endif
PYTHON_GLOBAL_METHOD(methods, PtAtTimeCallback);
PYTHON_GLOBAL_METHOD(methods, PtClearTimerCallbacks);
PYTHON_GLOBAL_METHOD(methods, PtFindSceneobject);
PYTHON_GLOBAL_METHOD(methods, PtFindActivator);
PYTHON_BASIC_GLOBAL_METHOD(methods, PtClearCameraStack);
PYTHON_GLOBAL_METHOD(methods, PtWasLocallyNotified);
PYTHON_GLOBAL_METHOD(methods, PtAttachObject);
PYTHON_GLOBAL_METHOD(methods, PtDetachObject);
//PYTHON_GLOBAL_METHOD(methods, PtLinkToAge);
PYTHON_GLOBAL_METHOD(methods, PtDirtySynchState);
PYTHON_GLOBAL_METHOD(methods, PtDirtySynchClients);
PYTHON_GLOBAL_METHOD(methods, PtEnableControlKeyEvents);
PYTHON_GLOBAL_METHOD(methods, PtDisableControlKeyEvents);
PYTHON_BASIC_GLOBAL_METHOD(methods, PtEnableAvatarCursorFade);
PYTHON_BASIC_GLOBAL_METHOD(methods, PtDisableAvatarCursorFade);
PYTHON_GLOBAL_METHOD(methods, PtFadeLocalAvatar);
PYTHON_GLOBAL_METHOD(methods, PtSetOfferBookMode);
PYTHON_GLOBAL_METHOD(methods, PtSetShareSpawnPoint);
PYTHON_GLOBAL_METHOD(methods, PtSetShareAgeInstanceGuid);
PYTHON_GLOBAL_METHOD(methods, PtNotifyOffererLinkAccepted);
PYTHON_GLOBAL_METHOD(methods, PtNotifyOffererLinkRejected);
PYTHON_GLOBAL_METHOD(methods, PtNotifyOffererLinkCompleted);
PYTHON_BASIC_GLOBAL_METHOD(methods, PtClearOfferBookMode);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetLocalClientID);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtIsCCRAway);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtAmCCR);
PYTHON_GLOBAL_METHOD(methods, PtToggleAvatarClickability);
PYTHON_GLOBAL_METHOD(methods, PtTransferParticlesToObject);
PYTHON_GLOBAL_METHOD(methods, PtSetParticleDissentPoint);
PYTHON_GLOBAL_METHOD(methods, PtGetControlEvents);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetLanguage);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtUsingUnicode);
PYTHON_GLOBAL_METHOD(methods, PtFakeLinkAvatarToObject);
PYTHON_GLOBAL_METHOD(methods, PtWearDefaultClothingType);
PYTHON_GLOBAL_METHOD(methods, PtFileExists);
PYTHON_GLOBAL_METHOD(methods, PtCreateDir);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetUserPath);
PYTHON_GLOBAL_METHOD_NOARGS(methods, PtGetInitPath);
}