SPAR/AIModule/SparAIModule/SparAIContainer.h

Go to the documentation of this file.

#pragma once
#include "../Utils/Utils.h"
#include "Utils/Process.h"
#include <Config.h>
#include <iostream>
#include <BWAPI.h>
#include <BWTA.h>

class SparAIContainer;
extern SparAIContainer* Spar;

class PerceptualState;
class UnitManager;
class Scheduler;
class Timer;

class SparAIContainer : public BWAPI::AIModule, public Process
{
public:
  SparAIContainer(Scheduler* scheduler,
                  PerceptualState* perceptualState,
                  UnitManager* unitManager,
                  Timer* timer,
                  Config* configuration)
    : Process(NULL)
    , m_schedulerPtr(scheduler)
    , m_perceptualStatePtr(perceptualState)
    , m_unitManagerPtr(unitManager)
    , m_timerPtr(timer)
    , m_configuration(configuration)
  {
    Spar = this;
  }
  ~SparAIContainer()
  {
    assert(m_zombieComponents.empty());
  }

  PerceptualState& getPerceptualState() { return *m_perceptualStatePtr; }
  UnitManager& getUnitManager() { return *m_unitManagerPtr; }
  Scheduler& getScheduler() { return *m_schedulerPtr; }
  Timer& getTimer() { return *m_timerPtr; }
  Config& getConfiguration() { return *m_configuration; }

  virtual void onStart()
  {
    Process::execute();
  }

  virtual void onFrame()
  {
    deleteZombieComponents();
  }

  virtual void onEnd(bool isWinner)
  {
    unused(isWinner);

    Process::terminate(Success);
    deleteZombieComponents();
  }

  template <class ComponentType>
  void addZombieComponent(const ComponentType* component)
  {
    // This static_assert is supposed to prevent people from zombifying processes manually; 
    // use Process::zombifyOnTerminate() or ProcessContainer/ProcessContainerList instead.
    static_assert<!boost::is_convertible<const ComponentType*,const Process*>::value || boost::is_same<ComponentType,Process>::value> use_process_zombify_on_terminate_or_process_container_to_zombify_processes;
    unused(use_process_zombify_on_terminate_or_process_container_to_zombify_processes);
    assert(std::find(m_zombieComponents.begin(), m_zombieComponents.end(), component) == m_zombieComponents.end());

    if (component != NULL)
      m_zombieComponents.push_back(component);
  }

protected:
  virtual void output(std::ostream& out) const
  {
    out << "SPAR agent";
  }

  void deleteZombieComponents()
  {
    for (std::list<const Component*>::const_iterator it = m_zombieComponents.begin();
         it != m_zombieComponents.end();
         ++it)
    {
      delete *it;
    }
    m_zombieComponents.clear();
  }

private:
  // Keep m_scheduler BEFORE m_perceptualState (else deleting locations will fail on Component::verifyPendingTasks())
  Scheduler* m_schedulerPtr;
  PerceptualState* m_perceptualStatePtr;
  UnitManager* m_unitManagerPtr;
  Timer* m_timerPtr;
  Config* m_configuration;

  // Optimization: chain the UnitData to each other?
  std::list<const Component*> m_zombieComponents;
};