SPAR/AIModule/SparAIModule/DecisionMaking/Layer1Reactive/FSM/Behaviors/EngageEnemies/GroupAttack.h

Go to the documentation of this file.

#pragma once
#include "EngageEnemies.h"
#include "../../BehaviorState.h"
#include "../../Conditions/IsAttacking.h"
#include "../../Conditions/ReachedDestination.h"
#include "../../../../../PersistentUnitGroup.h"
#include "UnitAttackFSM.h"
#include <BWAPI.h>
#include <hash_map>

//class UnitAttackFSM;

//TODO: Needs to be cleaned!  Units now select their own target, so select target is no longer useful... but it's what allows the machine to switch from engaging to moving...
//maybe this machine is not required anymore... only individual FSMs?
//Observer logic should be put in another file, this class is getting messy

class GroupAttack : public EngageEnemies<GroupAttack>
{
protected:
  class GoToLocation;
  class Engaging;
  class Terminate;

protected:
  struct BehaviorWrapper
  {
    IUnitAttackFSM* behavior;
    Behavior::OnTerminate::SubscriberID subscriberId;
  };

  // GoToLocation state /////////////////////////////////////////////////////////
  class GoToLocation : public BehaviorState<GroupAttack, GoToLocation>
  {
  public:
    GoToLocation(GroupAttack& behaviour, Location* m_location);
    void onEnterImpl();

    void onExitImpl() {}

    void unitAdded(BWAPI::Unit* unit);

    void onTimer();

    typedef SCHEDULER_EVENT(GoToLocation, onTimer) TimerEvent;

    typedef boost::tuple<
          TimerEvent&
          > Events;
                Events m_events;
    
                typedef boost::tuple<
          Transition<GoToLocation, GroupIsAttacking, NoTransitionAction, Engaging>&,
          Transition<GoToLocation, GroupReachedDestinationLocation<PersistentUnitGroup>, NoTransitionAction, Terminate>&
                  > Transitions;
                Transitions m_transitions;

  
  private:
    Location* m_location;
    int time;

    TimerEvent m_isAttacking;
                Transition<GoToLocation, GroupIsAttacking, NoTransitionAction, Engaging> m_transitionToEngaging;
    Transition<GoToLocation, GroupReachedDestinationLocation<PersistentUnitGroup>, NoTransitionAction, Terminate> m_transitionToTerminate;
  };

  // Engaging state ////////////////////////////////////////////////////////////
  class Engaging : public BehaviorState<GroupAttack, Engaging>
  {
  public:
    Engaging(GroupAttack& behavior);
    void onEnterImpl();
    void onExitImpl() {}
    
    void onTimer();

    void unitAdded(BWAPI::Unit* unit);

    void onSubBehaviorTerminated(void* data);

  private:
    bool selectTarget();

    typedef SCHEDULER_EVENT(Engaging, onTimer) TimerEvent;
    TimerEvent m_enemySighted;

    EVENT_HANDLER(Engaging, onSubBehaviorTerminated) m_onSubBehaviorTerminated;
    Transition<Engaging, NoCondition, NoTransitionAction, GoToLocation> m_transitionToGoTo;

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

    typedef boost::tuple<
          Transition<Engaging, NoCondition, NoTransitionAction, GoToLocation>& 
      > Transitions;
    const Transitions m_transitions;
  };

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

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

public:
  GroupAttack(const Process* parent, unsigned int initialPriority, const PersistentUnitGroup* group, Location* location)
    : EngageEnemies(parent, initialPriority, group)
    , IEngageEnemies(parent, initialPriority, group)
    , IGroupBehavior(parent, initialPriority, group)
    , IBehavior(parent, initialPriority)
    , IFSM(parent)
    , Process(parent)
    , m_engagingState(*this)
    , m_goToState(*this, location)
    , m_terminateState(*this)
    , m_states(m_goToState, m_engagingState)
    , m_location(location)
    , m_observerGroup("GroupAttack observers")
  {
  }

  virtual std::string getName() const
  {
    return "GroupAttack (" + getGroup()->getName() + ")";
  }

  virtual void onUnitAddedToGroup(void* data, BWAPI::Unit* unit);
  virtual void onUnitRemovedFromGroup(void* data, BWAPI::Unit* unit);
  
  typedef boost::tuple<
    GoToLocation&,
    Engaging&
  > States;
  const States m_states;

protected:
  virtual void executeImpl()
  {
    EngageEnemies::executeImpl();
    m_goToState.onEnter();
  }

  // Member variables //////////////////////////////////////////////////////////
  Engaging m_engagingState;
  GoToLocation m_goToState;
  Terminate m_terminateState;
  stdext::hash_map<BWAPI::Unit*, BehaviorWrapper> m_subBehaviors;
  //BWAPI::Position m_location;
  Location* m_location;
  PersistentUnitGroup m_observerGroup;
};