Enum GameModSeed

Source

pub enum GameModSeed {
    Mode {
        mode: GameMode,
        deny_unknown_fields: bool,
    },
    GuessMode {
        deny_unknown_fields: bool,
    },
}

Available on crate feature serde only.

Expand description

Struct to pass parameters into a GameMod deserialization.

This deserializes an integer as bitflags, a string as an acronym, or a map as a GameMod struct.

§Examples

If the GameMode is available, we can use the Mode variant.

use rosu_mods::{GameMod, GameMode, serde::GameModSeed, generated_mods::DifficultyAdjustMania};
use serde::de;

// Note that `GameMod` does not implement `Deserialize` so we must
// implement it manually.
#[derive(serde::Deserialize)]
struct MyStruct(
    #[serde(deserialize_with = "custom_deser")]
    GameMod
);

// If this is our JSON...
const JSON: &str = r#"{
    "mode": 3,
    "mod": {
        "acronym": "DA",
        "settings": {
            "drain_rate": 0.73
        }
    }
}"#;

// ... our deserialization could look like this
fn custom_deser<'de, D: de::Deserializer<'de>>(d: D) -> Result<GameMod, D::Error> {
    struct MyVisitor;

    impl<'de> de::Visitor<'de> for MyVisitor {
        type Value = GameMod;

        fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            f.write_str("MyStruct")
        }

        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
        where
            A: de::MapAccess<'de>
        {
            let Some("mode") = map.next_key()? else {
                return Err(de::Error::custom("expected `mode` as first field"));
            };
            let mode: GameMode = map.next_value()?;
            let Some("mod") = map.next_key()? else {
                return Err(de::Error::custom("expected `mod` as second field"));
            };

            let seed = GameModSeed::Mode { mode, deny_unknown_fields: true }; // <-

            map.next_value_seed(seed)
        }
    }

    d.deserialize_map(MyVisitor)
}

let MyStruct(gamemod) = serde_json::from_str(JSON).unwrap();

assert_eq!(
    gamemod,
    GameMod::DifficultyAdjustMania(DifficultyAdjustMania {
        drain_rate: Some(0.73),
        ..Default::default()
    })
);

If the mode is not available, we can use the GuessMode variant.

use rosu_mods::{GameMod, serde::GameModSeed, generated_mods::DifficultyAdjustTaiko};
use serde::de;

#[derive(serde::Deserialize)]
struct MyStruct(
    #[serde(deserialize_with = "custom_deser")]
    GameMod,
);

// No mode in here so we can only guess
const JSON: &str = r#"{
    "acronym": "DA",
    "settings": {
        "scroll_speed": 0.95
    }
}"#;

// For the above JSON, the deserialization will try to use each mode's
// `GameMod` variant for the `DA` acronym.
// First it tries `DifficultyAdjustOsu` but sees that it has no
// `scroll_speed` field so it continues on and succeeds for the taiko
// variant. Note that if `deny_unknown_fields` was set to `false`, the
// unknown `scroll_speed` field would not have caused an error when
// deserializing the `DifficultyAdjustOsu`.

fn custom_deser<'de, D: de::Deserializer<'de>>(d: D) -> Result<GameMod, D::Error> {
    d.deserialize_map(GameModSeed::GuessMode { deny_unknown_fields: true })
}

let MyStruct(gamemod) = serde_json::from_str(JSON).unwrap();

assert_eq!(
    gamemod,
    GameMod::DifficultyAdjustTaiko(DifficultyAdjustTaiko {
        scroll_speed: Some(0.95),
        ..Default::default()
    })
);