Improve tasks UI

Cargo.toml

@@ -39,6 +39,7 @@ ron = "0.10"
 thiserror = "*"
 glam = { version = "0.29" } # Ensure that this match's bevy_math's glam before updating.
 uuid = { version = "1.13"}
+chrono = "*"
 sdformat_rs = { git = "https://github.com/open-rmf/sdf_rust_experimental", rev = "514949e" }
 urdf-rs = { version = "0.7.3"}
 once_cell = "1"

assets/demo_maps/test.site.json

@@ -856,7 +856,8 @@
               }
             }
           },
-          "inclusion": "Included"
+          "inclusion": "Included",
+          "on_level": 22
         },
         "62": {
           "pose": {
@@ -879,7 +880,8 @@
               ]
             }
           },
-          "inclusion": "Included"
+          "inclusion": "Included",
+          "on_level": 22
         },
         "63": {
           "pose": {
@@ -894,7 +896,8 @@
               }
             }
           },
-          "inclusion": "Included"
+          "inclusion": "Included",
+          "on_level": 22
         },
         "122": {
           "pose": {
@@ -994,6 +997,32 @@
             }
           },
           "inclusion": "Included"
+        },
+        "138": {
+          "inclusion": "Included"
+        },
+        "139": {
+          "inclusion": "Included"
+        }
+      },
+      "tasks": {
+        "138": {
+          "inclusion": "Included",
+          "params": {
+            "unix_millis_earliest_start_time": null,
+            "unix_millis_request_time": null,
+            "priority": null,
+            "labels": []
+          }
+        },
+        "139": {
+          "inclusion": "Included",
+          "params": {
+            "unix_millis_earliest_start_time": null,
+            "unix_millis_request_time": null,
+            "priority": null,
+            "labels": []
+          }
         }
       },
       "name": "Default Scenario",
@@ -1016,6 +1045,7 @@
   },
   "robots": {
     "52": {
+      "fleet": "HospitalRobot",
       "properties": {
         "Collision": {
           "config": {
@@ -1053,7 +1083,7 @@
   },
   "model_instances": {
     "53": {
-      "parent": 1,
+      "parent": 22,
       "name": "L1_robot",
       "pose": {
         "trans": [
@@ -1222,5 +1252,35 @@
       },
       "description": 129
     }
+  },
+  "tasks": {
+    "138": {
+      "Dispatch": {
+        "request": {
+          "id": "task-20250904-030419",
+          "category": "Go To Place",
+          "description": {
+            "location": 121
+          },
+          "description_display": "A",
+          "created_time": 1756955059673
+        }
+      }
+    },
+    "139": {
+      "Direct": {
+        "robot": 53,
+        "fleet": "HospitalRobot",
+        "request": {
+          "id": "task-20250904-030447",
+          "category": "Wait For",
+          "description": {
+            "duration": 30.0
+          },
+          "description_display": "30 seconds",
+          "created_time": 1756955087335
+        }
+      }
+    }
   }
 }

crates/rmf_site_editor/src/interaction/model.rs

@@ -55,6 +55,5 @@ pub fn update_model_instance_visual_cues(
                 }
             }
         }
-        // TODO(@xiyuoh) support task-based visual cues
     }
 }

crates/rmf_site_editor/src/mapf_rse/config_widget.rs

@@ -41,7 +41,7 @@ pub struct MapfConfigWidget<'w, 's> {
     negotiation_task: Res<'w, NegotiationTask>,
     occupancy_display: ResMut<'w, OccupancyDisplay>,
     robots: Query<'w, 's, Entity, With<Robot>>,
-    tasks: Query<'w, 's, &'static Task>,
+    tasks: Query<'w, 's, &'static Task<Entity>>,
 }
 
 impl<'w, 's> WidgetSystem<Tile> for MapfConfigWidget<'w, 's> {
@@ -80,7 +80,7 @@ impl<'w, 's> MapfConfigWidget<'w, 's> {
             .tasks
             .iter()
             .filter(|task| {
-                if task.request().category() == GoToPlace::label() {
+                if task.request().category() == GoToPlace::<Entity>::label() {
                     true
                 } else {
                     false

crates/rmf_site_editor/src/mapf_rse/negotiation/mod.rs

@@ -30,7 +30,7 @@ use crate::{
     occupancy::{Cell, Grid},
     site::{
         Affiliation, CircleCollision, CurrentLevel, DifferentialDrive, GoToPlace, Group,
-        LocationTags, ModelMarker, NameInSite, Point, Pose, Robot, Task as RobotTask,
+        LocationTags, ModelMarker, Point, Pose, Robot, Task as RobotTask,
     },
 };
 use mapf::negotiation::*;
@@ -225,17 +225,17 @@ pub fn handle_compute_negotiation_complete(
 }
 
 pub fn start_compute_negotiation(
-    locations: Query<(&NameInSite, &Point<Entity>), With<LocationTags>>,
+    locations: Query<&Point<Entity>, With<LocationTags>>,
     anchors: Query<&GlobalTransform>,
     negotiation_request: EventReader<NegotiationRequest>,
     negotiation_params: Res<NegotiationParams>,
     mut negotiation_debug_data: ResMut<NegotiationDebugData>,
     current_level: Res<CurrentLevel>,
     grids: Query<(Entity, &Grid)>,
     child_of: Query<&ChildOf>,
-    robots: Query<(Entity, &NameInSite, &Pose, &Affiliation<Entity>), With<Robot>>,
+    robots: Query<(Entity, &Pose, &Affiliation<Entity>), With<Robot>>,
     robot_descriptions: Query<(&DifferentialDrive, &CircleCollision)>,
-    tasks: Query<(&RobotTask, &GoToPlace)>,
+    tasks: Query<(&RobotTask<Entity>, &GoToPlace<Entity>)>,
     mut negotiation_task: ResMut<NegotiationTask>,
 ) {
     if negotiation_request.len() == 0 {
@@ -286,13 +286,11 @@ pub fn start_compute_negotiation(
     let mut agents = BTreeMap::<String, Agent>::new();
     // Only loop tasks that have specified a valid robot
     for (task, go_to_place) in tasks.iter() {
-        // Identify robot
-        let robot_name = task.robot();
-        for (robot_entity, robot_site_name, robot_pose, robot_group) in robots.iter() {
-            if robot_name == robot_site_name.0 {
+        for (robot_entity, robot_pose, robot_group) in robots.iter() {
+            if task.robot().0.is_some_and(|e| robot_entity == e) {
                 // Match location to entity
-                for (location_name, Point(anchor_entity)) in locations.iter() {
-                    if location_name.0 == go_to_place.location {
+                for Point(anchor_entity) in locations.iter() {
+                    if go_to_place.location.0.is_some_and(|e| e == *anchor_entity) {
                         let Ok(goal_transform) = anchors.get(*anchor_entity) else {
                             warn!("Unable to get robot's goal transform");
                             continue;

crates/rmf_site_editor/src/site/inclusion.rs

@@ -31,9 +31,12 @@ impl Property for Inclusion {
     fn on_new_element(
         for_element: Entity,
         in_scenario: Entity,
-        _value: Inclusion,
+        value: Inclusion,
         world: &mut World,
     ) {
+        // Insert inclusion modifier with given value into target scenario
+        world.trigger(UpdateModifier::modify(in_scenario, for_element, value));
+
         let mut scenario_state: SystemState<
             Query<(Entity, &ScenarioModifiers<Entity>, &Affiliation<Entity>)>,
         > = SystemState::new(world);

crates/rmf_site_editor/src/site/load.rs

@@ -536,8 +536,9 @@ fn generate_site_entities(
     }
 
     for (task_id, task_data) in &site_data.tasks {
+        let task = task_data.convert(&id_to_entity).for_site(site_id)?;
         let task_entity = commands
-            .spawn(task_data.clone())
+            .spawn(task.clone())
             .insert(SiteID(*task_id))
             .insert(Category::Task)
             .insert(ChildOf(site_id))

crates/rmf_site_editor/src/site/mod.rs

@@ -298,11 +298,11 @@ impl Plugin for SitePlugin {
             ChangePlugin::<ModelProperty<Scale>>::default(),
             ChangePlugin::<ModelProperty<IsStatic>>::default(),
             ChangePlugin::<ModelProperty<Robot>>::default(),
-            ChangePlugin::<Task>::default(),
+            ChangePlugin::<Task<Entity>>::default(),
             PropertyPlugin::<Pose, InstanceMarker>::default(),
             PropertyPlugin::<Inclusion, InstanceMarker>::default(),
-            PropertyPlugin::<Inclusion, Task>::default(),
-            PropertyPlugin::<TaskParams, Task>::default(),
+            PropertyPlugin::<Inclusion, Task<Entity>>::default(),
+            PropertyPlugin::<TaskParams, Task<Entity>>::default(),
             PropertyPlugin::<OnLevel<Entity>, Robot>::default(),
             SlotcarSdfPlugin,
             MaterialPlugin::<ExtendedMaterial<StandardMaterial, LaneArrowMaterial>>::default(),

crates/rmf_site_editor/src/site/save.rs

@@ -120,7 +120,7 @@ fn assign_site_ids(world: &mut World, site: Entity) -> Result<(), SiteGeneration
         Query<Entity, (With<ModelMarker>, With<Group>)>,
         Query<Entity, (With<ModelMarker>, Without<Group>, Without<Preview>)>,
         Query<(Entity, &Affiliation<Entity>), With<ScenarioModifiers<Entity>>>,
-        Query<Entity, (With<Task>, Without<Pending>)>,
+        Query<Entity, (With<Task<Entity>>, Without<Pending>)>,
         Query<
             Entity,
             (
@@ -1541,15 +1541,37 @@ fn generate_scenarios(
 fn generate_tasks(
     site: Entity,
     world: &mut World,
-) -> Result<BTreeMap<u32, Task>, SiteGenerationError> {
-    let mut state: SystemState<(Query<(&SiteID, &Task), Without<Pending>>, Query<&Children>)> =
-        SystemState::new(world);
-    let (tasks, children) = state.get(world);
-    let mut res = BTreeMap::<u32, Task>::new();
+) -> Result<BTreeMap<u32, Task<u32>>, SiteGenerationError> {
+    let mut state: SystemState<(
+        Query<(Entity, &SiteID, &Task<Entity>), Without<Pending>>,
+        Query<&SiteID, (With<Robot>, Without<Pending>)>,
+        Query<&Children>,
+    )> = SystemState::new(world);
+    let (tasks, robots, children) = state.get(world);
+    let mut res = BTreeMap::<u32, Task<u32>>::new();
     if let Ok(children) = children.get(site) {
         for child in children.iter() {
-            if let Ok((site_id, task)) = tasks.get(child) {
-                res.insert(site_id.0, task.clone());
+            if let Ok((task_entity, site_id, task)) = tasks.get(child) {
+                let task = match task {
+                    Task::Dispatch(request) => Task::Dispatch(request.clone()),
+                    Task::Direct(request) => {
+                        let robot_entity = match request.robot.0 {
+                            Some(e) => e,
+                            None => return Err(SiteGenerationError::EmptyAffiliation(task_entity)),
+                        };
+                        Task::Direct(RobotTaskRequest::new(
+                            match robots.get(robot_entity) {
+                                Ok(id) => Affiliation(Some(id.0)),
+                                Err(_) => {
+                                    return Err(SiteGenerationError::MissingSiteID(robot_entity))
+                                }
+                            },
+                            request.fleet.clone(),
+                            request.request.clone(),
+                        ))
+                    }
+                };
+                res.insert(site_id.0, task);
             }
         }
     }

crates/rmf_site_editor/src/site/task.rs

@@ -21,23 +21,24 @@ use std::collections::HashMap;
 
 pub type InsertTaskKindFn = fn(EntityCommands);
 pub type RemoveTaskKindFn = fn(EntityCommands);
+pub type IsTaskValidFn = fn(Entity, &mut World) -> bool;
 
 #[derive(Resource)]
-pub struct TaskKinds(pub HashMap<String, (InsertTaskKindFn, RemoveTaskKindFn)>);
+pub struct TaskKinds(pub HashMap<String, (InsertTaskKindFn, RemoveTaskKindFn, IsTaskValidFn)>);
 
 impl FromWorld for TaskKinds {
     fn from_world(_world: &mut World) -> Self {
         TaskKinds(HashMap::new())
     }
 }
 
-impl Element for Task {}
+impl Element for Task<Entity> {}
 
 impl StandardProperty for TaskParams {}
 
 pub fn update_task_kind_component<T: TaskKind>(
     mut commands: Commands,
-    tasks: Query<(Entity, Ref<Task>, Option<&T>)>,
+    tasks: Query<(Entity, Ref<Task<Entity>>, Option<&T>)>,
 ) {
     for (entity, task, task_kind) in tasks.iter() {
         if task.is_changed() {