jong/src/game/round.rs

use bevy::prelude::*;
use strum::{EnumCount, FromRepr};

use crate::{EnumNextCycle, game::GameState};

#[derive(Component)]
pub(crate) struct Dice(u8, u8);

#[derive(Resource)]
pub(crate) struct Compass {
    pub(crate) prevalent_wind: Wind,
    pub(crate) round: u8,
    pub(crate) dealer_wind: Wind,
    pub(crate) riichi: usize,
    pub(crate) honba: usize,
}

impl Default for Compass {
    fn default() -> Self {
        Self {
            prevalent_wind: Wind::Ton,
            round: 1,
            dealer_wind: Wind::Ton,
            riichi: 0,
            honba: 0,
        }
    }
}

#[derive(Resource)]
pub(crate) struct MatchSettings {
    pub(crate) starting_points: isize,
    pub(crate) player_count: u8,
}

impl Default for MatchSettings {
    fn default() -> Self {
        Self {
            starting_points: 25000,
            player_count: 4,
        }
    }
}

#[derive(Component, Clone, Copy, FromRepr, EnumCount)]
pub enum Wind {
    Ton,
    Nan,
    Shaa,
    Pei,
}

impl EnumNextCycle for Wind {
    fn next(&self) -> Self {
        if (*self as usize + 1) >= Self::COUNT {
            Self::from_repr(0).unwrap()
        } else {
            Self::from_repr(*self as usize + 1).unwrap()
        }
    }
}

#[derive(Resource)]
pub(crate) struct CurrentPlayer(pub Entity);

#[derive(SubStates, Default, Clone, Copy, PartialEq, Eq, Hash, Debug, FromRepr, EnumCount)]
#[source(GameState = GameState::Play)]
pub(crate) enum TurnState {
    #[default]
    Tsumo,
    Menzen,
    RiichiKan,
    Discard,
    RonChiiPonKan,
    End,
}

impl EnumNextCycle for TurnState {
    fn next(&self) -> Self {
        if (*self as usize + 1) >= Self::COUNT {
            Self::from_repr(0).unwrap()
        } else {
            Self::from_repr(*self as usize + 1).unwrap()
        }
    }
}