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.

1454 lines
45 KiB

/*==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 "hsConfig.h"
#include "hsWindows.h"
#include "plAvCallbackAction.h" // subclasses a havok object; must be in first include section
#include "plAvBrainHuman.h"
#include "plAvBrainClimb.h"
#include "plAvBrainDrive.h"
#include "plAvBrainGeneric.h"
#include "plAvBrainSwim.h"
#include "plArmatureMod.h"
#include "plAGModifier.h"
#include "plMatrixChannel.h"
#include "plAvTask.h"
#include "plAvTaskBrain.h"
#include "plAvTaskSeek.h"
#include "plAGAnim.h"
#include "plAGAnimInstance.h"
#include "plAvatarMgr.h"
#include "plAnimStage.h"
#include "plAvatarClothing.h"
#include "hsTimer.h"
#include "hsGeometry3.h"
#include "float.h"
#include "plPipeline.h"
#include "plgDispatch.h"
#include "hsQuat.h"
#include "plPhysical.h"
#include "plStatusLog/plStatusLog.h"
#include "pnNetCommon/plNetApp.h"
#include "pnSceneObject/plCoordinateInterface.h"
#include "plInputCore/plAvatarInputInterface.h"
#include "plInputCore/plInputDevice.h"
#include "plMath/plRandom.h"
#include "plPipeline/plDebugText.h"
#include "plNetClient/plNetLinkingMgr.h"
#include "plMessage/plAvatarMsg.h"
#include "plMessage/plClimbMsg.h"
#include "plMessage/plInputEventMsg.h"
#include "plMessage/plLOSHitMsg.h"
#include "plMessage/plLOSRequestMsg.h"
#include "plMessage/plSimStateMsg.h"
#include "plMessage/plSwimMsg.h"
#include "plMessage/plAgeLoadedMsg.h"
#include "pnMessage/plWarpMsg.h"
#include "pnMessage/plProxyDrawMsg.h"
#include "plMessage/plRideAnimatedPhysMsg.h"
float plAvBrainHuman::fWalkTimeToMaxTurn = .3f;
float plAvBrainHuman::fRunTimeToMaxTurn = .1f;
float plAvBrainHuman::fWalkMaxTurnSpeed = 2.0f;
float plAvBrainHuman::fRunMaxTurnSpeed = 1.7;
plAvBrainHuman::TurnCurve plAvBrainHuman::fWalkTurnCurve = plAvBrainHuman::kTurnExponential;
plAvBrainHuman::TurnCurve plAvBrainHuman::fRunTurnCurve = plAvBrainHuman::kTurnExponential;
const hsScalar plAvBrainHuman::kAirTimePanicThreshold = 10; // seconds
void plAvBrainHuman::SetTimeToMaxTurn(float time, hsBool walk)
{
if (walk)
fWalkTimeToMaxTurn = time;
else
fRunTimeToMaxTurn = time;
}
float plAvBrainHuman::GetTimeToMaxTurn(hsBool walk)
{
return (walk ? fWalkTimeToMaxTurn : fRunTimeToMaxTurn);
}
void plAvBrainHuman::SetMaxTurnSpeed(float radsPerSec, hsBool walk)
{
if (walk)
fWalkMaxTurnSpeed = radsPerSec;
else
fRunMaxTurnSpeed = radsPerSec;
}
float plAvBrainHuman::GetMaxTurnSpeed(hsBool walk)
{
return (walk ? fWalkMaxTurnSpeed : fRunMaxTurnSpeed);
}
void plAvBrainHuman::SetTurnCurve(TurnCurve curve, hsBool walk)
{
if (walk)
fWalkTurnCurve = curve;
else
fRunTurnCurve = curve;
}
plAvBrainHuman::TurnCurve plAvBrainHuman::GetTurnCurve(hsBool walk)
{
return (walk ? fWalkTurnCurve : fRunTurnCurve);
}
plAvBrainHuman::plAvBrainHuman(bool isActor /* = false */) :
fHandleAGMod(nil),
fStartedTurning(-1.0f),
fCallbackAction(nil),
fPreconditions(0),
fIsActor(isActor)
{
}
hsBool plAvBrainHuman::Apply(double timeNow, hsScalar elapsed)
{
#ifndef _DEBUG
try
{
#endif
// SetTurnStrength runs first to make sure it's set to a sane value
// (or cleared). RunStandardBehaviors may overwrite it.
fCallbackAction->SetTurnStrength(IGetTurnStrength(timeNow));
RunStandardBehaviors(timeNow, elapsed);
fCallbackAction->RecalcVelocity(timeNow, timeNow - elapsed, (fPreconditions & plHBehavior::kBehaviorTypeNeedsRecalcMask));
plArmatureBrain::Apply(timeNow, elapsed);
#ifndef _DEBUG
} catch (...)
{
// just catch all the crashes on exit...
plStatusLog *log = plAvatarMgr::GetInstance()->GetLog();
log->AddLine("plAvBrainHuman::Apply - crash caught");
}
#endif
return true;
}
void plAvBrainHuman::Activate(plArmatureModBase *avMod)
{
plArmatureBrain::Activate(avMod);
IInitBoneMap();
IInitAnimations();
if (!fCallbackAction)
{
plSceneObject* avObj = fArmature->GetTarget(0);
plAGModifier* agMod = const_cast<plAGModifier*>(plAGModifier::ConvertNoRef(FindModifierByClass(avObj, plAGModifier::Index())));
plPhysicalControllerCore* controller = avMod->GetController();
fCallbackAction = TRACKED_NEW plWalkingController(avObj, agMod->GetApplicator(kAGPinTransform), controller);
fCallbackAction->ActivateController();
}
plSceneObject *avSO = fAvMod->GetTarget(0);
hsBool isLocal = avSO->IsLocallyOwned();
if (fAvMod->GetClothingOutfit() && fAvMod->GetClothingOutfit()->fGroup != plClothingMgr::kClothingBaseNoOptions)
{
if (fAvMod->IsLocalAvatar())
fAvMod->GetClothingOutfit()->ReadFromVault();
else
{
fAvMod->GetClothingOutfit()->WearDefaultClothing();
fAvMod->GetClothingOutfit()->ForceUpdate(true);
}
}
if (fAvMod == plAvatarMgr::GetInstance()->GetLocalAvatar())
plAvatarInputInterface::GetInstance()->ForceAlwaysRun(plKeyboardDevice::GetInstance()->IsCapsLockKeyOn() != 0);
}
void plAvBrainHuman::IInitBoneMap()
{
struct tuple {
HumanBoneID fID;
const char * fName;
};
tuple tupleMap[] =
{
{ Pelvis, "Bone_Root" },
// left leg
{ LThigh, "Bone_LThigh" },
{ LCalf, "Bone_LCalf" },
{ LFoot, "Bone_LFoot" },
{ LFootPrint, "Print_L Foot" },
{ LToe0, "Bone_LToe" },
// right leg
{ RThigh, "Bone_RThigh" },
{ RCalf, "Bone_RCalf" },
{ RFoot, "Bone_RFoot" },
{ RFootPrint, "Print_R Foot" },
{ RToe0, "Bone_RToe" },
// spine and head, starting at base of spine
{ Spine, "Bone_Spine0" },
{ TrunkPrint, "Print_Trunk" },
{ Spine1, "Bone_Spine1" },
{ Spine2, "Bone_Spine2" },
{ Neck, "Bone_Neck" },
{ Head, "Bone_Head" },
{ Jaw, "Bone_Jaw" },
// left face bones
{ LMouthLower, "Bone_LMouthLower" },
{ RMouthLower, "Bone_RMouthLower" },
{ LBrowInner, "Bone_LBrowInner" },
{ LBrowOuter, "Bone_LBrowOuter" },
{ LCheek, "Bone_LCheek" },
{ LEye, "Bone_LEye" },
{ LEyeLid01, "Bone_LEyeLid1" },
{ LEyeLid02, "Bone_LEyeLid2" },
{ LMouthCorner, "Bone_LMouthCorner" },
{ LMouthUpper, "Bone_LMouthUpper" },
// right face bones
{ RBrowInner, "Bone_RBrowInner" },
{ RBrowOuter, "Bone_RBrowOuter" },
{ RCheek, "Bone_RCheek" },
{ REye, "Bone_REye" },
{ REyeLid01, "Bone_REyeLid1" },
{ REyeLid02, "Bone_REyeLid2" },
{ RMouthCorner, "Bone_RMouthCorner" },
{ RMouthUpper, "Bone_RMouthUpper" },
// Left Arm
{ LClavicle, "Bone_LClavicle" },
{ LUpperArm, "Bone_LUpperArm" },
{ LForearm, "Bone_LForearm" },
{ LHand, "Bone_LHand" },
{ LHandPrint, "Print_L Hand" },
{ LMiddleFinger1, "Bone_LMiddle1" },
{ LMiddleFinger2, "Bone_LMiddle2" },
{ LMiddleFinger3, "Bone_LMiddle3" },
{ LPinkyFinger1, "Bone_LPinky1" },
{ LPinkyFinger2, "Bone_LPinky2" },
{ LPinkyFinger3, "Bone_LPinky3" },
{ LPointerFinger1, "Bone_LPointer1" },
{ LPointerFinger2, "Bone_LPointer2" },
{ LPointerFinger3, "Bone_LPointer3" },
{ LRingFinger1, "Bone_LRing1" },
{ LRingFinger2, "Bone_LRing2" },
{ LRingFinger3, "Bone_LRing3" },
{ LThumb1, "Bone_LThumb1" },
{ LThumb2, "Bone_LThumb2" },
{ LThumb3, "Bone_LThumb3" },
// Right Arm
{ RClavicle, "Bone_RClavicle" },
{ RUpperArm, "Bone_RUpperArm" },
{ RForearm, "Bone_RForearm" },
{ RHand, "Bone_RHand" },
{ RHandPrint, "Print_R Hand" },
{ RMiddleFinger1, "Bone_RMiddle1" },
{ RMiddleFinger2, "Bone_RMiddle2" },
{ RMiddleFinger3, "Bone_RMiddle3" },
{ RPinkyFinger1, "Bone_RPinky1" },
{ RPinkyFinger2, "Bone_RPinky2" },
{ RPinkyFinger3, "Bone_RPinky3" },
{ RPointerFinger1, "Bone_RPointer1" },
{ RPointerFinger2, "Bone_RPointer2" },
{ RPointerFinger3, "Bone_RPointer3" },
{ RRingFinger1, "Bone_RRing1" },
{ RRingFinger2, "Bone_RRing2" },
{ RRingFinger3, "Bone_RRing3" },
{ RThumb1, "Bone_RThumb1" },
{ RThumb2, "Bone_RThumb2" },
{ RThumb3, "Bone_RThumb3" },
};
int numTuples = sizeof(tupleMap) / sizeof(tuple);
for(int i = 0; i < numTuples; i++)
{
HumanBoneID id = tupleMap[i].fID;
const char * name = tupleMap[i].fName;
const plSceneObject * bone = this->fAvMod->FindBone(name);
if( bone )
{
fAvMod->AddBoneMapping(id, bone);
}
else
hsStatusMessageF("Couldn't find standard bone %s.", name);
}
}
plAvBrainHuman::~plAvBrainHuman()
{
int i;
for (i = 0; i < fBehaviors.GetCount(); i++)
delete fBehaviors[i];
fBehaviors.Reset();
delete fCallbackAction;
fCallbackAction = nil;
}
void plAvBrainHuman::Deactivate()
{
// fAvMod will be nil here when exporting.
if (fAvMod)
plAvatarMgr::GetInstance()->RemoveAvatar(fAvMod); // unregister
plArmatureBrain::Deactivate();
}
void plAvBrainHuman::Suspend()
{
// Kind of hacky... but this is a rather rare case.
// If the user lets up on the PushToTalk key in another brain
// we'll miss the message to take off the animation.
char *chatAnimName = fAvMod->MakeAnimationName("Talk");
plAGAnimInstance *anim = fAvMod->FindAnimInstance(chatAnimName);
delete [] chatAnimName;
if (anim)
anim->FadeAndDetach(0, 1);
IdleOnly();
plArmatureBrain::Suspend();
}
void plAvBrainHuman::Resume()
{
// If we were in another brain when the key was pressed, we missed it.
if (fAvMod->GetInputFlag(S_PUSH_TO_TALK))
IChatOn();
fCallbackAction->Reset(false);
plArmatureBrain::Resume();
}
hsBool plAvBrainHuman::IHandleControlMsg(plControlEventMsg* msg)
{
ControlEventCode moveCode = msg->GetControlCode();
if( msg->ControlActivated() )
{
switch(moveCode)
{
case B_CONTROL_TOGGLE_PHYSICAL:
{
#ifndef PLASMA_EXTERNAL_RELEASE // external clients can't go non-physical
plAvBrainDrive *driver = TRACKED_NEW plAvBrainDrive(20, 1);
fAvMod->PushBrain(driver);
#endif
return true;
}
break;
case S_PUSH_TO_TALK:
fAvMod->SetInputFlag(S_PUSH_TO_TALK, true);
IChatOn();
return true;
break;
}
} else {
switch(moveCode)
{
case S_PUSH_TO_TALK:
fAvMod->SetInputFlag(S_PUSH_TO_TALK, false);
IChatOff();
return true;
break;
}
}
return false;
}
bool plAvBrainHuman::IsMovingForward()
{
if ((fBehaviors.Count() <= kWalk) || (fBehaviors.Count() <= kRun))
return false; // behaviors aren't set up yet
return (fBehaviors[kWalk]->GetStrength() > 0 || fBehaviors[kRun]->GetStrength() > 0);
}
bool plAvBrainHuman::IsBehaviorPlaying(int behavior)
{
if ((behavior < 0) || (behavior >= fBehaviors.Count()))
return false;
if (!fBehaviors[behavior])
return false;
return (fBehaviors[behavior]->GetStrength() > 0);
}
void plAvBrainHuman::Write(hsStream *stream, hsResMgr *mgr)
{
plArmatureBrain::Write(stream, mgr);
stream->WriteBool(fIsActor);
}
void plAvBrainHuman::Read(hsStream *stream, hsResMgr *mgr)
{
plArmatureBrain::Read(stream, mgr);
fIsActor = stream->ReadBool();
}
hsBool plAvBrainHuman::MsgReceive(plMessage * msg)
{
plControlEventMsg *ctrlMsg = plControlEventMsg::ConvertNoRef(msg);
if (ctrlMsg)
{
return IHandleControlMsg(ctrlMsg);
}
plClimbMsg *climb = plClimbMsg::ConvertNoRef(msg);
if (climb) {
return IHandleClimbMsg(climb);
}
plSwimMsg *swim = plSwimMsg::ConvertNoRef(msg);
if (swim)
{
if (swim->GetIsEntering())
{
plAvBrainSwim *swimBrain = TRACKED_NEW plAvBrainSwim();
swimBrain->MsgReceive(swim);
fAvMod->PushBrain(swimBrain);
}
else
{
hsStatusMessage("Got non-entering swim message. Discarding.");
}
return true;
}
plRideAnimatedPhysMsg *ride = plRideAnimatedPhysMsg::ConvertNoRef(msg);
if(ride)
{
if(ride->Entering())
{
//plAvBrainRideAnimatedPhysical *rideBrain = TRACKED_NEW plAvBrainRideAnimatedPhysical();
//fAvMod->PushBrain(rideBrain);
delete fCallbackAction;
plSceneObject* avObj = fArmature->GetTarget(0);
plAGModifier* agMod = const_cast<plAGModifier*>(plAGModifier::ConvertNoRef(FindModifierByClass(avObj, plAGModifier::Index())));
plPhysicalControllerCore* controller = fAvMod->GetController();
fCallbackAction= TRACKED_NEW plRidingAnimatedPhysicalController(avObj, agMod->GetApplicator(kAGPinTransform), controller);
fCallbackAction->ActivateController();
}
else
{
delete fCallbackAction;
plSceneObject* avObj = fArmature->GetTarget(0);
plAGModifier* agMod = const_cast<plAGModifier*>(plAGModifier::ConvertNoRef(FindModifierByClass(avObj, plAGModifier::Index())));
plPhysicalControllerCore* controller = fAvMod->GetController();
fCallbackAction= TRACKED_NEW plWalkingController(avObj, agMod->GetApplicator(kAGPinTransform), controller);
fCallbackAction->ActivateController();
//hsStatusMessage("Got an exiting ride animated physical message");
}
}
return plArmatureBrain::MsgReceive(msg);
}
hsBool plAvBrainHuman::IHandleClimbMsg(plClimbMsg *msg)
{
bool isStartClimb = msg->fCommand == plClimbMsg::kStartClimbing;
if(isStartClimb)
{
// let's build a seek task to get us to the attach point
plKey seekTarget = msg->fTarget;
plAvTaskSeek *seekTask = TRACKED_NEW plAvTaskSeek(seekTarget);
QueueTask(seekTask);
// now a brain task to start the actual climb.
plAvBrainClimb::Mode startMode;
switch(msg->fDirection)
{
case plClimbMsg::kUp:
startMode = plAvBrainClimb::kMountingUp;
break;
case plClimbMsg::kDown:
startMode = plAvBrainClimb::kMountingDown;
break;
case plClimbMsg::kLeft:
startMode = plAvBrainClimb::kMountingLeft;
break;
case plClimbMsg::kRight:
startMode = plAvBrainClimb::kMountingRight;
break;
}
plAvBrainClimb *brain = TRACKED_NEW plAvBrainClimb(startMode);
plAvTaskBrain *brainTask = TRACKED_NEW plAvTaskBrain(brain);
QueueTask(brainTask);
}
// ** potentially controversial:
// It's fairly easy for a human brain to hit a climb trigger - like when falling off a wall.
// When this happens, We should just eat the message to keep it from travelling any further.
// The argument against is that there might be a climb brain that actually wants the message,
// but if that were true the message would have been given to that climb brain first.
return true;
}
hsScalar plAvBrainHuman::IGetTurnStrength(double timeNow)
{
float result = 0.f;
float timeToMaxTurn, maxTurnSpeed;
plAvBrainHuman::TurnCurve turnCurve;
if (fAvMod->FastKeyDown())
{
timeToMaxTurn = fRunTimeToMaxTurn;
maxTurnSpeed = fRunMaxTurnSpeed;
turnCurve = fRunTurnCurve;
}
else
{
timeToMaxTurn = fWalkTimeToMaxTurn;
maxTurnSpeed = fWalkMaxTurnSpeed;
turnCurve = fWalkTurnCurve;
}
plArmatureBehavior * turnLeft = fBehaviors.Count() >= kMovingTurnLeft ? fBehaviors[kMovingTurnLeft] : nil;
plArmatureBehavior * turnRight = fBehaviors.Count() >= kMovingTurnRight ? fBehaviors[kMovingTurnRight] : nil;
hsScalar turnLeftStrength = turnLeft ? turnLeft->GetStrength() : 0.f;
hsScalar turnRightStrength = turnRight ? turnRight->GetStrength() : 0.f;
// Turning based on keypress
if ((turnLeftStrength > 0.f)
|| (turnRightStrength > 0.f)
|| (!fCallbackAction->IsOnGround()
&& !fCallbackAction->IsControlledFlight())
) {
float t = (float)(timeNow - fStartedTurning);
float turnSpeed;
if(t > timeToMaxTurn)
{
turnSpeed = maxTurnSpeed;
} else {
float n = t / timeToMaxTurn; // normalize
switch(turnCurve) {
case kTurnLinear:
// linear
turnSpeed = n * maxTurnSpeed;
break;
case kTurnExponential:
// exponential
turnSpeed = (n * n) * maxTurnSpeed;
break;
case kTurnLogarithmic:
// logarithmic
turnSpeed = n > .1 ? log10(n * 10) * maxTurnSpeed : .00001f;
break;
default:
hsAssert(false, "What the heck?");
turnSpeed = 0.0f;
}
}
result += fAvMod->GetKeyTurnStrength() * turnSpeed;
}
if (!fCallbackAction->IsControlledFlight())
result += fAvMod->GetAnalogTurnStrength() * maxTurnSpeed;
return result;
}
hsBool plAvBrainHuman::IHandleTaskMsg(plAvTaskMsg *msg)
{
if(plAvSeekMsg * seekM = plAvSeekMsg::ConvertNoRef(msg))
{
// seek and subclasses always have a seek first
if(seekM->fSmartSeek)
{
// use smart seek
plAvTaskSeek * seek = TRACKED_NEW plAvTaskSeek(seekM);
QueueTask(seek);
}
else
if (!seekM->fNoSeek)
{
// use dumb seek
plAvSeekTask *seek = TRACKED_NEW plAvSeekTask(seekM->fSeekPoint, seekM->fAlignType, seekM->fAnimName);
QueueTask(seek);
}
// else don't seek at all.
plAvOneShotMsg * oneshotM = plAvOneShotMsg::ConvertNoRef(msg);
if(oneshotM)
{
// if it's a oneshot, add the oneshot task as well
plAvOneShotTask *oneshot = TRACKED_NEW plAvOneShotTask(oneshotM, fAvMod, this);
QueueTask(oneshot);
}
} else if (plAvPushBrainMsg *pushM = plAvPushBrainMsg::ConvertNoRef(msg)) {
plAvTaskBrain * push = TRACKED_NEW plAvTaskBrain(pushM->fBrain);
QueueTask(push);
} else if (plAvPopBrainMsg *popM = plAvPopBrainMsg::ConvertNoRef(msg)) {
plAvTaskBrain * pop = TRACKED_NEW plAvTaskBrain();
QueueTask(pop);
} else if (plAvTaskMsg *taskM = plAvTaskMsg::ConvertNoRef(msg)) {
plAvTask *task = taskM->GetTask();
QueueTask(task);
} else {
hsStatusMessageF("Couldn't recognize task message type.\n");
return plArmatureBrain::IHandleTaskMsg(msg);
}
return true;
}
void plAvBrainHuman::ResetIdle()
{
if (fBehaviors.Count() > kIdle)
fBehaviors[kIdle]->Rewind();
}
void plAvBrainHuman::IdleOnly(bool instantOff)
{
if (!fCallbackAction)
return;
hsScalar rate = instantOff ? 0.f : 1.f;
int i;
for (i = kWalk; i < fBehaviors.GetCount(); i++)
fBehaviors[i]->SetStrength(0, rate);
}
bool plAvBrainHuman::IsMovementZeroBlend()
{
int i;
for (i = 0; i < fBehaviors.GetCount(); i++)
{
if (i == kIdle || i == kFall)
continue;
if (fBehaviors[i]->GetStrength() > 0)
return false;
}
return true;
}
void plAvBrainHuman::TurnToPoint(hsPoint3 point)
{
if (!fCallbackAction->IsOnGround() || IsRunningTask() || fAvMod->GetCurrentBrain() != this || !IsMovementZeroBlend())
return;
hsPoint3 avPos;
fAvMod->GetTarget(0)->GetCoordinateInterface()->GetLocalToWorld().GetTranslate(&avPos);
const plCoordinateInterface* subworldCI = nil;
if (fAvMod->GetController())
subworldCI = fAvMod->GetController()->GetSubworldCI();
if (subworldCI)
{
point = subworldCI->GetWorldToLocal() * point;
avPos = subworldCI->GetWorldToLocal() * avPos;
}
plAvSeekMsg *msg = TRACKED_NEW plAvSeekMsg(nil, fAvMod->GetKey(), nil, 1.f, true);
hsClearBits(msg->fFlags, plAvSeekMsg::kSeekFlagForce3rdPersonOnStart);
hsSetBits(msg->fFlags, plAvSeekMsg::kSeekFlagNoWarpOnTimeout | plAvSeekMsg::kSeekFlagRotationOnly);
msg->fTargetLookAt = point;
msg->fTargetPos = avPos;
msg->SetBCastFlag(plMessage::kNetPropagate);
msg->Send();
}
void plAvBrainHuman::IChatOn()
{
char *chatAnimName = fAvMod->MakeAnimationName("Talk");
// check that we aren't adding this twice...
if (!fAvMod->FindAnimInstance(chatAnimName))
{
plKey avKey = fAvMod->GetKey();
plAvAnimTask *animTask = TRACKED_NEW plAvAnimTask(chatAnimName, 0.0, 1.0, 1.0, 0.0, true, true, true);
if (animTask)
{
plAvTaskMsg *taskMsg = TRACKED_NEW plAvTaskMsg(avKey, avKey, animTask);
taskMsg->SetBCastFlag(plMessage::kNetPropagate);
taskMsg->Send();
}
}
delete [] chatAnimName;
}
void plAvBrainHuman::IChatOff()
{
char *chatAnimName = fAvMod->MakeAnimationName("Talk");
plKey avKey = fAvMod->GetKey();
plAvAnimTask *animTask = TRACKED_NEW plAvAnimTask(chatAnimName, -1.0);
if (animTask)
{
plAvTaskMsg *taskMsg = TRACKED_NEW plAvTaskMsg(avKey, avKey, animTask);
taskMsg->SetBCastFlag(plMessage::kNetPropagate);
taskMsg->Send();
}
delete[] chatAnimName;
}
hsBool plAvBrainHuman::IInitAnimations()
{
hsBool result = false;
plAGAnim *idle = fAvMod->FindCustomAnim("Idle");
plAGAnim *walk = fAvMod->FindCustomAnim("Walk");
plAGAnim *run = fAvMod->FindCustomAnim("Run");
plAGAnim *walkBack = fAvMod->FindCustomAnim("WalkBack");
plAGAnim *stepLeft = fAvMod->FindCustomAnim("StepLeft");
plAGAnim *stepRight = fAvMod->FindCustomAnim("StepRight");
plAGAnim *standingLeft = fAvMod->FindCustomAnim("TurnLeft");
plAGAnim *standingRight = fAvMod->FindCustomAnim("TurnRight");
plAGAnim *fall = fAvMod->FindCustomAnim("Fall");
plAGAnim *standJump = fAvMod->FindCustomAnim("StandingJump");
plAGAnim *walkJump = fAvMod->FindCustomAnim("WalkingJump");
plAGAnim *runJump = fAvMod->FindCustomAnim("RunningJump");
plAGAnim *groundImpact = fAvMod->FindCustomAnim("GroundImpact");
plAGAnim *runningImpact = fAvMod->FindCustomAnim("RunningImpact");
plAGAnim *movingLeft = nil; // fAvMod->FindCustomAnim("LeanLeft");
plAGAnim *movingRight = nil; // fAvMod->FindCustomAnim("LeanRight");
plAGAnim *pushWalk = fAvMod->FindCustomAnim("BallPushWalk");
//plAGAnim *pushIdle = fAvMod->FindCustomAnim("BallPushIdle");
const float kDefaultFade = 3.0; // most animations fade in and out in 1/4 of a second.
if (idle && walk && run && walkBack && standingLeft && standingRight && stepLeft && stepRight)
{
plHBehavior *behavior;
fBehaviors.SetCountAndZero(kHuBehaviorMax);
fBehaviors[kIdle] = behavior = TRACKED_NEW Idle;
behavior->Init(idle, true, this, fAvMod, kDefaultFade, kDefaultFade, kIdle, plHBehavior::kBehaviorTypeIdle);
behavior->SetStrength(1.f, 0.f);
fBehaviors[kWalk] = behavior = TRACKED_NEW Walk;
behavior->Init(walk, true, this, fAvMod, kDefaultFade, 5.f, kWalk, plHBehavior::kBehaviorTypeWalk);
fBehaviors[kRun] = behavior = TRACKED_NEW Run;
behavior->Init(run, true, this, fAvMod, kDefaultFade, 2.0, kRun, plHBehavior::kBehaviorTypeRun);
fBehaviors[kWalkBack] = behavior = TRACKED_NEW WalkBack;
behavior->Init(walkBack, true, this, fAvMod, kDefaultFade, kDefaultFade, kWalkBack, plHBehavior::kBehaviorTypeWalkBack);
fBehaviors[kStandingTurnLeft] = behavior = TRACKED_NEW StandingTurnLeft;
behavior->Init(standingLeft, true, this, fAvMod, 3.0f, 6.0f, kStandingTurnLeft, plHBehavior::kBehaviorTypeTurnLeft);
fBehaviors[kStandingTurnRight] = behavior = TRACKED_NEW StandingTurnRight;
behavior->Init(standingRight, true, this, fAvMod, 3.0f, 6.0f, kStandingTurnRight, plHBehavior::kBehaviorTypeTurnRight);
fBehaviors[kStepLeft] = behavior = TRACKED_NEW StepLeft;
behavior->Init(stepLeft, true, this, fAvMod, kDefaultFade, kDefaultFade, kStepLeft, plHBehavior::kBehaviorTypeSidestepLeft);
fBehaviors[kStepRight] = behavior = TRACKED_NEW StepRight;
behavior->Init(stepRight, true, this, fAvMod, kDefaultFade, kDefaultFade, kStepRight, plHBehavior::kBehaviorTypeSidestepRight);
// Warning: Changing the blend times of the jump animations will affect the path you take, because until we're fully blended,
// we won't be using the full motion defined in the animation. This isn't an issue for standing jump, but you need to be
// aware of it for the walk/run jumps.
fBehaviors[kFall] = behavior = TRACKED_NEW Fall;
behavior->Init(fall, true, this, fAvMod, 1.0f, 10, kFall, plHBehavior::kBehaviorTypeFall);
fBehaviors[kStandingJump] = behavior = TRACKED_NEW StandingJump;
behavior->Init(standJump, false, this, fAvMod, kDefaultFade, kDefaultFade, kStandingJump, plHBehavior::kBehaviorTypeStandingJump);
fBehaviors[kWalkingJump] = behavior = TRACKED_NEW WalkingJump;
behavior->Init(walkJump, false, this, fAvMod, 10, 3.0, kWalkingJump, plHBehavior::kBehaviorTypeWalkingJump);
fBehaviors[kRunningJump] = behavior = TRACKED_NEW RunningJump;
behavior->Init(runJump, false, this, fAvMod, 10, 2.0, kRunningJump, plHBehavior::kBehaviorTypeRunningJump);
fBehaviors[kGroundImpact] = behavior = TRACKED_NEW GroundImpact;
behavior->Init(groundImpact, false, this, fAvMod, 6.0f, kDefaultFade, kGroundImpact, plHBehavior::kBehaviorTypeGroundImpact);
fBehaviors[kRunningImpact] = behavior = TRACKED_NEW RunningImpact;
behavior->Init(runningImpact, false, this, fAvMod, 6.0f, kDefaultFade, kRunningImpact, plHBehavior::kBehaviorTypeRunningImpact);
fBehaviors[kMovingTurnLeft] = behavior = TRACKED_NEW MovingTurnLeft;
behavior->Init(movingLeft, true, this, fAvMod, kDefaultFade, kDefaultFade, kMovingTurnLeft, plHBehavior::kBehaviorTypeMovingTurnLeft);
fBehaviors[kMovingTurnRight] = behavior = TRACKED_NEW MovingTurnRight;
behavior->Init(movingRight, true, this, fAvMod, kDefaultFade, kDefaultFade, kMovingTurnRight, plHBehavior::kBehaviorTypeMovingTurnRight);
fBehaviors[kPushWalk] = behavior = TRACKED_NEW PushWalk;
behavior->Init(pushWalk, true, this, fAvMod, kDefaultFade, kDefaultFade, kPushWalk, plHBehavior::kBehaviorTypePushWalk);
//fBehaviors[kPushIdle] = behavior = TRACKED_NEW PushIdle;
//behavior->Init(pushIdle, true, this, fAvMod, kDefaultFade, kDefaultFade, kPushIdle, plHBehavior::kBehaviorTypePushIdle);
result = true;
}
return result;
}
hsBool plAvBrainHuman::RunStandardBehaviors(double timeNow, float elapsed)
{
int i;
for (i = 0; i < fBehaviors.GetCount(); i++)
{
plHBehavior *behavior = (plHBehavior*)fBehaviors[i];
if (behavior->PreCondition(timeNow, elapsed))
{
behavior->SetStrength(1.f, behavior->fFadeIn);
behavior->Process(timeNow, elapsed);
fPreconditions |= behavior->GetType();
}
else
{
behavior->SetStrength(0.f, behavior->fFadeOut);
fPreconditions &= ~behavior->GetType();
}
}
return true;
}
void plAvBrainHuman::SetStartedTurning(double when)
{
fStartedTurning = when;
}
void plAvBrainHuman::Spawn(double timeNow)
{
plArmatureBrain::Spawn(timeNow);
IdleOnly(true); // reset any behavior state we may have accumulated while waiting to spawn
// IdleOnly will set the blends of all anims to zero, and setting the blends will tell the AGModifier
// that it needs to compile. Trouble is, the modifier only checks once per frame. MoveViaAnimation
// works on the physics timestep, and will get called before compilation happens. It will go straight
// to the old compiled channel, ignore the blends and still move via any anim that was playing before
// we linked (only for the first frame).
//
// Trouble is, that first frame is usually a large physics step which we don't fully resolve. This means
// we could miss our spawn point, or worse, spawn into collision geometry and fall through.
//
// So we force the modifier to recompile.
if (fAvMod)
fAvMod->Compile(timeNow);
}
hsBool plAvBrainHuman::LeaveAge()
{
plPhysicalControllerCore* controller = fAvMod->GetController();
if(!controller->BehavingLikeAnAnimatedPhysical())
{
controller->BehaveLikeAnimatedPhysical(true);
delete fCallbackAction;
plSceneObject* avObj = fArmature->GetTarget(0);
plAGModifier* agMod = const_cast<plAGModifier*>(plAGModifier::ConvertNoRef(FindModifierByClass(avObj, plAGModifier::Index())));
fCallbackAction= TRACKED_NEW plWalkingController(avObj, agMod->GetApplicator(kAGPinTransform), controller);
fCallbackAction->ActivateController();
}
plArmatureBrain::LeaveAge();
// pin the physical so it doesn't fall when the world is deleted
fAvMod->EnablePhysics(false);
// this will get set to true when we hit ground
fCallbackAction->Reset(true);
return false;
}
void plAvBrainHuman::DumpToDebugDisplay(int &x, int &y, int lineHeight, char *strBuf, plDebugText &debugTxt)
{
sprintf(strBuf, "Brain type: Human");
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
const char *grounded = fCallbackAction->IsOnGround() ? "yes" : "no";
const char *falseGrounded = fCallbackAction->IsOnFalseGround() ? "yes" : "no";
const char *pushing = (fCallbackAction->GetPushingPhysical() ? (fCallbackAction->GetFacingPushingPhysical() ? "facing" : "behind") : "none");
sprintf(strBuf, "Ground: %3s, FalseGround: %3s, AirTime: %5.2f (Peak: %5.2f), PushingPhys: %6s",
grounded, falseGrounded, fCallbackAction->GetAirTime(), fCallbackAction->GetImpactTime(), pushing);
debugTxt.DrawString(x, y, strBuf);
y += lineHeight;
int i;
//strBuf[0] = '\0';
//for (i = 0; i < 32; i++)
// strcat(strBuf, fPreconditions & (0x1 << i) ? "1" : "0");
//debugTxt.DrawString(x, y, strBuf);
//y += lineHeight;
for (i = 0; i < fBehaviors.GetCount(); i++)
fBehaviors[i]->DumpDebug(x, y, lineHeight, strBuf, debugTxt);
debugTxt.DrawString(x, y, "Tasks:");
y += lineHeight;
if(fCurTask)
{
debugTxt.DrawString(x, y, "Current task:");
y += lineHeight;
int indentedX = x + 4;
fCurTask->DumpDebug("-", indentedX, y, lineHeight, strBuf, debugTxt);
}
int tasks = fTaskQueue.size();
if(tasks > 0)
{
debugTxt.DrawString(x, y, "Tasks in the Queue:");
y += lineHeight;
int indentedX = x + 4;
for (int i = 0; i < tasks; i++)
{
plAvTask *each = fTaskQueue[i];
each->DumpDebug("-", indentedX, y, lineHeight, strBuf, debugTxt);
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
// BEHAVIOR
plHBehavior::plHBehavior() :
fAvMod(nil),
fHuBrain(nil),
fFadeIn(1.0f),
fFadeOut(-1.0f),
fMaxBlend(1.0f)
{
}
plHBehavior::~plHBehavior()
{
}
void plHBehavior::Init(plAGAnim *anim, hsBool loop, plAvBrainHuman *brain,
plArmatureMod *body, float fadeIn, float fadeOut,
UInt8 index, UInt32 type /* = 0 */)
{
plArmatureBehavior::Init(anim, loop, brain, body, index);
fAvMod = body;
fHuBrain = brain;
fFadeIn = fadeIn;
fFadeOut = fadeOut;
fType = type;
fStartMsgSent = false; // start message hasn't been sent yet
fStopMsgSent = false; // stop message hasn't been sent yet
}
void plHBehavior::IStart()
{
plArmatureBehavior::IStart();
fAvMod->SynchIfLocal(hsTimer::GetSysSeconds(), false);
if (!fStartMsgSent)
fAvMod->IFireBehaviorNotify(fType);
fStartMsgSent = true; // we just sent a start message
fStopMsgSent = false; // we haven't sent a stop message yet
}
void plHBehavior::IStop()
{
plArmatureBehavior::IStop();
fAvMod->SynchIfLocal(hsTimer::GetSysSeconds(), false);
if (!fStopMsgSent)
fAvMod->IFireBehaviorNotify(fType, false);
fStartMsgSent = false; // we haven't sent a start message yet
fStopMsgSent = true; // we just sent a stop message
}
static plRandom sRandom;
void Idle::IStart()
{
plHBehavior::IStart();
if (fAnim)
{
hsScalar newStart = sRandom.RandZeroToOne() * fAnim->GetAnimation()->GetLength();
fAnim->SetCurrentTime(newStart, true);
}
}
hsBool Run::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (fAvMod->ForwardKeyDown() && fAvMod->FastKeyDown() && fHuBrain->fCallbackAction->IsOnGround() &&
(!fHuBrain->fCallbackAction->GetPushingPhysical() || !fHuBrain->fCallbackAction->GetFacingPushingPhysical()))
return true;
}
return false;
}
hsBool Walk::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (fAvMod->ForwardKeyDown() && !fAvMod->FastKeyDown() && fHuBrain->fCallbackAction->IsOnGround() &&
(!fHuBrain->fCallbackAction->GetPushingPhysical() || !fHuBrain->fCallbackAction->GetFacingPushingPhysical()))
return true;
}
return false;
}
hsBool WalkBack::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (fAvMod->BackwardKeyDown() && !fAvMod->ForwardKeyDown() && fHuBrain->fCallbackAction->IsOnGround() &&
(!fHuBrain->fCallbackAction->GetPushingPhysical() || fHuBrain->fCallbackAction->GetFacingPushingPhysical()))
return true;
}
return false;
}
hsBool StepLeft::PreCondition(double time, float elapsed)
{
if (fAnim)
{
return ((fAvMod->StrafeLeftKeyDown() || (fAvMod->StrafeKeyDown() && fAvMod->TurnLeftKeyDown())) &&
!(fAvMod->StrafeRightKeyDown() || (fAvMod->StrafeKeyDown() && fAvMod->TurnRightKeyDown())) &&
!(fAvMod->ForwardKeyDown() || fAvMod->BackwardKeyDown()) &&
fHuBrain->fCallbackAction->IsOnGround());
}
return false;
}
hsBool StepRight::PreCondition(double time, float elapsed)
{
if (fAnim)
{
return ((fAvMod->StrafeRightKeyDown() || (fAvMod->StrafeKeyDown() && fAvMod->TurnRightKeyDown())) &&
!(fAvMod->StrafeLeftKeyDown() || (fAvMod->StrafeKeyDown() && fAvMod->TurnLeftKeyDown())) &&
!(fAvMod->ForwardKeyDown() || fAvMod->BackwardKeyDown()) &&
fHuBrain->fCallbackAction->IsOnGround());
}
return false;
}
hsBool StandingTurnLeft::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (fAvMod->TurnLeftKeyDown() && !fAvMod->TurnRightKeyDown() && !fAvMod->StrafeKeyDown() &&
!fAvMod->ForwardKeyDown() && !fAvMod->BackwardKeyDown())
{
return true;
}
}
return false;
}
hsBool StandingTurnRight::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (fAvMod->TurnRightKeyDown() && !fAvMod->TurnLeftKeyDown() && !fAvMod->StrafeKeyDown() &&
!fAvMod->ForwardKeyDown() && !fAvMod->BackwardKeyDown())
{
return true;
}
}
return false;
}
void MovingTurn::IStart()
{
plHBehavior::IStart();
fHuBrain->SetStartedTurning(hsTimer::GetSysSeconds());
}
hsBool MovingTurnLeft::PreCondition(double time, float elapsed)
{
if (fAvMod->GetTurnStrength() > 0)
{
if (fHuBrain->fCallbackAction->IsOnGround() && (fAvMod->ForwardKeyDown() || fAvMod->BackwardKeyDown()) &&
(!fHuBrain->fCallbackAction->GetPushingPhysical() || !fHuBrain->fCallbackAction->GetFacingPushingPhysical()))
return true;
}
return false;
}
hsBool MovingTurnRight::PreCondition(double time, float elapsed)
{
if (fAvMod->GetTurnStrength() < 0)
{
if (fHuBrain->fCallbackAction->IsOnGround() && (fAvMod->ForwardKeyDown() || fAvMod->BackwardKeyDown()) &&
(!fHuBrain->fCallbackAction->GetPushingPhysical() || !fHuBrain->fCallbackAction->GetFacingPushingPhysical()))
return true;
}
return false;
}
void Jump::IStart()
{
fHuBrain->fCallbackAction->EnableControlledFlight(true);
plHBehavior::IStart();
}
void Jump::IStop()
{
fHuBrain->fCallbackAction->EnableControlledFlight(false);
plHBehavior::IStop();
}
hsBool StandingJump::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (GetStrength() > 0.f)
{
if (!fHuBrain->fCallbackAction->IsControlledFlight() ||
fAnim->GetTimeConvert()->WorldToAnimTimeNoUpdate(time) >= fAnim->GetTimeConvert()->GetEnd())
{
return false;
}
return !fAnim->IsFinished();
}
else
{
if (fAvMod->JumpKeyDown() &&
!fAvMod->ForwardKeyDown() &&
fAnim->GetBlend() == 0.0f &&
fHuBrain->fCallbackAction->IsOnGround())
{
if (fAvMod->ConsumeJump())
return true;
}
}
}
return false;
}
hsBool WalkingJump::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (GetStrength() > 0.f)
{
if (!fHuBrain->fCallbackAction->IsControlledFlight() ||
fAnim->GetTimeConvert()->WorldToAnimTimeNoUpdate(time) >= fAnim->GetTimeConvert()->GetEnd())
{
return false;
}
return !fAnim->IsFinished();
}
else
{
if (fAvMod->JumpKeyDown() &&
!fAvMod->FastKeyDown() &&
fAvMod->ForwardKeyDown() &&
fAnim->GetBlend() == 0.0f &&
fHuBrain->fCallbackAction->IsOnGround() &&
(!fHuBrain->fCallbackAction->GetPushingPhysical() || !fHuBrain->fCallbackAction->GetFacingPushingPhysical()))
{
if (fAvMod->ConsumeJump())
return true;
}
}
}
return false;
}
hsBool RunningJump::PreCondition(double time, float elapsed)
{
if (fAnim)
{
if (GetStrength() > 0.f)
{
if (!fHuBrain->fCallbackAction->IsControlledFlight() ||
fAnim->GetTimeConvert()->WorldToAnimTimeNoUpdate(time) >= fAnim->GetTimeConvert()->GetEnd())
{
return false;
}
return !fAnim->IsFinished();
}
else
{
if (fAvMod->JumpKeyDown() &&
fAvMod->ForwardKeyDown() &&
fAvMod->FastKeyDown() &&
fAnim->GetBlend() == 0.0f &&
fHuBrain->fCallbackAction->IsOnGround() &&
(!fHuBrain->fCallbackAction->GetPushingPhysical() || !fHuBrain->fCallbackAction->GetFacingPushingPhysical()))
{
if (fAvMod->ConsumeJump())
return true;
}
}
}
return false;
}
static const float kRunningImpactThresh = -1.0f;
static const float kFullImpactVel = 30.0f; // At this velocity (or greater) we blend the impact at full strength.
static const float kMinImpactVel = 10.f;
// If we just test IsOnGround(), we do a lot of impacts while running down stairs, so the impact
// behaviors have a more forgiving threshold.
static const float kMinAirTime = .5f;
RunningImpact::RunningImpact() : fDuration(0.0f) {}
hsBool RunningImpact::PreCondition(double time, float elapsed)
{
if (fDuration > 0.0f)
fDuration = fDuration - elapsed;
else if (fHuBrain->fCallbackAction->IsOnGround() && fHuBrain->fCallbackAction->GetImpactTime() > kMinAirTime)
{
if (fHuBrain->fCallbackAction->GetImpactVelocity().fZ < -kMinImpactVel)
{
if (fHuBrain->fCallbackAction->GetImpactVelocity().fY < kRunningImpactThresh)
{
fMaxBlend = 0.5f + (0.5f * (-fHuBrain->fCallbackAction->GetImpactVelocity().fZ / (kFullImpactVel - kMinImpactVel)));
if (fMaxBlend > 1)
fMaxBlend = 1;
fDuration = 1.0f / fFadeIn;
}
}
}
return(fDuration > 0.0f);
}
void RunningImpact::IStop()
{
fDuration = 0.0f;
plHBehavior::IStop();
}
GroundImpact::GroundImpact() : fDuration(0.0f) {}
hsBool GroundImpact::PreCondition(double time, float elapsed)
{
bool result = false;
if (fDuration > 0.0f)
fDuration = fDuration - elapsed;
else if (fHuBrain->fCallbackAction->IsOnGround() && fHuBrain->fCallbackAction->GetImpactTime() > kMinAirTime)
{
if (fHuBrain->fCallbackAction->GetImpactVelocity().fZ < -kMinImpactVel)
{
if (fHuBrain->fCallbackAction->GetImpactVelocity().fY >= kRunningImpactThresh)
{
fMaxBlend = 0.5f + (0.5f * (-fHuBrain->fCallbackAction->GetImpactVelocity().fZ / (kFullImpactVel - kMinImpactVel)));
if (fMaxBlend > 1)
fMaxBlend = 1;
fDuration = 1.0f / fFadeIn;
}
}
}
return(fDuration > 0.0f);
}
void GroundImpact::IStop()
{
fDuration = 0.0f;
plHBehavior::IStop();
}
hsBool Fall::PreCondition(double time, float elapsed)
{
return !fHuBrain->fCallbackAction->IsOnGround() && fHuBrain->fCallbackAction->HitGroundInThisAge();
}
void Fall::Process(double time, float elapsed)
{
// We don't see remote players panic link (from timeouts) because we don't know if they're
// really falling, or if our understanding of their physical location is just not up-to-date.
if (plAvatarMgr::GetInstance()->GetLocalAvatar() == fAvMod)
{
if (fAnim && fAnim->GetBlend() > 0.8)
{
float panicThresh = plAvBrainHuman::kAirTimePanicThreshold;
if (panicThresh > 0.0f && fHuBrain->fCallbackAction->GetAirTime() > panicThresh)
{
fHuBrain->IdleOnly(); // clear the fall state; we're going somewhere new
fAvMod->PanicLink();
}
}
}
}
extern float QuatAngleDiff(const hsQuat &a, const hsQuat &b);
void Push::Process(double time, float elapsed)
{
hsQuat rot;
hsPoint3 pos;
fAvMod->GetPositionAndRotationSim(&pos, &rot);
hsPoint3 lookAt;
fHuBrain->fCallbackAction->GetPushingPhysical()->GetPositionSim(lookAt);
hsVector3 up(0.f, 0.f, 1.f);
hsScalar angle = hsATan2(lookAt.fY - pos.fY, lookAt.fX - pos.fX) + hsScalarPI / 2;
hsQuat targRot(angle, &up);
const hsScalar kTurnSpeed = 3.f;
hsScalar angDiff = QuatAngleDiff(rot, targRot);
hsScalar turnSpeed = (angDiff > elapsed * kTurnSpeed ? kTurnSpeed : angDiff / elapsed);
hsQuat invRot = targRot.Conjugate();
hsPoint3 globFwd = invRot.Rotate(&kAvatarForward);
globFwd = rot.Rotate(&globFwd);
if (globFwd.fX < 0)
fHuBrain->fCallbackAction->SetTurnStrength(-turnSpeed);
else
fHuBrain->fCallbackAction->SetTurnStrength(turnSpeed);
}
//hsBool PushIdle::PreCondition(double time, float elapsed)
//{
// return (fHuBrain->fCallbackAction->GetPushingPhysical() &&
// fHuBrain->fCallbackAction->IsOnGround() &&
// !fAvMod->TurnLeftKeyDown() && !fAvMod->TurnRightKeyDown()
// && fAvMod->GetTurnStrength() == 0);
//}
hsBool PushWalk::PreCondition(double time, float elapsed)
{
return (fHuBrain->fCallbackAction->GetPushingPhysical() && fHuBrain->fCallbackAction->GetFacingPushingPhysical() &&
fHuBrain->fCallbackAction->IsOnGround() &&
fAvMod->ForwardKeyDown());
}
/////////////////////////////////////////////////////////////////////////////////////////
//
// UTIL FUNCTIONS
//
/////////////////////////////////////////////////////////////////////////////////////////
bool PushSimpleMultiStage(plArmatureMod *avatar, const char *enterAnim, const char *idleAnim, const char *exitAnim,
bool netPropagate, bool autoExit, plAGAnim::BodyUsage bodyUsage, plAvBrainGeneric::BrainType type /* = kGeneric */)
{
plAvBrainHuman *huBrain = plAvBrainHuman::ConvertNoRef(avatar->FindBrainByClass(plAvBrainHuman::Index()));
const char *names[3] = {enterAnim, idleAnim, exitAnim};
if (!huBrain || !huBrain->fCallbackAction->IsOnGround() || !huBrain->fCallbackAction->HitGroundInThisAge() || huBrain->IsRunningTask() ||
!avatar->IsPhysicsEnabled() || avatar->FindMatchingGenericBrain(names, 3))
return false;
// XXX
if (type == plAvBrainGeneric::kSit || type == plAvBrainGeneric::kSitOnGround)
{
plAvBrainSwim *swimBrain = plAvBrainSwim::ConvertNoRef(avatar->GetCurrentBrain());
if (swimBrain && !swimBrain->IsWalking())
return false;
}
// if autoExit is true, then we will immediately exit the idle loop when the user hits a move
// key. otherwise, we'll loop until someone sends a message telling us explicitly to advance
plAnimStage::AdvanceType idleAdvance = autoExit ? plAnimStage::kAdvanceOnMove : plAnimStage::kAdvanceNone;
plAnimStageVec *v = TRACKED_NEW plAnimStageVec;
plAnimStage *s1 = TRACKED_NEW plAnimStage(enterAnim,
0,
plAnimStage::kForwardAuto, plAnimStage::kBackNone,
plAnimStage::kAdvanceAuto, plAnimStage::kRegressNone,
0);
v->push_back(s1);
plAnimStage *s2 = TRACKED_NEW plAnimStage(idleAnim, 0,
plAnimStage::kForwardAuto, plAnimStage::kBackNone,
idleAdvance, plAnimStage::kRegressNone,
-1);
v->push_back(s2);
plAnimStage *s3 = TRACKED_NEW plAnimStage(exitAnim, 0,
plAnimStage::kForwardAuto, plAnimStage::kBackNone,
plAnimStage::kAdvanceAuto, plAnimStage::kRegressNone,
0);
v->push_back(s3);
plAvBrainGeneric *b = TRACKED_NEW plAvBrainGeneric(v, nil, nil, nil, plAvBrainGeneric::kExitAnyTask | plAvBrainGeneric::kExitNewBrain,
2.0f, 2.0f, plAvBrainGeneric::kMoveStandstill);
b->SetBodyUsage(bodyUsage);
b->SetType(type);
plAvTaskBrain *bt = TRACKED_NEW plAvTaskBrain(b);
plAvTaskMsg *btm = TRACKED_NEW plAvTaskMsg(plAvatarMgr::GetInstance()->GetKey(), avatar->GetKey(), bt);
if(netPropagate)
btm->SetBCastFlag(plMessage::kNetPropagate);
btm->Send();
return true;
}
bool AvatarEmote(plArmatureMod *avatar, const char *emoteName)
{
bool result = false;
char *fullName = avatar->MakeAnimationName(emoteName);
plAGAnim *anim = plAGAnim::FindAnim(fullName);
plEmoteAnim *emote = plEmoteAnim::ConvertNoRef(anim);
hsBool alreadyActive = avatar->FindAnimInstance(fullName) != nil;
plAvBrainHuman *huBrain = plAvBrainHuman::ConvertNoRef(avatar->FindBrainByClass(plAvBrainHuman::Index()));
delete[] fullName;
// XXX
plAvBrainSwim *swimBrain = plAvBrainSwim::ConvertNoRef(avatar->GetCurrentBrain());
if (swimBrain && swimBrain->IsSwimming())
return false;
if (huBrain && huBrain->fCallbackAction->IsOnGround() && huBrain->fCallbackAction->HitGroundInThisAge() && !huBrain->IsRunningTask() &&
emote && !alreadyActive && avatar->IsPhysicsEnabled())
{
plKey avKey = avatar->GetKey();
float fadeIn = emote->GetFadeIn();
float fadeOut = emote->GetFadeOut();
plAnimStage *s1 = TRACKED_NEW plAnimStage(emoteName,
0,
plAnimStage::kForwardAuto,
plAnimStage::kBackNone,
plAnimStage::kAdvanceOnMove,
plAnimStage::kRegressNone,
0);
plAnimStageVec *v = TRACKED_NEW plAnimStageVec;
v->push_back(s1);
plAvBrainGeneric *b = TRACKED_NEW plAvBrainGeneric(v, nil, nil, nil,
plAvBrainGeneric::kExitAnyInput | plAvBrainGeneric::kExitNewBrain | plAvBrainGeneric::kExitAnyTask,
2.0f, 2.0f, huBrain->IsActor() ? plAvBrainGeneric::kMoveRelative : plAvBrainGeneric::kMoveStandstill);
b->SetType(plAvBrainGeneric::kEmote);
b->SetBodyUsage(emote->GetBodyUsage());
plAvTaskBrain *bt = TRACKED_NEW plAvTaskBrain(b);
plAvTaskMsg *btm = TRACKED_NEW plAvTaskMsg(plAvatarMgr::GetInstance()->GetKey(), avKey, bt);
btm->SetBCastFlag(plMessage::kNetPropagate);
btm->Send();
result = true;
}
return result;
}