TIC TAC TOE

in python 3
 1

GOUR MAHAVIDYALAYA
(Affiliated to UNIVERSITY OF GOUR BANGA
and Accredited by NAAC with B+ Grade)

MANGALBARI - 732 142

Department of Computer Science

MINI PROJECT WORK

MARCH 2018

This is to certify that the project entitled

TIC TAC TOE

is the bona fide record of mini project work done by

SHRABANTI DAS BISHAL GUPTA ANKUSH GHOSH

Registration No:1212368 Registration No:1212384 Registration No:1212348
Roll No: 1216CMSH-0020 Roll No: 1216CMSH-0007 Roll No: 1216CMSH-0001

of Bachelor of Computer Science during the year 2017-2018.

---------------------------- ------------------------------ ------------------------------

Project Guide Project Guide Head of the Department
Mr. Akhil Kumar Das Mr. Ekram Alam Mr. Arijit Bhattacharya
(Assistant Professor) (Assistant Professor) (Assistant Professor)

Submitted for the Mini Project Viva-Voce examination held on -------------------------------

--------------------------- ----------------------------
Internal Examiner External Examiner
 2

DECLARATION

We affirm that the mini project work titled “TIC TAC TOE” being submitted in partial
fulfilment for the award of Bachelor of Computer Science is the original work carried out by
us. It has not formed the part of any other project work submitted for award of any degree or
diploma, either in this or any other University.

(Signature of the Candidate) (Signature of the Candidate)

SHRABANTI DAS ANKUSH GHOSH
Registration No.: 1212368 Registration No.:1212348
Roll No. : 1216CMSH-0020 Roll No. : 1216CMSH-0001
Session: 2015-2016 Session: 2015-2016
 3

ACKNOWLEDGEMENTS

I take this opportunity to express my gratitude to our guide,

Professor Mr. Arijit Bhattacharya, Head of Dept. of Computer
Science for his valuable suggestion and noble guidance at all
stages of this project study.

I also express our sincere thanks to our other Professors Mr.

Ekram Alam, Mr. Avjit Ghosh, and Mr. Akhil Kumar Das for
giving us consistent encouragement, support and valuable
guidance throughout the course of the project without their
stable guidance this project would not have been achieved.

I am also thankful to the authority of “GOUR MAHAVIDYALAYA”

for their support in our project.

Our due thanks to our Principal Sir, Dr. Ashim Kumar Sarkar,
for his support throughout the course.

Finally, we would like to thank all those friends who are

involved directly and indirectly in completion of our project.
 4

TABLE OF CONTENTS

CHAPTER NO TITLE PAGE NO

1 ABSTRACT 4
2 INTRODUCTION 5
2.1 Objective 5
3 SYSTEM ANALYSIS 6
3.1 Existing System
3.2 Proposed System 7
3.3 Feasibility Study 7
3.3.1 Economical Feasibility 7
3.3.2 Technical Feasibility 7
3.3.3 Operational Feasibility 7
4 SYSTEM SPECIFICATION 8
4.1 Hardware Specification 8
4.2 Software Specification 8
5 SOFTWARE DESCRIPTION 9
5.1 Python 3.6.0 IDLE 2016
5.2 Development Tools and Technologies 9
5.2.1 Python 3 9
5.2.2 GUI 10
6 PROJECT DESCRIPTIONS 12
6.1 Problem Definition 12
6.2 Overview of the project 12
6.3 Module Description 12
6.4 System Flow Diagram 18
6.5 Data Flow Diagram(DFD) 19
6.6 Use case Diagram 20
6.7 Input Design 21
6.8 Output Design 21
 5

7 SYSTEM TESTING 22
7.1 Introduction 22
7.2 Testing Methodologies 22
7.2.1 Unit Testing 23
7.2.2 Integration Testing 23
7.2.3 System Testing 23
7.2.4 Performance Testing 23
8 SYETEM IMPLEMENTATION 24
8.1 Purpose 24
8.2 System Maintenance 24
9 CONCLUSIONS AND 25
FUTURE ENHANCEMENT
9.1 Conclusion 25
9.2 Scopes for Future Enhancement 25
10 APPENDICES 26
10.1 Program Listing 26
10.2 Screen Shots 30
11 BIBLIOGRAPHIES 33
 6

1. ABSTRACT

The game TIC TAC TOE had an early variant which began in the first century in
the Roman Empire. During that time, it was called Terni Lapilli where the
players only had three pieces and had to move around the empty spaces to play.
The actual game of TIC TAC TOE could be traced back to ancient Egypt. The
game was also known during that time as Three Men's Morris . The first
reference to Noughts and crosses was made in 1864 in a British novel called Can
You Forgive Her. For many years the game was referred to as noughts and
crosses but was changed in the 20th century by the United States to TIC TAC
TOE.

The purpose of this documentation is to capture all the requirements by which

the user can play a game of tic-tac-toe in Graphical User Interface as well as
they can develop a logic that what is actually happening.

`
 7

2. INTRODUCTION
2.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.
 8

3. 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
 Performing Trade Studies
 Performing Cost Benefit Analysis
 Recommending Alternative Solutions
 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.

3.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 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.
 9

3.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.

3.2.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.

3.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:

3.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.
 10

3.3.1 TECHNICAL FEASIBILITY:

The technical requirement for the system is economic and it doesn’t use any
other 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 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.

3.3.1 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.

4. SYSTEM SPECIFICATION

4.1 HARDWARE REQUIREMENT [minimum requirement]:

 Minimum RAM: - 1GB

 Minimum Hard Disk: - 128GB
 Processor: - Intel Pentium 4(1.50 GHz) or above

4.1 SOFTWARE REQUIREMENT [minimum requirement]:

 Operating System: - Support for both LINUX and WINDOWS users

 Back End: - Python 3.6.0 Interpreter
 Front End Language: - Python3
 Front Design: - Tkinterface
 11

5. SOFTWARE DESCRIPTION

5.1 PYTHON 3.6.0 IDLE 2016

IDLE stands for Integrated Development and Learning Environment is an integrated

development environment for python. It has been bundled with the default implementation of
the language since 1.5.2b.1. It is packaged as an optional part of the python packaging with
many Linux distribution. It is completely written in python3 and Tkinter GUI toolkit. IDLE is
intended to be a simple IDE and suitable for beginners as well as advanced users. To that
end it is cross platform and avoids feature clutter. The features provided by the IDLE
includes:

 Python shell with syntax highlighting.

 Integrated debugger with stepping, persistent breakpoints and call stack

visibility.

 Multi-window text editor with syntax highlighting, auto completion, smart

indenting etc.

5.2 DEVELOPMENT TOOLS AND TECHNOLOGIES

5.2.1 PYTHON 3:

Python is a general purpose interpreted, interactive, object-oriented, and high-level

programming language. It was created by Guido Van Rossum during 1985-1990.
Like Perl, Python source code is also available under the GNU General Public
License (GPL). Python is named after a TV show called ‘‘Monty Python’s Flying
Circus’’.

Python 3.0(also called “Python 3000” or “Py3K”) was released in December 3,

2008. The latest version of python accumulated new and redundant ways to program
the same task, Python 3.6 had an emphasis on removing duplicative constructs and
modules, in keeping with “There should be one and preferable only one – obvious
way to do it”. Python’s dynamic typing encourage the programmer to write a code
that is clear, well structured as well as easy to understand. The features of dynamic
typing are:
 12

 Types are bound to values but not to variables.

 Function and method lookup is done at runtime.
 Values are inspect-able.
 There is an interactive interpreter, more than one, in fact.
 You can list the methods supported by any given object.

Because code is automatically compiled to byte code and executed, Python is

suitable for use as a scripting language, Web application implementation language
etc. Because of its strong structuring constructs (nested code blocks, functions,
classes, modules and packages) and its consistent use of objects and OOP, Python
enables you to write clear and logical code for small and large projects.

5.2.2 GUI (GRAPHICAL USER INTERFACE):

Our goal in this article is to provide you with an introductory of GUI programming. In
order to learn the GUI programming, you must first understand a few core aspects of
GUI. So let’s begin the discussion. The primary GUI toolkit will be using Tk, Python’s
default GUI. We’ll access Tk from its python interface called Tkinter. It is not the
latest and greatest nor does it have the most robust set of GUI building blocks, but it
is fairly simple to use and using it, you can build GUI’s that run on most platforms.
Setting up GUI application is similar to how an artist produces a painting. Conventio-
nally there is a single canvas onto which the artist must put all the work. In GUI
programming a toplevel root windowing object contains all of the little windowing
objects that will be a part of your GUI application. These can be text labels, buttons,
list boxes etc. These individual little GUI components are known as widgets. Top
level windows are those that show up stand alone as part of your application.
Interestingly, you can have more than one top level window for your GUI, but only
one of them should be your root window.

The top level window can be created using this:

import tkinter
top=tkinter.Tk()
The object returned by tkinter.Tk( ) is usually referred to as the root window.
Within this window you can place multiple component pieces together to form your
GUI. Tk has three geometry managers that help with positioning your widget set.
 13

 Placer: You provide the size of the widgets and locations to place them,
this manager then places them for you.
 Packer: It packs widgets into the correct places.

 Grid: It is used to specify GUI widget placement based on grid

coordinates.

Now once the packer has determined the sizes and alignments of your widgets, it will
then place them on the screen for you. When all the widgets are in place we instruct
the application to infinite main loop. In Tkinter the code that does it is:

Tkinter.mainloop()

This is normally the last piece of sequential code your program runs.
 14

6. PROJECT DESCRIPTION

6.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.

6.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.

6.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 top 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.
 15

 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.

 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.
 16

 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 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 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
 17

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:

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
 18

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.

 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.
 19

 GRID TO PIXELS:
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.

 EXIT:
This module is used for closing the root window permanently. In this module
we ve passed event as an argument based upon this event the window can be
closed. We want the access from the current instance in our exit () method
which is done through self.

self.destroy()

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

6.4 SYSTEM FLOW DIAGRAM

 21

6.5 DATA FLOW DIAGRAM

 22

6.6 USE CASE DIAGRAM

Start Game

Player 1
moves

Player 2
moves

Check the
result

Player 1 Player 2

Play again
 23

6.7 INPUT DESIGN:

Input design is part of overall system design that requires special attention
designing input data is to make the data entered easy and free from errors. The
input forms are designed using the controls available in PYTHON
INTERPRETER. Validation is made for each and every event that is happened.
Help (how to play the game) information is provided for the users during when
the players feels difficult.
Input design is the process of converting the user originated inputs to a
computer-based format. A system user interacting through a workstation must
be able to tell the system whether to accept the input to produce reports. The
collection of input data is considered to be most expensive part of the system
design. Since the input has to be planned in such a manner so as to get relevant
information, extreme care is taken to obtain pertinent information.

6.8 OUTPUT DESIGN:

Output design this application TIC TAC TOE” generally refers to the results
and information that are generated by the system for many end-users; output is
the main reason for developing the system and the basis on which they evaluate
the usefulness of the application.
The output is designed in such a way that it is attractive, convenient and
informative. Board is designed with various features, which make the console
output more pleasing. As the outputs are the most important sources of
information to the users, better design should improve the system s
relationships with us and also will help in decision making. Form design
elaborates the way output is presented and the layout available for capturing
information.
One of the most important factors of the system is the output it produces.
This system refers to the results and information generated. Basically, the
output from a computer system is used to communicate the result of processing
to the user.
 24

7. SYSTEM TESTING

7.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.

7.1.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.

7.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 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.

7.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
 25

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.

7.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.

7.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.

7.2.4 PERFORMANCE TESTING:

Performance testing is designed to test the run-time performance

of the software within the context of an integrated system.
Performance testing occurs throughout all steps in the testing
process. Even at the unit level, the performance of an individual
module may be assessed as white-box tests are conducted.
 26

8. SYSTEM IMPLEMENTATION

8.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.

8.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 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 Maintenance
 Perfective Maintenance
 Corrective Maintenance
 Preventive Maintenance
 27

9. CONCLUSION AND FUTURE ENHANCEMENTS

 ALLOW THE PLAYERS TO CHOOSE THE MODE OF THE GAME:

An option to select the mode of the game that is whether the player wants to play the game
with his/her friends or with the machine.

 ALLOW THE PLAYERS TO DEFINE THE METRICS:

An option to increase the board to size to n x n, where n can be any positive number (>0).
This will increase the complexity of the code and when added with artificial intelligence will
greatly make the game robust. Also, we can add a feature where k(< n) consecutive
marks/dots (filled by the user) is a point/score. Or we can go even further and use a range of
number n.

 INTRODUCTION OF ARTIFICIAL INTELLIGENCE:

An option of playing against the computer (machine) can be added too. An algorithm can be
implemented for the machine based on actual rules a player uses to fill the Tic-Tac-Toe
board. This can pose a challenge to the user when playing.

 INTRODUCTION OF DIFFICULTY LEVELS:

One option to select the difficulty levels of the game can be added. We would also like to
create a computer AI that offered increasing resistance as the difficulty level increased.

 USER PROFILES AND SCORES:

One of the other enhancements could be that users can create their profiles and save their
scores.

 IN-GAME ASSISTANT:

An option to include an Assistant which will provide hints and suggestions to the user when
playing against a bot.
 28

10. APPENDICES

10.1 PROGRAM LISTING

1 from tkinter import *
2
3 WINDOW_SIZE = 400
4 GRID_LINE_WIDTH = 2
5 SYMBOL_WIDTH = WINDOW_SIZE/80
6 SYMBOL_SIZE = 0.375
7 X_COLOR = 'deep sky blue4'
8 O_COLOR = 'tomato'
9 DRAW_SCREEN_COLOR = 'light sea green'
10 GRID_COLOR = 'black'
11 FIRST_PLAYER = 2
12 CELL_SIZE = WINDOW_SIZE / 3
13 STATE_TITLE_SCREEN = 0
14 STATE_X_TURN = 1
15 STATE_O_TURN = 2
16 STATE_GAME_OVER = 3
17 EMPTY = 0
18 X = 1
19 O = 2
20
21 class Game(Tk):
22
23 def __init__(self):
24 Tk.__init__(self)
25 self.canvas = Canvas(height=WINDOW_SIZE,
width=WINDOW_SIZE, bg='white')
26 self.canvas.pack()
27 self.bind('<x>', self.exit)
28 self.canvas.bind('<Button-1>', self.click)
29 self.gamestate = STATE_TITLE_SCREEN
30 self.title_screen()
31 self.board = [
32 [EMPTY, EMPTY, EMPTY],
33 [EMPTY, EMPTY, EMPTY],
34 [EMPTY, EMPTY, EMPTY]]
35
36 def title_screen(self):
37 self.canvas.delete('all')
38 self.canvas.create_rectangle(0, 0,WINDOW_SIZE,
WINDOW_SIZE,fill='white',outline='')
39 self.canvas.create_rectangle( int(WINDOW_SIZE/15),
int(WINDOW_SIZE/15),
40 int(WINDOW_SIZE*14/15),
int(WINDOW_SIZE*14/15),
41 outline='')
42 self.canvas.create_rectangle( int(WINDOW_SIZE/10),
int(WINDOW_SIZE/10),
43 int(WINDOW_SIZE*9/10),
int(WINDOW_SIZE*9/10),
44 fill='light blue', outline='')
 29

45 self.canvas.create_text(WINDOW_SIZE/2, WINDOW_SIZE/3,
46 text='TIC TAC TOE', fill='black',
47 font=('Calibri', int(-WINDOW_SIZE/12),
'bold underline'))
48 self.canvas.create_text(int(WINDOW_SIZE/2),
int(WINDOW_SIZE/2.5),
49 text='[click to play]', fill='purple',
50 font=('Arial', int(-WINDOW_SIZE/25)) )
51
52 def new_board(self):
53 self.canvas.delete('all')
54 self.board = [
55 [EMPTY, EMPTY, EMPTY],
56 [EMPTY, EMPTY, EMPTY],
57 [EMPTY, EMPTY, EMPTY] ]
58 for n in range(1, 3):
59 self.canvas.create_line(CELL_SIZE*n, 0,
60 CELL_SIZE*n, WINDOW_SIZE,
61 width=GRID_LINE_WIDTH,
fill=GRID_COLOR)
62 self.canvas.create_line(0, CELL_SIZE*n,
63 WINDOW_SIZE, CELL_SIZE*n,
64 width=GRID_LINE_WIDTH,fill=GRID_COLOR )
65
66 def gameover_screen(self, outcome):
67 self.canvas.delete('all')
68 if outcome == 'X WINS':
69 wintext = 'X wins'
70 wincolor = 'light green'
71 elif outcome == 'O WINS':
72 wintext = 'O wins'
73 wincolor = 'gold2'
74 elif outcome == 'DRAW':
75 wintext = 'Draw'
76 wincolor = DRAW_SCREEN_COLOR
77 self.canvas.create_rectangle( 0, 0,
78 WINDOW_SIZE, WINDOW_SIZE,
79 fill=wincolor, outline='')
80 self.canvas.create_text(int(WINDOW_SIZE/2), int(WINDOW_SIZE/2),
81 text=wintext, fill='black',
82 font=('Calibri',int(-WINDOW_SIZE/6),
'bold'))
83 self.canvas.create_text( int(WINDOW_SIZE/2),int(WINDOW_SIZE/1.65),
84 text='[Click to play again]',
fill='purple', font=('Arial',
85 int(-WINDOW_SIZE/25)) )
86
87 def click(self, event):
88 x = self.pixel_to_grid(event.x)
89 y = self.pixel_to_grid(event.y)
90 if self.gamestate == STATE_TITLE_SCREEN:
91 self.new_board()
92 self.gamestate = FIRST_PLAYER
93 elif(self.gamestate==STATE_X_TURN and self.board[y][x]==EMPTY):
94 self.new_move(X, x, y)
95 if self.has_won(X):
96 self.gamestate = STATE_GAME_OVER
97 self.gameover_screen('X WINS')
98 elif self.is_a_draw():
99 self.gamestate = STATE_GAME_OVER
100 self.gameover_screen('DRAW')
 30

101 else:
102 self.gamestate = STATE_O_TURN
103 elif(self.gamestate==STATE_O_TURN and self.board[y][x]==EMPTY):
104 self.new_move(O, x, y)
105 if self.has_won(O):
106 self.gamestate = STATE_GAME_OVER
107 self.gameover_screen('O WINS')
108 elif self.is_a_draw():
109 self.gamestate = STATE_GAME_OVER
110 self.gameover_screen('DRAW')
111 else:
112 self.gamestate = STATE_X_TURN
113 elif self.gamestate == STATE_GAME_OVER:
114 self.new_board()
115 self.gamestate = FIRST_PLAYER
116
117 def new_move(self, player, grid_x, grid_y):
118 if player == X:
119 self.draw_X(grid_x, grid_y)
120 self.board[grid_y][grid_x] = X
121 elif player == O:
122 self.draw_O(grid_x, grid_y)
123 self.board[grid_y][grid_x] = O
124
125 def draw_X(self, grid_x, grid_y):
126 x = self.grid_to_pixel(grid_x)
127 y = self.grid_to_pixel(grid_y)
128 delta = CELL_SIZE/2*SYMBOL_SIZE
129 self.canvas.create_line( x-delta, y-delta,
130 x+delta, y+delta,
131 width=SYMBOL_WIDTH, fill=X_COLOR)
132 self.canvas.create_line( x+delta, y-delta,
133 x-delta, y+delta,
134 width=SYMBOL_WIDTH, fill=X_COLOR )
135
136 def draw_O(self, grid_x, grid_y):
137 x = self.grid_to_pixel(grid_x)
138 y = self.grid_to_pixel(grid_y)
139 delta = CELL_SIZE/2*SYMBOL_SIZE
140 self.canvas.create_oval( x-delta, y-delta,
141 x+delta, y+delta,
142 width=SYMBOL_WIDTH, outline=O_COLOR )
143
144 def has_won(self, symbol):
145 for y in range(3):
146 if self.board[y] == [symbol, symbol, symbol]:
147 return True
148 for x in range(3):
149 if self.board[0][x]==self.board[1][x]==self.board[2][x]==symbol:
150 return True
151 if self.board[0][0]==self.board[1][1]==self.board[2][2]==symbol:
152 return True
153 elif self.board[0][2]==self.board[1][1]==self.board[2][0]==symbol:
154 return True
155 return False
156
157 def is_a_draw(self):
158 for row in self.board:
159 if EMPTY in row:
160 return False
161 return True
 31

162
163 def grid_to_pixel(self, grid_coord):
164 pixel_coord = grid_coord * CELL_SIZE + CELL_SIZE / 2
165 return pixel_coord
166
167 def pixel_to_grid(self, pixel_coord):
168 if pixel_coord >= WINDOW_SIZE:
169 pixel_coord = WINDOW_SIZE - 1
170 grid_coord = int(pixel_coord / CELL_SIZE)
171 return grid_coord
172
173 def exit(self, event):
174 self.destroy()
175
176 def main():
177 root = Game()
178 root.title("TIC TAC TOE")
179 root.mainloop()
180
181 main()
 32

10.2 SCREEN SHOTS:

33
34
 35

11. BIBLIOGRAPHY

BOOKS REFERENCES:

1. Python Without Fear BRIAN OVERLAND.

2. Python and Tkinter Programming JOHN E. GRAYSON.

3. A Practical Introduction to python Programming BRIAN HEINHOLD.

4. Invent Your Own Computer Games with Python 3rd Edition AL SWEIGART.

5. The Coder’s Apprentice Learning Programming with Python 3 PIETER SPRONCK.

OTHER REFERENCES:

1. Tic Tac Toe Documentation Release 0.1 by Deterralba December 18, 2015.
2. International Journal of Computer Trends and Technology (IJCTT) –
volume 12 number2– Jun 2014 ISSN: 2231-2803 http://www.ijcttjournal.org/
Page71 Implementation of Tic-Tac-Toe Game in LabVIEW.
3. Interactive tic tac toe Stefan Bennie Botha.

WEBSITES:

1. https://effbot.org/
2. http://codeproject.com/
3. http://stackoverflow.com/