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.
 
 
 
 
 

399 lines
14 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "pyNotify.h"
#include "pyEnum.h"
#include <python.h>
// glue functions
PYTHON_CLASS_DEFINITION(ptNotify, pyNotify);
PYTHON_DEFAULT_NEW_DEFINITION(ptNotify, pyNotify)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptNotify)
PYTHON_INIT_DEFINITION(ptNotify, args, keywords)
{
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObj))
{
PyErr_SetString(PyExc_TypeError, "__init__ expects a ptKey");
PYTHON_RETURN_INIT_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "__init__ expects a ptKey");
PYTHON_RETURN_INIT_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
self->fThis->SetSender(*key);
PYTHON_RETURN_INIT_OK;
}
PYTHON_BASIC_METHOD_DEFINITION(ptNotify, clearReceivers, ClearReceivers)
PYTHON_METHOD_DEFINITION(ptNotify, addReceiver, args)
{
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObj))
{
PyErr_SetString(PyExc_TypeError, "addReceiver expects a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "addReceiver expects a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
self->fThis->AddReceiver(key);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, netPropagate, args)
{
char netFlag;
if (!PyArg_ParseTuple(args, "b", &netFlag))
{
PyErr_SetString(PyExc_TypeError, "netPropagate expects a boolean");
PYTHON_RETURN_ERROR;
}
self->fThis->SetNetPropagate(netFlag != 0);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, netForce, args)
{
char netFlag;
if (!PyArg_ParseTuple(args, "b", &netFlag))
{
PyErr_SetString(PyExc_TypeError, "netForce expects a boolean");
PYTHON_RETURN_ERROR;
}
self->fThis->SetNetForce(netFlag != 0);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, setActivate, args)
{
float actState;
if (!PyArg_ParseTuple(args, "f", &actState))
{
PyErr_SetString(PyExc_TypeError, "setActivate expects a float");
PYTHON_RETURN_ERROR;
}
self->fThis->SetActivateState(actState);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, setType, args)
{
long msgType;
if (!PyArg_ParseTuple(args, "l", &msgType))
{
PyErr_SetString(PyExc_TypeError, "setType expects a long");
PYTHON_RETURN_ERROR;
}
self->fThis->SetType(msgType);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addCollisionEvent, args)
{
char enterFlag;
PyObject* hitterKey = NULL;
PyObject* hitteeKey = NULL;
if (!PyArg_ParseTuple(args, "bOO", &enterFlag, &hitterKey, &hitteeKey))
{
PyErr_SetString(PyExc_TypeError, "addCollisionEvent expects a boolean, and two ptKeys");
PYTHON_RETURN_ERROR;
}
if ((!pyKey::Check(hitterKey)) || (!pyKey::Check(hitteeKey)))
{
PyErr_SetString(PyExc_TypeError, "addCollisionEvent expects a boolean, and two ptKeys");
PYTHON_RETURN_ERROR;
}
pyKey* hitter = pyKey::ConvertFrom(hitterKey);
pyKey* hittee = pyKey::ConvertFrom(hitteeKey);
self->fThis->AddCollisionEvent(enterFlag != 0, hitter, hittee);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addPickEvent, args)
{
char enabledFlag;
PyObject* pickerKey = NULL;
PyObject* pickeeKey = NULL;
PyObject* hitPointObj = NULL;
if (!PyArg_ParseTuple(args, "bOOO", &enabledFlag, &pickerKey, &pickeeKey, &hitPointObj))
{
PyErr_SetString(PyExc_TypeError, "addPickEvent expects a boolean, two ptKeys and a ptPoint3");
PYTHON_RETURN_ERROR;
}
if ((!pyKey::Check(pickerKey)) || (!pyKey::Check(pickeeKey)) || (!pyPoint3::Check(hitPointObj)))
{
PyErr_SetString(PyExc_TypeError, "addPickEvent expects a boolean, two ptKeys and a ptPoint3");
PYTHON_RETURN_ERROR;
}
pyKey* picker = pyKey::ConvertFrom(pickerKey);
pyKey* pickee = pyKey::ConvertFrom(pickeeKey);
pyPoint3* hitPoint = pyPoint3::ConvertFrom(hitPointObj);
self->fThis->AddPickEvent(enabledFlag != 0, picker, pickee, *hitPoint);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addControlKeyEvent, args)
{
long key;
char down;
if (!PyArg_ParseTuple(args, "lb", &key, &down))
{
PyErr_SetString(PyExc_TypeError, "addControlKeyEvent expects a long and a boolean");
PYTHON_RETURN_ERROR;
}
self->fThis->AddControlKeyEvent(key, down != 0);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addVarNumber, args)
{
char* name;
float number;
if (!PyArg_ParseTuple(args, "sf", &name, &number))
{
PyErr_SetString(PyExc_TypeError, "addVarNumber expects a string and a float");
PYTHON_RETURN_ERROR;
}
self->fThis->AddVarNumber(name, number);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addVarKey, args)
{
char* name;
PyObject* keyObj = NULL;
if (!PyArg_ParseTuple(args, "sO", &name, &keyObj))
{
PyErr_SetString(PyExc_TypeError, "addVarKey expects a string and a ptKey");
PYTHON_RETURN_ERROR;
}
if (!pyKey::Check(keyObj))
{
PyErr_SetString(PyExc_TypeError, "addVarKey expects a string and a ptKey");
PYTHON_RETURN_ERROR;
}
pyKey* key = pyKey::ConvertFrom(keyObj);
self->fThis->AddVarKey(name, key);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addFacingEvent, args)
{
char enabledFlag;
PyObject* facerKey = NULL;
PyObject* faceeKey = NULL;
float dot;
if (!PyArg_ParseTuple(args, "bOOf", &enabledFlag, &facerKey, &faceeKey, &dot))
{
PyErr_SetString(PyExc_TypeError, "addFacingEvent expects a boolean, two ptKeys, and a float");
PYTHON_RETURN_ERROR;
}
if ((!pyKey::Check(facerKey)) || (!pyKey::Check(faceeKey)))
{
PyErr_SetString(PyExc_TypeError, "addFacingEvent expects a boolean, two ptKeys, and a float");
PYTHON_RETURN_ERROR;
}
pyKey* facer = pyKey::ConvertFrom(facerKey);
pyKey* facee = pyKey::ConvertFrom(faceeKey);
self->fThis->AddFacingEvent(enabledFlag != 0, facer, facee, dot);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addContainerEvent, args)
{
char enterFlag;
PyObject* containerKey = NULL;
PyObject* containedKey = NULL;
if (!PyArg_ParseTuple(args, "bOO", &enterFlag, &containerKey, &containedKey))
{
PyErr_SetString(PyExc_TypeError, "addContainerEvent expects a boolean, and two ptKeys");
PYTHON_RETURN_ERROR;
}
pyKey* container = NULL;
pyKey* contained = NULL;
if (containerKey != Py_None)
{
if (!pyKey::Check(containerKey))
{
PyErr_SetString(PyExc_TypeError, "addContainerEvent expects a boolean, and two ptKeys");
PYTHON_RETURN_ERROR;
}
container = pyKey::ConvertFrom(containerKey);
}
if (containedKey != Py_None)
{
if (!pyKey::Check(containedKey))
{
PyErr_SetString(PyExc_TypeError, "addContainerEvent expects a boolean, and two ptKeys");
PYTHON_RETURN_ERROR;
}
contained = pyKey::ConvertFrom(containedKey);
}
self->fThis->AddContainerEvent(enterFlag != 0, container, contained);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addActivateEvent, args)
{
char activeFlag, activateFlag;
if (!PyArg_ParseTuple(args, "bb", &activeFlag, &activateFlag))
{
PyErr_SetString(PyExc_TypeError, "addActivateEvent expects two booleans");
PYTHON_RETURN_ERROR;
}
self->fThis->AddActivateEvent(activeFlag != 0, activateFlag != 0);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addCallbackEvent, args)
{
long eventNumber;
if (!PyArg_ParseTuple(args, "l", &eventNumber))
{
PyErr_SetString(PyExc_TypeError, "addCallbackEvent expects a long");
PYTHON_RETURN_ERROR;
}
self->fThis->AddCallbackEvent(eventNumber);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptNotify, addResponderState, args)
{
long respState;
if (!PyArg_ParseTuple(args, "l", &respState))
{
PyErr_SetString(PyExc_TypeError, "addResponderState expects a long");
PYTHON_RETURN_ERROR;
}
self->fThis->AddResponderState(respState);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptNotify, send, Send)
PYTHON_START_METHODS_TABLE(ptNotify)
PYTHON_BASIC_METHOD(ptNotify, clearReceivers, "Remove all the receivers that this Notify message has\n"
"- receivers are automatically added if from a ptAttribActivator"),
PYTHON_METHOD(ptNotify, addReceiver, "Params: key\nAdd a receivers key to receive this Notify message"),
PYTHON_METHOD(ptNotify, netPropagate, "Params: netFlag\nSets the net propagate flag - default to set"),
PYTHON_METHOD(ptNotify, netForce, "Params: forceFlag\nSpecify whether this object needs to use messages that are forced to the network\n"
"- This is to be used if your Python program is running on only one client\n"
"Such as a game master, only running on the client that owns a particular object"),
PYTHON_METHOD(ptNotify, setActivate, "Params: state\nSet the activate state to true(1.0) or false(0.0)"),
PYTHON_METHOD(ptNotify, setType, "Params: type\nSets the message type"),
PYTHON_METHOD(ptNotify, addCollisionEvent, "Params: enterFlag,hitterKey,hitteeKey\nAdd a collision event record to the Notify message"),
PYTHON_METHOD(ptNotify, addPickEvent, "Params: enabledFlag,pickerKey,pickeeKey,hitPoint\nAdd a pick event record to the Notify message"),
PYTHON_METHOD(ptNotify, addControlKeyEvent, "Params: keynumber,downFlag\nAdd a keyboard event record to the Notify message"),
PYTHON_METHOD(ptNotify, addVarNumber, "Params: name,number\nAdd a number variable event record to the Notify message\n"
"This event record is used to pass a number variable to another python program"),
PYTHON_METHOD(ptNotify, addVarKey, "Params: name,key\nAdd a ptKey variable event record to the Notify message\n"
"This event record is used to pass a ptKey variable to another python program"),
PYTHON_METHOD(ptNotify, addFacingEvent, "Params: enabledFlag,facerKey, faceeKey, dotProduct\nAdd a facing event record to the Notify message"),
PYTHON_METHOD(ptNotify, addContainerEvent, "Params: enteringFlag,containerKey,containedKey\nAdd a container event record to the notify message"),
PYTHON_METHOD(ptNotify, addActivateEvent, "Params: activeFlag,activateFlag\nAdd an activate event record to the notify message"),
PYTHON_METHOD(ptNotify, addCallbackEvent, "Params: eventNumber\nAdd a callback event record to the notify message"),
PYTHON_METHOD(ptNotify, addResponderState, "Params: state\nAdd a responder state event record to the notify message"),
PYTHON_BASIC_METHOD(ptNotify, send, "Send the notify message"),
PYTHON_END_METHODS_TABLE;
// Type structure definition
PLASMA_DEFAULT_TYPE(ptNotify, "Params: selfKey\nCreates a Notify message\n"
"- selfKey is ptKey of your PythonFile modifier");
// required functions for PyObject interoperability
PyObject *pyNotify::New(pyKey& selfkey)
{
ptNotify *newObj = (ptNotify*)ptNotify_type.tp_new(&ptNotify_type, NULL, NULL);
newObj->fThis->SetSender(selfkey);
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptNotify, pyNotify)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptNotify, pyNotify)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyNotify::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptNotify);
PYTHON_CLASS_IMPORT_END(m);
}
void pyNotify::AddPlasmaConstantsClasses(PyObject *m)
{
PYTHON_ENUM_START(PtNotificationType);
PYTHON_ENUM_ELEMENT(PtNotificationType, kActivator, plNotifyMsg::kActivator);
PYTHON_ENUM_ELEMENT(PtNotificationType, kVarNotification, plNotifyMsg::kVarNotification);
PYTHON_ENUM_ELEMENT(PtNotificationType, kNotifySelf, plNotifyMsg::kNotifySelf);
PYTHON_ENUM_ELEMENT(PtNotificationType, kResponderFF, plNotifyMsg::kResponderFF);
PYTHON_ENUM_ELEMENT(PtNotificationType, kResponderChangeState, plNotifyMsg::kResponderChangeState);
PYTHON_ENUM_END(m, PtNotificationType);
PYTHON_ENUM_START(PtEventType);
PYTHON_ENUM_ELEMENT(PtEventType, kCollision, proEventData::kCollision);
PYTHON_ENUM_ELEMENT(PtEventType, kPicked, proEventData::kPicked);
PYTHON_ENUM_ELEMENT(PtEventType, kControlKey, proEventData::kControlKey);
PYTHON_ENUM_ELEMENT(PtEventType, kVariable, proEventData::kVariable);
PYTHON_ENUM_ELEMENT(PtEventType, kFacing, proEventData::kFacing);
PYTHON_ENUM_ELEMENT(PtEventType, kContained, proEventData::kContained);
PYTHON_ENUM_ELEMENT(PtEventType, kActivate, proEventData::kActivate);
PYTHON_ENUM_ELEMENT(PtEventType, kCallback, proEventData::kCallback);
PYTHON_ENUM_ELEMENT(PtEventType, kResponderState, proEventData::kResponderState);
PYTHON_ENUM_ELEMENT(PtEventType, kMultiStage, proEventData::kMultiStage);
PYTHON_ENUM_ELEMENT(PtEventType, kSpawned, proEventData::kSpawned);
PYTHON_ENUM_ELEMENT(PtEventType, kClickDrag, proEventData::kClickDrag);
PYTHON_ENUM_ELEMENT(PtEventType, kOfferLinkingBook, proEventData::kOfferLinkingBook);
PYTHON_ENUM_ELEMENT(PtEventType, kBook, proEventData::kBook);
PYTHON_ENUM_END(m, PtEventType);
PYTHON_ENUM_START(PtNotifyDataType);
PYTHON_ENUM_ELEMENT(PtNotifyDataType, kNumber, proEventData::kNumber);
PYTHON_ENUM_ELEMENT(PtNotifyDataType, kKey, proEventData::kKey);
PYTHON_ENUM_END(m, PtNotifyDataType);
PYTHON_ENUM_START(PtMultiStageEventType);
PYTHON_ENUM_ELEMENT(PtMultiStageEventType, kEnterStage, proEventData::kEnterStage);
PYTHON_ENUM_ELEMENT(PtMultiStageEventType, kBeginingOfLoop, proEventData::kBeginingOfLoop);
PYTHON_ENUM_ELEMENT(PtMultiStageEventType, kAdvanceNextStage, proEventData::kAdvanceNextStage);
PYTHON_ENUM_ELEMENT(PtMultiStageEventType, kRegressPrevStage, proEventData::kRegressPrevStage);
PYTHON_ENUM_END(m, PtMultiStageEventType);
}