linly/oxidised4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

RED/BLU? more like P1 P2

Browse Source
This commit is contained in:
LinlyBoi
2023-05-06 13:57:39 +03:00
parent 01b8d7fb15
commit e42a30a4c6
4 changed files with 121 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/gamedata/algorithms.rs
View File

@@ -39,7 +39,7 @@ fn minimise(board: &Board, disk: &Disk, depth: &i32) -> (Option<Board>, i32) {
#[test] #[test]
fn minimax_test() { fn minimax_test() {
let mut board = Board::default(); let mut board = Board::default();
let mut disk = Disk::BLU; let mut disk = Disk::P2;
let _depth = 5; let _depth = 5;
let _turn1 = board.play(disk, minimax_decision(&board, disk, &5).last_move); let _turn1 = board.play(disk, minimax_decision(&board, disk, &5).last_move);
disk = flip_disk(disk); disk = flip_disk(disk);

66
src/gamedata/heuristic.rs
View File

@@ -17,8 +17,8 @@ pub fn get_score(board: &Board, disk: Disk) -> i32 {
//this should be summing up a bunch of functions defined below this one //this should be summing up a bunch of functions defined below this one
let sequences = get_streaks(&board.columns, &disk); let sequences = get_streaks(&board.columns, &disk);
let score: i32 = match disk { let score: i32 = match disk {
Disk::RED => board.red_score - board.blu_score, Disk::P1 => board.p1_score - board.p2_score,
Disk::BLU => board.blu_score - board.red_score, Disk::P2 => board.p2_score - board.p1_score,
Disk::EMPTY => panic!("Why would you ever"), Disk::EMPTY => panic!("Why would you ever"),
}; };
potential_streaks(&sequences, &disk) + potential_wins(&sequences, &disk) + score * SCORE_DIFF potential_streaks(&sequences, &disk) + potential_wins(&sequences, &disk) + score * SCORE_DIFF
@@ -225,44 +225,44 @@ fn heur_scan(
#[test] #[test]
fn streak_test_1() { fn streak_test_1() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::BLU, 2); board.play(Disk::P2, 2);
board.play(Disk::BLU, 1); board.play(Disk::P2, 1);
let sequences = get_streaks(&board.columns, &Disk::BLU); let sequences = get_streaks(&board.columns, &Disk::P2);
assert_eq!(18, potential_streaks(&sequences, &Disk::BLU)); assert_eq!(18, potential_streaks(&sequences, &Disk::P2));
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
let _sequences = get_streaks(&board.columns, &Disk::BLU); let _sequences = get_streaks(&board.columns, &Disk::P2);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
let sequences = get_streaks(&board.columns, &Disk::BLU); let sequences = get_streaks(&board.columns, &Disk::P2);
assert_eq!(12, potential_streaks(&sequences, &Disk::BLU)); assert_eq!(12, potential_streaks(&sequences, &Disk::P2));
} }
#[test] #[test]
fn win_test_flipping() { fn win_test_flipping() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::RED, 4); board.play(Disk::P1, 4);
board.play(Disk::BLU, 4); board.play(Disk::P2, 4);
board.play(Disk::RED, 5); board.play(Disk::P1, 5);
board.play(Disk::RED, 5); board.play(Disk::P1, 5);
board.play(Disk::RED, 6); board.play(Disk::P1, 6);
board.play(Disk::RED, 6); board.play(Disk::P1, 6);
board.play(Disk::RED, 6); board.play(Disk::P1, 6);
board.play(Disk::BLU, 6); board.play(Disk::P2, 6);
let sequences = get_wins(&board.columns, &Disk::BLU); let sequences = get_wins(&board.columns, &Disk::P2);
dbg!(&sequences); dbg!(&sequences);
assert_eq!(POT_WIN, potential_wins(&sequences, &Disk::BLU)); assert_eq!(POT_WIN, potential_wins(&sequences, &Disk::P2));
} }
#[test] #[test]
fn win_test_flipping_hard() { fn win_test_flipping_hard() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 1); board.play(Disk::P2, 1);
board.play(Disk::BLU, 2); board.play(Disk::P2, 2);
board.play(Disk::BLU, 4); board.play(Disk::P2, 4);
let sequences = get_wins(&board.columns, &Disk::BLU); let sequences = get_wins(&board.columns, &Disk::P2);
assert_eq!(POT_WIN, potential_wins(&sequences, &Disk::BLU)); assert_eq!(POT_WIN, potential_wins(&sequences, &Disk::P2));
} }

26
src/gamedata/mod.rs
View File

@@ -10,8 +10,8 @@ pub use indices::*;
#[derive(Clone)] #[derive(Clone)]
pub struct Board { pub struct Board {
red_score: i32, p1_score: i32,
blu_score: i32, p2_score: i32,
columns: Array2D<Disk>, columns: Array2D<Disk>,
last_move: usize, last_move: usize,
} }
@@ -21,8 +21,8 @@ impl Default for Board {
let columns = Array2D::filled_with(Disk::EMPTY, 6, 7); let columns = Array2D::filled_with(Disk::EMPTY, 6, 7);
Self { Self {
red_score: 0, p1_score: 0,
blu_score: 0, p2_score: 0,
columns, columns,
last_move: 0, last_move: 0,
} }
@@ -31,7 +31,7 @@ impl Default for Board {
impl Board { impl Board {
fn getscore(&self) -> (i32, i32) { fn getscore(&self) -> (i32, i32) {
(self.red_score, self.blu_score) (self.p1_score, self.p2_score)
} }
fn play(&mut self, disk: Disk, col: usize) -> bool { fn play(&mut self, disk: Disk, col: usize) -> bool {
let column = &self.columns.as_columns()[col]; let column = &self.columns.as_columns()[col];
@@ -55,7 +55,7 @@ impl Board {
); );
match self.columns.get(index.0, index.1) { match self.columns.get(index.0, index.1) {
Some(disk) => match disk { Some(disk) => match disk {
Disk::RED => { Disk::P1 => {
for _move in moves { for _move in moves {
let mut consecutive = scan(&self.columns, &index, _move.clone(), 4); let mut consecutive = scan(&self.columns, &index, _move.clone(), 4);
if consecutive < 4 { if consecutive < 4 {
@@ -67,11 +67,11 @@ impl Board {
) )
} }
if consecutive - 1 == 4 { if consecutive - 1 == 4 {
self.red_score += 1 self.p1_score += 1
} }
} }
} }
Disk::BLU => { Disk::P2 => {
for _move in moves { for _move in moves {
let mut consecutive = scan(&self.columns, &index, _move.clone(), 4); let mut consecutive = scan(&self.columns, &index, _move.clone(), 4);
if consecutive < 4 { if consecutive < 4 {
@@ -83,7 +83,7 @@ impl Board {
) )
} }
if consecutive - 1 == 4 { if consecutive - 1 == 4 {
self.blu_score += 1 self.p2_score += 1
} }
} }
} }
@@ -115,14 +115,14 @@ impl Board {
#[derive(Copy, Clone, Debug, PartialEq, Eq)] #[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Disk { pub enum Disk {
RED, P1,
BLU, P2,
EMPTY, EMPTY,
} }
pub fn flip_disk(disk: Disk) -> Disk { pub fn flip_disk(disk: Disk) -> Disk {
match disk { match disk {
Disk::RED => Disk::BLU, Disk::P1 => Disk::P2,
Disk::BLU => Disk::RED, Disk::P2 => Disk::P1,
Disk::EMPTY => Disk::EMPTY, //why..just why Disk::EMPTY => Disk::EMPTY, //why..just why
} }
} }

148
src/gamedata/tests.rs
View File

@@ -11,68 +11,68 @@ use super::*;
#[test] #[test]
fn play() { fn play() {
let mut board = Board::default(); let mut board = Board::default();
assert!(board.play(Disk::BLU, 0)); assert!(board.play(Disk::P2, 0));
assert!(board.play(Disk::BLU, 0)); assert!(board.play(Disk::P2, 0));
assert!(board.play(Disk::BLU, 0)); assert!(board.play(Disk::P2, 0));
assert!(board.play(Disk::BLU, 0)); assert!(board.play(Disk::P2, 0));
assert_eq!(1, board.blu_score); assert_eq!(1, board.p2_score);
assert!(board.play(Disk::BLU, 0)); assert!(board.play(Disk::P2, 0));
assert!(board.play(Disk::BLU, 0)); assert!(board.play(Disk::P2, 0));
assert!(!board.play(Disk::BLU, 0)); assert!(!board.play(Disk::P2, 0));
assert!(board.play(Disk::BLU, 1)); assert!(board.play(Disk::P2, 1));
assert!(board.play(Disk::BLU, 1)); assert!(board.play(Disk::P2, 1));
assert!(board.play(Disk::BLU, 1)); assert!(board.play(Disk::P2, 1));
assert!(board.play(Disk::BLU, 1)); assert!(board.play(Disk::P2, 1));
assert!(board.play(Disk::BLU, 1)); assert!(board.play(Disk::P2, 1));
assert!(board.play(Disk::BLU, 1)); assert!(board.play(Disk::P2, 1));
assert!(!board.play(Disk::BLU, 1)); assert!(!board.play(Disk::P2, 1));
assert!(board.play(Disk::BLU, 2)); assert!(board.play(Disk::P2, 2));
assert!(board.play(Disk::BLU, 2)); assert!(board.play(Disk::P2, 2));
assert!(board.play(Disk::BLU, 2)); assert!(board.play(Disk::P2, 2));
assert!(board.play(Disk::BLU, 2)); assert!(board.play(Disk::P2, 2));
assert!(board.play(Disk::BLU, 2)); assert!(board.play(Disk::P2, 2));
assert!(board.play(Disk::BLU, 2)); assert!(board.play(Disk::P2, 2));
assert!(!board.play(Disk::BLU, 2)); assert!(!board.play(Disk::P2, 2));
assert!(board.play(Disk::BLU, 3)); assert!(board.play(Disk::P2, 3));
assert!(board.play(Disk::BLU, 3)); assert!(board.play(Disk::P2, 3));
assert!(board.play(Disk::BLU, 3)); assert!(board.play(Disk::P2, 3));
assert!(board.play(Disk::BLU, 3)); assert!(board.play(Disk::P2, 3));
assert!(board.play(Disk::BLU, 3)); assert!(board.play(Disk::P2, 3));
assert!(board.play(Disk::BLU, 3)); assert!(board.play(Disk::P2, 3));
assert!(!board.play(Disk::BLU, 3)); assert!(!board.play(Disk::P2, 3));
} }
#[test] #[test]
fn scan_updown() { fn scan_updown() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
assert_eq!(4, scan(&board.columns, &(4, 0), Direction::Down, 4)); assert_eq!(4, scan(&board.columns, &(4, 0), Direction::Down, 4));
assert_eq!(4, scan(&board.columns, &(3, 0), Direction::Down, 4)); assert_eq!(4, scan(&board.columns, &(3, 0), Direction::Down, 4));
} }
#[test] #[test]
fn scan_updown2() { fn scan_updown2() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::RED, 0); board.play(Disk::P1, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
assert_eq!(1, scan(&board.columns, &(0, 0), Direction::Up, 4)); assert_eq!(1, scan(&board.columns, &(0, 0), Direction::Up, 4));
} }
#[test] #[test]
fn scan_forwardback() { fn scan_forwardback() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 1); board.play(Disk::P2, 1);
board.play(Disk::BLU, 2); board.play(Disk::P2, 2);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
assert_eq!(4, scan(&board.columns, &(0, 0), Direction::Right, 4)); assert_eq!(4, scan(&board.columns, &(0, 0), Direction::Right, 4));
assert_eq!(4, scan(&board.columns, &(0, 3), Direction::Left, 4)); assert_eq!(4, scan(&board.columns, &(0, 3), Direction::Left, 4));
@@ -80,59 +80,59 @@ fn scan_forwardback() {
#[test] #[test]
fn scan_forwardback2() { fn scan_forwardback2() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::BLU, 1); board.play(Disk::P2, 1);
board.play(Disk::RED, 2); board.play(Disk::P1, 2);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
assert_eq!(2, scan(&board.columns, &(0, 0), Direction::Right, 4)); assert_eq!(2, scan(&board.columns, &(0, 0), Direction::Right, 4));
assert_eq!(1, scan(&board.columns, &(0, 3), Direction::Left, 4)); assert_eq!(1, scan(&board.columns, &(0, 3), Direction::Left, 4));
} }
#[test] #[test]
fn scan_diag1() { fn scan_diag1() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
board.play(Disk::RED, 1); board.play(Disk::P1, 1);
board.play(Disk::BLU, 1); board.play(Disk::P2, 1);
board.play(Disk::RED, 2); board.play(Disk::P1, 2);
board.play(Disk::RED, 2); board.play(Disk::P1, 2);
board.play(Disk::BLU, 2); board.play(Disk::P2, 2);
board.play(Disk::RED, 3); board.play(Disk::P1, 3);
board.play(Disk::RED, 3); board.play(Disk::P1, 3);
board.play(Disk::RED, 3); board.play(Disk::P1, 3);
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
assert_eq!(4, scan(&board.columns, &(0, 0), Direction::UpRight, 4)); assert_eq!(4, scan(&board.columns, &(0, 0), Direction::UpRight, 4));
assert_eq!(4, scan(&board.columns, &(3, 3), Direction::DownLeft, 4)); assert_eq!(4, scan(&board.columns, &(3, 3), Direction::DownLeft, 4));
} }
#[test] #[test]
fn scan_diag2() { fn scan_diag2() {
let mut board = Board::default(); let mut board = Board::default();
board.play(Disk::BLU, 3); board.play(Disk::P2, 3);
board.play(Disk::RED, 2); board.play(Disk::P1, 2);
board.play(Disk::BLU, 2); board.play(Disk::P2, 2);
board.play(Disk::RED, 1); board.play(Disk::P1, 1);
board.play(Disk::RED, 1); board.play(Disk::P1, 1);
board.play(Disk::BLU, 1); board.play(Disk::P2, 1);
board.play(Disk::RED, 0); board.play(Disk::P1, 0);
board.play(Disk::RED, 0); board.play(Disk::P1, 0);
board.play(Disk::RED, 0); board.play(Disk::P1, 0);
board.play(Disk::BLU, 0); board.play(Disk::P2, 0);
dbg!(&board.columns.as_columns()); dbg!(&board.columns.as_columns());
assert_eq!(4, scan(&board.columns, &(0, 3), Direction::UpLeft, 4)); assert_eq!(4, scan(&board.columns, &(0, 3), Direction::UpLeft, 4));
assert_eq!(4, scan(&board.columns, &(3, 0), Direction::DownRight, 4)); assert_eq!(4, scan(&board.columns, &(3, 0), Direction::DownRight, 4));
} }
#[test] #[test]
fn variant_eq_test() { fn variant_eq_test() {
assert!(score_checkers::variant_eq(&Disk::RED, &Disk::RED)); assert!(score_checkers::variant_eq(&Disk::P1, &Disk::P1));
assert!(matches!(Disk::RED, Disk::RED)); assert!(matches!(Disk::P1, Disk::P1));
assert!(matches!(&Disk::BLU, &Disk::BLU)); assert!(matches!(&Disk::P2, &Disk::P2));
assert!(!score_checkers::variant_eq(&Disk::BLU, &Disk::RED)); assert!(!score_checkers::variant_eq(&Disk::P2, &Disk::P1));
assert!(!matches!(Disk::BLU, Disk::RED)); assert!(!matches!(Disk::P2, Disk::P1));
} }
#[test] #[test]
fn game_over_test() { fn game_over_test() {
let mut board = Board::default(); let mut board = Board::default();
assert!(!board.game_over()); assert!(!board.game_over());
board.columns = Array2D::filled_with(Disk::BLU, 7, 6); board.columns = Array2D::filled_with(Disk::P2, 7, 6);
assert!(board.game_over()); assert!(board.game_over());
board.columns.set(0, 0, Disk::EMPTY).expect("balls"); board.columns.set(0, 0, Disk::EMPTY).expect("balls");
assert!(!board.game_over()); assert!(!board.game_over());