CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/pyCritterBrainGlue.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "pyCritterBrain.h"
#include "pyEnum.h"
#include "pyGeometry3.h"

#include "..\plMessage\plAIMsg.h"

#include <python.h>

///////////////////////////////////////////////////////////////////////////////
//
// AddPlasmaConstantsClasses
//
void pyAIMsg::AddPlasmaConstantsClasses(PyObject *m)
{
	PYTHON_ENUM_START(PtAIMsgType);
	PYTHON_ENUM_ELEMENT(PtAIMsgType, kUnknown, plAIMsg::kAIMsg_Unknown);
	PYTHON_ENUM_ELEMENT(PtAIMsgType, kBrainCreated, plAIMsg::kAIMsg_BrainCreated);
	PYTHON_ENUM_ELEMENT(PtAIMsgType, kArrivedAtGoal, plAIMsg::kAIMsg_ArrivedAtGoal);
	PYTHON_ENUM_END(m, PtAIMsgType);
}

///////////////////////////////////////////////////////////////////////////////

// glue functions
PYTHON_CLASS_DEFINITION(ptCritterBrain, pyCritterBrain);

PYTHON_DEFAULT_NEW_DEFINITION(ptCritterBrain, pyCritterBrain)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptCritterBrain)

PYTHON_NO_INIT_DEFINITION(ptCritterBrain)

PYTHON_RICH_COMPARE_DEFINITION(ptCritterBrain, obj1, obj2, compareType)
{
	if ((obj1 == Py_None) || (obj2 == Py_None) || !pyCritterBrain::Check(obj1) || !pyCritterBrain::Check(obj2))
	{
		// if they aren't the same type, they don't match, obviously (we also never equal none)
		if (compareType == Py_EQ)
			PYTHON_RCOMPARE_FALSE;
		else if (compareType == Py_NE)
			PYTHON_RCOMPARE_TRUE;
		else
		{
			PyErr_SetString(PyExc_NotImplementedError, "invalid comparison for a ptCritterBrain object");
			PYTHON_RCOMPARE_ERROR;
		}
	}
	pyCritterBrain* brain1 = pyCritterBrain::ConvertFrom(obj1);
	pyCritterBrain* brain2 = pyCritterBrain::ConvertFrom(obj2);
	if (compareType == Py_EQ)
	{
		if ((*brain1) == (*brain2))
			PYTHON_RCOMPARE_TRUE;
		PYTHON_RCOMPARE_FALSE;
	}
	else if (compareType == Py_NE)
	{
		if ((*brain1) != (*brain2))
			PYTHON_RCOMPARE_TRUE;
		PYTHON_RCOMPARE_FALSE;
	}
	PyErr_SetString(PyExc_NotImplementedError, "invalid comparison for a ptCritterBrain object");
	PYTHON_RCOMPARE_ERROR;
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, addReceiver, args)
{
	PyObject* keyObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &keyObj))
	{
		PyErr_SetString(PyExc_TypeError, "addReceiver expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(keyObj))
	{
		PyErr_SetString(PyExc_TypeError, "addReceiver expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey* key = pyKey::ConvertFrom(keyObj);
	self->fThis->AddReceiver(*key);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, removeReceiver, args)
{
	PyObject* keyObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &keyObj))
	{
		PyErr_SetString(PyExc_TypeError, "removeReceiver expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	if (!pyKey::Check(keyObj))
	{
		PyErr_SetString(PyExc_TypeError, "removeReceiver expects a ptKey");
		PYTHON_RETURN_ERROR;
	}
	pyKey* key = pyKey::ConvertFrom(keyObj);
	self->fThis->RemoveReceiver(*key);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, setLocallyControlled, args)
{
	char local;
	if (!PyArg_ParseTuple(args, "b", &local))
	{
		PyErr_SetString(PyExc_TypeError, "setLocallyControlled expects a boolean");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->LocallyControlled(local != 0);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, getLocallyControlled)
{
	PYTHON_RETURN_BOOL(self->fThis->LocallyControlled());
}

PYTHON_METHOD_DEFINITION_WKEY(ptCritterBrain, addBehavior, args, keywords)
{
	char* kwlist[] = {"animationName", "behaviorName", "loop", "randomStartPos", "fadeInLen", "fadeOutLen", NULL};
	PyObject* animNameObj = NULL;
	PyObject* behNameObj = NULL;
	char loop = 1, randomStartPos = 1;
	float fadeInLen = 2.f, fadeOutLen = 2.f;
	if (!PyArg_ParseTupleAndKeywords(args, keywords, "OO|bbff", kwlist, &animNameObj, &behNameObj, &loop, &randomStartPos, &fadeInLen, &fadeOutLen))
	{
		PyErr_SetString(PyExc_TypeError, "addBehavior expects two strings, and optionally two booleans and two floats");
		PYTHON_RETURN_ERROR;
	}

	std::string animName = "";
	if (PyUnicode_Check(animNameObj))
	{
		int strLen = PyUnicode_GetSize(animNameObj);
		wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
		PyUnicode_AsWideChar((PyUnicodeObject*)animNameObj, text, strLen);
		text[strLen] = L'\0';
		char* cText = hsWStringToString(text);
		animName = cText;
		delete [] cText;
		delete [] text;
	}
	else if (PyString_Check(animNameObj))
		animName = PyString_AsString(animNameObj);
	else
	{
		PyErr_SetString(PyExc_TypeError, "addBehavior expects two strings, and optionally two booleans and two floats");
		PYTHON_RETURN_ERROR;
	}

	std::string behName = "";
	if (PyUnicode_Check(behNameObj))
	{
		int strLen = PyUnicode_GetSize(behNameObj);
		wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
		PyUnicode_AsWideChar((PyUnicodeObject*)behNameObj, text, strLen);
		text[strLen] = L'\0';
		char* cText = hsWStringToString(text);
		behName = cText;
		delete [] cText;
		delete [] text;
	}
	else if (PyString_Check(behNameObj))
		behName = PyString_AsString(behNameObj);
	else
	{
		PyErr_SetString(PyExc_TypeError, "addBehavior expects two strings, and optionally two booleans and two floats");
		PYTHON_RETURN_ERROR;
	}

	self->fThis->AddBehavior(animName, behName, loop != 0, randomStartPos != 0, fadeInLen, fadeOutLen);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_WKEY(ptCritterBrain, startBehavior, args, keywords)
{
	char* kwlist[] = {"behaviorName", "fade", NULL};
	PyObject* behNameObj = NULL;
	char fade = 1;
	if (!PyArg_ParseTupleAndKeywords(args, keywords, "O|b", kwlist, &behNameObj, &fade))
	{
		PyErr_SetString(PyExc_TypeError, "startBehavior expects a string, and an optional boolean");
		PYTHON_RETURN_NONE;
	}

	std::string behName = "";
	if (PyUnicode_Check(behNameObj))
	{
		int strLen = PyUnicode_GetSize(behNameObj);
		wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
		PyUnicode_AsWideChar((PyUnicodeObject*)behNameObj, text, strLen);
		text[strLen] = L'\0';
		char* cText = hsWStringToString(text);
		behName = cText;
		delete [] cText;
		delete [] text;
	}
	else if (PyString_Check(behNameObj))
		behName = PyString_AsString(behNameObj);
	else
	{
		PyErr_SetString(PyExc_TypeError, "startBehavior expects a string, and an optional boolean");
		PYTHON_RETURN_ERROR;
	}

	self->fThis->StartBehavior(behName, fade != 0);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, runningBehavior, args)
{
	PyObject* behNameObj = NULL;
	if (!PyArg_ParseTuple(args, "O", &behNameObj))
	{
		PyErr_SetString(PyExc_TypeError, "runningBehavior expects a string");
		PYTHON_RETURN_ERROR;
	}

	if (PyUnicode_Check(behNameObj))
	{
		int strLen = PyUnicode_GetSize(behNameObj);
		wchar_t* text = TRACKED_NEW wchar_t[strLen + 1];
		PyUnicode_AsWideChar((PyUnicodeObject*)behNameObj, text, strLen);
		text[strLen] = L'\0';
		char* cText = hsWStringToString(text);
		bool retVal = self->fThis->RunningBehavior(cText);
		delete [] cText;
		delete [] text;
		PYTHON_RETURN_BOOL(retVal);
	}
	else if (PyString_Check(behNameObj))
	{
		bool retVal = self->fThis->RunningBehavior(PyString_AsString(behNameObj));
		PYTHON_RETURN_BOOL(retVal);
	}
	else
	{
		PyErr_SetString(PyExc_TypeError, "runningBehavior expects a string");
		PYTHON_RETURN_ERROR;
	}
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, behaviorName, args)
{
	int behavior;
	if (!PyArg_ParseTuple(args, "i", &behavior))
	{
		PyErr_SetString(PyExc_TypeError, "behaviorName expects an integer");
		PYTHON_RETURN_ERROR;
	}
	return PyString_FromString(self->fThis->BehaviorName(behavior).c_str());
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, animationName, args)
{
	int behavior;
	if (!PyArg_ParseTuple(args, "i", &behavior))
	{
		PyErr_SetString(PyExc_TypeError, "animationName expects an integer");
		PYTHON_RETURN_ERROR;
	}
	return PyString_FromString(self->fThis->AnimationName(behavior).c_str());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, curBehavior)
{
	return PyInt_FromLong(self->fThis->CurBehavior());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, nextBehavior)
{
	return PyInt_FromLong(self->fThis->NextBehavior());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, idleBehaviorName)
{
	return PyString_FromString(self->fThis->IdleBehaviorName().c_str());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, runBehaviorName)
{
	return PyString_FromString(self->fThis->RunBehaviorName().c_str());
}

PYTHON_METHOD_DEFINITION_WKEY(ptCritterBrain, goToGoal, args, keywords)
{
	char* kwlist[] = {"newGoal", "avoidingAvatars", NULL};
	PyObject* goalObj = NULL;
	char avoidingAvatars = 0;
	if (!PyArg_ParseTupleAndKeywords(args, keywords, "O|b", kwlist, &goalObj, &avoidingAvatars))
	{
		PyErr_SetString(PyExc_TypeError, "goToGoal expects a ptPoint and an optional boolean.");
		PYTHON_RETURN_ERROR;
	}

	if (!pyPoint3::Check(goalObj))
	{
		PyErr_SetString(PyExc_TypeError, "goToGoal expects a ptPoint and an optional boolean.");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->GoToGoal(pyPoint3::ConvertFrom(goalObj)->fPoint, avoidingAvatars != 0);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, currentGoal)
{
	return self->fThis->CurrentGoal();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, avoidingAvatars)
{
	PYTHON_RETURN_BOOL(self->fThis->AvoidingAvatars());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, atGoal)
{
	PYTHON_RETURN_BOOL(self->fThis->AtGoal());
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, setStopDistance, args)
{
	float dist;
	if (!PyArg_ParseTuple(args, "f", &dist))
	{
		PyErr_SetString(PyExc_TypeError, "setStopDistance expects a float");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->StopDistance(dist);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, getStopDistance)
{
	return PyFloat_FromDouble(self->fThis->StopDistance());
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, setSightCone, args)
{
	float dist;
	if (!PyArg_ParseTuple(args, "f", &dist))
	{
		PyErr_SetString(PyExc_TypeError, "setSightCone expects a float");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->SightCone(dist);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, getSightCone)
{
	return PyFloat_FromDouble(self->fThis->SightCone());
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, setSightDistance, args)
{
	float dist;
	if (!PyArg_ParseTuple(args, "f", &dist))
	{
		PyErr_SetString(PyExc_TypeError, "setSightDistance expects a float");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->SightDistance(dist);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, getSightDistance)
{
	return PyFloat_FromDouble(self->fThis->SightDistance());
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, setHearingDistance, args)
{
	float dist;
	if (!PyArg_ParseTuple(args, "f", &dist))
	{
		PyErr_SetString(PyExc_TypeError, "setHearingDistance expects a float");
		PYTHON_RETURN_ERROR;
	}
	self->fThis->HearingDistance(dist);
	PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, getHearingDistance)
{
	return PyFloat_FromDouble(self->fThis->HearingDistance());
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, canSeeAvatar, args)
{
	unsigned long id;
	if (!PyArg_ParseTuple(args, "k", &id))
	{
		PyErr_SetString(PyExc_TypeError, "canSeeAvatar expects an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	PYTHON_RETURN_BOOL(self->fThis->CanSeeAvatar(id));
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, canHearAvatar, args)
{
	unsigned long id;
	if (!PyArg_ParseTuple(args, "k", &id))
	{
		PyErr_SetString(PyExc_TypeError, "canHearAvatar expects an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	PYTHON_RETURN_BOOL(self->fThis->CanHearAvatar(id));
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, playersICanSee)
{
	return self->fThis->PlayersICanSee();
}

PYTHON_METHOD_DEFINITION_NOARGS(ptCritterBrain, playersICanHear)
{
	return self->fThis->PlayersICanHear();
}

PYTHON_METHOD_DEFINITION(ptCritterBrain, vectorToPlayer, args)
{
	unsigned long id;
	if (!PyArg_ParseTuple(args, "k", &id))
	{
		PyErr_SetString(PyExc_TypeError, "vectorToPlayer expects an unsigned long");
		PYTHON_RETURN_ERROR;
	}
	return self->fThis->VectorToPlayer(id);
}

PYTHON_START_METHODS_TABLE(ptCritterBrain)
	PYTHON_METHOD(ptCritterBrain, addReceiver, "Params: key\nTells the brain that the specified key wants AI messages"),
	PYTHON_METHOD(ptCritterBrain, removeReceiver, "Params: key\nTells the brain that the specified key no longer wants AI messages"),
	PYTHON_METHOD(ptCritterBrain, setLocallyControlled, "Params: local\nTells the brain that we are the ones making all the AI decisions, and to prop location "
		"and other information to the server."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, getLocallyControlled, "Are we the one making AI decisions? NOTE: Not set automatically, some python script needs to "
		"tell the brain this using setLocallyControlled()."),
	PYTHON_METHOD_WKEY(ptCritterBrain, addBehavior, "Params: animName, behaviorName, loop = 1, randomStartPos = 1, fadeInLen = 2.0, fadeOutLen = 2.0\n"
		"Adds a new animation to the brain as a behavior with the specified name and parameters. If multiple animations are assigned to the same behavior, "
		"they will be randomly picked from when started."),
	PYTHON_METHOD_WKEY(ptCritterBrain, startBehavior, "Params: behaviorName, fade = 1\nStarts playing the named behavior. If fade is true, it will fade out "
		"the previous behavior and fade in the new one. If false, they will immediately switch."),
	PYTHON_METHOD(ptCritterBrain, runningBehavior, "Params: behaviorName\nReturns true if the named behavior is running."),
	PYTHON_METHOD(ptCritterBrain, behaviorName, "Params: behavior\nReturns the behavior name associated with the specified integral behavior."),
	PYTHON_METHOD(ptCritterBrain, animationName, "Params: behavior\nReturns the animation name associated with the specified integral behavior."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, curBehavior, "Returns the current integral behavior the brain is running."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, nextBehavior, "Returns the behavior the brain will be switching to next frame. (-1 if no change)"),
	PYTHON_METHOD_NOARGS(ptCritterBrain, idleBehaviorName, "Returns the name of the brain's idle behavior."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, runBehaviorName, "Returns the name of the brain's run behavior."),
	PYTHON_METHOD_WKEY(ptCritterBrain, goToGoal, "Params: newGoal, avoidingAvatars = 0\nTells the brain to start running towards the specified location, "
		"avoiding avatars it can see or hear if told to."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, currentGoal, "Returns the current ptPoint that the brain is running towards."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, avoidingAvatars, "Are we currently avoiding avatars while pathfinding?"),
	PYTHON_METHOD_NOARGS(ptCritterBrain, atGoal, "Are we currently are our final destination?"),
	PYTHON_METHOD(ptCritterBrain, setStopDistance, "Params: dist\nSet how far away from the goal we should be when we are considered there and stop running."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, getStopDistance, "Returns how far away from the goal we could be and still be considered there."),
	PYTHON_METHOD(ptCritterBrain, setSightCone, "Params: radians\nSet how wide the brain's field of view is in radians. Note that it is the total angle of the "
		"cone, half on one side of the brain's line of sight, half on the other."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, getSightCone, "Returns the width of the brain's field of view in radians."),
	PYTHON_METHOD(ptCritterBrain, setSightDistance, "Params: dist\nSet how far away the brain can see."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, getSightDistance, "Returns how far the brain can see."),
	PYTHON_METHOD(ptCritterBrain, setHearingDistance, "Params: dist\nSet how far away the brain can hear (360 degree field of hearing)."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, getHearingDistance, "Returns how far away the brain can hear."),
	PYTHON_METHOD(ptCritterBrain, canSeeAvatar, "Params: avatarID\nReturns whether this brain can see the avatar with the specified id."),
	PYTHON_METHOD(ptCritterBrain, canHearAvatar, "Params: avatarID\nReturns whether this brain can hear the avatar with the specified id."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, playersICanSee, "Returns a list of player ids which this brain can see."),
	PYTHON_METHOD_NOARGS(ptCritterBrain, playersICanHear, "Returns a list of player ids which this brain can hear."),
	PYTHON_METHOD(ptCritterBrain, vectorToPlayer, "Params: avatarID\nReturns the vector between us and the specified player."),
PYTHON_END_METHODS_TABLE;

// Type structure definition
#define ptCritterBrain_COMPARE		PYTHON_NO_COMPARE
#define ptCritterBrain_AS_NUMBER	PYTHON_NO_AS_NUMBER
#define ptCritterBrain_AS_SEQUENCE	PYTHON_NO_AS_SEQUENCE
#define ptCritterBrain_AS_MAPPING	PYTHON_NO_AS_MAPPING
#define ptCritterBrain_STR			PYTHON_NO_STR
#define ptCritterBrain_RICH_COMPARE	PYTHON_DEFAULT_RICH_COMPARE(ptCritterBrain)
#define ptCritterBrain_GETSET		PYTHON_NO_GETSET
#define ptCritterBrain_BASE			PYTHON_NO_BASE
PLASMA_CUSTOM_TYPE(ptCritterBrain, "Object to manipulate critter brains");

// required functions for PyObject interoperability
PyObject* pyCritterBrain::New(plAvBrainCritter* brain)
{
	ptCritterBrain *newObj = (ptCritterBrain*)ptCritterBrain_type.tp_new(&ptCritterBrain_type, NULL, NULL);
	newObj->fThis->fBrain = brain;
	return (PyObject*)newObj;
}

PYTHON_CLASS_CHECK_IMPL(ptCritterBrain, pyCritterBrain)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptCritterBrain, pyCritterBrain)

///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyCritterBrain::AddPlasmaClasses(PyObject *m)
{
	PYTHON_CLASS_IMPORT_START(m);
	PYTHON_CLASS_IMPORT(m, ptCritterBrain);
	PYTHON_CLASS_IMPORT_END(m);
}