initial implementation of MoveValueStats

src/logic/move.rs

@@ -1,9 +1,78 @@
+use std::cmp::Ordering;
+
 use super::board_value::BoardValueMap;
 use crate::repr::{Board, CoordPair, Piece, Winner};
 use allocative::Allocative;
 
 pub type MoveCoord = Option<CoordPair>;
 
+#[derive(Clone, Copy, PartialEq, Eq, Allocative, Debug, PartialOrd, Ord)]
+pub enum MVSGameState {
+    Win = 1,
+    Loss = 0,
+    Tie = -1,
+}
+
+#[derive(Clone, Copy, Debug, Allocative, PartialEq, Eq, Default)]
+pub struct MoveValueStats {
+    state: Option<MVSGameState>,
+    wins: u16,
+    losses: u16,
+    pub value: i32,
+}
+
+impl MoveValueStats {
+    fn chance_win(&self) -> Option<f32> {
+        let sum = self.losses + self.wins;
+        if sum == 0 {
+            return None;
+        }
+        Some(self.wins as f32 / sum as f32)
+    }
+
+    pub fn populate_self_from_children(&mut self, others: &[Self]) {
+        let wins = others.iter().map(|x| x.wins).sum::<u16>()
+            + others
+                .iter()
+                .filter(|x| x.state == Some(MVSGameState::Win))
+                .count() as u16;
+        let losses = others.iter().map(|x| x.losses).sum::<u16>()
+            + others
+                .iter()
+                .filter(|x| x.state == Some(MVSGameState::Loss))
+                .count() as u16;
+
+        self.wins = wins;
+        self.losses = losses;
+    }
+}
+
+impl PartialOrd for MoveValueStats {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MoveValueStats {
+    fn cmp(&self, other: &Self) -> Ordering {
+        if self.state.is_some() && other.state.is_some() {
+            return self.state.cmp(&other.state);
+        }
+
+        let s_cw = self.chance_win();
+        let o_cw = other.chance_win();
+        if s_cw.is_some() && o_cw.is_some() {
+            if s_cw > o_cw {
+                return Ordering::Greater;
+            } else if o_cw > s_cw {
+                return Ordering::Less;
+            }
+        }
+
+        self.value.cmp(&other.value)
+    }
+}
+
 #[derive(Clone, Debug, Allocative)]
 pub struct Move {
     /// Coordinates (i, j) of the move (if it exists)
@@ -23,7 +92,7 @@ pub struct Move {
     pub children: Vec<usize>,
 
     /// Value of this move (including children)
-    pub value: i32,
+    pub value: MoveValueStats,
 
     /// What is the inherit value of this move (not including children)
     pub self_value: i16,
@@ -35,7 +104,9 @@ pub struct Move {
     pub is_trimmed: bool,
 }
 
-pub struct MoveValueConfig {}
+pub struct MoveValueConfig {
+    pub self_value_raw: bool,
+}
 
 impl Move {
     pub fn new(
@@ -50,12 +121,34 @@ impl Move {
             winner: board.game_winner(),
             parent: None,
             children: Vec::new(),
-            value: i32::MIN,
+            value: Default::default(),
             color,
             is_trimmed: false,
             self_value: 0,
         };
-        m.self_value = m.compute_self_value(agent_color, &board, mvc);
+
+        // set wins/losses values appropriately
+        match m.winner {
+            Winner::Player(piece) => {
+                if piece == agent_color {
+                    m.value.wins += 1;
+                    m.value.state = Some(MVSGameState::Win);
+                } else {
+                    m.value.losses += 1;
+                    m.value.state = Some(MVSGameState::Loss);
+                }
+            }
+            Winner::Tie => {
+                m.value.state = Some(MVSGameState::Tie);
+            }
+            Winner::None => {}
+        }
+
+        if !mvc.self_value_raw {
+            m.self_value = m.compute_self_value(agent_color, &board, mvc);
+        } else {
+            m.self_value = const { BoardValueMap::weighted() }.board_value(&board, agent_color);
+        }
         m
     }
 
@@ -71,7 +164,6 @@ impl Move {
         }
 
         // I guess ignore Ties here, don't give them an explicit value,
-
         const { BoardValueMap::weighted() }.board_value(board, agent_color)
     }