Enum onejoker::poker::hand_scale::Scale

#[repr(u8)]
pub enum Scale {
    None = 0,
    HighHand = 1,
    AceToFive = 2,
    DeuceToSeven = 3,
    AceToSix = 4,
    Badugi = 5,
    Badeucy = 6,
    PaiGow = 7,
    Stripped = 8,
    ActionRazz = 9,
    HighHandBug = 10,
    AceToFiveBug = 11,
    Mexican = 12,
    ThreeCard = 13,
}

wiki | Poker hand evaluation info

Enum representing hand “scales”, or ways in which poker hands are evaluated in different games.

Variants

None = 0

None / Invalid

HighHand = 1

Traditional “high” poker hands

AceToFive = 2

Low hands, aces low, no straights or flushes

DeuceToSeven = 3

Low hands, aces low (“Kansas City” low)

AceToSix = 4

Low hands, aces high (“London” low)

Badugi = 5

Four cards, aces low, no matching suits

Badeucy = 6

Badugi, aces high

PaiGow = 7

High hands, except wheel beats K-high straight

Stripped = 8

Stripped deck: flush beats full house

ActionRazz = 9

Ace-to-five low, face card needed to qualify

HighHandBug = 10

High hands with single bug

AceToFiveBug = 11

Ace-to-five low with single bug

Mexican = 12

Spanish deck with single bug

ThreeCard = 13

Three-card high hands

Implementations

impl Scale

pub const fn from_u8(index: u8) -> Scale

Get a hand scale by index

pub fn by_name(sname: &str) -> Scale

Get hand scale by name

use onejoker::prelude::*;

let scale = Scale::by_name("ace-to-five");
assert_eq!(scale, Scale::AceToFive);

pub fn new_deck(&self) -> Deck

Create a new deck for this game

pub fn name(&self) -> &'static str

Canonical name of the game or hand type

use onejoker::prelude::*;

assert_eq!(Scale::AceToFive.name(), "ace-to-five");

pub const fn deck_type(&self) -> DeckType

Preferred deck for this game

use onejoker::prelude::*;

assert_eq!(DeckType::Low, Scale::AceToFive.deck_type());

pub const fn complete_hand(&self) -> usize

Number of cards in a complete hand

use onejoker::prelude::*;

assert_eq!(5, Scale::AceToFive.complete_hand());

pub const fn low_aces(&self) -> bool

Calculations and comparisons expect low aces

use onejoker::prelude::*;

assert!(Scale::AceToFive.low_aces());
assert!(! Scale::DeuceToSeven.low_aces());

pub const fn low_hands(&self) -> bool

Hand values are calculated for low hands

use onejoker::prelude::*;

assert!(Scale::AceToFive.low_hands());
assert!(Scale::DeuceToSeven.low_hands());
assert!(! Scale::HighHand.low_hands());

pub const fn straights_and_flushes(&self) -> bool

Does the game include straights and flushes?

use onejoker::prelude::*;

assert!(Scale::HighHand.straights_and_flushes());
assert!(! Scale::AceToFive.straights_and_flushes());

pub const fn high_wheel(&self) -> bool

Is wheel a straight for high-ace games?

use onejoker::prelude::*;

assert!(Scale::HighHand.high_wheel());
assert!(! Scale::DeuceToSeven.high_wheel());

pub const fn pai_gow_wheel(&self) -> bool

Does wheel beat K-high straight?

use onejoker::prelude::*;

assert!(! Scale::HighHand.pai_gow_wheel());
assert!(Scale::PaiGow.pai_gow_wheel());

pub const fn low_broadway(&self) -> bool

Is Broadway a straight for low-ace games?

use onejoker::prelude::*;

// The only game that might: but I prefer this rule
assert!(! Scale::AceToSix.low_broadway());

pub const fn spanish_gap(&self) -> bool

Does deck have 8s, 9s, and 10s removed?

use onejoker::prelude::*;

assert!(Scale::Mexican.spanish_gap());

pub fn value_from_level(&self, hl: HandLevel) -> u32

Mapping from generic hand level to numeric value

use onejoker::prelude::*;

assert_eq!(4, Scale::AceToFive.value_from_level(HandLevel::Trips));

pub fn level_from_value(&self, v: u32) -> HandLevel

Mapping from numeric value to generic hand level

use onejoker::prelude::*;

assert_eq!(HandLevel::Trips, Scale::AceToFive.level_from_value(4));

pub fn valid_card(&self, c: Card) -> bool

Is the given card valid for this game?

pub fn valid_hand(&self, h: &Hand) -> bool

Is this hand valid for this game?

pub fn to_string(&self, d: &HandDescription) -> String

Print hand

pub fn full_text(&self, d: &HandDescription) -> String

Game-specific function to get full English name of hand

use onejoker::prelude::*;
use onejoker::poker::{ojp_hh_value,ojp_hh_description};

let hand = Hand::new(DeckType::English).init(hand!("9s","As","9d","Ks","Ah"));
let v = ojp_hh_value(&hand);
let d = ojp_hh_description(&hand, v);
println!("{}", d.full_text());
println!("{}", Scale::HighHand.full_text(&d));

pub fn value(&self, hand: &Hand) -> HandValue

Game-specific quick value-only hand evaluation function

use onejoker::prelude::*;

let hand = Hand::new(DeckType::English).init(hand!("9s","As","9d","Ks","Ah"));
let v = Scale::HighHand.value(&hand);
println!("{}", v);

pub fn description(&self, h: &Hand, v: HandValue) -> HandDescription

Get description of hand

use onejoker::prelude::*;

let hand = Hand::new(DeckType::English).init(hand!("9s","As","9d","Ks","Ah"));
let v = Scale::HighHand.value(&hand);
let d = Scale::HighHand.description(&hand, v);
println!("{}", v);

Trait Implementations

impl Clone for Scale

fn clone(&self) -> Scale

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Scale

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

Formats the value using the given formatter.

impl Default for Scale

fn default() -> Scale

Returns the “default value” for a type.

impl From<u8> for Scale

fn from(n: u8) -> Self

Converts to this type from the input type.

impl Hash for Scale

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Scale

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Copy for Scale

impl Eq for Scale

impl StructuralPartialEq for Scale