A

Raport Micro Proiect

pe

Jocul Ludo
Trimis de
Siddhesh Jagdish Shelar
Jainul Jignesh Dave
Shreyash Kiran Dahale
Ojas Yogesh Joshi

Sub îndrumarea

Prof. G.K. Gaikwad

În îndeplinirea parț ială a semestrului al cincilea al diplomului în

Inginerie Computerizată

Departamentul de Inginerie a Calculatoarelor

Politehnica Sandip
Mahiravani, Nashik - 422213

Afilat la

Statul Maharashtra
Consiliul de Educaț ie Tehnică

Anul Academic 2020-21

 Statul Maharashtra
Consiliul pentru Educaț ie Tehnică

Certificat

Acesta este pentru a certifica că dl. Siddhesh Jagdish Shelar cu Nr. de rulare - 12 a finalizat cu succes Micro-
proiect în cadrul cursului Programare cu Python (22616) pentru anul academic 2020-21 aș a cum este prescris în
Manual de evaluare' în timpul completării celui de-al ș aselea semestru al programului de diplomă în
Inginerie Computerizată de la institutul Sandip Polytechnic cu codul institutului 1167.

Nashik 1711670171

Data://2021 Numărul locului la examen:

Profesor de curs Ș eful Departamentului Ș eful Institutului

 Anexa – I

Propunere de Micro Proiect

1.0 Obiectivele/Beneficiile Micro-Proiectului:
Joc de masă Ludois, care poate fi jucat de 2 până la 4 jucători, fiecare jucător având un set de 4 piese
(de obicei identificate prin culoare) plasate în zona de start, care se află în colț ul stâng pentru fiecare jucător. Prin aruncarea zarurilor
În joc, jucătorii concurează cu cele patru piese pe tablă de la început până la sfârș it, încercând să evite să fie uciș i sau capturaț i.
de către adversarii lor.

Obiectivul principal pentru fiecare jucător este să-ș i mute toate piesele sau token-urile la final înaintea oponenț ilor săi.
Desigur, pe parcursul drumului există câteva obstacole pe care jucătorul trebuie să le depăș ească. Parcurgeț i aceste lucruri pas cu pas.
instrucț iuni pentru a obț ine o perspectivă mai bună asupra modului de a stăpâni acest joc uș or.

2.0 Rezultatele cursului abordate:

i. Afi ș aț i mesajul pe ecran folosind un script Python în IDE.
ii. Dezvolta un program Python pentru a demonstra utilizarea operatorilor
iii. Efectua ț i opera ț iuni pe structuri de date în Python.
iv. Dezvolta ț i func ț ii pentru problema dată.
v. Proiecta ț i clase pentru problema dată.
vi. Gestionează excep ț iile.
3.0 Metodologie propusă:

Un caz de utilizare este o descriere a unui set de secvenț e de acț iuni grafic, fiind redat ca un
elipsă cu Linie solidă incluzând doar numele său. Diagrama de caz de utilizare este o diagramă comportamentală
care arată un set de cazuri de utilizare ș i actori ș i relaț ia lor. Este o asociere între
cazurile de utilizare ș i actorii. Un actor reprezintă un obiect din lumea reală.

Elementele modelului

Jucător: Acesta este modelat printr-un tip de nod. Jucătorii pot avea un identificator sau o culoare pentru
distingeț i-i. Ordinea cíclică a jucătorilor este tipic modelată explicit (prin
margini).

Pion: Acesta este modelat printr-un tip de nod. Fiecare pion aparț ine unui anumit jucător; acesta este
de obicei modelat printr-o margine, sau în unele cazuri printr-o atribut.

Domeniu: Acesta este modelat printr-un tip de nod. Câmpurile de intrare ș i obiectivele sunt tipuri speciale de câmpuri,
de obicei modelat de subtipuri, sau în unele cazuri marcat prin bucle speciale. Acelaș i
poate fi realizat pentru terenurile de acasă, deș i acestea nu sunt esenț iale pentru joc (le-am lăsat
din Fig. 2). Spaț iile de intrare ș i de obiectiv (ș i de acasă) aparț in unui jucător; acesta este, de obicei
modelat de o margine. Poziț ia unui pion (pe un câmp) este la fel modelată de un
margine.

Placă: Aceasta constă din toate câmpurile ș i interconexiunile lor, adică câmpurile următoare ș i
intersec ț iile către câmpurile de obiectiv. Interconexiunile pot fi transformate în noduri, dar
 în mod tipic va fi modelat de margini. Tabla în sine nu are neapărat nevoie de o specială
nod, deoarece toate câmpurile îi aparț in deja în mod implicit.

Aceasta este modelată de un nod (singleton), posibil de un tip special, dar opț ional
integrat cu un anumit nod existent. Rezultatul unei aruncări de zar este apoi de obicei un
atributul nodului die.

Strategie: Acesta este modelat de un nod sau o valoare atribut; un jucător poate fi apoi atribuit
o strategie prin adăugarea unei margini sau atribut.

Plan de ac ț iune 4.0:

 Și Detalii despre activitate
Planificat Planificat Numele echipei responsabile
r Data de început Data finalizării Membri
Nu
1 Discu ț ie ș i Selec ț ie a 11/12/1018
Temelor 15/12/2018
2 Revizuirea Literaturii 17/12/2018 22/12/2018
3 Scop/Beneficii ș i Importan ț ă24/12/2018 29/12/2018

4 Resurse Necesare 31/12/2018 05/01/2019

5 Analiza datelor colectate 07/01/2019 12/01/2019

6 Proiectarea sistemului oSiddhesh Jagdish
14/01/2019 19/01/2019
Shelar
7 Codare ș i testare a 21/01/2019
modulelor 25/01/2019 oJainul Jignesh Dave
oShreyash Kiran
8 Codare ș i Testare a 28/01/2019
Modulilor 02/02/2019 Dahale
oOjas Yogesh Joshi
9 Programare ș i Testare a 04/02/2019
Modulilor 09/02/2019
10 Integrarea modulelor sistemului11/02/2019 16/02/2019

11 Testare ș i Implementare 18/02/2019 23/02/2019

Sistem
12 Compilarea Raportului 25/02/2019 02/03/2019

13 Compilare de Prezentare 05/03/2019 09/03/2019

14 Prezentarea Seminarului 11/03/2019 16/03/2019

15 Distribu ț ie finală de 18/03/2019 20/03/2019

Depunere

5.0 Resurse necesare:

Sr Numele de
Specificaț ie Cant. Observaț ii
Fără resurse/material
Desktop cu Intel Core 2 Duo -
1 Resursă hardware 2.93 GHz, RAM 2GB, HDD 1
160 GB
Resursă software IDE Python -
2 1
3 Orice altă resursă Internet - -
Numele membrilor echipei cu numerele de rol:

Număr de rulare Numele membrilor echipei

Siddhesh Jagdish Shelar
12
Jainul Jignesh Dave
01
Shreyash Kiran Dahale
08
Ojas Yogesh Joshi
57

Numele ș i semnătura profesorului de curs

([Link])
 Anexa – I
Raport Micro Proiect
1.0 Rationale

Acesta este un joc de Ludo care este foarte uș or de înț eles ș i de utilizat. Vorbind despre

jocul, toate regulile de joc sunt aceleaș i la fel cum jucăm în ludo în timp real. Aici, la început,

utilizatorul trebuie să selecteze jucători, adică fie umani, fie computer. După selectarea umanului, jucătorul

trebuie să introducă detalii precum numele ș i să selecteze o culoare (roș u, verde, galben ș i albastru). jucătorul

poate începe jocul cu doi jucători dacă doreș te. După ce a început jocul, o consolă

tabloul de joc Ludo bazat apare, celelalte reguli rămân aceleaș i. În primul rând, computerul sau jucătorul trebuie să

lansaț i zarurile.

Cel mai important lucru în acest joc bazat pe consolă este că jucătorul trebuie doar să apese „Enter

Apasă tasta "Key" pentru a arunca zarul. În partea de sus a tablei, se afiș ează un zar cu numărul. Sistemul

continuă să se rostogolească până când există un pion posibil de mutat. Toate mi ș cările din joc sunt

efectuat automat. Ori de câte ori jucătorul încearcă să încheie jocul, există o opț iune

disponibil pentru a salva jocul nefinalizat astfel încât el/ea să poată continua mai târziu. O consolă simplă

GUI este oferit pentru un gameplay uș or. Designul gameplay-ului este atât de simplu încât utilizatorul nu va

îi este greu să folosească ș i să înț eleagă. [Link]@[Link]

Obiectivele/Beneficiile Micro-Proiectului:

Cum se joacă
[Link] jucătorului de Ludo.

[Link] Acasă.

[Link] de start.

[Link] ț i de la pătratul de start, în sensul acelor de ceasornic în jurul perimetrului.

5. Fără pătrate de odihnă.

6. Culoarea identificării jucătorului.

Reguli de joc

1. Patru piese sunt plasate în zona de start a culorii lor.

Aruncă un singur zar.

3. Mai întâi aruncă un ș ase sau un unu pentru a te muta.

[Link]ătorul mută o piesă înainte cu 1 până la 6 pătrate.

5. Şase duce la o altă tură.

[Link]ătorul nu se poate mi ș ca, pasează la următorul jucător.

7. Capturat ș i returnat în zona de pornire.

8. Fără reguli de dublare.

9. Avansează către Pia ț a Principală.

3.0 Rezultatele cursului ob ț inute:
i. Afi ș aț i mesaj pe ecran folosind un script Python în IDE.
ii. Dezvoltă un program Python pentru a demonstra utilizarea operatorilor
iii. Efectuează opera ț iuni pe structuri de date în Python.
iv. Dezvolta ț i func ț ii pentru problema dată.
v. Proiecta ț i clase pentru problema dată.
vi. Gestionează excep ț iile.

4.0 Metodologia Actuală Urmărită:

Figura: Modelul Spiral al Dezvoltării Software

Figura arată modelul spiral al dezvoltării software-ului. Acest model este o combina ț ie de bine-
modelul cunoscut al căderii de apă ș i prototiparea iterativă. Aceasta generează o dezvoltare rapidă a unor soluț ii mai complete
versiunea software-ului. Folosind modelul spiral, software-ul este dezvoltat ca o serie de
Lansări evolutive. În timpul lansărilor iniț iale, poate fi doar documentaț ie sau un prototip. Dar în timpul
versiunile ulterioare ajung la o etapă mai completă.
Modelul spiral poate fi adoptat pentru a fi aplicat pe parcursul întregului ciclu de viaț ă al aplicaț iei de la
dezvoltarea conceptului până la întreț inere. Modelul spiral este împărț it într-un set de activităț i de cadru
definită de echipa de ingineri software. Activitatea ini ț ială este arătată din centrul cercului ș i
dezvoltat în direcț ia acelor de ceasornic. Fiecare spirală a modelului include următoarele patru etape:
Faza de planificare: Această etapă include culegerea cerinț elor, estimarea costurilor, alocarea resurselor.
Risk Analysis Phase: This stage involves strengths and weaknesses of the project. Design Phase:
Această etapă include codificarea, testarea internă ș i implementarea.
Faza de evaluare: Ultima etapă implică evaluarea clientului (testare de partea clientului) pentru a obț ine feedback.
Diverse activităț i care sunt efectuate conform fazelor modelului spiral sunt prezentate în tab.
5.0 Resurse Actuale Utilizate:

Sr
Numele resursei/materialului Specificaț ie Cant. Observaț ii
Nu
Procesor i3/HDD-
1 Resurse hardware 1
1TB/RAM-8GB
IDE Python
2 Resursă software 1

3 Orice altă resursă Imprimantă 1

Cod :
din .game importă Player, Game
din .pictor importă prezent_6_numărul_mortii
din .recorder importă RunRecord, MakeRecord
din os importă linesep

clasa CLIGame(): def

acesta (sine)
>
[Link] = Joc() #
utilizat pentru o imprimare mai frumoasă

self.prompted_for_pawn = False #
salvarea datelor jocului
self.record_maker = MakeRecord()
obț inerea datelor de joc self.record_runner =
Niciunul

def valideaza_input(self, prompt, tip_dorit, input_permis=None,

Opț iune invalidă!
'''
buclează în timp ce primeș ti valoarea corectă
param allowed_input poate fi o listă de valori permise
param str_len este un tuplu de două dimensiuni dacă min ș i max
'''
prompt += linesep + self.prompt_end
în timp ce Adevărat:
alegere = input(prompt) dacă
nu alegere:
print(linii_sep + mesaj_eroare)
continua
încercaț i:
alegere = tip_dorinț ă(alegere)
cu excepț ia ValueError:
print(linii_separate + mesaj_eroare)
continuă
dacă inputul este permis:
dacă alegerea este în inputul permis:
pauză
altfel:
Opț iune invalidă!
continuare
elif lungimea_str:
min_len
dacă min_len < len(alegere) < max_len:
pauză
 altfel:
print(linia separata + mesaj_eroare)
altfel:
pauză
print()
returnaț i alegerea

def obtine_alegerea_initiala_a_utilizatorului(self):

alege opț iunea

0 - începe un joc nou
- continuă jocul
2 - rulează (revizuieș te) jocul înregistrat
ales = self.validate_input(text, int, (0, 1, 2)) return
alegere

def solicitare_fisier(self, modul="rb"):

returnaț i descriptorul de fiș ier
Introduceț i numele fiș ierului (numele înregistrării)
în timp ce adevărat:
nume_fisier = self.validare_input(text, str)
încearcă:
file_descr = open(nume_fisier, mod=mod)
returnaț i file_descr
cu excepț ia IOError ca e:
print(e) print("Încearcă"
din nou

def vrea_utilizatorul_sa_salveze_jocul(self):
returnează True dacă utilizatorul vrea să salveze jocul
sau Fals
'''
Salvează jocul? 0
- Nu
1 - Da
alegere = self.validate_input(text, int, (0, 1))
returnare alegerea == 1

def solicitare_jucător(self):
obț ine atributele jucătorului din intrare,

instanț a iniț ială a jucătorului ș i

adaugă jucător în joc
'''
culorile_disponibile = [Link].get_available_colours()
alege tipul de jucător
0 - computer
1 - uman
alegere = self.validate_input(text, int, (0, 1))

dacă alegerea == 1:
nume = self.validate_input("Introduceț i numele jucătorului",
 ș ir
opț iuni_disponibile = range(len(culori_disponibile)) dacă
len(opț iunilor_disponibile) > 1:
# arată culorile disponibile
options = ["{} - {}".format(index, colour) for
index, culoare în zip(opț iuni_disponibile,
culori_disponibile
alege culoarea
text += [Link](opț iuni)
alegere = self.validate_input(text, int, available_options)
culoare
altfel:
doar o singură culoare rămasă
culoare = available_colours.pop()
jucător = Jucător(culoare, nume, self.prompt_alege_pion)
elif alegerea == 0:
atribui culori automat
culoare
player = Jucător(culoare)
[Link].add_jucator(player)

defineaț i promptul pentru jucători

toț i jucătorii din joc
counts = ("first", "second", "third", "fourth last")
Adaugă {} jucător
pentru i în intervalul(2):
print(text_add.format(counts[i]))
[Link]ă_pentru_jucător()
Jucător adăugat

Alegeț i opț iunea:

0 - adăugaț i jucător
1 - începe jocul cu {} jucători
pentru i în intervalul(2, 4):

alegere = self.validate_input([Link](str(i)), int, (0, 1)) dacă

opț iune == 1:
pauză
elif alegerea == 0:
print(text_add.format(counts[i]))
auto.solicitare_pentru_jucător()
Jucător adăugat

def afiseaza_informatia_dupa_turn(self):
a folosit atributele jocului pentru a imprima informaț ii
[[Link] for pawn in [Link].allowed_pawns]
o imprimare mai frumoasă a zarurilor

mesaj = prezent_6_numele_die([Link].rolled_value,
str([Link].curr_player)
+= linie separat
 dacă [Link].allowed_pawns: mesaj_de_mutat =
{} este mutat.
[Link].picked_pawn.id) dacă
auto.solictat_pentru_pion
self.prompted_for_pawn = False
mesaj mutat
întoarce
{} pioni posibili de mutat.
.join(pawns_id)
mesaj += " " + mesaj_miș cat dacă
[Link].joga_pionii
Jog pion
mesaj += " ".join([[Link] pentru pawn în [Link].jog_pawns])
altfel:
Nu sunt pioni de mutat.
print(mesaj)

def print_standing(self):
{} - {}
pentru index, jucător în enumerate([Link])]
Clasament:
printaț i(mesajul)

def afiseaza_tabla(self):

print([Link].get_board_pic())

def run_recorded_game(self):
obț ine istoricul jocului (valoare_rulată
ș i pionul permis al indexului) din
înregistrează_executant pentru a reîncerca jocul
îș i încarcă jucătorii înregistraț i()
self.print_players_info()
îș i cere să continue()
pentru rolled_value, index în self.record_runner:
[Link].juca_tura(index, valoare_rolată)
self.print_info_after_turn() self.print_board()
auto.prompt_de_continuare() auto.print_tablou()

def continua_jocul_inregistrat(self):
îmbarcă jocul prin apelarea
metoda play_turn până în momentul în care
jocul a fost întrerupt.
'''
self.load_recorded_players()
self.inregistreaza_jucatorii()
pentru rolled_value, index în self.record_runner:
[Link].joca_ț urn(index, valoare_rulată)
self.record_maker.adauga_tura_joc()
[Link].rolled_value, [Link]
self.print_players_info()
 self.print_info_after_turn()
self.print_board()

defineste_jucatorii(self): '''salveaza
jucători pe recorder
pentru jucător în [Link]ători:
self.record_maker.adauga_jucator(player)

def încărca_jucătorii înregistraț i(self): '''obț ine

jucători înregistraț i (salvaț i) din
înregistrează-le ș i pune-le în joc
'''
dacă self.record_runner este None: file_descr
= self.prompt_for_file()
self.record_runner = RunRecord(file_descr)

file_descr.close()
pentru jucător în self.record_runner.get_players(
alegeț i_pion
[Link].adauga_jucator(player)

def carga_jucătorii_pentru_joacă_nouă(self):
self.prompt_for_players()
self.print_info_jucatori()
self.record_players()

def joacă_joc(self): '''în principal

apelare joc_mutură
Metoda jocului în timp ce jocul s-a terminat
încearcă:
în timp ce jocul meu nu s-a terminat:
[Link]ă_o_rând()
self.print_info_after_turn()
self.print_board()
self.record_maker.adauga_tura_joc(
[Link].rolled_value, [Link]
prompt_îț i_Continuare()
Jocul s-a terminat
self.print_standing()
self.offer_save_game()
cu excepț ia (KeyboardInterrupt, EOFError):
print(liniar +
Ieș ire din joc.
Salvează jocul ș i continuă acelaș i joc mai târziu?
self.offer_save_game()
creș te

def oferă_salvare_joc(self):
oferă utilizatorului salvarea jocului
dacă self.does_user_want_save_game():
file_descr = self.prompt_for_file(mode="wb")
 self.record_maker.save(file_descr)
file_descr.close()
Jocul este salvat

definitie incepe(self):
metoda principală, pornind cli
print()

încearcă:
alegerea = self.get_user_initial_choice() dacă
alegere == 0: # începe un joc nou
self.load_players_for_new_game()
îș i joacă jocul()
elif alegerea == 1: # continuă jocul
self.continue_recorded_game() dacă
[Link]
Nu s-a putut continua.
Jocul este deja terminat
linesep + "Ieș ire"
altfel:
auto.propunere_pentru_a_continua()
self.juca_jocul()
elif alegerea == 2: # recenzie joc jucat
îș i desfăș oară jocul înregistrat()
cu excepț ia (KeyboardInterrupt, EOFError):
Ieș i din joc
dacă numele == ' principal ' :
CLIGame().start()
def oferă_salvare_joc(self):
oferă utilizatorului să salvze jocul
dacă self.does_user_want_save_game():
file_descr = self.prompt_for_file(mode="wb")
self.record_maker.save(file_descr)
file_descr.close()
Jocul este salvat

începe(self):
Ieș iri
1.

2.
3.
4.
7.1 Competen ț e dezvoltate / Rezultatul învă ț ării
acest Micro-Proiect:

a) Rezultate practice:

Înț eles punctele forte ș i slabe actuale ale pieț ei

Am învăț at o planificare, o gestionare, o facilitare ș i o execuț ie mai bune a proiectelor
Îmbunătăț irea abilităț ilor de rezolvare a problemelor.

b) Rezultatele unită ț ii în domeniul cognitiv:

Informaț ii anterioare recuperate sau aduse înapoi.

Interpretarea instrucț iunilor ș i problemelor.
Utilizarea conceptului cunoscut în implementare
Depanare module mici
Selectarea celei mai eficiente soluț ii

c) Rezultate în domeniul afectiv:

Conș tientizare ș i dorinț a de a asculta opiniile altora

Abilităț i de prezentare îmbunătăț ite
Cooperare în activităț i de grup

CONCLUZIE
 Ludo este un joc de societate simplu, pentru doi până la patru jucători, în care
jucătorii îș i aleargă cele patru monede de la început până la sfârș it conform aruncărilor de zaruri ș i se bucură
joc, toate regulile de joc coincid similar cu modul în care jucăm în timp real ludo. Mai jos
Iniț ial, individul trebuie să selecteze jucători.

Numele ș i semnătura profesorului de curs

(Prof. G.K. Gaikwad)

Anexă – IV

Fiș a de evaluare a microproiectului

Siddhesh Jagdish Shelar Număr de înregistrare: 1711670171

Numele Programului: Inginerie Computerizată VI
Programare cu Python Codul cursului: 22616
Titlul Micro Proiectului: Jocul Ludo

Rezultatele învăț ării realizate:

1. Afiș aț i un mesaj pe ecran folosind un script Python în IDE.
2. Dezvoltă un program Python pentru a demonstra utilizarea operatorilor
3. Efectuaț i operaț ii pe structuri de date în Python.
4. Dezvoltaț i funcț ii pentru problema dată.
5. Proiectaț i clase pentru problema dată.
6. Gestionaț i excepț iile.

Sărac Medie Bine Excelent

Sr Caracteristica care trebuie evaluată
Sub
Note Note Note Note
Nu Total
(1-3) (4-5) (6-8) (9-10)
(A) Evaluarea Procesului ș i a Produsului (6 Puncte)
1 Relevanț a pentru curs
 2 Revizuirea literaturii/Colectarea informaț iilor

3 Finalizarea obiectivului conform propunerii de proiect

4 Analiza datelor ș i reprezentarea

5 Calitatea prototipului/modelului

6 Pregătirea raportului
(B) Prezentare individuală/Viva (4 puncte)
7 Prezentare
8 Trăiască

(A) (B)
Total punctaj
Evaluarea procesului ș i a produsului Prezentare individuală/Viva
(10 Puncte)
(6 Puncte) (4 Puncte)

Comentarii/Sugestii despre Colaborare/Liderat/Comunicare interpersonală (dacă este cazul)

…………………………………..……………………………………………………………………………
Numele ș i titlul profesorului cursului: Prof. G.K. Gaikwad, Lecturer

Semnătura datată:

Anexa – IV

Foaie de evaluare a microproiectului

Jainual Jignesh Dave 1611670124

Inginerie Informatica VI
Programare cu Python 22616
Titlul Micro Proiectului: Jocul Ludo

Rezultatele învăț ării obț inute:

1. Afi ș aț i mesajul pe ecran folosind un script Python în IDE.
2. Dezvolta un program Python pentru a demonstra utilizarea operatorilor
3. Efectuează opera ț ii pe structuri de date în Python.
4. Dezvoltă func ț ii pentru problema dată.
5. Proiecta ț i clase pentru problema dată.
6. Gestiona ț i excep ț iile.

Sărăcăcioasă
Medie Bine Excelent
Sr Sub
Caracteristica de evaluat Note Note Note Note
Nu Total
(1-3) (4-5) (6-8) (9-10)
(A) Evaluarea procesului ș i a produsului (6 puncte)
 1 Relevanț a pentru curs
2 Revizuirea Literaturii/Colectarea Informaț iilor

3 Finalizarea obiectivului conform propunerii de proiect

4 Analiza datelor ș i reprezentarea

5 Calitatea prototipului/modelului

6 Pregătirea raportului
(B) Prezentare individuală/Viva (4 puncte)
7 Prezentare
8 Viva

(A) (B)
Total punctaj
Evaluarea procesului ș i produsului Prezentare individuală/Viva
(10 Puncte)
(6 Puncte) (4 puncte)

Comentarii/Sugestii despre Colaborare/Leadership/Comunicaț ia interpersoanală (dacă există)

…………………………………..……………………………………………………………………………
[Link], Lector

Semnătură datată:

Anexa – IV
Fiș a de evaluare a microproiectului
Shreyash Kiran Dahale 1711670155
Inginerie Computerizată V
Cursul: Programare cu Python Codul cursului: 22616
Titlul Micro Proiectului: Jocul Ludo

Rezultatele învăț ării realizate:

1. Afiș aț i mesajul pe ecran folosind un script Python în IDE.
2. Dezvoltă un program Python pentru a demonstra utilizarea operatorilor
3. Efectuează operaț ii pe structuri de date în Python.
4. Dezvoltaț i funcț ii pentru problema dată.
5. Proiectaț i clase pentru problema dată.
6. Gestionează excepț iile.

Sărăcie Medie Bine Excelent

Sr Sub
Caracteristica ce trebuie evaluată Note Note Note Note
Nu Total
(1-3) (4-5) (6-8) (9-10)
(A) Evaluarea procesului ș i a produsului (6 Puncte)
1 Relevanț a pentru curs
 2 Revizuirea literaturii/Colectarea informaț iilor

3 Finalizarea obiectivului conform propunerii de proiect

4 Analiza datelor ș i reprezentarea

5 Calitatea prototipului/modelului

6 Pregătirea raportului
(B) Prezentare individuală/Viva (4 Puncte)
7 Prezentare
8 Trăiască

(A) (B)
Punctaj total
Evaluarea procesului ș i a produsului Prezentare Individuală/Viva
(10 Puncte)
(6 Puncte) (4 Puncte)

Comentarii/Sugestii despre Lucru în echipă/Conducere/Comunicare interpersoanală (dacă este cazul)

…………………………………..……………………………………………………………………………

[Link], Lector

Semnătură datată:

Anexa – IV
Foaie de evaluare a microproiectului
Ojas Yogesh Joshi 1811670507
Inginerie Computerizată V
Titlul cursului: Programare cu Python Codul cursului: 22616
Titlul microproiectului: Jocul Ludo

Rezultate de învăț are realizate:

1. Afi ș ează un mesaj pe ecran folosind un script Python în IDE.
2. Dezvolta ț i un program Python pentru a demonstra utilizarea operatorilor
3. Efectua ț i opera ț ii asupra structurilor de date în Python.
4. Dezvolta ț i func ț ii pentru problema dată.
5. Proiecta ț i clase pentru problema dată.
6. Gestiona ț i excep ț iile.
Sărac Medie Bine Excelent
Sr Sub
Caracteristica de evaluat Note Marci Note Note
Nu Total
(1-3) (4-5) (6-8) (9-10)
(A) Evaluarea procesului ș i a produsului (6 puncte)
1 R
e
l
e
v
a
n
c
e
t
o
t
h
e
C
o
u
r
s
e
2 L
eu
t
e
r
a
t
u
r
e
R
e
v
eu
e
w
/
Eu
n
f
o
r
m
a
t
eu
o
n
C
o
l
 l
e
c
t
i
o
n
3 C
o
m
p
l
e
t
eu
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
o
l
4 A
n
a
 l
y
s
eu
s
o
f
D
a
t
a
&

R
e
p
r
e
s
e
n
t
a
t
eu
o
n
5 Q
u
un
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
eu
o
n
(B) Prezentare individuală/Viva (4 Puncte)
7 Prezentare
8 Viva

(A) (B)
Punctaj total
Evaluarea procesului ș i a produsului Prezentare individuală/Viva
(10 Puncte)
(6 Puncte) (4 puncte)

Comentarii/Sugestii despre Lucrul în echipă/Leadership/Comunicarea interpersoanală (dacă există)

…………………………………..……………………………………………………………………………

[Link], Lector

Semnătură datată:

Statul Maharashtra
Consiliul de Educaț ie Tehnică
 Certificat

Se certifică prin prezenta că domnul Jainul Jignesh Dave cu numărul de rol - 01 a finalizat cu succes Micro-proiectul.

în cursul Programării cu Python (22616) pentru anul academic 2021-22 a ș a cum este prescris în
Manual de Evaluare în timpul desfăș urării celui de-al cincilea semestru al Programului de Diplomă în Informatică
Inginerie de la institutul Sandip Polytechnic cu codul institutului 1167.

Locaț ia: Nashik 1711670120

Date://2021 Numărul locului de examen

Profesor de curs Ș eful Departamentului Ș eful Institutului

Statul Maharashtra
Consiliul de Educaț ie Tehnică
 Certificat

Aceasta este pentru a certifica că Dl. Shreyash Kiran Dahale cu Nr. de înscriere - 08 a finalizat cu succes Micro-
proiect în cadrul cursului Programare cu Python (22616) pentru anul universitar 2021-22, aș a cum este stabilit în

'Manual de evaluare' în timpul completării Semestrului Cinci al Programului de Diplomă în Informatică

Inginerie de la institutul Sandip Polytechnic cu codul institutului 1167.

Nashik 1711670155

Date://2021 Număr loc de examen:

Profesor de curs Ș eful departamentului Ș eful Institutului

Statul Maharashtra
Consiliul de Educaț ie Tehnică
 Certificat

Aceasta este pentru a certifica că dl. Ojas Yogesh Joshi cu numărul de rol - 57 a finalizat cu succes Micro-proiectul în

cursProgramare cu Python(22616) pentru anul universitar 2021-22 aș a cum este prescris în 'Evaluare
Manual' în timpul stagiului său de completare a Semestrului Cinci al Programului de Diplomă în Inginerie Computerizată

de la institut, Sandip Polytechnic cu codul institutului 1167.

Locaț ie:Nashik 1611670156

Data://2021 Numărul locului de examen

Profesor de curs Ș eful Departamentului Ș eful Institutului