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

#![allow(dead_code)]

use serde::{Deserialize, Serialize};
use specs::{
    error::NoError,
    hibitset::BitSet,
    saveload::{ConvertSaveload, Marker},
    Component, Entity, HashMapStorage, VecStorage,
};

use crate::{
    builder::FleetBuilder,
    components::{Ship, ShipCount},
    misc::FlaggedStorage,
};

/// A fleet is a group of ships that share the same operation
#[derive(Debug, Clone)]
pub struct Fleet {
    owned: BitSet,
    count: ShipCount,
}

/// Entities with this component are owned by a certain fleet entity
#[derive(Copy, Clone, Debug)]
pub struct FleetOwned {
    owner: Entity,
}

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

/* Fleet */

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

    #[inline]
    pub fn owned(&self) -> &BitSet {
        &self.owned
    }

    #[inline]
    pub fn count(&self) -> &ShipCount {
        &self.count
    }
}

impl Fleet {
    pub(crate) fn new() -> Self {
        Self {
            owned: BitSet::new(),
            count: ShipCount::none(),
        }
    }

    pub(crate) fn add_ship(&mut self, ship_id: Entity, ship: &Ship) {
        let type_ = ship.type_();

        self.count[type_] += 1;
        self.owned.add(ship_id.id());
    }

    pub(crate) fn remove_ship(&mut self, ship_id: Entity, ship: &Ship) {
        let type_ = ship.type_();

        self.count[type_] -= 1;
        self.owned.remove(ship_id.id());
    }
}

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

/* FleetOwned */

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

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

    pub(crate) fn set_owner(&mut self, owner: Entity) {
        self.owner = owner;
    }
}

impl Component for FleetOwned {
    type Storage = FlaggedStorage<Self, VecStorage<Self>>;
}

impl<M> ConvertSaveload<M> for FleetOwned
where
    for<'de> M: Marker + Serialize + Deserialize<'de>,
{
    type Data = FleetOwnedData<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(FleetOwnedData { 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(FleetOwned { owner })
    }
}