PRATerrain.H

Go to the documentation of this file.

#ifndef PRATERRAIN_H
#define PRATERRAIN_H

// $Id: PRATerrain.H 5279 2007-06-23 02:49:08Z mburo $

// This is an ORTS file 
// (c) Michael Buro, Sami Wagiaalla, David Deutscher
// licensed under the GPL
// Most (if not all) of the code is taken from SimpleTerrain.
// 

#include "TerrainBasicImp.H"
#include "TerrainBase.H"
#include <boost/shared_ptr.hpp>
#include "Random.H"
#include "Global.H"


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// fixme: Transfer this functionality into ST_Task, this is a heritage from before
// the TerrainBase interface.

// struct UnitPath
// {
//   const Object *obj;
//   Vector<TerrainBase::Loc> path;
//   TerrainBase::Loc goal;
//   int current_target; // index of current way point in path vector
//   bool no_orders_yet; // true 
//   int collision_step; // this is incremented while solving unexpected stops
//   uint4 wakeup;       // if SDL_GetTicks() >= wakeup then this UnitPath is not
//   // sleeping ie not to be skipped over.
//   TerrainBase::Loc spot;           // spot of the last unexpected collision

//   UnitPath(const Object *obj_, const Vector<TerrainBase::Loc> &path_);
//   ~UnitPath() {};

//   void mark_spot(const TerrainBase::Loc &p) { spot = p; };
//   void sleep(int time) { wakeup = SDL_GetTicks() + time; };
//   bool sleeping() const { return wakeup > SDL_GetTicks(); };

//   bool is_intersect(const TerrainBase::Segment &) const;
// };


/// The internal data complementing Task data:
struct PR_Task {
  TerrainBase::Task task;
  bool isPending;
  bool isFailed;
  bool noPathFound;
  const Object *obj;
  Vector<TerrainBase::Loc> path;
  sint4 current_target;
  sint4 collision_step;
  TerrainBase::Loc motion_vector;
  
  PR_Task(const TerrainBase::Task& task_);
  PR_Task(const PR_Task& other) 
    : task(other.task), isPending(other.isPending),
      isFailed(other.isFailed), noPathFound(other.noPathFound), obj(other.obj),
      path(other.path), current_target(other.current_target),
      collision_step(other.collision_step), motion_vector(other.motion_vector) {};
  void init_path(const Object *obj_, const Vector<TerrainBase::Loc> &path_);
  //~ST_Task() { delete path; };
  bool isValid() const { return !isPending && !isFailed && !noPathFound && path.size()>0; };
private:
  PR_Task operator=(const PR_Task& other);
};

struct Vec_2D{
  sint4 x;
  sint4 y;
  Vec_2D(sint4 x_, sint4 y_) :  x(x_), y(y_){};
  Vec_2D(const Vec_2D &other) :  x(other.x), y(other.y){};
  Vec_2D operator+(const Vec_2D &other) const;
  Vec_2D operator-(const Vec_2D &other) const;
  Vec_2D project_onto(const Vec_2D &other) const;
  sint4 dot_prod(const Vec_2D &other) const;
  real8 length() const;
};


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

<<<<<<< PRATerrain.H
/// A Simple implementation of the TerrainBase interface.
/** This TerrainBase implementation is using the PRAstar algorithm.
    Limitations:
    - Only considers a single Obj per Task (ignoring the second and on obj_ids).
    - Does not currently work for IN_AIR units
*/
class PR_Terrain : public TerrainBasicImp<PR_Task> {
  typedef TerrainBase::Loc      Loc;
  typedef TerrainBase::Segment  Segment;  
  typedef TerrainBase::Task     Task;
public:
  PR_Terrain(){};
  virtual ~PR_Terrain() {};

  /// add command-line options specific to this implementation, using static methods of class Options
  static void add_options(void);

  //---------------------------------------------------------------------
  /// \name Implementation of relevant parts of the TerrainBase interface
  //---------------------------------------------------------------------
  //@{
  virtual void init(sint4 tiles_x_, sint4 tiles_y_, sint4 tile_points_, sint4 me, sint4 neutral);

  virtual void add_obj(const Object *obj);
  virtual void update_obj(const Object *obj);
  virtual void remove_obj(const Object *obj);
  virtual void add_segments(const Vector<TerrainBase::Segment> &s);

  //    virtual void add_task(const Task &task);
  virtual void cancel_task(const Object *obj);
  virtual void remove_task(TaskId tid);

  virtual void execute_tasks(Vector<MoveCmd> &cmds, Vector<StatusMsg> &msgs);
  virtual bool plan_tasks(void);

  virtual real8 find_path(const Loc &l1, const Loc &l2, sint4 radius, Path &path);
  //@}
  //---------------------------------------------------------------------

protected:
  bool calculate_vector(const Object *obj, const TerrainBase::Loc &target, TerrainBase::Loc &output);
  //void find_obstacles(const Object *obj, Vector<const Object*> &output);
  void restrict_vector(const Vec_2D &target_vec, Vec_2D &vec);
  void normalize_vector(Loc &vec, const real8 &length);
  Loc get_point_repulsion(const Object *moving_obj, const Loc &loc, sint4 radius = 0);
  Loc get_line_repulsion(const Object *moving_obj, const Segment &seg);
  bool plan_pending_task(void);
  bool plan_failed_task(void);
  bool is_at_location(const Object *obj, const Loc &target);
  bool is_at_goal(const Object *obj, const TerrainBase::Task  &task);
  bool is_near_waypoint(const Object *obj, const Loc &wp);
  bool is_in_range(const Object *moving_obj, const Object *goal_obj);
  void invalidate_paths(const Vector<Segment> &segments);
 
=======
  /// A Simple implementation of the TerrainBase interface.
  /** This TerrainBase implementation is using the PRAstar algorithm.
      Limitations:
      - Only considers a single Obj per Task (ignoring the second and on obj_ids).
      - Does not currently work for IN_AIR units
  */
  class PR_Terrain : public TerrainBasicImp<ST_Task>
  {
  public:
    PR_Terrain() {};
    virtual ~PR_Terrain() {};

    /// add command-line options specific to this implementation, using static methods of class Options
    static void add_options(void);

    //---------------------------------------------------------------------
    /// \name Implementation of relevant parts of the TerrainBase interface
    //---------------------------------------------------------------------
    //@{
    virtual void init(sint4 tiles_x_, sint4 tiles_y_, sint4 tile_points_);

    virtual void add_obj(const Object *obj);
    virtual void update_obj(const Object *obj);
    virtual void remove_obj(const Object *obj);
    virtual void add_segments(const Vector<TerrainBase::Segment> &s);

    virtual void cancel_task(const Object *obj);
    virtual void remove_task(TaskId tid);

    virtual void execute_tasks(Vector<MoveCmd> &cmds, Vector<StatusMsg> &msgs);
    virtual bool plan_tasks(sint4 max_time = 0);

    virtual real8 find_path(const Loc &l1, const Loc &l2, sint4 radius, Path &path);
    //@}
    //---------------------------------------------------------------------


  private:
    // prevent copying as we currently don't need it.
    PR_Terrain(const PR_Terrain& other);
    PR_Terrain operator=(const PR_Terrain& other);

    /// The mechanics of world representation and PRA* path-finding
    class PRAEngine; friend class PR_Terrain::PRAEngine;

    //---------------------------------------------------------------------
    /// \name Internal accessories
    //---------------------------------------------------------------------
    //@{
    /** Perform PF for a single pending task, and insert results to data structures. 
        Return true iff did some planning. */
    bool plan_pending_task(void);
    /** Perform PF for a single failed task, and insert results to data structures. 
        Return true iff did some planning. */
    bool plan_failed_task(void);
    /// Invalidate existing paths that intersect a given new boundary.
    void invalidate_paths(const Vector<Segment> &segments);
    /** Test if the object is at the given location, 
        accounting for a 1-tick look-ahead for moving objects. */
    static bool is_at_location(const Object* obj, const Loc& target);
    /** Test if the object is at the goal of the given task, implementing 
        (some) of the various definitions of 'goal'. */
    static bool is_at_goal(const Object* obj, const Task& task);
    /** Test if the object is within firing range */
    static bool is_in_range(const Object* moving_obj, const Object *goal_obj);
>>>>>>> 1.3
  
  void add_move_command(const Object *obj, const Loc &motion_vec, Vector<TerrainBase::MoveCmd> &cmds);
  
private:
  static sint4 round(real8 real);
  // prevent copying as we currently don't need it.
  PR_Terrain(const PR_Terrain& other);
  PR_Terrain operator=(const PR_Terrain& other);

  /// The mechanics of world representation and PRA* path-finding
  class PRAEngine; friend class PR_Terrain::PRAEngine;


  //@}
  //---------------------------------------------------------------------

  boost::shared_ptr<PRAEngine> pfEngine; ///< The internal Path Finding engine
  std::set<const Object*> objsToStop;
  std::map<const Object*, Loc> objects;
  Vector<Segment> segments;
  static const sint4 FIELD_RANGE_MULTIPLIER = 3;
  static const sint4 ATTRACTOR_FORCE = 32;
  static const sint4 REPULSOR_BASELINE = 128;
  static const sint4 WAYPOINT_PROX = 2;

};



#endif