jong/jong-types/src/tiles.rs

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

use super::derive;

#[derive(..Base)]
#[derive(Component, SpacetimeType)]
pub struct Tile {
    pub suit: Suit,
}

#[derive(..Base)]
#[derive(SpacetimeType)]
pub enum Suit {
    Man(Rank),
    Pin(Rank),
    Sou(Rank),
    Wind(Wind),
    Dragon(Dragon),
}

impl Suit {
    pub fn rank(&self) -> Option<Rank> {
        match self {
            Suit::Man(rank) => Some(*rank),
            Suit::Pin(rank) => Some(*rank),
            Suit::Sou(rank) => Some(*rank),
            // Suit::Wind(wind) | Suit::Dragon(dragon) => None,
            _ => None,
        }
    }
}

#[derive(
    ..Base,
    Deref,
    DerefMut,
)]
#[derive(SpacetimeType)]
pub struct Rank {
    pub number: u8,
}

#[derive(
    ..Base,
    FromRepr,
)]
#[derive(SpacetimeType)]
pub enum Wind {
    Ton,
    Nan,
    Shaa,
    Pei,
}

#[derive(
    ..Base,
    FromRepr,
)]
#[derive(SpacetimeType)]
pub enum Dragon {
    Haku,
    Hatsu,
    Chun,
}

pub fn tiles() -> Vec<Tile> {
    let mut tiles = vec![];
    for _ in 0..4 {
        for i in 1..=9 {
            tiles.push(Tile {
                suit: Suit::Pin(Rank { number: i }),
            });
            tiles.push(Tile {
                suit: Suit::Sou(Rank { number: i }),
            });
            tiles.push(Tile {
                suit: Suit::Man(Rank { number: i }),
            });
        }
        for i in 0..4 {
            tiles.push(Tile {
                suit: Suit::Wind(Wind::from_repr(i).unwrap()),
            });
        }
        for i in 0..3 {
            tiles.push(Tile {
                suit: Suit::Dragon(Dragon::from_repr(i).unwrap()),
            });
        }
    }
    tiles
}