BGE patch: Add PyDoc for new logic bricks, set exception message on Py error, remove...
authorBenoit Bolsee <benoit.bolsee@online.be>
Wed, 23 Jul 2008 21:37:37 +0000 (21:37 +0000)
committerBenoit Bolsee <benoit.bolsee@online.be>
Wed, 23 Jul 2008 21:37:37 +0000 (21:37 +0000)
24 files changed:
source/blender/makesdna/DNA_actuator_types.h
source/blender/src/buttons_logic.c
source/gameengine/Converter/BL_ShapeActionActuator.cpp
source/gameengine/Converter/BL_ShapeActionActuator.h
source/gameengine/Converter/KX_ConvertActuators.cpp
source/gameengine/GameLogic/SCA_ActuatorSensor.cpp
source/gameengine/GameLogic/SCA_ActuatorSensor.h
source/gameengine/GameLogic/SCA_ISensor.cpp
source/gameengine/GameLogic/SCA_ISensor.h
source/gameengine/Ketsji/KX_ConstraintActuator.cpp
source/gameengine/Ketsji/KX_ConstraintActuator.h
source/gameengine/Ketsji/KX_GameObject.cpp
source/gameengine/Ketsji/KX_IpoActuator.cpp
source/gameengine/Ketsji/KX_IpoActuator.h
source/gameengine/Ketsji/KX_ObjectActuator.cpp
source/gameengine/Ketsji/KX_ObjectActuator.h
source/gameengine/Ketsji/KX_PythonInit.cpp
source/gameengine/PyDoc/BL_ShapeActionActuator.py [new file with mode: 0644]
source/gameengine/PyDoc/KX_ActuatorSensor.py [new file with mode: 0644]
source/gameengine/PyDoc/KX_ConstraintActuator.py
source/gameengine/PyDoc/KX_IpoActuator.py
source/gameengine/PyDoc/KX_ObjectActuator.py
source/gameengine/PyDoc/KX_StateActuator.py [new file with mode: 0644]
source/gameengine/PyDoc/SCA_ISensor.py

index ac9761f..7444ce9 100644 (file)
@@ -368,9 +368,9 @@ typedef struct FreeCamera {
 #define ACT_CONST_DIRPX                1
 #define ACT_CONST_DIRPY                2
 #define ACT_CONST_DIRPZ                4
-#define ACT_CONST_DIRMX                8
-#define ACT_CONST_DIRMY                16
-#define ACT_CONST_DIRMZ                32
+#define ACT_CONST_DIRNX                8
+#define ACT_CONST_DIRNY                16
+#define ACT_CONST_DIRNZ                32
 
 /* constraint type */
 #define ACT_CONST_TYPE_LOC     0
index 6b29a05..498edc0 100644 (file)
@@ -2088,8 +2088,8 @@ static short draw_actuatorbuttons(Object *ob, bActuator *act, uiBlock *block, sh
                        uiDefBut(block, LABEL,                  0, "Range",     xco+80, yco-45, (width-115)/2, 19, NULL, 0.0, 0.0, 0, 0, "Set the maximum length of ray");
                        uiDefButBitS(block, TOG, ACT_CONST_DISTANCE, B_REDR, "Dist",    xco+80+(width-115)/2, yco-45, (width-115)/2, 19, &coa->flag, 0.0, 0.0, 0, 0, "Force distance of object to point of impact of ray");
 
-                       if(coa->mode & (ACT_CONST_DIRPX|ACT_CONST_DIRMX)) fp= coa->minloc;
-                       else if(coa->mode & (ACT_CONST_DIRPY|ACT_CONST_DIRMY)) fp= coa->minloc+1;
+                       if(coa->mode & (ACT_CONST_DIRPX|ACT_CONST_DIRNX)) fp= coa->minloc;
+                       else if(coa->mode & (ACT_CONST_DIRPY|ACT_CONST_DIRNY)) fp= coa->minloc+1;
                        else fp= coa->minloc+2;
 
                        uiDefButF(block, NUM, 0, "",            xco+80, yco-65, (width-115)/2, 19, fp+3, 0.0, 2000.0, 10, 0, "Maximum length of ray");
index 7196b39..242d648 100644 (file)
@@ -442,15 +442,15 @@ PyMethodDef BL_ShapeActionActuator::Methods[] = {
        {"setProperty", (PyCFunction) BL_ShapeActionActuator::sPySetProperty, METH_VARARGS, SetProperty_doc},
        {"setBlendtime", (PyCFunction) BL_ShapeActionActuator::sPySetBlendtime, METH_VARARGS, SetBlendtime_doc},
 
-       {"getAction", (PyCFunction) BL_ShapeActionActuator::sPyGetAction, METH_VARARGS, GetAction_doc},
-       {"getStart", (PyCFunction) BL_ShapeActionActuator::sPyGetStart, METH_VARARGS, GetStart_doc},
-       {"getEnd", (PyCFunction) BL_ShapeActionActuator::sPyGetEnd, METH_VARARGS, GetEnd_doc},
-       {"getBlendin", (PyCFunction) BL_ShapeActionActuator::sPyGetBlendin, METH_VARARGS, GetBlendin_doc},
-       {"getPriority", (PyCFunction) BL_ShapeActionActuator::sPyGetPriority, METH_VARARGS, GetPriority_doc},
-       {"getFrame", (PyCFunction) BL_ShapeActionActuator::sPyGetFrame, METH_VARARGS, GetFrame_doc},
-       {"getProperty", (PyCFunction) BL_ShapeActionActuator::sPyGetProperty, METH_VARARGS, GetProperty_doc},
-       {"getType", (PyCFunction) BL_ShapeActionActuator::sPyGetType, METH_VARARGS, GetType_doc},       
-       {"setType", (PyCFunction) BL_ShapeActionActuator::sPySetType, METH_VARARGS, SetType_doc},
+       {"getAction", (PyCFunction) BL_ShapeActionActuator::sPyGetAction, METH_NOARGS, GetAction_doc},
+       {"getStart", (PyCFunction) BL_ShapeActionActuator::sPyGetStart, METH_NOARGS, GetStart_doc},
+       {"getEnd", (PyCFunction) BL_ShapeActionActuator::sPyGetEnd, METH_NOARGS, GetEnd_doc},
+       {"getBlendin", (PyCFunction) BL_ShapeActionActuator::sPyGetBlendin, METH_NOARGS, GetBlendin_doc},
+       {"getPriority", (PyCFunction) BL_ShapeActionActuator::sPyGetPriority, METH_NOARGS, GetPriority_doc},
+       {"getFrame", (PyCFunction) BL_ShapeActionActuator::sPyGetFrame, METH_NOARGS, GetFrame_doc},
+       {"getProperty", (PyCFunction) BL_ShapeActionActuator::sPyGetProperty, METH_NOARGS, GetProperty_doc},
+       {"getType", (PyCFunction) BL_ShapeActionActuator::sPyGetType, METH_NOARGS, GetType_doc},        
+       {"setType", (PyCFunction) BL_ShapeActionActuator::sPySetType, METH_NOARGS, SetType_doc},
        {NULL,NULL} //Sentinel
 };
 
@@ -463,9 +463,7 @@ char BL_ShapeActionActuator::GetAction_doc[] =
 "getAction()\n"
 "\tReturns a string containing the name of the current action.\n";
 
-PyObject* BL_ShapeActionActuator::PyGetAction(PyObject* self, 
-                                                                                         PyObject* args, 
-                                                                                         PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetAction(PyObject* self) {
        PyObject *result;
        
        if (m_action){
@@ -484,9 +482,7 @@ char BL_ShapeActionActuator::GetProperty_doc[] =
 "getProperty()\n"
 "\tReturns the name of the property to be used in FromProp mode.\n";
 
-PyObject* BL_ShapeActionActuator::PyGetProperty(PyObject* self, 
-                                                                                               PyObject* args, 
-                                                                                               PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetProperty(PyObject* self) {
        PyObject *result;
        
        result = Py_BuildValue("s", (const char *)m_propname);
@@ -499,9 +495,7 @@ char BL_ShapeActionActuator::GetFrame_doc[] =
 "getFrame()\n"
 "\tReturns the current frame number.\n";
 
-PyObject* BL_ShapeActionActuator::PyGetFrame(PyObject* self, 
-                                                                                        PyObject* args, 
-                                                                                        PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetFrame(PyObject* self) {
        PyObject *result;
        
        result = Py_BuildValue("f", m_localtime);
@@ -514,9 +508,7 @@ char BL_ShapeActionActuator::GetEnd_doc[] =
 "getEnd()\n"
 "\tReturns the last frame of the action.\n";
 
-PyObject* BL_ShapeActionActuator::PyGetEnd(PyObject* self, 
-                                                                                  PyObject* args, 
-                                                                                  PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetEnd(PyObject* self) {
        PyObject *result;
        
        result = Py_BuildValue("f", m_endframe);
@@ -529,9 +521,7 @@ char BL_ShapeActionActuator::GetStart_doc[] =
 "getStart()\n"
 "\tReturns the starting frame of the action.\n";
 
-PyObject* BL_ShapeActionActuator::PyGetStart(PyObject* self, 
-                                                                                        PyObject* args, 
-                                                                                        PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetStart(PyObject* self) {
        PyObject *result;
        
        result = Py_BuildValue("f", m_startframe);
@@ -545,9 +535,7 @@ char BL_ShapeActionActuator::GetBlendin_doc[] =
 "\tReturns the number of interpolation animation frames to be\n"
 "\tgenerated when this actuator is triggered.\n";
 
-PyObject* BL_ShapeActionActuator::PyGetBlendin(PyObject* self, 
-                                                                                          PyObject* args, 
-                                                                                          PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetBlendin(PyObject* self) {
        PyObject *result;
        
        result = Py_BuildValue("f", m_blendin);
@@ -561,9 +549,7 @@ char BL_ShapeActionActuator::GetPriority_doc[] =
 "\tReturns the priority for this actuator.  Actuators with lower\n"
 "\tPriority numbers will override actuators with higher numbers.\n";
 
-PyObject* BL_ShapeActionActuator::PyGetPriority(PyObject* self, 
-                                                                                           PyObject* args, 
-                                                                                               PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetPriority(PyObject* self) {
        PyObject *result;
        
        result = Py_BuildValue("i", m_priority);
@@ -605,6 +591,7 @@ PyObject* BL_ShapeActionActuator::PySetAction(PyObject* self,
                }
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -627,6 +614,7 @@ PyObject* BL_ShapeActionActuator::PySetStart(PyObject* self,
                m_startframe = start;
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -649,6 +637,7 @@ PyObject* BL_ShapeActionActuator::PySetEnd(PyObject* self,
                m_endframe = end;
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -672,6 +661,7 @@ PyObject* BL_ShapeActionActuator::PySetBlendin(PyObject* self,
                m_blendin = blendin;
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -700,6 +690,7 @@ PyObject* BL_ShapeActionActuator::PySetBlendtime(PyObject* self,
                        m_blendframe = m_blendin;
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -724,6 +715,7 @@ PyObject* BL_ShapeActionActuator::PySetPriority(PyObject* self,
                m_priority = priority;
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -750,6 +742,7 @@ PyObject* BL_ShapeActionActuator::PySetFrame(PyObject* self,
                        m_localtime=m_endframe;
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -773,6 +766,7 @@ PyObject* BL_ShapeActionActuator::PySetProperty(PyObject* self,
                m_propname = string;
        }
        else {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -784,9 +778,7 @@ PyObject* BL_ShapeActionActuator::PySetProperty(PyObject* self,
 char BL_ShapeActionActuator::GetType_doc[] =
 "getType()\n"
 "\tReturns the operation mode of the actuator.\n";
-PyObject* BL_ShapeActionActuator::PyGetType(PyObject* self,
-                                                                                       PyObject* args, 
-                                                                                       PyObject* kwds) {
+PyObject* BL_ShapeActionActuator::PyGetType(PyObject* self) {
     return Py_BuildValue("h", m_playtype);
 }
 
@@ -801,6 +793,7 @@ PyObject* BL_ShapeActionActuator::PySetType(PyObject* self,
        short typeArg;
                                                                                                              
     if (!PyArg_ParseTuple(args, "h", &typeArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
         return NULL;
     }
 
index 434a62a..a9b9ad8 100644 (file)
@@ -87,15 +87,15 @@ public:
        KX_PYMETHOD_DOC(BL_ShapeActionActuator,SetBlendtime);
        KX_PYMETHOD_DOC(BL_ShapeActionActuator,SetChannel);
 
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetAction);
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetBlendin);
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetPriority);
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetStart);
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetEnd);
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetFrame);
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetProperty);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetAction);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetBlendin);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetPriority);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetStart);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetEnd);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetFrame);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetProperty);
 //     KX_PYMETHOD(BL_ActionActuator,GetChannel);
-       KX_PYMETHOD_DOC(BL_ShapeActionActuator,GetType);
+       KX_PYMETHOD_DOC_NOARGS(BL_ShapeActionActuator,GetType);
        KX_PYMETHOD_DOC(BL_ShapeActionActuator,SetType);
 
        virtual PyObject* _getattr(const STR_String& attr);
index f2ec01d..53ac730 100644 (file)
@@ -658,18 +658,18 @@ void BL_ConvertActuators(char* maggiename,
                                                min = conact->minloc[2];
                                                max = conact->maxloc[2];
                                                break;
-                                       case ACT_CONST_DIRMX:
-                                               locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRMX;
+                                       case ACT_CONST_DIRNX:
+                                               locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNX;
                                                min = conact->minloc[0];
                                                max = conact->maxloc[0];
                                                break;
-                                       case ACT_CONST_DIRMY:
-                                               locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRMY;
+                                       case ACT_CONST_DIRNY:
+                                               locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNY;
                                                min = conact->minloc[1];
                                                max = conact->maxloc[1];
                                                break;
-                                       case ACT_CONST_DIRMZ:
-                                               locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRMZ;
+                                       case ACT_CONST_DIRNZ:
+                                               locrot = KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNZ;
                                                min = conact->minloc[2];
                                                max = conact->maxloc[2];
                                                break;
index e1c8ef8..099cb8e 100644 (file)
@@ -149,7 +149,7 @@ PyParentObject SCA_ActuatorSensor::Parents[] = {
 };
 
 PyMethodDef SCA_ActuatorSensor::Methods[] = {
-       {"getActuator", (PyCFunction) SCA_ActuatorSensor::sPyGetActuator, METH_VARARGS, GetActuator_doc},
+       {"getActuator", (PyCFunction) SCA_ActuatorSensor::sPyGetActuator, METH_NOARGS, GetActuator_doc},
        {"setActuator", (PyCFunction) SCA_ActuatorSensor::sPySetActuator, METH_VARARGS, SetActuator_doc},
        {NULL,NULL} //Sentinel
 };
@@ -162,7 +162,7 @@ PyObject* SCA_ActuatorSensor::_getattr(const STR_String& attr) {
 char SCA_ActuatorSensor::GetActuator_doc[] = 
 "getActuator()\n"
 "\tReturn the Actuator with which the sensor operates.\n";
-PyObject* SCA_ActuatorSensor::PyGetActuator(PyObject* self, PyObject* args, PyObject* kwds
+PyObject* SCA_ActuatorSensor::PyGetActuator(PyObject* self) 
 {
        return PyString_FromString(m_checkactname);
 }
@@ -180,6 +180,7 @@ PyObject* SCA_ActuatorSensor::PySetActuator(PyObject* self, PyObject* args, PyOb
        char *actNameArg = NULL;
 
        if (!PyArg_ParseTuple(args, "s", &actNameArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
 
index 6086c5b..a71145f 100644 (file)
@@ -66,7 +66,7 @@ public:
        /* 3. setProperty */
        KX_PYMETHOD_DOC(SCA_ActuatorSensor,SetActuator);
        /* 4. getProperty */
-       KX_PYMETHOD_DOC(SCA_ActuatorSensor,GetActuator);
+       KX_PYMETHOD_DOC_NOARGS(SCA_ActuatorSensor,GetActuator);
        
 };
 
index 68341b5..f11c804 100644 (file)
@@ -168,23 +168,23 @@ PyMethodDef SCA_ISensor::Methods[] = {
        {"isPositive", (PyCFunction) SCA_ISensor::sPyIsPositive, 
         METH_VARARGS, IsPositive_doc},
        {"getUsePosPulseMode", (PyCFunction) SCA_ISensor::sPyGetUsePosPulseMode, 
-        METH_VARARGS, GetUsePosPulseMode_doc},
+        METH_NOARGS, GetUsePosPulseMode_doc},
        {"setUsePosPulseMode", (PyCFunction) SCA_ISensor::sPySetUsePosPulseMode, 
         METH_VARARGS, SetUsePosPulseMode_doc},
        {"getFrequency", (PyCFunction) SCA_ISensor::sPyGetFrequency, 
-        METH_VARARGS, GetFrequency_doc},
+        METH_NOARGS, GetFrequency_doc},
        {"setFrequency", (PyCFunction) SCA_ISensor::sPySetFrequency, 
         METH_VARARGS, SetFrequency_doc},
        {"getUseNegPulseMode", (PyCFunction) SCA_ISensor::sPyGetUseNegPulseMode, 
-        METH_VARARGS, GetUseNegPulseMode_doc},
+        METH_NOARGS, GetUseNegPulseMode_doc},
        {"setUseNegPulseMode", (PyCFunction) SCA_ISensor::sPySetUseNegPulseMode, 
         METH_VARARGS, SetUseNegPulseMode_doc},
        {"getInvert", (PyCFunction) SCA_ISensor::sPyGetInvert, 
-        METH_VARARGS, GetInvert_doc},
+        METH_NOARGS, GetInvert_doc},
        {"setInvert", (PyCFunction) SCA_ISensor::sPySetInvert, 
         METH_VARARGS, SetInvert_doc},
        {"getLevel", (PyCFunction) SCA_ISensor::sPyGetLevel, 
-        METH_VARARGS, GetLevel_doc},
+        METH_NOARGS, GetLevel_doc},
        {"setLevel", (PyCFunction) SCA_ISensor::sPySetLevel, 
         METH_VARARGS, SetLevel_doc},
        {NULL,NULL} //Sentinel
@@ -259,7 +259,7 @@ PyObject* SCA_ISensor::PyIsPositive(PyObject* self, PyObject* args, PyObject* kw
 char SCA_ISensor::GetUsePosPulseMode_doc[] = 
 "getUsePosPulseMode()\n"
 "\tReturns whether positive pulse mode is active.\n";
-PyObject* SCA_ISensor::PyGetUsePosPulseMode(PyObject* self, PyObject* args, PyObject* kwds)
+PyObject* SCA_ISensor::PyGetUsePosPulseMode(PyObject* self)
 {
        return BoolToPyArg(m_pos_pulsemode);
 }
@@ -286,7 +286,7 @@ PyObject* SCA_ISensor::PySetUsePosPulseMode(PyObject* self, PyObject* args, PyOb
 char SCA_ISensor::GetFrequency_doc[] = 
 "getFrequency()\n"
 "\tReturns the frequency of the updates in pulse mode.\n" ;
-PyObject* SCA_ISensor::PyGetFrequency(PyObject* self, PyObject* args, PyObject* kwds)
+PyObject* SCA_ISensor::PyGetFrequency(PyObject* self)
 {
        return PyInt_FromLong(m_pulse_frequency);
 }
@@ -321,7 +321,7 @@ PyObject* SCA_ISensor::PySetFrequency(PyObject* self, PyObject* args, PyObject*
 char SCA_ISensor::GetInvert_doc[] = 
 "getInvert()\n"
 "\tReturns whether or not pulses from this sensor are inverted.\n" ;
-PyObject* SCA_ISensor::PyGetInvert(PyObject* self, PyObject* args, PyObject* kwds)
+PyObject* SCA_ISensor::PyGetInvert(PyObject* self)
 {
        return BoolToPyArg(m_invert);
 }
@@ -342,11 +342,10 @@ char SCA_ISensor::GetLevel_doc[] =
 "getLevel()\n"
 "\tReturns whether this sensor is a level detector or a edge detector.\n"
 "\tIt makes a difference only in case of logic state transition (state actuator).\n"
-"\tA level detector will immediately generate a pulse if the condition for the\n"
-"\tdetector is met when entering the state. A edge detector will wait for an off-on\n"
-"\ttransition to occur.\n"
-"\tOnly some sensors implement this feature: keyboard.\n";
-PyObject* SCA_ISensor::PyGetLevel(PyObject* self, PyObject* args, PyObject* kwds)
+"\tA level detector will immediately generate a pulse, negative or positive\n"
+"\tdepending on the sensor condition, as soon as the state is activated.\n"
+"\tA edge detector will wait for a state change before generating a pulse.\n";
+PyObject* SCA_ISensor::PyGetLevel(PyObject* self)
 {
        return BoolToPyArg(m_level);
 }
@@ -366,7 +365,7 @@ PyObject* SCA_ISensor::PySetLevel(PyObject* self, PyObject* args, PyObject* kwds
 char SCA_ISensor::GetUseNegPulseMode_doc[] = 
 "getUseNegPulseMode()\n"
 "\tReturns whether negative pulse mode is active.\n";
-PyObject* SCA_ISensor::PyGetUseNegPulseMode(PyObject* self, PyObject* args, PyObject* kwds)
+PyObject* SCA_ISensor::PyGetUseNegPulseMode(PyObject* self)
 {
        return BoolToPyArg(m_neg_pulsemode);
 }
index 4ce49e7..5183775 100644 (file)
@@ -136,15 +136,15 @@ public:
 
        /* Python functions: */
        KX_PYMETHOD_DOC(SCA_ISensor,IsPositive);
-       KX_PYMETHOD_DOC(SCA_ISensor,GetUsePosPulseMode);
+       KX_PYMETHOD_DOC_NOARGS(SCA_ISensor,GetUsePosPulseMode);
        KX_PYMETHOD_DOC(SCA_ISensor,SetUsePosPulseMode);
-       KX_PYMETHOD_DOC(SCA_ISensor,GetFrequency);
+       KX_PYMETHOD_DOC_NOARGS(SCA_ISensor,GetFrequency);
        KX_PYMETHOD_DOC(SCA_ISensor,SetFrequency);
-       KX_PYMETHOD_DOC(SCA_ISensor,GetUseNegPulseMode);
+       KX_PYMETHOD_DOC_NOARGS(SCA_ISensor,GetUseNegPulseMode);
        KX_PYMETHOD_DOC(SCA_ISensor,SetUseNegPulseMode);
-       KX_PYMETHOD_DOC(SCA_ISensor,GetInvert);
+       KX_PYMETHOD_DOC_NOARGS(SCA_ISensor,GetInvert);
        KX_PYMETHOD_DOC(SCA_ISensor,SetInvert);
-       KX_PYMETHOD_DOC(SCA_ISensor,GetLevel);
+       KX_PYMETHOD_DOC_NOARGS(SCA_ISensor,GetLevel);
        KX_PYMETHOD_DOC(SCA_ISensor,SetLevel);
 
 };
index 800416b..2401d69 100644 (file)
@@ -237,9 +237,9 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
                case KX_ACT_CONSTRAINT_DIRPX:
                case KX_ACT_CONSTRAINT_DIRPY:
                case KX_ACT_CONSTRAINT_DIRPZ:
-               case KX_ACT_CONSTRAINT_DIRMX:
-               case KX_ACT_CONSTRAINT_DIRMY:
-               case KX_ACT_CONSTRAINT_DIRMZ:
+               case KX_ACT_CONSTRAINT_DIRNX:
+               case KX_ACT_CONSTRAINT_DIRNY:
+               case KX_ACT_CONSTRAINT_DIRNZ:
                        switch (m_locrot) {
                        case KX_ACT_CONSTRAINT_DIRPX:
                                direction[0] = rotation[0][0];
@@ -262,21 +262,21 @@ bool KX_ConstraintActuator::Update(double curtime, bool frame)
                                axis = 2;
                                sign = 1;
                                break;
-                       case KX_ACT_CONSTRAINT_DIRMX:
+                       case KX_ACT_CONSTRAINT_DIRNX:
                                direction[0] = -rotation[0][0];
                                direction[1] = -rotation[1][0];
                                direction[2] = -rotation[2][0];
                                axis = 0;
                                sign = 0;
                                break;
-                       case KX_ACT_CONSTRAINT_DIRMY:
+                       case KX_ACT_CONSTRAINT_DIRNY:
                                direction[0] = -rotation[0][1];
                                direction[1] = -rotation[1][1];
                                direction[2] = -rotation[2][1];
                                axis = 1;
                                sign = 0;
                                break;
-                       case KX_ACT_CONSTRAINT_DIRMZ:
+                       case KX_ACT_CONSTRAINT_DIRNZ:
                                direction[0] = -rotation[0][2];
                                direction[1] = -rotation[1][2];
                                direction[2] = -rotation[2][2];
@@ -437,27 +437,27 @@ PyParentObject KX_ConstraintActuator::Parents[] = {
 
 PyMethodDef KX_ConstraintActuator::Methods[] = {
        {"setDamp", (PyCFunction) KX_ConstraintActuator::sPySetDamp, METH_VARARGS, SetDamp_doc},
-       {"getDamp", (PyCFunction) KX_ConstraintActuator::sPyGetDamp, METH_VARARGS, GetDamp_doc},
+       {"getDamp", (PyCFunction) KX_ConstraintActuator::sPyGetDamp, METH_NOARGS, GetDamp_doc},
        {"setRotDamp", (PyCFunction) KX_ConstraintActuator::sPySetRotDamp, METH_VARARGS, SetRotDamp_doc},
-       {"getRotDamp", (PyCFunction) KX_ConstraintActuator::sPyGetRotDamp, METH_VARARGS, GetRotDamp_doc},
+       {"getRotDamp", (PyCFunction) KX_ConstraintActuator::sPyGetRotDamp, METH_NOARGS, GetRotDamp_doc},
        {"setDirection", (PyCFunction) KX_ConstraintActuator::sPySetDirection, METH_VARARGS, SetDirection_doc},
-       {"getDirection", (PyCFunction) KX_ConstraintActuator::sPyGetDirection, METH_VARARGS, GetDirection_doc},
+       {"getDirection", (PyCFunction) KX_ConstraintActuator::sPyGetDirection, METH_NOARGS, GetDirection_doc},
        {"setOption", (PyCFunction) KX_ConstraintActuator::sPySetOption, METH_VARARGS, SetOption_doc},
-       {"getOption", (PyCFunction) KX_ConstraintActuator::sPyGetOption, METH_VARARGS, GetOption_doc},
+       {"getOption", (PyCFunction) KX_ConstraintActuator::sPyGetOption, METH_NOARGS, GetOption_doc},
        {"setTime", (PyCFunction) KX_ConstraintActuator::sPySetTime, METH_VARARGS, SetTime_doc},
-       {"getTime", (PyCFunction) KX_ConstraintActuator::sPyGetTime, METH_VARARGS, GetTime_doc},
+       {"getTime", (PyCFunction) KX_ConstraintActuator::sPyGetTime, METH_NOARGS, GetTime_doc},
        {"setProperty", (PyCFunction) KX_ConstraintActuator::sPySetProperty, METH_VARARGS, SetProperty_doc},
-       {"getProperty", (PyCFunction) KX_ConstraintActuator::sPyGetProperty, METH_VARARGS, GetProperty_doc},
+       {"getProperty", (PyCFunction) KX_ConstraintActuator::sPyGetProperty, METH_NOARGS, GetProperty_doc},
        {"setMin", (PyCFunction) KX_ConstraintActuator::sPySetMin, METH_VARARGS, SetMin_doc},
-       {"getMin", (PyCFunction) KX_ConstraintActuator::sPyGetMin, METH_VARARGS, GetMin_doc},
+       {"getMin", (PyCFunction) KX_ConstraintActuator::sPyGetMin, METH_NOARGS, GetMin_doc},
        {"setDistance", (PyCFunction) KX_ConstraintActuator::sPySetMin, METH_VARARGS, SetDistance_doc},
-       {"getDistance", (PyCFunction) KX_ConstraintActuator::sPyGetMin, METH_VARARGS, GetDistance_doc},
+       {"getDistance", (PyCFunction) KX_ConstraintActuator::sPyGetMin, METH_NOARGS, GetDistance_doc},
        {"setMax", (PyCFunction) KX_ConstraintActuator::sPySetMax, METH_VARARGS, SetMax_doc},
-       {"getMax", (PyCFunction) KX_ConstraintActuator::sPyGetMax, METH_VARARGS, GetMax_doc},
+       {"getMax", (PyCFunction) KX_ConstraintActuator::sPyGetMax, METH_NOARGS, GetMax_doc},
        {"setRayLength", (PyCFunction) KX_ConstraintActuator::sPySetMax, METH_VARARGS, SetRayLength_doc},
-       {"getRayLength", (PyCFunction) KX_ConstraintActuator::sPyGetMax, METH_VARARGS, GetRayLength_doc},
+       {"getRayLength", (PyCFunction) KX_ConstraintActuator::sPyGetMax, METH_NOARGS, GetRayLength_doc},
        {"setLimit", (PyCFunction) KX_ConstraintActuator::sPySetLimit, METH_VARARGS, SetLimit_doc},
-       {"getLimit", (PyCFunction) KX_ConstraintActuator::sPyGetLimit, METH_VARARGS, GetLimit_doc},
+       {"getLimit", (PyCFunction) KX_ConstraintActuator::sPyGetLimit, METH_NOARGS, GetLimit_doc},
        {NULL,NULL} //Sentinel
 };
 
@@ -476,6 +476,7 @@ PyObject* KX_ConstraintActuator::PySetDamp(PyObject* self,
                                                                                   PyObject* kwds) {
        int dampArg;
        if(!PyArg_ParseTuple(args, "i", &dampArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        
@@ -488,9 +489,7 @@ PyObject* KX_ConstraintActuator::PySetDamp(PyObject* self,
 char KX_ConstraintActuator::GetDamp_doc[] = 
 "getDamp()\n"
 "\tReturns the damping parameter.\n";
-PyObject* KX_ConstraintActuator::PyGetDamp(PyObject* self, 
-                                                                                  PyObject* args, 
-                                                                                  PyObject* kwds){
+PyObject* KX_ConstraintActuator::PyGetDamp(PyObject* self){
        return PyInt_FromLong(m_posDampTime);
 }
 
@@ -505,6 +504,7 @@ PyObject* KX_ConstraintActuator::PySetRotDamp(PyObject* self,
                                                                                      PyObject* kwds) {
        int dampArg;
        if(!PyArg_ParseTuple(args, "i", &dampArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        
@@ -517,9 +517,7 @@ PyObject* KX_ConstraintActuator::PySetRotDamp(PyObject* self,
 char KX_ConstraintActuator::GetRotDamp_doc[] = 
 "getRotDamp()\n"
 "\tReturns the damping time for application of the constraint.\n";
-PyObject* KX_ConstraintActuator::PyGetRotDamp(PyObject* self, 
-                                                                                     PyObject* args, 
-                                                                                     PyObject* kwds){
+PyObject* KX_ConstraintActuator::PyGetRotDamp(PyObject* self){
        return PyInt_FromLong(m_rotDampTime);
 }
 
@@ -536,6 +534,7 @@ PyObject* KX_ConstraintActuator::PySetDirection(PyObject* self,
        MT_Vector3 dir;
 
        if(!PyArg_ParseTuple(args, "(fff)", &x, &y, &z)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        dir[0] = x;
@@ -554,9 +553,7 @@ PyObject* KX_ConstraintActuator::PySetDirection(PyObject* self,
 char KX_ConstraintActuator::GetDirection_doc[] = 
 "getDirection()\n"
 "\tReturns the reference direction of the orientation constraint as a 3-tuple.\n";
-PyObject* KX_ConstraintActuator::PyGetDirection(PyObject* self, 
-                                                                                       PyObject* args, 
-                                                                                       PyObject* kwds){
+PyObject* KX_ConstraintActuator::PyGetDirection(PyObject* self){
        PyObject *retVal = PyList_New(3);
 
        PyList_SetItem(retVal, 0, PyFloat_FromDouble(m_refDirection[0]));
@@ -580,6 +577,7 @@ PyObject* KX_ConstraintActuator::PySetOption(PyObject* self,
                                                                                     PyObject* kwds) {
        int option;
        if(!PyArg_ParseTuple(args, "i", &option)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        
@@ -591,9 +589,7 @@ PyObject* KX_ConstraintActuator::PySetOption(PyObject* self,
 char KX_ConstraintActuator::GetOption_doc[] = 
 "getOption()\n"
 "\tReturns the option parameter.\n";
-PyObject* KX_ConstraintActuator::PyGetOption(PyObject* self, 
-                                                                                    PyObject* args, 
-                                                                                    PyObject* kwds){
+PyObject* KX_ConstraintActuator::PyGetOption(PyObject* self){
        return PyInt_FromLong(m_option);
 }
 
@@ -609,6 +605,7 @@ PyObject* KX_ConstraintActuator::PySetTime(PyObject* self,
                                                                                   PyObject* kwds) {
        int t;
        if(!PyArg_ParseTuple(args, "i", &t)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        
@@ -622,9 +619,7 @@ PyObject* KX_ConstraintActuator::PySetTime(PyObject* self,
 char KX_ConstraintActuator::GetTime_doc[] = 
 "getTime()\n"
 "\tReturns the time parameter.\n";
-PyObject* KX_ConstraintActuator::PyGetTime(PyObject* self, 
-                                                                                  PyObject* args, 
-                                                                                  PyObject* kwds){
+PyObject* KX_ConstraintActuator::PyGetTime(PyObject* self){
        return PyInt_FromLong(m_activeTime);
 }
 
@@ -639,6 +634,7 @@ PyObject* KX_ConstraintActuator::PySetProperty(PyObject* self,
                                                                                       PyObject* kwds) {
        char *property;
        if (!PyArg_ParseTuple(args, "s", &property)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        if (property == NULL) {
@@ -654,9 +650,7 @@ PyObject* KX_ConstraintActuator::PySetProperty(PyObject* self,
 char KX_ConstraintActuator::GetProperty_doc[] = 
 "getProperty()\n"
 "\tReturns the property parameter.\n";
-PyObject* KX_ConstraintActuator::PyGetProperty(PyObject* self, 
-                                                                                      PyObject* args, 
-                                                                                      PyObject* kwds){
+PyObject* KX_ConstraintActuator::PyGetProperty(PyObject* self){
        return PyString_FromString(m_property);
 }
 
@@ -676,6 +670,7 @@ PyObject* KX_ConstraintActuator::PySetMin(PyObject* self,
                                                                                  PyObject* kwds) {
        float minArg;
        if(!PyArg_ParseTuple(args, "f", &minArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
 
@@ -701,9 +696,7 @@ char KX_ConstraintActuator::GetMin_doc[] =
 "getMin()\n"
 "\tReturns the lower value of the interval to which the value\n"
 "\tis clipped.\n";
-PyObject* KX_ConstraintActuator::PyGetMin(PyObject* self, 
-                                                                                 PyObject* args, 
-                                                                                 PyObject* kwds) {
+PyObject* KX_ConstraintActuator::PyGetMin(PyObject* self) {
        return PyFloat_FromDouble(m_minimumBound);
 }
 
@@ -723,6 +716,7 @@ PyObject* KX_ConstraintActuator::PySetMax(PyObject* self,
                                                                                  PyObject* kwds){
        float maxArg;
        if(!PyArg_ParseTuple(args, "f", &maxArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
 
@@ -748,9 +742,7 @@ char KX_ConstraintActuator::GetMax_doc[] =
 "getMax()\n"
 "\tReturns the upper value of the interval to which the value\n"
 "\tis clipped.\n";
-PyObject* KX_ConstraintActuator::PyGetMax(PyObject* self, 
-                                                                                 PyObject* args, 
-                                                                                 PyObject* kwds) {
+PyObject* KX_ConstraintActuator::PyGetMax(PyObject* self) {
        return PyFloat_FromDouble(m_maximumBound);
 }
 
@@ -778,6 +770,7 @@ PyObject* KX_ConstraintActuator::PySetLimit(PyObject* self,
                                                                                        PyObject* kwds) {
        int locrotArg;
        if(!PyArg_ParseTuple(args, "i", &locrotArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        
@@ -789,9 +782,7 @@ PyObject* KX_ConstraintActuator::PySetLimit(PyObject* self,
 char KX_ConstraintActuator::GetLimit_doc[] = 
 "getLimit()\n"
 "\tReturns the type of constraint.\n";
-PyObject* KX_ConstraintActuator::PyGetLimit(PyObject* self, 
-                                                                                       PyObject* args, 
-                                                                                       PyObject* kwds) {
+PyObject* KX_ConstraintActuator::PyGetLimit(PyObject* self) {
        return PyInt_FromLong(m_locrot);
 }
 
index 3ef5159..d9f3912 100644 (file)
@@ -84,9 +84,9 @@ protected:
                KX_ACT_CONSTRAINT_DIRPX,
                KX_ACT_CONSTRAINT_DIRPY,
                KX_ACT_CONSTRAINT_DIRPZ,
-               KX_ACT_CONSTRAINT_DIRMX,
-               KX_ACT_CONSTRAINT_DIRMY,
-               KX_ACT_CONSTRAINT_DIRMZ,
+               KX_ACT_CONSTRAINT_DIRNX,
+               KX_ACT_CONSTRAINT_DIRNY,
+               KX_ACT_CONSTRAINT_DIRNZ,
                KX_ACT_CONSTRAINT_ORIX,
                KX_ACT_CONSTRAINT_ORIY,
                KX_ACT_CONSTRAINT_ORIZ,
@@ -131,27 +131,27 @@ protected:
        virtual PyObject* _getattr(const STR_String& attr);
 
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetDamp);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetDamp);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetDamp);
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetRotDamp);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetRotDamp);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetRotDamp);
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetDirection);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetDirection);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetDirection);
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetOption);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetOption);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetOption);
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetTime);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetTime);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetTime);
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetProperty);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetProperty);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetProperty);
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetMin);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetMin);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetMin);
        static char SetDistance_doc[];
        static char GetDistance_doc[];
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetMax);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetMax);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetMax);
        static char SetRayLength_doc[];
        static char GetRayLength_doc[];
        KX_PYMETHOD_DOC(KX_ConstraintActuator,SetLimit);
-       KX_PYMETHOD_DOC(KX_ConstraintActuator,GetLimit);
+       KX_PYMETHOD_DOC_NOARGS(KX_ConstraintActuator,GetLimit);
 };
 
 #endif //__KX_CONSTRAINTACTUATOR
index cdcba8a..6c8b32b 100644 (file)
@@ -1568,8 +1568,10 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCastTo,
        float dist = 0.0f;
        char *propName = NULL;
 
-       if (!PyArg_ParseTuple(args,"O|fs", &pyarg, &dist, &propName))
+       if (!PyArg_ParseTuple(args,"O|fs", &pyarg, &dist, &propName)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
+       }
 
        if (!PyVecTo(pyarg, toPoint))
        {
@@ -1616,11 +1618,11 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCastTo,
 }
 
 KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
-"rayCast(to,from,dist,prop): cast a ray and return tuple (object,hit,normal) of contact point with object within dist that matches prop or None if no hit\n"
+                                  "rayCast(to,from,dist,prop): cast a ray and return tuple (object,hit,normal) of contact point with object within dist that matches prop or (None,None,None) tuple if no hit\n"
 " prop = property name that object must have; can be omitted => detect any object\n"
 " dist = max distance to look (can be negative => look behind); 0 or omitted => detect up to to\n"
 " from = 3-tuple or object reference for origin of ray (if object, use center of object)\n"
-"        Can None or omitted => start from self object center\n"
+"        Can be None or omitted => start from self object center\n"
 " to = 3-tuple or object reference for destination of ray (if object, use center of object)\n"
 "Note: the object on which you call this method matters: the ray will ignore it if it goes through it\n")
 {
@@ -1632,8 +1634,10 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
        char *propName = NULL;
        KX_GameObject *other;
 
-       if (!PyArg_ParseTuple(args,"O|Ofs", &pyto, &pyfrom, &dist, &propName))
+       if (!PyArg_ParseTuple(args,"O|Ofs", &pyto, &pyfrom, &dist, &propName)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
+       }
 
        if (!PyVecTo(pyto, toPoint))
        {
@@ -1691,16 +1695,14 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
     if (m_pHitObject)
        {
                PyObject* returnValue = PyTuple_New(3);
-               if (!returnValue)
+               if (!returnValue) {
+                       PyErr_SetString(PyExc_TypeError, "PyTuple_New() failed");
                        return NULL;
+               }
                PyTuple_SET_ITEM(returnValue, 0, m_pHitObject->AddRef());
                PyTuple_SET_ITEM(returnValue, 1, PyObjectFrom(resultPoint));
                PyTuple_SET_ITEM(returnValue, 2, PyObjectFrom(resultNormal));
                return returnValue;
-               //return Py_BuildValue("(O,(fff),(fff))", 
-               //      m_pHitObject->AddRef(),         // trick: KX_GameObject are not true Python object, they use a difference reference count system
-               //      resultPoint[0], resultPoint[1], resultPoint[2],
-               //      resultNormal[0], resultNormal[1], resultNormal[2]);
        }
        return Py_BuildValue("OOO", Py_None, Py_None, Py_None);
        //Py_RETURN_NONE;
index b7103f4..af3add8 100644 (file)
@@ -430,27 +430,27 @@ PyMethodDef KX_IpoActuator::Methods[] = {
        {"setStart", (PyCFunction) KX_IpoActuator::sPySetStart, 
                METH_VARARGS, SetStart_doc},
        {"getStart", (PyCFunction) KX_IpoActuator::sPyGetStart, 
-               METH_VARARGS, GetStart_doc},
+               METH_NOARGS, GetStart_doc},
        {"setEnd", (PyCFunction) KX_IpoActuator::sPySetEnd, 
                METH_VARARGS, SetEnd_doc},
        {"getEnd", (PyCFunction) KX_IpoActuator::sPyGetEnd, 
-               METH_VARARGS, GetEnd_doc},
+               METH_NOARGS, GetEnd_doc},
        {"setIpoAsForce", (PyCFunction) KX_IpoActuator::sPySetIpoAsForce, 
                METH_VARARGS, SetIpoAsForce_doc},
        {"getIpoAsForce", (PyCFunction) KX_IpoActuator::sPyGetIpoAsForce, 
-               METH_VARARGS, GetIpoAsForce_doc},
+               METH_NOARGS, GetIpoAsForce_doc},
        {"setIpoAdd", (PyCFunction) KX_IpoActuator::sPySetIpoAdd, 
                METH_VARARGS, SetIpoAdd_doc},
        {"getIpoAdd", (PyCFunction) KX_IpoActuator::sPyGetIpoAdd, 
-               METH_VARARGS, GetIpoAdd_doc},
+               METH_NOARGS, GetIpoAdd_doc},
        {"setType", (PyCFunction) KX_IpoActuator::sPySetType, 
                METH_VARARGS, SetType_doc},
        {"getType", (PyCFunction) KX_IpoActuator::sPyGetType, 
-               METH_VARARGS, GetType_doc},     
+               METH_NOARGS, GetType_doc},      
        {"setForceIpoActsLocal", (PyCFunction) KX_IpoActuator::sPySetForceIpoActsLocal,
                METH_VARARGS, SetForceIpoActsLocal_doc},
        {"getForceIpoActsLocal", (PyCFunction) KX_IpoActuator::sPyGetForceIpoActsLocal,
-               METH_VARARGS, GetForceIpoActsLocal_doc},
+               METH_NOARGS, GetForceIpoActsLocal_doc},
        {NULL,NULL} //Sentinel
 };
 
@@ -480,6 +480,7 @@ PyObject* KX_IpoActuator::PySet(PyObject* self,
        int startFrame, stopFrame;
        if(!PyArg_ParseTuple(args, "siii", &mode, &startFrame, 
                                                 &stopFrame, &forceToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        modenum = string2mode(mode);
@@ -515,6 +516,7 @@ PyObject* KX_IpoActuator::PySetProperty(PyObject* self,
        /* args: property */
        char *propertyName;
        if(!PyArg_ParseTuple(args, "s", &propertyName)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
 
@@ -533,6 +535,7 @@ PyObject* KX_IpoActuator::PySetStart(PyObject* self,
                                                                         PyObject* kwds) {
        float startArg;
        if(!PyArg_ParseTuple(args, "f", &startArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        
@@ -544,9 +547,7 @@ PyObject* KX_IpoActuator::PySetStart(PyObject* self,
 char KX_IpoActuator::GetStart_doc[] = 
 "getStart()\n"
 "\tReturns the frame from which the ipo starts playing.\n";
-PyObject* KX_IpoActuator::PyGetStart(PyObject* self, 
-                                                                        PyObject* args, 
-                                                                        PyObject* kwds) {
+PyObject* KX_IpoActuator::PyGetStart(PyObject* self) {
        return PyFloat_FromDouble(m_startframe);
 }
 
@@ -560,6 +561,7 @@ PyObject* KX_IpoActuator::PySetEnd(PyObject* self,
                                                                   PyObject* kwds) {
        float endArg;
        if(!PyArg_ParseTuple(args, "f", &endArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;            
        }
        
@@ -571,9 +573,7 @@ PyObject* KX_IpoActuator::PySetEnd(PyObject* self,
 char KX_IpoActuator::GetEnd_doc[] = 
 "getEnd()\n"
 "\tReturns the frame at which the ipo stops playing.\n";
-PyObject* KX_IpoActuator::PyGetEnd(PyObject* self, 
-                                                                  PyObject* args, 
-                                                                  PyObject* kwds) {
+PyObject* KX_IpoActuator::PyGetEnd(PyObject* self) {
        return PyFloat_FromDouble(m_endframe);
 }
 
@@ -588,6 +588,7 @@ PyObject* KX_IpoActuator::PySetIpoAsForce(PyObject* self,
        int boolArg;
        
        if (!PyArg_ParseTuple(args, "i", &boolArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
 
@@ -601,9 +602,7 @@ PyObject* KX_IpoActuator::PySetIpoAsForce(PyObject* self,
 char KX_IpoActuator::GetIpoAsForce_doc[] = 
 "getIpoAsForce()\n"
 "\tReturns whether to interpret the ipo as a force rather than a displacement.\n";
-PyObject* KX_IpoActuator::PyGetIpoAsForce(PyObject* self, 
-                                                                                 PyObject* args, 
-                                                                                 PyObject* kwds) {
+PyObject* KX_IpoActuator::PyGetIpoAsForce(PyObject* self) {
        return BoolToPyArg(m_ipo_as_force);
 }
 
@@ -618,6 +617,7 @@ PyObject* KX_IpoActuator::PySetIpoAdd(PyObject* self,
        int boolArg;
        
        if (!PyArg_ParseTuple(args, "i", &boolArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
 
@@ -631,9 +631,7 @@ PyObject* KX_IpoActuator::PySetIpoAdd(PyObject* self,
 char KX_IpoActuator::GetIpoAdd_doc[] = 
 "getIpoAsAdd()\n"
 "\tReturns whether to interpret the ipo as additive rather than absolute.\n";
-PyObject* KX_IpoActuator::PyGetIpoAdd(PyObject* self, 
-                                                                         PyObject* args, 
-                                                                         PyObject* kwds) {
+PyObject* KX_IpoActuator::PyGetIpoAdd(PyObject* self) {
        return BoolToPyArg(m_ipo_add);
 }
 
@@ -648,6 +646,7 @@ PyObject* KX_IpoActuator::PySetType(PyObject* self,
        int typeArg;
        
        if (!PyArg_ParseTuple(args, "i", &typeArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        
@@ -662,9 +661,7 @@ PyObject* KX_IpoActuator::PySetType(PyObject* self,
 char KX_IpoActuator::GetType_doc[] = 
 "getType()\n"
 "\tReturns the operation mode of the actuator.\n";
-PyObject* KX_IpoActuator::PyGetType(PyObject* self, 
-                                                                       PyObject* args, 
-                                                                       PyObject* kwds) {
+PyObject* KX_IpoActuator::PyGetType(PyObject* self) {
        return PyInt_FromLong(m_type);
 }
 
@@ -681,6 +678,7 @@ PyObject* KX_IpoActuator::PySetForceIpoActsLocal(PyObject* self,
        int boolArg;
        
        if (!PyArg_ParseTuple(args, "i", &boolArg)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
 
@@ -693,9 +691,7 @@ char KX_IpoActuator::GetForceIpoActsLocal_doc[] =
 "getForceIpoActsLocal()\n"
 "\tReturn whether to apply the force in the object's local\n"
 "\tcoordinates rather than the world global coordinates.\n";
-PyObject* KX_IpoActuator::PyGetForceIpoActsLocal(PyObject* self, 
-                                                                                        PyObject* args, 
-                                                                                        PyObject* kwds) {
+PyObject* KX_IpoActuator::PyGetForceIpoActsLocal(PyObject* self) {
        return BoolToPyArg(m_ipo_local);
 }
 
index ae554fb..d6f52f8 100644 (file)
@@ -143,17 +143,17 @@ public:
        KX_PYMETHOD_DOC(KX_IpoActuator,SetProperty);
 /*     KX_PYMETHOD_DOC(KX_IpoActuator,SetKey2Key); */
        KX_PYMETHOD_DOC(KX_IpoActuator,SetStart);
-       KX_PYMETHOD_DOC(KX_IpoActuator,GetStart);
+       KX_PYMETHOD_DOC_NOARGS(KX_IpoActuator,GetStart);
        KX_PYMETHOD_DOC(KX_IpoActuator,SetEnd);
-       KX_PYMETHOD_DOC(KX_IpoActuator,GetEnd);
+       KX_PYMETHOD_DOC_NOARGS(KX_IpoActuator,GetEnd);
        KX_PYMETHOD_DOC(KX_IpoActuator,SetIpoAsForce);
-       KX_PYMETHOD_DOC(KX_IpoActuator,GetIpoAsForce);
+       KX_PYMETHOD_DOC_NOARGS(KX_IpoActuator,GetIpoAsForce);
        KX_PYMETHOD_DOC(KX_IpoActuator,SetIpoAdd);
-       KX_PYMETHOD_DOC(KX_IpoActuator,GetIpoAdd);
+       KX_PYMETHOD_DOC_NOARGS(KX_IpoActuator,GetIpoAdd);
        KX_PYMETHOD_DOC(KX_IpoActuator,SetType);
-       KX_PYMETHOD_DOC(KX_IpoActuator,GetType);
+       KX_PYMETHOD_DOC_NOARGS(KX_IpoActuator,GetType);
        KX_PYMETHOD_DOC(KX_IpoActuator,SetForceIpoActsLocal);
-       KX_PYMETHOD_DOC(KX_IpoActuator,GetForceIpoActsLocal);
+       KX_PYMETHOD_DOC_NOARGS(KX_IpoActuator,GetForceIpoActsLocal);
        
 };
 
index 9ac0b4d..5cd4d08 100644 (file)
@@ -304,27 +304,27 @@ PyParentObject KX_ObjectActuator::Parents[] = {
 };
 
 PyMethodDef KX_ObjectActuator::Methods[] = {
-       {"getForce", (PyCFunction) KX_ObjectActuator::sPyGetForce, METH_VARARGS},
+       {"getForce", (PyCFunction) KX_ObjectActuator::sPyGetForce, METH_NOARGS},
        {"setForce", (PyCFunction) KX_ObjectActuator::sPySetForce, METH_VARARGS},
-       {"getTorque", (PyCFunction) KX_ObjectActuator::sPyGetTorque, METH_VARARGS},
+       {"getTorque", (PyCFunction) KX_ObjectActuator::sPyGetTorque, METH_NOARGS},
        {"setTorque", (PyCFunction) KX_ObjectActuator::sPySetTorque, METH_VARARGS},
-       {"getDLoc", (PyCFunction) KX_ObjectActuator::sPyGetDLoc, METH_VARARGS},
+       {"getDLoc", (PyCFunction) KX_ObjectActuator::sPyGetDLoc, METH_NOARGS},
        {"setDLoc", (PyCFunction) KX_ObjectActuator::sPySetDLoc, METH_VARARGS},
-       {"getDRot", (PyCFunction) KX_ObjectActuator::sPyGetDRot, METH_VARARGS},
+       {"getDRot", (PyCFunction) KX_ObjectActuator::sPyGetDRot, METH_NOARGS},
        {"setDRot", (PyCFunction) KX_ObjectActuator::sPySetDRot, METH_VARARGS},
-       {"getLinearVelocity", (PyCFunction) KX_ObjectActuator::sPyGetLinearVelocity, METH_VARARGS},
+       {"getLinearVelocity", (PyCFunction) KX_ObjectActuator::sPyGetLinearVelocity, METH_NOARGS},
        {"setLinearVelocity", (PyCFunction) KX_ObjectActuator::sPySetLinearVelocity, METH_VARARGS},
-       {"getAngularVelocity", (PyCFunction) KX_ObjectActuator::sPyGetAngularVelocity, METH_VARARGS},
+       {"getAngularVelocity", (PyCFunction) KX_ObjectActuator::sPyGetAngularVelocity, METH_NOARGS},
        {"setAngularVelocity", (PyCFunction) KX_ObjectActuator::sPySetAngularVelocity, METH_VARARGS},
        {"setDamping", (PyCFunction) KX_ObjectActuator::sPySetDamping, METH_VARARGS},
-       {"getDamping", (PyCFunction) KX_ObjectActuator::sPyGetDamping, METH_VARARGS},
+       {"getDamping", (PyCFunction) KX_ObjectActuator::sPyGetDamping, METH_NOARGS},
        {"setForceLimitX", (PyCFunction) KX_ObjectActuator::sPySetForceLimitX, METH_VARARGS},
-       {"getForceLimitX", (PyCFunction) KX_ObjectActuator::sPyGetForceLimitX, METH_VARARGS},
+       {"getForceLimitX", (PyCFunction) KX_ObjectActuator::sPyGetForceLimitX, METH_NOARGS},
        {"setForceLimitY", (PyCFunction) KX_ObjectActuator::sPySetForceLimitY, METH_VARARGS},
-       {"getForceLimitY", (PyCFunction) KX_ObjectActuator::sPyGetForceLimitY, METH_VARARGS},
+       {"getForceLimitY", (PyCFunction) KX_ObjectActuator::sPyGetForceLimitY, METH_NOARGS},
        {"setForceLimitZ", (PyCFunction) KX_ObjectActuator::sPySetForceLimitZ, METH_VARARGS},
-       {"getForceLimitZ", (PyCFunction) KX_ObjectActuator::sPyGetForceLimitZ, METH_VARARGS},
-       {"setPID", (PyCFunction) KX_ObjectActuator::sPyGetPID, METH_VARARGS},
+       {"getForceLimitZ", (PyCFunction) KX_ObjectActuator::sPyGetForceLimitZ, METH_NOARGS},
+       {"setPID", (PyCFunction) KX_ObjectActuator::sPyGetPID, METH_NOARGS},
        {"getPID", (PyCFunction) KX_ObjectActuator::sPySetPID, METH_VARARGS},
 
 
@@ -340,9 +340,7 @@ PyObject* KX_ObjectActuator::_getattr(const STR_String& attr) {
 /* Removed! */
 
 /* 2. getForce                                                               */
-PyObject* KX_ObjectActuator::PyGetForce(PyObject* self, 
-                                                                               PyObject* args, 
-                                                                               PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetForce(PyObject* self)
 {
        PyObject *retVal = PyList_New(4);
 
@@ -362,6 +360,7 @@ PyObject* KX_ObjectActuator::PySetForce(PyObject* self,
        int bToggle = 0;
        if (!PyArg_ParseTuple(args, "fffi", &vecArg[0], &vecArg[1], 
                                                  &vecArg[2], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_force.setValue(vecArg);
@@ -371,9 +370,7 @@ PyObject* KX_ObjectActuator::PySetForce(PyObject* self,
 }
 
 /* 4. getTorque                                                              */
-PyObject* KX_ObjectActuator::PyGetTorque(PyObject* self, 
-                                                                                PyObject* args, 
-                                                                                PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetTorque(PyObject* self)
 {
        PyObject *retVal = PyList_New(4);
 
@@ -393,6 +390,7 @@ PyObject* KX_ObjectActuator::PySetTorque(PyObject* self,
        int bToggle = 0;
        if (!PyArg_ParseTuple(args, "fffi", &vecArg[0], &vecArg[1], 
                                                  &vecArg[2], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_torque.setValue(vecArg);
@@ -402,9 +400,7 @@ PyObject* KX_ObjectActuator::PySetTorque(PyObject* self,
 }
 
 /* 6. getDLoc                                                                */
-PyObject* KX_ObjectActuator::PyGetDLoc(PyObject* self, 
-                                                                          PyObject* args, 
-                                                                          PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetDLoc(PyObject* self)
 {
        PyObject *retVal = PyList_New(4);
 
@@ -424,6 +420,7 @@ PyObject* KX_ObjectActuator::PySetDLoc(PyObject* self,
        int bToggle = 0;
        if(!PyArg_ParseTuple(args, "fffi", &vecArg[0], &vecArg[1], 
                                                 &vecArg[2], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_dloc.setValue(vecArg);
@@ -433,9 +430,7 @@ PyObject* KX_ObjectActuator::PySetDLoc(PyObject* self,
 }
 
 /* 8. getDRot                                                                */
-PyObject* KX_ObjectActuator::PyGetDRot(PyObject* self, 
-                                                                          PyObject* args, 
-                                                                          PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetDRot(PyObject* self)
 {
        PyObject *retVal = PyList_New(4);
 
@@ -455,6 +450,7 @@ PyObject* KX_ObjectActuator::PySetDRot(PyObject* self,
        int bToggle = 0;
        if (!PyArg_ParseTuple(args, "fffi", &vecArg[0], &vecArg[1], 
                                                  &vecArg[2], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_drot.setValue(vecArg);
@@ -464,9 +460,7 @@ PyObject* KX_ObjectActuator::PySetDRot(PyObject* self,
 }
 
 /* 10. getLinearVelocity                                                 */
-PyObject* KX_ObjectActuator::PyGetLinearVelocity(PyObject* self, 
-                                                                                                PyObject* args, 
-                                                                                                PyObject* kwds) {
+PyObject* KX_ObjectActuator::PyGetLinearVelocity(PyObject* self) {
        PyObject *retVal = PyList_New(4);
 
        PyList_SetItem(retVal, 0, PyFloat_FromDouble(m_linear_velocity[0]));
@@ -485,6 +479,7 @@ PyObject* KX_ObjectActuator::PySetLinearVelocity(PyObject* self,
        int bToggle = 0;
        if (!PyArg_ParseTuple(args, "fffi", &vecArg[0], &vecArg[1], 
                                                  &vecArg[2], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_linear_velocity.setValue(vecArg);
@@ -495,9 +490,7 @@ PyObject* KX_ObjectActuator::PySetLinearVelocity(PyObject* self,
 
 
 /* 12. getAngularVelocity                                                */
-PyObject* KX_ObjectActuator::PyGetAngularVelocity(PyObject* self, 
-                                                                                                 PyObject* args, 
-                                                                                                 PyObject* kwds) {
+PyObject* KX_ObjectActuator::PyGetAngularVelocity(PyObject* self) {
        PyObject *retVal = PyList_New(4);
 
        PyList_SetItem(retVal, 0, PyFloat_FromDouble(m_angular_velocity[0]));
@@ -515,6 +508,7 @@ PyObject* KX_ObjectActuator::PySetAngularVelocity(PyObject* self,
        int bToggle = 0;
        if (!PyArg_ParseTuple(args, "fffi", &vecArg[0], &vecArg[1], 
                                                  &vecArg[2], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_angular_velocity.setValue(vecArg);
@@ -529,6 +523,7 @@ PyObject* KX_ObjectActuator::PySetDamping(PyObject* self,
                                                                                  PyObject* kwds) {
        int damping = 0;
        if (!PyArg_ParseTuple(args, "i", &damping) || damping < 0 || damping > 1000) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_damping = damping;
@@ -536,15 +531,11 @@ PyObject* KX_ObjectActuator::PySetDamping(PyObject* self,
 }
 
 /* 13. getVelocityDamping                                                */
-PyObject* KX_ObjectActuator::PyGetDamping(PyObject* self, 
-                                                                                 PyObject* args, 
-                                                                                 PyObject* kwds) {
+PyObject* KX_ObjectActuator::PyGetDamping(PyObject* self) {
        return Py_BuildValue("i",m_damping);
 }
 /* 6. getForceLimitX                                                                */
-PyObject* KX_ObjectActuator::PyGetForceLimitX(PyObject* self, 
-                                                                                         PyObject* args, 
-                                                                                         PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetForceLimitX(PyObject* self)
 {
        PyObject *retVal = PyList_New(3);
 
@@ -562,6 +553,7 @@ PyObject* KX_ObjectActuator::PySetForceLimitX(PyObject* self,
        float vecArg[2];
        int bToggle = 0;
        if(!PyArg_ParseTuple(args, "ffi", &vecArg[0], &vecArg[1], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_drot[0] = vecArg[0];
@@ -571,9 +563,7 @@ PyObject* KX_ObjectActuator::PySetForceLimitX(PyObject* self,
 }
 
 /* 6. getForceLimitY                                                                */
-PyObject* KX_ObjectActuator::PyGetForceLimitY(PyObject* self, 
-                                                                                         PyObject* args, 
-                                                                                         PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetForceLimitY(PyObject* self)
 {
        PyObject *retVal = PyList_New(3);
 
@@ -591,6 +581,7 @@ PyObject* KX_ObjectActuator::PySetForceLimitY(PyObject* self,
        float vecArg[2];
        int bToggle = 0;
        if(!PyArg_ParseTuple(args, "ffi", &vecArg[0], &vecArg[1], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_drot[1] = vecArg[0];
@@ -600,9 +591,7 @@ PyObject* KX_ObjectActuator::PySetForceLimitY(PyObject* self,
 }
 
 /* 6. getForceLimitZ                                                                */
-PyObject* KX_ObjectActuator::PyGetForceLimitZ(PyObject* self, 
-                                                                                         PyObject* args, 
-                                                                                         PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetForceLimitZ(PyObject* self)
 {
        PyObject *retVal = PyList_New(3);
 
@@ -620,6 +609,7 @@ PyObject* KX_ObjectActuator::PySetForceLimitZ(PyObject* self,
        float vecArg[2];
        int bToggle = 0;
        if(!PyArg_ParseTuple(args, "ffi", &vecArg[0], &vecArg[1], &bToggle)) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_drot[2] = vecArg[0];
@@ -629,9 +619,7 @@ PyObject* KX_ObjectActuator::PySetForceLimitZ(PyObject* self,
 }
 
 /* 4. getPID                                                              */
-PyObject* KX_ObjectActuator::PyGetPID(PyObject* self, 
-                                                                         PyObject* args, 
-                                                                         PyObject* kwds)
+PyObject* KX_ObjectActuator::PyGetPID(PyObject* self)
 {
        PyObject *retVal = PyList_New(3);
 
@@ -648,6 +636,7 @@ PyObject* KX_ObjectActuator::PySetPID(PyObject* self,
 {
        float vecArg[3];
        if (!PyArg_ParseTuple(args, "fff", &vecArg[0], &vecArg[1], &vecArg[2])) {
+               PyErr_SetString(PyExc_TypeError, "Invalid arguments");
                return NULL;
        }
        m_torque.setValue(vecArg);
index bb74756..aa686f4 100644 (file)
@@ -155,27 +155,27 @@ public:
        
        virtual PyObject* _getattr(const STR_String& attr);
 
-       KX_PYMETHOD(KX_ObjectActuator,GetForce);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetForce);
        KX_PYMETHOD(KX_ObjectActuator,SetForce);
-       KX_PYMETHOD(KX_ObjectActuator,GetTorque);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetTorque);
        KX_PYMETHOD(KX_ObjectActuator,SetTorque);
-       KX_PYMETHOD(KX_ObjectActuator,GetDLoc);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetDLoc);
        KX_PYMETHOD(KX_ObjectActuator,SetDLoc);
-       KX_PYMETHOD(KX_ObjectActuator,GetDRot);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetDRot);
        KX_PYMETHOD(KX_ObjectActuator,SetDRot);
-       KX_PYMETHOD(KX_ObjectActuator,GetLinearVelocity);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetLinearVelocity);
        KX_PYMETHOD(KX_ObjectActuator,SetLinearVelocity);
-       KX_PYMETHOD(KX_ObjectActuator,GetAngularVelocity);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetAngularVelocity);
        KX_PYMETHOD(KX_ObjectActuator,SetAngularVelocity);
        KX_PYMETHOD(KX_ObjectActuator,SetDamping);
-       KX_PYMETHOD(KX_ObjectActuator,GetDamping);
-       KX_PYMETHOD(KX_ObjectActuator,GetForceLimitX);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetDamping);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetForceLimitX);
        KX_PYMETHOD(KX_ObjectActuator,SetForceLimitX);
-       KX_PYMETHOD(KX_ObjectActuator,GetForceLimitY);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetForceLimitY);
        KX_PYMETHOD(KX_ObjectActuator,SetForceLimitY);
-       KX_PYMETHOD(KX_ObjectActuator,GetForceLimitZ);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetForceLimitZ);
        KX_PYMETHOD(KX_ObjectActuator,SetForceLimitZ);
-       KX_PYMETHOD(KX_ObjectActuator,GetPID);
+       KX_PYMETHOD_NOARGS(KX_ObjectActuator,GetPID);
        KX_PYMETHOD(KX_ObjectActuator,SetPID);
 };
 
index 61ed8b6..b66c3e4 100644 (file)
@@ -756,6 +756,15 @@ PyObject* initGameLogic(KX_Scene* scene) // quick hack to get gravity hook
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ROTX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ROTX);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ROTY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ROTY);
        KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ROTZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ROTZ);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DIRPX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRPX);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DIRPY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRPY);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DIRPY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRPY);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DIRNX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNX);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DIRNY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNY);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_DIRNY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_DIRNY);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIX, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIX);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIY, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIY);
+       KX_MACRO_addTypesToDict(d, KX_CONSTRAINTACT_ORIZ, KX_ConstraintActuator::KX_ACT_CONSTRAINT_ORIZ);
 
        /* 4. Ipo actuator, simple part                                            */
        KX_MACRO_addTypesToDict(d, KX_IPOACT_PLAY,     KX_IpoActuator::KX_ACT_IPO_PLAY);
diff --git a/source/gameengine/PyDoc/BL_ShapeActionActuator.py b/source/gameengine/PyDoc/BL_ShapeActionActuator.py
new file mode 100644 (file)
index 0000000..63cce25
--- /dev/null
@@ -0,0 +1,158 @@
+# $Id$
+# Documentation for BL_ShapeActionActuator
+from SCA_IActuator import *
+
+class BL_ShapeActionActuator(SCA_IActuator):
+       """
+       ShapeAction Actuators apply an shape action to an mesh object.
+       """
+       def setAction(action, reset = True):
+               """
+               Sets the current action.
+               
+               @param action: The name of the action to set as the current action.
+               @type action: string
+               @param reset: Optional parameter indicating whether to reset the
+                             blend timer or not.  A value of 1 indicates that the
+                             timer should be reset.  A value of 0 will leave it
+                             unchanged.  If reset is not specified, the timer will
+                             be reset.
+               """
+
+       def setStart(start):
+               """
+               Specifies the starting frame of the animation.
+               
+               @param start: the starting frame of the animation
+               @type start: float
+               """
+
+       def setEnd(end):
+               """
+               Specifies the ending frame of the animation.
+               
+               @param end: the ending frame of the animation
+               @type end: float
+               """
+       def setBlendin(blendin):
+               """
+               Specifies the number of frames of animation to generate
+               when making transitions between actions.
+               
+               @param blendin: the number of frames in transition.
+               @type blendin: float
+               """
+
+       def setPriority(priority):
+               """
+               Sets the priority of this actuator.
+               
+               @param priority: Specifies the new priority.  Actuators will lower
+                                priority numbers will override actuators with higher
+                                numbers.
+               @type priority: integer
+               """
+       def setFrame(frame):
+               """
+               Sets the current frame for the animation.
+               
+               @param frame: Specifies the new current frame for the animation
+               @type frame: float
+               """
+
+       def setProperty(prop):
+               """
+               Sets the property to be used in FromProp playback mode.
+               
+               @param prop: the name of the property to use.
+               @type prop: string.
+               """
+
+       def setBlendtime(blendtime):
+               """
+               Sets the internal frame timer.
+                
+               Allows the script to directly modify the internal timer
+               used when generating transitions between actions.  
+               
+               @param blendtime: The new time. This parameter must be in the range from 0.0 to 1.0.
+               @type blendtime: float
+               """
+
+       def setType(mode):
+               """
+               Sets the operation mode of the actuator
+
+               @param mode: KX_ACTIONACT_PLAY, KX_ACTIONACT_PROPERTY, KX_ACTIONACT_FLIPPER, KX_ACTIONACT_LOOPSTOP, KX_ACTIONACT_LOOPEND
+               @type mode: integer
+               """
+       
+       def setContinue(cont):
+               """
+               Set the actions continue option True or False. see getContinue.
+
+               @param cont: The continue option.
+               @type cont: bool
+               """
+
+       def getType():
+               """
+               Returns the operation mode of the actuator
+           
+               @rtype: integer
+               @return: KX_ACTIONACT_PLAY, KX_ACTIONACT_PROPERTY, KX_ACTIONACT_FLIPPER, KX_ACTIONACT_LOOPSTOP, KX_ACTIONACT_LOOPEND
+               """
+
+       def getContinue():
+               """
+               When True, the action will always play from where last left off, otherwise negative events to this actuator will reset it to its start frame.
+           
+               @rtype: bool
+               """
+       
+       def getAction():
+               """
+               getAction() returns the name of the action associated with this actuator.
+               
+               @rtype: string
+               """
+       
+       def getStart():
+               """
+               Returns the starting frame of the action.
+               
+               @rtype: float
+               """
+       def getEnd():
+               """
+               Returns the last frame of the action.
+               
+               @rtype: float
+               """
+       def getBlendin():
+               """
+               Returns the number of interpolation animation frames to be generated when this actuator is triggered.
+               
+               @rtype: float
+               """
+       def getPriority():
+               """
+               Returns the priority for this actuator.  Actuators with lower Priority numbers will
+               override actuators with higher numbers.
+               
+               @rtype: integer
+               """
+       def getFrame():
+               """
+               Returns the current frame number.
+               
+               @rtype: float
+               """
+       def getProperty():
+               """
+               Returns the name of the property to be used in FromProp mode.
+               
+               @rtype: string
+               """
+
+
diff --git a/source/gameengine/PyDoc/KX_ActuatorSensor.py b/source/gameengine/PyDoc/KX_ActuatorSensor.py
new file mode 100644 (file)
index 0000000..f9aef86
--- /dev/null
@@ -0,0 +1,24 @@
+# $Id$
+# Documentation for KX_ActuatorSensor
+from SCA_IActuator import *
+
+class KX_ActuatorSensor(SCA_ISensor):
+       """
+       Actuator sensor detect change in actuator state of the parent object.
+       It generates a positive pulse if the corresponding actuator is activated
+       and a negative pulse if the actuator is deactivated.
+       """
+       def getActuator():
+               """
+               Return the Actuator with which the sensor operates.
+               
+               @rtype: string
+               """
+       def setActuator(name):
+               """
+               Sets the Actuator with which to operate. If there is no Actuator
+               of this name, the function has no effect.
+               
+               @param name: actuator name
+               @type name: string
+               """
index 9630690..b1c6f3c 100644 (file)
@@ -4,7 +4,7 @@ from SCA_IActuator import *
 
 class KX_ConstraintActuator(SCA_IActuator):
        """
-       A constraint actuator limits the position or orientation of an object.
+       A constraint actuator limits the position, rotation, distance or orientation of an object.
        """
        def setDamp(time):
                """
@@ -24,7 +24,7 @@ class KX_ConstraintActuator(SCA_IActuator):
                """
                Sets the lower bound of the constraint.
                
-               For rotational constraints, lower is specified in degrees.
+               For rotational and orientation constraints, lower is specified in degrees.
                
                @type lower: float
                """
@@ -32,7 +32,7 @@ class KX_ConstraintActuator(SCA_IActuator):
                """
                Gets the lower bound of the constraint.
                
-               For rotational constraints, the lower bound is returned in radians.
+               For rotational and orientation constraints, the lower bound is returned in radians.
                
                @rtype: float
                """
@@ -40,7 +40,7 @@ class KX_ConstraintActuator(SCA_IActuator):
                """
                Sets the upper bound of the constraint.
                
-               For rotational constraints, upper is specified in degrees.
+               For rotational and orientation constraints, upper is specified in degrees.
                
                @type upper: float
                """
@@ -48,7 +48,7 @@ class KX_ConstraintActuator(SCA_IActuator):
                """
                Gets the upper bound of the constraint.
                
-               For rotational constraints, the upper bound is returned in radians.
+               For rotational and orientation constraints, the upper bound is returned in radians.
                
                @rtype: float
                """
@@ -60,6 +60,9 @@ class KX_ConstraintActuator(SCA_IActuator):
                
                @param limit: Position constraints: KX_CONSTRAINTACT_LOCX, KX_CONSTRAINTACT_LOCY, KX_CONSTRAINTACT_LOCZ, 
                              Rotation constraints: KX_CONSTRAINTACT_ROTX, KX_CONSTRAINTACT_ROTY or KX_CONSTRAINTACT_ROTZ
+                             Distance contraints: KX_ACT_CONSTRAINT_DIRPX, KX_ACT_CONSTRAINT_DIRPY, KX_ACT_CONSTRAINT_DIRPZ,
+                                                  KX_ACT_CONSTRAINT_DIRNX, KX_ACT_CONSTRAINT_DIRNY, KX_ACT_CONSTRAINT_DIRNZ,
+                             Orientation constraints: KX_ACT_CONSTRAINT_ORIX, KX_ACT_CONSTRAINT_ORIY, KX_ACT_CONSTRAINT_ORIZ
                """
        def getLimit():
                """
@@ -68,5 +71,110 @@ class KX_ConstraintActuator(SCA_IActuator):
                See module L{GameLogic} for valid constraints.
                
                @return: Position constraints: KX_CONSTRAINTACT_LOCX, KX_CONSTRAINTACT_LOCY, KX_CONSTRAINTACT_LOCZ, 
-                        Rotation constraints: KX_CONSTRAINTACT_ROTX, KX_CONSTRAINTACT_ROTY or KX_CONSTRAINTACT_ROTZ
+                        Rotation constraints: KX_CONSTRAINTACT_ROTX, KX_CONSTRAINTACT_ROTY, KX_CONSTRAINTACT_ROTZ,
+                        Distance contraints: KX_ACT_CONSTRAINT_DIRPX, KX_ACT_CONSTRAINT_DIRPY, KX_ACT_CONSTRAINT_DIRPZ,
+                                             KX_ACT_CONSTRAINT_DIRNX, KX_ACT_CONSTRAINT_DIRNY, KX_ACT_CONSTRAINT_DIRNZ,
+                        Orientation constraints: KX_ACT_CONSTRAINT_ORIX, KX_ACT_CONSTRAINT_ORIY, KX_ACT_CONSTRAINT_ORIZ
                """
+       def setRotDamp(duration):
+               """
+               Sets the time constant of the orientation constraint.
+               
+               @param duration: If the duration is negative, it is set to 0.
+               @type duration: integer
+               """
+       def getRotDamp():
+               """ 
+               Returns the damping time for application of the constraint.
+               
+               @rtype: integer
+               """
+       def setDirection(vector):
+               """
+               Sets the reference direction in world coordinate for the orientation constraint
+               
+               @type vector: 3-tuple
+               """
+       def getDirection():
+               """
+               Returns the reference direction of the orientation constraint in world coordinate.
+               
+               @rtype: 3-tuple
+               """
+       def setOption(option):
+               """
+               Sets several options of the distance constraint.
+               
+               @type option: integer
+               @param option: Binary combination of the following values:
+                               64 : Activate alignment to surface
+                              128 : Detect material rather than property
+                              256 : No deactivation if ray does not hit target
+                              512 : Activate distance control
+               """
+       def getOption():
+               """
+               Returns the option parameter.
+               
+               @rtype: integer
+               """
+       def setTime(duration):
+               """
+               Sets the activation time of the actuator.
+               
+               @type duration: integer
+               @param duration: The actuator disables itself after this many frame.
+                                If set to 0 or negative, the actuator is not limited in time.
+               """
+       def getTime():
+               """
+               Returns the time parameter.
+               
+               @rtype: integer
+               """
+       def setProperty(property):
+               """
+               Sets the name of the property or material for the ray detection of the distance constraint.
+               
+               @type property: string
+               @param property: If empty, the ray will detect any collisioning object.
+               """
+       def getProperty():
+               """
+               Returns the property parameter.
+               
+               @rtype: string
+               """
+       def setDistance(distance):
+               """
+               Sets the target distance in distance constraint.
+               
+               @type distance: float
+               """
+       def getDistance():
+               """
+               Returns the distance parameter.
+               
+               @rtype: float
+               """
+       def setRayLength(length):
+               """
+               Sets the maximum ray length of the distance constraint.
+               
+               @type length: float
+               """
+       def getRayLength():
+               """
+               Returns the length of the ray
+               
+               @rtype: float
+               """
+
+
+
+
+
+
+
+
+               
index da8d05d..1cdab82 100644 (file)
@@ -6,7 +6,7 @@ class KX_IpoActuator(SCA_IActuator):
        """
        IPO actuator activates an animation.
        """
-       def set(mode, startframe, endframe, force):
+       def set(mode, startframe, endframe, mode):
                """
                Sets the properties of the actuator.
                
@@ -16,8 +16,8 @@ class KX_IpoActuator(SCA_IActuator):
                @type startframe: integer
                @param endframe: last frame to use
                @type endframe: integer
-               @param force: interpret this ipo as a force
-               @type force: boolean (KX_TRUE, KX_FALSE)
+               @param mode: special mode
+               @type mode: integer (0=normal, 1=interpret location as force, 2=additive)
                """
        def setProperty(property):
                """
@@ -60,6 +60,19 @@ class KX_IpoActuator(SCA_IActuator):
                """
                Returns whether to interpret the ipo as a force rather than a displacement.
                
+               @rtype: boolean
+               """
+       def setIpoAdd(add):
+               """
+               Set whether to interpret the ipo as additive rather than absolute.
+               
+               @type add: boolean
+               @param add: KX_TRUE or KX_FALSE
+               """
+       def getIpoAdd():
+               """
+               Returns whether to interpret the ipo as additive rather than absolute.
+               
                @rtype: boolean
                """
        def setType(mode):
index 532c18e..db577d2 100644 (file)
@@ -6,6 +6,7 @@ class KX_ObjectActuator(SCA_IActuator):
        """
        The object actuator ("Motion Actuator") applies force, torque, displacement, angular displacement,
        velocity, or angular velocity to an object.
+       Servo control allows to regulate force to achieve a certain speed target.
        """
        def getForce():
                """
@@ -107,15 +108,17 @@ class KX_ObjectActuator(SCA_IActuator):
        def getLinearVelocity():
                """
                Returns the linear velocity applied by the actuator.
+               For the servo control actuator, this is the target speed.
                
                @rtype: list [vx, vy, vz, local]
                @return: A four item list, containing the vector velocity, and whether
                         the velocity is applied in local coordinates (True) or world
-                        coordinates (False)
+                            coordinates (False)
                """
        def setLinearVelocity(vx, vy, vz, local):
                """
                Sets the linear velocity applied by the actuator.
+               For the servo control actuator, sets the target speed.
                
                @type vx: float
                @param vx: the x component of the velocity vector.
@@ -124,8 +127,8 @@ class KX_ObjectActuator(SCA_IActuator):
                @type vz: float
                @param vz: the z component of the velocity vector.
                @type local: boolean
-               @param local: - False: the velocity vector is applied in world coordinates.
-                             - True: the velocity vector is applied in local coordinates.
+               @param local: - False: the velocity vector is in world coordinates.
+                             - True: the velocity vector is in local coordinates.
                """
        def getAngularVelocity():
                """
@@ -150,5 +153,100 @@ class KX_ObjectActuator(SCA_IActuator):
                @param local: - False: the velocity vector is applied in world coordinates.
                              - True: the velocity vector is applied in local coordinates.
                """
+       def getDamping():
+               """
+               Returns the damping parameter of the servo controller.
+               
+               @rtype: integer
+               @return: the time constant of the servo controller in frame unit.
+               """
+       def setDamping(damp):
+               """
+               Sets the damping parameter of the servo controller.
+               
+               @type damp: integer
+               @param damp: the damping parameter in frame unit.
+               """
+       def getForceLimitX():
+               """
+               Returns the min/max force limit along the X axis used by the servo controller.
+               
+               @rtype: list [min, max, enabled]
+               @return: A three item list, containing the min and max limits of the force as float
+                        and whether the limits are active(true) or inactive(true)
+               """
+       def setForceLimitX(min, max, enable):
+               """
+               Sets the min/max force limit along the X axis and activates or deactivates the limits in the servo controller.
+               
+               @type min: float
+               @param min: the minimum value of the force along the X axis.
+               @type max: float
+               @param max: the maximum value of the force along the X axis.
+               @type enable: boolean
+               @param enable: - True: the force will be limited to the min/max
+                              - False: the force will not be limited                          
+               """
+       def getForceLimitY():
+               """
+               Returns the min/max force limit along the Y axis used by the servo controller.
+               
+               @rtype: list [min, max, enabled]
+               @return: A three item list, containing the min and max limits of the force as float
+                        and whether the limits are active(true) or inactive(true)
+               """
+       def setForceLimitY(min, max, enable):
+               """
+               Sets the min/max force limit along the Y axis and activates or deactivates the limits in the servo controller.
+               
+               @type min: float
+               @param min: the minimum value of the force along the Y axis.
+               @type max: float
+               @param max: the maximum value of the force along the Y axis.
+               @type enable: boolean
+               @param enable: - True: the force will be limited to the min/max
+                              - False: the force will not be limited                          
+               """
+       def getForceLimitZ():
+               """
+               Returns the min/max force limit along the Z axis used by the servo controller.
+               
+               @rtype: list [min, max, enabled]
+               @return: A three item list, containing the min and max limits of the force as float
+                        and whether the limits are active(true) or inactive(true)
+               """
+       def setForceLimitZ(min, max, enable):
+               """
+               Sets the min/max force limit along the Z axis and activates or deactivates the limits in the servo controller.
+               
+               @type min: float
+               @param min: the minimum value of the force along the Z axis.
+               @type max: float
+               @param max: the maximum value of the force along the Z axis.
+               @type enable: boolean
+               @param enable: - True: the force will be limited to the min/max
+                              - False: the force will not be limited                          
+               """
+       def getPID():
+               """
+               Returns the PID coefficient of the servo controller.
+               
+               @rtype: list [P, I, D]
+               @return: A three item list, containing the PID coefficient as floats:
+                        P : proportional coefficient
+                        I : Integral coefficient
+                        D : Derivate coefficient
+               """
+       def setPID(P, I, D):
+               """
+               Sets the PID coefficients of the servo controller.
+               
+               @type P: flat
+               @param P: proportional coefficient
+               @type I: float
+               @param I: Integral coefficient
+               @type D: float
+               @param D: Derivate coefficient
+               """
 
 
diff --git a/source/gameengine/PyDoc/KX_StateActuator.py b/source/gameengine/PyDoc/KX_StateActuator.py
new file mode 100644 (file)
index 0000000..fb6ae5a
--- /dev/null
@@ -0,0 +1,26 @@
+# $Id$
+# Documentation for KX_StateActuator
+from SCA_IActuator import *
+
+class KX_StateActuator(SCA_IActuator):
+       """
+       State actuator changes the state mask of parent object.
+       """
+       def setOperation(op):
+               """
+               Set the type of bit operation to be applied on object state mask.
+               Use setMask() to specify the bits that will be modified.
+               
+               @param op: bit operation (0=Copy, 1=Add, 2=Substract, 3=Invert)
+               @type op: integer
+               """
+       def setMask(mask):
+               """
+               Set the value that defines the bits that will be modified by the operation.
+               The bits that are 1 in the value will be updated in the object state,
+               the bits that are 0 are will be left unmodified expect for the Copy operation
+               which copies the value to the object state.
+               
+               @param mask: bits that will be modified
+               @type mask: integer
+               """
index b96d8c8..0ebc2de 100644 (file)
@@ -59,4 +59,22 @@ class SCA_ISensor(SCA_ILogicBrick):
                @type invert: boolean
                @param invert: true if activates on negative events; false if activates on positive events.
                """
+       def getLevel():
+               """
+               Returns whether this sensor is a level detector or a edge detector.
+               It makes a difference only in case of logic state transition (state actuator).
+               A level detector will immediately generate a pulse, negative or positive
+               depending on the sensor condition, as soon as the state is activated.
+               A edge detector will wait for a state change before generating a pulse.
+               
+               @rtype: boolean
+               @return: true if sensor is level sensitive, false if it is edge sensitive
+               """
+       def setLevel(level):
+               """
+               Set whether to detect level or edge transition when entering a state.
+               
+               @param level: Detect level instead of edge? (KX_TRUE, KX_FALSE)
+               @type level: boolean
+               """