CWE-ou-minkata/Sources/Plasma/PubUtilLib/plAvatar/plAvTaskSeek.h

/*==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==*/
#ifndef PLAVTASKSEEK_INC
#define PLAVTASKSEEK_INC
#pragma once

#include "plAvatarTasks.h"
#include "hsQuat.h"
#include "hsGeometry3.h"

class plArmatureMod;
class plArmatureBrain;
class plAvBrainHuman;
class plSceneObject;

// PLAVTASKSEEK
class plAvTaskSeek : public plAvTask
{
public:
	static hsBool fLogProcess;
		
	enum State {
		kSeekRunNormal,
		kSeekAbort,
	};
	UInt8 fState;

	enum 
	{
		kSeekFlagUnForce3rdPersonOnFinish	= 0x1,
		kSeekFlagForce3rdPersonOnStart		= 0x2,
		kSeekFlagNoWarpOnTimeout			= 0x4,
		kSeekFlagRotationOnly				= 0x8,
	};

	plAvTaskSeek();
	plAvTaskSeek(plKey target);
	plAvTaskSeek(plAvSeekMsg *msg);
	plAvTaskSeek(plKey target, plAvAlignment align, const char *animName, bool moving);

	void SetTarget(plKey target);
	void SetTarget(hsPoint3 &pos, hsPoint3 &lookAt);

	/** Initiate the task; make sure we're running on the right type of brain, save off
		user input state, and turn off any other running behaviors.*/
	virtual hsBool Start(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed);

	/** Progress towards the goal using a combination of walking and cheating-via-sliding.
		Returns true if we're still working on it; false if we're done. */
	
	virtual hsBool Process(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed);

	/** Restore user input state, etc. */
	virtual void Finish(plArmatureMod *avatar, plArmatureBrain *brain, double time, hsScalar elapsed);
	
	/** clear our target, and when we try to eval, we'll just finish */
	virtual void LeaveAge(plArmatureMod *avatar);

	/** Spew "useful" information to the game screen. Used when Avatar.Debug is active. */
	virtual void DumpDebug(const char *name, int &x, int&y, int lineHeight, char *strBuf, plDebugText &debugTxt);

	void DumpToAvatarLog(plArmatureMod *avatar);
		
	CLASSNAME_REGISTER( plAvTaskSeek );
	GETINTERFACE_ANY( plAvTaskSeek, plAvTask );

protected:

	/////////////////////////////////////////////////////////////////////////////////////
	//
	// METHODS
	//
	/////////////////////////////////////////////////////////////////////////////////////
	
	/** Called by constructors */
	void IInitDefaults();

	/** Make some observations about our current relation to our target.
		Done every frame. */
	hsBool IAnalyze(plArmatureMod *avatar);

	/** Progress towards the goal. We get as close as we can by just pushing the same
		buttons as the user (forward, turn, etc.) when we're really close we slide
		around a bit so we can wind up on the *exact* initial orientation. */
	hsBool IMoveTowardsGoal(plArmatureMod *avatar, plAvBrainHuman *brain, double time, hsScalar elapsed);

	/** Okay, we're in the pure cheating mode now. Try to wrap it up;
		returns true when it's finally there. */
	bool ITryFinish(plArmatureMod *avatar, plAvBrainHuman *brain, double time, hsScalar elapsed);

	/** Final cheating for position */
	hsBool IFinishPosition(hsPoint3 &newPosition, plArmatureMod *avatar, plAvBrainHuman *brain,
						   double time, hsScalar elapsed);

	/** Final cheating for rotation */
	hsBool IFinishRotation(hsQuat &newRotation, plArmatureMod *avatar, plAvBrainHuman *brain,
						   double time, hsScalar elapsed);

	/** If our target's moving, cache its new position and orientation for later math */
	hsBool IUpdateObjective(plArmatureMod *avatar);

	/////////////////////////////////////////////////////////////////////////////////////
	//
	// VARS
	//
	/////////////////////////////////////////////////////////////////////////////////////

	plSceneObject * fSeekObject;			// the seek target....	
	hsQuat fSeekRot;						// The (current) orientation of our objective
	hsPoint3 fSeekPos;						// The (current) position of our objective
	bool fMovingTarget;						// do we check our target's position each frame?
	// animation alignment:
	// sometimes your seek position depends on a particular animation
	// for example, you can say "find a good start point so that you can play this animation
	// and have your handle wind up here" i.e: aligntype = "kAlignHandleAnimEnd"
	plAvAlignment	fAlign;		// how to line up with the seek point
	const char * fAnimName;					// an (optional) anim to use to line up our target
											// so you can say "seek to a place where your hand
											// will be here after you play animation foo"

	hsPoint3 fPosition;						// our current position
	hsQuat fRotation;						// our current rotation
	
	// These are set to true once we EVER get close enough to the goal, so that if we fall out
	// of range from the anim blend out, we don't later try and correct again, and get in a fun
	// little back-and-forth loop.
	hsBool fPosGoalHit;
	hsBool fRotGoalHit;

	hsBool fStillPositioning;				// haven't yet reached the final position
	hsBool fStillRotating;					// haven't yet reached the final orientation
	
	hsVector3 fGoalVec;						// vec from us to the goal
	hsScalar fDistance;						// how far to the goal?
	hsScalar fAngForward;					// 1.0 = goal is forward; -1.0 = goal is backward
	hsScalar fAngRight;						// 1.0 = goal is directly right; -1.0 = goal is directly left
	hsScalar fDistForward;					// distance straight forward to goal plane
	hsScalar fDistRight;					// distance straight right to goal plane

	hsScalar fShuffleRange;
	hsScalar fMaxSidleAngle;		// in right . goal
	hsScalar fMaxSidleRange;		// in feet
	hsScalar fMinFwdAngle;			// in fwd . goal
	hsScalar fMaxBackAngle;			// in fwd . goal
	
	double	 fStartTime;
	UInt8	 fFlags;
	plKey	 fNotifyFinishedKey;	// Send a message to this key when we're done.
};

#endif