Beta Chess Engine

Project Phase II Report

On

Beta Chess Engine

Submitted for the requirement of

Project course

BACHELOR OF ENGINEERING

COMPUTER SCIENCE & ENGINEERING

Submitted to: Submitted By:

Project Teacher (Supervisor) Student Group
(Er. Shiwali Yadav-E13277) NAME
Akshay Singh Negi
Aryan Jaiswal
Vedant Bisht

UID
20BCS7263
20BCS3392
20BCS7212
Co-Supervisor Signature

DEPARTMENT OF COMPUTER SCIENCE & ENGINEERING

CHANDIGARH UNIVERSITY, GHARUAN
June 2022
 Beta Chess Engine

ABSTRACT

Algorithms like searching, sorting, and path-finding algorithms may be learned

through visualization using the online learning platform "Algorithm Visualizer".
Visualization is a simple method of learning that attracts more attention than
academic studies. It makes basic algorithmic concepts like searching, sorting,
and path-finding techniques easier to grasp. In recent years, virtual learning has
become essential as demand for it has grown. Teaching methods have altered,
and visual learning now takes precedence over more conventional ones. One of
the simplest methods for understanding an idea is to visualize it. Using visual
aids
to communicate the topic also makes it much simpler to do so.

Algorithms are crucial in the field of computer science. The demand for
innovative issue-solving, improving current solutions, boosting the
effectiveness of developing new solutions, etc., has grown recently. A solid
grasp of algorithms is a prerequisite for these talents. This project aims to
illustrate all sorting
and shortest path algorithms that determine the best route from a source to a
destination node while taking into account time and cost restrictions.
The most effective uses of path-finding algorithms can be found through
experimentation with various sets and combinations of these algorithms.
These applications include traffic congestion management, digital mapping
services, social networking applications, robotics, game development, and many
other real-world situations. And it's capability includes several algorithms,
including BFS, DFS, Dijkstra, A* Search, IDA* Search, Jump Point Search,
and test simulations, where all the aforementioned techniques are compared by
shared parameters to determine which algorithm provides the best path in each
scenario. Sorting algorithms, on the other hand, can highlight effective
programming paradigms and stimulate conversations regarding algorithm
complexity. Research has demonstrated that rather than programming exercises,
hands-on activities that use analogies and enjoyable activities may enhance
learning in this area in a variety of ways.

In particular, by making these mostly abstract processes more apparent,

visualizations and animations might aid in the achievement of learning
objectives.
It may also encourage motivational, emotional, and perceptual variables that
have an impact on learning processes, as well as new ways of interacting with
representations.
 Beta Chess Engine

TABLE OF CONTENT

1. Introduction 5

2. Literature Review 6

3. Problem Definition 8

4. Objectives 10

5. References 11
 SORTING & PATHFINDING VISUALIZER

INTRODUCTION

SORTING & PATHFINDING VISUALIZER

Data structures and Path Finding algorithms are of utmost importance. The

development of students' problem-solving abilities depends on them fully grasping
each
of these principles. The use of programming languages and data structures by IT
developers is crucial since these are the solutions to problems. The state of the art in
computer science is algorithms. The same issue can be solved in a variety of ways,
some of which are superior to others. Time and money may be greatly reduced by
employing the proper algorithm at the appropriate location.

This platform's major goal is to assist instructors in using visualization to educate, as

well as to assist students in learning about algorithms through visualization. Data
structures and algorithms are two core topics in every computer science curriculum.
Learning and teaching the principles of algorithms and data structures may be
challenging for both students and teachers. Students struggle to comprehend
theoretical knowledge and the fundamental ideas behind algorithms.

According to experts, it might be challenging to convey to students a practical

understanding of the design and use of data structures through traditional
communication. As there may be relatively little interaction between the students and
the professors in the classroom environment, remote learning presents even greater
challenges. To overcome the aforementioned difficulties, several Algorithm Visualizer
tools have been developed in recent years. These tools aim to make algorithm and data
structure ideas easier to comprehend using animation and visualization. Algorithm
visualization methods have changed significantly in recent years, evolving from basic
computer-based visualization systems to complex computer-based instructors that let
users engage with the platform. Although algorithm visualizer tools continue to
advance, they still struggle to fully capture students' interest, keep them engaged, and
ensure their entire satisfaction as online learners.

Software and Libraries Requirement:

• React js

• VS CODE

• Github

• JavaScript

4
 SORTING & PATHFINDING VISUALIZER

LITERATURE REVIEW

The employment of filtering techniques as visual aids has been the subject of various
research and articles throughout the years. One covers every aspect of animation and
mathematical analysis, while the others concentrate on various methods for better
comprehending a single animation. For students to readily learn algorithms, a variety
of techniques have been created. The process of visualizing algorithms into
applications is a popular way of planning and programming. It is taught using the
following techniques: classic expressions and laboratories, robots, problem-based
learning, software visibility, programming areas, and support tools Teachers still
struggle with the laborious learning-teaching process, which includes interdisciplinary
testing, fine-tuning, publishing supplementary materials, and 78.6% of CS teaching-
related strategies.

The majority of algorithm visualization tools delivered positive outcomes when used
to their fullest ability to illustrate the data structure and algorithms. Students want
accurate graphical representations that provide accurate information about how a
specific algorithm is executed. Algorithm visualizer tools have been the subject of
several assessments in recent years. Overall, the findings indicated that passive
algorithm visualization or basic visualization had little effect on learners due to poor
student involvement. Christopher D. Hundhausen conducted a methodical analysis of
algorithm visualizer tools' efficacy. They found from their meta-study of 24 studies on
algorithm visualizer tools that how learners utilize visuals is more crucial than the
visualizations themselves, and that the environments of algorithm visualizer tools only
work well when the learners are actively involved in the learning process.

Our Methodology :

We examine the pedagogy, usability, and accessibility objectives of online students to

develop an efficient algorithm visualizer. We then incorporate the features of the
aforementioned objectives to create efficient user interfaces and visualizations for an
online algorithm visualizer tool. Three people are involved in this design process.

basic activities:
1 Creating specifications
2 Creating alternative designs and prototypes
3 Evaluation

The aims and their pertinent elements were determined by a thorough literature review
we did for the activity of creating specifications. We created the user interfaces and
the visualizations during the developing alternatives and prototyping activity by
adhering to Shneiderman's eight guiding principles. In this study, we focused mostly

5
 SORTING & PATHFINDING VISUALIZER

on the tasks of defining requirements, creating alternatives, and prototyping. The

evaluation activity is currently in work-in-progress.

Software Requirements
To test this process, software was developed and implemented. The program is based
on React js, JavaScript and Html where it needs to be shipped, windows 10 and others.

● Visual Studio code

● Github
● Chrome Web development tools

PROBLEM DEFINITION

Block Diagram

6
 SORTING & PATHFINDING VISUALIZER

Problem: The problem is to design a chess game using machine learning, neural
networks and artificial intelligence. The main classes available are -

1. Point: A point represents an 8x8 grid of blocks and optional shapes.

2. Piece: Basic building blocks of the system, each part in one place. The Piece class
is an abstract class. Extension classes (pawn, king, queen, rook, knight, bishop)
implement abstracted operations.
Chess is played by two players, one color, a white and black piece for each. Then
there are the following pieces for each side:
• ♔ — King
• ♕ — Queen
• ♖ — Two towers
• ♗— Two bishops
• ♘ — Two knights
• ♙ — Eight Pawns

3. Board: The board is a set of 8x8 boxes containing all valid chess pieces.

4. Player: The player class represents one of the participants in the game.

5.Movement: Represents a movement with a start and end position. The Move class
also keeps track of the player who performed the move. There are basically 4 types of
moves that can be combined according to the figure:
1. Straight (used for Rooks, Queen and King)
2. Diagonal (Bishops, Queen, King)
3. «L» (Knights)
4. Pawn moves
Note that en passant special moves, pawn promotion and castling are deliberately
ignored for simplicity. Some other restrictions on making a move: a piece cannot jump
over another piece, except knights, and when a piece reaches an enemy piece, it can
capture it and take its place on the board.
To highlight the movements, design an optional colored border around the squares:
• Red — currently selected piece
• Blue — possible destination of the selected piece

7
 SORTING & PATHFINDING VISUALIZER

• Green — the last move played by the opponent

6. Game: The game class controls the course of the game. It keeps track of all the
turns of the game, which player is currently on the turn and the final result of the
game.

7.Rules: Now that we can move the pieces, we have to consider the rules of the
game: there are things that can be done and also things that must be done (typically an
escape check).
It's out of scope to explain every single rule here, but I've tried to implement most of
the restrictions, including:
• Player moves;
• Determining whether the king is in check and, if there is no way out, determining
that the king is checkmate (game lost);
• Both kings are always a square away from each other

OBJECTIVES

The Specific Objectives of Beta chess engine Include:

● A detailed Study of the chess engine.

● Coming Up with Beta chess engine.

● Design and develop a software platform for playing chess, predicting next
move, Next move suggestion, monitoring the voting system.

● Run Simulations and code to compare the results of the designed Beta Chess
Engine.

● Validating the Software to ensure that only the valid moves are allowed.

8
 SORTING & PATHFINDING VISUALIZER

REFERENCES

1-https://en.wikipedia.org/wiki/Chess_engine#History

2-https://en.wikipedia.org/wiki/Chess_engine#Limiting_an_engine's_strength

3-https://en.wikipedia.org/wiki/
Chess_engine#Kasparov_versus_the_World_(chess_game_played_with_computer
_assistance)

4-How to write a bitboard chess engine(book).

5-https://chess.stackexchange.com/questions/32379/book-recommendation-for-
chess-engine-building

6-https://www.chess.com/terms/chess-engine#most-popular-chess-engines

7-https://www.youtube.com/watch?v=OpL0Gcfn4B4&t=2432s

8-https://github.com/CSSLab/maia-chess

9-https://github.com/fsmosca/Python-Easy-Chess-GUI/blob/master/
python_easy_chess_gui.py

10-https://news.cornell.edu/stories/2021/01/chess-engine-sacrifices-mastery-
mimic-human-play