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

Go to the documentation of this file.

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

class ScoutFSM : public UnitBehavior<ScoutFSM>
{
protected:
  class GoToLocation;
  class Scouting;
  friend class GoToLocation;
  friend class Scouting;

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

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

  protected:
    ScoutFSM* const m_fsm;
  };


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

    void onTimer()
    {
      m_transitionToScouting.testTransition(boost::make_tuple());
    }

    typedef SCHEDULER_EVENT(GoToLocation, onTimer) TimerEvent;

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

        protected:
    //Variable
    //BWAPI::Position m_location;
    Location* const m_location;

    // Actions
                layer1::MoveAction m_moveAction;

    //temp event and transition
    TimerEvent m_locationReached;
                Transition<GoToLocation, UnitReachedLocation, RaiseScoutArrived, Scouting> m_transitionToScouting;
  };

  class Scouting : public BehaviorState<ScoutFSM, Scouting>
  {
  public:
    Scouting(ScoutFSM& behavior, Location* location);
    void onEnterImpl();
    void onExitImpl() {}

    void onTimer()
    {
      m_transitionToSelf.testTransition(boost::make_tuple());
    }

    typedef SCHEDULER_EVENT(Scouting, onTimer) TimerEvent;

    typedef boost::tuple<
        TimerEvent&
      > Events;
                const Events m_events;
    
    typedef boost::tuple<
        Transition<Scouting, NoCondition, NoTransitionAction, Scouting>&
      > Transitions;
                const Transitions m_transitions;

  protected:
    // Variables
    int m_maxX;
    int m_maxY;
    Location* const m_location;
    BWTA::Region* m_region;  //TODO: temp... switch to location!

    // Actions
    layer1::MoveAction m_moveAction;

    // Transitions
    TimerEvent m_newMove;
    Transition<Scouting, NoCondition, NoTransitionAction, Scouting> m_transitionToSelf;

    //Other
    BWAPI::Position getFleeDestination(double fleeX, double fleeY);
  };

public:
  ScoutFSM(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_scoutingState(*this, location)
    , m_goToLocationState(*this, location)
    , m_location(location)
    , m_states(m_goToLocationState, m_scoutingState)
  {
    //m_baseRegion = BWTA::getRegion(enemyCC.x()/TILE_SIZE, enemyCC.y()/TILE_SIZE);
  }

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

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

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

    DECLARE_EVENT1(OnLocationScouted, PrimitiveLocation*);    //TODO: Not yet implemented
    OnLocationScouted& getLocationScoutedEvent() const { return m_locationScoutedEvent; }

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

  // Arguments

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

  // States
  GoToLocation m_goToLocationState;
  Scouting m_scoutingState;
};