Briscola C++
ciao ragazzi ho due problemini in questo programma che sto facendo...so perfettamente che non è il massimo a livello di efficienza ma al corso di informatica abbiamo fatto solo le stringhe fino ad ora nemmeno i puntatori siate buoni con i commenti...XD
tornando a noi il primo problema è che non mi calcola il punteggio stranamente (la funzione creata che dovrebbe svolgere questo compito sembra giusta...)
secondo problema alla fine chieda una ulteriore conferma prima di terminare, nonostante le carte siano finite mi chiede di giocare un'altra carta(inesistente) e poi termina...questo è il codice :
tornando a noi il primo problema è che non mi calcola il punteggio stranamente (la funzione creata che dovrebbe svolgere questo compito sembra giusta...)
secondo problema alla fine chieda una ulteriore conferma prima di terminare, nonostante le carte siano finite mi chiede di giocare un'altra carta(inesistente) e poi termina...questo è il codice :
//gioco della briscola...
#include <iostream>
#include <ctime>
#include <cstdlib>
#include <cmath>
using namespace std;
int Score(int, int, int [][6], int);
bool controllo(int, int, int [][6], int, int, int);
int mescola(int mazzo[][ 10 ]);
int gioca(const char *palo[], const char *carte[], int mazzo[][10], int & cont, int giocatori[][6], int , int, int &, int &);
int distribuisci(const char *palo[], const char *carte[], int mazzo[][10], int & cont, int giocatori[][6], int &, int &, int, int );
int main ()
{
cout << "\t\t\t\t***Brown***\n\t\t\t#Il gioco della briscola!!#\n\n\n" << endl;
const char *palo[ 4 ] = {"Spade","Oro","Coppe","Mazze"};//puntatore ad array contenenti i semi
//puntatore ad array contenenti le carte
const char *carte[ 10 ] = {"Due","Quattro","Cinque","Sei","Sette","Otto","Nove","Dieci","Tre","Asso"};
int giocatori[2][6] = {0};//variabile in cui si salvano le carte del giocatore e del pc
int mazzo[ 4 ][ 10 ] = {0}, cont = 1;
int briscolaS, briscolaC;//variabili in cui si salvano le briscole
srand(time(NULL));
int Punti = 0, aux = 0;// variabile di contenimento del punteggio
mescola(mazzo);
distribuisci(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
cout << "Si comincia a giocare, in bocca al lupo!!\n\n";
distribuisci(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
gioca(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
cout << "\n\n\t\t\tLa partita e' terminata!!\n\n";
if(Punti > 60)
cout << "\nHai Vinto!\n\nIl tuo punteggio e' " << Punti << " mentre il computer ha fatto " << 120 - Punti << endl << endl;
if(Punti < 60)
cout << "\nHai Perso!\n\nIl tuo punteggio e' " << Punti << " mentre il computer ha fatto " << 120 - Punti << endl << endl;
if(Punti == 60)
cout << "\nParita'!!!\n\n";
system("pause");
return 0;
}
//_____________________________________________________________________________________________________________________________________________________
//funzione che mescola il mazzo (array di int 4x10)
int mescola(int mazzo[][ 10 ])
{
int colonna, riga;
for(int i = 1; i <= 40; i++)
{
do{
riga = rand()% 4;
colonna = rand()% 10;
}while(mazzo[ riga ][ colonna ] != 0);
mazzo[ riga ][ colonna ] = i;
}
return 0;
}
//______________________________________________________________________________________________________________________________________________________
//funzione in cui si sviluppa effettivamente il gioco
int gioca(const char *palo[], const char *carte[], int mazzo[][10], int & cont, int giocatori[][6], int briscolaS, int briscolaC, int & Punti, int & aux)
{
bool Vinto = false;//variabile che controllo chi deve prendere
srand(time(NULL));
int scelta, computer, aux1;//variabile in cui si salva la carta giocata da computer e da giocatore umano
if(giocatori[0][0] == 0 && giocatori[0][1] == 0 && giocatori[0][2] == 0 && giocatori[0][3] == 0 && giocatori[0][4] == 0 && giocatori[0][5] == 0)
return 0;
computer = rand()% 3 + 3;//genera casualmente un numero da 3 a 5(compresi)
if(giocatori[0][computer] == 0)
for(int i = 3; i < 6; i++)
if(giocatori[0][i] != 0)
computer = i;
if(Punti == aux)//se il punteggio è rimasto inalterato e quindi ha preso il computer fallo tirare per primo
{
cout << "il computer gioca " << carte[giocatori[0][computer]] << " di " << palo[giocatori[1][computer]] << "\n\n";
aux1 = 0;
}
do
{
cout << "Le tue carte sono: \n";
if(cont < 41)
{
for(int i = 0; i < 3; i++)
cout << i + 1 << ") " << carte[giocatori[0][i]] << " di " << palo[giocatori[1][i]] << "\n";
}
else
{
for(int i = 0; i < 3; i++)
if(giocatori[0][i] != 0)
cout << i + 1 << ") " << carte[giocatori[0][i]] << " di " << palo[giocatori[1][i]] << "\n";
else
cout << i + 1 << ") --------\n";
}
cout << "quale delle tre vuoi giocare? 1/2/3\n\n";
cin >> scelta;
}while(scelta > 3 || scelta < 1);
scelta = scelta - 1;
if(Punti > aux)//se il punteggio è aumentato è quindi ha preso l'utente fai giocare il computer per secondo
{
cout << "il computer gioca " << carte[giocatori[0][computer]] << " di " << palo[giocatori[1][computer]] << "\n\n";
aux1 = 1;
}
Vinto = controllo(scelta, computer, giocatori, briscolaS, briscolaC, aux1);//qua si controlla chi prende
aux = Punti;//poni l'ausiliare uguale al punteggio
switch (Vinto)
{
case true://caso in cui prende l'utente
cout << "\nPrendi tu!\n\n";
Punti = Score(scelta, computer, giocatori, Punti);
break;
case false://caso in cui prende il computer
cout << "\nPrende il computer!\n\n";
break;
}
//azzeramente delle locazioni che ospiteranno le nuove carte pescate
giocatori[0][scelta] = 0;
giocatori[1][scelta] = 0;
giocatori[0][computer] = 0;
giocatori[1][computer] = 0;
//se ancora si è in gioco continua a distribuire le carte ai giocatori
distribuisci(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
}
//_____________________________________________________________________________________________________________________________________________________
//funzione che calcola il punteggio
int Score(int scelta, int computer, int giocatori[][6], int Punti)
{
switch (giocatori[0][computer])
{
case 5:
Punti += 2;
break;
case 6:
Punti += 3;
break;
case 7:
Punti += 4;
break;
case 8:
Punti += 10;
break;
case 9:
Punti += 11;
break;
default:
Punti += 0;
}
switch (giocatori[0][scelta])
{
case 5:
Punti += 2;
break;
case 6:
Punti += 3;
break;
case 7:
Punti += 4;
break;
case 8:
Punti += 10;
break;
case 9:
Punti += 11;
break;
default:
Punti += 0;
}
return Punti;
}
//funzione che controlla chi prende nella mano corrispondente..
//_____________________________________________________________________________________________________________________________________________________
bool controllo(int scelta, int computer, int giocatori[][6], int briscolaS, int briscolaC, int aux1)
{
switch (aux1)
{
case 1:
if(giocatori[1][scelta] == briscolaS && giocatori[1][computer] != briscolaS)
return true;
if(giocatori[1][scelta] != briscolaS && giocatori[1][computer] == briscolaS)
return false;
if(giocatori[1][scelta] == briscolaS && giocatori[1][computer] == briscolaS)
{
if(giocatori[0][scelta] > giocatori[0][computer])
return true;
else
return false;
}
if(giocatori[1][scelta] != briscolaS && giocatori[1][computer] != briscolaS)
{
if(giocatori[1][scelta] == giocatori[1][computer])
{
if(giocatori[0][scelta] > giocatori[0][computer])
return true;
else
return false;
}
else
return true;
}
break;
case 0:
if(giocatori[1][scelta] == briscolaS && giocatori[1][computer] != briscolaS)
return true;
if(giocatori[1][scelta] != briscolaS && giocatori[1][computer] == briscolaS)
return false;
if(giocatori[1][scelta] == briscolaS && giocatori[1][computer] == briscolaS)
{
if(giocatori[0][scelta] > giocatori[0][computer])
return true;
else
return false;
}
if(giocatori[1][scelta] != briscolaS && giocatori[1][computer] != briscolaS)
{
if(giocatori[1][scelta] == giocatori[1][computer])
{
if(giocatori[0][scelta] > giocatori[0][computer])
return true;
else
return false;
}
else
return false;
}
break;
}
}
//funzione che distribuisce i volta in volta le carte ai giocatori...
//______________________________________________________________________________________________________________________________________________________
int distribuisci(const char *palo[], const char *carte[], int mazzo[][10], int & cont, int giocatori[][6], int & briscolaS, int & briscolaC, int Punti, int aux)
{
int esci = 0;
for(int i = cont; i <= 40; i++)
for(int j = 0; j < 4; j++)
for(int k = 0; k < 10; k++)
{
if(i == 1 && mazzo[ j ][ k ] == i)
{
cout << "La briscola per questa partita e' \"" << carte[ k ] << " di " << palo[ j ] << "\"" << endl;
cont++;
briscolaS = j;
briscolaC = k;
return 0;
}
if(mazzo[ j ][ k ] == i && esci < 6 && cont < 8 )
{
for(int n = 0; n < 6; n++)
{
if(giocatori[0][n] == 0)
{
giocatori[0][n] = k;
giocatori[1][n] = j;
cont++;
esci++;
if(esci == 8)
gioca(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
break;
}
}
}
else if(mazzo[ j ][ k ] == i && esci < 2 && cont >= 8 && cont < 40)
{
for(int n = 0; n < 6; n++)
{
if(giocatori[0][n] == 0)
{
giocatori[0][n] = k;
giocatori[1][n] = j;
cont++;
esci++;
if(esci == 2 && cont != 40)
gioca(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
break;
}
}
}
if(cont == 40)
{
for(int n = 0; n < 6; n++)
{
if(giocatori[0][n] == 0)
{
giocatori[0][n] = briscolaC;
giocatori[1][n] = briscolaS;
cont ++;
gioca(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
}
}
}
}
gioca(palo, carte, mazzo, cont, giocatori, briscolaS, briscolaC, Punti, aux);
return 0;
}
Risposte
Non ho ancora dato un occhiata al codice, ti consiglio comunque di non inserire righe troppo lunghe nel codice che quando viene visualizzato in un forum allarghi la discussione e costringi chi ha un computer piccolo (come il netbook che sto usando adesso) di andare avanti e indietro in continuazione. Una vecchia norma (dovuta a finestre abbastanza piccole) era di limitarsi a 80 (adesso può andare bene anche 100) caratteri per riga.
ok mi scuso allora per la eccessiva lunghezza delle righe..........
Sembra quasi che io abbia sempre pronto un rimprovero nei tuoi confronti... Era solo un consiglio comunque, è un po' fastidioso ma per verificare il codice copio comunque il codice in un file di testo per provare a compilarlo e forse fare un debug. Non so quando riuscirò a compilarlo che non sto usando il mio PC. Ho però un altro consiglio per aumentare la leggibilità del tuo codice. Nel tuo programma infatti fai spesso ricorso a costanti per riferirti alle carte (per esempio l'otto è il 3...). In questi casi è meglio definire delle costanti (nella forma di una enumerazione ad esempio) e utilizzare queste costanti per riferirti alle carte. Per esempio:
enum Carte {
DUE,
QUATTRO,
CINQUE,
SEI,
SETTE,
OTTO,
NOVE,
DIECI,
TRE,
ASSO,
NUM_CARTE,
};
In questo modo non devi preoccuparti di sapere quanto vale ad esempio DIECI ma è sufficiente scrivere DIECI nel codice. Lo scopo di NUM_CARTE è quello di servire da limite quando devi iterare su tutte le carte e può anche essere usata per definire la dimensione dell'array con le stringhe dei nomi delle carte ad esempio.
ok il fatto dell'enumerativo è una bella idea per mettere ordine e chiarezza nel codice sorgente....comunque se guardi la funzione che calcola il punteggio (Score)...è sbagliato metter in switch un elemento dell'array e poi nei case i vari numeri che potrebbero esserci con le relative somme da fare?
L'uso degli switch e corretto, ma non capisco bene qual'è la logica dell'array giocatori. Mi sembra tuttavia strano che nella funzione score si faccia sempre riferimento solo a giocatori[0]. C'era una soluzione diversa per ottenere i punteggi che non faceva però uso di una funzione e di switch. Era infatti sufficiente memorizzare in un array di 10 elementi i punteggi per ogni carta e poi usare l'array giocatori come indice per ottenere i punteggi.
Stasera devo uscire a cena e quindi non ho tempo di commentare e correggere il resto del codice (che comunque non ho ancora avuto tempo di compilare e testare). Vedo se riesco a farlo stasera dopo cena.
Stasera devo uscire a cena e quindi non ho tempo di commentare e correggere il resto del codice (che comunque non ho ancora avuto tempo di compilare e testare). Vedo se riesco a farlo stasera dopo cena.
la logica dell'array giocatori è che da 0 a 2 come indici salva le carte dell'utente, mentre da 3 a 5 quelle del pc...nella riga 0 come vedi si salvano le carte mentre sotto alla riga 1 si salvano i semi delle corrispondenti carte che stanno sulla stessa colonna ma in riga 0...questo è il motivo per cui c'è sempre riga 0 in quanto il controllo avviene solo sui semi e non sui pali....
Se ho ben capito il codice, calcoli il punteggio ad ogni singola giocata, e non alla fine.
Se è cosi', hai provato a controllare il punteggio subito dopo la prima presa ?
Se è cosi', hai provato a controllare il punteggio subito dopo la prima presa ?
si ed è giusto il fatto è che lo azzera alla fine inspiegabilmente-.....
Hai provato ad usare un debugger oppure a stampare i punteggi in varie parti del programma in modo da stabilire l'esatto punto del codice in cui si verifica l'azzeramento? Questo deve essere sempre il primo passo per trovare un errore.
ok ho risolto, se a qualcuno servisse il codice eccolo qui:
#include <iostream>
using namespace std;
const char *carte[ 10 ] = {"Due","Quattro","Cinque","Sei","Sette","Otto","Nove","Dieci","Tre","Asso"};
const char *palo[ 4 ] = {"Spade","Oro","Coppe","Mazze"};
int N = 0;
int X = 0;
int Y = 0;
struct carta{
int seme; //0-3
int numero; //0-9
};
int Score(carta Computer[], carta Utente[], int, int scelta, int Pc);
int gioca(carta Computer[], carta Utente[], int & Punti, carta );
int dai_carte_utente(carta Utente[], carta mazzo[]);
int dai_carte_pc(carta Computer[], carta mazzo[]);
bool maggiore(carta[], carta[], carta);
void ordina(carta []);
void mescola(carta []);
void brisc(carta [], carta &);
int pesca(carta mazzo[], carta Computer[], carta Utente[], carta);
int main()
{
srand(time(NULL));
carta Utente[3];
carta Computer[3];
carta briscola;
carta mazzo[40];
int Punti = 0;
cout << "\t\t\t ***Briscola By Bruno***\n\n\n";
ordina(mazzo);
mescola(mazzo);
brisc(mazzo, briscola);
cout << "La briscola e' \"" << carte[briscola.numero] << " di " << palo[briscola.seme] << "\"" << endl << endl;
dai_carte_utente(Utente, mazzo);
dai_carte_pc(Computer, mazzo);
do{
gioca(Computer, Utente, Punti, briscola);
if(N < 40)
pesca(mazzo, Computer, Utente, briscola);
}while(Y < 2);
if(Punti > 60)
cout << "\n\nHAI VINTO!!!\n\nLa partita e' terminata con il Punteggio:\nUtente : " << Punti << "\tComputer : " << 120 - Punti << endl;
if(Punti < 60)
cout << "\n\nHAI PERSO!!!\n\nLa partita e' terminata con il Punteggio:\nUtente : " << Punti << "\tComputer : " << 120 - Punti << endl;
if(Punti == 60)
cout << "\n\nPARITA'!!\n";
system("pause");
return 0;
}
void ordina(carta mazzo[])
{
int cont = 0;
for(int j = 0; j < 4; j++)
for(int i = 0; i < 10; i++)
{
mazzo[cont].seme = j;
mazzo[cont].numero = i;
cont++;
}
}
void mescola(carta mazzo[])
{
carta temp;
int x, y;
for(int i = 0; i < 20; i++)
{
x = rand()% 40;
y = rand()% 40;
temp = mazzo[x];
mazzo[x] = mazzo[y];
mazzo[y] = temp;
}
}
bool maggiore(carta prima[], carta seconda[], carta briscola, int x, int y)
{
return (prima[x].seme == seconda[y].seme) ? (prima[x].numero > seconda[y].numero) : (seconda[y].seme != briscola.seme);
}
void brisc(carta mazzo[], carta & briscola)
{
briscola.seme = mazzo[N].seme;
briscola.numero = mazzo[N].numero;
N++;
}
int dai_carte_utente(carta Utente[], carta mazzo[])
{
int x = 0;
for(int i = N; i < N + 3; i++)
{
Utente[x].seme = mazzo[i].seme;
Utente[x].numero = mazzo[i].numero;
x++;
}
N += 3;
return 0;
}
int dai_carte_pc(carta Computer[], carta mazzo[])
{
int x = 0;
for(int i = N; i < N + 3; i++)
{
Computer[x].seme = mazzo[i].seme;
Computer[x].numero = mazzo[i].numero;
x++;
}
N += 3;
return 0;
}
int gioca(carta Computer[], carta Utente[], int & Punti, carta briscola)
{
if(N > 39)
Y++;
int Pc = rand()%3, scelta;
if(Punti == X)
cout << "Il pc gioca " << carte[Computer[Pc].numero] << " di " << palo[Computer[Pc].seme] << endl << endl;
do
{
cout << "Le tue carte sono: \n";
if(N < 40)
{
for(int i = 0; i < 3; i++)
cout << i + 1 << ") " << carte[Utente[i].numero] << " di " << palo[Utente[i].seme] << "\n";
}
else
{
for(int i = 0; i < 3; i++)
if(Utente[i].numero != 0)
cout << i + 1 << ") " << carte[Utente[i].numero] << " di " << palo[Utente[i].seme] << "\n";
else
cout << i + 1 << ") --------\n";
}
cout << "\nquale delle tre vuoi giocare? 1/2/3\n\n";
cin >> scelta;
}while(scelta > 3 || scelta < 1);
scelta = scelta - 1;
if(Punti > X)
cout << "il pc gioca " << carte[Computer[Pc].numero] << " di " << palo[Computer[Pc].seme] << "\n\n";
if(Punti > X)
{
if(maggiore(Utente, Computer, briscola, scelta, Pc))
{
Punti = Score(Computer, Utente, Punti, scelta, Pc);
cout << "Prendi tu!\n";
}
else
{
X = Punti;
cout << "Prende il PC\n";
}
}
else if(Punti == X){
if(maggiore(Computer, Utente, briscola, Pc, scelta))
{
cout << "Prende il PC\n";
X = Punti;
}
else
{
Punti = Score(Computer, Utente, Punti, scelta, Pc);
cout << "Prendi tu!\n";
}
}
Utente[scelta].numero = 0;
Computer[Pc].numero = 0;
return 0;
}
int Score(carta Computer[], carta Utente[], int Punti, int scelta, int Pc)
{
X = Punti;
switch (Utente[scelta].numero)
{
case 5:
Punti += 2;
break;
case 6:
Punti += 3;
break;
case 7:
Punti += 4;
break;
case 8:
Punti += 10;
break;
case 9:
Punti += 11;
break;
default:
Punti += 0;
}
switch (Computer[Pc].numero)
{
case 5:
Punti += 2;
break;
case 6:
Punti += 3;
break;
case 7:
Punti += 4;
break;
case 8:
Punti += 10;
break;
case 9:
Punti += 11;
break;
default:
Punti += 0;
}
return Punti;
}
int pesca(carta mazzo[], carta Computer[], carta Utente[], carta briscola)
{
int i;
if (N == 39)
{
for(int i = 0; i < 4; i++)
{
if(Computer[i].numero == 0 && i < 3)
{
Computer[i].numero = briscola.numero;
Computer[i].seme = briscola.seme;
N++;
return 0;
}
else if(i == 4)
{
for(int j = 0; j < 3; j++)
{
if(Computer[j].numero == 0 && i < 3)
{
Utente[j].numero = briscola.numero;
Utente[j].seme = briscola.seme;
N++;
return 0;
}
}
}
}
}
if(N < 39){
do{
i = rand()% 3;
}while(Computer[i].numero != 0);
Computer[i].numero = mazzo[N].numero;
Computer[i].seme = mazzo[N].seme;
N++;
}
if(N < 39)
{
do{
i = rand()% 3;
}while(Utente[i].numero != 0);
Utente[i].numero = mazzo[N].numero;
Utente[i].seme = mazzo[N].seme;
N++;
}
return 0;
}
Sarebbe interessante far "giocare" 2 software diversi, magari si potrebbe pensare ad un mini-campionato nel caso in cui ci siano diversi utenti in grado di realizzare il programma. 
si sarebbe interessante, possiamo farlo asd
"Riuzaki":
si sarebbe interessante, possiamo farlo asd
La mia proposta è nata, perchè avevo notato qualcosa di non molto convincente nel tuo codice (in particolare la scelta della carta da giocare da parte del computer).
Per poter giocare uno contro l'altro è necessario un server e un protocollo di rete o almeno un codice di base che gestisca le partite e una interfaccia da implementare.
il fatto è che io ancora non ho solide basi c++...faccio il primo anno di informatica e quindi ancora non so creare grafica ...mi pare piuttosto difficile riuscire nell'impresa XD
...mi pare piuttosto difficile riuscire nell'impresa XD
"Riuzaki":
il fatto è che io ancora non ho solide basi c++...faccio il primo anno di informatica e quindi ancora non so creare grafica
Lungi da me l'idea di disegnare la carte...
Le carte saranno dei numeri che vanno da 1 a 40. (Si potrebbe adottare una convenzione alfabetica: B-C-D-S per i 4 semi). Esempio: la carta 27 è il 7 Denari.
Creare un'interfaccia grafica è in realtà una cosa abbastanza semplice. Non richiede infatti grosse conoscenze teoriche. Ma volendo far giocare diverse intelligenze artificiali tra di loro, non è necessario avere una qualche interfaccia utente. Si potrebbe anche fare a meno. È invece necessario un codice di base che gestisca le partite e una serie di funzioni e/o classi da implementare.
quindi creare interfaccie non è difficile?? mi consigli qualche manuale o qualche guida da cui cominciare ad imparare?? thanks
Non ci sono librerie standard per la creazione di interfacce grafiche per il C++. È cioè necessario ricorrere a librerie fornite dal sistema operativo oppure ad una delle tante librerie multi-piattaforma disponibili. Per prima cosa si deve quindi scegliere la libreria da usare, scelta che comunque non è sempre facile e dipende da molti fattori.
Anche se è in realtà abbastanza facile realizzare interfacce grafiche è in generale abbastanza lungo (richiede molto codice e infatti ci sono spesso dei tools che facilitano il lavoro) e la maggior parte delle librerie richiedono una conoscenza del linguaggio che tu non sembri ancora avere. Secondo me non sei insomma ancora pronto per passare alla programmazione grafica. Su che piattaforma vorresti sviluppare comunque? Vuoi imparare a realizzare interfacce per giochi o applicazioni come un browser o un editor di testo?
Anche se è in realtà abbastanza facile realizzare interfacce grafiche è in generale abbastanza lungo (richiede molto codice e infatti ci sono spesso dei tools che facilitano il lavoro) e la maggior parte delle librerie richiedono una conoscenza del linguaggio che tu non sembri ancora avere. Secondo me non sei insomma ancora pronto per passare alla programmazione grafica. Su che piattaforma vorresti sviluppare comunque? Vuoi imparare a realizzare interfacce per giochi o applicazioni come un browser o un editor di testo?
Voglio imparare soprattutto a sviluppare software...non tanto giochi comunque hai ragione ancora ho tanto da studiare meglio rimandare a più tardi la grafica XD
comunque hai ragione ancora ho tanto da studiare meglio rimandare a più tardi la grafica XD
Accedi a tutti gli appunti
Tutor AI: studia meglio e in meno tempo