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.
1453 lines
50 KiB
1453 lines
50 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; |
|
} |
|
|
|
|