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

Go to the documentation of this file.

#pragma once
#include "StaticLocation.h"
#include "PrimitiveLocation.h"
#include "CompositeLocationBase.h"

class PrimitiveLocation;

class CompositeLocation : public virtual CompositeLocationBase, public virtual StaticLocation
{
public:
  typedef CompositeLocationBase::own_unit_const_iterator own_unit_const_iterator;
  typedef CompositeLocationBase::own_unit_type_const_iterator own_unit_type_const_iterator;
  typedef CompositeLocationBase::own_building_const_iterator own_building_const_iterator;

  typedef CompositeLocationBase::enemy_unit_iterator enemy_unit_iterator;
  typedef CompositeLocationBase::enemy_unit_const_iterator enemy_unit_const_iterator;
  typedef CompositeLocationBase::enemy_unit_type_iterator enemy_unit_type_iterator;
  typedef CompositeLocationBase::enemy_unit_type_const_iterator enemy_unit_type_const_iterator;
  typedef CompositeLocationBase::enemy_building_iterator enemy_building_iterator;
  typedef CompositeLocationBase::enemy_building_const_iterator enemy_building_const_iterator;

  typedef CompositeLocationBase::neutral_unit_iterator neutral_unit_iterator;
  typedef CompositeLocationBase::neutral_unit_const_iterator neutral_unit_const_iterator;
  typedef CompositeLocationBase::neutral_unit_type_iterator neutral_unit_type_iterator;
  typedef CompositeLocationBase::neutral_unit_type_const_iterator neutral_unit_type_const_iterator;
  typedef CompositeLocationBase::neutral_building_iterator neutral_building_iterator;
  typedef CompositeLocationBase::neutral_building_const_iterator neutral_building_const_iterator;

  CompositeLocation(CompositeLocation* parent)
    : StaticLocation(parent)
  {
  }

#pragma region Sub_Locations

  typedef std::list<StaticLocation*>::iterator sub_location_iterator;
  std::pair<sub_location_iterator, sub_location_iterator> getSubLocations()
  {
    return std::make_pair(m_subLocations.begin(),
                          m_subLocations.end());
  }
  typedef std::list<StaticLocation*>::const_iterator sub_location_const_iterator;
  std::pair<sub_location_const_iterator, sub_location_const_iterator> getSubLocations() const
  {
    return std::make_pair(m_subLocations.begin(),
                          m_subLocations.end());
  }
  size_t getNbSubLocations() const { return m_subLocations.size(); }

  typedef std::list<PrimitiveLocation*>::iterator primitive_sub_location_iterator;
  std::pair<primitive_sub_location_iterator, primitive_sub_location_iterator> getPrimitiveSubLocations()
  {
    return std::make_pair(m_primitiveSubLocationsCache.begin(),
                          m_primitiveSubLocationsCache.end());
  }
  typedef std::list<PrimitiveLocation*>::const_iterator primitive_sub_location_const_iterator;
  std::pair<primitive_sub_location_const_iterator, primitive_sub_location_const_iterator> getPrimitiveSubLocations() const
  {
    return std::make_pair(m_primitiveSubLocationsCache.begin(),
                          m_primitiveSubLocationsCache.end());
  }  
  size_t getNbPrimitiveSubLocations() const { return m_primitiveSubLocationsCache.size(); }

  bool contains(const StaticLocation* staticLocation) const
  {
    return staticLocation->isIn(this);
  }

#pragma endregion Sub_Locations

#pragma region Own_Units

  std::pair<own_unit_type_const_iterator, own_unit_type_const_iterator> 
    getOwnUnits(BWAPI::UnitType unitType) const
  {
    std::pair<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>>::const_iterator, stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>>::const_iterator> iterators = m_ownUnitsCache.equal_range(unitType);
    return std::make_pair(own_unit_type_const_iterator(iterators.first), 
                          own_unit_type_const_iterator(iterators.second));
  }

  std::pair<own_unit_const_iterator, own_unit_const_iterator> 
    getOwnUnits() const
  {
    return std::make_pair(own_unit_const_iterator(m_ownUnitsCache.begin()),
                          own_unit_const_iterator(m_ownUnitsCache.end()));
  }

  size_t getNbOwnUnits() const
  {
    const size_t nbUnitsCache = m_ownUnitsCache.size();

#ifdef _DEBUG
    size_t nbUnits = 0;
    for (std::list<StaticLocation*>::const_iterator it = m_subLocations.begin(); it != m_subLocations.end(); ++it)
      nbUnits += (*it)->getNbOwnUnits();
    assert(nbUnits == nbUnitsCache);
#endif

    return nbUnitsCache;
  }

  size_t getNbOwnUnits(BWAPI::UnitType unitType) const
  {
    const size_t nbUnitsCache = m_ownUnitsCache.count(unitType);

#ifdef _DEBUG
    size_t nbUnits = 0;
    for (std::list<StaticLocation*>::const_iterator it = m_subLocations.begin(); it != m_subLocations.end(); ++it)
      nbUnits += (*it)->getNbOwnUnits(unitType);
    assert(nbUnits == nbUnitsCache);
#endif

    return nbUnitsCache;
  }

  std::pair<own_building_const_iterator, own_building_const_iterator>
    getOwnBuildings() const
  {
    std::pair<own_unit_const_iterator, own_unit_const_iterator> ownUnits = getOwnUnits();
    return std::make_pair(own_building_const_iterator(IsBuilding<OwnUnit>(), ownUnits.first, ownUnits.second),
                          own_building_const_iterator(IsBuilding<OwnUnit>(), ownUnits.second, ownUnits.second));
  }

  size_t getNbOwnBuildings() const
  {
    // Note that this could be implemented in log n (instead of n) by using a std::map with BWAPI::UnitTypes building ID ranges

    std::pair<own_building_const_iterator, own_building_const_iterator> ownBuildings = getOwnBuildings();
    return std::distance(ownBuildings.first, ownBuildings.second);
  }

  void updateOwnUnits()
  {
    for (std::list<PrimitiveLocation*>::iterator it = m_primitiveSubLocationsCache.begin(); it != m_primitiveSubLocationsCache.end(); ++it)
    {
      (*it)->updateOwnUnits();
    }
  }

#pragma endregion Own_Units

#pragma region Enemy_Units

  std::pair<enemy_unit_iterator, enemy_unit_iterator> 
    getEnemyUnits()
  {
    return std::make_pair(enemy_unit_iterator(m_enemyUnitsCache.begin()),
                          enemy_unit_iterator(m_enemyUnitsCache.end()));
  }

  std::pair<enemy_unit_const_iterator, enemy_unit_const_iterator> 
    getEnemyUnits() const
  {
    return std::make_pair(enemy_unit_const_iterator(m_enemyUnitsCache.begin()),
                          enemy_unit_const_iterator(m_enemyUnitsCache.end()));
  }

  std::pair<enemy_unit_type_iterator, enemy_unit_type_iterator> 
    getEnemyUnits(BWAPI::UnitType unitType)
  {
    std::pair<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::iterator, stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::iterator> iterators = m_enemyUnitsCache.equal_range(unitType);
    return std::make_pair(enemy_unit_type_iterator(iterators.first), enemy_unit_type_iterator(iterators.second));
  }

  std::pair<enemy_unit_type_const_iterator, enemy_unit_type_const_iterator> 
    getEnemyUnits(BWAPI::UnitType unitType) const
  {
    std::pair<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::const_iterator, stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>::const_iterator> iterators = m_enemyUnitsCache.equal_range(unitType);
    return std::make_pair(enemy_unit_type_const_iterator(iterators.first), enemy_unit_type_const_iterator(iterators.second));
  }

  std::pair<enemy_building_iterator, enemy_building_iterator>
    getEnemyBuildings()
  {
    std::pair<enemy_unit_iterator, enemy_unit_iterator> enemyUnits = getEnemyUnits();
    return std::make_pair(enemy_building_iterator(IsBuilding<EnemyUnit>(), enemyUnits.first, enemyUnits.second),
                          enemy_building_iterator(IsBuilding<EnemyUnit>(), enemyUnits.second, enemyUnits.second));
  }

  std::pair<enemy_building_const_iterator, enemy_building_const_iterator>
    getEnemyBuildings() const
  {
    std::pair<enemy_unit_const_iterator, enemy_unit_const_iterator> enemyUnits = getEnemyUnits();
    return std::make_pair(enemy_building_const_iterator(IsBuilding<EnemyUnit>(), enemyUnits.first, enemyUnits.second),
                          enemy_building_const_iterator(IsBuilding<EnemyUnit>(), enemyUnits.second, enemyUnits.second));
  }

  size_t getNbEnemyUnits() const
  {
    const size_t nbUnitsCache = m_enemyUnitsCache.size();

#ifdef _DEBUG
    size_t nbUnits = 0;
    for (std::list<StaticLocation*>::const_iterator it = m_subLocations.begin(); it != m_subLocations.end(); ++it)
      nbUnits += (*it)->getNbEnemyUnits();
    assert(nbUnits == nbUnitsCache);
#endif

    return nbUnitsCache;
  }

  size_t getNbEnemyUnits(BWAPI::UnitType unitType) const
  {
    const size_t nbUnitsCache = m_enemyUnitsCache.count(unitType);

#ifdef _DEBUG
    size_t nbUnits = 0;
    for (std::list<StaticLocation*>::const_iterator it = m_subLocations.begin(); it != m_subLocations.end(); ++it)
      nbUnits += (*it)->getNbEnemyUnits(unitType);
    assert(nbUnits == nbUnitsCache);
#endif

    return nbUnitsCache;
  }

  size_t getNbEnemyBuildings() const
  {
    std::pair<enemy_building_const_iterator, enemy_building_const_iterator> enemyBuildings = getEnemyBuildings();
    return std::distance(enemyBuildings.first, enemyBuildings.second);
  }

  void updateEnemyBuildings()
  {
    for (std::list<PrimitiveLocation*>::iterator it = m_primitiveSubLocationsCache.begin(); it != m_primitiveSubLocationsCache.end(); ++it)
    {
      (*it)->updateEnemyBuildings();
    }
  }

  void updateEnemyUnits()
  {
    for (std::list<PrimitiveLocation*>::iterator it = m_primitiveSubLocationsCache.begin(); it != m_primitiveSubLocationsCache.end(); ++it)
    {
      (*it)->updateEnemyUnits();
    }
  }

#pragma endregion Enemy_Units

#pragma region Neutral_Units

  std::pair<neutral_unit_iterator, neutral_unit_iterator> 
    getNeutralUnits()
  {
    return std::make_pair(neutral_unit_iterator(m_neutralUnitsCache.begin()),
                          neutral_unit_iterator(m_neutralUnitsCache.end()));
  }

  std::pair<neutral_unit_const_iterator, neutral_unit_const_iterator> 
    getNeutralUnits() const
  {
    return std::make_pair(neutral_unit_const_iterator(m_neutralUnitsCache.begin()),
                          neutral_unit_const_iterator(m_neutralUnitsCache.end()));
  }

  std::pair<neutral_unit_type_iterator, neutral_unit_type_iterator> 
    getNeutralUnits(BWAPI::UnitType unitType)
  {
    std::pair<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::iterator, stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::iterator> iterators = m_neutralUnitsCache.equal_range(unitType);
    return std::make_pair(neutral_unit_type_iterator(iterators.first), neutral_unit_type_iterator(iterators.second));
  }

  std::pair<neutral_unit_type_const_iterator, neutral_unit_type_const_iterator> 
    getNeutralUnits(BWAPI::UnitType unitType) const
  {
    std::pair<stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::const_iterator, stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>::const_iterator> iterators = m_neutralUnitsCache.equal_range(unitType);
    return std::make_pair(neutral_unit_type_const_iterator(iterators.first), neutral_unit_type_const_iterator(iterators.second));
  }

  std::pair<neutral_building_iterator, neutral_building_iterator>
    getNeutralBuildings()
  {
    std::pair<neutral_unit_iterator, neutral_unit_iterator> neutralUnits = getNeutralUnits();
    return std::make_pair(neutral_building_iterator(IsBuilding<NeutralUnit>(), neutralUnits.first, neutralUnits.second),
                          neutral_building_iterator(IsBuilding<NeutralUnit>(), neutralUnits.second, neutralUnits.second));
  }

  std::pair<neutral_building_const_iterator, neutral_building_const_iterator>
    getNeutralBuildings() const
  {
    std::pair<neutral_unit_const_iterator, neutral_unit_const_iterator> neutralUnits = getNeutralUnits();
    return std::make_pair(neutral_building_const_iterator(IsBuilding<NeutralUnit>(), neutralUnits.first, neutralUnits.second),
                          neutral_building_const_iterator(IsBuilding<NeutralUnit>(), neutralUnits.second, neutralUnits.second));
  }

  size_t getNbNeutralUnits() const
  {
    const size_t nbUnitsCache = m_neutralUnitsCache.size();

#ifdef _DEBUG
    size_t nbUnits = 0;
    for (std::list<StaticLocation*>::const_iterator it = m_subLocations.begin(); it != m_subLocations.end(); ++it)
      nbUnits += (*it)->getNbNeutralUnits();
    assert(nbUnits == nbUnitsCache);
#endif

    return nbUnitsCache;
  }

  size_t getNbNeutralUnits(BWAPI::UnitType unitType) const
  {
    const size_t nbUnitsCache = m_neutralUnitsCache.count(unitType);

#ifdef _DEBUG
    size_t nbUnits = 0;
    for (std::list<StaticLocation*>::const_iterator it = m_subLocations.begin(); it != m_subLocations.end(); ++it)
      nbUnits += (*it)->getNbNeutralUnits(unitType);
    assert(nbUnits == nbUnitsCache);
#endif

    return nbUnitsCache;
  }

  size_t getNbNeutralBuildings() const
  {
    std::pair<neutral_building_const_iterator, neutral_building_const_iterator> neutralBuildings = getNeutralBuildings();
    return std::distance(neutralBuildings.first, neutralBuildings.second);
  }

  void updateNeutralBuildings()
  {
    for (std::list<PrimitiveLocation*>::iterator it = m_primitiveSubLocationsCache.begin(); it != m_primitiveSubLocationsCache.end(); ++it)
    {
      (*it)->updateNeutralBuildings();
    }
  }

  void updateNeutralUnits()
  {
    for (std::list<PrimitiveLocation*>::iterator it = m_primitiveSubLocationsCache.begin(); it != m_primitiveSubLocationsCache.end(); ++it)
    {
      (*it)->updateNeutralUnits();
    }
  }

#pragma endregion Neutral_Units

protected:
  friend class PrimitiveLocation;

  template <class UnitType>
  struct UnitManagement : public StaticLocation::UnitManagement<UnitType>
  {
  };
  template <>
  struct UnitManagement<OwnUnit> : public StaticLocation::UnitManagement<OwnUnit>
  {
    static stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>>& getUnits(CompositeLocation* location)
    {
      return location->m_ownUnitsCache;
    }
  };
  template <>
  struct UnitManagement<EnemyUnit> : public StaticLocation::UnitManagement<EnemyUnit>
  {
    static stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>& getUnits(CompositeLocation* location)
    {
      return location->m_enemyUnitsCache;
    }
  };
  template <>
  struct UnitManagement<NeutralUnit> : public StaticLocation::UnitManagement<NeutralUnit>
  {
    static stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>& getUnits(CompositeLocation* location)
    {
      return location->m_neutralUnitsCache;
    }
  };
  template <class UnitType> friend struct UnitManagement;

  template <class UnitType>
  void onUnitAdded(UnitType* unit);

  template <class UnitType>
  void onUnitRemoved(UnitType* unit);

  //template <class UnitType>
  //void onUnitMorphed(UnitType* ownUnit);

  template <class UnitType>
  void onUnitTransferred(UnitType* ownUnit, StaticLocation* fromLocation, StaticLocation* toLocation);

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

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

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

  virtual void updateOwnUnitsV()
  {
    updateOwnUnits();
  }
  virtual void updateEnemyBuildingsV()
  {
    updateEnemyBuildings();
  }
  virtual void updateEnemyUnitsV()
  {
    updateEnemyUnits();
  }
  virtual void updateNeutralBuildingsV()
  {
    updateNeutralBuildings();
  }
  virtual void updateNeutralUnitsV()
  {
    updateNeutralUnits();
  }

  void addSubLocation(StaticLocation* location)
  {
    m_subLocations.insert(m_subLocations.end(), location);

    PrimitiveLocation* primitiveLocation = dynamic_cast<PrimitiveLocation*>(location);
    if (primitiveLocation != NULL)
    {
      onPrimitiveSubLocationAdded(primitiveLocation);
    }
  }

  void onPrimitiveSubLocationAdded(PrimitiveLocation* location)
  {
    m_primitiveSubLocationsCache.insert(m_primitiveSubLocationsCache.end(), location);

    if (m_parent != NULL)
    {
      m_parent->onPrimitiveSubLocationAdded(location);
    }
  }

  std::list<StaticLocation*> m_subLocations;
  std::list<PrimitiveLocation*> m_primitiveSubLocationsCache;

  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>> m_ownUnitsCache;
  
  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>> m_enemyUnitsCache;

  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>> m_neutralUnitsCache;

private:
  template <class UnitType>
  void addUnitInternal(UnitType* unit);

  template <class UnitType>
  void removeUnitInternal(UnitType* unit);
};

template <class UnitType>
void CompositeLocation::onUnitAdded(UnitType* unit)
{
  addUnitInternal(unit);
  UnitManagement<UnitType>::getUnitAddedEvent(this).raise(unit);

  if (m_parent != NULL)
    m_parent->onUnitAdded(unit);
}

template <class UnitType>
void CompositeLocation::onUnitRemoved(UnitType* unit)
{
  removeUnitInternal(unit);
  UnitManagement<UnitType>::getUnitRemovedEvent(this).raise(unit);

  if (m_parent != NULL)
    m_parent->onUnitRemoved(unit);
}

//template <class UnitType>
//void CompositeLocation::onUnitMorphed(UnitType* unit)
//{
//  removeUnitInternal(unit);
//  addUnitInternal(unit);
//
//  if (m_parent != NULL)
//    m_parent->onUnitMorphed(unit);
//}

template <class UnitType>
void CompositeLocation::onUnitTransferred(UnitType* unit, StaticLocation* fromLocation, StaticLocation* toLocation)
{
  const bool containsFromLocation = fromLocation->isIn(this);
  const bool containsToLocation = toLocation->isIn(this);
  if (containsFromLocation != containsToLocation)
  {
    if (containsFromLocation)
    {
      assert(!containsToLocation);
      removeUnitInternal(unit);
      UnitManagement<UnitType>::getUnitRemovedEvent(this).raise(unit);
    }
    else
    {
      assert(!containsFromLocation);
      addUnitInternal(unit);
      UnitManagement<UnitType>::getUnitAddedEvent(this).raise(unit);
    }
  }
  if (m_parent != NULL)
    m_parent->onUnitTransferred(unit, fromLocation, toLocation);
}

template <class UnitType>
void CompositeLocation::addUnitInternal(UnitType* unit)
{
  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<UnitType>>::iterator it = 
    UnitManagement<UnitType>::getUnits(this).insert(std::make_pair(UnitManagement<UnitType>::getUnitType(unit), UnitWrapper<UnitType>(unit)));
  UnitWrapper<UnitType>& unitWrapper = it->second;
  unitWrapper.m_posInContainer = it;
  if (dynamic_cast<Region*>(this) != NULL)
  {
    assert(unit->m_regionData == NULL);
    unit->m_regionData = &unitWrapper;
  }
  else if (dynamic_cast<Map*>(this) != NULL)
  {
    assert(unit->m_mapData == NULL);
    unit->m_mapData = &unitWrapper;
  }
  else
  {
    throw std::runtime_error("Unsupported composite location class...(oups)");
  }
  assert(&unitWrapper.m_posInContainer->second == &unitWrapper);
}

template <class UnitType>
void CompositeLocation::removeUnitInternal(UnitType* unit)
{
  UnitWrapper<UnitType>* unitWrapper = NULL;
  if (dynamic_cast<Region*>(this) != NULL)
  {
    assert(unit->m_regionData != NULL);
    unitWrapper = reinterpret_cast<UnitWrapper<UnitType>*>(unit->m_regionData);
    unit->m_regionData = NULL;
  }
  else if (dynamic_cast<Map*>(this) != NULL)
  {
    assert(unit->m_mapData != NULL);
    unitWrapper = reinterpret_cast<UnitWrapper<UnitType>*>(unit->m_mapData);
    unit->m_mapData = NULL;
  }
  else
  {
    throw std::runtime_error("Unsupported composite location class...(oups)");
  }

  assert(&unitWrapper->m_posInContainer->second == unitWrapper);

  UnitManagement<UnitType>::getUnits(this).erase(unitWrapper->m_posInContainer);
}