Merge branch 'main' into font-pieces

Author: brianch

src/main.rs

@@ -1,3 +1,5 @@
+#![windows_subsystem = "windows"]
+
 use iced::{button, container, slider, pick_list, Container, Align, Length, HorizontalAlignment, VerticalAlignment, Background, Button, Slider, PickList, Row, Column, Element, Sandbox, Settings, Text};
 use iced::Font;
 use chess::{Board, BoardStatus, ChessMove, Color, Piece, Rank, Square, File};
@@ -134,6 +136,30 @@ impl PositionGUI {
         };
         Square::make_square(rank, file)
     }
+
+    pub fn chesssquare_to_posgui(square: Square) -> PositionGUI {
+        let col = match square.get_file() {
+            File::A => 0,
+            File::B => 1,
+            File::C => 2,
+            File::D => 3,
+            File::E => 4,
+            File::F => 5,
+            File::G => 6,
+            File::H => 7,
+        };
+        let row = match square.get_rank() {
+            Rank::First => 0,
+            Rank::Second => 1,
+            Rank::Third => 2,
+            Rank::Fourth => 3,
+            Rank::Fifth => 4,
+            Rank::Sixth => 5,
+            Rank::Seventh => 6,
+            Rank::Eighth => 7,
+        };
+        PositionGUI::new(row,col)
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -167,11 +193,11 @@ pub enum TaticsThemes {
     Mate, MateIn1, MateIn2, MateIn3, MateIn4, MateIn5, AnastasiaMate, ArabianMate, BackRankMate, BodenMate, DoubleBishopMate, DovetailMate, HookMate, SmotheredMate,
     Castling, EnPassant, Promotion, UnderPromotion, Equality, Advantage, Crushing,
     OneMove, Short, Long, VeryLong,
-    Master, MasterVsMaster, SuperGM, OfPlayer
+    Master, MasterVsMaster, SuperGM
 }
 
 impl TaticsThemes {
-    const ALL: [TaticsThemes; 62] = [
+    const ALL: [TaticsThemes; 61] = [
         TaticsThemes::All,
         TaticsThemes::Opening, TaticsThemes::Middlegame, TaticsThemes::Endgame, TaticsThemes::RookEndgame,
         TaticsThemes::BishopEndgame, TaticsThemes::PawnEndgame, TaticsThemes::KnightEndgame,
@@ -198,7 +224,7 @@ impl TaticsThemes {
 
         TaticsThemes::OneMove, TaticsThemes::Short, TaticsThemes::Long, TaticsThemes::VeryLong,
 
-        TaticsThemes::Master, TaticsThemes::MasterVsMaster, TaticsThemes::SuperGM, TaticsThemes::OfPlayer
+        TaticsThemes::Master, TaticsThemes::MasterVsMaster, TaticsThemes::SuperGM
     ];
 }
 
@@ -281,7 +307,6 @@ impl std::fmt::Display for TaticsThemes {
                 TaticsThemes::Master => "master",
                 TaticsThemes::MasterVsMaster => "masterVsMaster",
                 TaticsThemes::SuperGM => "superGM",
-                TaticsThemes::OfPlayer => "of-player",
 
             }
         )
@@ -403,6 +428,9 @@ pub struct OfflinePuzzles {
     from_square: Option<PositionGUI>,
     board: Board,
     squares: [button::State; 64],
+    last_move_from: Option<PositionGUI>,
+    last_move_to: Option<PositionGUI>,
+    is_playing: bool,
 
     theme_list: pick_list::State<TaticsThemes>,
     theme: TaticsThemes,
@@ -431,6 +459,9 @@ impl Default for OfflinePuzzles {
             from_square: None,
             board: Board::default(),
             squares: [button::State::default(); 64],
+            last_move_from: None,
+            last_move_to: None,
+            is_playing: false,
 
             theme_list: pick_list::State::default(),
             theme : TaticsThemes::default(),
@@ -499,7 +530,9 @@ impl Sandbox for OfflinePuzzles {
     fn update(&mut self, message: Message) {
         match (self.from_square, message) {
             (None, Message::SelectSquare(pos)) => {
-                self.from_square = Some(pos);
+                if self.is_playing && self.board.color_on(pos.posgui_to_square()) == Some(self.board.side_to_move()) {
+                    self.from_square = Some(pos);
+                }
             } (Some(from), Message::SelectSquare(to)) if from != to => {
                 self.from_square = None;
 
@@ -534,13 +567,12 @@ impl Sandbox for OfflinePuzzles {
 
                     // If the move is correct we can apply it to the board
                     if is_mate || (move_made == correct_move) {
-                        //We can savely do these unwraps as we know it's a valid position
-                        
+                       
                         self.board = self.board.make_move_new(move_made);
                         self.current_puzzle_move += 1;
 
                         if self.current_puzzle_move == correct_moves.len() {
-                            if self.current_puzzle < self.puzzles.len() {
+                            if self.current_puzzle < self.puzzles.len() - 1 {
                                 // The previous puzzle ended, and we still have puzzles available,
                                 // so we prepare the next one.
                                 self.current_puzzle += 1;
@@ -556,25 +588,41 @@ impl Sandbox for OfflinePuzzles {
                                     Square::from_str(&String::from(&puzzle_moves[0][..2])).unwrap(),
                                     Square::from_str(&String::from(&puzzle_moves[0][2..4])).unwrap(), check_promotion(&puzzle_moves[0]));
 
+                                self.last_move_from = Some(PositionGUI::chesssquare_to_posgui(movement.get_source()));
+                                self.last_move_to = Some(PositionGUI::chesssquare_to_posgui(movement.get_dest()));
+        
                                 self.board = self.board.make_move_new(movement);
 
                                 if self.board.side_to_move() == Color::White {
                                     self.puzzle_status = String::from("White to move!");
                                 } else {
                                     self.puzzle_status = String::from("Black to move!");
                                 }
+                            } else {
+                                self.board = Board::default();
+                                self.last_move_from = None;
+                                self.last_move_to = None;
+                                self.is_playing = false;
+                                self.puzzle_status = String::from("All puzzles done for this search!");
                             }
                         } else {
                             movement = ChessMove::new(
                                 Square::from_str(&String::from(&correct_moves[self.current_puzzle_move][..2])).unwrap(),
                                 Square::from_str(&String::from(&correct_moves[self.current_puzzle_move][2..4])).unwrap(), check_promotion(&correct_moves[self.current_puzzle_move]));
 
+                            self.last_move_from = Some(PositionGUI::chesssquare_to_posgui(movement.get_source()));
+                            self.last_move_to = Some(PositionGUI::chesssquare_to_posgui(movement.get_dest()));
+    
                             self.board = self.board.make_move_new(movement);
                             self.current_puzzle_move += 1;
                             self.puzzle_status = String::from("Correct! What now?");
                         }
                     } else {
-                        self.puzzle_status = String::from("Ops! Wrong move...");
+                        if self.board.side_to_move() == Color::White {
+                            self.puzzle_status = String::from("Ops! Wrong move... White to play.");
+                        } else {
+                            self.puzzle_status = String::from("Ops! Wrong move... Black to play.");
+                        }
                     }
                 }
             } (Some(_), Message::SelectSquare(to)) => {
@@ -621,16 +669,23 @@ impl Sandbox for OfflinePuzzles {
                                     Square::from_str(&puzzle_moves[0][..2]).unwrap(),
                                     Square::from_str(&puzzle_moves[0][2..4]).unwrap(), check_promotion(&puzzle_moves[0]));
 
+                            self.last_move_from = Some(PositionGUI::chesssquare_to_posgui(movement.get_source()));
+                            self.last_move_to = Some(PositionGUI::chesssquare_to_posgui(movement.get_dest()));
+
                             self.board = self.board.make_move_new(movement);
 
                             if self.board.side_to_move() == Color::White {
                                 self.puzzle_status = String::from("white to move!");
                             } else {
                                 self.puzzle_status = String::from("Black to move!");
                             }
+                            self.is_playing = true;
                         } else {
                             // Just putting the default position to make it obvious the search ended.
                             self.board = Board::default();
+                            self.last_move_from = None;
+                            self.last_move_to = None;
+                            self.is_playing = false;
                             self.puzzle_status = String::from("Sorry, no puzzle found");
                         }
                     } Err(_) => {
@@ -682,7 +737,9 @@ impl Sandbox for OfflinePuzzles {
                     };
                 }
             }
-            
+
+            let selected = self.from_square == Some(pos) || self.last_move_from == Some(pos) || self.last_move_to == Some(pos);
+
             row = row.push(Button::new(button,
                 Text::new(text)
                         .horizontal_alignment(HorizontalAlignment::Center)
@@ -695,7 +752,7 @@ impl Sandbox for OfflinePuzzles {
                 .width(Length::Units(SETTINGS.square_size))
                 .height(Length::Units(SETTINGS.square_size))
                 .on_press(Message::SelectSquare(pos))
-                .style(ChessSquare::from((pos, self.from_square == Some(pos))))
+                .style(ChessSquare::from((pos, selected)))
             );
 
             i += 1;
@@ -833,4 +890,4 @@ fn main() -> iced::Result {
         },
         ..Settings::default()
     })
-}
+}