Python MP (Ludo Game)

A
Micro Project Report

on
The Ludo Game

Submitted by
Siddhesh Jagdish Shelar
Jainul Jignesh Dave
Shreyash Kiran Dahale
Ojas Yogesh Joshi
Under the Guidance of
Prof.G.K.Gaikwad
In the Partial Fulfilment of Fifth Semester of Diploma in

Computer Engineering
Department of Computer Engineering

Sandip Polytechnic
Mahiravani, Nashik - 422213
Affiliated to
Maharashtra State
Board of Technical Education
Academic Year 2020-21

Maharashtra State
Certificate
This is to certify that Mr. Siddhesh Jagdish Shelar with Roll No- 12 has successfully completed Micro-
project in course Programming with Python(22616) for the academic year 2020-21 as prescribed in the
'Assessment Manual' during his/her tenure of completing Sixth Semester of Diploma Programme in
Computer Engineering from institute, Sandip Polytechnic with institute code 1167.
Place: Nashik Enrollment No: 1711670171
Date: //2021 Exam Seat No:
Course Teacher Head of the Department Head of the Institute

Annexure – I
Micro Project Proposal

1.0 Aims/Benefits of the Micro-Project:
Ludo is strategy board game, which can be played by 2 to 4 players with each player having a set of 4 pieces
(usually identified by color) placed in the starting zone, which is at the left corner for each player. By rolling the
dice, players race their four pieces on the board from start to finish, while trying to avoid being killed or captured
by their opponents.
The main objective for each player is to move all his/her tokens or pieces to the finish before his/her opponents. Of
course, en-route there are some more obstacles that the player has to overcome. Go through these step-by-step
instructions to get a better perspective on how to master this easy game.
2.0 Course Outcomes Addressed:

i. Display message on screen using Python script on IDE.
ii. Develop python program to demonstrate use of Operators
iii. Perform operations on data structures in Python.
iv. Develop functions for given problem.
v. Design classes for given problem.
vi. Handle exceptions.
3.0 Proposed Methodology:
A Use case is a description of set of sequence of actions graphically it is rendered as an

ellipse with solid line including only its name. Use case diagram is a behavioural diagram
that shows a set of use cases and actors and their relationship. It is an association between
the use cases and actors. An actor represents a real-world object.
Elements of the model
Player : This is modelled by a node type. Players can have an identifier or colour to
distinguish them. The cyclic order of players is typically modelled explicitly (through
edges).
Pawn : This is modelled by a node type. Each pawn belongs to a certain player; this is
typically modelled by an edge, or in some cases by an attribute.
Field : This is modelled by a node type. Entry and goal fields are special kinds of fields,
typically modelled by subtypes, or in some cases marked by special self-loops. The same
may be done for home fields, although these are not essential for the game (we left them
out of Fig. 2). Entry and goal (and home) fields belong to a player; this is typically
modelled by an edge. The position of a pawn (on a field) is likewise modelled by an
edge.
Board : This consists of all the fields and their interconnections, i.e., the next fields and
the junctions to the goal fields. The interconnections may be turned into nodes, but
typically will be modelled by edges. The board itself does not necessarily need a special
node, since all fields already implicitly belong to it.
Die : This is modelled by a (singleton) node, possibly of a special type but optionally
integrated with some existing node. The outcome of a die roll is then typically an
attribute of the die node.
Strategy : This is modeled by a node or an attribute value; a player can then be assigned
a strategy by adding an edge or attribute.
4.0 Action Plan:

Si Planned Planned Name of Responsible Team
Details of Activity
r Start Date Finish Date Members
No
1 Topic Discussion & Selection 11/12/1018 15/12/2018
2 Review of Literature 17/12/2018 22/12/2018
3 Aim/Benefits & Importance 24/12/2018 29/12/2018
4 Resources Required 31/12/2018 05/01/2019
5 Analysis of Collected Data 07/01/2019 12/01/2019

6 Design of System 14/01/2019 19/01/2019 o Siddhesh Jagdish
Shelar
7 Coding & Testing of Modules 21/01/2019 25/01/2019 o Jainul Jignesh Dave
o Shreyash Kiran
8 Coding & Testing of Modules 28/01/2019 02/02/2019 Dahale
9 Coding & Testing of Modules 04/02/2019 09/02/2019 o Ojas Yogesh Joshi
10 Integration of System Modules 11/02/2019 16/02/2019
11 Testing & Deployment of 18/02/2019 23/02/2019

System
12 Compilation of Report 25/02/2019 02/03/2019
13 Compilation of Presentation 05/03/2019 09/03/2019
14 Presentation of Seminar 11/03/2019 16/03/2019
15 Final Deployment of 18/03/2019 20/03/2019

Submission
5.0 Resources required:
Sr Name of
Specification Qty. Remarks
No Resource/Material
Desktop with Intel Core 2 Duo -
1 Hardware Resource 2.93 GHz, RAM 2GB, HDD 1
160 GB
Software Resource Python IDE -
2 1
3 Any Other Resource Internet - -
Name of Team Members with Roll Nos:
Roll No Name of Team Members

Siddhesh Jagdish Shelar
12
Jainul Jignesh Dave
01
Shreyash Kiran Dahale
08
Ojas Yogesh Joshi
57
Name & Signature of Course Teacher

(Prof. G.K.GAIKWAD)
Annexure – I
Micro Project Report
1.0 Rationale:
This is a Ludo game which is very easy to understand and use. Talking about the
gameplay, all the playing rules are the same just like we play in real time ludo. Here at first,
the user has to select players i.e. either human or computer. After selecting human, the player
has to enter details such as name and select colour (red, green, yellow and blue). the player
can also start the game within two players if he/she wants.After starting the game, a console
based ludo board appears, other rules are the same. First, the computer or the player has to
roll the dice.
The main thing in this console based game is that the player just has to press “Enter
Key” to roll the dice. At the top of the board, it displays a dice with the number. The system
keeps on rolling until there’s a possible pawn to move. All the game movements are
performed automatically. Whenever the player tries to end the game, there’s an option
available to save the unfinished game so that he/she can continue it later. A simple console
GUI is provided for the easy gameplay. The gameplay design is so simple that user won’t
find it difficult to use and understand. dheeraj.umardand@gmail.com

Aims/Benefits of the Micro-Project:
How to Play
1. Ludo player path.
2. Ludo Home.
3. Start area.
4. Move from starting square, clockwise around the perimeter.
5. No resting squares.
6. Player Identification colour.
Game Rules
1. Four pieces are placed in the start area of their colour.
2. Throw a single die.
3. First throw a six or one to move.
4. Player moves a piece forward 1 to 6 squares.
5. Six results in another turn.
6. Player can’t move, pass to next player.
7. Captured and returns to the starting area.
8. No doubling rules.
9. Advance to Home Square.

3.0 Course Outcomes Achieved:
i. Display message on screen using Python script on IDE.
ii. Develop python program to demonstrate use of Operators
iii. Perform operations on data structures in Python.
iv. Develop functions for given problem.
v. Design classes for given problem.
vi. Handle exceptions.
4.0 Actual Methodology Followed:
Figure : Spiral Model of Software Development
Figure shows the spiral model of software development. This model is combination of well-
known waterfall model and iterative prototyping. It yields rapid development of more complete
version of software. Using spiral model software is developed as series of
Evolutionary releases. During the initial releases, it may just paperwork or prototype. But during
later releases the version goes towards more completed stage.
The spiral model can be adopted to apply throughout entire lifecycle of the application from
concept development to maintenance. The spiral model is divided into set of framework activities
defined by software engineer team. The initial activity is shown from center of circle and
developed in clockwise direction. Each spiral of the model includes following four stages:
Planning Phase: This stage includes requirement gathering, cost estimation, resource allocation.
Risk Analysis Phase: This stage involves strengths and weaknesses of the project. Design Phase:
This stage includes coding, internal testing and deployment.
Evaluation Phase: Last stage involves client evaluation (client side testing) to get the feedback.
Various activities which are performed according to the spiral model phases are shownTab.
5.0 Actual Resources Used:
Sr
Name of Resource/Material Specification Qty. Remarks
No
Processor i3/HDD-
1 Hardware Resource 1
1TB/RAM-8GB
Python IDE
2 Software Resource 1
3 Any Other Resource Printer 1

Code :
from .game import Player, Game
from .painter import present_6_die_name
from .recorder import RunRecord, MakeRecord
from os import linesep
class CLIGame(): def
it (self):
self.prompt_end = "> "
self.game = Game() #
used for nicer print
self.prompted_for_pawn = False #
saving game data
self.record_maker = MakeRecord() #
getting game data self.record_runner =
None
def validate_input(self, prompt, desire_type, allawed_input=None,

error_mess="Invalid Option!", str_len=None):
'''
loop while receive correct value
param allowed_input can be list of allowed values
param str_len is two sized tuple if min and max
'''
prompt += linesep + self.prompt_end
while True:
choice = input(prompt) if
not choice:
print(linesep + error_mess)
continue
try:
choice = desire_type(choice)
except ValueError:
continue
if allawed_input:
if choice in allawed_input:
break
else:
print("Invalid Option!")
continue
elif str_len:
min_len, max_len = str_len
if min_len < len(choice) < max_len:
break
else:
else:
break
print()
return choice
def get_user_initial_choice(self):
text = linesep.join(["choose option",
"0 - start new game", "1
- continue game",
"2 - run (review) recorded game"])
choice = self.validate_input(text, int, (0, 1, 2)) return
choice
def prompt_for_file(self, mode="rb"):

'''return file descriptor'''
text = "Enter filename (name of the record)"
while True:
filename = self.validate_input(text, str)
try:
file_descr = open(filename, mode=mode)
return file_descr
except IOError as e:
print(e) print("Try
again")
def does_user_want_save_game(self):
'''return True if user want to save game
or False
'''
text = linesep.join(["Save game?", "0
- No",
"1 - Yes"])
choice = self.validate_input(text, int, (0, 1))
return choice == 1
def prompt_for_player(self):
''' get player attributes from input,
initial player instance and

add player to the game
'''
available_colours = self.game.get_available_colours()
text = linesep.join(["choose type of player",
"0 - computer",
"1 - human"])
choice = self.validate_input(text, int, (0, 1))
if choice == 1:
name = self.validate_input("Enter name for player",
str, str_len=(1, 30))
available_options = range(len(available_colours)) if
len(available_options) > 1:
# show available colours
options = ["{} - {}".format(index, colour) for
index, colour in zip(available_options,
available_colours)]
text = "choose colour" + linesep
text += linesep.join(options)
choice = self.validate_input(text, int, available_options)
colour = available_colours.pop(choice)
else:
# only one colour left
colour = available_colours.pop()
player = Player(colour, name, self.prompt_choose_pawn)
elif choice == 0:
# automatically assign colours
colour = available_colours.pop()
player = Player(colour)
self.game.add_palyer(player)
def prompt_for_players(self): '''put

all players in the game'''
counts = ("first", "second", "third", "fourth last")
text_add = "Add {} player"
for i in range(2):
print(text_add.format(counts[i]))
self.prompt_for_player()
print("Player added")
text = linesep.join(["Choose option:",
"0 - add player",

"1 - start game with {} players"]) for
i in range(2, 4):
choice = self.validate_input(text.format(str(i)), int, (0, 1)) if
choice == 1:
break
elif choice == 0:
print(text_add.format(counts[i]))
self.prompt_for_player()
print("Player added")
def print_info_after_turn(self):
'''it used game attributes to print info'''
pawns_id = [pawn.id for pawn in self.game.allowed_pawns] #
nicer print of dice
message = present_6_die_name(self.game.rolled_value,
str(self.game.curr_player)) message
+= linesep
if self.game.allowed_pawns: message_moved =
"{} is moved. ".format(
self.game.picked_pawn.id) if
self.prompted_for_pawn:
self.prompted_for_pawn = False
print(message_moved)
return
message += "{} possible pawns to move.".format( "
".join(pawns_id))
message += " " + message_moved if
self.game.jog_pawns:
message += "Jog pawn "
message += " ".join([pawn.id for pawn in self.game.jog_pawns])
else:
message += "No possible pawns to move."
print(message)
def print_standing(self):
standing_list = ["{} - {}".format(index + 1, player)
for index, player in enumerate(self.game.standing)]
message = "Standing:" + linesep + linesep.join(standing_list)
print(message)
def print_board(self):
print(self.game.get_board_pic())
def run_recorded_game(self):
'''get history of game (rolled_value
and index's allowed pawn) from
record_runner in order to replay game'''
self.load_recorded_players()
self.print_players_info()
self.prompt_to_continue()
for rolled_value, index in self.record_runner:
self.game.play_turn(index, rolled_value)
self.print_info_after_turn() self.print_board()
self.prompt_to_continue() self.print_board()
def continue_recorded_game(self):
'''move forward the game by calling
play_turn method to the moment where
game was interrupted.
'''
self.load_recorded_players()
self.record_players()
for rolled_value, index in self.record_runner:
self.game.play_turn(index, rolled_value)
self.record_maker.add_game_turn(
self.game.rolled_value, self.game.index)
self.print_info_after_turn()
self.print_board()
def record_players(self): '''save

players on recorder'''
for player in self.game.players:
self.record_maker.add_player(player)
def load_recorded_players(self): '''get

recorded (save) players from
recorder and put them in game
'''
if self.record_runner is None: file_descr
= self.prompt_for_file()
self.record_runner = RunRecord(file_descr)
file_descr.close()
for player in self.record_runner.get_players(
self.prompt_choose_pawn):
self.game.add_palyer(player)
def load_players_for_new_game(self):
self.prompt_for_players()
self.record_players()
def play_game(self): '''mainly

calling play_turn
Game's method while game finished '''
try:
while not self.game.finished:
self.game.play_turn()
self.print_info_after_turn()
self.print_board()
self.record_maker.add_game_turn(
self.game.rolled_value, self.game.index)
print("Game finished")
self.print_standing()
self.offer_save_game()
except (KeyboardInterrupt, EOFError):
print(linesep +
"Exiting game. " +
"Save game and continue same game later?")
self.offer_save_game()
raise
def offer_save_game(self):
'''offer user save game'''
if self.does_user_want_save_game():
file_descr = self.prompt_for_file(mode="wb")
self.record_maker.save(file_descr)
file_descr.close()
print("Game is saved")
def start(self):
'''main method, starting cli'''
print()
try:
choice = self.get_user_initial_choice() if
choice == 0: # start new game
self.load_players_for_new_game()
self.play_game()
elif choice == 1: # continue game
self.continue_recorded_game() if
self.game.finished:
print("Could not continue.",
"Game is already finished",
linesep + "Exit")
else:
self.play_game()
elif choice == 2: # review played game
self.run_recorded_game()
except (KeyboardInterrupt, EOFError):
print(linesep + "Exit Game")
if name == ' main ':
CLIGame().start()
def offer_save_game(self):
'''offer user save game'''
if self.does_user_want_save_game():
file_descr = self.prompt_for_file(mode="wb")
self.record_maker.save(file_descr)
file_descr.close()
print("Game is saved") def
start(self):
Outputs
1.
2.
3.
4.
7.1 Skilled Developed/Learning Outcome of
this Micro-Project:
a) Practical Outcomes:
 Understood current market strengths and weaknesses

 Learned better planning, management, facilitation and execution of projects
 Improved problem solving skills.
b) Unit Outcomes in Cognitive Domain:
 Recalled or retrieved previous information.

 Interpretation of instructions and problems.
 Utilization of known concept in implementation
 Troubleshoot small modules
 Selection of the most effective solution
c) Outcomes in Affective Domain:
 Awareness and willingness to listen others opinion

 Improved presentation skills
 Cooperation in group activities
CONCLUSION
Ludo is a simple board game, for two to four players, in which the
players race their four coins from start to finish according to dice rolls, and enjoy
game, all the playing regulations coincide similar to we play in real time ludo. Below
initially, the individual needs to select players.
Name & Signature of Course Teacher

(Prof.G.K.Gaikwad)
Annexure – IV
Micro Project Evaluation Sheet
Name of Student: Siddhesh Jagdish Shelar Enrollment No: 1711670171

Name of Program: Computer Engineering Semester: VI
Course Title: Programming with Python Course Code: 22616
Title of Micro Project: The Ludo Game
Learning Outcomes Achieved:

1. Display message on screen using Python script on IDE.
2. Develop python program to demonstrate use of Operators
3. Perform operations on data structures in Python.
4. Develop functions for given problem.
5. Design classes for given problem.
6. Handle exceptions.
Poor Average Good Excellent

Sr Sub
Characteristic to be Assessed Marks Marks Marks Marks
No Total
(1-3) (4-5) (6-8) (9-10)
(A) Process and Product Assessment (6 Marks)
1 Relevance to the Course
2 Literature Review/Information Collection
3 Completion of the Target as per Project Proposal
4 Analysis of Data & Representation
5 Quality of Prototype/Model
6 Report Preparation
(B) Individual Presentation/Viva (4 Marks)
7 Presentation
8 Viva
(A) (B)
Total Marks
Process and Product Assessment Individual Presentation/Viva
(10 Marks)
(6 Marks) (4 Marks)
Comments/Suggestions about Teamwork/Leadership/Inter-personal Communication (if any)

…………………………………..……………………………………………………………………………
Name & Designation of Course Teacher: Prof. G.K.Gaikwad, Lecturer
Dated Signature:
Annexure – IV
Name of Student:Jainual Jignesh Dave Enrollment No: 1611670124

Name of Program: Computer Engineering Semester: VI


Sr Sub
No Total
(1-3) (4-5) (6-8) (9-10)
7 Presentation
8 Viva
(A) (B)
Total Marks
(10 Marks)
(6 Marks) (4 Marks)

…………………………………..……………………………………………………………………………
Dated Signature:
Annexure – IV
Name of Student: Shreyash Kiran Dahale Enrollment No: 1711670155
Name of Programme: Computer Engineering Semester: V


Sr Sub
No Total
(1-3) (4-5) (6-8) (9-10)
7 Presentation
8 Viva
(A) (B)
Total Marks
(10 Marks)
(6 Marks) (4 Marks)
…………………………………..……………………………………………………………………………
Dated Signature:
Annexure – IV
Name of Student: Ojas Yogesh Joshi Enrollment No: 1811670507
Name of Programme: Computer Engineering Semester: V

Sr Sub
No Total
(1-3) (4-5) (6-8) (9-10)
1 R
e
l
e
v
a
n
c
e
t
o
t
h
e
C
o
u
r
s
e
2 L
i
t
e
r
a
t
u
r
e
R
e
v
i
e
w
/
I
n
f
o
r
m
a
t
i
o
n
C
o
l
l
e
c
t
i
o
n
3 C
o
m
p
l
e
t
i
o
n
o
f
t
h
e
T
a
r
g
e
t
a
s
p
e
r
P
r
o
j
e
c
t
P
r
o
p
o
s
a
l
4 A
n
a
l
y
s
i
s
o
f
D
a
t
a
&
R
e
p
r
e
s
e
n
t
a
t
i
o
n
5 Q
u
a
l
i
t
y
o
f
P
r
o
t
o
t
y
p
e
/
M
o
d
e
l
6 R
e
p
o
r
t
P
r
e
p
a
r
a
t
i
o
n
7 Presentation
8 Viva
(A) (B)
Total Marks
(10 Marks)
(6 Marks) (4 Marks)

…………………………………..……………………………………………………………………………
Dated Signature:
Maharashtra State
Certificate
This is to certify that Mr. Jainul Jignesh Dave with Roll No- 01 has successfully completed Micro-project
in course Programming with Python(22616) for the academic year 2021-22 as prescribed in the
'Assessment Manual' during his/her tenure of completing Fifth Semester of Diploma Program in Computer
Engineering from institute, Sandip Polytechnic with institute code 1167.
Maharashtra State
Certificate
This is to certify that Mr. Shreyash Kiran Dahale with Roll No- 08 has successfully completed Micro-
project in course Programming with Python(22616) for the academic year 2021-22 as prescribed in the
'Assessment Manual' during his/her tenure of completing Fifth Semester of Diploma Program in Computer
Engineering from institute, Sandip Polytechnic with institute code 1167.
Maharashtra State
Certificate
This is to certify that Mr. Ojas Yogesh Joshi with Roll No- 57 has successfully completed Micro-project in
course Programming with Python(22616) for the academic year 2021-22 as prescribed in the 'Assessment
Manual' during his/her tenure of completing Fifth Semester of Diploma Program in Computer Engineering
from institute, Sandip Polytechnic with institute code 1167.

Python MP (Ludo Game)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Python MP (Ludo Game)

Uploaded by

Copyright:

Available Formats

A

Micro Project Report

The Ludo Game

Under the Guidance of

In the Partial Fulfilment of Fifth Semester of Diploma in

Department of Computer Engineering

Academic Year 2020-21

Place: Nashik Enrollment No: 1711670171

Date: //2021 Exam Seat No:

Course Teacher Head of the Department Head of the Institute

Micro Project Proposal

2.0 Course Outcomes Addressed:

A Use case is a description of set of sequence of actions graphically it is rendered as an

Elements of the model

4.0 Action Plan:

2 Review of Literature 17/12/2018 22/12/2018

3 Aim/Benefits & Importance 24/12/2018 29/12/2018

4 Resources Required 31/12/2018 05/01/2019

5 Analysis of Collected Data 07/01/2019 12/01/2019

10 Integration of System Modules 11/02/2019 16/02/2019

11 Testing & Deployment of 18/02/2019 23/02/2019

13 Compilation of Presentation 05/03/2019 09/03/2019

14 Presentation of Seminar 11/03/2019 16/03/2019

15 Final Deployment of 18/03/2019 20/03/2019

5.0 Resources required:

Roll No Name of Team Members

Name & Signature of Course Teacher

roll the dice.

find it difficult to use and understand. dheeraj.umardand@gmail.com

4. Move from starting square, clockwise around the perimeter.

6. Player Identification colour.

2. Throw a single die.

3. First throw a six or one to move.

4. Player moves a piece forward 1 to 6 squares.

5. Six results in another turn.

6. Player can’t move, pass to next player.

7. Captured and returns to the starting area.

9. Advance to Home Square.

4.0 Actual Methodology Followed:

Figure : Spiral Model of Software Development

3 Any Other Resource Printer 1

class CLIGame(): def

def validate_input(self, prompt, desire_type, allawed_input=None,

def prompt_for_file(self, mode="rb"):

initial player instance and

def prompt_for_players(self): '''put

text = linesep.join(["Choose option:",

"0 - add player",

def record_players(self): '''save

def load_recorded_players(self): '''get

def play_game(self): '''mainly

 Understood current market strengths and weaknesses

b) Unit Outcomes in Cognitive Domain:

 Recalled or retrieved previous information.

c) Outcomes in Affective Domain:

 Awareness and willingness to listen others opinion

Name & Signature of Course Teacher

Micro Project Evaluation Sheet

Name of Student: Siddhesh Jagdish Shelar Enrollment No: 1711670171

Learning Outcomes Achieved:

Poor Average Good Excellent

Comments/Suggestions about Teamwork/Leadership/Inter-personal Communication (if any)

Micro Project Evaluation Sheet