CHESS BOARD CREATION

BY USING GRID LAYOUT

INTRODUCTION

B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT

Project Overview:
The aim of the program is to come up with a game of chess .The program also
includes pieces of chess, board and the frame.
The game of chess is the game where two players are involved one takes pieces
that are white and another that are black.
It consisting of different snap shorts have been taken to future explain how the class
program works. Firstly the programmer had started to look at the pieces of chess and then
chess board, thereafter a chess board together with pieces
The pictures are of the pieces of chess are called as:

Piece

King Queen Rook Bishop Knight Pawn

Number 1

Symbols

The chess board has been drawn by using rectangles, ellipses, and also 2-dimension
java classes. Set color method has also been used which enables us to change the appearance
of the board has we Would have to wanted . After looking at the board then we looked at the
final board that contains pieces.

Scope of the project:

The objective of the project is to finding the problems and the progress of the
client projects. Solutions are regularly monitored and measured quantitatively and the
consolidated health is reported to the TSG Head on a fortnightly basis. The main goal of
this software is to find out the current status of the projects so that managers can take
decisions to carryout successful completion of projects.
B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT

SYSTEM ANALYSIS

B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT

Existing System:
In the opinion of the inventor, free and open discussion between team members and
collective decision making process may make the game spectacular by increasing its
dynamism and presenting the various stages of chess players' thinking, evaluation of
positions, calculation of variants, choice of alternatives, and so on. In turn, in order to ensure
active team discussion and effective decision making process the Interactive Cognitive
Scenario was developed

Contents:
Key Ideas Branch: version of a chess game having own rating, that is played on one demonstration
chessboard .
Branch rating: a number indicating how important the branch, which is a marks (colored
chips), located in the upper part of the demonstration chessboard. The score of each branch is
equal to its chess result, multiplied by the rating of the given branch.
Branching: splitting a branch of a single move by splitting one of the existing branches
(the "parent") into two and distributing the ratings between the two child" branches.
Different moves will subsequently be made in each branch. This can only be done if there is a
free demonstration chessboard.
Selection: removing a branch in a single move in recognition of defeat from a position on
that branch, and redistribution of its branch rating between those of its remaining siblings.
The opponent team gets points equal to the lost branch rating.
Passing: transferring one unit (colored chip) in a single move from one branch rating to a
sibling, with no gain nor loss of points.

B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT

Description:

The board, pieces, their positions and rules of movement are the same as for standard
chess. But several parallel branches (versions of the same game) can be played at the
same time on the several boards, with the help of rating (importance) indicators of a

certain branch (red marks on top of the board).

The game is for two teams, recommended each to have five members. During the
game members of one team may discuss it, as well as actively move, and then form

the alternative (parallel) branches.

They also can change the rating of each branch by transferring its marks.

Demonstration boards :

Parallel variants of a game (branches) can be played on five nearby demonstration

boards, numbered 1 to 5, each of which has its own rating Teams can decide to

change the number of branches and their ratings.

The score of each branch (on a particular board) is equal to its chess result, multiplied

by the rating of the given branch.

The final score of the game is equal to the sum of results of all branches.

B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT
The game tree with Passing has a more complicated form.

A business chess game tree with chess passing . The rectangles denote branches (1
to 5) and their respective ratings (1 to 10)

Only one member of the team may move pieces and ratings on the demonstration board

after the team decides collectively.

This stops players crowding in front of the demonstration boards. For this purpose the
zone before the rows of demonstration boards is separated from the zone of team location
by red lines which only one team member may cross.

Game parameters: The time allowed for thinking over the moves and the form of time control. There is a
huge number of possible ways the Interactive Cognitive Scenario can be realized. Therefore,
before a game is played some parameters should be agreed:

Initial game rating

The number of demonstration boards (the maximum allowed number of branches)

The number of players in each team and the rules for their replacement during the game

The rules of branching, selection, distribution, redistribution and passing

B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT
Tournaments:

Tournaments have been held regularly since 1997. ] Running commentary of one of them

was broadcast on Armenian national television.

In Moscow Russian leading grandmasters participated in two representative tournaments.
The first was held in the Central House of Chess by M. M. Botvinnik in 2004, the
proceedings of which were broadcast by the Sports channel of Russian TV. The second
was held in the Moscow Chess Club by T. V. Petrosian in 2005.

Wider aspects: Apart from being a sport, Business Chess can also be used for scientific modeling of
mental activity, the processes of problem solving and a choice of strategy, as a general
educational business game.

Proposed System:

The first system, and the one that may be thought of as the simplest in concept, is just an
8 x 8 matrix that can hold one value per square: 0 if there the square is empty, 1 if

there is a white pawn, 2 if there is a white knight, -1 if there is a black pawn, etc.
This concept is really quite easy, because it just requires a matrix and some constants.
However, it can become difficult to compute the possible moves on the board, because the
computer must check the bounds and the locations of the pieces over and over. So, the

program will cycle through the board perhaps 20-30 times per turn.
Another representation method tries to help the computation of moves by combining the

normal move generator and the bounds checking mechanism.

The hardest moves to compute are those of the knight, for it can leap over and around
other pieces, and the moves are not in a straight line or diagonal like all of the other
pieces. Also, the knight can jump far outside the board, and it is difficult to compute an
illegal move for the knight.
So, this new system proposes to have the board represented not on an 8 x 8 matrix as

previously done, but in a 12 x 12 matrix.

The 8 x 8 matrix of the board is then centered with a2 row border around it. This ensures
that all knight moves lie within the matrix, no matter where the knight starts from. Next,
B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT
the program treats the 2 row border as "filled" (that is, occupied by un moveable ,

undesignated pieces) and thus, the moves into the border by any piece would be illegal.
This method tries to integrate the move generator and the bounds checker by creating a
raised "rim" around the board, ensuring that any move trying to get out will be blocked by

the "rim."
By far one of the most innovative representations is the bit board. Say you have a 64-bit
integer. Now, that's interesting...there are also 64 squares on a chess board...quite a

coincidence.
Some programmers also recognized this coincidence, and they quickly caught on to how

valuable this relationship might be.

A 64-bit integer can be processed by a 64-bit CPU quite easily and quickly, so
programmers reasoned that if the chess board could be represented on a 64-bit integer, the

CPU would process the application faster and more easily.

Bit board contains all of the possible moves of Black's knights. Although it takes a bit of
work, this method can be applied in similar ways to generate the moves of other pieces as
Bit boards are also quite handy for move generation. For instance, let's say you have all

of the possible moves for Black's knights computed and recorded on a bit board.
Then, to decide which moves are blocked by Black's own pieces, you take a bit board of
all of Black's pieces, take the complement (the N OT operator) and then AND it to your

knights' moves bit board..

The resulting well. The main reason to use the bit board over other representations is
speed, but there are tradeoffs

Feasibility Study:chess has undergone a few changes. One of the biggest changes in chess is the switch
from classical openings to style referred to as hypermodern openings. Before you can
B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT
understand this change ,you must know about the history, rules, and strategy of chess. There
are many theories about the origination of chess. The most popular idea is that it originated
from the game Chaturanga , once thought to be Chinese Checkers, but now is believed to be
of Indian Origin (from India, the country). According to Eastern Legend, Chaturanga was
invented by a man named Sissa . Sissa was a Brahman at the Court of King Balhait of India.
King Balhait was tired of dice games that depended primarily on luck and chance, so he
ordered his wise men to come up with a game that depended on a player's judgement and
skill.

B.V.C. Institute of Technology & Science

CHESS BOARD CREATION

BY USING GRID LAYOUT

SOFTWARE
REQUIREMENTS
SPECIFICATION

This software will be used by PMO to check current status of the client projects.
Health of projects that are executed under the Non-Telecom Business Unit of Infinite
Computer Solutions are regularly monitored and measured quantitatively and the
consolidated health is reported to the TSG Head on a fortnightly basis.

B.V.C. Institute of Technology & Science

10

CHESS BOARD CREATION

BY USING GRID LAYOUT
Purpose:The purpose of this SRS is to gather requirement for both the system and the
software to be documented and reviewed with the customer. The requirements gathering
process is intensive file and focused specifically on software. To understand the nature of
program(s) to be built, the software engineer (analyst) must understand the information
domain for the software, as well as required functions, behavior, performance and
interfacing. A complete understanding of software requirements is essential to the
success of a software development effort. No matter how well designed or well coded, a
poorly analyzed and specified program will disappoint the user and bring grief to the
developer. The requirement, analysis task is a process of discovery, refinement, modeling
and specification.

Intended Audience and Reading Suggestions:The intended audience of this SRS is PMO (Project Manager Officer), project
managers, developers, testers, and documentation writers .This SRS contains product
functions, external interface requirements, functional requirements and non-functional
requirements. The section System features mentioned in this SRS is useful for
Developers and Non-functional requirement will be useful for testers.

B.V.C. Institute of Technology & Science

11

CHESS BOARD CREATION

BY USING GRID LAYOUT

HARDWARE
&
SOFTWARE
REQUIREMENTS

Hardware Specifications:Processor
Intel processor IV
RAM
128 MB
Hard disk
- 20 GB
Pen drive
- Kingston
4GB
B.V.C. Institute
of Technology
& Science

12

CHESS BOARD CREATION

BY USING GRID LAYOUT
Monitor
Keyboard
Mouse

19 inch LCD
108 mercury keyboard
Microsoft mouse

Software Specifications:Operating system

Frontend

- windows XP/2000
- JDK1.50-0.5

B.V.C. Institute of Technology & Science

13

CHESS BOARD CREATION

BY USING GRID LAYOUT

SYSTEM
DESIGN

Design:-

B.V.C. Institute of Technology & Science

14

CHESS BOARD CREATION

BY USING GRID LAYOUT

Fig: - Chess Board Design

A chessboard is a square game board composed of smaller squares.
A chessboard is a game board, similar in appearance to a checkers board, that is composed of
64 squares. The squares are in eight even rows of eight that alternate between two colors from
square to square. A self-portrait chessboard will use the board's imagery to represent you. The
typically solid colored squares will instead hold two alternating photos of yourself. The size
of the overall board will depend on the desired size of the squares.

Module Design:It has a board data where every field is represented with a row . There are
interface functions like move- piece and clear-board and set /get complete board/field.
The board integrates internal business logic. Like checking if a certain move is legal
are removing pieces, and it is only used once, because two boards at the same time are
useless.
I want this chess board in a file/module/class. While this is a good job for a class,
there might be other ways in python. What is the one way .
a. Instance of a class inside a file/module.
b. Class without instance approach.
c. Pure module approach.

UML diagram:Multiplicity of Qualifier

B.V.C. Institute of Technology & Science

15

CHESS BOARD CREATION

BY USING GRID LAYOUT
UML 2.4 specification (p.135) is mumbo jumbo gibberish explaining multiplicity of
qualifier:
The multiplicity of a qualifier is given assuming that the qualifier value is supplied. The
raw multiplicity without the qualifier is assumed to be 0. This is not fully general but it is
almost always adequate, as a situation in which the raw multiplicity is 1 would best be
modeled without a qualifier.

Given

chessboard

and specific

rank

and file

we'll

locate

exactly 1

square.

UML specification provides no lucid explanation of what multiplicity 1 means for qualifier.

Implementation:I am trying to decide how best to implement threads into my java chess program. The
program is pretty good as far as it goes, but right now it is just a single threaded app. When I
make a move, a command is issued to repaint the board. At the same time, the chess engine
(computer brain) starts churning, to calculate the next move.

I understand there are two

ways to do implement a thread, have my engine class extend Thread or implement Runnable.
It is my under -standing that the only real difference between the two is that implementing
runnable is preferable because of flexibility, it won't prevent you from extending another
class if you need to. In any event, I don't really have any concerns with how to do either at
this point.

System Architecture:
Large systems are always decomposed into subsystem that provides some related set of
services. The initial design process of identifying these sub-systems and establish a
framework for the subsystem control and communication is called the Architectural Design.
System architecture is the conceptual design that defines the structure and behavior of
system. It specifies the set of relations between the part of system. It is formal description of
B.V.C. Institute of Technology & Science

16

CHESS BOARD CREATION

BY USING GRID LAYOUT
the system, or a detailed plan of the system at component level to guide its implementation.
The current system follows three-tier architecture:
The three layers in this architecture are described as follows:

User Interface Layer: This is the layer where user interacts with the system.
Business Logic Layer: the business logic is implemented in this layer.
Data Access Layer: All the calls to the stored procedures are made from here.

Fig: Dataflow Diagram of Chessboard

Overview of the User Interface:User Interface Design

On a chess board :B.V.C. Institute of Technology & Science

17

CHESS BOARD CREATION

BY USING GRID LAYOUT

The pieces are different colors, so that you can easily tell which pieces belong to
which side.

The pieces are different shapes, so that you can easily tell which pieces are of which
type.

The squares are arranged in rows and columns, so that you can easily see, for
example, which squares this rook can move to.

The squares are different colors, so that you can easily see which squares each bishop
can move to.

What I'm trying to get at is: there's a lot of information packed into a chess board, but it
doesn't get overwhelming. When I look at the board, if I ask myself, "Where are the kings?"
my brain instantly picks them out. If I ask myself, "Where can this bishop move to?" my
brain instantly focuses on those particular diagonals. If I ask myself, "Where can this rook
move to?" I instantly see that, too - the differently-colored squares (which help me with the
bishop) don't distract me when I'm thinking about the rook. My brain just... focuses on the
right thing.

B.V.C. Institute of Technology & Science

18

CHESS BOARD CREATION

BY USING GRID LAYOUT

CODING

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
public
class
ChessGameDemo
MouseMotionListener
{
JLayeredPane layeredPane;
JPanel chessBoard;
JLabel chessPiece;
int xAdjustment;

extends

JFrame

implements

B.V.C. Institute of Technology & Science

19

MouseListener,

CHESS BOARD CREATION

BY USING GRID LAYOUT
int yAdjustment;
public ChessGameDemo(String title){
super(title);
Dimension boardSize = new Dimension(800, 600);
layeredPane = new JLayeredPane();
getContentPane().add(layeredPane);
layeredPane.setPreferredSize(boardSize);
layeredPane.addMouseListener(this);
layeredPane.addMouseMotionListener(this);
chessBoard = new JPanel();
layeredPane.add(chessBoard, JLayeredPane.DEFAULT_LAYER);
chessBoard.setLayout( new GridLayout(8, 8) );
chessBoard.setPreferredSize( boardSize );
chessBoard.setBounds(0, 0, boardSize.width, boardSize.height);
for (int i = 0; i < 64; i++) {
JPanel square = new JPanel( new BorderLayout() );
chessBoard.add( square );
int row = (i / 8) % 2;
if (row == 0)
square.setBackground( i % 2 == 0 ? Color.black : Color.white );
else
square.setBackground( i % 2 == 0 ? Color.white : Color.black );
}
JLabel piece = new JLabel( new ImageIcon("D:/subbu/pi/6.gif") );
JPanel panel = (JPanel)chessBoard.getComponent(0);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/3.gif"));
panel = (JPanel)chessBoard.getComponent(1);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/1.gif"));
panel = (JPanel)chessBoard.getComponent(2);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/2.gif"));
panel = (JPanel)chessBoard.getComponent(3);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/5.gif"));
panel = (JPanel)chessBoard.getComponent(4);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/1.gif"));
panel = (JPanel)chessBoard.getComponent(5);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/3.gif"));
B.V.C. Institute of Technology & Science

20

CHESS BOARD CREATION

BY USING GRID LAYOUT
panel = (JPanel)chessBoard.getComponent(6);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/6.gif"));
panel = (JPanel)chessBoard.getComponent(7);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(8);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(9);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(10);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(11);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(12);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(13);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(14);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/4.gif"));
panel = (JPanel)chessBoard.getComponent(15);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
panel = (JPanel)chessBoard.getComponent(48);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
panel = (JPanel)chessBoard.getComponent(49);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
panel = (JPanel)chessBoard.getComponent(50);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
panel = (JPanel)chessBoard.getComponent(51);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
panel = (JPanel)chessBoard.getComponent(52);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
panel = (JPanel)chessBoard.getComponent(53);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
B.V.C. Institute of Technology & Science

21

CHESS BOARD CREATION

BY USING GRID LAYOUT
panel = (JPanel)chessBoard.getComponent(54);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wpawn.gif"));
panel = (JPanel)chessBoard.getComponent(55);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wrook.gif"));
panel = (JPanel)chessBoard.getComponent(56);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wknight.gif"));
panel = (JPanel)chessBoard.getComponent(57);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wbishop.gif"));
panel = (JPanel)chessBoard.getComponent(58);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wqueen.gif"));
panel = (JPanel)chessBoard.getComponent(59);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wbishop.gif"));
panel = (JPanel)chessBoard.getComponent(61);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wking.gif"));
panel = (JPanel)chessBoard.getComponent(60);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wknight.gif"));
panel = (JPanel)chessBoard.getComponent(62);
panel.add(piece);
piece = new JLabel(new ImageIcon("D:/subbu/pi/wrook.gif"));
panel = (JPanel)chessBoard.getComponent(63);
panel.add(piece);
piece = new JLabel(new ImageIcon("/home/vinod/amarexamples/camel.jpg"));
panel = (JPanel)chessBoard.getComponent(20);
panel.add(piece);
}
public void mousePressed(MouseEvent e)
{
chessPiece = null;
Component c = chessBoard.findComponentAt(e.getX(), e.getY());
if (c instanceof JPanel)
return;
Point parentLocation = c.getParent().getLocation();
xAdjustment = parentLocation.x - e.getX();
yAdjustment = parentLocation.y - e.getY();
chessPiece = (JLabel)c;
chessPiece.setLocation(e.getX() + xAdjustment, e.getY() + yAdjustment);
chessPiece.setSize(chessPiece.getWidth(), chessPiece.getHeight());
B.V.C. Institute of Technology & Science

22

CHESS BOARD CREATION

BY USING GRID LAYOUT
layeredPane.add(chessPiece, JLayeredPane.DRAG_LAYER);
}
public void mouseDragged(MouseEvent me) {
if (chessPiece == null) return;
chessPiece.setLocation(me.getX() + xAdjustment, me.getY() + yAdjustment);
}
public void mouseReleased(MouseEvent e) {
if(chessPiece == null) return;
chessPiece.setVisible(false);
Component c = chessBoard.findComponentAt(e.getX(), e.getY());
if (c instanceof JLabel){
Container parent = c.getParent();
parent.remove(0);
parent.add( chessPiece );
}
else {
Container parent = (Container)c;
parent.add( chessPiece );
}
chessPiece.setVisible(true);
}
public void mouseClicked(MouseEvent e) {
}
public void mouseMoved(MouseEvent e) {
}
public void mouseEntered(MouseEvent e){
}
public void mouseExited(MouseEvent e) {
}
public static void main(String[] args) {
JFrame frame = new ChessGameDemo("Chess Board");
frame.setDefaultCloseOperation(DISPOSE_ON_CLOSE );
frame.pack();
frame.setResizable(true);
frame.setLocationRelativeTo( null );
frame.setVisible(true);
}
}
B.V.C. Institute of Technology & Science

23

CHESS BOARD CREATION

BY USING GRID LAYOUT

B.V.C. Institute of Technology & Science

24

CHESS BOARD CREATION

BY USING GRID LAYOUT

TESTING

Introduction
Software testing is an investigation conducted to provide stakeholders with information about
the quality of the product or service under test. Software testing also provides an objective,
independent view of the software to allow the business to appreciate and understand the risks
at implementation of the software.
Software testing can also be started as the process of validating and verifying that a
software program/application/product:
1. Meets the business and technical requirements that guided its design and
development.
2. works as expected; and
3. Can be implemented with the same characteristics.

B.V.C. Institute of Technology & Science

25

CHESS BOARD CREATION

BY USING GRID LAYOUT
Scope
A primary purpose for testing is to detect software failures so that defects may be uncovered
and corrected. The scope of software testing often includes examination of code as well as
execution of that code in various environments and conditions as well as examining the
aspects of code: does it do what it is supposed to do and do what it needs to do.

Testing Levels
Unit Testing:
Unit testing refers to tests that verify the functionality of a specific section of code, usually at
the function level. In an object-oriented environment, this is usually at the class level, and the
minimal unit tests include the constructors and destructors. These type of tests are usually
written by developers as they work on code (white-box style), to ensure that the specific
function is working as expected. One function might have multiple tests, to catch corner cases
or other branches in the code. Unit testing alone cannot verify the functionality of a piece of
software, but rather is used to assure that the building blocks the software uses work
independently of each other. Unit testing is also called component testing.
Unit tool is used to carry out the unit testing for the project.
Source Code Testing
This examines the logic of the system. If we are getting the output that is required by
the user, then we can say that the logic is perfect.
Specification Testing
We can set with, what program should do and how it should perform under various
conditions. This testing is a comparative study of evolution of system performance and
system requirements.
Module Level Testing
In this type of testing, the error will be found at each individual module, it encourages
the programmer to find and rectify the errors without affecting the other modules.
Unit Testing
Unit testing focuses on verifying the effort on the smallest unit of software-module.
The local data structure is examined to ensure that the data stored temporarily maintains its
integrity during all steps in the algorithms execution. Boundary conditions are tested to
B.V.C. Institute of Technology & Science

26

CHESS BOARD CREATION

BY USING GRID LAYOUT
ensure that the module operates properly at boundaries established to limit or restrict
processing.
Integration Testing
Data can be tested across an interface. One module can have an inadvertent, adverse
effect on the other. Integration testing is a systematic technique for constructing a program
structure while conducting tests to uncover errors associated with intervening.
Validation Testing
It begins after the integration testing is successfully assembled. Validation succeeds
when the software functions in a manner that can be reasonably accepted by the client. In this
type of testing, the majority of the validation is done during the data entry operation where
there is a maximum possibility of entering wrong data. Other validation will be performed in
all process where correct details and data should be entered to get the required results.
Recovery Testing
Recovery Testing is a system that forces the software to fail in variety of ways and
verifies that the recovery is properly performed. If recovery is automatic, re-initialization, and
data recovery are each evaluated for correctness.

Security Testing
Security testing attempts to verify that protection mechanism built into system will in
fact protect it from improper penetration. The tester may attempt to acquire password through
external clerical means, may attack the system with custom software design to break down
any defenses to others, and may purposely cause errors.
Performance Testing
Performance Testing is used to test runtime performance of software within the
context of an integrated system. Performance test are often coupled with stress testing and
require both software instrumentation.
Black Box Testing
Black- box testing focuses on functional requirement of software. It enables to derive
set of input conditions that will fully exercise all functional requirements for a program.
Black box testing attempts to find error in the following category:

Incorrect or missing function.

B.V.C. Institute of Technology & Science

27

CHESS BOARD CREATION

BY USING GRID LAYOUT

Interface errors.
Errors in data structures or external database access and performance errors.
White Box Testing

White Box Testing is a testing in which in which the software tester has knowledge
of the inner workings, structure and language of the software, or at least its purpose. It is
purpose. It is used to test areas that cannot be reached from a black box level

B.V.C. Institute of Technology & Science

28

CHESS BOARD CREATION

BY USING GRID LAYOUT

SCREEN
LAYOUTS

Fig: Output Screen for Empty Chess Board

B.V.C. Institute of Technology & Science

29

CHESS BOARD CREATION

BY USING GRID LAYOUT

Fig: Output Screen for Chessboard with One Type of Pieces

Fig: Output Screen for Chessboard with two type of pieces

B.V.C. Institute of Technology & Science

30

CHESS BOARD CREATION

BY USING GRID LAYOUT

Fig: Output Screen for Chessboard with Moves the Pieces

B.V.C. Institute of Technology & Science

31

CHESS BOARD CREATION

BY USING GRID LAYOUT

FUTURE
SCOPE

B.V.C. Institute of Technology & Science

32

CHESS BOARD CREATION

BY USING GRID LAYOUT
Chess Applet:A good chess applet to play with for the following reasons:

Completeness:
The applet implements the complete set of chess rules, including en passant (EP)
capture, pawn promotion, castling, draw by stalemate, draw by repetition, draw by lack of
progress, and optional time control.

Functionality:
The chess applet is easy to use with mouse clicks to designate moves, sound and
color to prompt the user or give feedback as appropriate, automatic generation of an
algebraic notation game listing, and it allows users to change sides.

Server Features:
The chess data server allows the user to save and restore games. Applet-computed
moves are stored at the server for future use resulting in faster response and optimal
playing strength.

Development:
The applet is written with strict object oriented (OO) discipline for easier
development and maintenance.

Performance:
On fast hardware, the applet will challenge the average chess player and will
occasionally beat the expert player. Playing strength will be improved by running the
chess applet on faster hardware: it adjusts its look-ahead depth to fit your machines
power.

B.V.C. Institute of Technology & Science

33

CHESS BOARD CREATION

BY USING GRID LAYOUT
Applet Design:Java is an object oriented language that encourages object oriented design. The chess
applet was written using strict OO discipline. All object data are declared private with public
accessor and mutator functions. For the interested programmer, general information on
computer chess programming is available at the computer chess programming page.
Chess Modeling:The design goal is to have a simple, flexible, maintainable applet that is complete and
correct in its play, and that uses the classic mini-max (AKA min-max) algorithm for finding
the best move. Central to achieving this design goal is to have an optimal chess model.
Defining a good chess model is not a trivial problem.
The following classes are defined:

Square, a location (rank and file) with some state data for en passant capture and pawn
promotion.

Chess Piece, a representation of a piece with material value, location (Square), state data,
a Vector of Squares (legal moves) and legal move generation functions.

Chess Board, an array of Chess Pieces with some state variables and pieces movement
functions.

Game Node, a node in the chess game tree that has a Chess Board to represent a point in
the chess configuration space, a Chess Board to represent the best move, and a Vector of
Game Nodes to represent the next available moves.

Chess, the applet itself, which has a Chess Board and a chess game tree represented by a
root Game Node.

B.V.C. Institute of Technology & Science

34

CHESS BOARD CREATION

BY USING GRID LAYOUT
Sound:The chess applet plays various sounds upon certain events.
All sound files were obtained from public domain Web sites and are assigned to the
following events:

Startup sound ("Shall we play a game?" from War Games), a long sound.

Alternate startup sound ("Would you like to play a game of chess? I play very well."
HAL 9000 computer from 2001 Space Odyssey), a long sound.

Reset sound. ("Wouldn't you rather play a game of chess?" from War Games), a long
sound.

Laughter sound on computer win (long sound).

Scream sound on computer loss (long sound).

Ding sound after computer move.

Sound for check.

Sound on illegal user move.

Vomit sound if user tries to move into check.

Sigh sound if computer resigns.

Fanfare sound on pawn promotion.

Yawn sound on a drawn game.

Client-Server Memory Version 3.00 introduces client-server memory. Each time the computer is to move, it
will first query the server move database to see if that position is on record. If so, the
recommended move is returned along with the search depth that move was computed with. If
the current applet instance is using an equal or shallower search depth, the server move will
be used. If the current applet is searching deeper, the applet will compute the move. Moves
computed by the applet are sent to the server for storage for future use. Using client-server
memory makes the applet respond faster for cases when the move is found on the server. The
client-server memory can make the applet play stronger by using stored moves computed on
faster hardware.

B.V.C. Institute of Technology & Science

35

CHESS BOARD CREATION

BY USING GRID LAYOUT
Known Limitations The following are the known limitations of the chess applet. At this time there are no
plans to amend any of them.

The applet does not enforce "touch move." Official chess rules require that a player
move the first piece he touches (except for piece adjustment, which does not apply
here).

The applet does not allow the taking back of moves (and neither do the rules of
chess).

Some browsers will re-initialize the applet when returning to the page. To prevent the
loss of game data, save your game before leaving the page.

The applet does not think during the human's turn to move.

In the timed game mode, upon notification of game loss, the players are allowed to
continue play.

B.V.C. Institute of Technology & Science

36

CHESS BOARD CREATION

BY USING GRID LAYOUT

CONCLUSION

Conclusion:B.V.C. Institute of Technology & Science

37

CHESS BOARD CREATION

BY USING GRID LAYOUT
The main objective of the program was to develop a chess program using java
language that will enable the user to be able to play chess but since this document only
explains what a chess look like and what each piece is hence it did not really described
how the game is played.

B.V.C. Institute of Technology & Science

38

CHESS BOARD CREATION

BY USING GRID LAYOUT

BIBILOGRAPHY

Bibliography:B.V.C. Institute of Technology & Science

39

CHESS BOARD CREATION

BY USING GRID LAYOUT
Some of the chess books ever written -

There are thousands of books available on chess, covering just about

every aspect you can imagine. Listed here are a few titles considered
classics by many experts on the subject.
Classic chess books frequently go in and out of print. If you can't find a
new copy of a title that interests you, check out used book resources. And
don't forget your local library!
Chess for Idle Moments Looking for a single volume that will tell you everything you need to
know about chess? These books are great for vacation or bedtime reading.
The Immortal Game A History of Chess by David Shenk This book won't teach you much
about playing the game, but it will explain why chess is so popular. If you
take it on vacation, you won't even need chess set.
The Mammoth Book of Chess by Graham Burgess
Over 500 pages cover all the technical aspects of chess: tactics,
openings, glossary, and much more. If you take it on vacation, you will need
chess set to take full advantage of it.

B.V.C. Institute of Technology & Science

40