SPAR/AIModule/SparAIModule/SparAIModule.h

Go to the documentation of this file.

#pragma once
#include "SparAIContainer.h"
#include "PerceptualState/PerceptualState.h"
#include "Scheduler/Scheduler.h"
#include "Scheduler/Timer.h"
#include "SparObserver.h"
#include "UnitManagerImpl.h"
#include "Utils/Logger.h"
#include "Scheduler/Timer.h"

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
class SparAIModule : public SparAIContainer
{
public:
  SparAIModule();
  ~SparAIModule();

  S1& getS1() { return *m_layer1SituationAnalysis; }
  S2& getS2() { return *m_layer2SituationAnalysis; }
  S3& getS3() { return *m_layer3SituationAnalysis; }
  S4& getS4() { return *m_layer4SituationAnalysis; }

  D1& getD1() { return m_layer1DecisionMaking; }
  D2& getD2() { return m_layer2DecisionMaking; }
  D3& getD3() { return m_layer3DecisionMaking; }
  D4& getD4() { return m_layer4DecisionMaking; }

  void addObserver(SparObserver* observer)
  {
    m_observers.push_back(observer);
  }

  virtual void onStart();
  virtual void onEnd(bool isWinner);
  virtual void onFrame();
  virtual void onSendText(std::string text);

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

  void showStats();
  void showPlayers();
  void showForces();

  // GUI //
  virtual std::set<BWAPI::Unit*> getCommandedUnits() const
  {
    return std::set<BWAPI::Unit*>();
  }

protected:

#pragma region SparLocations

  struct LocationTypes
  {
    class SparAirLocation : public D2::LocationTypes<AirLocation>::Type, 
                            public D3::LocationTypes<AirLocation>::Type,
                            public virtual AirLocation
    {
    public:
      SparAirLocation(Map* parent)
        : D2::LocationTypes<AirLocation>::Type((LocationTypes*)NULL, parent)
        , D3::LocationTypes<AirLocation>::Type((LocationTypes*)NULL, parent)
        , AirLocation((LocationTypes*)NULL, parent)
        , PrimitiveLocation(parent)
        , StaticLocation(parent)
      {}
      virtual BWAPI::Position getCurrentCenter() const { return AirLocation::getCurrentCenter(); }
    protected:
      //virtual void output(std::ostream& out) const { AirLocation::output(out); }
    };

    class SparBaseLocation : public D2::LocationTypes<BaseLocation>::Type, 
                             public D3::LocationTypes<BaseLocation>::Type,
                             public virtual BaseLocation
    {
    public:
      SparBaseLocation(const BWTA::BaseLocation* location, Region* parent)
        : D2::LocationTypes<BaseLocation>::Type((LocationTypes*)NULL, location, parent)
        , D3::LocationTypes<BaseLocation>::Type((LocationTypes*)NULL, location, parent)
        , BaseLocation((LocationTypes*)NULL, location, parent)
        , PrimitiveLocation(parent)
        , StaticLocation(parent)
      {}
      virtual BWAPI::Position getCurrentCenter() const { return BaseLocation::getCurrentCenter(); }
    protected:
      //virtual void output(std::ostream& out) const { BaseLocation::output(out); }
    };

    class SparChokepoint : public D2::LocationTypes<Chokepoint>::Type, 
                           public D3::LocationTypes<Chokepoint>::Type,
                           public virtual Chokepoint
    {
    public:
      SparChokepoint(BWTA::Chokepoint* chokepoint, Region* firstRegion, Region* secondRegion, Map* parent)
        : D2::LocationTypes<Chokepoint>::Type((LocationTypes*)NULL, chokepoint, firstRegion, secondRegion, parent)
        , D3::LocationTypes<Chokepoint>::Type((LocationTypes*)NULL, chokepoint, firstRegion, secondRegion, parent)
        , Chokepoint((LocationTypes*)NULL, chokepoint, firstRegion, secondRegion, parent)
        , PrimitiveLocation(parent)
        , StaticLocation(parent)
      {}
      virtual BWAPI::Position getCurrentCenter() const { return Chokepoint::getCurrentCenter(); }
    protected:
      //virtual void output(std::ostream& out) const { Chokepoint::output(out); }
    };

    class SparRegion : public D2::LocationTypes<Region>::Type, 
                       public D3::LocationTypes<Region>::Type,
                       public virtual Region
    {
    public:
      SparRegion(BWTA::Region* region, Map* parent)
        : D2::LocationTypes<Region>::Type((LocationTypes*)NULL, region, parent)
        , D3::LocationTypes<Region>::Type((LocationTypes*)NULL, region, parent)
        , Region((LocationTypes*)NULL, region, parent)
        , CompositeLocation(parent)
        , StaticLocation(parent)
      {}
      virtual BWAPI::Position getCurrentCenter() const { return Region::getCurrentCenter(); }
    protected:
      //virtual void output(std::ostream& out) const { Region::output(out); }
    };

    class SparRegionLocation : public D2::LocationTypes<RegionLocation>::Type, 
                               public D3::LocationTypes<RegionLocation>::Type,
                               public virtual RegionLocation
    {
    public:
      SparRegionLocation(Region* parent)
        : D2::LocationTypes<RegionLocation>::Type((LocationTypes*)NULL, parent)
        , D3::LocationTypes<RegionLocation>::Type((LocationTypes*)NULL, parent)
        , RegionLocation((LocationTypes*)NULL, parent)
        , PrimitiveLocation(parent)
        , StaticLocation(parent)
      {}
      virtual BWAPI::Position getCurrentCenter() const { return RegionLocation::getCurrentCenter(); }
    protected:
      //virtual void output(std::ostream& out) const { RegionLocation::output(out); }
    };

    class SparMap : public D2::LocationTypes<Map>::Type, 
                         public D3::LocationTypes<Map>::Type,
                         public virtual Map
    {
    public:
      SparMap()
        : D2::LocationTypes<Map>::Type((LocationTypes*)NULL)
        , D3::LocationTypes<Map>::Type((LocationTypes*)NULL)
        , Map((LocationTypes*)NULL)
        , CompositeLocation(NULL)
        , StaticLocation(NULL)
      {}
      virtual BWAPI::Position getCurrentCenter() const { return Map::getCurrentCenter(); }
    protected:
      //virtual void output(std::ostream& out) const { Map::output(out); }
    };

    static AirLocation* instantiateAirLocation(Map* map) {
      SparAirLocation* sparAirLocation = new SparAirLocation(map);
      assert(dynamic_cast<Location*>(sparAirLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparAirLocation) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparAirLocation) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparAirLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<AirLocation>::Type*>(sparAirLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<AirLocation>::Type*>(sparAirLocation) != NULL);

      Location* sparLocation = dynamic_cast<Location*>(sparAirLocation);
      assert(dynamic_cast<Location*>(sparLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparLocation) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparLocation) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<AirLocation>::Type*>(sparLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<AirLocation>::Type*>(sparLocation) != NULL);

      return sparAirLocation;
    }

    static BaseLocation* instantiateBaseLocation(const BWTA::BaseLocation* location, Region* parentRegion) {
      SparBaseLocation* sparBaseLocation = new SparBaseLocation(location, parentRegion);
      assert(dynamic_cast<Location*>(sparBaseLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparBaseLocation) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparBaseLocation) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparBaseLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<BaseLocation>::Type*>(sparBaseLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<BaseLocation>::Type*>(sparBaseLocation) != NULL);

      Location* sparLocation = dynamic_cast<Location*>(sparBaseLocation);
      assert(dynamic_cast<Location*>(sparLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparLocation) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparLocation) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<BaseLocation>::Type*>(sparLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<BaseLocation>::Type*>(sparLocation) != NULL);

      return sparBaseLocation;
    }

    static Chokepoint* instantiateChokepoint(BWTA::Chokepoint* chokepoint, Region* firstRegion, Region* secondRegion, Map* parent) {
      SparChokepoint* sparChokepoint = new SparChokepoint(chokepoint, firstRegion, secondRegion,  parent);
      assert(dynamic_cast<Location*>(sparChokepoint) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparChokepoint) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparChokepoint) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparChokepoint) != NULL);
      assert(dynamic_cast<D2::LocationTypes<Chokepoint>::Type*>(sparChokepoint) != NULL);
      assert(dynamic_cast<D3::LocationTypes<Chokepoint>::Type*>(sparChokepoint) != NULL);

      Location* sparLocation = dynamic_cast<Location*>(sparChokepoint);
      assert(dynamic_cast<Location*>(sparLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparLocation) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparLocation) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<Chokepoint>::Type*>(sparLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<Chokepoint>::Type*>(sparLocation) != NULL);

      return sparChokepoint;
    }

    static Region* instantiateRegion(BWTA::Region* region, Map* parent) {
      SparRegion* sparRegion = new SparRegion(region, parent);
      assert(dynamic_cast<Location*>(sparRegion) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparRegion) != NULL);
      assert(dynamic_cast<CompositeLocation*>(sparRegion) != NULL);
      assert(dynamic_cast<D2::LocationTypes<Region>::Type*>(sparRegion) != NULL);
      assert(dynamic_cast<D3::LocationTypes<Region>::Type*>(sparRegion) != NULL);

      Location* sparLocation = dynamic_cast<Location*>(sparRegion);
      assert(dynamic_cast<Location*>(sparLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<CompositeLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<Region>::Type*>(sparLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<Region>::Type*>(sparLocation) != NULL);

      return sparRegion;
    }

    static RegionLocation* instantiateRegionLocation(Region* parent) {
      SparRegionLocation* sparRegionLocation = new SparRegionLocation(parent);
      assert(dynamic_cast<Location*>(sparRegionLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparRegionLocation) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparRegionLocation) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparRegionLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<RegionLocation>::Type*>(sparRegionLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<RegionLocation>::Type*>(sparRegionLocation) != NULL);

      Location* sparLocation = dynamic_cast<Location*>(sparRegionLocation);
      assert(dynamic_cast<Location*>(sparLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<PrimitiveLocation*>(sparLocation) != NULL);
      //assert(dynamic_cast<UnitsContainer*>(sparLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<RegionLocation>::Type*>(sparLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<RegionLocation>::Type*>(sparLocation) != NULL);

      return sparRegionLocation;
    }

    static Map* instantiateMap() {
      SparMap* sparMap = new SparMap();
      assert(dynamic_cast<Location*>(sparMap) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparMap) != NULL);
      assert(dynamic_cast<CompositeLocation*>(sparMap) != NULL);
      assert(dynamic_cast<D2::LocationTypes<Map>::Type*>(sparMap) != NULL);
      assert(dynamic_cast<D3::LocationTypes<Map>::Type*>(sparMap) != NULL);

      Location* sparLocation = dynamic_cast<Location*>(sparMap);
      assert(dynamic_cast<Location*>(sparLocation) != NULL);
      assert(dynamic_cast<StaticLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<CompositeLocation*>(sparLocation) != NULL);
      assert(dynamic_cast<D2::LocationTypes<Map>::Type*>(sparLocation) != NULL);
      assert(dynamic_cast<D3::LocationTypes<Map>::Type*>(sparLocation) != NULL);

      return sparMap;
    }
  };

#pragma endregion SparLocations

  class SparUnitData : public D1::L1UnitData, 
                       public D2::L2UnitData,
                       public D3::L3UnitData,
                       public virtual UnitData
  {
  public:
    SparUnitData(BWAPI::Unit* unit)
      : D1::L1UnitData(unit)
      , D2::L2UnitData(unit)
      , D3::L3UnitData(unit)
      , UnitData(unit)
    {}

    static UnitData* instantiate(BWAPI::Unit* unit)
    {
      UnitData* unitData = new SparUnitData(unit);
      assert(dynamic_cast<D1::L1UnitData*>(unitData) != NULL);
      assert(dynamic_cast<D2::L2UnitData*>(unitData) != NULL);
      assert(dynamic_cast<D3::L3UnitData*>(unitData) != NULL);
      
      return unitData;
    }
  };

#pragma region SparTechs

  struct TechTypes
  {
    class SparUnitTypeTech : public D3::TechTypes<UnitTypeTech>::Type, 
                             public D4::TechTypes<UnitTypeTech>::Type,
                             public virtual UnitTypeTech
    {
    public:
      SparUnitTypeTech(BWAPI::UnitType unitType)
        : D3::TechTypes<UnitTypeTech>::Type(unitType)
        , D4::TechTypes<UnitTypeTech>::Type(unitType)
        , UnitTypeTech(unitType)
      {}
    };
    class SparTechTypeTech : public D3::TechTypes<TechTypeTech>::Type, 
                             public D4::TechTypes<TechTypeTech>::Type,
                             public virtual TechTypeTech
    {
    public:
      SparTechTypeTech(BWAPI::TechType techType)
        : D3::TechTypes<TechTypeTech>::Type(techType)
        , D4::TechTypes<TechTypeTech>::Type(techType)
        , TechTypeTech(techType)
      {}
    };
    class SparUpgradeTypeTech : public D3::TechTypes<UpgradeTypeTech>::Type, 
                                public D4::TechTypes<UpgradeTypeTech>::Type,
                                public virtual UpgradeTypeTech
    {
    public:
      SparUpgradeTypeTech(BWAPI::UpgradeType upgradeType)
        : D3::TechTypes<UpgradeTypeTech>::Type(upgradeType)
        , D4::TechTypes<UpgradeTypeTech>::Type(upgradeType)
        , UpgradeTypeTech(upgradeType)
      {}
      SparUpgradeTypeTech(BWAPI::UpgradeType upgradeType, int level)
        : D3::TechTypes<UpgradeTypeTech>::Type(upgradeType, level)
        , D4::TechTypes<UpgradeTypeTech>::Type(upgradeType, level)
        , UpgradeTypeTech(upgradeType, level)
      {}
    };

    static UnitTypeTech* instantiateUnitTypeTech(BWAPI::UnitType unitType) {
      return new SparUnitTypeTech(unitType);
    }
    static TechTypeTech* instantiateTechTypeTech(BWAPI::TechType techType) {
      return new SparTechTypeTech(techType);
    }
    static UpgradeTypeTech* instantiateUpgradeTypeTech(BWAPI::UpgradeType upgradeType) {
      return new SparUpgradeTypeTech(upgradeType);
    }
    static UpgradeTypeTech* instantiateUpgradeTypeTech(BWAPI::UpgradeType upgradeType, int level) {
      return new SparUpgradeTypeTech(upgradeType, level);
    }
  };

#pragma endregion SparTechs

  // NOTE: UnitManager must be declared BEFORE the layers so that it is destructed AFTER them
  UnitManagerImpl<SparUnitData> m_unitManager;
  // Keep m_scheduler BEFORE m_perceptualState (else deleting locations will fail on Component::verifyPendingTasks())
  Timer m_timer;
  Scheduler m_scheduler;
  PerceptualState m_perceptualState;
  Config m_configuration;

  // Situation analysis
  S1 m_layer1SituationAnalysis;
  S2 m_layer2SituationAnalysis;
  S3 m_layer3SituationAnalysis;
  S4 m_layer4SituationAnalysis;

  // Decision making
  D1 m_layer1DecisionMaking;
  D2 m_layer2DecisionMaking;
  D3 m_layer3DecisionMaking;
  D4 m_layer4DecisionMaking;

#ifdef USE_SPAR_GUI
  std::list<SparObserver*> m_observers;
#endif
};

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::SparAIModule()
  : SparAIContainer(&m_scheduler, &m_perceptualState, &m_unitManager, &m_timer, &m_configuration)
  , m_layer1DecisionMaking(m_layer1SituationAnalysis)
  , m_layer2DecisionMaking(m_layer2SituationAnalysis, m_layer1DecisionMaking)
  , m_layer3DecisionMaking(m_layer3SituationAnalysis, m_layer2DecisionMaking)
  , m_layer4DecisionMaking(m_layer4SituationAnalysis, m_layer3DecisionMaking)
  , m_layer1SituationAnalysis()
  , m_layer2SituationAnalysis(m_layer1SituationAnalysis)
  , m_layer3SituationAnalysis(m_layer2SituationAnalysis)
  , m_layer4SituationAnalysis(m_layer3SituationAnalysis)
{
  SPAR_LOG(LogTypes::GENERAL, "SPAR AI created");
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::~SparAIModule()
{
  SPAR_LOG(LogTypes::GENERAL, "SPAR AI destroyed");
#ifdef USE_SPAR_GUI
  for (std::list<SparObserver*>::const_iterator it = m_observers.begin(); it != m_observers.end(); ++it)
  {
    delete *it;
  }
#endif
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onStart()
{
  SparAIContainer::onStart();

  SPAR_LOG(LogTypes::GENERAL, "Game started");
  if (BWAPI::Broodwar->isReplay()) return;
  // Enable some cheat flags
  BWAPI::Broodwar->enableFlag(BWAPI::Flag::UserInput);

  //BWAPI::Broodwar->setGUI(false);
  //BWAPI::Broodwar->enableFlag(Flag::CompleteMapInformation);
  SPAR_LOG(LogTypes::GENERAL, "Analyzing map...");
  BWTA::readMap();
  BWTA::analyze();
  SPAR_LOG(LogTypes::GENERAL, "Done.");

  m_unitManager.onStart();

  m_perceptualState.onStart<LocationTypes, TechTypes>();

  m_layer1DecisionMaking.onStart();
  m_layer2DecisionMaking.onStart();
  m_layer3DecisionMaking.onStart();
  m_layer4DecisionMaking.onStart();

  m_layer1SituationAnalysis.onStart();
  m_layer2SituationAnalysis.onStart();
  m_layer3SituationAnalysis.onStart();
  m_layer4SituationAnalysis.onStart();

#ifdef USE_SPAR_GUI
  for (std::list<SparObserver*>::const_iterator it = m_observers.begin(); it != m_observers.end(); ++it)
  {
    (*it)->onStart();
  }
#endif
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onEnd(bool isWinner)
{
  if(isWinner)
    SPAR_LOG(LogTypes::GENERAL, "Game won");
  else
    SPAR_LOG(LogTypes::GENERAL, "Game lost");

#ifdef USE_SPAR_GUI
  for (std::list<SparObserver*>::const_iterator it = m_observers.begin(); it != m_observers.end(); ++it)
  {
    (*it)->close();
  }
#endif

  // Inverse order of onStart()

  SparAIContainer::onEnd(isWinner);

  m_layer4SituationAnalysis.onEnd();
  m_layer3SituationAnalysis.onEnd();
  m_layer2SituationAnalysis.onEnd();
  m_layer1SituationAnalysis.onEnd();

  m_layer4DecisionMaking.onEnd();
  m_layer3DecisionMaking.onEnd();
  m_layer2DecisionMaking.onEnd();
  m_layer1DecisionMaking.onEnd();

  m_perceptualState.onEnd();

  m_unitManager.onEnd();

  deleteZombieComponents();
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onFrame()
{
#ifdef DRAW_ON_SCREEN
  BWAPI::Broodwar->drawTextScreen(10, 10, "AVG %0.4f\nFPS %d\nAPM %d\nPos (%d,%d)\nTile (%d,%d)", 
    BWAPI::Broodwar->getAverageFPS(), 
    BWAPI::Broodwar->getFPS(),
    int(BWAPI::Broodwar->getAPM()),
    (BWAPI::Broodwar->getScreenPosition() + BWAPI::Broodwar->getMousePosition()).x(), (BWAPI::Broodwar->getScreenPosition() + BWAPI::Broodwar->getMousePosition()).y(),
    BWAPI::TilePosition(BWAPI::Broodwar->getScreenPosition() + BWAPI::Broodwar->getMousePosition()).x(), BWAPI::TilePosition(BWAPI::Broodwar->getScreenPosition() + BWAPI::Broodwar->getMousePosition()).y());
#endif

  SPAR_LOG(LogTypes::ON_FRAME, "onFrame()");

  if (BWAPI::Broodwar->isReplay()) return;
  
  //Timer::value_type t0 = Spar->getTimer().currentTime();
  SparAIContainer::onFrame();
  //Timer::value_type t1 = Spar->getTimer().currentTime();

  m_perceptualState.onFrame();
  //Timer::value_type t2 = Spar->getTimer().currentTime();

  m_layer4SituationAnalysis.onFrame();
  //Timer::value_type t3 = Spar->getTimer().currentTime();
  m_layer3SituationAnalysis.onFrame();
  //Timer::value_type t4 = Spar->getTimer().currentTime();
  m_layer2SituationAnalysis.onFrame();
  //Timer::value_type t5 = Spar->getTimer().currentTime();
  m_layer1SituationAnalysis.onFrame();
  //Timer::value_type t6 = Spar->getTimer().currentTime();

  m_layer4DecisionMaking.onFrame();
  //Timer::value_type t7 = Spar->getTimer().currentTime();
  m_layer3DecisionMaking.onFrame();
  //Timer::value_type t8 = Spar->getTimer().currentTime();
  m_layer2DecisionMaking.onFrame();
  //Timer::value_type t9 = Spar->getTimer().currentTime();
  m_layer1DecisionMaking.onFrame();
  //Timer::value_type t10 = Spar->getTimer().currentTime();

  m_unitManager.onFrame();
  //Timer::value_type t11 = Spar->getTimer().currentTime();

  //Timer::value_type t12 = Spar->getTimer().currentTime();

  Spar->getScheduler().onFrame();
  //Timer::value_type t13 = Spar->getTimer().currentTime();

  //SPAR_LOG(LogTypes::GENERAL_ERROR, "AIC %I64d PS %I64d 4A %I64d 3A %I64d 2A %I64d 1A %I64d 4D %I64d 3D %I64d 2D %I64d 1D %I64d UM %I64d GUI %I64d S %I64d"
  //  , t1 - t0, t2 - t1, t3 - t2, t4 - t3, t5 - t4, t6 - t5, t7 - t6, t8 - t7, t9 - t8, t10 - t9, t11 - t10, t12 - t11, t13 - t12);

  // We may need to move the GUI before the scheduler, but in this case some stuff may be produce errors
  // (techs not acquired, for example).
#ifdef USE_SPAR_GUI
  for (std::list<SparObserver*>::const_iterator it = m_observers.begin(); it != m_observers.end(); ++it)
  {
    (*it)->onFrame();
  }
#endif
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitDiscover(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_DISCOVER, "onUnitDiscover(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());
  
  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitDiscover(unit);

  m_unitManager.onUnitDiscover(unit);
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitEvade(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_EVADE, "onUnitEvade(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());

  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitEvade(unit);

  m_unitManager.onUnitEvade(unit);
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitShow(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_SHOW, "onUnitShow(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());

  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitShow(unit);

  m_unitManager.onUnitShow(unit);
}


template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitHide(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_HIDE, "onUnitHide(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());

  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitHide(unit);

  m_unitManager.onUnitHide(unit);
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitCreate(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_CREATE, "onUnitCreate(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());

  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitCreate(unit);

  m_unitManager.onUnitCreate(unit);
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitDestroy(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_DESTROY, "onUnitDestroy(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());

  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitDestroy(unit);

  // This call must stay at the end, else subscribers may use deleted unit data
  m_unitManager.onUnitDestroy(unit);
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitMorph(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_MORPH, "onUnitMorph(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());

  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitMorph(unit);

  m_unitManager.onUnitMorph(unit);
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onUnitRenegade(BWAPI::Unit* unit)
{
  SPAR_LOG(LogTypes::ON_RENEGADE, "onUnitRenegade(0x%x): %s %s %d", unit,
    (unit->getPlayer() == BWAPI::Broodwar->self() ? "Own" : (unit->getPlayer()->isNeutral() ? "Neutral" : "Enemy")),
    unit->getType().getName().c_str(), unit->getID());

  if (BWAPI::Broodwar->isReplay()) return;

  m_perceptualState.onUnitRenegade(unit);

  m_unitManager.onUnitRenegade(unit);
}

template <class S1, class S2, class S3, class S4, class D1, class D2, class D3, class D4>
void SparAIModule<S1, S2, S3, S4, D1, D2, D3, D4>::onSendText(std::string text)
{
  BWAPI::Broodwar->sendText("%s",text.c_str());
  if (BWAPI::Broodwar->isReplay()) return;

  m_layer1SituationAnalysis.onSendText(text);
  m_layer2SituationAnalysis.onSendText(text);
  m_layer3SituationAnalysis.onSendText(text);
  m_layer4SituationAnalysis.onSendText(text);
  m_layer1DecisionMaking.onSendText(text);
  m_layer2DecisionMaking.onSendText(text);
  m_layer3DecisionMaking.onSendText(text);
  m_layer4DecisionMaking.onSendText(text);

  if (text == "actions")
  {
    BWAPI::Broodwar->drawTextScreen(5, 0, "Currently %u actions:", getNbChildProcesses());
    struct PrintChildProcess
    {
      PrintChildProcess() : m_line(0)
      {}
      SafeListBase::ConstFunctionReturn operator()(const Process* process) const
      {
        BWAPI::Broodwar->drawTextScreen(5, 16*m_line, "%d. %s", m_line, getObjectDescription(process).c_str());
        ++m_line;

        return SafeListBase::ConstFunctionReturn();
      }
    private:
      mutable int m_line;
    };
    for_each_child_process(PrintChildProcess());
  }
}