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]
fn minimax_test() {
let mut board = Board::default();
let mut disk = Disk::BLU;
let mut disk = Disk::P2;
let _depth = 5;
let _turn1 = board.play(disk, minimax_decision(&board, disk, &5).last_move);
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
let sequences = get_streaks(&board.columns, &disk);
let score: i32 = match disk {
Disk::RED => board.red_score - board.blu_score,
Disk::BLU => board.blu_score - board.red_score,
Disk::P1 => board.p1_score - board.p2_score,
Disk::P2 => board.p2_score - board.p1_score,
Disk::EMPTY => panic!("Why would you ever"),
};
potential_streaks(&sequences, &disk) + potential_wins(&sequences, &disk) + score * SCORE_DIFF
@@ -225,44 +225,44 @@ fn heur_scan(
#[test]
fn streak_test_1() {
let mut board = Board::default();
board.play(Disk::BLU, 3);
board.play(Disk::BLU, 3);
board.play(Disk::BLU, 3);
board.play(Disk::BLU, 2);
board.play(Disk::BLU, 1);
let sequences = get_streaks(&board.columns, &Disk::BLU);
assert_eq!(18, potential_streaks(&sequences, &Disk::BLU));
board.play(Disk::BLU, 0);
let _sequences = get_streaks(&board.columns, &Disk::BLU);
board.play(Disk::BLU, 3);
board.play(Disk::BLU, 3);
board.play(Disk::BLU, 3);
board.play(Disk::BLU, 3);
let sequences = get_streaks(&board.columns, &Disk::BLU);
assert_eq!(12, potential_streaks(&sequences, &Disk::BLU));
board.play(Disk::P2, 3);
board.play(Disk::P2, 3);
board.play(Disk::P2, 3);
board.play(Disk::P2, 2);
board.play(Disk::P2, 1);
let sequences = get_streaks(&board.columns, &Disk::P2);
assert_eq!(18, potential_streaks(&sequences, &Disk::P2));
board.play(Disk::P2, 0);
let _sequences = get_streaks(&board.columns, &Disk::P2);
board.play(Disk::P2, 3);
board.play(Disk::P2, 3);
board.play(Disk::P2, 3);
board.play(Disk::P2, 3);
let sequences = get_streaks(&board.columns, &Disk::P2);
assert_eq!(12, potential_streaks(&sequences, &Disk::P2));
}
#[test]
fn win_test_flipping() {
let mut board = Board::default();
board.play(Disk::BLU, 3);
board.play(Disk::RED, 4);
board.play(Disk::BLU, 4);
board.play(Disk::RED, 5);
board.play(Disk::RED, 5);
board.play(Disk::RED, 6);
board.play(Disk::RED, 6);
board.play(Disk::RED, 6);
board.play(Disk::BLU, 6);
let sequences = get_wins(&board.columns, &Disk::BLU);
board.play(Disk::P2, 3);
board.play(Disk::P1, 4);
board.play(Disk::P2, 4);
board.play(Disk::P1, 5);
board.play(Disk::P1, 5);
board.play(Disk::P1, 6);
board.play(Disk::P1, 6);
board.play(Disk::P1, 6);
board.play(Disk::P2, 6);
let sequences = get_wins(&board.columns, &Disk::P2);
dbg!(&sequences);
assert_eq!(POT_WIN, potential_wins(&sequences, &Disk::BLU));
assert_eq!(POT_WIN, potential_wins(&sequences, &Disk::P2));
}
#[test]
fn win_test_flipping_hard() {
let mut board = Board::default();
board.play(Disk::BLU, 1);
board.play(Disk::BLU, 2);
board.play(Disk::BLU, 4);
let sequences = get_wins(&board.columns, &Disk::BLU);
assert_eq!(POT_WIN, potential_wins(&sequences, &Disk::BLU));
board.play(Disk::P2, 1);
board.play(Disk::P2, 2);
board.play(Disk::P2, 4);
let sequences = get_wins(&board.columns, &Disk::P2);
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)]
pub struct Board {
red_score: i32,
blu_score: i32,
p1_score: i32,
p2_score: i32,
columns: Array2D<Disk>,
last_move: usize,
}
@@ -21,8 +21,8 @@ impl Default for Board {
let columns = Array2D::filled_with(Disk::EMPTY, 6, 7);
Self {
red_score: 0,
blu_score: 0,
p1_score: 0,
p2_score: 0,
columns,
last_move: 0,
}
@@ -31,7 +31,7 @@ impl Default for Board {
impl Board {
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 {
let column = &self.columns.as_columns()[col];
@@ -55,7 +55,7 @@ impl Board {
);
match self.columns.get(index.0, index.1) {
Some(disk) => match disk {
Disk::RED => {
Disk::P1 => {
for _move in moves {
let mut consecutive = scan(&self.columns, &index, _move.clone(), 4);
if consecutive < 4 {
@@ -67,11 +67,11 @@ impl Board {
)
}
if consecutive - 1 == 4 {
self.red_score += 1
self.p1_score += 1
}
}
}
Disk::BLU => {
Disk::P2 => {
for _move in moves {
let mut consecutive = scan(&self.columns, &index, _move.clone(), 4);
if consecutive < 4 {
@@ -83,7 +83,7 @@ impl Board {
)
}
if consecutive - 1 == 4 {
self.blu_score += 1
self.p2_score += 1
}
}
}
@@ -115,14 +115,14 @@ impl Board {
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum Disk {
RED,
BLU,
P1,
P2,
EMPTY,
}
pub fn flip_disk(disk: Disk) -> Disk {
match disk {
Disk::RED => Disk::BLU,
Disk::BLU => Disk::RED,
Disk::P1 => Disk::P2,
Disk::P2 => Disk::P1,
Disk::EMPTY => Disk::EMPTY, //why..just why
}
}

148
src/gamedata/tests.rs
View File

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