From e54503b1b0e9ede4afe5eb3b5973acd364a10b3d Mon Sep 17 00:00:00 2001
From: Elijah Voigt <elijah.caine.mv@gmail.com>
Date: Mon, 21 Jul 2025 16:45:13 -0700
Subject: [PATCH] Fix tooltip ish

---
 src/bin/trees/main.rs | 165 ++++++++++++++++++++++++++----------------
 1 file changed, 102 insertions(+), 63 deletions(-)

diff --git a/src/bin/trees/main.rs b/src/bin/trees/main.rs
index 901a3a5..044e8e5 100644
--- a/src/bin/trees/main.rs
+++ b/src/bin/trees/main.rs
@@ -17,6 +17,8 @@ fn main() {
         })
         .add_plugins(MonologueAssetsPlugin)
         .add_event::<DialogEvent>()
+        .add_event::<PlantTree>()
+        .add_event::<AssignMonologue>()
         .init_state::<DialogState>()
         .insert_resource(ClearColor(WHITE.into()))
         .add_systems(
@@ -43,6 +45,8 @@ fn main() {
                     .run_if(in_state(DialogState::Idle))
                     .run_if(on_event::<Pointer<Click>>),
                 spawn_debug_buttons.run_if(on_event::<AssetEvent<Monologue>>),
+                handle_plant_tree.run_if(on_event::<PlantTree>),
+                assign_monologue_to_tree.run_if(on_event::<AssignMonologue>),
                 dialog_engine.run_if(on_event::<DialogEvent>),
                 auto_scroll.run_if(any_component_added::<DialogOption>),
                 dialog_box_visibility.run_if(state_changed::<DialogState>),
@@ -57,7 +61,6 @@ fn main() {
         .add_observer(add_dialog_option)
         .add_observer(add_tree_monologue)
         .add_observer(remove_tree_monologue)
-        .add_observer(populate_tree)
         .add_observer(show_monologue_list)
         .add_observer(hide_monologue_list)
         .run();
@@ -119,13 +122,29 @@ struct MonologuePreview;
 
 /// Panel for selecting which monologue tree to spawn
 fn init_debug_ui(mut commands: Commands) {
-    let button = commands
+    commands.spawn((
+        Name::new("Tree Planter"),
+        Text::new("+Tree"),
+        Node {
+            top: Val::Px(0.0),
+            left: Val::Px(0.0),
+            min_width: Val::Px(25.0),
+            min_height: Val::Px(25.0),
+            ..default()
+        },
+        BackgroundColor(RED.into()),
+        DebuggingState::On,
+        MonologuesContainer,
+        Button,
+    )).observe(spawn_tree);
+
+    let monologue_button = commands
         .spawn((
             Name::new("Monologue Assignment Menu"),
-            Text::new("+ Monologue"),
+            Text::new("+Monologue"),
             Node {
-                align_self: AlignSelf::Start,
-                justify_self: JustifySelf::Start,
+                top: Val::Px(25.0),
+                left: Val::Px(0.0),
                 min_width: Val::Px(25.0),
                 min_height: Val::Px(25.0),
                 ..default()
@@ -137,12 +156,12 @@ fn init_debug_ui(mut commands: Commands) {
         .id();
     commands
         .spawn((
-            NavParent(button),
+            NavParent(monologue_button),
             NavState::default(),
             Name::new("Container"),
             Node {
                 flex_direction: FlexDirection::Row,
-                top: Val::Px(25.0),
+                top: Val::Px(50.0),
                 height: Val::Percent(90.0),
                 width: Val::Percent(80.0),
                 ..default()
@@ -166,7 +185,7 @@ fn init_debug_ui(mut commands: Commands) {
             parent.spawn((
                 Name::new("Preview"),
                 MonologuePreview,
-                NavParent(button),
+                NavParent(monologue_button),
                 NavState::default(),
                 Node {
                     flex_direction: FlexDirection::Column,
@@ -452,24 +471,30 @@ fn monologue_asset_tooltip(
     mut over_events: EventReader<Pointer<Over>>,
     mut out_events: EventReader<Pointer<Out>>,
     mut tooltip: ResMut<ToolTip>,
-    scripts: Query<&TreeMonologue>,
+    trees: Query<(&Tree, Option<&TreeMonologue>)>,
 ) {
     out_events
         .read()
-        .filter_map(|Pointer { target, .. }| scripts.contains(*target).then_some(*target))
+        .filter_map(|Pointer { target, .. }| trees.contains(*target).then_some(*target))
         .for_each(|_| {
             tooltip.remove("Script");
         });
 
     over_events
         .read()
-        .filter_map(|Pointer { target, .. }| scripts.contains(*target).then_some(*target))
+        .filter_map(|Pointer { target, .. }| trees.contains(*target).then_some(*target))
         .for_each(|e| {
-            if let Ok(TreeMonologue(handle)) = scripts.get(e) {
-                match handle.path() {
-                    Some(p) => tooltip.insert("Script", format!("{p}")),
-                    None => tooltip.insert("Script", "???".into()),
-                }
+            match trees.get(e) {
+                Ok((_tree, Some(TreeMonologue(handle)))) => {
+                    match handle.path() {
+                        Some(p) => tooltip.insert("Script", format!("{p}")),
+                        None => tooltip.insert("Script", "A".into()),
+                    }
+                },
+                Ok((_tree, None)) => {
+                    tooltip.insert("Script", "N/A".into());
+                },
+                _ => ()
             }
         });
 }
@@ -576,7 +601,6 @@ fn spawn_debug_buttons(
                         BackgroundColor(PINK.into()),
                     ))
                     .observe(preview_monologue)
-                    .observe(spawn_monologue_tree)
                     .observe(toggle_debug_button_color_over)
                     .observe(toggle_debug_button_color_out);
             });
@@ -665,64 +689,71 @@ fn hide_monologue_list(
     }
 }
 
-fn spawn_monologue_tree(
-    trigger: Trigger<Pointer<Click>>,
-    tree_monologues: Query<&TreeMonologue, With<Button>>,
-    mut commands: Commands,
-) {
-    let tree_monologue = tree_monologues.get(trigger.target()).unwrap();
-    info!("Spawning monologuing tree");
-    commands.spawn((Tree, tree_monologue.clone()));
-}
+#[derive(Event)]
+struct PlantTree;
 
-/// When a monologuing tree is added, give it a mesh, a material, and a position in space
-///
-/// TODO: This can be an `on_add` hook intead, just a little more clunky
-fn populate_tree(
-    trigger: Trigger<OnAdd, TreeMonologue>,
+/// Plan a tree in the world
+/// Handles random placement, 3d model, materials, and observers
+fn handle_plant_tree(
+    mut events: EventReader<PlantTree>,
     trees: Query<Entity, With<Tree>>,
     server: Res<AssetServer>,
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    if !trees.contains(trigger.target()) {
-        return;
-    }
+    events.read().for_each(|_event| {
+        let mut tree = commands.spawn(Tree);
+
+        // Generate "random" X and Y Coordinates for this tree
+        // 1. Take the top 2 bytes
+        // 2. Interpet as u8s
+        // 3. Re-interpret as i8s
+        // 4. Cast to f32
+        let transform = {
+            let n = RandomState::default().hash_one(tree.id());
+            let [a, b, ..] = n.to_be_bytes();
+
+            let x: f32 = a.cast_signed().wrapping_div(4).into();
+            let y: f32 = b.cast_signed().wrapping_div(4).into();
+            // Avoid mesh clipping by offsetting each on the z axis
+            let z = trees.iter().len() as f32;
+            debug!("Coordiantes: {x} {y}");
+            Transform::from_xyz(x, z, y).with_scale(Vec3::splat(10.0))
+        };
 
-    // Generate "random" X and Y Coordinates for this tree
-    // 1. Take the top 2 bytes
-    // 2. Interpet as u8s
-    // 3. Re-interpret as i8s
-    // 4. Cast to f32
-    let transform = {
-        let n = RandomState::default().hash_one(trigger.target());
-        let [a, b, ..] = n.to_be_bytes();
-
-        let x: f32 = a.cast_signed().wrapping_div(4).into();
-        let y: f32 = b.cast_signed().wrapping_div(4).into();
-        // Avoid mesh clipping by offsetting each on the z axis
-        let z = trees.iter().len() as f32;
-        debug!("Coordiantes: {x} {y}");
-        Transform::from_xyz(x, z, y).with_scale(Vec3::splat(10.0))
-    };
+        let material = MeshMaterial3d(materials.add(StandardMaterial {
+            base_color_texture: Some(server.load("trees/placeholder/tree.png")),
+            base_color: WHITE.with_alpha(0.9).into(),
+            alpha_mode: AlphaMode::Blend,
+            ..default()
+        }));
 
-    let material = MeshMaterial3d(materials.add(StandardMaterial {
-        base_color_texture: Some(server.load("trees/placeholder/tree.png")),
-        base_color: WHITE.into(),
-        alpha_mode: AlphaMode::Blend,
-        ..default()
-    }));
+        let mesh = Mesh3d(meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.0))));
 
-    let mesh = Mesh3d(meshes.add(Plane3d::new(Vec3::Y, Vec2::splat(1.0))));
+        tree.insert((mesh, material, transform))
+            .observe(delete_tree)
+            .observe(drag_tree);
+    });
+}
 
-    debug!("Fleshing out monologuing tree");
+#[derive(Event)]
+struct AssignMonologue(Handle<Monologue>);
 
-    commands
-        .entity(trigger.target())
-        .insert((mesh, material, transform))
-        .observe(delete_tree)
-        .observe(drag_tree);
+/// Assign the given monologue to a tree
+fn assign_monologue_to_tree(
+    mut events: EventReader<AssignMonologue>,
+    query: Query<Entity, (With<Tree>, Without<TreeMonologue>)>,
+    mut commands: Commands,
+) {
+    events.read().for_each(|event| {
+        // Get a valid tree to assign an entity to
+        let tree = query.iter().next().unwrap();
+        // Create the TreeMonologue component
+        let monologue = TreeMonologue(event.0.clone());
+        // Insert the component to the entity
+        commands.entity(tree).insert(monologue);
+    })
 }
 
 fn drag_tree(
@@ -823,3 +854,11 @@ fn control_menu(
         }
     })
 }
+
+/// Observer for the "Plant a new tree" button in the debug UI
+fn spawn_tree(
+    _trigger: Trigger<Pointer<Click>>,
+    mut events: EventWriter<PlantTree>,
+) {
+    events.write(PlantTree);
+}