SPAR/AIModule/SparAIModule/PerceptualState/Locations/Static/StaticLocation.h

Go to the documentation of this file.

#pragma once
#include "../../../../Utils/Utils.h"
#include "../../../Utils/Utils.h"
#include "../../../Utils/Component.h"
#include "../Location.h"
#include "StaticLocationBase.h"
// Necessary to hack iterator
#include "PrimitiveLocationBase.h"
#include "CompositeLocationBase.h"

class CompositeLocation;

class StaticLocation : public Location, public Component, public virtual StaticLocationBase
{
public:
  typedef general_iterator<PrimitiveLocationBase::own_unit_const_iterator,
                           CompositeLocationBase::own_unit_const_iterator> own_unit_const_iterator;
  typedef general_iterator<PrimitiveLocationBase::own_unit_type_const_iterator,
                           CompositeLocationBase::own_unit_type_const_iterator> own_unit_type_const_iterator;
  typedef general_iterator<PrimitiveLocationBase::own_building_const_iterator,
                           CompositeLocationBase::own_building_const_iterator> own_building_const_iterator;

  typedef general_iterator<PrimitiveLocationBase::enemy_unit_iterator,
                           CompositeLocationBase::enemy_unit_iterator> enemy_unit_iterator;
  typedef general_iterator<PrimitiveLocationBase::enemy_unit_const_iterator,
                           CompositeLocationBase::enemy_unit_const_iterator> enemy_unit_const_iterator;
  typedef general_iterator<PrimitiveLocationBase::enemy_unit_type_iterator,
                           CompositeLocationBase::enemy_unit_type_iterator> enemy_unit_type_iterator;
  typedef general_iterator<PrimitiveLocationBase::enemy_unit_type_const_iterator,
                           CompositeLocationBase::enemy_unit_type_const_iterator> enemy_unit_type_const_iterator;
  typedef general_iterator<PrimitiveLocationBase::enemy_building_iterator,
                           CompositeLocationBase::enemy_building_iterator> enemy_building_iterator;
  typedef general_iterator<PrimitiveLocationBase::enemy_building_const_iterator,
                           CompositeLocationBase::enemy_building_const_iterator> enemy_building_const_iterator;

  typedef general_iterator<PrimitiveLocationBase::neutral_unit_iterator,
                           CompositeLocationBase::neutral_unit_iterator> neutral_unit_iterator;
  typedef general_iterator<PrimitiveLocationBase::neutral_unit_const_iterator,
                           CompositeLocationBase::neutral_unit_const_iterator> neutral_unit_const_iterator;
  typedef general_iterator<PrimitiveLocationBase::neutral_unit_type_iterator,
                           CompositeLocationBase::neutral_unit_type_iterator> neutral_unit_type_iterator;
  typedef general_iterator<PrimitiveLocationBase::neutral_unit_type_const_iterator,
                           CompositeLocationBase::neutral_unit_type_const_iterator> neutral_unit_type_const_iterator;
  typedef general_iterator<PrimitiveLocationBase::neutral_building_iterator,
                           CompositeLocationBase::neutral_building_iterator> neutral_building_iterator;
  typedef general_iterator<PrimitiveLocationBase::neutral_building_const_iterator,
                           CompositeLocationBase::neutral_building_const_iterator> neutral_building_const_iterator;

  StaticLocation(CompositeLocation* parent)
    : m_id(s_id++)
    , m_parent(parent)
  {
  }

  size_t getId() const
  { 
    return m_id;
  }

  CompositeLocation* getParent()
  { 
    return m_parent;
  }

  bool isIn(const CompositeLocation* compositeLocation) const;

#pragma region Own_Units

  std::pair<own_unit_const_iterator, own_unit_const_iterator> 
    getOwnUnits() const;

  std::pair<own_unit_type_const_iterator, own_unit_type_const_iterator> 
    getOwnUnits(BWAPI::UnitType unitType) const;

  std::pair<own_building_const_iterator, own_building_const_iterator>
    getOwnBuildings() const;

  size_t getNbOwnUnits() const
  {
    return getNbOwnUnitsV();
  }

  size_t getNbOwnUnits(BWAPI::UnitType unitType) const
  {
    return getNbOwnUnitsV(unitType);
  }
  size_t getNbOwnBuildings() const
  {
    return getNbOwnBuildingsV();
  }

  void updateOwnUnits()
  {
    updateOwnUnitsV();
  }

  // #################### ADD-ON ####################
  // Copy-paste this stuff in PrimitiveLocation.h and CompositeLocation.h for better performance ;-)

  //template <class Predicate>
  //std::pair<boost::filter_iterator<Predicate, own_unit_const_iterator>, boost::filter_iterator<Predicate, own_unit_const_iterator>> 
  //  getOwnUnits(Predicate predicate) const
  //{
  //  std::pair<own_unit_const_iterator, own_unit_const_iterator> ownUnits = getOwnUnits();
  //  return std::make_pair(boost::filter_iterator<Predicate, own_unit_const_iterator>(predicate, ownUnits.first, ownUnits.second),
  //                        boost::filter_iterator<Predicate, own_unit_const_iterator>(predicate, ownUnits.second, ownUnits.second));
  //}

  //template <class Predicate>
  //std::pair<boost::filter_iterator<Predicate, own_unit_const_iterator>, boost::filter_iterator<Predicate, own_unit_const_iterator>> 
  //  getOwnUnits(BWAPI::UnitType unitType, Predicate predicate) const
  //{
  //  std::pair<own_unit_const_iterator, own_unit_const_iterator> ownUnits = getOwnUnits(unitType);
  //  return std::make_pair(boost::filter_iterator<Predicate, own_unit_const_iterator>(predicate, ownUnits.first, ownUnits.second),
  //                        boost::filter_iterator<Predicate, own_unit_const_iterator>(predicate, ownUnits.second, ownUnits.second));
  //}

  //typedef boost::filter_iterator<IsCompleted, own_unit_const_iterator> own_completed_unit_const_iterator;
  //std::pair<own_completed_unit_const_iterator, own_completed_unit_const_iterator>
  //  getCompletedOwnUnits() const
  //{
  //  std::pair<own_unit_const_iterator, own_unit_const_iterator> ownUnits = getOwnUnits();
  //  return std::make_pair(own_completed_unit_const_iterator(IsCompleted(), ownUnits.first, ownUnits.second),
  //                        own_completed_unit_const_iterator(IsCompleted(), ownUnits.second, ownUnits.second));
  //}

  typedef boost::filter_iterator<IsCompleted<OwnUnit>, own_unit_const_iterator> own_completed_unit_const_iterator;
  std::pair<own_completed_unit_const_iterator, own_completed_unit_const_iterator>
    getCompletedOwnUnits(BWAPI::UnitType unitType) const
  {
    std::pair<own_unit_const_iterator, own_unit_const_iterator> ownUnits = getOwnUnits(unitType);
    return std::make_pair(own_completed_unit_const_iterator(IsCompleted<OwnUnit>(), ownUnits.first, ownUnits.second),
                          own_completed_unit_const_iterator(IsCompleted<OwnUnit>(), ownUnits.second, ownUnits.second));
  }

  //typedef boost::filter_iterator<IsCompletedBuilding, own_unit_const_iterator> own_completed_building_const_iterator;
  //std::pair<own_completed_building_const_iterator, own_completed_building_const_iterator>
  //  getCompletedOwnBuildings() const
  //{
  //  std::pair<own_unit_const_iterator, own_unit_const_iterator> ownUnits = getOwnUnits();
  //  return std::make_pair(own_completed_building_const_iterator(IsCompletedBuilding(), ownUnits.first, ownUnits.second),
  //                        own_completed_building_const_iterator(IsCompletedBuilding(), ownUnits.second, ownUnits.second));
  //}

  //size_t getNbCompletedOwnUnits() const
  //{
  //  std::pair<own_completed_unit_const_iterator, own_completed_unit_const_iterator> ownUnits =
  //    getCompletedOwnUnits();
  //  return std::distance(ownUnits.first, ownUnits.second);
  //}

  size_t getNbCompletedOwnUnits(BWAPI::UnitType unitType) const
  {
    std::pair<own_completed_unit_const_iterator, own_completed_unit_const_iterator> ownUnits =
      getCompletedOwnUnits(unitType);
    return std::distance(ownUnits.first, ownUnits.second);
  }

  //size_t getNbCompletedOwnBuildings() const
  //{
  //  std::pair<own_completed_building_const_iterator, own_completed_building_const_iterator> ownBuildings = 
  //    getCompletedOwnBuildings();
  //  return std::distance(ownBuildings.first, ownBuildings.second);
  //}

#pragma endregion Own_Units

#pragma region Enemy_Units

  std::pair<enemy_unit_iterator, enemy_unit_iterator> 
    getEnemyUnits();

  std::pair<enemy_unit_const_iterator, enemy_unit_const_iterator> 
    getEnemyUnits() const;

  std::pair<enemy_unit_type_iterator, enemy_unit_type_iterator> 
    getEnemyUnits(BWAPI::UnitType unitType);

  std::pair<enemy_unit_type_const_iterator, enemy_unit_type_const_iterator> 
    getEnemyUnits(BWAPI::UnitType unitType) const;

  std::pair<enemy_building_iterator, enemy_building_iterator> 
    getEnemyBuildings();

  std::pair<enemy_building_const_iterator, enemy_building_const_iterator> 
    getEnemyBuildings() const;

  size_t getNbEnemyUnits() const
  {
    return getNbEnemyUnitsV();
  }

  size_t getNbEnemyUnits(BWAPI::UnitType unitType) const
  {
    return getNbEnemyUnitsV(unitType);
  }

  size_t getNbEnemyBuildings() const
  {
    return getNbEnemyBuildingsV();
  }

  void updateEnemyBuildings()
  {
    updateEnemyBuildingsV();
  }

  void updateEnemyUnits()
  {
    updateEnemyUnitsV();
  }

#pragma endregion Enemy_Units

#pragma region Neutral_Units

  std::pair<neutral_unit_iterator, neutral_unit_iterator> 
    getNeutralUnits();

  std::pair<neutral_unit_const_iterator, neutral_unit_const_iterator> 
    getNeutralUnits() const;

  std::pair<neutral_unit_type_iterator, neutral_unit_type_iterator> 
    getNeutralUnits(BWAPI::UnitType unitType);

  std::pair<neutral_unit_type_const_iterator, neutral_unit_type_const_iterator> 
    getNeutralUnits(BWAPI::UnitType unitType) const;

  std::pair<neutral_building_iterator, neutral_building_iterator> 
    getNeutralBuildings();

  std::pair<neutral_building_const_iterator, neutral_building_const_iterator> 
    getNeutralBuildings() const;

  size_t getNbNeutralUnits() const
  {
    return getNbNeutralUnitsV();
  }

  size_t getNbNeutralUnits(BWAPI::UnitType unitType) const
  {
    return getNbNeutralUnitsV(unitType);
  }

  size_t getNbNeutralBuildings() const
  {
    return getNbNeutralBuildingsV();
  }

  void updateNeutralBuildings()
  {
    updateNeutralBuildingsV();
  }

  void updateNeutralUnits()
  {
    updateNeutralUnitsV(); 
  }

#pragma endregion Neutral_Units

  DECLARE_EVENT1(OnOwnUnitAdded, OwnUnit*);
  OnOwnUnitAdded& getOwnUnitAddedEvent() const { return m_ownUnitAddedEvent; }
  DECLARE_EVENT1(OnOwnUnitRemoved, OwnUnit*);
  OnOwnUnitRemoved& getOwnUnitRemovedEvent() const { return m_ownUnitRemovedEvent; }

  DECLARE_EVENT1(OnEnemyUnitAdded, EnemyUnit*);
  OnEnemyUnitAdded& getEnemyUnitAddedEvent() const { return m_enemyUnitAddedEvent; }
  DECLARE_EVENT1(OnEnemyUnitRemoved, EnemyUnit*);
  OnEnemyUnitRemoved& getEnemyUnitRemovedEvent() const { return m_enemyUnitRemovedEvent; }

  DECLARE_EVENT1(OnNeutralUnitAdded, NeutralUnit*);
  OnNeutralUnitAdded& getNeutralUnitAddedEvent() const { return m_neutralUnitAddedEvent; }

  DECLARE_EVENT1(OnNeutralUnitRemoved, NeutralUnit*);
  OnNeutralUnitRemoved& getNeutralUnitRemovedEvent() const { return m_neutralUnitRemovedEvent; }

protected:
  template <class UnitType>
  struct UnitManagement
  {
  };
  template <>
  struct UnitManagement<OwnUnit>
  {
    static BWAPI::UnitType getUnitType(const OwnUnit* ownUnit)
    {
      return ownUnit->getUnit()->getType();
    }
    static Event1<OwnUnit*>& getUnitAddedEvent(StaticLocation* location)
    {
      return location->m_ownUnitAddedEvent;
    }
    static Event1<OwnUnit*>& getUnitRemovedEvent(StaticLocation* location)
    {
      return location->m_ownUnitRemovedEvent;
    }
  };
  template <>
  struct UnitManagement<EnemyUnit>
  {
    static BWAPI::UnitType getUnitType(const EnemyUnit* enemyUnit)
    {
      if (enemyUnit->isAccessible())
        return enemyUnit->getUnit()->getType();
      else
        return enemyUnit->getLastKnownState().getType();
    }
    static Event1<EnemyUnit*>& getUnitAddedEvent(StaticLocation* location)
    {
      return location->m_enemyUnitAddedEvent;
    }
    static Event1<EnemyUnit*>& getUnitRemovedEvent(StaticLocation* location)
    {
      return location->m_enemyUnitRemovedEvent;
    }
  };
  template <>
  struct UnitManagement<NeutralUnit>
  {
    static BWAPI::UnitType getUnitType(const NeutralUnit* neutralUnit)
    {
      if (neutralUnit->isAccessible())
        return neutralUnit->getUnit()->getType();
      else
        return neutralUnit->getLastKnownState().getType();
    }
    static Event1<NeutralUnit*>& getUnitAddedEvent(StaticLocation* location)
    {
      return location->m_neutralUnitAddedEvent;
    }
    static Event1<NeutralUnit*>& getUnitRemovedEvent(StaticLocation* location)
    {
      return location->m_neutralUnitRemovedEvent;
    }
  };
  template <class UnitType> friend struct UnitManagement;

  virtual size_t getNbOwnUnitsV() const = 0;
  virtual size_t getNbOwnUnitsV(BWAPI::UnitType unitType) const = 0;
  virtual size_t getNbOwnBuildingsV() const = 0;

  virtual size_t getNbEnemyUnitsV() const = 0;
  virtual size_t getNbEnemyUnitsV(BWAPI::UnitType unitType) const = 0;
  virtual size_t getNbEnemyBuildingsV() const = 0;

  virtual size_t getNbNeutralUnitsV() const = 0;
  virtual size_t getNbNeutralUnitsV(BWAPI::UnitType unitType) const = 0;
  virtual size_t getNbNeutralBuildingsV() const = 0;

  virtual void updateOwnUnitsV() = 0;
  virtual void updateEnemyBuildingsV() = 0;
  virtual void updateEnemyUnitsV() = 0;
  virtual void updateNeutralBuildingsV() = 0;
  virtual void updateNeutralUnitsV() = 0;

  const size_t m_id;
  CompositeLocation* const m_parent;

  EVENT(OnOwnUnitAdded) m_ownUnitAddedEvent;
  EVENT(OnOwnUnitRemoved) m_ownUnitRemovedEvent;

  EVENT(OnEnemyUnitAdded) m_enemyUnitAddedEvent;
  EVENT(OnEnemyUnitRemoved) m_enemyUnitRemovedEvent;

  EVENT(OnNeutralUnitAdded) m_neutralUnitAddedEvent;
  EVENT(OnNeutralUnitRemoved) m_neutralUnitRemovedEvent;
private:
  static size_t s_id;
};