Main

  1"""Main file of Chess game entirely made in python with properly working game engine. Contains a lot of customization option for user.
  2App allows using custom assets, fonts and colors. Comes with easy to use menu to change the properties and readable config file.
  3
  4Libraries used: 
  5 - customtkinter
  6 - threading
  7 - os
  8 - sys
  9 - platform
 10 - configparser
 11 - Pillow [PIL]
 12 - re [regex]
 13 - fontTools
 14 - subprocess
 15 - pywinstyles
 16 - built in libraries
 17 - sounddevice
 18 - soundfile
 19
 20Link to full documentation: http://chessdocumentation.ct.ws/
 21"""
 22
 23import customtkinter as ctk
 24import os
 25import threading
 26from concurrent.futures import ThreadPoolExecutor
 27
 28from tools import resource_path, get_from_config
 29from properties import COLOR, SYSTEM
 30from menus import MovesRecord, Options
 31from board import Board
 32
 33class MainWindow(ctk.CTk):
 34    """Main class handling the app. Setting size, minimum size, font loading, icon setting,
 35    updating font, updating assets and restarting the game all happens here.
 36
 37    Args:
 38        ctk.CTk : Main app window of customtkinter library (master).
 39    """
 40    def __init__(self) -> None:
 41        """Constructor for the MainWindow class: 
 42             - sets title
 43             - sets geometry
 44             - sets minimum size of the window
 45             - loads font
 46             - Creates instances of the classes:
 47              - MoveRecord
 48              - Options
 49              - Board
 50             - loads theme of the app from the config: get_from_config
 51        """
 52        super().__init__(fg_color=COLOR.BACKGROUND)
 53        self.title('Chess')
 54        self.geometry(self.set_window_size())
 55        size: int = int(get_from_config('size'))
 56        self.minsize(((size + 2) * 10 + 40)+ 400, ((size + 2) * 10 + 40))
 57        self.load_font()
 58        self.moves_record: MovesRecord = MovesRecord(self)
 59        self.moves_record.pack(side=ctk.RIGHT, padx=10, pady=10, fill=ctk.Y)
 60        self.options: Options = Options(self, self.restart_game, self.update_assets, self.update_font, self.get_board)
 61        self.options.pack(side=ctk.LEFT, padx=10, pady=10, fill=ctk.Y)
 62        self.board: Board = Board(self, self.moves_record, size)
 63        self.theme: str = str(get_from_config('theme'))
 64        self.set_icon()
 65
 66    def load_font(self) -> None:
 67        """Function loads font independently on the users operating system.
 68        """
 69        font: str = str(get_from_config('font_file_name'))
 70        if SYSTEM == 'Windows':
 71            ctk.FontManager.windows_load_font(resource_path(os.path.join('fonts', font)))
 72        else:
 73            ctk.FontManager.load_font(resource_path(os.path.join('fonts', font)))
 74
 75    def set_icon(self) -> None:
 76        """Only for windows machines logo icon will be set due to lack of implementation for linux and mac.
 77        """
 78        if SYSTEM == 'Windows':
 79            self.iconbitmap(resource_path(os.path.join('assets', 'logo.ico')))
 80
 81    def set_window_size(self) -> str:
 82        """Calculates the size necessary to display all elements of the app on the screen.
 83
 84        Returns:
 85            str: f'{width}x{height]}' because customtkinter uses f'{width}x{height]}' to set the size of the window.
 86        """
 87        size: int = int(get_from_config('size'))
 88        size = (size+2) * 10 + 40
 89        center_pos: str = f'+{(self.winfo_screenwidth()-(int(size*1.5)))//2}+{(self.winfo_screenheight()-(int(size)*1.1))//2}'
 90        return f'{size + 300}x{size}{center_pos}'
 91
 92    def restart_game(self) -> None:
 93        """Helper function for game restart just by calling functions from Board and MoveRecord classes.
 94        """
 95        self.board.restart_game()
 96        self.moves_record.restart()
 97
 98    def update_assets(self) -> None:
 99        """Updates asset on the Board using thread to avoid window freezing.
100        """
101        for row in self.board.board:
102            for cell in row:
103                if cell.figure:
104                    threading.Thread(target=cell.figure.update_image).start()
105
106    def get_board(self) -> Board:
107        """Getter for board object.
108
109        Returns:
110            Board: Board object.
111        """
112        return self.board
113
114    def update_font(self, widget=None) -> None:
115        """Helper function updating the font during app runtime without freezing the window.
116
117        Args:
118            widget (Any, optional): Child of the widget. Defaults to None as master widget doesn't have any parents.
119        """
120        if widget is None:
121            widget = self
122            self.load_font()
123        def thread_task():
124            widgets = []
125            queue = [widget]
126            while queue:
127                current_widget = queue.pop()
128                widgets.append(current_widget)
129                queue.extend(current_widget.winfo_children())
130            with ThreadPoolExecutor() as executor:
131                for child in widgets:
132                    if isinstance(child, ctk.CTkLabel | ctk.CTkButton):
133                        size = child.cget('font').cget('size')
134                        executor.submit(self.__update_font_on_main_thread, child, size)
135        threading.Thread(target=thread_task, daemon=True).start()
136
137    def __update_font_on_main_thread(self, widget, size: int) -> None:
138        self.after(0, lambda: widget.configure(font=ctk.CTkFont(get_from_config('font_name'), size)))
139
140if __name__ == "__main__":
141    ctk.deactivate_automatic_dpi_awareness()
142    app = MainWindow()
143    app.mainloop()