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

Go to the documentation of this file.

#pragma once
#include "CompositeLocation.h"
#include "BaseLocation.h"
#include "Chokepoint.h"
#include "Region.h"
#include "AirLocation.h"
#include <hash_map>

class Map : public virtual CompositeLocation
{
public:
  typedef boost::transform_iterator<extract_pair_second<stdext::hash_map<const BWTA::Chokepoint*, Chokepoint*>::iterator::value_type>, 
                                    stdext::hash_map<const BWTA::Chokepoint*, Chokepoint*>::iterator> 
          chokepoint_iterator;
  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_map<const BWTA::Chokepoint*, Chokepoint*>::const_iterator::value_type>, 
                                    stdext::hash_map<const BWTA::Chokepoint*, Chokepoint*>::const_iterator> 
          chokepoint_const_iterator;  
  typedef boost::transform_iterator<extract_pair_second<stdext::hash_map<const BWTA::Region*, Region*>::iterator::value_type>, 
                                    stdext::hash_map<const BWTA::Region*, Region*>::iterator> 
          region_iterator;
  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_map<const BWTA::Region*, Region*>::const_iterator::value_type>, 
                                    stdext::hash_map<const BWTA::Region*, Region*>::const_iterator> 
          region_const_iterator;  
  typedef boost::transform_iterator<extract_pair_second<stdext::hash_map<const BWTA::BaseLocation*, BaseLocation*>::iterator::value_type>, 
                                    stdext::hash_map<const BWTA::BaseLocation*, BaseLocation*>::iterator> 
          base_location_iterator;
  typedef boost::transform_iterator<extract_pair_second_const<stdext::hash_map<const BWTA::BaseLocation*, BaseLocation*>::const_iterator::value_type>, 
                                    stdext::hash_map<const BWTA::BaseLocation*, BaseLocation*>::const_iterator> 
          base_location_const_iterator;

  template <class LocationTypes>
  Map(LocationTypes*)
    : CompositeLocation(NULL)
    , StaticLocation(NULL)
    , m_ownStartBaseLocation(NULL)
    , m_airLocation(LocationTypes::instantiateAirLocation(this))
  {
    addSubLocation(m_airLocation);

    for(std::set<BWTA::Region*>::const_iterator itRegion = BWTA::getRegions().begin(); itRegion != BWTA::getRegions().end(); ++itRegion)
    {
      Region* region = LocationTypes::instantiateRegion(*itRegion, this);
      m_regionsCache.insert(std::make_pair(*itRegion, region));
      addSubLocation(region);

      for (std::set<BaseLocation*>::const_iterator itBaseLocation = region->getBaseLocations().begin(); itBaseLocation != region->getBaseLocations().end(); ++itBaseLocation)
      {
        BaseLocation* baseLocation = *itBaseLocation;
        m_baseLocationsCache.insert(std::make_pair(baseLocation->getBWTABaseLocation(), baseLocation));
      }
    }

    for (std::set< BWAPI::TilePosition >::const_iterator itStartLocation = BWAPI::Broodwar->getStartLocations().begin(); itStartLocation != BWAPI::Broodwar->getStartLocations().end(); ++itStartLocation)
    {
      stdext::hash_map<const BWTA::BaseLocation*, BaseLocation*>::iterator it = m_baseLocationsCache.find(BWTA::getNearestBaseLocation(*itStartLocation));
      if (it != m_baseLocationsCache.end())
        m_startBaseLocationsCache.insert(it->second);
    }

#ifdef _DEBUG
    for(std::set<BWTA::BaseLocation*>::const_iterator itBaseLocation = BWTA::getBaseLocations().begin(); itBaseLocation != BWTA::getBaseLocations().end(); ++itBaseLocation)
    {
      assert(m_baseLocationsCache.find(*itBaseLocation) != m_baseLocationsCache.end());
    }
#endif
    for(std::set<BWTA::Chokepoint*>::const_iterator itChokepoint = BWTA::getChokepoints().begin(); itChokepoint != BWTA::getChokepoints().end(); ++itChokepoint)
    {
      if(
        // Remove chokepoint blocked by generators in benzene
        ((*itChokepoint)->getSides().first == BWAPI::Position(4000, 1088) && (*itChokepoint)->getSides().second == BWAPI::Position(4088, 1088))
        || ((*itChokepoint)->getSides().first == BWAPI::Position(0, 1064) && (*itChokepoint)->getSides().second == BWAPI::Position(88, 1064))
        // Remove chokepoint blocked by minerals in Destination
        || ((*itChokepoint)->getSides().first == BWAPI::Position(1708, 204) && (*itChokepoint)->getSides().second == BWAPI::Position(1752, 248))
        || ((*itChokepoint)->getSides().first == BWAPI::Position(1288, 3832) && (*itChokepoint)->getSides().second == BWAPI::Position(1331, 3870))
        // Remove chokepoint blocked by doors in Fortress
        || ((*itChokepoint)->getSides().first == BWAPI::Position(744, 3304) && (*itChokepoint)->getSides().second == BWAPI::Position(784, 3320))
        || ((*itChokepoint)->getSides().first == BWAPI::Position(808, 848) && (*itChokepoint)->getSides().second == BWAPI::Position(848, 840))
        || ((*itChokepoint)->getSides().first == BWAPI::Position(3112, 904) && (*itChokepoint)->getSides().second == BWAPI::Position(3152, 920))
        || ((*itChokepoint)->getSides().first == BWAPI::Position(3424, 3374) && (*itChokepoint)->getSides().second == BWAPI::Position(3472, 3368))
        )
      {
        //TODO: Handle those chokepoint in a better way
        unused(itChokepoint);
      } else {
        std::pair<BWTA::Region*, BWTA::Region*> connectedRegions = (*itChokepoint)->getRegions();
        Region* firstRegion = m_regionsCache.find(connectedRegions.first)->second;
        Region* secondRegion = m_regionsCache.find(connectedRegions.second)->second;
        Chokepoint* chokepoint = LocationTypes::instantiateChokepoint(*itChokepoint, firstRegion, secondRegion, this);
        m_chokepointsCache.insert(std::make_pair(*itChokepoint, chokepoint));
        firstRegion->addChokepoint(chokepoint);
        secondRegion->addChokepoint(chokepoint);
        addSubLocation(chokepoint);
      }
    }

    //
    // Add players' stuff AFTER creating the map structures (so that possible subscribers can use them)
    //
    for(std::set<BWAPI::Unit*>::const_iterator itUnit = BWAPI::Broodwar->self()->getUnits().begin(); itUnit != BWAPI::Broodwar->self()->getUnits().end(); ++itUnit)
    {
      if((*itUnit)->getType() == BWAPI::UnitTypes::Protoss_Nexus)
      {
        for (stdext::hash_map<const BWTA::BaseLocation*, BaseLocation*>::const_iterator it2 = m_baseLocationsCache.begin(); it2 != m_baseLocationsCache.end(); ++it2)
        {
          if (it2->second->getCurrentCenter() == (*itUnit)->getPosition())
          {
            assert(m_ownStartBaseLocation == NULL);
            m_ownStartBaseLocation = it2->second;
            size_t nb = m_startBaseLocationsCache.erase(m_ownStartBaseLocation);
            assert(nb == 1);
          }
        }
      }
    }
  }

  ~Map()
  {
    delete m_airLocation;
    for (stdext::hash_map<const BWTA::Region*, Region*>::iterator it = m_regionsCache.begin(); it != m_regionsCache.end(); ++it)
    {
      delete it->second;
    }
    for (stdext::hash_map<const BWTA::Chokepoint*, Chokepoint*>::iterator it = m_chokepointsCache.begin(); it != m_chokepointsCache.end(); ++it)
    {
      delete it->second;
    }
  }

  bool isInLocation(BWAPI::Position position) const
  {
    unused(position);

    return true;
  }

  virtual BWAPI::Position getCurrentCenter() const
  {
    int y = BWAPI::Broodwar->mapHeight() * TILE_SIZE;
    int x = BWAPI::Broodwar->mapWidth() * TILE_SIZE;
    return BWAPI::Position(x/2,y/2);
  }

  Chokepoint* getChokepoint(const BWTA::Chokepoint* chokepoint)
  {
    return m_chokepointsCache.find(chokepoint)->second;
  }

  Region* getRegion(const BWTA::Region* region)
  {
    return m_regionsCache.find(region)->second;
  }

  BaseLocation* getBaseLocation(const BWTA::BaseLocation* baseLocation)
  {
    return m_baseLocationsCache.find(baseLocation)->second;
  }

  const std::set<BaseLocation*>& getEnemyPossibleStartBaseLocations()
  {
    return m_startBaseLocationsCache;
  }

  BaseLocation* getOwnStartBaseLocation()
  {
    return m_ownStartBaseLocation;
  }

  AirLocation* getAirLocation() { return m_airLocation; }
  const AirLocation* getAirLocation() const { return m_airLocation; }

  chokepoint_iterator chokepointsBegin() { return chokepoint_iterator(m_chokepointsCache.begin()); }
  chokepoint_iterator chokepointsEnd() { return chokepoint_iterator(m_chokepointsCache.end()); }
  chokepoint_const_iterator chokepointsBegin() const { return chokepoint_const_iterator(m_chokepointsCache.begin()); }
  chokepoint_const_iterator chokepointsEnd() const { return chokepoint_const_iterator(m_chokepointsCache.end()); }
  size_t getNbChokepoints() const { return m_chokepointsCache.size(); }

  region_iterator regionsBegin() { return region_iterator(m_regionsCache.begin()); }
  region_iterator regionsEnd() { return region_iterator(m_regionsCache.end()); }
  region_const_iterator regionsBegin() const { return region_const_iterator(m_regionsCache.begin()); }
  region_const_iterator regionsEnd() const { return region_const_iterator(m_regionsCache.end()); }
  size_t getNbRegions() const { return m_regionsCache.size(); }
  
  base_location_iterator baseLocationsBegin() { return base_location_iterator(m_baseLocationsCache.begin()); }
  base_location_iterator baseLocationsEnd() { return base_location_iterator(m_baseLocationsCache.end()); }
  base_location_const_iterator baseLocationsBegin() const { return base_location_const_iterator(m_baseLocationsCache.begin()); }
  base_location_const_iterator baseLocationsEnd() const { return base_location_const_iterator(m_baseLocationsCache.end()); }
  size_t getNbBaseLocations() const { return m_baseLocationsCache.size(); }

  DECLARE_EVENT1(OnUnitCompleted, BWAPI::Unit*);
  OnUnitCompleted& getUnitCompletedEvent() const { return m_unitCompletedEvent; }
  DECLARE_EVENT1(OnUnitMorphCompleted, BWAPI::Unit*);
  OnUnitMorphCompleted& getUnitMorphCompletedEvent() const { return m_unitMorphCompletedEvent; }
  
protected:
  virtual void output(std::ostream& out) const
  {
    out << "Map";
  }

  EVENT(OnUnitCompleted) m_unitCompletedEvent;
  EVENT(OnUnitMorphCompleted) m_unitMorphCompletedEvent;

  AirLocation* const m_airLocation;
  stdext::hash_map<const BWTA::Chokepoint*, Chokepoint*> m_chokepointsCache;
  stdext::hash_map<const BWTA::Region*, Region*> m_regionsCache;
  stdext::hash_map<const BWTA::BaseLocation*, BaseLocation*> m_baseLocationsCache;
  std::set<BaseLocation*> m_startBaseLocationsCache;
  BaseLocation* m_ownStartBaseLocation;
};