From 2d8dd0f58fccc78912f1807a06ab0c39d242a8f5 Mon Sep 17 00:00:00 2001
From: Adrian Gunnar Lauterer <adrian@lauterer.it>
Date: Mon, 25 Mar 2024 08:53:44 +0100
Subject: [PATCH] moved validation logic to seperate call

---
 src/azul.rs | 63 ++++++++++++++++++++++++++++++++++++++---------------
 1 file changed, 45 insertions(+), 18 deletions(-)

diff --git a/src/azul.rs b/src/azul.rs
index e7fa9ac..2af14b3 100644
--- a/src/azul.rs
+++ b/src/azul.rs
@@ -255,7 +255,14 @@ impl GameState {
             return Err(MoveErr::Other("Game is over"));
         }
 
-        self.do_move(game_move).map_err(|e| e)?;
+        self.do_move(game_move.clone()).map_err(|e| e)?;
+        match game_move.policy {
+            //if validate return ok and do not iterate 
+            Policy::Validate => return Ok(()),
+            //else continue the function
+            _ => (),
+        }
+
 
         if self.is_empty() {
             self.score_unchecked().map_err(|e| MoveErr::Other(e))?;
@@ -285,30 +292,18 @@ impl GameState {
         match game_move.policy {
             Policy::Strict => self.do_move_strict(game_move),
             Policy::Loose => self.do_move_loose(game_move),
+            Policy::Validate => self.do_move_validate(game_move),
         }
     }
 
-    /// Does a move, if the move is placed where it can't fit, places it on the floor
-    fn do_move_loose(&mut self, game_move: GameMove) -> Result<(), MoveErr> {
-        match self.do_move_strict(game_move.clone()) {
-            Ok(()) => Ok(()),
-            Err(MoveErr::Dst(_)) => {
-                let mut new_game_move = game_move;
-                new_game_move.destination = Destination::Floor;
-                self.do_move_strict(new_game_move)
-            }
-            e => e,
-        }
-    }
 
-    /// Does a move, errors out if the move is weird in any way
-    fn do_move_strict(&mut self, game_move: GameMove) -> Result<(), MoveErr> {
+
+    /// Validates a move, errors out if the move is weird in any way
+    fn do_move_validate(&mut self, game_move: GameMove) -> Result<(), MoveErr> {
         if self.current_player != game_move.player {
             return Err(MoveErr::Player("Not this player's turn"));
         }
 
-        // let player = &mut self.players[current_player];
-
         let color = game_move.color;
         let src = game_move.source;
         let dst = game_move.destination;
@@ -347,6 +342,32 @@ impl GameState {
                     "That pattern line and color is already filled on the wall",
                 ))
             }
+            _ => Ok(()),
+        }
+    }
+
+    /// Does a move, if the move is placed where it can't fit, places it on the floor
+    fn do_move_loose(&mut self, game_move: GameMove) -> Result<(), MoveErr> {
+        match self.do_move_strict(game_move.clone()) {
+            Ok(()) => Ok(()),
+            Err(MoveErr::Dst(_)) => {
+                let mut new_game_move = game_move;
+                new_game_move.destination = Destination::Floor;
+                self.do_move_strict(new_game_move)
+            }
+            e => e,
+        }
+    }
+
+    /// Does a move, errors out if the move is weird in any way
+    fn do_move_strict(&mut self, game_move: GameMove) -> Result<(), MoveErr> {
+        self.do_move_validate(game_move.clone())?;
+        
+        let color = game_move.color;
+        let src = game_move.source;
+        let dst = game_move.destination;
+
+        match (color, src, dst) {
             (c, s, Destination::PatternLine(p)) => {
                 let amount = self.take_tiles(s, c);
 
@@ -378,6 +399,7 @@ impl GameState {
                     .add_color(c, amount as isize)
                     .map_err(|e| MoveErr::Other(e))?;
             }
+            _ => (),
         };
 
         self.current_player = self
@@ -870,9 +892,14 @@ enum Policy {
     /// Anything weird will return an error
     #[serde(rename = "strict")]
     Strict,
-    #[serde(rename = "loose")]
     /// If you place tiles wrongly, they will fall on the floor, anything else will return an error
+    #[serde(rename = "loose")]
     Loose,
+
+    /// Will validate the move, but not execute it
+    #[serde(rename = "validate")]
+    Validate,
+
     // Anything weird will instead play a random move
     // #[serde(rename = "random")]
     // Random,