A

MICRO PROJECT REPORT

ON

“The Ludo Game”

Under The Guidance

Mr. D.K. KAMBLE

DEPARTMENT OF COMPUTER ENGINEERING

K.P.PATIL INSTITUTE OF TECHNOLOGY (POLY)
MUDAL-416209
Academic Year
2024-25
 K.P.PATIL INSTITUTE OF TECHNOLOGY, MUDAL.
MICRO PROJECT ON

“The Ludo Game”

CLASS: SIXTH SEMESTER

COURSE: COMPUTER ENGINEERING

SR.NO STUDENT NAME ENROLLMENT NO.

1. NADIR J.MALANGFAKIR 2216610073

Signature of Signature of Signature of

Teacher Guide Head of Department Principal
 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 thauser

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.
vii.
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
No Name of Resource/Material Specification Qty. Remarks
Processor i3/HDD-
1 Hardware Resource 1TB/RAM-8GB 1
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:
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):
OUTPUT:-
CONCLUSION
The Ludo Game project developed in Python has been a successful implementation of the
classic board game in a digital environment. Using Python's libraries such as pygame, we
recreated the traditional rules and gameplay mechanics in an interactive format. The project
enhanced our understanding of game loops, event handling, graphics rendering, and object-
oriented programming. It also demonstrated how Python can be effectively used for building
engaging GUI-based games. Overall, this project not only improved our programming skills but
also provided insight into real-world application development using Python.
REFERENCES

• https://www.studocu.com/in/document
• https://www.google.com/python