Struct BinaryExplorer 

pub struct BinaryExplorer<G: ActionOptimiser, A: NodeStoreTrait> { /* private fields */ }

Implementations

impl<G: ActionOptimiser, A: NodeStoreTrait> BinaryExplorer<G, A>

pub fn new_checked( contract: Contract, initial_node: TrickNode, north_south_target: u8, ) -> Result<Self, BridgeCoreError>

pub fn current_side(&self) -> Side

pub fn explore_actions(&mut self) -> Result<bool, DoubleDummyError>

use brydz_dd::{
    node::{
        TrickNode
    },
};
use brydz_core::{
    player::side::{SideMap, Side::*},
    cards::trump::Trump,
    bidding::Bid,
    contract::{Contract, ContractParametersGen, ContractMechanics},
    karty::{
        suits::Suit::*,
        cards::*,
        set::CardSetStd,
        card_set
    }
};
use brydz_dd::actions::DistinctCardGrouper;
use brydz_dd::explore::{BinaryExplorer, ExploreOutput, Explorer};
use brydz_dd::hash::DummyNodeStore;

let contract = Contract::new(
ContractParametersGen::new(West, Bid::init(Trump::Colored(Diamonds), 1).unwrap()));
let hands = SideMap::new(
    card_set![ACE_SPADES, QUEEN_SPADES, JACK_CLUBS, KING_CLUBS],
    card_set!(ACE_HEARTS, KING_DIAMONDS, KING_HEARTS, JACK_DIAMONDS),
    card_set![ACE_DIAMONDS, ACE_CLUBS, QUEEN_HEARTS, QUEEN_CLUBS],
    card_set![KING_SPADES, QUEEN_DIAMONDS, JACK_SPADES, JACK_HEARTS ]);
let node = TrickNode::new_checked(hands, contract.current_side()).unwrap();
let mut explorer = BinaryExplorer::<DistinctCardGrouper, DummyNodeStore>::new_checked(contract.clone(), node.clone(), 1).unwrap();

assert_eq!(explorer.explore_actions(), Ok(true));
let mut explorer2 = BinaryExplorer::<DistinctCardGrouper, DummyNodeStore>::new_checked(contract.clone(), node.clone(), 2).unwrap();
assert_eq!(explorer2.explore_actions(), Ok(false));

pub fn hint(&mut self) -> Result<TrackStep, DoubleDummyError>

pub fn update( &mut self, state_update: ExplorerStateUpdate, ) -> Result<(), BridgeCoreErrorGen<Card>>

pub fn state(&self) -> &ExplorerGameState<G>

Trait Implementations

impl<G: Clone + ActionOptimiser, A: Clone + NodeStoreTrait> Clone for BinaryExplorer<G, A>

fn clone(&self) -> BinaryExplorer<G, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<G: Debug + ActionOptimiser, A: Debug + NodeStoreTrait> Debug for BinaryExplorer<G, A>

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

Formats the value using the given formatter.