SPAR/AIModule/SparAIModule/DecisionMaking/Layer2Actions/Interface/Actions/GroupTacticalAction.h

Go to the documentation of this file.

#pragma once
#include "TacticalAction.h"
#include "../Layer2UnitData.h"
#include "../../../../PersistentUnitGroup.h"
#include "../../../../Utils/GroupProcess.h"

class UnitManager;

namespace layer2
{
  class GroupTacticalAction : public GroupProcess, public virtual TacticalAction
  {
  public:
    GroupTacticalAction(unsigned int priority)
      : GroupProcess(NULL, new PersistentUnitGroup("Action-group"))
      , Process(Spar)
      , TacticalAction(priority)
      , m_initialGroup(&PersistentUnitGroup::EmptyGroup, *this)
      , m_initialUnitAddedEventHandler(*this)
      , m_initialUnitRemovedEventHandler(*this)
    {
      for (PersistentUnitGroup::const_iterator it = m_initialGroup->begin(); it != m_initialGroup->end(); ++it)
      {
        group()->insert(*it);
      }
      m_initialUnitAddedID = m_initialGroup->getUnitAddedEvent().subscribe(&m_initialUnitAddedEventHandler, NULL);
      m_initialUnitRemovedID = m_initialGroup->getUnitRemovedEvent().subscribe(&m_initialUnitRemovedEventHandler, NULL);
    }

    GroupTacticalAction(unsigned int priority, const PersistentUnitGroup* initialGroup)
      : GroupProcess(NULL, new PersistentUnitGroup("Action-group"))
      , Process(Spar)
      , TacticalAction(priority)
      , m_initialGroup(initialGroup, *this)
      , m_initialUnitAddedEventHandler(*this)
      , m_initialUnitRemovedEventHandler(*this)
    {
      for (PersistentUnitGroup::const_iterator it = m_initialGroup->begin(); it != m_initialGroup->end(); ++it)
      {
        group()->insert(*it);
      }
      m_initialUnitAddedID = m_initialGroup->getUnitAddedEvent().subscribe(&m_initialUnitAddedEventHandler, NULL);
      m_initialUnitRemovedID = m_initialGroup->getUnitRemovedEvent().subscribe(&m_initialUnitRemovedEventHandler, NULL);
    }

    ~GroupTacticalAction()
    {
      m_initialGroup->getUnitAddedEvent().unsubscribe(m_initialUnitAddedID);
      m_initialGroup->getUnitRemovedEvent().unsubscribe(m_initialUnitRemovedID);
    }

    void onUnitAddedToInitialGroup(void*, BWAPI::Unit* unit)
    {
      group()->insert(unit);
    }

    void onUnitRemovedFromInitialGroup(void*, BWAPI::Unit* unit)
    {
      group()->remove(unit);
    }

    bool addUnit(BWAPI::Unit* unit, bool force = false)
    {
      bool success = true;
      if (isWaitingToExecute())
      {
        success = group()->insert(unit);
      }
      else if (isExecuting())
      {
        success = addActionToUnit(unit, force);
        if (success)
        {
          group()->insert(unit);
        }
      }
      return success;
    }

    static int transfer(GroupTacticalAction* source, GroupTacticalAction* destination, const int n);

    // GUI //
    virtual std::set<BWAPI::Unit*> getCommandedUnits() const
    {
      return std::set<BWAPI::Unit*>(getGroup()->begin(), getGroup()->end());
    }

  protected:
    friend class Layer2UnitData;

    virtual void output(std::ostream& out) const
    {
      TacticalAction::output(out);
    }

    void removeUnit(BWAPI::Unit* unit)
    {
      // Condition instead?
     
      if (isWaitingToExecute())
      {
        group()->remove(unit);
      }
      else if (isExecuting())
      {
        removeActionFromUnit(unit);
        group()->remove(unit);
      }
    }

    virtual void executeImpl()
    {
      // Don't call GroupProcess::executeImpl() as it will be called in executeCommonImpl()
      TacticalAction::executeImpl();
    }

    virtual void executeCommonImpl()
    {
      TacticalAction::executeCommonImpl();

      m_initialGroup->getUnitAddedEvent().unsubscribe(m_initialUnitAddedID);
      m_initialGroup->getUnitRemovedEvent().unsubscribe(m_initialUnitRemovedID);
      for (PersistentUnitGroup::iterator it = group()->begin(); it != group()->end(); )
      {
        BWAPI::Unit* initialUnit = *it;
        PersistentUnitGroup::iterator next = ++PersistentUnitGroup::iterator(it);
        if (!addActionToUnit(initialUnit, false))
        {
          group()->remove(it);
        }
        it = next;
      }

      GroupProcess::executeImpl();
      // At this point the reference to initialGroup could be released
#ifdef _DEBUG
      for (PersistentUnitGroup::const_iterator it = getGroup()->begin(); it != getGroup()->end(); ++it)
      {
        assert(dynamic_cast<Layer2UnitData&>(Spar->getUnitManager().getUnitData(*it)).getCurrentAction() == this);
      }
#endif
    }
    
    virtual void terminateImpl()
    {
      // Don't call GroupProcess::terminateImpl() as it will be called in terminateCommonImpl()
      TacticalAction::terminateImpl();
    }

    virtual void terminateCommonImpl()
    {
      TacticalAction::terminateCommonImpl();

      GroupProcess::terminateImpl();

      for (PersistentUnitGroup::iterator it = group()->begin(); it != group()->end(); )
      {
        PersistentUnitGroup::iterator next = ++PersistentUnitGroup::iterator(it);
        removeActionFromUnit(*it);
        group()->remove(it);
        it = next;
      }
      //assert(getGroup()->empty());
    }

  private:
    PersistentUnitGroup* group() const
    {
      // To remove the const_cast, the PersistentUnitGroup would have to be declared on the stack!
      return const_cast<PersistentUnitGroup*>(GroupProcess::getGroup());
    }

    bool addActionToUnit(BWAPI::Unit* unit, bool force)
    {
      return dynamic_cast<Layer2UnitData&>(Spar->getUnitManager().getUnitData(unit)).proposeAction(this, force);
    }

    void removeActionFromUnit(BWAPI::Unit* unit)
    {
      dynamic_cast<Layer2UnitData&>(Spar->getUnitManager().getUnitData(unit)).removeAction(this);
    }

    EVENT_HANDLER1(GroupTacticalAction, onUnitAddedToInitialGroup, BWAPI::Unit*) m_initialUnitAddedEventHandler;
    PersistentUnitGroup::OnUnitAdded::SubscriberID m_initialUnitAddedID;
    EVENT_HANDLER1(GroupTacticalAction, onUnitRemovedFromInitialGroup, BWAPI::Unit*) m_initialUnitRemovedEventHandler;
    PersistentUnitGroup::OnUnitRemoved::SubscriberID m_initialUnitRemovedID;

    // Initial units sent to action
    AutoPtr<const PersistentUnitGroup> m_initialGroup;
  };
}