ai_backgammon/
evaluation.rs1use crate::{GameKind, Player, Point, Position};
2
3const WIN_SINGLE: usize = 0;
4const WIN_GAMMON: usize = 1;
5const WIN_BACKGAMMON: usize = 2;
6const LOSE_SINGLE: usize = 3;
7const LOSE_GAMMON: usize = 4;
8const LOSE_BACKGAMMON: usize = 5;
9
10#[derive(Clone, Copy, Debug, PartialEq)]
11pub struct Equity {
13 outcomes: [f32; 6],
14}
15
16impl Equity {
17 pub const fn win(kind: GameKind) -> Self {
18 let mut outcomes = [0.0; 6];
19 outcomes[match kind {
20 GameKind::Single => WIN_SINGLE,
21 GameKind::Gammon => WIN_GAMMON,
22 GameKind::Backgammon => WIN_BACKGAMMON,
23 }] = 1.0;
24 Self { outcomes }
25 }
26
27 pub const fn loss(kind: GameKind) -> Self {
28 let mut outcomes = [0.0; 6];
29 outcomes[match kind {
30 GameKind::Single => LOSE_SINGLE,
31 GameKind::Gammon => LOSE_GAMMON,
32 GameKind::Backgammon => LOSE_BACKGAMMON,
33 }] = 1.0;
34 Self { outcomes }
35 }
36
37 pub const fn outcomes(self) -> [f32; 6] {
40 self.outcomes
41 }
42
43 pub fn win_probability(self) -> f32 {
44 self.outcomes[..=WIN_BACKGAMMON].iter().sum()
45 }
46
47 pub fn expected_points(self) -> f32 {
48 self.outcomes[WIN_SINGLE]
49 + 2.0 * self.outcomes[WIN_GAMMON]
50 + 3.0 * self.outcomes[WIN_BACKGAMMON]
51 - self.outcomes[LOSE_SINGLE]
52 - 2.0 * self.outcomes[LOSE_GAMMON]
53 - 3.0 * self.outcomes[LOSE_BACKGAMMON]
54 }
55
56 pub const fn reversed(self) -> Self {
57 Self {
58 outcomes: [
59 self.outcomes[LOSE_SINGLE],
60 self.outcomes[LOSE_GAMMON],
61 self.outcomes[LOSE_BACKGAMMON],
62 self.outcomes[WIN_SINGLE],
63 self.outcomes[WIN_GAMMON],
64 self.outcomes[WIN_BACKGAMMON],
65 ],
66 }
67 }
68
69 pub(crate) const fn zero() -> Self {
70 Self { outcomes: [0.0; 6] }
71 }
72
73 pub(crate) fn add_weighted(&mut self, other: Self, weight: f32) {
74 for (total, value) in self.outcomes.iter_mut().zip(other.outcomes) {
75 *total += value * weight;
76 }
77 }
78}
79
80pub fn pip_count(position: Position, player: Player) -> u16 {
81 let board: u16 = (1..=24)
82 .map(|number| {
83 let point = Point::new(number).expect("board point is valid");
84 let distance = match player {
85 Player::White => number,
86 Player::Black => 25 - number,
87 };
88 u16::from(position.count(player, point)) * u16::from(distance)
89 })
90 .sum();
91 board + 25 * u16::from(position.bar(player))
92}
93
94pub fn evaluate_position(position: Position) -> Equity {
96 if let Some(outcome) = position.game_outcome() {
97 return if outcome.winner == position.side_to_move() {
98 Equity::win(outcome.kind)
99 } else {
100 Equity::loss(outcome.kind)
101 };
102 }
103
104 let player = position.side_to_move();
105 let opponent = player.other();
106 let score = relative_score(position, player);
107 let win_probability = logistic(score / 42.0);
108 let (win_gammon, win_backgammon) = gammon_rates(position, player);
109 let (lose_gammon, lose_backgammon) = gammon_rates(position, opponent);
110
111 let win_backgammon = win_probability * win_backgammon;
112 let win_gammon = win_probability * win_gammon;
113 let lose_probability = 1.0 - win_probability;
114 let lose_backgammon = lose_probability * lose_backgammon;
115 let lose_gammon = lose_probability * lose_gammon;
116 Equity {
117 outcomes: [
118 win_probability - win_gammon - win_backgammon,
119 win_gammon,
120 win_backgammon,
121 lose_probability - lose_gammon - lose_backgammon,
122 lose_gammon,
123 lose_backgammon,
124 ],
125 }
126}
127
128fn relative_score(position: Position, player: Player) -> f32 {
129 let opponent = player.other();
130 let pip_lead =
131 f32::from(pip_count(position, opponent)) - f32::from(pip_count(position, player));
132 let off_lead = f32::from(position.off(player)) - f32::from(position.off(opponent));
133 let bar_lead = f32::from(position.bar(opponent)) - f32::from(position.bar(player));
134 let made_lead = made_points(position, player) - made_points(position, opponent);
135 let home_lead = home_points(position, player) - home_points(position, opponent);
136 let prime_lead = longest_prime(position, player) - longest_prime(position, opponent);
137 let blot_lead = blots(position, opponent) - blots(position, player);
138 let anchor_lead = anchors(position, player) - anchors(position, opponent);
139
140 if has_contact(position) {
141 pip_lead * 0.55
142 + off_lead * 9.0
143 + bar_lead * 18.0
144 + made_lead * 3.5
145 + home_lead * 5.5
146 + prime_lead * 4.5
147 + blot_lead * 2.5
148 + anchor_lead * 2.0
149 } else {
150 let wastage_lead = bearoff_wastage(position, opponent) - bearoff_wastage(position, player);
151 pip_lead * 1.15 + off_lead * 8.0 + wastage_lead * 1.5
152 }
153}
154
155fn made_points(position: Position, player: Player) -> f32 {
156 (1..=24)
157 .filter(|&number| position.count(player, Point::new(number).unwrap()) >= 2)
158 .count() as f32
159}
160
161fn home_points(position: Position, player: Player) -> f32 {
162 home_range(player)
163 .filter(|&number| position.count(player, Point::new(number).unwrap()) >= 2)
164 .count() as f32
165}
166
167fn anchors(position: Position, player: Player) -> f32 {
168 home_range(player.other())
169 .filter(|&number| position.count(player, Point::new(number).unwrap()) >= 2)
170 .count() as f32
171}
172
173fn blots(position: Position, player: Player) -> f32 {
174 (1..=24)
175 .filter(|&number| position.count(player, Point::new(number).unwrap()) == 1)
176 .count() as f32
177}
178
179fn longest_prime(position: Position, player: Player) -> f32 {
180 let mut longest = 0;
181 let mut current = 0;
182 for number in 1..=24 {
183 if position.count(player, Point::new(number).unwrap()) >= 2 {
184 current += 1;
185 longest = longest.max(current);
186 } else {
187 current = 0;
188 }
189 }
190 longest as f32
191}
192
193fn bearoff_wastage(position: Position, player: Player) -> f32 {
194 home_range(player)
195 .map(|number| {
196 let point = Point::new(number).unwrap();
197 let count = position.count(player, point).saturating_sub(2);
198 let distance = match player {
199 Player::White => number,
200 Player::Black => 25 - number,
201 };
202 f32::from(count) * f32::from(7 - distance)
203 })
204 .sum()
205}
206
207fn has_contact(position: Position) -> bool {
208 if position.bar(Player::White) > 0 || position.bar(Player::Black) > 0 {
209 return true;
210 }
211 let highest_white = (1..=24)
212 .rev()
213 .find(|&number| position.count(Player::White, Point::new(number).unwrap()) > 0)
214 .unwrap_or(0);
215 let lowest_black = (1..=24)
216 .find(|&number| position.count(Player::Black, Point::new(number).unwrap()) > 0)
217 .unwrap_or(25);
218 highest_white >= lowest_black
219}
220
221fn gammon_rates(position: Position, player: Player) -> (f32, f32) {
222 let opponent = player.other();
223 if position.off(opponent) > 0 {
224 return (0.0, 0.0);
225 }
226 let progress = f32::from(position.off(player)) / 15.0;
227 let home = home_points(position, player) / 6.0;
228 let trapped = f32::from(position.bar(opponent)) / 4.0
229 + checkers_in_home(position, opponent, player) / 15.0;
230 let total = (0.04 + progress * 0.28 + home * 0.08 + trapped * 0.08).clamp(0.0, 0.42);
231 let backgammon =
232 if position.bar(opponent) > 0 || checkers_in_home(position, opponent, player) > 0.0 {
233 (0.01 + trapped * 0.055).min(total * 0.35)
234 } else {
235 0.0
236 };
237 (total - backgammon, backgammon)
238}
239
240fn checkers_in_home(position: Position, player: Player, home_owner: Player) -> f32 {
241 home_range(home_owner)
242 .map(|number| f32::from(position.count(player, Point::new(number).unwrap())))
243 .sum()
244}
245
246fn home_range(player: Player) -> std::ops::RangeInclusive<u8> {
247 match player {
248 Player::White => 1..=6,
249 Player::Black => 19..=24,
250 }
251}
252
253fn logistic(value: f32) -> f32 {
254 if value >= 0.0 {
255 1.0 / (1.0 + (-value).exp())
256 } else {
257 let exponent = value.exp();
258 exponent / (1.0 + exponent)
259 }
260}