goap 0.1.0

A general purpose Goal-Oriented Action Planning (GOAP) library written in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use goap::prelude::*;

fn main() {
    // Create initial state
    let initial_state = State::new()
        .set("has_wood", false)
        .set("has_planks", false)
        .set("has_axe", false)
        .set("has_money", true)
        .set("at_store", false)
        .set("at_tree", false)
        .set("at_sawmill", false)
        .build();

    // Create goal state
    let goal = Goal::new("craft_planks")
        .requires("has_planks", true)
        .build();

    // Create actions
    let goto_store = Action::new("goto_store")
        .cost(1.0)
        .sets("at_store", true)
        .build();

    let buy_axe = Action::new("buy_axe")
        .cost(1.0)
        .requires("at_store", true)
        .requires("has_money", true)
        .sets("has_axe", true)
        .sets("has_money", false)
        .build();

    let goto_tree = Action::new("goto_tree")
        .cost(1.0)
        .sets("at_store", false)
        .sets("at_tree", true)
        .build();

    let chop_tree = Action::new("chop_tree")
        .cost(2.0)
        .requires("has_axe", true)
        .requires("at_tree", true)
        .sets("has_wood", true)
        .build();

    let goto_sawmill = Action::new("goto_sawmill")
        .cost(1.0)
        .requires("has_wood", true)
        .sets("at_tree", false)
        .sets("at_sawmill", true)
        .build();

    let saw_planks = Action::new("saw_planks")
        .cost(1.0)
        .requires("has_wood", true)
        .requires("at_sawmill", true)
        .sets("has_planks", true)
        .build();

    // Collect all actions
    let actions = vec![
        goto_store,
        buy_axe,
        goto_tree,
        chop_tree,
        goto_sawmill,
        saw_planks,
    ];

    // Create planner
    let planner = Planner::new();

    // Find plan
    let plan_result = planner.plan(initial_state.clone(), &goal, &actions);
    assert!(plan_result.is_ok(), "Expected to find a valid plan");

    let plan = plan_result.unwrap();
    assert_eq!(plan.cost, 7.0, "Expected total cost to be 7.0");

    let expected_actions = [
        "goto_store",
        "buy_axe",
        "goto_tree",
        "chop_tree",
        "goto_sawmill",
        "saw_planks",
    ];
    assert_eq!(
        plan.actions.len(),
        expected_actions.len(),
        "Plan length doesn't match expected length"
    );

    for (action, expected_name) in plan.actions.iter().zip(expected_actions.iter()) {
        assert_eq!(
            action.name,
            *expected_name,
            "Expected action {expected} but got {actual}",
            expected = expected_name,
            actual = action.name
        );
    }

    println!("\nComplex plan found with cost {cost}", cost = plan.cost);
    for action in plan.actions {
        let name = &action.name;
        println!("- {name}");
    }
}