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

Go to the documentation of this file.

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

// TODO: Fail when there is no more Nexus
// TODO: Keep next mineralPatchIterator to cycle the assignement of probes

class GatherMinerals : public GroupBehavior<GatherMinerals>
{
protected:
  class Mining;
  friend class Mining;

  class Mining : public BehaviorState<GatherMinerals, Mining>
  {
  public:
    Mining(GatherMinerals& behavior);
    void onEnterImpl();
    void onExitImpl();

    void onTimer()
    {
      if(defence == NULL)
      {
        defence = new PersistentUnitGroup("Defence");
      }
      PersistentUnitGroup::const_iterator itUnit = m_context.getGroup()->begin();
      while(defence->size() < 3 && itUnit!=m_context.getGroup()->end())
      {
        if(defence->find((*itUnit))==defence->end())
        {
          defence->insert(defence->end(),(*itUnit));
        }
        ++itUnit;
      }
      bool doSomething = false;
      if(isAttacking){doSomething=true;}
      std::pair<BaseLocation::crystal_iterator, BaseLocation::crystal_iterator> crystals = m_context.m_baseLocation->getLastKnownCrystalsLeft();
      BaseLocation::crystal_iterator patch = crystals.first;

      if(crystals.first != crystals.second)
      {
        for(PersistentUnitGroup::const_iterator i = m_context.getGroup()->begin() ; i!=m_context.getGroup()->end() ; ++i)
        {
          if((*i)->isIdle())
          {
            if(patch != crystals.second)
            {
              (*i)->gather((*patch)->getUnit());
              patch++;
            }
            else
            {
              patch = crystals.first;
              (*i)->gather((*patch)->getUnit());
              patch++;
            }
          }
          if(!isAttacking && (*i)->isUnderAttack())
          {
            doSomething=true;
          }
          if(isAttacking && (*i)->isUnderAttack())
          {
            doSomething=false;
          }
        }
      }

      if(doSomething && isAttacking)
      {
        //stop attacking
        crystals = m_context.m_baseLocation->getLastKnownCrystalsLeft();
        patch = crystals.first;
        for(PersistentUnitGroup::const_iterator i = defence->begin() ; i!=defence->end() ; ++i)
        {
          if(patch != crystals.second)
          {
            (*i)->gather((*patch)->getUnit());
            patch++;
          }
          else
          {
            patch = crystals.first;
            (*i)->gather((*patch)->getUnit());
            patch++;
          }
        }
        isAttacking = false;
        m_target = NULL;
      }
      else if(doSomething && !isAttacking)
      {
        //start attacking
        isAttacking = true;
        //find a target
        UnitGroup units = Spar->getPerceptualState().getEnemyUnits(CircularLocation((*m_context.getGroup()->begin())->getPosition(), 7*TILE_SIZE));
        UnitGroup::iterator itEnemy = units.begin();
        m_target = NULL;
        while(m_target == NULL && itEnemy!=units.end())
        {
          if((*itEnemy)->isDetected() == true)
          {
            m_target = (*itEnemy);
          }
          itEnemy++;
        }
        //everybody attack move it
        if(m_target!=NULL)
        {
          defence->attackMove(m_target->getPosition());
        }
        else
        {
          isAttacking = false;
        }
      }
      else if(!doSomething && isAttacking)
      {
        //if target is dead
        
        if(!m_target->exists() || !m_target->isDetected())
        {
          UnitGroup units = Spar->getPerceptualState().getEnemyUnits(CircularLocation((*m_context.getGroup()->begin())->getPosition(), 7*TILE_SIZE));
          UnitGroup::iterator it = units.begin();
          m_target = NULL;
          while(m_target == NULL && it!=units.end())
          {
            if((*it)->isDetected() == true)
            {
              m_target = (*it);
            }
            it++;
          }
        }
        //change target
        //attack move target
        if(m_target != NULL)
        {
          defence->attackMove(m_target->getPosition());
        }
        else
        {
          isAttacking = false;
        }
      }
    };

    void onUnitAddedToGroup(BWAPI::Unit* unit);
    void onNeutralBuildingRemoved(void* data, NeutralUnit* crystal);

    typedef SCHEDULER_EVENT(Mining, onTimer) TimerEvent;

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

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

  protected:
    // Events
    Event<boost::tuples::tuple<NeutralUnit*>>::SubscriberID m_crystalRemovedSubscriberId;
    EVENT_HANDLER1(Mining, onNeutralBuildingRemoved, NeutralUnit*) m_crystalRemovedEventHandler;

    TimerEvent m_event;

    // Variables
    BWAPI::Unit* m_target;
    bool isAttacking;
    PersistentUnitGroup* defence;
    // Actions

    // Transitions
  };

public:
  GatherMinerals(const Process* parent, unsigned int initialPriority, const PersistentUnitGroup* probes, BaseLocation* baseLocation)
    : GroupBehavior(parent, initialPriority, probes)
    , IGroupBehavior(parent, initialPriority, probes)
    , IBehavior(parent, initialPriority)
    , IFSM(parent)
    , Process(parent)
    , m_miningState(*this)
    , m_baseLocation(baseLocation)
    , m_lastMineral(NULL)
    , m_states(m_miningState)
  { }

  virtual std::string getName() const
  {
    return "GatherMinerals at " + getObjectDescription(m_baseLocation);
  }

  virtual void onUnitAddedToGroup(void*, BWAPI::Unit* unit)
  {
    assert(unit->getType() == BWAPI::UnitTypes::Protoss_Probe);
    if(m_currentState == &m_miningState)
      m_miningState.onUnitAddedToGroup(unit);
  }

  virtual void onUnitRemovedFromGroup(void*, BWAPI::Unit* unit)
  {
    unused(unit);
  }

  // TODO: Move elsewhere ?
  static const TerminationMode NoMoreMinerals;

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

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

  BaseLocation* m_baseLocation;
  BWAPI::Unit* m_lastMineral;

  Mining m_miningState;
};