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

Go to the documentation of this file.

#pragma once
#include "StaticLocation.h"
#include "PrimitiveLocationBase.h"
#include "../../../SparAIContainer.h"
#include "../../../UnitManager.h"
#include "../../../Utils/Utils.h"

//
// onUnitRenegade events are not handled since we only store buildings and they cannot be mind-controlled
// (and geysers->refineries are handled by the onUnitMorph event).
//
// Other implementations are possible (for CompositeLocation also)
// - unit types in std::map ([min-max] unit types for buildings)
// - one container for units and one container for buildings
//
// Additionally, the same containers could be used for PrimitiveLocation/CompositeLocation, to avoid
// duplicating code and to offer the same kind of iterators (instead of general_iterator) in StaticLocation.
//

static const bool KEEP_UNITS_IN_FOG_OF_WAR = true;

class CompositeLocation;
class PerceptualState;

class PrimitiveLocation : public virtual PrimitiveLocationBase, public virtual StaticLocation
{
public:
  typedef PrimitiveLocationBase::own_unit_const_iterator own_unit_const_iterator;
  typedef PrimitiveLocationBase::own_unit_type_const_iterator own_unit_type_const_iterator;
  typedef PrimitiveLocationBase::own_building_const_iterator own_building_const_iterator;

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

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

  PrimitiveLocation(CompositeLocation* parent)
    : StaticLocation(parent)
    , m_unitDestroyEventHandler(*this)
    , m_unitMorphEventHandler(*this)
    , m_unitRenegadeEventHandler(*this)
    , m_unitEvadeEventHandler(*this)
  {
  }

  ~PrimitiveLocation()
  {
    std::pair<own_unit_wrapper_iterator, own_unit_wrapper_iterator> ownBuildings = getOwnUnitWrappers();
    while (ownBuildings.first != ownBuildings.second)
    {
      own_unit_wrapper_iterator next = ++(own_unit_wrapper_iterator(ownBuildings.first));
      OwnUnit* ownUnit = (*ownBuildings.first).getUnit();
      removeUnitInternal(ownUnit);
      delete ownUnit;
      ownBuildings.first = next;
    }

    std::pair<enemy_unit_wrapper_iterator, enemy_unit_wrapper_iterator> enemyBuildings = getEnemyUnitWrappers();
    while (enemyBuildings.first != enemyBuildings.second)
    {
      enemy_unit_wrapper_iterator next = ++(enemy_unit_wrapper_iterator(enemyBuildings.first));
      EnemyUnit* enemyUnit = (*enemyBuildings.first).getUnit();
      removeUnitInternal(enemyUnit);
      delete enemyUnit;
      enemyBuildings.first = next;
    }

    std::pair<neutral_unit_wrapper_iterator, neutral_unit_wrapper_iterator> neutralUnits = getNeutralUnitWrappers();
    while (neutralUnits.first != neutralUnits.second)
    {
      neutral_unit_wrapper_iterator next = ++(neutral_unit_wrapper_iterator(neutralUnits.first));
      NeutralUnit* neutralUnit = (*neutralUnits.first).getUnit();
      removeUnitInternal(neutralUnit);
      delete neutralUnit;
      neutralUnits.first = next;
    }
  }

#pragma region Own_Units

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

  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_ownUnits.equal_range(unitType);
    return std::make_pair(own_unit_type_const_iterator(own_unit_wrapper_const_iterator(iterators.first)), 
                          own_unit_type_const_iterator(own_unit_wrapper_const_iterator(iterators.second)));
  }

  std::pair<own_building_const_iterator, own_building_const_iterator>
    getOwnBuildings() 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_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 getNbOwnUnits() const
  {
    return m_ownUnits.size();
  }

  size_t getNbOwnUnits(BWAPI::UnitType unitType) const
  {
    return m_ownUnits.count(unitType);
  }

  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()
  {
    std::pair<own_unit_iterator, own_unit_iterator> ownUnits = getOwnUnits();
    updateUnits(ownUnits.first, ownUnits.second);
  }

#pragma endregion Own_Units

#pragma region Enemy_Units

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

  std::pair<enemy_unit_const_iterator, enemy_unit_const_iterator> 
    getEnemyUnits() const
  {
    return std::make_pair(enemy_unit_const_iterator(enemy_unit_wrapper_const_iterator(m_enemyUnits.begin())),
                          enemy_unit_const_iterator(enemy_unit_wrapper_const_iterator(m_enemyUnits.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_enemyUnits.equal_range(unitType);
    return std::make_pair(enemy_unit_type_iterator(enemy_unit_wrapper_iterator(iterators.first)), 
                          enemy_unit_type_iterator(enemy_unit_wrapper_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_enemyUnits.equal_range(unitType);
    return std::make_pair(enemy_unit_type_const_iterator(enemy_unit_wrapper_const_iterator(iterators.first)), 
                          enemy_unit_type_const_iterator(enemy_unit_wrapper_const_iterator(iterators.second)));
  }

  std::pair<enemy_building_iterator, enemy_building_iterator>
    getEnemyBuildings()
  {
    std::pair<enemy_building_wrapper_iterator, enemy_building_wrapper_iterator> enemyWrappers = getEnemyBuildingWrappers();
    return std::make_pair(enemy_building_iterator(enemyWrappers.first), 
                          enemy_building_iterator(enemyWrappers.second));
  }

  std::pair<enemy_building_const_iterator, enemy_building_const_iterator>
    getEnemyBuildings() const
  {
    std::pair<enemy_building_wrapper_const_iterator, enemy_building_wrapper_const_iterator> enemyWrappers = getEnemyBuildingWrappers();
    return std::make_pair(enemy_building_const_iterator(enemyWrappers.first), 
                          enemy_building_const_iterator(enemyWrappers.second));
  }

  size_t getNbEnemyUnits() const
  {
    return m_enemyUnits.size();
  }

  size_t getNbEnemyUnits(BWAPI::UnitType unitType) const
  {
    return m_enemyUnits.count(unitType);
  }

  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()
  {
    std::pair<enemy_building_iterator, enemy_building_iterator> enemyBuildings = getEnemyBuildings();
    updateUnits(enemyBuildings.first, enemyBuildings.second);
  }

  void updateEnemyUnits()
  {
    std::pair<enemy_unit_iterator, enemy_unit_iterator> enemyUnits = getEnemyUnits();
    updateUnits(enemyUnits.first, enemyUnits.second);
  }

#pragma endregion Enemy_Units

#pragma region Neutral_Units

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

  std::pair<neutral_unit_const_iterator, neutral_unit_const_iterator> 
    getNeutralUnits() const
  {
    return std::make_pair(neutral_unit_const_iterator(neutral_unit_wrapper_const_iterator(m_neutralUnits.begin())),
                          neutral_unit_const_iterator(neutral_unit_wrapper_const_iterator(m_neutralUnits.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_neutralUnits.equal_range(unitType);
    return std::make_pair(neutral_unit_type_iterator(neutral_unit_wrapper_iterator(iterators.first)), 
                          neutral_unit_type_iterator(neutral_unit_wrapper_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_neutralUnits.equal_range(unitType);
    return std::make_pair(neutral_unit_type_const_iterator(neutral_unit_wrapper_const_iterator(iterators.first)), 
                          neutral_unit_type_const_iterator(neutral_unit_wrapper_const_iterator(iterators.second)));
  }

  std::pair<neutral_building_iterator, neutral_building_iterator>
    getNeutralBuildings()
  {
    std::pair<neutral_building_wrapper_iterator, neutral_building_wrapper_iterator> neutralWrappers = getNeutralBuildingWrappers();
    return std::make_pair(neutral_building_iterator(neutralWrappers.first), 
                          neutral_building_iterator(neutralWrappers.second));
  }

  std::pair<neutral_building_const_iterator, neutral_building_const_iterator>
    getNeutralBuildings() const
  {
    std::pair<neutral_building_wrapper_const_iterator, neutral_building_wrapper_const_iterator> neutralWrappers = getNeutralBuildingWrappers();
    return std::make_pair(neutral_building_const_iterator(neutralWrappers.first), 
                          neutral_building_const_iterator(neutralWrappers.second));
  }

  size_t getNbNeutralUnits() const
  {
    return m_neutralUnits.size();
  }

  size_t getNbNeutralUnits(BWAPI::UnitType unitType) const
  {
    return m_neutralUnits.count(unitType);
  }

  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()
  {
    std::pair<neutral_building_iterator, neutral_building_iterator> neutralBuildings = getNeutralBuildings();
    updateUnits(neutralBuildings.first, neutralBuildings.second);
  }

  void updateNeutralUnits()
  {
    std::pair<neutral_unit_iterator, neutral_unit_iterator> neutralUnits = getNeutralUnits();
    updateUnits(neutralUnits.first, neutralUnits.second);
  }

#pragma endregion Neutral_Units

  void onUnitDestroy(void* data);
  void onUnitMorph(void* data);
  void onUnitRenegade(void* data);
  void onUnitEvade(void* data);

protected:
  friend class PerceptualState;

  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(PrimitiveLocation* location)
    {
      return location->m_ownUnits;
    }
  };
  template <>
  struct UnitManagement<EnemyUnit> : public StaticLocation::UnitManagement<EnemyUnit>
  {
    static stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>>& getUnits(PrimitiveLocation* location)
    {
      return location->m_enemyUnits;
    }
  };
  template <>
  struct UnitManagement<NeutralUnit> : public StaticLocation::UnitManagement<NeutralUnit>
  {
    static stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>>& getUnits(PrimitiveLocation* location)
    {
      return location->m_neutralUnits;
    }
  };
  template <class UnitType> friend struct UnitManagement;

  void onUnitDiscover(BWAPI::Unit* unit);

  std::pair<own_unit_iterator, own_unit_iterator> 
    getOwnUnits()
  {
    return std::make_pair(own_unit_iterator(own_unit_wrapper_iterator(m_ownUnits.begin())),
                          own_unit_iterator(own_unit_wrapper_iterator(m_ownUnits.end())));
  }

  std::pair<own_unit_wrapper_iterator, own_unit_wrapper_iterator> 
    getOwnUnitWrappers()
  {
    return std::make_pair(own_unit_wrapper_iterator(m_ownUnits.begin()), 
                          own_unit_wrapper_iterator(m_ownUnits.end()));
  }

  std::pair<own_unit_wrapper_const_iterator, own_unit_wrapper_const_iterator> 
    getOwnUnitWrappers() const
  {
    return std::make_pair(own_unit_wrapper_const_iterator(m_ownUnits.begin()), 
                          own_unit_wrapper_const_iterator(m_ownUnits.end()));
  }

  std::pair<enemy_unit_wrapper_iterator, enemy_unit_wrapper_iterator> 
    getEnemyUnitWrappers()
  {
    return std::make_pair(enemy_unit_wrapper_iterator(m_enemyUnits.begin()), 
                          enemy_unit_wrapper_iterator(m_enemyUnits.end()));
  }

  std::pair<enemy_unit_wrapper_const_iterator, enemy_unit_wrapper_const_iterator> 
    getEnemyUnitWrappers() const
  {
    return std::make_pair(enemy_unit_wrapper_const_iterator(m_enemyUnits.begin()), 
                          enemy_unit_wrapper_const_iterator(m_enemyUnits.end()));
  }

  std::pair<enemy_building_wrapper_iterator, enemy_building_wrapper_iterator> 
    getEnemyBuildingWrappers()
  {
    std::pair<enemy_unit_wrapper_iterator, enemy_unit_wrapper_iterator> unitWrappers = getEnemyUnitWrappers();
    return std::make_pair(enemy_building_wrapper_iterator(WrapperIsBuilding(), unitWrappers.first, unitWrappers.second), 
                          enemy_building_wrapper_iterator(WrapperIsBuilding(), unitWrappers.second, unitWrappers.second));
  }

  std::pair<enemy_building_wrapper_const_iterator, enemy_building_wrapper_const_iterator> 
    getEnemyBuildingWrappers() const
  {
    std::pair<enemy_unit_wrapper_const_iterator, enemy_unit_wrapper_const_iterator> unitWrappers = getEnemyUnitWrappers();
    return std::make_pair(enemy_building_wrapper_const_iterator(WrapperIsBuilding(), unitWrappers.first, unitWrappers.second), 
                          enemy_building_wrapper_const_iterator(WrapperIsBuilding(), unitWrappers.second, unitWrappers.second));
  }

  std::pair<neutral_unit_wrapper_iterator, neutral_unit_wrapper_iterator> 
    getNeutralUnitWrappers()
  {
    return std::make_pair(neutral_unit_wrapper_iterator(m_neutralUnits.begin()), 
                          neutral_unit_wrapper_iterator(m_neutralUnits.end()));
  }

  std::pair<neutral_unit_wrapper_const_iterator, neutral_unit_wrapper_const_iterator> 
    getNeutralUnitWrappers() const
  {
    return std::make_pair(neutral_unit_wrapper_const_iterator(m_neutralUnits.begin()), 
                          neutral_unit_wrapper_const_iterator(m_neutralUnits.end()));
  }

  std::pair<neutral_building_wrapper_iterator, neutral_building_wrapper_iterator> 
    getNeutralBuildingWrappers()
  {
    std::pair<neutral_unit_wrapper_iterator, neutral_unit_wrapper_iterator> unitWrappers = getNeutralUnitWrappers();
    return std::make_pair(neutral_building_wrapper_iterator(WrapperIsBuilding(), unitWrappers.first, unitWrappers.second), 
                          neutral_building_wrapper_iterator(WrapperIsBuilding(), unitWrappers.second, unitWrappers.second));
  }

  std::pair<neutral_building_wrapper_const_iterator, neutral_building_wrapper_const_iterator> 
    getNeutralBuildingWrappers() const
  {
    std::pair<neutral_unit_wrapper_const_iterator, neutral_unit_wrapper_const_iterator> unitWrappers = getNeutralUnitWrappers();
    return std::make_pair(neutral_building_wrapper_const_iterator(WrapperIsBuilding(), unitWrappers.first, unitWrappers.second), 
                          neutral_building_wrapper_const_iterator(WrapperIsBuilding(), unitWrappers.second, unitWrappers.second));
  }

  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();
  }

  template <class UnitIterator>
  void updateUnits(UnitIterator unitBegin, UnitIterator unitEnd);

  class UpdateOwnUnit
  {
  public:
    UpdateOwnUnit(PrimitiveLocation* thisLocation)
      : m_thisLocation(thisLocation)
    {}
    void update(OwnUnit* ownUnit)
    {
      PrimitiveLocation* newLocation = m_thisLocation->getHostLocation(ownUnit->getUnit());
      if (newLocation != m_thisLocation)
      {
        m_thisLocation->transferUnitTo(ownUnit, newLocation);
      }
    }
  protected:
    PrimitiveLocation* const m_thisLocation;
  };
  friend class UpdateOwnUnit;

  class UpdateForeignUnit
  {
  public:
    UpdateForeignUnit(PrimitiveLocation* thisLocation)
      : m_thisLocation(thisLocation)
    {}
    template <class UnitType>
    void update(UnitType* unitType)
    {
      if (unitType->isAccessible())
      {   
        PrimitiveLocation* newLocation = m_thisLocation->getHostLocation(unitType->getUnit());
        if (newLocation != m_thisLocation)
        {
          m_thisLocation->transferUnitTo(unitType, newLocation);
        }
      }
      else
      {
        // Remove unit if its last known position is visible but the building isn't there anymore (since the building was destroyed or moved away)
        assert(Spar->getPerceptualState().getHostLocation(unitType->getLastKnownState()) == m_thisLocation);

        const typename UnitType::SavedState& state = unitType->getLastKnownState();
        if (Spar->getPerceptualState().tileInSight(state.getTilePosition(), state.getType()))
        {
          m_thisLocation->removeUnit(unitType);
        }
      }
    }
  protected:
    PrimitiveLocation* const m_thisLocation;
  };
  friend class UpdateForeignUnit;

private:
  
  template <class UnitType>
  void onUnitDestroy(UnitType* unitWrapper);
  template <class UnitType>
  void onUnitMorph(UnitType* unitWrapper);
  template <class UnitType>
  void onUnitRenegade(UnitType* unitWrapper);
  template <class UnitType>
  void onUnitEvade(UnitType* unitWrapper);

  PrimitiveLocation* getHostLocation(BWAPI::Unit* unit);

  template <class UnitType>
  UnitWrapper<UnitType>* transferUnitTo(UnitType* unitWrapper, PrimitiveLocation* toLocation);
  template <class UnitType>
  UnitWrapper<UnitType>* transferUnitFrom(UnitType* unit, PrimitiveLocation* fromLocation);

  void addUnit(BWAPI::Unit* unit);
  template <class UnitType>
  UnitWrapper<UnitType>* addUnit(BWAPI::Unit* unit);
  template <class UnitType>
  UnitWrapper<UnitType>* addUnitInternal(UnitType* unit);

  void updateUnit(BWAPI::Unit* unit);

  void removeUnit(BWAPI::Unit* unit);
  template <class UnitType>
  void removeUnit(UnitType* unitWrapper);
  template <class UnitType>
  void removeUnitInternal(UnitType* unit);

  EVENT_HANDLER(PrimitiveLocation, onUnitDestroy) m_unitDestroyEventHandler;
  EVENT_HANDLER(PrimitiveLocation, onUnitEvade) m_unitEvadeEventHandler;
  EVENT_HANDLER(PrimitiveLocation, onUnitMorph) m_unitMorphEventHandler;
  EVENT_HANDLER(PrimitiveLocation, onUnitRenegade) m_unitRenegadeEventHandler;

  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<OwnUnit>> m_ownUnits;

  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<EnemyUnit>> m_enemyUnits;

  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<NeutralUnit>> m_neutralUnits;
};

template <class UnitType>
void PrimitiveLocation::onUnitDestroy(UnitType* unitType)
{
  unitType->markAsAccessible();

  removeUnit(unitType);
}

template <class UnitType>
void PrimitiveLocation::onUnitMorph(UnitType* unitType)
{
  BWAPI::Unit* unit = unitType->getUnit();

  // If player has changed the modifications will be handled in the next onUnitRenegade event
  if (unitType->getPlayer() == unit->getPlayer())
  {
    // TODO: no UnitRemoved/UnitAdded events should be raised here

    if (unitType->getLastType() != unit->getType())
    {
      removeUnit(unitType);

      getHostLocation(unit)->addUnit(unit);

      // ################################################
      //other possible implementation: no events
      //removeUnitInternal(unitWrapper);
      //unitWrapper = addUnitInternal(unit);
      //if (m_parent != NULL)
      //  m_parent->onUnitMorphed(unit);
      //PrimitiveLocation* newLocation = getHostLocation(unit->getUnit());
      //if (newLocation != this)
      //{
      //  transferUnitTo(unitWrapper, newLocation);
      //}
    }
  }
}

template <class UnitType>
void PrimitiveLocation::onUnitRenegade(UnitType* unitType)
{
  BWAPI::Unit* unit = unitType->getUnit();

  if (unitType->getPlayer() != unit->getPlayer())
  {
    removeUnit(unitType);

    getHostLocation(unit)->addUnit(unit);
  }
}

template <class UnitType>
void PrimitiveLocation::onUnitEvade(UnitType* unitType)
{
  BWAPI::Unit* unit = unitType->getUnit();
  assert(unit->getType() == unitType->getType());
  assert(unit->getPlayer() == unitType->getPlayer());

  if (KEEP_UNITS_IN_FOG_OF_WAR || unit->getType().isBuilding())
  {
    UnitWrapper<UnitType>* unitWrapper = static_cast<UnitWrapper<UnitType>*>(unitType->m_primitiveLocationData);
    PrimitiveLocation* newLocation = getHostLocation(unit);
    if (newLocation != this)
    {
      UnitWrapper<UnitType>* otherLocationWrapper = transferUnitTo(unitType, newLocation);
      unitWrapper = otherLocationWrapper;
    }
    //Spar->getUnitManager().unsubscribeIndividualUnitDestroy(unit, unitWrapper->m_unitDestroyID);
    Spar->getUnitManager().unsubscribeIndividualUnitEvade(unit, unitWrapper->m_unitEvadeID);
    Spar->getUnitManager().unsubscribeIndividualUnitMorph(unit, unitWrapper->m_unitMorphID);
    Spar->getUnitManager().unsubscribeIndividualUnitRenegade(unit, unitWrapper->m_unitRenegadeID);

    unitType->markAsInaccessible();
  }
  else
  {
    removeUnit(unitType);
  }
}

template <class UnitType>
PrimitiveLocation::UnitWrapper<UnitType>* PrimitiveLocation::addUnit(BWAPI::Unit* unit)
{
  UnitType* unitType = new UnitType(unit, this);

  UnitWrapper<UnitType>* unitWrapper = addUnitInternal(unitType);

  if (boost::is_same<UnitType, EnemyUnit>::value)
  {
    SPAR_LOG(LogTypes::PERCEPTUAL_STATE, "Enemy unit manager: Add \"%s\" to \"%s\"", 
      getObjectDescription(unitType).c_str(),
      getObjectDescription(this).c_str());
  }

  UnitManagement<UnitType>::getUnitAddedEvent(this).raise(unitType);

  if (m_parent != NULL)
    m_parent->onUnitAdded(unitType);

  return unitWrapper;
}

template <class UnitType>
void PrimitiveLocation::removeUnit(UnitType* unitType)
{
  if (boost::is_same<UnitType, EnemyUnit>::value)
  {
    SPAR_LOG(LogTypes::PERCEPTUAL_STATE, "Enemy unit manager: Remove \"%s\" from \"%s\"", 
      getObjectDescription(unitType).c_str(),
      getObjectDescription(this).c_str());
  }

  removeUnitInternal(unitType);
  UnitManagement<UnitType>::getUnitRemovedEvent(this).raise(unitType);

  if (m_parent != NULL)
    m_parent->onUnitRemoved(unitType);

  Spar->addZombieComponent(unitType);
}

template <class UnitType>
PrimitiveLocation::UnitWrapper<UnitType>* PrimitiveLocation::addUnitInternal(UnitType* unitType)
{
  BWAPI::Unit* unit = unitType->m_unit;

  stdext::hash_multimap<BWAPI::UnitType, UnitWrapper<UnitType>>::iterator it = 
    UnitManagement<UnitType>::getUnits(this).insert(std::make_pair(unit->getType().getID(), UnitWrapper<UnitType>(unitType)));
  UnitWrapper<UnitType>& unitWrapper = it->second;
  unitWrapper.m_posInContainer = it;
  if (unitType->isAccessible())
  {
    unitWrapper.m_unitDestroyID = Spar->getUnitManager().subscribeIndividualUnitDestroy(unit, &m_unitDestroyEventHandler, unitType);
    unitWrapper.m_unitEvadeID = Spar->getUnitManager().subscribeIndividualUnitEvade(unit, &m_unitEvadeEventHandler, unitType);
    unitWrapper.m_unitMorphID = Spar->getUnitManager().subscribeIndividualUnitMorph(unit, &m_unitMorphEventHandler, unitType);
    unitWrapper.m_unitRenegadeID = Spar->getUnitManager().subscribeIndividualUnitRenegade(unit, &m_unitRenegadeEventHandler, unitType);
  }
  unitType->m_primitiveLocationData = &unitWrapper;
  unitType->updateLocation(this);
  Spar->getUnitManager().setUnitLocation(unit, this, unitType);

  assert(&unitWrapper.m_posInContainer->second == &unitWrapper);
  assert(Spar->getUnitManager().getUnitData(unit).m_data == unitType);

  return &unitWrapper;
}

template <class UnitType>
void PrimitiveLocation::removeUnitInternal(UnitType* unitType)
{
  BWAPI::Unit* unit = unitType->m_unit; // To avoid the assert() in getUnit()

  UnitWrapper<UnitType>* unitWrapper = static_cast<UnitWrapper<UnitType>*>(unitType->m_primitiveLocationData);
  Spar->getUnitManager().unsubscribeIndividualUnitDestroy(unit, unitWrapper->m_unitDestroyID);
  Spar->getUnitManager().unsubscribeIndividualUnitEvade(unit, unitWrapper->m_unitEvadeID);
  Spar->getUnitManager().unsubscribeIndividualUnitMorph(unit, unitWrapper->m_unitMorphID);
  Spar->getUnitManager().unsubscribeIndividualUnitRenegade(unit, unitWrapper->m_unitRenegadeID);

  UnitManagement<UnitType>::getUnits(this).erase(unitWrapper->m_posInContainer);
  unitType->m_primitiveLocationData = NULL;
  Spar->getUnitManager().getUnitData(unit).m_data = NULL;
}

template <class UnitType>
PrimitiveLocation::UnitWrapper<UnitType>* PrimitiveLocation::transferUnitFrom(UnitType* unit, PrimitiveLocation* fromLocation)
{
  PrimitiveLocation::UnitWrapper<UnitType>* unitWrapper = addUnitInternal(unit);
  UnitManagement<UnitType>::getUnitAddedEvent(this).raise(unit);

  if (m_parent != NULL)
    m_parent->onUnitTransferred(unit, fromLocation, this);

  return unitWrapper;
}

template <class UnitType>
PrimitiveLocation::UnitWrapper<UnitType>* PrimitiveLocation::transferUnitTo(UnitType* unitType, PrimitiveLocation* toLocation)
{
  if (boost::is_same<UnitType, EnemyUnit>::value)
  {
    SPAR_LOG(LogTypes::PERCEPTUAL_STATE, "Enemy unit manager: Transfer \"%s\" from \"%s\" to \"%s\"", 
      getObjectDescription(unitType).c_str(),
      getObjectDescription(this).c_str(),
      getObjectDescription(toLocation).c_str());
  }

  if (m_parent != NULL)
    m_parent->onUnitTransferred(unitType, this, toLocation);

  removeUnitInternal(unitType);

  UnitWrapper<UnitType>* toLocationWrapper = toLocation->transferUnitFrom(unitType, this);

  UnitManagement<UnitType>::getUnitRemovedEvent(this).raise(unitType);

  return toLocationWrapper;
}

template <class UnitIterator>
void PrimitiveLocation::updateUnits(UnitIterator unitBegin, UnitIterator unitEnd)
{
  static_if_else<boost::is_same<typename UnitIterator::value_type, OwnUnit*>::value, UpdateOwnUnit, UpdateForeignUnit>::type updater(this);

  while (unitBegin != unitEnd)
  {
    UnitIterator next = ++(UnitIterator(unitBegin));
    typename UnitIterator::value_type unit = *unitBegin;

    updater.update(unit);

    unitBegin = next;
  }
}