Upload 18 files

.gitignore

@@ -0,0 +1,3 @@
+stockfish.exe/*.exe
+*.exe
+__pycache__/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 callmerem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,157 @@
+# CheckerChesser
+
+CheckerChesser is a powerful chess utility application that combines a local chess analysis board with real-time screen monitoring capabilities. It is designed to assist players in analyzing games, finding best moves, and testing positions.
+
+<img width="1354" height="680" alt="image" src="https://github.com/user-attachments/assets/dc902cf0-a31c-4abf-8f85-9dda475eaac8" />
+<img width="1323" height="719" alt="image" src="https://github.com/user-attachments/assets/1dc5c833-bf2b-4562-a5f7-8630c72fefab" />
+<img width="1347" height="675" alt="image" src="https://github.com/user-attachments/assets/4005f25a-b1ef-42a6-a732-cad55ea27a32" />
+
+<img width="587" height="187" alt="image" src="https://github.com/user-attachments/assets/85ca3a62-fdd3-4e7d-ad34-058520587279" />
+<img width="1366" height="681" alt="image" src="https://github.com/user-attachments/assets/3935066d-b436-486a-8c40-813bf5b3bed0" />
+<img width="1363" height="681" alt="image" src="https://github.com/user-attachments/assets/07a27629-3aef-4d9b-a4fc-6e16633dfb7b" />
+
+<img width="1366" height="715" alt="image" src="https://github.com/user-attachments/assets/e82defd9-f2fc-4f9b-9172-2b107105dec2" /><br><br>
+
+_So yeah, it was so good I got banned_
+<img width="863" height="115" alt="image" src="https://github.com/user-attachments/assets/2803a361-f8dd-4160-97a8-4f4d70756967" /><br><br>
+
+**_All that grind for nothing lol!_**
+
+<img width="331" height="126" alt="image" src="https://github.com/user-attachments/assets/e4b20a49-4d3b-4424-b24e-5fdafece9185" />
+
+
+
+
+## Core Features
+
+### 1. Local Analysis Board
+- **Full Chess Engine Integration**: Powered by **Stockfish**, one of the strongest chess engines in the world.
+- **Interactive Board**: Move pieces, flip the board, and play against the AI.
+- **Dual Player Mode**: Play locally against a friend or test moves for both sides.
+- **Analysis Visualization**: Visualize top engine moves with colored arrows indicating strength and threat.
+
+### 2. Board Editor
+- **Custom Scenario Setup**: Manually place any piece on the board to recreate specific game states.
+- **Automation Control**: The engine is strictly disabled during editing to prevent interference.
+- **Piece Palette**: Intuitive drag-and-drop style interface (click-to-place) for all piece types.
+
+### 3. Screen Analysis (Vision)
+- **Real-time Monitoring**: Define a region on your screen to monitor a live chess board (e.g., from a website or video).
+- **Auto-Calibration**: The application automatically detects the board structure from a standard starting position.
+- **Live suggestions**: As moves are played on the screen, the app updates the internal board and suggests the best response instantly.
+
+### 4. Turn Swapping & Customization
+- **First Move Control**: Choose whether White or Black moves first (useful for variants or playing as Black from the start).
+- **Play As**: Switch sides to play as Black or White against the engine.
+
+---
+
+## Technical Architecture & Machine Learning
+
+### Is it based on Machine Learning?
+**Yes and No.**
+
+1.  **Chess Intelligence (Yes)**: The application utilizes **Stockfish**, which employs **NNUE (Efficiently Updatable Neural Network)** technology. This is a form of machine learning where a neural network attempts to evaluate positions, providing superior performance over classical hand-crafted evaluation functions.
+2.  **Vision System (No)**: The screen analysis feature uses **Computer Vision** techniques (specifically Template Matching and Mean Squared Error comparisons), not Deep Learning. It requires a clear view of a 2D chess board to "calibrate" and match pieces against a known template.
+
+---
+
+## Installation
+
+1.  **Prerequisites**:
+    - Python 3.8+
+    - Stockfish Engine (Executable must be placed in the project folder or specified in config).
+
+2.  **Dependencies**:
+    Install the required Python packages:
+    ```bash
+    pip install -r requirements.txt
+    ```
+    *(Requires: customtkinter, python-chess, mss, opencv-python, numpy)*
+
+3.  **Setup (Stockfish Guide)**:
+    This application requires the **Stockfish Chess Engine** to function.
+    
+    **Step-by-Step Guide:**
+    1.  **Download**: Visit the official Stockfish website: [https://stockfishchess.org/download/](https://stockfishchess.org/download/)
+    2.  **Select Version**: Download the version suitable for your system (usually "Windows (AVX2)" or "Windows (x64-modern)").
+    3.  **Extract**: Unzip the downloaded folder. Inside, you will find an executable file (e.g., `stockfish-windows-x86-64-avx2.exe`).
+    4.  **Rename**: Rename this file to simply `stockfish.exe`.
+    5.  **Place File**: Move `stockfish.exe` directly into the `CheckerChesser` project folder.
+    
+    **Correct Folder Structure:**
+```text
+CheckerChesser/
+├── src/
+│   ├── __pycache__/
+│   ├── __init__.py
+│   ├── board_ui.py
+│   ├── engine.py
+│   ├── game_state.py
+│   ├── gui.py
+│   ├── mirror.py
+│   ├── overlay.py
+│   └── vision.py
+├── tests/  
+├── main.py
+├── requirements.txt
+├── stockfish.exe/  <-- PLACE HERE (folder named btw)
+├── LICENSE
+└── README.md
+```
+
+---
+
+## Usage Guide
+
+### Starting the App
+Run the main script:
+```bash
+python main.py
+```
+
+### Modes
+
+#### Local Game
+- **Play**: Drag and drop or click squares to move pieces.
+- **Analysis Mode**: Toggle `Analysis Mode` switch to see Best Move arrows overlaid on the board.
+- **Two Player**: Toggle `Two Player Mode` to control both sides manually.
+- **Flip Board**: Click `⟳ Flip Board` to rotate the view.
+
+#### Board Editor
+1. Toggle `Edit Mode` switch to **ON**.
+2. A palette of pieces (White/Black) and a Trash Bin will appear.
+3. **Left Click** a piece in the palette to select it.
+4. **Left Click** any square on the board to place that piece.
+5. Select the **Trash Bin** and click a square to clear it.
+6. Toggle `Edit Mode` **OFF** to resume play.
+   > **Note**: AI logic is paused while Edit Mode is active.
+
+#### Screen Analysis
+1. Click `Screen Analysis` in the sidebar.
+2. An overlay window will appear. Drag to select the area of the chess board you want to monitor.
+3. **Important**: Ensure the board on screen is at the **Starting Position** when you start monitoring. The tool needs this to calibrate piece textures.
+4. Once calibrated, the app will track moves and display the best engine move in real-time.
+
+---
+
+## Troubleshooting
+
+- **Engine Not Found**: Ensure `stockfish.exe` is in the folder.
+- **Vision Not Working**: Make sure the board on screen is not obstructed and matches standard 2D chess pieces. Glare or unusual piece sets may confuse the template matcher.
+- **Performance**: High `Best Moves` count or deep analysis may use significant CPU resources. Lower the number of moves if the app lags.
+
+
+
+## Citation
+
+```bibtex
+@misc{CheckerChesser,
+  author = {algorembrant},
+  title = {CheckerChesser},
+  year = {2026},
+  publisher = {GitHub},
+  journal = {GitHub repository},
+  howpublished = {\url{https://github.com/algorembrant/CheckerChesser}},
+}
+```

STRUCTURE.md

@@ -0,0 +1,24 @@
+## Project Structure
+
+```text
+CheckerChesser/
+├── src/
+│   ├── __init__.py
+│   ├── board_ui.py
+│   ├── engine.py
+│   ├── game_state.py
+│   ├── gui.py
+│   ├── mirror.py
+│   ├── overlay.py
+│   └── vision.py
+├── tests/
+│   ├── test_engine.py
+│   ├── test_engine_manual.py
+│   └── test_mirror.py
+├── .gitignore
+├── LICENSE
+├── main.py
+├── README.md
+├── requirements.txt
+└── TECHSTACK.md
+```

TECHSTACK.md

@@ -0,0 +1,11 @@
+## Techstack
+
+Audit of **CheckerChesser** project files (excluding environment and cache):
+
+| File Type | Count | Size (KB) |
+| :--- | :--- | :--- |
+| Python (.py) | 12 | 55.9 |
+| (no extension) | 2 | 1.1 |
+| Markdown (.md) | 1 | 7.1 |
+| Plain Text (.txt) | 1 | 0.1 |
+| **Total** | **16** | **64.2** |

main.py

@@ -0,0 +1,10 @@
+import customtkinter as ctk
+from src.gui import ChessApp
+
+if __name__ == "__main__":
+    ctk.set_appearance_mode("Dark")
+    ctk.set_default_color_theme("blue")
+    
+    app = ChessApp()
+    app.mainloop()
+ 

requirements.txt

@@ -0,0 +1,10 @@
+customtkinter
+python-chess
+opencv-python
+pillow
+mss
+numpy
+paramiko
+pyglet
+pywin32
+pyautogui

src/board_ui.py

@@ -0,0 +1,222 @@
+import customtkinter as ctk
+import chess
+
+class BoardUI(ctk.CTkFrame):
+    def __init__(self, master, game_state, **kwargs):
+        super().__init__(master, **kwargs)
+        self.game_state = game_state
+        self.canvas = ctk.CTkCanvas(self, bg="#302E2B", highlightthickness=0)
+        self.canvas.pack(fill="both", expand=True)
+        
+        self.square_size = 50  # Will be recalculated on resize
+        self.selected_square = None
+        self.pieces = {}
+        self.flipped = False  # Board orientation
+        self.edit_mode = False
+        self.selected_edit_piece = None  # Piece to place in edit mode (None = Delete)
+        self.last_analysis_moves = [] # cache for redrawing arrows
+        
+        self.canvas.bind("<Button-1>", self.on_click)
+        self.canvas.bind("<Configure>", self.on_resize)
+        
+    def on_resize(self, event):
+        # Calculate square size based on available space (use smaller dimension)
+        size = min(event.width, event.height)
+        self.square_size = size // 8
+        self.draw_board()
+
+    def get_visual_coords(self, file, rank):
+        """Convert chess file/rank to visual coordinates accounting for flip."""
+        if self.flipped:
+            visual_file = 7 - file
+            visual_rank = rank  # When flipped, rank 0 (row 1) is at top
+        else:
+            visual_file = file
+            visual_rank = 7 - rank  # Normal: rank 7 (row 8) is at top
+        return visual_file, visual_rank
+
+    def get_chess_square_from_visual(self, visual_file, visual_rank):
+        """Convert visual coordinates to chess square."""
+        if self.flipped:
+            file = 7 - visual_file
+            rank = visual_rank
+        else:
+            file = visual_file
+            rank = 7 - visual_rank
+        return chess.square(file, rank)
+
+    def draw_board(self):
+        self.canvas.delete("all")
+        colors = ["#EBECD0", "#779556"]  # Light, Dark squares
+        
+        # Center the board if window is not square
+        canvas_w = self.canvas.winfo_width()
+        canvas_h = self.canvas.winfo_height()
+        board_size = self.square_size * 8
+        offset_x = (canvas_w - board_size) // 2
+        offset_y = (canvas_h - board_size) // 2
+        
+        self.offset_x = max(0, offset_x)
+        self.offset_y = max(0, offset_y)
+        
+        for visual_rank in range(8):
+            for visual_file in range(8):
+                color = colors[(visual_rank + visual_file) % 2]
+                x1 = self.offset_x + visual_file * self.square_size
+                y1 = self.offset_y + visual_rank * self.square_size
+                x2 = x1 + self.square_size
+                y2 = y1 + self.square_size
+                
+                self.canvas.create_rectangle(x1, y1, x2, y2, fill=color, outline="")
+                
+                # Get chess square for this visual position
+                chess_square = self.get_chess_square_from_visual(visual_file, visual_rank)
+                piece = self.game_state.board.piece_at(chess_square)
+                
+                if piece:
+                    self.draw_piece(x1, y1, piece)
+        
+        # Highlight King if in Check
+        if self.game_state.board.is_check():
+            self.highlight_king_check()
+            
+        if self.selected_square is not None:
+             self.highlight_square(self.selected_square)
+
+        # Redraw arrows if they exist
+        if self.last_analysis_moves:
+             self.display_analysis(self.last_analysis_moves, cache=False)
+
+    def draw_piece(self, x, y, piece):
+        symbol = piece.unicode_symbol()
+        font_size = int(self.square_size * 0.7)
+        fill_color = "#1a1a1a" if piece.color == chess.BLACK else "#ffffff"
+        
+        # Add shadow for better visibility
+        shadow_offset = max(1, int(self.square_size * 0.02))
+        self.canvas.create_text(
+            x + self.square_size/2 + shadow_offset, 
+            y + self.square_size/2 + shadow_offset,
+            text=symbol, 
+            font=("Segoe UI Symbol", font_size, "bold"), 
+            fill="gray30"
+        )
+        self.canvas.create_text(
+            x + self.square_size/2, 
+            y + self.square_size/2,
+            text=symbol, 
+            font=("Segoe UI Symbol", font_size, "bold"), 
+            fill=fill_color
+        )
+        
+    def highlight_king_check(self):
+        """Highlight the King's square in red if in check."""
+        king_square = self.game_state.board.king(self.game_state.board.turn)
+        if king_square is not None:
+             file = chess.square_file(king_square)
+             rank = chess.square_rank(king_square)
+             visual_file, visual_rank = self.get_visual_coords(file, rank)
+             
+             x1 = self.offset_x + visual_file * self.square_size
+             y1 = self.offset_y + visual_rank * self.square_size
+             x2 = x1 + self.square_size
+             y2 = y1 + self.square_size
+             
+             # Create a red glow/border
+             self.canvas.create_oval(x1+2, y1+2, x2-2, y2-2, outline="#FF0000", width=4, tag="check")
+             self.canvas.create_rectangle(x1, y1, x2, y2, fill="red", stipple="gray25", outline="")
+
+    def highlight_square(self, square):
+        file = chess.square_file(square)
+        rank = chess.square_rank(square)
+        visual_file, visual_rank = self.get_visual_coords(file, rank)
+        
+        x1 = self.offset_x + visual_file * self.square_size
+        y1 = self.offset_y + visual_rank * self.square_size
+        x2 = x1 + self.square_size
+        y2 = y1 + self.square_size
+        
+        self.canvas.create_rectangle(x1, y1, x2, y2, fill="yellow", stipple="gray50", outline="gold", width=2)
+
+    def on_click(self, event):
+        # Adjust for offset
+        adj_x = event.x - getattr(self, 'offset_x', 0)
+        adj_y = event.y - getattr(self, 'offset_y', 0)
+        
+        if adj_x < 0 or adj_y < 0:
+            return
+            
+        visual_file = int(adj_x // self.square_size)
+        visual_rank = int(adj_y // self.square_size)
+        
+        if visual_file < 0 or visual_file > 7 or visual_rank < 0 or visual_rank > 7:
+            return
+        
+        chess_square = self.get_chess_square_from_visual(visual_file, visual_rank)
+        
+        if self.edit_mode:
+            # Edit Mode Logic
+            self.game_state.set_piece(chess_square, self.selected_edit_piece)
+            self.draw_board()
+            return
+
+        # Normal Play Logic
+        if self.selected_square is None:
+            piece = self.game_state.board.piece_at(chess_square)
+            if piece and piece.color == self.game_state.board.turn:
+                self.selected_square = chess_square
+                self.draw_board()
+        else:
+            # Try to move
+            move = chess.Move(self.selected_square, chess_square)
+            # Check for promotion
+            piece_at_start = self.game_state.board.piece_at(self.selected_square)
+            if piece_at_start and piece_at_start.piece_type == chess.PAWN:
+                if (self.game_state.board.turn == chess.WHITE and chess.square_rank(chess_square) == 7) or \
+                   (self.game_state.board.turn == chess.BLACK and chess.square_rank(chess_square) == 0):
+                    move = chess.Move(self.selected_square, chess_square, promotion=chess.QUEEN)
+
+            if move in self.game_state.board.legal_moves:
+                self.game_state.board.push(move)
+                self.selected_square = None
+                self.draw_board()
+                self.master.event_generate("<<MoveMade>>")
+            else:
+                piece = self.game_state.board.piece_at(chess_square)
+                if piece and piece.color == self.game_state.board.turn:
+                    self.selected_square = chess_square
+                    self.draw_board()
+                else:
+                    self.selected_square = None
+                    self.draw_board()
+
+    def draw_arrow(self, start_sq, end_sq, color="#00FF00", width=4):
+        # Get visual coordinates for arrow
+        start_file = chess.square_file(start_sq)
+        start_rank = chess.square_rank(start_sq)
+        end_file = chess.square_file(end_sq)
+        end_rank = chess.square_rank(end_sq)
+        
+        start_vf, start_vr = self.get_visual_coords(start_file, start_rank)
+        end_vf, end_vr = self.get_visual_coords(end_file, end_rank)
+        
+        x1 = self.offset_x + start_vf * self.square_size + self.square_size // 2
+        y1 = self.offset_y + start_vr * self.square_size + self.square_size // 2
+        x2 = self.offset_x + end_vf * self.square_size + self.square_size // 2
+        y2 = self.offset_y + end_vr * self.square_size + self.square_size // 2
+        
+        self.canvas.create_line(x1, y1, x2, y2, fill=color, width=width, arrow="last", arrowshape=(16, 20, 6), tag="arrow")
+
+    def display_analysis(self, top_moves, cache=True):
+        if cache:
+             self.last_analysis_moves = top_moves
+             
+        self.canvas.delete("arrow")
+        
+        colors = ["#00FF00", "#00FFFF", "#FFFF00"]
+        
+        for i, move_data in enumerate(top_moves):
+            if i >= len(colors):
+                break
+            move = move_data["move"]
+            self.draw_arrow(move.from_square, move.to_square, color=colors[i], width=6 - i)

src/engine.py

@@ -0,0 +1,120 @@
+import chess
+import chess.engine
+import os
+import threading
+
+class EngineHandler:
+    def __init__(self, engine_path="stockfish.exe"):
+        self.engine_path = engine_path
+        self.engine = None
+        self.lock = threading.Lock()  # Prevent concurrent engine access
+
+    def initialize_engine(self):
+        # 1. Check if path exists
+        if not os.path.exists(self.engine_path):
+            return False, f"Engine not found at {self.engine_path}. Please place 'stockfish.exe' in the project folder."
+        
+        # 2. If it is a directory, search for an executable inside
+        final_path = self.engine_path
+        if os.path.isdir(self.engine_path):
+            found_exe = None
+            for root, dirs, files in os.walk(self.engine_path):
+                for file in files:
+                    if "stockfish" in file.lower() and file.lower().endswith(".exe"):
+                        found_exe = os.path.join(root, file)
+                        break
+                if found_exe:
+                    break
+             
+            if found_exe:
+                final_path = found_exe
+            else:
+                return False, f"Directory found at {self.engine_path}, but no 'stockfish' executable was found inside."
+
+        try:
+            self.engine = chess.engine.SimpleEngine.popen_uci(final_path)
+            return True, f"Engine initialized successfully ({os.path.basename(final_path)})."
+        except PermissionError:
+            return False, f"Permission denied accessing {self.engine_path}. Try running as Administrator or check file properties."
+        except Exception as e:
+            return False, f"Failed to initialize engine: {e}"
+
+    def get_best_move(self, fen, time_limit=1.0):
+        if not self.engine:
+            return None
+        
+        with self.lock:
+            try:
+                board = chess.Board(fen)
+                result = self.engine.play(board, chess.engine.Limit(time=time_limit))
+                return result.move
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                print(f"Error getting best move: {e!r}")
+                # Try to reinitialize engine if it died
+                self._try_reinit()
+                return None
+
+    def _try_reinit(self):
+        """Attempt to reinitialize the engine if it crashed."""
+        try:
+            if self.engine:
+                try:
+                    self.engine.quit()
+                except:
+                    pass
+            self.engine = None
+            self.initialize_engine()
+        except:
+            pass
+
+    def get_top_moves(self, fen, limit=3, time_limit=1.0):
+        if not self.engine:
+            return []
+        
+        with self.lock:
+            try:
+                board = chess.Board(fen)
+                info = self.engine.analyse(board, chess.engine.Limit(time=time_limit), multipv=limit)
+                
+                if isinstance(info, dict):
+                    info = [info]
+
+                top_moves = []
+                for i, line in enumerate(info):
+                    if "pv" in line:
+                        move = line["pv"][0]
+                        score = line["score"].relative.score(mate_score=10000)
+                        top_moves.append({
+                            "rank": i + 1,
+                            "move": move,
+                            "score": score,
+                            "pv": line["pv"]
+                        })
+                return top_moves
+                
+            except Exception as e:
+                print(f"Error analyzing: {e}")
+                self._try_reinit()
+                return []
+
+    def quit(self):
+        if self.engine:
+            try:
+                self.engine.quit()
+            except:
+                pass
+
+    def get_evaluation(self, fen):
+        if not self.engine:
+            return None
+        
+        with self.lock:
+            try:
+                board = chess.Board(fen)
+                info = self.engine.analyse(board, chess.engine.Limit(depth=15))
+                return info["score"].relative.score(mate_score=10000)
+            except Exception as e:
+                print(f"Error in evaluation: {e}")
+                return None

src/game_state.py

@@ -0,0 +1,28 @@
+import chess
+
+class GameState:
+    def __init__(self):
+        self.board = chess.Board()
+
+    def reset(self):
+        self.board.reset()
+
+    def make_move(self, uci_move):
+        try:
+            move = chess.Move.from_uci(uci_move)
+            if move in self.board.legal_moves:
+                self.board.push(move)
+                return True
+            return False
+        except:
+            return False
+
+    def set_piece(self, square, piece):
+        """Set a piece on the board directly."""
+        self.board.set_piece_at(square, piece)
+
+    def get_fen(self):
+        return self.board.fen()
+
+    def is_game_over(self):
+        return self.board.is_game_over()

src/gui.py

@@ -0,0 +1,498 @@
+import customtkinter as ctk
+import threading
+import chess
+import time
+from src.game_state import GameState
+from src.engine import EngineHandler
+from src.board_ui import BoardUI
+from src.overlay import SelectionOverlay, ProjectionOverlay
+from src.vision import VisionHandler
+from src.mirror import MirrorHandler
+
+class ChessApp(ctk.CTk):
+    def __init__(self):
+        super().__init__()
+        
+        self.title("CheckerChesser")
+        self.geometry("900x700")
+        self.minsize(600, 500)  # Minimum window size
+        
+        # Initialize Logic
+        self.game_state = GameState()
+        self.engine = EngineHandler()
+        self.vision = VisionHandler()
+        self.mirror = MirrorHandler()
+        
+        # Screen Mirroring State
+        self.mirroring = False
+        self.mirror_region = None
+        self.projection_overlay = None
+        
+        self.grid_rowconfigure(0, weight=1)
+        self.grid_columnconfigure(0, weight=0) # Sidebar
+        self.grid_columnconfigure(1, weight=1) # Main Content
+        
+        # Sidebar
+        self.sidebar = ctk.CTkFrame(self, width=200, corner_radius=0)
+        self.sidebar.grid(row=0, column=0, sticky="nsew")
+        
+        self.logo_label = ctk.CTkLabel(self.sidebar, text="CheckerChesser", font=ctk.CTkFont(size=20, weight="bold"))
+        self.logo_label.grid(row=0, column=0, padx=20, pady=(20, 10))
+        
+        self.new_game_btn = ctk.CTkButton(self.sidebar, text="New Local Game", command=self.start_local_game)
+        self.new_game_btn.grid(row=1, column=0, padx=20, pady=10)
+        
+        self.mirror_btn = ctk.CTkButton(self.sidebar, text="Screen Mirroring", command=self.start_screen_mirroring)
+        self.mirror_btn.grid(row=2, column=0, padx=20, pady=10)
+        
+        self.stop_btn = ctk.CTkButton(self.sidebar, text="Stop Mirroring", command=self.stop_mirroring, fg_color="red", hover_color="darkred")
+        self.stop_btn.grid(row=3, column=0, padx=20, pady=10)
+        self.stop_btn.grid_remove() # Hidden by default
+
+        self.status_label = ctk.CTkLabel(self.sidebar, text="Status: Idle", anchor="w")
+        self.status_label.grid(row=4, column=0, padx=20, pady=(20, 0), sticky="ew")
+
+        # Content Area
+        self.content_frame = ctk.CTkFrame(self, corner_radius=0, fg_color="transparent")
+        self.content_frame.grid(row=0, column=1, sticky="nsew")
+        self.content_frame.grid_rowconfigure(0, weight=1)
+        self.content_frame.grid_columnconfigure(0, weight=1)
+
+        # Init Engine
+        # Defer execution to ensure mainloop is running before thread tries to callback
+        self.after(200, self.init_engine_thread)
+        
+        # Sidebar Toggle State
+        self.sidebar_visible = True
+        
+        # Sidebar Toggle Button (Floating)
+        self.sidebar_toggle_btn = ctk.CTkButton(self, text="☰", width=30, height=30, 
+                                                command=self.toggle_sidebar,
+                                                fg_color="gray20", hover_color="gray30")
+        self.sidebar_toggle_btn.place(x=10, y=10)
+
+        # Current Board View
+        self.board_ui = None
+        self.start_local_game()
+
+    def toggle_sidebar(self):
+        if self.sidebar_visible:
+            self.sidebar.grid_remove()
+            self.sidebar_visible = False
+            self.sidebar_toggle_btn.configure(fg_color="transparent") # Blend in more when closed? Or keep visible?
+            # When closed, content takes full width. 
+            # self.grid_columnconfigure(0, weight=0) is already set for sidebar column.
+            # But the sidebar frame is gone, so column 0 collapses.
+        else:
+            self.sidebar.grid()
+            self.sidebar_visible = True
+            self.sidebar_toggle_btn.configure(fg_color="gray20")
+
+    def init_engine_thread(self):
+        def _init():
+            success, msg = self.engine.initialize_engine()
+            self.after(0, lambda: self.status_label.configure(text="Engine: Ready" if success else "Engine: Not Found"))
+            if not success:
+                print(msg)
+        threading.Thread(target=_init, daemon=True).start()
+
+    def start_local_game(self):
+        self.stop_mirroring() # Stop any active mirroring
+        
+        # Clear content
+        for widget in self.content_frame.winfo_children():
+            widget.destroy()
+            
+        self.game_state.reset()
+        
+        # Controls Frame (horizontal layout for controls)
+        self.controls_frame = ctk.CTkFrame(self.content_frame, fg_color="transparent")
+        self.controls_frame.grid(row=1, column=0, pady=10, sticky="ew")
+        
+        # Left controls
+        left_frame = ctk.CTkFrame(self.controls_frame, fg_color="transparent")
+        left_frame.pack(side="left", padx=20)
+        
+        # Play As selector
+        self.play_as_var = ctk.StringVar(value="White")
+        play_as_label = ctk.CTkLabel(left_frame, text="Play as:")
+        play_as_label.pack(side="left", padx=(0, 5))
+        self.play_as_menu = ctk.CTkOptionMenu(left_frame, variable=self.play_as_var, 
+                                               values=["White", "Black"],
+                                               command=self.on_play_as_change,
+                                               width=80)
+        self.play_as_menu.pack(side="left", padx=5)
+
+        # First Move selector
+        self.first_move_var = ctk.StringVar(value="White")
+        first_move_label = ctk.CTkLabel(left_frame, text="First Move:")
+        first_move_label.pack(side="left", padx=(10, 5))
+        self.first_move_menu = ctk.CTkOptionMenu(left_frame, variable=self.first_move_var,
+                                                  values=["White", "Black"],
+                                                  command=self.on_first_move_change,
+                                                  width=80)
+        self.first_move_menu.pack(side="left", padx=5)
+        
+        # Flip Board button
+        self.flip_btn = ctk.CTkButton(left_frame, text="⟳ Flip Board", command=self.flip_board, width=100)
+        self.flip_btn.pack(side="left", padx=10)
+        
+        # Right controls
+        right_frame = ctk.CTkFrame(self.controls_frame, fg_color="transparent")
+        right_frame.pack(side="right", padx=20)
+        
+        # Best Moves count
+        moves_label = ctk.CTkLabel(right_frame, text="Show Best Moves:")
+        moves_label.pack(side="left", padx=(0, 5))
+        self.best_moves_var = ctk.StringVar(value="3")
+        self.best_moves_menu = ctk.CTkOptionMenu(right_frame, variable=self.best_moves_var, 
+                                                  values=["1", "2", "3"],
+                                                  command=self.on_best_moves_change,
+                                                  width=60)
+        self.best_moves_menu.pack(side="left", padx=5)
+        
+        # Board UI
+        self.board_ui = BoardUI(self.content_frame, self.game_state)
+        self.board_ui.grid(row=0, column=0, padx=20, pady=20, sticky="nsew")
+        
+        # Toggles Frame
+        toggles_frame = ctk.CTkFrame(self.content_frame, fg_color="transparent")
+        toggles_frame.grid(row=2, column=0, pady=5)
+        
+        # Analysis Toggle
+        self.analysis_var = ctk.BooleanVar(value=False)
+        self.analysis_switch = ctk.CTkSwitch(toggles_frame, text="Analysis Mode", 
+                                             variable=self.analysis_var, command=self.toggle_analysis)
+        self.analysis_switch.pack(side="left", padx=15)
+        
+        # Two Player Mode Toggle
+        self.two_player_var = ctk.BooleanVar(value=False)
+        self.two_player_switch = ctk.CTkSwitch(toggles_frame, text="Two Player Mode", 
+                                               variable=self.two_player_var, command=self.toggle_two_player)
+        self.two_player_switch.pack(side="left", padx=15)
+        
+        # Force Move Button (Initially hidden or shown based on mode? Best to just have it handy)
+        self.force_move_btn = ctk.CTkButton(left_frame, text="⚡ Force Move", command=self.force_ai_move, width=100, fg_color="orange", hover_color="darkorange")
+        self.force_move_btn.pack(side="left", padx=10)
+
+        # Edit Mode Toggle
+        self.edit_mode_var = ctk.BooleanVar(value=False)
+        self.edit_mode_switch = ctk.CTkSwitch(toggles_frame, text="Edit Mode", 
+                                              variable=self.edit_mode_var, command=self.toggle_edit_mode)
+        self.edit_mode_switch.pack(side="left", padx=15)
+        
+        # Piece Palette (Hidden by default)
+        self.palette_frame = ctk.CTkFrame(self.content_frame, fg_color="transparent")
+        self.palette_frame.grid(row=3, column=0, pady=5)
+        self.palette_frame.grid_remove()
+        
+        self.init_palette()
+
+        # Score display label
+        self.score_label = ctk.CTkLabel(self.content_frame, text="", font=("Arial", 12))
+        self.score_label.grid(row=4, column=0, pady=5)
+        
+        # Bind move event
+        self.bind("<<MoveMade>>", self.on_move_made)
+        self.status_label.configure(text="Mode: vs AI (White)")
+
+    def start_screen_mirroring(self):
+        self.status_label.configure(text="Select Region to Mirror to...")
+        self.withdraw() # Hide main win
+        
+        # Function called when region is selected
+        def on_selection(region):
+            self.deiconify() # Show main win
+            self.begin_mirroring(region)
+
+        SelectionOverlay(self, on_selection)
+
+    def begin_mirroring(self, region):
+        """
+        Start mirroring moves to the selected region.
+        """
+        self.mirror_region = region
+        self.mirroring = True
+        
+        self.stop_btn.grid() # Show stop button
+        
+        # Clear content and show mirroring UI
+        # We can actually KEEP the board UI for mirroring, so the user can play!
+        # The original analysis mode cleared everything. Mirroring implies playing locally.
+        
+        # Just update status
+        self.status_label.configure(text="Mode: Screen Mirroring Active")
+        self.stop_btn.grid()
+        
+        # Optional: Show overlay on the target region to confirm?
+        self.projection_overlay = ProjectionOverlay(region)
+        # Maybe draw a box or something? For now just keep it simple.
+
+    def stop_mirroring(self):
+        self.mirroring = False
+        self.mirror_region = None
+        
+        if self.projection_overlay:
+            self.projection_overlay.destroy()
+            self.projection_overlay = None
+            
+        self.stop_btn.grid_remove()
+        self.status_label.configure(text="Mirroring Stopped")
+        
+        # Restore normal status text if game is ongoing
+        if not self.game_state.is_game_over():
+             turn_str = "White" if self.game_state.board.turn == chess.WHITE else "Black"
+             self.status_label.configure(text=f"Your Turn ({turn_str})")
+
+    def toggle_analysis(self):
+        if self.analysis_var.get():
+            self.update_analysis()
+        else:
+            self.board_ui.canvas.delete("arrow")
+
+    def toggle_two_player(self):
+        if self.two_player_var.get():
+            self.status_label.configure(text="Mode: Two Player")
+            turn = "White" if self.game_state.board.turn == chess.WHITE else "Black"
+            self.status_label.configure(text=f"{turn}'s Turn")
+            # Clear AI thinking text if any
+            if "Thinking" in self.status_label.cget("text"):
+                 self.status_label.configure(text=f"{turn}'s Turn")
+        else:
+            self.status_label.configure(text="Mode: vs AI (White)")
+            if self.game_state.board.turn == chess.WHITE:
+                self.status_label.configure(text="Your Turn (White)")
+
+    def flip_board(self):
+        """Flip the board orientation."""
+        if hasattr(self, 'board_ui') and self.board_ui:
+            self.board_ui.flipped = not getattr(self.board_ui, 'flipped', False)
+            self.board_ui.draw_board()
+            
+    def on_play_as_change(self, value):
+        """Handle play as color change."""
+        if self.edit_mode_var.get():
+             return # Do not reset if editing
+        self.reset_game()
+        
+    def init_palette(self):
+        """Initialize the piece palette for editing."""
+        pieces = [
+            (chess.PAWN, chess.WHITE, "♙"), (chess.KNIGHT, chess.WHITE, "♘"), (chess.BISHOP, chess.WHITE, "♗"),
+            (chess.ROOK, chess.WHITE, "♖"), (chess.QUEEN, chess.WHITE, "♕"), (chess.KING, chess.WHITE, "♔"),
+            (chess.PAWN, chess.BLACK, "♟"), (chess.KNIGHT, chess.BLACK, "♞"), (chess.BISHOP, chess.BLACK, "♝"),
+            (chess.ROOK, chess.BLACK, "♜"), (chess.QUEEN, chess.BLACK, "♛"), (chess.KING, chess.BLACK, "♚")
+        ]
+        
+        # White pieces row
+        for i, (pt, color, symbol) in enumerate(pieces[:6]):
+            btn = ctk.CTkButton(self.palette_frame, text=symbol, width=40, font=("Segoe UI Symbol", 24),
+                                command=lambda p=chess.Piece(pt, color): self.select_palette_piece(p))
+            btn.grid(row=0, column=i, padx=2, pady=2)
+            
+        # Black pieces row
+        for i, (pt, color, symbol) in enumerate(pieces[6:]):
+            btn = ctk.CTkButton(self.palette_frame, text=symbol, width=40, font=("Segoe UI Symbol", 24),
+                                command=lambda p=chess.Piece(pt, color): self.select_palette_piece(p))
+            btn.grid(row=1, column=i, padx=2, pady=2)
+            
+        # Trash / Delete
+        trash_btn = ctk.CTkButton(self.palette_frame, text="🗑", width=40, font=("Segoe UI Symbol", 20), fg_color="red", hover_color="darkred",
+                                  command=lambda: self.select_palette_piece(None))
+        trash_btn.grid(row=0, column=6, rowspan=2, padx=5, sticky="ns")
+
+    def select_palette_piece(self, piece):
+        self.board_ui.selected_edit_piece = piece
+
+    def toggle_edit_mode(self):
+        is_edit = self.edit_mode_var.get()
+        self.board_ui.edit_mode = is_edit
+        self.board_ui.selected_square = None # Clear selection
+        self.board_ui.draw_board()
+        
+        if is_edit:
+            self.palette_frame.grid()
+            self.status_label.configure(text="Edit Mode: Select piece to place")
+        else:
+            self.palette_frame.grid_remove()
+            self.status_label.configure(text="Edit Mode Disabled")
+            # Resume game logic state
+            turn_str = "White" if self.game_state.board.turn == chess.WHITE else "Black"
+            self.status_label.configure(text=f"Your Turn ({turn_str})")
+
+    def on_first_move_change(self, value):
+        """Handle first move color change."""
+        if self.edit_mode_var.get():
+             return # Do not reset if editing
+        self.reset_game()
+
+    def reset_game(self):
+        """Reset the game state based on current controls."""
+        self.game_state.reset()
+        
+        # Set turn based on First Move selection
+        first_move_color = chess.BLACK if self.first_move_var.get() == "Black" else chess.WHITE
+        self.game_state.board.turn = first_move_color
+        
+        play_as = self.play_as_var.get()
+        
+        if play_as == "Black":
+            # Flip board so black is at bottom
+            self.board_ui.flipped = True
+        else:
+            self.board_ui.flipped = False
+            
+        # Check if AI should move
+        ai_color = chess.WHITE if play_as == "Black" else chess.BLACK
+        
+        if self.game_state.board.turn == ai_color and not self.two_player_var.get():
+            self.status_label.configure(text="AI Thinking...")
+            threading.Thread(target=self.make_ai_move, daemon=True).start()
+        else:
+            turn_str = "White" if self.game_state.board.turn == chess.WHITE else "Black"
+            self.status_label.configure(text=f"Your Turn ({turn_str})")
+            
+        self.board_ui.draw_board()
+        
+    def on_best_moves_change(self, value):
+        """Handle best moves count change."""
+        if self.analysis_var.get():
+            self.update_analysis()
+
+    def update_analysis(self):
+        if not self.analysis_var.get():
+            return
+            
+        def _analyze():
+            fen = self.game_state.get_fen()
+            limit = int(self.best_moves_var.get()) if hasattr(self, 'best_moves_var') else 3
+            top_moves = self.engine.get_top_moves(fen, limit=limit)
+            self.after(0, lambda: self.display_analysis_results(top_moves))
+            
+        threading.Thread(target=_analyze, daemon=True).start()
+
+    def display_analysis_results(self, top_moves):
+        """Display analysis results with scores."""
+        if hasattr(self, 'board_ui') and self.board_ui:
+            self.board_ui.display_analysis(top_moves)
+        
+        # Update score label
+        if hasattr(self, 'score_label') and top_moves:
+            score_texts = []
+            found_mate = False
+            for i, move_data in enumerate(top_moves):
+                move = move_data["move"]
+                score = move_data["score"]
+                # Convert score to more readable format
+                if abs(score) >= 9000:
+                    # Mate score
+                    found_mate = True
+                    mate_in = (10000 - abs(score))
+                    score_str = f"M{mate_in}" if score > 0 else f"-M{mate_in}"
+                    
+                    if i == 0: # If top move is mate
+                         if score > 0:
+                             self.status_label.configure(text=f"White wins in {mate_in}!")
+                         else:
+                             self.status_label.configure(text=f"Black wins in {mate_in}!")
+                else:
+                    score_str = f"{score/100:+.2f}"
+                    
+                colors = ["🟢", "🔵", "🟡"]
+                score_texts.append(f"{colors[i]} {move}: {score_str}")
+            
+            self.score_label.configure(text="  |  ".join(score_texts))
+            
+            # If no mate found in top moves, ensure status doesn't stick (unless editing/thinking)
+            if not found_mate and not self.mirroring and not self.edit_mode_var.get() and "Thinking" not in self.status_label.cget("text"):
+                 # Restore turn status
+                 turn = "White" if self.game_state.board.turn == chess.WHITE else "Black"
+                 if self.two_player_var.get():
+                      self.status_label.configure(text=f"{turn}'s Turn")
+                 # Else AI turn text is handled by 'AI Thinking' or 'Your Turn'
+                 
+        elif hasattr(self, 'score_label'):
+            self.score_label.configure(text="")
+
+    def on_move_made(self, event=None):
+        # Check for game over
+        if self.game_state.is_game_over():
+            result = self.game_state.board.result()
+            self.status_label.configure(text=f"Game Over: {result}")
+            # Do NOT return here, we might still want to mirror the last move that caused game over?
+            # Actually if game is over, we still want to update UI.
+            # But let's act normal.
+            
+        # MIRROR LOGIC
+        if self.mirroring and event:
+             # Just made a move.
+             # The event might not carry the move info directly if it's a generic binding, 
+             # but we can get the last move from the board stack.
+             try:
+                 if self.game_state.board.move_stack:
+                     last_move = self.game_state.board.peek()
+                     # If it's a move made by the player (or AI if we want to mirror AI too)
+                     # For now, let's mirror ALL moves (Player and AI) so the external board stays in sync?
+                     # User said "whatever i move ... it will mirroe".
+                     # If AI moves on local board, user probably wants that on external board too if playing against external opponent?
+                     # OR if playing vs AI locally, and mirroring to analysis board.
+                     # Let's mirror everything.
+                     
+                     # Need to know if we are 'flipped' on the external board?
+                     # User selects one region. We assume it matches our orientation?
+                     # User request: "make the mirror doenst matter if i am black of white... it will mirror i move on the right"
+                     # This implies they want the Target Orientation to MATCH the Local Orientation.
+                     # If I am flipped (Black), Target is flipped (Black).
+                     is_flipped = getattr(self.board_ui, 'flipped', False)
+                     
+                     threading.Thread(target=self.mirror.execute_move, args=(last_move, self.mirror_region, is_flipped), daemon=True).start()
+             except Exception as e:
+                 print(f"Mirror error: {e}")
+
+        if self.analysis_var.get():
+            self.update_analysis()
+
+        # Check if two player mode
+        if self.two_player_var.get():
+            # Two player mode - just update turn indicator
+            turn = "White" if self.game_state.board.turn == chess.WHITE else "Black"
+            self.status_label.configure(text=f"{turn}'s Turn")
+        else:
+            # vs AI mode
+            if self.game_state.board.turn == chess.BLACK:
+                # Trigger AI move
+                if not self.edit_mode_var.get() and not self.two_player_var.get():
+                   self.status_label.configure(text="AI Thinking...")
+                   threading.Thread(target=self.make_ai_move, daemon=True).start()
+            else:
+                self.status_label.configure(text="Your Turn (White)")
+
+    def make_ai_move(self):
+        if self.edit_mode_var.get():
+            return
+            
+        # AI plays best move
+        best_move = self.engine.get_best_move(self.game_state.get_fen())
+        if best_move:
+            self.game_state.board.push(best_move)
+            self.after(0, self.update_board_after_ai)
+        else:
+            self.after(0, lambda: self.status_label.configure(text="Engine Error"))
+
+    def update_board_after_ai(self):
+        self.board_ui.draw_board()
+        self.status_label.configure(text="Your Turn")
+        
+        if self.analysis_var.get():
+            self.update_analysis()
+            
+        if self.game_state.is_game_over():
+            self.status_label.configure(text=f"Game Over: {self.game_state.board.result()}")
+            
+    def force_ai_move(self):
+        """Force the AI to make a move for the current side."""
+        if self.game_state.is_game_over():
+            return
+            
+        self.status_label.configure(text="Forcing AI Move...")
+        threading.Thread(target=self.make_ai_move, daemon=True).start()

src/mirror.py

@@ -0,0 +1,95 @@
+import pyautogui
+import chess
+import time
+import math
+
+class MirrorHandler:
+    def __init__(self):
+        # Configure pyautogui to be a bit safer/slower if needed
+        pyautogui.FAILSAFE = True
+        pyautogui.PAUSE = 0.1
+
+    def execute_move(self, move, region, is_flipped=False):
+        """
+        Execute a chess move on the screen region using mouse drag.
+        
+        Args:
+            move (chess.Move): The move to execute.
+            region (dict): {'left', 'top', 'width', 'height'} of the target board.
+            is_flipped (bool): If True, board is viewed from Black's perspective (rank 1 at top).
+        """
+        if not region or not move:
+            return
+
+        start_sq = move.from_square
+        end_sq = move.to_square
+
+        # Calculate coordinates
+        start_x, start_y = self._get_square_center(start_sq, region, is_flipped)
+        end_x, end_y = self._get_square_center(end_sq, region, is_flipped)
+
+        # Save current position to restore later? 
+        # Actually user said "just use my mouse", implies they expect it to take over.
+        # But maybe restoring it is nice? Let's just do the move for now.
+
+        # Perform the drag
+        # Move to start
+        pyautogui.moveTo(start_x, start_y)
+        # Drag to end
+        pyautogui.dragTo(end_x, end_y, button='left')
+        
+        # Check for promotion
+        if move.promotion:
+            # Assumes auto-queen or standard promotion UI (usually Queen is closest/first)
+            # This is tricky for generic sites. 
+            # Often, clicking the target square again acts as "Question" or immediate select.
+            # For now, let's just click the target square again to select Queen if it pops up.
+            time.sleep(0.1)
+            pyautogui.click() 
+
+    def _get_square_center(self, square, region, is_flipped):
+        """
+        Calculate center x, y for a given square index (0-63).
+        """
+        file_idx = chess.square_file(square)
+        rank_idx = chess.square_rank(square)
+
+        if is_flipped:
+            # Board is black options (rank 8 at bottom? Wait.)
+            # Standard: White at bottom (Rank 0 is bottom).
+            # Flipped: Black at bottom (Rank 7 is bottom, Rank 0 is top).
+            
+            # If Flipped (Black at bottom):
+            # File 0 (a) is on the Right? No, usually board just rotates 180.
+            # Visual:
+            # White bottom: a1 bottom-left.
+            # Black bottom: h8 bottom-left.
+            
+            # Let's assume Standard Rotation (180 degrees):
+            # a1 (0,0) becomes top-right.
+            # h8 (7,7) becomes bottom-left.
+            
+            # Let's map visual col/row (0-7 from top-left)
+            # Normal:
+            # col = file_idx
+            # row = 7 - rank_idx
+            
+            # Flipped:
+            # col = 7 - file_idx
+            # row = rank_idx
+            
+            col = 7 - file_idx
+            row = rank_idx
+        else:
+            # Standard (White at bottom)
+            # a1 is bottom-left
+            col = file_idx
+            row = 7 - rank_idx
+
+        sq_w = region['width'] / 8
+        sq_h = region['height'] / 8
+
+        center_x = region['left'] + (col * sq_w) + (sq_w / 2)
+        center_y = region['top'] + (row * sq_h) + (sq_h / 2)
+
+        return center_x, center_y

src/overlay.py

@@ -0,0 +1,137 @@
+import customtkinter as ctk
+import tkinter as tk
+import chess
+import win32gui
+import win32con
+import win32api
+
+class SelectionOverlay(ctk.CTkToplevel):
+    def __init__(self, master, on_select_callback):
+        super().__init__(master)
+        
+        self.on_select_callback = on_select_callback
+        
+        self.attributes("-alpha", 0.3)
+        self.attributes("-fullscreen", True)
+        self.attributes("-topmost", True)
+        self.configure(bg="black")
+        
+        self.start_x = None
+        self.start_y = None
+        self.rect = None
+        
+        self.canvas = ctk.CTkCanvas(self, cursor="cross", bg="grey15", highlightthickness=0)
+        self.canvas.pack(fill="both", expand=True)
+        
+        self.canvas.bind("<ButtonPress-1>", self.on_press)
+        self.canvas.bind("<B1-Motion>", self.on_drag)
+        self.canvas.bind("<ButtonRelease-1>", self.on_release)
+        
+        # Exit on Escape
+        self.bind("<Escape>", lambda e: self.destroy())
+
+    def on_press(self, event):
+        self.start_x = event.x
+        self.start_y = event.y
+        if self.rect:
+            self.canvas.delete(self.rect)
+        self.rect = self.canvas.create_rectangle(self.start_x, self.start_y, self.start_x, self.start_y, outline="red", width=2)
+
+    def on_drag(self, event):
+        cur_x, cur_y = (event.x, event.y)
+        self.canvas.coords(self.rect, self.start_x, self.start_y, cur_x, cur_y)
+
+    def on_release(self, event):
+        end_x, end_y = (event.x, event.y)
+        
+        # Calculate region
+        left = min(self.start_x, end_x)
+        top = min(self.start_y, end_y)
+        width = abs(self.start_x - end_x)
+        height = abs(self.start_y - end_y)
+        
+        if width > 50 and height > 50:
+            self.on_select_callback({'left': left, 'top': top, 'width': width, 'height': height})
+            self.destroy()
+        else:
+            # Too small, just reset
+            pass
+
+class ProjectionOverlay(ctk.CTkToplevel):
+    def __init__(self, region):
+        """
+        region: {'left': int, 'top': int, 'width': int, 'height': int}
+        """
+        super().__init__()
+        
+        self.region = region
+        # Position exactly over the board
+        self.geometry(f"{region['width']}x{region['height']}+{region['left']}+{region['top']}")
+        
+        # Remove title bar
+        self.overrideredirect(True)
+        self.attributes("-topmost", True)
+        
+        # Transparency setup for Windows
+        # We use a specific color as the transparent key.
+        self.transparent_color = "#000001" # Very nearly black
+        self.configure(bg=self.transparent_color)
+        self.wm_attributes("-transparentcolor", self.transparent_color)
+        
+        # Canvas for drawing
+        self.canvas = tk.Canvas(self, bg=self.transparent_color, highlightthickness=0)
+        self.canvas.pack(fill="both", expand=True)
+        
+        # Make click-through
+        self.make_click_through()
+        
+    def make_click_through(self):
+        hwnd = win32gui.GetParent(self.winfo_id())
+        # If GetParent returns 0, try the window id directly (sometimes needed for Toplevels without parents)
+        if hwnd == 0:
+            hwnd = self.winfo_id()
+            
+        styles = win32gui.GetWindowLong(hwnd, win32con.GWL_EXSTYLE)
+        styles = styles | win32con.WS_EX_LAYERED | win32con.WS_EX_TRANSPARENT
+        win32gui.SetWindowLong(hwnd, win32con.GWL_EXSTYLE, styles)
+        
+    def draw_best_move(self, move):
+        """
+        Draw an arrow for the best move.
+        move: python-chess Move object (e.g. e2e4)
+        """
+        self.canvas.delete("all")
+        
+        if not move:
+            return
+
+        # Calculate coordinates
+        # File 0-7 (a-h), Rank 0-7 (1-8)
+        # 0,0 is bottom-left (a1)
+        
+        sq_w = self.region['width'] / 8
+        sq_h = self.region['height'] / 8
+        
+        start_sq = move.from_square
+        end_sq = move.to_square
+        
+        # Convert to x,y (top-left origin for drawing)
+        # File (x) is same
+        # Rank (y) needs flip: Rank 0 is at bottom (y moves down) -> Rank 7 is top (y=0)
+        # Rank r -> visual row (7-r)
+        
+        x1 = (chess.square_file(start_sq) + 0.5) * sq_w
+        y1 = ((7 - chess.square_rank(start_sq)) + 0.5) * sq_h
+        
+        x2 = (chess.square_file(end_sq) + 0.5) * sq_w
+        y2 = ((7 - chess.square_rank(end_sq)) + 0.5) * sq_h
+        
+        # Draw Arrow
+        self.canvas.create_line(x1, y1, x2, y2, fill="#00ff00", width=6, arrow=tk.LAST, arrowshape=(16, 20, 6), tag="arrow")
+        
+        # Draw Circle on target
+        r = min(sq_w, sq_h) * 0.2
+        self.canvas.create_oval(x2-r, y2-r, x2+r, y2+r, outline="#00ff00", width=4, tag="arrow")
+
+    def clear(self):
+        self.canvas.delete("all")

src/vision.py

@@ -0,0 +1,182 @@
+import cv2
+import numpy as np
+import mss
+
+class VisionHandler:
+    def __init__(self):
+        self.templates = {}
+        self.is_calibrated = False
+
+    def capture_screen(self, region):
+        """
+        Capture a specific region of the screen.
+        region: {'top': int, 'left': int, 'width': int, 'height': int}
+        """
+        with mss.mss() as sct:
+            # mss requires int for all values
+            monitor = {
+                "top": int(region["top"]),
+                "left": int(region["left"]),
+                "width": int(region["width"]),
+                "height": int(region["height"])
+            }
+            screenshot = sct.grab(monitor)
+            img = np.array(screenshot)
+            return cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+
+    def split_board(self, board_image):
+        """
+        Split board image into 64 squares.
+        Assumption: board_image is cropped exactly to the board edges.
+        """
+        h, w, _ = board_image.shape
+        sq_h, sq_w = h // 8, w // 8
+        squares = []
+        # Row-major order (rank 8 down to rank 1)
+        # Standard FEN order: Rank 8 (index 0) to Rank 1 (index 7)
+        for r in range(8):
+            row_squares = []
+            for c in range(8):
+                # Add a small crop margin to avoid border noise
+                margin_h = int(sq_h * 0.1)
+                margin_w = int(sq_w * 0.1)
+                
+                y1 = r * sq_h + margin_h
+                y2 = (r + 1) * sq_h - margin_h
+                x1 = c * sq_w + margin_w
+                x2 = (c + 1) * sq_w - margin_w
+                
+                square = board_image[y1:y2, x1:x2]
+                row_squares.append(square)
+            squares.append(row_squares)
+        return squares
+
+    def calibrate(self, board_image):
+        """
+        Calibrate by learning piece appearance from a starting position board image.
+        Standard Starting Position:
+        r n b q k b n r
+        p p p p p p p p
+        . . . . . . . .
+        . . . . . . . .
+        . . . . . . . .
+        . . . . . . . .
+        P P P P P P P P
+        R N B Q K B N R
+        """
+        squares = self.split_board(board_image)
+        self.templates = {}
+
+        # Dictionary mapping piece chars to list of coordinates (row, col) in start pos
+        # We'll take the average or just the first instance as template
+        # 0-indexed rows: 0=BlackBack, 1=BlackPawn, ... 6=WhitePawn, 7=WhiteBack
+        
+        piece_map = {
+            'r': [(0, 0), (0, 7)],
+            'n': [(0, 1), (0, 6)],
+            'b': [(0, 2), (0, 5)],
+            'q': [(0, 3)],
+            'k': [(0, 4)],
+            'p': [(1, i) for i in range(8)],
+            'R': [(7, 0), (7, 7)],
+            'N': [(7, 1), (7, 6)],
+            'B': [(7, 2), (7, 5)],
+            'Q': [(7, 3)],
+            'K': [(7, 4)],
+            'P': [(6, i) for i in range(8)],
+            '.': [] # Empty squares
+        }
+        
+        # Add empty squares (rows 2, 3, 4, 5)
+        for r in range(2, 6):
+            for c in range(8):
+                piece_map['.'].append((r, c))
+
+        # Store one template per piece type (simplest approach)
+        # Better: Store all samples and use KNN, but simple template match might suffice for consistent graphics
+        
+        for p_char, coords in piece_map.items():
+            if not coords:
+                continue
+            
+            # Use the first coordinate as the primary template
+            r, c = coords[0]
+            template = squares[r][c]
+            
+            # We convert to grayscale for simpler matching
+            gray_template = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
+            
+            # Store just one template for now
+            self.templates[p_char] = gray_template
+
+        self.is_calibrated = True
+        print("Calibration complete.")
+
+    def match_square(self, square_img):
+        if not self.templates:
+            return '.'
+            
+        gray_sq = cv2.cvtColor(square_img, cv2.COLOR_BGR2GRAY)
+        
+        best_score = float('inf')
+        best_piece = '.'
+        
+        # Compare against all templates using MSE
+        # Note: Templates must be same size. If slightly different due to rounding, resize.
+        
+        target_h, target_w = gray_sq.shape
+        
+        for p_char, template in self.templates.items():
+            # Resize template to match square if needed (should be identical if grid is uniform)
+            if template.shape != gray_sq.shape:
+                template = cv2.resize(template, (target_w, target_h))
+                
+            # Mean Squared Error
+            err = np.sum((gray_sq.astype("float") - template.astype("float")) ** 2)
+            err /= float(gray_sq.shape[0] * gray_sq.shape[1])
+            
+            if err < best_score:
+                best_score = err
+                best_piece = p_char
+                
+        return best_piece
+
+    def get_fen_from_image(self, board_image):
+        if not self.is_calibrated:
+            # Fallback or error
+            return None
+        
+        squares = self.split_board(board_image)
+        fen_rows = []
+        
+        for r in range(8):
+            empty_count = 0
+            row_str = ""
+            for c in range(8):
+                piece = self.match_square(squares[r][c])
+                
+                if piece == '.':
+                    empty_count += 1
+                else:
+                    if empty_count > 0:
+                        row_str += str(empty_count)
+                        empty_count = 0
+                    row_str += piece
+            
+            if empty_count > 0:
+                row_str += str(empty_count)
+            
+            fen_rows.append(row_str)
+            
+        # Join with '/'
+        fen_board = "/".join(fen_rows)
+        
+        # Add default game state info (w KQkq - 0 1)
+        # TODO: Detect turn based on external logic or diff? 
+        # For now, we might alternate or assume it's always the user's turn to move? 
+        # Actually, if we are just showing analysis, we want the engine to evaluate for the SIDE TO MOVE.
+        # But we don't know who is to move just from the static board.
+        # We can try to infer from previous state or just ask the user.
+        # For this version, let's return the board part, and handle the rest in logic.
+        
+        return f"{fen_board} w KQkq - 0 1"

tests/test_engine.py

@@ -0,0 +1,31 @@
+import sys
+import os
+import unittest
+
+# Add src to path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from src.engine import EngineHandler
+from src.game_state import GameState
+
+class TestChessLogic(unittest.TestCase):
+    def test_game_state_init(self):
+        gs = GameState()
+        self.assertEqual(gs.get_fen(), "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
+
+    def test_make_move(self):
+        gs = GameState()
+        # e2e4
+        success = gs.make_move("e2e4")
+        self.assertTrue(success)
+        self.assertNotEqual(gs.get_fen(), "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")
+
+    def test_engine_missing(self):
+        # Should handle missing engine gracefully
+        engine = EngineHandler("non_existent_stockfish.exe")
+        success, msg = engine.initialize_engine()
+        self.assertFalse(success)
+        self.assertIn("not found", msg)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_engine_manual.py

@@ -0,0 +1,37 @@
+
+import sys
+import os
+
+# Add src to path
+sys.path.append(os.path.join(os.getcwd()))
+
+from src.engine import EngineHandler
+
+def test_engine():
+    print("Testing EngineHandler...")
+    engine = EngineHandler()
+    success, msg = engine.initialize_engine()
+    
+    if not success:
+        print(f"FAILED: {msg}")
+        return
+
+    print(f"SUCCESS: {msg}")
+    
+    # Test FEN (Start Position)
+    fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+    
+    print("\nTesting get_top_moves(limit=3)...")
+    top_moves = engine.get_top_moves(fen, limit=3)
+    
+    if len(top_moves) == 0:
+        print("FAILED: No moves returned. (Check stockfish path?)")
+    else:
+        print(f"SUCCESS: Returned {len(top_moves)} moves.")
+        for m in top_moves:
+            print(f"Rank {m['rank']}: {m['move']} (Score: {m['score']})")
+    
+    engine.quit()
+
+if __name__ == "__main__":
+    test_engine()

tests/test_mirror.py

@@ -0,0 +1,56 @@
+import unittest
+import chess
+from src.mirror import MirrorHandler
+
+class TestMirrorLogic(unittest.TestCase):
+    def setUp(self):
+        self.mirror = MirrorHandler()
+        self.region = {'left': 100, 'top': 100, 'width': 800, 'height': 800}
+
+    def test_coordinate_mapping_standard(self):
+        # Test a1 (start square)
+        # Standard: a1 is bottom-left (0,0) in cartesian, but for screen pixels:
+        # col 0, row 7 (since y increases downwards)
+        # region top=100. height=800. square height=100.
+        # row 7 y range: 100 + 700 = 800 to 900. Center = 850.
+        # col 0 x range: 100 + 0 = 100 to 200. Center = 150.
+        
+        sq = chess.A1
+        x, y = self.mirror._get_square_center(sq, self.region, is_flipped=False)
+        self.assertEqual(x, 150)
+        self.assertEqual(y, 850)
+        
+        # Test h8 (top-right)
+        # col 7, row 0
+        # x: 100 + 700 + 50 = 850
+        # y: 100 + 0 + 50 = 150
+        sq = chess.H8
+        x, y = self.mirror._get_square_center(sq, self.region, is_flipped=False)
+        self.assertEqual(x, 850)
+        self.assertEqual(y, 150)
+
+    def test_coordinate_mapping_flipped(self):
+        # Flipped: Black at bottom.
+        # a1 (0,0) becomes top-right?
+        # Let's re-verify logic:
+        # Flipped: col = 7 - file_idx, row = rank_idx
+        
+        # a1: file 0, rank 0
+        # col = 7, row = 0
+        # x: 850, y: 150 (Top-Right) -> Correct for rotated 180.
+        
+        sq = chess.A1
+        x, y = self.mirror._get_square_center(sq, self.region, is_flipped=True)
+        self.assertEqual(x, 850)
+        self.assertEqual(y, 150)
+        
+        # h8: file 7, rank 7
+        # col = 0, row = 7
+        # x: 150, y: 850 (Bottom-Left)
+        sq = chess.H8
+        x, y = self.mirror._get_square_center(sq, self.region, is_flipped=True)
+        self.assertEqual(x, 150)
+        self.assertEqual(y, 850)
+
+if __name__ == '__main__':
+    unittest.main()