//-----------------------------------------------------------------------------
//
//  $Logfile:: /Code/DLLs/game/actor_locomotion.h                             $
// $Revision:: 22                                                             $
//   $Author:: Steven                                                         $
//     $Date:: 10/13/03 8:53a                                                 $
//
// Copyright (C) 2001 by Ritual Entertainment, Inc.
// All rights reserved.
//
// This source may not be distributed and/or modified without
// expressly written permission by Ritual Entertainment, Inc.
//
//
// DESCRIPTION:
// Motion and Movement Related Classes
//

class MovementSubsystem;
class LocomotionController;

#ifndef __ACTOR_LOCOMOTION_H__
#define __ACTOR_LOCOMOTION_H__

#include "actorincludes.h"
#include "path.h"

class LocomotionController
{
public:
  LocomotionController();

  explicit LocomotionController(Actor *actor)
  {
    //Initialize our Actor
    if (actor)
      act = actor;
    else
      gi.Error(ERR_DROP, "LocomotionController::LocomotionController -- actor is NULL");

    _init();
  }

  virtual ~LocomotionController();

  void Begin();
  void Evaluate();
  void End();

  // Accessors & Mutators
  void						SetMovementStyle(MovementStyle style);
  MovementStyle				GetMovementStyle();

  // Archiving
  virtual void				Archive(Archiver &arc);
  void DoArchive(Archiver &arc, Actor *actor);

protected:
  void						_init();

private:
  Actor						*act;
  MovementStyle				_movementStyle;
  FollowPath					_chase;

};

//============================
// Class MovementSubsystem
//============================
//
// Encapsulates movement related data and functionality for the actor
//
class MovementSubsystem
{
public:
  MovementSubsystem();
  explicit MovementSubsystem(Actor *actor);
  virtual ~MovementSubsystem();

  qboolean					CanMoveTo(const Vector &pos);
  bool						CanWalkTowardsPoint(const Vector &goalPoint, const int mask = -1);
  qboolean					CanWalkTo(const Vector &pos, float bounding_box_extra = 0, int entnum = ENTITYNUM_NONE, const int mask = -1);
  qboolean					CanWalkToFrom(const Vector &origin, const Vector &pos, float bounding_box_extra = 0, int entnum = ENTITYNUM_NONE, const int mask = -1);
  void						Accelerate(const Vector &steering);
  void						CalcMove(void);
  stepmoveresult_t			WaterMove(void);
  stepmoveresult_t			AirMove(void);
  stepmoveresult_t			IsMoveValid(trace_t &horizontalTrace, trace_t &verticalTrace, const Vector &moveBegin, const Vector &moveEnd);
  stepmoveresult_t			TryMove(void);
  stepmoveresult_t			SimpleMove(const bool stickToGround);

  qboolean					Push(const Vector &dir);
  void						CheckWater(void);
  float						JumpTo(PathNode * goal, const Angle angle = 45.0f);
  float						JumpTo(Entity * goal, const Angle angle = 45.0f);
  float						JumpTo(const Vector &targ, const Angle angle = 45.0f);
  Vector SteerTowardsPoint(const Vector &targetPosition, const Vector &targetVelocity, const Vector &moveDirection, const float maxSpeed = 1.0f, const bool adjustSpeed = false);


  // Archiving
  virtual void				Archive(Archiver &arc);
  void						DoArchive(Archiver &arc, Actor *actor);

  // Accessors and Mutators
  void						setStep(const Vector &step);
  const Vector &				getStep() const;

  void						setLastMove(stepmoveresult_t lastMove);
  stepmoveresult_t			getLastMove();

  void						setMove(const Vector &move);
  Vector						getMove();

  void						setMoveDir(const Vector &moveDir);
  Vector						getMoveDir();

  void						setMoveVelocity(const Vector &moveVelocity);
  Vector						getMoveVelocity();

  void						setAnimDir(const Vector &animDir);
  Vector						getAnimDir();

  void						setDiveDir(const Vector &diveDir);
  Vector						getDiveDir();

  void						setStartPos(const Vector &startPos);
  Vector						getStartPos();

  void						setTotalLen(float totalLen);
  float						getTotalLen();

  void						setTurnSpeed(float turnSpeed);
  float						getTurnSpeed();

  void						setForwardSpeed(float forwardSpeed);
  float						getForwardSpeed();

  void						setMoveSpeed(float moveSpeed);
  float						getMoveSpeed();

  void						setPath(Path* path);
  Path*						getPath();

  void						setFlipLegs(qboolean flip);
  qboolean					getFlipLegs();
  void						flipLegs();

  void						setMovingBackwards(qboolean backwards);
  qboolean					getMovingBackwards();

  void						setFaceEnemy(bool faceEnemy);
  bool						getFaceEnemy();

  void						setAdjustAnimDir(bool adjustAnimDir);
  bool						getAdjustAnimDir();


  void						setMovementType(MovementType_t mType);
  MovementType_t				getMovementType();

  void						SetStickToGround(const bool stick);
  bool GetStickToGround(void) const;

  void						setUseCodeDrivenSpeed(bool useCode);
  bool						getUseCodeDrivenSpeed();

  Entity*						getBlockingEntity();
  void						clearBlockingEntity();


protected: // Functions

  Vector						_getRealDestinationPosition(const Vector &pos) const;
  stepmoveresult_t			_noGravityTryMove(const Vector &oldorg, trace_t &verticalTrace) const;
  trace_t						_feetWidthTrace(const Vector &currentLoc, const Vector &bottom, const Vector &endPos, const int mask) const;
  float						_getTraceStep() const;
  void						_saveGroundInformation(trace_t &trace);
  qboolean					_isBlockedByDoor(trace_t &trace) const;
  qboolean					_canMoveSimplePath(const Vector &mins, const Vector &maxs, const Vector &pos) const;
  qboolean					_isBlockedByFall(trace_t &trace) const;
  qboolean					_allowFall() const;
  qboolean					_shouldTryMove() const;
  qboolean					_checkHaveGroundEachStep(const Vector &start, const Vector &end, const Vector &test_mins, const Vector &test_maxs, const int mask = -1) const;
  void						_init();

private: // Member Variables
  static Vector				_step;

  stepmoveresult_t			_lastmove;
  float						_forwardspeed;
  PathPtr						_path;
  Vector						_move;
  Vector						_movedir;
  float						_movespeed;
  Vector						_movevelocity;
  float						_totallen;
  float						_turnspeed;
  Vector						_animdir;
  Vector						_divedir;
  Vector						_startpos;
  qboolean					_fliplegs;
  qboolean					_movingBackwards;
  bool						_faceEnemy;
  bool						_adjustAnimDir;
  MovementType_t				_movementType;
  bool						_stickToGround;
  bool						_useCodeDrivenSpeed;

  Actor						*act;
  EntityPtr					_blockingEntity;

};

inline void MovementSubsystem::setUseCodeDrivenSpeed(bool useCode)
{
  _useCodeDrivenSpeed = useCode;
}

inline bool MovementSubsystem::getUseCodeDrivenSpeed()
{
  return _useCodeDrivenSpeed;
}

#endif /* __ACTOR_LOCOMOTION_H__ */