wip server & reducer
This commit is contained in:
parent
92fcea330c
commit
c8e7420396
7 changed files with 1108 additions and 1 deletions
467
store/src/board.rs
Normal file
467
store/src/board.rs
Normal file
|
|
@ -0,0 +1,467 @@
|
|||
use crate::Player;
|
||||
use crate::Error;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// Represents the Backgammon board
|
||||
///
|
||||
/// A Backgammon board consists of 24 fields, each of which can hold 0 or more checkers. In
|
||||
/// addition there is a bar to hold checkers that have been hit and an off area to hold checkers
|
||||
/// that have been removed from the board.
|
||||
///
|
||||
/// ```
|
||||
/// # fn foo() {}
|
||||
/// // +12-11-10--9--8--7-------6--5--4--3--2--1-+
|
||||
/// // | X O | | O X | +-------+
|
||||
/// // | X O | | O X | | OFF O |
|
||||
/// // | X O | | O | +-------+
|
||||
/// // | X | | O |
|
||||
/// // | X | | O |
|
||||
/// // | |BAR| |
|
||||
/// // | O | | X |
|
||||
/// // | O | | X |
|
||||
/// // | O X | | X | +-------+
|
||||
/// // | O X | | X O | | OFF X |
|
||||
/// // | O X | | X O | +-------+
|
||||
/// // +13-14-15-16-17-18------19-20-21-22-23-24-+
|
||||
/// ```
|
||||
|
||||
#[derive(Debug, Clone, Serialize, PartialEq, Deserialize, Default)]
|
||||
pub struct Board {
|
||||
raw_board: (PlayerBoard, PlayerBoard),
|
||||
}
|
||||
|
||||
/// Represents the Backgammon board for both players (to be used for graphical representation).
|
||||
#[derive(Debug, Serialize, PartialEq, Deserialize)]
|
||||
pub struct BoardDisplay {
|
||||
/// The board represented as an array of 24 fields, each of which can hold 0 or more checkers.
|
||||
/// Positive amounts represent checkers of player 0, negative amounts represent checkers of
|
||||
/// player 1.
|
||||
pub board: [i8; 24],
|
||||
/// The off for both players
|
||||
pub off: (u8, u8),
|
||||
}
|
||||
|
||||
impl Board {
|
||||
/// Create a new board
|
||||
pub fn new() -> Self {
|
||||
Board::default()
|
||||
}
|
||||
|
||||
/// Get the board for both players. Use for graphical representation of the board.
|
||||
///
|
||||
/// This method outputs a tuple with three values:
|
||||
///
|
||||
/// 1. the board represented as an array of 24 fields, each of which can hold 0 or more
|
||||
/// checkers. Positive amounts represent checkers of player 0, negative amounts represent
|
||||
/// checkers of player 1.
|
||||
/// 3. the off for both players
|
||||
pub fn get(&self) -> BoardDisplay {
|
||||
let mut board: [i8; 24] = [0; 24];
|
||||
|
||||
for (i, val) in board.iter_mut().enumerate() {
|
||||
*val = self.raw_board.0.board[i] as i8 - self.raw_board.1.board[23 - i] as i8;
|
||||
}
|
||||
|
||||
BoardDisplay {
|
||||
board,
|
||||
bar: self.get_bar(),
|
||||
off: self.get_off(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the off for both players
|
||||
fn get_off(&self) -> (u8, u8) {
|
||||
(self.raw_board.0.off, self.raw_board.1.off)
|
||||
}
|
||||
|
||||
/// Set checkers for a player on a field
|
||||
///
|
||||
/// This method adds the amount of checkers for a player on a field. The field is numbered from
|
||||
/// 0 to 23, starting from the last field of each player in the home board, the most far away
|
||||
/// field for each player (where there are 2 checkers to start with) is number 23.
|
||||
///
|
||||
/// If the field is blocked for the player, an error is returned. If the field is not blocked,
|
||||
/// but there is already one checker from the other player on the field, that checker is hit and
|
||||
/// moved to the bar.
|
||||
pub fn set(&mut self, player: Player, field: usize, amount: i8) -> Result<(), Error> {
|
||||
if field > 23 {
|
||||
return Err(Error::FieldInvalid);
|
||||
}
|
||||
|
||||
if self.blocked(player, field)? {
|
||||
return Err(Error::FieldBlocked);
|
||||
}
|
||||
|
||||
match player {
|
||||
Player::Player0 => {
|
||||
let new = self.raw_board.0.board[field] as i8 + amount;
|
||||
if new < 0 {
|
||||
return Err(Error::MoveInvalid);
|
||||
}
|
||||
self.raw_board.0.board[field] = new as u8;
|
||||
|
||||
// in case one opponent's checker is hit, move it to the bar
|
||||
self.raw_board.1.bar += self.raw_board.1.board[23 - field];
|
||||
self.raw_board.1.board[23 - field] = 0;
|
||||
Ok(())
|
||||
}
|
||||
Player::Player1 => {
|
||||
let new = self.raw_board.1.board[field] as i8 + amount;
|
||||
if new < 0 {
|
||||
return Err(Error::MoveInvalid);
|
||||
}
|
||||
self.raw_board.1.board[field] = new as u8;
|
||||
|
||||
// in case one opponent's checker is hit, move it to the bar
|
||||
self.raw_board.0.bar += self.raw_board.0.board[23 - field];
|
||||
self.raw_board.0.board[23 - field] = 0;
|
||||
Ok(())
|
||||
}
|
||||
Player::Nobody => Err(Error::PlayerInvalid),
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if a field is blocked for a player
|
||||
pub fn blocked(&self, player: Player, field: usize) -> Result<bool, Error> {
|
||||
if field > 23 {
|
||||
return Err(Error::FieldInvalid);
|
||||
}
|
||||
|
||||
match player {
|
||||
Player::Player0 => {
|
||||
if self.raw_board.1.board[23 - field] > 1 {
|
||||
Ok(true)
|
||||
} else {
|
||||
Ok(false)
|
||||
}
|
||||
}
|
||||
Player::Player1 => {
|
||||
if self.raw_board.0.board[23 - field] > 1 {
|
||||
Ok(true)
|
||||
} else {
|
||||
Ok(false)
|
||||
}
|
||||
}
|
||||
Player::Nobody => Err(Error::PlayerInvalid),
|
||||
}
|
||||
}
|
||||
|
||||
/// Set checkers for a player on the bar. This method adds amount to the already existing
|
||||
/// checkers there.
|
||||
pub fn set_bar(&mut self, player: Player, amount: i8) -> Result<(), Error> {
|
||||
match player {
|
||||
Player::Player0 => {
|
||||
let new = self.raw_board.0.bar as i8 + amount;
|
||||
if new < 0 {
|
||||
return Err(Error::MoveInvalid);
|
||||
}
|
||||
self.raw_board.0.bar = new as u8;
|
||||
Ok(())
|
||||
}
|
||||
Player::Player1 => {
|
||||
let new = self.raw_board.1.bar as i8 + amount;
|
||||
if new < 0 {
|
||||
return Err(Error::MoveInvalid);
|
||||
}
|
||||
self.raw_board.1.bar = new as u8;
|
||||
Ok(())
|
||||
}
|
||||
Player::Nobody => Err(Error::PlayerInvalid),
|
||||
}
|
||||
}
|
||||
|
||||
/// Set checkers for a player off the board. This method adds amount to the already existing
|
||||
/// checkers there.
|
||||
pub fn set_off(&mut self, player: Player, amount: u8) -> Result<(), Error> {
|
||||
match player {
|
||||
Player::Player0 => {
|
||||
let new = self.raw_board.0.off + amount;
|
||||
self.raw_board.0.off = new;
|
||||
Ok(())
|
||||
}
|
||||
Player::Player1 => {
|
||||
let new = self.raw_board.1.off + amount;
|
||||
self.raw_board.1.off = new;
|
||||
Ok(())
|
||||
}
|
||||
Player::Nobody => Err(Error::PlayerInvalid),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Represents the Backgammon board for one player
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
struct PlayerBoard {
|
||||
board: [u8; 24],
|
||||
bar: u8,
|
||||
off: u8,
|
||||
}
|
||||
|
||||
impl Default for PlayerBoard {
|
||||
fn default() -> Self {
|
||||
PlayerBoard {
|
||||
board: [
|
||||
0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
|
||||
],
|
||||
bar: 0,
|
||||
off: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Trait to move checkers
|
||||
pub trait Move {
|
||||
/// Move a checker
|
||||
fn move_checker(&mut self, player: Player, dice: u8, from: usize) -> Result<&mut Self, Error>
|
||||
where
|
||||
Self: Sized;
|
||||
|
||||
/// Move a checker from bar
|
||||
fn move_checker_from_bar(&mut self, player: Player, dice: u8) -> Result<&mut Self, Error>
|
||||
where
|
||||
Self: Sized;
|
||||
|
||||
/// Move permitted
|
||||
fn move_permitted(&mut self, player: Player, dice: u8) -> Result<&mut Self, Error>
|
||||
where
|
||||
Self: Sized;
|
||||
}
|
||||
|
||||
// Unit Tests
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn default_board() {
|
||||
assert_eq!(Board::new(), Board::default());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn default_player_board() {
|
||||
assert_eq!(
|
||||
PlayerBoard::default(),
|
||||
PlayerBoard {
|
||||
board: [0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,],
|
||||
bar: 0,
|
||||
off: 0
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn get_board() {
|
||||
let board = Board::new();
|
||||
assert_eq!(
|
||||
board.get(),
|
||||
BoardDisplay {
|
||||
board: [
|
||||
-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 0, 2,
|
||||
],
|
||||
bar: (0, 0),
|
||||
off: (0, 0)
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn get_bar() {
|
||||
let board = Board::new();
|
||||
assert_eq!(board.get_bar(), (0, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn get_off() {
|
||||
let board = Board::new();
|
||||
assert_eq!(board.get_off(), (0, 0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_player0() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player0, 1, 1)?;
|
||||
assert_eq!(board.get().board[1], 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_player1() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player1, 2, 1)?;
|
||||
assert_eq!(board.get().board[21], -1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_player0_bar() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set_bar(Player::Player0, 1)?;
|
||||
assert_eq!(board.get().bar.0, 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_player1_bar() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set_bar(Player::Player1, 1)?;
|
||||
assert_eq!(board.get().bar.1, 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_player0_off() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set_off(Player::Player0, 1)?;
|
||||
assert_eq!(board.get().off.0, 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_player1_off() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set_off(Player::Player1, 1)?;
|
||||
assert_eq!(board.get().off.1, 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_player1_off1() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set_off(Player::Player1, 1)?;
|
||||
board.set_off(Player::Player1, 1)?;
|
||||
assert_eq!(board.get().off.1, 2);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_invalid_player() {
|
||||
let mut board = Board::new();
|
||||
assert!(board.set(Player::Nobody, 0, 1).is_err());
|
||||
assert!(board.set_bar(Player::Nobody, 1).is_err());
|
||||
assert!(board.set_off(Player::Nobody, 1).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blocked_player0() -> Result<(), Error> {
|
||||
let board = Board::new();
|
||||
assert!(board.blocked(Player::Player0, 0)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blocked_player1() -> Result<(), Error> {
|
||||
let board = Board::new();
|
||||
assert!(board.blocked(Player::Player1, 0)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blocked_player0_a() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player1, 1, 2)?;
|
||||
assert!(board.blocked(Player::Player0, 22)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blocked_player1_a() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player0, 1, 2)?;
|
||||
assert!(board.blocked(Player::Player1, 22)?);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blocked_invalid_player() {
|
||||
let board = Board::new();
|
||||
assert!(board.blocked(Player::Nobody, 0).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn blocked_invalid_field() {
|
||||
let board = Board::new();
|
||||
assert!(board.blocked(Player::Player0, 24).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_field_with_1_checker_player0_a() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player0, 1, 1)?;
|
||||
board.set(Player::Player1, 22, 1)?;
|
||||
assert_eq!(board.get().board[1], -1);
|
||||
assert_eq!(board.get().bar.0, 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_field_with_1_checker_player0_b() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player0, 1, 1)?;
|
||||
board.set_bar(Player::Player0, 5)?;
|
||||
board.set(Player::Player1, 22, 1)?;
|
||||
assert_eq!(board.get().board[1], -1);
|
||||
assert_eq!(board.get().bar.0, 6);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_field_with_1_checker_player1_a() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player1, 1, 1)?;
|
||||
board.set(Player::Player0, 22, 1)?;
|
||||
assert_eq!(board.get().board[22], 1);
|
||||
assert_eq!(board.get().bar.1, 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_field_with_1_checker_player1_b() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player1, 1, 1)?;
|
||||
board.set_bar(Player::Player1, 5)?;
|
||||
board.set(Player::Player0, 22, 1)?;
|
||||
assert_eq!(board.get().board[22], 1);
|
||||
assert_eq!(board.get().bar.1, 6);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_field_with_2_checkers_player0_a() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player0, 23, 2)?;
|
||||
assert_eq!(board.get().board[23], 4);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_field_with_2_checkers_player0_b() -> Result<(), Error> {
|
||||
let mut board = Board::new();
|
||||
board.set(Player::Player0, 23, -1)?;
|
||||
assert_eq!(board.get().board[23], 1);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_field_blocked() {
|
||||
let mut board = Board::new();
|
||||
assert!(board.set(Player::Player0, 0, 2).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_wrong_field1() {
|
||||
let mut board = Board::new();
|
||||
assert!(board.set(Player::Player0, 50, 2).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_wrong_amount0() {
|
||||
let mut board = Board::new();
|
||||
assert!(board.set(Player::Player0, 23, -3).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn set_wrong_amount1() {
|
||||
let mut board = Board::new();
|
||||
assert!(board.set(Player::Player1, 23, -3).is_err());
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue