import { Blackboard } from "@rbxts/state-management";

// Define a type for your blackboard data (optional but recommended)
interface MyAgentBlackboard {
    health: number;
    target?: Instance;
    isAlert: boolean;
}

// Create a blackboard with initial data
const blackboard = new Blackboard<MyAgentBlackboard>({
    health: 100,
    isAlert: false,
});

// Set values
blackboard.Set("health", 90);
blackboard.Set("target", game.Workspace.FindFirstChild("Enemy"));

// Get values
const currentHealth = blackboard.Get("health");
print(currentHealth); // 90

// Use wild keys for dynamic data
blackboard.SetWild("lastKnownPosition", new Vector3(10, 0, 5));
const pos = blackboard.GetWild<Vector3>("lastKnownPosition");

// Update values with callbacks
const newHealth = blackboard.UpdateWild<number>("health", (current) => (current ?? 100) - 10);
print(newHealth); // 80

import { FSM, Blackboard } from "@rbxts/state-management";

// Define some states
class IdleState implements FSM.IFSMState {
    OnEnter(bb: Blackboard) {
        print("Entering Idle State");
    }
    Update(dt: number, bb: Blackboard) {
        /* Idle logic */
    }
    OnExit(bb: Blackboard) {
        print("Exiting Idle State");
    }
}

class PatrolState implements FSM.IFSMState {
    OnEnter(bb: Blackboard) {
        print("Entering Patrol State");
    }
    Update(dt: number, bb: Blackboard) {
        /* Patrol logic */
    }
    OnExit(bb: Blackboard) {
        print("Exiting Patrol State");
    }
}

const blackboard = new Blackboard({ enemySpotted: false });
const fsm = new FSM.FSM("Idle", blackboard);

fsm.RegisterState("Idle", new IdleState());
fsm.RegisterState("Patrol", new PatrolState());

// Add transitions
fsm.AddTransition("Idle", "Patrol", 1, (bb) => {
    return bb.Get("enemySpotted") === true;
});

fsm.AddTransition("Patrol", "Idle", 1, (bb) => {
    return bb.Get("enemySpotted") === false;
});

fsm.Start();

// In your game loop
game.GetService("RunService").Heartbeat.Connect((dt) => {
    fsm.Update(dt);
});

import { BTree, Blackboard } from "@rbxts/state-management";

const blackboard = new Blackboard({
    hasTarget: false,
    energyLevel: 100,
    cooldownTimer: 0,
});

// Create a behavior tree with enhanced nodes
const root = new BTree.Sequence()
    .AddChild(new BTree.Condition((bb) => bb.Get("hasTarget") === true))
    .AddChild(
        new BTree.Cooldown(
            new BTree.Action((bb) => {
                print("Attacking target!");
                bb.Set("energyLevel", bb.Get("energyLevel") - 10);
                return BTree.ENodeStatus.SUCCESS;
            }),
            2.0, // 2 second cooldown
        ),
    );

// Enhanced parallel execution
const patrolBehavior = new BTree.Parallel(
    BTree.EParallelPolicy.ONE, // Success policy: one child succeeds
    BTree.EParallelPolicy.ONE, // Failure policy: one child fails
)
    .AddChild(
        new BTree.Action((bb) => {
            // Patrol movement logic
            return BTree.ENodeStatus.RUNNING;
        }),
    )
    .AddChild(new BTree.Condition((bb) => bb.Get("hasTarget") === true));

const behaviorTree = new BTree.BehaviorTree(root, blackboard);

// In your game loop
game.GetService("RunService").Heartbeat.Connect((dt) => {
    behaviorTree.Tick(dt);
});

import { Goap, Blackboard } from "@rbxts/state-management";

// Define a world state with typed support
interface WorldData {
    hasWeapon: boolean;
    enemyVisible: boolean;
    isSafe: boolean;
}

const worldState = new Goap.WorldState<WorldData>({
    hasWeapon: false,
    enemyVisible: false,
    isSafe: true,
});

// Define actions with enhanced features
class PickupWeaponAction extends Goap.Action {
    GetStaticEffects() {
        return new Map<string, Goap.Effect>().set("hasWeapon", Goap.Effect.Set(true));
    }
    GetStaticRequirements() {
        return new Map<string, Goap.Requirement>().set("isSafe", Goap.Comparison.Is()); // Only pick up when safe
    }
    GetCost() {
        return 1;
    }

    protected OnTick() {
        print("Picking up weapon...");
        // Simulate time to pick up
        return Goap.EActionStatus.SUCCESS;
    }
}

class AttackEnemyAction extends Goap.Action {
    GetStaticEffects() {
        return new Map<string, Goap.Effect>()
            .set("enemyVisible", Goap.Effect.Set(false))
            .set("isSafe", Goap.Effect.Set(true));
    }
    GetStaticRequirements() {
        return new Map<string, Goap.Requirement>()
            .set("hasWeapon", Goap.Comparison.Is())
            .set("enemyVisible", Goap.Comparison.Is());
    }
    GetCost() {
        return 2;
    }

    protected OnTick() {
        print("Attacking enemy...");
        return Goap.EActionStatus.SUCCESS;
    }
}

// Enhanced goals with weighted requirements and dynamic priorities
const combatGoal = new Goap.Goal("Combat", (worldState, agent) => {
    // Dynamic priority based on world state
    const enemyVisible = worldState.GetWild<boolean>("enemyVisible");
    return enemyVisible ? 20 : 5;
})
    .AddRequirement("enemyVisible", Goap.Comparison.IsNot(), 3) // Weight: 3
    .AddRequirement("isSafe", Goap.Comparison.Is(), 1); // Weight: 1

// Hierarchical goal support
const survivalGoal = new Goap.Goal("Survival", 15, true) // Composite goal
    .AddSubGoal(new Goap.Goal("GetWeapon", 10).AddRequirement("hasWeapon", Goap.Comparison.Is()))
    .AddSubGoal(combatGoal);

// Create agent with enhanced features
const agent = new Goap.Agent(
    worldState,
    [new PickupWeaponAction(), new AttackEnemyAction()],
    [survivalGoal, combatGoal],
);

// Enhanced effects with clamping and default values
worldState.SetWild("playerHealth", 100);
const healthEffect = Goap.Effect.DecrementClamp(10, 0, 100);
const newHealth = healthEffect(worldState.GetWild("playerHealth"));

game.GetService("RunService").Heartbeat.Connect((dt) => {
    // Simulate world changes
    if (math.random() < 0.01) {
        worldState.SetWild("enemyVisible", true);
    }

    agent.Update(dt);
});