goaprs 0.2.1

Goal Oriented Action Planning implementation 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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use crate::{Action, Result, State};
use std::fs::File;
use std::io::Write;

/// A visualizer for GOAP plans that generates Graphviz DOT files
pub struct GoapVisualizer;

impl GoapVisualizer {
    /// Create a new GOAP visualizer
    pub fn new() -> Self {
        Self
    }

    /// Generate a DOT file visualization of a GOAP plan
    pub fn visualize_plan(
        &self,
        actions: &[Action],
        current_state: &State,
        goal_state: &State,
        plan: &[Action],
        filename: &str,
    ) -> Result<()> {
        let mut file = File::create(filename)?;

        // Write DOT file header
        writeln!(file, "digraph GOAP {{")?;
        writeln!(file, "    rankdir=LR;")?;
        writeln!(
            file,
            "    node [shape=box, style=filled, fillcolor=lightblue];"
        )?;
        writeln!(file, "    edge [fontsize=10];")?;

        // Write initial state
        writeln!(
            file,
            "    initial [label=\"Initial State\\n{}\", fillcolor=lightgreen];",
            Self::state_to_string(current_state)
        )?;

        // Write goal state
        writeln!(
            file,
            "    goal [label=\"Goal State\\n{}\", fillcolor=lightpink];",
            Self::state_to_string(goal_state)
        )?;

        // Write all available actions
        for (i, action) in actions.iter().enumerate() {
            writeln!(
                file,
                "    action_{} [label=\"{}\\nCost: {}\\nPre: {}\\nEff: {}\"];",
                i,
                action.name,
                action.cost,
                Self::state_to_string(&action.preconditions),
                Self::state_to_string(&action.effects)
            )?;
        }

        // Write edges from initial state to possible actions
        for (i, action) in actions.iter().enumerate() {
            if action.can_perform(current_state) {
                writeln!(file, "    initial -> action_{} [label=\"possible\"];", i)?;
            }
        }

        // Write edges from actions to goal state
        for (i, action) in actions.iter().enumerate() {
            let mut new_state = current_state.clone();
            action.apply_effects(&mut new_state);
            if new_state.satisfies(goal_state) {
                writeln!(file, "    action_{} -> goal [label=\"achieves\"];", i)?;
            }
        }

        // Highlight the chosen plan path
        writeln!(file, "    edge [color=red, penwidth=2.0];")?;
        for action in plan {
            if let Some(idx) = actions.iter().position(|a| a.name == action.name) {
                writeln!(file, "    action_{} [fillcolor=lightcoral];", idx)?;
            }
        }

        // Write closing brace
        writeln!(file, "}}")?;

        Ok(())
    }

    /// Helper method to convert a state to a string representation
    fn state_to_string(state: &State) -> String {
        state
            .values()
            .iter()
            .map(|(key, value)| format!("{}: {}", key, value))
            .collect::<Vec<_>>()
            .join("\\n")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_visualize_plan() {
        // Create a simple action
        let mut action = Action::new("test_action", 1.0).unwrap();
        action.preconditions.set("has_item", true);
        action.effects.set("goal_achieved", true);

        let actions = vec![action.clone()];
        let plan = vec![action];

        // Set up states
        let mut current_state = State::new();
        current_state.set("has_item", true);
        current_state.set("goal_achieved", false);

        let mut goal_state = State::new();
        goal_state.set("goal_achieved", true);

        // Create visualizer and generate DOT file
        let visualizer = GoapVisualizer::new();
        visualizer
            .visualize_plan(
                &actions,
                &current_state,
                &goal_state,
                &plan,
                "test_plan.dot",
            )
            .unwrap();

        // Verify file was created and contains expected content
        let content = std::fs::read_to_string("test_plan.dot").unwrap();
        assert!(content.contains("digraph GOAP"));
        assert!(content.contains("test_action"));
        assert!(content.contains("has_item: true"));
        assert!(content.contains("goal_achieved: true"));

        // Clean up
        std::fs::remove_file("test_plan.dot").unwrap();
    }
}