behavior_state_machine_types.h

#pragma once
 
#include "pixelbullet/filesystem/virtual_path.h"
#include "pixelbullet/scene/entity_id.h"
 
#include <glm/vec2.hpp>
 
#include <optional>
#include <string>
#include <vector>
 
namespace pixelbullet
{
namespace platform::scene_play
{
enum class RuntimeUiAction : int
{
    TogglePause,
    ResumeRun,
    ReloadCurrentScene,
    RestartRun,
};
} // namespace platform::scene_play
 
enum class InputSignal
{
    Interact,
    Confirm,
    Cancel,
    PrimaryAction,
};
 
enum class BehaviorTargetAddressing
{
    Self,
    Binding,
};
 
struct BehaviorTarget
{
    BehaviorTargetAddressing addressing = BehaviorTargetAddressing::Self;
    std::string binding_slot;
 
    [[nodiscard]] bool operator==(const BehaviorTarget&) const noexcept = default;
};
 
enum class BehaviorTriggerType
{
    OnEnter,
    AfterSeconds,
    InputSignal,
    TriggerEnter,
    TriggerExit,
    KeyPickupCollected,
    InteractionFocusEnter,
    InteractionFocusExit,
    InteractionInputSignal,
    LevelCheckpointActivated,
    LevelRespawned,
    LevelCompleted,
    InteractionSequenceCompleted,
    PatrolWaypointReached,
    PatrolRouteCompleted,
    PerceptionTargetDetected,
    PerceptionTargetLost,
    PatrolInvestigationReached,
    TargetEnteredAttackRange,
    TargetExitedAttackRange,
    TargetEnteredRangedAttackRange,
    TargetExitedRangedAttackRange,
    MeleeAttackRecovered,
    RangedHitscanAttackRecovered,
    TargetKilled,
    CombatantDamaged,
    CombatantDefeated,
};
 
enum class BehaviorVariableType
{
    Bool,
    Int,
};
 
enum class BehaviorVariableScope
{
    Local,
    Scene,
};
 
struct BehaviorVariableDeclaration
{
    std::string name;
    BehaviorVariableType type = BehaviorVariableType::Bool;
    BehaviorVariableScope scope = BehaviorVariableScope::Local;
    bool bool_initial_value = false;
    int int_initial_value = 0;
 
    [[nodiscard]] bool operator==(const BehaviorVariableDeclaration&) const noexcept = default;
};
 
struct BehaviorStringParameterDeclaration
{
    std::string name;
    std::string default_value = {};
 
    [[nodiscard]] bool operator==(const BehaviorStringParameterDeclaration&) const noexcept = default;
};
 
struct BehaviorStringParameterValue
{
    std::string name;
    std::string value;
 
    [[nodiscard]] bool operator==(const BehaviorStringParameterValue&) const noexcept = default;
};
 
enum class BehaviorGuardComparison
{
    BoolEquals,
    IntEquals,
    IntGreaterOrEqual,
    IntLessOrEqual,
};
 
enum class BehaviorGuardSource
{
    Variable,
    InventoryKey,
    RunFlag,
};
 
struct BehaviorGuardCondition
{
    BehaviorGuardSource source = BehaviorGuardSource::Variable;
    std::string variable_name;
    std::string key_id;
    std::string key_id_parameter;
    BehaviorVariableScope scope = BehaviorVariableScope::Local;
    BehaviorGuardComparison comparison = BehaviorGuardComparison::BoolEquals;
    bool bool_value = false;
    int int_value = 0;
 
    [[nodiscard]] bool operator==(const BehaviorGuardCondition&) const noexcept = default;
};
 
struct BehaviorTrigger
{
    BehaviorTriggerType type = BehaviorTriggerType::OnEnter;
    float after_seconds = 0.0f;
    InputSignal input_signal = InputSignal::Interact;
    BehaviorTarget target{};
    std::string interaction_outcome_id;
    int patrol_waypoint_index = -1;
 
    [[nodiscard]] bool operator==(const BehaviorTrigger&) const noexcept = default;
};
 
enum class BehaviorActionType
{
    SetMeshVisible,
    SetSpriteVisible,
    SetPointLightEnabled,
    SetSpotLightEnabled,
    SetDirectionalLightEnabled,
    SetAudioSourceEnabled,
    StartAudioSource,
    StopAudioSource,
    SelectCamera,
    ControlTransformAnimation,
    SetBoolVariable,
    ToggleBoolVariable,
    SetIntVariable,
    AddIntVariable,
    SetInteractableEnabled,
    SetColliderEnabled,
    SetRigidBodyEnabled,
    SetRuntimeObjective,
    ClearRuntimeObjective,
    SetRuntimeStatusText,
    ClearRuntimeStatusText,
    SetRuntimeHintText,
    ClearRuntimeHintText,
    SetInteractionPromptText,
    ClearInteractionPromptText,
    SetPausedMenuContent,
    ClearPausedMenuContent,
    SetCompletedMenuContent,
    ClearCompletedMenuContent,
    ShowRuntimeNotification,
    SetTrackedObjective,
    SetTrackedObjectiveStage,
    CompleteObjective,
    FailObjective,
    ClearTrackedObjective,
    StartMission,
    EmitMissionEvent,
    SetRunFlag,
    ClearRunFlag,
    StartInteractionSequence,
    SetPatrolEnabled,
    PausePatrol,
    ResumePatrol,
    SetPatrolRoute,
    SetPatrolMoveSpeed,
    ChaseTarget,
    InvestigateLastSeenTarget,
    ReturnToPatrol,
    StartMeleeAttack,
    StartPrimaryHitscanAttack,
    StartRangedHitscanAttack,
};
 
enum class TransformAnimationPlaybackCommand
{
    Play,
    Pause,
    Stop,
    Restart,
};
 
struct BehaviorAction
{
    BehaviorActionType type = BehaviorActionType::SetMeshVisible;
    BehaviorTarget target{};
    std::string variable_name;
    std::string text_value;
    BehaviorVariableScope scope = BehaviorVariableScope::Local;
    bool bool_value = true;
    int int_value = 0;
    float duration_seconds = 2.5f;
    TransformAnimationPlaybackCommand animation_command = TransformAnimationPlaybackCommand::Play;
    std::string detail_text_value;
    std::string hint_text_value;
    std::string objective_id;
    pixelbullet::VirtualPath objective_asset;
    std::string objective_stage_id;
    pixelbullet::VirtualPath mission_asset;
    std::string mission_event_id;
    pixelbullet::VirtualPath interaction_asset;
    BehaviorTarget patrol_route_target{};
    float patrol_move_speed = 0.0f;
    std::vector<platform::scene_play::RuntimeUiAction> runtime_ui_actions;
 
    [[nodiscard]] bool operator==(const BehaviorAction&) const noexcept = default;
};
 
struct BehaviorTransition
{
    BehaviorTrigger trigger{};
    std::vector<BehaviorGuardCondition> guards;
    std::string target_state;
 
    [[nodiscard]] bool operator==(const BehaviorTransition&) const noexcept = default;
};
 
struct BehaviorState
{
    std::string name;
    std::vector<BehaviorAction> entry_actions;
    std::vector<BehaviorTransition> transitions;
 
    [[nodiscard]] bool operator==(const BehaviorState&) const noexcept = default;
};
 
struct BehaviorBinding
{
    std::string slot_name;
    EntityId entity = EntityId::Invalid();
 
    [[nodiscard]] bool operator==(const BehaviorBinding&) const noexcept = default;
};
 
struct BehaviorEditorGraphNodeLayout
{
    std::string state_name;
    glm::vec2 position = glm::vec2(0.0f);
 
    [[nodiscard]] bool operator==(const BehaviorEditorGraphNodeLayout&) const noexcept = default;
};
 
struct BehaviorEditorGraphLayout
{
    std::vector<BehaviorEditorGraphNodeLayout> nodes;
 
    [[nodiscard]] bool Empty() const noexcept
    {
        return nodes.empty();
    }
 
    [[nodiscard]] bool operator==(const BehaviorEditorGraphLayout&) const noexcept = default;
};
 
struct BehaviorStateMachineAsset
{
    std::string initial_state;
    std::vector<BehaviorVariableDeclaration> variables;
    std::vector<BehaviorStringParameterDeclaration> string_parameters;
    std::vector<std::string> binding_slots;
    std::vector<BehaviorState> states;
    std::optional<BehaviorEditorGraphLayout> editor_graph;
 
    [[nodiscard]] bool operator==(const BehaviorStateMachineAsset&) const noexcept = default;
};
} // namespace pixelbullet