Merge pull request #374 from sahilrw/chess-game

Chess game

GAMES/chess/src/color.py

@@ -0,0 +1,4 @@
+class Color:
+    def __init__(self, light, dark):
+        self.light = light
+        self.dark = dark

GAMES/chess/src/config.py

@@ -0,0 +1,60 @@
+import pygame
+import os
+
+from sound import Sound
+from theme import Theme
+
+
+class Config:
+    def __init__(self):
+        # themes code
+        self.themes = []
+        self._add_themes()
+        self.idx = 0
+        self.theme = self.themes[self.idx]
+        # font
+        self.font = pygame.font.SysFont("monospace", 18, bold=True)
+        # sound file path
+        self.move_sound = Sound(os.path.join("assets/sounds/move.wav"))
+        self.capture_sound = Sound(os.path.join("assets/sounds/capture.wav"))
+
+    def change_theme(self):
+        self.idx += 1
+        self.idx %= len(self.themes)
+        self.theme = self.themes[self.idx]
+
+    def _add_themes(self):
+        green = Theme(
+            (234, 235, 200),
+            (119, 154, 88),
+            (244, 247, 116),
+            (172, 195, 51),
+            "#C86464",
+            "#C84646",
+        )
+        brown = Theme(
+            (235, 209, 166),
+            (165, 117, 80),
+            (245, 234, 100),
+            (209, 185, 59),
+            "#C86464",
+            "#C84646",
+        )
+        blue = Theme(
+            (229, 228, 200),
+            (60, 95, 135),
+            (124, 187, 227),
+            (43, 119, 191),
+            "#C86464",
+            "#C84646",
+        )
+        gray = Theme(
+            (128, 119, 118),
+            (86, 85, 84),
+            (99, 126, 143),
+            (82, 102, 128),
+            "#C86464",
+            "#C84646",
+        )
+
+        self.themes = [green, brown, blue, gray]

GAMES/chess/src/const.py

@@ -0,0 +1,8 @@
+# Screen dimensions
+WIDTH = 700
+HEIGHT = 700
+
+# Board dimensions
+ROWS = 8
+COLS = 8
+SQSIZE = WIDTH // COLS

GAMES/chess/src/dragger.py

@@ -0,0 +1,46 @@
+import pygame
+
+from const import *
+
+
+class Dragger:
+    def __init__(self):
+        self.piece = None
+        self.dragging = False
+        self.mouseX = 0
+        self.mouseY = 0
+        self.initial_row = 0
+        self.initial_col = 0
+
+    # blit method
+
+    def update_blit(self, surface):
+        # texture
+        self.piece.set_texture(size=80)
+        texture = self.piece.texture
+        # image
+        img = pygame.image.load(texture)
+
+        # drag coordinates
+        img_center = (self.mouseX, self.mouseY)
+        self.piece.texture_rect = img.get_rect(center=img_center)
+
+        # update blit
+        surface.blit(img, self.piece.texture_rect)
+
+    # other dragging methods
+
+    def update_mouse(self, pos):
+        self.mouseX, self.mouseY = pos
+
+    def save_initial(self, pos):
+        self.initial_row = pos[1] // SQSIZE
+        self.initial_col = pos[0] // SQSIZE
+
+    def drag_piece(self, piece):
+        self.piece = piece
+        self.dragging = True
+
+    def undrag_piece(self):
+        self.piece = None
+        self.dragging = False

GAMES/chess/src/game.py

@@ -0,0 +1,150 @@
+import pygame
+
+from const import *
+from board import Board
+from dragger import Dragger
+from config import Config
+from square import Square
+
+
+class Game:
+    def __init__(self):
+        self.next_player = "white"
+        self.hovered_sqr = None
+        self.board = Board()
+        self.dragger = Dragger()
+        self.config = Config()
+
+    # background display
+    def show_bg(self, surface):
+        theme = self.config.theme
+
+        for row in range(ROWS):
+            for col in range(COLS):
+                # color
+                color = theme.bg.light if (row + col) % 2 == 0 else theme.bg.dark
+                # rect
+                rect = (col * SQSIZE, row * SQSIZE, SQSIZE, SQSIZE)
+                # blit
+                pygame.draw.rect(surface, color, rect)
+
+                # row coordinates
+                if col == 0:
+                    # color
+                    color = theme.bg.dark if row % 2 == 0 else theme.bg.light
+                    # label
+                    lbl = self.config.font.render(str(ROWS - row), 1, color)
+                    lbl_pos = (5, 5 + row * SQSIZE)
+                    # blit
+                    surface.blit(lbl, lbl_pos)
+
+                # col coordinates
+                if row == 7:
+                    # color
+                    color = theme.bg.dark if (row + col) % 2 == 0 else theme.bg.light
+                    # label
+                    lbl = self.config.font.render(Square.get_alphacol(col), 1, color)
+                    lbl_pos = (col * SQSIZE + SQSIZE - 20, HEIGHT - 20)
+                    # blit
+                    surface.blit(lbl, lbl_pos)
+
+    def show_pieces(self, surface):
+        for row in range(ROWS):
+            for col in range(COLS):
+                if self.board.squares[row][col].has_piece():
+                    piece = self.board.squares[row][col].piece
+                    if piece is not self.dragger.piece:
+                        piece.set_texture(size=80)
+                        img = pygame.image.load(piece.texture)
+                        img_center = (
+                            col * SQSIZE + SQSIZE // 2,
+                            row * SQSIZE + SQSIZE // 2,
+                        )
+                        piece.texture_rect = img.get_rect(center=img_center)
+                        surface.blit(img, piece.texture_rect)
+
+    def show_moves(self, surface):
+        theme = self.config.theme
+        if self.dragger.dragging:
+            piece = self.dragger.piece
+
+            # loop all valid moves
+            for move in piece.moves:
+                # color
+                color = (
+                    theme.moves.light
+                    if (move.final.row + move.final.col) % 2 == 0
+                    else theme.moves.dark
+                )
+                # rect
+                rect = (
+                    move.final.col * SQSIZE,
+                    move.final.row * SQSIZE,
+                    SQSIZE,
+                    SQSIZE,
+                )
+                # blit
+                pygame.draw.rect(surface, color, rect)
+
+                # circle
+                # center_x = move.final.col * SQSIZE + SQSIZE // 2
+                # center_y = move.final.row * SQSIZE + SQSIZE // 2
+                # radius = SQSIZE // 6
+                # blit
+                # pygame.draw.circle(surface, color, (center_x, center_y), radius)
+
+    def show_last_move(self, surface):
+        theme = self.config.theme
+
+        if self.board.last_move:
+            initial = self.board.last_move.initial
+            final = self.board.last_move.final
+
+            for pos in [initial, final]:
+                # color
+                color = (
+                    theme.trace.light
+                    if (pos.row + pos.col) % 2 == 0
+                    else theme.trace.dark
+                )
+                # rect
+                rect = (pos.col * SQSIZE, pos.row * SQSIZE, SQSIZE, SQSIZE)
+                # blit
+                pygame.draw.rect(surface, color, rect)
+
+    def show_hover(self, surface):
+        if self.hovered_sqr:
+            # color
+            color = (180, 180, 180)
+            # rect
+            rect = (
+                self.hovered_sqr.col * SQSIZE,
+                self.hovered_sqr.row * SQSIZE,
+                SQSIZE,
+                SQSIZE,
+            )
+            # blit
+            pygame.draw.rect(surface, color, rect, width=3)
+
+    def next_turn(self):
+        self.next_player = "white" if self.next_player == "black" else "black"
+
+    def set_hover(self, row, col):
+        if 0 <= row < ROWS and 0 <= col < COLS:
+            self.hovered_sqr = self.board.squares[row][col]
+        else:
+            # Handle the case where the indices are out of range
+            # print(f"Invalid indices: row={row}, col={col}")
+            self.hovered_sqr = None
+
+    def change_theme(self):
+        self.config.change_theme()
+
+    def play_sound(self, captured=False):
+        if captured:
+            self.config.capture_sound.play()
+        else:
+            self.config.move_sound.play()
+
+    def reset(self):
+        self.__init__()

GAMES/chess/src/main.py

@@ -0,0 +1,126 @@
+import pygame
+import sys
+
+from const import *
+from game import Game
+from square import Square
+from move import Move
+
+
+class Main:
+    def __init__(self):
+        pygame.init()
+        self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
+        pygame.display.set_caption("Chess")
+        self.game = Game()
+
+    def mainloop(self):
+        screen = self.screen
+        game = self.game
+        board = self.game.board
+        dragger = self.game.dragger
+
+        while True:
+            # display methods
+            game.show_bg(screen)
+            game.show_last_move(screen)
+            game.show_moves(screen)
+            game.show_pieces(screen)
+
+            game.show_hover(screen)
+
+            if dragger.dragging:
+                dragger.update_blit(screen)
+
+            for event in pygame.event.get():
+                # click
+                if event.type == pygame.MOUSEBUTTONDOWN:
+                    dragger.update_mouse(event.pos)
+                    # print(event.pos)
+
+                    clicked_row = dragger.mouseY // SQSIZE
+                    clicked_col = dragger.mouseX // SQSIZE
+
+                    # print(dragger.mouseY, clicked_row)
+                    # print(dragger.mouseX, clicked_col)
+
+                    # if clicked square has a piece
+                    if board.squares[clicked_row][clicked_col].has_piece():
+                        piece = board.squares[clicked_row][clicked_col].piece
+                        if piece.color == game.next_player:
+                            board.calc_moves(piece, clicked_row, clicked_col, bool=True)
+                            dragger.save_initial(event.pos)
+                            dragger.drag_piece(piece)
+                            # display methods
+                            game.show_bg(screen)
+                            game.show_last_move(screen)
+                            game.show_moves(screen)
+                            game.show_pieces(screen)
+
+                # dragging the pieces
+                elif event.type == pygame.MOUSEMOTION:
+                    motion_row = event.pos[1] // SQSIZE
+                    motion_col = event.pos[0] // SQSIZE
+                    game.set_hover(motion_row, motion_col)
+                    if dragger.dragging:
+                        dragger.update_mouse(event.pos)
+                        # display methods
+                        game.show_bg(screen)
+                        game.show_last_move(screen)
+                        game.show_moves(screen)
+                        game.show_pieces(screen)
+                        game.show_hover(screen)
+                        dragger.update_blit(screen)
+
+                # mouse release
+                elif event.type == pygame.MOUSEBUTTONUP:
+                    if dragger.dragging:
+                        dragger.update_mouse(event.pos)
+                        released_row = dragger.mouseY // SQSIZE
+                        released_col = dragger.mouseX // SQSIZE
+
+                        initial = Square(dragger.initial_row, dragger.initial_col)
+                        final = Square(released_row, released_col)
+                        move = Move(initial, final)
+
+                        if board.valid_move(dragger.piece, move):
+                            captured = board.squares[released_row][
+                                released_col
+                            ].has_piece()
+
+                            board.move(dragger.piece, move)
+                            board.set_true_en_passant(dragger.piece)
+                            game.play_sound(captured)
+                            # display move methods
+                            game.show_bg(screen)
+                            game.show_last_move(screen)
+                            game.show_pieces(screen)
+
+                            # next turn
+                            game.next_turn()
+
+                    dragger.undrag_piece()
+
+                # key press
+                elif event.type == pygame.KEYDOWN:
+                    # change themes
+                    if event.key == pygame.K_t:
+                        game.change_theme()
+
+                    # restart event
+                    if event.key == pygame.K_r:
+                        game.reset()
+                        game = self.game
+                        board = self.game.board
+                        dragger = self.game.dragger
+
+                # quit application
+                elif event.type == pygame.QUIT:
+                    pygame.quit()
+                    sys.exit()
+
+            pygame.display.update()
+
+
+main = Main()
+main.mainloop()