SPAR/AIModule/SparAIModule/PerceptualState/PerceptualState.h

Go to the documentation of this file.

#pragma once
#include "../PersistentUnitGroup.h"
//#include "../UnitManager.h"
//#include "../UnitData.h"
#include "../Scheduler/SchedulerTask.h"
#include "../Utils/Functors.hpp"
#include "../Utils/Vector2.h"
#include "../Utils/Utils.h"
#include "../Utils/Event.h"
#include "../Utils/UnitGroup.h"
#include "../Utils/Resources.h"
#include "Locations/Common.h"
#include "InfluenceMap/InfluenceMap.h"
#include "InfluenceMap/StructuralImportance.h"
#include "InfluenceMap/Threat.h"
#include "InfluenceMap/Visibility.h"
#include "Tasks/UpdateInfluenceMapTask.h"
#include "Tasks/UpdateBuildingsTask.h"
#include "Tasks/UpdateUnitsTask.h"
#include "Techs/Techs.h"
#include <algorithm>

static const int SAFE_POSITION_RANGE = 3;
static const int DODGE_DISTANCE = 90;

class PerceptualState : public Component
{
public:
  PerceptualState();

  ~PerceptualState();

  template <class LocationTypes, class TechTypes>
  void onStart()
  {
    m_map = LocationTypes::instantiateMap();
    Techs::onStart<TechTypes>(m_map);
    activateTasks();
  }

  void onFrame()
  {
#ifdef DRAW_ON_SCREEN
    if (Spar->getConfiguration().displayMap())
      displayMap();

    if (Spar->getConfiguration().displayEnemyInfluenceMap())
      m_enemyInfluenceMap.display();
    if (Spar->getConfiguration().displaySelfInfluenceMap())
      m_selfInfluenceMap.display();
    if (Spar->getConfiguration().displayVisibilityInfluenceMap())
      m_visibilityInfluenceMap.display();
    if (Spar->getConfiguration().displayStructureInfluenceMap())
      m_structureInfluenceMap.display();
#endif
  }

  void onEnd()
  {
    Techs::onEnd();
  }

  void onUnitDiscover(BWAPI::Unit* unit);
  void onUnitEvade(BWAPI::Unit* unit);
  void onUnitShow(BWAPI::Unit* unit);
  void onUnitHide(BWAPI::Unit* unit);
  void onUnitCreate(BWAPI::Unit* unit);
  void onUnitDestroy(BWAPI::Unit* unit);
  void onUnitMorph(BWAPI::Unit* unit);
  void onUnitRenegade(BWAPI::Unit* unit);

  class ResearchInProgress;
  ResearchInProgress* onResearchStarted(const Process* parent, TechTypeTech* m_tech, BWAPI::Unit* m_building);
  ResearchInProgress* onUpgradeStarted(const Process* parent, UpgradeTypeTech* m_upgrade, BWAPI::Unit* m_building);

  // TODO: all this getUnits() stuff should go in Map, and should return enemy units in fog of war as well
  //       (hence units should be kept on a per-tile basis, as in BWAPI)

  template <class Predicate>
  UnitGroup getUnits(const CircularLocation& location, Predicate predicate) const
  {
    // TODO: this may crash before BWAPI is fixed!
    UnitGroup units(BWAPI::Broodwar->getUnitsInRadius(location.getCurrentCenter(), location.getRadius()));
    UnitGroup::iterator it = units.begin();
    while (it != units.end())
    {
      UnitGroup::iterator next = ++(UnitGroup::iterator(it));
      if (!predicate(*it))
        units.erase(it);
      it = next;
    }
    return units;
  }

  template <class Location>
  UnitGroup getUnits(const Location& lcoation)
  {
    return getUnits(location, True());
  }

  template <class Predicate>
  UnitGroup getUnits(const RectangularLocation& location, Predicate predicate) const
  {
    // TODO: use this when BWAPI is fixed!
    //UnitGroup units(BWAPI::Broodwar->getUnitsInRectangle(location.getTopLeftCorner().makeValid(), location.getBottomRightCorner().makeValid()));
    //UnitGroup::iterator it = units.begin();
    //while (it != units.end())
    //{
    //  UnitGroup::iterator next = ++(UnitGroup::iterator(it));
    //  if (!predicate(*it))
    //    units.erase(it);
    //  it = next;
    //}
    //return units;

    const BWAPI::TilePosition topLeft(location.getTopLeftCorner().makeValid());
    int tileLeft = topLeft.x();
    int tileTop = topLeft.y();
    const BWAPI::TilePosition bottomRight(location.getBottomRightCorner().makeValid());
    int tileRight = bottomRight.x();
    int tileBottom = bottomRight.y();

    UnitGroup allUnits;
    for (int x = tileLeft; x <= tileRight; ++x)
    {
      for (int y = tileTop; y <= tileBottom; ++y)
      {
        const std::set<BWAPI::Unit*>& units = BWAPI::Broodwar->getUnitsOnTile(x, y);
        for (std::set<BWAPI::Unit*>::const_iterator it = units.begin(); it != units.end(); ++it)
        {
          BWAPI::Unit* unit= *it;
          BWAPI::Position pos = unit->getPosition();
          if (is_between<int, true>(location.getTopLeftCorner().x(), location.getBottomRightCorner().x())(pos.x()) &&
              is_between<int, true>(location.getTopLeftCorner().y(), location.getBottomRightCorner().y())(pos.y()) &&
              predicate(unit))
            allUnits.insert(unit);
        }
      }
    }
#ifdef _DEBUG
    for (UnitGroup::const_iterator it = allUnits.begin(); it != allUnits.end(); ++it)
    {
      BWAPI::Position pos = (*it)->getPosition();
      bool isBetweenX = is_between<int, true>(location.getTopLeftCorner().x(), location.getBottomRightCorner().x())(pos.x());
      bool isBetweenY = is_between<int, true>(location.getTopLeftCorner().y(), location.getBottomRightCorner().y())(pos.y());
      assert(isBetweenX && isBetweenY);
    }
#endif
    return allUnits;
  }
  template <class Predicate>
  UnitGroup getUnits(const CircularUnitDynamicLocation& location, Predicate predicate) const
  {
    return getUnits(location.getCircularLocation(), predicate);
  }
  template <class Predicate>
  UnitGroup getUnits(const RectangularGroupDynamicLocation& location, Predicate predicate) const
  {
    if (location.getGroup()->empty())
      return UnitGroup();
    else
      return getUnits(location.getExpandedRectangularLocation(), predicate);
  }

  template <class LocationType>
  UnitGroup getOwnUnits(const LocationType& location) const
  {
    return getUnits(location, IsOwnUnit<BWAPI::Unit>());
  }

  template <class LocationType>
  UnitGroup getEnemyUnits(const LocationType& location) const
  {
    return getUnits(location, IsEnemyUnit<BWAPI::Unit>());
  }

  UnitGroup getEnemiesNearUnit(BWAPI::Unit* unit, int range) const
  {
    return getEnemyUnits(CircularLocation(unit->getPosition(), range));
  }

  bool unitInSight(BWAPI::Unit* unit) const
  {
    return tileInSight(unit->getTilePosition(), unit->getType());
  }

  bool tileInSight(BWAPI::TilePosition tile, BWAPI::UnitType unitType) const;

  //This check if the position is reachable by a ground unit.  
  //It checks if there is a static obstacle and if the position itself is obstructed (either by other units or by static obstacles)
  bool positionIsReachable( const BWAPI::Position& current_pos, const BWAPI::Position& destination) const;

  std::set<BWAPI::Unit*> PerceptualState::getTargetingUnits(BWAPI::Unit* unit) const;
  bool isUnitTargeted(BWAPI::Unit* unit) const;

  BWAPI::Position getGroundFrontier(const BWAPI::Position& position, const double angle) const;

  BWAPI::Position getBorder(const BWAPI::Position& position) const;

  BWAPI::Position getSafeDodgePosition(BWAPI::Unit* unit) const;

  BWAPI::Position getSafeRetreatPosition(BWAPI::Unit* unit) const;

  BWAPI::Position getSafeRetreatPosition(const PersistentUnitGroup* group, const UnitGroup& enemyUnits) const;

  BWAPI::Position getScoutingLocation(BWAPI::Unit* unit, const BWTA::Region* const region) const;

  Map* getMap() { return m_map; }
  const Map* getMap() const { return m_map; }

  PrimitiveLocation* getHostLocation(BWAPI::UnitType unitType, bool isLifted, BWAPI::Position position, BWAPI::TilePosition tilePosition) const;
  PrimitiveLocation* getHostLocation(BWAPI::Unit* unit) const
  {
    return getHostLocation(unit->getType(), unit->isLifted(), unit->getPosition(), unit->getTilePosition());
  }
  PrimitiveLocation* getHostLocation(const EnemyUnit::SavedState& state) const
  {
    return getHostLocation(state.getType(), state.isLifted(), state.getPosition(), state.getTilePosition());
  }

  // Dynamically creating static locations will require events if we allow them to be subsequently deleted

  DECLARE_EVENT1(OnUnitDiscover, BWAPI::Unit*);
  OnUnitDiscover& getUnitDiscoverEvent() const { return m_unitDiscoverEvent; }
  DECLARE_EVENT1(OnUnitEvade, BWAPI::Unit*);
  OnUnitEvade& getUnitEvadeEvent() const { return m_unitEvadeEvent; }
  DECLARE_EVENT1(OnUnitShow, BWAPI::Unit*);
  OnUnitShow& getUnitShowEvent() const { return m_unitShowEvent; }
  DECLARE_EVENT1(OnUnitHide, BWAPI::Unit*);
  OnUnitHide& getUnitHideEvent() const { return m_unitHideEvent; }
  DECLARE_EVENT1(OnUnitCreate, BWAPI::Unit*);
  OnUnitCreate& getUnitCreateEvent() const { return m_unitCreateEvent; }
  DECLARE_EVENT1(OnUnitDestroy, BWAPI::Unit*);
  OnUnitDestroy& getUnitDestroyEvent() const { return m_unitDestroyEvent; }
  DECLARE_EVENT1(OnUnitMorph, BWAPI::Unit*);
  OnUnitMorph& getUnitMorphEvent() const { return m_unitMorphEvent; }
  DECLARE_EVENT1(OnUnitRenegade, BWAPI::Unit*);
  OnUnitRenegade& getUnitRenegadeEvent() const { return m_unitRenegadeEvent; }

  typedef Map::OnUnitCompleted OnUnitCompleted;
  OnUnitCompleted& getUnitCompletedEvent() const
  {
    return m_map->getUnitCompletedEvent();
  }

  typedef Map::OnUnitMorphCompleted OnUnitMorphCompleted;
  OnUnitMorphCompleted& getUnitMorphCompletedEvent() const
  {
    return m_map->getUnitMorphCompletedEvent();
  }

  class ResearchInProgress : public Process
  {
  public:
    ResearchInProgress(const Process* parent, BWAPI::Unit* unit, TechTypeTech* tech);
    ResearchInProgress(const Process* parent, BWAPI::Unit* unit, UpgradeTypeTech* upgrade);
    void onTimeout();
    void onUnitDestroyed(void* data);
    void cancel();
    // GUI //
    virtual std::set<BWAPI::Unit*> getCommandedUnits() const
    {
      return std::set<BWAPI::Unit*>(&m_building, &m_building + 1);
    }
    static const TerminationMode ResearchCancelled;
    static const TerminationMode BuildingDestroyed;
  protected:
    virtual void output(std::ostream& out) const;
    virtual void executeImpl();
    virtual void terminateImpl();

    BWAPI::Unit* const m_building;
    UpgradeTypeTech* const m_upgrade;
    TechTypeTech* const m_tech;
    SCHEDULER_EVENT(ResearchInProgress, onTimeout) m_timeoutEvent;
    Event<boost::tuples::tuple<>>::SubscriberID m_unitDestroyedSubscriberId;
    EVENT_HANDLER(ResearchInProgress, onUnitDestroyed) m_unitDestroyedEventHandler;
  };

private:
  friend class ResearchInProgress;

  // TODO: this should be a process
  class UnitInConstruction : public Component
  {
  public:
    UnitInConstruction(BWAPI::Unit* unit);
    UnitInConstruction(const UnitInConstruction& other);
    void setPosInContainer(stdext::hash_map<BWAPI::Unit*, UnitInConstruction>::iterator posInContainer) { m_posInContainer = posInContainer; }
    stdext::hash_map<BWAPI::Unit*, UnitInConstruction>::iterator getPosInContainer() const { return m_posInContainer; }
    void execute();
    void onTimeout();
    void onUnitDestroyed(void* data);
    void externalTerminate()
    {
      terminate();
    }
  private:
    void terminate();

    BWAPI::Unit* const m_unitInConstruction;
    SCHEDULER_EVENT(UnitInConstruction, onTimeout) m_timeoutEvent;
    Event<boost::tuples::tuple<>>::SubscriberID m_unitDestroyedSubscriberId;
    EVENT_HANDLER(UnitInConstruction, onUnitDestroyed) m_unitDestroyedEventHandler;
    stdext::hash_map<BWAPI::Unit*, UnitInConstruction>::iterator m_posInContainer;
  };
  friend class UnitInConstruction;
  
  class UnitMorphing : public Component
  {
  public:
    UnitMorphing(BWAPI::Unit* unit);
    UnitMorphing(const UnitMorphing& other);
    void setPosInContainer(stdext::hash_map<BWAPI::Unit*, UnitMorphing>::iterator posInContainer) { m_posInContainer = posInContainer; }
    stdext::hash_map<BWAPI::Unit*, UnitMorphing>::iterator getPosInContainer() const { return m_posInContainer; }
    void execute();
    void onTimeout();
    void onUnitDestroyed(void* data);
    void externalTerminate()
    {
      terminate();
    }
  private:
    void terminate();

    BWAPI::Unit* const m_unitMorphing;
    SCHEDULER_EVENT(UnitMorphing, onTimeout) m_timeoutEvent;
    Event<boost::tuples::tuple<>>::SubscriberID m_unitDestroyedSubscriberId;
    EVENT_HANDLER(UnitMorphing, onUnitDestroyed) m_unitDestroyedEventHandler;
    stdext::hash_map<BWAPI::Unit*, UnitMorphing>::iterator m_posInContainer;
  };
  friend class UnitMorphing;


  void monitorUnitCompletion(BWAPI::Unit* unit);
  void activateTasks();
  void displayMap();

  void onUnitInConstructionTerminate(UnitInConstruction* unitInConstruction)
  {
    m_unitsInConstruction.erase(unitInConstruction->getPosInContainer());
  }

  void onUnitMorphingTerminate(UnitMorphing* unitMorphing)
  {
    m_unitsMorphing.erase(unitMorphing->getPosInContainer());
  }

  stdext::hash_map<BWAPI::Unit*, UnitInConstruction> m_unitsInConstruction;
  stdext::hash_map<BWAPI::Unit*, UnitMorphing> m_unitsMorphing;

  Map* m_map;

  // Events
  EVENT(OnUnitDiscover) m_unitDiscoverEvent;
  EVENT(OnUnitEvade) m_unitEvadeEvent;
  EVENT(OnUnitShow) m_unitShowEvent;
  EVENT(OnUnitHide) m_unitHideEvent;
  EVENT(OnUnitCreate) m_unitCreateEvent;
  EVENT(OnUnitDestroy) m_unitDestroyEvent;
  EVENT(OnUnitMorph) m_unitMorphEvent;
  EVENT(OnUnitRenegade) m_unitRenegadeEvent;

  // Influence maps
  InfluenceMap<Threat> m_enemyInfluenceMap;
  InfluenceMap<Threat> m_selfInfluenceMap;
  InfluenceMap<Visibility> m_visibilityInfluenceMap;
  InfluenceMap<StructuralImportance> m_structureInfluenceMap;

  // Tasks
  UpdateInfluenceMapTask<Threat> m_updateEnemyThreatInfluenceMap;
  UpdateInfluenceMapTask<Threat> m_updateSelfThreatInfluenceMap;
  UpdateInfluenceMapTask<Visibility> m_updateVisibilityInfluenceMap;
  UpdateInfluenceMapTask<StructuralImportance> m_updateStructuralImportanceInfluenceMap;
  UpdateBuildingsTask* m_updateBuildings;
  UpdateUnitsTask* m_updateUnits;
};