StateMachine.h

#pragma once
 
#include <GameEngine/StateMachine/Implementation/StateMachineInstanceData.h>
 
#include <Foundation/Reflection/Reflection.h>
#include <Foundation/Strings/HashedString.h>
#include <Foundation/Types/SharedPtr.h>
 
class plComponent;
class plWorld;
class plBlackboard;
class plStateMachineInstance;
 
class PL_GAMEENGINE_DLL plStateMachineState : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineState, plReflectedClass);
 
public:
  plStateMachineState(plStringView sName = plStringView());
 
  void SetName(plStringView sName);
  plStringView GetName() const { return m_sName; }
  const plHashedString& GetNameHashed() const { return m_sName; }
 
  virtual void OnEnter(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pFromState) const = 0;
  virtual void OnExit(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pToState) const;
  virtual void Update(plStateMachineInstance& ref_instance, void* pInstanceData, plTime deltaTime) const;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const;
  virtual plResult Deserialize(plStreamReader& inout_stream);
 
  virtual bool GetInstanceDataDesc(plInstanceDataDesc& out_desc);
 
private:
  // These are dummy functions for the scripting reflection
  void Reflection_OnEnter(plStateMachineInstance* pStateMachineInstance, const plStateMachineState* pFromState);
  void Reflection_OnExit(plStateMachineInstance* pStateMachineInstance, const plStateMachineState* pToState);
  void Reflection_Update(plStateMachineInstance* pStateMachineInstance, plTime deltaTime);
 
  plHashedString m_sName;
};
 
class PL_GAMEENGINE_DLL plStateMachineState_Empty final : public plStateMachineState
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineState_Empty, plStateMachineState);
 
public:
  plStateMachineState_Empty(plStringView sName = plStringView());
  ~plStateMachineState_Empty() = default;
 
  virtual void OnEnter(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pFromState) const override {}
};
 
struct plStateMachineState_ScriptBaseClassFunctions
{
  enum Enum
  {
    OnEnter,
    OnExit,
    Update,
 
    Count
  };
};
 
class PL_GAMEENGINE_DLL plStateMachineTransition : public plReflectedClass
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineTransition, plReflectedClass);
 
  virtual bool IsConditionMet(plStateMachineInstance& ref_instance, void* pInstanceData) const = 0;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const;
  virtual plResult Deserialize(plStreamReader& inout_stream);
 
  virtual bool GetInstanceDataDesc(plInstanceDataDesc& out_desc);
};
 
class PL_GAMEENGINE_DLL plStateMachineDescription : public plRefCounted
{
  PL_DISALLOW_COPY_AND_ASSIGN(plStateMachineDescription);
 
public:
  plStateMachineDescription();
  ~plStateMachineDescription();
 
  plUInt32 AddState(plUniquePtr<plStateMachineState>&& pState);
 
  void AddTransition(plUInt32 uiFromStateIndex, plUInt32 uiToStateIndex, plUniquePtr<plStateMachineTransition>&& pTransistion);
 
  plResult Serialize(plStreamWriter& inout_stream) const;
  plResult Deserialize(plStreamReader& inout_stream);
 
private:
  friend class plStateMachineInstance;
 
  struct TransitionContext
  {
    plUniquePtr<plStateMachineTransition> m_pTransition;
    plUInt32 m_uiToStateIndex = 0;
    plUInt32 m_uiInstanceDataOffset = plInvalidIndex;
  };
 
  using TransitionArray = plSmallArray<TransitionContext, 2>;
  TransitionArray m_FromAnyTransitions;
 
  struct StateContext
  {
    plUniquePtr<plStateMachineState> m_pState;
    TransitionArray m_Transitions;
    plUInt32 m_uiInstanceDataOffset = plInvalidIndex;
  };
 
  plDynamicArray<StateContext> m_States;
  plHashTable<plHashedString, plUInt32> m_StateNameToIndexTable;
 
  plInstanceDataAllocator m_InstanceDataAllocator;
};
 
class PL_GAMEENGINE_DLL plStateMachineInstance
{
  PL_DISALLOW_COPY_AND_ASSIGN(plStateMachineInstance);
 
public:
  plStateMachineInstance(plReflectedClass& ref_owner, const plSharedPtr<const plStateMachineDescription>& pDescription = nullptr);
  ~plStateMachineInstance();
 
  plResult SetState(plStateMachineState* pState);
  plResult SetState(plUInt32 uiStateIndex);
  plResult SetState(const plHashedString& sStateName);
  plResult SetStateOrFallback(const plHashedString& sStateName, plUInt32 uiFallbackStateIndex = 0);
  plStateMachineState* GetCurrentState() { return m_pCurrentState; }
 
  void Update(plTime deltaTime);
 
  plReflectedClass& GetOwner() { return m_Owner; }
  plWorld* GetOwnerWorld();
 
  void SetBlackboard(const plSharedPtr<plBlackboard>& pBlackboard);
  const plSharedPtr<plBlackboard>& GetBlackboard() const { return m_pBlackboard; }
 
  plTime GetTimeInCurrentState() const { return m_TimeInCurrentState; }
 
  void FireTransitionEvent(plStringView sEvent);
 
  plStringView GetCurrentTransitionEvent() const { return m_sCurrentTransitionEvent; }
 
private:
  PL_ALLOW_PRIVATE_PROPERTIES(plStateMachineInstance);
 
  bool Reflection_SetState(const plHashedString& sStateName);
  plComponent* Reflection_GetOwnerComponent() const;
  plBlackboard* Reflection_GetBlackboard() const { return m_pBlackboard.Borrow(); }
 
  void SetStateInternal(plUInt32 uiStateIndex);
  void EnterCurrentState(const plStateMachineState* pFromState);
  void ExitCurrentState(const plStateMachineState* pToState);
  plUInt32 FindNewStateToTransitionTo();
 
  PL_ALWAYS_INLINE void* GetInstanceData(plUInt32 uiOffset)
  {
    return plInstanceDataAllocator::GetInstanceData(m_InstanceData.GetByteBlobPtr(), uiOffset);
  }
 
  PL_ALWAYS_INLINE void* GetCurrentStateInstanceData()
  {
    if (m_pDescription != nullptr && m_uiCurrentStateIndex < m_pDescription->m_States.GetCount())
    {
      return GetInstanceData(m_pDescription->m_States[m_uiCurrentStateIndex].m_uiInstanceDataOffset);
    }
    return nullptr;
  }
 
  plReflectedClass& m_Owner;
  plSharedPtr<const plStateMachineDescription> m_pDescription;
  plSharedPtr<plBlackboard> m_pBlackboard;
 
  plStateMachineState* m_pCurrentState = nullptr;
  plUInt32 m_uiCurrentStateIndex = plInvalidIndex;
  plTime m_TimeInCurrentState;
  plStringView m_sCurrentTransitionEvent;
 
  const plStateMachineDescription::TransitionArray* m_pCurrentTransitions = nullptr;
 
  plBlob m_InstanceData;
};
 
PL_DECLARE_REFLECTABLE_TYPE(PL_GAMEENGINE_DLL, plStateMachineInstance);