Adjust debug & add validation for some inputs

Zerthox · Zerthox · commit c85ed6455cc3 · 2024-12-10T22:25:29.000+01:00
diff --git a/reffect/src/addon/ui/debug.rs b/reffect/src/addon/ui/debug.rs
@@ -6,7 +6,9 @@ use crate::{
     render::colors::{Colored, GREEN, RED},
 };
 use nexus::imgui::{StyleColor, Ui, Window};
+use reffect_internal::{Slot, State};
 use std::fmt;
+use strum::IntoEnumIterator;
 
 impl Addon {
     pub fn render_debug(&mut self, ui: &Ui) {
@@ -41,9 +43,17 @@ impl Addon {
                     }
                 });
 
+                let State {
+                    own_resources,
+                    own_skillbar,
+                    own_buffs,
+                    target_buffs,
+                    group_buffs,
+                } = &ctx.state;
+
                 ui.text("Own resources:");
                 ui.same_line();
-                debug_result(ui, ctx.state.own_resources.as_ref(), |resources| {
+                debug_result(ui, own_resources.as_ref(), |resources| {
                     let Resources {
                         health,
                         barrier,
@@ -64,26 +74,58 @@ impl Addon {
                     ));
                 });
 
+                ui.text("Own skillbar:");
+                ui.same_line();
+                debug_result(ui, own_skillbar.as_ref(), |skillbar| {
+                    let passed = skillbar.passed(ctx.now);
+
+                    for slot in Slot::iter() {
+                        if let Some(ability) = skillbar.slot(slot) {
+                            ui.text(format!("{}x {:>5}", ability.ammo, ability.id));
+
+                            let recharge = ability.recharge_remaining(passed);
+                            if recharge > 0 {
+                                ui.same_line();
+                                ui.text(format!(
+                                    "{:.1}/{:.1}s {:.1}%",
+                                    to_secs(recharge),
+                                    to_secs(ability.recharge),
+                                    100.0 * ability.recharge_progress(passed)
+                                ));
+                            }
+
+                            let ammo_recharge = ability.ammo_recharge_remaining(passed);
+                            if ammo_recharge > 0 {
+                                ui.same_line();
+                                ui.text(format!(
+                                    "Ammo {:.1}/{:.1}s {:.1}%",
+                                    to_secs(ammo_recharge),
+                                    to_secs(ability.ammo_recharge),
+                                    100.0 * ability.ammo_recharge_progress(passed)
+                                ));
+                            }
+                        }
+                    }
+                });
+
                 ui.text("Own buffs:");
                 ui.same_line();
-                debug_result(ui, ctx.state.own_buffs.as_ref(), |buffs| {
+                debug_result(ui, own_buffs.as_ref(), |buffs| {
                     buffs_tooltip(ui, ctx, infos, buffs)
                 });
 
                 ui.text("Target buffs:");
                 ui.same_line();
-                debug_result(ui, ctx.state.target_buffs.as_ref(), |buffs| {
+                debug_result(ui, target_buffs.as_ref(), |buffs| {
                     buffs_tooltip(ui, ctx, infos, buffs)
                 });
 
                 for i in 0..4 {
                     ui.text(format!("Group Member {} buffs:", i + 1));
                     ui.same_line();
-                    debug_result(
-                        ui,
-                        ctx.state.group_buffs.as_ref().map(|group| &group[i]),
-                        |buffs| buffs_tooltip(ui, ctx, infos, buffs),
-                    );
+                    debug_result(ui, group_buffs.as_ref().map(|group| &group[i]), |buffs| {
+                        buffs_tooltip(ui, ctx, infos, buffs)
+                    });
                 }
 
                 ui.text(format!("Combat: {}", ctx.ui.combat));
@@ -138,25 +180,27 @@ fn debug_result<T>(ui: &Ui, result: Result<&T, &Error>, tooltip: impl FnOnce(&T)
 
 fn buffs_tooltip(ui: &Ui, ctx: &Context, infos: Option<&BuffInfoMap>, buffs: &BuffMap) {
     for (id, buff) in buffs {
-        ui.text(format!("{}x {id}", buff.stacks));
+        ui.text(format!("{:>2}x {id:>5}", buff.stacks));
         if let Some(info) = infos.and_then(|infos| infos.get(id)) {
             ui.same_line();
             ui.text(format!("{:?} {:?}", info.category, info.stacking));
         }
-        if let Some(remain) = ctx.time_until(buff.runout_time) {
-            let full = buff.runout_time - buff.apply_time;
-            let progress = remain as f32 / full as f32;
+        if !buff.is_infinite() {
             ui.same_line();
             ui.text(format!(
                 "{:.1}/{:.1}s {:.1}%",
-                remain as f32 / 1000.0,
-                full as f32 / 1000.0,
-                progress * 100.0,
+                to_secs(buff.remaining(ctx.now)),
+                to_secs(buff.duration()),
+                100.0 * buff.progress(ctx.now),
             ));
         }
     }
 }
 
+fn to_secs(millisecs: u32) -> f32 {
+    millisecs as f32 / 1000.0
+}
+
 fn name_or_unknown_id_colored<T, N>(ui: &Ui, value: Result<T, N>)
 where
     T: AsRef<str> + Colored,
diff --git a/reffect/src/addon/ui/editor.rs b/reffect/src/addon/ui/editor.rs
@@ -97,6 +97,7 @@ impl Addon {
 
         let State {
             own_resources,
+            own_skillbar,
             own_buffs,
             target_buffs,
             group_buffs,
@@ -106,9 +107,10 @@ impl Addon {
             ui,
             [
                 ("Resources", own_resources.as_ref().err()),
+                ("Skills", own_skillbar.as_ref().err()),
                 ("Own Buffs", own_buffs.as_ref().err()),
-                ("Target Buffs", target_buffs.as_ref().err()),
-                ("Group Buffs", group_buffs.as_ref().err()),
+                // ("Target Buffs", target_buffs.as_ref().err()),
+                // ("Group Buffs", group_buffs.as_ref().err()),
                 ("Player", player.as_ref().err()),
             ],
         );
diff --git a/reffect/src/addon/ui/options.rs b/reffect/src/addon/ui/options.rs
@@ -95,7 +95,10 @@ impl Addon {
                 }
 
                 ui.spacing();
-                if ui.collapsing_header("Advanced", TreeNodeFlags::SPAN_AVAIL_WIDTH) {
+                if ui.collapsing_header(
+                    "Advanced",
+                    TreeNodeFlags::SPAN_AVAIL_WIDTH | TreeNodeFlags::DEFAULT_OPEN,
+                ) {
                     if input_u32(
                         ui,
                         "Own character interval",
diff --git a/reffect/src/context/mod.rs b/reffect/src/context/mod.rs
@@ -125,24 +125,6 @@ impl Context {
     pub fn own_resources(&self) -> Option<&Resources> {
         self.state.own_resources.as_ref().ok()
     }
-
-    /// Returns the duration passed since a given timestamp.
-    pub fn time_since(&self, time: u32) -> Option<u32> {
-        (time != u32::MAX).then(|| self.now.saturating_sub(time))
-    }
-
-    /// Returns the remaining duration until a given timestamp.
-    pub fn time_until(&self, time: u32) -> Option<u32> {
-        (time != u32::MAX).then(|| time.saturating_sub(self.now))
-    }
-
-    /// Returns the remaining progress between two timestamps.
-    pub fn progress_remaining(&self, start: u32, end: u32) -> Option<f32> {
-        self.time_until(end).map(|remain| {
-            let full = end - start;
-            remain as f32 / full as f32
-        })
-    }
 }
 
 impl Default for Context {
diff --git a/reffect/src/elements/text/mod.rs b/reffect/src/elements/text/mod.rs
@@ -9,8 +9,8 @@ use crate::{
     fmt::Pretty,
     render::{Bounds, ComponentWise, Render, RenderDebug, RenderOptions},
     render_util::{
-        debug_optional, draw_text_bg, font_select, helper, helper_error,
-        input_text_multi_with_menu, Font, FontToken, Rect,
+        debug_optional, draw_text_bg, font_select, helper, input_text_multi_with_menu, Font,
+        FontToken, Rect, Validation,
     },
     tree::TreeNode,
     trigger::ProgressActive,
@@ -182,16 +182,20 @@ impl RenderOptions for Text {
 
         self.align.render_combo(ui);
 
-        if font_select(ui, "Font", &mut self.loaded_font) {
-            self.font_name = self.loaded_font.map(|font| font.name_owned());
-        }
-        if self.font_name.is_some() && self.loaded_font.is_none() {
+        let validation = if self.font_name.is_some() {
             match self.loaded_font {
-                Some(font) if !font.is_valid() => helper_error(ui, || ui.text("Font invalidated")),
-                Some(_) => {}
-                None => helper_error(ui, || ui.text("Failed to find font")),
+                Some(font) if !font.is_valid() => Validation::Error("Font invalidated"),
+                Some(_) => Validation::Ok,
+                None => Validation::Error("Failed to find fond"),
             }
-        }
+        } else {
+            Validation::Ok
+        };
+        validation.for_item(ui, || {
+            if font_select(ui, "Font", &mut self.loaded_font) {
+                self.font_name = self.loaded_font.map(|font| font.name_owned());
+            }
+        });
 
         self.props.base.render_options(ui, state);
     }
diff --git a/reffect/src/render_util/helper.rs b/reffect/src/render_util/helper.rs
@@ -1,5 +1,5 @@
 use crate::render::colors;
-use nexus::imgui::Ui;
+use nexus::imgui::{ColorStackToken, StyleColor, Ui};
 
 pub fn helper(ui: &Ui, contents: impl FnOnce()) {
     ui.same_line();
@@ -17,6 +17,7 @@ pub fn helper_warn(ui: &Ui, tooltip: impl FnOnce()) {
     }
 }
 
+#[allow(unused)]
 pub fn helper_error(ui: &Ui, tooltip: impl FnOnce()) {
     ui.same_line();
     ui.text_colored(colors::RED, "(!)");
@@ -28,3 +29,54 @@ pub fn helper_error(ui: &Ui, tooltip: impl FnOnce()) {
 pub fn helper_slider(ui: &Ui) {
     helper(ui, || ui.text("Ctrl+click to type a number"))
 }
+
+#[derive(Debug, Clone)]
+#[must_use]
+pub enum Validation<T> {
+    Ok,
+    Confirm(T),
+    Warn(T),
+    Error(T),
+}
+
+impl<T> Validation<T> {
+    pub fn push_color<'ui>(&self, ui: &'ui Ui) -> ColorStackToken<'ui> {
+        const STYLE_COLOR: StyleColor = StyleColor::FrameBg;
+        const INTENSITY: f32 = 0.3;
+
+        let color = ui.style_color(STYLE_COLOR);
+        match self {
+            Self::Ok | Self::Confirm(_) => ui.push_style_color(STYLE_COLOR, color),
+            Self::Warn(_) => {
+                ui.push_style_color(STYLE_COLOR, colors::lerp(color, colors::YELLOW, INTENSITY))
+            }
+            Self::Error(_) => {
+                ui.push_style_color(STYLE_COLOR, colors::lerp(color, colors::RED, INTENSITY))
+            }
+        }
+    }
+
+    pub fn render_tooltip(&self, ui: &Ui)
+    where
+        T: AsRef<str>,
+    {
+        if ui.is_item_hovered() {
+            match self {
+                Self::Ok => {}
+                Validation::Confirm(text) => ui.tooltip(|| ui.text_colored(colors::GREEN, text)),
+                Validation::Warn(text) => ui.tooltip(|| ui.text_colored(colors::YELLOW, text)),
+                Validation::Error(text) => ui.tooltip(|| ui.text_colored(colors::RED, text)),
+            }
+        }
+    }
+
+    pub fn for_item<R>(&self, ui: &Ui, item: impl FnOnce() -> R) -> R
+    where
+        T: AsRef<str>,
+    {
+        let _color = self.push_color(ui);
+        let result = item();
+        self.render_tooltip(ui);
+        result
+    }
+}
diff --git a/reffect/src/trigger/progress/source.rs b/reffect/src/trigger/progress/source.rs
@@ -2,12 +2,12 @@ use super::ProgressActive;
 use crate::{
     action::Action,
     context::{Context, EditState},
-    internal::Resource,
-    internal::{Interface, Internal},
+    internal::{Interface, Internal, Resource},
     render::RenderOptions,
-    render_util::{enum_combo, helper, helper_error, impl_static_variants, input_skill_id},
+    render_util::{enum_combo, helper, impl_static_variants, input_skill_id, Validation},
 };
 use nexus::imgui::{ComboBoxFlags, InputTextFlags, Ui};
+use reffect_internal::Category;
 use serde::{Deserialize, Serialize};
 use strum::{AsRefStr, EnumIter, IntoStaticStr};
 
@@ -134,15 +134,23 @@ impl ProgressSource {
         }
     }
 
-    fn buff_helper(ui: &Ui, id: u32) {
+    fn buff_validate(id: u32) -> Validation<impl AsRef<str>> {
         if let Ok(infos) = Internal::get_buff_infos() {
-            if infos.get(&id).is_none() {
-                helper_error(ui, || {
-                    ui.text(format!("Buff {id} is invalid or hidden"));
-                });
-                return;
+            if let Some(info) = infos.get(&id) {
+                if info.category == Category::ScreenBorder {
+                    Validation::Warn(format!("{} {id} is only valid for yourself", info.category))
+                } else {
+                    Validation::Confirm(format!("{} {id} is valid", info.category))
+                }
+            } else {
+                Validation::Error(format!("Effect {id} is invalid or hidden"))
             }
+        } else {
+            Validation::Ok
         }
+    }
+
+    fn buff_helper(ui: &Ui) {
         helper(ui, || {
             ui.text("Can be found on the wiki");
             ui.text("Supports pasting chat links");
@@ -167,21 +175,25 @@ impl RenderOptions for ProgressSource {
 
         match self {
             Self::Buff(id) => {
-                input_skill_id(ui, "Effect Id", id, InputTextFlags::empty());
-                Self::buff_helper(ui, *id);
+                Self::buff_validate(*id).for_item(ui, || {
+                    input_skill_id(ui, "Effect Id", id, InputTextFlags::empty());
+                });
+                Self::buff_helper(ui);
             }
             Self::AnyBuff(ids) => {
                 let mut action = Action::new();
                 for (i, id) in ids.iter_mut().enumerate() {
                     let _id = ui.push_id(i as i32);
 
                     action.input_with_buttons(ui, i, || {
-                        input_skill_id(ui, "##id", id, InputTextFlags::empty())
+                        Self::buff_validate(*id).for_item(ui, || {
+                            input_skill_id(ui, "##id", id, InputTextFlags::empty());
+                        });
                     });
 
                     ui.same_line();
                     ui.text(format!("Effect Id {}", i + 1));
-                    Self::buff_helper(ui, *id);
+                    Self::buff_helper(ui);
                 }
                 if ui.button("Add Effect") {
                     ids.push(0);
