robopoker 0.1.1

Implementations of Meta's Pluribus No-Limit Texas Hold-Em solution.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use super::bucket::Bucket;
use super::player::Player;
use crate::mccfr::data::Data;
use crate::mccfr::edge::Edge;
use crate::play::continuation::Transition;
use crate::Utility;
use petgraph::graph::DiGraph;
use petgraph::graph::NodeIndex;
use petgraph::Direction::Incoming;
use petgraph::Direction::Outgoing;
use std::ptr::NonNull;

pub struct Node {
    graph: NonNull<DiGraph<Self, Edge>>,
    index: NodeIndex,
    datum: Data,
}

impl From<(NodeIndex, NonNull<DiGraph<Node, Edge>>, Data)> for Node {
    fn from((index, graph, datum): (NodeIndex, NonNull<DiGraph<Node, Edge>>, Data)) -> Self {
        Self {
            index,
            graph,
            datum,
        }
    }
}

/// collection of these three is what you would get in a Node, which may be too restrictive for a lot of the use so we'll se
impl Node {
    pub fn datum(&self) -> &Data {
        &self.datum
    }
    pub fn index(&self) -> NodeIndex {
        self.index
    }

    pub fn bucket(&self) -> &Bucket {
        self.datum.bucket()
    }
    pub fn player(&self) -> Player {
        self.datum.player()
    }
    pub fn payoff(&self, player: &Player) -> Utility {
        let position = match player {
            Player::Choice(Transition::Decision(x)) => x.to_owned(),
            _ => unreachable!("payoffs defined relative to decider"),
        };
        match player {
            Player::Choice(_) => unreachable!("payoffs defined relative to decider"),
            Player::Chance => self
                .datum()
                .game()
                .settlement()
                .get(position)
                .clone()
                .map(|settlement| settlement.pnl() as f32)
                .expect("player index in bounds"),
        }
    }

    /// Navigational methods
    ///
    /// maybe make these methods private and implement Walkable for Node?
    /// or add &Node as argument and impl Walkable for Tree?
    pub fn history(&self) -> Vec<&Edge> {
        if let (Some(edge), Some(head)) = (self.incoming(), self.parent()) {
            let mut history = head.history();
            history.push(edge);
            history
        } else {
            vec![]
        }
    }
    pub fn outgoing(&self) -> Vec<&Edge> {
        self.graph_ref()
            .edges_directed(self.index, Outgoing)
            .map(|e| e.weight())
            .collect()
    }
    pub fn incoming(&self) -> Option<&Edge> {
        self.graph_ref()
            .edges_directed(self.index, Incoming)
            .next()
            .map(|e| e.weight())
    }
    pub fn parent(&self) -> Option<&Self> {
        self.graph_ref()
            .neighbors_directed(self.index, Incoming)
            .next()
            .map(|p| {
                self.graph_ref()
                    .node_weight(p)
                    .expect("if incoming edge, then parent")
            })
    }
    pub fn children(&self) -> Vec<&Self> {
        self.graph_ref()
            .neighbors_directed(self.index, Outgoing)
            .map(|c| {
                self.graph_ref()
                    .node_weight(c)
                    .expect("if outgoing edge, then child")
            })
            .collect()
    }
    pub fn follow(&self, edge: &Edge) -> &Self {
        self.children()
            .iter()
            .find(|child| edge == child.incoming().unwrap())
            .expect("valid edge to follow")
        //? TODO O(A) performance
    }
    pub fn leaves(&self) -> Vec<&Self> {
        if self.children().is_empty() {
            vec![self]
        } else {
            self.children()
                .iter()
                .flat_map(|child| child.leaves())
                .collect()
        }
    }
    /// SAFETY:
    /// we have logical assurance that lifetimes work out effectively:
    /// 'info: 'node: 'tree
    /// Info is created from a Node
    /// Node is created from a Tree
    /// Tree owns its Graph
    fn graph_ref(&self) -> &DiGraph<Self, Edge> {
        unsafe { self.graph.as_ref() }
    }
}