diff --git a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp index c658cf2a..665a4325 100644 --- a/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp +++ b/Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp @@ -1358,12 +1358,19 @@ hsBool plPythonFileMod::MsgReceive(plMessage* msg) // depending on the data type create the data switch ( eventData->fDataType ) { - case proEventData::kNumber: - PyList_SetItem(event, 3, PyFloat_FromDouble(eventData->fNumber)); + case proEventData::kFloat: + PyList_SetItem(event, 3, PyFloat_FromDouble(eventData->fNumber.f)); break; case proEventData::kKey: PyList_SetItem(event, 3, pyKey::New(eventData->fKey)); break; + case proEventData::kInt: + PyList_SetItem(event, 3, PyInt_FromLong(eventData->fNumber.i)); + break; + default: + Py_XINCREF(Py_None); + PyList_SetItem(event, 3, Py_None); + break; } // add this event record to the main event list (lists within a list) PyList_Append(levents, event); diff --git a/Sources/Plasma/FeatureLib/pfPython/pyNotify.cpp b/Sources/Plasma/FeatureLib/pfPython/pyNotify.cpp index a8846251..275f525b 100644 --- a/Sources/Plasma/FeatureLib/pfPython/pyNotify.cpp +++ b/Sources/Plasma/FeatureLib/pfPython/pyNotify.cpp @@ -148,7 +148,17 @@ void pyNotify::AddControlKeyEvent( int32_t key, hsBool down ) void pyNotify::AddVarNumber(const char* name, float number) { - fBuildMsg.AddVariableEvent(name,number); + fBuildMsg.AddVariableEvent(name, number); +} + +void pyNotify::AddVarNumber(const char* name, int number) +{ + fBuildMsg.AddVariableEvent(name, number); +} + +void pyNotify::AddVarNull(const char* name) +{ + fBuildMsg.AddVariableEvent(name); } void pyNotify::AddVarKey(const char* name, pyKey* key) diff --git a/Sources/Plasma/FeatureLib/pfPython/pyNotify.h b/Sources/Plasma/FeatureLib/pfPython/pyNotify.h index b02b6ffe..95b84bc9 100644 --- a/Sources/Plasma/FeatureLib/pfPython/pyNotify.h +++ b/Sources/Plasma/FeatureLib/pfPython/pyNotify.h @@ -100,6 +100,8 @@ public: virtual void AddPickEvent(hsBool enabled, pyKey* other, pyKey* self, pyPoint3 hitPoint); virtual void AddControlKeyEvent( int32_t key, hsBool down ); virtual void AddVarNumber(const char* name, float number); + virtual void AddVarNumber(const char* name, int number); + virtual void AddVarNull(const char* name); virtual void AddVarKey(const char* name, pyKey* key); virtual void AddFacingEvent( hsBool enabled, pyKey* other, pyKey* self, float dot); virtual void AddContainerEvent( hsBool entering, pyKey* container, pyKey* contained); diff --git a/Sources/Plasma/FeatureLib/pfPython/pyNotifyGlue.cpp b/Sources/Plasma/FeatureLib/pfPython/pyNotifyGlue.cpp index 5824712e..5e787bd9 100644 --- a/Sources/Plasma/FeatureLib/pfPython/pyNotifyGlue.cpp +++ b/Sources/Plasma/FeatureLib/pfPython/pyNotifyGlue.cpp @@ -194,18 +194,71 @@ PYTHON_METHOD_DEFINITION(ptNotify, addControlKeyEvent, args) } PYTHON_METHOD_DEFINITION(ptNotify, addVarNumber, args) +{ + char* name; + PyObject* number = NULL; + if (!PyArg_ParseTuple(args, "s|O", &name, &number)) + { + PyErr_SetString(PyExc_TypeError, "addVarNumber expects a string and optional number"); + PYTHON_RETURN_ERROR; + } + + if (number == NULL || number == Py_None) + self->fThis->AddVarNull(name); + else if (PyInt_Check(number)) + self->fThis->AddVarNumber(name, PyInt_AsLong(number)); + else if (PyNumber_Check(number)) + { + PyObject* f = PyNumber_Float(number); + self->fThis->AddVarNumber(name, (float)PyFloat_AsDouble(f)); + Py_DECREF(f); + } + else + { + PyErr_SetString(PyExc_TypeError, "addVarNumber expects a string and a number"); + PYTHON_RETURN_ERROR; + } + PYTHON_RETURN_NONE; +} + +PYTHON_METHOD_DEFINITION(ptNotify, addVarFloat, args) { char* name; float number; if (!PyArg_ParseTuple(args, "sf", &name, &number)) { - PyErr_SetString(PyExc_TypeError, "addVarNumber expects a string and a float"); + PyErr_SetString(PyExc_TypeError, "addVarFloat expects a string and a float"); PYTHON_RETURN_ERROR; } self->fThis->AddVarNumber(name, number); PYTHON_RETURN_NONE; } +PYTHON_METHOD_DEFINITION(ptNotify, addVarInt, args) +{ + char* name; + int number; + if (!PyArg_ParseTuple(args, "si", &name, &number)) + { + PyErr_SetString(PyExc_TypeError, "addVarInt expects a string and a integer"); + PYTHON_RETURN_ERROR; + } + self->fThis->AddVarNumber(name, number); + PYTHON_RETURN_NONE; +} + +PYTHON_METHOD_DEFINITION(ptNotify, addVarNull, args) +{ + char* name; + if (!PyArg_ParseTuple(args, "s", &name)) + { + PyErr_SetString(PyExc_TypeError, "addVarNull expects a string"); + PYTHON_RETURN_ERROR; + } + self->fThis->AddVarNull(name); + PYTHON_RETURN_NONE; +} + PYTHON_METHOD_DEFINITION(ptNotify, addVarKey, args) { char* name; @@ -337,6 +390,13 @@ PYTHON_START_METHODS_TABLE(ptNotify) 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" + "Method will try to pick appropriate variable type\n" + "This event record is used to pass a number variable to another python program"), + PYTHON_METHOD(ptNotify, addVarFloat, "Params: name,number\nAdd a float 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, addVarInt, "Params: name,number\nAdd a int 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, addVarNull, "Params: name,number\nAdd a null (no data) 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"), @@ -402,7 +462,9 @@ void pyNotify::AddPlasmaConstantsClasses(PyObject *m) PYTHON_ENUM_END(m, PtEventType); PYTHON_ENUM_START(PtNotifyDataType); - PYTHON_ENUM_ELEMENT(PtNotifyDataType, kNumber, proEventData::kNumber); + PYTHON_ENUM_ELEMENT(PtNotifyDataType, kFloat, proEventData::kFloat); + PYTHON_ENUM_ELEMENT(PtNotifyDataType, kInt, proEventData::kInt); + PYTHON_ENUM_ELEMENT(PtNotifyDataType, kNull, proEventData::kNull); PYTHON_ENUM_ELEMENT(PtNotifyDataType, kKey, proEventData::kKey); PYTHON_ENUM_END(m, PtNotifyDataType); diff --git a/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.cpp b/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.cpp index 344da416..4636326e 100644 --- a/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.cpp +++ b/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.cpp @@ -174,8 +174,14 @@ void plNotifyMsg::AddEvent( proEventData* ed ) proVariableEventData *evt = (proVariableEventData *)ed; switch (evt->fDataType) { - case proEventData::kNumber: - AddVariableEvent(evt->fName, evt->fNumber); + case proEventData::kFloat: + AddVariableEvent(evt->fName, evt->fNumber.f); + break; + case proEventData::kInt: + AddVariableEvent(evt->fName, evt->fNumber.i); + break; + case proEventData::kNull: + AddVariableEvent(evt->fName); break; case proEventData::kKey: AddVariableEvent(evt->fName, evt->fKey); @@ -588,12 +594,44 @@ void plNotifyMsg::AddVariableEvent( const char* name, float number ) // create the control key event record proVariableEventData* pED = new proVariableEventData; pED->fName = hsStrcpy(nil,name); -// pED->fName = (char*)name; - pED->fDataType = proEventData::kNumber; - pED->fNumber = number; + pED->fDataType = proEventData::kFloat; + pED->fNumber.f = number; fEvents.Append(pED); // then add it to the list of event records } +///////////////////////////////////////////////////////////////////////////// +// +// Function : AddVariableEvent +// PARAMETERS : name - name of the variable +// : number - the value of the variable as a number +// +// PURPOSE : Add a variable event record to this notify message +// +void plNotifyMsg::AddVariableEvent( const char* name, int number ) +{ + // create the control key event record + proVariableEventData* pED = new proVariableEventData; + pED->fName = hsStrcpy(nil,name); + pED->fDataType = proEventData::kInt; + pED->fNumber.i = number; + fEvents.Append(pED); // then add it to the list of event records +} + +///////////////////////////////////////////////////////////////////////////// +// +// Function : AddVariableEvent +// PARAMETERS : name - name of the variable +// +// PURPOSE : Add a variable event record to this notify message +// +void plNotifyMsg::AddVariableEvent( const char* name) +{ + // create the control key event record + proVariableEventData* pED = new proVariableEventData; + pED->fName = hsStrcpy(nil,name); + pED->fDataType = proEventData::kNull; + fEvents.Append(pED); // then add it to the list of event records +} ///////////////////////////////////////////////////////////////////////////// // @@ -1283,11 +1321,41 @@ void proVariableEventData::IDestruct() fName = nil; } +void proVariableEventData::IReadNumber(hsStream * stream) { + switch (fDataType) + { + case kFloat: + fNumber.f = stream->ReadLEScalar(); + break; + case kInt: + fNumber.i = stream->ReadLE32(); + break; + default: + stream->ReadLE32(); //ignore + break; + } +} + +void proVariableEventData::IWriteNumber(hsStream * stream) { + switch (fDataType) + { + case kFloat: + stream->WriteLEScalar(fNumber.f); + break; + case kInt: + stream->WriteLE32(fNumber.i); + break; + default: + stream->WriteLE32(0); + break; + } +} + void proVariableEventData::IRead(hsStream* stream, hsResMgr* mgr) { fName = stream->ReadSafeString(); fDataType = stream->ReadLE32(); - fNumber = stream->ReadLEScalar(); + IReadNumber(stream); fKey = mgr->ReadKey(stream); } @@ -1295,7 +1363,7 @@ void proVariableEventData::IWrite(hsStream* stream, hsResMgr* mgr) { stream->WriteSafeString(fName); stream->WriteLE32(fDataType); - stream->WriteLEScalar(fNumber); + IWriteNumber(stream); mgr->WriteKey(stream, fKey); } @@ -1317,7 +1385,7 @@ void proVariableEventData::IReadVersion(hsStream* s, hsResMgr* mgr) if (contentFlags.IsBitSet(kProVariableDataType)) fDataType = s->ReadLE32(); if (contentFlags.IsBitSet(kProVariableNumber)) - fNumber = s->ReadLEScalar(); + IReadNumber(s); if (contentFlags.IsBitSet(kProVariableKey)) fKey = mgr->ReadKey(s); } @@ -1336,7 +1404,7 @@ void proVariableEventData::IWriteVersion(hsStream* s, hsResMgr* mgr) // kProVariableDataType s->WriteLE32(fDataType); // kProVariableNumber - s->WriteLEScalar(fNumber); + IWriteNumber(s); // kProVariableKey mgr->WriteKey(s, fKey); } diff --git a/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.h b/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.h index b629e472..29072beb 100644 --- a/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.h +++ b/Sources/Plasma/NucleusLib/pnMessage/plNotifyMsg.h @@ -87,8 +87,10 @@ public: enum dataType { - kNumber=1, + kFloat=1, kKey, + kInt, + kNull, kNotta }; @@ -181,9 +183,12 @@ proEventType(Variable) int32_t fDataType; // type of data // Can't be a union, sadly, but it isn't that much of a waste of space... - float fNumber; // if its a number plKey fKey; // if its a plKey (pointer to something) + union { + float f; + int32_t i; + } fNumber; protected: virtual void IInit(); @@ -193,6 +198,9 @@ protected: virtual void IReadVersion(hsStream* s, hsResMgr* mgr); virtual void IWriteVersion(hsStream* s, hsResMgr* mgr); + + virtual void IReadNumber(hsStream * stream); + virtual void IWriteNumber(hsStream * stream); }; proEventType(Facing) @@ -368,7 +376,9 @@ public: void AddPickEvent( const plKey &other, const plKey& self, hsBool enabled, hsPoint3 hitPoint ); void AddControlKeyEvent( int32_t key, hsBool down ); void AddVariableEvent( const char* name, float number ); - void AddVariableEvent( const char *name, const plKey &key); + void AddVariableEvent( const char* name, int number ); + void AddVariableEvent( const char* name ); + void AddVariableEvent( const char *name, const plKey &key ); void AddFacingEvent( const plKey &other, const plKey &self, float dot, hsBool enabled); void AddContainerEvent( const plKey &container, const plKey &contained, hsBool entering); void AddActivateEvent( hsBool activate );