diff --git a/src/gamedata/algorithms.rs b/src/gamedata/algorithms.rs
index 6bf0171..258a258 100644
--- a/src/gamedata/algorithms.rs
+++ b/src/gamedata/algorithms.rs
@@ -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);
diff --git a/src/gamedata/heuristic.rs b/src/gamedata/heuristic.rs
index 413af63..f52d920 100644
--- a/src/gamedata/heuristic.rs
+++ b/src/gamedata/heuristic.rs
@@ -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));
 }
diff --git a/src/gamedata/mod.rs b/src/gamedata/mod.rs
index 877b08c..7efa4a5 100644
--- a/src/gamedata/mod.rs
+++ b/src/gamedata/mod.rs
@@ -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
     }
 }
diff --git a/src/gamedata/tests.rs b/src/gamedata/tests.rs
index 3686800..4a0a595 100644
--- a/src/gamedata/tests.rs
+++ b/src/gamedata/tests.rs
@@ -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());