SONIYA GANDHI POLYTECHNIC

SHRIGONDA-413701

CERTIFICATE

This is to certify that the project entitled

Submitted by

Mr. Gaikwad .K.S 2111640080

Mr. Sayyad .S.S 2111640083

Mr. Hole .T.D 2111640094

Mr. Randive .S.R 2111640228

Is the Bonafide work completed in the academic year 2023-24 under my

supervision and guidance in partial fulfillment for award of "Diploma In
Computer Engineering "by Maharashtra state Board Of Technical Education.

Place:Shrigoanda

Prof. Gawade Mam Prof.Nagne Sir Prof.Nagawade A.B.

Project Guide]. [H.O.D]. [PRINCIPAL].

 A MICRO PROJECT REPORT

"The Ludo Game”

OF IN PARTIAL FULFILLENT OF THE REQUIRMENT OF

THE AWARD OF THE DIPLOMA

In

COMPUTER ENGINEERING

Mr. Gaikwad .K.S 2111640080

Mr. Sayyad .S.S 2111640083

Mr. Hole .T.D 2111640094

Mr. Randive .S.R 2111640228

Gawade Mam

MAHARASHTRA STATE OF TECHNICAL EDUCATION

(2023-2024)
 DECLARATION

We hereby declare that the Micro Project entitle "The Ludo Game"
was carried out and written by us under the guidance of Gawade Mam
Department of Computer Engineering, Soniya Gandhi Polytechnic,
Shrigonda . This work has not been previously formed the basis for the
award of any Diploma, Degree or Certificate.
Date:

Place: Shrigoanda

Name of student Enrollment no Sign

MR. Gaikwad .K.S 2111640080

Mr. Sayyad .S.S 2111640083

Mr. Hole .T.D 2111640094

Mr. Randive .S.R 2111640228

 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.
 5.0 Resources required:
Sr Name of
Specification Qty. Remarks
No Resource/Material
Desktop with Intel Core 2 -
Hardware Duo
1 1
Resource 2.93 GHz, RAM 2GB, HDD
160 GB
2 Software Resource Python IDE 1 -

3 Any Other Internet - -

Resource
 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. [email protected]

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

Sr
Name of Resource/Material Specification Qty. Remarks
No
Processor
1 Hardware Resource i3/HDD1TB/RAM- 1
8GB
2 Software Resource Python IDE 1
3 Any Other Resource Printer 1

5.0 Actual Resources Used:

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: print(linesep + error_mess)

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: print(linesep + error_mess)

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_players_info()

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.print_players_info()
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)

self.prompt_to_continue()

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.prompt_to_continue() 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
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.

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