jong/src/game/round.rs

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

use crate::{
    EnumNextCycle,
    game::{
        GameMessage, GameState,
        hand::{DiscardedTile, DrawnTile, Hand},
        player::Player,
        wall::Wall,
    },
};

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

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

#[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,
}

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

pub enum WindRelation {
    Shimocha,
    Toimen,
    Kamicha,
}

#[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,
}

#[derive(EntityEvent)]
pub struct Discard(pub Entity);

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

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

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()
        }
    }
}

impl Wind {
    pub fn relate(&self, other: &Self) -> WindRelation {
        if self.next() == *other {
            WindRelation::Shimocha
        } else if other.next() == *self {
            WindRelation::Kamicha
        } else {
            WindRelation::Toimen
        }
    }
}

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()
        }
    }
}

pub(crate) fn tsumo(
    mut commands: Commands,
    curr_player: Res<CurrentPlayer>,
    // players: Populated<Entity, With<Player>>,
    wall_ent: Single<Entity, With<Wall>>,
    walltiles: Single<&Children, With<Wall>>,
    curr_turnstate: Res<State<TurnState>>,
    mut next_turnstate: ResMut<NextState<TurnState>>,
) {
    debug!("tsumo for: {:?}", curr_player.0);

    let drawn = walltiles.last().unwrap();
    commands.entity(*wall_ent).remove_child(*drawn);
    let drawn_ent = commands.spawn(DrawnTile(*drawn)).id();
    commands.entity(curr_player.0).add_child(drawn_ent);

    debug!("drew: ent: {drawn_ent:?} tile_ent: {:?}", drawn);

    next_turnstate.set(curr_turnstate.next());
}

pub(crate) fn menzen(
    curr_turnstate: Res<State<TurnState>>,
    mut next_turnstate: ResMut<NextState<TurnState>>,
) {
    trace!("menzen check");
    next_turnstate.set(curr_turnstate.next());
}

pub(crate) fn riichi_kan(
    curr_turnstate: Res<State<TurnState>>,
    mut next_turnstate: ResMut<NextState<TurnState>>,
) {
    trace!("riichi_kan");
    next_turnstate.set(curr_turnstate.next());
}

#[allow(clippy::too_many_arguments, irrefutable_let_patterns)]
pub(crate) fn discard(
    mut commands: Commands,
    mut reader: MessageReader<GameMessage>,

    currplayer: Res<CurrentPlayer>,
    drawntile: Single<(&DrawnTile, Entity), With<DrawnTile>>,
    player_hands: Populated<(&Player, &Children), With<Hand>>,
    hands: Populated<&Children, (With<Hand>, Without<Player>)>,

    curr_turnstate: Res<State<TurnState>>,
    mut next_turnstate: ResMut<NextState<TurnState>>,
) {
    let curr = currplayer.0;
    let hand = player_hands.get(curr).unwrap().1.iter().next().unwrap();
    let handtiles = hands.get(hand).unwrap();
    let (drawntile, drawn_ent) = *drawntile;

    // debug!("discard turn for: {curr:?}");

    while let Some(message) = reader.read().next() {
        if let GameMessage::Discarded(entity) = message {
            debug!("{curr:?} discarded: {entity:?}");
            // commands.entity(drawn_ent).despawn();
            if *entity == drawntile.0 {
            } else if handtiles.contains(entity) {
                commands
                    .entity(hand)
                    .remove_child(*entity)
                    .add_child(drawntile.0);
            } else {
                panic!("discarded illegal player tile?")
            }
            commands.spawn(DiscardedTile(*entity));
            next_turnstate.set(curr_turnstate.next());
            break;
        }
    }
}

pub(crate) fn ron_chi_pon_kan(
    curr_turnstate: Res<State<TurnState>>,
    mut next_turnstate: ResMut<NextState<TurnState>>,
) {
    next_turnstate.set(curr_turnstate.next());
}

pub(crate) fn end(
    curr_turnstate: Res<State<TurnState>>,
    mut next_turnstate: ResMut<NextState<TurnState>>,
) {
    next_turnstate.set(curr_turnstate.next());
}