werewolves/werewolves-proto/src/message/ident.rs

use core::{fmt::Display, num::NonZeroU8};

use serde::{Deserialize, Serialize};

use crate::{
    diedto::DiedTo,
    player::{CharacterId, PlayerId},
    role::RoleTitle,
};

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Identification {
    pub player_id: PlayerId,
    pub public: PublicIdentity,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct PublicIdentity {
    pub name: String,
    pub pronouns: Option<String>,
    pub number: Option<NonZeroU8>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CharacterIdentity {
    pub character_id: CharacterId,
    pub name: String,
    pub pronouns: Option<String>,
    pub number: NonZeroU8,
}

impl From<CharacterIdentity> for PublicIdentity {
    fn from(c: CharacterIdentity) -> Self {
        Self {
            name: c.name,
            pronouns: c.pronouns,
            number: Some(c.number),
        }
    }
}

impl From<&CharacterIdentity> for PublicIdentity {
    fn from(c: &CharacterIdentity) -> Self {
        Self {
            name: c.name.clone(),
            pronouns: c.pronouns.clone(),
            number: Some(c.number),
        }
    }
}

impl Display for CharacterIdentity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let CharacterIdentity {
            character_id,
            name,
            pronouns,
            number,
        } = self;
        let pronouns = pronouns
            .as_ref()
            .map(|p| format!(" ({p})"))
            .unwrap_or_default();

        write!(f, "[{number}] {name}{pronouns} <<{character_id}>>")
    }
}

impl CharacterIdentity {
    pub const fn new(
        character_id: CharacterId,
        name: String,
        pronouns: Option<String>,
        number: NonZeroU8,
    ) -> Self {
        Self {
            name,
            number,
            pronouns,
            character_id,
        }
    }
}

impl Display for PublicIdentity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let PublicIdentity {
            name,
            pronouns,
            number,
        } = self;
        let pronouns = pronouns
            .as_ref()
            .map(|p| format!(" ({p})"))
            .unwrap_or_default();
        let number = number
            .as_ref()
            .map(|n| format!("[{n}] "))
            .unwrap_or_default();
        write!(f, "{number}{name}{pronouns}")
    }
}

impl core::hash::Hash for Identification {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.player_id.hash(state);
    }
}

impl Display for Identification {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let Identification { player_id, public } = self;
        write!(f, "{public} [{player_id}]")
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PlayerState {
    pub identification: Identification,
    pub connected: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CharacterState {
    pub player_id: PlayerId,
    pub identity: CharacterIdentity,
    pub role: RoleTitle,
    pub died_to: Option<DiedTo>,
}