390 lines
18 KiB
Rust
390 lines
18 KiB
Rust
//! Task executor system — the dispatcher that drives entity behaviour.
|
|
//!
|
|
//! Runs in FixedUpdate. For each entity with TaskQueue:
|
|
//! 1. If no active task, pop front of queue → set TaskState::Active
|
|
//! 2. Match on active Task variant, execute corresponding logic
|
|
//! 3. On completion/failure, update TaskState, fire event, pop task
|
|
//! 4. If queue empty after pop, assign default Task::Idle
|
|
//!
|
|
//! Uses Changed<TaskQueue> + Changed<TaskState> to minimise queries.
|
|
|
|
use crate::entities::behaviour::{EntityBehaviourRegistry, EntityType};
|
|
use crate::entities::cargo::{Cargo, HaulSlot};
|
|
use crate::entities::shared_components::Ambulatory;
|
|
use crate::entities::tasks::components::{
|
|
ChopStep, DropStep, HaulStep, IdleState, Task, TaskQueue, TaskState,
|
|
};
|
|
use crate::entities::tasks::events::{TaskClaimed, TaskCompleted, TaskFailed};
|
|
use crate::entities::tasks::idle::execute_idle;
|
|
use crate::world::chunks::ChunkMap;
|
|
use crate::world::generation::forestry::{fell_tree, TreePart};
|
|
use crate::world::tiles::tile_changed::TileChangedEvent;
|
|
use crate::world::tiles::visibility::TileOcclusionEvent;
|
|
use crate::world::tiles::TileMap;
|
|
use bevy::prelude::*;
|
|
use bevy_rand::prelude::*;
|
|
|
|
/// Main task executor. Runs in FixedUpdate.
|
|
pub fn task_executor_system(
|
|
mut commands: Commands,
|
|
mut tilemap_mut: ResMut<TileMap>,
|
|
chunk_map: Res<ChunkMap>,
|
|
asset_server: Res<AssetServer>,
|
|
mut rng_q: Query<&mut WyRand, With<GlobalRng>>,
|
|
mut tick: Local<u32>,
|
|
tree_parts: Query<(Entity, &TreePart)>,
|
|
mut cargo_query: Query<&mut Cargo>,
|
|
mut query: Query<(
|
|
Entity,
|
|
&mut TaskQueue,
|
|
&mut TaskState,
|
|
&mut Ambulatory,
|
|
&Transform,
|
|
&mut Sprite,
|
|
&EntityType,
|
|
Option<&mut HaulSlot>,
|
|
)>,
|
|
mut claimed_writer: MessageWriter<TaskClaimed>,
|
|
mut completed_writer: MessageWriter<TaskCompleted>,
|
|
mut failed_writer: MessageWriter<TaskFailed>,
|
|
mut tile_changed: MessageWriter<TileChangedEvent>,
|
|
mut occlusion: MessageWriter<TileOcclusionEvent>,
|
|
) {
|
|
let Ok(mut rng) = rng_q.single_mut() else {
|
|
return;
|
|
};
|
|
|
|
*tick = tick.wrapping_add(1);
|
|
let current_tick = *tick;
|
|
|
|
for (
|
|
entity,
|
|
mut queue,
|
|
mut state,
|
|
mut ambulatory,
|
|
transform,
|
|
mut sprite,
|
|
entity_type,
|
|
mut haul_slot,
|
|
) in query.iter_mut()
|
|
{
|
|
let origin = transform.translation.as_ivec3();
|
|
let behaviour = EntityBehaviourRegistry::global_get(entity_type.0);
|
|
|
|
if queue.is_empty() {
|
|
queue.push(Task::Idle {
|
|
origin,
|
|
sigma_world: behaviour.idle.sigma_world,
|
|
state: IdleState::Picking {
|
|
retry_after_tick: 0,
|
|
retry_count: 0,
|
|
},
|
|
});
|
|
}
|
|
|
|
// Promote Pending → Active if needed
|
|
if *state == TaskState::Pending && !queue.is_empty() {
|
|
*state = TaskState::Active;
|
|
if let Some(task) = queue.current() {
|
|
claimed_writer.write(TaskClaimed {
|
|
entity,
|
|
task: task.clone(),
|
|
});
|
|
}
|
|
}
|
|
|
|
// Execute current task if Active
|
|
if *state == TaskState::Active {
|
|
if let Some(current_task) = queue.current_mut() {
|
|
match current_task {
|
|
Task::Idle { .. } => {
|
|
execute_idle(
|
|
current_task,
|
|
transform,
|
|
&mut ambulatory,
|
|
&mut sprite,
|
|
&*tilemap_mut,
|
|
&chunk_map,
|
|
&behaviour.idle,
|
|
&mut rng,
|
|
current_tick,
|
|
);
|
|
}
|
|
Task::GoTo {
|
|
target,
|
|
threshold_tiles,
|
|
} => {
|
|
let entity_pos = (transform.translation / 16.0f32).as_ivec3();
|
|
let distance = (entity_pos.x - target.x)
|
|
.abs()
|
|
.max((entity_pos.y - target.y).abs());
|
|
|
|
if distance <= *threshold_tiles || !tilemap_mut.is_standable(*target) {
|
|
*state = TaskState::Completed;
|
|
} else {
|
|
ambulatory.target = Some(Vec3::new(
|
|
target.x as f32,
|
|
target.y as f32,
|
|
target.z as f32 + 1.0,
|
|
));
|
|
ambulatory.current_path = None;
|
|
}
|
|
}
|
|
Task::ChopTree {
|
|
trunk_pos,
|
|
chop_ticks,
|
|
step,
|
|
} => match step {
|
|
ChopStep::MovingToTree => {
|
|
if !tilemap_mut.fixture_tiles.contains_key(trunk_pos) {
|
|
failed_writer.write(TaskFailed {
|
|
entity,
|
|
task: current_task.clone(),
|
|
reason: "tree already gone",
|
|
});
|
|
*state = TaskState::Failed;
|
|
continue;
|
|
}
|
|
if ambulatory.target.is_none() {
|
|
ambulatory.target = Some(Vec3::new(
|
|
trunk_pos.x as f32,
|
|
trunk_pos.y as f32,
|
|
trunk_pos.z as f32 + 1.0,
|
|
));
|
|
ambulatory.current_path = None;
|
|
}
|
|
let dx = transform.translation.x - trunk_pos.x as f32;
|
|
let dy = transform.translation.y - trunk_pos.y as f32;
|
|
let dist_sq = dx * dx + dy * dy;
|
|
let chop_range_sq = (crate::constants::TILE_SIZE * 2.5)
|
|
* (crate::constants::TILE_SIZE * 2.5);
|
|
if dist_sq <= chop_range_sq {
|
|
ambulatory.target = None;
|
|
ambulatory.current_path = None;
|
|
*step = ChopStep::Chopping {
|
|
ticks_remaining: *chop_ticks,
|
|
};
|
|
}
|
|
}
|
|
ChopStep::Chopping { ticks_remaining } => {
|
|
if *ticks_remaining == 0 {
|
|
let trunk_positions = fell_tree(
|
|
*trunk_pos,
|
|
&tree_parts,
|
|
&mut commands,
|
|
&mut tilemap_mut,
|
|
&mut tile_changed,
|
|
&mut occlusion,
|
|
);
|
|
let log_sprite = asset_server.load("tree_trunk.png");
|
|
for &pos in trunk_positions.iter() {
|
|
crate::entities::cargo::spawn_log_cargo(
|
|
&mut commands,
|
|
&mut tilemap_mut,
|
|
pos,
|
|
log_sprite.clone(),
|
|
);
|
|
}
|
|
*step = ChopStep::Done;
|
|
} else {
|
|
*ticks_remaining -= 1;
|
|
}
|
|
}
|
|
ChopStep::Done => {
|
|
*state = TaskState::Completed;
|
|
}
|
|
},
|
|
Task::HaulCargo {
|
|
cargo_entity,
|
|
cargo_pos,
|
|
dest,
|
|
step,
|
|
} => {
|
|
let Some(ref mut haul) = haul_slot else {
|
|
failed_writer.write(TaskFailed {
|
|
entity,
|
|
task: current_task.clone(),
|
|
reason: "entity has no HaulSlot",
|
|
});
|
|
*state = TaskState::Failed;
|
|
continue;
|
|
};
|
|
|
|
match step {
|
|
HaulStep::MovingToCargo => {
|
|
if !tilemap_mut.cargo_tiles.contains_key(cargo_pos) {
|
|
failed_writer.write(TaskFailed {
|
|
entity,
|
|
task: current_task.clone(),
|
|
reason: "cargo no longer exists",
|
|
});
|
|
*state = TaskState::Failed;
|
|
continue;
|
|
}
|
|
if ambulatory.target.is_none() {
|
|
ambulatory.target = Some(Vec3::new(
|
|
cargo_pos.x as f32,
|
|
cargo_pos.y as f32,
|
|
cargo_pos.z as f32 + 1.0,
|
|
));
|
|
ambulatory.current_path = None;
|
|
}
|
|
let dx = transform.translation.x - cargo_pos.x as f32;
|
|
let dy = transform.translation.y - cargo_pos.y as f32;
|
|
let dist_sq = dx * dx + dy * dy;
|
|
let pickup_range_sq = (crate::constants::TILE_SIZE * 1.5)
|
|
* (crate::constants::TILE_SIZE * 1.5);
|
|
if dist_sq <= pickup_range_sq {
|
|
ambulatory.target = None;
|
|
*step = HaulStep::PickingUp;
|
|
}
|
|
}
|
|
HaulStep::PickingUp => {
|
|
if haul.is_occupied() {
|
|
failed_writer.write(TaskFailed {
|
|
entity,
|
|
task: current_task.clone(),
|
|
reason: "HaulSlot already occupied",
|
|
});
|
|
*state = TaskState::Failed;
|
|
continue;
|
|
}
|
|
if let Some(_) = tilemap_mut.remove_cargo(cargo_pos) {
|
|
haul.pick_up(*cargo_entity);
|
|
*step = HaulStep::MovingToDest { chosen_drop: None };
|
|
} else {
|
|
failed_writer.write(TaskFailed {
|
|
entity,
|
|
task: current_task.clone(),
|
|
reason: "cargo vanished before pickup",
|
|
});
|
|
*state = TaskState::Failed;
|
|
}
|
|
}
|
|
HaulStep::MovingToDest { chosen_drop } => {
|
|
if chosen_drop.is_none() {
|
|
*chosen_drop = Some(
|
|
tilemap_mut
|
|
.find_nearest_free_cargo_tile(*dest, 8)
|
|
.unwrap_or(*dest),
|
|
);
|
|
}
|
|
let drop_pos = chosen_drop.unwrap();
|
|
if ambulatory.target.is_none() {
|
|
ambulatory.target = Some(Vec3::new(
|
|
drop_pos.x as f32,
|
|
drop_pos.y as f32,
|
|
drop_pos.z as f32 + 1.0,
|
|
));
|
|
ambulatory.current_path = None;
|
|
}
|
|
let target_pos = ambulatory.target.unwrap_or(Vec3::ZERO);
|
|
let dx = transform.translation.x - target_pos.x;
|
|
let dy = transform.translation.y - target_pos.y;
|
|
let dist_sq = dx * dx + dy * dy;
|
|
let arrive_sq = (crate::constants::TILE_SIZE * 1.5)
|
|
* (crate::constants::TILE_SIZE * 1.5);
|
|
if dist_sq <= arrive_sq {
|
|
ambulatory.target = None;
|
|
*step = HaulStep::Dropping { drop_pos };
|
|
}
|
|
}
|
|
HaulStep::Dropping { drop_pos } => {
|
|
if let Some(cargo_entity) = haul.release() {
|
|
let _ = tilemap_mut.place_cargo(*drop_pos, cargo_entity);
|
|
if let Ok(mut cargo) = cargo_query.get_mut(cargo_entity) {
|
|
cargo.tile_pos = *drop_pos;
|
|
}
|
|
}
|
|
*step = HaulStep::Done;
|
|
}
|
|
HaulStep::Done => {
|
|
*state = TaskState::Completed;
|
|
}
|
|
}
|
|
}
|
|
Task::DropHauled { pos, step } => {
|
|
let Some(ref mut haul) = haul_slot else {
|
|
*state = TaskState::Completed;
|
|
continue;
|
|
};
|
|
|
|
match step {
|
|
DropStep::Moving { chosen_drop } => {
|
|
if chosen_drop.is_none() {
|
|
*chosen_drop = Some(
|
|
tilemap_mut
|
|
.find_nearest_free_cargo_tile(*pos, 8)
|
|
.unwrap_or(*pos),
|
|
);
|
|
}
|
|
let drop_pos = chosen_drop.unwrap();
|
|
if ambulatory.target.is_none() {
|
|
ambulatory.target = Some(Vec3::new(
|
|
drop_pos.x as f32,
|
|
drop_pos.y as f32,
|
|
drop_pos.z as f32 + 1.0,
|
|
));
|
|
ambulatory.current_path = None;
|
|
}
|
|
let target_pos = ambulatory.target.unwrap_or(Vec3::ZERO);
|
|
let dx = transform.translation.x - target_pos.x;
|
|
let dy = transform.translation.y - target_pos.y;
|
|
let dist_sq = dx * dx + dy * dy;
|
|
let arrive_sq = (crate::constants::TILE_SIZE * 1.5)
|
|
* (crate::constants::TILE_SIZE * 1.5);
|
|
if dist_sq <= arrive_sq {
|
|
ambulatory.target = None;
|
|
*step = DropStep::Dropping { drop_pos };
|
|
}
|
|
}
|
|
DropStep::Dropping { drop_pos } => {
|
|
if let Some(cargo_entity) = haul.release() {
|
|
let _ = tilemap_mut.place_cargo(*drop_pos, cargo_entity);
|
|
if let Ok(mut cargo) = cargo_query.get_mut(cargo_entity) {
|
|
cargo.tile_pos = *drop_pos;
|
|
}
|
|
}
|
|
*step = DropStep::Done;
|
|
}
|
|
DropStep::Done => {
|
|
*state = TaskState::Completed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Handle task completion/failure
|
|
if *state == TaskState::Completed || *state == TaskState::Failed {
|
|
if let Some(completed_task) = queue.pop() {
|
|
if *state == TaskState::Completed {
|
|
completed_writer.write(TaskCompleted {
|
|
entity,
|
|
task: completed_task.clone(),
|
|
});
|
|
} else {
|
|
failed_writer.write(TaskFailed {
|
|
entity,
|
|
task: completed_task.clone(),
|
|
reason: completed_task.name(),
|
|
});
|
|
}
|
|
|
|
if completed_task.is_terminal() && queue.is_empty() {
|
|
queue.push(Task::Idle {
|
|
origin,
|
|
sigma_world: behaviour.idle.sigma_world,
|
|
state: IdleState::Picking {
|
|
retry_after_tick: 0,
|
|
retry_count: 0,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
*state = TaskState::Pending;
|
|
}
|
|
}
|
|
}
|