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

use specs::{
    saveload::MarkedBuilder, world::EntitiesRes, Builder, Entity, LazyUpdate, World, WorldExt,
    WriteStorage,
};

use crate::{
    components::{Fleet, FleetMoving, FleetOrbiting, PlayerOwned},
    misc::{Persistence, WorldPersistence},
};

use super::Error;

#[derive(Default, Clone)]
pub struct FleetBuilder {
    player: Option<Entity>,
    state: Option<State>,
}

#[derive(Clone)]
enum State {
    Orbiting(Entity),
    Moving(Entity),
}

impl FleetBuilder {
    pub fn build(&self, world: &mut World) -> Result<Entity, Error> {
        let player = self.player.ok_or(Error::MissingValue("player"))?;
        let state = self.state.as_ref().ok_or(Error::MissingValue("state"))?;

        let player_owned = PlayerOwned::new(player);
        let fleet = Fleet::new();

        let builder = world
            .create_entity()
            .marked::<<WorldPersistence as Persistence>::Marker>()
            .with(player_owned)
            .with(fleet);

        let builder = match state {
            State::Moving(target) => builder.with(FleetMoving::new(*target)),
            State::Orbiting(meeting_point) => builder.with(FleetOrbiting::new(*meeting_point)),
        };

        let entity = builder.build();

        Ok(entity)
    }

    pub fn lazy(
        &self,
        lazy: &LazyUpdate,
        entities: &EntitiesRes,
        players_owned: &mut WriteStorage<'_, PlayerOwned>,
        fleets: &mut WriteStorage<'_, Fleet>,
        fleets_moving: &mut WriteStorage<'_, FleetMoving>,
        fleets_orbiting: &mut WriteStorage<'_, FleetOrbiting>,
    ) -> Result<Entity, Error> {
        let player = self.player.ok_or(Error::MissingValue("player"))?;
        let state = self.state.as_ref().ok_or(Error::MissingValue("state"))?;

        let player_owned = PlayerOwned::new(player);
        let fleet = Fleet::new();

        let entity = lazy
            .create_entity(entities)
            .marked::<<WorldPersistence as Persistence>::Marker>()
            .build();

        players_owned.insert(entity, player_owned)?;
        fleets.insert(entity, fleet)?;

        match state {
            State::Moving(target) => {
                fleets_moving.insert(entity, FleetMoving::new(*target))?;
            }
            State::Orbiting(meeting_point) => {
                fleets_orbiting.insert(entity, FleetOrbiting::new(*meeting_point))?;
            }
        };

        Ok(entity)
    }

    pub fn player(mut self, player: Entity) -> Self {
        self.player = Some(player);

        self
    }

    pub fn orbiting(mut self, meeting_point: Entity) -> Self {
        self.state = Some(State::Orbiting(meeting_point));

        self
    }

    pub fn moving(mut self, target: Entity) -> Self {
        self.state = Some(State::Moving(target));

        self
    }
}