StateMachineComponent.h

#pragma once
 
#include <Core/Messages/EventMessage.h>
#include <GameEngine/StateMachine/StateMachineResource.h>
 
struct PL_GAMEENGINE_DLL plMsgStateMachineStateChanged : public plEventMessage
{
  PL_DECLARE_MESSAGE_TYPE(plMsgStateMachineStateChanged, plEventMessage);
 
  plHashedString m_sOldStateName;
  plHashedString m_sNewStateName;
 
private:
  const char* GetOldStateName() const { return m_sOldStateName; }
  void SetOldStateName(const char* szName) { m_sOldStateName.Assign(szName); }
 
  const char* GetNewStateName() const { return m_sNewStateName; }
  void SetNewStateName(const char* szName) { m_sNewStateName.Assign(szName); }
};
 
 
class plStateMachineState_SendMsg : public plStateMachineState
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineState_SendMsg, plStateMachineState);
 
public:
  plStateMachineState_SendMsg(plStringView sName = plStringView());
  ~plStateMachineState_SendMsg();
 
  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 plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  plTime m_MessageDelay;
 
  bool m_bSendMessageOnEnter = true;
  bool m_bSendMessageOnExit = false;
  bool m_bLogOnEnter = false;
  bool m_bLogOnExit = false;
};
 
 
class plStateMachineState_SwitchObject : public plStateMachineState
{
  PL_ADD_DYNAMIC_REFLECTION(plStateMachineState_SwitchObject, plStateMachineState);
 
public:
  plStateMachineState_SwitchObject(plStringView sName = plStringView());
  ~plStateMachineState_SwitchObject();
 
  virtual void OnEnter(plStateMachineInstance& ref_instance, void* pInstanceData, const plStateMachineState* pFromState) const override;
 
  virtual plResult Serialize(plStreamWriter& inout_stream) const override;
  virtual plResult Deserialize(plStreamReader& inout_stream) override;
 
  plString m_sGroupPath;
  plString m_sObjectToEnable;
  bool m_bDeactivateOthers = true;
};
 
 
class PL_GAMEENGINE_DLL plStateMachineComponentManager : public plComponentManager<class plStateMachineComponent, plBlockStorageType::Compact>
{
public:
  plStateMachineComponentManager(plWorld* pWorld);
  ~plStateMachineComponentManager();
 
  virtual void Initialize() override;
 
  void Update(const plWorldModule::UpdateContext& context);
 
private:
  void ResourceEventHandler(const plResourceEvent& e);
 
  plHashSet<plComponentHandle> m_ComponentsToReload;
};
 
 
class PL_GAMEENGINE_DLL plStateMachineComponent : public plComponent
{
  PL_DECLARE_COMPONENT_TYPE(plStateMachineComponent, plComponent, plStateMachineComponentManager);
 
  // plComponent
 
public:
  virtual void SerializeComponent(plWorldWriter& inout_stream) const override;
  virtual void DeserializeComponent(plWorldReader& inout_stream) override;
 
protected:
  virtual void OnActivated() override;
  virtual void OnDeactivated() override;
 
  // plStateMachineComponent
 
public:
  plStateMachineComponent();
  plStateMachineComponent(plStateMachineComponent&& other);
  ~plStateMachineComponent();
 
  plStateMachineComponent& operator=(plStateMachineComponent&& other);
 
  plStateMachineInstance* GetStateMachineInstance() { return m_pStateMachineInstance.Borrow(); }
  const plStateMachineInstance* GetStateMachineInstance() const { return m_pStateMachineInstance.Borrow(); }
 
  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 ]
 
  bool SetState(plStringView sName); // [ scriptable ]
 
  plStringView GetCurrentState() const; // [ scriptable ]
 
  void FireTransitionEvent(plStringView sEvent);
 
  void SetBlackboardName(const char* szName);                         // [ property ]
  const char* GetBlackboardName() const { return m_sBlackboardName; } // [ property ]
 
private:
  friend class plStateMachineState_SendMsg;
  void SendStateChangedMsg(plMsgStateMachineStateChanged& msg, plTime delay);
  void InstantiateStateMachine();
  void Update();
 
  plStateMachineResourceHandle m_hResource;
  plHashedString m_sInitialState;
  plHashedString m_sBlackboardName;
 
  plUniquePtr<plStateMachineInstance> m_pStateMachineInstance;
 
  plEventMessageSender<plMsgStateMachineStateChanged> m_StateChangedSender; // [ event ]
};