CHAPTER 1

1
 Chapter 1. Introduction

1.1 Brief Description:

The project ‘CHESS MASTER’ implements a classic version of chess with a
graphical user interface (GUI). The game of chess follows the basic rules of
chess, and all chess pieces move only according to the moves allowed for that
piece. Chess is played for two players. It is played on an 8x8 checkered board,
with each player having a dark square in the lower left corner.
I have successfully created a GUI using text-based versioning, inheritance and
templates as specified. Despite several unusual bugs in the GUI, My Chess
Program is a nice, user-friendly game for two players and also for single player
against Artificial Intelligence.
1.2 Does chess have a game?
Chess is a game played by 2 people on a chessboard with 16 pieces each. My
project implements a chess game with a graphical user interface. The game of
chess follows the basic rules of chess and all chess pieces move only according
to the moves allowed for that piece. My implementation of chess is for two
players and also for single player against Artificial Intelligence. It is played on
an 8*8 checkered board.

1.3 Keywords:
Chess, hierarchy, templates, GUI, inheritance, Artificial Intelligence,MinMax
Searching, Alpha-beta Pruning, Python.

2
CHAPTER 2

3
 Chapter 2. Proposed Objective

This project implements a classic version of Chess using Python and a graphical user
interface. The game of chess follows the basic rules of chess, and all chess pieces move
only according to the moves allowed for that piece. My implementation of chess is for
two players. It is played on an 8x8 checkered board, with each player having a dark
square in the lower left corner.

2.1 Goals of my project:

• Develop a user-friendly chess game interface.
• Implement chess logic using a custom chess engine.
• Allow players to make moves by clicking on a graphical chessboard.
• Give visual feedback on valid moves and highlight the last move.
• Enable undo functionality to correct player moves.
• Implement checkmate and deadlock conditions, declare winner accordingly.
• Implement a Menu for choosing the game of mode either Single Player
mode or Multiplayer mode.
• Implement Chess Ai module capable of making moves against human
player.
• Implement a move log for storing captured pieces.
• Implement a timer which gets reset after every move or if the timer runs out
switch the player.

2.2 What can my chess game do?

• Improves problem solving techniques
• Improve logic and reasoning skills
• Increase patience and perseverance
• Improves decision making skills

4
CHAPTER 3

5
 Chapter 3. Requirement Specification

These are some of the specifics on which my project is based and following my "Chess
Game Design" was able to proceed as follows:

3.1 Software Requirement Specification:

• Python (v3.x)
• pygame library
• Operating system: Windows, Linux, or macOS

3.2 Hardware Requirement Specification:

• RAM: 128MB (minimum).
• Processor: Pentium 2 and higher.
• Hard disk: 150 MB.
• Includes memory storage, mouse, keyboard

6
CHAPTER 4

7
 Chapter 4. Existing Syatem

In the context of a chess game project using Pygame, "current system" refers to the state
of the chess game implementation prior to the development of the current project.
Because this is a specific implementation and not an upgrade to existing software, the
term "existing system" may not be directly applicable. Instead, the literature review
provides an overview of relevant current work, frameworks, or project-related
techniques.

4.1 Existing System (Literature Review):

• Traditional chess software: Historically, traditional chess
software has been characterized by a simple text-based or basic graphical
interface. These implementations, while functional, often lack the
sophistication of advanced graphics and interactive features, prompting a
reevaluation of user experience and engagement.
• Pygame Framework: The Pygame Framework has emerged as a
key component in contemporary game development. As a widely adopted
tool for creating 2D games in Python, PyGame is respected for its versatility
in handling graphics, user input, and sound. Its popularity in the game
development community reflects its role as a transformative force in
interactive application creation.
• Chess Engines: Various chess engines, including pioneers like
Stockfish and Komodo, have gained fame for their prowess in playing chess.
These engines explore the algorithmic complexities of chess, providing
valuable insights into the recognition of moves and the management of game
states.
• Graphical Chess Interface: Some chess interfaces have leapt
beyond functionality with an emphasis on aesthetics and user experience.
Using technologies such as WebGL or sophisticated graphical libraries,
these interfaces aim to create visually immersive and captivating chess
gaming experiences

4.2 Abstract Representation of a Game:

An abstract representation of a game is a set of rules which allow a player to play
the game lawfully, but which is more compacted than the general representation of the
game. The concept of abstract representation is basic to all work on games in AI. It
is a prerequisite for game analysis. Thus game analysis is significantly dependent on the
existence of an abstract representation of the game.
Also the books such as Primer Labs (2013) CODE HERO is a game that teaches
how to make games | Primer Labs, is of great significance for developing the
game such as chess.
Last but not the least a literature review is one described above and
the one which is an evaluative report of information found in the
8
literature related to the selected area of study, ours is the CHESS.

9
CHAPTER 5

10
 Chapter 5. Characteristics

In this scenario, we present the basic definition of chess moves. Before starting the
game, we need to know what it is and what it is known for.

5.1 Standard Limitation:

Chess Board: A board for playing Chess. There should be 64 white and white
boxes.

Chess: The game is played by 2 people on a backgammon board with 16 pieces each.
Player or User: The user or player will be the person who plays chess.
king: The main part of the game is to check the artifacts of this game object. Can
move 1 space in any direction.

Knight: This piece can move 1 space vertically and 2 spaces horizontally or 2
spaces vertically. This work looks like a horse. This work can also jump through other
parts.

Queen: This piece can move in any direction in any space unless there is another
piece.

Rook: one of two pieces of the same color that can move the number of
squares horizontally or vertically, unless another piece interferes.
Bishop: one of two pieces of the same color that can move any number of squares
diagonally, unless another piece interferes. One piece always remains in the White Box
and the other always in the Black Box. The bishop does not have restrictions on each
move, but only on diagonal moves. The bishop, like all pieces except the knight, cannot
jump over other pieces. The bishop occupies a square occupied by one of the enemy
units.
Bishops can be distinguished by the wing that starts with, which is the bishop of the
king and the bishop of the queen. As a result of the diagonal movement, each bishop
always remains in the white or black square, so it is also commonly called a light or
dark colored bishop.

Check: Perform an action that immediately attacks the opponent's King. In chess,
check occurs when a player's king is in danger of being captured by his opponent's next
turn. A king so threatened said in control. If possible, the player must move out of check
by adding a piece between the threatening piece and the king, capturing the threatening
piece, or moving the king to a square that is no longer controlled. If the player fails to
check out, the game ends with a partner and the player who loses. Players cannot make
moves that control their king.

11
Scout: keep the opponent's king under control and avoid capture. He then brings the
game to a winning conclusion.

Castling: move the king two squares diagonally and bring the joker to the area
where the king passed. Casting is a movement in chess involving the player's king and
the player's original piece. A rook is the only move by the player that two pieces move
in the same move, and the only move where one piece of the knight's move can be
called "push" for another.
Casting consists of moving the king two squares to the hole of the player's first level,
then moving the king to the next square. Casting is only controlled if the king has never
moved, the castle involved has never moved, the square between the king and the castle
is not occupied, the king is not in control, and the king has not passed or finished the
square. Casting is one of the rules of chess and is technically a king move.

Stalemate: A situation where one player's king is not in control, but the player
cannot move. Then the results are inconsistent.

5.2 Product Perspective:

A product perspective emphasizes the overall role and purpose of a chess engine in
the context of a chess-playing application. It describes how the chess engine
interacts with users, end-user expectations, and the potential for integration with
various front-end applications to enhance the overall chess-playing experience.
5.2.1 System Interface: The GameState class manages the chess game state,
using an 8x8 2D list for the chessboard. It includes methods for handling moves,
captures, checks, and other game logic. The Move class facilitates user
interaction by representing individual moves.
5.2.2 User Interface: While the code itself does not provide a user interface, it
serves as the backend logic for the game of chess. User interaction is usually
through a graphical or command-line interface built around these classes.
5.2.3 User Characteristics: End-users are expected to be familiar with the
rules and gameplay of chess, including understanding chess notation and
terminology.
5.2.4 Constraints: The implementation is in Python, and dependencies include
the 2D catalog for the chessboard and the pygame library for the graphical
interface.
5.2.5 Operations: GameState methods handle moves, captures, checks, en
passant and castling. The Move class represents moves, including special
moves such as pawn promotion and castling. Methods for converting between
chess notation and internal representation are provided. This code handles
various chess scenarios, such as passant capture, castling, and pawn promotion.

12
5.2.6 Additional Functionalities:
 Game Mode Selection: Users can now choose between single-player
and multiplayer modes, providing flexibility and catering to different
preferences in gameplay.

 Display of Captured Pieces in Move Log: The move log panel

now includes the captured pieces by each player, offering visibility into the
game progression and strategic decisions made by players.

 Timer Functionality: A timer has been integrated to track each player's

time during gameplay, enhancing competitiveness and encouraging timely
decision-making.

5.2.7 System Interface (Updated): The GameState class has been

extended to manage game modes, captured pieces, and timer functionality.
These updates ensure that the game state accurately reflects the chosen mode
and tracks relevant game information.
5.2.8 User Interface (Updated): The user interface now includes options for
selecting game modes and displays relevant information such as captured pieces
and timers. These enhancements enrich the user experience and provide intuitive
interaction with the application.
5.2.9 User Characteristics (Updated): End-users are expected to be
familiar not only with the rules and gameplay of chess but also with the
additional functionalities introduced, such as game mode selection, captured
piece display, and timer functionality. Understanding these features enhances
user engagement and enjoyment of the game.
5.2.10 Constraints (Updated): The implementation remains in Python,
leveraging the pygame library for graphical interface elements and
multiprocessing for handling timer functionality. Additional dependencies may
include image files for piece representations and font files for text rendering.
5.2.11 Operations (Updated): In addition to existing operations, the system
now includes methods for managing game modes, displaying captured pieces
in the move log, and implementing timers. These operations ensure smooth
gameplay and provide users with a comprehensive chess-playing experience.

13
CHAPTER 6

14
 Chapter 6. Proposed Methodology:

The development of the chess application will adhere to a modular approach,

emphasizing a clear separation between chess logic and graphical representation.
Drawing inspiration from the provided code structure and incorporating the Pygame
library for graphical rendering, the proposed methodology unfolds in several key
aspects.

6.1 Modular Design: The architecture of the chess application will be

structured around a modular design paradigm, facilitating clear separation
and organization of different functional components. This approach ensures
that the codebase remains manageable, scalable, and easier to maintain over
time. Each module will be dedicated to specific tasks, such as managing
chess logic, handling user interface elements, implementing AI algorithms,
and controlling different game modes.
6.2 Chess Engine Enhancement: The core chess engine will undergo
enhancements aimed at refining its capabilities and improving overall
gameplay. Focus areas include enhancing move validation mechanisms,
optimizing algorithms responsible for evaluating board states and selecting
optimal moves, and implementing advanced strategies to enhance the AI
opponent's decision-making process. These enhancements will contribute to
a more challenging and dynamic gaming experience for players of all skill
levels.
6.3 Pygame Integration: Building upon the Pygame library for graphical
rendering, the integration will be extended to enhance the visual
representation of the chessboard and pieces. Additionally, Pygame's
capabilities for mouse event handling will be leveraged to enable seamless
interaction with the game interface. Furthermore, timer functionality will be
introduced to add a time-based dimension to gameplay, allowing for timed
matches and increasing strategic depth.
6.4 User Interaction Refinement: The user interface will undergo
refinements to improve usability and provide a more intuitive experience for
players. This includes implementing better feedback mechanisms to inform
users of game state changes, introducing tooltips or visual aids to assist in
understanding game mechanics, and refining user interaction elements to
enhance overall engagement.
6.5 Chess AI Integration: The integration of AI opponents will
introduce varying difficulty levels, allowing players to challenge themselves
against increasingly sophisticated opponents. This will involve
implementing algorithms for evaluating game states, predicting opponent
moves, and making intelligent move selections. The AI opponent will
provide a balanced and enjoyable gaming experience, offering players a
chance to improve their skills and test their strategic prowess.

15
6.6 Event-Driven Programming: Embracing an event-driven
programming model within the Pygame loop will ensure responsiveness to
user actions and facilitate seamless execution of game-related events. Event
handlers will be utilized to manage user inputs, trigger graphical updates,
and synchronize gameplay elements, ensuring a smooth and immersive
gaming experience.
6.7 Comprehensive Game State Management: A robust game
state management system will be developed to accurately track the state of
the game at any given time. This includes managing game modes, tracking
timers for timed matches, enforcing turn-based gameplay rules, and
implementing error handling mechanisms to provide informative feedback to
users in case of invalid moves or unexpected scenarios.
6.8 Special Moves Handling: Special moves handling will be
expanded to cover a wide range of scenarios, ensuring compliance with the
rules of chess. This includes implementing logic for special moves such as
castling, en passant captures, and pawn promotions, with careful
consideration for their impact on game dynamics and strategic decision-
making.
6.9 Testing Strategy Augmentation: A comprehensive testing
strategy will be devised and implemented to verify the correctness and
reliability of newly introduced functionalities. This will involve conducting
unit tests to validate individual components, integration testing to ensure
seamless interaction between modules, and error handling tests to assess the
robustness of the application under various scenarios.

6.10 Mini-Max Algorithm: Minimax is an algorithm used to determine the

score in a zero-sum game after a certain number of moves, with best play
according to an evaluation function. Here we have used the minimax
approach.
The algorithm can be explained like this: In a one-ply search, where only
move sequences with length one are examined, the side to move (max player)
can simply look at the evaluation after playing all possible moves. The move
with the best evaluation is chosen. But for a two-ply search, when the
opponent also moves, things become more complicated. The opponent (min
player) also chooses the move that gets the best score. Therefore, the score of
each move is now the score of the worst that the opponent can do.
We are utilizing a tree to generate the possible chessboard with depth first
search and minimax to find the best move based on the following heuristics:
• material (total piece count for each player)
• number of possible legal moves with emphasis on center squares
• check/checkmate status
• pawn structure

16
6.11 Alpha-beta Pruning:
This common pruning function is used to considerably decrease the min-max
search space. It essentially keeps track of the worst and best moves for each
player so far, and using those can completely avoid searching branches
which are guaranteed to yield worse results. Using this pruning will return
the same exact moves as using min-max (i.e. there is no loss of accuracy).
Ideally, it can double the depth of the search tree without increasing search
time. To get close to this optimum, the available moves at each branch
should be appropriately sorted. The sorting is done by the looking at the
scores of each possible move, looking only 1 ply ahead. The intuitive sort
would be to arrange them from best to worst, but that's not always best. Most
moves in chess end up being ones with small gains and losses (ones that
improve position, not necessarily capturing pieces), so it makes sense to
order the "stand pat" moves first. So the sorting is based on the absolute
value of the move scores (with the smaller ones coming first). The average
branching factor for min-max in chess is about 35, but with the alpha-beta
pruning and sorting, the program achieves a branching factor of around 25.

17
CHAPTER 7

18
 Chapter 7. System Design

The system design of a chess application includes various components, each of

which contributes to the overall functionality and user experience. The design is
structured to seamlessly integrate chess logic and graphical representation to provide
users with an engaging and intuitive interface

7.1 Flow Charts:

19
7.2 Game Flow Diagram

20
7.3 StateDiagram:

PIECE MOVE

21
CHAPTER 8

22
 Chapter 8. Feasibility Study

Based on the the initial investigation conducted using the ChessAI and
ChessMain projects as references, the feasibility of developing a new chess engine
integrated with a graphical user interface (GUI) can be assessed. The primary objective
of the feasibility study is to evaluate the technical and operational viability of the
proposed project.

8.1 Technical Feasibility:

Technical feasibility involves evaluating whether the proposed project can be
successfully implemented from a technical perspective. This section examines the
feasibility of integrating a chess engine with a GUI using modern programming
techniques and libraries.

8.1.1 Implementation Techniques:

Python Programming Language: Adopting Python as the primary
programming language offers several advantages, including its simplicity, readability,
and extensive library support. Python's versatility makes it well-suited for developing
both the chess engine and the GUI components.

ChessAI Architecture: Leveraging the architecture and design principles

employed in ChessAI, such as object-oriented programming (OOP) and efficient move
generation algorithms, can ensure the technical robustness of the new chess engine .

8.1.2 Codebase Integration:

Modular Design: Following the modular approach demonstrated in ChessMain,
where the chess engine and the GUI are developed as separate modules, promotes code
organization, reusability, and maintainability.

Integration with Pygame: Integrating the chess engine with a GUI built using
the Pygame library allows for the creation of visually appealing and interactive chess
interfaces. Pygame's extensive features for graphics rendering and event handling
facilitate seamless integration with the underlying chess logic.

8.2 Operational Feasibility:

Operational feasibility focuses on evaluating whether the proposed system meets the
operational requirements and user expectations effectively.

23
8.2.1 User Interaction:
Intuitive GUI: The graphical user interface enables users to interact with the
chess engine through intuitive mouse clicks and keyboard events, enhancing the overall
user experience.

Accessibility Features: Incorporating features from ChessMain, such as

Undo/Reset functionality, displaying captured pieces in the movelog, displaying the
time left that the system caters to the needs of Human players.

8.2.2 Gameplay Experience:

Smooth Gameplay: The integration of the chess engine with a visually
appealing GUI enhances the overall gameplay experience, providing smooth
animations, responsive controls, and real-time feedback on game status.

Feature-Rich Interface: Implementing essential features such as move

validation, checkmate detection, legal move highlighting, and customizable board
themes contributes to a rich and engaging gameplay experience.

24
CHAPTER 9

25
 Chapter 9. Proposed Evaluation Method

The Python Chess Game implementation has introduced significant enhancements

over the previous system. The proposed evaluation method focuses on key aspects to
assess the success and effectiveness of the system.

9.1 User Interface: The graphical user interface (GUI) significantly improves
the user experience compared to the previous text-based interface. The evaluation will
consider the clarity, intuitiveness, and overall user-friendliness of the GUI. The system's
ability to engage users and make chess gameplay visually appealing will be assessed.

9.2 Automation and Responsiveness: The introduction of automation in

move validation and game state updates enhances the system's efficiency. The
evaluation will assess the responsiveness of the system in automating chess moves,
reducing response times, and providing seamless gameplay. The effectiveness of
automation in streamlining user interactions will be a key focus.

9.3 Accuracy and Reliability: Accurate representation of the chessboard and

pieces is crucial. The evaluation will ensure that the system accurately reflects the game
state, validates moves correctly, and provides reliable information to users. The
accuracy of piece movements and the alignment with standard chess rules will be
thoroughly examined.

9.4 User Interaction: The user-friendly interface aims to provide players with a
positive and enjoyable experience. The evaluation will consider how well the system
engages users, the ease of making moves, and the overall satisfaction of the gaming
experience. Visual cues and highlights for possible moves will be evaluated for their
effectiveness.

9.5 Maintenance and Code Optimization: The evaluation will assess

the maintenance aspects of the system, considering code optimization techniques. The
modular structure and documentation will be examined to determine how well the code
supports future maintenance and enhancements. The reduction in maintenance costs
through well-organized and optimized code will be a key criterion.

9.6 Overall System Performance: A holistic evaluation will be conducted

to assess the overall performance of the Chess Game (2 player) system. This includes
examining the combined impact of user interface improvements, automation, accuracy,
and user interaction on the overall gaming experience.

26
CHAPTER 10

27
 Chapter 10. Testing
Testing Testing is a process, which reveals error in the program. It is a major
quality measure employed during software development. During testing the program is
executed with a set of test cases and the output of the program with test cases is
evaluated to determine if the program is performing as it is expected to perform. In
order to make sure that the system doesn’t have errors there are the different levels of
testing strategies which are applied at different phases of software development .

10.1 Testing Strategies:

•Unit Testing: Exhaustive examination of individual components to guarantee
their intended functionality. This includes rigorous testing of chess engine methods,
graphical rendering functions, and user interaction handling.

•Integration Testing: Thorough assessment of interactions between

different modules to confirm seamless integration and communication.

•User Acceptance Testing (UAT): Active involvement of end-users to

evaluate the application's overall usability, user interface, and alignment with chess
game expectations.

•Alpha Testing: Internal testing conducted by the development team to

identify and rectify issues before releasing the software to a wider audience .

•Beta Testing: External testing involving a select group of users to gather

feedback on the application's performance in real-world scenarios.

10.2 Functional Testing:

• Move Validity Testing: Precise verification that all chess moves,
including special moves like castling and en passant, are correctly validated.
• Game State Transition Testing: Assurance that game state
transitions accurately reflect the progress of the game, considering factors like
checkmate, stalemate, and piece captures.
• User Interface Interaction Testing: Thorough validation of user
interactions such as mouse clicks, keyboard inputs, and undo functionality.

10.3 Non-Functional Testing:

• Scalability Testing: In-depth assessment of the application's ability to
handle an increasing number of users and moves without significant
performance degradation.

28
 • Reliability Testing: Rigorous verification of the application's reliability
by analyzing its ability to maintain consistent performance over extended
periods.
• Security Testing: Ensuring the security of user inputs and preventing
unauthorized access or manipulation of the game state.

10.4 Test Results and Analysis:

• Detailed presentation of results from each testing phase, including any identified
issues, bugs, or areas for improvement.
• In-depth analysis of the impact of testing on the overall quality and performance
of the Python Chess Game.

29
CHAPTER 11

30
 Chapter 11. Project Snapshots

11.1 Chess-Board:

31
11.2 Highlighting Legal Moves:

32
11.4 Drawing Captured pieces:

33
CHAPTER 12

34
 CHAPTER 12. Future Proposed System

As we look forward to the future of the Python Chess Game with the implementation of
ChessAI, the goal is to enhance both its intelligence and accessibility, making it a
leading choice for chess enthusiasts of all levels. The following features outline the
roadmap for the future development of the system:

12.1 Advanced AI Capabilities:

Building upon the foundation of ChessAI, the future system will delve deeper into AI
capabilities, aiming to create a truly formidable opponent for players. This includes :

Advanced Decision Making: Enhance the AI algorithms to make more

sophisticated decisions, considering long-term strategies and tactical nuances.

Learning Capabilities: Implement machine learning techniques to allow the

AI to adapt and improve over time, learning from its experiences and player
interactions.

Analysis Tools: Integrate analytical tools that provide insights into the AI's
thought process, allowing players to learn and grow from their games.

12.2 Enhanced User Experience:

To ensure an engaging and immersive experience for players, the future system will
focus on improving user interaction and accessibility. This involves:

Intuitive Interface: Redesign the user interface to be more intuitive and user-
friendly, drawing inspiration from ChessMain's interface design principles.

Interactive Tutorials: Develop interactive tutorials and learning resources

within the application, helping players of all skill levels improve their chess knowledge
and skills.

Accessibility Features: Incorporate accessibility features such as customizable

settings for color schemes, piece styles, and font sizes to cater to a diverse user base.

12.3 Cross-Platform Compatibility:

Expanding the reach of the Python Chess Game across different platforms is essential
for fostering a broader community of players. This includes:

Mobile Compatibility: Develop a mobile version of the chess game optimized

for smartphones and tablets, allowing users to enjoy chess on the go.

35
Web Integration: Create a web-based version of the game that can be accessed
through internet browsers, enabling seamless gameplay across desktop and mobile
devices.

Cloud Syncing: Implement cloud syncing capabilities to allow users to

seamlessly switch between different devices while preserving their game progress and
settings.

12.4 Community Engagement:

To nurture a vibrant and active community around the Python Chess Game, efforts will
be made to encourage collaboration and interaction among players. This involves:

Online Multiplayer: Introduce online multiplayer functionality, enabling

players to compete against each other in real-time matches.

Social Integration: Integrate social features such as friend lists, chat

functionality, and sharing capabilities to facilitate communication and interaction
among players.

36
CHAPTER 13

37
 CHAPTER 13. Conclusion

In contemplating the future trajectory of the Python Chess Game, my vision is

centered on an evolution that transcends the conventional boundaries of chess
applications. The forthcoming system is poised to redefine the user experience and
functionality, introducing innovative elements to cultivate a vibrant and dynamic
community.
At the forefront of this evolution is the integration of Artificial Intelligence (AI)
capabilities, particularly in the realm of single-player mode. The exploration of adaptive
AI algorithms promises to offer players a nuanced and challenging experience, tailored
to diverse skill levels.
Ensuring universal accessibility is a key tenet of the envisioned future. The
development of a cross-platform application stands as a testament to this commitment,
allowing users to seamlessly enjoy the game on a variety of devices and operating
systems, be it Windows, macOS, Linux, Android, or iOS.
The prospect of mobile application development adds another layer to this jMyney.
By investigating the feasibility of a mobile version, the aim is to broaden the game's
reach, making it accessible to a wider audience. The optimization of the user interface
and controls specifically for mobile devices is envisioned to provide a smooth and
engaging gameplay experience on handheld platforms.

38
 List of References

[1] Chess Programming" by Walter F. Brown

[2] Bratko, P. Tancig, and S. Tancig, “Detection of positional patterns in chess”, in
Advances in Computer Chess 4.
[3]https://www.youtube.com/watch?v=EnYui0e73Rs&list=PLBwF487qi8MGU81nDG
aeNE1EnNEPYWKY_
[4] Chess for Programmers" by Martin C. Martin[5] S. Russell and P. Norvig, Artificial
Intelligence: A Modern Approach Prentice Hall, 1995.

39