Il primo decennio degli anni '2000, professionalmente è stato caratterizzato dalla mia esperienza di formatore con la Sun Educational Services, la divisione della Sun Microsystems Italia che si occupava dei servizi di training.

In quel periodo la mia esperienza in DGS si era conclusa; volevo creare qualcosa di innovativo nel settore della formazione, ma nel nuovo modello di business di DGS la formazione non era più strategica, per questo motivo abbandonai l'azienda e fondai il Consorzio Copernicus. L'obiettivo era quello di rivoluzionare il mondo della formazione con le mie idee -  non fu un caso se scelsi il nome Copernicus.

Nel 2003, quando ci fu la fusione tra Telecom Italia e l'Olivetti, Adriana Fasano, la mia ex responsabile dell'area formazione in Olivetti, diventò  account manager education in Sun Educational Services. Questo evento mi diede l'opportunità d'iniziare a collaborare, attraverso il Consorzio Copernicus, con la più importante azienda di formazione al mondo. Naturalmente devo tutto ad Adriana Fasano che mi permise di entrare a far parte del suo team di formatori.

In Sun, collaboravo anche con Claudia Castellano responsabile dei servizi di formazione,  che ho conosciuto a Milano, quando tenevo i corsi persso la sede di v.le Fulvio Testi, 327 e Alberto Mosca,  che ho conosciuto a Roma, lui svolgeva il ruolo di commerciale.

Grazie ad Adriana Fasano, Claudia Castellano e Alberto Mosca, ho avuto l'opportunità di formare i dipendneti delle aziende d'informatica più importanti d’Italia.

All'inizio, facevo  corsi di Unix Sun Solaris, formavo i dipendenti delle aziende IT che utilizzavano le workstation oppure i server Sun; già conoscevo Unix System V (Unix System Five) e le mie conoscenze di C risultarono molto utili perché con Solaris si utilizzava la C shell, che permetteva di creare script Unix con il linguaggio C, mentre con Unix System V si usava la Korn shell, che invece permetteva di creare gli script Unix con un linguaggio proprietario.

Poi, a causa della profonda crisi del mercato dello sviluppo software che si verificò tra la fine degli anni '90 e l'inizio del 2000, Java diventò uno dei linguaggi di programmazione ad oggetti più utilizzati dai programmatori. Il passaggio dalla programmazione procedurale a quella ad oggetti creò una grossa richiesta di corsi, prima di alfabettizzazione e via via sempre di maggiore specializzazione. Fu così che iniziò la mia esperinza in Sun di formatore Java. 

QUANDO E' NATO L'OBJECT ORIENTED
Alla fine degli anni '90, il Modello a cascata (Waterfall) venne messo in discussione, perché non era adatto alla produzione di software di qualità sempre più complesso e che richiedeva la riusabilità del codice e  continui aggiornamenti.

Il Waterfall prevedeva che il ciclo di vita del software si basasse sulle seguenti fasi, svolte in sequenza: pianificazione (plan), analisi (analysis), progettazione (design), implementazione (code), collaudo (test), installazione (install), utilizzo (use),  come mostra l'immagine seguente:

Questo tipo di modello di sviluppo software andava bene solo per applicazioni dove i requisiti funzionali e di business, definiti durante la fase di analisi, non cambiavano nel tempo, altrimenti si rischiava di non soddisfare mai i clienti. 

Naturalmente cambiarono anche i linguaggi di programmazione utilizzati, tra questi quelli che ebbero il maggiore successo furono il linguaggio C++ (C plus plus) creato da Bjarne Stroustrup e il linguaggio Java creato da James Gosling della Sun Microsytems e il linguaggio C# (C sharp) creato da Anders Hejlsberg della Microsoft. 

Tutti è tre i linguaggi permettevano di sviluppare applicazioni orientate agli  oggetti, ma Java e C# erano stati pensati per il Web, per questo motivo erano trasportabili (generavano codice intermedio, diverso dal linguaggio macchina,  eseguibile con Virtual Machine), a differenza del C++ non permettevano l'ereditarietà multipla e disponevano di linguaggi di tipo SERVER SIDE come JSP (Java Server Page) per Java e ASP (Active Server Page) per C#, che permettevano di creare pagine Html dinamiche.

Per approfondire la conoscenza del linguaggio C clicca qui.
Per maggiori informazioni sugli oggetti e sul linguaggio C++ clicca qui.
Per imparare tutto quello che ti serve su Java Object Oriented clicca qui.

Allora conoscevo benissimo il C++ e in breve tempo, attraverso il supporto della Sun Educational Services, imparai tutto quello che bisognava sapere su Java.

Con il diffondersi di Java, iniziarono ad aumentare le richieste di corsi e di certificazioni Java da parte del mercato IT. Fu così che iniziò la mia esperienza di formatore esperto di linguaggio Java. Ricordo ancora i codici dei corsi che erogavo in tutta Italia:

1) SL-110 (Introduzione al linguaggio Java);
2) SL-275 (Java Programming Language);
3) SL-314 (Java Web Component);
4) SL-351 (Java Business Component);
5) FJ-310 (Developing Application for Java EE Platform);
6) SL-425 (Architecting and Designing J2EE Applications);
7) DWS-385 (Java Web Service);
8) DTJ-3109 (Developing Secure Web Applications).

A Roma, la sede della Sun si trovava in via Gian Domenico Romagnosi, 4,  nei pressi di p.zza del Popolo, ma i corsi si tenevano presso la sede di Atlantica, in P.zza Barberini, adiacente a Via Veneto e a pochi passi dalla fontana di Trevi e da P.zza di Spagna - è lì che ho imparato ad amare Roma e la Formazione, quella con la EFFE maiuscola.

Conservo ancora in libreria i manuali originali da cui studiavo:

Purtroppo, non trovo il manuale SL-275 Java Programming Language, devo averlo prestato a qualche collega o a qualche mio studente; in questo manuale c'era tutto quello che bisognava sapere per lavorare con Java SE (Standard Edition). Con questa versione di Java si potevano creare applicazione a due livelli di tipo desktop che permettevano di archiviare informazioni in un database relazionale.

Per creare le interfacce grafiche, inizialmente usavo la libreria Java AWT, successivamente passai alla libreria Java SWING, perché era molto più dinamica della precedente. Per gestire i database usavo la libreria Java JDBC, ovviamente combinata con il linguaggio SQL. 

Sono molto legato all'SL-275, perché tutte le conoscenze di Object Oriented che ho appreso da questo manuale sono state utili superare l'esame di certificazione Java Programmer.

LA PIATTAFROMA JAVA EE (ENTERPRISE EDITION)
La Sun Microsystems a dicembre del 1999 estende la versione Java SE con una versione molto più potente che, inizialmente venne chiamata Java 2 EE, poi qualeche anno dopo Java EE.

Java EE è un framework potente e completo per lo sviluppo e la distribuzione di applicazioni aziendali su larga scala, affidabili e sicure. Fornisce un'architettura solida e multilivello che separa i livelli di logica aziendale, presentazione e accesso ai dati, promuovendo modularità e manutenibilità.

La piattaforma comprende un'ampia gamma di API (Application Programming Interface) che facilitano vari aspetti dello sviluppo di applicazioni, come servizi Web, architettura basata su componenti e servizi a livello aziendale. Queste API aiutano gli sviluppatori a gestire attività come la connettività del database, la messaggistica, la gestione delle transazioni e la sicurezza, consentendo la creazione di applicazioni scalabili e ad alte prestazioni.

I componenti principali di Java EE sono:

• servlet
• JavaServer Pagine (JSP)
• JavaBean aziendali (EJB)
• API di persistenza Java (JPA)
• Servizio messaggi Java (JMS)
• API di transazione Java (JTA)
• JavaMail
• API Java per servizi Web RESTful (JAX-RS)
• API Java per servizi Web XML (JAX-WS)
• Interfaccia di denominazione e directory Java (JNDI).

Tutto quello che mi serviva per lavorare con questi nuovi componenti l'ho appreso dai manuali seguenti: 

1) SL-351 (Java Business Component);
2) FJ-310 (Developing Application for Java EE Platform);
3) SL-425 (Architecting and Designing J2EE Applications);
4) DWS-385 (Java Web Service);
5) DTJ-3109 (Developing Secure Web Applications).

Per lavorare con gli EJB usavo i seguenti Application Server:

1) Glassfish (della Oracle)
2) WebLogic (della Oracle)
3) WebSphere (dell'IBM)
4) JBoss (allora era un prodotto Open Source, oggi della Red Hat).

Gli EJB erano oggetti che potevano essere istanziati solo in un EJB Container di un Application Server, a differenza dei POJO (Plan Old Java Object - Oggetti Java Standard), che possono essere istanziati sia in una Java Virtual Machine, sia in un Web Container di un Web Server come Apache o di un Application Server qualsiasi, perchè questo servizio dispone sia di un Web Container, sia di un EJB Containar, come mostra l'immagine seguente:

PERCHE'  OGGI I POJO SONO MOLTO PIU' UTILIZZATI DEGLI EJB? 
Gli EJB permettono di fare in modo più professionale esattamente tutto quello che facciamo oggi con i POJO (Plan Old Java Object - Oggetti Java standard), utilizzando Hibernate e Spring. Il motivo per cui oggi quasi tutti i programmatori, per implementare la Dipendency Injection e l'ORM, usano oggetti POJO,  si spiega con il fatto che i framework  Hibernate e Spring sono più semplici da utilizzare e quindi richiedono un minore costo d'implementazione rispetto alle soluzioni di tipo EJB che invece risultano più complesse da utilizzare, ma probabilmente esiste anche un'altra spiegazione dovuta a un fattore storico che ho vissuto personalmente ...

Purtroppo, la versione EJB 2.0 della piattaforma Java EE, aveva diversi problemi, che creavano grosse difficoltà ai programmatori, quindi erano considerati non affidabili. Questo ha dato spazio a soluzioni alternative  come Hibernate prima e Spring dopo. Quando la Sun, con la versione EJB 3.5 ha risolto tutti i problemi, probabilmente non sono più riusciti a riconquistare la fiducia dei programmatori che ormai avevano iniziato ad usare le soluzioni alternative.

Questo grave errore della Sun ha permesso a Hibernate e Spring di diventare i leader di questa fascia di mercato.

LA RIVOLUZIONE DELLO SVILUPPO AGILE
Quando si è verificata la crisi dello sviluppo software, oltre al paradigma di sviluppo, cambiarono anche i modelli di sviluppo software che diventarono prima iterativi e successivamente iterativi incrementali. Allora collaboravo anche con l'IBM e altre società del gruppo come la Sistemi Informativi e la Selfin, per i clienti del gruppo ho fatto molti corsi di Rational Unified Process (RUP), uno dei primi modelli di sviluppo software iterativi.

Il RUP a differenza del Waterfall divideva il ciclo di vita del software in quattro transazioni: avvio (inception), elaborazione (elaboration), costruzione (construction) e transizione (transaction), ciascuna indicava il livello di maturità di un progetto di sviluppo software.  In base alla transazione, le fasi del modello a cascata venivano gestite in modo diverso, in base agli obiettivi da raggiungere. Ad esempio, per le transazioni iniziali (avvio/elaborazione), dove la conoscenza del progetto software era minore, si dedicava più tempo alle fasi di analisi e di progettazione, mentre per le transizioni finali (costruzione/transizione), dove l'applicazione cominciava a prendere forma, si dedicava più tempo alle fasi d'implementazione, testing e deployment.

L'immagine seguente mostra il RUP (Rational Unified Process):  

Comunque, l'evento più importante che cambiò radicalmente il modo di sviluppare le applicazioni software e da cui dipendono gli attuali modelli di sviluppo software, fu l'incontro del 2001 a Snowbird (Utah), tra i più grandi produttori di software del mondo. Alla fine di questo storico incontro, in diciassette, sottoscrissero il Manifesto Agile che conteneva i 4 valori e 12 principi guida da seguire per progettare e sviluppare applicazioni complesse in modo agile.

I quattro valori del Manifesto agile erano:

1. Individui e interazioni su processi e strumenti;
2. Software funzionante sulla documentazione completa;
3. Collaborazione con i clienti sulla negoziazione del contratto;
4. Rispondere al cambiamento anziché seguire un piano.

Per ricevere maggiori informazioni sul manifesto agile clicca qui.

Oggi il modello di sviluppo software che maggiormente si rifà ai valori e ai principi del Manifesto agile è il modello iterativo incrementale DevOps, riportato nell'immagine seguente:

La metodologia Agile più usata nelle aziende che fanno sviluppo software è SCRUM, un framework, inteso come insieme di regole, ruoli, eventi e artefatti, che permette di accelerare le attività di progettazione applicativa, migliorando contestualmente la qualità del software.

L'immagine seguente mostra gli elementi che compongono il framework SCRUM:

Conosco bene sia il modello di sviluppo software DevOps, sia la metodologia SCRUM,  perché sono corsi molto richiesti dalle aziende IT che devono aggiornare oppure riqualificare i propri dipendenti. Faccio anche molta consulenza per supportare le aziende IT che vogliono implementare il modello DevOps e applicare un project management di tipo Agile, svolgendo spesso il ruolo di SCRUM Master.

IL TRAMONTO DELLA SUN MICROSYSTEMS: LA FINE DI UNA GRANDE VISIONE AZIENDALE
Prima degli anni '80 i sistemi informatici erano di tipo mainframe, sistemi centralizzati, molto affidabili, con grosse capacità di elaborazione dati, utilizzati solo dalle grandi aziende; i principali produttori mondiali di mainframe erano l'IBM, l'HP e l'Olivetti.

Solo qualche anno più tardi arriveranno i minicomputer e i personal computer, accessibili a tutti e che attraverso le reti comunicavano tra loro, rendendo i sistemi non più centralizzati, ma distribuiti; fu così che inizio l'era della trasformazione digitale. 

Tra le aziende che hanno favorito il passaggio dai sistemi centralizzati verso i sistemi distribuiti,  la Sun Microsystems ha avuto un ruolo molto importante, dovuto soprattutto all'innovativa visione commerciale di questa grande azienda Californiana.

Lo slogan della SUN era "La rete è il computer", anticipando quello che poi diventerà Internet e il cloud. 

La Sun Microsystems nasce nel 1982 da un piccolo gruppo di compagni di classe dell'Università di Stanford in California: Vinod Khosla, Scott MacNealy, Bill Joy, Andy Bechtolsheim, Vaughan Pratt; la vision di quest'azienda rivoluzionerà completamente il mondo dell'informatica. 

Scott McNealy, uno dei co-fondatori della Sun, affermava: "Il mondo sta cambiando, sarà tutto in rete". È assurdo che conserviamo tutti i nostri dati su PC e laptop, dove possono essere persi troppo facilmente. Se affidi i tuoi soldi alla banca, perché non dovresti affidare i tuoi dati alla rete? Affidando i dati alla rete li potresti scaricare quando ti servono, così come prelevi soldi quando ne hai bisogno.

Inizialmente era un'azienda di nicchia che produceva workstation con sistema operativo Unix Sun Solaris, alla fine degli anni '80 è entrata nel mercato dei server multiutente e verso la meta degli anni '90 ha iniziato ad operare anche nel mercato emergente dei server web. 

La Sun, attraverso le sue scelte di mercato s'era riposizionata dal mercato delle workstation, considerato a crescita lenta, verso il mercato Internet a crescita elevata. I suoi server gestivano siti Web di alto profilo come AOL, Amazon.com ed e-bay.

Nel 1997, ogni giorno dagli stabilimenti Sun, venivano spediti ai clienti circa 100 server e 2.500 workstation. Il prezzo di un Server SUN oscillava dai 14.000 a un milione di dollari ($), mentre una workstation costava in media 15.000 dollari ($).

Alla fine del 1998, Sun era cresciuta fino a raggiungere quasi 26.300 dipendenti con circa 10 miliardi di dollari di ricavi. I ricavi erano suddivisi per il 52% negli Stati Uniti e per il 48% a livello mondiale. 

Sun rispetto ai suoi concorrenti offriva soluzioni hardware scalabili e affidabili per il funzionamento di Unix; era il principale concorrente di Microsoft. Insieme ad Apple, era l'unico fornitore a non installare Windows NT sui propri server o Windows sulle workstation.

I server e le workstation Sun non usavano processori Intel, ma avevano una propria architettura basata su processori SPARC RISC. Anche IBM, Compaq e Hewlett-Packard avevano sistemi operativi e architetture proprietarie, ma vendevano anche macchine basate sullo standard Wintel (Windows/Intel). 

Compaq, Dell e la maggior parte dei piccoli venditori operavano quasi completamente nel campo Wintel. 

I prodotti della Sun erano progettati per comunicare attraverso le reti e il protocollo TCP/IP, erano scalabili e affidabili, per questo motivo la Sun riuscì a soddisfare anche le esigenze delle grandi aziende, che si convertirono ai server basati su Unix su cui potevano girare applicazioni come SAP, PeopleSoft, Baan e Oracle.

Sun, oltre a progettare il proprio microprocessore SPARC, il proprio sistema operativo Unix Solaris, creò anche il linguaggio di programmazione Java, per sviluppare applicazioni a oggetti basate sul web. Tutte queste tecnologie pur essendo proprietarie erano considerate aperte, perché Sun pubblicava gli standard e i protocolli concedendoli in licenza per l'utilizzo ad altri.

Sun faceva molto affidamento su terze parti per i servizi di integrazione e il supporto, tra i partner software strategici di Sun cerano: Baan, BEA, Computer Associates, Informix, J.D. Edwards,Lotus, Netscape, Oracle, PeopleSoft, SAP, SAS Institute, Sybase, Tivoli e IBM.

Aveva anche forti rapporti con le principali società di consulenza, tra cui KPMG, Price Waterhouse, Andersen Consulting, EDS, MCI e Cambridge Technology Partner, Perot Systems, Ernst and Young, CSC, Cap Gemini e Deloitte ICS.

La più grande debolezza di Sun fu la sua focalizzazione sul mercato Unix; mentre altri fornitori iniziavano ad investire su Windows NT e Linux e sulla tecnologia Wintel, il CIO (chief information officer) della Sun, ovvero il  responsabile della gestione strategica dei sistemi informativi dichiarava: 

“La tecnologia Sun on Sun è un punto religioso... Gestiamo la nostra azienda da soli.

Sebbene Java proliferasse con una penetrazione dell'85% sui client, la concorrenza dei prodotti Microsoft e delle tecnologie Intel compatibili aumentò a tal punto che la Sun entrò in crisi.

Dopo una serie di voci sulla possibile acquisizione da parte di IBM e di Cisco, a gennaio del 2010, arrivò inaspettata la mossa di Oracle, che acquistò Sun Microsystems per un valore di 7,4 miliardi di dollari ($).

Con questa acquisizione la Oracle ottenne grossi vantaggi di mercato perché poteva disporre di un ottimo sistema operativo Unix, di un ottimo linguaggio di programmazione come Java e dalla disponibilità di tutto l'hardware prodotto dalla Sun.

Con l'acquisto di Sun, Oracle portò in casa anche MySQL, acquistato da Sun nel gennaio 2008.

Il resto lo conoscete perché è storia recente ...

LA BREVE ESPERIENZA DI FORMATORE IN ORACLE
In Sun, oltre a ricevere una grande crescita professionale come formatore, avevo avuto anche l'opportunità di diventare un programmatore molto esperto; tutto quello che insegnavo, lo sapevo anche applicare praticamente. Quindi oltre alla formazione ero capace di fare anche progettazione ed implementazione di applicazioni aziendali distribuite, multilivello.

La gratificazione maggiore che ho ricevuto durante la mia esperienza in Sun è stato l'invito in Scozia, ricevuto direttamente dalla Sun Microsystems al meeting degli Educational Center Sun di tutto il mondo. E' stata un'esperienza bellissima che mi ha ripagato di tutto lo studio e i sacrifici che avevo fatto per arrivare a quel livello.

Conservo ancora il badge che mi consegnarono per accedere all'evento:

Ho continuato a collaborare con la Sun fino al 2010, quando in modo inaspettato, arrivò la notizia improvvisa che la Oracle aveva acquistato la Sun Microsystems.

In questa lezione finalmente implementeremo la prima esperienza in HAMMER-XP, l'obiettivo sarà quello di eliminare tutti i numeri pari tra 1 e 100.

L'idea è quella di visualizzare nell'area di gioco una tabella con 100 sprite rettangolari di colore blue che contengono i numeri da 1 a 100. Se Hammer  tocca uno sprite che contiene un numero pari lo score s'incrementa di uno, se per sbaglio si tocca un sprite che contiene un numero dispari allora sarà il wrong a incrementarsi di uno.

Il gioco s'interromperà con il messaggio GAME OVER se il numero di wrong (errori) supererà il numero di score (successi) oppure se il tempo di gioco supererà  i 120 secondi (2 minuti).

Il gioco terminerà con il messaggio GOOL!!!, se verranno eliminati tutti i numeri pari nel tempo utile.

LA CLASSE BLOCCO
La classe seguente servirà per creare gli oggetti sprite che conterranno i numeri da 1 a 100. Una classe è un modello per creare oggetti da utilizzare nei programmi.
Una classe può ereditare il codice di altre classi per specializzarsi a fare qualcosa. La classe Blocco ereditando la classe pygame.sprite.Sprite si specializza nella gestione di sprite perché eredità tutti gli attributi e i metodi che serviranno all'oggetto creato per comportarsi come un sprite. 

# Questa classe permette di creare gli oggetti sprite rettangolari con i numeri
class Blocco(pygame.sprite.Sprite):
    # Costruttore dello sprite
    def __init__(self, color, width, height, text, hit):
        super().__init__()
        self.hit=hit
        self.numero=int(text)
        self.image = pygame.Surface([width, height])
        self.rect = self.image.get_rect()
        self.font= pygame.font.SysFont('arialunicode', 30)
        self.textSurf = self.font.render(text, 1, (255,255,255))
        self.image = pygame.Surface((width, height))
        W = self.textSurf.get_width()
        H = self.textSurf.get_height()
        self.image.fill(color)
        # Centra il testo nel blocco sprite
        self.image.blit(self.textSurf, [width/2 - W/2, height/2 - H/2])

Il costruttore __init__ è il metodo di una classe usato per inizializzare l'oggetto creato, gli argomenti del costruttore:

def __init__(self, color, width, height, text, hit),

sono importanti per capire quali informazioni si dovranno passare alla classe per creare un oggetto di quel tipo. In questo caso per creare uno sprite di tipo Blocco sono richieste le seguenti informazioni:

color=colore dello sprite in formato (red, green, blue)

width=larghezza in pixel dello sprite

height=altezza  in pixel dello sprite

text=testo che corrisponderà al numero visualizzato nello sprite

hit=questo parametro potrà contenere False oppure True (False se il numero assegnato allo sprite sarà dispari, True se il numero assegnato allo sprite sarà pari).

Il comando   self.rect = self.image.get_rect() è importante perché permette di creare l'oggetto serf.rect  con gli attributi x e y, corrispondenti alle coordinate della posizione di uno sprite sullo schermo.

Assegnando un valore a self.rect.x e self.rect.y sarà possibile posizionare qualunque sprite creato all'interno dello schermo.

Vediamo un esempio:

BLUE=(0,0,255) # RED=0 GREEN=0 BLUE=255, impostiamo il colore BLUE con la codifica RGB
primoBloccoSprite=Blocco(BLUE, 35, 35,"1",False) 

il codice Python precedente crea un oggetto sprite di nome primoBloccoSprite di colore blue e di 35X35 pixel. Al centro dello sprite verrà visualizzato il numero 1, quindi il parametro hit dovrà essere impostato a False, perché il numero è dispari.

secondoBloccoSprite=Blocco(BLUE, 35, 35,"2",True) 

il codice Python precedente crea un oggetto sprite di nome secondoBloccoSprite di colore blue e di 35X35 pixel. Al centro dello sprite verrà visualizzato il numero 2, quindi il parametro hit dovrà essere impostato a True, perché il numero è pari.

I comandi seguenti:

primoBloccoSprite.rect.x=100
primoBloccoSprite.rect.y=50
secondoBloccoSprite.rect.x=140
secondoBloccoSprite.rect.y=50

permettono di posizionare i due sprite nell'area di gioco, il primo alla posizione di coordinate (100, 50), il secondo alla posizione di coordinate (140, 50).

COME CREARE E DISPORRE NELL'AREA DI GIOCO GLI SPRITE CON I NUMERI DA 1 A 100
Il codice Python seguente mostra come creare e disporre sull'area di gioco gli sprite con i numeri da 1 a 100:

BLUE=(0, 0, 255) # impostiamo il colore blue
pos_x=55
pos_y=2
for x in range(1,101): # range genera un vettore di numeri interi da 1 a 100, per ogni numero del vettore il for esegue i comandi associati 
      if x%2==0:
            hit=True   # Se il numero è pari imposta hit=True
      else:
            hit=False  # Se il numero è dispari imposta hit=False
      blocco = Blocco(BLUE, 35, 35,str(x),hit) # Crea un blocco di tipo sprite che visualizzera il valore del numero x corrente 
      # Posiziona gli sprite creati nell'area di gioco
      blocco.rect.x=pos_x
      pos_x+=44
      blocco.rect.y=pos_y
      # Aggiunge gli sprite creati ai gruppi di sprite
      block_list.add(blocco)
      sprite_list.add(blocco)
      # Cambia riga dell'area di gioco quando gli sprite hanno occupato tutto lo spazio disponibile sulla riga corrente
      if x==25 or x==50 or x==75:
         pos_x=50
         pos_y+=108

La funzione struttura_tempo riceve il tempo trascorso in secondi e lo converte in una stringa nel formato hh:mm:ss.

Per calcolare il tempo trascorso basta leggere l'ora di sistema quando parte il gioco e confrontarla ogni volta con l'ora di sistema corrente.

Per fare questa operazioni, quando parte il gioco, possiamo usare il comando:

t1=time.time()

La funzione time() dell'oggetto time, legge l'ora di sistema alla partenza del gioco e la converte in secondi trascorsi dal 01/01/1970; salvando questo valore nella variabile  t1, conosciamo il numero di secondi trascorsi dal 01/01/1970 all'avvio del gioco.

def struttura_tempo(t_value):
    ore=math.floor(t_value/3600)
    minuti=t_value-(ore*3600)
    minuti=math.floor(minuti/60)
    secondi=t_value-((ore*3600)+(minuti*60))
    secondiStr="0"+str(secondi)
    minutiStr="0"+str(minuti)
    oreStr="0"+str(ore)
    s_tempo=oreStr[-2:]+":"+minutiStr[-2:]+":"+secondiStr[-2:]
    return s_tempo

LA FUNZIONE CHE CREA IL PRIMO LIVELLO DELLA PRIMA ESPERIENZA DI MATEMATICA

La funzione exp_01_01 viene utilizzata per creare il primo livello della prima esperienza di matematica.

La funzione riceve i seguenti argomenti:

block_list=riferimento del gruppo in cui aggiungere i blocchi dell'esperienza, serve per rilevare le collisioni con Hammer

sprite_list=riferimento del gruppo in cui aggiungere i blocchi dell'esperienza, serve per visualizzare tutti gli sprite creati nell'area di gioco 

informazioni_del_gioco=gli attributi di questo oggetto servono per impostare il progressivo dell'esperienza, il livello, lo score obiettivo, la durata del gioco

La classe con cui viene creato questo oggetto è la seguente:

class Informazioni_del_gioco():
    # Costruttore dello sprite, quando viene eseguito dovete passare il colore dello sprite, la larghezza e l'altezza in pixel
    def __init__(self, experience_value,level_value,score_value_exit,t_value_exit):
        super().__init__()
        self.experience_value=experience_value
        self.level_value=level_value
        self.score_value_exit=score_value_exit
        self.t_value_exit=t_value_exit

Infine, c'è l'argomento:

scheda=vettore che conterrà le stringhe che corrispondono alle righe che descrivono l'esperienza che si sta giocando

Di seguito il codice completo della funzione exp_01_01:

def exp_01_01(block_list,sprite_list,informazioni_del_gioco,scheda):
    BLUE=(0, 0, 255) # impostiamo il colore blue
    pos_x=55
    pos_y=2
    for x in range(1,101): 
        if x%2==0:
            hit=True
        else:
            hit=False
        blocco = Blocco(BLUE, 35, 35,str(x),hit) 
        # Posiziona gli sprite creati nell'area di gioco
        blocco.rect.x=pos_x
        pos_x+=44
        blocco.rect.y=pos_y
        # Aggiunge gli sprite creati ai gruppi di sprite
        block_list.add(blocco)
        sprite_list.add(blocco)
        if x==25 or x==50 or x==75:
           pos_x=50
           pos_y+=108
    informazioni_del_gioco.experience_value=1
    informazioni_del_gioco.level_value=1   
    informazioni_del_gioco.score_value_exit=50    # Il valore di score obiettivo è quello di 50 successi
    informazioni_del_gioco.t_value_exit=120          # L'esperienza dura 2 minuti
    # Aggiungiamo al vettore scheda le stringhe che corrispondono alle righe che descrivono l'esperienza che si sta giocando 
    scheda.append("MATEMATICA I")
    scheda.append("Elimina dall'area di gioco i numeri pari.")
    scheda.append("Il gioco termina se gli errori superano le risposte esatte.")
    scheda.append("L'esperienza avrà una durata di 2 minuti.")
    scheda.append("Aggancia Hammer con il puntatore del mouse e inizia a")
    scheda.append("giocare.")

LA GESTIONE DEI SUCCESSI (SCORE) O DEGLI ERRORI (WRONG) DOPO LE COLLISIONI

Il metodo spritecollide permette di rilevare la collisione tra uno sprite e gli sprite di un gruppo.

Per rilevare le collisioni tra Hammer e i blocchi con i numeri, dovete passare come argomenti alla funzione spritecollide, sia il riferimento dell'oggetto hammer, sia il riferimento del gruppo che contiene i riferimenti dei blocchi con i numeri presenti nell'area di gioco: block_list.

Il terzo argomento della funzione, se impostato a True, indica che l'oggetto che collide con Hammer, dovrà essere eliminato dal gruppo e non dovrà più essere visibile nell'area di gioco.

Gli oggetti che collidono con Hammer vengono aggiunti al gruppo  blocks_hit_list; quindi, con un ciclo for possiamo ottenere il riferimento di tutti gli sprite che hanno avuto una collisione con Hummer. Leggendo il valore dell'attributo hit dei blocchi presenti nel gruppo  blocks_hit_list sarà possibile capire se il blocco era associato a un numero pari (hit=True) o a un numero dispari (hit=false).

In base allo stato dell'attributo hit (True/False) vengono aggiornati i valori dei contatori wrong e score, come mostra il codice Python seguente:

# Aggiunge al gruppo blocks_hit_list i riferimenti dei blocchi che collidono con l'oggetto hummer
blocks_hit_list = pygame.sprite.spritecollide(hammer, block_list, True)
# Legge il riferimento dei blocchi che hanno avuto una collisione con Hammer e verifica se incrementare il contatore score o wrong
for blocco in blocks_hit_list:
    # Genera un suono, come un click, per indicare che c'è stata una collisione
     winsound.Beep(3000,1)
    # Incrementa di 1 score_value se hit è True (numero pari), altrimenti incrementa di 1 wrong_value se hit è False (numero dispari)
    if blocco.hit:
       score_value+=1
    else:
       wrong_value+=1

La funzione Beep della libreria winsound emette un breve suono  di 3000 HZ, serve per indicare che Hammer ha toccato un blocco con un numero.

LA FINE DEL GIOCO

Il gioco termina con GAME OVER se il numero di WRONG (Errori) sumera il numero di SCORE (Successi) oppure se il tempo di gioco supera la durata prevista. In questo caso verrà emesso un suono che indica un insuccesso e verrà visualizzata l'etichetta GAME OVER:

I

Il gioco termina con GOAL!!! se viene raggiunto l'obiettivo previsto dall'esperienza che prevede che Hammer elimini dall'area di gioco tutti i blocchi con numeri pari. In questo caso verrà emesso un suono che indica successo e verrà visualizzata l'etichetta GOAL!!!:

Le etichette GAME OVER e GOAL!!! sono due oggetti sprite creati nel modo seguente:

bloccoGameOver=Etichetta((255,0,0),200,40,500,164,'GAME OVER')
bloccoGoal=Etichetta((0,200,86),200,40,500,164,'GOOL!!!')

Entrambi gli oggetti sono dello stesso tipo, perché sono stati creati con la classe Etichette:

class Etichetta(pygame.sprite.Sprite):
    # Quando si crea l'oggeto sprite passare il colore, la larghezza, l'altezza
    # la posizione dello sprite nell'ambiente di gioco
    def __init__(self, color, width, height, x,y,text):
        super().__init__()
        self.image = pygame.Surface([width, height])
        self.rect = self.image.get_rect()
        self.rect.x=x
        self.rect.y=y
        self.font= pygame.font.SysFont('arialunicode', 30)
        self.textSurf = self.font.render(text, 1, (255,255,255))
        self.image = pygame.Surface((width, height))
        W = self.textSurf.get_width()
        H = self.textSurf.get_height()
        self.image.fill(color)
        self.image.blit(self.textSurf, [width/2 - W/2, height/2 - H/2])

Il codice Python seguente mostra come viene gestita la fine del gioco:

# Il gioco termina se gli errori sono maggiori dei successi, se si va oltre il tempo massimo disponibile, se si raggiunge l'obiettivo previsto
if wrong_value>score_value or t_value==informazioni_del_gioco.t_value_exit or score_value==informazioni_del_gioco.score_value_exit:
    # Impostando a True questa variabile vengono inibiti tutti i movimenti di Hummer e la gestione degli eventi, quindi il gioco termina
   gameOver=True
   # Obiettivo raggiunto
   if score_value==informazioni_del_gioco.score_value_exit:
      sprite_list.add(bloccoGoal)
      beep_goal()
   else: # Obiettivo non raggiunto
      beep_game_over()
      sprite_list.add(bloccoGameOver)

Per gestire le tonalità sonore che indicano il successo oppure l'insuccesso sono state create le funzioni:

beep_goal() # Successo

beep_game_over() # Insuccesso

In questa nuova lezione imparerete a muovere Hammer nell'area di gioco, utilizzando il puntatore del mouse e a gestire le collisioni con altri sprite.

Prima di tutto dobbiamo definire le coordinate dell'area di gioco in cui sia Hammer, sia gli altri sprite potranno muoversi.

L'immagine seguente mostra le dimensioni dell'interfaccia espresse in pixel.

L'interfaccia del gioco ha una larghezza di 1200 pixel e un'altezza di 690 pixel, mentre l'area di gioco ha una larghezza di 1200 pixel e un'altezza di 320 pixel.

COME MUOVERE HAMMER USANDO IL PUNTATORE DEL MOUSE

Per associare i movimenti di Hammer al puntatore del mouse, servono le coordinate x, y del puntatore.   

Il comando seguente cattura le coordinate x, y delle posizioni del mouse nella finestra di gioco:

pos = pygame.mouse.get_pos()

La variabile pos è una tupla, quindi:

pos[0] indica la coordinata x del mouse, nella posizione corrente, mentre 

pos[1] indica la coordinata y del mouse, nella posizione corrente.

Per associare il movimento dal mouse ad Hammer, dovete usare il codice seguente:

hammer.rect.x=pos[0]-5  
hammer.rect.y=pos[1]-50

Alla posizione x del mouse sottraiamo 5 pixel e a quella y sottraiamo 50 pixel, per posizionare il puntatore del mouse sul manico del martelletto, come mostra la figura seguente:

COME LIMITARE I MOVIMENTI DI HAMMER ALL'AREA DI GIOCO

Per evitare che Hammer si sposti oltre l'area di gioco, dovete verificare  che le coordinate pos[0] e pos[1] non assumano valori esterni al perimetro dell'area di gioco. Quando si verifica questa condizione i valori di  pos[0] e pos[1] vanno impostati in modo che Hammer non superi i limiti definiti dal perimetro di gioco.  

Il codice Python seguente vi permetterà di limitare i movimenti di Hammer, solo all'interno dell'area di gioco:

# Legge la coordinate della posizione del puntatore del mouse
pos = pygame.mouse.get_pos()

# Se le coordinte pos[0] e pos[1] si trovano nel perimetro dell'area di gioco Hammer si sposta insieme al puntatore del mouse
if pos[0]>0 and pos[0]<1156 and pos[1]>50 and pos[1]<320:
   hammer.rect.x=pos[0]-5  
   hammer.rect.y=pos[1]-50
# Se le coordinte pos[0] e pos[1] si trovano fuori dal perimetro dell'area di gioco Hammer si ferma
else:    
    if pos[1]<=50:     
       hammer.rect.y=0
    elif pos[1]>=320:     
       hammer.rect.y=268
    if pos[0]<=0:
          hammer.rect.x=0 
    elif pos[0]>=1156:
          hammer.rect.x=1150

Di seguito trovate il codice Python completo per muovere Hammer all'interno dell'area di gioco:

import pygame

SIZE = WIDTH, HEIGHT = 1200, 690 # Impostiamo la larghezza e l'altezza dello schermo
# Carichiamo l'immagine di sfondo del gioco
SFONDO = pygame.image.load("sfondo_hammer_xp.png")

# La classe seguente permette di creare lo sprite e le sue caratteristiche
class Hammer(pygame.sprite.Sprite):
    def __init__(self):
        super(Hammer, self).__init__()
        self.images = []
        self.images.append(pygame.image.load('hammer.png')) # Associamo allo sprite l'immagine di hammer
        self.index = 0
        self.x=0
        self.y=0
        self.image = self.images[self.index]
        self.rect = self.image.get_rect()
def main():
    # Inizializziamo l'ambiente pygame
    pygame.init()
    # Impostiamo le dimensioni dello schermo
    screen = pygame.display.set_mode(SIZE)
    # Creiamo lo sprite hammer usando la classe sprite Hammer
    hammer = Hammer()
    # Creiamo il gruppo che contiene gli sprite del gioco
    sprite_group = pygame.sprite.Group()
    # Aggiungiamo al gruppo lo sprite hammer
    sprite_group.add(hammer)
    # Gestiamo gli eventi prodotti dal giocatore
    while True:
        for event in pygame.event.get():
            # Interrompiamo il gioco se clicchiamo sulla X di fine gioco
            if event.type == pygame.QUIT: 
                pygame.quit()
                quit()
        # Impostiamo la posizione di HAMMER attraverso il movimento del mouse
        pos = pygame.mouse.get_pos()
        # I controlli seguenti limitano i movimenti di HAMMER solo nella sezione di gioco
        if pos[0]>0 and pos[0]<1156 and pos[1]>50 and pos[1]<320:
            hammer.rect.x=pos[0]-5  
            hammer.rect.y=pos[1]-50
        else:    
            if pos[1]<=50:     
                hammer.rect.y=0
            elif pos[1]>=320:     
                hammer.rect.y=268
            if pos[0]<=0:
                hammer.rect.x=0 
            elif pos[0]>=1156:
                hammer.rect.x=1150

        # Disegniamo l'immagine come sfondo del gioco 
        screen.blit(SFONDO,(0,0))
        # Disegniamo tutti gli sprite associati al gruppo sullo schermo
        sprite_group.draw(screen)
        # Aggiorniamo lo schermo per vedere i cambiamenti
        pygame.display.update()

# Avvia il programma eseguendo il metodo main() 
if __name__ == '__main__':
    main()

COME AGGIUNGERE ALTRI SPRITE ALL'AREA DI GIOCO DI HAMMER-XP

Per creare le esperienze di gioco occorre aggiungere all'area di gioco di HAMMER-XP altri sprite.

Come avete già visto nella lezione precedente per creare uno sprite serve prima la classe seguente, che ne rappresenta il tipo:

class MioSprite(pygame.sprite.Sprite):
    # Costruttore dello sprite, quando viene eseguito dovete passare il colore dello sprite, la larghezza e l'altezza in pixel
    def __init__(self, color, width, height):
        super().__init__()
        self.image = pygame.Surface([width, height])
        self.image.fill(color)
        self.rect = self.image.get_rect()

Definito il tipo (classe), per creare un oggetto sprite da aggiungere al gioco, dovete usare il codice Python seguente:

RED=(255, 0, 0) # impostiamo il colore rosso 
primoSprite = MioSprite(RED, 30, 30) 

In questo caso abbiamo creato uno sprite che corrisponde ad un blocco di colore rosso di 30X30 pixel.

Adesso impostiamo la posizione dello sprite creato nell'area di gioco:

primoSprite.rect.x=500
primoSprite.rect.y=145

Con il codice Python seguente creiamo un nuovo sprite, ma di colre blu:

BLUE=(0, 0, 255) # impostiamo il colore blu 
secondoSprite = MioSprite(BLUE, 30, 30)

Adesso impostiamo la posizione dello sprite creato nell'area di gioco:

secondoSprite.rect.x=670
secondoSprite.rect.y=145

block_list = pygame.sprite.Group()

Successivamente dovete aggiungere al gruppo gli sprite creati:

block_list.add(primoSprite)
block_list.add(secondoSprite)

infine per completare l'operazione dovete usare i comandi segueti:

sprite_group.draw(screen)
pygame.display.update()

Di seguito trovate il codice Python completo per disegnare i due sprite dell'area di gioco:

import pygame

SIZE = WIDTH, HEIGHT = 1200, 690 # Impostiamo la larghezza e l'altezza dello schermo
# Carichiamo l'immagine di sfondo del gioco
SFONDO = pygame.image.load("sfondo_hammer_xp.png")

# Impostiamo una classe che serve a creare sprite
class MioSprite(pygame.sprite.Sprite):
    # Costruttore dello sprite, quando viene eseguito dovete passare il colore dello sprite, la larghezza e l'altezza in pixel
    def __init__(self, color, width, height):
        super().__init__()
        self.image = pygame.Surface([width, height])
        self.image.fill(color)
        self.rect = self.image.get_rect()

def main():
    # Inizializziamo l'ambiente pygame
    pygame.init()
    # Impostiamo le dimensioni dello schermo
    screen = pygame.display.set_mode(SIZE)

    # Creaiamo un primo sprite di colore rosso 30X30
    RED=(255, 0, 0) # impostiamo il colore rosso 
    primoSprite = MioSprite(RED, 30, 30) 
    # Posizioniamo lo sprite creato alle coordinate x=500 e y=145 dell'area di gioco
    primoSprite.rect.x=500
    primoSprite.rect.y=145
    # Creaiamo un secondo sprite di colore rosso 30X30
    BLUE=(0, 0, 255) # impostiamo il colore blu 
    secondoSprite = MioSprite(BLUE, 30, 30)
    # Posizioniamo lo sprite creato alle coordinate x=500 e y=145 dell'area di gioco
    secondoSprite.rect.x=670
    secondoSprite.rect.y=145

    # Creaiamo un gruppo di sprite
    block_list = pygame.sprite.Group()

    # Aggiungiamo al gruppo gli sprite creati

    block_list.add(primoSprite)
    block_list.add(secondoSprite)

    # Gestiamo gli eventi prodotti dal giocatore
    while True:
        for event in pygame.event.get():
            # Interrompiamo il gioco se clicchiamo sulla X di fine gioco
            if event.type == pygame.QUIT: 
                pygame.quit()
                quit()
        # Disegniamo l'immagine come sfondo del gioco 
        screen.blit(SFONDO,(0,0))
        # Disegniamo tutti gli sprite associati al gruppo sullo schermo
        block_list.draw(screen)
        # Aggiorniamo lo schermo per vedere i cambiamenti
        pygame.display.update()

# Avvia il programma eseguendo il metodo main() 
if __name__ == '__main__':
    main()

Eseguendo il programma Python otterrete la schermata seguente:

COME AGGIUNGERE ALL'AREA DI GIOCO 10 BLOCCHI COLORATI IN POSIZIONI CASUALI

Per creare 10 blocchi colorati in posizioni casuali prima di tutto dovete importare la libreria random per generare numeri casuali.

Poi serve un vettore che contiene i colori da assegnare agli sprite, come mostra il codice Python seguente:

RED=(255, 0, 0) # impostiamo il colore rosso 
GREEN=(0,255,0) # impostiamo il colore verde
BLUE=(0,0,255)  # impostiamo il colore blue
colori=[RED,GREEN,BLUE] # impostiamo un vettore con i tre colori

Per ottenere un colore casuale basterà generare un indice casuale tra 0 e 2 come mostra il codice Python seguente:

indice=random.randint(0,2)
colore=colori[indice]

Le posizioni casuali dei blocchi colorati le potete generare con il codice Python seguente:

blocco.rect.x = random.randrange(1170)
blocco.rect.y = random.randrange(339)

Il metodo randrange genera un valore casuale compreso tra 0 e il valore passato come argomento. In questo caso gli argomenti passati rappresentano i limiti massimi della larghezza e dell'altezza dell'area di gioco.  

Di seguito trovate il codice Python completo per disegnare 10 sprite colorati in posizioni casuali dell'area di gioco:

import pygame
import random

SIZE = WIDTH, HEIGHT = 1200, 690 # Impostiamo la larghezza e l'altezza dello schermo
# Carichiamo l'immagine di sfondo del gioco
SFONDO = pygame.image.load("sfondo_hammer_xp.png")
RED=(255, 0, 0) # impostiamo il colore rosso 
GREEN=(0,255,0) # impostiamo il colore verde
BLUE=(0,0,255)  # impostiamo il colore blue
colori=[RED,GREEN,BLUE] # impostiamo un vettore con i tre colori
indice=0
# Impostiamo una classe che serve a creare sprite
class Blocco(pygame.sprite.Sprite):
    # Costruttore dello sprite, quando viene eseguito dovete passare il colore dello sprite, la larghezza e l'altezza in pixel
    def __init__(self, color, width, height):
        super().__init__()
        self.image = pygame.Surface([width, height])
        self.image.fill(color)
        self.rect = self.image.get_rect()

def main():
    # Inizializziamo l'ambiente pygame
    pygame.init()
    # Impostiamo le dimensioni dello schermo
    screen = pygame.display.set_mode(SIZE)
    # Creaiamo un gruppo di sprite
    block_list = pygame.sprite.Group()
    for x in range (10):
        # Creaiamo un valore casuale che corrisponde a un indice tra 0 e 2
        indice=random.randint(0,2)
        colore=colori[indice]
        blocco = Blocco(colore, 30, 30)
        # Impostiamo una posizione casuale per il blocco creato
        blocco.rect.x = random.randrange(1170)
        blocco.rect.y = random.randrange(339)
        # Aggiungiamo al gruppo gli sprite creati
        block_list.add(blocco)

    # Gestiamo gli eventi prodotti dal giocatore
    while True:
        for event in pygame.event.get():
            # Interrompiamo il gioco se clicchiamo sulla X di fine gioco
            if event.type == pygame.QUIT: 
                pygame.quit()
                quit()
        # Disegniamo l'immagine come sfondo del gioco 
        screen.blit(SFONDO,(0,0))
        # Disegniamo tutti gli sprite associati al gruppo sullo schermo
        block_list.draw(screen)
        # Aggiorniamo lo schermo per vedere i cambiamenti
        pygame.display.update()

# Avvia il programma eseguendo il metodo main() 
if __name__ == '__main__':
    main()

Eseguendo il programma Python otterrete la schermata seguente:

COME GESTIRE LE COLLISIONI TRA HAMMER E GLI ALTRI SPRITE DELL'AREA DI GIOCO

Per rilevare le collisioni tra uno sprite e un gruppo di sprite, dovete usare il metodo spritecollide:

blocks_hit_list = pygame.sprite.spritecollide(hammer, block_list, True)

Questo metodo restituisce la lista dei riferimenti degli sprite del gruppo che intersecano lo sprite che non appartiene al gruppo.

Il primo argomento del metodo è il riferimento dello sprite di cui volete rilevare le collisioni; nel nostro caso l'oggetto hammer (sprite).

Il secondo argomento è il riferimento del gruppo che contiene i riferimenti degli sprite con cui lo sprite hammer collide; nel nostro caso i blocchi presenti sull'area di gioco.

L'ultimo argomento è un valore booleano; quando è True il blocco che colliderà con lo sprite hammer verrà eliminato dalla memoria; quindi non potrà più essere visibile perché verrà eliminato anche da tutti i gruppi in cui è stato aggiunto.

Quindi per eliminare dall'area di gioco i blocchi con cui lo sprite hammer colliderà, serviranno  due gruppi: il primo gruppo conterrà i riferimenti di tutti gli sprite che dovranno essere visibili nell'area di gioco, incluso lo sprite hammer; invece il secondo gruppo dovrà contenere solo gli sprite di tipo blocco da fornire come argomento al metodo spritecollode.

Il programma Python seguente visualizzerà 10 blocchi colorati in posizioni casuali, i blocchi verranno eliminati dall'area di gioco quando Hammer li interseca:

import pygame
import random

SIZE = WIDTH, HEIGHT = 1200, 690 # Impostiamo la larghezza e l'altezza dello schermo
# Carichiamo l'immagine di sfondo del gioco
SFONDO = pygame.image.load("sfondo_hammer_xp.png")
RED=(255, 0, 0) # impostiamo il colore rosso 
GREEN=(0,255,0) # impostiamo il colore verde
BLUE=(0,0,255)  # impostiamo il colore blue
colori=[RED,GREEN,BLUE] # impostiamo un vettore con i tre colori
indice=0

# Impostiamo La classe che serve a creare lo sprite Hammer
class Hammer(pygame.sprite.Sprite):
    def __init__(self):
        super(Hammer, self).__init__()
        self.images = []
        self.images.append(pygame.image.load('hammer.png')) # Associamo allo sprite l'immagine di hammer
        self.index = 0
        self.x=0
        self.y=0
        self.image = self.images[self.index]
        self.rect = self.image.get_rect()

# Impostiamo una classe che serve a creare sprite
class Blocco(pygame.sprite.Sprite):
    # Costruttore dello sprite, quando viene eseguito dovete passare il colore dello sprite, la larghezza e l'altezza in pixel
    def __init__(self, color, width, height):
        super().__init__()
        self.image = pygame.Surface([width, height])
        self.image.fill(color)
        self.rect = self.image.get_rect()

def main():
    # Inizializziamo l'ambiente pygame
    pygame.init()
    # Impostiamo le dimensioni dello schermo
    screen = pygame.display.set_mode(SIZE)
    # Creaiamo il gruppo di sprite che conterrà solo i blocchi.
    # Questo blocco deve essere passato come argomento al metodo spritecollide
    block_list = pygame.sprite.Group()
    # Creiamo il gruppo che conterrà tutti gli sprite del gioco, incluso Hammer.
    # Questo gruppo verrà usato per visualizzare tutti gli sprite visibili nell'area di gioco.
    sprite_group = pygame.sprite.Group()
    hammer = Hammer()
    sprite_group.add(hammer)
    for x in range (10):
        # Creaiamo un valore casuale che corrisponde a un indice tra 0 e 2
        indice=random.randint(0,2)
        colore=colori[indice]
        blocco = Blocco(colore, 30, 30)
        # Impostiamo una posizione casuale per il blocco creato
        blocco.rect.x = random.randrange(1170)
        blocco.rect.y = random.randrange(339)
        # Aggiungiamo ai gruppo gli sprite di tipo blocco creati
        block_list.add(blocco)
        sprite_group.add(blocco)

    # Gestiamo gli eventi prodotti dal giocatore
    while True:
        for event in pygame.event.get():
            # Interrompiamo il gioco se clicchiamo sulla X di fine gioco
            if event.type == pygame.QUIT: 
                pygame.quit()
                quit()
            # Impostiamo la posizione di HAMMER attraverso il movimento del mouse
            pos = pygame.mouse.get_pos()
            # I controlli seguenti limitano i movimenti di HAMMER solo nella sezione di gioco
            if pos[0]>0 and pos[0]<1156 and pos[1]>50 and pos[1]<320:
                hammer.rect.x=pos[0]-5  
                hammer.rect.y=pos[1]-50
            else:    
                if pos[1]<=50:     
                    hammer.rect.y=0
                elif pos[1]>=320:     
                    hammer.rect.y=268
                if pos[0]<=0:
                    hammer.rect.x=0 
                elif pos[0]>=1156:
                    hammer.rect.x=1150
        # Se Hammer interseca un blocco, il suo riferimento viene aggiunto alla lista
        # blocks_hit_list e poi viene eliminato dalla memoria, quindi verrà rimosso anche
        # dai gruppi block_list e sprite_group.
        blocks_hit_list = pygame.sprite.spritecollide(hammer, block_list, True)
        # Disegniamo l'immagine come sfondo del gioco 
        screen.blit(SFONDO,(0,0))
        # Disegniamo tutti gli sprite associati al gruppo sullo schermo
        sprite_group.draw(screen)
        # Aggiorniamo lo schermo per vedere i cambiamenti
        pygame.display.update()

# Avvia il programma eseguendo il metodo main() 
if __name__ == '__main__':
    main()
 

Eseguendo il programma Python e puntando Hammer con il mouse, ogni volta che il martelletto intersecherà un blocco, lo sprite verrà eliminato dall'area di gioco:

Nella prossima lezione vedrete come implementare un'esperienza reale con cui gli studenti potranno confrontarsi con l'obiettivo di dimostrare il loro livello di conoscenza sull'argomento proposto.

Per il download delle risorse di questa lezione cliccate qui.

< LEZIONE PRECEDENTE    |   LEZIONE SUCCESSIVA > | VAI ALLA PRIMA LEZIONE

T U T O R I A L S    S U G G E R I T I

• Competenze per programmare
• Impariamo Python giocando al "Solitario del ferroviere"
• Impariamo a programmare con JavaScript
• Laboratori di Logica di programmazione in C
• Introduzione alla Logica degli oggetti
• Ricominciamo ... dal Linguaggio SQL
• APP Mania
• Come sviluppare un Sito con Wordpress

PER IMPARARE A PROGRAMMARE, SEGUI LE PLAYLIST SUL NOSTRO CANALE YOUTUBE "SKILL FACTORY CHANNEL": clicca qui per accedere alle playlist

PAR GOL (Garanzia di Occupabilità dei Lavoratori)

Se sei residente in Campania e cerchi lavoro, sai che puoi partecipare gratuitamente ad un corso di formazione professionale PAR GOL?

I corsi di formazione professionale PAR GOL sono finanziati dalla Regione Campania e ti permettono di acquisire una Qualifica Professionale Europea (EQF) e di partecipare ad un tirocinio formativo aziendale.

Invia il tuo CV o una manifestazione d'interesse a: recruiting@skillfactory.it

oppure

chiama ai seguenti numeri di telefono:

Tel.: 081/18181361
Cell.: 327 0870141

oppure

Contattaci attraverso il nostro sito: www.skillfactory.it

Per maggiori informazioni sul progetto PAR GOL, clicca qui.

Per maggiori informazioni sulle Qualifiche Professionali Europee (EQF), clicca qui.

Academy delle professioni digitali

Per consultare il catalogo dei corsi online della nostra Academy ...

... collegati al nostro sito: www.skillfactory.it

Nella lezione precedente abbiamo visto gli step fondamentali per creare un gioco digitale da utilizzare nel mondo della scuola o della formazione professionale, per educare e facilitare l'apprendimento degli studenti. 

In questa nuova lezione inizieremo a creare un semplice gioco digitale; l'obiettivo delle attività svolte in questa  prima parte  è quello di prendere confidenza con gli sprite.

Gli sprite sono oggetti che possono contenere immagini, vengono usati per creare le animazioni dei giochi.

Il protagonista del gioco sarà Hammer un martelletto che avrà lo scopo di eliminare dalle scene del gioco gli elementi non corretti.

Lo scopo del gioco sarà  quello di verificare se gli studenti conoscono gli argomenti delle diverse esperienze di gioco proposte; ogni esperienza potrà prevedere anche più livelli.

Il gioco è adatto agli studenti della scuola elementare o media di età compresa tra gli otto e gli undici anni, naturalmente le esperienze di gioco possono essere create in base all'età. Quindi possiamo prevedere che il giocatore prima d'iniziare a giocare imposti la sua età.

L'immagine seguente mostra il mockup dell'interfaccia del gioco HAMMER-XP:

COME TRASFORMARE HAMMER IN UNO SPRITE

Prima di tutto vi suggerisco di creare una directory sul disco C, con il nome HAMMER-XP.

Per il download di HAMMER cliccate qui per visualizzare l'immagine, poi premete il tasto destro del mouse e salvate l'immagine di HAMMER nella directory HAMMER-XP.

Il codice Python seguente vi permetterà di trasformare HAMMER in uno sprite e visualizzarlo sullo schermo:

import pygame

SIZE = WIDTH, HEIGHT = 1200, 690 # Impostiamo la larghezza e l'altezza dello schermo
BACKGROUND_COLOR = pygame.Color('white') # Impostiamo il colore dello sfondo dello schermo
  
# La classe seguente permette di creare lo sprite e le sue caratteristiche
class Hammer(pygame.sprite.Sprite):
    def __init__(self):
        super(Hammer, self).__init__()
        self.images = []
        self.images.append(pygame.image.load('hammer.png')) # Associamo allo sprite l'immagine di hammer
        self.index = 0
        self.x=0
        self.y=0
        self.image = self.images[self.index]
        self.rect = self.image.get_rect()
  
def main():
    # Inizializziamo l'ambiente pygame
    pygame.init()
    # Impostiamo le dimensioni dello schermo
    screen = pygame.display.set_mode(SIZE)
    # Creiamo lo sprite hammer usando la classe sprite Hammer
    hammer = Hammer()
    # Creiamo il gruppo che contiene gli sprite del gioco
    sprite_group = pygame.sprite.Group()
    # Aggiungiamo al gruppo lo sprite hammer
    sprite_group.add(hammer)
    # Gestiamo gli eventi prodotti dal giocatore
    while True:
        for event in pygame.event.get():
            # Interrompiamo il gioco se clicchiamo sulla X di fine gioco
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
        # Impostiamo la posizione di HAMMER nello schermo
        hammer.rect.x=550  
        hammer.rect.y=150      
        # Impostiamo il colore dello sfondo dello schermo 
        screen.fill(BACKGROUND_COLOR)
        # Disegniamo tutti gli sprite associati al gruppo sullo schermo
        sprite_group.draw(screen)
        # Aggiorniamo lo schermo per vedere i cambiamenti
        pygame.display.update()
  
# Avviamo il programma eseguendo il metodo main() 
if __name__ == '__main__':
    main()

Avviando il programma otterrete la schermata seguente:

COME AGGIUNGERE AL GIOCO UN'IMMAGINE DI SFONDO

Per il download dell'immagine di sfondo del gioco cliccate qui per visualizzare l'immagine, poi premete il tasto destro del mouse e salvate l'immagine dello sfondo nella directory HAMMER-XP.

Il codice Python seguente vi permetterà di aggiungere al gioco anche l'immagine di sfondo:

---

import pygame

SIZE = WIDTH, HEIGHT = 1200, 690 # Impostiamo la larghezza e l'altezza dello schermo
# Carichiamo l'immagine di sfondo del gioco
SFONDO = pygame.image.load("sfondo_hammer_xp.png")

# La classe seguente permette di creare lo sprite e le sue caratteristiche
class Hammer(pygame.sprite.Sprite):
    def __init__(self):
        super(Hammer, self).__init__()
        self.images = []
        self.images.append(pygame.image.load('hammer.png')) # Associamo allo sprite l'immagine di hammer
        self.index = 0
        self.x=0
        self.y=0
        self.image = self.images[self.index]
        self.rect = self.image.get_rect()
def main():
    # Inizializziamo l'ambiente pygame
    pygame.init()
    # Impostiamo le dimensioni dello schermo
    screen = pygame.display.set_mode(SIZE)
    # Creiamo lo sprite hammer usando la classe sprite Hammer
    hammer = Hammer()
    # Creiamo il gruppo che contiene gli sprite del gioco
    sprite_group = pygame.sprite.Group()
    # Aggiungiamo al gruppo lo sprite hammer
    sprite_group.add(hammer)
    # Gestiamo gli eventi prodotti dal giocatore
    while True:
        for event in pygame.event.get():
            # Interrompiamo il gioco se clicchiamo sulla X di fine gioco
            if event.type == pygame.QUIT: 
                pygame.quit()
                quit()
        # Impostiamo la posizione di HAMMER nello schermo
        hammer.rect.x=550  
        hammer.rect.y=150      
        # Disegniamo l'immagine come sfondo del gioco 
        screen.blit(SFONDO,(0,0))
        # Disegniamo tutti gli sprite associati al gruppo sullo schermo
        sprite_group.draw(screen)
        # Aggiorniamo lo schermo per vedere i cambiamenti
        pygame.display.update()

# Avvia il programma eseguendo il metodo main() 
if __name__ == '__main__':
    main()

---

Avviando il programma otterrete la schermata seguente:

Nella prossima lezione imparerete a mettere HAMMER in movimento e a gestire le collisioni tra gli sprite.

---

Per il download delle risorse di questa lezione cliccate qui.

---

< LEZIONE PRECEDENTE    |   LEZIONE SUCCESSIVA > | VAI ALLA PRIMA LEZIONE

---

T U T O R I A L S    S U G G E R I T I

• Competenze per programmare
• Impariamo Python giocando al "Solitario del ferroviere"
• Impariamo a programmare con JavaScript
• Laboratori di Logica di programmazione in C
• Introduzione alla Logica degli oggetti
• Ricominciamo ... dal Linguaggio SQL
• APP Mania
• Come sviluppare un Sito con Wordpress

---

PER IMPARARE A PROGRAMMARE, SEGUI LE PLAYLIST SUL NOSTRO CANALE YOUTUBE "SKILL FACTORY CHANNEL": clicca qui per accedere alle playlist

---

PAR GOL (Garanzia di Occupabilità dei Lavoratori)

Se sei residente in Campania e cerchi lavoro, sai che puoi partecipare gratuitamente ad un corso di formazione professionale PAR GOL?

I corsi di formazione professionale PAR GOL sono finanziati dalla Regione Campania e ti permettono di acquisire una Qualifica Professionale Europea (EQF) e di partecipare ad un tirocinio formativo aziendale.

 

Invia il tuo CV o una manifestazione d'interesse a: recruiting@skillfactory.it

oppure

chiama ai seguenti numeri di telefono:

Tel.: 081/18181361
Cell.: 327 0870141

oppure

Contattaci attraverso il nostro sito: www.skillfactory.it

---

Per maggiori informazioni sul progetto PAR GOL, clicca qui.

Per maggiori informazioni sulle Qualifiche Professionali Europee (EQF), clicca qui.

---

Academy delle professioni digitali

Per consultare il catalogo dei corsi online della nostra Academy ...

... collegati al nostro sito: www.skillfactory.it

 

Questo tutorial è rivolto a tutti coloro che lavorano nel mondo dell'istruzione, dell'educazione e della formazione professionale, allo scopo di introdurre le conoscenze e le abilità che servono per utilizzare, progettare e sviluppare giochi digitali da utilizzare per il  game based learning e la gamification.

Gli obiettivi principali del tutorial sono i seguenti:

1) Comprendere le reali potenzialità dei giochi digitali per la scuola e la formazione professionale;
2) Imparare a disegnare (progettare) giochi digitali;
3) Capire come si può trasformare il disegno di un gioco digitale in una vera applicazione.

Naturalmente, oltre ad acquisire conoscenza, potete anche strutturarvi in un team di lavoro, per progettare e sviluppare in autonomia i vostri giochi digitali.

Per iniziare, dobbiamo capire prima di tutto la differenza tra game based learning e gamification.   

GAME BASED LEARNING
Il Game Based Learning è molto utile a scuola, perché attraverso l'impiego di giochi digitali permette di aumentare il livello di attenzione degli studenti, favorisce la collaborazione e il lavoro di gruppo e rafforza le capacità creative e di problem solving perché ti pone di fronte ad esigenze reali da risolvere per raggiungere gli obiettivi previsti.



Introdurre i giochi digitali nella didattica significa innovare le metodologie d'insegnamento, potenziando le tecniche di educazione degli studenti attraverso l'aspetto ludico.

GAMIFICATION O GAMIFICAZIONE
La Gamificazione può essere utile sia a scuola, sia per la formazione professionale; utilizza il gioco digitale per favorire le capacità di apprendimento e lo sviluppo di alcuni comportamenti.

Questa tecnica d'insegnamento è utile perché rende più efficace la comunicazione, permette di fare esempi pratici, aumenta il livello di concentrazione dei destinatari dell'azione formativa favorendo sia l'apprendimento, sia il ricordo dei concetti importanti.

Inoltre, la gamificazione permette di creare scenari diversi, utili per sviluppare comportamenti specifici in base al contesto in cui si opera.

Attenzione, un gioco digitale non deve assolutamente essere confuso con un corso e-learning.

Un corso e-learning può essere un'alternativa al ruolo dell'insegnante o del formatore, mentre un gioco digitale deve essere considerato uno strumento di supporto per il lavoro dell'insegnate o del formatore.  

Quindi i giochi digitali potenziano le capacità educative e didattiche sia degli insegnanti, sia dei formatori, mettendone in risalto i ruoli.

All'origine di un gioco digitale c'è sempre un progetto, quindi tutto nasce da un'idea (concept) e da uno o più obiettivi da raggiungere.  

Vediamo quali sono gli step fondamentali per creare la progettazione un gioco digitale.

LA FASE DI ANALISI

Per creare un gioco digitale dovete prima porvi queste tre domande:

1. "Qual è lo scopo del gioco?"

2. "Chi sono i destinatari?"

3. "Se è un gioco di individuale oppure di gruppo?"

Quando avete chiare le risposte delle tre domande, dovete interrogarvi sulla reale esigenza di creare il gioco - magari esiste già - sulla sua fattibilità e sugli eventuali rischi.

Per fattibilità s'intende soprattutto accertarsi che:

1) ci sono le competenze;
2) c'è il tempo;
3) ci sono le risorse finanziarie.

Un progetto non può iniziare se non c'è una risposta affermativa a queste tre le domande e non siete sicuri di riuscire a gestire i rischi oppure le difficoltà che si possono presentare.

Tutto questo lavoro preliminare rappresenta la fase di analisi.

LA FASE DI DISEGNO O PROGETTAZIONE

Questa è la fase più importante, perché le attività svolte risulteranno fondamentali per la produzione del gioco digitale da creare.

Qui nascono le regole, le storie, le scene, gli attori, le tecniche d'interazione e si sceglie il linguaggio di programmazione con cui sviluppare il gioco digitale.

Per svolgere le attività previste da questa fase occorre un po' di fantasia e bisogna avere sempre ben chiari gli obiettivi educativi o didattici per cui è stato concepito il gioco e chi sono i destinatari.

Il ruolo di designer di giochi digitali non richiede competenze specifiche, quindi lo può svolgere chiunque, basta avere una buona esperienza nel settore educativo e didattico e saper descrivere la propria idea di gioco digitale, anche con carta e penna, indicando le regole, scrivendo le storie, spiegando le tecniche d'interazione e abbozzando i disegni delle scene e degli attori, per creare lo storyboard.

Quello che conta è avere una buona idea di gioco digitale. 

LA FASE DI COSTRUZIONE

 

 

Nella prossima lezione vi parlerò di Sprite, indispensabili per creare il nostro primo gioco digitale.

LEZIONE SUCCESSIVA >

T U T O R I A L S    S U G G E R I T I

• Competenze per programmare
• Impariamo Python giocando al "Solitario del ferroviere"
• Impariamo a programmare con JavaScript
• Laboratori di Logica di programmazione in C
• Introduzione alla Logica degli oggetti
• Ricominciamo ... dal Linguaggio SQL
• APP Mania
• Come sviluppare un Sito con Wordpress

PER IMPARARE A PROGRAMMARE, SEGUI LE PLAYLIST SUL NOSTRO CANALE YOUTUBE "SKILL FACTORY CHANNEL": clicca qui per accedere alle playlist

PAR GOL (Garanzia di Occupabilità dei Lavoratori)

Se sei residente in Campania e cerchi lavoro, sai che puoi partecipare gratuitamente ad un corso di formazione professionale PAR GOL?

I corsi di formazione professionale PAR GOL sono finanziati dalla Regione Campania e ti permettono di acquisire una Qualifica Professionale Europea (EQF) e di partecipare ad un tirocinio formativo aziendale.

Invia il tuo CV o una manifestazione d'interesse a: recruiting@skillfactory.it

oppure

chiama ai seguenti numeri di telefono:

Tel.: 081/18181361
Cell.: 327 0870141

oppure

Contattaci attraverso il nostro sito: www.skillfactory.it

Per maggiori informazioni sul progetto PAR GOL, clicca qui.

Per maggiori informazioni sulle Qualifiche Professionali Europee (EQF), clicca qui.

Academy delle professioni digitali

Per consultare il catalogo dei corsi online della nostra Academy ...

... collegati al nostro sito: www.skillfactory.it