Merge of itasc branch. Project files, scons and cmake should be working. Makefile updated but not tested. Comes with Eigen2 2.0.6 C++ matrix library.

60 files changed, 3581 insertions, 219 deletions

diff --git a/source/gameengine/Converter/BL_ActionActuator.cpp b/source/gameengine/Converter/BL_ActionActuator.cpp
index ca4290703e1..2f0e3e9fa65 100644
--- a/source/gameengine/Converter/BL_ActionActuator.cpp
+++ b/source/gameengine/Converter/BL_ActionActuator.cpp
@@ -526,12 +526,11 @@ KX_PYMETHODDEF_DOC(BL_ActionActuator, setChannel,
 		mat.setValue((const float *)matrix);
 		
 		BL_ArmatureObject *obj = (BL_ArmatureObject*)GetParent();
-		obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
 		
 		if (!m_userpose) {
 			if(!m_pose)
 				obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
-			game_copy_pose(&m_userpose, m_pose);
+			game_copy_pose(&m_userpose, m_pose, 0);
 		}
 		// pchan= verify_pose_channel(m_userpose, string); // adds the channel if its not there.
 		pchan= get_pose_channel(m_userpose, string); // adds the channel if its not there.
@@ -554,7 +553,7 @@ KX_PYMETHODDEF_DOC(BL_ActionActuator, setChannel,
 		if (!m_userpose) {
 			if(!m_pose)
 				obj->GetPose(&m_pose); /* Get the underlying pose from the armature */
-			game_copy_pose(&m_userpose, m_pose);
+			game_copy_pose(&m_userpose, m_pose, 0);
 		}
 		// pchan= verify_pose_channel(m_userpose, string);
 		pchan= get_pose_channel(m_userpose, string); // adds the channel if its not there.
@@ -572,7 +571,6 @@ KX_PYMETHODDEF_DOC(BL_ActionActuator, setChannel,
 		return NULL;
 	}
 	
-	pchan->flag |= POSE_ROT|POSE_LOC|POSE_SIZE;
 	Py_RETURN_NONE;
 }
 
diff --git a/source/gameengine/Converter/BL_ActionActuator.h b/source/gameengine/Converter/BL_ActionActuator.h
index a6b4c4a055d..2e0e38b4cc3 100644
--- a/source/gameengine/Converter/BL_ActionActuator.h
+++ b/source/gameengine/Converter/BL_ActionActuator.h
@@ -50,7 +50,7 @@ public:
 						short	priority,
 						short	end_reset,
 						float	stride) 
-		: SCA_IActuator(gameobj),
+		: SCA_IActuator(gameobj, KX_ACT_ACTION),
 		
 		m_lastpos(0, 0, 0),
 		m_blendframe(0),
diff --git a/source/gameengine/Converter/BL_ArmatureActuator.cpp b/source/gameengine/Converter/BL_ArmatureActuator.cpp
new file mode 100644
index 00000000000..741f1cf0553
--- /dev/null
+++ b/source/gameengine/Converter/BL_ArmatureActuator.cpp
@@ -0,0 +1,265 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "DNA_action_types.h"
+#include "DNA_constraint_types.h"
+#include "DNA_actuator_types.h"
+#include "BKE_constraint.h"
+#include "BLI_arithb.h"
+#include "BL_ArmatureActuator.h"
+#include "BL_ArmatureObject.h"
+
+/**
+ * This class is the conversion of the Pose channel constraint.
+ * It makes a link between the pose constraint and the KX scene.
+ * The main purpose is to give access to the constraint target 
+ * to link it to a game object. 
+ * It also allows to activate/deactivate constraints during the game.
+ * Later it will also be possible to create constraint on the fly
+ */
+
+BL_ArmatureActuator::BL_ArmatureActuator(SCA_IObject* obj,
+						int type,
+						const char *posechannel,
+						const char *constraintname,
+						KX_GameObject* targetobj,
+						KX_GameObject* subtargetobj,
+						float weight) :
+	SCA_IActuator(obj, KX_ACT_ARMATURE),
+	m_constraint(NULL),
+	m_gametarget(targetobj),
+	m_gamesubtarget(subtargetobj),
+	m_posechannel(posechannel),
+	m_constraintname(constraintname),
+	m_weight(weight),
+	m_type(type)
+{
+	if (m_gametarget)
+		m_gametarget->RegisterActuator(this);
+	if (m_gamesubtarget)
+		m_gamesubtarget->RegisterActuator(this);
+	FindConstraint();
+}
+
+BL_ArmatureActuator::~BL_ArmatureActuator()
+{
+	if (m_gametarget)
+		m_gametarget->UnregisterActuator(this);
+	if (m_gamesubtarget)
+		m_gamesubtarget->UnregisterActuator(this);
+}
+
+void BL_ArmatureActuator::ProcessReplica()
+{
+	// the replica is tracking the same object => register it (this may be changed in Relnk())
+	if (m_gametarget)
+		m_gametarget->RegisterActuator(this);
+	if (m_gamesubtarget)
+		m_gamesubtarget->UnregisterActuator(this);
+	SCA_IActuator::ProcessReplica();
+}
+
+void BL_ArmatureActuator::ReParent(SCA_IObject* parent)
+{
+	SCA_IActuator::ReParent(parent);
+	// must remap the constraint
+	FindConstraint();
+}
+
+bool BL_ArmatureActuator::UnlinkObject(SCA_IObject* clientobj)
+{
+	bool res=false;
+	if (clientobj == m_gametarget)
+	{
+		// this object is being deleted, we cannot continue to track it.
+		m_gametarget = NULL;
+		res = true;
+	}
+	if (clientobj == m_gamesubtarget)
+	{
+		// this object is being deleted, we cannot continue to track it.
+		m_gamesubtarget = NULL;
+		res = true;
+	}
+	return res;
+}
+
+void BL_ArmatureActuator::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_gametarget];
+	if (h_obj) {
+		if (m_gametarget)
+			m_gametarget->UnregisterActuator(this);
+		m_gametarget = (KX_GameObject*)(*h_obj);
+		m_gametarget->RegisterActuator(this);
+	}
+	h_obj = (*obj_map)[m_gamesubtarget];
+	if (h_obj) {
+		if (m_gamesubtarget)
+			m_gamesubtarget->UnregisterActuator(this);
+		m_gamesubtarget = (KX_GameObject*)(*h_obj);
+		m_gamesubtarget->RegisterActuator(this);
+	}
+}
+
+void BL_ArmatureActuator::FindConstraint()
+{
+	m_constraint = NULL;
+
+	if (m_gameobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE) {
+		BL_ArmatureObject* armobj = (BL_ArmatureObject*)m_gameobj;
+		m_constraint = armobj->GetConstraint(m_posechannel, m_constraintname);
+	}
+}
+
+bool BL_ArmatureActuator::Update(double curtime, bool frame)
+{
+	// the only role of this actuator is to ensure that the armature pose will be evaluated
+	bool result = false;	
+	bool bNegativeEvent = IsNegativeEvent();
+	RemoveAllEvents();
+
+	if (!bNegativeEvent) {
+		BL_ArmatureObject *obj = (BL_ArmatureObject*)GetParent();
+		switch (m_type) {
+		case ACT_ARM_RUN:
+			result = true;
+			obj->SetActiveAction(NULL, 0, curtime);
+			break;
+		case ACT_ARM_ENABLE:
+			if (m_constraint)
+				m_constraint->ClrConstraintFlag(CONSTRAINT_OFF);
+			break;
+		case ACT_ARM_DISABLE:
+			if (m_constraint)
+				m_constraint->SetConstraintFlag(CONSTRAINT_OFF);
+			break;
+		case ACT_ARM_SETTARGET:
+			if (m_constraint) {
+				m_constraint->SetTarget(m_gametarget);
+				m_constraint->SetSubtarget(m_gamesubtarget);
+			}
+			break;
+		case ACT_ARM_SETWEIGHT:
+			if (m_constraint)
+				m_constraint->SetWeight(m_weight);
+			break;
+		}
+	}
+	return result;
+}
+
+/* ------------------------------------------------------------------------- */
+/* Python Integration Hooks					                                 */
+/* ------------------------------------------------------------------------- */
+
+PyTypeObject BL_ArmatureActuator::Type = {
+#if (PY_VERSION_HEX >= 0x02060000)
+	PyVarObject_HEAD_INIT(NULL, 0)
+#else
+	/* python 2.5 and below */
+	PyObject_HEAD_INIT( NULL )  /* required py macro */
+	0,                          /* ob_size */
+#endif
+		"BL_ArmatureActuator",
+		sizeof(PyObjectPlus_Proxy),
+		0,
+		py_base_dealloc,
+		0,
+		0,
+		0,
+		0,
+		py_base_repr,
+		0,0,0,0,0,0,0,0,0,
+		Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+		0,0,0,0,0,0,0,
+		Methods,
+		0,
+		0,
+		&SCA_IActuator::Type,
+		0,0,0,0,0,0,
+		py_base_new
+};
+
+
+PyMethodDef BL_ArmatureActuator::Methods[] = {
+	{NULL,NULL} //Sentinel
+};
+
+PyAttributeDef BL_ArmatureActuator::Attributes[] = {
+	KX_PYATTRIBUTE_RO_FUNCTION("constraint", BL_ArmatureActuator, pyattr_get_constraint),
+	KX_PYATTRIBUTE_RW_FUNCTION("target", BL_ArmatureActuator, pyattr_get_object, pyattr_set_object),
+	KX_PYATTRIBUTE_RW_FUNCTION("subtarget", BL_ArmatureActuator, pyattr_get_object, pyattr_set_object),
+	KX_PYATTRIBUTE_FLOAT_RW("weight",0.0f,1.0f,BL_ArmatureActuator,m_weight),
+	KX_PYATTRIBUTE_INT_RW("type",0,ACT_ARM_MAXTYPE,false,BL_ArmatureActuator,m_type),
+	{ NULL }	//Sentinel
+};
+
+PyObject* BL_ArmatureActuator::pyattr_get_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ArmatureActuator* actuator = static_cast<BL_ArmatureActuator*>(self);
+	KX_GameObject *target = (!strcmp(attrdef->m_name, "target")) ? actuator->m_gametarget : actuator->m_gamesubtarget;
+	if (!target)	
+		Py_RETURN_NONE;
+	else
+		return target->GetProxy();
+}
+
+int BL_ArmatureActuator::pyattr_set_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	BL_ArmatureActuator* actuator = static_cast<BL_ArmatureActuator*>(self);
+	KX_GameObject* &target = (!strcmp(attrdef->m_name, "target")) ? actuator->m_gametarget : actuator->m_gamesubtarget;
+	KX_GameObject *gameobj;
+		
+	if (!ConvertPythonToGameObject(value, &gameobj, true, "actuator.object = value: BL_ArmatureActuator"))
+		return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error
+		
+	if (target != NULL)
+		target->UnregisterActuator(actuator);	
+
+	target = gameobj;
+		
+	if (target)
+		target->RegisterActuator(actuator);
+		
+	return PY_SET_ATTR_SUCCESS;
+}
+
+PyObject* BL_ArmatureActuator::pyattr_get_constraint(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ArmatureActuator* actuator = static_cast<BL_ArmatureActuator*>(self);
+	BL_ArmatureConstraint* constraint = actuator->m_constraint;
+	if (!constraint)	
+		Py_RETURN_NONE;
+	else
+		return constraint->GetProxy();
+}
+
+
+
diff --git a/source/gameengine/Converter/BL_ArmatureActuator.h b/source/gameengine/Converter/BL_ArmatureActuator.h
new file mode 100644
index 00000000000..5a7752b8169
--- /dev/null
+++ b/source/gameengine/Converter/BL_ArmatureActuator.h
@@ -0,0 +1,89 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef BL_ARMATUREACTUATOR
+#define BL_ARMATUREACTUATOR
+
+#include "SCA_IActuator.h"
+#include "BL_ArmatureConstraint.h"
+
+/**
+ * This class is the conversion of the Pose channel constraint.
+ * It makes a link between the pose constraint and the KX scene.
+ * The main purpose is to give access to the constraint target 
+ * to link it to a game object. 
+ * It also allows to activate/deactivate constraints during the game.
+ * Later it will also be possible to create constraint on the fly
+ */
+
+class	BL_ArmatureActuator : public SCA_IActuator
+{
+	Py_Header;
+public:
+	BL_ArmatureActuator(SCA_IObject* gameobj,
+						int type,
+						const char *posechannel,
+						const char *constraintname,
+						KX_GameObject* targetobj,
+						KX_GameObject* subtargetobj,
+						float weight);
+
+	virtual ~BL_ArmatureActuator();
+
+	virtual CValue* GetReplica() {
+		BL_ArmatureActuator* replica = new BL_ArmatureActuator(*this);
+		replica->ProcessReplica();
+		return replica;
+	};
+	virtual void ProcessReplica();
+	virtual bool UnlinkObject(SCA_IObject* clientobj);
+	virtual void Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
+	virtual bool Update(double curtime, bool frame);
+	virtual void ReParent(SCA_IObject* parent);
+	
+	/* These are used to get and set m_target */
+	static PyObject* pyattr_get_constraint(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+	static PyObject* pyattr_get_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+	static int pyattr_set_object(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+
+private:
+	// identify the constraint that this actuator controls
+	void FindConstraint();
+
+	BL_ArmatureConstraint*	m_constraint;
+	KX_GameObject*	m_gametarget;
+	KX_GameObject*	m_gamesubtarget;
+	STR_String		m_posechannel;
+	STR_String		m_constraintname;
+	float			m_weight;
+	int				m_type;
+};
+
+#endif //BL_ARMATUREACTUATOR
+
+
diff --git a/source/gameengine/Converter/BL_ArmatureChannel.cpp b/source/gameengine/Converter/BL_ArmatureChannel.cpp
new file mode 100644
index 00000000000..c0afeb008f6
--- /dev/null
+++ b/source/gameengine/Converter/BL_ArmatureChannel.cpp
@@ -0,0 +1,461 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "DNA_armature_types.h"
+#include "BL_ArmatureChannel.h"
+#include "BL_ArmatureObject.h"
+#include "BL_ArmatureConstraint.h"
+#include "BLI_arithb.h"
+#include "BLI_string.h"
+
+PyTypeObject BL_ArmatureChannel::Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"BL_ArmatureChannel",
+	sizeof(PyObjectPlus_Proxy),
+	0,
+	py_base_dealloc,
+	0,
+	0,
+	0,
+	0,
+	py_base_repr,
+	0,0,0,0,0,0,0,0,0,
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	0,0,0,0,0,0,0,
+	Methods,
+	0,
+	0,
+	&CValue::Type,
+	0,0,0,0,0,0,
+	py_base_new
+};
+
+PyObject* BL_ArmatureChannel::py_repr(void)
+{
+	return PyUnicode_FromString(m_posechannel->name);
+}
+
+PyObject *BL_ArmatureChannel::GetProxy()
+{
+	return GetProxyPlus_Ext(this, &Type, m_posechannel);
+}
+
+PyObject *BL_ArmatureChannel::NewProxy(bool py_owns)
+{
+	return NewProxyPlus_Ext(this, &Type, m_posechannel, py_owns);
+}
+
+BL_ArmatureChannel::BL_ArmatureChannel(
+	BL_ArmatureObject *armature, 
+	bPoseChannel *posechannel)
+	: PyObjectPlus(), m_posechannel(posechannel), m_armature(armature)
+{
+}
+
+BL_ArmatureChannel::~BL_ArmatureChannel()
+{
+}
+
+// PYTHON
+
+PyMethodDef BL_ArmatureChannel::Methods[] = {
+  {NULL,NULL} //Sentinel
+};
+
+// order of definition of attributes, must match Attributes[] array
+#define BCA_BONE		0
+#define BCA_PARENT		1
+
+PyAttributeDef BL_ArmatureChannel::Attributes[] = {
+	// Keep these attributes in order of BCA_ defines!!! used by py_attr_getattr and py_attr_setattr
+	KX_PYATTRIBUTE_RO_FUNCTION("bone",BL_ArmatureChannel,py_attr_getattr),	
+	KX_PYATTRIBUTE_RO_FUNCTION("parent",BL_ArmatureChannel,py_attr_getattr),	
+	
+	{ NULL }	//Sentinel
+};
+
+/* attributes directly taken from bPoseChannel */
+PyAttributeDef BL_ArmatureChannel::AttributesPtr[] = {
+	KX_PYATTRIBUTE_CHAR_RO("name",bPoseChannel,name),
+	KX_PYATTRIBUTE_FLAG_RO("has_ik",bPoseChannel,flag, POSE_CHAIN),
+	KX_PYATTRIBUTE_FLAG_NEGATIVE_RO("ik_dof_x",bPoseChannel,ikflag, BONE_IK_NO_XDOF),
+	KX_PYATTRIBUTE_FLAG_NEGATIVE_RO("ik_dof_y",bPoseChannel,ikflag, BONE_IK_NO_YDOF),
+	KX_PYATTRIBUTE_FLAG_NEGATIVE_RO("ik_dof_z",bPoseChannel,ikflag, BONE_IK_NO_ZDOF),
+	KX_PYATTRIBUTE_FLAG_RO("ik_limit_x",bPoseChannel,ikflag, BONE_IK_XLIMIT),
+	KX_PYATTRIBUTE_FLAG_RO("ik_limit_y",bPoseChannel,ikflag, BONE_IK_YLIMIT),
+	KX_PYATTRIBUTE_FLAG_RO("ik_limit_z",bPoseChannel,ikflag, BONE_IK_ZLIMIT),
+	KX_PYATTRIBUTE_FLAG_RO("ik_rot_control",bPoseChannel,ikflag, BONE_IK_ROTCTL),
+	KX_PYATTRIBUTE_FLAG_RO("ik_lin_control",bPoseChannel,ikflag, BONE_IK_LINCTL),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RW("location",-FLT_MAX,FLT_MAX,bPoseChannel,loc,3),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RW("scale",-FLT_MAX,FLT_MAX,bPoseChannel,size,3),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RW("rotation",-1.0f,1.0f,bPoseChannel,quat,4),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RW("euler_rotation",-10.f,10.f,bPoseChannel,eul,3),
+	KX_PYATTRIBUTE_SHORT_RW("rotation_mode",0,PCHAN_ROT_MAX-1,false,bPoseChannel,rotmode),
+	KX_PYATTRIBUTE_FLOAT_MATRIX_RO("channel_matrix",bPoseChannel,chan_mat,4),
+	KX_PYATTRIBUTE_FLOAT_MATRIX_RO("pose_matrix",bPoseChannel,pose_mat,4),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RO("pose_head",bPoseChannel,pose_head,3),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RO("pose_tail",bPoseChannel,pose_tail,3),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_min_x",bPoseChannel,limitmin[0]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_max_x",bPoseChannel,limitmax[0]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_min_y",bPoseChannel,limitmin[1]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_max_y",bPoseChannel,limitmax[1]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_min_z",bPoseChannel,limitmin[2]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_max_z",bPoseChannel,limitmax[2]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_stiffness_x",bPoseChannel,stiffness[0]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_stiffness_y",bPoseChannel,stiffness[1]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_stiffness_z",bPoseChannel,stiffness[2]),
+	KX_PYATTRIBUTE_FLOAT_RO("ik_stretch",bPoseChannel,ikstretch),
+	KX_PYATTRIBUTE_FLOAT_RW("ik_rot_weight",0,1.0f,bPoseChannel,ikrotweight),
+	KX_PYATTRIBUTE_FLOAT_RW("ik_lin_weight",0,1.0f,bPoseChannel,iklinweight),
+	KX_PYATTRIBUTE_RW_FUNCTION("joint_rotation",BL_ArmatureChannel,py_attr_get_joint_rotation,py_attr_set_joint_rotation),
+	{ NULL }	//Sentinel
+};
+
+PyObject* BL_ArmatureChannel::py_attr_getattr(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ArmatureChannel* self= static_cast<BL_ArmatureChannel*>(self_v);
+	bPoseChannel* channel = self->m_posechannel;
+	int attr_order = attrdef-Attributes;
+
+	if (!channel) {
+		PyErr_SetString(PyExc_AttributeError, "channel is NULL");
+		return NULL;
+	}
+
+	switch (attr_order) {
+	case BCA_BONE:
+		// bones are standalone proxy
+		return NewProxyPlus_Ext(NULL,&BL_ArmatureBone::Type,channel->bone,false);
+	case BCA_PARENT:
+		{
+			BL_ArmatureChannel* parent = self->m_armature->GetChannel(channel->parent);
+			if (parent)
+				return parent->GetProxy();
+			else
+				Py_RETURN_NONE;
+		}
+	}
+	PyErr_SetString(PyExc_AttributeError, "channel unknown attribute");
+	return NULL;
+}
+
+int BL_ArmatureChannel::py_attr_setattr(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	BL_ArmatureChannel* self= static_cast<BL_ArmatureChannel*>(self_v);
+	bPoseChannel* channel = self->m_posechannel;
+	int attr_order = attrdef-Attributes;
+
+	int ival;
+	double dval;
+	char* sval;
+	KX_GameObject *oval;
+
+	if (!channel) {
+		PyErr_SetString(PyExc_AttributeError, "channel is NULL");
+		return PY_SET_ATTR_FAIL;
+	}
+	
+	switch (attr_order) {
+	default:
+		break;
+	}
+
+	PyErr_SetString(PyExc_AttributeError, "channel unknown attribute");
+	return PY_SET_ATTR_FAIL;
+}
+
+PyObject* BL_ArmatureChannel::py_attr_get_joint_rotation(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ArmatureChannel* self= static_cast<BL_ArmatureChannel*>(self_v);
+	bPoseChannel* pchan = self->m_posechannel;
+	// decompose the pose matrix in euler rotation
+	float rest_mat[3][3];
+	float pose_mat[3][3];
+	float joint_mat[3][3];
+	float joints[3];
+	float norm;
+	double sa, ca;
+	// get rotation in armature space
+	Mat3CpyMat4(pose_mat, pchan->pose_mat);
+	Mat3Ortho(pose_mat);
+	if (pchan->parent) {
+		// bone has a parent, compute the rest pose of the bone taking actual pose of parent
+		Mat3IsMat3MulMat4(rest_mat, pchan->bone->bone_mat, pchan->parent->pose_mat);
+		Mat3Ortho(rest_mat);
+	} else {
+		// otherwise, the bone matrix in armature space is the rest pose
+		Mat3CpyMat4(rest_mat, pchan->bone->arm_mat);
+	}
+	// remove the rest pose to get the joint movement
+	Mat3Transp(rest_mat);
+	Mat3MulMat3(joint_mat, rest_mat, pose_mat);		
+	joints[0] = joints[1] = joints[2] = 0.f;
+	// returns a 3 element list that gives corresponding joint
+	int flag = 0;
+	if (!(pchan->ikflag & BONE_IK_NO_XDOF))
+		flag |= 1;
+	if (!(pchan->ikflag & BONE_IK_NO_YDOF))
+		flag |= 2;
+	if (!(pchan->ikflag & BONE_IK_NO_ZDOF))
+		flag |= 4;
+	switch (flag) {
+	case 0:	// fixed joint
+		break;
+	case 1:	// X only
+		Mat3ToEulO(joint_mat, joints, EULER_ORDER_XYZ);
+		joints[1] = joints[2] = 0.f;
+		break;
+	case 2:	// Y only
+		Mat3ToEulO(joint_mat, joints, EULER_ORDER_XYZ);
+		joints[0] = joints[2] = 0.f;
+		break;
+	case 3:	// X+Y
+		Mat3ToEulO(joint_mat, joints, EULER_ORDER_ZYX);
+		joints[2] = 0.f;
+		break;
+	case 4:	// Z only
+		Mat3ToEulO(joint_mat, joints, EULER_ORDER_XYZ);
+		joints[0] = joints[1] = 0.f;
+		break;
+	case 5:	// X+Z
+		// decompose this as an equivalent rotation vector in X/Z plane
+		joints[0] = joint_mat[1][2];
+		joints[2] = -joint_mat[1][0];
+		norm = Normalize(joints);
+		if (norm < FLT_EPSILON) {
+			norm = (joint_mat[1][1] < 0.f) ? M_PI : 0.f;
+		} else {
+			norm = acos(joint_mat[1][1]);
+		}
+		VecMulf(joints, norm);
+		break;
+	case 6:	// Y+Z
+		Mat3ToEulO(joint_mat, joints, EULER_ORDER_XYZ);
+		joints[0] = 0.f;
+		break;
+	case 7: // X+Y+Z
+		// equivalent axis
+		joints[0] = (joint_mat[1][2]-joint_mat[2][1])*0.5f;
+		joints[1] = (joint_mat[2][0]-joint_mat[0][2])*0.5f;
+		joints[2] = (joint_mat[0][1]-joint_mat[1][0])*0.5f;
+		sa = VecLength(joints);
+		ca = (joint_mat[0][0]+joint_mat[1][1]+joint_mat[1][1]-1.0f)*0.5f;
+		if (sa > FLT_EPSILON) {
+			norm = atan2(sa,ca)/sa;
+		} else {
+		   if (ca < 0.0) {
+			   norm = M_PI;
+			   VecMulf(joints,0.f);
+			   if (joint_mat[0][0] > 0.f) {
+				   joints[0] = 1.0f;
+			   } else if (joint_mat[1][1] > 0.f) {
+				   joints[1] = 1.0f;
+			   } else {
+				   joints[2] = 1.0f;
+			   }
+		   } else {
+			   norm = 0.0;
+		   }
+		}
+		VecMulf(joints,norm);
+		break;
+	}
+	return newVectorObject(joints, 3, Py_NEW, NULL);
+}
+
+int BL_ArmatureChannel::py_attr_set_joint_rotation(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	BL_ArmatureChannel* self= static_cast<BL_ArmatureChannel*>(self_v);
+	bPoseChannel* pchan = self->m_posechannel;
+	PyObject *item;
+	float joints[3];
+	float quat[4];
+
+	if (!PySequence_Check(value) || PySequence_Size(value) != 3) {
+		PyErr_SetString(PyExc_AttributeError, "expected a sequence of [3] floats");
+		return PY_SET_ATTR_FAIL;
+	}
+	for (int i=0; i<3; i++) {
+		item = PySequence_GetItem(value, i); /* new ref */
+		joints[i] = PyFloat_AsDouble(item);
+		Py_DECREF(item);
+		if (joints[i] == -1.0f && PyErr_Occurred()) {
+			PyErr_SetString(PyExc_AttributeError, "expected a sequence of [3] floats");
+			return PY_SET_ATTR_FAIL;
+		}
+	}
+
+	int flag = 0;
+	if (!(pchan->ikflag & BONE_IK_NO_XDOF))
+		flag |= 1;
+	if (!(pchan->ikflag & BONE_IK_NO_YDOF))
+		flag |= 2;
+	if (!(pchan->ikflag & BONE_IK_NO_ZDOF))
+		flag |= 4;
+	QuatOne(quat);
+	switch (flag) {
+	case 0:	// fixed joint
+		break;
+	case 1:	// X only
+		joints[1] = joints[2] = 0.f;
+		EulOToQuat(joints, EULER_ORDER_XYZ, quat);
+		break;
+	case 2:	// Y only
+		joints[0] = joints[2] = 0.f;
+		EulOToQuat(joints, EULER_ORDER_XYZ, quat);
+		break;
+	case 3:	// X+Y
+		joints[2] = 0.f;
+		EulOToQuat(joints, EULER_ORDER_ZYX, quat);
+		break;
+	case 4:	// Z only
+		joints[0] = joints[1] = 0.f;
+		EulOToQuat(joints, EULER_ORDER_XYZ, quat);
+		break;
+	case 5:	// X+Z
+		// X and Z are components of an equivalent rotation axis
+		joints[1] = 0;
+		VecRotToQuat(joints, VecLength(joints), quat);
+		break;
+	case 6:	// Y+Z
+		joints[0] = 0.f;
+		EulOToQuat(joints, EULER_ORDER_XYZ, quat);
+		break;
+	case 7: // X+Y+Z
+		// equivalent axis
+		VecRotToQuat(joints, VecLength(joints), quat);
+		break;
+	}
+	if (pchan->rotmode > 0) {
+		QuatToEulO(quat, joints, pchan->rotmode);
+		VecCopyf(pchan->eul, joints);
+	} else
+		QuatCopy(pchan->quat, quat);
+	return PY_SET_ATTR_SUCCESS;
+}
+
+// *************************
+// BL_ArmatureBone
+//
+// Access to Bone structure
+PyTypeObject BL_ArmatureBone::Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"BL_ArmatureBone",
+	sizeof(PyObjectPlus_Proxy),
+	0,
+	py_base_dealloc,
+	0,
+	0,
+	0,
+	0,
+	py_bone_repr,
+	0,0,0,0,0,0,0,0,0,
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	0,0,0,0,0,0,0,
+	Methods,
+	0,
+	0,
+	&CValue::Type,
+	0,0,0,0,0,0,
+	py_base_new
+};
+
+// not used since this class is never instantiated
+PyObject *BL_ArmatureBone::GetProxy() 
+{ 
+	return NULL; 
+}
+PyObject *BL_ArmatureBone::NewProxy(bool py_owns) 
+{ 
+	return NULL; 
+}
+
+PyObject *BL_ArmatureBone::py_bone_repr(PyObject *self)
+{
+	Bone* bone = static_cast<Bone*>BGE_PROXY_PTR(self);
+	return PyUnicode_FromString(bone->name);
+}
+
+PyMethodDef BL_ArmatureBone::Methods[] = {
+	{NULL,NULL} //Sentinel
+};
+
+/* no attributes on C++ class since it is never instantiated */
+PyAttributeDef BL_ArmatureBone::Attributes[] = {
+	{ NULL }	//Sentinel
+};
+
+// attributes that work on proxy ptr (points to a Bone structure)
+PyAttributeDef BL_ArmatureBone::AttributesPtr[] = {
+	KX_PYATTRIBUTE_CHAR_RO("name",Bone,name),
+	KX_PYATTRIBUTE_FLAG_RO("connected",Bone,flag, BONE_CONNECTED),
+	KX_PYATTRIBUTE_FLAG_RO("hinge",Bone,flag, BONE_HINGE),
+	KX_PYATTRIBUTE_FLAG_NEGATIVE_RO("inherit_scale",Bone,flag, BONE_NO_SCALE),
+	KX_PYATTRIBUTE_SHORT_RO("bbone_segments",Bone,segments),
+	KX_PYATTRIBUTE_FLOAT_RO("roll",Bone,roll),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RO("head",Bone,head,3),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RO("tail",Bone,tail,3),
+	KX_PYATTRIBUTE_FLOAT_RO("length",Bone,length),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RO("arm_head",Bone,arm_head,3),
+	KX_PYATTRIBUTE_FLOAT_VECTOR_RO("arm_tail",Bone,arm_tail,3),
+	KX_PYATTRIBUTE_FLOAT_MATRIX_RO("arm_mat",Bone,arm_mat,4),
+	KX_PYATTRIBUTE_FLOAT_MATRIX_RO("bone_mat",Bone,bone_mat,4),
+	KX_PYATTRIBUTE_RO_FUNCTION("parent",BL_ArmatureBone,py_bone_get_parent),
+	KX_PYATTRIBUTE_RO_FUNCTION("children",BL_ArmatureBone,py_bone_get_parent),
+	{ NULL }	//Sentinel
+};
+
+PyObject *BL_ArmatureBone::py_bone_get_parent(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	Bone* bone = reinterpret_cast<Bone*>BGE_PROXY_PTR(self);
+	if (bone->parent) {
+		// create a proxy unconnected to any GE object
+		return NewProxyPlus_Ext(NULL,&Type,bone->parent,false);
+	}
+	Py_RETURN_NONE;
+}
+
+PyObject *BL_ArmatureBone::py_bone_get_children(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	Bone* bone = reinterpret_cast<Bone*>BGE_PROXY_PTR(self);
+	Bone* child;
+	int count = 0;
+	for (child=(Bone*)bone->childbase.first; child; child=(Bone*)child->next)
+		count++;
+
+	PyObject* childrenlist = PyList_New(count);
+
+	for (count = 0, child=(Bone*)bone->childbase.first; child; child=(Bone*)child->next, ++count)
+		PyList_SET_ITEM(childrenlist,count,NewProxyPlus_Ext(NULL,&Type,child,false));
+
+	return childrenlist;
+}
diff --git a/source/gameengine/Converter/BL_ArmatureChannel.h b/source/gameengine/Converter/BL_ArmatureChannel.h
new file mode 100644
index 00000000000..0f0f5a062e0
--- /dev/null
+++ b/source/gameengine/Converter/BL_ArmatureChannel.h
@@ -0,0 +1,91 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef __BL_ARMATURECHANNEL
+#define __BL_ARMATURECHANNEL
+
+#include "DNA_action_types.h"
+#include "GEN_HashedPtr.h"
+#include "GEN_Map.h"
+#include "PyObjectPlus.h"
+
+class SCA_IObject;
+class KX_GameObject;
+class BL_ArmatureObject;
+struct bConstraint;
+struct bPoseChannel;
+struct Object;
+struct bPose;
+
+class BL_ArmatureChannel : public PyObjectPlus
+{
+	// use Py_HeaderPtr since we use generic pointer in proxy
+	Py_HeaderPtr;
+
+private:
+	friend class BL_ArmatureObject;
+	struct bPoseChannel* m_posechannel;
+	BL_ArmatureObject* m_armature;
+
+public:
+	BL_ArmatureChannel(class BL_ArmatureObject *armature, 
+						struct bPoseChannel *posechannel);
+	virtual ~BL_ArmatureChannel();
+
+	virtual PyObject* py_repr(void);
+
+	// Python access
+	static PyObject* py_attr_getattr(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+	static int py_attr_setattr(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+	static PyObject* py_attr_get_joint_rotation(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+	static int py_attr_set_joint_rotation(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+
+};
+
+/* this is a factory class to access bBone data field in the GE.
+   It's not supposed to be instantiated, we only need it for the Attributes and Method array.
+   The actual proxy object will be manually created using NewProxyPtr */
+class BL_ArmatureBone : public PyObjectPlus
+{
+	// use Py_HeaderPtr since we use generic pointer in proxy
+	Py_HeaderPtr;
+private:
+	// make constructor private to make sure no one tries to instantiate this class
+	BL_ArmatureBone() {}
+	virtual ~BL_ArmatureBone() {}
+
+public:
+	static PyObject *py_bone_repr(PyObject *self);
+	static PyObject *py_bone_get_parent(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+	static PyObject *py_bone_get_children(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+
+};
+
+
+#endif //__BL_ARMATURECHANNEL
+
diff --git a/source/gameengine/Converter/BL_ArmatureConstraint.cpp b/source/gameengine/Converter/BL_ArmatureConstraint.cpp
new file mode 100644
index 00000000000..15e12611483
--- /dev/null
+++ b/source/gameengine/Converter/BL_ArmatureConstraint.cpp
@@ -0,0 +1,447 @@
+/**
+ * $Id$
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "DNA_constraint_types.h"
+#include "DNA_action_types.h"
+#include "BL_ArmatureConstraint.h"
+#include "BL_ArmatureObject.h"
+#include "BLI_arithb.h"
+#include "BLI_string.h"
+
+PyTypeObject BL_ArmatureConstraint::Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"BL_ArmatureConstraint",
+	sizeof(PyObjectPlus_Proxy),
+	0,
+	py_base_dealloc,
+	0,
+	0,
+	0,
+	0,
+	py_base_repr,
+	0,0,0,0,0,0,0,0,0,
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	0,0,0,0,0,0,0,
+	Methods,
+	0,
+	0,
+	&CValue::Type,
+	0,0,0,0,0,0,
+	py_base_new
+};
+
+PyObject* BL_ArmatureConstraint::py_repr(void)
+{
+	return PyUnicode_FromString(m_name);
+}
+
+BL_ArmatureConstraint::BL_ArmatureConstraint(
+	BL_ArmatureObject *armature, 
+	bPoseChannel *posechannel,
+	bConstraint *constraint, 
+	KX_GameObject* target,
+	KX_GameObject* subtarget)
+	: PyObjectPlus(), m_armature(armature), m_constraint(constraint), m_posechannel(posechannel)
+{
+	m_target = target;
+	m_blendtarget = (target) ? target->GetBlenderObject() : NULL;
+	m_subtarget = subtarget;
+	m_blendsubtarget = (subtarget) ? subtarget->GetBlenderObject() : NULL;
+	m_pose = m_subpose = NULL;
+	if (m_blendtarget) {
+		Mat4CpyMat4(m_blendmat, m_blendtarget->obmat);
+		if (m_blendtarget->type == OB_ARMATURE)
+			m_pose = m_blendtarget->pose;
+	}
+	if (m_blendsubtarget) {
+		Mat4CpyMat4(m_blendsubmat, m_blendsubtarget->obmat);
+		if (m_blendsubtarget->type == OB_ARMATURE)
+			m_subpose = m_blendsubtarget->pose;
+	}
+	if (m_target)
+		m_target->RegisterObject(m_armature);
+	if (m_subtarget)
+		m_subtarget->RegisterObject(m_armature);
+	BLI_snprintf(m_name, sizeof(m_name), "%s:%s", m_posechannel->name, m_constraint->name);
+}
+
+BL_ArmatureConstraint::~BL_ArmatureConstraint()
+{
+	if (m_target)
+		m_target->UnregisterObject(m_armature);
+	if (m_subtarget)
+		m_subtarget->UnregisterObject(m_armature);
+}
+
+BL_ArmatureConstraint* BL_ArmatureConstraint::GetReplica() const
+{
+	BL_ArmatureConstraint* replica = new BL_ArmatureConstraint(*this);
+	replica->ProcessReplica();
+	return replica;
+}
+
+void BL_ArmatureConstraint::ReParent(BL_ArmatureObject* armature)
+{
+	m_armature = armature;
+	if (m_target)
+		m_target->RegisterObject(armature);
+	if (m_subtarget)
+		m_subtarget->RegisterObject(armature);
+	// find the corresponding constraint in the new armature object
+	if (m_constraint) {
+		bPose* newpose = armature->GetOrigPose();
+		char* constraint = m_constraint->name;
+		char* posechannel = m_posechannel->name;
+		bPoseChannel* pchan;
+		bConstraint* pcon;
+		m_constraint = NULL;
+		m_posechannel = NULL;
+		// and locate the constraint
+		for (pchan = (bPoseChannel*)newpose->chanbase.first; pchan; pchan=(bPoseChannel*)pchan->next) {
+			if (!strcmp(pchan->name, posechannel)) {
+				// now locate the constraint
+				for (pcon = (bConstraint*)pchan->constraints.first; pcon; pcon=(bConstraint*)pcon->next) {
+					if (!strcmp(pcon->name, constraint)) {
+						m_constraint = pcon;
+						m_posechannel = pchan;
+						break;
+					}
+				}
+				break;
+			}
+		}
+	}
+}
+
+void BL_ArmatureConstraint::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	void **h_obj = (*obj_map)[m_target];
+	if (h_obj) {
+		m_target->UnregisterObject(m_armature);
+		m_target = (KX_GameObject*)(*h_obj);
+		m_target->RegisterObject(m_armature);
+	}
+	h_obj = (*obj_map)[m_subtarget];
+	if (h_obj) {
+		m_subtarget->UnregisterObject(m_armature);
+		m_subtarget = (KX_GameObject*)(*h_obj);
+		m_subtarget->RegisterObject(m_armature);
+	}
+}
+
+bool BL_ArmatureConstraint::UnlinkObject(SCA_IObject* clientobj)
+{
+	bool res=false;
+	if (clientobj == m_target) {
+		m_target = NULL;
+		res = true;
+	}
+	if (clientobj == m_subtarget) {
+		m_subtarget = NULL;
+		res = true;
+	}
+	return res;
+}
+
+void BL_ArmatureConstraint::UpdateTarget()
+{
+	if (m_constraint && !(m_constraint->flag&CONSTRAINT_OFF) && (!m_blendtarget || m_target)) {
+		if (m_blendtarget) {
+			// external target, must be updated
+			m_target->UpdateBlenderObjectMatrix(m_blendtarget);
+			if (m_pose && m_target->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
+				// update the pose in case a bone is specified in the constraint target
+				m_blendtarget->pose = ((BL_ArmatureObject*)m_target)->GetOrigPose();
+		}
+		if (m_blendsubtarget && m_subtarget) {
+			m_subtarget->UpdateBlenderObjectMatrix(m_blendsubtarget);
+			if (m_subpose && m_subtarget->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
+				m_blendsubtarget->pose = ((BL_ArmatureObject*)m_target)->GetOrigPose();
+		}
+	}
+}
+
+void BL_ArmatureConstraint::RestoreTarget()
+{
+	if (m_constraint && !(m_constraint->flag&CONSTRAINT_OFF) && (!m_blendtarget || m_target)) {
+		if (m_blendtarget) {
+			Mat4CpyMat4(m_blendtarget->obmat, m_blendmat);
+			if (m_pose)
+				m_blendtarget->pose = m_pose;
+		}
+		if (m_blendsubtarget && m_subtarget) {
+			Mat4CpyMat4(m_blendsubtarget->obmat, m_blendsubmat);
+			if (m_subpose)
+				m_blendsubtarget->pose = m_subpose;
+		}
+	}
+}
+
+bool BL_ArmatureConstraint::Match(const char* posechannel, const char* constraint)
+{
+	return (!strcmp(m_posechannel->name, posechannel) && !strcmp(m_constraint->name, constraint));
+}
+
+void BL_ArmatureConstraint::SetTarget(KX_GameObject* target)
+{
+	if (m_blendtarget) {
+		if (target != m_target) {
+			m_target->UnregisterObject(m_armature);
+			m_target = target;
+			if (m_target)
+				m_target->RegisterObject(m_armature);
+		}
+	}
+
+}
+
+void BL_ArmatureConstraint::SetSubtarget(KX_GameObject* subtarget)
+{
+	if (m_blendsubtarget) {
+		if (subtarget != m_subtarget) {
+			m_subtarget->UnregisterObject(m_armature);
+			m_subtarget = subtarget;
+			if (m_subtarget)
+				m_subtarget->RegisterObject(m_armature);
+		}
+	}
+
+}
+
+// PYTHON
+
+PyMethodDef BL_ArmatureConstraint::Methods[] = {
+  {NULL,NULL} //Sentinel
+};
+
+// order of definition of attributes, must match Attributes[] array
+#define BCA_TYPE		0
+#define BCA_NAME		1
+#define BCA_ENFORCE		2
+#define BCA_HEADTAIL	3
+#define BCA_LINERROR	4
+#define BCA_ROTERROR	5
+#define BCA_TARGET		6
+#define BCA_SUBTARGET	7
+#define BCA_ACTIVE		8
+#define BCA_IKWEIGHT	9
+#define BCA_IKTYPE		10
+#define BCA_IKFLAG		11
+#define BCA_IKDIST		12
+#define BCA_IKMODE		13
+
+PyAttributeDef BL_ArmatureConstraint::Attributes[] = {
+	// Keep these attributes in order of BCA_ defines!!! used by py_attr_getattr and py_attr_setattr
+	KX_PYATTRIBUTE_RO_FUNCTION("type",BL_ArmatureConstraint,py_attr_getattr),	
+	KX_PYATTRIBUTE_RO_FUNCTION("name",BL_ArmatureConstraint,py_attr_getattr),	
+	KX_PYATTRIBUTE_RW_FUNCTION("enforce",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	KX_PYATTRIBUTE_RW_FUNCTION("headtail",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	KX_PYATTRIBUTE_RO_FUNCTION("lin_error",BL_ArmatureConstraint,py_attr_getattr),
+	KX_PYATTRIBUTE_RO_FUNCTION("rot_error",BL_ArmatureConstraint,py_attr_getattr),
+	KX_PYATTRIBUTE_RW_FUNCTION("target",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	KX_PYATTRIBUTE_RW_FUNCTION("subtarget",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	KX_PYATTRIBUTE_RW_FUNCTION("active",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	KX_PYATTRIBUTE_RW_FUNCTION("ik_weight",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	KX_PYATTRIBUTE_RO_FUNCTION("ik_type",BL_ArmatureConstraint,py_attr_getattr),
+	KX_PYATTRIBUTE_RO_FUNCTION("ik_flag",BL_ArmatureConstraint,py_attr_getattr),
+	KX_PYATTRIBUTE_RW_FUNCTION("ik_dist",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	KX_PYATTRIBUTE_RW_FUNCTION("ik_mode",BL_ArmatureConstraint,py_attr_getattr,py_attr_setattr),
+	
+	{ NULL }	//Sentinel
+};
+
+
+PyObject* BL_ArmatureConstraint::py_attr_getattr(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ArmatureConstraint* self= static_cast<BL_ArmatureConstraint*>(self_v);
+	bConstraint* constraint = self->m_constraint;
+	bKinematicConstraint* ikconstraint = (constraint && constraint->type == CONSTRAINT_TYPE_KINEMATIC) ? (bKinematicConstraint*)constraint->data : NULL;
+	int attr_order = attrdef-Attributes;
+
+	if (!constraint) {
+		PyErr_SetString(PyExc_AttributeError, "constraint is NULL");
+		return NULL;
+	}
+
+	switch (attr_order) {
+	case BCA_TYPE:
+		return PyLong_FromLong(constraint->type);
+	case BCA_NAME:
+		return PyUnicode_FromString(constraint->name);
+	case BCA_ENFORCE:
+		return PyFloat_FromDouble(constraint->enforce);
+	case BCA_HEADTAIL:
+		return PyFloat_FromDouble(constraint->headtail);
+	case BCA_LINERROR:
+		return PyFloat_FromDouble(constraint->lin_error);
+	case BCA_ROTERROR:
+		return PyFloat_FromDouble(constraint->rot_error);
+	case BCA_TARGET:
+		if (!self->m_target)	
+			Py_RETURN_NONE;
+		else
+			return self->m_target->GetProxy();
+	case BCA_SUBTARGET:
+		if (!self->m_subtarget)	
+			Py_RETURN_NONE;
+		else
+			return self->m_subtarget->GetProxy();
+	case BCA_ACTIVE:
+		return PyBool_FromLong(constraint->flag & CONSTRAINT_OFF);
+	case BCA_IKWEIGHT:
+	case BCA_IKTYPE:
+	case BCA_IKFLAG:
+	case BCA_IKDIST:
+	case BCA_IKMODE:
+		if (!ikconstraint) {
+			PyErr_SetString(PyExc_AttributeError, "constraint is not of IK type");
+			return NULL;
+		}
+		switch (attr_order) {
+		case BCA_IKWEIGHT:
+			return PyFloat_FromDouble((ikconstraint)?ikconstraint->weight:0.0);
+		case BCA_IKTYPE:
+			return PyLong_FromLong(ikconstraint->type);
+		case BCA_IKFLAG:
+			return PyLong_FromLong(ikconstraint->flag);
+		case BCA_IKDIST:
+			return PyFloat_FromDouble(ikconstraint->dist);
+		case BCA_IKMODE:
+			return PyLong_FromLong(ikconstraint->mode);
+		}
+		// should not come here
+		break;
+	}
+	PyErr_SetString(PyExc_AttributeError, "constraint unknown attribute");
+	return NULL;
+}
+
+int BL_ArmatureConstraint::py_attr_setattr(void *self_v, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value)
+{
+	BL_ArmatureConstraint* self= static_cast<BL_ArmatureConstraint*>(self_v);
+	bConstraint* constraint = self->m_constraint;
+	bKinematicConstraint* ikconstraint = (constraint && constraint->type == CONSTRAINT_TYPE_KINEMATIC) ? (bKinematicConstraint*)constraint->data : NULL;
+	int attr_order = attrdef-Attributes;
+	int ival;
+	double dval;
+	char* sval;
+	KX_GameObject *oval;
+
+	if (!constraint) {
+		PyErr_SetString(PyExc_AttributeError, "constraint is NULL");
+		return PY_SET_ATTR_FAIL;
+	}
+	
+	switch (attr_order) {
+	case BCA_ENFORCE:
+		dval = PyFloat_AsDouble(value);
+		if (dval < 0.0f || dval > 1.0f) { /* also accounts for non float */
+			PyErr_SetString(PyExc_AttributeError, "constraint.enforce = float: BL_ArmatureConstraint, expected a float between 0 and 1");
+			return PY_SET_ATTR_FAIL;
+		}
+		constraint->enforce = dval;
+		return PY_SET_ATTR_SUCCESS;
+
+	case BCA_HEADTAIL:
+		dval = PyFloat_AsDouble(value);
+		if (dval < 0.0f || dval > 1.0f) { /* also accounts for non float */
+			PyErr_SetString(PyExc_AttributeError, "constraint.headtail = float: BL_ArmatureConstraint, expected a float between 0 and 1");
+			return PY_SET_ATTR_FAIL;
+		}
+		constraint->headtail = dval;
+		return PY_SET_ATTR_SUCCESS;
+
+	case BCA_TARGET:
+		if (!ConvertPythonToGameObject(value, &oval, true, "constraint.target = value: BL_ArmatureConstraint"))
+			return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error
+		self->SetTarget(oval);
+		return PY_SET_ATTR_SUCCESS;
+
+	case BCA_SUBTARGET:
+		if (!ConvertPythonToGameObject(value, &oval, true, "constraint.subtarget = value: BL_ArmatureConstraint"))
+			return PY_SET_ATTR_FAIL; // ConvertPythonToGameObject sets the error
+		self->SetSubtarget(oval);
+		return PY_SET_ATTR_SUCCESS;
+
+	case BCA_ACTIVE:
+		ival = PyObject_IsTrue( value );
+		if (ival == -1) {
+			PyErr_SetString(PyExc_AttributeError, "constraint.active = bool: BL_ArmatureConstraint, expected True or False");
+			return PY_SET_ATTR_FAIL;
+		}
+		self->m_constraint->flag = (self->m_constraint->flag & ~CONSTRAINT_OFF) | ((ival)?0:CONSTRAINT_OFF);
+		return PY_SET_ATTR_SUCCESS;
+
+	case BCA_IKWEIGHT:
+	case BCA_IKDIST:
+	case BCA_IKMODE:
+		if (!ikconstraint) {
+			PyErr_SetString(PyExc_AttributeError, "constraint is not of IK type");
+			return PY_SET_ATTR_FAIL;
+		}
+		switch (attr_order) {
+		case BCA_IKWEIGHT:
+			dval = PyFloat_AsDouble(value);
+			if (dval < 0.0f || dval > 1.0f) { /* also accounts for non float */
+				PyErr_SetString(PyExc_AttributeError, "constraint.weight = float: BL_ArmatureConstraint, expected a float between 0 and 1");
+				return PY_SET_ATTR_FAIL;
+			}
+			ikconstraint->weight = dval;
+			return PY_SET_ATTR_SUCCESS;
+
+		case BCA_IKDIST:
+			dval = PyFloat_AsDouble(value);
+			if (dval < 0.0f) { /* also accounts for non float */
+				PyErr_SetString(PyExc_AttributeError, "constraint.ik_dist = float: BL_ArmatureConstraint, expected a positive float");
+				return PY_SET_ATTR_FAIL;
+			}
+			ikconstraint->dist = dval;
+			return PY_SET_ATTR_SUCCESS;
+
+		case BCA_IKMODE:
+			ival = PyLong_AsLong(value);
+			if (ival < 0) {
+				PyErr_SetString(PyExc_AttributeError, "constraint.ik_mode = integer: BL_ArmatureConstraint, expected a positive integer");
+				return PY_SET_ATTR_FAIL;
+			}
+			ikconstraint->mode = ival;
+			return PY_SET_ATTR_SUCCESS;
+		}
+		// should not come here
+		break;
+
+	}
+
+	PyErr_SetString(PyExc_AttributeError, "constraint unknown attribute");
+	return PY_SET_ATTR_FAIL;
+}
+
diff --git a/source/gameengine/Converter/BL_ArmatureConstraint.h b/source/gameengine/Converter/BL_ArmatureConstraint.h
new file mode 100644
index 00000000000..f10849ea05b
--- /dev/null
+++ b/source/gameengine/Converter/BL_ArmatureConstraint.h
@@ -0,0 +1,117 @@
+/**
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+#ifndef __BL_ARMATURECONSTRAINT
+#define __BL_ARMATURECONSTRAINT
+
+#include "DNA_constraint_types.h"
+#include "GEN_HashedPtr.h"
+#include "GEN_Map.h"
+#include "PyObjectPlus.h"
+
+class SCA_IObject;
+class KX_GameObject;
+class BL_ArmatureObject;
+struct bConstraint;
+struct bPoseChannel;
+struct Object;
+struct bPose;
+
+/**
+ * SG_DList : element of controlled constraint list 
+ *            head = BL_ArmatureObject::m_controlledConstraints
+ * SG_QList : not used
+ */
+class BL_ArmatureConstraint	: public PyObjectPlus
+{
+	Py_Header;
+
+private:
+	struct bConstraint* m_constraint;
+	struct bPoseChannel* m_posechannel;
+	class BL_ArmatureObject* m_armature;
+	char m_name[64];
+	KX_GameObject*  m_target;
+	KX_GameObject*  m_subtarget;
+	struct Object*	m_blendtarget;
+	struct Object*	m_blendsubtarget;
+	float		m_blendmat[4][4];
+	float		m_blendsubmat[4][4];
+	struct bPose*	m_pose;
+	struct bPose*	m_subpose;
+
+public:
+	BL_ArmatureConstraint(class BL_ArmatureObject *armature, 
+						struct bPoseChannel *posechannel, 
+						struct bConstraint *constraint, 
+						KX_GameObject* target,
+						KX_GameObject* subtarget);
+	virtual ~BL_ArmatureConstraint();
+
+
+	virtual PyObject* py_repr(void);
+
+	BL_ArmatureConstraint* GetReplica() const;
+	void ReParent(BL_ArmatureObject* armature);
+	void Relink(GEN_Map<GEN_HashedPtr, void*> *map);
+	bool UnlinkObject(SCA_IObject* clientobj);
+
+	void UpdateTarget();
+	void RestoreTarget();
+
+	bool Match(const char* posechannel, const char* constraint);
+	const char* GetName() { return m_name; }
+
+	void SetConstraintFlag(int flag)
+	{
+		if (m_constraint)
+			m_constraint->flag |= flag;
+	}
+	void ClrConstraintFlag(int flag)
+	{
+		if (m_constraint)
+			m_constraint->flag &= ~flag;
+	}
+	void SetWeight(float weight)
+	{
+		if (m_constraint && m_constraint->type == CONSTRAINT_TYPE_KINEMATIC && m_constraint->data) {
+			bKinematicConstraint* con = (bKinematicConstraint*)m_constraint->data;
+			con->weight = weight;
+		}
+	}
+	void SetTarget(KX_GameObject* target);
+	void SetSubtarget(KX_GameObject* subtarget);
+
+	// Python access
+	static PyObject* py_attr_getattr(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+	static int py_attr_setattr(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef, PyObject *value);
+
+};
+
+#endif //__BL_ARMATURECONSTRAINT
+
diff --git a/source/gameengine/Converter/BL_ArmatureObject.cpp b/source/gameengine/Converter/BL_ArmatureObject.cpp
index cfd90813a16..d5660d9ef84 100644
--- a/source/gameengine/Converter/BL_ArmatureObject.cpp
+++ b/source/gameengine/Converter/BL_ArmatureObject.cpp
@@ -29,9 +29,15 @@
 
 #include "BL_ArmatureObject.h"
 #include "BL_ActionActuator.h"
+#include "KX_BlenderSceneConverter.h"
 #include "BLI_blenlib.h"
+#include "BLI_ghash.h"
+#include "BLI_arithb.h"
+#include "BIK_api.h"
 #include "BKE_action.h"
 #include "BKE_armature.h"
+#include "BKE_utildefines.h"
+#include "BKE_constraint.h"
 #include "GEN_Map.h"
 #include "GEN_HashedPtr.h"
 #include "MEM_guardedalloc.h"
@@ -39,6 +45,11 @@
 #include "DNA_armature_types.h"
 #include "DNA_object_types.h"
 #include "DNA_scene_types.h"
+#include "DNA_nla_types.h"
+#include "DNA_constraint_types.h"
+#include "KX_PythonSeq.h"
+#include "KX_PythonInit.h"
+#include "KX_KetsjiEngine.h"
 
 #include "MT_Matrix4x4.h"
 
@@ -46,6 +57,153 @@
 #include <config.h>
 #endif
 
+/** 
+ * Move here pose function for game engine so that we can mix with GE objects
+ * Principle is as follow:
+ * Use Blender structures so that where_is_pose can be used unchanged
+ * Copy the constraint so that they can be enabled/disabled/added/removed at runtime
+ * Don't copy the constraints for the pose used by the Action actuator, it does not need them.
+ * Scan the constraint structures so that the KX equivalent of target objects are identified and 
+ * stored in separate list.
+ * When it is about to evaluate the pose, set the KX object position in the obmat of the corresponding
+ * Blender objects and restore after the evaluation.
+ */
+void game_copy_pose(bPose **dst, bPose *src, int copy_constraint)
+{
+	bPose *out;
+	bPoseChannel *pchan, *outpchan;
+	GHash *ghash;
+	
+	/* the game engine copies the current armature pose and then swaps
+	 * the object pose pointer. this makes it possible to change poses
+	 * without affecting the original blender data. */
+
+	if (!src) {
+		*dst=NULL;
+		return;
+	}
+	else if (*dst==src) {
+		printf("copy_pose source and target are the same\n");
+		*dst=NULL;
+		return;
+	}
+	
+	out= (bPose*)MEM_dupallocN(src);
+	out->agroups.first= out->agroups.last= NULL;
+	out->ikdata = NULL;
+	out->ikparam = MEM_dupallocN(out->ikparam);
+	out->flag |= POSE_GAME_ENGINE;
+	BLI_duplicatelist(&out->chanbase, &src->chanbase);
+
+	/* remap pointers */
+	ghash= BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp);
+
+	pchan= (bPoseChannel*)src->chanbase.first;
+	outpchan= (bPoseChannel*)out->chanbase.first;
+	for (; pchan; pchan=pchan->next, outpchan=outpchan->next)
+		BLI_ghash_insert(ghash, pchan, outpchan);
+
+	for (pchan=(bPoseChannel*)out->chanbase.first; pchan; pchan=(bPoseChannel*)pchan->next) {
+		pchan->parent= (bPoseChannel*)BLI_ghash_lookup(ghash, pchan->parent);
+		pchan->child= (bPoseChannel*)BLI_ghash_lookup(ghash, pchan->child);
+		pchan->path= NULL;
+
+		if (copy_constraint) {
+			ListBase listb;
+			// copy all constraint for backward compatibility
+			copy_constraints(&listb, &pchan->constraints);  // copy_constraints NULLs listb
+			pchan->constraints= listb;
+		} else {
+			pchan->constraints.first = NULL;
+			pchan->constraints.last = NULL;
+		}
+	}
+
+	BLI_ghash_free(ghash, NULL, NULL);
+	
+	*dst=out;
+}
+
+
+
+/* Only allowed for Poses with identical channels */
+void game_blend_poses(bPose *dst, bPose *src, float srcweight/*, short mode*/)
+{
+	short mode= ACTSTRIPMODE_BLEND;
+	
+	bPoseChannel *dchan;
+	const bPoseChannel *schan;
+	bConstraint *dcon, *scon;
+	float dstweight;
+	int i;
+
+	switch (mode){
+	case ACTSTRIPMODE_BLEND:
+		dstweight = 1.0F - srcweight;
+		break;
+	case ACTSTRIPMODE_ADD:
+		dstweight = 1.0F;
+		break;
+	default :
+		dstweight = 1.0F;
+	}
+	
+	schan= (bPoseChannel*)src->chanbase.first;
+	for (dchan = (bPoseChannel*)dst->chanbase.first; dchan; dchan=(bPoseChannel*)dchan->next, schan= (bPoseChannel*)schan->next){
+		// always blend on all channels since we don't know which one has been set
+		/* quat interpolation done separate */
+		if (schan->rotmode == PCHAN_ROT_QUAT) {
+			float dquat[4], squat[4];
+			
+			QUATCOPY(dquat, dchan->quat);
+			QUATCOPY(squat, schan->quat);
+			if (mode==ACTSTRIPMODE_BLEND)
+				QuatInterpol(dchan->quat, dquat, squat, srcweight);
+			else {
+				QuatMulFac(squat, srcweight);
+				QuatMul(dchan->quat, dquat, squat);
+			}
+			
+			NormalQuat(dchan->quat);
+		}
+
+		for (i=0; i<3; i++) {
+			/* blending for loc and scale are pretty self-explanatory... */
+			dchan->loc[i] = (dchan->loc[i]*dstweight) + (schan->loc[i]*srcweight);
+			dchan->size[i] = 1.0f + ((dchan->size[i]-1.0f)*dstweight) + ((schan->size[i]-1.0f)*srcweight);
+			
+			/* euler-rotation interpolation done here instead... */
+			// FIXME: are these results decent?
+			if (schan->rotmode)
+				dchan->eul[i] = (dchan->eul[i]*dstweight) + (schan->eul[i]*srcweight);
+		}
+		for(dcon= (bConstraint*)dchan->constraints.first, scon= (bConstraint*)schan->constraints.first; dcon && scon; dcon= (bConstraint*)dcon->next, scon= (bConstraint*)scon->next) {
+			/* no 'add' option for constraint blending */
+			dcon->enforce= dcon->enforce*(1.0f-srcweight) + scon->enforce*srcweight;
+		}
+	}
+	
+	/* this pose is now in src time */
+	dst->ctime= src->ctime;
+}
+
+void game_free_pose(bPose *pose)
+{
+	if (pose) {
+		/* free pose-channels and constraints */
+		free_pose_channels(pose);
+		
+		/* free IK solver state */
+		BIK_clear_data(pose);
+
+		/* free IK solver param */
+		if (pose->ikparam)
+			MEM_freeN(pose->ikparam);
+
+		MEM_freeN(pose);
+	}
+}
+
 BL_ArmatureObject::BL_ArmatureObject(
 				void* sgReplicationInfo, 
 				SG_Callbacks callbacks, 
@@ -53,12 +211,17 @@ BL_ArmatureObject::BL_ArmatureObject(
 				Scene *scene)
 
 :	KX_GameObject(sgReplicationInfo,callbacks),
+	m_controlledConstraints(),
+	m_poseChannels(),
 	m_objArma(armature),
 	m_framePose(NULL),
 	m_scene(scene), // maybe remove later. needed for where_is_pose
 	m_lastframe(0.0),
+	m_timestep(0.040),
 	m_activeAct(NULL),
 	m_activePriority(999),
+	m_constraintNumber(0),
+	m_channelNumber(0),
 	m_lastapplyframe(0.0)
 {
 	m_armature = (bArmature *)armature->data;
@@ -67,7 +230,177 @@ BL_ArmatureObject::BL_ArmatureObject(
 	 * the original pose before calling into blender functions, to deal with
 	 * replica's or other objects using the same blender object */
 	m_pose = NULL;
-	game_copy_pose(&m_pose, m_objArma->pose);
+	game_copy_pose(&m_pose, m_objArma->pose, 1);
+	// store the original armature object matrix
+	memcpy(m_obmat, m_objArma->obmat, sizeof(m_obmat));
+}
+
+BL_ArmatureObject::~BL_ArmatureObject()
+{
+	BL_ArmatureConstraint* constraint;
+	while ((constraint = m_controlledConstraints.Remove()) != NULL) {
+		delete constraint;
+	}
+	BL_ArmatureChannel* channel;
+	while ((channel = static_cast<BL_ArmatureChannel*>(m_poseChannels.Remove())) != NULL) {
+		delete channel;
+	}
+	if (m_pose)
+		game_free_pose(m_pose);
+	if (m_framePose)
+		game_free_pose(m_framePose);
+}
+
+
+void BL_ArmatureObject::LoadConstraints(KX_BlenderSceneConverter* converter)
+{
+	// first delete any existing constraint (should not have any)
+	while (!m_controlledConstraints.Empty()) {
+		BL_ArmatureConstraint* constraint = m_controlledConstraints.Remove();
+		delete constraint;
+	}
+	m_constraintNumber = 0;
+
+	// list all the constraint and convert them to BL_ArmatureConstraint
+	// get the persistent pose structure
+	bPoseChannel* pchan;
+	bConstraint* pcon;
+	bConstraintTypeInfo* cti;
+	Object* blendtarget;
+	KX_GameObject* gametarget;
+	KX_GameObject* gamesubtarget;
+
+	// and locate the constraint
+	for (pchan = (bPoseChannel*)m_pose->chanbase.first; pchan; pchan=(bPoseChannel*)pchan->next) {
+		for (pcon = (bConstraint*)pchan->constraints.first; pcon; pcon=(bConstraint*)pcon->next) {
+			if (pcon->flag & CONSTRAINT_DISABLE)
+				continue;
+			// which constraint should we support?
+			switch (pcon->type) {
+			case CONSTRAINT_TYPE_TRACKTO:
+			case CONSTRAINT_TYPE_KINEMATIC:
+			case CONSTRAINT_TYPE_ROTLIKE:
+			case CONSTRAINT_TYPE_LOCLIKE:
+			case CONSTRAINT_TYPE_MINMAX:
+			case CONSTRAINT_TYPE_SIZELIKE:
+			case CONSTRAINT_TYPE_LOCKTRACK:
+			case CONSTRAINT_TYPE_STRETCHTO:
+			case CONSTRAINT_TYPE_CLAMPTO:
+			case CONSTRAINT_TYPE_TRANSFORM:
+			case CONSTRAINT_TYPE_DISTLIMIT:
+				cti = constraint_get_typeinfo(pcon);
+				gametarget = gamesubtarget = NULL;
+				if (cti && cti->get_constraint_targets) {
+					ListBase listb = { NULL, NULL };
+					cti->get_constraint_targets(pcon, &listb);
+					if (listb.first) {
+						bConstraintTarget* target = (bConstraintTarget*)listb.first;
+						if (target->tar && target->tar != m_objArma) {
+							// only remember external objects, self target is handled automatically
+							blendtarget = target->tar;
+							gametarget = converter->FindGameObject(blendtarget);
+						}
+						if (target->next != NULL) {
+							// secondary target
+							target = (bConstraintTarget*)target->next;
+							if (target->tar && target->tar != m_objArma) {
+								// only track external object
+								blendtarget = target->tar;
+								gamesubtarget = converter->FindGameObject(blendtarget);
+							}
+						}
+					}
+					if (cti->flush_constraint_targets)
+						cti->flush_constraint_targets(pcon, &listb, 1);
+				}
+				BL_ArmatureConstraint* constraint = new BL_ArmatureConstraint(this, pchan, pcon, gametarget, gamesubtarget);
+				m_controlledConstraints.AddBack(constraint);
+				m_constraintNumber++;
+			}
+		}
+	}
+}
+
+BL_ArmatureConstraint* BL_ArmatureObject::GetConstraint(const char* posechannel, const char* constraintname)
+{
+	SG_DList::iterator<BL_ArmatureConstraint> cit(m_controlledConstraints);
+	for (cit.begin(); !cit.end(); ++cit) {
+		BL_ArmatureConstraint* constraint = *cit;
+		if (constraint->Match(posechannel, constraintname))
+			return constraint;
+	}
+	return NULL;
+}
+
+BL_ArmatureConstraint* BL_ArmatureObject::GetConstraint(const char* posechannelconstraint)
+{
+	// performance: use hash string instead of plain string compare
+	SG_DList::iterator<BL_ArmatureConstraint> cit(m_controlledConstraints);
+	for (cit.begin(); !cit.end(); ++cit) {
+		BL_ArmatureConstraint* constraint = *cit;
+		if (!strcmp(constraint->GetName(), posechannelconstraint))
+			return constraint;
+	}
+	return NULL;
+}
+
+BL_ArmatureConstraint* BL_ArmatureObject::GetConstraint(int index)
+{
+	SG_DList::iterator<BL_ArmatureConstraint> cit(m_controlledConstraints);
+	for (cit.begin(); !cit.end() && index; ++cit, --index);
+	return (cit.end()) ? NULL : *cit;
+}
+
+/* this function is called to populate the m_poseChannels list */
+void BL_ArmatureObject::LoadChannels()
+{
+	if (m_poseChannels.Empty()) {
+		bPoseChannel* pchan;
+		BL_ArmatureChannel* proxy;
+	
+		m_channelNumber = 0;
+		for (pchan = (bPoseChannel*)m_pose->chanbase.first; pchan; pchan=(bPoseChannel*)pchan->next) {
+			proxy = new BL_ArmatureChannel(this, pchan);
+			m_poseChannels.AddBack(proxy);
+			m_channelNumber++;
+		}
+	}
+}
+
+BL_ArmatureChannel* BL_ArmatureObject::GetChannel(bPoseChannel* pchan)
+{
+	LoadChannels();
+	SG_DList::iterator<BL_ArmatureChannel> cit(m_poseChannels);
+	for (cit.begin(); !cit.end(); ++cit) 
+	{
+		BL_ArmatureChannel* channel = *cit;
+		if (channel->m_posechannel == pchan)
+			return channel;
+	}
+	return NULL;
+}
+
+BL_ArmatureChannel* BL_ArmatureObject::GetChannel(const char* str)
+{
+	LoadChannels();
+	SG_DList::iterator<BL_ArmatureChannel> cit(m_poseChannels);
+	for (cit.begin(); !cit.end(); ++cit) 
+	{
+		BL_ArmatureChannel* channel = *cit;
+		if (!strcmp(channel->m_posechannel->name, str))
+			return channel;
+	}
+	return NULL;
+}
+
+BL_ArmatureChannel* BL_ArmatureObject::GetChannel(int index)
+{
+	LoadChannels();
+	if (index < 0 || index >= m_channelNumber)
+		return NULL;
+	SG_DList::iterator<BL_ArmatureChannel> cit(m_poseChannels);
+	for (cit.begin(); !cit.end() && index; ++cit, --index);
+	return (cit.end()) ? NULL : *cit;
 }
 
 CValue* BL_ArmatureObject::GetReplica()
@@ -83,22 +416,61 @@ void BL_ArmatureObject::ProcessReplica()
 	KX_GameObject::ProcessReplica();
 
 	m_pose = NULL;
-	game_copy_pose(&m_pose, pose);
+	m_framePose = NULL;
+	game_copy_pose(&m_pose, pose, 1);	
 }
 
-BL_ArmatureObject::~BL_ArmatureObject()
+void BL_ArmatureObject::ReParentLogic()
 {
-	if (m_pose)
-		game_free_pose(m_pose);
+	SG_DList::iterator<BL_ArmatureConstraint> cit(m_controlledConstraints);
+	for (cit.begin(); !cit.end(); ++cit) {
+		(*cit)->ReParent(this);
+	}
+	KX_GameObject::ReParentLogic();
+}
+
+void BL_ArmatureObject::Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map)
+{
+	SG_DList::iterator<BL_ArmatureConstraint> cit(m_controlledConstraints);
+	for (cit.begin(); !cit.end(); ++cit) {
+		(*cit)->Relink(obj_map);
+	}
+	KX_GameObject::Relink(obj_map);
+}
+
+bool BL_ArmatureObject::UnlinkObject(SCA_IObject* clientobj)
+{
+	// clientobj is being deleted, make sure we don't hold any reference to it
+	bool res = false;
+	SG_DList::iterator<BL_ArmatureConstraint> cit(m_controlledConstraints);
+	for (cit.begin(); !cit.end(); ++cit) {
+		res |= (*cit)->UnlinkObject(clientobj);
+	}
+	return res;
 }
 
 void BL_ArmatureObject::ApplyPose()
 {
 	m_armpose = m_objArma->pose;
 	m_objArma->pose = m_pose;
+	// in the GE, we use ctime to store the timestep
+	m_pose->ctime = (float)m_timestep;
 	//m_scene->r.cfra++;
 	if(m_lastapplyframe != m_lastframe) {
+		// update the constraint if any, first put them all off so that only the active ones will be updated
+		SG_DList::iterator<BL_ArmatureConstraint> cit(m_controlledConstraints);
+		for (cit.begin(); !cit.end(); ++cit) {
+			(*cit)->UpdateTarget();
+		}
+		// update ourself
+		UpdateBlenderObjectMatrix(m_objArma);
 		where_is_pose(m_scene, m_objArma); // XXX
+		// restore ourself
+		memcpy(m_objArma->obmat, m_obmat, sizeof(m_obmat));
+		// restore active targets
+		for (cit.begin(); !cit.end(); ++cit) {
+			(*cit)->RestoreTarget();
+		}
 		m_lastapplyframe = m_lastframe;
 	}
 }
@@ -119,30 +491,37 @@ bool BL_ArmatureObject::SetActiveAction(BL_ActionActuator *act, short priority,
 {
 	if (curtime != m_lastframe){
 		m_activePriority = 9999;
+		// compute the timestep for the underlying IK algorithm
+		m_timestep = curtime-m_lastframe;
 		m_lastframe= curtime;
 		m_activeAct = NULL;
 		// remember the pose at the start of the frame
-		m_framePose = m_pose;
+		GetPose(&m_framePose);
 	}
 
-	if (priority<=m_activePriority)
+	if (act) 
 	{
-		if (priority<m_activePriority)
-			// this action overwrites the previous ones, start from initial pose to cancel their effects
-			m_pose = m_framePose;
-		if (m_activeAct && (m_activeAct!=act))
-			m_activeAct->SetBlendTime(0.0);	/* Reset the blend timer */
-		m_activeAct = act;
-		m_activePriority = priority;
-		m_lastframe = curtime;
-	
-		return true;
-	}
-	else{
-		act->SetBlendTime(0.0);
-		return false;
+		if (priority<=m_activePriority)
+		{
+			if (priority<m_activePriority) {
+				// this action overwrites the previous ones, start from initial pose to cancel their effects
+				SetPose(m_framePose);
+				if (m_activeAct && (m_activeAct!=act))
+					/* Reset the blend timer since this new action cancels the old one */
+					m_activeAct->SetBlendTime(0.0);	
+			}
+			m_activeAct = act;
+			m_activePriority = priority;
+			m_lastframe = curtime;
+		
+			return true;
+		}
+		else{
+			act->SetBlendTime(0.0);
+			return false;
+		}
 	}
-	
+	return false;
 }
 
 BL_ActionActuator * BL_ArmatureObject::GetActiveAction()
@@ -161,7 +540,7 @@ void BL_ArmatureObject::GetPose(bPose **pose)
 			a crash and memory leakage when 
 			&BL_ActionActuator::m_pose is freed
 		*/
-		game_copy_pose(pose, m_pose);
+		game_copy_pose(pose, m_pose, 0);
 	}
 	else {
 		if (*pose == m_pose)
@@ -178,7 +557,7 @@ void BL_ArmatureObject::GetMRDPose(bPose **pose)
 	/* Otherwise, copy the armature's pose channels into the caller-supplied pose */
 
 	if (!*pose)
-		game_copy_pose(pose, m_pose);
+		game_copy_pose(pose, m_pose, 0);
 	else
 		extract_pose_from_pose(*pose, m_pose);
 }
@@ -210,3 +589,68 @@ float BL_ArmatureObject::GetBoneLength(Bone* bone) const
 {
 	return (float)(MT_Point3(bone->head) - MT_Point3(bone->tail)).length();
 }
+
+// PYTHON
+
+PyTypeObject BL_ArmatureObject::Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"BL_ArmatureObject",
+	sizeof(PyObjectPlus_Proxy),
+	0,
+	py_base_dealloc,
+	0,
+	0,
+	0,
+	0,
+	py_base_repr,
+	0,
+	&KX_GameObject::Sequence,
+	&KX_GameObject::Mapping,
+	0,0,0,
+	NULL,
+	NULL,
+	0,
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	0,0,0,0,0,0,0,
+	Methods,
+	0,
+	0,
+	&KX_GameObject::Type,
+	0,0,0,0,0,0,
+	py_base_new
+};
+
+PyMethodDef BL_ArmatureObject::Methods[] = {
+
+	KX_PYMETHODTABLE_NOARGS(BL_ArmatureObject, update),
+	{NULL,NULL} //Sentinel
+};
+
+PyAttributeDef BL_ArmatureObject::Attributes[] = {
+
+	KX_PYATTRIBUTE_RO_FUNCTION("constraints",		BL_ArmatureObject, pyattr_get_constraints),
+	KX_PYATTRIBUTE_RO_FUNCTION("channels",		BL_ArmatureObject, pyattr_get_channels),
+	{NULL} //Sentinel
+};
+
+PyObject* BL_ArmatureObject::pyattr_get_constraints(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+	return KX_PythonSeq_CreatePyObject((static_cast<BL_ArmatureObject*>(self_v))->m_proxy, KX_PYGENSEQ_OB_TYPE_CONSTRAINTS);
+}
+
+PyObject* BL_ArmatureObject::pyattr_get_channels(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef)
+{
+	BL_ArmatureObject* self = static_cast<BL_ArmatureObject*>(self_v);
+	self->LoadChannels(); // make sure we have the channels
+	return KX_PythonSeq_CreatePyObject((static_cast<BL_ArmatureObject*>(self_v))->m_proxy, KX_PYGENSEQ_OB_TYPE_CHANNELS);
+}
+
+KX_PYMETHODDEF_DOC_NOARGS(BL_ArmatureObject, update, 
+						  "update()\n"
+						  "Make sure that the armature will be updated on next graphic frame.\n"
+						  "This is automatically done if a KX_ArmatureActuator with mode run is active\n"
+						  "or if an action is playing. This function is usefull in other cases.\n")
+{
+	SetActiveAction(NULL, 0, KX_GetActiveEngine()->GetFrameTime());
+	Py_RETURN_NONE;
+}
diff --git a/source/gameengine/Converter/BL_ArmatureObject.h b/source/gameengine/Converter/BL_ArmatureObject.h
index af0b7dc201c..3e917e08001 100644
--- a/source/gameengine/Converter/BL_ArmatureObject.h
+++ b/source/gameengine/Converter/BL_ArmatureObject.h
@@ -31,21 +31,34 @@
 #define BL_ARMATUREOBJECT
 
 #include "KX_GameObject.h"
+#include "BL_ArmatureConstraint.h"
+#include "BL_ArmatureChannel.h"
 
 #include "SG_IObject.h"
+#include <vector>
+#include <algorithm>
 
 struct bArmature;
 struct Bone;
+struct bConstraint;
 class BL_ActionActuator;
+class BL_ArmatureActuator;
 class MT_Matrix4x4;
 struct Object;
+class KX_BlenderSceneConverter;
 
 class BL_ArmatureObject : public KX_GameObject  
 {
+	Py_Header;
 public:
+
 	double GetLastFrame ();
 	short GetActivePriority();
 	virtual void ProcessReplica();
+	virtual void ReParentLogic();
+	virtual void Relink(GEN_Map<GEN_HashedPtr, void*> *obj_map);
+	virtual bool UnlinkObject(SCA_IObject* clientobj);
+
 	class BL_ActionActuator * GetActiveAction();
 	
 	BL_ArmatureObject(
@@ -73,6 +86,19 @@ public:
 	
 	Object* GetArmatureObject() {return m_objArma;}
 
+	// for constraint python API
+	void LoadConstraints(KX_BlenderSceneConverter* converter);
+	size_t GetConstraintNumber() const { return m_constraintNumber; }
+	BL_ArmatureConstraint* GetConstraint(const char* posechannel, const char* constraint);
+	BL_ArmatureConstraint* GetConstraint(const char* posechannelconstraint);
+	BL_ArmatureConstraint* GetConstraint(int index);
+	// for pose channel python API
+	void LoadChannels();
+	size_t GetChannelNumber() const { return m_constraintNumber; }
+	BL_ArmatureChannel* GetChannel(bPoseChannel* channel);
+	BL_ArmatureChannel* GetChannel(const char* channel);
+	BL_ArmatureChannel* GetChannel(int index);
+
 	/// Retrieve the pose matrix for the specified bone.
 	/// Returns true on success.
 	bool GetBoneMatrix(Bone* bone, MT_Matrix4x4& matrix);
@@ -81,7 +107,17 @@ public:
 	float GetBoneLength(Bone* bone) const;
 
 	virtual int GetGameObjectType() { return OBJ_ARMATURE; }
+
+	// PYTHON
+	static PyObject* pyattr_get_constraints(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	static PyObject* pyattr_get_channels(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
+	KX_PYMETHOD_DOC_NOARGS(BL_ArmatureObject, update);
+
 protected:
+	/* list element: BL_ArmatureConstraint. Use SG_DListHead to have automatic list replication */
+	SG_DListHead<BL_ArmatureConstraint>	 m_controlledConstraints;
+	/* list element: BL_ArmatureChannel. Use SG_DList to avoid list replication */
+	SG_DList			m_poseChannels;
 	Object				*m_objArma;
 	struct bArmature	*m_armature;
 	struct bPose		*m_pose;
@@ -89,8 +125,13 @@ protected:
 	struct bPose		*m_framePose;
 	struct Scene		*m_scene; // need for where_is_pose 
 	double	m_lastframe;
+	double  m_timestep;		// delta since last pose evaluation.
 	class BL_ActionActuator *m_activeAct;
 	short	m_activePriority;
+	size_t  m_constraintNumber;
+	size_t  m_channelNumber;
+	// store the original armature object matrix
+	float m_obmat[4][4];
 
 	double			m_lastapplyframe;
 
@@ -102,5 +143,12 @@ public:
 #endif
 };
 
+/* Pose function specific to the game engine */
+void game_blend_poses(struct bPose *dst, struct bPose *src, float srcweight/*, short mode*/); /* was blend_poses */
+//void extract_pose_from_pose(struct bPose *pose, const struct bPose *src);
+void game_copy_pose(struct bPose **dst, struct bPose *src, int copy_con);
+void game_free_pose(struct bPose *pose);
+
+
 #endif
 
diff --git a/source/gameengine/Converter/BL_BlenderDataConversion.cpp b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
index 230820719aa..8feae48f12e 100644
--- a/source/gameengine/Converter/BL_BlenderDataConversion.cpp
+++ b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
@@ -2501,6 +2501,14 @@ void BL_ConvertBlenderObjects(struct Main* maggie,
 			gameobj->GetDeformer()->UpdateBuckets();
 	}
 
+	// Set up armature constraints
+	for (i=0;i<sumolist->GetCount();++i)
+	{
+		KX_GameObject* gameobj = (KX_GameObject*) sumolist->GetValue(i);
+		if (gameobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE)
+			((BL_ArmatureObject*)gameobj)->LoadConstraints(converter);
+	}
+
 	bool processCompoundChildren = false;
 
 	// create physics information
diff --git a/source/gameengine/Converter/BL_ShapeActionActuator.h b/source/gameengine/Converter/BL_ShapeActionActuator.h
index 28a6d90abdf..80157630e27 100644
--- a/source/gameengine/Converter/BL_ShapeActionActuator.h
+++ b/source/gameengine/Converter/BL_ShapeActionActuator.h
@@ -51,7 +51,7 @@ public:
 						short	blendin,
 						short	priority,
 						float	stride) 
-		: SCA_IActuator(gameobj),
+		: SCA_IActuator(gameobj, KX_ACT_SHAPEACTION),
 		
 		m_lastpos(0, 0, 0),
 		m_blendframe(0),
diff --git a/source/gameengine/Converter/CMakeLists.txt b/source/gameengine/Converter/CMakeLists.txt
index 257ca856b2c..d617934ec01 100644
--- a/source/gameengine/Converter/CMakeLists.txt
+++ b/source/gameengine/Converter/CMakeLists.txt
@@ -59,6 +59,7 @@ SET(INC
 	../../../source/blender/misc
 	../../../source/blender/blenloader
 	../../../source/blender/gpu
+	../../../source/blender/ikplugin
 	../../../extern/bullet2/src
 	${PYTHON_INC}
 )
diff --git a/source/gameengine/Converter/KX_ConvertActuators.cpp b/source/gameengine/Converter/KX_ConvertActuators.cpp
index 91a39bd7686..1cb16acf148 100644
--- a/source/gameengine/Converter/KX_ConvertActuators.cpp
+++ b/source/gameengine/Converter/KX_ConvertActuators.cpp
@@ -88,6 +88,7 @@
 #include "DNA_packedFile_types.h"
 #include "BL_ActionActuator.h"
 #include "BL_ShapeActionActuator.h"
+#include "BL_ArmatureActuator.h"
 /* end of blender include block */
 
 #include "BL_BlenderDataConversion.h"
@@ -1021,6 +1022,15 @@ void BL_ConvertActuators(char* maggiename,
 				break;
 			}
 		
+		case ACT_ARMATURE:
+			{
+				bArmatureActuator* armAct = (bArmatureActuator*) bact->data;
+				KX_GameObject *tmpgob = converter->FindGameObject(armAct->target);
+				KX_GameObject *subgob = converter->FindGameObject(armAct->subtarget);
+				BL_ArmatureActuator* tmparmact = new BL_ArmatureActuator(gameobj, armAct->type, armAct->posechannel, armAct->constraint, tmpgob, subgob, armAct->weight);
+				baseact = tmparmact;
+				break;
+			}
 		default:
 			; /* generate some error */
 		}
diff --git a/source/gameengine/Converter/KX_ConvertSensors.cpp b/source/gameengine/Converter/KX_ConvertSensors.cpp
index 09027f18844..99a2ec3ca64 100644
--- a/source/gameengine/Converter/KX_ConvertSensors.cpp
+++ b/source/gameengine/Converter/KX_ConvertSensors.cpp
@@ -64,6 +64,7 @@ probably misplaced */
 #include "KX_NearSensor.h"
 #include "KX_RadarSensor.h"
 #include "KX_MouseFocusSensor.h"
+#include "KX_ArmatureSensor.h"
 #include "SCA_JoystickSensor.h"
 #include "KX_NetworkMessageSensor.h"
 #include "SCA_ActuatorSensor.h"
@@ -302,7 +303,7 @@ void BL_ConvertSensors(struct Object* blenderobject,
 		case  SENS_ALWAYS:
 			{
 				
-				SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::ALWAYS_EVENTMGR);
+				SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::BASIC_EVENTMGR);
 				if (eventmgr)
 				{
 					gamesensor = new SCA_AlwaysSensor(eventmgr, gameobj);
@@ -314,7 +315,7 @@ void BL_ConvertSensors(struct Object* blenderobject,
 		case  SENS_DELAY:
 			{
 				// we can reuse the Always event manager for the delay sensor
-				SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::ALWAYS_EVENTMGR);
+				SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::BASIC_EVENTMGR);
 				if (eventmgr)
 				{
 					bDelaySensor* delaysensor = (bDelaySensor*)sens->data;
@@ -550,7 +551,7 @@ void BL_ConvertSensors(struct Object* blenderobject,
 			{
 				bPropertySensor* blenderpropsensor = (bPropertySensor*) sens->data;
 				SCA_EventManager* eventmgr 
-					= logicmgr->FindEventManager(SCA_EventManager::PROPERTY_EVENTMGR);
+					= logicmgr->FindEventManager(SCA_EventManager::BASIC_EVENTMGR);
 				if (eventmgr)
 				{
 					STR_String propname=blenderpropsensor->name;
@@ -601,6 +602,21 @@ void BL_ConvertSensors(struct Object* blenderobject,
 				break;
 			}
 			
+		case SENS_ARMATURE:
+			{
+				bArmatureSensor* blenderarmsensor = (bArmatureSensor*) sens->data;
+				// we will reuse the property event manager, there is nothing special with this sensor
+				SCA_EventManager* eventmgr 
+					= logicmgr->FindEventManager(SCA_EventManager::BASIC_EVENTMGR);
+				if (eventmgr)
+				{
+					STR_String bonename=blenderarmsensor->posechannel;
+					STR_String constraintname=blenderarmsensor->constraint;
+					gamesensor = new KX_ArmatureSensor(eventmgr,gameobj,bonename,constraintname, blenderarmsensor->type, blenderarmsensor->value);
+				}
+				break;
+			}
+
 		case SENS_RADAR:
 			{
 				
@@ -659,7 +675,7 @@ void BL_ConvertSensors(struct Object* blenderobject,
 				bRaySensor* blenderraysensor = (bRaySensor*) sens->data;
 				
 				//blenderradarsensor->angle;
-				SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::RAY_EVENTMGR);
+				SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::BASIC_EVENTMGR);
 				if (eventmgr)
 				{
 					bool bFindMaterial = (blenderraysensor->mode & SENS_COLLISION_MATERIAL);
@@ -691,7 +707,7 @@ void BL_ConvertSensors(struct Object* blenderobject,
 				// some files didn't write randomsensor, avoid crash now for NULL ptr's
 				if (blenderrndsensor)
 				{
-					SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::RANDOM_EVENTMGR);
+					SCA_EventManager* eventmgr = logicmgr->FindEventManager(SCA_EventManager::BASIC_EVENTMGR);
 					if (eventmgr)
 					{
 						int randomSeed = blenderrndsensor->seed;
diff --git a/source/gameengine/Converter/Makefile b/source/gameengine/Converter/Makefile
index e261f9350e9..d41cc705087 100644
--- a/source/gameengine/Converter/Makefile
+++ b/source/gameengine/Converter/Makefile
@@ -53,6 +53,7 @@ CPPFLAGS += -I../../blender/blenlib
 CPPFLAGS += -I../../blender/blenkernel
 CPPFLAGS += -I../../blender/render/extern/include
 CPPFLAGS += -I../../blender/gpu
+CPPFLAGS += -I../../blender/ikplugin
 CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
 CPPFLAGS += -I../Expressions -I../Rasterizer -I../GameLogic
 CPPFLAGS += -I../Ketsji -I../BlenderRoutines -I../SceneGraph
diff --git a/source/gameengine/Converter/SConscript b/source/gameengine/Converter/SConscript
index 2d126310475..5f6e9df521b 100644
--- a/source/gameengine/Converter/SConscript
+++ b/source/gameengine/Converter/SConscript
@@ -19,6 +19,7 @@ incs += ' #source/gameengine/Network/LoopBackNetwork'
 incs += ' #source/blender/misc #source/blender/blenloader #source/blender/gpu'
 incs += ' #source/blender/windowmanager'
 incs += ' #source/blender/makesrna'
+incs += ' #source/blender/ikplugin'
 
 incs += ' ' + env['BF_PYTHON_INC']
 incs += ' ' + env['BF_BULLET_INC']
diff --git a/source/gameengine/Expressions/CMakeLists.txt b/source/gameengine/Expressions/CMakeLists.txt
index 439a50852a7..ec3738d1fe8 100644
--- a/source/gameengine/Expressions/CMakeLists.txt
+++ b/source/gameengine/Expressions/CMakeLists.txt
@@ -30,6 +30,7 @@ SET(INC
 	.
 	../../../source/kernel/gen_system
 	../../../intern/string
+	../../../intern/guardedalloc
 	../../../intern/moto/include
 	../../../source/gameengine/SceneGraph
 	../../../source/blender/blenloader
diff --git a/source/gameengine/Expressions/PyObjectPlus.cpp b/source/gameengine/Expressions/PyObjectPlus.cpp
index 1d1d9e6103b..7adbf5ac651 100644
--- a/source/gameengine/Expressions/PyObjectPlus.cpp
+++ b/source/gameengine/Expressions/PyObjectPlus.cpp
@@ -51,6 +51,7 @@
 #include "PyObjectPlus.h"
 #include "STR_String.h"
 #include "MT_Vector3.h"
+#include "MEM_guardedalloc.h"
 /*------------------------------
  * PyObjectPlus Type		-- Every class, even the abstract one should have a Type
 ------------------------------*/
@@ -95,7 +96,6 @@ PyObject *PyObjectPlus::py_base_repr(PyObject *self)			// This should be the ent
 		PyErr_SetString(PyExc_SystemError, BGE_PROXY_ERROR_MSG);
 		return NULL;
 	}
-	
 	return self_plus->py_repr();  
 }
 
@@ -145,42 +145,55 @@ PyObject * PyObjectPlus::py_base_new(PyTypeObject *type, PyObject *args, PyObjec
 
 	PyObjectPlus_Proxy *ret = (PyObjectPlus_Proxy *) type->tp_alloc(type, 0); /* starts with 1 ref, used for the return ref' */
 	ret->ref= base->ref;
-	base->ref= NULL;		/* invalidate! disallow further access */
-
+	ret->ptr= base->ptr;
 	ret->py_owns= base->py_owns;
+	ret->py_ref = base->py_ref;
 
-	ret->ref->m_proxy= NULL;
-
-	/* 'base' may be free'd after this func finished but not necessarily
-	 * there is no reference to the BGE data now so it will throw an error on access */
-	Py_DECREF(base);
-
-	ret->ref->m_proxy= (PyObject *)ret; /* no need to add a ref because one is added when creating. */
-	Py_INCREF(ret); /* we return a new ref but m_proxy holds a ref so we need to add one */
-
-
-	/* 'ret' will have 2 references.
-	 * - One ref is needed because ret->ref->m_proxy holds a refcount to the current proxy.
-	 * - Another is needed for returning the value.
-	 *
-	 * So we should be ok with 2 refs, but for some reason this crashes. so adding a new ref...
-	 * */
+	if (ret->py_ref) {
+		base->ref= NULL;		/* invalidate! disallow further access */
+		base->ptr = NULL;
+		if (ret->ref)
+			ret->ref->m_proxy= NULL;
+		/* 'base' may be free'd after this func finished but not necessarily
+		 * there is no reference to the BGE data now so it will throw an error on access */
+		Py_DECREF(base);
+		if (ret->ref) {
+			ret->ref->m_proxy= (PyObject *)ret; /* no need to add a ref because one is added when creating. */
+			Py_INCREF(ret); /* we return a new ref but m_proxy holds a ref so we need to add one */
+		}
+	} else {
+		// generic structures don't hold a reference to this proxy, so don't increment ref count
+		if (ret->py_owns)
+			// but if the proxy owns the structure, there can be only one owner
+			base->ptr= NULL;
+	}
 
 	return (PyObject *)ret;
 }
 
 void PyObjectPlus::py_base_dealloc(PyObject *self)				// python wrapper
 {
-	PyObjectPlus *self_plus= BGE_PROXY_REF(self);
-	if(self_plus) {
-		if(BGE_PROXY_PYOWNS(self)) { /* Does python own this?, then delete it  */
-			self_plus->m_proxy = NULL; /* Need this to stop ~PyObjectPlus from decrefing m_proxy otherwise its decref'd twice and py-debug crashes */
-			delete self_plus;
+	if (BGE_PROXY_PYREF(self)) {
+		PyObjectPlus *self_plus= BGE_PROXY_REF(self);
+		if(self_plus) {
+			if(BGE_PROXY_PYOWNS(self)) { /* Does python own this?, then delete it  */
+				self_plus->m_proxy = NULL; /* Need this to stop ~PyObjectPlus from decrefing m_proxy otherwise its decref'd twice and py-debug crashes */
+				delete self_plus;
+			}
+			BGE_PROXY_REF(self)= NULL; // not really needed
+		}
+		// the generic pointer is not deleted directly, only through self_plus
+		BGE_PROXY_PTR(self)= NULL; // not really needed
+	} else {
+		void *ptr= BGE_PROXY_PTR(self);
+		if(ptr) {
+			if(BGE_PROXY_PYOWNS(self)) { /* Does python own this?, then delete it  */
+				// generic structure owned by python MUST be created though MEM_alloc
+				MEM_freeN(ptr);
+			}
+			BGE_PROXY_PTR(self)= NULL; // not really needed
 		}
-
-		BGE_PROXY_REF(self)= NULL; // not really needed
 	}
-
 #if 0
 	/* is ok normally but not for subtyping, use tp_free instead. */
 	PyObject_DEL( self );
@@ -217,8 +230,9 @@ PyObject* PyObjectPlus::pyattr_get_invalid(void *self_v, const KX_PYATTRIBUTE_DE
 /* note, this is called as a python 'getset, where the PyAttributeDef is the closure */
 PyObject *PyObjectPlus::py_get_attrdef(PyObject *self_py, const PyAttributeDef *attrdef)
 {
-	void *self= (void *)(BGE_PROXY_REF(self_py));
-	if(self==NULL) {
+	PyObjectPlus *ref= (BGE_PROXY_REF(self_py));
+	char* ptr = (attrdef->m_usePtr) ? (char*)BGE_PROXY_PTR(self_py) : (char*)ref;
+	if(ptr == NULL || (BGE_PROXY_PYREF(self_py) && (ref==NULL || !ref->py_is_valid()))) {
 		if(attrdef == attr_invalid)
 			Py_RETURN_TRUE; // dont bother running the function
 
@@ -226,7 +240,6 @@ PyObject *PyObjectPlus::py_get_attrdef(PyObject *self_py, const PyAttributeDef *
 		return NULL;
 	}
 
-
 	if (attrdef->m_type == KX_PYATTRIBUTE_TYPE_DUMMY)
 	{
 		// fake attribute, ignore
@@ -237,9 +250,9 @@ PyObject *PyObjectPlus::py_get_attrdef(PyObject *self_py, const PyAttributeDef *
 		// the attribute has no field correspondance, handover processing to function.
 		if (attrdef->m_getFunction == NULL)
 			return NULL;
-		return (*attrdef->m_getFunction)(self, attrdef);
+		return (*attrdef->m_getFunction)(ref, attrdef);
 	}
-	char *ptr = reinterpret_cast<char*>(self)+attrdef->m_offset;
+	ptr += attrdef->m_offset;
 	if (attrdef->m_length > 1)
 	{
 		PyObject* resultlist = PyList_New(attrdef->m_length);
@@ -293,6 +306,35 @@ PyObject *PyObjectPlus::py_get_attrdef(PyObject *self_py, const PyAttributeDef *
 	else
 	{
 		switch (attrdef->m_type) {
+		case KX_PYATTRIBUTE_TYPE_FLAG:
+			{
+				bool bval;
+				switch (attrdef->m_size) {
+				case 1:
+					{
+						unsigned char *val = reinterpret_cast<unsigned char*>(ptr);
+						bval = (*val & attrdef->m_imin);
+						break;
+					}
+				case 2:
+					{
+						unsigned short *val = reinterpret_cast<unsigned short*>(ptr);
+						bval = (*val & attrdef->m_imin);
+						break;
+					}
+				case 4:
+					{
+						unsigned int *val = reinterpret_cast<unsigned int*>(ptr);
+						bval = (*val & attrdef->m_imin);
+						break;
+					}
+				default:
+					return NULL;
+				}
+				if (attrdef->m_imax)
+					bval = !bval;
+				return PyLong_FromSsize_t(bval);
+			}
 		case KX_PYATTRIBUTE_TYPE_BOOL:
 			{
 				bool *val = reinterpret_cast<bool*>(ptr);
@@ -318,7 +360,49 @@ PyObject *PyObjectPlus::py_get_attrdef(PyObject *self_py, const PyAttributeDef *
 		case KX_PYATTRIBUTE_TYPE_FLOAT:
 			{
 				float *val = reinterpret_cast<float*>(ptr);
-				return PyFloat_FromDouble(*val);
+				if (attrdef->m_imin == 0) {
+					if (attrdef->m_imax == 0) {
+						return PyFloat_FromDouble(*val);
+					} else {
+						// vector, verify size
+						if (attrdef->m_size != attrdef->m_imax*sizeof(float)) 
+						{
+							return NULL;
+						}
+#ifdef USE_MATHUTILS
+						return newVectorObject(val, attrdef->m_imax, Py_NEW, NULL);
+#else
+						PyObject* resultlist = PyList_New(attrdef->m_imax);
+						for (unsigned int i=0; i<attrdef->m_imax; i++)
+						{
+							PyList_SET_ITEM(resultlist,i,PyFloat_FromDouble(val[i]));
+						}
+						return resultlist;
+#endif
+					}
+				} else {
+					// matrix case
+					if (attrdef->m_size != attrdef->m_imax*attrdef->m_imin*sizeof(float)) 
+					{
+						return NULL;
+					}
+#ifdef USE_MATHUTILS
+					return newMatrixObject(val, attrdef->m_imin, attrdef->m_imax, Py_WRAP, NULL);
+#else
+					PyObject* rowlist = PyList_New(attrdef->m_imin);
+					for (unsigned int i=0; i<attrdef->m_imin; i++)
+					{
+						PyObject* collist = PyList_New(attrdef->m_imax);
+						for (unsigned int j=0; j<attrdef->m_imax; j++)
+						{
+							PyList_SET_ITEM(collist,j,PyFloat_FromDouble(val[j]));
+						}
+						PyList_SET_ITEM(rowlist,i,collist);
+						val += attrdef->m_imax;
+					}
+					return rowlist;
+#endif
+				}
 			}
 		case KX_PYATTRIBUTE_TYPE_VECTOR:
 			{
@@ -340,17 +424,47 @@ PyObject *PyObjectPlus::py_get_attrdef(PyObject *self_py, const PyAttributeDef *
 				STR_String *val = reinterpret_cast<STR_String*>(ptr);
 				return PyUnicode_FromString(*val);
 			}
+		case KX_PYATTRIBUTE_TYPE_CHAR:
+			{
+				return PyUnicode_FromString(ptr);
+			}
 		default:
 			return NULL;
 		}
 	}
 }
 
+
+static bool py_check_attr_float(float *var, PyObject *value, const PyAttributeDef *attrdef)
+{
+	double val = PyFloat_AsDouble(value);
+	if (val == -1.0 && PyErr_Occurred())
+	{
+		PyErr_Format(PyExc_TypeError, "expected float value for attribute \"%s\"", attrdef->m_name);
+		return false;
+	}
+	if (attrdef->m_clamp)
+	{
+		if (val < attrdef->m_fmin)
+			val = attrdef->m_fmin;
+		else if (val > attrdef->m_fmax)
+			val = attrdef->m_fmax;
+	}
+	else if (val < attrdef->m_fmin || val > attrdef->m_fmax)
+	{
+		PyErr_Format(PyExc_ValueError, "value out of range for attribute \"%s\"", attrdef->m_name);
+		return false;
+	}
+	*var = (float)val;
+	return true;
+}
+
 /* note, this is called as a python getset */
 int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAttributeDef *attrdef)
 {
-	void *self= (void *)(BGE_PROXY_REF(self_py));
-	if(self==NULL) {
+	PyObjectPlus *ref= (BGE_PROXY_REF(self_py));
+	char* ptr = (attrdef->m_usePtr) ? (char*)BGE_PROXY_PTR(self_py) : (char*)ref;
+	if(ref==NULL || !ref->py_is_valid() || ptr==NULL) {
 		PyErr_SetString(PyExc_SystemError, BGE_PROXY_ERROR_MSG);
 		return PY_SET_ATTR_FAIL;
 	}
@@ -358,8 +472,10 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 	void *undoBuffer = NULL;
 	void *sourceBuffer = NULL;
 	size_t bufferSize = 0;
+	PyObject *item = NULL;	// to store object that must be dereferenced in case of error
+	PyObject *list = NULL;	// to store object that must be dereferenced in case of error
 	
-	char *ptr = reinterpret_cast<char*>(self)+attrdef->m_offset;
+	ptr += attrdef->m_offset;
 	if (attrdef->m_length > 1)
 	{
 		if (!PySequence_Check(value)) 
@@ -380,7 +496,7 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 				PyErr_Format(PyExc_AttributeError, "function attribute without function for attribute \"%s\", report to blender.org", attrdef->m_name);
 				return PY_SET_ATTR_FAIL;
 			}
-			return (*attrdef->m_setFunction)(self, attrdef, value);
+			return (*attrdef->m_setFunction)(ref, attrdef, value);
 		case KX_PYATTRIBUTE_TYPE_BOOL:
 			bufferSize = sizeof(bool);
 			break;
@@ -409,10 +525,7 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 		}
 		for (int i=0; i<attrdef->m_length; i++)
 		{
-			PyObject *item = PySequence_GetItem(value, i); /* new ref */
-			// we can decrement the reference immediately, the reference count
-			// is at least 1 because the item is part of an array
-			Py_DECREF(item);
+			item = PySequence_GetItem(value, i); /* new ref */
 			switch (attrdef->m_type) 
 			{
 			case KX_PYATTRIBUTE_TYPE_BOOL:
@@ -528,11 +641,14 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 				PyErr_Format(PyExc_AttributeError, "type check error for attribute \"%s\", report to blender.org", attrdef->m_name);
 				goto UNDO_AND_ERROR;
 			}
+			// finished using item, release
+			Py_DECREF(item);
+			item = NULL;
 		}
 		// no error, call check function if any
 		if (attrdef->m_checkFunction != NULL)
 		{
-			if ((*attrdef->m_checkFunction)(self, attrdef) != 0)
+			if ((*attrdef->m_checkFunction)(ref, attrdef) != 0)
 			{
 				// if the checing function didnt set an error then set a generic one here so we dont set an error with no exception
 				if (PyErr_Occurred()==0)
@@ -545,6 +661,8 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 					memcpy(sourceBuffer, undoBuffer, bufferSize);
 					free(undoBuffer);
 				}
+				if (item)
+					Py_DECREF(item);
 				return PY_SET_ATTR_FAIL;
 			}
 		}
@@ -561,7 +679,7 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 				PyErr_Format(PyExc_AttributeError, "function attribute without function \"%s\", report to blender.org", attrdef->m_name);
 				return PY_SET_ATTR_FAIL;
 			}
-			return (*attrdef->m_setFunction)(self, attrdef, value);
+			return (*attrdef->m_setFunction)(ref, attrdef, value);
 		}
 		if (attrdef->m_checkFunction != NULL || attrdef->m_type == KX_PYATTRIBUTE_TYPE_VECTOR)
 		{
@@ -576,11 +694,19 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 				bufferSize = sizeof(short);
 				break;
 			case KX_PYATTRIBUTE_TYPE_ENUM:
+			case KX_PYATTRIBUTE_TYPE_FLAG:
+			case KX_PYATTRIBUTE_TYPE_CHAR:
+				bufferSize = attrdef->m_size;
+				break;
 			case KX_PYATTRIBUTE_TYPE_INT:
 				bufferSize = sizeof(int);
 				break;
 			case KX_PYATTRIBUTE_TYPE_FLOAT:
 				bufferSize = sizeof(float);
+				if (attrdef->m_imax)
+					bufferSize *= attrdef->m_imax;
+				if (attrdef->m_imin)
+					bufferSize *= attrdef->m_imin;
 				break;
 			case KX_PYATTRIBUTE_TYPE_STRING:
 				sourceBuffer = reinterpret_cast<STR_String*>(ptr)->Ptr();
@@ -624,6 +750,49 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 				}
 				break;
 			}
+		case KX_PYATTRIBUTE_TYPE_FLAG:
+			{
+				bool bval;
+				if (PyLong_Check(value)) 
+				{
+					bval = (PyLong_AsSsize_t(value) != 0);
+				} 
+				else if (PyBool_Check(value))
+				{
+					bval = (value == Py_True);
+				}
+				else
+				{
+					PyErr_Format(PyExc_TypeError, "expected an integer or a bool for attribute \"%s\"", attrdef->m_name);
+					goto FREE_AND_ERROR;
+				}
+				if (attrdef->m_imax)
+					bval = !bval;
+				switch (attrdef->m_size) {
+				case 1:
+					{
+						unsigned char *val = reinterpret_cast<unsigned char*>(ptr);
+						*val = (*val & ~attrdef->m_imin) | ((bval)?attrdef->m_imin:0);
+						break;
+					}
+				case 2:
+					{
+						unsigned short *val = reinterpret_cast<unsigned short*>(ptr);
+						*val = (*val & ~attrdef->m_imin) | ((bval)?attrdef->m_imin:0);
+						break;
+					}
+				case 4:
+					{
+						unsigned int *val = reinterpret_cast<unsigned int*>(ptr);
+						*val = (*val & ~attrdef->m_imin) | ((bval)?attrdef->m_imin:0);
+						break;
+					}
+				default:
+					PyErr_Format(PyExc_TypeError, "internal error: unsupported flag field \"%s\"", attrdef->m_name);
+					goto FREE_AND_ERROR;
+				}
+				break;
+			}
 		case KX_PYATTRIBUTE_TYPE_SHORT:
 			{
 				short int *var = reinterpret_cast<short int*>(ptr);
@@ -689,25 +858,71 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 		case KX_PYATTRIBUTE_TYPE_FLOAT:
 			{
 				float *var = reinterpret_cast<float*>(ptr);
-				double val = PyFloat_AsDouble(value);
-				if (val == -1.0 && PyErr_Occurred())
+				if (attrdef->m_imin != 0) 
 				{
-					PyErr_Format(PyExc_TypeError, "expected a float for attribute \"%s\"", attrdef->m_name);
-					goto FREE_AND_ERROR;
-				}
-				else if (attrdef->m_clamp)
+					if (attrdef->m_size != attrdef->m_imin*attrdef->m_imax*sizeof(float)) 
+					{
+						PyErr_Format(PyExc_TypeError, "internal error: incorrect field size for attribute \"%s\"", attrdef->m_name);
+						goto FREE_AND_ERROR;
+					}
+					if (!PySequence_Check(value) || PySequence_Size(value) != attrdef->m_imin) 
+					{
+						PyErr_Format(PyExc_TypeError, "expected a sequence of [%d][%d] floats for attribute \"%s\"", attrdef->m_imin, attrdef->m_imax, attrdef->m_name);
+						goto FREE_AND_ERROR;
+					}
+					for (int i=0; i<attrdef->m_imin; i++)
+					{
+						PyObject *list = PySequence_GetItem(value, i); /* new ref */
+						if (!PySequence_Check(list) || PySequence_Size(list) != attrdef->m_imax) 
+						{
+							PyErr_Format(PyExc_TypeError, "expected a sequence of [%d][%d] floats for attribute \"%s\"", attrdef->m_imin, attrdef->m_imax, attrdef->m_name);
+							goto RESTORE_AND_ERROR;
+						}
+						for (int j=0; j<attrdef->m_imax; j++)
+						{
+							item = PySequence_GetItem(list, j); /* new ref */
+							if (!py_check_attr_float(var, item, attrdef))
+							{
+								PyErr_Format(PyExc_TypeError, "expected a sequence of [%d][%d] floats for attribute \"%s\"", attrdef->m_imin, attrdef->m_imax, attrdef->m_name);
+								goto RESTORE_AND_ERROR;
+							}
+							Py_DECREF(item);
+							item = NULL;
+							++var;
+						}
+						Py_DECREF(list);
+						list = NULL;
+					}
+				} 
+				else if (attrdef->m_imax != 0) 
 				{
-					if (val < attrdef->m_fmin)
-						val = attrdef->m_fmin;
-					else if (val > attrdef->m_fmax)
-						val = attrdef->m_fmax;
-				}
-				else if (val < attrdef->m_fmin || val > attrdef->m_fmax)
+					if (attrdef->m_size != attrdef->m_imax*sizeof(float)) 
+					{
+						PyErr_Format(PyExc_TypeError, "internal error: incorrect field size for attribute \"%s\"", attrdef->m_name);
+						goto FREE_AND_ERROR;
+					}
+					if (!PySequence_Check(value) || PySequence_Size(value) != attrdef->m_imax) 
+					{
+						PyErr_Format(PyExc_TypeError, "expected a sequence of [%d] floats for attribute \"%s\"", attrdef->m_imax, attrdef->m_name);
+						goto FREE_AND_ERROR;
+					}
+					for (int i=0; i<attrdef->m_imax; i++)
+					{
+						item = PySequence_GetItem(value, i); /* new ref */
+						if (!py_check_attr_float(var, item, attrdef))
+						{
+							goto RESTORE_AND_ERROR;
+						}
+						Py_DECREF(item);
+						item = NULL;
+						++var;
+					}
+				} 
+				else
 				{
-					PyErr_Format(PyExc_ValueError, "value out of range for attribute \"%s\"", attrdef->m_name);
-					goto FREE_AND_ERROR;
+					if (!py_check_attr_float(var, value, attrdef))
+						goto FREE_AND_ERROR;
 				}
-				*var = (float)val;
 				break;
 			}
 		case KX_PYATTRIBUTE_TYPE_VECTOR:
@@ -715,16 +930,15 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 				if (!PySequence_Check(value) || PySequence_Size(value) != 3) 
 				{
 					PyErr_Format(PyExc_TypeError, "expected a sequence of 3 floats for attribute \"%s\"", attrdef->m_name);
-					return PY_SET_ATTR_FAIL;
+					goto FREE_AND_ERROR;
 				}
 				MT_Vector3 *var = reinterpret_cast<MT_Vector3*>(ptr);
 				for (int i=0; i<3; i++)
 				{
-					PyObject *item = PySequence_GetItem(value, i); /* new ref */
-					// we can decrement the reference immediately, the reference count
-					// is at least 1 because the item is part of an array
-					Py_DECREF(item);
+					item = PySequence_GetItem(value, i); /* new ref */
 					double val = PyFloat_AsDouble(item);
+					Py_DECREF(item);
+					item = NULL;
 					if (val == -1.0 && PyErr_Occurred())
 					{
 						PyErr_Format(PyExc_TypeError, "expected a sequence of 3 floats for attribute \"%s\"", attrdef->m_name);
@@ -746,6 +960,22 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 				}
 				break;
 			}
+		case KX_PYATTRIBUTE_TYPE_CHAR:
+			{
+				if (PyUnicode_Check(value)) 
+				{
+					Py_ssize_t val_len;
+					char *val = _PyUnicode_AsStringAndSize(value, &val_len);
+					strncpy(ptr, val, attrdef->m_size);
+					ptr[attrdef->m_size-1] = 0;
+				}
+				else
+				{
+					PyErr_Format(PyExc_TypeError, "expected a string for attribute \"%s\"", attrdef->m_name);
+					goto FREE_AND_ERROR;
+				}
+				break;
+			}
 		case KX_PYATTRIBUTE_TYPE_STRING:
 			{
 				STR_String *var = reinterpret_cast<STR_String*>(ptr);
@@ -793,7 +1023,7 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 	// check if post processing is needed
 	if (attrdef->m_checkFunction != NULL)
 	{
-		if ((*attrdef->m_checkFunction)(self, attrdef) != 0)
+		if ((*attrdef->m_checkFunction)(ref, attrdef) != 0)
 		{
 			// restore value
 		RESTORE_AND_ERROR:
@@ -814,6 +1044,10 @@ int PyObjectPlus::py_set_attrdef(PyObject *self_py, PyObject *value, const PyAtt
 		FREE_AND_ERROR:
 			if (undoBuffer)
 				free(undoBuffer);
+			if (list)
+				Py_DECREF(list);
+			if (item)
+				Py_DECREF(item);
 			return 1;
 		}
 	}
@@ -857,23 +1091,35 @@ void PyObjectPlus::InvalidateProxy()		// check typename of each parent
 	}
 }
 
-PyObject *PyObjectPlus::GetProxy_Ext(PyObjectPlus *self, PyTypeObject *tp)
+PyObject *PyObjectPlus::GetProxyPlus_Ext(PyObjectPlus *self, PyTypeObject *tp, void *ptr)
 {
 	if (self->m_proxy==NULL)
 	{
 		self->m_proxy = reinterpret_cast<PyObject *>PyObject_NEW( PyObjectPlus_Proxy, tp);
 		BGE_PROXY_PYOWNS(self->m_proxy) = false;
+		BGE_PROXY_PYREF(self->m_proxy) = true;
 	}
 	//PyObject_Print(self->m_proxy, stdout, 0);
 	//printf("ref %d\n", self->m_proxy->ob_refcnt);
 	
 	BGE_PROXY_REF(self->m_proxy) = self; /* Its possible this was set to NULL, so set it back here */
+	BGE_PROXY_PTR(self->m_proxy) = ptr;
 	Py_INCREF(self->m_proxy); /* we own one, thos ones fore the return */
 	return self->m_proxy;
 }
 
-PyObject *PyObjectPlus::NewProxy_Ext(PyObjectPlus *self, PyTypeObject *tp, bool py_owns)
+PyObject *PyObjectPlus::NewProxyPlus_Ext(PyObjectPlus *self, PyTypeObject *tp, void *ptr, bool py_owns)
 {
+	if (!self) 
+	{
+		// in case of proxy without reference to game object
+		PyObject* proxy = reinterpret_cast<PyObject *>PyObject_NEW( PyObjectPlus_Proxy, tp);
+		BGE_PROXY_PYREF(proxy) = false;
+		BGE_PROXY_PYOWNS(proxy) = py_owns;
+		BGE_PROXY_REF(proxy) = NULL; 
+		BGE_PROXY_PTR(proxy) = ptr;
+		return proxy;
+	}
 	if (self->m_proxy)
 	{
 		if(py_owns)
@@ -889,7 +1135,7 @@ PyObject *PyObjectPlus::NewProxy_Ext(PyObjectPlus *self, PyTypeObject *tp, bool
 		
 	}
 	
-	GetProxy_Ext(self, tp);
+	GetProxyPlus_Ext(self, tp, ptr);
 	if(py_owns) {
 		BGE_PROXY_PYOWNS(self->m_proxy) = py_owns;
 		Py_DECREF(self->m_proxy); /* could avoid thrashing here but for now its ok */
diff --git a/source/gameengine/Expressions/PyObjectPlus.h b/source/gameengine/Expressions/PyObjectPlus.h
index d8ab007dde9..237f01f5a3a 100644
--- a/source/gameengine/Expressions/PyObjectPlus.h
+++ b/source/gameengine/Expressions/PyObjectPlus.h
@@ -88,13 +88,17 @@ typedef struct {
 
 typedef struct PyObjectPlus_Proxy {
 	PyObject_HEAD		/* required python macro   */
-	class PyObjectPlus *ref;
-	bool py_owns;
+	class PyObjectPlus *ref;	// pointer to GE object, it holds a reference to this proxy
+	void *ptr;					// optional pointer to generic structure, the structure holds no reference to this proxy
+	bool py_owns;		// true if the object pointed by ref should be deleted when the proxy is deleted
+	bool py_ref;		// true if proxy is connected to a GE object (ref is used)
 } PyObjectPlus_Proxy;
 
 #define BGE_PROXY_ERROR_MSG "Blender Game Engine data has been freed, cannot use this python variable"
 #define BGE_PROXY_REF(_self) (((PyObjectPlus_Proxy *)_self)->ref)
+#define BGE_PROXY_PTR(_self) (((PyObjectPlus_Proxy *)_self)->ptr)
 #define BGE_PROXY_PYOWNS(_self) (((PyObjectPlus_Proxy *)_self)->py_owns)
+#define BGE_PROXY_PYREF(_self) (((PyObjectPlus_Proxy *)_self)->py_ref)
 
 /* Note, sometimes we dont care what BGE type this is as long as its a proxy */
 #define BGE_PROXY_CHECK_TYPE(_type) ((_type)->tp_dealloc == PyObjectPlus::py_base_dealloc)
@@ -103,27 +107,51 @@ typedef struct PyObjectPlus_Proxy {
 #define BGE_PROXY_FROM_REF(_self) (((PyObjectPlus *)_self)->GetProxy())
 
 
-								// This must be the first line of each 
-								// PyC++ class
+// This must be the first line of each 
+// PyC++ class
+// AttributesPtr correspond to attributes of proxy generic pointer 
+// each PyC++ class must be registered in KX_PythonInitTypes.cpp
 #define __Py_Header \
  public: \
   static PyTypeObject   Type; \
   static PyMethodDef    Methods[]; \
   static PyAttributeDef Attributes[]; \
   virtual PyTypeObject *GetType(void) {return &Type;}; \
-  virtual PyObject *GetProxy() {return GetProxy_Ext(this, &Type);}; \
-  virtual PyObject *NewProxy(bool py_owns) {return NewProxy_Ext(this, &Type, py_owns);}; 
+  virtual PyObject *GetProxy() {return GetProxyPlus_Ext(this, &Type, NULL);}; \
+  virtual PyObject *NewProxy(bool py_owns) {return NewProxyPlus_Ext(this, &Type, NULL, py_owns);}; \
 
+// leave above line empty (macro)!
+// use this macro for class that use generic pointer in proxy
+// GetProxy() and NewProxy() must be defined to set the correct pointer in the proxy
+#define __Py_HeaderPtr \
+ public: \
+  static PyTypeObject   Type; \
+  static PyMethodDef    Methods[]; \
+  static PyAttributeDef Attributes[]; \
+  static PyAttributeDef AttributesPtr[]; \
+  virtual PyTypeObject *GetType(void) {return &Type;}; \
+  virtual PyObject *GetProxy(); \
+  virtual PyObject *NewProxy(bool py_owns); \
 
+// leave above line empty (macro)!
 #ifdef WITH_CXX_GUARDEDALLOC
 #define Py_Header __Py_Header \
   void *operator new( unsigned int num_bytes) { return MEM_mallocN(num_bytes, Type.tp_name); } \
-  void operator delete( void *mem ) { MEM_freeN(mem); } 
+  void operator delete( void *mem ) { MEM_freeN(mem); } \
 
 #else
 #define Py_Header __Py_Header
 #endif
 
+#ifdef WITH_CXX_GUARDEDALLOC
+#define Py_HeaderPtr __Py_HeaderPtr \
+  void *operator new( unsigned int num_bytes) { return MEM_mallocN(num_bytes, Type.tp_name); } \
+  void operator delete( void *mem ) { MEM_freeN(mem); } \
+
+#else
+#define Py_HeaderPtr __Py_HeaderPtr
+#endif
+
 /*
  * nonzero values are an error for setattr
  * however because of the nested lookups we need to know if the errors
@@ -245,6 +273,8 @@ enum KX_PYATTRIBUTE_TYPE {
 	KX_PYATTRIBUTE_TYPE_DUMMY,
 	KX_PYATTRIBUTE_TYPE_FUNCTION,
 	KX_PYATTRIBUTE_TYPE_VECTOR,
+	KX_PYATTRIBUTE_TYPE_FLAG,
+	KX_PYATTRIBUTE_TYPE_CHAR,
 };
 
 enum KX_PYATTRIBUTE_ACCESS {
@@ -261,11 +291,14 @@ typedef struct KX_PYATTRIBUTE_DEF {
 	const char *m_name;				// name of the python attribute
 	KX_PYATTRIBUTE_TYPE m_type;		// type of value
 	KX_PYATTRIBUTE_ACCESS m_access;	// read/write access or read-only
-	int m_imin;						// minimum value in case of integer attributes (for string: minimum string length)
-	int m_imax;						// maximum value in case of integer attributes (for string: maximum string length)
+	int m_imin;						// minimum value in case of integer attributes 
+									// (for string: minimum string length, for flag: mask value, for float: matrix row size)
+	int m_imax;						// maximum value in case of integer attributes 
+									// (for string: maximum string length, for flag: 1 if flag is negative, float: vector/matrix col size)
 	float m_fmin;					// minimum value in case of float attributes
 	float m_fmax;					// maximum value in case of float attributes
 	bool   m_clamp;					// enforce min/max value by clamping
+	bool   m_usePtr;				// the attribute uses the proxy generic pointer, set at runtime
 	size_t m_offset;				// position of field in structure
 	size_t m_size;					// size of field for runtime verification (enum only)
 	size_t m_length;				// length of array, 1=simple attribute
@@ -283,104 +316,146 @@ typedef struct KX_PYATTRIBUTE_DEF {
 		float *m_floatPtr;
 		STR_String *m_stringPtr;
 		MT_Vector3 *m_vectorPtr;
+		char *m_charPtr;
 	} m_typeCheck;
 } PyAttributeDef;
 
 #define KX_PYATTRIBUTE_DUMMY(name) \
-	{ name, KX_PYATTRIBUTE_TYPE_DUMMY, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, 0, 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_DUMMY, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, 0, 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 
 #define KX_PYATTRIBUTE_BOOL_RW(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_BOOL, KX_PYATTRIBUTE_RW, 0, 1, 0.f, 0.f, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {&((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_BOOL, KX_PYATTRIBUTE_RW, 0, 1, 0.f, 0.f, false, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {&((object *)0)->field, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_BOOL_RW_CHECK(name,object,field,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_BOOL, KX_PYATTRIBUTE_RW, 0, 1, 0.f, 0.f, false, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {&((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_BOOL, KX_PYATTRIBUTE_RW, 0, 1, 0.f, 0.f, false, false, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {&((object *)0)->field, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_BOOL_RO(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_BOOL, KX_PYATTRIBUTE_RO, 0, 1, 0.f, 0.f, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {&((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_BOOL, KX_PYATTRIBUTE_RO, 0, 1, 0.f, 0.f, false, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {&((object *)0)->field, NULL, NULL, NULL, NULL, NULL, NULL} }
+
+/* attribute points to a single bit of an integer field, attribute=true if bit is set */
+#define KX_PYATTRIBUTE_FLAG_RW(name,object,field,bit) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLAG, KX_PYATTRIBUTE_RW, bit, 0, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLAG_RW_CHECK(name,object,field,bit,function) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLAG, KX_PYATTRIBUTE_RW, bit, 0, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLAG_RO(name,object,field,bit) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLAG, KX_PYATTRIBUTE_RO, bit, 0, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
+
+/* attribute points to a single bit of an integer field, attribute=true if bit is set*/
+#define KX_PYATTRIBUTE_FLAG_NEGATIVE_RW(name,object,field,bit) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLAG, KX_PYATTRIBUTE_RW, bit, 1, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLAG_NEGATIVE_RW_CHECK(name,object,field,bit,function) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLAG, KX_PYATTRIBUTE_RW, bit, 1, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLAG_NEGATIVE_RO(name,object,field,bit) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLAG, KX_PYATTRIBUTE_RO, bit, 1, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 
 // enum field cannot be mapped to pointer (because we would need a pointer for each enum)
 // use field size to verify mapping at runtime only, assuming enum size is equal to int size.
 #define KX_PYATTRIBUTE_ENUM_RW(name,min,max,clamp,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_ENUM, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_ENUM, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_ENUM_RW_CHECK(name,min,max,clamp,object,field,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_ENUM, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), sizeof(((object *)0)->field), 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_ENUM, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), sizeof(((object *)0)->field), 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_ENUM_RO(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_ENUM, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_ENUM, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 
 #define KX_PYATTRIBUTE_SHORT_RW(name,min,max,clamp,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_SHORT_RW_CHECK(name,min,max,clamp,object,field,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_SHORT_RO(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_SHORT_ARRAY_RW(name,min,max,clamp,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, ((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, ((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_SHORT_ARRAY_RW_CHECK(name,min,max,clamp,object,field,length,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, ((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, ((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_SHORT_ARRAY_RO(name,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, ((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, ((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 // SHORT_LIST
 #define KX_PYATTRIBUTE_SHORT_LIST_RW(name,min,max,clamp,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_SHORT_LIST_RW_CHECK(name,min,max,clamp,object,field,length,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_SHORT_LIST_RO(name,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_SHORT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, &((object *)0)->field, NULL, NULL, NULL, NULL, NULL} }
 
 #define KX_PYATTRIBUTE_INT_RW(name,min,max,clamp,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_INT_RW_CHECK(name,min,max,clamp,object,field,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_INT_RO(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_INT_ARRAY_RW(name,min,max,clamp,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, ((object *)0)->field, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_INT_ARRAY_RW_CHECK(name,min,max,clamp,object,field,length,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, NULL, ((object *)0)->field, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_INT_ARRAY_RO(name,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, ((object *)0)->field, NULL, NULL, NULL, NULL} }
 // INT_LIST
 #define KX_PYATTRIBUTE_INT_LIST_RW(name,min,max,clamp,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_INT_LIST_RW_CHECK(name,min,max,clamp,object,field,length,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_INT_LIST_RO(name,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_INT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, &((object *)0)->field, NULL, NULL, NULL, NULL} }
 
 // always clamp for float
 #define KX_PYATTRIBUTE_FLOAT_RW(name,min,max,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, &((object *)0)->field, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_FLOAT_RW_CHECK(name,min,max,object,field,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, NULL, &((object *)0)->field, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, false, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_FLOAT_RO(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, &((object *)0)->field, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, &((object *)0)->field, NULL, NULL, NULL} }
+// field must be float[n], returns a sequence
 #define KX_PYATTRIBUTE_FLOAT_ARRAY_RW(name,min,max,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_FLOAT_ARRAY_RW_CHECK(name,min,max,object,field,length,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, false, offsetof(object,field), 0, length, &object::function, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_FLOAT_ARRAY_RO(name,object,field,length) \
-	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL} }
-
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, length, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
+// field must be float[n], returns a vector
+#define KX_PYATTRIBUTE_FLOAT_VECTOR_RW(name,min,max,object,field,length) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, length, min, max, true, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLOAT_VECTOR_RW_CHECK(name,min,max,object,field,length,function) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, 0, length, min, max, true, false, offsetof(object,field), sizeof(((object *)0)->field), 1, &object::function, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLOAT_VECTOR_RO(name,object,field,length) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RO, 0, length, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field, NULL, NULL, NULL} }
+// field must be float[n][n], returns a matrix
+#define KX_PYATTRIBUTE_FLOAT_MATRIX_RW(name,min,max,object,field,length) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, length, length, min, max, true, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field[0], NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLOAT_MATRIX_RW_CHECK(name,min,max,object,field,length,function) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RW, length, length, min, max, true, false, offsetof(object,field), sizeof(((object *)0)->field), 1, &object::function, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field[0], NULL, NULL, NULL} }
+#define KX_PYATTRIBUTE_FLOAT_MATRIX_RO(name,object,field,length) \
+	{ name, KX_PYATTRIBUTE_TYPE_FLOAT, KX_PYATTRIBUTE_RO, length, length, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, ((object *)0)->field[0], NULL, NULL, NULL} }
+
+// only for STR_String member
 #define KX_PYATTRIBUTE_STRING_RW(name,min,max,clamp,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_STRING, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, &((object *)0)->field, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_STRING, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, &((object *)0)->field, NULL, NULL} }
 #define KX_PYATTRIBUTE_STRING_RW_CHECK(name,min,max,clamp,object,field,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_STRING, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, &((object *)0)->field, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_STRING, KX_PYATTRIBUTE_RW, min, max, 0.f, 0.f, clamp, false, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, &((object *)0)->field, NULL, NULL} }
 #define KX_PYATTRIBUTE_STRING_RO(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_STRING, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, 1 , NULL, NULL, NULL, {NULL, NULL, NULL, NULL, &((object *)0)->field, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_STRING, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, 1 , NULL, NULL, NULL, {NULL, NULL, NULL, NULL, &((object *)0)->field, NULL, NULL} }
+
+// only for char [] array 
+#define KX_PYATTRIBUTE_CHAR_RW(name,object,field) \
+	{ name, KX_PYATTRIBUTE_TYPE_CHAR, KX_PYATTRIBUTE_RW, 0, 0, 0.f, 0.f, true, false, offsetof(object,field), sizeof(((object *)0)->field), 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, ((object *)0)->field} }
+#define KX_PYATTRIBUTE_CHAR_RW_CHECK(name,object,field,function) \
+	{ name, KX_PYATTRIBUTE_TYPE_CHAR, KX_PYATTRIBUTE_RW, 0, 0, 0.f, 0.f, true, false, offsetof(object,field), sizeof(((object *)0)->field), 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, ((object *)0)->field} }
+#define KX_PYATTRIBUTE_CHAR_RO(name,object,field) \
+	{ name, KX_PYATTRIBUTE_TYPE_CHAR, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), sizeof(((object *)0)->field), 1 , NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, NULL, ((object *)0)->field} }
 
+// for MT_Vector3 member
 #define KX_PYATTRIBUTE_VECTOR_RW(name,min,max,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_VECTOR, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, &((object *)0)->field} }
+	{ name, KX_PYATTRIBUTE_TYPE_VECTOR, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, false, offsetof(object,field), 0, 1, NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, &((object *)0)->field, NULL} }
 #define KX_PYATTRIBUTE_VECTOR_RW_CHECK(name,min,max,clamp,object,field,function) \
-	{ name, KX_PYATTRIBUTE_TYPE_VECTOR, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, &((object *)0)->field} }
+	{ name, KX_PYATTRIBUTE_TYPE_VECTOR, KX_PYATTRIBUTE_RW, 0, 0, min, max, true, false, offsetof(object,field), 0, 1, &object::function, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, &((object *)0)->field, NULL} }
 #define KX_PYATTRIBUTE_VECTOR_RO(name,object,field) \
-	{ name, KX_PYATTRIBUTE_TYPE_VECTOR, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, offsetof(object,field), 0, 1 , NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, &((object *)0)->field} }
+	{ name, KX_PYATTRIBUTE_TYPE_VECTOR, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, offsetof(object,field), 0, 1 , NULL, NULL, NULL, {NULL, NULL, NULL, NULL, NULL, &((object *)0)->field, NULL} }
 
 #define KX_PYATTRIBUTE_RW_FUNCTION(name,object,getfunction,setfunction) \
-	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RW, 0, 0, 0.f, 0.f, false, 0, 0, 1, NULL, &object::setfunction, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RW, 0, 0, 0.f, 0.f, false, false, 0, 0, 1, NULL, &object::setfunction, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_RO_FUNCTION(name,object,getfunction) \
-	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, 0, 0, 1, NULL, NULL, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0.f, false, false, 0, 0, 1, NULL, NULL, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_ARRAY_RW_FUNCTION(name,object,length,getfunction,setfunction) \
-	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RW, 0, 0, 0.f, 0,f, false, 0, 0, length, NULL, &object::setfunction, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RW, 0, 0, 0.f, 0,f, false, false, 0, 0, length, NULL, &object::setfunction, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 #define KX_PYATTRIBUTE_ARRAY_RO_FUNCTION(name,object,length,getfunction) \
-	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0,f, false, 0, 0, length, NULL, NULL, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL} }
+	{ name, KX_PYATTRIBUTE_TYPE_FUNCTION, KX_PYATTRIBUTE_RO, 0, 0, 0.f, 0,f, false, false, 0, 0, length, NULL, NULL, &object::getfunction, {NULL, NULL, NULL, NULL, NULL, NULL, NULL} }
 
 
 /*------------------------------
@@ -422,16 +497,23 @@ public:
 	/* These are all virtual python methods that are defined in each class
 	 * Our own fake subclassing calls these on each class, then calls the parent */
 	virtual PyObject*		py_repr(void);
+	/* subclass may overwrite this function to implement more sophisticated method of validating a proxy */
+	virtual bool			py_is_valid(void) { return true; }
 
 	static PyObject*		py_get_attrdef(PyObject *self_py, const PyAttributeDef *attrdef);
 	static int				py_set_attrdef(PyObject *self_py, PyObject *value, const PyAttributeDef *attrdef);
 	
 	/* Kindof dumb, always returns True, the false case is checked for, before this function gets accessed */
 	static PyObject*	pyattr_get_invalid(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef);
-	
-	static PyObject *GetProxy_Ext(PyObjectPlus *self, PyTypeObject *tp);
-	static PyObject *NewProxy_Ext(PyObjectPlus *self, PyTypeObject *tp, bool py_owns);
-	
+
+	static PyObject *GetProxyPlus_Ext(PyObjectPlus *self, PyTypeObject *tp, void *ptr);
+	/* self=NULL => proxy to generic pointer detached from GE object
+	                if py_owns is true, the memory pointed by ptr will be deleted automatially with MEM_freeN 
+	   self!=NULL=> proxy attached to GE object, ptr is optional and point to a struct from which attributes can be defined
+	                if py_owns is true, the object will be deleted automatically, ptr will NOT be deleted 
+					(assume object destructor takes care of it) */
+	static PyObject *NewProxyPlus_Ext(PyObjectPlus *self, PyTypeObject *tp, void *ptr, bool py_owns);
+
 	void	InvalidateProxy();
 	
 	/**
diff --git a/source/gameengine/Expressions/SConscript b/source/gameengine/Expressions/SConscript
index c819bfb0d3e..26cafb004b2 100644
--- a/source/gameengine/Expressions/SConscript
+++ b/source/gameengine/Expressions/SConscript
@@ -3,7 +3,7 @@ Import ('env')
 
 sources = env.Glob('*.cpp')
 
-incs ='. #source/kernel/gen_system #intern/string #intern/moto/include #source/gameengine/SceneGraph #source/blender/blenloader'
+incs ='. #source/kernel/gen_system #intern/guardedalloc #intern/string #intern/moto/include #source/gameengine/SceneGraph #source/blender/blenloader'
 incs += ' ' + env['BF_PYTHON_INC']
 
 env.BlenderLib ( 'bf_expressions', sources, Split(incs), [], libtype=['core','player'], priority = [360,80], cxx_compileflags=env['BGE_CXXFLAGS'])
diff --git a/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp b/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
index 9dfb5ddc38f..9b04e263350 100644
--- a/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_2DFilterActuator.cpp
@@ -43,7 +43,7 @@ SCA_2DFilterActuator::SCA_2DFilterActuator(
 		int int_arg,
 		RAS_IRasterizer* rasterizer,
 		RAS_IRenderTools* rendertools)
-    : SCA_IActuator(gameobj),
+    : SCA_IActuator(gameobj, KX_ACT_2DFILTER),
      m_type(type),
 	 m_disableMotionBlur(flag),
 	 m_float_arg(float_arg),
diff --git a/source/gameengine/GameLogic/SCA_BasicEventManager.cpp b/source/gameengine/GameLogic/SCA_BasicEventManager.cpp
new file mode 100644
index 00000000000..24cae439fb7
--- /dev/null
+++ b/source/gameengine/GameLogic/SCA_BasicEventManager.cpp
@@ -0,0 +1,62 @@
+/**
+ * Manager for 'always' events. Since always sensors can operate in pulse
+ * mode, they need to be activated.
+ *
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "SCA_BasicEventManager.h"
+#include "SCA_LogicManager.h"
+#include <vector>
+#include "SCA_ISensor.h"
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+using namespace std;
+
+SCA_BasicEventManager::SCA_BasicEventManager(class SCA_LogicManager* logicmgr)
+	: SCA_EventManager(BASIC_EVENTMGR),
+	m_logicmgr(logicmgr)
+{
+}
+
+SCA_BasicEventManager::~SCA_BasicEventManager()
+{
+}
+
+void SCA_BasicEventManager::NextFrame()
+{
+	SG_DList::iterator<SCA_ISensor> it(m_sensors);
+	for (it.begin();!it.end();++it)
+	{
+		(*it)->Activate(m_logicmgr);
+	}
+}
+
diff --git a/source/gameengine/GameLogic/SCA_BasicEventManager.h b/source/gameengine/GameLogic/SCA_BasicEventManager.h
new file mode 100644
index 00000000000..1aae5f9be5c
--- /dev/null
+++ b/source/gameengine/GameLogic/SCA_BasicEventManager.h
@@ -0,0 +1,59 @@
+/**
+ * Manager for sensor that only need to call Update
+ *
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __SCA_BASICEVENTMGR
+#define __SCA_BASICEVENTMGR
+
+#include "SCA_EventManager.h"
+#include <vector>
+
+using namespace std;
+
+class SCA_BasicEventManager : public SCA_EventManager
+{
+	class SCA_LogicManager* m_logicmgr;
+
+public:
+	SCA_BasicEventManager(class SCA_LogicManager* logicmgr);
+	~SCA_BasicEventManager();
+
+	virtual void NextFrame();
+
+
+#ifdef WITH_CXX_GUARDEDALLOC
+public:
+	void *operator new( unsigned int num_bytes) { return MEM_mallocN(num_bytes, "GE:SCA_BasicEventManager"); }
+	void operator delete( void *mem ) { MEM_freeN(mem); }
+#endif
+};
+
+#endif //__SCA_BASICEVENTMGR
+
diff --git a/source/gameengine/GameLogic/SCA_EventManager.h b/source/gameengine/GameLogic/SCA_EventManager.h
index 424150ffa63..f77b115ee03 100644
--- a/source/gameengine/GameLogic/SCA_EventManager.h
+++ b/source/gameengine/GameLogic/SCA_EventManager.h
@@ -52,10 +52,10 @@ public:
 		TIME_EVENTMGR,
 		RANDOM_EVENTMGR,
 		RAY_EVENTMGR,
-		RADAR_EVENTMGR,
 		NETWORK_EVENTMGR,
 		JOY_EVENTMGR,
-		ACTUATOR_EVENTMGR
+		ACTUATOR_EVENTMGR,
+		BASIC_EVENTMGR
 	};
 
 	SCA_EventManager(EVENT_MANAGER_TYPE mgrtype);
diff --git a/source/gameengine/GameLogic/SCA_IActuator.cpp b/source/gameengine/GameLogic/SCA_IActuator.cpp
index 0fda75590c1..0338213b3cf 100644
--- a/source/gameengine/GameLogic/SCA_IActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_IActuator.cpp
@@ -34,8 +34,9 @@
 
 using namespace std;
 
-SCA_IActuator::SCA_IActuator(SCA_IObject* gameobj) :
+SCA_IActuator::SCA_IActuator(SCA_IObject* gameobj, KX_ACTUATOR_TYPE type) :
 	SCA_ILogicBrick(gameobj),
+	m_type(type),
 	m_links(0),
 	m_posevent(false),
 	m_negevent(false)
diff --git a/source/gameengine/GameLogic/SCA_IActuator.h b/source/gameengine/GameLogic/SCA_IActuator.h
index 00ba8c9ce4e..2f1c04192ab 100644
--- a/source/gameengine/GameLogic/SCA_IActuator.h
+++ b/source/gameengine/GameLogic/SCA_IActuator.h
@@ -41,6 +41,7 @@ class SCA_IActuator : public SCA_ILogicBrick
 {
 	friend class SCA_LogicManager;
 protected:
+	int					 m_type;
 	int					 m_links;	// number of active links to controllers
 									// when 0, the actuator is automatically stopped
 	//std::vector<CValue*> m_events;
@@ -60,8 +61,33 @@ public:
 	/**
 	 * This class also inherits the default copy constructors
 	 */
-
-	SCA_IActuator(SCA_IObject* gameobj); 
+	enum KX_ACTUATOR_TYPE {
+		KX_ACT_OBJECT,
+		KX_ACT_IPO,
+		KX_ACT_CAMERA,
+		KX_ACT_SOUND,
+		KX_ACT_PROPERTY,
+		KX_ACT_ADD_OBJECT,
+		KX_ACT_END_OBJECT,
+		KX_ACT_DYNAMIC,
+		KX_ACT_REPLACE_MESH,
+		KX_ACT_TRACKTO,
+		KX_ACT_CONSTRAINT,
+		KX_ACT_SCENE,
+		KX_ACT_RANDOM,
+		KX_ACT_MESSAGE,
+		KX_ACT_ACTION,
+		KX_ACT_CD,
+		KX_ACT_GAME,
+		KX_ACT_VISIBILITY,
+		KX_ACT_2DFILTER,
+		KX_ACT_PARENT,
+		KX_ACT_SHAPEACTION,
+		KX_ACT_STATE,
+		KX_ACT_ARMATURE,
+	};
+
+	SCA_IActuator(SCA_IObject* gameobj, KX_ACTUATOR_TYPE type); 
 
 	/**
 	 * UnlinkObject(...)
@@ -127,7 +153,7 @@ public:
 	void IncLink() { m_links++; }
 	void DecLink();
 	bool IsNoLink() const { return !m_links; }
-	
+	bool IsType(KX_ACTUATOR_TYPE type) { return m_type == type; }
 	
 #ifdef WITH_CXX_GUARDEDALLOC
 public:
diff --git a/source/gameengine/GameLogic/SCA_IObject.cpp b/source/gameengine/GameLogic/SCA_IObject.cpp
index 2bffd029bd4..fbf66b64d08 100644
--- a/source/gameengine/GameLogic/SCA_IObject.cpp
+++ b/source/gameengine/GameLogic/SCA_IObject.cpp
@@ -26,6 +26,7 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 #include <iostream>
+#include <algorithm>
 
 #include "SCA_IObject.h"
 #include "SCA_ISensor.h"
@@ -76,6 +77,12 @@ SCA_IObject::~SCA_IObject()
 		(*ita)->Delete();
 	}
 
+	SCA_ObjectList::iterator ito;
+	for (ito = m_registeredObjects.begin(); !(ito==m_registeredObjects.end()); ++ito)
+	{
+		(*ito)->UnlinkObject(this);
+	}
+
 	//T_InterpolatorList::iterator i;
 	//for (i = m_interpolators.begin(); !(i == m_interpolators.end()); ++i) {
 	//	delete *i;
@@ -123,6 +130,26 @@ void SCA_IObject::UnregisterActuator(SCA_IActuator* act)
 	}
 }
 
+void SCA_IObject::RegisterObject(SCA_IObject* obj)
+{
+	// one object may be registered multiple times via constraint target
+	// store multiple reference, this will serve as registration counter
+	m_registeredObjects.push_back(obj);
+}
+
+void SCA_IObject::UnregisterObject(SCA_IObject* obj)
+{
+	SCA_ObjectList::iterator ito;
+	for (ito = m_registeredObjects.begin(); ito != m_registeredObjects.end(); ++ito)
+	{
+		if ((*ito) == obj) {
+			(*ito) = m_registeredObjects.back();
+			m_registeredObjects.pop_back();
+			break;
+		}
+	}
+}
+
 void SCA_IObject::ReParentLogic()
 {
 	SCA_ActuatorList& oldactuators  = GetActuators();
@@ -165,7 +192,7 @@ void SCA_IObject::ReParentLogic()
 
 	// a new object cannot be client of any actuator
 	m_registeredActuators.clear();
-		
+	m_registeredObjects.clear();
 }
 
 
diff --git a/source/gameengine/GameLogic/SCA_IObject.h b/source/gameengine/GameLogic/SCA_IObject.h
index 3060410dc6b..64ea0a76af1 100644
--- a/source/gameengine/GameLogic/SCA_IObject.h
+++ b/source/gameengine/GameLogic/SCA_IObject.h
@@ -36,6 +36,7 @@
 #include "Value.h"
 #include <vector>
 
+class SCA_IObject;
 class SCA_ISensor;
 class SCA_IController;
 class SCA_IActuator;
@@ -45,6 +46,7 @@ template<class T> T PyVecTo(PyObject*);
 typedef std::vector<SCA_ISensor *>       SCA_SensorList;
 typedef std::vector<SCA_IController *>   SCA_ControllerList;
 typedef std::vector<SCA_IActuator *>     SCA_ActuatorList;
+typedef std::vector<SCA_IObject *>		 SCA_ObjectList;
 
 class SCA_IObject :	public CValue
 {
@@ -59,6 +61,7 @@ protected:
 	SCA_ControllerList     m_controllers;
 	SCA_ActuatorList       m_actuators;
 	SCA_ActuatorList       m_registeredActuators;	// actuators that use a pointer to this object
+	SCA_ObjectList		   m_registeredObjects;		// objects that hold reference to this object
 
 	// SG_Dlist: element of objects with active actuators
 	//           Head: SCA_LogicManager::m_activeActuators
@@ -143,13 +146,22 @@ public:
 	void RegisterActuator(SCA_IActuator* act);
 	void UnregisterActuator(SCA_IActuator* act);
 	
+	void RegisterObject(SCA_IObject* objs);
+	void UnregisterObject(SCA_IObject* objs);
+	/**
+	 * UnlinkObject(...)
+	 * this object is informed that one of the object to which it holds a reference is deleted
+	 * returns true if there was indeed a reference.
+	 */
+	virtual bool UnlinkObject(SCA_IObject* clientobj) { return false; }
+
 	SCA_ISensor* FindSensor(const STR_String& sensorname);
 	SCA_IActuator* FindActuator(const STR_String& actuatorname);
 	SCA_IController* FindController(const STR_String& controllername);
 
 	void SetCurrentTime(float currentTime) {}
 
-	void ReParentLogic();
+	virtual void ReParentLogic();
 	
 	/**
 	 * Set whether or not to ignore activity culling requests
diff --git a/source/gameengine/GameLogic/SCA_PropertyActuator.cpp b/source/gameengine/GameLogic/SCA_PropertyActuator.cpp
index 9446487cdb7..2a3e600a653 100644
--- a/source/gameengine/GameLogic/SCA_PropertyActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_PropertyActuator.cpp
@@ -43,7 +43,7 @@
 /* ------------------------------------------------------------------------- */
 
 SCA_PropertyActuator::SCA_PropertyActuator(SCA_IObject* gameobj,SCA_IObject* sourceObj,const STR_String& propname,const STR_String& expr,int acttype)
-   :	SCA_IActuator(gameobj),
+   :	SCA_IActuator(gameobj, KX_ACT_PROPERTY),
 	m_type(acttype),
 	m_propname(propname),
 	m_exprtxt(expr),
diff --git a/source/gameengine/GameLogic/SCA_RandomActuator.cpp b/source/gameengine/GameLogic/SCA_RandomActuator.cpp
index a3a5cc2303e..8f9482b7826 100644
--- a/source/gameengine/GameLogic/SCA_RandomActuator.cpp
+++ b/source/gameengine/GameLogic/SCA_RandomActuator.cpp
@@ -51,7 +51,7 @@ SCA_RandomActuator::SCA_RandomActuator(SCA_IObject *gameobj,
 									 float para1,
 									 float para2,
 									 const STR_String &propName)
-	: SCA_IActuator(gameobj),
+	: SCA_IActuator(gameobj, KX_ACT_RANDOM),
 	  m_propname(propName),
 	  m_parameter1(para1),
 	  m_parameter2(para2),
diff --git a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp
index 3af8f765251..1cfab87d78b 100644
--- a/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp
+++ b/source/gameengine/Ketsji/KXNetwork/KX_NetworkMessageActuator.cpp
@@ -42,7 +42,7 @@ KX_NetworkMessageActuator::KX_NetworkMessageActuator(
 	const STR_String &subject,
 	int bodyType,
 	const STR_String &body) :
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_MESSAGE),
 	m_networkscene(networkscene),
 	m_toPropName(toPropName),
 	m_subject(subject),
diff --git a/source/gameengine/Ketsji/KX_ArmatureSensor.cpp b/source/gameengine/Ketsji/KX_ArmatureSensor.cpp
new file mode 100644
index 00000000000..1b759bda28e
--- /dev/null
+++ b/source/gameengine/Ketsji/KX_ArmatureSensor.cpp
@@ -0,0 +1,205 @@
+/**
+ * Armature sensor
+ *
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#include "DNA_action_types.h"
+#include "DNA_constraint_types.h"
+#include "BKE_constraint.h"
+#include "DNA_sensor_types.h"
+
+#include "BL_ArmatureObject.h"
+#include "KX_ArmatureSensor.h"
+#include "SCA_EventManager.h"
+#include "SCA_LogicManager.h"
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+KX_ArmatureSensor::KX_ArmatureSensor(class SCA_EventManager* eventmgr,
+					SCA_IObject* gameobj,
+					const char *posechannel,
+					const char *constraintname,
+					int type,
+					float value)
+	: SCA_ISensor(gameobj,eventmgr),
+	m_constraint(NULL),
+	m_posechannel(posechannel),
+	m_constraintname(constraintname),
+	m_type(type),
+	m_value(value)
+{
+	FindConstraint();
+}
+
+void KX_ArmatureSensor::Init()
+{
+	m_lastresult = m_invert?true:false;
+	m_result = false;
+	m_reset = true;
+}
+
+void KX_ArmatureSensor::FindConstraint()
+{
+	m_constraint = NULL;
+
+	if (m_gameobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE) {
+		BL_ArmatureObject* armobj = (BL_ArmatureObject*)m_gameobj;
+		// get the persistent pose structure
+		bPose* pose = armobj->GetOrigPose();
+		bPoseChannel* pchan;
+		bConstraint* pcon;
+		// and locate the constraint
+		for (pchan = (bPoseChannel*)pose->chanbase.first; pchan; pchan=(bPoseChannel*)pchan->next) {
+			if (!strcmp(pchan->name, m_posechannel)) {
+				// now locate the constraint
+				for (pcon = (bConstraint*)pchan->constraints.first; pcon; pcon=(bConstraint*)pcon->next) {
+					if (!strcmp(pcon->name, m_constraintname)) {
+						if (pcon->flag & CONSTRAINT_DISABLE)
+							/* this constraint is not valid, can't use it */
+							break;
+						m_constraint = pcon;
+						break;	
+					}
+				}
+				break;
+			}
+		}
+	}
+}
+
+
+CValue* KX_ArmatureSensor::GetReplica()
+{
+	KX_ArmatureSensor* replica = new KX_ArmatureSensor(*this);
+	// m_range_expr must be recalculated on replica!
+	replica->ProcessReplica();
+	return replica;
+}
+
+void KX_ArmatureSensor::ReParent(SCA_IObject* parent)
+{
+	SCA_ISensor::ReParent(parent);
+	// must remap the constraint
+	FindConstraint();
+}
+
+bool KX_ArmatureSensor::IsPositiveTrigger()
+{
+	return (m_invert) ? !m_result : m_result;
+}
+
+
+KX_ArmatureSensor::~KX_ArmatureSensor()
+{
+}
+
+bool KX_ArmatureSensor::Evaluate()
+{
+	bool reset = m_reset && m_level;
+
+	m_reset = false;
+	if (!m_constraint)
+		return false;
+	switch (m_type) {
+	case SENS_ARM_STATE_CHANGED:
+		m_result = !(m_constraint->flag & CONSTRAINT_OFF);
+		break;
+	case SENS_ARM_LIN_ERROR_BELOW:
+		m_result = (m_constraint->lin_error < m_value);
+		break;
+	case SENS_ARM_LIN_ERROR_ABOVE:
+		m_result = (m_constraint->lin_error > m_value);
+		break;
+	case SENS_ARM_ROT_ERROR_BELOW:
+		m_result = (m_constraint->rot_error < m_value);
+		break;
+	case SENS_ARM_ROT_ERROR_ABOVE:
+		m_result = (m_constraint->rot_error > m_value);
+		break;
+	}
+	if (m_lastresult!=m_result)
+	{
+		m_lastresult = m_result;
+		return true;
+	}
+	return (reset) ? true : false;
+}
+
+
+/* ------------------------------------------------------------------------- */
+/* Python functions                                                          */
+/* ------------------------------------------------------------------------- */
+
+/* Integration hooks ------------------------------------------------------- */
+PyTypeObject KX_ArmatureSensor::Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"KX_ArmatureSensor",
+	sizeof(PyObjectPlus_Proxy),
+	0,
+	py_base_dealloc,
+	0,
+	0,
+	0,
+	0,
+	py_base_repr,
+	0,0,0,0,0,0,0,0,0,
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+	0,0,0,0,0,0,0,
+	Methods,
+	0,
+	0,
+	&SCA_ISensor::Type,
+	0,0,0,0,0,0,
+	py_base_new
+};
+
+PyMethodDef KX_ArmatureSensor::Methods[] = {
+	{NULL,NULL} //Sentinel
+};
+
+PyAttributeDef KX_ArmatureSensor::Attributes[] = {
+	KX_PYATTRIBUTE_RO_FUNCTION("constraint", KX_ArmatureSensor, pyattr_get_constraint),
+	KX_PYATTRIBUTE_FLOAT_RW("value",-FLT_MAX,FLT_MAX,KX_ArmatureSensor,m_value),
+	KX_PYATTRIBUTE_INT_RW("type",0,SENS_ARM_MAXTYPE,false,KX_ArmatureSensor,m_type),
+	{ NULL }	//Sentinel
+};
+
+PyObject* KX_ArmatureSensor::pyattr_get_constraint(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef)
+{
+	KX_ArmatureSensor* sensor = static_cast<KX_ArmatureSensor*>(self);
+	if (sensor->m_gameobj->GetGameObjectType() == SCA_IObject::OBJ_ARMATURE) {
+		BL_ArmatureObject* armobj = (BL_ArmatureObject*)sensor->m_gameobj;
+		BL_ArmatureConstraint* constraint = armobj->GetConstraint(sensor->m_posechannel, sensor->m_constraintname);
+		if (constraint)	
+			return constraint->GetProxy();
+	}
+	Py_RETURN_NONE;
+}
diff --git a/source/gameengine/Ketsji/KX_ArmatureSensor.h b/source/gameengine/Ketsji/KX_ArmatureSensor.h
new file mode 100644
index 00000000000..2af002afff9
--- /dev/null
+++ b/source/gameengine/Ketsji/KX_ArmatureSensor.h
@@ -0,0 +1,85 @@
+/**
+ * Property sensor
+ *
+ * $Id$
+ *
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __KX_ARMATURESENSOR
+#define __KX_ARMATURESENSOR
+
+struct bConstraint;
+
+#include "SCA_ISensor.h"
+#include "DNA_sensor_types.h"
+
+class KX_ArmatureSensor : public SCA_ISensor
+{
+	Py_Header;
+	//class CExpression*	m_rightexpr;
+
+protected:
+
+public:
+	KX_ArmatureSensor(class SCA_EventManager* eventmgr,
+					SCA_IObject* gameobj,
+					const char *posechannel,
+					const char *constraintname,
+					int type,
+					float value);
+	
+	/** 
+	 *  For property sensor, it is used to release the pre-calculated expression
+	 *  so that self references are removed before the sensor itself is released
+	 */
+	virtual ~KX_ArmatureSensor();
+	virtual CValue* GetReplica();
+	virtual void ReParent(SCA_IObject* parent);
+	virtual void Init();
+	virtual bool Evaluate();
+	virtual bool IsPositiveTrigger();
+
+	// identify the constraint that this actuator controls
+	void FindConstraint();
+
+	/* --------------------------------------------------------------------- */
+	/* Python interface ---------------------------------------------------- */
+	/* --------------------------------------------------------------------- */
+	static PyObject* pyattr_get_constraint(void *self, const struct KX_PYATTRIBUTE_DEF *attrdef);
+
+private:
+	struct bConstraint*	m_constraint;
+	STR_String		m_posechannel;
+	STR_String		m_constraintname;
+	int				m_type;
+	float			m_value;
+	bool			m_result;
+	bool			m_lastresult;
+};
+
+#endif
+
diff --git a/source/gameengine/Ketsji/KX_CameraActuator.cpp b/source/gameengine/Ketsji/KX_CameraActuator.cpp
index 9c00b5991af..99618fab8e3 100644
--- a/source/gameengine/Ketsji/KX_CameraActuator.cpp
+++ b/source/gameengine/Ketsji/KX_CameraActuator.cpp
@@ -55,7 +55,7 @@ KX_CameraActuator::KX_CameraActuator(
 	float maxhght,
 	bool  xytog
 ): 
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_CAMERA),
 	m_ob (obj),
 	m_height (hght),
 	m_minHeight (minhght),
diff --git a/source/gameengine/Ketsji/KX_ConstraintActuator.cpp b/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
index 7f1d2c7d53c..ea0b9f4f1e2 100644
--- a/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
+++ b/source/gameengine/Ketsji/KX_ConstraintActuator.cpp
@@ -56,7 +56,7 @@ KX_ConstraintActuator::KX_ConstraintActuator(SCA_IObject *gameobj,
 											 int time,
 											 int option,
 											 char *property) :
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_CONSTRAINT),
 	m_refDirVector(refDir),
 	m_currentTime(0)
 {
diff --git a/source/gameengine/Ketsji/KX_GameActuator.cpp b/source/gameengine/Ketsji/KX_GameActuator.cpp
index 42dc4d8fd24..71980a3347e 100644
--- a/source/gameengine/Ketsji/KX_GameActuator.cpp
+++ b/source/gameengine/Ketsji/KX_GameActuator.cpp
@@ -50,7 +50,7 @@ KX_GameActuator::KX_GameActuator(SCA_IObject *gameobj,
 								   const STR_String& loadinganimationname,
 								   KX_Scene* scene,
 								   KX_KetsjiEngine* ketsjiengine)
-								   : SCA_IActuator(gameobj)
+								   : SCA_IActuator(gameobj, KX_ACT_GAME)
 {
 	m_mode = mode;
 	m_filename = filename;
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index 8193aa8c37b..a02fd9cec1b 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -46,6 +46,7 @@ typedef unsigned long uint_ptr;
 
 
 #define KX_INERTIA_INFINITE 10000
+#include "BLI_arithb.h"
 #include "RAS_IPolygonMaterial.h"
 #include "KX_BlenderMaterial.h"
 #include "KX_GameObject.h"
@@ -454,6 +455,22 @@ double*	KX_GameObject::GetOpenGLMatrix()
 	return fl;
 }
 
+void KX_GameObject::UpdateBlenderObjectMatrix(Object* blendobj)
+{
+	if (!blendobj)
+		blendobj = m_pBlenderObject;
+	if (blendobj) {
+		const MT_Matrix3x3& rot = NodeGetWorldOrientation();
+		const MT_Vector3& scale = NodeGetWorldScaling();
+		const MT_Vector3& pos = NodeGetWorldPosition();
+		rot.getValue(blendobj->obmat[0]);
+		pos.getValue(blendobj->obmat[3]);
+		VecMulf(blendobj->obmat[0], scale[0]);
+		VecMulf(blendobj->obmat[1], scale[1]);
+		VecMulf(blendobj->obmat[2], scale[2]);
+	}
+}
+
 void KX_GameObject::AddMeshUser()
 {
 	for (size_t i=0;i<m_meshes.size();i++)
diff --git a/source/gameengine/Ketsji/KX_GameObject.h b/source/gameengine/Ketsji/KX_GameObject.h
index 845cead1cdb..4c4eed9ca71 100644
--- a/source/gameengine/Ketsji/KX_GameObject.h
+++ b/source/gameengine/Ketsji/KX_GameObject.h
@@ -158,6 +158,15 @@ public:
 		return &m_OpenGL_4x4Matrix;
 	};
 
+	/**
+	 * Update the blender object obmat field from the object world position
+	 * if blendobj is NULL, update the object pointed by m_pBlenderObject
+	 * The user must take action to restore the matrix before leaving the GE.
+	 * Used in Armature evaluation
+	 */
+		void
+	UpdateBlenderObjectMatrix(Object* blendobj=NULL);
+
 	/** 
 	 * Get a pointer to the game object that is the parent of 
 	 * this object. Or NULL if there is no parent. The returned
diff --git a/source/gameengine/Ketsji/KX_IpoActuator.cpp b/source/gameengine/Ketsji/KX_IpoActuator.cpp
index b71907be961..d7f800fe5bd 100644
--- a/source/gameengine/Ketsji/KX_IpoActuator.cpp
+++ b/source/gameengine/Ketsji/KX_IpoActuator.cpp
@@ -71,7 +71,7 @@ KX_IpoActuator::KX_IpoActuator(SCA_IObject* gameobj,
 							   bool ipo_as_force,
 							   bool ipo_add,
 							   bool ipo_local)
-	: SCA_IActuator(gameobj),
+	: SCA_IActuator(gameobj, KX_ACT_IPO),
 	m_bNegativeEvent(false),
 	m_startframe (starttime),
 	m_endframe(endtime),
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
index 4117e493322..e95676ff9d2 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
@@ -1783,6 +1783,11 @@ double KX_KetsjiEngine::GetClockTime(void) const
 	return m_clockTime;
 }
 
+double KX_KetsjiEngine::GetFrameTime(void) const
+{
+	return m_frameTime;
+}
+
 double KX_KetsjiEngine::GetRealTime(void) const
 {
 	return m_kxsystem->GetTimeInSeconds();
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.h b/source/gameengine/Ketsji/KX_KetsjiEngine.h
index acb9e53df8a..373e8bf218c 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.h
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.h
@@ -269,6 +269,10 @@ public:
 	 * Returns current render frame clock time
 	 */
 	double GetClockTime(void) const;
+	/**
+	 * Returns current logic frame clock time
+	 */
+	double GetFrameTime(void) const;
 
 	double GetRealTime(void) const;
 	/**
diff --git a/source/gameengine/Ketsji/KX_ObjectActuator.cpp b/source/gameengine/Ketsji/KX_ObjectActuator.cpp
index 2601ced9c38..924e4a47008 100644
--- a/source/gameengine/Ketsji/KX_ObjectActuator.cpp
+++ b/source/gameengine/Ketsji/KX_ObjectActuator.cpp
@@ -55,7 +55,7 @@ KX_ObjectActuator(
 	const short damping,
 	const KX_LocalFlags& flag
 ) : 
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_OBJECT),
 	m_force(force),
 	m_torque(torque),
 	m_dloc(dloc),
diff --git a/source/gameengine/Ketsji/KX_ParentActuator.cpp b/source/gameengine/Ketsji/KX_ParentActuator.cpp
index 20e982f03e0..a4a6b67ad10 100644
--- a/source/gameengine/Ketsji/KX_ParentActuator.cpp
+++ b/source/gameengine/Ketsji/KX_ParentActuator.cpp
@@ -51,7 +51,7 @@ KX_ParentActuator::KX_ParentActuator(SCA_IObject *gameobj,
 									 bool addToCompound,
 									 bool ghost,
 									 SCA_IObject *ob)
-	: SCA_IActuator(gameobj),
+	: SCA_IActuator(gameobj, KX_ACT_PARENT),
 	  m_mode(mode),
 	  m_addToCompound(addToCompound),
 	  m_ghost(ghost),
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index 298d485aaaf..bef00fb7a06 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -51,6 +51,7 @@ extern "C" {
 #include "KX_KetsjiEngine.h"
 #include "KX_RadarSensor.h"
 #include "KX_RaySensor.h"
+#include "KX_ArmatureSensor.h"
 #include "KX_SceneActuator.h"
 #include "KX_GameActuator.h"
 #include "KX_ParentActuator.h"
@@ -65,6 +66,7 @@ extern "C" {
 #include "KX_SoundActuator.h"
 #include "KX_StateActuator.h"
 #include "BL_ActionActuator.h"
+#include "BL_ArmatureObject.h"
 #include "RAS_IRasterizer.h"
 #include "RAS_ICanvas.h"
 #include "RAS_BucketManager.h"
@@ -1218,6 +1220,53 @@ PyObject* initGameLogic(KX_KetsjiEngine *engine, KX_Scene* scene) // quick hack
 	KX_MACRO_addTypesToDict(d, KX_PARENT_SET, KX_ParentActuator::KX_PARENT_SET);
 	KX_MACRO_addTypesToDict(d, KX_PARENT_REMOVE, KX_ParentActuator::KX_PARENT_REMOVE);
 
+	/* BL_ArmatureConstraint type */
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_TRACKTO, CONSTRAINT_TYPE_TRACKTO);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_KINEMATIC, CONSTRAINT_TYPE_KINEMATIC);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_ROTLIKE, CONSTRAINT_TYPE_ROTLIKE);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_LOCLIKE, CONSTRAINT_TYPE_LOCLIKE);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_MINMAX, CONSTRAINT_TYPE_MINMAX);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_SIZELIKE, CONSTRAINT_TYPE_SIZELIKE);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_LOCKTRACK, CONSTRAINT_TYPE_LOCKTRACK);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_STRETCHTO, CONSTRAINT_TYPE_STRETCHTO);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_CLAMPTO, CONSTRAINT_TYPE_CLAMPTO);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_TRANSFORM, CONSTRAINT_TYPE_TRANSFORM);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_TYPE_DISTLIMIT, CONSTRAINT_TYPE_DISTLIMIT);
+	/* BL_ArmatureConstraint ik_type */
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_COPYPOSE, CONSTRAINT_IK_COPYPOSE);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_DISTANCE, CONSTRAINT_IK_DISTANCE);
+	/* BL_ArmatureConstraint ik_mode */
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_MODE_INSIDE, LIMITDIST_INSIDE);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_MODE_OUTSIDE, LIMITDIST_OUTSIDE);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_MODE_ONSURFACE, LIMITDIST_ONSURFACE);
+	/* BL_ArmatureConstraint ik_flag */
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_FLAG_TIP, CONSTRAINT_IK_TIP);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_FLAG_ROT, CONSTRAINT_IK_ROT);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_FLAG_STRETCH, CONSTRAINT_IK_STRETCH);
+	KX_MACRO_addTypesToDict(d, CONSTRAINT_IK_FLAG_POS, CONSTRAINT_IK_POS);
+	/* KX_ArmatureSensor type */
+	KX_MACRO_addTypesToDict(d, KX_ARMSENSOR_STATE_CHANGED, SENS_ARM_STATE_CHANGED);
+	KX_MACRO_addTypesToDict(d, KX_ARMSENSOR_LIN_ERROR_BELOW, SENS_ARM_LIN_ERROR_BELOW);
+	KX_MACRO_addTypesToDict(d, KX_ARMSENSOR_LIN_ERROR_ABOVE, SENS_ARM_LIN_ERROR_ABOVE);
+	KX_MACRO_addTypesToDict(d, KX_ARMSENSOR_ROT_ERROR_BELOW, SENS_ARM_ROT_ERROR_BELOW);
+	KX_MACRO_addTypesToDict(d, KX_ARMSENSOR_ROT_ERROR_ABOVE, SENS_ARM_ROT_ERROR_ABOVE);
+
+	/* BL_ArmatureActuator type */
+	KX_MACRO_addTypesToDict(d, KX_ACT_ARMATURE_RUN, ACT_ARM_RUN);
+	KX_MACRO_addTypesToDict(d, KX_ACT_ARMATURE_ENABLE, ACT_ARM_ENABLE);
+	KX_MACRO_addTypesToDict(d, KX_ACT_ARMATURE_DISABLE, ACT_ARM_DISABLE);
+	KX_MACRO_addTypesToDict(d, KX_ACT_ARMATURE_SETTARGET, ACT_ARM_SETTARGET);
+	KX_MACRO_addTypesToDict(d, KX_ACT_ARMATURE_SETWEIGHT, ACT_ARM_SETWEIGHT);
+
+	/* BL_Armature Channel rotation_mode */
+	KX_MACRO_addTypesToDict(d, PCHAN_ROT_QUAT, PCHAN_ROT_QUAT);
+	KX_MACRO_addTypesToDict(d, PCHAN_ROT_XYZ, PCHAN_ROT_XYZ);
+	KX_MACRO_addTypesToDict(d, PCHAN_ROT_XZY, PCHAN_ROT_XZY);
+	KX_MACRO_addTypesToDict(d, PCHAN_ROT_YXZ, PCHAN_ROT_YXZ);
+	KX_MACRO_addTypesToDict(d, PCHAN_ROT_YZX, PCHAN_ROT_YZX);
+	KX_MACRO_addTypesToDict(d, PCHAN_ROT_ZXY, PCHAN_ROT_ZXY);
+	KX_MACRO_addTypesToDict(d, PCHAN_ROT_ZYX, PCHAN_ROT_ZYX);
+
 	// Check for errors
 	if (PyErr_Occurred())
     {
diff --git a/source/gameengine/Ketsji/KX_PythonInitTypes.cpp b/source/gameengine/Ketsji/KX_PythonInitTypes.cpp
index 61e563791c3..c2c33918172 100644
--- a/source/gameengine/Ketsji/KX_PythonInitTypes.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInitTypes.cpp
@@ -35,6 +35,10 @@
 /* Only for Class::Parents */
 #include "BL_BlenderShader.h"
 #include "BL_ShapeActionActuator.h"
+#include "BL_ArmatureActuator.h"
+#include "BL_ArmatureConstraint.h"
+#include "BL_ArmatureObject.h"
+#include "BL_ArmatureChannel.h"
 #include "KX_BlenderMaterial.h"
 #include "KX_CameraActuator.h"
 #include "KX_ConstraintActuator.h"
@@ -86,7 +90,22 @@
 #include "SCA_RandomActuator.h"
 #include "SCA_IController.h"
 
-static void PyType_Ready_ADD(PyObject *dict, PyTypeObject *tp, PyAttributeDef *attributes, int init_getset)
+static void PyType_Attr_Set(PyGetSetDef *attr_getset, PyAttributeDef *attr)
+{
+	attr_getset->name= (char *)attr->m_name;
+	attr_getset->doc= NULL;
+
+	attr_getset->get= reinterpret_cast<getter>(PyObjectPlus::py_get_attrdef);
+
+	if(attr->m_access==KX_PYATTRIBUTE_RO)
+		attr_getset->set= NULL;
+	else
+		attr_getset->set= reinterpret_cast<setter>(PyObjectPlus::py_set_attrdef);
+
+	attr_getset->closure= reinterpret_cast<void *>(attr);
+}
+
+static void PyType_Ready_ADD(PyObject *dict, PyTypeObject *tp, PyAttributeDef *attributes, PyAttributeDef *attributesPtr, int init_getset)
 {
 	PyAttributeDef *attr;
 
@@ -97,29 +116,31 @@ static void PyType_Ready_ADD(PyObject *dict, PyTypeObject *tp, PyAttributeDef *a
 		//if(tp->tp_base==NULL)
 		//	printf("Debug: No Parents - '%s'\n" , tp->tp_name);
 
-		if(tp->tp_getset==NULL && attributes->m_name) {
+		if(tp->tp_getset==NULL && ((attributes && attributes->m_name) || (attributesPtr && attributesPtr->m_name))) {
 			PyGetSetDef *attr_getset;
 			int attr_tot= 0;
 
-			for(attr= attributes; attr->m_name; attr++, attr_tot++) {};
+			if (attributes) {
+				for(attr= attributes; attr->m_name; attr++, attr_tot++)
+					attr->m_usePtr = false;
+			}
+			if (attributesPtr) {
+				for(attr= attributesPtr; attr->m_name; attr++, attr_tot++)
+					attr->m_usePtr = true;
+			}
 
 			tp->tp_getset = attr_getset = reinterpret_cast<PyGetSetDef *>(PyMem_Malloc((attr_tot+1) * sizeof(PyGetSetDef))); // XXX - Todo, free
 
-
-			for(attr= attributes; attr->m_name; attr++, attr_getset++) {
-				attr_getset->name= (char *)attr->m_name;
-				attr_getset->doc= NULL;
-
-				attr_getset->get= reinterpret_cast<getter>(PyObjectPlus::py_get_attrdef);
-
-				if(attr->m_access==KX_PYATTRIBUTE_RO)
-					attr_getset->set= NULL;
-				else
-					attr_getset->set= reinterpret_cast<setter>(PyObjectPlus::py_set_attrdef);
-
-				attr_getset->closure= reinterpret_cast<void *>(attr);
+			if (attributes) {
+				for(attr= attributes; attr->m_name; attr++, attr_getset++) {
+					PyType_Attr_Set(attr_getset, attr);
+				}
+			}
+			if (attributesPtr) {
+				for(attr= attributesPtr; attr->m_name; attr++, attr_getset++) {
+					PyType_Attr_Set(attr_getset, attr);
+				}
 			}
-
 			memset(attr_getset, 0, sizeof(PyGetSetDef));
 		}
 	} else {
@@ -130,7 +151,8 @@ static void PyType_Ready_ADD(PyObject *dict, PyTypeObject *tp, PyAttributeDef *a
 }
 
 
-#define PyType_Ready_Attr(d, n, i)   PyType_Ready_ADD(d, &n::Type, n::Attributes, i)
+#define PyType_Ready_Attr(d, n, i)   PyType_Ready_ADD(d, &n::Type, n::Attributes, NULL, i)
+#define PyType_Ready_AttrPtr(d, n, i)   PyType_Ready_ADD(d, &n::Type, n::Attributes, n::AttributesPtr, i)
 
 void initPyTypes(void)
 {
@@ -151,6 +173,11 @@ void initPyTypes(void)
 		PyType_Ready_Attr(dict, BL_ActionActuator, init_getset);
 		PyType_Ready_Attr(dict, BL_Shader, init_getset);
 		PyType_Ready_Attr(dict, BL_ShapeActionActuator, init_getset);
+		PyType_Ready_Attr(dict, BL_ArmatureObject, init_getset);
+		PyType_Ready_Attr(dict, BL_ArmatureActuator, init_getset);
+		PyType_Ready_Attr(dict, BL_ArmatureConstraint, init_getset);
+		PyType_Ready_AttrPtr(dict, BL_ArmatureBone, init_getset);
+		PyType_Ready_AttrPtr(dict, BL_ArmatureChannel, init_getset);
 		PyType_Ready_Attr(dict, CListValue, init_getset);
 		PyType_Ready_Attr(dict, CValue, init_getset);
 		PyType_Ready_Attr(dict, KX_BlenderMaterial, init_getset);
diff --git a/source/gameengine/Ketsji/KX_PythonSeq.cpp b/source/gameengine/Ketsji/KX_PythonSeq.cpp
index 75a7c9b8aeb..f7ad7acb252 100644
--- a/source/gameengine/Ketsji/KX_PythonSeq.cpp
+++ b/source/gameengine/Ketsji/KX_PythonSeq.cpp
@@ -31,6 +31,7 @@
 
 #include "KX_PythonSeq.h"
 #include "KX_GameObject.h"
+#include "BL_ArmatureObject.h"
 #include "SCA_ISensor.h"
 #include "SCA_IController.h"
 #include "SCA_IActuator.h"
@@ -72,6 +73,10 @@ static Py_ssize_t KX_PythonSeq_len( PyObject * self )
 		return ((KX_GameObject *)self_plus)->GetControllers().size();
 	case KX_PYGENSEQ_OB_TYPE_ACTUATORS:
 		return ((KX_GameObject *)self_plus)->GetActuators().size();
+	case KX_PYGENSEQ_OB_TYPE_CONSTRAINTS:
+		return ((BL_ArmatureObject *)self_plus)->GetConstraintNumber();
+	case KX_PYGENSEQ_OB_TYPE_CHANNELS:
+		return ((BL_ArmatureObject *)self_plus)->GetChannelNumber();
 	default:
 		/* Should never happen */
 		PyErr_SetString(PyExc_SystemError, "invalid type, internal error");
@@ -139,6 +144,29 @@ static PyObject *KX_PythonSeq_getIndex(PyObject* self, int index)
 			}
 			return linkedactuators[index]->GetProxy();
 		}
+		case KX_PYGENSEQ_OB_TYPE_CONSTRAINTS:
+		{
+			int nb_constraint = ((BL_ArmatureObject *)self_plus)->GetConstraintNumber();
+			if(index<0) 
+				index += nb_constraint;
+			if(index<0 || index>= nb_constraint) {
+				PyErr_SetString(PyExc_IndexError, "seq[i]: index out of range");
+				return NULL;
+			}
+			return ((BL_ArmatureObject *)self_plus)->GetConstraint(index)->GetProxy();
+		}
+		case KX_PYGENSEQ_OB_TYPE_CHANNELS:
+		{
+			int nb_channel = ((BL_ArmatureObject *)self_plus)->GetChannelNumber();
+			if(index<0) 
+				index += nb_channel;
+			if(index<0 || index>= nb_channel) {
+				PyErr_SetString(PyExc_IndexError, "seq[i]: index out of range");
+				return NULL;
+			}
+			return ((BL_ArmatureObject *)self_plus)->GetChannel(index)->GetProxy();
+		}
+
 	}
 	
 	PyErr_SetString(PyExc_SystemError, "invalid sequence type, this is a bug");
@@ -206,6 +234,14 @@ static PyObjectPlus * KX_PythonSeq_subscript__internal(PyObject *self, char *key
 			}
 			break;
 		}
+		case KX_PYGENSEQ_OB_TYPE_CONSTRAINTS:
+		{
+			return ((BL_ArmatureObject*)self_plus)->GetConstraint(key);
+		}
+		case KX_PYGENSEQ_OB_TYPE_CHANNELS:
+		{
+			return ((BL_ArmatureObject*)self_plus)->GetChannel(key);
+		}
 	}
 	
 	return NULL;
diff --git a/source/gameengine/Ketsji/KX_PythonSeq.h b/source/gameengine/Ketsji/KX_PythonSeq.h
index 15a016224a9..34243aa9b9c 100644
--- a/source/gameengine/Ketsji/KX_PythonSeq.h
+++ b/source/gameengine/Ketsji/KX_PythonSeq.h
@@ -39,7 +39,9 @@ enum KX_PYGENSEQ_TYPE {
 	KX_PYGENSEQ_CONT_TYPE_ACTUATORS,
 	KX_PYGENSEQ_OB_TYPE_SENSORS,
 	KX_PYGENSEQ_OB_TYPE_CONTROLLERS,
-	KX_PYGENSEQ_OB_TYPE_ACTUATORS
+	KX_PYGENSEQ_OB_TYPE_ACTUATORS,
+	KX_PYGENSEQ_OB_TYPE_CONSTRAINTS,
+	KX_PYGENSEQ_OB_TYPE_CHANNELS,
 };
 
 /* The Main PyType Object defined in Main.c */
diff --git a/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp b/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
index 099403fc28d..c1e74070d72 100644
--- a/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SCA_AddObjectActuator.cpp
@@ -57,7 +57,7 @@ KX_SCA_AddObjectActuator::KX_SCA_AddObjectActuator(SCA_IObject *gameobj,
 												   const float *angvel,
 												   bool angv_local)
 	: 
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_ADD_OBJECT),
 	m_OriginalObject(original),
 	m_scene(scene),
 	
diff --git a/source/gameengine/Ketsji/KX_SCA_DynamicActuator.cpp b/source/gameengine/Ketsji/KX_SCA_DynamicActuator.cpp
index 646cfb7219f..73c85ad07b3 100644
--- a/source/gameengine/Ketsji/KX_SCA_DynamicActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SCA_DynamicActuator.cpp
@@ -87,7 +87,7 @@ KX_SCA_DynamicActuator::KX_SCA_DynamicActuator(SCA_IObject *gameobj,
 													   short dyn_operation,
 													   float setmass) :
 
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_DYNAMIC),
 	m_dyn_operation(dyn_operation),
 	m_setmass(setmass)
 {
diff --git a/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp b/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp
index dd9d8015724..e7dc71d9b27 100644
--- a/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SCA_EndObjectActuator.cpp
@@ -44,7 +44,7 @@
 
 KX_SCA_EndObjectActuator::KX_SCA_EndObjectActuator(SCA_IObject *gameobj,
 												   SCA_IScene* scene):
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_END_OBJECT),
 	m_scene(scene)
 {
     // intentionally empty 
diff --git a/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp b/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
index e85b8a32798..e118972edc8 100644
--- a/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SCA_ReplaceMeshActuator.cpp
@@ -122,7 +122,7 @@ KX_SCA_ReplaceMeshActuator::KX_SCA_ReplaceMeshActuator(SCA_IObject *gameobj,
 													   bool use_gfx,
 													   bool use_phys) :
 
-	SCA_IActuator(gameobj),
+	SCA_IActuator(gameobj, KX_ACT_REPLACE_MESH),
 	m_mesh(mesh),
 	m_scene(scene),
 	m_use_gfx(use_gfx),
diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp
index 3483496c3a6..140be3fb3db 100644
--- a/source/gameengine/Ketsji/KX_Scene.cpp
+++ b/source/gameengine/Ketsji/KX_Scene.cpp
@@ -40,14 +40,15 @@
 #include "ListValue.h"
 #include "SCA_LogicManager.h"
 #include "SCA_TimeEventManager.h"
-#include "SCA_AlwaysEventManager.h"
-#include "SCA_RandomEventManager.h"
-#include "KX_RayEventManager.h"
+//#include "SCA_AlwaysEventManager.h"
+//#include "SCA_RandomEventManager.h"
+//#include "KX_RayEventManager.h"
 #include "KX_TouchEventManager.h"
 #include "SCA_KeyboardManager.h"
 #include "SCA_MouseManager.h"
-#include "SCA_PropertyEventManager.h"
+//#include "SCA_PropertyEventManager.h"
 #include "SCA_ActuatorEventManager.h"
+#include "SCA_BasicEventManager.h"
 #include "KX_Camera.h"
 #include "SCA_JoystickManager.h"
 
@@ -168,25 +169,27 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice,
 	m_keyboardmgr = new SCA_KeyboardManager(m_logicmgr,keyboarddevice);
 	m_mousemgr = new SCA_MouseManager(m_logicmgr,mousedevice);
 	
-	SCA_AlwaysEventManager* alwaysmgr = new SCA_AlwaysEventManager(m_logicmgr);
-	SCA_PropertyEventManager* propmgr = new SCA_PropertyEventManager(m_logicmgr);
+	//SCA_AlwaysEventManager* alwaysmgr = new SCA_AlwaysEventManager(m_logicmgr);
+	//SCA_PropertyEventManager* propmgr = new SCA_PropertyEventManager(m_logicmgr);
 	SCA_ActuatorEventManager* actmgr = new SCA_ActuatorEventManager(m_logicmgr);
-	SCA_RandomEventManager* rndmgr = new SCA_RandomEventManager(m_logicmgr);
-	KX_RayEventManager* raymgr = new KX_RayEventManager(m_logicmgr);
+	//SCA_RandomEventManager* rndmgr = new SCA_RandomEventManager(m_logicmgr);
+	SCA_BasicEventManager* basicmgr = new SCA_BasicEventManager(m_logicmgr);
+	//KX_RayEventManager* raymgr = new KX_RayEventManager(m_logicmgr);
 
 	KX_NetworkEventManager* netmgr = new KX_NetworkEventManager(m_logicmgr, ndi);
 	
 	
 
-	m_logicmgr->RegisterEventManager(alwaysmgr);
-	m_logicmgr->RegisterEventManager(propmgr);
+	//m_logicmgr->RegisterEventManager(alwaysmgr);
+	//m_logicmgr->RegisterEventManager(propmgr);
 	m_logicmgr->RegisterEventManager(actmgr);
 	m_logicmgr->RegisterEventManager(m_keyboardmgr);
 	m_logicmgr->RegisterEventManager(m_mousemgr);
 	m_logicmgr->RegisterEventManager(m_timemgr);
-	m_logicmgr->RegisterEventManager(rndmgr);
-	m_logicmgr->RegisterEventManager(raymgr);
+	//m_logicmgr->RegisterEventManager(rndmgr);
+	//m_logicmgr->RegisterEventManager(raymgr);
 	m_logicmgr->RegisterEventManager(netmgr);
+	m_logicmgr->RegisterEventManager(basicmgr);
 
 
 	SYS_SystemHandle hSystem = SYS_GetSystem();
diff --git a/source/gameengine/Ketsji/KX_SceneActuator.cpp b/source/gameengine/Ketsji/KX_SceneActuator.cpp
index ea1be7bca6c..c7721c480e0 100644
--- a/source/gameengine/Ketsji/KX_SceneActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SceneActuator.cpp
@@ -50,7 +50,7 @@ KX_SceneActuator::KX_SceneActuator(SCA_IObject *gameobj,
 								   KX_KetsjiEngine* ketsjiEngine,
 								   const STR_String& nextSceneName,
 								   KX_Camera* camera)
-								   : SCA_IActuator(gameobj)
+								   : SCA_IActuator(gameobj, KX_ACT_SCENE)
 {
 	m_mode = mode;
 	m_scene  = scene;
diff --git a/source/gameengine/Ketsji/KX_SoundActuator.cpp b/source/gameengine/Ketsji/KX_SoundActuator.cpp
index e2b4022a312..9d261137497 100644
--- a/source/gameengine/Ketsji/KX_SoundActuator.cpp
+++ b/source/gameengine/Ketsji/KX_SoundActuator.cpp
@@ -49,7 +49,7 @@ KX_SoundActuator::KX_SoundActuator(SCA_IObject* gameobj,
 								   bool is3d,
 								   KX_3DSoundSettings settings,
 								   KX_SOUNDACT_TYPE type)//,
-								   : SCA_IActuator(gameobj)
+								   : SCA_IActuator(gameobj, KX_ACT_SOUND)
 {
 	m_sound = sound;
 	m_volume = volume;
diff --git a/source/gameengine/Ketsji/KX_StateActuator.cpp b/source/gameengine/Ketsji/KX_StateActuator.cpp
index 4159e9c373d..60812220953 100644
--- a/source/gameengine/Ketsji/KX_StateActuator.cpp
+++ b/source/gameengine/Ketsji/KX_StateActuator.cpp
@@ -40,7 +40,7 @@ KX_StateActuator::KX_StateActuator(
 	int operation,
 	unsigned int mask
 	) 
-	: SCA_IActuator(gameobj),
+	: SCA_IActuator(gameobj, KX_ACT_STATE),
 	  m_operation(operation),
 	  m_mask(mask)
 {
diff --git a/source/gameengine/Ketsji/KX_TrackToActuator.cpp b/source/gameengine/Ketsji/KX_TrackToActuator.cpp
index e6c2f86bbce..ace1cf8a6f4 100644
--- a/source/gameengine/Ketsji/KX_TrackToActuator.cpp
+++ b/source/gameengine/Ketsji/KX_TrackToActuator.cpp
@@ -60,7 +60,7 @@ KX_TrackToActuator::KX_TrackToActuator(SCA_IObject *gameobj,
 									   bool allow3D,
 									   int trackflag,
 									   int upflag)
-									   : SCA_IActuator(gameobj)
+									   : SCA_IActuator(gameobj, KX_ACT_TRACKTO)
 {
     m_time = time;
     m_allow3D = allow3D;
diff --git a/source/gameengine/Ketsji/KX_VisibilityActuator.cpp b/source/gameengine/Ketsji/KX_VisibilityActuator.cpp
index 184e127209f..5b0f6e6e9f2 100644
--- a/source/gameengine/Ketsji/KX_VisibilityActuator.cpp
+++ b/source/gameengine/Ketsji/KX_VisibilityActuator.cpp
@@ -41,7 +41,7 @@ KX_VisibilityActuator::KX_VisibilityActuator(
 	bool occlusion,
 	bool recursive
 	) 
-	: SCA_IActuator(gameobj),
+	: SCA_IActuator(gameobj, KX_ACT_VISIBILITY),
 	  m_visible(visible),
 	  m_occlusion(occlusion),
 	  m_recursive(recursive)
diff --git a/source/gameengine/PyDoc/GameTypes.py b/source/gameengine/PyDoc/GameTypes.py
index c391d0c3dec..60511f41c2b 100644
--- a/source/gameengine/PyDoc/GameTypes.py
+++ b/source/gameengine/PyDoc/GameTypes.py
@@ -4,15 +4,17 @@ Documentation for the GameTypes Module.
 
 @group Base: PyObjectPlus, CValue, CPropValue, SCA_ILogicBrick, SCA_IObject, SCA_ISensor, SCA_IController, SCA_IActuator
 
-@group Object: KX_GameObject, KX_LightObject, KX_Camera
+@group Object: KX_GameObject, KX_LightObject, KX_Camera, BL_ArmatureObject
+
+@group Animation: BL_ArmatureConstraint
 
 @group Mesh: KX_MeshProxy, KX_PolyProxy, KX_VertexProxy
 
 @group Shading: KX_PolygonMaterial, KX_BlenderMaterial, BL_Shader
 
-@group Sensors: SCA_ActuatorSensor, SCA_AlwaysSensor, SCA_DelaySensor, SCA_JoystickSensor, SCA_KeyboardSensor, KX_MouseFocusSensor, SCA_MouseSensor, KX_NearSensor, KX_NetworkMessageSensor, SCA_PropertySensor, KX_RadarSensor, SCA_RandomSensor, KX_RaySensor, KX_TouchSensor
+@group Sensors: SCA_ActuatorSensor, SCA_AlwaysSensor, SCA_DelaySensor, SCA_JoystickSensor, SCA_KeyboardSensor, KX_MouseFocusSensor, SCA_MouseSensor, KX_NearSensor, KX_NetworkMessageSensor, SCA_PropertySensor, KX_RadarSensor, SCA_RandomSensor, KX_RaySensor, KX_TouchSensor, KX_ArmatureSensor
 
-@group Actuators: SCA_2DFilterActuator, BL_ActionActuator, KX_SCA_AddObjectActuator, KX_CameraActuator, KX_ConstraintActuator, KX_SCA_DynamicActuator, KX_SCA_EndObjectActuator, KX_GameActuator, KX_IpoActuator, KX_NetworkMessageActuator, KX_ObjectActuator, KX_ParentActuator, SCA_PropertyActuator, SCA_RandomActuator, KX_SCA_ReplaceMeshActuator, KX_SceneActuator, BL_ShapeActionActuator, KX_SoundActuator, KX_StateActuator, KX_TrackToActuator, KX_VisibilityActuator
+@group Actuators: SCA_2DFilterActuator, BL_ActionActuator, BL_ArmatureActuator, KX_SCA_AddObjectActuator, KX_CameraActuator, KX_ConstraintActuator, KX_SCA_DynamicActuator, KX_SCA_EndObjectActuator, KX_GameActuator, KX_IpoActuator, KX_NetworkMessageActuator, KX_ObjectActuator, KX_ParentActuator, SCA_PropertyActuator, SCA_RandomActuator, KX_SCA_ReplaceMeshActuator, KX_SceneActuator, BL_ShapeActionActuator, KX_SoundActuator, KX_StateActuator, KX_TrackToActuator, KX_VisibilityActuator
 
 @group Controllers: SCA_ANDController, SCA_NANDController, SCA_NORController, SCA_ORController, SCA_PythonController, SCA_XNORController, SCA_XORController
 """
@@ -5686,6 +5688,332 @@ class KX_Camera(KX_GameObject):
 		@return: the first object hit or None if no object or object does not match prop
 		"""
 
+class BL_ArmatureObject(KX_GameObject):
+	"""
+	An armature object.
+	
+	@ivar constraints: The list of armature constraint defined on this armature
+	                   Elements of the list can be accessed by index or string.
+	                   The key format for string access is '<bone_name>:<constraint_name>'
+	@type constraints: list of L{BL_ArmatureConstraint}
+	@ivar channels: The list of armature channels. 
+		Elements of the list can be accessed by index or name the bone. 
+	@type channels: list of L{BL_ArmatureChannel}
+	"""
+	
+	def update():
+		"""
+		Ensures that the armature will be updated on next graphic frame.
+		
+		This action is unecessary if a KX_ArmatureActuator with mode run is active
+		or if an action is playing. Use this function in other cases. It must be called
+		on each frame to ensure that the armature is updated continously.
+		"""
+		
+class BL_ArmatureActuator(SCA_IActuator):
+	"""
+	Armature Actuators change constraint condition on armatures.
+	
+	@group Constants: KX_ACT_ARMATURE_RUN, KX_ACT_ARMATURE_ENABLE, KX_ACT_ARMATURE_DISABLE, KX_ACT_ARMATURE_SETTARGET, KX_ACT_ARMATURE_SETWEIGHT
+	@ivar KX_ACT_ARMATURE_RUN: see type
+	@ivar KX_ACT_ARMATURE_ENABLE: see type
+	@ivar KX_ACT_ARMATURE_DISABLE: see type
+	@ivar KX_ACT_ARMATURE_SETTARGET: see type
+	@ivar KX_ACT_ARMATURE_SETWEIGHT: see type
+ 	@ivar type: The type of action that the actuator executes when it is active.
+
+				KX_ACT_ARMATURE_RUN(0): just make sure the armature will be updated on the next graphic frame
+				This is the only persistent mode of the actuator: it executes automatically once per frame until stopped by a controller
+
+				KX_ACT_ARMATURE_ENABLE(1): enable the constraint.
+
+				KX_ACT_ARMATURE_DISABLE(2): disable the constraint (runtime constraint values are not updated).
+
+				KX_ACT_ARMATURE_SETTARGET(3): change target and subtarget of constraint
+
+				KX_ACT_ARMATURE_SETWEIGHT(4): change weight of (only for IK constraint)
+	@type type: integer
+	@ivar constraint: The constraint object this actuator is controlling.
+	@type constraint: L{BL_ArmatureConstraint}
+	@ivar target: The object that this actuator will set as primary target to the constraint it controls
+	@type target: L{KX_GameObject}
+	@ivar subtarget: The object that this actuator will set as secondary target to the constraint it controls.
+	                 Currently, the only secondary target is the pole target for IK constraint.
+	@type subtarget: L{KX_GameObject}
+	@ivar weight: The weight this actuator will set on the constraint it controls.
+	              Currently only the IK constraint has a weight. It must be a value between 0 and 1.
+	              A weight of 0 disables a constraint while still updating constraint runtime values (see L{BL_ArmatureConstraint})
+	@type weight: float
+	"""
+
+class KX_ArmatureSensor(SCA_ISensor):
+	"""
+	Armature sensor detect conditions on armatures.
+	
+	@group Constants: KX_ARMSENSOR_STATE_CHANGED, KX_ARMSENSOR_LIN_ERROR_BELOW, KX_ARMSENSOR_LIN_ERROR_ABOVE, KX_ARMSENSOR_ROT_ERROR_BELOW, KX_ARMSENSOR_ROT_ERROR_ABOVE
+	@ivar KX_ARMSENSOR_STATE_CHANGED: see type
+ 	@ivar KX_ARMSENSOR_LIN_ERROR_BELOW: see type
+	@ivar KX_ARMSENSOR_LIN_ERROR_ABOVE: see type
+	@ivar KX_ARMSENSOR_ROT_ERROR_BELOW: see type
+	@ivar KX_ARMSENSOR_ROT_ERROR_ABOVE: see type
+	@ivar type: The type of measurement that the sensor make when it is active.
+
+				KX_ARMSENSOR_STATE_CHANGED(0): detect that the constraint is changing state (active/inactive)
+
+				KX_ARMSENSOR_LIN_ERROR_BELOW(1): detect that the constraint linear error is above a threshold
+
+				KX_ARMSENSOR_LIN_ERROR_ABOVE(2): detect that the constraint linear error is below a threshold
+
+				KX_ARMSENSOR_ROT_ERROR_BELOW(3): detect that the constraint rotation error is above a threshold
+
+				KX_ARMSENSOR_ROT_ERROR_ABOVE(4): detect that the constraint rotation error is below a threshold
+	@type type: integer
+	@ivar constraint: The constraint object this sensor is watching.
+	@type constraint: L{BL_ArmatureConstraint}
+	@ivar value: The threshold used in the comparison with the constraint error
+	             The linear error is only updated on CopyPose/Distance IK constraint with iTaSC solver
+	             The rotation error is only updated on CopyPose+rotation IK constraint with iTaSC solver
+	             The linear error on CopyPose is always >= 0: it is the norm of the distance between the target and the bone
+	             The rotation error on CopyPose is always >= 0: it is the norm of the equivalent rotation vector between the bone and the target orientations
+	             The linear error on Distance can be positive if the distance between the bone and the target is greater than the desired distance, and negative if the distance is smaller
+	@type value: float
+	"""
+
+class BL_ArmatureConstraint(PyObjectPlus):
+	"""
+	Proxy to Armature Constraint. Allows to change constraint on the fly.
+	Obtained through L{BL_ArmatureObject}.constraints.
+	Note: not all armature constraints are supported in the GE.
+	
+	@group Constants: CONSTRAINT_TYPE_TRACKTO, CONSTRAINT_TYPE_KINEMATIC, CONSTRAINT_TYPE_ROTLIKE, CONSTRAINT_TYPE_LOCLIKE, CONSTRAINT_TYPE_MINMAX, CONSTRAINT_TYPE_SIZELIKE, CONSTRAINT_TYPE_LOCKTRACK, CONSTRAINT_TYPE_STRETCHTO, CONSTRAINT_TYPE_CLAMPTO, CONSTRAINT_TYPE_TRANSFORM, CONSTRAINT_TYPE_DISTLIMIT,CONSTRAINT_IK_COPYPOSE, CONSTRAINT_IK_DISTANCE,CONSTRAINT_IK_MODE_INSIDE, CONSTRAINT_IK_MODE_OUTSIDE,CONSTRAINT_IK_MODE_ONSURFACE,CONSTRAINT_IK_FLAG_TIP,CONSTRAINT_IK_FLAG_ROT, CONSTRAINT_IK_FLAG_STRETCH, CONSTRAINT_IK_FLAG_POS
+	@ivar CONSTRAINT_TYPE_TRACKTO: see type
+	@ivar CONSTRAINT_TYPE_KINEMATIC: see type
+	@ivar CONSTRAINT_TYPE_ROTLIKE: see type
+	@ivar CONSTRAINT_TYPE_LOCLIKE: see type
+	@ivar CONSTRAINT_TYPE_MINMAX: see type
+	@ivar CONSTRAINT_TYPE_SIZELIKE: see type
+	@ivar CONSTRAINT_TYPE_LOCKTRACK: see type
+	@ivar CONSTRAINT_TYPE_STRETCHTO: see type
+	@ivar CONSTRAINT_TYPE_CLAMPTO: see type
+	@ivar CONSTRAINT_TYPE_TRANSFORM: see type
+	@ivar CONSTRAINT_TYPE_DISTLIMIT: see type
+	@ivar CONSTRAINT_IK_COPYPOSE: see ik_type
+	@ivar CONSTRAINT_IK_DISTANCE: see ik_type
+	@ivar CONSTRAINT_IK_MODE_INSIDE: see ik_mode
+	@ivar CONSTRAINT_IK_MODE_OUTSIDE: see ik_mode
+	@ivar CONSTRAINT_IK_MODE_ONSURFACE: see ik_mode
+	@ivar CONSTRAINT_IK_FLAG_TIP: see ik_flag
+	@ivar CONSTRAINT_IK_FLAG_ROT: see ik_flag
+	@ivar CONSTRAINT_IK_FLAG_STRETCH: see ik_flag
+	@ivar CONSTRAINT_IK_FLAG_POS: see ik_flag
+	@ivar type: Type of constraint, read-only
+	@type type: integer, one of CONSTRAINT_TYPE_ constant
+	@ivar name: Name of constraint constructed as <bone_name>:<constraint_name>
+	            This name is also the key subscript on L{BL_ArmatureObject}.constraints list
+	@type name: string
+	@ivar enforce: fraction of constraint effect that is enforced. Between 0 and 1.
+	@type enforce: float
+	@ivar headtail: position of target between head and tail of the target bone: 0=head, 1=tail
+	                Only used if the target is a bone (i.e target object is an armature)
+	@type headtail: float
+	@ivar lin_error: runtime linear error (in Blender unit) on constraint at the current frame.
+	                 This is a runtime value updated on each frame by the IK solver. Only available on IK constraint and iTaSC solver.
+	@type lin_error: float
+	@ivar rot_error: runtime rotation error (in radiant) on constraint at the current frame.
+	                 This is a runtime value updated on each frame by the IK solver. Only available on IK constraint and iTaSC solver.
+	                 It is only set if the constraint has a rotation part, for example, a CopyPose+Rotation IK constraint.
+	@type rot_error: float
+	@ivar target: Primary target object for the constraint. The position of this object in the GE will be used as target for the constraint.
+	@type target: L{KX_GameObject}
+	@ivar subtarget: Secondary target object for the constraint. The position of this object in the GE will be used as secondary target for the constraint.
+	                 Currently this is only used for pole target on IK constraint.
+	@type subtarget: L{KX_GameObject}
+	@ivar active: True if the constraint is active.
+	              Note: an inactive constraint does not update lin_error and rot_error.
+	@type active: boolean
+	@ivar ik_weight: Weight of the IK constraint between 0 and 1. 
+	                 Only defined for IK constraint.
+	@type ik_weight: float
+	@ivar ik_type: Type of IK constraint, read-only
+
+				   CONSTRAINT_IK_COPYPOSE(0): constraint is trying to match the position and eventually the rotation of the target.
+
+				   CONSTRAINT_IK_DISTANCE(1): constraint is maintaining a certain distance to target subject to ik_mode
+	@type ik_type: integer
+	@ivar ik_flag: Combination of IK constraint option flags, read-only
+
+				   CONSTRAINT_IK_FLAG_TIP(1) : set when the constraint operates on the head of the bone and not the tail
+
+				   CONSTRAINT_IK_FLAG_ROT(2) : set when the constraint tries to match the orientation of the target
+
+				   CONSTRAINT_IK_FLAG_STRETCH(16) : set when the armature is allowed to stretch (only the bones with stretch factor > 0.0)
+
+				   CONSTRAINT_IK_FLAG_POS(32) : set when the constraint tries to match the position of the target
+	@type ik_flag: integer
+	@ivar ik_dist: Distance the constraint is trying to maintain with target, only used when ik_type=CONSTRAINT_IK_DISTANCE
+	@type ik_dist: float
+	@ivar ik_mode: Additional mode for IK constraint. Currently only used for Distance constraint:
+
+				   CONSTRAINT_IK_MODE_INSIDE(0) : the constraint tries to keep the bone within ik_dist of target
+
+				   CONSTRAINT_IK_MODE_OUTSIDE(1) : the constraint tries to keep the bone outside ik_dist of the target
+
+				   CONSTRAINT_IK_MODE_ONSURFACE(2) : the constraint tries to keep the bone exactly at ik_dist of the target
+	@type ik_mode: integer
+	"""
+
+class BL_ArmatureChannel(PyObjectPlus):
+	"""
+	Proxy to armature pose channel. Allows to read and set armature pose.
+	The attributes are identical to RNA attributes, but mostly in read-only mode.
+	
+	@group Constants: PCHAN_ROT_QUAT, PCHAN_ROT_XYZ, PCHAN_ROT_XZY, PCHAN_ROT_YXZ, PCHAN_ROT_YZX, PCHAN_ROT_ZXY, PCHAN_ROT_ZYX
+	@ivar PCHAN_ROT_QUAT: see rotation_mode
+	@ivar PCHAN_ROT_XYZ: see rotation_mode
+	@ivar PCHAN_ROT_XZY: see rotation_mode
+	@ivar PCHAN_ROT_YXZ: see rotation_mode
+	@ivar PCHAN_ROT_YZX: see rotation_mode
+	@ivar PCHAN_ROT_ZXY: see rotation_mode
+	@ivar PCHAN_ROT_ZYX: see rotation_mode
+	@ivar name: channel name (=bone name), read-only.
+	@type name: string
+	@ivar bone: return the bone object corresponding to this pose channel, read-only.
+	@type bone: L{BL_ArmatureBone}
+	@ivar parent: return the parent channel object, None if root channel, read-only.
+	@type parent: L{BL_ArmatureChannel}
+	@ivar has_ik: true if the bone is part of an active IK chain, read-only.
+		This flag is not set when an IK constraint is defined but not enabled (miss target information for example)
+	@type has_ik: boolean
+	@ivar ik_dof_x: true if the bone is free to rotation in the X axis, read-only.
+	@type ik_dof_x: boolean
+	@ivar ik_dof_y: true if the bone is free to rotation in the Y axis, read-only.
+	@type ik_dof_y: boolean
+	@ivar ik_dof_z: true if the bone is free to rotation in the Z axis, read-only.
+	@type ik_dof_z: boolean
+	@ivar ik_limit_x: true if a limit is imposed on X rotation, read-only.
+	@type ik_limit_x: boolean
+	@ivar ik_limit_y: true if a limit is imposed on Y rotation, read-only.
+	@type ik_limit_y: boolean
+	@ivar ik_limit_z: true if a limit is imposed on Z rotation, read-only.
+	@type ik_limit_z: boolean
+	@ivar ik_rot_control: true if channel rotation should applied as IK constraint, read-only.
+	@type ik_rot_control: boolean
+	@ivar ik_lin_control: true if channel size should applied as IK constraint, read-only.
+	@type ik_lin_control: boolean
+	@ivar location: displacement of the bone head in armature local space, read-write.
+		You can only move a bone if it is unconnected to its parent. An action playing on the armature may change the value. An IK chain does not update this value, see joint_rotation.
+		Changing this field has no immediate effect, the pose is updated when the armature is updated during the graphic render (see L{BL_ArmatureObject.update})
+	@type location: vector [X,Y,Z]
+	@ivar scale: scale of the bone relative to its parent, read-write.
+		An action playing on the armature may change the value.  An IK chain does not update this value, see joint_rotation.
+		Changing this field has no immediate effect, the pose is updated when the armature is updated during the graphic render (see L{BL_ArmatureObject.update})
+	@type scale: vector [sizeX, sizeY, sizeZ]
+	@ivar rotation: rotation of the bone relative to its parent expressed as a quaternion, read-write.
+		This field is only used if rotation_mode is 0. An action playing on the armature may change the value.  An IK chain does not update this value, see joint_rotation.
+		Changing this field has no immediate effect, the pose is updated when the armature is updated during the graphic render (see L{BL_ArmatureObject.update})
+	@type rotation: vector [qr, qi, qj, qk]
+	@ivar euler_rotation: rotation of the bone relative to its parent expressed as a set of euler angles, read-write.
+		This field is only used if rotation_mode is > 0. You must always pass the angles in [X,Y,Z] order; the order of applying the angles to the bone depends on rotation_mode. An action playing on the armature may change this field.  An IK chain does not update this value, see joint_rotation.
+		Changing this field has no immediate effect, the pose is updated when the armature is updated during the graphic render (see L{BL_ArmatureObject.update})
+	@type euler_rotation: vector [X, Y, Z]
+	@ivar rotation_mode: method of updating the bone rotation, read-write.
+		Use the following constants (euler mode are named as in BLender UI but the actual axis order is reversed):
+		  - PCHAN_ROT_QUAT(0) : use quaternioin in rotation attribute to update bone rotation
+		  - PCHAN_ROT_XYZ(1) : use euler_rotation and apply angles on bone's Z, Y, X axis successively
+		  - PCHAN_ROT_XZY(2) : use euler_rotation and apply angles on bone's Y, Z, X axis successively
+		  - PCHAN_ROT_YXZ(3) : use euler_rotation and apply angles on bone's Z, X, Y axis successively
+		  - PCHAN_ROT_YZX(4) : use euler_rotation and apply angles on bone's X, Z, Y axis successively
+		  - PCHAN_ROT_ZXY(5) : use euler_rotation and apply angles on bone's Y, X, Z axis successively
+		  - PCHAN_ROT_ZYX(6) : use euler_rotation and apply angles on bone's X, Y, Z axis successively
+	@type rotation_mode: integer
+	@ivar channel_matrix: pose matrix in bone space (deformation of the bone due to action, constraint, etc), Read-only.
+		This field is updated after the graphic render, it represents the current pose.
+	@type channel_matrix: matrix [4][4]
+	@ivar pose_matrix: pose matrix in armature space, read-only,
+		This field is updated after the graphic render, it represents the current pose.
+	@type pose_matrix: matrix [4][4]
+	@ivar pose_head: position of bone head in armature space, read-only.
+	@type pose_head: vector [x, y, z]
+	@ivar pose_tail: position of bone tail in armature space, read-only.
+	@type pose_tail: vector [x, y, z]
+	@ivar ik_min_x: minimum value of X rotation in degree (<= 0) when X rotation is limited (see ik_limit_x), read-only.
+	@type ik_min_x: float
+	@ivar ik_max_x: maximum value of X rotation in degree (>= 0) when X rotation is limited (see ik_limit_x), read-only.
+	@type ik_max_x: float
+	@ivar ik_min_y: minimum value of Y rotation in degree (<= 0) when Y rotation is limited (see ik_limit_y), read-only.
+	@type ik_min_y: float
+	@ivar ik_max_y: maximum value of Y rotation in degree (>= 0) when Y rotation is limited (see ik_limit_y), read-only.
+	@type ik_max_y: float
+	@ivar ik_min_z: minimum value of Z rotation in degree (<= 0) when Z rotation is limited (see ik_limit_z), read-only.
+	@type ik_min_z: float
+	@ivar ik_max_z: maximum value of Z rotation in degree (>= 0) when Z rotation is limited (see ik_limit_z), read-only.
+	@type ik_max_z: float
+	@ivar ik_stiffness_x: bone rotation stiffness in X axis, read-only
+	@type ik_stiffness_x: float between 0 and 1
+	@ivar ik_stiffness_y: bone rotation stiffness in Y axis, read-only
+	@type ik_stiffness_y: float between 0 and 1
+	@ivar ik_stiffness_z: bone rotation stiffness in Z axis, read-only
+	@type ik_stiffness_z: float between 0 and 1
+	@ivar ik_stretch: ratio of scale change that is allowed, 0=bone can't change size, read-only.
+	@type ik_stretch: float
+	@ivar ik_rot_weight: weight of rotation constraint when ik_rot_control is set, read-write.
+	@type ik_rot_weight: float between 0 and 1
+	@ivar ik_lin_weight: weight of size constraint when ik_lin_control is set, read-write.
+	@type ik_lin_weight: float between 0 and 1
+	@ivar joint_rotation: control bone rotation in term of joint angle (for robotic applications), read-write.
+		When writing to this attribute, you pass a [x, y, z] vector and an appropriate set of euler angles or quaternion is calculated according to the rotation_mode.
+		When you read this attribute, the current pose matrix is converted into a [x, y, z] vector representing the joint angles.
+		The value and the meaning of the x, y, z depends on the ik_dof_ attributes:
+		  - 1DoF joint X, Y or Z: the corresponding x, y, or z value is used an a joint angle in radiant
+		  - 2DoF joint X+Y or Z+Y: treated as 2 successive 1DoF joints: first X or Z, then Y. The x or z value is used as a joint angle in radiant along the X or Z axis, followed by a rotation along the new Y axis of y radiants.
+		  - 2DoF joint X+Z: treated as a 2DoF joint with rotation axis on the X/Z plane. The x and z values are used as the coordinates of the rotation vector in the X/Z plane.
+		  - 3DoF joint X+Y+Z: treated as a revolute joint. The [x,y,z] vector represents the equivalent rotation vector to bring the joint from the rest pose to the new pose.
+
+		Notes:
+		  - The bone must be part of an IK chain if you want to set the ik_dof_ attributes via the UI, but this will interfere with this attribute since the IK solver will overwrite the pose. You can stay in control of the armature if you create an IK constraint but do not finalize it (e.g. don't set a target): the IK solver will not run but the IK panel will show up on the UI for each bone in the chain.
+		  - [0,0,0] always corresponds to the rest pose. 
+		  - You must request the armature pose to update and wait for the next graphic frame to see the effect of setting this attribute (see L{BL_ArmatureObject.update}). 
+		  - You can read the result of the calculation in rotation or euler_rotation attributes after setting this attribute.
+	@type joint_rotation: vector [x, y, z]
+	"""
+	
+class BL_ArmatureBone(PyObjectPlus):
+	"""
+	Proxy to Blender bone structure. All fields are read-only and comply to RNA names.
+	All space attribute correspond to the rest pose.
+	
+	@ivar name: bone name
+	@type name: string
+	@ivar connected: true when the bone head is struck to the parent's tail
+	@type connected: boolean
+	@ivar hinge: true when bone doesn't inherit rotation or scale from parent bone
+	@type hinge: boolean
+	@ivar inherit_scale: true when bone inherits scaling from parent bone
+	@type inherit_scale: boolean
+	@ivar bbone_segments: number of B-bone segments
+	@type bbone_segments: integer
+	@ivar roll: bone rotation around head-tail axis
+	@type roll: float
+	@ivar head: location of head end of the bone in parent bone space
+	@type head: vector [x, y, z]
+	@ivar tail: location of head end of the bone in parent bone space
+	@type tail: vector [x, y, z]
+	@ivar length: bone length
+	@type length: float
+	@ivar arm_head: location of head end of the bone in armature space
+	@type arm_head: vector [x, y, z]
+	@ivar arm_tail: location of tail end of the bone in armature space
+	@type arm_tail: vector [x, y, z]
+	@ivar arm_mat: matrix of the bone head in armature space
+		This matrix has no scale part.
+	@type arm_mat: matrix [4][4]
+	@ivar bone_mat: rotation matrix of the bone in parent bone space.
+	@type bone_mat: matrix [3][3]
+	@ivar parent: parent bone, or None for root bone
+	@type parent: L{BL_ArmatureBone}
+	@ivar children: list of bone's children
+	@type children: list of L{BL_ArmatureBone}
+	"""
 # Util func to extract all attrs
 """
 import types
diff --git a/source/gameengine/SceneGraph/SG_DList.h b/source/gameengine/SceneGraph/SG_DList.h
index 3e17fb55dc0..97951792ab5 100644
--- a/source/gameengine/SceneGraph/SG_DList.h
+++ b/source/gameengine/SceneGraph/SG_DList.h
@@ -89,6 +89,46 @@ public:
 		}
 	};
 
+	template<typename T> class const_iterator
+	{
+	private:
+		const SG_DList&	m_head;
+		const T*		m_current;
+	public:
+		typedef const_iterator<T> _myT;
+		const_iterator(const SG_DList& head) : m_head(head), m_current(NULL) {}
+		~const_iterator() {}
+
+		void begin()
+		{
+			m_current = (const T*)m_head.Peek();
+		}
+		void back()
+		{
+			m_current = (const T*)m_head.Back();
+		}
+		bool end()
+		{
+			return (m_current == (const T*)m_head.Self());
+		}
+		const T* operator*()
+		{
+			return m_current;
+		}
+		_myT& operator++()
+		{
+			// no check of NULL! make sure you don't try to increment beyond end
+			m_current = (const T*)m_current->Peek();
+			return *this;
+		}
+		_myT& operator--()
+		{
+			// no check of NULL! make sure you don't try to increment beyond end
+			m_current = (const T*)m_current->Back();
+			return *this;
+		}
+	};
+
     SG_DList() 
     { 
         m_flink = m_blink = this; 
@@ -159,6 +199,18 @@ public:
     { 
         return this; 
     }
+    inline const SG_DList *Peek() const			// Look at front without removing
+    { 
+        return (const SG_DList*)m_flink; 
+    }  
+    inline const SG_DList *Back() const			// Look at front without removing
+    { 
+        return (const SG_DList*)m_blink; 
+    }  
+    inline const SG_DList *Self() const 
+    { 
+        return this; 
+    }
 	
 	
 #ifdef WITH_CXX_GUARDEDALLOC
@@ -168,5 +220,32 @@ public:
 #endif
 };
 
+/**
+ * SG_DListHead : Template class that implements copy constructor to duplicate list automatically
+ *                The elements of the list must have themselves a copy constructor.
+ */
+template<typename T> class SG_DListHead : public SG_DList
+{
+public:
+	typedef SG_DListHead<T> _myT;
+	SG_DListHead() : SG_DList() {}
+	SG_DListHead(const _myT& other) : SG_DList()
+	{
+		// copy the list, assuming objects of type T
+		const_iterator<T> eit(other);
+		T* elem;
+		for (eit.begin(); !eit.end(); ++eit) {
+			elem = (*eit)->GetReplica();
+			AddBack(elem);
+		}
+	}
+	virtual ~SG_DListHead() {}
+    T* Remove()
+    {
+		return static_cast<T*>(SG_DList::Remove());
+    }
+
+};
+
 #endif //__SG_DLIST