non user visible changes and small optimizations to the game engine pyapi as well as fixing some bugs.

* 2 returning errors without exception set another return None instead of NULL.
* a missing check for parent relation
* BPY matrix length was incorrect in matrix.c, this change could break some scripts, however when a script expects a list of lists for a matrix, the len() function is incorrect and will give an error. This was the only thing stopping apricot game logic running in trunk.

Also added a function for GameObjects  -  getAxisVect(vec), multiplies the vector be the objects worldspace rotation matrix. Very useful if you want to know what the forward direction is for an object and dont want to use Blender.Mathutils which is tedious and not available in BlenderPlayer yet.

7 files changed, 235 insertions, 290 deletions

diff --git a/source/blender/python/api2_2x/matrix.c b/source/blender/python/api2_2x/matrix.c
index d81e56ec3dc..9f5e49e8d88 100644
--- a/source/blender/python/api2_2x/matrix.c
+++ b/source/blender/python/api2_2x/matrix.c
@@ -483,7 +483,7 @@ static char MatrixObject_doc[] = "This is a wrapper for matrix objects.";
   sequence length*/
 static int Matrix_len(MatrixObject * self)
 {
-	return (self->colSize * self->rowSize);
+	return (self->rowSize);
 }
 /*----------------------------object[]---------------------------
   sequence accessor (get)
diff --git a/source/gameengine/Expressions/PyObjectPlus.h b/source/gameengine/Expressions/PyObjectPlus.h
index de89ed9b5c8..04cc119efee 100644
--- a/source/gameengine/Expressions/PyObjectPlus.h
+++ b/source/gameengine/Expressions/PyObjectPlus.h
@@ -99,6 +99,18 @@ static inline void Py_Fatal(char *M) {
 		return ((class_name*) self)->Py##method_name(self, args, kwds);		\
 	}; \
 
+#define KX_PYMETHOD_NOARGS(class_name, method_name)			\
+	PyObject* Py##method_name(PyObject* self); \
+	static PyObject* sPy##method_name( PyObject* self) { \
+		return ((class_name*) self)->Py##method_name(self);		\
+	}; \
+	
+#define KX_PYMETHOD_O(class_name, method_name)			\
+	PyObject* Py##method_name(PyObject* self, PyObject* value); \
+	static PyObject* sPy##method_name( PyObject* self, PyObject* value) { \
+		return ((class_name*) self)->Py##method_name(self, value);		\
+	}; \
+
 #define KX_PYMETHOD_DOC(class_name, method_name)			\
 	PyObject* Py##method_name(PyObject* self, PyObject* args, PyObject* kwds); \
 	static PyObject* sPy##method_name( PyObject* self, PyObject* args, PyObject* kwds) { \
@@ -106,6 +118,21 @@ static inline void Py_Fatal(char *M) {
 	}; \
     static char method_name##_doc[]; \
 
+#define KX_PYMETHOD_DOC_O(class_name, method_name)			\
+	PyObject* Py##method_name(PyObject* self, PyObject* value); \
+	static PyObject* sPy##method_name( PyObject* self, PyObject* value) { \
+		return ((class_name*) self)->Py##method_name(self, value);		\
+	}; \
+    static char method_name##_doc[]; \
+
+#define KX_PYMETHOD_DOC_NOARGS(class_name, method_name)			\
+	PyObject* Py##method_name(PyObject* self); \
+	static PyObject* sPy##method_name( PyObject* self) { \
+		return ((class_name*) self)->Py##method_name(self);		\
+	}; \
+    static char method_name##_doc[]; \
+
+
 /* The line above should remain empty */
 /**
  * Method table macro (with doc)
diff --git a/source/gameengine/GameLogic/SCA_PythonController.cpp b/source/gameengine/GameLogic/SCA_PythonController.cpp
index be00117cd21..76386079bdf 100644
--- a/source/gameengine/GameLogic/SCA_PythonController.cpp
+++ b/source/gameengine/GameLogic/SCA_PythonController.cpp
@@ -144,9 +144,7 @@ static char* sPyGetCurrentController__doc__;
 #endif
 
 
-PyObject* SCA_PythonController::sPyGetCurrentController(PyObject* self, 
-											 PyObject* args, 
-											 PyObject* kwds)
+PyObject* SCA_PythonController::sPyGetCurrentController(PyObject* self)
 {
 	m_sCurrentController->AddRef();
 	return m_sCurrentController;
@@ -159,8 +157,7 @@ static char* sPyAddActiveActuator__doc__;
 PyObject* SCA_PythonController::sPyAddActiveActuator(
 	  
 		PyObject* self, 
-		PyObject* args, 
-		PyObject* kwds)
+		PyObject* args)
 {
 	
 	PyObject* ob1;
@@ -187,8 +184,7 @@ PyObject* SCA_PythonController::sPyAddActiveActuator(
 		m_sCurrentLogicManager->AddActiveActuator((SCA_IActuator*)act,boolval);
 		boolval->Release();
 	}
-	Py_INCREF(Py_None);
-	return Py_None;
+	Py_RETURN_NONE;
 }
 
 
@@ -222,17 +218,13 @@ PyParentObject SCA_PythonController::Parents[] = {
 	NULL
 };
 PyMethodDef SCA_PythonController::Methods[] = {
-	{"getActuators", (PyCFunction) SCA_PythonController::sPyGetActuators, 
-		METH_VARARGS, SCA_PythonController::GetActuators_doc},
-	{"getActuator", (PyCFunction) SCA_PythonController::sPyGetActuator, 
-	METH_VARARGS, SCA_PythonController::GetActuator_doc},
-	{"getSensors", (PyCFunction) SCA_PythonController::sPyGetSensors, 
-	METH_VARARGS, SCA_PythonController::GetSensors_doc},
-	{"getSensor", (PyCFunction) SCA_PythonController::sPyGetSensor, 
-	METH_VARARGS, SCA_PythonController::GetSensor_doc},
-	{"getScript", (PyCFunction) SCA_PythonController::sPyGetScript, METH_VARARGS},
-	{"setScript", (PyCFunction) SCA_PythonController::sPySetScript, METH_VARARGS},
-	{"getState", (PyCFunction) SCA_PythonController::sPyGetState, METH_VARARGS},
+	{"getActuators", (PyCFunction) SCA_PythonController::sPyGetActuators, METH_NOARGS, SCA_PythonController::GetActuators_doc},
+	{"getActuator", (PyCFunction) SCA_PythonController::sPyGetActuator, METH_O, SCA_PythonController::GetActuator_doc},
+	{"getSensors", (PyCFunction) SCA_PythonController::sPyGetSensors, METH_NOARGS, SCA_PythonController::GetSensors_doc},
+	{"getSensor", (PyCFunction) SCA_PythonController::sPyGetSensor, METH_O, SCA_PythonController::GetSensor_doc},
+	{"getScript", (PyCFunction) SCA_PythonController::sPyGetScript, METH_NOARGS},
+	{"setScript", (PyCFunction) SCA_PythonController::sPySetScript, METH_O},
+	{"getState", (PyCFunction) SCA_PythonController::sPyGetState, METH_NOARGS},
 	{NULL,NULL} //Sentinel
 };
 
@@ -330,14 +322,12 @@ PyObject* SCA_PythonController::_getattr(const STR_String& attr)
 
 
 
-PyObject* SCA_PythonController::PyGetActuators(PyObject* self, 
-								   PyObject* args, 
-								   PyObject* kwds)
+PyObject* SCA_PythonController::PyGetActuators(PyObject* self)
 {
 	PyObject* resultlist = PyList_New(m_linkedactuators.size());
 	for (unsigned int index=0;index<m_linkedactuators.size();index++)
 	{
-		PyList_SetItem(resultlist,index,m_linkedactuators[index]->AddRef());
+		PyList_SET_ITEM(resultlist,index,m_linkedactuators[index]->AddRef());
 	}
 
 	return resultlist;
@@ -346,14 +336,12 @@ PyObject* SCA_PythonController::PyGetActuators(PyObject* self,
 char SCA_PythonController::GetSensor_doc[] = 
 "GetSensor (char sensorname) return linked sensor that is named [sensorname]\n";
 PyObject*
-SCA_PythonController::PyGetSensor(PyObject* self, 
-								 PyObject* args, 
-								 PyObject* kwds)
+SCA_PythonController::PyGetSensor(PyObject* self, PyObject* value)
 {
 
-	char *scriptArg;
-
-	if (!PyArg_ParseTuple(args, "s", &scriptArg)) {
+	char *scriptArg = PyString_AsString(value);
+	if (scriptArg==NULL) {
+		PyErr_SetString(PyExc_TypeError, "expected a string (sensor name)");
 		return NULL;
 	}
 	
@@ -376,14 +364,12 @@ SCA_PythonController::PyGetSensor(PyObject* self,
 char SCA_PythonController::GetActuator_doc[] = 
 "GetActuator (char sensorname) return linked actuator that is named [actuatorname]\n";
 PyObject*
-SCA_PythonController::PyGetActuator(PyObject* self, 
-								 PyObject* args, 
-								 PyObject* kwds)
+SCA_PythonController::PyGetActuator(PyObject* self, PyObject* value)
 {
 
-	char *scriptArg;
-
-	if (!PyArg_ParseTuple(args, "s", &scriptArg)) {
+	char *scriptArg = PyString_AsString(value);
+	if (scriptArg==NULL) {
+		PyErr_SetString(PyExc_TypeError, "expected a string (actuator name)");
 		return NULL;
 	}
 	
@@ -404,34 +390,29 @@ SCA_PythonController::PyGetActuator(PyObject* self,
 
 char SCA_PythonController::GetSensors_doc[]   = "getSensors returns a list of all attached sensors";
 PyObject*
-SCA_PythonController::PyGetSensors(PyObject* self, 
-								 PyObject* args, 
-								 PyObject* kwds)
+SCA_PythonController::PyGetSensors(PyObject* self)
 {
 	PyObject* resultlist = PyList_New(m_linkedsensors.size());
 	for (unsigned int index=0;index<m_linkedsensors.size();index++)
 	{
-		PyList_SetItem(resultlist,index,m_linkedsensors[index]->AddRef());
+		PyList_SET_ITEM(resultlist,index,m_linkedsensors[index]->AddRef());
 	}
 	
 	return resultlist;
 }
 
 /* 1. getScript */
-PyObject* SCA_PythonController::PyGetScript(PyObject* self, 
-										   PyObject* args, 
-										   PyObject* kwds)
+PyObject* SCA_PythonController::PyGetScript(PyObject* self)
 {
 	return PyString_FromString(m_scriptText);
 }
 
 /* 2. setScript */
-PyObject* SCA_PythonController::PySetScript(PyObject* self, 
-										   PyObject* args, 
-										   PyObject* kwds)
+PyObject* SCA_PythonController::PySetScript(PyObject* self, PyObject* value)
 {
-	char *scriptArg;
-	if (!PyArg_ParseTuple(args, "s", &scriptArg)) {
+	char *scriptArg = PyString_AsString(value);
+	if (scriptArg==NULL) {
+		PyErr_SetString(PyExc_TypeError, "expected a string (script name)");
 		return NULL;
 	}
 	
@@ -440,13 +421,11 @@ PyObject* SCA_PythonController::PySetScript(PyObject* self,
 
 	this->SetScriptText(scriptArg);
 	
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
 /* 1. getScript */
-PyObject* SCA_PythonController::PyGetState(PyObject* self, 
-										   PyObject* args, 
-										   PyObject* kwds)
+PyObject* SCA_PythonController::PyGetState(PyObject* self)
 {
 	return PyInt_FromLong(m_statemask);
 }
diff --git a/source/gameengine/GameLogic/SCA_PythonController.h b/source/gameengine/GameLogic/SCA_PythonController.h
index f3af54f402f..39b6c68c359 100644
--- a/source/gameengine/GameLogic/SCA_PythonController.h
+++ b/source/gameengine/GameLogic/SCA_PythonController.h
@@ -66,22 +66,19 @@ class SCA_PythonController : public SCA_IController
 	void	SetDictionary(PyObject*	pythondictionary);
 
 	static char* sPyGetCurrentController__doc__;
-	static PyObject* sPyGetCurrentController(PyObject* self, 
-											 PyObject* args, 
-											 PyObject* kwds);
+	static PyObject* sPyGetCurrentController(PyObject* self);
 	static char* sPyAddActiveActuator__doc__;
 	static PyObject* sPyAddActiveActuator(PyObject* self, 
-										  PyObject* args, 
-										  PyObject* kwds);
+										  PyObject* args);
 	virtual PyObject* _getattr(const STR_String& attr);
 
-	KX_PYMETHOD_DOC(SCA_PythonController,GetSensors);
-	KX_PYMETHOD_DOC(SCA_PythonController,GetSensor);
-	KX_PYMETHOD_DOC(SCA_PythonController,GetActuator);
-	KX_PYMETHOD_DOC(SCA_PythonController,GetActuators);
-	KX_PYMETHOD(SCA_PythonController,SetScript);
-	KX_PYMETHOD(SCA_PythonController,GetScript);
-	KX_PYMETHOD(SCA_PythonController,GetState);
+	KX_PYMETHOD_DOC_NOARGS(SCA_PythonController,GetSensors);
+	KX_PYMETHOD_DOC_NOARGS(SCA_PythonController,GetActuators);
+	KX_PYMETHOD_DOC_O(SCA_PythonController,GetSensor);
+	KX_PYMETHOD_DOC_O(SCA_PythonController,GetActuator);
+	KX_PYMETHOD_O(SCA_PythonController,SetScript);
+	KX_PYMETHOD_NOARGS(SCA_PythonController,GetScript);
+	KX_PYMETHOD_NOARGS(SCA_PythonController,GetState);
 	
 
 };
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index 993e852a7ee..c4925cb772c 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -648,7 +648,6 @@ MT_Vector3 KX_GameObject::GetLinearVelocity(bool local)
 {
 	MT_Vector3 velocity(0.0,0.0,0.0), locvel;
 	MT_Matrix3x3 ori;
-	int i, j; 
 	if (m_pPhysicsController1)
 	{
 		velocity = m_pPhysicsController1->GetLinearVelocity();
@@ -668,7 +667,6 @@ MT_Vector3 KX_GameObject::GetAngularVelocity(bool local)
 {
 	MT_Vector3 velocity(0.0,0.0,0.0), locvel;
 	MT_Matrix3x3 ori;
-	int i, j; 
 	if (m_pPhysicsController1)
 	{
 		velocity = m_pPhysicsController1->GetAngularVelocity();
@@ -802,36 +800,37 @@ void KX_GameObject::Suspend(void)
 
 
 PyMethodDef KX_GameObject::Methods[] = {
-	{"setVisible",(PyCFunction) KX_GameObject::sPySetVisible, METH_VARARGS},  
-	{"getVisible",(PyCFunction) KX_GameObject::sPyGetVisible, METH_VARARGS},  
-	{"setState",(PyCFunction) KX_GameObject::sPySetState, METH_VARARGS},
-	{"getState",(PyCFunction) KX_GameObject::sPyGetState, METH_VARARGS},
-	{"alignAxisToVect",(PyCFunction) KX_GameObject::sPyAlignAxisToVect, METH_VARARGS},
-	{"setPosition", (PyCFunction) KX_GameObject::sPySetPosition, METH_VARARGS},
-	{"getPosition", (PyCFunction) KX_GameObject::sPyGetPosition, METH_VARARGS},
-	{"getOrientation", (PyCFunction) KX_GameObject::sPyGetOrientation, METH_VARARGS},
-	{"setOrientation", (PyCFunction) KX_GameObject::sPySetOrientation, METH_VARARGS},
+	{"getPosition", (PyCFunction) KX_GameObject::sPyGetPosition, METH_NOARGS},
+	{"setPosition", (PyCFunction) KX_GameObject::sPySetPosition, METH_O},
 	{"getLinearVelocity", (PyCFunction) KX_GameObject::sPyGetLinearVelocity, METH_VARARGS},
 	{"setLinearVelocity", (PyCFunction) KX_GameObject::sPySetLinearVelocity, METH_VARARGS},
 	{"getVelocity", (PyCFunction) KX_GameObject::sPyGetVelocity, METH_VARARGS},
-	{"getMass", (PyCFunction) KX_GameObject::sPyGetMass, METH_VARARGS},
-	{"getReactionForce", (PyCFunction) KX_GameObject::sPyGetReactionForce, METH_VARARGS},
+	{"getMass", (PyCFunction) KX_GameObject::sPyGetMass, METH_NOARGS},
+	{"getReactionForce", (PyCFunction) KX_GameObject::sPyGetReactionForce, METH_NOARGS},
+	{"getOrientation", (PyCFunction) KX_GameObject::sPyGetOrientation, METH_NOARGS},
+	{"setOrientation", (PyCFunction) KX_GameObject::sPySetOrientation, METH_O},
+	{"getVisible",(PyCFunction) KX_GameObject::sPyGetVisible, METH_NOARGS},
+	{"setVisible",(PyCFunction) KX_GameObject::sPySetVisible, METH_O},
+	{"getState",(PyCFunction) KX_GameObject::sPyGetState, METH_NOARGS},
+	{"setState",(PyCFunction) KX_GameObject::sPySetState, METH_O},
+	{"alignAxisToVect",(PyCFunction) KX_GameObject::sPyAlignAxisToVect, METH_VARARGS},
+	{"getAxisVect",(PyCFunction) KX_GameObject::sPyGetAxisVect, METH_O},
+	{"suspendDynamics", (PyCFunction)KX_GameObject::sPySuspendDynamics,METH_NOARGS},
+	{"restoreDynamics", (PyCFunction)KX_GameObject::sPyRestoreDynamics,METH_NOARGS},
+	{"enableRigidBody", (PyCFunction)KX_GameObject::sPyEnableRigidBody,METH_NOARGS},
+	{"disableRigidBody", (PyCFunction)KX_GameObject::sPyDisableRigidBody,METH_NOARGS},
 	{"applyImpulse", (PyCFunction) KX_GameObject::sPyApplyImpulse, METH_VARARGS},
-	{"setCollisionMargin", (PyCFunction) KX_GameObject::sPySetCollisionMargin, METH_VARARGS},
-	{"suspendDynamics", (PyCFunction)KX_GameObject::sPySuspendDynamics,METH_VARARGS},
-	{"restoreDynamics", (PyCFunction)KX_GameObject::sPyRestoreDynamics,METH_VARARGS},
-	{"enableRigidBody", (PyCFunction)KX_GameObject::sPyEnableRigidBody,METH_VARARGS},
-	{"disableRigidBody", (PyCFunction)KX_GameObject::sPyDisableRigidBody,METH_VARARGS},
-	{"getParent", (PyCFunction)KX_GameObject::sPyGetParent,METH_VARARGS},
-	{"setParent", (PyCFunction)KX_GameObject::sPySetParent,METH_VARARGS},
-	{"removeParent", (PyCFunction)KX_GameObject::sPyRemoveParent,METH_VARARGS},
+	{"setCollisionMargin", (PyCFunction) KX_GameObject::sPySetCollisionMargin, METH_O},
+	{"getParent", (PyCFunction)KX_GameObject::sPyGetParent,METH_NOARGS},
+	{"setParent", (PyCFunction)KX_GameObject::sPySetParent,METH_O},
+	{"removeParent", (PyCFunction)KX_GameObject::sPyRemoveParent,METH_NOARGS},
 	{"getMesh", (PyCFunction)KX_GameObject::sPyGetMesh,METH_VARARGS},
-	{"getPhysicsId", (PyCFunction)KX_GameObject::sPyGetPhysicsId,METH_VARARGS},
-	{"getPropertyNames", (PyCFunction)KX_GameObject::sPyGetPropertyNames,METH_VARARGS},
-	{"endObject",(PyCFunction) KX_GameObject::sPyEndObject, METH_VARARGS},
-	KX_PYMETHODTABLE(KX_GameObject, getDistanceTo),
+	{"getPhysicsId", (PyCFunction)KX_GameObject::sPyGetPhysicsId,METH_NOARGS},
+	{"getPropertyNames", (PyCFunction)KX_GameObject::sPyGetPropertyNames,METH_NOARGS},
+	{"endObject",(PyCFunction) KX_GameObject::sPyEndObject, METH_NOARGS},
 	KX_PYMETHODTABLE(KX_GameObject, rayCastTo),
 	KX_PYMETHODTABLE(KX_GameObject, rayCast),
+	KX_PYMETHODTABLE(KX_GameObject, getDistanceTo),
 	{NULL,NULL} //Sentinel
 };
 
@@ -853,18 +852,7 @@ bool KX_GameObject::ConvertPythonVectorArgs(PyObject* args,
 }
 */
 
-
-PyObject* KX_GameObject::sPySetPosition(PyObject* self,
-										PyObject* args,
-										PyObject* kwds)
-{
-	return ((KX_GameObject*) self)->PySetPosition(self, args, kwds);
-}
-	
-
-PyObject* KX_GameObject::PyEndObject(PyObject* self,
-									 PyObject* args, 
-									 PyObject* kwds)
+PyObject* KX_GameObject::PyEndObject(PyObject* self)
 {
 
 	KX_Scene *scene = PHY_GetActiveScene();
@@ -875,9 +863,7 @@ PyObject* KX_GameObject::PyEndObject(PyObject* self,
 }
 
 
-PyObject* KX_GameObject::PyGetPosition(PyObject* self,
-									   PyObject* args, 
-									   PyObject* kwds)
+PyObject* KX_GameObject::PyGetPosition(PyObject* self)
 {
 	return PyObjectFrom(NodeGetWorldPosition());
 }
@@ -931,7 +917,7 @@ PyObject* KX_GameObject::_getattr(const STR_String& attr)
 			parent->AddRef();
 			return parent;
 		}
-		Py_Return;
+		Py_RETURN_NONE;
 	}
 
 	if (attr == "visible")
@@ -982,7 +968,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 	{
 		MT_Scalar val = PyFloat_AsDouble(value);
 		if (attr == "timeOffset") {
-			if (m_pSGNode->GetSGParent()->IsSlowParent()) {
+			if (m_pSGNode->GetSGParent() && m_pSGNode->GetSGParent()->IsSlowParent()) {
 				static_cast<KX_SlowParentRelation *>(m_pSGNode->GetSGParent()->GetParentRelation())->SetTimeOffset(val);
 				return 0;
 			} else {
@@ -1103,68 +1089,57 @@ PyObject* KX_GameObject::PySetLinearVelocity(PyObject* self,
 		MT_Vector3 velocity;
 		if (PyVecTo(pyvect, velocity)) {
 			setLinearVelocity(velocity, (local!=0));
-			Py_Return;
+			Py_RETURN_NONE;
 		}
 	}
 	return NULL;
 }
 
-PyObject* KX_GameObject::PySetVisible(PyObject* self,
-									  PyObject* args,
-									  PyObject* kwds)
+PyObject* KX_GameObject::PySetVisible(PyObject* self, PyObject* value)
 {
-	int visible = 1;
+	int visible = PyInt_AsLong(value);
 	
-	if (PyArg_ParseTuple(args,"i",&visible))
-	{
-		MarkVisible(visible!=0);
-		m_bVisible = (visible!=0);
-	}
-	else
-	{
-		return NULL;	     
+	if (visible==-1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "expected 0 or 1");
+		return NULL;
 	}
-	Py_Return;
+	
+	MarkVisible(visible!=0);
+	m_bVisible = (visible!=0);
+	Py_RETURN_NONE;
 	
 }
 
-PyObject* KX_GameObject::PyGetVisible(PyObject* self,
-									  PyObject* args,
-									  PyObject* kwds)
+PyObject* KX_GameObject::PyGetVisible(PyObject* self)
 {
 	return PyInt_FromLong(m_bVisible);	
 }
 
-PyObject* KX_GameObject::PyGetState(PyObject* self,
-									  PyObject* args,
-									  PyObject* kwds)
+PyObject* KX_GameObject::PyGetState(PyObject* self)
 {
 	int state = 0;
 	state |= GetState();
 	return PyInt_FromLong(state);
 }
 
-PyObject* KX_GameObject::PySetState(PyObject* self,
-									  PyObject* args,
-									  PyObject* kwds)
+PyObject* KX_GameObject::PySetState(PyObject* self, PyObject* value)
 {
-	int state_i;
+	int state_i = PyInt_AsLong(value);
 	unsigned int state = 0;
 	
-	if (PyArg_ParseTuple(args,"i",&state_i))
-	{
-		state |= state_i;
-		if ((state & ((1<<30)-1)) == 0) {
-			PyErr_SetString(PyExc_AttributeError, "The state bitfield was not between 0 and 30 (1<<0 and 1<<29)");
-			return NULL;
-		}
-		SetState(state);
+	if (state_i == -1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "expected an int bit field");
+		return NULL;
 	}
-	else
-	{
-		return NULL;	     
+	
+	state |= state_i;
+	if ((state & ((1<<30)-1)) == 0) {
+		PyErr_SetString(PyExc_AttributeError, "The state bitfield was not between 0 and 30 (1<<0 and 1<<29)");
+		return NULL;
 	}
-	Py_Return;
+	SetState(state);
+	
+	Py_RETURN_NONE;
 }
 
 
@@ -1198,26 +1173,14 @@ PyObject* KX_GameObject::PyGetVelocity(PyObject* self,
 
 
 
-PyObject* KX_GameObject::PyGetMass(PyObject* self, 
-								   PyObject* args, 
-								   PyObject* kwds)
+PyObject* KX_GameObject::PyGetMass(PyObject* self)
 {
-	PyObject* pymass = NULL;
-	
-	float mass = GetPhysicsController()->GetMass();
-	pymass = PyFloat_FromDouble(mass);
-
-	if (pymass)
-		return pymass;
-	
-	Py_Return;
+	return PyFloat_FromDouble(GetPhysicsController()->GetMass());
 }
 
 
 
-PyObject* KX_GameObject::PyGetReactionForce(PyObject* self, 
-											PyObject* args, 
-											PyObject* kwds)
+PyObject* KX_GameObject::PyGetReactionForce(PyObject* self)
 {
 	// only can get the velocity if we have a physics object connected to us...
 	return PyObjectFrom(GetPhysicsController()->getReactionForce());
@@ -1225,32 +1188,25 @@ PyObject* KX_GameObject::PyGetReactionForce(PyObject* self,
 
 
 
-PyObject* KX_GameObject::PyEnableRigidBody(PyObject* self, 
-										   PyObject* args, 
-										   PyObject* kwds)
+PyObject* KX_GameObject::PyEnableRigidBody(PyObject* self)
 {
-	
 	GetPhysicsController()->setRigidBody(true);
 
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
 
 
-PyObject* KX_GameObject::PyDisableRigidBody(PyObject* self, 
-											PyObject* args, 
-											PyObject* kwds)
+PyObject* KX_GameObject::PyDisableRigidBody(PyObject* self)
 {
 	GetPhysicsController()->setRigidBody(false);
 
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
 
 
-PyObject* KX_GameObject::PyGetParent(PyObject* self, 
-									 PyObject* args, 
-									 PyObject* kwds)
+PyObject* KX_GameObject::PyGetParent(PyObject* self)
 {
 	KX_GameObject* parent = this->GetParent();
 	if (parent)
@@ -1258,37 +1214,31 @@ PyObject* KX_GameObject::PyGetParent(PyObject* self,
 		parent->AddRef();
 		return parent;
 	}
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
-PyObject* KX_GameObject::PySetParent(PyObject* self, 
-									 PyObject* args, 
-									 PyObject* kwds)
+PyObject* KX_GameObject::PySetParent(PyObject* self, PyObject* value)
 {
-	PyObject* gameobj;
-	if (PyArg_ParseTuple(args, "O!", &KX_GameObject::Type, &gameobj))
-	{
-		// The object we want to set as parent
-		CValue *m_ob = (CValue*)gameobj;
-		KX_GameObject *obj = ((KX_GameObject*)m_ob);
-		KX_Scene *scene = PHY_GetActiveScene();
-		
-		this->SetParent(scene, obj);
-	}
-	else {
+	if (!PyObject_TypeCheck(value, &KX_GameObject::Type)) {
+		PyErr_SetString(PyExc_TypeError, "expected a KX_GameObject type");
 		return NULL;
 	}
 	
-	Py_Return;
+	// The object we want to set as parent
+	CValue *m_ob = (CValue*)value;
+	KX_GameObject *obj = ((KX_GameObject*)m_ob);
+	KX_Scene *scene = PHY_GetActiveScene();
+	
+	this->SetParent(scene, obj);
+		
+	Py_RETURN_NONE;
 }
 
-PyObject* KX_GameObject::PyRemoveParent(PyObject* self, 
-									 PyObject* args, 
-									 PyObject* kwds)
+PyObject* KX_GameObject::PyRemoveParent(PyObject* self)
 {
 	KX_Scene *scene = PHY_GetActiveScene();
 	this->RemoveParent(scene);
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
 PyObject* KX_GameObject::PyGetMesh(PyObject* self, 
@@ -1312,21 +1262,21 @@ PyObject* KX_GameObject::PyGetMesh(PyObject* self,
 
 
 
-PyObject* KX_GameObject::PySetCollisionMargin(PyObject* self, 
-										PyObject* args, 
-										PyObject* kwds)
+PyObject* KX_GameObject::PySetCollisionMargin(PyObject* self, PyObject* value)
 {
-	float collisionMargin;
-	if (PyArg_ParseTuple(args, "f", &collisionMargin))
-	{
-		if (m_pPhysicsController1)
-		{
-			m_pPhysicsController1->setMargin(collisionMargin);
-			Py_Return;
-		}
-
+	float collisionMargin = PyFloat_AsDouble(value);
+	
+	if (collisionMargin==-1 && PyErr_Occurred()) {
+		PyErr_SetString(PyExc_TypeError, "expected a float");
+		return NULL;
 	}
 	
+	if (m_pPhysicsController1)
+	{
+		m_pPhysicsController1->setMargin(collisionMargin);
+		Py_RETURN_NONE;
+	}
+	PyErr_SetString(PyExc_RuntimeError, "This object has no physics controller");
 	return NULL;
 }
 
@@ -1338,17 +1288,20 @@ PyObject* KX_GameObject::PyApplyImpulse(PyObject* self,
 {
 	PyObject* pyattach;
 	PyObject* pyimpulse;
+	
+	if (!m_pPhysicsController1)	{
+		PyErr_SetString(PyExc_RuntimeError, "This object has no physics controller");
+		return NULL;
+	}
+	
 	if (PyArg_ParseTuple(args, "OO", &pyattach, &pyimpulse))
 	{
 		MT_Point3  attach;
 		MT_Vector3 impulse;
-		if (m_pPhysicsController1)
+		if (PyVecTo(pyattach, attach) && PyVecTo(pyimpulse, impulse))
 		{
-			if (PyVecTo(pyattach, attach) && PyVecTo(pyimpulse, impulse))
-			{
-				m_pPhysicsController1->applyImpulse(attach, impulse);
-				Py_Return;
-			}
+			m_pPhysicsController1->applyImpulse(attach, impulse);
+			Py_RETURN_NONE;
 		}
 
 	}
@@ -1358,59 +1311,46 @@ PyObject* KX_GameObject::PyApplyImpulse(PyObject* self,
 
 
 
-PyObject* KX_GameObject::PySuspendDynamics(PyObject* self, 
-										   PyObject* args, 
-										   PyObject* kwds)
+PyObject* KX_GameObject::PySuspendDynamics(PyObject* self)
 {
 	SuspendDynamics();
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
 
 
-PyObject* KX_GameObject::PyRestoreDynamics(PyObject* self, 
-										   PyObject* args, 
-										   PyObject* kwds)
+PyObject* KX_GameObject::PyRestoreDynamics(PyObject* self)
 {
 	RestoreDynamics();
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
 
 
-PyObject* KX_GameObject::PyGetOrientation(PyObject* self,
-										  PyObject* args,
-										  PyObject* kwds) //keywords
+PyObject* KX_GameObject::PyGetOrientation(PyObject* self) //keywords
 {
 	return PyObjectFrom(NodeGetWorldOrientation());
 }
 
 
 
-PyObject* KX_GameObject::PySetOrientation(PyObject* self, 
-										  PyObject* args, 
-										  PyObject* kwds)
+PyObject* KX_GameObject::PySetOrientation(PyObject* self, PyObject* value)
 {
-	PyObject* pylist;
-	
-	if (PyArg_ParseTuple(args,"O",&pylist))
+	MT_Matrix3x3 matrix;
+	if (PyObject_IsMT_Matrix(value, 3) && PyMatTo(value, matrix))
 	{
-		MT_Matrix3x3 matrix;
-		if (PyObject_IsMT_Matrix(pylist, 3) && PyMatTo(pylist, matrix))
-		{
-			NodeSetLocalOrientation(matrix);
-			NodeUpdateGS(0.f,true);
-			Py_Return;
-		}
-	
-		MT_Quaternion quat;
-		if (PyVecTo(pylist, quat))
-		{
-			matrix.setRotation(quat);
-			NodeSetLocalOrientation(matrix);
-			NodeUpdateGS(0.f,true);
-			Py_Return;
-		}
+		NodeSetLocalOrientation(matrix);
+		NodeUpdateGS(0.f,true);
+		Py_RETURN_NONE;
+	}
+
+	MT_Quaternion quat;
+	if (PyVecTo(value, quat))
+	{
+		matrix.setRotation(quat);
+		NodeSetLocalOrientation(matrix);
+		NodeUpdateGS(0.f,true);
+		Py_RETURN_NONE;
 	}
 	return NULL;
 }
@@ -1428,30 +1368,36 @@ PyObject* KX_GameObject::PyAlignAxisToVect(PyObject* self,
 		if (PyVecTo(pyvect, vect))
 		{
 			AlignAxisToVect(vect,axis);				
-			Py_Return;
+			Py_RETURN_NONE;
 		}
 	}
 	return NULL;
 }
 
-PyObject* KX_GameObject::PySetPosition(PyObject* self, 
-									   PyObject* args, 
-									   PyObject* kwds)
+PyObject* KX_GameObject::PyGetAxisVect(PyObject* self, PyObject* value)
+{
+	MT_Vector3 vect;
+	if (PyVecTo(value, vect))
+	{
+		return PyObjectFrom(vect * NodeGetWorldOrientation());
+	}
+	return NULL;
+}
+
+PyObject* KX_GameObject::PySetPosition(PyObject* self, PyObject* value)
 {
 	MT_Point3 pos;
-	if (PyVecArgTo(args, pos))
+	if (PyVecTo(value, pos))
 	{
 		NodeSetLocalPosition(pos);
 		NodeUpdateGS(0.f,true);
-		Py_Return;
+		Py_RETURN_NONE;
 	}
-	
+
 	return NULL;
 }
 
-PyObject* KX_GameObject::PyGetPhysicsId(PyObject* self,
-											   PyObject* args,
-											   PyObject* kwds)
+PyObject* KX_GameObject::PyGetPhysicsId(PyObject* self)
 {
 	KX_IPhysicsController* ctrl = GetPhysicsController();
 	uint_ptr physid=0;
@@ -1462,9 +1408,7 @@ PyObject* KX_GameObject::PyGetPhysicsId(PyObject* self,
 	return PyInt_FromLong((long)physid);
 }
 
-PyObject* KX_GameObject::PyGetPropertyNames(PyObject* self,
-											   PyObject* args,
-											   PyObject* kwds)
+PyObject* KX_GameObject::PyGetPropertyNames(PyObject* self)
 {
 	return ConvertKeysToPython();
 }
@@ -1563,7 +1507,7 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCastTo,
 		m_pHitObject->AddRef();
 		return m_pHitObject;
 	}
-	Py_Return;
+	Py_RETURN_NONE;
 }
 
 KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
@@ -1646,7 +1590,7 @@ KX_PYMETHODDEF_DOC(KX_GameObject, rayCast,
 		//	resultNormal[0], resultNormal[1], resultNormal[2]);
 	}
 	return Py_BuildValue("OOO", Py_None, Py_None, Py_None);
-	//Py_Return;
+	//Py_RETURN_NONE;
 }
 
 /* --------------------------------------------------------------------- 
diff --git a/source/gameengine/Ketsji/KX_GameObject.h b/source/gameengine/Ketsji/KX_GameObject.h
index 3a9abd2fc61..31b56df5368 100644
--- a/source/gameengine/Ketsji/KX_GameObject.h
+++ b/source/gameengine/Ketsji/KX_GameObject.h
@@ -696,47 +696,34 @@ public:
 		PyObject *value
 	);		// _setattr method
 
-		PyObject*					
-	PySetPosition(
-		PyObject* self,
-		PyObject* args,
-		PyObject* kwds
-	);
-
-	static 
-		PyObject*			
-	sPySetPosition(
-		PyObject* self,
-		PyObject* args,
-		PyObject* kwds
-	);
-
-	KX_PYMETHOD(KX_GameObject,GetPosition);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetPosition);
+	KX_PYMETHOD_O(KX_GameObject,SetPosition);
 	KX_PYMETHOD(KX_GameObject,GetLinearVelocity);
 	KX_PYMETHOD(KX_GameObject,SetLinearVelocity);
 	KX_PYMETHOD(KX_GameObject,GetVelocity);
-	KX_PYMETHOD(KX_GameObject,GetMass);
-	KX_PYMETHOD(KX_GameObject,GetReactionForce);
-	KX_PYMETHOD(KX_GameObject,GetOrientation);
-	KX_PYMETHOD(KX_GameObject,SetOrientation);
-	KX_PYMETHOD(KX_GameObject,GetVisible);
-	KX_PYMETHOD(KX_GameObject,SetVisible);
-	KX_PYMETHOD(KX_GameObject,GetState);
-	KX_PYMETHOD(KX_GameObject,SetState);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetMass);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetReactionForce);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetOrientation);
+	KX_PYMETHOD_O(KX_GameObject,SetOrientation);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetVisible);
+	KX_PYMETHOD_O(KX_GameObject,SetVisible);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetState);
+	KX_PYMETHOD_O(KX_GameObject,SetState);
 	KX_PYMETHOD(KX_GameObject,AlignAxisToVect);
-	KX_PYMETHOD(KX_GameObject,SuspendDynamics);
-	KX_PYMETHOD(KX_GameObject,RestoreDynamics);
-	KX_PYMETHOD(KX_GameObject,EnableRigidBody);
-	KX_PYMETHOD(KX_GameObject,DisableRigidBody);
+	KX_PYMETHOD_O(KX_GameObject,GetAxisVect);
+	KX_PYMETHOD_NOARGS(KX_GameObject,SuspendDynamics);
+	KX_PYMETHOD_NOARGS(KX_GameObject,RestoreDynamics);
+	KX_PYMETHOD_NOARGS(KX_GameObject,EnableRigidBody);
+	KX_PYMETHOD_NOARGS(KX_GameObject,DisableRigidBody);
 	KX_PYMETHOD(KX_GameObject,ApplyImpulse);
-	KX_PYMETHOD(KX_GameObject,SetCollisionMargin);
+	KX_PYMETHOD_O(KX_GameObject,SetCollisionMargin);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetParent);
+	KX_PYMETHOD_O(KX_GameObject,SetParent);
+	KX_PYMETHOD_NOARGS(KX_GameObject,RemoveParent);
 	KX_PYMETHOD(KX_GameObject,GetMesh);
-	KX_PYMETHOD(KX_GameObject,GetParent);
-	KX_PYMETHOD(KX_GameObject,SetParent);
-	KX_PYMETHOD(KX_GameObject,RemoveParent);
-	KX_PYMETHOD(KX_GameObject,GetPhysicsId);
-	KX_PYMETHOD(KX_GameObject,GetPropertyNames);
-	KX_PYMETHOD(KX_GameObject,EndObject);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetPhysicsId);
+	KX_PYMETHOD_NOARGS(KX_GameObject,GetPropertyNames);
+	KX_PYMETHOD_NOARGS(KX_GameObject,EndObject);
 	KX_PYMETHOD_DOC(KX_GameObject,rayCastTo);
 	KX_PYMETHOD_DOC(KX_GameObject,rayCast);
 	KX_PYMETHOD_DOC(KX_GameObject,getDistanceTo);
diff --git a/source/gameengine/PyDoc/KX_GameObject.py b/source/gameengine/PyDoc/KX_GameObject.py
index faadf61abb5..37c188b7f22 100644
--- a/source/gameengine/PyDoc/KX_GameObject.py
+++ b/source/gameengine/PyDoc/KX_GameObject.py
@@ -90,11 +90,22 @@ class KX_GameObject:
 					- 1: Y axis
 					- 2: Z axis (default) 
 		"""
+	def getAxisVect(vect):
+		"""
+		Returns the axis vector rotates by the objects worldspace orientation.
+		This is the equivalent if multiplying the vector by the orientation matrix.
+		
+		@type vect: 3d vector.
+		@param vect: a vector to align the axis.
+		@rtype: 3d vector.
+		@return: The vector in relation to the objects rotation.
+
+		"""
 	def getOrientation():
 		"""
 		Gets the game object's orientation.
 		
-		@rtype: 3x3 inverted rotation matrix
+		@rtype: 3x3 rotation matrix
 		@return: The game object's rotation matrix
 		@note: When using this matrix with Blender.Mathutils.Matrix() types, it will need to be transposed.
 		"""