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.
378 lines
12 KiB
378 lines
12 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 "plAvatar/plAvCallbackAction.h" |
|
|
|
#include "hsTypes.h" |
|
|
|
// singular |
|
#include "plAvLadderModifier.h" |
|
|
|
// local |
|
#include "plArmatureMod.h" |
|
#include "plAvatarMgr.h" |
|
#include "plAvBrainGeneric.h" |
|
#include "plAGAnim.h" |
|
#include "plAnimStage.h" |
|
|
|
// global |
|
#include "plCreatableIndex.h" |
|
// #include "plgDispatch.h" // Message Dependencies |
|
#include "hsStream.h" |
|
|
|
//other |
|
#include "plMessage/plCollideMsg.h" |
|
#include "plMessage/plAvatarMsg.h" |
|
#include "pnMessage/plNotifyMsg.h" |
|
#include "plStatusLog/plStatusLog.h" |
|
#include "pnKeyedObject/plKey.h" |
|
#include "pnMessage/plEnableMsg.h" |
|
|
|
#include "pnMessage/plTimeMsg.h" |
|
#include "plgDispatch.h" |
|
#include "pnNetCommon/plNetApp.h" |
|
#include "pnSceneObject/plCoordinateInterface.h" |
|
#include "plAvatar/plAvBrainHuman.h" |
|
#include "plModifier/plDetectorLog.h" |
|
|
|
enum NotifyType |
|
{ |
|
kNotifyTrigger, |
|
kNotifyAvatarOnLadder, |
|
}; |
|
|
|
// CTOR default |
|
plAvLadderMod::plAvLadderMod() |
|
: fGoingUp(true), |
|
fType(kBig), |
|
fLoops(0), |
|
fEnabled(true), |
|
fAvatarInBox(false), |
|
fLadderView(0,0,0), |
|
fAvatarMounting(false) |
|
{ |
|
fTarget = nil; |
|
} |
|
|
|
// CTOR goingUp, type, loops |
|
plAvLadderMod::plAvLadderMod(bool goingUp, int type, int loops, bool enabled, hsVector3& ladderView) |
|
: fGoingUp(goingUp), |
|
fType(type), |
|
fLoops(loops), |
|
fEnabled(enabled), |
|
fAvatarInBox(false), |
|
fLadderView(ladderView) |
|
{ |
|
fTarget = nil; |
|
} |
|
|
|
// Must be facing within 45 degrees of the ladder |
|
static const hsScalar kTolerance = hsCosine(hsScalarDegToRad(45)); |
|
|
|
bool plAvLadderMod::IIsReadyToClimb() |
|
{ |
|
if (fAvatarMounting) |
|
return false; |
|
|
|
plArmatureMod* armMod = plAvatarMgr::GetInstance()->GetLocalAvatar(); |
|
plSceneObject* avatar = armMod->GetTarget(0); |
|
if (avatar) |
|
{ |
|
hsVector3 playerView = avatar->GetCoordinateInterface()->GetLocalToWorld().GetAxis(hsMatrix44::kView); |
|
playerView.fZ = 0; |
|
|
|
// Are we facing towards the ladder? |
|
hsScalar dot = playerView * fLadderView; |
|
|
|
bool movingForward = false; |
|
|
|
// And are we walking towards it? |
|
hsAssert(armMod, "Avatar doesn't have an armature mod"); |
|
if (armMod) |
|
{ |
|
plAvBrainHuman* brain = plAvBrainHuman::ConvertNoRef(armMod->GetCurrentBrain()); |
|
if (brain && brain->IsMovingForward() && brain->fCallbackAction->IsOnGround()) |
|
movingForward = true; |
|
} |
|
|
|
if (dot >= kTolerance && movingForward) |
|
{ |
|
DetectorLogSpecial("%s: Ladder starting climb (%f)", GetKeyName(), hsScalarRadToDeg(hsACosine(dot))); |
|
return true; |
|
} |
|
else if (movingForward) |
|
{ |
|
// DetectorLog("%s: Ladder rejecting climb (%f)", GetKeyName(), hsScalarRadToDeg(hsACosine(dot))); |
|
return false; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
// use a plNotify (to ourself) to propagate across the network |
|
void plAvLadderMod::ITriggerSelf(plKey avKey) |
|
{ |
|
if (fEnabled) |
|
{ |
|
plKey avPhysKey = avKey; |
|
// I'm going to lie and pretend it's from the avatar. the alternative is lengthy and unreadable. |
|
plNotifyMsg *notifyMsg = TRACKED_NEW plNotifyMsg(avPhysKey, GetKey()); |
|
notifyMsg->fID = kNotifyTrigger; |
|
notifyMsg->Send(); |
|
fAvatarMounting = true; |
|
} |
|
} |
|
|
|
// MSGRECEIVE |
|
hsBool plAvLadderMod::MsgReceive(plMessage* msg) |
|
{ |
|
// Avatar is entering or exiting our detector box |
|
plCollideMsg* collMsg = plCollideMsg::ConvertNoRef(msg); |
|
if (collMsg) |
|
{ |
|
// make sure this is the local player... the notify will be the thing that propagates over the network |
|
if (plNetClientApp::GetInstance()->GetLocalPlayerKey() != collMsg->fOtherKey) |
|
return true; |
|
|
|
fAvatarInBox = (collMsg->fEntering != 0); |
|
|
|
// If entering, check if ready to climb. If not, register for eval so |
|
// we can check every frame |
|
if (fAvatarInBox) |
|
{ |
|
DetectorLogSpecial("%s: Avatar entered ladder region", GetKeyName()); |
|
|
|
if (IIsReadyToClimb()) |
|
ITriggerSelf(collMsg->fOtherKey); |
|
else |
|
plgDispatch::Dispatch()->RegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
} |
|
else |
|
{ |
|
DetectorLogSpecial("%s: Avatar exited ladder region", GetKeyName()); |
|
|
|
plgDispatch::Dispatch()->UnRegisterForExactType(plEvalMsg::Index(), GetKey()); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
// Avatar is inside our detector box, so every frame we check if he's ready to climb |
|
plEvalMsg* evalMsg = plEvalMsg::ConvertNoRef(msg); |
|
if (evalMsg) |
|
{ |
|
if (IIsReadyToClimb()) |
|
ITriggerSelf(plNetClientApp::GetInstance()->GetLocalPlayerKey()); |
|
return true; |
|
} |
|
|
|
plNotifyMsg *notifyMsg = plNotifyMsg::ConvertNoRef(msg); |
|
if (notifyMsg) |
|
{ |
|
if (notifyMsg->fID == kNotifyTrigger && fEnabled) |
|
{ |
|
const plKey avPhysKey = notifyMsg->GetSender(); |
|
EmitCommand(avPhysKey); |
|
} |
|
else if (notifyMsg->fID == kNotifyAvatarOnLadder) |
|
{ |
|
DetectorLogSpecial("%s: Avatar mounted ladder", GetKeyName()); |
|
fAvatarMounting = false; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
plEnableMsg *enableMsg = plEnableMsg::ConvertNoRef(msg); |
|
if (enableMsg) |
|
{ |
|
if (enableMsg->Cmd(plEnableMsg::kDisable)) |
|
fEnabled = false; |
|
else if (enableMsg->Cmd(plEnableMsg::kEnable)) |
|
fEnabled = true; |
|
} |
|
|
|
return plSingleModifier::MsgReceive(msg); |
|
} |
|
|
|
// EMITCOMMAND |
|
void plAvLadderMod::EmitCommand(const plKey receiver) |
|
{ |
|
hsKeyedObject *object = receiver->ObjectIsLoaded(); |
|
plSceneObject *SO = plSceneObject::ConvertNoRef(object); |
|
if(SO) |
|
{ |
|
const plArmatureMod *constAvMod = (plArmatureMod*)SO->GetModifierByType(plArmatureMod::Index()); |
|
if(constAvMod) |
|
{ |
|
plAvBrainGeneric *curGenBrain = (plAvBrainGeneric *)constAvMod->FindBrainByClass(plAvBrainGeneric::Index()); |
|
// *** warning; if there's more than one generic brain active, this will only look at the first |
|
bool alreadyOnLadder = ( curGenBrain && curGenBrain->GetType() == plAvBrainGeneric::kLadder ); |
|
|
|
if( ! alreadyOnLadder) |
|
{ |
|
plSceneObject *seekObj = GetTarget(); |
|
plKey seekKey = seekObj->GetKey(); // this modifier's target is the seek object |
|
|
|
char *mountName, *dismountName, *traverseName; |
|
|
|
if(fGoingUp) |
|
{ |
|
mountName = "LadderUpOn"; |
|
dismountName = "LadderUpOff"; |
|
traverseName = "LadderUp"; |
|
} else { |
|
mountName = "LadderDownOn"; |
|
dismountName = "LadderDownOff"; |
|
traverseName = "LadderDown"; |
|
} |
|
|
|
plAnimStageVec *v = TRACKED_NEW plAnimStageVec; |
|
|
|
plAnimStage *s1 = TRACKED_NEW plAnimStage(mountName, |
|
0, |
|
plAnimStage::kForwardAuto, |
|
plAnimStage::kBackAuto, |
|
plAnimStage::kAdvanceAuto, |
|
plAnimStage::kRegressAuto, |
|
0); |
|
if( ! fGoingUp) |
|
s1->SetReverseOnIdle(true); |
|
v->push_back(s1); |
|
|
|
// if loops is zero, we don't need the traverse animation at all. |
|
if(fLoops) |
|
{ |
|
plAnimStage *s2 = TRACKED_NEW plAnimStage(traverseName, |
|
0, |
|
plAnimStage::kForwardKey, |
|
plAnimStage::kBackKey, |
|
plAnimStage::kAdvanceAuto, |
|
plAnimStage::kRegressAuto, |
|
fLoops - 1 // first loop is implied; zero loops means |
|
// play this anim once, 1 loop means "loop |
|
// once after reaching the end." |
|
); |
|
if( ! fGoingUp) |
|
s2->SetReverseOnIdle(true); |
|
v->push_back(s2); |
|
} |
|
plAnimStage *s3 = TRACKED_NEW plAnimStage(dismountName, |
|
0, |
|
plAnimStage::kForwardAuto, |
|
plAnimStage::kBackAuto, |
|
plAnimStage::kAdvanceAuto, |
|
plAnimStage::kRegressAuto, |
|
0); |
|
if( ! fGoingUp) |
|
s3->SetReverseOnIdle(true); |
|
v->push_back(s3); |
|
|
|
plNotifyMsg* enterNotify = TRACKED_NEW plNotifyMsg(GetKey(), GetKey()); |
|
enterNotify->fID = kNotifyAvatarOnLadder; |
|
|
|
UInt32 exitFlags = plAvBrainGeneric::kExitNormal; |
|
|
|
plAvBrainGeneric *ladBrain = TRACKED_NEW plAvBrainGeneric(v, enterNotify, nil, nil, exitFlags, plAvBrainGeneric::kDefaultFadeIn, |
|
plAvBrainGeneric::kDefaultFadeOut, plAvBrainGeneric::kMoveRelative); |
|
ladBrain->SetType(plAvBrainGeneric::kLadder); |
|
ladBrain->SetReverseFBControlsOnRelease(!fGoingUp); |
|
|
|
plKey avKey = constAvMod->GetKey(); |
|
|
|
// Very important that we dumb seek here. Otherwise you can run off the edge of a ladder, and seek will be helpless |
|
// until you hit the ground, at which point you have no hope of successfully seeking. |
|
plAvSeekMsg *seeker = TRACKED_NEW plAvSeekMsg(nil, avKey, seekKey, 1.0f, false); |
|
seeker->Send(); |
|
plAvPushBrainMsg *brainer = TRACKED_NEW plAvPushBrainMsg(nil, avKey, ladBrain); |
|
brainer->Send(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void plAvLadderMod::Read(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plSingleModifier::Read(stream, mgr); |
|
|
|
fType = stream->ReadSwap32(); |
|
fLoops = stream->ReadSwap32(); |
|
fGoingUp = stream->Readbool(); |
|
fEnabled = stream->Readbool(); |
|
fLadderView.fX = stream->ReadSwapScalar(); |
|
fLadderView.fY = stream->ReadSwapScalar(); |
|
fLadderView.fZ = stream->ReadSwapScalar(); |
|
} |
|
|
|
void plAvLadderMod::Write(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plSingleModifier::Write(stream, mgr); |
|
|
|
stream->WriteSwap32(fType); |
|
stream->WriteSwap32(fLoops); |
|
stream->Writebool(fGoingUp); |
|
stream->WriteBool(fEnabled); |
|
stream->WriteSwapScalar(fLadderView.fX); |
|
stream->WriteSwapScalar(fLadderView.fY); |
|
stream->WriteSwapScalar(fLadderView.fZ); |
|
} |
|
|
|
// true is up; false is down |
|
bool plAvLadderMod::GetGoingUp() const |
|
{ |
|
return fGoingUp; |
|
} |
|
|
|
void plAvLadderMod::SetGoingUp(bool up) |
|
{ |
|
fGoingUp = up; |
|
} |
|
|
|
int plAvLadderMod::GetLoops() const |
|
{ |
|
return fLoops; |
|
} |
|
|
|
void plAvLadderMod::SetLoops(int loops) |
|
{ |
|
fLoops = loops; |
|
} |
|
|
|
int plAvLadderMod::GetType() const |
|
{ |
|
return fType; |
|
} |
|
|
|
void plAvLadderMod::SetType(int type) |
|
{ |
|
if(type >= kNumOfTypeFields || type < 0) |
|
{ |
|
hsStatusMessage("Invalid param to plAvLadderMod::SetType: defaulting to kBig"); |
|
fType = kBig; |
|
} else { |
|
fType = type; |
|
} |
|
}
|
|
|