1

TABLE OF CONTENTS

CHAPTER TITLE PAGE

NO. NO.

1 INTRODUCTION 3

1.1 Objective 3

2 SYSTEM ANALYSIS 4

2.1 Existing System 4

2.2 Proposed System 5

2.3 Feasibility Study 6

2.3.1 Economical Feasibility 6

2.3.2 Technical Feasibility 6

2.3.3 Operational Feasibility 7

3 SYSTEM SPECIFICATION 7

3.1 Hardware Specification 7

3.2 Software Specification 7

4 PROJECT DESCRIPTIONS 8

4.1 Problem Definition 8

4.2 Overview of the project 8

4.3 Module Description 8

4.4 System Flow Diagram 17

4.5 Data Flow Diagram(DFD) 18

4.6 Use case Diagram 19

 2

5 20
SYSTEM TESTING

5.1 Introduction 20

5.2 Testing Methodologies 20

5.2.1 Unit Testing 21

5.2.2 Integration Testing 21

5.2.3 System Testing 22

6 SYETEM IMPLEMENTATION 24

6.1 Purpose 24

6.2 System Maintenance 24

7 APPENDICES 26

7.1 Program Listing 26

7.2 Screen Shots 34

8 BIBLIOGRAPHIES 37
 3

INTRODUCTION
1.
1.1 OBJECTIVE:

One of the most universally played childhood games is TIC TAC TOE. An
interactive TIC TAC TOE game is developed where two players will be able to
play against each other in a suitable GUI by using proper mouse movements.
This game will start by showing a simple display, prompt the user for a move
and then prints the new board. The board looks like a large hash symbol (#)
with nine slots that can each contain an X, an O, or a blank. There are two
players, the X player and the O player. By default, player1 (the O player) takes
the initiative. The game will end in two situations: a win, when one player gets
three in a row, horizontally, vertically or diagonally. A draw, when there are no
remaining places to choose and neither of them has won. Here are some rules
for the game:

● The player with symbol ‘O’ goes first

● Players alternate placing X s and O s on the board until either

● one player has three in a row, horizontally, vertically or diagonally; or

● all nine squares are filled.

● The player who can draw three X s or three O s in a row wins.

● If all nine squares are filled and none of the players have three in a row,
the game is a draw.
 4

2. SYSTEM ANALYSIS

INTRODUCTION:

Analysis can be defined by breaking up of any whole so as to find out their

nature, working functionalities etc. It defines design as to make preliminary
sketches of; to sketch a pattern or outline for planning. To plan and carry out
especially by artistic arrangement or in a skilful wall. System analysis and
design can be characterized as a set of techniques and processes, a community
of interests, a culture and intellectual orientation.

The various tasks in system analysis phase including the following:

● Understanding Application

● Project Planning

● Project Scheduling

● Supervising, Installing, Maintaining the system

This system allows the user to feel the taste of playing the game endlessly. First
design the class which will keeps track various functions like board structure,
pixel selection, grid selection, canvas structure, click recognition, gameplay,
game over screen etc. And according to the moves played by the players this
project will display the result in very attractive format.

2.1 EXISTING SYSTEM:

The Existing system is a simple game to play with paper and pencil between two
people. Here the whole process will be carried out in the hand-written format
making nine square grids, placing X’s and O’s and checking for the winner. This
 5

.process will repeat every time. So, it will be a tedious job to draw a nine square
grid every time with paper and pencil. The human effort is more here. Along
with that the retrieval of the information is not easy as the records are
maintained in the hand-written papers. This application requires correct feed on
input into the respective field. Suppose the wrong inputs are entered, then the
whole process is to be done again. So, the users find it difficult to use.

2.2 PROPOSED SYSTEM:

To overcome the drawbacks of the existing system, the proposed system has
been evolved. This project aims to reduce the paper work and saving time to
generate accurate results from the player’s perspective. The system provides
with the best Graphical User Interface. The efficient reports can be generated by
using this proposed system.

1. ADVANTAGES OF PROPOSED SYSTEM

● The game has been made user friendly with proper use of
graphical interface.

● The user can play as many games without any interpretation.

● It is highly reliable, approximate result from user.

● The game has been made as a thorough expert system.

● The players can win the game, draw the game or will lose the
game.

● It is a good brain exercise for all age group people.

 6

2.3 FEASIBILITY STUDY:

Feasibility study begins once the goals are defined. It starts by generating board
possible solutions, which are possible to give an indication of what is new
system should look like. That is where creativity and imagination are used.
Analysts must think up the new ways of doing things generating new ideas.
There is no need to go into the detailed system operation yet. The solution
should provide enough information to make reasonable estimates about project
cost and give user an indication of how the new system will fit into the
organization. Feasibility of a new system means ensuring that the new system,
which we’re going to implement is efficient and affordable. There are various
types of feasibility that should be taken into consideration:

2.3.1 ECONOMICAL FEASIBILITY

Development of this application is highly economically feasible. The only thing
to be done is making an environment with the effective supervision. It is time
effective in the sense that it will eliminate the paper work completely. The
system that is being developed is also cost effective.

2.3.2 TECHNICAL FEASIBILITY:

The technical requirement for the system is economic and it doesn’t use anyother
hardware or software. Technical evaluation must also assess whether the Existing
System can be upgraded to use the new technology and whether the
organization has the expertise to use it. Install all the upgrades frameworks into
 7

the Python IDLE package supported Linux based application. This application
mostly depends two packages namely tkinter package and pygame package
provided by Python 3.6.0.

2.3.3 OPERATIONAL FEASIBILITY:

The system working is quite easy to use and learn due to its simple but attractive
interface. User requires no prerequisites for operating the product. Technical
performance includes issues such as determining whether the system can sense
the proper click of the mouse or after sensing the click it places the symbol in the
desired cell and whether the system is organized in such a way that it always
displays the correct result according to the moves made by the players.

3. SYSTEM SPECIFICATION:

3.1 HARDWARE REQUIREMENT [minimum requirement]:

● Mi n i mu m RAM: - 1GB

● Mi n i mu m Hard Disk: - 128GB

● Processor: - Intel Pentium 4(1.50 GHz) o r above

3.2 SOFTWARE REQUIREMENT [minimum requirement]:

● Operating System: - Support for both LINUX and

WINDOWS users

● Back End: - Python 3.6.0 Interpreter

 8

4. PROJECT DESCRIPTION

4.1 PROBLEM DEFINITION:

The project consists of developing and implementing a computer program that
plays TIC TAC TOE against another player. This developed system will reduce
the manual work that is for playing a game you’ve not to carry a pen or a pencil
and a few sheets of papers on your pocket all the time. The system can able to
provide hundreds or thousands of TIC TAC TOE game without any interruption.

4.2 OVERVIEW OF THE PROJECT:

This project is divided into several modules and all the modules are appearing in
one class. These modules are called from the main module located at the root of
the project. All the modules have different as well as vital functionalities in
order to develop the right product. These modules are designed in such a way
that they reflect a highly cohesiveness.

4.3 MODULE DESCRIPTION:

● INITIALIZATION:
In the main class we’ve created a constructor which will hold all the tkinter
widgets that we are using in our program. First of all, we’ve used a highly
versatile widget called canvas to draw graphs and plots on our root window. We
set the background colour as white. Now we want to realize the effects that we
are made in our root window. For that we have to use the pack geometry
manager. Then we’ve called the bind function, which is actually used to interact
the GUI widget with our computer program. In the bind function we’ve passed
two objects namely '< x >', self.exit. The later one is used to exit from the root
window. In the root window there should be three options displaying at the top9
level. The minimize button , the maximize button and the close button ( X ) .
Now whenever the user clicks on the X button the bind function should capture
that and accordingly the root window will destroy that means it could not be
displayed any more. Then we set our game state to zero ( 0 ) and call the
title_screen module. After that we create a list with nine strings and initiate
each of them with a value zero ( 0 ) and store it in a variable called board.

● TITLE SCREEN:
In this module, what we’ve done is we use the delete method to clear the
canvas. We use the special tag “all” to delete all the items on the canvas. Then
we create three rectangles on our root window. We create these rectangles by
using canvas supported standard item call create_rectangle. For drawing the
first rectangle we’ve passed the rectangle bounding size which is nothing but
the original window size and the rectangle options which includes fill and
outline as an object. We choose the white colour as the rectangle boundary
colour. Applying the same procedure, we have created the second rectangle.
The only additional thing that is done here is regardless of sending the original
window size we’ll send the adjusted window size as an object. That means
we’ll just modify the X and Y axis is such a way that the beauty of the window
is preserved. Now, for the third rectangle we’ve applied the same procedure and
we select appropriate colour for displaying all the texts that will be appeared in
this rectangle. Now we want to display the title of the game and besides that,
because we also would like to increase the usability of the software that we are
developing so we also have to create another text that will increase the usability
of the software. For that we are using canvas supported standard item called
create_text that will enable us to create informative text on the screen.
Intuitively, the title of the game should be TIC TAC TOE and just below to
that another text that will be appearing is Click to play.
 10

● NEW BOARD:
The main objective of this module is to create a new board that consists of three
rows and the columns. The board is nothing but a 2 Dimensional three by three
matrix and we’ll create the matrix by using list of strings. So, to do that first we
clear all the widgets that is appearing in the window by using the delete method
and passing a special parameter “all” to it. Then we reset the board by
assigning 0 value to all the nine locations in the board. Now we’ve to draw two
lines vertically and horizontally. To achieve this, we have to use canvas
supported another standard item called create_line. To use the create_line
function we should have to pass the line co-ordinates and the line options as a
parameter. Thus, we create a loop which will repeat two times and inside the
loop we declare two create_line functions with appropriate X co-ordinates, Y
co-ordinates, grid / line width and grid colour. Insides the loop we use the
create_line function twice because one is for drawing the lines vertically and the
other one does the desired job for us by creating the lines horizontally. By this
we’ve completed our board structure.

● GAMEOVER SCREEN:
This module is concerned with displaying the result according to the outcome
on the screen. It takes outcome as an object and displays the appropriate result.
If the outcome is in favour of player 1, “O Wins” appears on the screen in the
form of a text. Similarly, if the outcome is in favour of player2, “X Wins”
should appear on the screen and if the outcome is a draw, then both the players
will see the text “Draw” on the screen. We add one extra feature in the game
over module by introducing a text called “Click to play again” and we’re very
optimistic that it should increase the usability of the developed software. For
displaying the texts, we’ve used the canvas supported standard item call
create_text function. In the game over screen firstly we create a rectangle on
 11

the canvas and fills it with appropriate colour and inside that rectangle all the
texts will appear. We’ve created the texts by adjusting the text size, font style,
text height, text width and text colour.

● CLICK:

This module handles most of the game logic. A tkinter application runs most of
its time inside an event loop, which is entered via the main loop method. It
waits for an event to happen. Events are generally key pressed or mouse
operations by the users. We’ve already set the game states globally by
assigning the values STATE_TITLE_SCREEN to 0, STATE_X

_TURN to 1, STATE_O_TURN to 2 and STATE_GAME_OVER to 3. In

the click method
we’ve passed the first argument implicitly (called ‘self’) which is the reference
to our main class itself and it should have the ‘event’ object that merely
describes what is actually happened. We begin our task by converting the pixels
into gird coordinates and then we have to check for the current game state
condition and accordingly the game will continue. Now if game state is 0, then
it will draw a new board on the screen and sets the game states as the value of
the first player. If the game state is 1 i.e. X’s turn and the cell is empty then the
control goes to new move module (where we’ve to mandatorily pass the current
player and the board coordinates as arguments) and the appropriate cell is filled
up with symbol X. Now it checks all the possible conditions (i.e. whether
player X has won or it is a draw) one by one. So, at first the control moves to
has won module and if the result is true then it sets the game state to 3 and calls
the game over module by passing the parameter ‘X wins’. If it is false then the
control goes to is a draw module and if the result is true then again it will set
the game state to 3 and calls the game over module with the parameter ‘Draw’.
If the result of both the cases is false then only it will set the game state as 2
 12

which is nothing but player O can now take its turn. Now If the game state is 2
i.e. O’s turn and the cell is empty then the control goes to new move module
and the appropriate cell is filled up with symbol O. Now, it checks all the
possible conditions (i.e. whether player O has won or it is a draw) one by one.
So, at first the control moves to has won module and if the result is true then it
sets the game state to 3 and calls the game over module by passing the
parameter ‘O wins’. If it is false then the control goes to is a draw module and if
the result is true then again it will set the game state to 3 and calls the game
over module with the parameter ‘Draw’. If the result of both the cases is false
then only it will set the game state as 1 which is nothing but player 1 can now
again take its turn. Finally, it checks for if the game state is being at 3 or not. If
it is 3, then it will reset the board by calling the module new board and sets the
game state according to the first player. With this we’re completing most of the
work that is behind our game logic.

● NEW MOVE:

This module is concerned with pacing the X’s and O’s in the selected cells on the
board. It receives the current player and the grid coordinates from the click
module as an argument and places the symbol of the player in the desired cell.
Now let us consider our board structure:
 133

Here X and Y are 0 based grid coordinates. If the current player is X then it will
call the draw X module (discussed later) with the grid coordinates and places
the X symbol with appropriate size and colour into that grid. Now if the current
player is O then it will call the draw O module with the 0 based grid
coordinates and places the O symbol into that cell.

● DRAW X:
This module deals with drawing X on the canvas. So, for that what we’ve to do
is, first of all we’ve to convert the grid into pixels and then we can start our
drawing using canvas supported standard packages namely create_line. For that
reason, we’ve called the grid_to_pixel module twice and we get the converted
pixels. Now we must have to adjust the width and height of the X so that no
extra outline would appear in the right-hand side and left-hand side. We divide
he cell size by 2 and multiplied it with the symbol size and store it in a variable
called delta. By adjusting the delta, choosing the colour and selecting the width
in the create_line function we’ve completed our task

● DRAW O:

This module is concerned with drawing an O on the canvas. Like the previous
module, here also we’ve to convert the grid coordinates into pixels and then
we’ve to adjust the O’s in the board. Again, we divided the cell size by 2 and
multiplied it with the symbol size and assigned it in a variable called delta. For
drawing an O we’ve to use the canvas supported standard package called
create_oval function. In create_oval function, pixel coordinates are adjusted in
such a way that the O’s have no odd lines on the left-hand side as well as right-
hand side. Then we select the appropriate width and the colour for O’s so that it
looks better.
 14

● HAS WON:
This module is concerned with checking for the winner and returns the result to
an appropriate calling function. In the click module, we’ve already converted
the grids into pixels and store them into some variables. Now the has_won
function takes those pixels as an argument and accordingly the board will fill up
with the winning symbols. The checking for the winner is quite simple. If any of
the players can able to fill all the cells in a row vertically or horizontally or
diagonally, he /she will consider to be the clear winner. So, in the first for loop,
we basically check that whether all the cells of a row (vertically or horizontally
or diagonally) are filled with the same symbol or not. Now if this condition
satisfies, then the player with that symbol is the winner. In the second for loop
we need to check those positions that are conventionally reserved for the
winning position. So, we need to check the positions ([0][0],[0][1],[0][2]) or
([1][0],[1][1],[1][2]) or ([2][0],[2][1],[2][2]) or ([0][0],[1][0],[2][0])

or ([0][1],[1][1],[2][1]) or ([0][2],[1][2],[2][2]) or ([0][0],[1][1],[2][2]) or

([0][2],[1][1],[2][0]) and by

checking these positions we will certainly get the winner.

● IS A DRAW:

In this module, we’re just checking the result is a tie or not. The result is a tie
when all the boxes/cells are filled. Checking whether it is a draw is fairly
straightforward. All we’ve to do is check whether all the board boxes are filled.
We can do this by iterating through the board array.

●GRID TO PIXELS:
. 15

The main objective of this module is to transform the grid coordinate into
pixels. Intuitively we’ve passed the grid coordinate as an argument and this
module returns accurate pixel coordinate of the centre. The pixel coordinate
should be calculated with the help of grid coordinate and the cell size. Thus, we
add the original cell size with the half of it and multiplied it with the gird
coordinate and stored the result in a variable called pixel_coord. By doing this,
the grid to pixel transformation is mostly done

● PIXELS TO GRID:

It is just the reverse of the previous module. This module performs exactly the
opposite task, taking a pixel coordinate as an argument and converting this into
its equivalent grid coordinate. Somehow the canvas has a few extra pixels on
the right and bottom side so we’ve to fix this. For clipping the extra pixels, we
must check the condition that if the pixel coordinate is somehow greater than
the original window size then we’ve to reduce the window size. The
transformation can be achieved by dividing the pixel coordinates by the cell
size. The resultant grid can now be stored into a variable say grid_coord. The
main objective of this module is to transform the grid coordinate into pixels.
Intuitively we’ve passed the grid coordinate as an argument and this module
returns accurate pixel coordinate of the centre. The pixel coordinate should be
calculated with the help of grid coordinate and the cell size. Thus, we add the
original cell size with the half of it and multiplied it with the gird coordinate
and stored the result in a variable called pixel_coord.
 16
.

● EXIT:

This module is used for closing t h e root wi n d o w permanently. In

this module we’ve passed event a s a n a rg u me n t based u p o n
this event t h e wi n d o w can be closed. We w a n t t h e access f r o m
t h e c u r r e n t instance in o u r exit() m e t h o d wh i c h is d o n e t h r o u gh
self.
self.destroy()

However, this only destroys the frame and its child windows, like the canvas,
not the top-level window.
 17

4.4 SYSTEM FLOW DIAGRAM

 18

4.5 DATA FLOW DIAGRAM

 19

4.6 USE CASE DIAGRAM

StartGame

Player 1
moves

Player 2
moves

Check the
result

Player 1 Player 2

Playagain
 20

5. SYSTEM TESTING

5.1 INTRODUCTION
Once source code has been generated, software must be tested to uncover and
correct as many errors as possible before delivery to customer. Our goal is to
design a series of test cases that have a high likelihood of finding errors. To
uncover the residual errors software techniques are used. These techniques
provide systematic guidance for designing test that

● Exercise the internal logic of software components, and

● Exercise the input and output domains of the program to uncover errors in
program function, behaviour and performance.

1. STEPS:
Software is tested from two different perspectives:

● Internal program logic is exercised using ―White box test case design
techniques.

● Software requirements are exercised using ―block box test case design
techniques.
In both cases, the intent is to find the maximum number of
errors with the minimum amount of effort and time and cost.

5.2 TESTING METHODOLOGIES:

A strategy for software testing must accommodate low-level tests that are
necessary to verify that a small source code segment has been correctly
implemented as well as high- level tests that validate major system functions
against customer requirements. A strategy must provide guidance for the
 1621
practitioner and a set of milestones for the manager. Because the steps of the
test strategy occur at a time when deadline pressure begins to rise, progress
must be measurable and problems must surface as early as possible. Following
testing techniques are well known and the same strategy is adopted during this
project testing.

5.2.1 UNIT TESTING:

Since this is a game which may have various forms of user input, it would
be nearly impossible to test every possible user combination. However,
testing functionality and likely user scenarios should be our overall goal
of testing Tic-Tac-Toe. Unit testing focuses verification effort on the
smallest unit of software design- the software component or module. The
unit test is white-box oriented.
The unit testing is implemented in every module of this project by giving
correct manual input to the system, the inputted data are stored in database and
can be retrieved. If you want required module to access input or get the output
from the End user, any error will accrue that time will provide handler to show
what type of error will accrued.

5.2.2 INTEGRATION TESTING:

First and most importantly we will ensure the tkinter builds and runs without
errors. Also make sure it still works while embedded. GUI should display
correctly on the root window. There should be no states which freeze the game.
Switching between the players should update seamlessly and no logical errors
should occur. All warnings (highlights) should be identified by the game state
and displayed correctly by the GUI. All in all, a full game should be playable
without programming or logical errors.
 22

5.2.3 SYSTEM TESTING:

System testing is actually a series of different tests whose primary

purpose is to fully exercise the computer-based system. Below we have
described the two types of testing which have been taken for this project.
it is to check all modules worked on input basis. If you want change any
values or inputs, it will change all information, so specified input is must.
System testing can be stated as the process of validating and verifying
that a computer program/ application / product:

● Meets the requirements that guided its design and development

● Works as expected

● Can be implemented with the same characteristics

● Satisfies the needs of stakeholders.

 24

6. SYSTEM IMPLEMENTATION

6.1 PURPOSE:

System implementation is the important stage of project when the theoretical

design is tuned into practical system. The main stages in the implementation
are as follows:

● Planning

● Training

● System testing and

● Changeover Planning

Planning is the first task in the system implementation. At the time of

implementation of any system people from different departments and system
analysts involve. They are confirmed to practical problem of controlling
various activities of people outside their own data processing departments.

6.2 SYSTEM MAINTENANCE:

Software maintenance is far more than finding mistakes. Provision must be

made for environment changes, which may affect either the computer, or other
parts of the computer- based systems. Such activity is normally called
maintenance. It includes both the improvement of the system functions and the
corrections of faults, which arise during the operation of a new system. It may
involve the continuing involvement of a large proportion of computer
department recourses. The main task may be to adapt existing systems in a
changing environment. Back up for the entire database files are taken and stored
in storage devices like
 25

flash drives, pen drives and disks so that it is possible to restore the system at
the earliest. If there is a breakdown or collapse, then the system gives provision
to restore from database files. We focus on four types of maintenance:

● Adaptive M a i n t e na nc e

● Perfective M a i n t e nan ce

● Corrective M a i n t e n a n c e

● Preventive M a i n t e na nc e
 26

7. APPENDICES

7.1 PROGRAM LISTING

from tkinter import * 2
WINDOW_SIZE = 400
GRID_LINE_WIDTH = 2
SYMBOL_WIDTH = WINDOW_SIZE/80
SYMBOL_SIZE = 0.375
X_COLOR = 'deep sky blue4'
O_COLOR = 'tomato'
DRAW_SCREEN_COLOR = 'light sea
green'
GRID_COLOR = 'black'
3 FIRST_PLAYER = 2
CELL_SIZE = WINDOW_SIZE / 3
STATE_TITLE_SCREEN = 0
STATE_X_TURN = 1
STATE_O_TURN = 2
STATE_GAME_OVER = 3
EMPTY = 0
X=1
O=2
class Game(Tk):
 27

def __init__(self):
Tk.__init__(self)
self.canvas = Canvas(height=WINDOW_SIZE,
width=WINDOW_SIZE, bg='white')
self.canvas.pack()
self.bind('<x>', self.exit)
self.canvas.bind('<Button-1>', self.click)
self.gamestate = STATE_TITLE_SCREEN
self.title_screen()
self.board = [
[EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY]]
def title_screen(self):
self.canvas.delete('all')
self.canvas.create_rectangle(0, 0,WINDOW_SIZE,
WINDOW_SIZE,fill='white',outline='')
self.canvas.create_rectangle( int(WINDOW_SIZE/15),
int(WINDOW_SIZE*15/15),
int(WINDOW_SIZE*14/15),
int(WINDOW_SIZE*14/15),
outline='')
self.canvas.create_rectangle( int(WINDOW_SIZE/10),
int(WINDOW_SIZE*10/10),
int(WINDOW_SIZE*9/10),
int(WINDOW_SIZE*9/10),
fill='light blue', outline='')
 28

self.canvas.create_text(WINDOW_SIZE/2,
WINDOW_SIZE/3,

text='TIC TAC TOE', fill='black',

font=('Calibri', int(-WINDOW_SIZE/12),
'bold underline'))
self.canvas.create_text(int(WINDOW_SIZE/2),
int(WINDOW_SIZE/2.5),
text='[click to play]', fill='purple',
font=('Arial', int(-WINDOW_SIZE/25)) )
def new_board(self):
self.canvas.delete('all')
self.board = [
[EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY],
[EMPTY, EMPTY, EMPTY] ]
for n in range(1, 3):
self.canvas.create_line(CELL_SIZE*n, 0,
CELL_SIZE*n, WINDOW_SIZE,
width=GRID_LINE_WIDTH,
fill=GRID_COLOR)
self.canvas.create_line(0, CELL_SIZE*n,
WINDOW_SIZE, CELL_SIZE*n,
width=GRID_LINE_WIDTH,fill=GRID_COLOR )
 29

def gameover_screen(self, outcome):

self.canvas.delete('all')
if outcome == 'X WINS':
wintext = 'X wins'
wincolor = 'light green'
elif outcome == 'O WINS':
wintext = 'O wins'
wincolor = 'gold2'
elif outcome == 'DRAW':
wintext = 'Draw'
wincolor = DRAW_SCREEN_COLOR
self.canvas.create_rectangle( 0, 0,
WINDOW_SIZE, WINDOW_SIZE,
fill=wincolor, outline='')
self.canvas.create_text(int(WINDOW_SIZE/2),
int(WINDOW_SIZE/2),
text=wintext, fill='black',
font=('Calibri',int(-WINDOW_SIZE/6),
'bold'))
self.canvas.create_text(
int(WINDOW_SIZE/2),int(WINDOW_SIZE/1.65),
text='[Click to play again]',
fill='purple', font=('Arial',
int(-WINDOW_SIZE/25)) )
 30

def click(self, event):

x = self.pixel_to_grid(event.x)
y = self.pixel_to_grid(event.y)
if self.gamestate == STATE_TITLE_SCREEN:
self.new_board()
self.gamestate = FIRST_PLAYER
elif(self.gamestate==STATE_X_TURN and
self.board[y][x]==EMPTY):
self.new_move(X, x, y)
if self.has_won(X):
self.gamestate = STATE_GAME_OVER
self.gameover_screen('X WINS')
elif self.is_a_draw():
self.gamestate = STATE_GAME_OVER
self.gameover_screen('DRAW')
else:
self.gamestate = STATE_O_TURN
elif(self.gamestate==STATE_O_TURN and
self.board[y][x]==EMPTY):
self.new_move(O, x, y)
if self.has_won(O):
self.gamestate = STATE_GAME_OVER
self.gameover_screen('O WINS')
elif self.is_a_draw():
self.gamestate = STATE_GAME_OVER
self.gameover_screen('DRAW')
else:
 31

self.gamestate = STATE_X_TURN
elif self.gamestate == STATE_GAME_OVER:
self.new_board()
self.gamestate = FIRST_PLAYER
def new_move(self, player, grid_x, grid_y):
if player == X:
self.draw_X(grid_x, grid_y)
self.board[grid_y][grid_x] = X
elif player == O:
self.draw_O(grid_x, grid_y)
self.board[grid_y][grid_x] = O
def draw_X(self, grid_x, grid_y):
x = self.grid_to_pixel(grid_x)
y = self.grid_to_pixel(grid_y)
delta = CELL_SIZE/2*SYMBOL_SIZE
self.canvas.create_line( x-delta, y-delta,
x+delta, y+delta,
width=SYMBOL_WIDTH, fill=X_COLOR)
self.canvas.create_line( x+delta, y-delta,
x-delta, y+delta,
width=SYMBOL_WIDTH, fill=X_COLOR)

def draw_O(self, grid_x, grid_y):

x = self.grid_to_pixel(grid_x)
y = self.grid_to_pixel(grid_y)
delta = CELL_SIZE/2*SYMBOL_SIZE
 32

self.canvas.create_oval( x-delta, y-delta,

x+delta, y+delta,
width=SYMBOL_WIDTH, outline=O_COLOR )
def has_won(self, symbol):
for y in range(3):
if self.board[y] == [symbol, symbol, symbol]:
return True
for x in range(3):
if self.board[0][x]==self.board[1][x]==self.board[2][x]==symbol:
return True
if self.board[0][0]==self.board[1][1]==self.board[2][2]==symbol:
return True
elif self.board[0][2]==self.board[1][1]==self.board[2][0]==symbol:
return True
return False

def is_a_draw(self):
for row in self.board:
if EMPTY in row:
return False
return True
def grid_to_pixel(self, grid_coord):
pixel_coord = grid_coord * CELL_SIZE + CELL_SIZE / 2
return pixel_coord
 33

grid_coord = int(pixel_coord / CELL_SIZE)

return grid_coord

def exit(self, event):

self.destroy()

def main():
root = Game()
root.title("TIC TAC TOE")
root.mainloop()

main()
 34

7.2 SCREEN SHOTS:

35
36
 37

8. BIBLIOGRAPHY

BOOKS REFERENCES:

1. A Practical Introduction to python Programming BRIANHEINHOLD.

2. Invent Your Own Computer Games with Python 3rd Edition ALSWEIGART.

WEBSITES:

1 . h t t p://c ode pr oje ct.c

o m/
2 . h t t ps ://e ffbot.org/
3 . h t t p://s ta c kove rflo
w.c o m/
4 . h t t ps ://yo utube .c om
/