Convert old prof trigger to new specs trigger

Author: Zerthox

src/context/player/mod.rs

@@ -34,8 +34,7 @@ impl PlayerContext {
         if mumble.read_ui_tick() > 0 {
             match mumble.parse_identity() {
                 Ok(identity) => {
-                    self.prof =
-                        Profession::try_from(identity.profession as u8).map_err(|err| err.number);
+                    self.prof = Profession::try_from(identity.profession as u8);
                     self.spec = Specialization::try_from(self.prof.ok(), identity.spec)
                         .ok_or(identity.spec);
                     self.race = (identity.race as u8).try_into();

src/context/player/profession.rs

@@ -2,10 +2,14 @@ use crate::{
     colors::{self, Color},
     traits::{Colored, ShortName},
 };
-use num_enum::{IntoPrimitive, TryFromPrimitive};
+use enumflags2::{bitflags, BitFlags};
 use serde::{Deserialize, Serialize};
 use strum::{AsRefStr, Display, EnumIter, IntoStaticStr, VariantArray};
 
+use super::Specialization;
+
+// TODO: transition from bitflags to enum after sufficient grace period for updating
+
 #[derive(
     Debug,
     Clone,
@@ -22,20 +26,99 @@ use strum::{AsRefStr, Display, EnumIter, IntoStaticStr, VariantArray};
     VariantArray,
     Serialize,
     Deserialize,
-    TryFromPrimitive,
-    IntoPrimitive,
 )]
-#[repr(u8)]
+#[bitflags]
+#[repr(u16)]
 pub enum Profession {
-    Guardian = 1,
-    Warrior = 2,
-    Engineer = 3,
-    Ranger = 4,
-    Thief = 5,
-    Elementalist = 6,
-    Mesmer = 7,
-    Necromancer = 8,
-    Revenant = 9,
+    Guardian = 1 << 1,
+    Warrior = 1 << 2,
+    Engineer = 1 << 3,
+    Ranger = 1 << 4,
+    Thief = 1 << 5,
+    Elementalist = 1 << 6,
+    Mesmer = 1 << 7,
+    Necromancer = 1 << 8,
+    Revenant = 1 << 9,
+}
+
+impl TryFrom<u8> for Profession {
+    type Error = u8;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            1 => Ok(Self::Guardian),
+            2 => Ok(Self::Warrior),
+            3 => Ok(Self::Engineer),
+            4 => Ok(Self::Ranger),
+            5 => Ok(Self::Thief),
+            6 => Ok(Self::Elementalist),
+            7 => Ok(Self::Mesmer),
+            8 => Ok(Self::Necromancer),
+            9 => Ok(Self::Revenant),
+            _ => Err(value),
+        }
+    }
+}
+
+impl Profession {
+    pub fn specializations(&self) -> BitFlags<Specialization> {
+        match self {
+            Self::Guardian => {
+                Specialization::Guardian
+                    | Specialization::Dragonhunter
+                    | Specialization::Firebrand
+                    | Specialization::Willbender
+            }
+            Self::Warrior => {
+                Specialization::Warrior
+                    | Specialization::Berserker
+                    | Specialization::Spellbreaker
+                    | Specialization::Bladesworn
+            }
+            Self::Revenant => {
+                Specialization::Revenant
+                    | Specialization::Herald
+                    | Specialization::Renegade
+                    | Specialization::Vindicator
+            }
+            Self::Engineer => {
+                Specialization::Engineer
+                    | Specialization::Scrapper
+                    | Specialization::Holosmith
+                    | Specialization::Mechanist
+            }
+            Self::Ranger => {
+                Specialization::Ranger
+                    | Specialization::Druid
+                    | Specialization::Soulbeast
+                    | Specialization::Untamed
+            }
+            Self::Thief => {
+                Specialization::Thief
+                    | Specialization::Daredevil
+                    | Specialization::Deadeye
+                    | Specialization::Specter
+            }
+            Self::Elementalist => {
+                Specialization::Elementalist
+                    | Specialization::Tempest
+                    | Specialization::Weaver
+                    | Specialization::Catalyst
+            }
+            Self::Mesmer => {
+                Specialization::Mesmer
+                    | Specialization::Chronomancer
+                    | Specialization::Mirage
+                    | Specialization::Virtuoso
+            }
+            Self::Necromancer => {
+                Specialization::Necromancer
+                    | Specialization::Reaper
+                    | Specialization::Scourge
+                    | Specialization::Harbinger
+            }
+        }
+    }
 }
 
 impl ShortName for Profession {

src/tree/load.rs

@@ -1,5 +1,8 @@
 use super::VisitMut;
-use crate::elements::{IconElement, IconList};
+use crate::{
+    elements::{IconElement, IconList},
+    trigger::MetaTrigger,
+};
 
 #[derive(Debug, Default, Clone, Copy)]
 pub struct Loader;
@@ -14,4 +17,8 @@ impl VisitMut for Loader {
     fn visit_icon(&mut self, el: &mut IconElement) {
         el.icon.load()
     }
+
+    fn visit_meta_trigger(&mut self, trigger: &mut MetaTrigger) {
+        trigger.load();
+    }
 }

src/tree/visit.rs

@@ -1,4 +1,7 @@
-use crate::elements::{Bar, Element, ElementType, Group, IconElement, IconList, Text};
+use crate::{
+    elements::{Bar, Element, ElementType, Group, IconElement, IconList, Text},
+    trigger::MetaTrigger,
+};
 
 pub trait VisitMut {
     fn visit_elements(&mut self, elements: &mut [Element]) {
@@ -8,7 +11,12 @@ pub trait VisitMut {
     }
 
     fn visit_element(&mut self, element: &mut Element) {
-        match &mut element.kind {
+        self.visit_meta_trigger(&mut element.trigger);
+        self.visit_element_type(&mut element.kind);
+    }
+
+    fn visit_element_type(&mut self, element_type: &mut ElementType) {
+        match element_type {
             ElementType::Group(group) => {
                 self.visit_group(group);
                 self.visit_elements(&mut group.members);
@@ -29,4 +37,6 @@ pub trait VisitMut {
     fn visit_text(&mut self, _text: &mut Text) {}
 
     fn visit_bar(&mut self, _bar: &mut Bar) {}
+
+    fn visit_meta_trigger(&mut self, _trigger: &mut MetaTrigger) {}
 }

src/trigger/meta.rs

@@ -13,6 +13,12 @@ pub struct MetaTrigger {
     pub map: Memo<MapTrigger>, // memoize map
 }
 
+impl MetaTrigger {
+    pub fn load(&mut self) {
+        self.player.load();
+    }
+}
+
 impl Trigger for MetaTrigger {
     fn is_active(&mut self, ctx: &Context) -> bool {
         if ctx.has_update(ContextUpdate::Map) {

src/trigger/player.rs

@@ -1,6 +1,6 @@
 use super::{CombatTrigger, Trigger};
 use crate::{
-    context::{Context, Mount, Specialization},
+    context::{Context, Mount, Profession, Specialization},
     render_util::enum_combo_bitflags,
     serde_bitflags,
     traits::RenderOptions,
@@ -14,13 +14,29 @@ use serde::{Deserialize, Serialize};
 pub struct PlayerTrigger {
     pub combat: CombatTrigger,
 
+    #[serde(skip_serializing)]
+    #[serde(with = "serde_bitflags")]
+    profs: BitFlags<Profession>, // TODO: remove after grace period
+
     #[serde(with = "serde_bitflags")]
     pub specs: BitFlags<Specialization>,
 
     #[serde(with = "serde_bitflags")]
     pub mounts: BitFlags<Mount>,
 }
 
+impl PlayerTrigger {
+    pub fn load(&mut self) {
+        // translate old profs to specs if specs empty
+        // TODO: remove after grace period
+        if self.specs.is_empty() {
+            for prof in self.profs.iter() {
+                self.specs.insert(prof.specializations());
+            }
+        }
+    }
+}
+
 impl Trigger for PlayerTrigger {
     fn is_active(&mut self, ctx: &Context) -> bool {
         self.combat.is_active(ctx)
@@ -61,3 +77,39 @@ where
         .map(|value| check_bitflags(flags, value))
         .unwrap_or(true)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn prof_transition() {
+        let mut trigger = PlayerTrigger {
+            profs: Profession::Guardian | Profession::Necromancer,
+            ..Default::default()
+        };
+        trigger.load();
+        assert_eq!(
+            trigger.specs,
+            Specialization::Guardian
+                | Specialization::Dragonhunter
+                | Specialization::Firebrand
+                | Specialization::Willbender
+                | Specialization::Necromancer
+                | Specialization::Reaper
+                | Specialization::Scourge
+                | Specialization::Harbinger
+        );
+
+        let mut trigger = PlayerTrigger {
+            profs: Profession::Guardian | Profession::Necromancer,
+            specs: Specialization::Dragonhunter | Specialization::Reaper,
+            ..Default::default()
+        };
+        trigger.load();
+        assert_eq!(
+            trigger.specs,
+            Specialization::Dragonhunter | Specialization::Reaper
+        );
+    }
+}