Struct RegularWait 

pub struct RegularWait {
    pub pair: Option<Tile>,
    pub waiting_kind: WaitingKind,
    pub pattern_tile: Tile,
    pub waiting_tile: Tile,
    /* private fields */
}

A regular waiting pattern and hand decomposition of a waiting hand.

For a regular 3N+1 hand, this includes:

• Exactly N hand groups, including at most one incomplete (waiting) hand group. The complete hand groups can be iterated using RegularWait::groups().
• A complete pair (雀頭) or a Tanki (単騎) waiting pattern (= incomplete pair).

Note that there is exactly one waiting pattern, either a Tanki or an incomplete group.

Optional serde support

Custom format, serialization only. Example:

{
    "groups": [
        {"type": "Koutsu", "tile": "1m"},
        {"type": "Koutsu", "tile": "2m"},
        {"type": "Shuntsu", "tile": "7m"}
    ],
    "pair": "6z",
    "kind": "Shanpon",
    "pattern": "7z",
    "waiting": "7z"
}

Fields

pair: Option<Tile>

The complete pair (excluding Tanki).

waiting_kind: WaitingKind

The detailed kind of the waiting pattern.

pattern_tile: Tile

The smallest tile in the waiting pattern.

Examples:

• 12m wait 3m => 1m
• 34m wait 2m => 3m
• 79p wait 8p => 7p
• 3s wait 3s => 3s

waiting_tile: Tile

The waiting tile (duh).

Implementations

impl RegularWait

pub fn groups(&self) -> impl Iterator<Item = HandGroup>

Iterate all complete groups in this hand decomposition.

pub fn has_pair_or_tanki(&self) -> bool

Returns whether this waiting pattern has a pair (complete or incomplete).

pub fn pair_or_tanki(&self) -> Option<Tile>

Returns the tile of the pair (complete or incomplete).

pub fn is_true_ryanmen(&self) -> bool

Returns whether this waiting pattern is part of a double-sided wait, i.e. 45m waits 3m or 6m (両面). This mostly affects scoring and the Pinfu Yaku.

The reason this is separate is because we overloaded the “Ryanmen” term in WaitingKind to broaden its scope to any 2 consecutive numerals, which simplified handling.

For game rule purposes, this method should be used.

Trait Implementations

impl Clone for RegularWait

fn clone(&self) -> RegularWait

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RegularWait

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for RegularWait

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for RegularWait

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for RegularWait

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for RegularWait

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for RegularWait

fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for RegularWait

impl Eq for RegularWait