Add climbing speed and cost

assets/common/skill_trees/skill_max_levels.ron

@@ -72,4 +72,6 @@
     Roll(Cost): Some(2),
     Roll(Strength): Some(2),
     Roll(Duration): Some(2),
+    Climb(Cost): Some(2),
+    Climb(Speed): Some(2),
 })

assets/common/skill_trees/skills_skill-groups_manifest.ron

@@ -12,6 +12,8 @@
         Roll(Cost),
         Roll(Strength),
         Roll(Duration),
+        Climb(Cost),
+        Climb(Speed)
     ],
     Weapon(Sword): [
         Sword(InterruptingAttacks),

assets/voxygen/i18n/en/skills.ron

@@ -30,9 +30,15 @@
         "hud.skill.roll_stamina_title": "Roll Stamina Cost",
         "hud.skill.roll_stamina": "Rolling uses 20% less stamina{SP}",
         "hud.skill.roll_speed_title": "Rolling Speed",
-        "hud.skill.roll_speed": "Roll 30% faster{SP}",
+        "hud.skill.roll_speed": "Roll 20% faster{SP}",
         "hud.skill.roll_dur_title": "Rolling Duration",
         "hud.skill.roll_dur": "Roll for 20% more time{SP}",
+        "hud.skill.climbing_title": "Climbing",
+        "hud.skill.climbing": "Jumping higher",
+        "hud.skill.climbing_cost_title": "Climbing Cost",
+        "hud.skill.climbing_cost": "Climbing uses 20% less stamina{SP}",
+        "hud.skill.climbing_speed_title": "Climbing Speed",
+        "hud.skill.climbing_speed": "Climb 20% faster{SP}",
         // Sceptre
         "hud.skill.sc_lifesteal_title": "Lifesteal Beam",
         "hud.skill.sc_lifesteal": "Drain the life from your enemies",

assets/voxygen/i18n/fr_FR/skills.ron

@@ -30,9 +30,15 @@
         "hud.skill.roll_stamina_title": "Coût d'Endurance de la Roulade",
         "hud.skill.roll_stamina": "Rouler coûte 20% moins d'endurance{SP}",
         "hud.skill.roll_speed_title": "Vitesse de la Roulade",
-        "hud.skill.roll_speed": "Rouler 30% plus vite{SP}",
+        "hud.skill.roll_speed": "Rouler 20% plus vite{SP}",
         "hud.skill.roll_dur_title": "Durée de la Roulade",
         "hud.skill.roll_dur": "Augmente de 20% la durée de la roulade{SP}",
+        "hud.skill.climbing_title": "Escalade",
+        "hud.skill.climbing": "Sauter encore plus haut",
+        "hud.skill.climbing_cost_title": "Coût d'endurance de l'Escalade",
+        "hud.skill.climbing_cost": "Escalader coûte 20% moins d'endurance{SP}",
+        "hud.skill.climbing_speed_title": "Climbing Speed",
+        "hud.skill.climbing_speed": "Escalader 20% plus vite{SP}",
         // Sceptre
         "hud.skill.sc_lifesteal_title": "Rayon de Vol-Vie",
         "hud.skill.sc_lifesteal": "Draine la vie de vos ennemis",

common/src/comp/ability.rs

@@ -124,6 +124,10 @@ pub enum CharacterAbility {
         roll_strength: f32,
         immune_melee: bool,
     },
+    Climb {
+        energy_cost: f32,
+        movement_speed: f32,
+    },
     ComboMelee {
         stage_data: Vec<combo_melee::Stage<f32>>,
         initial_energy_gain: f32,
@@ -404,6 +408,7 @@ impl CharacterAbility {
                 *movement_duration /= speed;
                 *recover_duration /= speed;
             },
+            Climb { .. } => {},
             ComboMelee {
                 ref mut stage_data, ..
             } => {
@@ -538,6 +543,7 @@ impl CharacterAbility {
             | RepeaterRanged { energy_cost, .. }
             | DashMelee { energy_cost, .. }
             | Roll { energy_cost, .. }
+            | Climb { energy_cost, .. }
             | LeapMelee { energy_cost, .. }
             | SpinMelee { energy_cost, .. }
             | ChargedMelee { energy_cost, .. }
@@ -1067,25 +1073,44 @@ impl CharacterAbility {
                 }
             },
             None => {
-                use skills::RollSkill::*;
+                use skills::{
-                if let CharacterAbility::Roll {
+                    ClimbSkill::{self, *},
-                    ref mut immune_melee,
+                    RollSkill::{self, *},
-                    ref mut energy_cost,
+                };
-                    ref mut roll_strength,
+                match self {
-                    ref mut movement_duration,
+                    CharacterAbility::Roll {
-                    ..
+                        ref mut immune_melee,
-                } = self
+                        ref mut energy_cost,
-                {
+                        ref mut roll_strength,
-                    *immune_melee = skillset.has_skill(Skill::Roll(ImmuneMelee));
+                        ref mut movement_duration,
-                    if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Cost)) {
+                        ..
-                        *energy_cost *= 0.8_f32.powi(level.into());
+                    } => {
-                    }
+                        *immune_melee = skillset.has_skill(Skill::Roll(ImmuneMelee));
-                    if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Strength)) {
+                        if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(RollSkill::Cost))
-                        *roll_strength *= 1.2_f32.powi(level.into());
+                        {
-                    }
+                            *energy_cost *= 0.8_f32.powi(level.into());
-                    if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Duration)) {
+                        }
-                        *movement_duration *= 1.2_f32.powi(level.into());
+                        if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Strength)) {
-                    }
+                            *roll_strength *= 1.2_f32.powi(level.into());
+                        }
+                        if let Ok(Some(level)) = skillset.skill_level(Skill::Roll(Duration)) {
+                            *movement_duration *= 1.2_f32.powi(level.into());
+                        }
+                    },
+                    CharacterAbility::Climb {
+                        ref mut energy_cost,
+                        ref mut movement_speed,
+                    } => {
+                        if let Ok(Some(level)) =
+                            skillset.skill_level(Skill::Climb(ClimbSkill::Cost))
+                        {
+                            *energy_cost *= 0.8_f32.powi(level.into());
+                        }
+                        if let Ok(Some(level)) = skillset.skill_level(Skill::Climb(Speed)) {
+                            *movement_speed *= 1.2_f32.powi(level.into());
+                        }
+                    },
+                    _ => {},
                 }
             },
             Some(_) => {},
@@ -1224,6 +1249,13 @@ impl From<(&CharacterAbility, AbilityInfo)> for CharacterState {
                 was_sneak: false,
                 was_combo: None,
             }),
+            CharacterAbility::Climb {
+                energy_cost,
+                movement_speed,
+            } => CharacterState::Climb(climb::Data {
+                energy_cost: *energy_cost,
+                movement_speed: *movement_speed,
+            }),
             CharacterAbility::ComboMelee {
                 stage_data,
                 initial_energy_gain,

common/src/comp/character_state.rs

@@ -42,7 +42,7 @@ impl From<&JoinData<'_>> for StateUpdate {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum CharacterState {
     Idle,
-    Climb,
+    Climb(climb::Data),
     Sit,
     Dance,
     Talk,

common/src/comp/skills.rs

@@ -103,6 +103,7 @@ pub enum Skill {
     Sceptre(SceptreSkill),
     UnlockGroup(SkillGroupKind),
     Roll(RollSkill),
+    Climb(ClimbSkill),
 }
 
 pub enum SkillError {
@@ -250,6 +251,12 @@ pub enum RollSkill {
     Duration,
 }
 
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ClimbSkill {
+    Cost,
+    Speed,
+}
+
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, Serialize, Deserialize)]
 pub enum SkillGroupKind {
     General,

common/src/states/climb.rs

@@ -11,11 +11,20 @@ use crate::{
 use serde::{Deserialize, Serialize};
 use vek::*;
 
-const HUMANOID_CLIMB_ACCEL: f32 = 24.0;
+#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
-const CLIMB_SPEED: f32 = 5.0;
+pub struct Data {
+    pub energy_cost: f32,
+    pub movement_speed: f32,
+}
 
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)]
+impl Default for Data {
-pub struct Data;
+    fn default() -> Self {
+        Data {
+            energy_cost: 5.0,
+            movement_speed: 5.0,
+        }
+    }
+}
 
 impl CharacterBehavior for Data {
     fn behavior(&self, data: &JoinData) -> StateUpdate {
@@ -38,19 +47,18 @@ impl CharacterBehavior for Data {
             update.character = CharacterState::Idle {};
             return update;
         };
-
         // Move player
         update.vel.0 += Vec2::broadcast(data.dt.0)
             * data.inputs.move_dir
-            * if update.vel.0.magnitude_squared() < CLIMB_SPEED.powi(2) {
+            * if update.vel.0.magnitude_squared() < self.movement_speed.powi(2) {
-                HUMANOID_CLIMB_ACCEL
+                self.movement_speed.powi(2)
             } else {
                 0.0
             };
 
         // Expend energy if climbing
         let energy_use = match climb {
-            Climb::Up => 5,
+            Climb::Up => self.energy_cost as i32,
             Climb::Down => 1,
             Climb::Hold => 1,
         };
@@ -74,8 +82,8 @@ impl CharacterBehavior for Data {
 
         // Apply Vertical Climbing Movement
         match climb {
-            Climb::Down => update.vel.0.z += data.dt.0 * (GRAVITY - HUMANOID_CLIMB_ACCEL),
+            Climb::Down => update.vel.0.z += data.dt.0 * (GRAVITY - self.movement_speed.powi(2)),
-            Climb::Up => update.vel.0.z += data.dt.0 * (GRAVITY + HUMANOID_CLIMB_ACCEL),
+            Climb::Up => update.vel.0.z += data.dt.0 * (GRAVITY + self.movement_speed.powi(2)),
             Climb::Hold => update.vel.0.z += data.dt.0 * GRAVITY,
         }
 

common/src/states/utils.rs

@@ -407,7 +407,13 @@ pub fn handle_climb(data: &JoinData, update: &mut StateUpdate) {
         && data.body.can_climb()
         && update.energy.current() > 100
     {
-        update.character = CharacterState::Climb;
+        let ability = CharacterAbility::Climb {
+            energy_cost: 5.0,
+            movement_speed: 5.0,
+        }
+        .adjusted_by_skills(&data.stats.skill_set, None);
+        let ability_info = AbilityInfo::from_input(data, false, InputKind::Roll);
+        update.character = CharacterState::from((&ability, ability_info));
     }
 }
 

common/sys/src/character_behavior.rs

@@ -267,7 +267,7 @@ impl<'a> System<'a> for Sys {
                 let mut state_update = match j.character {
                     CharacterState::Idle => states::idle::Data.handle_event(&j, action),
                     CharacterState::Talk => states::talk::Data.handle_event(&j, action),
-                    CharacterState::Climb => states::climb::Data.handle_event(&j, action),
+                    CharacterState::Climb(data) => data.handle_event(&j, action),
                     CharacterState::Glide => states::glide::Data.handle_event(&j, action),
                     CharacterState::GlideWield => {
                         states::glide_wield::Data.handle_event(&j, action)
@@ -329,7 +329,7 @@ impl<'a> System<'a> for Sys {
             let mut state_update = match j.character {
                 CharacterState::Idle => states::idle::Data.behavior(&j),
                 CharacterState::Talk => states::talk::Data.behavior(&j),
-                CharacterState::Climb => states::climb::Data.behavior(&j),
+                CharacterState::Climb(data) => data.behavior(&j),
                 CharacterState::Glide => states::glide::Data.behavior(&j),
                 CharacterState::GlideWield => states::glide_wield::Data.behavior(&j),
                 CharacterState::Stunned(data) => data.behavior(&j),

common/sys/src/phys.rs

@@ -11,6 +11,7 @@ use common::{
     consts::{FRIC_GROUND, GRAVITY},
     event::{EventBus, ServerEvent},
     resources::DeltaTime,
+    states::*,
     terrain::{Block, TerrainGrid},
     uid::Uid,
     vol::{BaseVol, ReadVol},
@@ -669,8 +670,9 @@ impl<'a> PhysicsData<'a> {
 
                     let was_on_ground = physics_state.on_ground;
                     let block_snap = body.map_or(false, |body| body.jump_impulse().is_some());
-                    let climbing =
+                    let climbing = character_state.map_or(false, |cs| {
-                        character_state.map_or(false, |cs| matches!(cs, CharacterState::Climb));
+                        matches!(cs, CharacterState::Climb(climb::Data { .. }))
+                    });
 
                     match &collider {
                         Collider::Voxel { .. } => {

server/src/persistence/json_models.rs

@@ -40,8 +40,8 @@ pub fn skill_to_db_string(skill: comp::skills::Skill) -> String {
     use comp::{
         item::tool::ToolKind,
         skills::{
-            AxeSkill, BowSkill, GeneralSkill, HammerSkill, RollSkill, SceptreSkill, Skill::*,
+            AxeSkill, BowSkill, ClimbSkill, GeneralSkill, HammerSkill, RollSkill, SceptreSkill,
-            SkillGroupKind, StaffSkill, SwordSkill,
+            Skill::*, SkillGroupKind, StaffSkill, SwordSkill,
         },
     };
     let skill_string = match skill {
@@ -134,6 +134,8 @@ pub fn skill_to_db_string(skill: comp::skills::Skill) -> String {
         Roll(RollSkill::Cost) => "Roll Cost",
         Roll(RollSkill::Strength) => "Roll Strength",
         Roll(RollSkill::Duration) => "Roll Duration",
+        Climb(ClimbSkill::Cost) => "Climbing Cost",
+        Climb(ClimbSkill::Speed) => "Climbing Speed",
         UnlockGroup(SkillGroupKind::Weapon(ToolKind::Sword)) => "Unlock Weapon Sword",
         UnlockGroup(SkillGroupKind::Weapon(ToolKind::Axe)) => "Unlock Weapon Axe",
         UnlockGroup(SkillGroupKind::Weapon(ToolKind::Hammer)) => "Unlock Weapon Hammer",
@@ -163,8 +165,8 @@ pub fn db_string_to_skill(skill_string: &str) -> comp::skills::Skill {
     use comp::{
         item::tool::ToolKind,
         skills::{
-            AxeSkill, BowSkill, GeneralSkill, HammerSkill, RollSkill, SceptreSkill, Skill::*,
+            AxeSkill, BowSkill, ClimbSkill, GeneralSkill, HammerSkill, RollSkill, SceptreSkill,
-            SkillGroupKind, StaffSkill, SwordSkill,
+            Skill::*, SkillGroupKind, StaffSkill, SwordSkill,
         },
     };
     match skill_string {
@@ -257,6 +259,8 @@ pub fn db_string_to_skill(skill_string: &str) -> comp::skills::Skill {
         "Roll Cost" => Roll(RollSkill::Cost),
         "Roll Strength" => Roll(RollSkill::Strength),
         "Roll Duration" => Roll(RollSkill::Duration),
+        "Climbing Cost" => Climb(ClimbSkill::Cost),
+        "Climbing Speed" => Climb(ClimbSkill::Speed),
         "Unlock Weapon Sword" => UnlockGroup(SkillGroupKind::Weapon(ToolKind::Sword)),
         "Unlock Weapon Axe" => UnlockGroup(SkillGroupKind::Weapon(ToolKind::Axe)),
         "Unlock Weapon Hammer" => UnlockGroup(SkillGroupKind::Weapon(ToolKind::Hammer)),

voxygen/src/hud/diary.rs

@@ -163,6 +163,9 @@ widget_ids! {
         skill_general_roll_1,
         skill_general_roll_2,
         skill_general_roll_3,
+        skill_general_climb_0,
+        skill_general_climb_1,
+        skill_general_climb_2,
     }
 }
 
@@ -572,6 +575,7 @@ impl<'a> Widget for Diary<'a> {
             _ => 0,
         };
         let skills_bot_r = match sel_tab {
+            SelectedSkillTree::General => 3,
             SelectedSkillTree::Weapon(ToolKind::Sword) => 1,
             SelectedSkillTree::Weapon(ToolKind::Bow) => 1,
             _ => 0,
@@ -701,7 +705,12 @@ impl<'a> Widget for Diary<'a> {
         let art_size = [320.0, 320.0];
         match sel_tab {
             SelectedSkillTree::General => {
-                use skills::{GeneralSkill::*, RollSkill::*, SkillGroupKind::*};
+                use skills::{
+                    ClimbSkill::{self},
+                    GeneralSkill::*,
+                    RollSkill::{self, *},
+                    SkillGroupKind::*,
+                };
                 use ToolKind::*;
                 // General Combat
                 Image::new(animate_by_pulse(
@@ -964,7 +973,7 @@ impl<'a> Widget for Diary<'a> {
                 {
                     events.push(Event::UnlockSkill(skill));
                 };
-                let skill = Skill::Roll(Cost);
+                let skill = Skill::Roll(RollSkill::Cost);
                 if create_skill_button(
                     self.imgs.utility_cost_skill,
                     state.skills_bot_l[1],
@@ -1018,7 +1027,7 @@ impl<'a> Widget for Diary<'a> {
                 };
                 let skill = Skill::Roll(Duration);
                 if create_skill_button(
-                    self.imgs.utility_amount_skill,
+                    self.imgs.utility_duration_skill,
                     state.skills_bot_l[3],
                     &self.stats.skill_set,
                     skill,
@@ -1042,6 +1051,70 @@ impl<'a> Widget for Diary<'a> {
                 {
                     events.push(Event::UnlockSkill(skill));
                 };
+                // Bottom right skills
+                Button::image(self.imgs.skill_climbing_skill)
+                    .w_h(74.0, 74.0)
+                    .mid_top_with_margin_on(state.skills_bot_r[0], 3.0)
+                    .with_tooltip(
+                        self.tooltip_manager,
+                        &self.localized_strings.get("hud.skill.climbing_title"),
+                        &self.localized_strings.get("hud.skill.climbing"),
+                        &diary_tooltip,
+                        TEXT_COLOR,
+                    )
+                    .set(state.skill_general_climb_0, ui);
+                let skill = Skill::Climb(ClimbSkill::Cost);
+                if create_skill_button(
+                    self.imgs.utility_cost_skill,
+                    state.skills_bot_r[1],
+                    &self.stats.skill_set,
+                    skill,
+                    self.fonts,
+                    &get_skill_label(skill, &self.stats.skill_set),
+                )
+                .with_tooltip(
+                    self.tooltip_manager,
+                    &self.localized_strings.get("hud.skill.climbing_cost_title"),
+                    &add_sp_cost_tooltip(
+                        &self.localized_strings.get("hud.skill.climbing_cost"),
+                        skill,
+                        &self.stats.skill_set,
+                        &self.localized_strings,
+                    ),
+                    &diary_tooltip,
+                    TEXT_COLOR,
+                )
+                .set(state.skill_general_climb_1, ui)
+                .was_clicked()
+                {
+                    events.push(Event::UnlockSkill(skill));
+                };
+                let skill = Skill::Climb(ClimbSkill::Speed);
+                if create_skill_button(
+                    self.imgs.utility_speed_skill,
+                    state.skills_bot_r[2],
+                    &self.stats.skill_set,
+                    skill,
+                    self.fonts,
+                    &get_skill_label(skill, &self.stats.skill_set),
+                )
+                .with_tooltip(
+                    self.tooltip_manager,
+                    &self.localized_strings.get("hud.skill.climbing_speed_title"),
+                    &add_sp_cost_tooltip(
+                        &self.localized_strings.get("hud.skill.climbing_speed"),
+                        skill,
+                        &self.stats.skill_set,
+                        &self.localized_strings,
+                    ),
+                    &diary_tooltip,
+                    TEXT_COLOR,
+                )
+                .set(state.skill_general_climb_2, ui)
+                .was_clicked()
+                {
+                    events.push(Event::UnlockSkill(skill));
+                };
             },
             SelectedSkillTree::Weapon(ToolKind::Sword) => {
                 use skills::SwordSkill::*;
@@ -3537,7 +3610,7 @@ impl<'a> Widget for Diary<'a> {
                 };
                 let skill = Skill::Sceptre(ADuration);
                 if create_skill_button(
-                    self.imgs.buff_speed_skill,
+                    self.imgs.buff_duration_skill,
                     state.skills_bot_l[2],
                     &self.stats.skill_set,
                     skill,

voxygen/src/hud/img_ids.rs

@@ -181,6 +181,7 @@ image_ids! {
         unlock_staff_skill0: "voxygen.element.icons.skilltree.unlock_staff-0",
         unlock_sword_skill: "voxygen.element.icons.skilltree.unlock_sword",
         skill_dodge_skill: "voxygen.element.icons.skilltree.skill_dodge",
+        skill_climbing_skill: "voxygen.element.icons.skilltree.skill_climbing",
 
         buff_amount_skill: "voxygen.element.icons.skilltree.buff_amount",
         buff_combo_skill: "voxygen.element.icons.skilltree.buff_combo",
@@ -198,6 +199,7 @@ image_ids! {
         buff_projectile_speed_skill: "voxygen.element.icons.skilltree.buff_projectile_speed",
         buff_radius_skill: "voxygen.element.icons.skilltree.buff_radius",
         buff_speed_skill: "voxygen.element.icons.skilltree.buff_speed",
+        buff_duration_skill: "voxygen.element.icons.skilltree.buff_duration",
 
         debuff_amount_skill: "voxygen.element.icons.skilltree.debuff_amount",
         debuff_combo_skill: "voxygen.element.icons.skilltree.debuff_combo",
@@ -215,6 +217,7 @@ image_ids! {
         debuff_projectile_speed_skill: "voxygen.element.icons.skilltree.debuff_projectile_speed",
         debuff_radius_skill: "voxygen.element.icons.skilltree.debuff_radius",
         debuff_speed_skill: "voxygen.element.icons.skilltree.debuff_speed",
+        debuff_duration_skill: "voxygen.element.icons.skilltree.debuff_duration",
 
         heal_amount_skill: "voxygen.element.icons.skilltree.heal_amount",
         heal_combo_skill: "voxygen.element.icons.skilltree.heal_combo",
@@ -232,6 +235,7 @@ image_ids! {
         heal_projectile_speed_skill: "voxygen.element.icons.skilltree.heal_projectile_speed",
         heal_radius_skill: "voxygen.element.icons.skilltree.heal_radius",
         heal_speed_skill: "voxygen.element.icons.skilltree.heal_speed",
+        heal_duration_skill: "voxygen.element.icons.skilltree.heal_duration",
 
         magic_amount_skill: "voxygen.element.icons.skilltree.magic_amount",
         magic_combo_skill: "voxygen.element.icons.skilltree.magic_combo",
@@ -249,6 +253,7 @@ image_ids! {
         magic_projectile_speed_skill: "voxygen.element.icons.skilltree.magic_projectile_speed",
         magic_radius_skill: "voxygen.element.icons.skilltree.magic_radius",
         magic_speed_skill: "voxygen.element.icons.skilltree.magic_speed",
+        magic_duration_skill: "voxygen.element.icons.skilltree.magic_duration",
 
         physical_amount_skill: "voxygen.element.icons.skilltree.physical_amount",
         physical_combo_skill: "voxygen.element.icons.skilltree.physical_combo",
@@ -266,6 +271,7 @@ image_ids! {
         physical_projectile_speed_skill: "voxygen.element.icons.skilltree.physical_projectile_speed",
         physical_radius_skill: "voxygen.element.icons.skilltree.physical_radius",
         physical_speed_skill: "voxygen.element.icons.skilltree.physical_speed",
+        physical_duration_skill: "voxygen.element.icons.skilltree.physical_duration",
 
         utility_amount_skill: "voxygen.element.icons.skilltree.utility_amount",
         utility_combo_skill: "voxygen.element.icons.skilltree.utility_combo",
@@ -283,6 +289,7 @@ image_ids! {
         utility_projectile_speed_skill: "voxygen.element.icons.skilltree.utility_projectile_speed",
         utility_radius_skill: "voxygen.element.icons.skilltree.utility_radius",
         utility_speed_skill: "voxygen.element.icons.skilltree.utility_speed",
+        utility_duration_skill: "voxygen.element.icons.skilltree.utility_duration",
 
         // Skillbar
         level_up: "voxygen.element.misc_bg.level_up",