more armour types

assets/voxygen/voxel/humanoid_armor_head_manifest.ron

@@ -0,0 +1,12 @@
+((
+    default: (
+        vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+        color: None
+    ),
+    map: {
+      Neck0: (
+          vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+          color: None
+      ),     
+    },
+))

assets/voxygen/voxel/humanoid_armor_lantern_manifest.ron

@@ -0,0 +1,12 @@
+((
+    default: (
+        vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+        color: None
+    ),
+    map: {
+      Green0: (
+          vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+          color: None
+      ),     
+    },
+))

assets/voxygen/voxel/humanoid_armor_neck_manifest.ron

@@ -0,0 +1,12 @@
+((
+    default: (
+        vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+        color: None
+    ),
+    map: {
+      Neck0: (
+          vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+          color: None
+      ),     
+    },
+))

assets/voxygen/voxel/humanoid_armor_ring_manifest.ron

@@ -0,0 +1,12 @@
+((
+    default: (
+        vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+        color: None
+    ),
+    map: {
+      Ring0: (
+          vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+          color: None
+      ),     
+    },
+))

assets/voxygen/voxel/humanoid_armor_tabard_manifest.ron

@@ -0,0 +1,12 @@
+((
+    default: (
+        vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+        color: None
+    ),
+    map: {
+      Neck0: (
+          vox_spec: ("armor.empty", (0.0, 0.0, 0.0)),
+          color: None
+      ),     
+    },
+))

common/src/comp/ability.rs

@@ -105,6 +105,11 @@ pub struct Loadout {
     pub pants: Option<Item>,
     pub foot: Option<Item>,
     pub back: Option<Item>,
+    pub ring: Option<Item>,
+    pub neck: Option<Item>,
+    pub lantern: Option<Item>,
+    pub head: Option<Item>,
+    pub tabard: Option<Item>,
 }
 
 impl From<&CharacterAbility> for CharacterState {

common/src/comp/inventory/item/armor.rs

@@ -169,6 +169,36 @@ pub enum Back {
     Short0 = 1,
 }
 pub const ALL_BACKS: [Back; 1] = [Back::Short0];
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[repr(u32)]
+pub enum Ring {
+    Ring0 = 1,
+}
+pub const ALL_RINGS: [Ring; 1] = [Ring::Ring0];
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[repr(u32)]
+pub enum Neck {
+    Neck0 = 1,
+}
+pub const ALL_NECKS: [Neck; 1] = [Neck::Neck0];
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[repr(u32)]
+pub enum Lantern {
+    Lantern0 = 1,
+}
+pub const ALL_LANTERNS: [Lantern; 1] = [Lantern::Lantern0];
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[repr(u32)]
+pub enum Head {
+    Head0 = 1,
+}
+pub const ALL_HEADS: [Head; 1] = [Head::Head0];
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[repr(u32)]
+pub enum Tabard {
+    Tabard0 = 1,
+}
+pub const ALL_TABARDS: [Tabard; 1] = [Tabard::Tabard0];
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum Armor {
@@ -179,6 +209,11 @@ pub enum Armor {
     Pants(Pants),
     Foot(Foot),
     Back(Back),
+    Ring(Ring),
+    Neck(Neck),
+    Lantern(Lantern),
+    Head(Head),
+    Tabard(Tabard),
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]

server/src/events/inventory_manip.rs

@@ -139,6 +139,11 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
                                 Pants(_) => &mut loadout.pants,
                                 Foot(_) => &mut loadout.foot,
                                 Back(_) => &mut loadout.back,
+                                Ring(_) => &mut loadout.back,
+                                Neck(_) => &mut loadout.back,
+                                Lantern(_) => &mut loadout.back,
+                                Head(_) => &mut loadout.back,
+                                Tabard(_) => &mut loadout.back,
                             };
 
                             // Insert old item into inventory

server/src/state_ext.rs

@@ -185,6 +185,11 @@ impl StateExt for State {
                     pants: None,
                     foot: None,
                     back: None,
+                    ring: None,
+                    neck: None,
+                    lantern: None,
+                    head: None,
+                    tabard: None,
                 }
             } else {
                 comp::Loadout::default()

server/src/sys/terrain.rs

@@ -244,6 +244,11 @@ impl<'a> System<'a> for Sys {
                                 "common.items.armor.foot.leather_0",
                             )),
                             back: None,
+                            ring: None,
+                            neck: None,
+                            lantern: None,
+                            head: None,
+                            tabard: None,
                         },
                         comp::Alignment::Enemy => comp::Loadout {
                             active_item,
@@ -267,6 +272,11 @@ impl<'a> System<'a> for Sys {
                                 "common.items.armor.foot.plate_0",
                             )),
                             back: None,
+                            ring: None,
+                            neck: None,
+                            lantern: None,
+                            head: None,
+                            tabard: None,
                         },
                         _ => comp::Loadout {
                             active_item,
@@ -278,6 +288,11 @@ impl<'a> System<'a> for Sys {
                             pants: None,
                             foot: None,
                             back: None,
+                            ring: None,
+                            neck: None,
+                            lantern: None,
+                            head: None,
+                            tabard: None,
                         },
                     };
 
@@ -339,6 +354,11 @@ impl<'a> System<'a> for Sys {
                                 "common.items.armor.foot.plate_0",
                             )),
                             back: None,
+                            ring: None,
+                            neck: None,
+                            lantern: None,
+                            head: None,
+                            tabard: None,
                         };
 
                         stats.level.set_level(rand::thread_rng().gen_range(30, 35));

voxygen/src/menu/char_selection/ui.rs

@@ -356,6 +356,11 @@ impl CharSelectionUi {
                     pants: None,
                     foot: None,
                     back: None,
+                    ring: None,
+                    neck: None,
+                    lantern: None,
+                    head: None,
+                    tabard: None,
                 };
                 Some(loadout)
             },

voxygen/src/scene/figure/load.rs

@@ -12,7 +12,7 @@ use common::{
         dragon, fish_medium, fish_small,
         humanoid::{Body, BodyType, EyeColor, Eyebrows, Race, Skin},
         item::{
-            armor::{Armor, Back, Belt, Chest, Foot, Hand, Pants, Shoulder},
+            armor::{Armor, Back, Belt, Chest, Foot, Hand, Head, Lantern, Pants, Shoulder, Tabard},
             tool::{Tool, ToolKind},
             ItemKind,
         },
@@ -258,6 +258,12 @@ pub struct HumArmorFootSpec(ArmorVoxSpecMap<Foot, ArmorVoxSpec>);
 pub struct HumMainWeaponSpec(HashMap<ToolKind, ArmorVoxSpec>);
 #[derive(Serialize, Deserialize)]
 pub struct HumArmorBackSpec(ArmorVoxSpecMap<Back, ArmorVoxSpec>);
+#[derive(Serialize, Deserialize)]
+pub struct HumArmorLanternSpec(ArmorVoxSpecMap<Lantern, ArmorVoxSpec>);
+#[derive(Serialize, Deserialize)]
+pub struct HumArmorHeadSpec(ArmorVoxSpecMap<Head, ArmorVoxSpec>);
+#[derive(Serialize, Deserialize)]
+pub struct HumArmorTabardSpec(ArmorVoxSpecMap<Tabard, ArmorVoxSpec>);
 
 impl Asset for HumArmorShoulderSpec {
     const ENDINGS: &'static [&'static str] = &["ron"];
@@ -308,6 +314,27 @@ impl Asset for HumArmorBackSpec {
         ron::de::from_reader(buf_reader).map_err(assets::Error::parse_error)
     }
 }
+impl Asset for HumArmorLanternSpec {
+    const ENDINGS: &'static [&'static str] = &["ron"];
+
+    fn parse(buf_reader: BufReader<File>) -> Result<Self, assets::Error> {
+        ron::de::from_reader(buf_reader).map_err(assets::Error::parse_error)
+    }
+}
+impl Asset for HumArmorHeadSpec {
+    const ENDINGS: &'static [&'static str] = &["ron"];
+
+    fn parse(buf_reader: BufReader<File>) -> Result<Self, assets::Error> {
+        ron::de::from_reader(buf_reader).map_err(assets::Error::parse_error)
+    }
+}
+impl Asset for HumArmorTabardSpec {
+    const ENDINGS: &'static [&'static str] = &["ron"];
+
+    fn parse(buf_reader: BufReader<File>) -> Result<Self, assets::Error> {
+        ron::de::from_reader(buf_reader).map_err(assets::Error::parse_error)
+    }
+}
 impl Asset for HumMainWeaponSpec {
     const ENDINGS: &'static [&'static str] = &["ron"];
 
@@ -315,7 +342,7 @@ impl Asset for HumMainWeaponSpec {
         ron::de::from_reader(buf_reader).map_err(assets::Error::parse_error)
     }
 }
-
+// Shoulder
 impl HumArmorShoulderSpec {
     pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
         assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_shoulder_manifest", indicator)
@@ -372,7 +399,7 @@ impl HumArmorShoulderSpec {
         self.mesh_shoulder(body, loadout, false)
     }
 }
-
+// Chest
 impl HumArmorChestSpec {
     pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
         assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_chest_manifest", indicator)
@@ -423,7 +450,7 @@ impl HumArmorChestSpec {
         generate_mesh(&chest, Vec3::from(spec.vox_spec.1))
     }
 }
-
+// Hand
 impl HumArmorHandSpec {
     pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
         assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_hand_manifest", indicator)
@@ -475,7 +502,7 @@ impl HumArmorHandSpec {
         self.mesh_hand(body, loadout, false)
     }
 }
-
+// Belt
 impl HumArmorBeltSpec {
     pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
         assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_belt_manifest", indicator)
@@ -509,7 +536,7 @@ impl HumArmorBeltSpec {
         generate_mesh(&belt_segment, Vec3::from(spec.vox_spec.1))
     }
 }
-
+// Legs
 impl HumArmorPantsSpec {
     pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
         assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_pants_manifest", indicator)
@@ -560,7 +587,7 @@ impl HumArmorPantsSpec {
         generate_mesh(&pants, Vec3::from(spec.vox_spec.1))
     }
 }
-
+// Foot
 impl HumArmorFootSpec {
     pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
         assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_foot_manifest", indicator)
@@ -632,6 +659,7 @@ impl HumMainWeaponSpec {
         generate_mesh(&tool_kind_segment, Vec3::from(spec.vox_spec.1))
     }
 }
+// Back
 impl HumArmorBackSpec {
     pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
         assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_back_manifest", indicator)
@@ -682,13 +710,164 @@ impl HumArmorBackSpec {
         generate_mesh(&back, Vec3::from(spec.vox_spec.1))
     }
 }
+// Lantern
+impl HumArmorLanternSpec {
+    pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
+        assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_lantern_manifest", indicator)
+            .unwrap()
+    }
 
+    pub fn mesh_lantern(&self, body: &Body, loadout: &Loadout) -> Mesh<FigurePipeline> {
+        let spec = if let Some(ItemKind::Armor {
+            kind: Armor::Lantern(lantern),
+            ..
+        }) = loadout.lantern.as_ref().map(|i| &i.kind)
+        {
+            match self.0.map.get(&lantern) {
+                Some(spec) => spec,
+                None => {
+                    error!("No lantern specification exists for {:?}", lantern);
+                    return load_mesh("not_found", Vec3::new(-5.0, -3.5, 1.0));
+                },
+            }
+        } else {
+            &self.0.default
+        };
+
+        let color = |mat_segment| {
+            color_segment(
+                mat_segment,
+                body.race.skin_color(body.skin),
+                body.race.hair_color(body.hair_color),
+                body.race.eye_color(body.eye_color),
+            )
+        };
+
+        let bare_lantern = graceful_load_mat_segment("armor.empty");
+
+        let mut lantern_armor = graceful_load_mat_segment(&spec.vox_spec.0);
+
+        if let Some(color) = spec.color {
+            let lantern_color = Vec3::from(color);
+            lantern_armor =
+                lantern_armor.map_rgb(|rgb| recolor_grey(rgb, Rgb::from(lantern_color)));
+        }
+
+        let lantern = DynaUnionizer::new()
+            .add(color(bare_lantern), Vec3::new(0, 0, 0))
+            .add(color(lantern_armor), Vec3::new(0, 0, 0))
+            .unify()
+            .0;
+
+        generate_mesh(&lantern, Vec3::from(spec.vox_spec.1))
+    }
+}
+impl HumArmorHeadSpec {
+    pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
+        assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_head_manifest", indicator)
+            .unwrap()
+    }
+
+    pub fn mesh_lantern(&self, body: &Body, loadout: &Loadout) -> Mesh<FigurePipeline> {
+        let spec = if let Some(ItemKind::Armor {
+            kind: Armor::Head(head),
+            ..
+        }) = loadout.head.as_ref().map(|i| &i.kind)
+        {
+            match self.0.map.get(&head) {
+                Some(spec) => spec,
+                None => {
+                    error!("No head specification exists for {:?}", head);
+                    return load_mesh("not_found", Vec3::new(-5.0, -3.5, 1.0));
+                },
+            }
+        } else {
+            &self.0.default
+        };
+
+        let color = |mat_segment| {
+            color_segment(
+                mat_segment,
+                body.race.skin_color(body.skin),
+                body.race.hair_color(body.hair_color),
+                body.race.eye_color(body.eye_color),
+            )
+        };
+
+        let bare_head = graceful_load_mat_segment("armor.empty");
+
+        let mut head_armor = graceful_load_mat_segment(&spec.vox_spec.0);
+
+        if let Some(color) = spec.color {
+            let head_color = Vec3::from(color);
+            head_armor = head_armor.map_rgb(|rgb| recolor_grey(rgb, Rgb::from(head_color)));
+        }
+
+        let head = DynaUnionizer::new()
+            .add(color(bare_head), Vec3::new(0, 0, 0))
+            .add(color(head_armor), Vec3::new(0, 0, 0))
+            .unify()
+            .0;
+
+        generate_mesh(&head, Vec3::from(spec.vox_spec.1))
+    }
+}
+impl HumArmorTabardSpec {
+    pub fn load_watched(indicator: &mut ReloadIndicator) -> Arc<Self> {
+        assets::load_watched::<Self>("voxygen.voxel.humanoid_armor_tabard_manifest", indicator)
+            .unwrap()
+    }
+
+    pub fn mesh_lantern(&self, body: &Body, loadout: &Loadout) -> Mesh<FigurePipeline> {
+        let spec = if let Some(ItemKind::Armor {
+            kind: Armor::Tabard(tabard),
+            ..
+        }) = loadout.tabard.as_ref().map(|i| &i.kind)
+        {
+            match self.0.map.get(&tabard) {
+                Some(spec) => spec,
+                None => {
+                    error!("No tabard specification exists for {:?}", tabard);
+                    return load_mesh("not_found", Vec3::new(-5.0, -3.5, 1.0));
+                },
+            }
+        } else {
+            &self.0.default
+        };
+
+        let color = |mat_segment| {
+            color_segment(
+                mat_segment,
+                body.race.skin_color(body.skin),
+                body.race.hair_color(body.hair_color),
+                body.race.eye_color(body.eye_color),
+            )
+        };
+
+        let bare_tabard = graceful_load_mat_segment("armor.empty");
+
+        let mut tabard_armor = graceful_load_mat_segment(&spec.vox_spec.0);
+
+        if let Some(color) = spec.color {
+            let tabard_color = Vec3::from(color);
+            tabard_armor = tabard_armor.map_rgb(|rgb| recolor_grey(rgb, Rgb::from(tabard_color)));
+        }
+
+        let tabard = DynaUnionizer::new()
+            .add(color(bare_tabard), Vec3::new(0, 0, 0))
+            .add(color(tabard_armor), Vec3::new(0, 0, 0))
+            .unify()
+            .0;
+
+        generate_mesh(&tabard, Vec3::from(spec.vox_spec.1))
+    }
+}
 // TODO: Inventory
 pub fn mesh_glider() -> Mesh<FigurePipeline> {
     load_mesh("object.glider", Vec3::new(-26.0, -26.0, -5.0))
 }
 pub fn mesh_lantern() -> Mesh<FigurePipeline> {
-    load_mesh("object.glider", Vec3::new(-26.0, -26.0, -5.0))
+    load_mesh("object.lantern0", Vec3::new(0.0, 0.0, 0.0))
 }
 
 /////////