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

Go to the documentation of this file.

#pragma once
#include "../GroupBehavior.h"
#include "../BehaviorState.h"

class Move : public GroupBehavior<Move>
{
protected:
  class Goto;
  friend class Goto;

  class Goto : public BehaviorState<Move, Goto>
  {
  public:
    Goto(Move& behavior, size_t refreshDelay);
    void onEnterImpl();
    void onExitImpl()
    {}

    void onUnitAddedToGroup(BWAPI::Unit* unit);
    void onUnitRemovedFromGroup(BWAPI::Unit* unit);

    void onTimer()
    {
      ++m_tickCounter;

      std::set<BWAPI::Unit*>::iterator nextIt;
      std::set<BWAPI::Unit*>::iterator it = m_context.unitsInMotion.begin();
      
      std::set<BWAPI::Unit*>::iterator toDelete = m_context.unitsInMotion.end();
      
      while(it != m_context.unitsInMotion.end())
      {
        nextIt = it;
        ++nextIt;

        BWAPI::Position toDelete2 = (*it)->getPosition();
        if((*it)->getPosition().getApproxDistance(m_context.m_destination) <= static_cast<int>(m_context.m_maxDistance))
        {
          BWAPI::Unit* unit = *it;
          m_context.unitsInMotion.erase(it);
          m_context.unitsAtDestination.insert(unit);
          m_context.getUnitAtDestinationEvent().raise(unit);
        }
        it = nextIt;
      }

      if(m_tickCounter >= m_context.m_nbTickBetweenAction)
      {
        m_tickCounter = 0;
        Layer1FSM::getInstance().getArbitrator().submitAction(m_context.getGroup(), m_moveAction, Arbitration::ActionImportance(*this));
      }
    }

    typedef SCHEDULER_EVENT(Goto, onTimer) TimerEvent;

    typedef boost::tuple<
      TimerEvent&
    > Events;
    const Events m_events;

    typedef boost::tuple<> Transitions;
                const Transitions m_transitions;

  protected:
    // Variables
    size_t m_tickCounter;

    // Actions
    layer1::MoveAction m_moveAction;

    // Transitions
    TimerEvent m_timerEvent;
  };

public:
  Move(const Process* parent, unsigned int initialPriority, const PersistentUnitGroup* group,
    BWAPI::Position destination, size_t maxDistance = 128, size_t refreshRate = 24, size_t nbTickBetweenAction = 1)
    : GroupBehavior(parent, initialPriority, group)
    , IGroupBehavior(parent, initialPriority, group)
    , IBehavior(parent, initialPriority)
    , IFSM(parent)
    , Process(parent)
    , m_gotoState(*this, refreshRate)
    , m_destination(destination)
    , m_destinationTP(destination.x()/TILE_SIZE, destination.y()/TILE_SIZE)
    , m_states(m_gotoState)
    , m_nbTickBetweenAction(nbTickBetweenAction)
    , m_maxDistance(maxDistance)
  { }

  Move(const Process* parent, unsigned int initialPriority, const PersistentUnitGroup* group,
    BWAPI::TilePosition destination, size_t maxDistance = 128, size_t refreshRate = 24, size_t nbTickBetweenAction = 1)
    : GroupBehavior(parent, initialPriority, group)
    , IGroupBehavior(parent, initialPriority, group)
    , IBehavior(parent, initialPriority)
    , IFSM(parent)
    , Process(parent)
    , m_gotoState(*this, refreshRate)
    , m_destination(destination.x()*TILE_SIZE + TILE_SIZE/2, destination.y()*TILE_SIZE + TILE_SIZE/2)
    , m_destinationTP(destination)
    , m_states(m_gotoState)
    , m_nbTickBetweenAction(nbTickBetweenAction)
    , m_maxDistance(maxDistance)
  { }
  
  virtual std::string getName() const
  {
    return "Moving at " + getObjectDescription(m_destination);//.x() + ", " + m_destination.y();
  }

  virtual void onUnitAddedToGroup(void*, BWAPI::Unit* unit)
  {
    assert(!unit->getType().isBuilding());
    if(m_currentState == &m_gotoState)
      m_gotoState.onUnitAddedToGroup(unit);
  }

  virtual void onUnitRemovedFromGroup(void*, BWAPI::Unit* unit)
  {
    if(m_currentState == &m_gotoState)
      m_gotoState.onUnitRemovedFromGroup(unit);
    if(getGroup()->empty())
      terminate(Success);
  }

  typedef boost::tuple<
      Goto&
    > States;
        const States m_states;

  DECLARE_EVENT1(OnUnitAtDestination, BWAPI::Unit*);
  OnUnitAtDestination& getUnitAtDestinationEvent() const { return m_unitAtDestination; }
  EVENT(OnUnitAtDestination) m_unitAtDestination;

protected:
  virtual void executeImpl()
  {
    GroupBehavior::executeImpl();
    m_gotoState.onEnter();
  }

  Goto m_gotoState;

  BWAPI::Position m_destination;
  BWAPI::TilePosition m_destinationTP;
  const size_t m_nbTickBetweenAction;
  const size_t m_maxDistance;

  //TODO: Change to safeSet
  std::set<BWAPI::Unit*> unitsInMotion;
  std::set<BWAPI::Unit*> unitsAtDestination;
};