TITLES OF MINI PROJECT DESCRIPTION

 
   1     ABSTRACT 
                                   2.     INTRODUCTION 

2.1    Objective 
   3     SYSTEM ANALYSIS 
3.1. Existing System 
3. 2    Proposed System
3.3 Feasibility Study 
3.3.1 Economical Feasibility 
3.3.2 Technical Feasibility 
3.3.3 Operational Feasibility 
  4 SYSTEM SPECIFICATION 
4.1 Hardware Specification 
4.2 Software Specification 
   5   SOFTWARE DESCRIPTION 
                    5.1 Python 3 6.0 IDLE 2016 
                              5.2 Development Tools and Technologies 

               5.2.1 Python 3 

         5.22 GUI DESCRIPTIONS 
                6.1 Problem Definition 
6.2 Overview of the project 
6.3 Module Description 
6.4 System Flow Diagram 6.5 Data
Flow Diagram (DFD) 
6.6 Use case Diagram 
6.7 Input Design 
6.8 Output Design 
7 SYSTEM TESTING 
7.1 Introduction 
7.2 Testing Methodologies 
7.2.1 Unit Testing 
7.22 Integration Testing 
7.2.3 System Testing 
7.24 Performance Testing 
8 SYETEM IMPLEMENTATION 
8.1 Purpose 
8.2 System Maintenance 
9 CONCLUSIONS AND FUTURE
ENHANCEMENT 
9.1 Conclusion 
9.2 Scopes for Future Enhancement 
10 APPENDICES 
10.1 Program Listing 
10.2 Screen Shots 
 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 Nougats and crosses was made in 1864 in a British novel called Can You Forgive
Her. For many years the game was referred to as nougats and crosses but was changed in the 20th
century by the United States to TIC TAC тоЕ. 

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. 
         

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 onentation 

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 Solution
# 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, and game over screen etc. And
according to the moves played by the players this project will display the result in very attractive
format 

EXISTING SYSTEM: 

The Existing system is a simple game to play with paper and pencil between two people. Here the
whole process will be craned 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 renewal 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. 

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. 

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 

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, 

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

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 
 SYSTEM SPECIFICATION 
HARDWARE REQUIREMENT (minimum requirement] : 

# Minimum RAM: - 1GB 

# Minimum   Hard Disk: - 128GB 

Processor: - Intel Pentium 4(1.50 GHz) or

above 

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 

SOFTWARE DESCRIPTION 

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

DEVELOPMENT TOOLS AND TECHNOLOGIES 

PYTHON 3: 

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

programming language. It was created by Guido Van Possum 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 
# 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 

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 GUL 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 Conventionally there is a single canvas onto which the artist must put all the work In
GUI programming a top-level 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 
# 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 
PROJECT DESCRIPTION 

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 

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 

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 color as white now we want to realize the
effects that we are made in our root window. For that we have to use the 
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 (O) 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 color as the rectangle boundary color. 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 color 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 color. 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 favor of player 1, "O
Wins" appears on the screen in the form of a text. Similarly, if the outcome is in favor 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 color and inside that rectangle all the texts will appear. We've created the texts by
adjusting the text size, font style, text height, and text width and text color 
 
CLICK: 
This module handles most of the game logic Atkinter 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 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 Xs 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
color into that gnd. Now if the current player is 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, weve 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 color 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
color 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],[01),[0[2]) or ((1100).[111][1]
[2]) or ([200],[211][22]) or (010),[1][0],[210]) or ([011][111],[211]) or (0[2].[1][2][2][2]) or ([010].[111].
[212]) or (012][111],[210]) 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: 
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
center. 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. 
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. 
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. 
SYSTEM TESTING 

 
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 behavior and performance 
 
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. 

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 

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

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. 

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

SYSTEM IMPLEMENTATION 

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 

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 

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 nxn, 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 kl< n) consecutive marks/dots (filled by the user) is a
point/score. Or we can go even further and use a range of 
Number. 

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