StateMachineBuiltins.h

#pragma once
 
#include <Core/Utils/Blackboard.h>
#include <GameEngine/StateMachine/StateMachineResource.h>
 
class PL_GAMEENGINE_DLL plStateMachineState_NestedStateMachine : public plStateMachineState
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineState_NestedStateMachine, plStateMachineState);
 
public:
  plStateMachineState_NestedStateMachine(plStringView sName = plStringView());
  ~plStateMachineState_NestedStateMachine();
 
  virtual void OnEnter(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pFromState) const override;
  virtual void OnExit(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pToState) const override;
  virtual void Update(plStateMachineInstance& ref_instance, void* pInstanceData, plTime deltaTime) const override;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  virtual bool GetInstanceDataDesc(plInstanceDataDesc& out_desc) override;
 
  void SetResource(const plStateMachineResourceHandle& hResource);
  const plStateMachineResourceHandle& GetResource() const { return m_hResource; }
 
  void SetResourceFile(const char* szFile); // [ property ]
  const char* GetResourceFile() const;      // [ property ]
 
  void SetInitialState(const char* szName);                       // [ property ]
  const char* GetInitialState() const { return m_sInitialState; } // [ property ]
 
private:
  plStateMachineResourceHandle m_hResource;
  plHashedString m_sInitialState;
 
  // Should the inner state machine keep its current state on exit and re-enter or should it exit as well and re-enter the initial state again.
  bool m_bKeepCurrentStateOnExit = false;
 
  struct InstanceData
  {
    plUniquePtr<plStateMachineInstance> m_pStateMachineInstance;
  };
};
 
 
class PL_GAMEENGINE_DLL plStateMachineState_Compound : public plStateMachineState
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineState_Compound, plStateMachineState);
 
public:
  plStateMachineState_Compound(plStringView sName = plStringView());
  ~plStateMachineState_Compound();
 
  virtual void OnEnter(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pFromState) const override;
  virtual void OnExit(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pToState) const override;
  virtual void Update(plStateMachineInstance& ref_instance, void* pInstanceData, plTime deltaTime) const override;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  virtual bool GetInstanceDataDesc(plInstanceDataDesc& out_desc) override;
 
  plSmallArray<plStateMachineState*, 2> m_SubStates;
 
private:
  plStateMachineInternal::Compound m_Compound;
};
 
 
struct PL_GAMEENGINE_DLL plStateMachineLogicOperator
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    And,
    Or,
 
    Default = And
  };
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_GAMEENGINE_DLL, plStateMachineLogicOperator);
 
 
class PL_GAMEENGINE_DLL plStateMachineTransition_BlackboardConditions : public plStateMachineTransition
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineTransition_BlackboardConditions, plStateMachineTransition);
 
public:
  plStateMachineTransition_BlackboardConditions();
  ~plStateMachineTransition_BlackboardConditions();
 
  virtual bool IsConditionMet(plStateMachineInstance& ref_instance, void* pInstanceData) const override;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  plEnum<plStateMachineLogicOperator> m_Operator;
  plHybridArray<plBlackboardCondition, 2> m_Conditions;
};
 
 
class PL_GAMEENGINE_DLL plStateMachineTransition_Timeout : public plStateMachineTransition
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineTransition_Timeout, plStateMachineTransition);
 
public:
  plStateMachineTransition_Timeout();
  ~plStateMachineTransition_Timeout();
 
  virtual bool IsConditionMet(plStateMachineInstance& ref_instance, void* pInstanceData) const override;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  plTime m_Timeout;
};
 
 
class PL_GAMEENGINE_DLL plStateMachineTransition_Compound : public plStateMachineTransition
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineTransition_Compound, plStateMachineTransition);
 
public:
  plStateMachineTransition_Compound();
  ~plStateMachineTransition_Compound();
 
  virtual bool IsConditionMet(plStateMachineInstance& ref_instance, void* pInstanceData) const override;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  virtual bool GetInstanceDataDesc(plInstanceDataDesc& out_desc) override;
 
  plEnum<plStateMachineLogicOperator> m_Operator;
  plSmallArray<plStateMachineTransition*, 2> m_SubTransitions;
 
private:
  plStateMachineInternal::Compound m_Compound;
};
 
 
class PL_GAMEENGINE_DLL plStateMachineTransition_TransitionEvent : public plStateMachineTransition
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineTransition_TransitionEvent, plStateMachineTransition);
 
public:
  plStateMachineTransition_TransitionEvent();
  ~plStateMachineTransition_TransitionEvent();
 
  virtual bool IsConditionMet(plStateMachineInstance& ref_instance, void* pInstanceData) const override;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  plHashedString m_sEventName;
};