Add and Implement AsGenericChar where possible right now

Cargo.lock

···
  "binrw",
  "paste",
  "svgbobdoc",
+ "thiserror 2.0.12",
  "vee_parse_macros",
 ]
 

crates/vee_parse/Cargo.toml

···
 paste = "1"
 vee_parse_macros = { path = "../vee_parse_macros", version = "0.2.0" }
 svgbobdoc = { version = "0.3", features = ["enable"] }
+thiserror = "2"
 
 [lints]
 workspace = true

crates/vee_parse/src/ctr.rs

···
-use crate::FixedLengthWideString;
+use crate::error::CharConversionError;
+use crate::generic::{
+    AsGenericChar, Beard, Body, CreationData, CtrCreationData, Eye, Eyebrow, Faceline,
+    FavoriteColor, Gender, GenericColor, Glass, Hair, MetaData, Mole, Mouth, Mustache, Nose,
+    Position, PositionY, Rotation, Scale, ScaleX, ScaleY, UniformScale,
+};
+use crate::nx::NxColor;
+use crate::seal::Sealant;
+use crate::{FixedLengthWideString, GenericChar, u8_to_bool};
 use bilge::prelude::*;
 use binrw::{BinRead, BinWrite, binrw};
 use vee_parse_macros::bitfield;
···
 pub struct BeardField {
     pub beard_type: u3,
     pub beard_color: u3,
-    pub beard_scale: u4,
-    pub beard_y: u5,
+    pub mustache_scale: u4,
+    pub mustache_y: u5,
     pub padding_7: u1,
 }
 
···
     pub data: [u8; 8],
 }
 
+// FFLiCreateID
 #[binrw]
 #[derive(Debug)]
 pub struct CtrCreateId {
···
     pub padding: u16,
     pub crc: u16,
 }
+
+fn cafe_color_generic(col: u8) -> GenericColor {
+    GenericColor::CafeTable(col.into())
+}
+
+impl Sealant for CtrStoreData {}
+
+impl AsGenericChar for CtrStoreData {
+    fn as_generic(&self) -> Result<GenericChar, CharConversionError> {
+        let char = GenericChar {
+            name: self.name.to_string(),
+
+            creation_data: CreationData::Ctr(CtrCreationData {}),
+            body: Body {
+                gender: Gender::from_u8(self.personal_info_2.gender().as_u8())?,
+                height: self.height,
+                build: self.build,
+            },
+            faceline: Faceline {
+                ty: self.face.face_type().as_u8(),
+                color: cafe_color_generic(self.face.face_color().as_u8()),
+                wrinkle_ty: self.face.face_texture().as_u8(),
+                makeup_ty: self.face.face_makeup().as_u8(),
+            },
+            hair: Hair {
+                ty: self.hair.hair_type(),
+                color: cafe_color_generic(self.hair.hair_color().as_u8()),
+                flip: u8_to_bool(self.hair.hair_flip().as_u8(), "hair::flip".to_string())?,
+            },
+            eye: Eye {
+                ty: self.eye.eye_type().as_u8(),
+                color: cafe_color_generic(self.eye.eye_color().as_u8()),
+                pos: Position {
+                    x: self.eye_position.eye_x().as_u8(),
+                    y: self.eye_position.eye_y().as_u8(),
+                },
+                scale: ScaleY {
+                    h: self.eye.eye_scale().as_u8(),
+                },
+                rotation: Rotation {
+                    ang: self.eye_position.eye_rotate().as_u8(),
+                },
+            },
+            eyebrow: Eyebrow {
+                ty: self.eyebrow.eyebrow_type().as_u8(),
+                color: cafe_color_generic(self.eyebrow.eyebrow_color().as_u8()),
+                pos: Position {
+                    x: self.eyebrow_position.eyebrow_x().as_u8(),
+                    y: self.eyebrow_position.eyebrow_y().as_u8(),
+                },
+                scale: Scale {
+                    w: self.eyebrow.eyebrow_scale().as_u8(),
+                    h: self.eyebrow.eyebrow_aspect().as_u8(),
+                },
+                rotation: Rotation {
+                    ang: self.eyebrow_position.eyebrow_rotate().as_u8(),
+                },
+            },
+            nose: Nose {
+                ty: self.nose.nose_type().as_u8(),
+                pos: PositionY {
+                    y: self.nose.nose_y().as_u8(),
+                },
+                scale: UniformScale {
+                    amount: self.nose.nose_scale().as_u8(),
+                },
+            },
+            mouth: Mouth {
+                ty: self.mouth.mouth_type().as_u8(),
+                color: cafe_color_generic(self.mouth.mouth_color().as_u8()),
+                pos: PositionY {
+                    y: self.mouth_position.mouth_y().as_u8(),
+                },
+                scale: Scale {
+                    w: self.mouth.mouth_scale().as_u8(),
+                    h: self.mouth.mouth_aspect().as_u8(),
+                },
+            },
+            beard: Beard {
+                ty: self.beard.beard_type().as_u8(),
+                color: cafe_color_generic(self.beard.beard_color().as_u8()),
+            },
+            mustache: Mustache {
+                ty: self.mouth_position.mustache_type().as_u8(),
+                pos: PositionY {
+                    y: self.beard.mustache_y().as_u8(),
+                },
+                scale: ScaleX {
+                    w: self.beard.mustache_scale().as_u8(),
+                },
+            },
+            glass: Glass {
+                ty: self.glass.glass_type().as_u8(),
+                color: cafe_color_generic(self.glass.glass_color().as_u8()),
+                pos: PositionY {
+                    y: self.glass.glass_y().as_u8(),
+                },
+                scale: ScaleX {
+                    w: self.glass.glass_scale().as_u8(),
+                },
+            },
+            mole: Mole {
+                ty: self.mole.mole_type().as_u8(),
+                pos: Position {
+                    x: self.mole.mole_x().as_u8(),
+                    y: self.mole.mole_y().as_u8(),
+                },
+                scale: ScaleX {
+                    w: self.mole.mole_scale().as_u8(),
+                },
+            },
+            meta_data: MetaData {
+                special: {
+                    println!("Warn: Special flag is NOT being read. Placeholder value used.");
+                    false
+                },
+                favorite_color: FavoriteColor(self.personal_info_2.favorite_color().as_usize()),
+            },
+        };
+
+        Ok(char)
+    }
+}

crates/vee_parse/src/error.rs

···
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum CharConversionError {
+    #[error("Field `{0}` is out of bounds.")]
+    FieldOob(String),
+}

crates/vee_parse/src/generic.rs

···
+use crate::{error::CharConversionError, nx::UuidVer4, seal::Sealant};
+
 pub struct Position {
     pub x: u8,
     pub y: u8,
···
 /// 'Aspect'.
 pub struct ScaleY {
     pub h: u8,
+}
+
+/// Scale and aspect, at the same time.
+pub struct UniformScale {
+    pub amount: u8,
 }
 
 /// The actual angle is somewhat dependant on what the shape is.
···
 }
 
 /// Just so happens to be the same on every platform. Cool!
-pub struct FavoriteColor(usize);
+pub struct FavoriteColor(pub usize);
 
 pub struct Eye {
     pub ty: u8,
···
 pub struct Nose {
     pub ty: u8,
     pub pos: PositionY,
-    pub scale: ScaleX,
+    pub scale: UniformScale,
 }
 pub struct Mouth {
     pub ty: u8,
···
 
 pub struct Mustache {
     pub ty: u8,
-    pub color: GenericColor,
-    pub scale: ScaleY,
+    pub pos: PositionY,
+    pub scale: ScaleX,
 }
 
 pub struct Glass {
···
     Male,
     Female,
 }
+impl Gender {
+    pub fn from_bool(b: bool) -> Gender {
+        if b { Gender::Female } else { Gender::Male }
+    }
+    pub fn from_u8(u: u8) -> Result<Gender, CharConversionError> {
+        match u {
+            0_u8 => Ok(Gender::Male),
+            1_u8 => Ok(Gender::Female),
+            _ => Err(CharConversionError::FieldOob("gender".to_string())),
+        }
+    }
+}
 
 /// The body shape of the Char.
 pub struct Body {
···
     pub favorite_color: FavoriteColor,
 }
 
+pub struct RvlCreationData {/* todo */}
 pub struct CtrCreationData {/* todo */}
-pub struct NxCreationData {/* todo */}
+pub struct NxCreationData {
+    pub create_info: UuidVer4,
+    pub font_region: u8,
+    pub region_move: u8,
+}
 
 pub enum CreationData {
+    None,
+    Rvl(RvlCreationData),
     Ctr(CtrCreationData),
     Nx(NxCreationData),
 }
···
 /// Generic `Char` information.
 /// Names here are based on names in target-specific structs, but not representative.
 pub struct GenericChar {
+    /// Sometimes called "nickname"
     pub name: String,
 
     pub meta_data: MetaData,
···
     pub glass: Glass,
     pub mole: Mole,
 }
+
+/// This trait is sealed (you can't implement this on your own items.)
+pub trait AsGenericChar: Sealant {
+    /// Convert this representation into [GenericChar]
+    fn as_generic(&self) -> Result<GenericChar, CharConversionError>;
+}
+
+/// This trait is sealed (you can't implement this on your own items.)
+pub trait FromGenericChar: Sealant {
+    /// Hopefully the type you are implementing on.
+    type Output;
+
+    /// Make this char representation from [GenericChar]
+    fn from_generic(char: GenericChar) -> Self::Output;
+}

crates/vee_parse/src/lib.rs

···
 //!
 //! Supported by this library:
 //!
-//! | ..          | Ntr[^gen1]           | Rvl[^gen1]       | Ctr/Cafe    | Nx             | WebStudio |
+//! | ...         | Ntr[^gen1]           | Rvl[^gen1]       | Ctr/Cafe    | Nx             | WebStudio |
 //! |-------------|----------------------|------------------|-------------|----------------|-----------|
-//! | `CharInfo`  | ❌                   | ❌        | ❌                           | [`.charinfo`](NxCharInfo) | .. |
-//! | `StoreData` |  [`.nsd`](NtrStoreData) | [`.rsd`](RvlStoreData) | [`.ffsd`](CtrStoreData)[^ff]   | ❌ | .. |
-//! | `CoreData`  | [`.ncd`](NtrCharData) | [`.rcd`](RvlCharData) | ❌ | ❌ | .. |
-//! | In-memory   | .. | .. | .. | .. | 🏗️[^mnms]  |
+//! | `CharInfo`  | ❌                   | ❌        | ❌                           | [`.charinfo`](NxCharInfo) | [`.mnms`](StudioCharInfo)[^mnms]<sup>🏗</sup> |
+//! | `StoreData` |  [`.nsd`](NtrStoreData) | [`.rsd`](RvlStoreData) | [`.ffsd`](CtrStoreData)[^ff]   | ❌ | ❌ |
+//! | `CoreData`  | [`.ncd`](NtrCharData) | [`.rcd`](RvlCharData) | ❌ | ❌ | ❌ |
 //! [^gen1]: These formats are the same, apart from Ntr being little-endian and Rvl being big-endian.
-//! [^ff]: The official format is Ca**f**e **F**ace **S**tore **D**ata, probably due to CFSD being taken by Ctr <sup>[src](https://github.com/HEYimHeroic/MiiDataFiles)</sup>.
-//! [^mnms]: Stored in the browser's `localStorage`. Often shared as a base64 string, or sometimes saved with the `.mnms` extension.
+//! [^ff]: The official format is Ca**f**e **F**ace **S**tore **D**ata, probably due to CFSD being taken by Ctr.
+//! [^mnms]: You could tenuously call this a `CharInfo`. Stored in the browser's `localStorage`. Often shared as a base64 string, or stored with the unofficial `.mnms` extension.
 //!
 //! # Conversion
 //!
···
 /// ┌──┴────────┐         │               │        │              │
 /// │           ├────────►└───────────────┘        └──────────────┘
 /// │  RSD,RCD  │                   ▲
-/// │           │                   │             ┌────────────────┐
-/// └───────────┘                   │             │                │
-///                                 └────────────►│  WsLocalStore  │
-///                                               │                │
-///                                               └────────────────┘
+/// │           │                   │            ┌──────────────────┐
+/// └───────────┘                   │            │                  │
+///                                 └───────────►│  StudioCharInfo  │
+///                                              │                  │
+///                                              └──────────────────┘
 /// ```
 /// </center>
 )]
···
 //! ```
 
 pub mod ctr;
+pub mod error;
 pub mod generic;
 pub mod nx;
 pub mod rvl_ntr;
 
-pub use binrw::{BinRead, NullWideString, binrw};
+use crate::error::CharConversionError;
+pub use binrw::{binrw, BinRead, NullWideString};
 pub use ctr::CtrStoreData;
 pub use generic::GenericChar;
 pub use nx::NxCharInfo;
···
 pub use rvl_ntr::RvlCharData;
 pub use rvl_ntr::RvlStoreData;
 
+fn u8_to_bool(int: u8, field: String) -> Result<bool, CharConversionError> {
+    match int {
+        0 => Ok(false),
+        1 => Ok(true),
+        _ => Err(CharConversionError::FieldOob(field)),
+    }
+}
+
+pub(crate) mod seal {
+    pub trait Sealant {}
+}
+
 /// A UTF-16 String with a fixed length and non-enforced null termination.
 /// The string is allowed to reach the maximum length without a null terminator,
 /// and any nulls are stripped.
···
 
 #[cfg(test)]
 mod tests {
-    use crate::{CtrStoreData, NxCharInfo, RvlCharData, rvl_ntr::FavoriteColor};
+    use crate::{rvl_ntr::FavoriteColor, CtrStoreData, NxCharInfo, RvlCharData};
     use binrw::BinRead;
     use std::{error::Error, fs::File};
 

crates/vee_parse/src/nx.rs

···
-use binrw::NullWideString;
+use crate::{
+    FixedLengthWideString, GenericChar,
+    error::CharConversionError,
+    generic::{
+        AsGenericChar, Beard, Body, CreationData, Eye, Eyebrow, Faceline, FavoriteColor, Gender,
+        GenericColor, Glass, Hair, MetaData, Mole, Mouth, Mustache, Nose, NxCreationData, Position,
+        PositionY, Rotation, Scale, ScaleX, ScaleY, UniformScale,
+    },
+    seal::Sealant,
+    u8_to_bool,
+};
 use binrw::binrw;
-
-use crate::FixedLengthWideString;
 
 /// Wrapper for nn::mii color index.
 #[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Default)]
···
     pub mole_y: u8,
     pub reserved: u8, /* always zero */
 }
+
+fn nx_color_generic(col: NxColor) -> GenericColor {
+    GenericColor::NxTable(col.0.into())
+}
+
+impl Sealant for NxCharInfo {}
+
+impl AsGenericChar for NxCharInfo {
+    fn as_generic(&self) -> Result<GenericChar, CharConversionError> {
+        Ok(GenericChar {
+            name: self.nickname.to_string(),
+            body: Body {
+                gender: Gender::from_u8(self.gender)?,
+                height: self.height,
+                build: self.build,
+            },
+            faceline: Faceline {
+                ty: self.faceline_type,
+                color: nx_color_generic(self.faceline_color),
+                wrinkle_ty: self.faceline_wrinkle,
+                makeup_ty: self.faceline_make,
+            },
+            hair: Hair {
+                ty: self.hair_type,
+                color: nx_color_generic(self.hair_color),
+                flip: u8_to_bool(self.hair_flip, "hair::flip".to_string())?,
+            },
+            eye: Eye {
+                ty: self.eye_type,
+                color: nx_color_generic(self.eye_color),
+                pos: Position {
+                    x: self.eye_x,
+                    y: self.eye_y,
+                },
+                scale: ScaleY { h: self.eye_aspect },
+                rotation: Rotation {
+                    ang: self.eye_rotate,
+                },
+            },
+            eyebrow: Eyebrow {
+                ty: self.eyebrow_type,
+                color: nx_color_generic(self.eyebrow_color),
+                pos: Position {
+                    x: self.eyebrow_x,
+                    y: self.eyebrow_y,
+                },
+                scale: Scale {
+                    w: self.eye_scale,
+                    h: self.eye_aspect,
+                },
+                rotation: Rotation {
+                    ang: self.eye_rotate,
+                },
+            },
+            nose: Nose {
+                ty: self.nose_type,
+                pos: PositionY { y: self.nose_y },
+                scale: UniformScale {
+                    amount: self.nose_scale,
+                },
+            },
+            mouth: Mouth {
+                ty: self.mouth_type,
+                color: nx_color_generic(self.mouth_color),
+                pos: PositionY { y: self.mouth_y },
+                scale: Scale {
+                    w: self.mouth_scale,
+                    h: self.mouth_aspect,
+                },
+            },
+            beard: Beard {
+                ty: self.beard_type,
+                color: nx_color_generic(self.beard_color),
+            },
+            mustache: Mustache {
+                ty: self.mustache_y,
+                pos: PositionY { y: self.mustache_y },
+                scale: ScaleX {
+                    w: self.mustache_scale,
+                },
+            },
+            glass: Glass {
+                ty: self.glass_type,
+                color: nx_color_generic(self.glass_color),
+                pos: PositionY { y: self.glass_y },
+                scale: ScaleX {
+                    w: self.glass_scale,
+                },
+            },
+            mole: Mole {
+                ty: self.mole_type,
+                pos: Position {
+                    x: self.mole_x,
+                    y: self.mole_y,
+                },
+                scale: ScaleX { w: self.mole_scale },
+            },
+            meta_data: MetaData {
+                special: u8_to_bool(self.is_special, "meta_data::special".to_string())?,
+                favorite_color: FavoriteColor(self.favorite_color.0.into()),
+            },
+            creation_data: CreationData::Nx(NxCreationData {
+                create_info: self.create_info,
+                font_region: self.font_region,
+                region_move: self.region_move,
+            }),
+        })
+    }
+}

crates/vee_parse/src/rvl_ntr.rs

···
-use crate::FixedLengthWideString;
+use crate::{
+    FixedLengthWideString, GenericChar,
+    generic::{
+        AsGenericChar, Beard, Body, CreationData, Eye, Eyebrow, Faceline, Glass, Hair, MetaData,
+        Mole, Mouth, Mustache, Nose, PositionY, Rotation, Scale, UniformScale,
+    },
+    seal::Sealant,
+};
 use bilge::prelude::*;
 use binrw::{BinRead, BinWrite, binrw};
 use paste::paste;
···
     Black = 11,
     #[fallback]
     Invalid(u4),
+}
+
+impl FavoriteColor {
+    fn as_u8(&self) -> u8 {
+        match self {
+            FavoriteColor::Red => 0,
+            FavoriteColor::Orange => 1,
+            FavoriteColor::Yellow => 2,
+            FavoriteColor::YellowGreen => 3,
+            FavoriteColor::Green => 4,
+            FavoriteColor::Blue => 5,
+            FavoriteColor::SkyBlue => 6,
+            FavoriteColor::Pink => 7,
+            FavoriteColor::Purple => 8,
+            FavoriteColor::Brown => 9,
+            FavoriteColor::White => 10,
+            FavoriteColor::Black => 11,
+            FavoriteColor::Invalid(n) => n.as_u8(),
+        }
+    }
 }
 
 #[bitsize(1)]