Obiettivo: Realizzare una pagina HTML che preveda l’utilizzo dei tag principali per inserire Titoli, Paragrafi, Liste, Immagini e Ritorni a capo.

La pagina HTML

HTML, acronimo di HyperText Markup Language, è il linguaggio di markup standard utilizzato per la creazione e la strutturazione di pagine web. È uno dei componenti fondamentali del World Wide Web ed è essenziale per la visualizzazione di contenuti su Internet. HTML si basa su un sistema di marcatura che utilizza una serie di tag per definire la struttura e il significato del contenuto all’interno di una pagina web. Questi tag forniscono istruzioni al browser su come presentare e organizzare il contenuto, consentendo agli sviluppatori di creare pagine web complesse e interattive.
I tag HTML sono elementi fondamentali del linguaggio di markup. Ogni tag è racchiuso tra parentesi angolari < > e può contenere attributi che forniscono informazioni aggiuntive sul tag stesso. Gli attributi forniscono informazioni aggiuntive sui tag e sui loro comportamenti. Ad esempio, l’attributo src dell’elemento specifica l’URL dell’immagine da visualizzare.

I Principali Tag

• Il tag <h1> in HTML viene utilizzato per definire il titolo principale di una pagina web. È il titolo di livello più alto e di solito viene visualizzato con una dimensione del carattere più grande rispetto agli altri elementi del testo sulla pagina.
• Il tag <h2> in HTML viene utilizzato per definire un titolo di secondo livello all’interno di una pagina web. È utilizzato per indicare una sezione o un sotto-titolo all’interno di un contesto più ampio rispetto al tag <h1>
• Il tag <h3> in HTML viene utilizzato per definire un titolo di terzo livello all’interno di una pagina web. Viene utilizzato per indicare una sezione o un sotto-sottotitolo all’interno di un contesto più specifico rispetto al tag <h2>
• Il tag <p> in HTML viene utilizzato per definire un paragrafo di testo all’interno di una pagina web. Questo tag è essenziale per organizzare e strutturare il contenuto testuale in paragrafi separati.
• Il tag <ol> in HTML viene utilizzato per creare una lista ordinata di elementi, mentre il tag <li> (list item) viene utilizzato all’interno del tag <ol> per definire ciascun elemento della lista.
• Il tag <ul> in HTML viene utilizzato per creare una lista non ordinata di elementi, mentre il tag <li> (list item) viene utilizzato all’interno del tag <ul> per definire ciascun elemento della lista.
• Il tag <br> in HTML viene utilizzato per inserire un’interruzione di linea, cioè una nuova riga, all’interno di un documento HTML. Questo tag non ha un tag di chiusura (<br>) poiché è un tag vuoto, il che significa che non contiene contenuti o testo.
• Il tag <img> in HTML viene utilizzato per inserire un’immagine all’interno di una pagina web. Questo tag è un elemento vuoto, il che significa che non ha un tag di chiusura e non contiene alcun contenuto. Questo tag prevede una serie di attributi quali: l’attributo src specifica l’URL o il percorso del file dell’immagine da visualizzare, l’attributo alt fornisce un testo alternativo che viene mostrato se l’immagine non può essere visualizzata, l’attributo width che fornisce indicazioni in merito alla grandezza dell’immagine, l’attributo height che fornisce indicazioni in merito alla altezza dell’immagine.
  .

Il codice

Viene in seguito riportato il codice di una ipotetica pagina web statica.

Esercizio:

Realizzare il sito di una semplice ricetta che preveda la seguente struttura

• Titolo
• Immagine
• Descrizione della ricetta
• Lista degli ingredienti
• Procedimento

Obiettivo: Imparare ad utilizzare i servomotori del Kit EV3 Mindstorm al fine di eseguire traiettorie curve. 

Teoria:

I contenuti teorici riportati in questa lezione sono relativi al robot Driving Base EV3. Questo robot è costituito da due servomotori, che permettono di controllare le due ruote, ed una ruota a sfera.

I servomotori presenti nel kit EV3 Minstrom presentano le seguenti caratteristiche:

• Contagiri con precisione di un grado
• 160/170 giri al minuto
• Coppia motrice 20 N/cm 
• Coppia massima 40 N/cm

La modalità di connessione è rapida, è sufficiente connettere i servomotori attraverso l’utilizzo dei cavi al mattoncini EV3 utilizzando le porte di uscita (A, B, C, D). Attraverso la programmazione del mattoncini sarà possibile selezionare la porta impiegata e programmare in modo corretto il servomotore regolando velocità di rotazione e tempo di accensione.

Regolando la velocità di rotazione dei entrambi i servomotori è possibile impostare 3 differenti modalità di curva:

• Pivot Turn: una ruota ferma ed una ruota in movimento. In questo caso il robot gira intorno alla ruota ferma, la quale funge da perno. La velocità di rotazione dipende dalla ruota in movimento.
• Smooth Turn: le ruote si muovono entrambe nella stessa direzione ma a velocità differente. In questo caso il robot tende a curvare nella direzione della ruota che si muove più lentamente.
• Spin Turn: le due ruote si muovo alla stessa velocità ma in direzioni differenti. In questo caso il robot ruota su se stesso. La velocità di rotazione dipende dalla velocità delle due ruote.

Codice:

Viene in seguito riportato il codice (schema a blocchi) utilizzato per effettuare le tre differenti tipologie di rotazione.

E’ importante considerare che attraverso il programma è possibile regolare la velocità di rotazione di ogni singola ruota ed il tempo di rotazione espresso in: secondi, rotazioni, gradi.

Si potrebbe pensare che attraverso il codice sia possibile definire immediatamente la tipologia di curva desiderata (ad esempio una curva a gomito a 90 gradi), d’altro canto questo non è possibile poiché lo stesso tempo e la stessa velocità di rotazione posso avere effetti differenti su robot differenti.

• Pivot Turn: il programma si avvia quando viene premuto il tasto centrale sul robot. Le ruote effettuano una sola rotazione. Il motore della ruota A è impostato ad una velocità pari al 50% mentre la velocità della ruota B è impostata allo 0%.
• Smooth Turn: il programma si avvia quando viene premuto il tasto sinistro sul robot. Le ruote effettuano una sola rotazione. Il motore della ruota A è impostato ad una velocità pari al 80% mentre la velocità della ruota B è impostata allo 20%.
• Spin Turn: il programma si avvia quando viene premuto il tasto sinistro sul robot. Le ruote effettuano una sola rotazione. Il motore della ruota A è impostato ad una velocità pari al 50% mentre la velocità della ruota B è impostata a -50%.

Obiettivo: Realizzare il gioco della tombola utilizzando il linguaggio di programmazione Java. Un progetto realizzato dagli alunni della classe terza del Istituto Tecnico Commerciale di Fano, Zaninati Luca, Cesarotti Valentina, Cuccaroni Edoardo, Bartoli Luca con la supervisione del Prof. Emanuele Tonucci

Teoria:

Il gioco della tombola è un tradizionale gioco da tavolo inventato a Napoli nel XVIII secolo come alternativa casalinga al gioco del lotto. Uno degli elementi caratterizzanti di questo gioco è il sistema di associazione tra numeri e significati di solito umoristici.
Elemento caratteristico del gioco è la casualità: un giocatore con il ruolo di croupier ha a disposizione un tabellone sul quale sono riportati i numeri da 1 a 90. Il croupier estrae i pezzi in modo casuale ed annuncia agli altri giocatori il numero uscito. L’annuncio termina generalmente con la citazione di una delle immagini che la trazione napoletana associa ai numeri da 1 a 90. I giocatori dispongono invece di una o più cartelle, ogni volta che il numero estratto è presente sulla scheda del giocatore questo copre la casella corrispondente. Vince il giocatore che per primo copre tutti e quindici i numeri presenti sulla scheda.

Scopo di questa lezione è implementare in codice Java il gioco della tombola, nello specifico il programma permetterà la gestione randomica dei numeri estratti, attività solitamente affidata al croupier.

Il codice:

Viene in seguito riportato il codice utilizzato per l’estrazione automatica dei 90 numeri.
Elemento caratterizzante della tombola è la personalizzazione della smorfia in dialetto Fanese.
Per gestire questi due elementi il tabellone e il testo associato ad ogni numero sono utilizzati due differenti array tombola e frasi con dimensione pari a 90.
Dopo la dichiarazione e relativa inizializzazione dell’array delle frasi, l’array tombola viene riempito con numeri casuali (da 1 a 90) utilizzando la classe rand del linguaggio di programmazione Java.
E’ importante considerare che l’array tombola non può contenere due volte lo stesso numero, per questo è stato implementato uno specifico meccanismo di controllo

Codice Eseguibile:

https://onlinegdb.com/b21Kj50g6

Obiettivo: Realizzare un programma che implementi un simulatore di gare di Formula1  utilizzando il linguaggio di programmazione C++.

Le automobili

Ogni automobile è caratterizzata da una serie di attributi, alcuni di questi non cambiano nel corso di una gara e sono utilizzati per determinare il tempo di percorrenza sul giro o altre importanti informazioni, altri parametri invece sono utilizzati per tenere traccia di alcune informazioni e cambiano nel corso di un gara (vedi ad esempio la benzina, che per ogni giro diminuisce).

Lista degli attributi costanti

• string nome;
• int velocità;
• int accelerazione;
• int controllo;
• int affidabilita;
• int consumo;

Lista degli attributi variabili

• int ritiro;
• int tempoGiro;
• int tempoGara;
• int benzina;
• int punteggio;

Le gare

Ogni gara è caratterizzata da una serie di attributi:

• string nome;
• string descrizione
• int lunghezza;
• int numeroGiri;

Il codice

Viene in seguito illustrato il codice utilizzato per implementare un gioco di simulazione di gare di formula 1.

Struttura del codice

• Definisce due strutture principali:
  Auto: rappresenta una macchina con caratteristiche (velocità, accelerazione, controllo, ecc.) e dati di gara (tempo, benzina, punteggio).
  Gara: rappresenta un circuito con nome, descrizione, lunghezza e numero di giri.
• Nel main vengono inizializzate alcune auto e alcune gare.
  Per ogni gara:
  – Resetta i parametri delle auto.
  – Simula giro per giro la corsa (calcolo tempo, consumo benzina, ecc.).
  – Permette all’utente di scegliere azioni durante i giri (es. rifornimento, guida aggressiva).
  – Stampa i tempi e la classifica.
  – Alla fine assegna punteggi e determina il vincitore (anche se alcune funzioni sono ancora da completare, segnate con TODO).

Obiettivo: Realizzare un programma che implementi una avventura testuale utilizzando il linguaggio di programmazione C++.

Le stanze

Ogni stanza è caratterizzata da una serie di attributi:

• string descrizione;
• int Nord;
• int Sud;
• int Ovest;
• int Est;

I valori dei parametri Nord, Sud, Ovest, Est, indicano la stanza accessibile attraverso la relativa porta. Se ad esempio il valore Nord è uguale a 2 vorrà dire che andando verso Nord si raggiungerà la stanza 2. Quando i valori sono inizializzati a -1 vuol dire invece che attraverso quella porta non è possibile raggiungere nessuna stanza.

Le persone

Ogni gara è caratterizzata da una serie di attributi:

• string nome;
• string presentazione
• int vita;
• int armatura
• int attacco;

Il codice

Viene in seguito illustrato il codice utilizzato per implementare un gioco di avventura testuale

Obiettivo: Realizzare un programma che implementi il gioco della Ruota della Fortuna utilizzando il linguaggio di programmazione C++.

La Ruota della Fortuna
La ruota della Fortuna è un gioco a turni per due giocatori. A ogni turno, un giocatore gira la ruota e sceglie una lettera. Il programma verifica se la lettera è presente nella frase misteriosa: in caso positivo, tutte le occorrenze della lettera vengono mostrate e il montepremi del giocatore viene aggiornato di conseguenza. Il gioco termina quando tutte le lettere della frase misteriosa sono state scoperte.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare una semplice versione del gioco della Ruota della Fortuna. Nel dettaglio, il codice prevede una netta distinzione tra il motore grafico che permette di stampare la griglia del gioco ed il codice di gestione del gioco (i.e., scelta della lettera, controllo del vincitore etc…).

• Motore Grafico: La funzione void mostraParola(string frase, int lettereScoperte[]) ha il compito di visualizzare la parola misteriosa sullo schermo. In particolare, la funzione:
  

  • Utilizza l’array lettereScoperte per visualizzare ogni carattere della stringa frase. Se il contenuto dell’array è 0 la lettera non viene mostrata se è 1 la lettera viene mostrata.

• Codice di gestione del gioco: Vengono in seguito riportate le principali funzioni utili per la gestione del gioco:
• La funzione mSleep ha il compito di sospendere temporaneamente l’esecuzione del programma per un intervallo di tempo espresso in millisecondi. Viene utilizzata per rendere più fluida la visualizzazione dei messaggi a schermo, inserendo brevi pause tra una stampa e la successiva.
• La funzione intro si occupa di stampare il messaggio iniziale del gioco. All’avvio del programma viene mostrata una scritta decorativa colorata seguita da una breve spiegazione delle regole del gioco della Ruota della Fortuna. La funzione illustra le azioni principali dei giocatori e attende l’interazione dell’utente prima di iniziare la partita.
• La funzione giraRuota simula il giro della ruota della fortuna. Essa restituisce un valore intero che rappresenta la quantità di denaro ottenuta dal giocatore in quel turno. Il valore dovrebbe essere generato in modo casuale per rendere il gioco imprevedibile.
• La funzione mostraParola ha il compito di visualizzare la frase misteriosa. Le lettere già indovinate vengono mostrate, mentre quelle ancora nascoste sono rappresentate dal carattere “_”. La funzione pulisce lo schermo e aggiorna la visualizzazione della parola a ogni turno.
• La funzione turnoGiocatore gestisce il turno di un singolo giocatore. Mostra il nome del giocatore di turno, avvia il giro della ruota e chiede di inserire una lettera. La funzione dovrà verificare quante volte la lettera scelta è presente nella parola, aggiornare il montepremi del giocatore in base al valore della ruota e segnare le lettere correttamente indovinate nell’array delle lettere scoperte.
• La funzione controlloVittoria verifica se la parola è stata completamente scoperta. Essa controlla l’array delle lettere scoperte e restituisce un valore che indica se tutte le lettere sono state indovinate, decretando così la fine della partita.
• Infine, la funzione main coordina l’intero funzionamento del programma. Al suo interno vengono inizializzate le variabili principali, come la parola da indovinare, i giocatori e i rispettivi montepremi. Viene mostrata l’introduzione e viene gestito il ciclo dei turni dei due giocatori. Il gioco continua fino a quando uno dei giocatori completa la parola misteriosa, momento in cui la partita termina.

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Completamento delle funzioni mancanti: implementare le funzioni di riferimento per rendere il gioco pienamente funzionante, come il giro della ruota con valori casuali, il controllo corretto delle lettere indovinate e la gestione della vittoria.
• Design più creativo del tabellone: utilizzare colori e formattazioni per distinguere le lettere scoperte da quelle nascoste, migliorando la leggibilità e l’impatto visivo della frase misteriosa.
• Introduzione di un avversario controllato dal computer: implementare una semplice intelligenza artificiale che permetta di giocare anche in modalità singolo giocatore. È possibile prevedere diversi livelli di difficoltà (facile, medio e difficile), variando la strategia di scelta delle lettere.
• Sistema di punteggio e statistiche: aggiungere un sistema che tenga traccia del montepremi accumulato da ciascun giocatore e memorizzi il numero di vittorie e sconfitte all’interno di una sessione di gioco.

Obiettivo: Realizzare un programma che implementi un gioco di calcio (nello specifico calci di rigore) utilizzando il linguaggio di programmazione C++.

I Calciatori

Vengono in seguito riportate una serie di Carte di alcuni giocatori dalle quali si può prendere spunto per la realizzazione del gioco. Ogni carta è caratterizzata da una serie di attributi (differenti per portieri e giocatori) che saranno definiti nel codice attraverso le strutture Calciatore e Portiere.
Nello specifico, gli attributi dei portieri sono:

• string nome;
• string ruolo;
• int tuffo;
• int presa;
• int rinvio;
• int riflessi;
• int reattivita;
• int piazzamento;

Differentemente, gli attributi dei Calciatori sono:

• string nome;
• string ruolo;
• int velocita;
• int tiro;
• int passaggio;
• int dribbling;
• int difesa;
• int fisico;

Il codice

Viene in seguito illustrato il codice utilizzato per implementare un gioco di combattimento tra Pokemon.
Il programma simula un gioco di combattimento tra due allenatori di Pokémon, ognuno con un mazzo di 3 Pokémon. Ogni Pokémon ha un nome, un tipo, dei punti vita, un attacco e una debolezza. Il codice gestisce la creazione di mazzi di Pokémon, l’inizializzazione delle proprietà di ogni Pokémon, e la simulazione di combattimenti tra i Pokémon di due allenatori.

Struttura del codice

1. Inclusioni e dichiarazioni globali:

   • La struttura Portiere definisce le caratteristiche dei portieri.
   • La struttura Calciatore definisce le caratteristiche dei calciatori.
   • La struttura Squadra è costituita dal nome della squadra da un portiere e da due giocatori.

2. Variabili locali:

   • Vengono dichiarati differenti oggetti di tipo Portiere e Calciatore (uno per ogni giocatore: Courtois, Martinez, Donnarumma, Messi, DiMaria, Barella, Immobile.

3. Funzioni:

   • inizializzaMessi(Calciatore &c): inizializza un oggetto di tipo calciatore con i valori specifici di Messi.
   • inizializzaDonnarumma(Portiere &p): inizializza un oggetto di tipo calciatore con i valori specifici di Donnarumma.
   • intro(): stampa un messaggio di benvenuto.

   • rigore(Calciatore calciatore, Portiere portiere, int indice)): Simula un calcio di rigore. La funzione dovrebbe restituire 1 se il calciatore segna e 0 se il portiere para.
   • sfida(Squadra team1, Squadra team2, int numRigori): simula una partita ai calci di rigore Questa funzione, richiama la funzione rigore per ciascun rigore tirato.

4. Funzione main():

   • Definisce le squadre.
   • Vengono inizializzati i calciatori ed i portieri.
   • La funzione intro() stampa un messaggio di benvenuto.

   • Viene eseguita la funzione sfida.

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Elementi di Randomicità nel calcio di rigore
  – Ogni tiro dovrebbe essere caratterizzato da un elemento di randomicità.

Obiettivo: Realizzare un programma che implementi un gioco di combattimento tra Pokemon utilizzando il linguaggio di programmazione C++.

I Pokemon

Vengono in seguito riportate una serie di Carte Pokemon dalle quali si può prendere spunto per la realizzazione del gioco. Ogni carta è caratterizzata da una serie di attributi che saranno definiti nel codice attraverso la struttura pokemon. Questi attributi sono: nome, tipo, puntiVita, nomeAttacco, danniAttacco, debolezza.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare un gioco di combattimento tra Pokemon.
Il programma simula un gioco di combattimento tra due allenatori di Pokémon, ognuno con un mazzo di 3 Pokémon. Ogni Pokémon ha un nome, un tipo, dei punti vita, un attacco e una debolezza. Il codice gestisce la creazione di mazzi di Pokémon, l’inizializzazione delle proprietà di ogni Pokémon, e la simulazione di combattimenti tra i Pokémon di due allenatori.

Struttura del codice

1. Inclusioni e dichiarazioni globali:

   • La struttura pokemon definisce un Pokémon con:
     – nome: nome del Pokémon (es. Pikachu, Charmander).
     – tipo: tipo del Pokémon (es. “fuoco”, “acqua”).
     – puntiVita: salute del Pokémon.
     – nomeAttacco: nome dell’attacco del Pokémon.
     – danniAttacco: danno dell’attacco.
     – debolezza: tipo di attacco che danneggia maggiormente il Pokémon.

2. Variabili globali:

   • Vengono dichiarati sei oggetti di tipo pokemon (uno per ogni Pokémon di gioco: Pikachu, Charmander, Pidgey, Squirtle, Vulpix, Bulbasaur).
   • Vengono dichiarate delle costanti di tipo stringa per rappresentare i tipi di Pokémon: elettro, fuoco, acqua, ghiaccio, lotta.

3. Funzioni:

   • inizializzaPikachu(pokemon &p): inizializza un oggetto di tipo pokemon con i valori specifici di Pikachu.
   • inizializzaCharmander(pokemon &p): inizializza un oggetto di tipo pokemon con i valori specifici di Charmander.
   • intro(): stampa un messaggio di benvenuto. La funzione è vuota e non implementata.
   • creazioneMazzi(pokemon mazzo1[], pokemon mazzo2[], int numPokemon): crea due mazzi con i Pokémon specificati. Ogni mazzo contiene 3 Pokémon.
   • combattimento(pokemon &p1, pokemon &p2): gestisce un combattimento tra due Pokémon. La funzione non è ancora implementata in modo completo, ma stampa un messaggio indicando i Pokémon che stanno combattendo. La funzione dovrebbe restituire 1 se il primo Pokémon vince e 2 se il secondo Pokémon vince.
   • combattimentoMazzi(pokemon mazzo1[], pokemon mazzo2[], int numPokemon): simula un combattimento tra i mazzi dei due allenatori. Chiama la funzione combattimento per ciascun Pokémon dei due mazzi. La funzione dovrebbe restituire 1 se il giocatore 1 vince più sfide e 2 se il giocatore 2 vince più sfide.

4. Funzione main():

   • Definisce i nomi degli allenatori e il numero di Pokémon in ciascun mazzo (3 per ciascun giocatore).
   • Viene inizializzato Pikachu e Charmander tramite le funzioni inizializzaPikachu e inizializzaCharmander.
   • La funzione intro() stampa un messaggio di benvenuto (anche se non implementata).
   • I mazzi dei due giocatori vengono creati dalla funzione creazioneMazzi.
   • Viene avviato un ciclo per eseguire un numero definito di sfide (3 in questo caso). Ad ogni sfida, si simula un combattimento tra i Pokémon nei mazzi.

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Elementi di Randomicità Probabilità di Colpo Critico:
  – Ogni attacco potrebbe avere una probabilità di infliggere danni doppi o tripli, per simulare i colpi critici. – Mossa Speciale Casuale: I Pokémon potrebbero avere un’abilità speciale che si attiva in modo casuale (per esempio, un attacco che colpisce 2 volte di seguito).
• Aggiungere Altri Pokémon: I giocatori potrebbero scegliere tra una lista di Pokémon più ampia, con caratteristiche diverse (punteggi vita, tipo di attacco, ecc.).
• Tipi di Attacco e Interazioni con i Tipi: Ogni Pokémon potrebbe avere una lista di attacchi con effetti diversi, e gli attacchi potrebbero essere influenzati dal tipo del Pokémon avversario. Ad esempio: Fuoco è efficace contro Erba. Acqua è efficace contro Fuoco. Elettrico è efficace contro Acqua. Potrebbero implementare la logica che, in base al tipo di attacco e al tipo di Pokémon, i danni subiti o inflitti cambiano.
• Punti Esperienza e Livelli Punti Esperienza (XP): Ogni volta che un Pokémon vince una battaglia, guadagna dei punti esperienza che lo fanno salire di livello, aumentando così i suoi punti vita o danni.
• Evoluzione: I Pokémon potrebbero evolversi quando raggiungono un certo livello, aumentando le loro statistiche (esempio: Pikachu evolve in Raichu).
• Intelligenza Artificiale: Implementare un’IA per il secondo giocatore.
• Modalità Storia: I giocatori potrebbero affrontare una serie di battaglie contro allenatori (che potrebbero avere Pokémon diversi) fino a raggiungere il “campione” finale.

Obiettivo: Realizzare un programma che implementi la grafica di una semplice slot machine  sfruttando la tecnica ASCII Art ed il linguaggio di programmazione C++.

Aspetto Gafico
L’obiettivo principale di questa lezione non è realizzare la meccanica utile per implementare una slot machine. Piuttosto, lo scopo è mostrare come sia possibile implementare una possibile grafica utilizzando la tecnica ASCII Art.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare una semplice grafica di una slot machine utilizzando la tecnica ASCII art. Nel codice oltre alle tecniche per la gestione dei colori, sono utilizzate due importanti funzioni:

• La funzione mSleep(int milliseconds) ha il compito di sospendere temporaneamente l’esecuzione del programma per un intervallo di tempo espresso in millisecondi. Viene utilizzata per rendere più fluida la visualizzazione dei messaggi a schermo, inserendo brevi pause tra una stampa e la successiva.
• La funzione cin.get() permette di bloccare il flusso del codice fino a che l’utente non preme invio.
• La funzione system(“clear”) permette di cancellare tutto quello che è presente nello schermo nello specifico momento in cui viene lanciata.

</script

E' importante considerare che il codice è stato scritto per il compilatore onlinegdb pertanto alcune funzionalità potrebbero non essere disponibili in altri ambienti di sviluppo.

Viene in seguito riportata la grafica della slot machine implementata attraverso il precedente codice.

Obiettivo: Realizzare un programma che implementi una Slot Machine utilizzando il linguaggio di programmazione C++.

Il codice

Viene in seguito illustrato il codice utilizzato per implementare una semplice versione di una Slot Machine. Nel dettaglio, il codice prevede una netta distinzione tra il motore grafico che permette di stampare la griglia del gioco ed il codice di gestione del gioco (i.e., gestione dei soldi, controllo delle vincite, etc…).

• Motore Grafico: La funzione void grafica(char s[]) ha il ruolo di stampare la griglia di gioco definita nell’array di caratteri t che contiene le informazioni relative alle celle del tabellone e aggiorna la console con il contenuto di ogni cella, disegnando una griglia di gioco.

• Codice di gestione del gioco: La dinamica del gioco viene sviluppata all’interno della funzione main. Nel dettaglio l’intero gioco viene implementato attraverso un ciclo while indefinito che prevede la condizione (soldi>0). In questo caso il giocatore continuerà a giocare fino a che avrà soldi a disposizione. Ogni volta che il giocatore preme invio per giocare, vengono rispettivamente: decrementi i soldi, generati nuovi valori nella griglia della slot, stampata la grafica, e controllate eventuali vincite.
  Sono inoltre definite una serie di funzioni, alcune già implementate ed altre invece da implementare al fine di terminare il gioco.
• Costanti e Definizione dei colori: Utilizza macro per definire alcuni colori (rosso, verde, giallo, blu) per il testo in console e applicarli tramite escape codes. La macro NUMCELLE definisce la dimensione del tabellone (3×3 = 9 celle).
• Funzione mySleep(int seconds): Definisce una versione personalizzata della funzione sleep, compatibile con l’ambiente di esecuzione online di OnlineGDB, per ritardare l’output di un certo numero di secondi. In aggiunta, std::cout.flush() forza l’output immediato del buffer di stampa.
• Funzione intro(): Visualizza un messaggio: Best Slot Machine Ever usando colori diversi per ogni parola (“Best”, “Slot”, “Machine”, “Ever”) con una pausa tra ognuna. Chiede poi all’utente di premere Invio per proseguire.
• Funzione regole(): È una funzione vuota che può essere riempita per mostrare le regole del gioco. Al momento, non ha alcuna implementazione.
• Funzione generazioneSlot(int slot[]): genera il contenuto della slot machine riempiendo ogni cella con un numero casuale compreso tra 0 e 2. Ogni numero rappresenta un simbolo differente.
  Funzione conversioneSlot(int slot[], char slotCaratteri[]): converte i valori interi generati in generazioneSlot in caratteri. I valori rappresentano i simboli:
• Funzione controlloVittoria(char s[], int &soldi): verifica se c’è una combinazione vincente nella slot machine

https://onlinegdb.com/cDD7cRgAy

Modifiche:

Al fine di rendere il gioco più avvincente è possibile introdurre una serie di modifiche:

• Completare le funzioni di riferimento per terminare il gioco.
  Design più Creativo per il Tabellone: Offrire temi personalizzati per il tabellone e simboli differenti.