CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plAvatar/plAvTaskSeek.cpp

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

/////////////////////////////////////////////////////////////////////////////////////////
//
// INCLUDES
//
/////////////////////////////////////////////////////////////////////////////////////////

// singular
#include "plAvTaskSeek.h"

// local
#include "plAvBrainHuman.h"
#include "plAGAnim.h"
#include "plArmatureMod.h"
#include "plAvatarMgr.h"
#include "plAvCallbackAction.h"

// other
#include "../plMessage/plAvatarMsg.h"
#include "../pnMessage/plCameraMsg.h"
#include "../pnInputCore/plControlEventCodes.h"
#include "../plPipeline/plDebugText.h"
#include "../plStatusLog/plStatusLog.h"
#include "../pnSceneObject/plCoordinateInterface.h"
#include "hsTimer.h"
#include "plgDispatch.h"

/////////////////////////////////////////////////////////////////////////////////////////
//
// PROTOTYPES
//
/////////////////////////////////////////////////////////////////////////////////////////
float QuatAngleDiff(const hsQuat &a, const hsQuat &b);
void MakeMatrixUpright(hsMatrix44 &mat);

/////////////////////////////////////////////////////////////////////////////////////////
//
// DEFINES
//
/////////////////////////////////////////////////////////////////////////////////////////

#define	kSeekTimeout 5.0f
#define kRotSpeed 1.0f		// normal rotation speed is 1.0 radians per second
#define kFloatSpeed 3.0f
#define kMaxRadiansPerSecond 1.5

#define kDefaultShuffleRange 0.5f
#define kDefaultMaxSidleRange 4.0f
#define kDefaultMaxSidleAngle 0.2f

hsBool plAvTaskSeek::fLogProcess = false;

/////////////////////////////////////////////////////////////////////////////////////////
//
// IMPLEMENTATION
//
/////////////////////////////////////////////////////////////////////////////////////////

void plAvTaskSeek::IInitDefaults()
{
	fSeekObject = nil;
	fMovingTarget = false;
	fAlign = kAlignHandle;
	fAnimName = nil;
	fPosGoalHit = false;
	fRotGoalHit = false;
	fStillPositioning = true;
	fStillRotating = true;
	fShuffleRange = kDefaultShuffleRange;
	fMaxSidleRange = kDefaultMaxSidleRange;
	fMaxSidleAngle = kDefaultMaxSidleAngle;
	fFlags = kSeekFlagForce3rdPersonOnStart;  
	fState = kSeekRunNormal;
	fNotifyFinishedKey = nil;
}
// plAvTaskSeek ------------
// -------------
plAvTaskSeek::plAvTaskSeek() {}

plAvTaskSeek::plAvTaskSeek(plAvSeekMsg *msg)
{
	IInitDefaults();

	fAlign = msg->fAlignType;
	fAnimName = msg->fAnimName;

	plKey &target = msg->fSeekPoint;
	if (target)
		SetTarget(target);
	else
		SetTarget(msg->fTargetPos, msg->fTargetLookAt);
	
	if (msg->UnForce3rdPersonOnFinish())
		fFlags |= kSeekFlagUnForce3rdPersonOnFinish;
	else
		fFlags &= ~kSeekFlagUnForce3rdPersonOnFinish;

	if (msg->Force3rdPersonOnStart())
		fFlags |= kSeekFlagForce3rdPersonOnStart;
	else
		fFlags &= ~kSeekFlagForce3rdPersonOnStart;

	if (msg->NoWarpOnTimeout())
		fFlags |= kSeekFlagNoWarpOnTimeout;
	else
		fFlags &= ~kSeekFlagNoWarpOnTimeout;

	if (msg->RotationOnly())
	{
		fFlags |= kSeekFlagRotationOnly;
		fStillPositioning = false;
		fPosGoalHit = true;
	}
	else
		fFlags &= ~kSeekFlagRotationOnly;

	fNotifyFinishedKey = msg->fFinishKey;
}

// plAvTaskSeek ------------------------
// -------------
plAvTaskSeek::plAvTaskSeek(plKey target)
{
	IInitDefaults();

	SetTarget(target);
}

// plAvTaskSeek -------------------------------------------------------------------------------------------
// -------------
plAvTaskSeek::plAvTaskSeek(plKey target, plAvAlignment align, const char *animName, bool moving)
{
	IInitDefaults();

	fMovingTarget = moving;
	fAlign = align;
	fAnimName = animName;

	SetTarget(target);
}

void plAvTaskSeek::SetTarget(plKey target)
{
	hsAssert(target, "Bad key to seek task");
	if(target)
	{
		fSeekObject = plSceneObject::ConvertNoRef(target->ObjectIsLoaded());
	}
	else
	{
		fSeekObject = nil;
	}
}
	
void plAvTaskSeek::SetTarget(hsPoint3 &pos, hsPoint3 &lookAt)
{
	fSeekPos = pos;
	hsVector3 up(0.f, 0.f, 1.f);
	hsScalar angle = hsATan2(lookAt.fY - pos.fY, lookAt.fX - pos.fX) + hsScalarPI / 2;
	fSeekRot.SetAngleAxis(angle, up);
}

// Start -----------------------------------------------------------------------------------------
// ------
hsBool plAvTaskSeek::Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	plAvBrainHuman *huBrain = plAvBrainHuman::ConvertNoRef(brain);
	hsAssert(huBrain, "Seek task only works on human brains");

	plAvatarMgr::GetInstance()->GetLog()->AddLine("Starting SMART SEEK");
	//controller needs to know we are seeking. prevents controller from interacting with exclusion regions
	
	if (avatar->GetController() )
		avatar->GetController()->SetSeek(true);
	fStartTime = time;
	if(huBrain)
	{
		avatar->SuspendInput();		// stop accepting input from the user, but queue any messages
									// ...and save our current input state.
		
		ILimitPlayersInput(avatar);
		
		if (plAvOneShotTask::fForce3rdPerson && avatar->IsLocalAvatar() && (fFlags & plAvSeekMsg::kSeekFlagForce3rdPersonOnStart))
		{
			// create message
			plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
			pMsg->SetBCastFlag(plMessage::kBCastByExactType);
			pMsg->SetBCastFlag(plMessage::kNetPropagate, false);
			pMsg->SetCmd(plCameraMsg::kResponderSetThirdPerson);
			plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
		}		

		huBrain->IdleOnly(); // Makes sure to kill jumps too. Just calling ClearInputFlags isn't enough
		IUpdateObjective(avatar);
		return true;
	}
	else
	{
		return false;
	}
}

// Process -------------------------------------------------------------------------------------------
// --------
hsBool plAvTaskSeek::Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	if (fState == kSeekAbort)
		return false;
	
	plAvBrainHuman *uBrain = plAvBrainHuman::ConvertNoRef(brain);
	if (uBrain)
	{
		if (fMovingTarget)
		{
			IUpdateObjective(avatar);
		}
		
		IAnalyze(avatar);
		hsBool result = IMoveTowardsGoal(avatar, uBrain, time, elapsed);
		if (fLogProcess)
			DumpToAvatarLog(avatar);
		return result;
	}

	return false;
}

// Finish ---------------------------------------------------------------------------------------
// -------
void plAvTaskSeek::Finish(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed)
{
	plAvBrainHuman *huBrain = plAvBrainHuman::ConvertNoRef(brain);
	
	if(huBrain)
	{
		// this will process any queued input messages so if the user pressed or released a key while we were busy, we'll note it now.
		avatar->ResumeInput();	
		IUndoLimitPlayersInput(avatar);
		
		if (plAvOneShotTask::fForce3rdPerson && avatar->IsLocalAvatar() && (fFlags & plAvSeekMsg::kSeekFlagUnForce3rdPersonOnFinish))
		{
			// create message
			plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
			pMsg->SetBCastFlag(plMessage::kBCastByExactType);
			pMsg->SetBCastFlag(plMessage::kNetPropagate, false);
			pMsg->SetCmd(plCameraMsg::kResponderUndoThirdPerson);
			plgDispatch::MsgSend( pMsg );	// whoosh... off it goes
		}
		
		avatar->SynchIfLocal(hsTimer::GetSysSeconds(), false);
	}

	if (fNotifyFinishedKey)
	{
		plAvTaskSeekDoneMsg *msg = TRACKED_NEW plAvTaskSeekDoneMsg(avatar->GetKey(), fNotifyFinishedKey);
		msg->fAborted = (fState == kSeekAbort);
		msg->Send();
	}
	plAvatarMgr::GetInstance()->GetLog()->AddLine("Finished SMART SEEK");	
	//inform controller we are done seeking
	if (avatar->GetController())
		avatar->GetController()->SetSeek(false);
}

void plAvTaskSeek::LeaveAge(plArmatureMod *avatar)
{
	fSeekObject = nil;
	fState = kSeekAbort;
}

// IAnalyze ----------------------------------------
// ---------
hsBool plAvTaskSeek::IAnalyze(plArmatureMod *avatar)
{
	avatar->GetPositionAndRotationSim(&fPosition, &fRotation);
	fGoalVec.Set(&(hsScalarTriple)(fSeekPos - fPosition));
	hsVector3 normalizedGoalVec(fGoalVec);
	normalizedGoalVec.Normalize();

	fDistance = hsSquareRoot(fGoalVec.fX * fGoalVec.fX + fGoalVec.fY * fGoalVec.fY);

	if(fDistance < 3.0f)
	{
		// we're in "near target" mode
		fMinFwdAngle = .5f;			// walk forward if target's in 90' cone straight ahead
		fMaxBackAngle = -.2f;		// walk backward if target's in a 144' cone behind
	}
	else
	{
		// we're in "far target" mode
		fMinFwdAngle = .2f;			// walk forward if target's in a 144' cone ahead
		fMaxBackAngle = -2.0;		// disable backing up if goal is far out (-1 is the minimum usable value here)
	}
	
	hsQuat invRot = fRotation.Conjugate();
	hsPoint3 globFwd = invRot.Rotate(&kAvatarForward);
	hsPoint3 globRight = invRot.Rotate(&kAvatarRight);

	hsPoint3 locGoalVec = fRotation.Rotate(&fGoalVec);

	fDistForward = -(locGoalVec.fY);
	fDistRight = -(locGoalVec.fX);

	fAngForward = globFwd.InnerProduct(normalizedGoalVec);
	fAngRight = globRight.InnerProduct(normalizedGoalVec);
	return true;
}

// IMoveTowardsGoal --------------------------------------------------------------
// -----------------
hsBool plAvTaskSeek::IMoveTowardsGoal(plArmatureMod *avatar, plAvBrainHuman *brain,
									  double time, hsScalar elapsed)
{
	bool stillRunning = true;
	avatar->ClearInputFlags(false, false);

	double duration = time - fStartTime;

	if(duration > kSeekTimeout)
	{
		if (fFlags & kSeekFlagNoWarpOnTimeout)
		{
			fState = kSeekAbort;
			return false;
		}
		fSeekRot.Normalize();
		avatar->SetPositionAndRotationSim(&fSeekPos, &fSeekRot);
		IAnalyze(avatar); // Recalcs fPosition, fDistance, etc.
		hsStatusMessage("Timing out on smart seek - jumping to target.");
		stillRunning = false;

		// We just set the pos/rot, so we know these are hit.
		fPosGoalHit = true;
		fRotGoalHit = true;
	}

	if (!(fDistance > fShuffleRange))
		fPosGoalHit = true;

	if (!fPosGoalHit)
	{
		bool right = fAngRight > 0.0f;
		bool inSidleRange = fDistance < fMaxSidleRange;
		
		bool sidling = fabs(fDistRight) > fabs(fDistForward) && inSidleRange;

		if(sidling)
		{
			if(right)
				avatar->SetStrafeRightKeyDown();
			else
				avatar->SetStrafeLeftKeyDown();
		}
		else
		{
			if(fAngForward < fMaxBackAngle)
				avatar->SetBackwardKeyDown();

			else
			{
				if(fAngForward > fMinFwdAngle)
					avatar->SetForwardKeyDown();

				if(right)
					avatar->SetTurnRightKeyDown();
				else
					avatar->SetTurnLeftKeyDown();
			}
		}
	}
	else 
	{
		if (!(QuatAngleDiff(fRotation, fSeekRot) > .1))
			fRotGoalHit = true;

		if (!fRotGoalHit)
		{
			hsQuat invRot = fSeekRot.Conjugate();
			hsPoint3 globFwd = invRot.Rotate(&kAvatarForward);
			globFwd = fRotation.Rotate(&globFwd);
		
			if (globFwd.fX < 0)
				avatar->SetTurnRightKeyDown();
			else
				avatar->SetTurnLeftKeyDown();
		}
	}		

	if (fPosGoalHit && fRotGoalHit)
		stillRunning = ITryFinish(avatar, brain, time, elapsed);

	return stillRunning;
}


// ITRYFINISH
bool plAvTaskSeek::ITryFinish(plArmatureMod *avatar, plAvBrainHuman *brain, double time, hsScalar elapsed)
{
	hsBool animsDone = brain->IsMovementZeroBlend();

	hsPoint3 newPosition = fPosition;
	hsQuat newRotation = fRotation;

	if (!(fFlags & kSeekFlagRotationOnly) && (fStillPositioning || !animsDone))
		fStillPositioning = IFinishPosition(newPosition, avatar, brain, time, elapsed);
	if (fStillRotating || !animsDone)
		fStillRotating = IFinishRotation(newRotation, avatar, brain, time, elapsed);

	newRotation.Normalize();
  	if (hsCheckBits(fFlags, kSeekFlagRotationOnly))
		avatar->SetPositionAndRotationSim(nil, &newRotation);
	else
		avatar->SetPositionAndRotationSim(&newPosition, &newRotation);

	return fStillPositioning || fStillRotating || !animsDone;
}

hsBool plAvTaskSeek::IFinishPosition(hsPoint3 &newPosition,
									 plArmatureMod *avatar, plAvBrainHuman *brain,
									 double time, hsScalar elapsed)
{
	// While warping, we might be hovering just above the ground. Don't want that to
	// trigger any falling behavior.
	if(brain&&brain->fCallbackAction)
	{
		
		brain->fCallbackAction->ResetAirTime();
	}
	// how far will we translate this frame?
	float thisDist = kFloatSpeed * elapsed;
	// what percentage of the remaining distance will we cover?
	float thisPct = (fDistance ? thisDist / fDistance : 1.f);
	
	if(thisPct > 0.9f)
	{
		// we're pretty much done; just hop the rest of the way
		newPosition = fSeekPos;
		return false; // we're done
	}
	else
	{
		// move incrementally toward the target position
		hsVector3 thisMove = fGoalVec * thisPct;
		newPosition = fPosition + thisMove;
		return true;		// we're still processing
	}
	return true;
}



// IFinishRotation --------------------------------------
// ----------------
hsBool plAvTaskSeek::IFinishRotation(hsQuat &newRotation,
									 plArmatureMod *avatar, plAvBrainHuman *brain,
									 double time, hsScalar elapsed)
{
	// we're pretty much done; just hop the rest of the way
	newRotation = fSeekRot;
	return false;
}

// IUpdateObjective ----------------------------------------
// -----------------
hsBool plAvTaskSeek::IUpdateObjective(plArmatureMod *avatar)
{
	// This is an entirely valid case. It just means our goal is fixed.
	if (fSeekObject == nil)
		return true;

	// goal here is to express the target matrix in the avatar's PHYSICAL space
	hsMatrix44 targL2W = fSeekObject->GetLocalToWorld();
	const plCoordinateInterface* subworldCI = nil;
	if (avatar->GetController())
		subworldCI = avatar->GetController()->GetSubworldCI();
	if (subworldCI)
		targL2W = subworldCI->GetWorldToLocal() * targL2W;

	MakeMatrixUpright(targL2W);

	switch(fAlign)
	{
		// match our handle to the target matrix at the end of the given animation
		// This case isn't currently used but will be important someday. The idea
		// is that you have a target point and an animation, and you want to seek
		// the avatar to a point where he can start playing the animation and wind
		// up, after the animation completes, at the target location.
		// Hence "AlignHandleAnimEnd" = "align the avatar so the animation will
		// end on the target."
		case kAlignHandleAnimEnd:
			{
				hsMatrix44 adjustment;
				plAGAnim *anim = avatar->FindCustomAnim(fAnimName);
				// don't need to do this every frame; the animation doesn't change.
				// *** cache the adjustment;
				GetStartToEndTransform(anim, nil, &adjustment, "Handle");	// actually getting end-to-start
				// ... but we do still need to multiply by the (potentially changed) target
				targL2W = targL2W * adjustment;
			}
			break;
		case kAlignHandle:		// targetMat is already correct
		default:
			break;
	};

	GetPositionAndRotation(targL2W, &fSeekPos, &fSeekRot);

	return true;
}



// DumpDebug -----------------------------------------------------------------------------------------------------
// ----------
void plAvTaskSeek::DumpDebug(const char *name, int &x, int&y, int lineHeight, char *strBuf, plDebugText &debugTxt)
{
	sprintf(strBuf, "duration: %.2f pos: (%.3f, %.3f, %.3f) goalPos: (%.3f, %.3f, %.3f) ",
			hsTimer::GetSysSeconds() - fStartTime,
			fPosition.fX, fPosition.fY, fPosition.fZ, fSeekPos.fX, fSeekPos.fY, fSeekPos.fZ);
	debugTxt.DrawString(x, y, strBuf);
	y += lineHeight;

	sprintf(strBuf, "positioning: %d rotating %d goalVec: (%.3f, %.3f, %.3f) dist: %.3f angFwd: %.3f angRt: %.3f",
			fStillPositioning, fStillRotating, fGoalVec.fX, fGoalVec.fY, fGoalVec.fZ, fDistance, fAngForward, fAngRight);
	debugTxt.DrawString(x, y, strBuf);
	y += lineHeight;
	
	sprintf(strBuf, " distFwd: %.3f distRt: %.3f shufRange: %.3f sidAngle: %.3f sidRange: %.3f, fMinWalk: %.3f",
			fDistForward, fDistRight, fShuffleRange, fMaxSidleAngle, fMaxSidleRange, fMinFwdAngle);
	debugTxt.DrawString(x, y, strBuf);
	y += lineHeight;
}

void plAvTaskSeek::DumpToAvatarLog(plArmatureMod *avatar)
{
	plStatusLog *log = plAvatarMgr::GetInstance()->GetLog();
	char strBuf[256];
	avatar->GetMoveKeyString(strBuf);
	log->AddLine(strBuf);

	sprintf(strBuf, "    duration: %.2f pos: (%.3f, %.3f, %.3f) goalPos: (%.3f, %.3f, %.3f) ",
			hsTimer::GetSysSeconds() - fStartTime,
			fPosition.fX, fPosition.fY, fPosition.fZ, fSeekPos.fX, fSeekPos.fY, fSeekPos.fZ);
	log->AddLine(strBuf);
	
	sprintf(strBuf, "    positioning: %d rotating %d goalVec: (%.3f, %.3f, %.3f) dist: %.3f angFwd: %.3f angRt: %.3f",
			fStillPositioning, fStillRotating, fGoalVec.fX, fGoalVec.fY, fGoalVec.fZ, fDistance, fAngForward, fAngRight);
	log->AddLine(strBuf);

	sprintf(strBuf, "    distFwd: %.3f distRt: %.3f shufRange: %.3f sidAngle: %.3f sidRange: %.3f, fMinWalk: %.3f",
			fDistForward, fDistRight, fShuffleRange, fMaxSidleAngle, fMaxSidleRange, fMinFwdAngle);
	log->AddLine(strBuf);
}

/////////////////////////////////////////////////////////////////////////////////////////
//
// LOCALS
//
/////////////////////////////////////////////////////////////////////////////////////////

// QuatAngleDiff ------------------------------------
// --------------
float QuatAngleDiff(const hsQuat &a, const hsQuat &b)
{
	hsScalar theta;		/* angle between A and B */
	hsScalar cos_t;		/* sine, cosine of theta */

	/* cosine theta = dot product of A and B */
	cos_t = a.Dot(b);

	/* if B is on opposite hemisphere from A, use -B instead */
 	if (cos_t < 0.0)
	{
		cos_t = -cos_t;
	} 

	// Calling acos on 1.0 is returning an undefined value. Need to check for it.
	hsScalar epsilon = 0.00001;
	if (hsABS(cos_t - 1.f) < epsilon)
		return 0;

	theta	= hsACosine(cos_t);
	return theta;
}

// MakeMatrixUpright -------------------------------------------
// ------------------
// ensure that the z axis of the given matrix points at the sky.
// does not orthonormalize
// man, I could have sworn I did this somewhere else...
void MakeMatrixUpright(hsMatrix44 &mat)
{
	mat.fMap[0][2] = 0.0f;			// eliminate any z in the x axis
	mat.fMap[1][2] = 0.0f;			// eliminate any z in the y axis
	mat.fMap[2][0] = 0.0f; mat.fMap[2][1] = 0.0f; mat.fMap[2][2] = 1.0f;	// z axis = pure sky
}