# data[].attributes.body
OpenSCAD è un software di modellazione di oggetti 3D basato su un linguaggio di programmazione script tipo il C

# data[].attributes.headline
Lezione 2: Trasformazioni di base con OpenSCAD

# data[].attributes.subject
Lezione 2: Trasformazioni di base con OpenSCAD

# data[].attributes.body
Una volta definita la figura 3D da disegnare, è necessario sottoporla
ad una trasformazione. Le trasformazioni possono essere:
· traslazione
· rotazione
· scalatura
· unione
· differenza
· intersezione

# data[].attributes.body
Giornata di mobilitazione sui cambiamenti climatici 27 settembre.
Materiale proposto dalla scuola ed utilizzato in classe per parlare di RAEE.
Scarica il materiale "zippato" e realizza la tua presentazione/riassunto/osservazioni/riflessioni in PowerPoint o Word.

# data[].attributes.body
Sperimenta le tue competenze dopo le prime due lezioni in laboratorio

# data[].attributes.body
Introduzione all'ambiente di programmazione.

# data[].attributes.body
I componenti principali.

# data[].attributes.body
Iniziamo ad usare i ferri del mestiere.
E non dimentichiamoci della riflessione che troverai a fine esercitazione.

# data[].attributes.body
Gestiamo meglio il dispositivo ed impariamo a disegnare a mano libera.
Anche alla fine di questo esercizio troverai uno spunto di riflessione sul quale lavoreremo in classe durante il tempo legato all'UDA sul cyberbullismo.

# data[].attributes.headline
App - Inventor - Esercizio 3 "Pallina rimbalzina"

# data[].attributes.subject
App - Inventor - Esercizio 3 "Pallina rimbalzina"

# data[].attributes.body
Lanciamo una pallina in qualsiasi direzione.
Anche qui troverai alla fine una piccola riflessione.

# data[].attributes.headline
App - Inventor - Esercizio 4 Toro "vedorosso"

# data[].attributes.subject
App - Inventor - Esercizio 4 Toro "vedorosso"

# data[].attributes.body
Usiamo i sensori integrati nello smartphone.
E non dimentichiamoci della riflessione finale: ti capita di lanciarti contro qualcuno nei social, anche solo per il colore così come fa il toro nei confronti di una pallina rossa ?

# data[].attributes.headline
App - Inventor - Esercizio 5 "Colpisci La Talpa".

# data[].attributes.subject
App - Inventor - Esercizio 5 "Colpisci La Talpa".

# data[].attributes.body
Proviamo a realizzare un giochino tutto nostro che può essere anche lo spunto per una riflessione sul cyberbullismo.

# data[].attributes.body
Immagini della talpa da utilizzare nella realizzazione della talpa. Le immagini vanno "unzippate" in una cartelletta sul vostro desktop.

# data[].attributes.headline
App - Inventor - Esercizio 5 - Un  piccolo aiuto

# data[].attributes.subject
App - Inventor - Esercizio 5 - Un  piccolo aiuto

# data[].attributes.body
Come piccolo aiuto per il programma della talpa, vi ho preparato l'avvio del codice e dell'ambiente dove avevate trovato più difficoltà prima delle vacanze di natale. E' sufficiente che importiate l'app nel vostro account di App Inventor.

# data[].attributes.body
Il coding è un’attività in rapida crescita, perfetta non solo per chi sogna di diventare un programmatore da grande ma soprattutto per abituare i più giovani al pensiero computazionale o algoritmico, che implica la capacità di trovare una soluzione a un problema e svilupparla.
Il corso di programmazione C++ proposto all'I.S. Marconi di Dalmine, pensato e messo a punto per i ragazzi del primo anno, mira, attraverso un approccio empirico, a favorire un’acquisizione completa e approfondita del linguaggio C++ e di tutti i suoi elementi caratterizzanti.
L’obiettivo è trasformare i ragazzi da usufruitori passivi della tecnologia in soggetti attivi, capaci non solo di comprenderne i meccanismi più intimi, ma di generarli.
Argomenti:
- Differenza tra linguaggi compilati e linguaggi interpretati;
- Primo programma in C++;
- Esercizi in arte ASCII.

# data[].attributes.body
In ogni ambito e settore, dalle scienze all’ economia, dalla biologia alla tecnologia,
dallo sport alla vita quotidiana, ciascuno di noi deve giornalmente
affrontare dei problemi , eseguire dei compiti e prendere delle decisioni.
Per individuare la soluzione poterebbe essere necessario cercare di comprendere meglio il problema, cioè effettuare un’analisi approfondita della situazione e, nei casi più complessi, individuare una strategia risolutiva.

# data[].attributes.body
Introduzione algoritmo.

# data[].attributes.headline
Linguaggio C++: introduzione all'uso di Dev C++ (Lab 2)

# data[].attributes.subject
Linguaggio C++: introduzione all'uso di Dev C++ (Lab 2)

# data[].attributes.body
Per realizzare gli esercizi proposti useremo l'ambiente di programmazione Dev C++. Anche la prova parallela e quella di competenza prevederanno l'usco ddi questo ambiente.
Se non potete installare a casa Dev C++ sul vostro computer, comunque svolgete gli esercizi utilizzando una delle tante piattaforme di programmazione online tipo: https://repl.it oop
https://www.onlinegdb.com/online_c++_compiler

# data[].attributes.body
Le variabili

# data[].attributes.body
Rappresentazione degli algoritmi

# data[].attributes.body
Diagrammi di flusso. Esercizi.

# data[].attributes.body
La matematica con il C++

# data[].attributes.headline
Linguaggio C++ (Teoria 6): Struttura di controllo if..else.

# data[].attributes.subject
Linguaggio C++ (Teoria 6): Struttura di controllo if..else.

# data[].attributes.body
Il blocco di istruzioni viene eseguito soltanto se la condizione di controllo si verifica. Se non si verifica il blocco non viene eseguito.
Provate i due esempi con DevC++ o, se non lo avete ancora installato nel PC di casa, utilizzate la piattaforma online https://repl.it/languages/cpp
Nei prossimi giorni vi caricherò un esercizio da fare, tipo i due della lezione, che verranno valutati.

# data[].attributes.headline
Esercizio (teoria 6) da consegnare in Moodle entro le ore 14 di martedì 3 marzo 2020

# data[].attributes.subject
Esercizio (teoria 6) da consegnare in Moodle entro le ore 14 di martedì 3 marzo 2020

# data[].attributes.body
Dovrai modificare il programma con if..else della lezione. Dovrete usare DevC++ o la piattaforma online https://repl.it/languages/cpp (anche con lo smartphone se non lo avete installato o se il pc di casa non funziona o non lo avete).
La consegna è entro le ore 14 di martedì 3 marzo. Lo potete svolgere nelle nostre ore di laboratorio.
In Moodle, potete fare il copia-incolla della vostra soluzione o allegare il file che salvate/esportate con DevC++/repl.it

# data[].attributes.body
prima di chiedere i dati all'utente con l'istruzione cin, a lezione avevamo detto che è necessario stampare sul video un messaggio con cout.
La risposta dell'utente, 0 o 1, viene poi messa nella variabile hoFame.

# data[].attributes.headline
Linguaggio C++ (Teoria 7): Parte 2 struttura di controllo if..else.

# data[].attributes.subject
Linguaggio C++ (Teoria 7): Parte 2 struttura di controllo if..else.

# data[].attributes.body
Lezione sulle strutture di controllo, parte 2.
Oggi parleremo degli altri operatori di  confronto e di quelli logici che vi
serviranno per controllare il flusso di un programma.
Domani vi verranno assegnati gli esercizi sulla lezione 2 che dovrete svolgere entro sabato 14 marzo

# data[].attributes.headline
Esercizio (teoria 7) da consegnare in Moodle entro le ore 12 di martedì 10 marzo 2020

# data[].attributes.subject
Esercizio (teoria 7) da consegnare in Moodle entro le ore 12 di martedì 10 marzo 2020

# data[].attributes.body
Per programmare in C++, come per l'altro esercizio, potrete usare DevC++ (la prof.ssa Daniele nel suo corso in piattaforma Lab Tin-1G-2019/20 vi ha caricato il link di un filmato con le spiegazioni per l'installazione nel PC di casa) o la piattaforma online https://repl.it/languages/cpp.

La consegna è entro le ore 12 di martedì 10 marzo. Lo potete svolgere nelle nostre ore di laboratorio.
Potete fare il copia incolla della vostra soluzione o allegare il file che salvate/esportate con DevC++/repl.it
Per rispondere alle domande è sufficiente fare foto al vostro quaderno ed allegarmi la foto.

# data[].attributes.body
Grazie a tutti gli studenti che hanno partecipato a questa attività di elearning in remoto ed hanno caricato i compiti in piattaforma Moodle.

# data[].attributes.headline
Lezione C++ (Teoria 9): Come sviluppare un programma informatico 

# data[].attributes.subject
Lezione C++ (Teoria 9): Come sviluppare un programma informatico 

# data[].attributes.body
I passi fondamentali per imparare a programmare sono i seguenti:

1. L’analisi del problema.

2. L’algoritmo.

3. Lo pseudocodice.

4. L’ implementazione.

5. L’ esecuzione, la verifica ed il test.

# data[].attributes.body
Uno pseudocodice è un linguaggio non informatico a metà tra il linguaggio di
programmazione ed il linguaggio naturale. Scoprirete come lo pseudocodice è l’anello di congiunzione tra il diagramma di flusso e l’implementazione in C++ del vostro algoritmo.

# data[].attributes.body
Oggi svolgiamo alcuni esercizi ancora con l'istruzione if..else. Useremo anche gli operatori logici (and, or, not) che abbiamo visto nelle scorse settimane. Ripasseremo anche l'operazione modulo della quale ne avevamo parlato in classe. Vi verrà chiesto di rispondere ad alcune domande e completare un programma.

# data[].attributes.body
Quando rivedete la lezione di oggi con le soluzioni, fate attenzione dove abbiamo messo le istruzioni if..elseif..else per dire se è un triangolo equilatero, isoscele o scaleno: sono state raggruppate nel sotto-caso di "triangolo esistente".

Trovate la definzione di complessità temporale e spaziale di un algoritmo nella lezione 004_PRO.PDF. Invece l'operatore NOT ! (bang) lo trovate nella lezione 008_PRO.PDF: vi ricordate del "bang bang" !!IndossaGuanti ?

Vi ho messo anche un aiutino per scrivere il codice C++ del programma per stabilire se un anno è bisestile.

# data[].attributes.headline
Introduzione ai cicli iterativi: l'istruzione FOR

# data[].attributes.subject
Introduzione ai cicli iterativi: l'istruzione FOR

# data[].attributes.body
Nelle lezioni precedenti, abbiamo imparato ad utilizzare l'istruzione if.
In queste nuove lezioni, esploreremo i cicli, detti anche “loop”, che sono strutture di codice che vi consentono di ripetere un blocco di codice in determinate condizioni.
Gli esercizi di compito sono per settimana prossima perché sabato prossimo c'è la vacanza del 25 aprile.

# data[].attributes.body
Oggi vedremo alcuni esempi di impiego del ciclo for. Non sono esempi facili come quelli della prima lezione introduttiva sui cicli iterativi. Ma avrete tempo fino a settimana prossima (sabato prossimo c'è il ponte del 1° maggio) per ricopiarli, provarli e capirli.
Li useremo nel mese di maggio per realizzare il programma in C++ di un gioco di avventura testuale (con grafica ASCII Art).

# data[].attributes.headline
Scrivere una avventura testuale in C++: introduzione

# data[].attributes.subject
Scrivere una avventura testuale in C++: introduzione

# data[].attributes.body
Un’avventura testuale è un gioco in cui il  giocatore muove un personaggio virtuale all'interno di un mondo virtuale.
Il computer fornisce la descrizione della situazione attuale e degli eventi che accadono e il giocatore decide le azioni del personaggio mediante dei comandi dati in linguaggio naturale.
Quello che cercherò  di  fornirvi   oggi in questa lezione introduttiva consiste  in  qualche suggerimento e qualche idea che ciascuno di voi può riprendere e sviluppare secondo le proprie capacità di programmatore.
Il lavoro va fatto in piccoli gruppi nei quali vi suddividerete i compiti e lo presenterete sia al MarconiDay che agli OpenDay del prossimo anno scolastico.
Nello sviluppare il nostro programma utilizzeremo il linguaggio C++ che abbiamo visto quest’anno.

# data[].attributes.headline
Esempio adventure game: "Il segreto della fontana"

# data[].attributes.subject
Esempio adventure game: "Il segreto della fontana"

# data[].attributes.body
Molte avventure testuali sono in inglese e costituiscono un buon metodo per imparare a leggere e scrivere in inglese. Basta una semplice ricerca con Google.

L'esempio che vi propongo è invece una avventura di tipo "artistico" in linguaggio BASIC che avevo scritto quando, alla vostra età, frequentavo la 1A del liceo scientifico di Caravaggio. In quegli anni a casa i ragazzi avevamo i primi computer Commodore Vic20 e 64 ed il Sinclair ZX80 (chiedete ai vostri papà se si ricordano i primi home computer degli anni 80). Ho trovato on line la possibilità di "compilare" (abbiamo detto nelle lezioni cosa vuol dire compilare, perché il BASIC è invece un linguaggio "interpretato") in modo tale che ho trasformato il programma in un eseguibile (adve.exe) che potete scaricare ed eseguire in modalità desktop nel vostro computer. L'adventure game è ambientato in una piccolo santuario di Romano di Lombardia e l'avevo realizzato per illustrare le opere artistiche e la storia del santuario. Poi c'è un po' di thriller perché bisogna scoprire quale sia il segreto della "fontana" sulla quale il santuario venne edificato nel 1606.
Chi di voi scopre il segreto della fontana mi deve anche dire quali sono i passaggi che ha fatto per risolvere i vari indizi.
Fate attenzione all'antivirus del vostro PC quando scaricate il gioco perché è un file di tipo eseguibile .exe e l'antivirus potrebbe bloccarlo.

Per spostarsi usare  le lettere n,s,o,e, corrispondenti  alle direzioni cardinali. Inoltre con la  lettera  i potrete  ottenere l'inventario, ossia la lista degli oggetti che avete con voi. Il gioco è implementato sul 'two  word-parsing', che permette di dare i comandi con il classico sistema del verbo, articolo e nome.Tenete sempre presente la seguente lista dei verbi:
abbandona       abbatti     accendi
afferra       annoda      apri
arrampicati      brucia      demolisci
discendi      guarda      inerpicati
issa      lascia      lega
leggi      muovi       osserva
prendi      pulisci     salta
scava      scavalca    scendi
siedi      spolvera    sposta
sali       suona       tira

# data[].attributes.body
Questo è il listato di base che dovrete scaricare e modificare, aggiungendo le descrizioni delle vostre stanze, dei vostri oggetti e la storia della vostra avventura testuale.
Come abbiamo detto nelle lezioni della scorsa settimana, il programma utilizza per lo più i cicli iterativi for per riconoscere i comandi e gli oggetti e le strutture if..else if ... else per eseguire le azioni date dal giocatore nel corso dell'avventura.
Per modificare il listato potete utilizzare la piattaforma di programmazione online https://repl.it/languages/cpp oppure l'ambiente di programmazione Dev C++ per chi l'ha installato nel proprio computer. E' sufficiente fare il copia-incolla del listato che vi ho fornito.

# data[].attributes.attachment_link.readable_text
// Listato di partenza per scrivere la propria avventura testuale
// I.S. Marconi - Dalmine - A.S. 2019/2020
// 1G - TIN
// prof. Luca Bergamaschi

#include <iostream>		// libreria per l'uso della tastiera e del video
#include <string>		// libreria per la gestione delle stringhe di testo
#include <vector>		// libreria per la gestione degli array dei comandi e dei nomi
#include <cctype>		// libreria per eliminare alcuni problemi tra i diversi tipi di variabili

using namespace std;	// uso le librerie standard

enum en_DIREZIONI {NORD, EST, SUD, OVEST};

// modifica il codice ed aggiungi le stanze che avranno senso nella vostra avventura
enum en_STANZE {NEGOZIO, CASINO, PARCHEGGIO, ATRIO, RISTORANTE, CORRIDOIO, MAGAZZINO, PISCINA, GIARDINO, LAGHETTO, POMPE};

// modifica il codice ed aggiungi i verbi delle azioni che avranno senso nella vostra avventura
enum en_VERBI {PRENDI, LASCIA, USA, APRI, CHIUDI, ESAMINA, INVENTARIO, GUARDA};

// modifica il codice ed aggiungi gli oggetti che avranno senso nella vostra avventura
enum en_OGGETTI {PORTA, MAGNETE, COLONNINA, ROULETTE, SOLDI, CANNAPESCA};
// ....

const int NESSUNO = -1;			// costante per dire nessuno nel programma
const int ZAINO = 1000;			// se un oggetto è nella stanza "1000" vuol dire che è nel tuo zaino

const int DIREZIONI = 4;		// numero delle direzioni
const int STANZE = 11;			// numero delle stanze
const int VERBI = 8;			// numero dei verbi

// modifica il codice inserendo il numero corretto degli oggetti
const int OGGETTI = 6;			// numero degli oggetti
// ....

struct comandi						// struttura dati per la gestione dei comandi
{
    string comandi;
    int code;
};

struct stanza						// struttura dati per la gestione dei verbi
{
    string descrizione;
    int uscita_verso[DIREZIONI];
};

// Se volete potete aggiungere altre strutture dati
struct oggetto				// struttura dati per gestione degli oggetti
{
    string comandi;
    string descrizione;
    int code;
    int posizione;
    bool trasportabile;
};
// ....

// -------------------------------------------------------------------------------------------------
// modifica il codice seguente ed aggiungi le stanze e le relative descrizioni
// integra la descrizione delle stanze. Potete aggiungere anche ASCII ART	
void set_STANZE(stanza *descrizione_stanza)
{
    descrizione_stanza[NEGOZIO].descrizione.assign("un negozio di articoli sportivi di marca");
    descrizione_stanza[NEGOZIO].uscita_verso[NORD] = NESSUNO;
    descrizione_stanza[NEGOZIO].uscita_verso[EST] = NESSUNO;
    descrizione_stanza[NEGOZIO].uscita_verso[SUD] = PARCHEGGIO;
    descrizione_stanza[NEGOZIO].uscita_verso[OVEST] = NESSUNO;

    descrizione_stanza[CASINO].descrizione.assign("un vivace casinò");
    descrizione_stanza[CASINO].uscita_verso[NORD] = NESSUNO;
    descrizione_stanza[CASINO].uscita_verso[EST] = NESSUNO;
    descrizione_stanza[CASINO].uscita_verso[SUD] = ATRIO;
    descrizione_stanza[CASINO].uscita_verso[OVEST] = NESSUNO;

    descrizione_stanza[PARCHEGGIO].descrizione.assign(
   "il parcheggio delle auto                \n"
   "Ci sono dei posti liberi per parcheggiare."  );
    descrizione_stanza[PARCHEGGIO].uscita_verso[NORD] = NEGOZIO;
    descrizione_stanza[PARCHEGGIO].uscita_verso[EST] = ATRIO;
    descrizione_stanza[PARCHEGGIO].uscita_verso[SUD] = NESSUNO;
    descrizione_stanza[PARCHEGGIO].uscita_verso[OVEST] = NESSUNO;

    descrizione_stanza[ATRIO].descrizione.assign(
    "l'atrio di un hotel             \n"
    "Un maggiordomo ti attende alla reception.....");
    descrizione_stanza[ATRIO].uscita_verso[NORD] = CASINO;
    descrizione_stanza[ATRIO].uscita_verso[EST] = RISTORANTE;
    descrizione_stanza[ATRIO].uscita_verso[SUD] = CORRIDOIO;
    descrizione_stanza[ATRIO].uscita_verso[OVEST] = PARCHEGGIO;

    descrizione_stanza[RISTORANTE].descrizione.assign("un ristorante à la carte. Un po caro per le nostre tasche!");
    descrizione_stanza[RISTORANTE].uscita_verso[NORD] = NESSUNO;
    descrizione_stanza[RISTORANTE].uscita_verso[EST] = NESSUNO;
    descrizione_stanza[RISTORANTE].uscita_verso[SUD] = NESSUNO;
    descrizione_stanza[RISTORANTE].uscita_verso[OVEST] = ATRIO;

    descrizione_stanza[CORRIDOIO].descrizione.assign("un corridoio");
    descrizione_stanza[CORRIDOIO].uscita_verso[NORD] = ATRIO;
    descrizione_stanza[CORRIDOIO].uscita_verso[EST] = NESSUNO;
    descrizione_stanza[CORRIDOIO].uscita_verso[SUD] = GIARDINO;
    descrizione_stanza[CORRIDOIO].uscita_verso[OVEST] = NESSUNO;

    descrizione_stanza[MAGAZZINO].descrizione.assign("il magazzino");
    descrizione_stanza[MAGAZZINO].uscita_verso[NORD] = NESSUNO;
    descrizione_stanza[MAGAZZINO].uscita_verso[EST] = NESSUNO;
    descrizione_stanza[MAGAZZINO].uscita_verso[SUD] = NESSUNO;
    descrizione_stanza[MAGAZZINO].uscita_verso[OVEST] = NESSUNO;

    descrizione_stanza[PISCINA].descrizione.assign("l'area all'aperto con la piscina");
    descrizione_stanza[PISCINA].uscita_verso[NORD] = NESSUNO;
    descrizione_stanza[PISCINA].uscita_verso[EST] = GIARDINO;
    descrizione_stanza[PISCINA].uscita_verso[SUD] = POMPE;
    descrizione_stanza[PISCINA].uscita_verso[OVEST] = NESSUNO;

    descrizione_stanza[GIARDINO].descrizione.assign("un giardino molto tranquillo, con un venticello leggero");
    descrizione_stanza[GIARDINO].uscita_verso[NORD] = CORRIDOIO;
    descrizione_stanza[GIARDINO].uscita_verso[EST] = LAGHETTO;
    descrizione_stanza[GIARDINO].uscita_verso[SUD] = NESSUNO;
    descrizione_stanza[GIARDINO].uscita_verso[OVEST] = PISCINA;

    descrizione_stanza[LAGHETTO].descrizione.assign("un bellissimo patio con laghetto");
    descrizione_stanza[LAGHETTO].uscita_verso[NORD] = NESSUNO;
    descrizione_stanza[LAGHETTO].uscita_verso[EST] = NESSUNO;
    descrizione_stanza[LAGHETTO].uscita_verso[SUD] = NESSUNO;
    descrizione_stanza[LAGHETTO].uscita_verso[OVEST] = GIARDINO;

    descrizione_stanza[POMPE].descrizione.assign("il luogo_attualeale tecnico per le pompe della piscina (molto umido)");
    descrizione_stanza[POMPE].uscita_verso[NORD] = PISCINA;
    descrizione_stanza[POMPE].uscita_verso[EST] = NESSUNO;
    descrizione_stanza[POMPE].uscita_verso[SUD] = NESSUNO;
    descrizione_stanza[POMPE].uscita_verso[OVEST] = NESSUNO;
}

// -------------------------------------------------------------------------------------------------

void set_directions(comandi *dir)
{
    dir[NORD].code = NORD;
    dir[NORD].comandi = "NORD";
    dir[EST].code = EST;
    dir[EST].comandi = "EST";
    dir[SUD].code = SUD;
    dir[SUD].comandi = "SUD";
    dir[OVEST].code = OVEST;
    dir[OVEST].comandi = "OVEST";
}

// -------------------------------------------------------------------------------------------------

// modifica il codice
void set_VERBI(comandi *descrizione_verbi)	
{
    // modifica la descrizione per ogni verbo
    descrizione_verbi[PRENDI].code = PRENDI;
    descrizione_verbi[PRENDI].comandi = "PRENDI";
    descrizione_verbi[LASCIA].code = LASCIA;
    descrizione_verbi[LASCIA].comandi = "LASCIA";
    descrizione_verbi[USA].code = USA;
    descrizione_verbi[USA].comandi = "USA";
    descrizione_verbi[APRI].code = APRI;
    descrizione_verbi[APRI].comandi = "APRI";
    descrizione_verbi[CHIUDI].code = CHIUDI;
    descrizione_verbi[CHIUDI].comandi = "CHIUDI";
    descrizione_verbi[ESAMINA].code = ESAMINA;
    descrizione_verbi[ESAMINA].comandi = "ESAMINA";
    descrizione_verbi[INVENTARIO].code = INVENTARIO;
    descrizione_verbi[INVENTARIO].comandi = "INVENTARIO";
    descrizione_verbi[GUARDA].code = GUARDA;
    descrizione_verbi[GUARDA].comandi = "GUARDA";
}

// -------------------------------------------------------------------------------------------------

// modifica il codice
void set_OGGETTI(oggetto *descrizione_oggetti)
{
    //emodifica la descrizione per ogni oggetto
    descrizione_oggetti[PORTA].comandi = "PORTA";
    descrizione_oggetti[PORTA].code = PORTA;
    descrizione_oggetti[PORTA].descrizione = "una porta chiusa che da accesso al magazzino";
    descrizione_oggetti[PORTA].trasportabile = false;
    descrizione_oggetti[PORTA].posizione = CORRIDOIO;
	
    descrizione_oggetti[MAGNETE].comandi = "MAGNETE";
    descrizione_oggetti[MAGNETE].code = MAGNETE;
    descrizione_oggetti[MAGNETE].descrizione = "una calamita (magnete)";
    descrizione_oggetti[MAGNETE].trasportabile = true;
    descrizione_oggetti[MAGNETE].posizione = 1000;
	
    descrizione_oggetti[COLONNINA].comandi = "COLONNINA";
    descrizione_oggetti[COLONNINA].code = COLONNINA;
    descrizione_oggetti[COLONNINA].descrizione = 
    "una colonnina per i biglietti del parcheggio    \n"
    "Avete le monete da mettere ?                      ";
    descrizione_oggetti[COLONNINA].trasportabile = false;
    descrizione_oggetti[COLONNINA].posizione = PARCHEGGIO;
	
    descrizione_oggetti[ROULETTE].comandi = "ROULETTE";
    descrizione_oggetti[ROULETTE].code = ROULETTE;
    descrizione_oggetti[ROULETTE].descrizione = "la ruota di una roulette";
    descrizione_oggetti[ROULETTE].trasportabile = false;
	descrizione_oggetti[ROULETTE].posizione = CASINO;
    
	descrizione_oggetti[SOLDI].comandi = "SOLDI";
    descrizione_oggetti[SOLDI].code = SOLDI;
    descrizione_oggetti[SOLDI].descrizione = "un mucchietto di soldi";
    descrizione_oggetti[SOLDI].trasportabile = true;
    descrizione_oggetti[SOLDI].posizione = NESSUNO;
	
    descrizione_oggetti[CANNAPESCA].comandi = "CANNAPESCA";
    descrizione_oggetti[CANNAPESCA].code = CANNAPESCA;
    descrizione_oggetti[CANNAPESCA].descrizione = "una canna da pesca";
    descrizione_oggetti[CANNAPESCA].trasportabile = false;
    descrizione_oggetti[CANNAPESCA].posizione = NEGOZIO;
}
// ....

// -------------------------------------------------------------------------------------------------

void section_command(string Cmd, string &wd1, string &wd2)
{
    string sub_str;
    vector<string> comandis;
    char search = ' ';
    size_t i, j;

    for(i = 0; i < Cmd.size(); i++)
    {
        if(Cmd.at(i) != search)
        {
            sub_str.insert(sub_str.end(), Cmd.at(i));
        }
        if(i == Cmd.size() - 1)
        {
            comandis.push_back(sub_str);
            sub_str.clear();
        }
        if(Cmd.at(i) == search)
        {
            comandis.push_back(sub_str);
            sub_str.clear();
        }
    }

    for(i = comandis.size() - 1; i > 0; i--)
    {
        if(comandis.at(i) == "")
        {
            comandis.erase(comandis.begin() + i);
        }
    }

    for(i = 0; i < comandis.size(); i++)
    {
        for(j = 0; j < comandis.at(i).size(); j++)
        {
            if(islower(comandis.at(i).at(j)))
            {
                comandis.at(i).at(j) = toupper(comandis.at(i).at(j));
            }
        }
    }

    if(comandis.size() == 0)
    {
        cout << "Nessun comando inserito" << endl;
    }
    if(comandis.size() == 1)
    {
        wd1 = comandis.at(0);
    }
    if(comandis.size() == 2)
    {
        wd1 = comandis.at(0);
        wd2 = comandis.at(1);
    }
    if(comandis.size() > 2)
    {
        cout << "Comando troppo lungo. Potete inserire frasi con una o due parole (direzione o verbo e complemento oggetto)" << endl;
    }
}

// ----------------------------------------------------------------------------------------
void guarda_intorno(int luogo_attuale, stanza *descrizione_stanza, comandi *dir, oggetto *descrizione_oggetti)
{
    int i;
    cout << "Sono arrivato qui: " << descrizione_stanza[luogo_attuale].descrizione << "." << endl;

    for(i = 0; i < DIREZIONI; i++)
    {
        if(descrizione_stanza[luogo_attuale].uscita_verso[i] != NESSUNO)
        {
            cout << "C'è una uscita a " << dir[i].comandi << " verso " << descrizione_stanza[descrizione_stanza[luogo_attuale].uscita_verso[i]].descrizione << "." << endl;
        }
    }

    // puoi modificare il codice
    // il comando GUARDA dovrebbe controllare la presenza di oggetti che ci sono nella stanza corrente e visualizzarli al giocatore.
    for(i = 0; i < OGGETTI; i++)
    {
        if(descrizione_oggetti[i].posizione == luogo_attuale)
        {
            cout << "Ho trovato " << descrizione_oggetti[i].descrizione << "." << endl;
        }
    }
}

// ----------------------------------------------------------------------------------------

bool parser(int &luogo_attuale, string wd1, string wd2, comandi *dir, comandi *descrizione_verbi, stanza *descrizione_stanza, oggetto *descrizione_oggetti)
{
    // modificate il codice, aggiungendo le vostre variabili booleane che utilizzeret nel gioco. Ricordatevi di aggiungere la parola static davanti a bool
    static bool stato_della_porta = false; // se mettete false la porta all'inizio del gioco è chiusa
	// ....

    int i;
    for(i = 0; i < DIREZIONI; i++)
    {
        if(wd1 == dir[i].comandi)
        {
            if(descrizione_stanza[luogo_attuale].uscita_verso[dir[i].code] != NESSUNO)
            {
                luogo_attuale = descrizione_stanza[luogo_attuale].uscita_verso[dir[i].code];
                cout << "Ora sono arrivato in " << descrizione_stanza[luogo_attuale].descrizione << "." << endl;
                // modificate il codice. Per esempio un caso speciale è quello in cui la porta del magazzino è chiusa e deve essere aperta da parte del giocatore (se ha la chiave con se).
                if(luogo_attuale == MAGAZZINO || luogo_attuale == CORRIDOIO)
                {
                    descrizione_oggetti[PORTA].posizione = luogo_attuale;
                }
                // ....
                return true;
            }
            else
            {
                cout << "NESSUNO uscita in quella direzione." << endl;
                return true;
            }
        }
    }

    // modificate il codice se necessario
    int COMPLEMENTO_OGGETTO = NESSUNO;
    // ....
    int AZIONE_VERBO = NESSUNO;

    for(i = 0; i < VERBI; i++)
    {
        if(wd1 == descrizione_verbi[i].comandi)
        {
            AZIONE_VERBO = descrizione_verbi[i].code;
            break;
        }
    }

    // modificate il codice se necessario
    if(wd2 != "")
    {
        for(i = 0; i < OGGETTI; i++)
        {
            if(wd2 == descrizione_oggetti[i].comandi)
            {
                COMPLEMENTO_OGGETTO = descrizione_oggetti[i].code;
                break;
            }
        }
    }

    if(AZIONE_VERBO == NESSUNO)
    {
        cout << "Nessun comando valido inserito." << endl;
        return true;
    }

    if(AZIONE_VERBO == GUARDA)
    {
        guarda_intorno(luogo_attuale, descrizione_stanza, dir, descrizione_oggetti);
        return true;
    }

    if(AZIONE_VERBO == INVENTARIO)
    {
		for(i = 0; i < OGGETTI; i++)
		{
			if(descrizione_oggetti[i].posizione == 1000)
			{
				cout << "Hai con te " << descrizione_oggetti[i].descrizione << "." << endl;
			}
		}	
	}
	
	
    // modificate il codice se necessario
    // Azioni per gestire il comando APRI
    if(AZIONE_VERBO == APRI)
    {
        if(COMPLEMENTO_OGGETTO == PORTA)
        {
            if(luogo_attuale == CORRIDOIO || luogo_attuale == MAGAZZINO)
            {
                if(stato_della_porta == false)
                {
                    stato_della_porta = true;
                    descrizione_stanza[CORRIDOIO].uscita_verso[EST] = MAGAZZINO;
                    descrizione_stanza[MAGAZZINO].uscita_verso[OVEST] = CORRIDOIO;
                    descrizione_oggetti[PORTA].descrizione.clear();
                    descrizione_oggetti[PORTA].descrizione.assign("una porta aperta verso il magazzino");
                    cout << "Ho aperto la porta." << endl;
                    return true;
                }
                else if(stato_della_porta == true)
                {
                    cout << "La porta è già aperta." << endl;
                    return true;
                }
            }
            else
            {
                cout << "Non c'è alcuna porta qui." << endl;
                return true;
            }
        }
        else
        {
            cout << "Non è possibile aprire questa porta." << endl;
            return true;
        }
    }
    // ....

    return false;
}

// ----------------------------------------------------------------------------------------



// ----------------------------------------------------------------------------------------

int main()
{
    string command;
    string comandi_1;
    string comandi_2;

    stanza STANZE[STANZE];
    set_STANZE(STANZE);

    comandi directions[DIREZIONI];
    set_directions(directions);

    comandi VERBI[VERBI];
    set_VERBI(VERBI);

    // modificate il codice se necessario
    oggetto OGGETTI[OGGETTI];
    set_OGGETTI(OGGETTI);
     // ....

    int posizione = PARCHEGGIO;

    while(comandi_1 != "FINE")
    {
        command.clear();
        cout << "Cosa devo fare ? ";
        getline(cin, command);

        comandi_1.clear();
        comandi_2.clear();

        section_command(command, comandi_1, comandi_2);

        if(comandi_1 != "FINE")
        {
            parser(posizione, comandi_1, comandi_2, directions, VERBI, STANZE, OGGETTI);
        }
    }
    return 0;
}

# data[].attributes.headline
Iniziamo con la descrizione delle stanze e dei luoghi

# data[].attributes.subject
Iniziamo con la descrizione delle stanze e dei luoghi

# data[].attributes.body
Nella lezione vi viene spiegato come fare e quali righe del programma base dovrete modificare. Le modifiche verranno apportate ad una mappa di base, messa come esempio da cui partirete.
Potete inserire descrizioni a più righe. Settimana prossima vi farò vedere come inserire anche le figure in ASCII ART sia per nelle descrizioni delle stanze che, per quello che faremo prossimamente, anche per gli oggetti che disseminerete nella vostra mappa e che costituiranno gli indizi per risolvere la vostra avventura testuale

# data[].attributes.headline
Aggiungiamo verbi ed oggetti al listato di base

# data[].attributes.subject
Aggiungiamo verbi ed oggetti al listato di base

# data[].attributes.body
Oggi vedremo come aggiungere dei nuovi verbi al listato del programma di base per consentire nuove azioni nella vostra avventura.
Vedremo anche come aggiungere gli oggetti che costituiranno gli indizi della vostra avventura. Per gli oggetti dovrete specificare, oltre alla descrizione, anche il fatto se siano trasportabili ed in quale stanza dovranno essere all'inizio del gioco. Poi durante il gioco, con i comandi PRENDI e LASCIA potete prenderli da una stanza e portarli in un'altra stanza o utilizzarli per delle particolari azioni che hanno senso con la trama della vostra avventura.
Per chi non riesce ad attendere fino a settimana prossima, vi ho messo dove dovete modificare il listato per aggiungere l azioni che hanno senso utilizzando le istruzioni dei cicli condizionali if..else if .. else che abbiamo visto nelle lezioni di marzo.

# data[].attributes.headline
Aggiungere azioni con senso al listato di base

# data[].attributes.subject
Aggiungere azioni con senso al listato di base

# data[].attributes.body
Questa è l'ultima lezione sulle tecniche di programmazione per realizzare avventure testuali in linguaggio C++. Vedrete come costruire le azioni con senso utilizzando le istruzioni if..else ed if ... else if ... else.
Nel programma in C++, mediante due variabili numeriche, saprete se il verbo e l'oggetto, contenuti nel comando dato dal giocatore, sono compresi tra quelli che hanno senso nella trama della vostra avventura.
Vedremo anche come utilizzare il ciclo for per stampare il contenuto dello zaino del giocatore. Il ciclo for viene anche utilizzato per riconoscere se il verbo e l'oggetto, digitati dal giocatore nella riga di comando del gioco, appartengono alla lista che avete definito all'inizio del programma C++.