Chaupar Game App

Microproject Proposal
Microproject for information about
A Chaupar Game App
a) To create game and get more knowledge about gaming application of python. We have chosen this microproject
to get knowledge about apps in python programming language

b) Because of the micro project now we have get deep knowledge.

Course Outcomes Addressed-

a) Develop functions for given problem

b) Design classes for given Problem
c) Handle exceptions

3.0 Proposed Methodology

Collect the information of A Pachisi Game and its Working. A Pachisi Game also include the methodology and
various info. detail. I searched the micro project topics related to subject. Then selected micro project title. After
selection of topic searched and collected information related to selected topic. Then completed proposal of micro
project.

4.0 Action Plan

Sr. No Details of activity Planned Planned Name of Responsible

Start Date Finish Date Team Members

1 Decide individual micro project Priyanka Gulab

Pokharkar
2 Search micro project topics Priyanka Gulab
related to subject. Pokharkar

3 Selection of micro project title Priyanka Gulab

Pokharkar

4 Search information related to Priyanka Gulab

selected topic Pokharkar

5 Collect information related to Priyanka Gulab

selected topic Pokharkar

6 Completion of micro project Priyanka Gulab

topic Proposal Pokharkar
7 Analyze collected data for Priyanka Gulab
micro-Project report. Pokharkar

Samarth Polytechnic , Belhe

Chaupar Game App

8 Finalize collected data For Priyanka Gulab

micro-Project report. Pokharkar

9 Finalize Design & flow of Priyanka Gulab

Implementation Pokharkar

10 Flow of Implementation Priyanka Gulab

Pokharkar
11 Implementation of report Priyanka Gulab
Pokharkar
12 Report preparation Priyanka Gulab
Pokharkar
13 Report preparation Priyanka Gulab
Pokharkar
14 Submission of report Priyanka Gulab
Pokharkar

Names of Team Members Roll No.

Priyanka Gulab Pokharkar 8

(To be Approved by the concerned teacher)

***************

Samarth Polytechnic , Belhe

Chaupar Game App

Project REPORT
ON

“A Chaupar Game ”

SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR THE AWARD

OF

DIPLOMA IN

COMPUTER ENGINEERING

SUBMITTED TO
MAHARASHTRA STATE BOARD OF TECHNICAL EDUCATION,
MUMBAI

SUBMITTED BY

Name of Student Enrollment Number

Priyanka Gulab Pokharkar 2009920097

GUIDED BY
(Prof. Kedar.A.L)

SAMARTH POLYTECHNIC, BELHE

Samarth Polytechnic , Belhe
Chaupar Game App

CERTIFICATE

This is to certify that the project report entitled “A Chaupar game” Was successfully
completed by Student of Sixth semester Diploma in computer engineering.

Priyanka Gulab Pokharkar

In partial fulfillment of the requirements for the award of the Diploma in Computer
engineering and submitted to the Department of Computer of Samarth Polytechnic,
Belhe work carried out during a period for the academic year 2022-23 as per
curriculum.

Prof.KEDAR.A.L Prof.Navale S.K Prof. Kapile A.S.

(Subject Teacher) (H.O.D) (Principal)

Samarth Polytechnic , Belhe

Chaupar Game App

ACKNOWLEDGMENT

This project is done as a sixth semester project, as a part course titled “Chaupar App”

I am really thankful to our course the Principal Prof. Kapile A. S. and the HOD Prof.Navale
S.k of Samarth Polytechnic, Belhe for his invaluable guidance and assistance, without which the
accomplishment of the task would have never been possible.

I also thank Prof.Kedar.A.L for giving this opportunity to explore into the real world and realize
the interrelation without which a Project can never progress. In our present project I have chosen the topic
“Chaupar App”

I also thankful to parents, friend and all staff of Computer engineering department, for providing
us relevant information and necessary clarifications, and great support

Samarth Polytechnic , Belhe

Chaupar Game App

Samarth Polytechnic , Belhe

Chaupar Game App

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

Samarth Polytechnic , Belhe

Chaupar Game App

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 Duo -
1 Hardware Resource 2.93 GHz, RAM 2GB, HDD 1
160 GB
Software Resource Python IDE -
2 1
3 Any Other Resource Internet - -

Samarth Polytechnic , Belhe

Chaupar Game App

Samarth Polytechnic , Belhe

Chaupar Game App

Annexure – I
Micro Project Report
1.0 Rationale:

This is a Chaupar 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

Samarth Polytechnic , Belhe

Chaupar Game App

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.

Samarth Polytechnic , Belhe

Chaupar Game App

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
Samarth Polytechnic , Belhe
Chaupar Game App

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

Samarth Polytechnic , Belhe

Chaupar Game App

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
Samarth Polytechnic , Belhe
Chaupar Game App

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 andadd

player to the game
'''
available_colours = self.game.get_available_colours()text

Samarth Polytechnic , Belhe

Chaupar Game App

= 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" + lineseptext
+= 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]))

Samarth Polytechnic , Belhe

Chaupar Game App

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_movedif
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_valueand
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)

Samarth Polytechnic , Belhe

Chaupar Game App

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

Samarth Polytechnic , Belhe

Chaupar Game App

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

Samarth Polytechnic , Belhe

Chaupar Game App

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

Samarth Polytechnic , Belhe

Chaupar Game App

1.

2.

Samarth Polytechnic , Belhe

Chaupar Game App

3.

4.

Samarth Polytechnic , Belhe

Chaupar Game App

7.0 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
Samarth Polytechnic , Belhe
Chaupar Game App

CONCLUSION

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

Samarth Polytechnic , Belhe

Chaupar Game App

ANNEXURE-II

Evaluation Sheet for Micro Project

Academic Year: -2022-23 Name of Faculty: - Prof.Kedar.A.L

Course: Computer Course Code: -22617 Semester: - VI

Title of Project: “Chaupar Game App”

Cos addressed by the Micro Project:-

d) Develop functions for given problem

e) Design classes for given Problem
f) Handle exceptions

Major Learning Outcomes a Outcomes achieved by students by doing the project:-

a) Practical Outcomes

b) Unit Out comes in Cognitive domain

c) Out comes in Affective Domain

Comments/suggestions about team work/leadership/inter-personal communication (if any)

Roll Student Name Marks out of 6 for Marks out of 4 Total

No performance for performance Out of
in group activity In/presentation 10
(D5 col.9)
8 Priyanka Gulab Pokharkar

Prof.Kedar A.L
(Name & Signature Of Faculty)

Samarth Polytechnic , Belhe

Chaupar Game App

Samarth Polytechnic , Belhe