Struct PlanExecutor 

pub struct PlanExecutor {
    pub state: ExecutorState,
    pub max_depth: usize,
    pub sim_time: f32,
    pub replan_count: u32,
    pub max_replans: u32,
    pub history: Vec<String>,
    /* private fields */
}

Drives execution of a GOAP plan, applying each action’s effects to the simulated world state, and replanning when the actual state diverges from the expected state.

Replanning policy

After each action completes, the executor compares the observed world state (provided by the game) against the expected state (computed by applying planned effects). If they differ in any condition that the next action cares about, the executor discards the remainder of the plan and calls the planner again.

Interruption

An external caller can call PlanExecutor::interrupt at any time. The current step is marked Interrupted and the executor transitions to the Interrupted state. The caller may then push a new goal and call PlanExecutor::start to begin fresh.

Fields

state: ExecutorState

Current executor state.

max_depth: usize

Maximum plan depth for the A* search.

sim_time: f32

Total simulation time elapsed.

replan_count: u32

How many times the executor has replanned this goal.

max_replans: u32

Maximum replanning attempts before giving up.

history: Vec<String>

Log of completed action names in order.

Implementations

impl PlanExecutor

pub fn new(actions: Vec<Action>, max_depth: usize) -> Self

pub fn set_world_state(&mut self, state: WorldState)

Set the initial world state.

pub fn update_bool(&mut self, key: &str, value: bool)

Update a single bool condition in the simulated world state.

pub fn update_float(&mut self, key: &str, value: f32)

Update a single float condition in the simulated world state.

pub fn start(&mut self, goal: WorldState) -> Result<usize, PlanError>

Push a new goal and (re)plan immediately.

Returns Ok(plan_length) on success or Err if no plan exists.

pub fn interrupt(&mut self)

Interrupt the current plan.

pub fn tick( &mut self, dt: f32, observe_state: impl Fn(&WorldState) -> WorldState, ) -> Option<&str>

Tick the executor by dt seconds.

observe_state should return the current observed world state, incorporating any changes that happened outside the planner (e.g. enemy died unexpectedly, health changed).

Returns the name of the action that should be executing this tick, or None if idle/finished.

pub fn current_action(&self) -> Option<&str>

The name of the action currently executing, if any.

pub fn plan_names(&self) -> Vec<&str>

The full current plan as action names.

pub fn progress(&self) -> (usize, usize)

Progress through the current plan: (completed_steps, total_steps).

pub fn has_succeeded(&self) -> bool

True if the executor has successfully completed its goal.

pub fn has_failed(&self) -> bool

True if the executor has permanently failed.

pub fn reset(&mut self)

Reset the executor to idle without changing the action library.

pub fn world_state(&self) -> &WorldState

Access the current simulated world state.

Trait Implementations

impl Debug for PlanExecutor

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.