SPAR/AIModule/SparAIModule/Utils/FSM/Transition.h

Go to the documentation of this file.

#pragma once
#include "../../Scheduler/SchedulerTask.h"
#include "../EventHandler.h"
#include "../Logger.h"
#include "Condition.h"

// Macro to create transitions?

class TransitionAction
{
};

class NoTransitionAction : public TransitionAction
{
public:
  void execute() const {}
  template <class Arguments>
  void execute(const Arguments& args) const {}
};

template <class OriginState, class Condition, class TransitionAction, class DestinationState, class EventHandlerType = EventHandler>
class Transition : public EventHandlerType
{
public:
  typedef typename EventHandlerType::arguments Arguments;
  Transition(OriginState& originState, Condition condition, TransitionAction action, 
             DestinationState& destinationState)
    : EventHandlerType(originState)
    , m_originState(originState)
    , m_condition(condition)
    , m_action(action)
    , m_destinationState(destinationState)
  {
  }

  virtual ~Transition() {}

  virtual void onEvent(void*, Arguments& args)
  {
    testTransition(args);
  }

  bool testTransition(Arguments& args)
  {
    const size_t frameNumber = BWAPI::Broodwar->getFrameCount();
    bool activation = false;
    // Check whether another transition has already been activated in this frame
    if (m_originState.getEarliestNextTransitionFrame() != frameNumber + 1)
    {
      if (ExpandArguments<Arguments>::evaluate(m_condition, args))
      {
        m_originState.setEarliestNextTransitionFrame(frameNumber + 1);
        activate(args);
        activation = true;
      }
    }
    return activation;
  }

protected:
  template <class Arguments>
  struct ExpandArguments {};

  template <>
  struct ExpandArguments<boost::tuple<>> {
    static bool evaluate(Condition& condition, boost::tuple<>&) {
      return condition.evaluate();
    }
    static void execute(TransitionAction& action, boost::tuple<>&) {
      action.execute();
    }
  };
  template <class T1>
  struct ExpandArguments<boost::tuple<T1>> {
    static bool evaluate(Condition& condition, boost::tuple<T1>& args) {
      return condition.evaluate(args.get<0>());
    }
    static void execute(TransitionAction& action, boost::tuple<T1>& args) {
      action.execute(args.get<0>());
    }
  };
  template <class T1,class T2>
  struct ExpandArguments<boost::tuple<T1,T2>> {
    static bool evaluate(Condition& condition, boost::tuple<T1,T2>& args) {
      return condition.evaluate(args.get<0>(), args.get<1>());
    }
    static void execute(TransitionAction& action, boost::tuple<T1,T2>& args) {
      action.execute(args.get<0>(), args.get<1>());
    }
  };
  template <class T1,class T2,class T3>
  struct ExpandArguments<boost::tuple<T1,T2,T3>> {
    static bool evaluate(Condition& condition, boost::tuple<T1,T2,T3>& args) {
      return condition.evaluate(args.get<0>(), args.get<1>(), args.get<2>());
    }
    static void execute(TransitionAction& action, boost::tuple<T1,T2,T3>& args) {
      action.execute(args.get<0>(), args.get<1>(), args.get<2>());
    }
  };
  template <class T1,class T2,class T3,class T4>
  struct ExpandArguments<boost::tuple<T1,T2,T3,T4>> {
    static bool evaluate(Condition& condition, boost::tuple<T1,T2,T3,T4>& args) {
      return condition.evaluate(args.get<0>(), args.get<1>(), args.get<2>(), args.get<3>());
    }
    static void execute(TransitionAction& action, boost::tuple<T1,T2,T3,T4>& args) {
      action.execute(args.get<0>(), args.get<1>(), args.get<2>(), args.get<3>());
    }
  };
  template <class T1,class T2,class T3,class T4,class T5>
  struct ExpandArguments<boost::tuple<T1,T2,T3,T4,T5>> {
    static bool evaluate(Condition& condition, boost::tuple<T1,T2,T3,T4,T5>& args) {
      return condition.evaluate(args.get<0>(), args.get<1>(), args.get<2>(), args.get<3>(), args.get<4>());
    }
    static void execute(TransitionAction& action, boost::tuple<T1,T2,T3,T4,T5>& args) {
      action.execute(args.get<0>(), args.get<1>(), args.get<2>(), args.get<3>(), args.get<4>());
    }
  };

  void activate(Arguments& args)
  {
    assert(&m_originState.getBehavior() == &m_destinationState.getBehavior());
    const IBehavior& behavior = m_originState.getBehavior();

    SPAR_LOG(LogTypes::LAYER_1_DECISION, "Behavior \"%s\": transition from state \"%s\" to state \"%s\"", 
      behavior.getName().c_str(), 
      m_originState.getName().c_str(), 
      m_destinationState.getName().c_str());

    m_originState.onExit();
    if (!behavior.isTerminated())
    {
      ExpandArguments<Arguments>::execute(m_action, args);
      if (!behavior.isTerminated())
        m_destinationState.onEnter();
    }
  }

  OriginState& m_originState;
  Condition m_condition;
  TransitionAction m_action;
  DestinationState& m_destinationState;
};