/*==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/>.

Additional permissions under GNU GPL version 3 section 7

If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.

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 "hsConfig.h"
#include "hsWindows.h"

#include "plPhysicalControllerCore.h"
#include "plAvBrainCritter.h"
#include "plAvBrainHuman.h"
#include "plArmatureMod.h"
#include "plAvBehaviors.h"
#include "plAGAnim.h"
#include "plAGAnimInstance.h"
#include "plAvatarMgr.h"

#include "plgDispatch.h"

#include "../plMessage/plAIMsg.h"

#include "../plPipeline/plDebugText.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "../plMath/plRandom.h"
#include "../plNetClient/plNetClientMgr.h"
#include "../plNetTransport/plNetTransportMember.h"

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

static plRandom sRandom; // random number generator

const char kDefaultIdleAnimName[] = "Idle";
const char kDefaultIdleBehName[] = "Idle";
const char kDefaultRunAnimName[] = "Run";
const char kDefaultRunBehName[] = "Run";

const float kLoudSoundMultiplyer = 2.0f;

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

class CritterBehavior : public plArmatureBehavior
{
	friend class plAvBrainCritter;

public:	
	CritterBehavior(const std::string& name, bool randomStart = false, float fadeInLength = 2.f, float fadeOutLength = 2.f) : plArmatureBehavior(),
		fAvMod(nil), fCritterBrain(nil), fName(name), fRandomStartPoint(randomStart), fFadeInLength(fadeInLength), fFadeOutLength(fadeOutLength) {}
	virtual ~CritterBehavior() {}

	void Init(plAGAnim* anim, hsBool loop, plAvBrainCritter* brain, plArmatureMod* body, UInt8 index)
	{
		plArmatureBehavior::Init(anim, loop, brain, body, index);
		fAvMod = body;
		fCritterBrain = brain;
		fAnimName = anim->GetName();
	}

	virtual hsBool PreCondition(double time, float elapsed) {return true;}

	hsScalar GetAnimLength() {return (fAnim->GetAnimation()->GetLength());}
	void SetAnimTime(hsScalar time) {fAnim->SetCurrentTime(time, true);}

	std::string Name() const {return fName;}
	std::string AnimName() const {return fAnimName;}
	bool RandomStartPoint() const {return fRandomStartPoint;}
	float FadeInLength() const {return fFadeInLength;}
	float FadeOutLength() const {return fFadeOutLength;}

protected:
	virtual void IStart()
	{
		plArmatureBehavior::IStart();
		fAvMod->SynchIfLocal(hsTimer::GetSysSeconds(), false);
	}

	virtual void IStop()
	{
		plArmatureBehavior::IStop();
		fAvMod->SynchIfLocal(hsTimer::GetSysSeconds(), false);
	}		

	plArmatureMod *fAvMod;
	plAvBrainCritter *fCritterBrain;

	std::string fName; // user-created name for this behavior, also used as the index into the brain's behavior map
	std::string fAnimName; // physical animation's name, for reference
	bool fRandomStartPoint; // do we want this behavior to start at a random frame every time we start it?
	float fFadeInLength; // how long to fade in this behavior
	float fFadeOutLength; // how long to fade out this behavior
};

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

plAvBrainCritter::plAvBrainCritter(): fWalkingStrategy(nil), fCurMode(kIdle), fNextMode(kIdle), fFadingNextBehavior(true),
	fLocallyControlled(false), fAvoidingAvatars(false), fFinalGoalPos(0, 0, 0), fImmediateGoalPos(0, 0, 0), fDotGoal(0),
	fAngRight(0)
{
	SightCone(hsScalarPI/2); // 90deg
	StopDistance(1);
	SightDistance(10);
	HearingDistance(10);
}

plAvBrainCritter::~plAvBrainCritter()
{
	for (int i = 0; i < fBehaviors.GetCount(); ++i)
	{
		delete fBehaviors[i];
		fBehaviors[i] = nil;
	}

	delete fWalkingStrategy;
	fWalkingStrategy = nil;

	fUserBehaviors.clear();
	fReceivers.clear();
}

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

hsBool plAvBrainCritter::Apply(double time, hsScalar elapsed)
{
	// update internal pathfinding variables
	IEvalGoal();

	if (fNextMode >= kIdle)
	{
		// next mode is set, fade out the previous mode and start up the new one
		IFadeOutBehavior();
		IStartBehavior();
	}
	else
		IProcessBehavior(time, elapsed); // just continue with the currently running one

	// update our controller to keep us turned and moving to where we want to go
	fWalkingStrategy->SetTurnStrength(IGetTurnStrength(time));
	fWalkingStrategy->RecalcVelocity(time, elapsed);

	return plArmatureBrain::Apply(time, elapsed);
}

hsBool plAvBrainCritter::MsgReceive(plMessage* msg)
{
	return plArmatureBrain::MsgReceive(msg);
}

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

void plAvBrainCritter::Activate(plArmatureModBase* avMod)
{
	plArmatureBrain::Activate(avMod);

	// initialize our base "Run" and "Idle" behaviors
	IInitBaseAnimations();

	// create the controller if we haven't done so already
	if (!fWalkingStrategy)
	{
		plSceneObject* avObj = fArmature->GetTarget(0);
		plAGModifier* agMod = const_cast<plAGModifier*>(plAGModifier::ConvertNoRef(FindModifierByClass(avObj, plAGModifier::Index())));
		plPhysicalControllerCore* controller = avMod->GetController();
		fWalkingStrategy = TRACKED_NEW plWalkingStrategy(agMod->GetApplicator(kAGPinTransform), controller);
		controller->SetMovementStrategy(fWalkingStrategy);
	}

	// tell people that care that we are good to go
	plAIBrainCreatedMsg* brainCreated = TRACKED_NEW plAIBrainCreatedMsg(fArmature->GetKey());
	plgDispatch::MsgSend(brainCreated);
}

void plAvBrainCritter::Deactivate()
{
	plArmatureBrain::Deactivate();
}

void plAvBrainCritter::Suspend()
{
	// fade out the previous behavior
	CritterBehavior *behavior = (CritterBehavior*)fBehaviors[fCurMode];
	behavior->SetStrength(0.f, fFadingNextBehavior ? behavior->FadeOutLength() : 0.f);

	// fade in the idle
	fNextMode = kIdle;

	plArmatureBrain::Suspend();
}

void plAvBrainCritter::Resume()
{
	// fade in the idle
	fNextMode = kIdle;

	fWalkingStrategy->Reset(false);

	plArmatureBrain::Resume();
}

void plAvBrainCritter::AddBehavior(const std::string& animationName, const std::string& behaviorName, bool loop /* = true */, bool randomStartPos /* = true */,
				 float fadeInLen /* = 2.f */, float fadeOutLen /* = 2.f */)
{
	// grab the animations
	plAGAnim* anim = fAvMod->FindCustomAnim(animationName.c_str());
	if (!anim)
		return; // can't find it, die

	// create the behavior and set it up
	CritterBehavior* behavior = TRACKED_NEW CritterBehavior(behaviorName, randomStartPos, fadeInLen, fadeOutLen);
	fBehaviors.Push(behavior);
	behavior->Init(anim, loop, this, fAvMod, fBehaviors.Count() - 1);
	fUserBehaviors[behaviorName].push_back(fBehaviors.Count() - 1);
}

void plAvBrainCritter::StartBehavior(const std::string& behaviorName, bool fade /* = true */)
{
	// make sure the new behavior exists
	if (fUserBehaviors.find(behaviorName) == fUserBehaviors.end())
		return;
	else
	{
		if (fUserBehaviors[behaviorName].size() == 0)
			return;
	}

	// remember the fade request
	fFadingNextBehavior = fade;

	// pick our next behavior
	fNextMode = IPickBehavior(behaviorName);
}

bool plAvBrainCritter::RunningBehavior(const std::string& behaviorName) const
{
	// make sure the behavior exists
	std::map<std::string, std::vector<int> >::const_iterator behaviorIterator = fUserBehaviors.find(behaviorName);
	if (behaviorIterator == fUserBehaviors.end())
		return false;
	else
	{
		if (behaviorIterator->second.size() == 0)
			return false;
	}

	// check all behaviors that use this tag and return true if we are running one of them
	for (unsigned i = 0; i < behaviorIterator->second.size(); ++i)
	{
		if (fCurMode == behaviorIterator->second[i])
			return true;
	}
	return false;
}

std::string plAvBrainCritter::BehaviorName(int behavior) const
{
	if ((behavior >= fBehaviors.Count()) || (behavior < 0))
		return "";
	return ((CritterBehavior*)fBehaviors[behavior])->Name();
}

std::string plAvBrainCritter::AnimationName(int behavior) const
{
	if ((behavior >= fBehaviors.Count()) || (behavior < 0))
		return "";
	return ((CritterBehavior*)fBehaviors[behavior])->AnimName();
}

std::string plAvBrainCritter::IdleBehaviorName() const
{
	return kDefaultIdleBehName;
}

std::string plAvBrainCritter::RunBehaviorName() const
{
	return kDefaultRunBehName;
}

void plAvBrainCritter::GoToGoal(hsPoint3 newGoal, bool avoidingAvatars /* = false */)
{
	fFinalGoalPos = newGoal;
	fAvoidingAvatars = avoidingAvatars;
	fNextMode = IPickBehavior(kRun);
	// TODO: Pathfinding here!
}

bool plAvBrainCritter::AtGoal() const
{
	// we are at our goal if our distance from it is less then or equal to our stopping distance
	hsPoint3 creaturePos;
	hsQuat creatureRot;
	fAvMod->GetPositionAndRotationSim(&creaturePos, &creatureRot);
	hsVector3 finalGoalVec(creaturePos - fFinalGoalPos);
	return (finalGoalVec.MagnitudeSquared() <= fStopDistanceSquared);
}

void plAvBrainCritter::SightCone(hsScalar coneRad)
{
	fSightConeAngle = coneRad;

	// calculate the minimum dot product for the cone of sight (angle/2 vector dotted with straight ahead)
	hsVector3 straightVector(1, 0, 0), viewVector(1, 0, 0);
	hsQuat rotation(fSightConeAngle/2, &hsVector3(0, 1, 0));
	viewVector = hsVector3(rotation.Rotate(&viewVector));
	viewVector.Normalize();
	fSightConeDotMin = straightVector * viewVector;
}

void plAvBrainCritter::HearingDistance(hsScalar hearDis)
{
	fHearingDistance = hearDis;
	fHearingDistanceSquared = fHearingDistance * fHearingDistance;
	fLoudHearingDistanceSquared = (fHearingDistance * kLoudSoundMultiplyer) * (fHearingDistance * kLoudSoundMultiplyer);
}

bool plAvBrainCritter::CanSeeAvatar(unsigned long id) const
{
	plArmatureMod* avatar = plAvatarMgr::GetInstance()->FindAvatarByPlayerID(id);
	if (avatar)
		return ICanSeeAvatar(avatar);
	return false;
}

bool plAvBrainCritter::CanHearAvatar(unsigned long id) const
{
	plArmatureMod* avatar = plAvatarMgr::GetInstance()->FindAvatarByPlayerID(id);
	if (avatar)
		return ICanHearAvatar(avatar);
	return false;
}

std::vector<unsigned long> plAvBrainCritter::PlayersICanSee() const
{
	std::vector<unsigned long> allPlayers = IGetAgePlayerIDList();
	std::vector<unsigned long> onesICanSee;
	for (unsigned i = 0; i < allPlayers.size(); ++i)
	{
		if (CanSeeAvatar(allPlayers[i]))
			onesICanSee.push_back(allPlayers[i]);
	}
	return onesICanSee;
}

std::vector<unsigned long> plAvBrainCritter::PlayersICanHear() const
{
	std::vector<unsigned long> allPlayers = IGetAgePlayerIDList();
	std::vector<unsigned long> onesICanHear;
	for (unsigned i = 0; i < allPlayers.size(); ++i)
	{
		if (CanHearAvatar(allPlayers[i]))
			onesICanHear.push_back(allPlayers[i]);
	}
	return onesICanHear;
}

hsVector3 plAvBrainCritter::VectorToPlayer(unsigned long id) const
{
	plArmatureMod* avatar = plAvatarMgr::GetInstance()->FindAvatarByPlayerID(id);
	if (!avatar)
		return hsVector3(0, 0, 0);

	hsPoint3 avPos;
	hsQuat avRot;
	avatar->GetPositionAndRotationSim(&avPos, &avRot);

	hsPoint3 creaturePos;
	hsQuat creatureRot;
	fAvMod->GetPositionAndRotationSim(&creaturePos, &creatureRot);

	return hsVector3(creaturePos - avPos);
}

void plAvBrainCritter::AddReceiver(const plKey key)
{
	for (unsigned i = 0; i < fReceivers.size(); ++i)
	{
		if (fReceivers[i] == key)
			return; // already in our list
	}
	fReceivers.push_back(key);
}

void plAvBrainCritter::RemoveReceiver(const plKey key)
{
	for (unsigned i = 0; i < fReceivers.size(); ++i)
	{
		if (fReceivers[i] == key)
		{
			fReceivers.erase(fReceivers.begin() + i);
			return;
		}
	}
	return; // not found, do nothing
}

void plAvBrainCritter::DumpToDebugDisplay(int& x, int& y, int lineHeight, char* strBuf, plDebugText& debugTxt)
{
	sprintf(strBuf, "Brain type: Critter");
	debugTxt.DrawString(x, y, strBuf, 0, 255, 255);
	y += lineHeight;

	// extract the name from the behavior running
	if (fBehaviors[fCurMode])
		sprintf(strBuf, "Mode: %s", ((CritterBehavior*)(fBehaviors[fCurMode]))->Name().c_str());
	else
		sprintf(strBuf, "Mode: Unknown");
	
	// draw it
	debugTxt.DrawString(x, y, strBuf);
	y += lineHeight;
	for (int i = 0; i < fBehaviors.GetCount(); ++i)
		fBehaviors[i]->DumpDebug(x, y, lineHeight, strBuf, debugTxt);
}

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

hsBool plAvBrainCritter::IInitBaseAnimations()
{
	// create the basic idle and run behaviors, and put them into our appropriate structures
	plAGAnim* idle = fAvMod->FindCustomAnim(kDefaultIdleAnimName);
	plAGAnim* run = fAvMod->FindCustomAnim(kDefaultRunAnimName);

	hsAssert(idle, "Creature is missing idle animation");
	hsAssert(run, "Creature is missing run animation");

	fBehaviors.SetCountAndZero(kNumDefaultModes);

	CritterBehavior* behavior;
	if (idle)
	{
		fBehaviors[kIdle] = behavior = TRACKED_NEW CritterBehavior(kDefaultIdleBehName, true); // starts at a random start point each time
		behavior->Init(idle, true, this, fAvMod, kIdle);
		fUserBehaviors[kDefaultIdleBehName].push_back(kIdle);
	}

	if (run)
	{
		fBehaviors[kRun] = behavior = TRACKED_NEW CritterBehavior(kDefaultRunBehName);
		behavior->Init(run, true, this, fAvMod, kRun);
		fUserBehaviors[kDefaultRunBehName].push_back(kRun);
	}

	return true;
}

int plAvBrainCritter::IPickBehavior(int behavior) const
{
	if ((behavior >= fBehaviors.Count()) || (behavior < 0))
		return IPickBehavior(kDefaultIdleBehName); // do an idle if the behavior is invalid

	CritterBehavior* behaviorObj = (CritterBehavior*)(fBehaviors[behavior]);
	return IPickBehavior(behaviorObj->Name());
}

int plAvBrainCritter::IPickBehavior(const std::string& behavior) const
{
	// make sure the behavior exists
	std::map<std::string, std::vector<int> >::const_iterator behaviorIterator = fUserBehaviors.find(behavior);
	if (behaviorIterator == fUserBehaviors.end())
	{
		if (behavior != kDefaultIdleBehName)
			return IPickBehavior(kDefaultIdleBehName); // do an idle if the behavior is invalid
		return -1; // can't recover from being unable to find an idle!
	}
	else
	{
		unsigned numBehaviors = behaviorIterator->second.size();
		if (numBehaviors == 0)
		{
			if (behavior != kDefaultIdleBehName)
				return IPickBehavior(kDefaultIdleBehName); // do an idle if the behavior is invalid
			return -1; // can't recover from being unable to find an idle!
		}

		// pick our behavior
		unsigned index = sRandom.RandRangeI(0, numBehaviors - 1);
		return behaviorIterator->second[index];
	}
}

void plAvBrainCritter::IFadeOutBehavior()
{
	if ((fCurMode >= fBehaviors.Count()) || (fCurMode < 0))
		return; // invalid fCurMode

	// fade out currently playing behavior
	CritterBehavior* behavior = (CritterBehavior*)fBehaviors[fCurMode];
	behavior->SetStrength(0.f, fFadingNextBehavior ? behavior->FadeOutLength() : 0.f);
}

void plAvBrainCritter::IStartBehavior()
{
	if ((fNextMode >= fBehaviors.Count()) || (fNextMode < 0))
		return; // invalid fNextMode

	// fade in our behavior
	CritterBehavior* behavior = (CritterBehavior*)fBehaviors[fNextMode];
	behavior->SetStrength(1.f, fFadingNextBehavior ? behavior->FadeInLength() : 0.f);

	// if we start at a random point, do so
	if (behavior->RandomStartPoint())
	{
		hsScalar newStart = sRandom.RandZeroToOne() * behavior->GetAnimLength();
		behavior->SetAnimTime(newStart);
	}

	// clean up the internal variables
	fCurMode = fNextMode;
	fNextMode = -1;
}

void plAvBrainCritter::IProcessBehavior(double time, float elapsed)
{
	// run the currently running behavior
	CritterBehavior* behavior = (CritterBehavior*)fBehaviors[fCurMode];
	behavior->SetStrength(1.f, fFadingNextBehavior ? behavior->FadeInLength() : 0.f);
	behavior->Process(time, elapsed);
}

void plAvBrainCritter::IEvalGoal()
{
	// TODO: Implement pathfinding logic here
	// (for now, this runs directly towards the goal)
	fImmediateGoalPos = fFinalGoalPos;

	// where am I relative to my goal?
	const plSceneObject* creatureObj = fArmature->GetTarget(0);
	hsVector3 view(creatureObj->GetCoordinateInterface()->GetLocalToWorld().GetAxis(hsMatrix44::kView));

	hsPoint3 creaturePos;
	hsQuat creatureRot;
	fAvMod->GetPositionAndRotationSim(&creaturePos, &creatureRot);
	hsVector3 goalVec(creaturePos - fImmediateGoalPos);
	goalVec.Normalize();
	fDotGoal = goalVec * view; // 1 = directly facing, 0 = 90 deg off, -1 = facing away

	// calculate a vector pointing to the creature's right
	hsQuat invRot = creatureRot.Conjugate();
	hsPoint3 globRight = invRot.Rotate(&kAvatarRight);
	fAngRight = globRight.InnerProduct(goalVec); // dot product, 1 = goal is 90 to the right, 0 = goal is in front or behind, -1 = goal is 90 to the left

	if (fAvoidingAvatars)
	{
		// check to see we can see anyone in our way (if we can't see them, we can't avoid them)
		std::vector<plArmatureMod*> playersICanSee = IAvatarsICanSee();
		for (unsigned i = 0; i < playersICanSee.size(); ++i)
		{
			hsPoint3 avPos;
			hsQuat avRot;
			playersICanSee[i]->GetPositionAndRotationSim(&avPos, &avRot);
			hsVector3 avVec(creaturePos - avPos);
			avVec.Normalize();

			hsScalar dotAv = avVec * goalVec;
			if (dotAv > 0.5f) // within a 45deg angle in front of us
			{
				// a player is in the way, so we will change our "goal" to a 90deg angle from the player
				// then we stop searching, since any other players in the way will just produce the same (or similar) result
				avVec.fZ = goalVec.fZ = 0.f;
				goalVec = goalVec % avVec;
				fAngRight = globRight.InnerProduct(goalVec);
				break;
			}
		}
	}

	// are we at our final goal?
	if (AtGoal())
	{
		if (RunningBehavior(kDefaultRunBehName)) // don't do anything if we're not running!
		{
			// we're close enough, stop running and pick an idle
			fNextMode = IPickBehavior(kIdle);

			// tell everyone who cares that we have arrived
			for (unsigned i = 0; i < fReceivers.size(); ++i)
			{
				plAIArrivedAtGoalMsg* msg = TRACKED_NEW plAIArrivedAtGoalMsg(fArmature->GetKey(), fReceivers[i]);
				msg->Goal(fFinalGoalPos);
				msg->Send();
			}
		}
	}
}

hsScalar plAvBrainCritter::IGetTurnStrength(double time) const
{
	if (!RunningBehavior(kDefaultRunBehName))
		return 0.0f;

	// am I directly facing my goal?
	if (fDotGoal < -0.98)
		return 0.f;

	if (fAngRight > 0.f)
		return 1.f;
	return -1.f;
}

std::vector<unsigned long> plAvBrainCritter::IGetAgePlayerIDList() const
{
	// make a list of non-local players
	std::vector<unsigned long> playerIDs;
	std::map<unsigned long, bool> tempMap; // slightly hacky way to remove dups
	plNetClientMgr* nc = plNetClientMgr::GetInstance();
	for (int i = 0; i < nc->TransportMgr().GetNumMembers(); ++i)
	{
		plNetTransportMember* mbr = nc->TransportMgr().GetMember(i);
		unsigned long id = mbr->GetPlayerID();
		if (tempMap.find(id) == tempMap.end())
		{
			playerIDs.push_back(id);
			tempMap[id] = true;
		}
	}
	// add the local player if he isn't already in the list
	unsigned long localID = nc->GetPlayerID();
	if (tempMap.find(localID) == tempMap.end())
		playerIDs.push_back(localID);

	// return result
	return playerIDs;
}

bool plAvBrainCritter::ICanSeeAvatar(plArmatureMod* avatar) const
{
	// sight is a x deg cone in front of the critter, cuts off at a certain distance
	hsPoint3 avPos;
	hsQuat avRot;
	avatar->GetPositionAndRotationSim(&avPos, &avRot);

	hsPoint3 creaturePos;
	hsQuat creatureRot;
	fAvMod->GetPositionAndRotationSim(&creaturePos, &creatureRot);

	hsVector3 avVec(creaturePos - avPos);
	if (avVec.MagnitudeSquared() > fSightDistanceSquared)
		return false; // too far away
	avVec.Normalize();
	
	const plSceneObject* creatureObj = fArmature->GetTarget(0);
	hsVector3 view(creatureObj->GetCoordinateInterface()->GetLocalToWorld().GetAxis(hsMatrix44::kView));
	hsScalar avDot = view * avVec;
	if (avDot < fSightConeDotMin)
		return false; // out of our cone of view
	return true;
}

bool plAvBrainCritter::ICanHearAvatar(plArmatureMod* avatar) const
{
	// check to see if the avatar is being loud (running or jumping)
	bool isLoud = false;
	plAvBrainHuman* humanBrain = plAvBrainHuman::ConvertNoRef(avatar->FindBrainByClass(plAvBrainHuman::Index()));
	if (humanBrain)
	{
		isLoud = humanBrain->IsBehaviorPlaying(plAvBrainHuman::kRun) || humanBrain->IsBehaviorPlaying(plAvBrainHuman::kStandingJump) ||
			humanBrain->IsBehaviorPlaying(plAvBrainHuman::kWalkingJump) || humanBrain->IsBehaviorPlaying(plAvBrainHuman::kRunningJump) ||
			humanBrain->IsBehaviorPlaying(plAvBrainHuman::kGroundImpact) || humanBrain->IsBehaviorPlaying(plAvBrainHuman::kRunningImpact);
	}

	// hearing is 360 degrees around the critter, cuts off at a certain distance
	hsPoint3 avPos;
	hsQuat avRot;
	avatar->GetPositionAndRotationSim(&avPos, &avRot);

	hsPoint3 creaturePos;
	hsQuat creatureRot;
	fAvMod->GetPositionAndRotationSim(&creaturePos, &creatureRot);

	hsVector3 avVec(creaturePos - avPos);
	hsScalar distSq = avVec.MagnitudeSquared();
	if (distSq <= fHearingDistanceSquared)
		return true; // within our normal hearing distance
	else if (isLoud && (distSq <= fLoudHearingDistanceSquared))
		return true; // they are being loud, and within our loud hearing distance
	return false;
}

std::vector<plArmatureMod*> plAvBrainCritter::IAvatarsICanSee() const
{
	std::vector<unsigned long> allPlayers = IGetAgePlayerIDList();
	std::vector<plArmatureMod*> onesICanSee;
	for (unsigned i = 0; i < allPlayers.size(); ++i)
	{
		plArmatureMod* avatar = plAvatarMgr::GetInstance()->FindAvatarByPlayerID(allPlayers[i]);
		if (!avatar)
			continue;

		if (ICanSeeAvatar(avatar))
			onesICanSee.push_back(avatar);
	}
	return onesICanSee;
}

std::vector<plArmatureMod*> plAvBrainCritter::IAvatarsICanHear() const
{
	std::vector<unsigned long> allPlayers = IGetAgePlayerIDList();
	std::vector<plArmatureMod*> onesICanHear;
	for (unsigned i = 0; i < allPlayers.size(); ++i)
	{
		plArmatureMod* avatar = plAvatarMgr::GetInstance()->FindAvatarByPlayerID(allPlayers[i]);
		if (!avatar)
			continue;

		if (ICanHearAvatar(avatar))
			onesICanHear.push_back(avatar);
	}
	return onesICanHear;
}