SPAR/AIModule/SparAIModule/DecisionMaking/Layer1Reactive/FSM/Layer1FSM.h

Go to the documentation of this file.

#pragma once
#include "../../../Scheduler/Scheduler.h"
#include "../../../SituationAnalysis/Layer1GameState/Layer1GameState.h"
#include "../../../Utils/SafeListAdaptor.h"
#include "../Layer1Reactive.h"
#include "Layer1FSMUnitData.h"
#include "Arbitrator.h"

class Layer1FSM : public Layer1Reactive<Layer1GameState>
{
protected:
//  struct BehaviorWrapper
//  {
//    BehaviorWrapper(IBehavior* behavior)
//      : m_behavior(behavior)
//    {
//    }
//    SafeList<BehaviorWrapper>::iterator m_id;
//    IBehavior* m_behavior;
//#ifdef _DEBUG_COMPONENT
//    IFSM::OnTerminate::SubscriberID m_subscriberID;
//#endif
//  };
//  struct extract_behavior : std::unary_function<BehaviorWrapper,const IBehavior*>
//  {
//    const IBehavior* operator()(const BehaviorWrapper& behaviorWrapper) const
//    {
//      return behaviorWrapper.m_behavior;
//    }
//  };
public:
  Layer1FSM(Layer1GameState& layer1GameState)
    : Layer1Reactive(layer1GameState)
    //, m_behaviorTerminateEventHandler(*this)
  {
    s_instance = this;
  }
  ~Layer1FSM()
  {
    //assert(m_behaviors.empty());
  }
  void onStart()
  {
    Layer1Reactive::onStart();
    m_arbitrator.onStart();
  }
  void onFrame()
  {
    Layer1Reactive::onFrame();
    m_arbitrator.onFrame();
  }
  void onEnd()
  {
    Layer1Reactive::onEnd();
    m_arbitrator.onEnd();

    //m_behaviors.for_each(TerminateBehavior());
  }
  void onSendText(std::string text)
  {
  }

  Arbitration& getArbitrator() { return m_arbitrator; }
  static Layer1FSM& getInstance() { return *s_instance; }

  typedef Layer1FSMUnitData L1UnitData; 

  //void onBehaviorStarted(IBehavior* behavior);

  //void onBehaviorTerminate(void* data);

  // GUI //
  //typedef boost::transform_iterator<extract_behavior, ConstSafeListAdaptor<BehaviorWrapper>::const_iterator> BehaviorIterator;
  //std::pair<BehaviorIterator, BehaviorIterator> getCurrentBehaviors() const
  //{
  //  ConstSafeListAdaptor<BehaviorWrapper> adaptor(m_behaviors);
  //  return std::make_pair(BehaviorIterator(adaptor.unsafe_begin()), BehaviorIterator(adaptor.unsafe_end()));
  //}

protected:
  //struct TerminateBehavior
  //{
  //  SafeListBase::ConstFunctionReturn operator()(const BehaviorWrapper& behaviorWrapper) const
  //  {
  //    behaviorWrapper.m_behavior->externalTerminate();
  //    return SafeListBase::ConstFunctionReturn();
  //  }
  //};

  // I know I know this is bad design... but I don't feel like passing the instance around.
  static Layer1FSM* s_instance;

  Arbitration m_arbitrator;

  //EVENT_HANDLER(Layer1FSM, onBehaviorTerminate) m_behaviorTerminateEventHandler;

  //SafeList<BehaviorWrapper> m_behaviors;
};