space-crush/space-crush-common/src/components/player.rs

use glc::vector::Vector3f;
use serde::{Deserialize, Serialize};
use specs::{
    error::NoError,
    saveload::{ConvertSaveload, Marker},
    Component, Entity, HashMapStorage,
};

use crate::{
    builder::PlayerBuilder,
    components::{ShipData, ShipType, ShipsData},
    constants::{SHIPS_DATA_FIGHTER, SHIPS_DATA_RESEARCHER, SHIPS_DATA_TRADER},
};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Player {
    index: usize,
    race: Race,
    color: Vector3f,

    #[serde(skip)]
    ships_data: ShipsData,
}

#[derive(Copy, Clone, Debug, Serialize, Deserialize)]
pub enum Race {
    Fighter,
    Trader,
    Researcher,
}

#[derive(Copy, Clone, Debug)]
pub struct PlayerOwned {
    owner: Entity,
}

#[derive(Serialize, Deserialize)]
pub struct PlayerOwnedData<M> {
    pub owner: M,
}

/* Player */

impl Player {
    #[inline]
    pub fn builder() -> PlayerBuilder {
        PlayerBuilder::default()
    }

    #[inline]
    pub fn index(&self) -> usize {
        self.index
    }

    #[inline]
    pub fn color(&self) -> &Vector3f {
        &self.color
    }

    #[inline]
    pub fn ship_data(&self, type_: ShipType) -> &ShipData {
        &self.ships_data[type_]
    }

    #[inline]
    pub fn ships_data(&self) -> &ShipsData {
        &self.ships_data
    }
}

impl Player {
    #[inline]
    pub(crate) fn new(index: usize, race: Race, color: Vector3f) -> Self {
        Self {
            index,
            race,
            color,
            ships_data: match race {
                Race::Fighter => SHIPS_DATA_FIGHTER,
                Race::Trader => SHIPS_DATA_TRADER,
                Race::Researcher => SHIPS_DATA_RESEARCHER,
            },
        }
    }
}

impl Component for Player {
    type Storage = HashMapStorage<Self>;
}

/* PlayerOwned */

impl PlayerOwned {
    pub fn owner(&self) -> Entity {
        self.owner
    }
}

impl PlayerOwned {
    pub(crate) fn new(owner: Entity) -> Self {
        Self { owner }
    }
}

impl Component for PlayerOwned {
    type Storage = HashMapStorage<Self>;
}

impl<M> ConvertSaveload<M> for PlayerOwned
where
    for<'de> M: Marker + Serialize + Deserialize<'de>,
{
    type Data = PlayerOwnedData<M>;
    type Error = NoError;

    fn convert_into<F>(&self, mut ids: F) -> Result<Self::Data, Self::Error>
    where
        F: FnMut(Entity) -> Option<M>,
    {
        let owner = ids(self.owner).unwrap();

        Ok(PlayerOwnedData { owner })
    }

    fn convert_from<F>(data: Self::Data, mut ids: F) -> Result<Self, Self::Error>
    where
        F: FnMut(M) -> Option<Entity>,
    {
        let owner = ids(data.owner).unwrap();

        Ok(PlayerOwned { owner })
    }
}