OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
543 Commits
80 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: be4b0732d5
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'be4b0732d5'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAvatar/plAvBrainCritter.cpp

740 lines
24 KiB
Raw Blame History

/*==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 "plAvCallbackAction.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_t index)
{
plArmatureBehavior::Init(anim, loop, brain, body, index);
fAvMod = body;
fCritterBrain = brain;
fAnimName = anim->GetName();
}
virtual hsBool PreCondition(double time, float elapsed) {return true;}
float GetAnimLength() {return (fAnim->GetAnimation()->GetLength());}
void SetAnimTime(float time) {fAnim->SetCurrentTime(time, true);}
std::string Name() const {return fName;}
plString 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
plString 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(): fCallbackAction(nil), fCurMode(kIdle), fNextMode(kIdle), fFadingNextBehavior(true),
fLocallyControlled(false), fAvoidingAvatars(false), fFinalGoalPos(0, 0, 0), fImmediateGoalPos(0, 0, 0), fDotGoal(0),
fAngRight(0)
{
SightCone(M_PI/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 fCallbackAction;
fCallbackAction = nil;
fUserBehaviors.clear();
fReceivers.clear();
}
///////////////////////////////////////////////////////////////////////////////
hsBool plAvBrainCritter::Apply(double time, float 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
fCallbackAction->RecalcVelocity(time, time - elapsed);
fCallbackAction->SetTurnStrength(IGetTurnStrength(time));
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 (!fCallbackAction)
{
plSceneObject* avObj = fArmature->GetTarget(0);
plAGModifier* agMod = const_cast<plAGModifier*>(plAGModifier::ConvertNoRef(FindModifierByClass(avObj, plAGModifier::Index())));
plPhysicalControllerCore* controller = avMod->GetController();
fCallbackAction = new plWalkingController(avObj, agMod->GetApplicator(kAGPinTransform), controller);
fCallbackAction->ActivateController();
}
// tell people that care that we are good to go
plAIBrainCreatedMsg* brainCreated = 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;
fCallbackAction->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 = 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();
}
plString plAvBrainCritter::AnimationName(int behavior) const
{
if ((behavior >= fBehaviors.Count()) || (behavior < 0))
return _TEMP_CONVERT_FROM_LITERAL("");
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(float 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(float 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 = 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 = 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())
{
float 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();
float 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 = new plAIArrivedAtGoalMsg(fArmature->GetKey(), fReceivers[i]);
msg->Goal(fFinalGoalPos);
msg->Send();
}
}
}
}
float 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));
float 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);
float 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;
}