SPAR/AIModule/SparAIModule/DecisionMaking/Layer1Reactive/FSM/Behaviors/ObsScout.h

Go to the documentation of this file.

#pragma once
#include "../UnitBehavior.h"
#include "../BehaviorState.h"
#include "../Arbitrator.h"
#include "../Conditions/ReachedDestination.h"

class ObsScout : public UnitBehavior<ObsScout>
{
protected:
  class GoToLocation;
  class Reached;
  friend class GoToLocation;
  friend class Reached;

  class RaiseScoutArrived : public TransitionAction
  {
  public:
    RaiseScoutArrived(ObsScout* const fsm)
      : m_fsm(fsm){}

    void execute()
    {
      m_fsm->getScoutArrivedEvent().raise();
    }

  protected:
    ObsScout* const m_fsm;
  };


  //State where the scout goes to the requested location
  class GoToLocation : public BehaviorState<ObsScout, GoToLocation>
  {
  public:
    GoToLocation(ObsScout& behavior, Location* location);
    void onEnterImpl();
    void onExitImpl(){}

    void onTimer();

    typedef SCHEDULER_EVENT(GoToLocation, onTimer) TimerEvent;

    typedef boost::tuple<
          TimerEvent&
          > Events;
                Events m_events;
    
                typedef boost::tuple<
          Transition<GoToLocation, UnitReachedDestination, RaiseScoutArrived, Reached>&
                  > Transitions;
                Transitions m_transitions;

        protected:
    //Variable
    Location* const m_location;
    int cpt;
    double lastDistance;

    // Actions
                layer1::MoveAction m_moveAction;

    //temp event and transition
    TimerEvent m_locationReached;
                Transition<GoToLocation, UnitReachedDestination, RaiseScoutArrived, Reached> m_transitionToReached;
  };

  class Reached : public BehaviorState<ObsScout, Reached>
  {
  public:
    Reached(ObsScout& behavior);
    void onEnterImpl();
    void onExitImpl(){}

    typedef boost::tuple<> Events;
                Events m_events;
    
                typedef boost::tuple<> Transitions;
                Transitions m_transitions;
  };


public:
  ObsScout(const Process* parent, unsigned int initialPriority, Location* location, BWAPI::Unit* scoutingUnit)
    : UnitBehavior(parent, initialPriority, scoutingUnit)
    , IUnitBehavior(parent, initialPriority, scoutingUnit)
    , IBehavior(parent, initialPriority)
    , IFSM(parent)
    , Process(parent)
    , m_reachedState(*this)
    , m_goToLocationState(*this, location)
    , m_location(location)
    , m_states(m_goToLocationState, m_reachedState)
  {
  }

  virtual std::string getName() const
  {
    return "ObsScout (" + getObjectDescription(m_unit) + ")";
  }

  typedef boost::tuple<
      GoToLocation&,
      Reached&
    > States;
        const States m_states;

  DECLARE_EVENT(OnScoutArrived);                           
  OnScoutArrived& getScoutArrivedEvent() const { return m_scoutArrivedEvent; }

protected:
  virtual void executeImpl()
  {
    UnitBehavior::executeImpl();
    m_goToLocationState.onEnter();
  }

  // Arguments

  // Variables
  //BWAPI::Position m_enemyCC;
  //BWTA::Region* m_baseRegion;
  Location* const m_location;
  
  // Events
  EVENT(OnScoutArrived) m_scoutArrivedEvent;

  // States
  GoToLocation m_goToLocationState;
  Reached m_reachedState;
  
};