Game Maker Guida(ottima)

Download ed installazione
Per prima cosa procuratevi Game Maker 6 dal sito ufficiale.
Questo programma и distribuito gratuitamente, ma alcune sue funzionalitа sono bloccate finchи non si effettua la registrazione. Consiglio caldamente di effettuare la registrazione subito (costa solo 15 euro), in modo da poter fin da subito sfruttare tutti gli aspetti di questo potente tool.

Nonostante Game Maker includa anche un semplice editor d'immagini и consigliabile procurarsi un programma di disegno (se non ne avete uno consiglio 'theGIMP' o 'Serif DrawPlus4' reperibili gratuitamente in rete sui siti dei relativi produttori), una collezione di suoni in formato wave (.wav) e una collezione di musiche libere da diritti d'autore (midi o mp3). Una piccola collezione di suoni, musiche e sprite и reperibile sempre dal sito ufficiale di Game Maker.

Una volta scaricato, Game Maker и estremamente semplice da installare: un doppio click sul programma d'installazione ed и pronto a funzionare. Al primo avvio, dopo l'installazione, chiede d'inserire il codice di registrazione. Se questo non gli viene fornito, sarа comunque utilizzabile rinunciando a qualche funzione. E' possibile inserire il codice di registrazione in un secondo momento, attraverso una voce del menщ help.

Concetti di base
Game Maker и un tool di sviluppo nato per permettere anche ai non-programmatori di realizzare un videogioco completo e, con una certa pratica, di notevole qualitа, il tutto senza essere obbligati a scrivere nemmeno una linea di codice. Tuttavia, come vedremo in seguito, i migliori risultati si ottengono utilizzando il suo linguaggio di scripting, ma di questo parleremo a tempo debito. Prima d'entrare nel vivo della descrizione del funzionamento di Game Maker и infatti necessario conoscere cosa costituisce un videogioco e comprendere come Game Maker aiuti a gestire questi elementi.

Se osserviamo un videogioco qualsiasi и fin da subito evidente che essenzialmente и composto da elementi grafici che interagiscono tra loro o con il giocatore secondo una determinata logica. E' altrettanto evidente che possono essere presenti musiche ed effetti sonori, ma questi, il piщ delle volte, hanno una funzione secondaria e solo di rado sono elementi indispensabili al fine del gioco.

Ogni elemento visibile puт essere considerato come un oggetto e puт essere reso attivo da una parte del programma che costituisce la logica del gioco. Nei capitoli a seguire andremo a vedere come Game Maker gestisce queste parti fondamentali di ogni gioco.

nterfaccia grafica e funzioni di base
Appena installato e avviato Game Maker si presenta come una finestra con un classico menщ, una classica toolbar e un'area di lavoro divisa in due campi principali: una colonna con delle icone a forma di cartella (che conterranno tutte le entitа utilizzate nel nostro gioco) sulla sinistra, e a destra un grande campo vuoto (и l'area di editing dell'entitа selezionata).

Andiamo a vedere e descrivere questi elementi:


Le voci dei menщ sono abbastanza comuni:

* File: contiene le voci New, per creare un nuovo gioco, Open per aprire un lavoro precedentemente salvato, Recent File per accedere rapidamente agli ultimi giochi realizzati, Save e Save As per salvare il lavoro in corso, Create Executable, Merge Game per fondere gli elementi di piщ giochi, l'opzione Advanced Mode, le Preferences da cui impostare le opzioni di funzionamento e la voce Exit per chiudere il programma.
* Edit: contiene le voci Insert, per inserire una nuova risorsa nel gioco, Duplicate per duplicare la risorsa selezionata, Add Group per aggiungere un gruppo di risorse, Delete e Rename per cancellare o rinominare una risorsa, Properties per editare le proprietа della risorsa ed alcune voci per cercare una determinata risorsa tra quelle inserite nel gioco.
* Add: contiene i comandi diretti per aggiungere una risorsa al gioco.
* Script: contiene le voci Import ed Export script, piщ una serie di strumenti per visualizzare le funzioni interne di Game Maker.
* Run: permette di eseguire il gioco in realizzazione in due modalitа diverse, quella normale e quella di debug, per la ricerca e correzione degli errori.
* Window: permette di arrangiare la visualizzazione delle finestre dei vari editor di Game Maker.
* Help: permette di accedere alla guida in linea, di inserire il codice di registrazione, un link al sito ufficiale e la classica voce About, che spiega chi l'ha realizzato.

La toolbar (la fila di pulsanti sotto ai menщ...) replica le funzioni principali contenute nei menщ, in modo da averle sempre sottocchio, e sono, nell'ordine: Nuovo, Apri, Salva, Run, Run Debug, Aggiungi Sprite, Suono, Fondale, Percorso, Script, Font, Oggetto, Stanza, Cambia informazioni di gioco, Cambia impostazioni di gioco ed Help.

La colonna di sinistra, come detto in precedenza, ha una struttura ad albero ed elenca tutte le risorse utilizzabili nel gioco. Quindi, per poter usare una risorsa qualsiasi bisogna prima inserirla nell'apposita cartella (in futuro vedremo che esiste un'alternativa, ma ora и prematuro parlarne), usando una voce del menщ, un bottone della toolbar o cliccando col pulsante destro del mouse sulla cartella ed usando il menщ contestuale che apparirа (si puт usare anche il tasto 'menщ contestuale' della tastiera...):



Ora che sappiamo come inserire le risorse all'interno di Game Maker, possiamo andare a studiare come possiamo utilizzarle.

Introduzione all'uso di Game Maker
Andiamo ad approfondire quanto spiegato nel Capitolo 1, ovvero in cosa consiste un gioco, questa volta osservandolo dal punto di vista di Game Maker

Ogni gioco и essenzialmente composto da oggetti sistemati all'interno di una o piщ stanze. Il gioco si svolge dunque sempre all'interno di una stanza. La stanza di gioco contiene tutti gli elementi del gioco ed и dotata di due caratteristiche importanti: le dimensioni (in pixel) e la velocitа (in cicli al secondo). Spesso mi riferirт alla stanza usando il termine inglese room in quanto и cosм chiamata all'interno di Game Maker.

Gli oggetti presenti all'interno di una stanza possono avere caratteristiche anche molto diverse gli uni dagli altri. Alcuni sono invisibili, altri al contrario servono solo a visualizzare un'immagine. Generalmente, perт, ad ogni oggetto corrisponde uno sprite, cioи un'immagine. Lo sprite puт essere un'immagine fissa o una sequenza d'animazione, a seconda dell'effetto che si intende ottenere.

La caratteristica piщ importante degli oggetti и che possono eseguire delle azioni all'avvenire di determinati eventi. Gli eventi sono di numerosi tipi:

* abbiamo un evento di creazione quando l'oggetto viene creato
* abbiamo un evento di distruzione quando l'oggetto viene distrutto
* abbiamo un evento di tipo 'alarm' quando si attiva un timer
* abbiamo un evento di tipo 'step' che viene ripetuto ad ogni ciclo (ricordate la velocitа delle stanze?)
* abbiamo un evento di collisione quando due oggetti si scontrano
* abbiamo un evento di tipo 'keyboard' quando si preme un tasto
* abbiamo un evento di tipo 'mouse' quando si usa il mouse
* e tanti altri che vedremo in seguito...

Le azioni che possono avvenire a seguito di un evento sono ancor piщ numerose, ma si possono raggruppare per tipo: abbiamo azioni di movimento, di controllo degli oggetti, degli sprite, dei suoni etc. Un esempio per tutti: premendo un tasto (evento keyboard) il giocatore si sposta a destra di qualche pixel (azione movimento).

Un oggetto puт essere presente in piщ copie uguali, ognuna delle quali prende il nome di istanza dell'oggetto.

Andiamo quindi alla prossima guida per vedere come funziona il sistema drag'n'drop di Game Maker.

Il sistema Drag'n'Drop
Il metodo piщ semplice di utilizzare Game Maker и quello basato sul concetto di drag'n'drop (su per giщ significa: 'trascina e lascia cadere'), che col solo impiego del mouse, trascinando delle icone nel posto giusto, consente di realizzare un videogioco completo e funzionante.

Ad esempio, osservate l'immagine seguente:


Immaginiamo di voler inserire in una room un oggetto che si sposta alla velocitа di un pixel per ciclo da sinistra verso destra. In questo caso dovremmo operare in questo modo:

* aggiungere un oggetto (Add Object).
* primo passo: cliccare sul bottone 'Add Event' e scegliere la voce 'Create' dalla finestra 'Event Selector'
* secondo passo: trascinare l'icona evidenziata nell'immagine nella colonna 'Action'.
* inserire il numero 1 nel campo attivo della finestra che si aprirа.

A questo punto, se inseriamo l'oggetto creato in una stanza ed avviamo il gioco, l'oggetto inizierа a muoversi nel modo desiderato. Notare bene che in quest'esempio l'oggetto и privo di sprite, quindi non sarebbe visibile. Per poterlo visualizzare, premere Add Sprite (dal menщ o dalla toolbar), creare un piccolo sprite, ed abbinarlo all'oggetto selezionando lo sprite nel menщ a tendina visibile nell'immagine (dove ora и scritto no sprite).

E' venuto il momento di mettere in pratica quanto visto fin ora e realizzare il primo gioco.

Il sistema Drag'n'Drop
Per prima cosa, appena lanciato Game Maker ed iniziato un nuovo gioco, facciamo un piccolo esperimento: premiamo subito il pulsante 'Run Game' (il simbolo 'play' in verde). Un messaggio d'errore ci avviserа che un gioco deve avere almeno una stanza per funzionare. Quindi iniziamo ad aggiungere una room, che per ora rimmarrа vuota.

In questo gioco useremo 5 oggetti, di cui uno privo di sprite. Questo significa che ci occorrono 4 sprite per gli altri oggetti. A livello esplicativo, quelli che ho usato io sono questi:

* per l'oggetto 'player' ho creato uno sprite chiamato 'player_sp': 32x32 pixel, trasparente, origine posta a 16,0
* per l'oggetto 'enemy' ho creato uno sprite chiamato 'enemy_sp': 32x32 pixel, trasparente, origine a 16,16.
* per l'oggetto 'block' ho creato uno sprite chiamato 'block_sp': 16x16 pixel, NON trasparente, origine a 0,0.
* per l'oggetto 'shot' ho creato uno sprite chiamato 'shot_sp': 12x12 pixel, trasparente, origine a 6,6.


A questo punto possiamo andare a creare gli oggetti che costituiscono il gioco. Per prima cosa, Add Object e creiamo l'oggetto block, che serve a disegnare la scena di gioco. Quest'oggetto, vista la sua particolare natura, rimmarrа privo di eventi ed azioni. L'importante и che sia solido e visibile ed abbia per sprite block_sp:



Il passo successivo и quello di aprire la stanza che avevamo creato ed apportare queste modifiche: dal 'TAB' background applicare un colore di fondo grosso modo come quello dell'immagine seguente, quindi, dal 'TAB' objects, inserire degli oggetti 'block', sempre come da figura:



Ora abbiamo l'ambiente di gioco pronto, quindi andiamo a creare gli oggetti di gioco. Iniziamo dall'oggetto che subito dopo a 'block' (che era inerte), risulta essere il piщ semplice: l'oggetto 'shot'. Quest'oggetto verrа creato dall'oggetto 'player' su pressione della barra spaziatrice, quindi sarа dotato di due soli eventi:

evento 'create':

evento 'outside room':


Per prima cosa, quindi, Add Object e creiamo un oggetto che chiamiamo 'shot' gli attribuiamo lo sprite 'shot_sp', premiamo sul pulsante 'Add Event' e selezioniamo l'evento 'create'. A questo punto, trasciniamo con il mouse l'icona 'Set vertical speed' (la quinta del tab 'move', vedere immagini sopra) e la lasciamo nella colonna delle azioni. Al rilascio del pulsante del mouse apparirа una finestra che chiederа a chi applicare l'azione e la velocitа di moto:



Impostiamo come da figura, quindi 'Add Event' e da 'Others' scegliamo 'Outside Room', ci spostiamo tra i tab delle azioni, precisamente in 'main1', e trasciniamo l'icona 'Destroy the instance' nella colonna delle azioni. Spieghiamo il comportamento di quest'oggetto: quando viene creato parte verso l'alto con uno spostamento di 10 pixel per ciclo, se esce dallo scermo, allora viene distrutto.

Proseguendo in ordine di complessitа, andiamo ora a definire l'oggetto 'player'. 'Add Object', nome 'player', sprite 'player_sp'. 'Add Event', e dalla lista 'Keyboard' scegliamo 'Left', quindi 'Add Event', e dalla lista 'Keyboard' scegliamo 'Right'. Per finire, 'Add Event', e dalla lista 'Key Press' scegliamo 'Space'.

Selezioniamo l'evento relativo alla pressione di 'Left' e, nella colonna delle azioni trasciniamo, dalla tab controll, l'icona 'If a position is collision free', settandola come nell'immagine seguente:



Subito sotto trasciniamo l'icona 'Start of a block' e sotto ancora 'Jump to a given position' che farа aprire una finestra di configurazione, che impostiamo cosм:



Dopodichи trasciniamo l'icona 'End of a block' subito sotto. Ripetiamo la stessa operazione con l'evento 'Right', avendo l'accortezza di sostituire i due valori -5 con dei valori +5. All'evento 'press < space >' facciamo corrispondere l'azione 'Create an instance of object shot at relative position (0,0)':



A questo punto piazziamo l'oggetto 'player' nella nostra stanza di gioco:



Ora creiamo l'oggetto 'enemy', gli attribuiamo lo sprite 'enemy_sp' e lo dotiamo dei segueti eventi:

- evento 'create':



Questo farа sм che 'enemy', una volta creato, parta in una direzione compresa tra 250° (in basso verso sinistra) e 290° (in basso verso destra), con velocitа di 4 pixel per ciclo.

- evento 'outside the room', 'instance destroy' (l'abbiamo giа visto per shot...)

- evento 'Collision' con 'block':



- evento 'Collision' con 'shot':



Ed anche quest'oggetto и finito, ma NON lo inseriremo nella stanza di gioco! A questo penserа l'ultimo oggetto: Add Object, lo chiamiamo 'controller' e lo lasciamo senza sprite. Lo dotiamo degli eventi: 'create', 'step', 'draw'.

Selezioniamo l'evento 'create' al cui fianco trasciniamo l'azione 'Set lives to 5', dal tab 'score'.

Selezioniamo l'evento 'draw' e gli facciamo corrispondere queste due azioni:




Selezioniamo l'evento 'step', il piщ complesso di questo gioco, e gli facciamo eseguire questo blocco:



La prima istruzione (if the number...) la configuriamo cosм:



La seconda (create...), invece cosм:



Il resto, come dalla figura che descrive il blocco. Ora non vi resta inserire l'oggetto 'controller' nella stanza di gioco e poter provare il gioco e studiarne la struttura. Concludendo: abbiamo dimostrato come sia possibile realizzare semplici giochi senza scrivere una riga di programma. Voglio perт mettere in evidenza come, per oggetti piщ complessi di quelli che abbiamo visto in questa guida, i blocchi di azioni legati agli eventi possano facilmente diventare lunghi e scarsamente leggibili, per questo poco adatti ad essere modificati. Per evitare questo inconveniente и preferibile abituarsi, per i giochi piщ complessi, ad usare gli script, come vedremo nelle prossime guide.

Introduzione al Game Maker Language (GML) - parte I
Come accennato nella guida precedente, anche se il sistema 'drag and drop' di Game Maker и molto semplice da usare, и poco indicato alla realizzazione di oggetti molto complessi. Ma al crescere della complessitа del gioco и frequente che ad un oggetto debbano essere affidate molte funzioni e comportamenti facilmente ridefinibili, modificabili, espandibili. Quindi и necessario abbinare, agli eventi a cui deve rispondere l'oggetto, un pezzo di codice che racchiuda tutte le azioni che l'oggetto deve compiere.

Fortunatamente Game Maker ci mette a disposizione il GML, acronimo di Game Maker Language, un semplice ma versatile linguaggio di programmazione che ricorda un po il C e il Pascal, che, con davvero poche linee di codice, permette di gestire tutti gli aspetti del gioco.

Questo capitolo introduttivo ha il solo scopo di spiegare dove puт essere profiquamente inserito un programma in GML e che struttura avrа in generale. Di una spiegazione piщ approfondita mi occuperт nella prossima guida.

Cominciamo dicendo che esitono due forme base che puт assumere un programma in GML: lo script ed il 'piece of code' (pezzo di codice):



Il 'piece of code' puт essere aggiunto alle azioni svolte da un oggetto in risposta ad un evento. Anche lo script puт essere impiegato alla stessa maniera, ma come vedremo in seguito, ha il vantaggio di poter essere utilizzato da piщ oggetti. Un caso particolare di 'piece of code' и il 'creation code' che puт essere eseguito alla creazione di una stanza.

Un programma in GML и essenzialmente una sequenza di istruzioni:

{
...
< istruzione 1>;
< istruzione 2>;
< istruzione 3>;
...
}

Ogni programma devrebbe essere racchiuso tra parentesi graffe. Per chi non lo sapesse, le graffe si ottengono premendo ALT+123 e ALT+125 (numeri del tastierino numerico). Le istruzioni dovrebbero finire con il puntoevirgola. Dico dovrebbero perchи normalmente Game Maker ignora l'assenza delle parentesi e dei puntievirgola. E' comunque buona norma abituarsi a farne uso.

Le istruzioni servono di solito a manipolare dei dati. Spesso questi dati sono contenuti in variabili. In GML una variabile puт contenere sia valori numerici che stringhe di testo. L'operazione di attribuire un certo contenuto ad una variabile si chiama 'assegnazione' e si compie col segno matematico che siamo abituati a chiamare 'uguale':

{

//assegno alla variabile 'a' il valore numerico 10
a=10;

//assegno alla variabile 'b' una stringa di testo
b='testo assegnato alla variabile b';

}

Esistono molte variabili predefinite. Ad esempio 'x' ed 'y' corrispondono alle coordinate dell'oggetto a cui si applica lo script (o il pezzo di codice), o come 'room_width', che indica la larghezza della stanza di gioco. Le variabili possono essere locali o globali. Quando un valore viene assegnato ad una variabile all'interno di un oggetto, questa variabile puт essere accessibile solo all'interno di quest'oggetto. Se dobbiamo utilizzarla all'interno di un altro oggetto, dobbiamo indicare il nome dell'oggetto in cui и stata definita:

{

//voglio usare la variabile chiamata 'alpha' definita
//nell'oggetto 'giocatore' ed usarla come direzione
//dell'oggetto che sto manipolando

direction=giocatore.alpha;

}

Se una variabile, definita all'interno di un oggetto, dovrа essere utilizzata spesso in oggetti diversi, allora ho convegnenza a crearla globale:

{

//assegnazione di una variabile globale:
global.a = room_width - player.x;

//impiego della variabile globale:
distanza = global.a;

}

Ora che conosciamo l'unitа di base in cui contenere i dati che useremo nei primi programmi, vediamo quali istruzioni abbiamo a disposizione per gestire il funzionamento del programma. L'istruzione piщ semplice di tutte и repeat, che non fa altro che ripetere un certo numero di volte un'altra istruzione:

{

//crea 1000 istanze dell'oggetto 'stella'
//per creare un cielo stellato
repeat (1000) instance_create(random(room_width),random(room_height),stella);

}

Se devo eseguire piщ operazioni lo stesso numero di volte, и sufficiente racchiuderle in un blocco:

{

//esegue 10 volte piщ operazioni:
repeat (10){
x+=1; //incrementa x
y-=1; //decrementa y
}

}

Se voglio che un blocco venga eseguito finchи una condizione и vera, posso usare l'istruzione while:

{

//esegue il blocco finchи y и maggiore di x:
while (y > x){
x+=1; //incrementa x
y-=1; //decrementa y
}

}

Se voglio che un blocco venga eseguito finchи una condizione non viene raggiunta, posso usare il ciclo do - until:

{
//sposta un oggetto a finchи non trova uno spazio libero:
do
{
x = random(room_width);
y = random(room_height);
}
until (place_free(x,y))
}



Un ciclo che venga eseguito un numero definito di volte si puт costruire con for:

{

//struttura di for:
//for (dichiarazione; espressione; dichiarazione;)
//incrementa x di 1 per 10 volte:

for (i=0; i<=9; i+=1) x+=1;

//spiegazione: il valore iniziale di i и zero,
//il ciclo viene ripetuto finchи i и minore di 9,
//ogni volta i viene incrementato di 1.

}



Se invece vogliamo che una certa operazione venga eseguita solo a certe condizioni, allora possiamo usare l'istruzione if:

{

//ferma l'oggetto 'auto' se raggiunge il bordo sinistro
//dello schermo:
if (auto.x=room_whidth) auto.speed=0;

}

Quando abbiamo l'esigenza che esista un comportamento particolare se la condizione non si verifica, allora possiamo scrivere cosм:

{

//ferma l'oggetto 'auto' se raggiunge il bordo sinistro
//dello schermo, altrimenti regola la velocitа:
if (auto.x < room_whidth){
auto.speed=0;
}
else {
auto.speed = 5;
}

}

Quando vogliamo una reazione diversa a seconda della condizione, allora possiamo usare switch:

{

//la risposta dell'oggetto varia a seconda si prema
//un tasto direzione o un tasto alternativo:
switch (keyboard_key)
{
case vk_left:
case vk_numpad4:
x -= 4; break;
case vk_right:
case vk_numpad6:
x += 4; break;
}

}

E con questo abbiamo visto le istruzioni principali con cui si controlla un programma in GML. Nella prossima guida introddurrт le funzioni, parlando tanto di quelle incorporate in Game Maker quanto del metodo per realizzarne di personalizzate.

Introduzione al Game Maker Language (GML)- parte II
Come anticipato nel capitolo precedente, andremo ora a vedere le principali funzioni fornite con Game Maker.
Sia chiaro, qui non verranno spiegate una ad una le mille e piщ funzioni fornite con Game Maker, non avrebbe senso pratico: sono giа sufficentemente spiegate nel manuale, disponibile in molte lingue in questa PAGINA.
E' invece utile spiegare come trovare quelle che ci servono per affrontare un determinato problema e come sia possibile crearne di proprie per rendere piщ flessibile, pratico e potente il proprio programma in GML.

Built-in function: le funzioni fornite con Game Maker.
Iniziamo il discorso spiegando cosa и una funzione. Una funzione и una porzione di programma, costituita da un'insieme di istruzioni, organizzate in modo da produrre un determinato risultato o svolgere un determinato compito. L'utilitа di una funzione risiede principalmente nel fatto che puт essere richiamata in qualsiasi punto del programma, o in punti diversi, evitando di dover riscrivere tutta la sequenza di istruzioni ogni volta sia necessario. Sono, in poche parole, dei sotto-programmi specializzati a risolvere certi problemi.

Game Maker mette a disposizione un migliaio circa (mi pare 1173, ma potrei ricordar male...) di funzioni incorporate, adatte ad affrontare la maggior parte dei problemi. Sono molte, ma fortunatamente non и necessario ricordare a memoria come si chiamano e come si usano, perchи sono state 'catalogate' con una certa intelligenza per scopo. Abbiamo quindi, un insieme minimo di funzioni 'generiche', come quelle matematiche o alcune di manipolazione delle stringhe, che suggeriscono giа dal nome l'operazione che svolgono. Tutte le altre hanno un nome composto, preceduto da un prefisso che ne indica chiaramente lo scopo. Ad esempio, tutte le funzioni di manipolazione delle stringhe (eccetto le due o tre citate prima) iniziano col prefisso string_, tutte quelle che si occupano dell'input da tastiera iniziano con keyboard_, e via discorrendo. Quindi, basta pensare un'attimo a quale tipo di operazione vogliamo svolgere ed avremo giа metа del nome. E qui interviene uno strumento decisamente utile presente nell'editor degli script. Difatti, sia che stiamo inserendo un piece of code, sia che stiamo scrivendo uno script indipendente, usiamo lo stesso editor che и diviso in due aree principali: quella superiore, in cui scriviamo, quella inferiore, utile help in linea, che suggerisce le varie funzioni che iniziano con quel prefisso e quali argomenti si aspetta. Ma cos'и l'argomento di una funzione?

Argomenti delle funzioni
Esistono diversi tipi di funzione, alcune svolgono compiti che non hanno bisogno di ulteriori informazioni per essere ultimati:

{
//recupera la data attuale
global.data_di_oggi = date_current_date();

//distrugge l'istanza che chiama questo codice
instance_destroy();
}

Altre, invece, hanno bisogno di ulteriori informazioni, per procedere:

{
//calcola il quadrato di un numero
var numero, numero_al_quadrato;
numero = 4;
numero_al_quadrato = sqr(numero);
}

Nell'esempio qui sopra, la variabile numero viene passato alla funzione sqr() come argomento.
Quindi, esistono funzioni che non necessitano di argomenti, altre che ne attendono almeno uno, altre ancora che ne vogliono di piщ.

script = Funzione?
In GML ogni script puт essere considerato come una procedura o come una funzione.
Vediamo di fare un esempio che aiuti a comprendere questo concetto. Immaginiamo un gioco in cui tutti gli oggetti liberi di muoversi, se escono fuori schermo da destra ne rientrano da sinistra, se escono da sopra, rientrano da sotto e viceversa. Potremmo semplicemente mettere in step di tutti gli oggetti un piece of code che contenga queste istruzioni:

{
if x>room_width x=0;
if x<0 x=room_width;
if y>room_height y=0;
if y<0 y=room_height;
}

Ma quando gli oggetti sono molti, anche se si tratta di una procedura di sole 4 linee, и poco pratico riscrivere lo stesso piece of code per ogni oggetto che debba eseguirla. E se anche usassimo copia/incolla per far prima, qualora decidessimo di modificare questa norma, dovremmo rimettere mano nel codice di tutti gli oggetti... abbiamo perт un'alternativa: scrivere uno script, che chiameremo ad esempio uscite_di_schermo, che andremo a richiamare nel piece of code messo in step di tutti gli oggetti che devono seguire questa regola:

{
uscite_di_schermo();
}

I piщ attenti avranno certamente notato che il nome dello script и seguito da due parentesi, esattamente come si usa fare per le funzioni. Non и un caso... In Game Maker possiamo aggiungere le nostre funzioni semplicemente scrivendo degli script. Qualora fosse necessario passare degli argomenti alle nostre funzioni, lo possiamo fare senza problemi. L'unico limite и il numero di argomenti (16) che possiamo gestire. Vediamo di scrivere una funzione d'esempio... immaginiamo di voler rendere i nostri oggetti 'sensibili' alla distanza di altri oggetti, di modo che, se un istanza di un certo tipo d'oggetto si trovi piщ vicina di un tot succeda qualcosa (per il momento non occupiamoci di cosa!). Game Maker mette giа a disposizione una funzione con questo scopo, ma dobbiamo spiegare come si scrive una funzione e non mi и venuto in mente niente di meglio... creiamo un nuovo script chiamato controllo_distanza e scriviamo:

{
var n;
if distance_to_object(instance_nearest(argument0)) else n=0;
return n;
}

Vediamo di spiegare cosa c'и scritto: nella prima linea viene dichiarata una variabile locale. Nella seconda vengono chiamate due funzioni fornite con Game Maker. Se la distanza con l'istanza piщ vicina del tipo passato come primo argomento (argument0) и minore della distanza passata come secondo argomento (argument1), allora la variabile n diventa 1, altrimenti diventa 0. Se per esempio volessimo far autodistruggere un oggetto quando la sua distanza con un'altro di tipo 'mio_oggetto' scenda sotto ai 50 pixel, scriveremo:

{
if controllo_distanza(mio_oggetto, 50) instance_destroy();
}

E con questo abbiamo almeno introdotto il discorso funzioni.
Riassumendo, nella parte precedente abbiamo visto le istruzione per creare cicli o controllare il flusso del programma. Qui abbiamo visto, anche se in maniera un po approsimativa, cosa sono script, procedure e funzioni. Non ci resta che andare avanti e vedere qualche semplice programma in azione...

Due semplici giochi con GML
Se le due guide precedenti avevano l'esplicito scopo di fornire un'infarinatura del Game Maker Language, sono convinto che l'unico modo per comprendere a fondo come sfruttare al meglio questo linguaggio sia attraverso degli esempi concreti. Questo и vero a maggior ragione per chi non ha mai avuto esperienze di programmazione. Quindi, a seguire, ecco due semplici giochi, che magari non eccellono per qualitа, ma che sicuramente aiuteranno a comprendere meglio il linguaggio.
Lista Giochi
Mini-tutorial 1: Adatto ad essere il primo gioco in assoluto.
Mini-tutorial 2: Vediamo qualcosa di un po piщ complesso, ma senza esagerare...
Una volta compresi questi ultimi due mini tutorial dovreste essere in grado di comprendere il materiale nell'appendice 'Giochi completi passo per passo' senza problemi. Se tuttavia dovessero permanere dubbi od incertezze, potete sempre chiedere charimenti sul forum.

Esempio 1: array monodimensionali
Partendo dallo scheletro vuoto citato nell'indice degli esempi, vediamo di comprendere cosa sono e come si usano gli array.

L'array и la struttura dati piщ semplice di cui possiamo disporre e va immaginato come una sequenza di celle. Ogni cella equivale ad una variabile, e puт contenere valori numerici o stringhe. Ogni cella и identificata da un'indice.

Nell'esempio a seguire andremo ad utilizzare un array di stringhe al fine di visualizzare una scritta animata sullo schermo.

Apriamo il nostro scheletro vuoto e, nello script CREATE, scriviamo:

testo=get_string('Inserisci un testo', 'http://gm6guide.altervista.org');

n=string_length(testo);
for (i=0; i<=n; i+=1){

lettera[i]=string_copy(testo,i,1);

}

sx=room_width;
sy=room_height/2;
sf=0;

La prima linea acquisisce una stringa e la memorizza nella variabile 'testo'. Successivamente la lunghezza di questa stringa viene letta e memorizzata nella variabile 'n', che indicherа il numero di volte che verrа eseguito il ciclo for che riempie l'array 'lettera'. In poche parole: viene letta una lettera della stringa ed assegnata ad una cella dell'array.

Le ultime 3 linee settano la posizione di partenza della scritta e la 'fase' dell'oscillazione.

Ora occupiamoci dello script STEP:

sf+=5;
sx-=5;

if sf>360 sf=0;
if sx<-n*21 sx=room_width;

Qui bastano poche spiegazioni: la posizione X della scritta viene fatta scorrere da destra verso sinistra e quando и minore di zero, meno la lunghezza della stringa, torna al limite destro dello schermo. Fase, invece, compie un ciclo da 0 a 360.

Evento DRAW:

draw_set_color(c_white);
draw_set_font(font0);

for (i=1; i<=n; i+=1){

sy[i]=sy + sin(degtorad(sf-(i*5)))*100;
nx[i]=sx + i*20;
draw_text(nx[i], sy[i] ,string(lettera[i]));

}

Le prime due linee settano il colore ed il font in uso. Il ciclo for, ripetuto anch'esso 'n' volte, genera due nuovi array, contenenti le coordinate x ed y di ogni singola lettera, quindi le disegna estraendole una ad una dal nostro primo array 'lettera'.

Materiale correlato: l'editabile dell'esempio.

Esempio 2: posizione del mouse
Partendo dal solito scheletro vuoto, vediamo come si rileva la posizione del mouse.

Le coordinate X ed Y del mouse sono memorizzate nelle variabili interne mouse_x e mouse_y.

In questo esempio le andremo ad utilizzare al fine di visualizzare una sorta di mirino disegnato con le funzioni grafiche. Nel prossimo esempio utilizzeremo questa base di partenza per costruire un semplice menщ di scelta.

Apriamo il nostro scheletro vuoto e, nello script CREATE, scriviamo:

vy1=0;
vy2=room_height;
vx=0;
hx1=0;
hx2=room_width;
hy=0;

Vengono semplicemente inizializzate 6 variabili, che verranno in seguito utilizzate per tracciare delle linee.

Nello script STEP scriviamo:

vx=mouse_x;
hy=mouse_y;

Due delle sei variabili vengono aggiornate in base alla posizione attuale del mouse.

Evento DRAW:

draw_line(vx,vy1,vx,vy2);
draw_line(hx1,hy,hx2,hy);
draw_rectangle(mouse_x-16,mouse_y-16,mouse_x+16,mouse_y+16,1);

mx=string(mouse_x);
my=string(mouse_y);
draw_text(5,5,'Mouse (' + mx + ',' + my + ')' );

Le prime due righe di codice tracciano 2 linee che si spostano in funzione del movimento del mouse. La terza richa traccia un quadrato che ha il centro nella posizione attuale del mouse. Il resto del codice si occupa di scrivere a schermo la posizione del mouse.

Materiale correlato: l'editabile dell'esempio.

Esempio 3: posizione del mouse
Partendo dall'esempio precedente andiamo a creare un semplice menщ di scelta.

Andiamo a modificare CREATE, aggiungendo:

cont=0;

Questa nuova variabile verrа utilizzata per visualizzare un contatore, in veritа privo di alcuna funzione pratica...

In STEP aggiungiamo:

cont+=1;
if cont>999999 cont=0;

Sempre per lo stesso inutile contatore...

Ed in DRAW:

cnt=string(cont);
while string_length(cnt)<6 cnt='0'+cnt;
draw_text(room_width-52, 5, cnt);

Anche questa parte и relativa al contatore, ma и abbastanza interessante da parlarne: il numero raggiunto dal contatore viene convertito in stringa per poterlo visualizzare. A questo punto, se il numero и composto da meno di 6 cifre, davanti alla stringa vengono aggiunti tanti zeri quanti ne servono per visualizzare sempre 6 cifre.

Ora viene la parte interessante. Creiamo altri 2 oggetti, chiamati 'pulsante1' e 'pulsante2', che rispondano agli stessi eventi CREATE, STEP, DRAW... a questo punto aggiungiamo 6 script: p1_CREATE, p1_STEP, p1_DRAW, p2_CREATE, p2_STEP e p2_DRAW.

p1_CREATE:

x=room_width/2;
mouse_over=0;

p1_STEP:

if mouse_x>x-150 && mouse_xy-25 && mouse_yelse mouse_over=0;

p1_DRAW:

if mouse_over=1 {
draw_rectangle(x-150,y-25,x+150,y+25,0);
draw_set_color(c_black);
if mouse_check_button(mb_left) {
draw_text(x-100,y-5,'Hai scelto questa opzione!');
}
else draw_text(x-50,y-5,'Mouse_over=1');
}
else {
draw_rectangle(x-150,y-25,x+150,y+25,1);
draw_text(x-50,y-5,'Mouse_over=0');
}

p2_CREATE:

x=room_width-75;
y=room_height-40;
mouse_over=0;

p2_STEP:

if mouse_x>x-50 && mouse_xy-15 && mouse_yelse mouse_over=0;

p2_DRAW:

if mouse_over=1 {
draw_rectangle(x-50,y-15,x+50,y+15,0);
draw_set_color(c_black);
if mouse_check_button(mb_left) {
game_end();
}
else draw_text(x-25,y-5,'Uscita');
}
else {
draw_rectangle(x-50,y-15,x+50,y+15,1);
draw_text(x-25,y-5,'Uscita');
}

Ora, attribuite i vari script ai relativi eventi di pulsante1 e pulsante2. Aprite la room ed inserite 2 o 3 pulsante1 ed 1 pulsante2 e provate ad eseguire.

Esempio 4: funzioni grafiche di base
Game Maker mette a disposizione diverse funzioni di disegno e di manipolazione grafica. Iniziamo a vedere le piщ semplici e versatili.

Prendiamo il solito scheletro vuoto ed editiamo i vari script.

CREATE:

forma=0;

Questa variabile ci permetterа di cambiare la forma visualizzata.

STEP:

if keyboard_check_released(vk_space) forma+=1;
if forma>4 forma=0;

Al rilascio della barra spaziatrice cambierа l'immagine mostrata. Evento DRAW:

switch (forma){

case 0:
draw_circle_color(320,240,160,c_red,c_blue,0);
exit;

case 1:
draw_rectangle_color(160,120,480,360,c_blue,c_red,c_yellow,c_olive,0);
exit;

case 2:
draw_triangle_color(320,60,100,400,540,400,c_blue,c_red,c_green,0);
exit;

case 3:
draw_ellipse_color(160,120,480,360,c_blue,c_yellow,0);
exit;

case 4:
draw_primitive_begin(pr_trianglestrip);
draw_vertex_color(320,90,c_red,1);
draw_vertex_color(478,204,c_blue,1);
draw_vertex_color(417,390,c_yellow,1);
draw_vertex_color(222,390,c_purple,1);
draw_vertex_color(161,204,c_red,1);
draw_vertex_color(320,90,c_blue,1);
draw_vertex_color(357,204,c_yellow,1);
draw_primitive_end();
exit;
}


Quando la variabile 'forma' assume un valore compreso tra 0 e 3 vengono disegnate le forme base piщ elementari: cerchio, rettangolo, triangolo ed elisse. Quando forma=4 viene utilizzata una funzione grafica poco piщ complessa e decisamente piщ versatile: draw_primitive permette di generare un poligono specificando la posizione dei suoi vertici. Puт lavorare in modi diversi: pr_pointlist, ovvero specificando una lista di punti scollegati tra loro; pr_linelist, in cui i vertici, a coppie, definiscono delle linee; pr_linestrip, in cui i vertici descrivono delle linee concatenate tra loro; pr_trianglelist, in cui i vertici, a terne, descrivono dei triangoli; pr_trianglestrip, quello che ho usato nell'esempio, in cui la prima terna descrive un triangolo, il terzo vertice un'altro triangolo che ha 2 punti in comune col precedente e via discorrendo. In seguito vedremo come grazie a queste funzioni si possono disegnare anche elementi complessi e come si possono utilizzare in un gioco.

Esempio 5: Background generato da script
In alcuni casi conviene usare meno immagini possibili e generare i nostri fondali con le funzioni di disegno di Game Maker. Questo vale, soprattutto, quando dobbiamo contenere le dimensioni dell'eseguibile, oppure quando abbiamo bisogno di poter modificare certi aspetti del fondale...

Prendiamo il solito scheletro vuoto e, per prima cosa, impostiamo la depth di object0 molto alta, attorno a 10000. Questo garantirа che nessun oggetto rimmarrа nascosto da quelli da noi disegnati.

CREATE:

//colori
azz=make_color_rgb(0,180,210);
ver=make_color_rgb(50,100,20);
mar=make_color_rgb(90,70,0);

//gradienti
cielo=background_create_gradient(room_width, room_height,azz,c_white,1,1);
background_index[0] = cielo;

Come si intuisce dai commenti, le prime 3 linee di codice generano i colori usati nella scena, mentre le restanti due linee creano un background come gradiente e lo attribuiscono a quello visibile (assicuratevi che il bg 0 sia indicato come 'visible when room start' dalle proprietа della room).

Evento DRAW:

//colline
draw_set_color(ver);
draw_ellipse(-room_width/3,room_height/4*3,room_width/2,room_height*1.5,0);
draw_ellipse(room_width/4,room_height/4*3,room_width*0.75,room_height*1.5,0);
draw_ellipse(room_width/2,room_height/4*3,room_width+room_width/3,room_height*1.5
,0);

//primo piano
draw_rectangle_color(0,room_height-room_height/6,room_width,room_height,ver,ver
,mar,mar,0);

Quando la variabile 'forma' assume un valore compreso tra 0 e 3 vengono disegnate le forme base piщ elementari: cerchio, rettangolo, triangolo ed elisse. Quando forma=4 viene utilizzata una funzione grafica poco piщ complessa e decisamente piщ versatile: draw_primitive permette di generare un poligono specificando la posizione dei suoi vertici. Puт lavorare in modi diversi: pr_pointlist, ovvero specificando una lista di punti scollegati tra loro; pr_linelist, in cui i vertici, a coppie, definiscono delle linee; pr_linestrip, in cui i vertici descrivono delle linee concatenate tra loro; pr_trianglelist, in cui i vertici, a terne, descrivono dei triangoli; pr_trianglestrip, quello che ho usato nell'esempio, in cui la prima terna descrive un triangolo, il terzo vertice un'altro triangolo che ha 2 punti in comune col precedente e via discorrendo. In seguito vedremo come grazie a queste funzioni si possono disegnare anche elementi complessi e come si possono utilizzare in un gioco.

Esempio 6: oggetto global
Capita sovente di dover gestire variabili uguali in istanze differenti. Il metodo piщ semplice per affrontare questo problema и rendere le variabili globali. Per rendere il tutto piщ semplice, partiamo con l'aesmpio, che questa volta porta alla realizzazione di un gioco (quasi) completo.

Prendiamo il solito scheletro vuoto ed attuiamo le seguenti modifiche: aggiungiamo uno sprite (io ho usato un 'dischetto' di 20px di diametro) ed attribuiamolo ad object0. Creiamo un secondo oggetto, lo chiamiamo object1, e gli conferiamo lo stesso sprite.

Ed ora editiamo i vari script. CREATE:

//inizializza posizione, direzione, velocitа
x=room_width/2;
y=room_height/2;
direction=0;
speed=5;

//inizializza il conteggio dei segmenti
global.parte[0]=id;
global.totale=0;

//genera i primi 10 segmenti
repeat (10) add_seg();

Le prime 4 linee determinano posizione, direzione e velocitа del nostro oggetto. La quinta linea inizia a scrivere l'ID dell'istanza in uso all'indice zero di un'array globale. La quinta inizializza un'altra variabile globale. L'ultima linea esegue 10 volte uno script che ancora non abbiamo...

STEP:

if keyboard_check(vk_up) direction=90;
if keyboard_check(vk_down) direction=270;
if keyboard_check(vk_left) direction=180;
if keyboard_check(vk_right) direction=0;

//nel demo aggiungo un pezzo su pressione della barra
if keyboard_check(vk_space) add_seg();


//aggiorna la posizione di tutti i segmenti
with object1 {
x=global.parte[numero-1].xprevious;
y=global.parte[numero-1].yprevious;
}

Anche qui le prime 4 linee sono riferite al movimento dell'oggetto. La quinta linea aggiunge una nuova istanza, tramite l'esecuzione di quello script che ancora non abbiamo, su pressione della barra spaziatrice L'ultimo blocco legge le variabili globali per posizionare le varie istanze di object1. Per comprenderne appieno il funzionamento и necessario prima vedere il contenuto di add_seg(), quindi, ancora un po di pazienza! Evento DRAW:

draw_sprite(sprite0,-1,x,y);
draw_set_color(c_green);
draw_text(20,20,"Premere spazio per allungare il serpente");

La prima linea disegna lo sprite (necessaria in quanto l'oggetto и munito di evento draw). Le altre 2 linee scrivono solo un messaggio a schermo... se volete potete togliere questo script, a patto di togliere tutto l'evento draw... ed ora, aggiungiamo uno script che chiamiamo add_seg.

add_seg:

segmento=instance_create(x,y,object1);
segmento.numero=global.totale+1;
global.totale+=1;
global.parte[global.totale]=segmento;

Crea una nuova istanza di object1 attribuendogli l'etichetta di segmento. Quindi crea una variabile 'numero' propria di segmento, e le assegna come valore global.totale+1. A questo punto aggiunge l'id di 'segmento' all' array globale 'parte', all'indice totale.

In poche parole, l'array 'parte' contiene l'id di tutte le istanze di object1, e queste sono dotate di numero di serie... quindi, rileggendo l'ultimo blocco di STEP: le coordinate x ed y, sono le coordinate che l'oggetto col numero di serie precedente aveva nello step precedente (previous).

Esempio 7: macchina a stati
La macchina a stati rappresenta la forma minima di Intelligenza Artificiale ( IA ). Per spiegare di cosa si tratta e come lavora mi servirт di un gioco d'esempio giа fatto, di poco piщ complesso del solito. Quindi, per prima cosa, scaricare l'editabile dell'esempio.

Vediamo di descrivere come funziona il gioco, dove interviene la macchina a stati e come lavora. In questo gioco, il giocatore gestisce un veicolo, mentre il computer ne gestisce un'altro. Lo scopo del gioco и costringere il nemico a cadere nel buco al centro dello schermo.

Mentre la parte relativa al veicolo gestito dal giocatore и molto semplice (semplice controllo da tastiera e delle collisoni), la gestione del nemico deve adattarsi alle diverse circostanze. E' in questo frangente che interviene la macchina a stati: nel determinare cosa sta accadendo ed adattare il comportamento del nemico.

E' quello che accade nella maggior parte dei giochi in cui le difficoltа sono rappresentate da oggetti dinamici e non semplici automi che seguono un percorso prestabilito.

Per semplicitа, nell'esempio, sono state considerate solo due condizioni, basate su un'unico fattore: in base alla distanza tra nemico e giocatore, il nemico puт essere in stato di 'pattugliamento' o in stato di 'ingaggio'.

Quando si trova nel primo stato, non farа altro che eseguire ciclicamente un blocco d'istruzioni che lo porteranno ad esplorare l'area di gioco. Contemporaneamente verrа eseguito un controllo sulla condizione che determina lo stato attuale... quando questa condizione, verrа modificato lo stato...

Nel secondo stato (ingaggio), il nemico aggiusterа la direzione fino a puntare nella direzione del giocatore, quindi inizierа a seguirlo, finchи sarа vera la condizione che ne determina lo stato o finchи il gioco non avrа termine (caduta del nemico nel buco...).

Naturalmente, per rendere il gioco piщ interessante o per eliminare certe imperfezioni di comportamento, и possibile prevedere piщ stati ai quali corrispondano azioni differenti.

Esempio 8: Selezione e comando di un'unitа
Esiste un'ampia schiera di giochi, come gli RTS e gli RPG, in cui il giocatore puт o deve gestire piщ di un'unitа.

In questo esempio vedremo come realizzare una primitiva ma funzionale area di selezione. Prendiamo il solito scheletro vuoto ed editiamo gli script.

CREATE:

//coordinate dell'area di selezione
mx1=0;
mx2=0;
my1=0;
my2=0;

Questi valori saranno utilizzati per rilevare l'area di selezione e determinare se un'oggetto si trova al suo interno oppure no.

STEP:

//inizio area di selezione
if mouse_check_button_pressed(mb_left){

mx1=mouse_x;
my1=mouse_y;

}

//fine area di selezione
if mouse_check_button(mb_left){

mx2=mouse_x;
my2=mouse_y;

}

Com'и piuttosto evidente, questo script attribuisce alle variabili inizializzate in CREATE i valori che mouse_x e mouse_y assumono in due momenti ben precisi: quando si preme il pulsante sinistro vuol dire che iniziamo a selezionare, finchи teniamo premuto vuol dire che stiamo ancora selezionando, per cui avremo il punto d'inizio e quello finale di un'area di selezione....

DRAW:

//scrive le coordinate
draw_text(20,20,'area: '+ string(mx1)+','+ string(my1)+','+ string(mx2)+','+
string(my2));

//disegna l'area di selezione
if mouse_check_button(mb_left) draw_rectangle(mx1,my1,mx2,my2,1);

//scrive lo stato di obj1 e ob2
draw_text(320,20, 'obj1: ' + string(obj1.sele)+', obj2: '+ string(obj2.sele));

In quest'esempio l'evento draw и in parte facoltativo e viene usato per disegnare l'area di selezione, scrivere a schermo le sue coordinate e lo stato di due oggetti che ora andremo ad inserire... Creiamo quindi due oggetti, che chiamiamo obj1 ed obj2, dotati dell'evento create e dell'evento step. In entrambi metteremo in create un piece of code:

CREATE:

tipo=1;
sele=0;

Notare che la variabile tipo NON verrа utilizzata in questo esempio, e servirа in futuro a distinguere un oggetto dall'altro. Quindi scriveremo tipo=1 in obj1 e tipo=2 in obj2, per impieghi futuri. Ora aggiungiamo un nuovo script che io ho chiamato ctrl_selezione(), e lo facciamo eseguire in step di entrambo gli oggetti: ctrl_selezione:

//seleziona
if x>object0.mx1 && y>object0.my1{

if x

}

//deseleziona
if mouse_check_button_pressed(mb_right) {

object0.mx1=0;
object0.mx2=0;
object0.my1=0;
object0.my2=0;
sele=0;

}

In questo modo и possibile attivare o disattivare un oggetto in funzione della variabile sele. Ora immaginiamo, ma lo vedremo in seguito, che in step di ogni oggetto sia presente una funzione di motion planing, eseguita solo se sele=1... Ma questo sarа argomento di un'altro esempio, per ora ho detto anche troppo...

Esempio 9: Homming Missile
In questo esempio vedremo come realizzare un missile ad inseguimento del bersaglio. Nell'editabile dell'esempio sono presenti 4 oggetti: una "torretta" che lancia i missili, 2 tipi di nemico e l'homming missile.

La torretta и dotata degli script minimi per muoversi, sparare e generare i nemici. I nemici sono dotati di script minimi di movimento. Il tipo nemico2 и parent di nemico, in modo da essere trattato alla pari dall'homming missile.

Tutto quello che ci interessa и appunto nell'homming missile:

CREATE:

speed=10;
bersaglio=instance_nearest(x,y,nemico);


Alla sua creazione, l'id dell'istanza nemico piщ vicina, viene passato alla variabile bersaglio.

STEP:

if instance_exists(bersaglio){

image_angle = point_direction(x, y, bersaglio.x, bersaglio.y);
mp_potential_step(bersaglio.x, bersaglio.y, speed, 0);

}

else bersaglio=instance_nearest(x,y,nemico);


Ad ogni ciclo viene verificata l'esistenza dell'istanza bersaglio. Se esiste le sue coordinate vengono utilizzate per il motion planning. Altrimenti viene cercata un'altra istanza nemico ed utilizzata come nuovo bersaglio.

Esempio 9: Terreno distruggibile
In alcuni giochi (e presto ne vedremo un esempio), и necessario modificare la forma del terreno a seguito delle azioni compiute dal giocatore. Esiste piщ di un sistema per ottenere questo risultato. Quello che vado a proporre и uno dei piщ semplici immaginabili, pur mantenendo una discreta funzionalitа.

Questo esempio non usa il consueto scheletro: basa il suo funzionamento su due soli oggetti piuttosto semplici, l'oggetto terrain e l'oggetto shot.

L'oggetto terrain
L'intero terreno и un unico oggetto, dotato di uno sprite ne che rappresenta l'andamento (le variazioni d'altezza).

N.B.: la room di questo esempio и di 320x240 pixel, quindi и possibile usare un solo oggetto per il terreno. Per dimensioni maggiori и consigliabile usare piщ di un oggetto, per evitare il rischio di possibili rallentamenti.

Alla creazione, l'oggetto terrain genera un gradiente e lo imposta come background.

CREATE:

//crea due colori
col1=make_color_rgb(30,30,100);
col2=make_color_rgb(140,180,200);

//li usa per generare un gradiente
bg_grad=background_create_gradient(room_width,room_height,col1,col2,1,0);

//che usa come fondale
background_index[0]=bg_grad;

In step, su pressione della barra spaziatrice, se non esistono istanze dell'oggetto shot, ne crea una in posizione casuale nella parte alta dello schermo.

STEP:

if keyboard_check(vk_space){
if instance_number(shot)<1{
instance_create(50+random(room_width-100),0, shot);
}
}

La funzionalitа di terrain finisce qui. Il lavoro vero e proprio viene effettuato dall'oggetto shot.

L'oggetto shot
Alla sua creazione (quando premiamo la barra spaziatrice), vengono impostate due variabili: la gravitа ed una variabile di controllo.

CREATE:

gravity=1;
explode=0;

Quando l'istanza viene creata, inizia a precipitare verso il terreno. Quando la tocca, si arresta, viene modificata la variabile di controllo e disabilitata la visualizzazione del gradiente, sostituito con un bel nero uniforme.

COLLISIONE:

speed=0;
explode=1;

background_index[0]=background_color;

La modifica del terreno vera e propria avviene nell'evento DRAW dell'oggetto shot. Qui, in base allo stato della variabile di controllo, avremo due comportamenti diversi:

DRAW:

if explode=0 draw_sprite(sprite0,0,x,y);

else {
draw_circle(x,y,20,0);
new_terrain=sprite_create_from_screen(0,0,320,240,1,1,0,0,0,0);

terrain.sprite_index=new_terrain;

background_index[0]=terrain.bg_grad;

instance_destroy();
screen_redraw();
}

Se non c'и stata collisione, l'oggetto mostrerа semplicemente il suo sprite.
Qualora, invece, entri in collisione, explode diventerа 1. Verrа dunque disegnato un cerchio pieno, del colore del background, con centro nel punto di collisione. Verrа chiamata la funzione sprite_create_from_screen(), in modo da catturare l'intera schermata e creare uno sprite trasparente che sarа etichettato come new_terrain, dopodichи questo andrа a sostituire lo sprite del terreno, verrа riabilitata la visualizzazione del gradiente e lo schermo ridisegnato. Quest'ultima operazione non и indispensabile, verrebbe comunque ridisegnato allo step sucessivo, ma si vedrebbe un leggero sfarfallio dell'immagine.

Nota finale: se ricordate il metodo con cui Game Maker attribuisce la trasparenza di uno sprite, allora avrete giа notato che l'angolo inferiore sinistro del nostro terreno, per un'area di 1x1 pixel и trasparente. Se questo fosse un problema, и sempre possibile nasconderlo con un puntino del colore del terreno limitrofo, ricordandosi di non mostrarlo quando lo schermo viene ricatturato!

Esempio 11: Creazione di oggetti nel periodo di run-time
Durante l'esecuzione di un gioco o di un programma, abitualmente, manipoliamo le caratteristiche di oggetti esistenti, cioи inseriti tra le risorse di gioco attraverso l'editor di oggetti. Tuttavia, in certi casi, potrebbe far comodo creare nuovi oggetti al volo, durante il periodo d'esecuzione (run-time). I motivi possono essere diversi: per ottimizzare l'esecuzione, dato che alcuni oggetti esisteranno solo quando serviranno realmente; oppure per semplificare e velocizzare la realizzazione, dato che alcuni oggetti 'ridondanti' possono essere generati attraverso procedure automatiche, invece che manualmente.

Questo esempio pone un caso banale, facilmente risolvibile con altre tecniche, ma utile ad inquadrare il sistema di generazione degli oggetti. Andremo a realizzare un effetto scia, formata dalla ripetizione dello sprite dell'oggetto stesso che man mano si dissolve. La scia, sarа quindi composta di istanze di un'oggetto creato al volo, impostate con lo stesso sprite dell'oggetto che le crea, che aumentano gradualmente la loro trasparenza e quindi si distruggono.

Il sistema si basa su due semplici script: scia_create(), che andrа messo nell'evento create di ogni oggetto che dovrа essere dotato di scia, e scia_step(), che andrа nello step degli stessi oggetti.

scia_create: la definizione dell'oggetto.
Adiamo ad aggiungere uno script e lo chiamiamo scia_create. Al suo interno sarа definito il nome dell'oggetto ed il codice che questo eseguirа alla crezione (evento create) e ad ogni step (evento step).

//argument0: nome oggetto
//argument1: duarata scia in step

global.argument0 = object_add();

create_code = "durata="+string(argument1)+";";
step_code = "durata-=1; if durata<1 instance_destroy(); else image_alpha-=1/durata;";

object_event_add(global.argument0,ev_create,0,create_code);
object_event_add(global.argument0,ev_step,1,step_code);


Le prime due linee sono commentate e rappresentano un promemoria sul funzionamento dello script.

La terza linea crea un oggetto e lo chiama col nome passato allo script come primo argomento. creation_code e step_code sono due stringhe che contengono il codice eseguito da questo oggetto all'evento create e all'evento step. Faccio notare che sarebbe stato possibile passare queste stringhe come argomento di funzione, generalizzando maggiormente l'impiego dello script stesso, ma alla creazione di ogni oggetto bisogna prevederne lo scopo, e strutturando cosм lo script dovrebbe essere piщ semplice comprenderne il funzionamento.

Nella quarta linea viene generato il codice per l'evento create in base a quanto passato da argument1.

Nella sesta e nella settima linea, i due pezzi di codice vengono abbinati ai relatvi eventi.

Una volta eseguito questo codice, verrа quindi creato un nuovo oggetto pronto a soddisfare le nostre esigenze. Vediamo, ora, di creare le istanze di questo oggetto quando necessario.

scia_step: le istanze dell'oggetto creato.
Adiamo ad aggiungere uno script e lo chiamiamo scia_step. Questo attende un solo argomento: il nome dell'oggetto. E' importante che questo sia uguale a quello dato alla creazione dell'oggetto, nello script precedente.

//argument0: nome scia

var nnn;
nnn=instance_create(x,y,global.argument0);
nnn.sprite_index=sprite_index;

http://nnn.image_speed=0;
http://nnn.image_index=image_index;


Questo script и talmente semplice che non dovrei neppure spiegarlo, ma giа che ci siamo... Non fa altro che creare un'istanza del nostro oggetto alla posizione attuale dell'oggetto chiamante, attribuendogli come sprite quello attualmente in uso. Le ultime linee sono commentate perchи, in caso di sprite animati, si potrebbe desiderare che la scia esegua l'animazione dall'inizio (senza usare quelle linee), oppure mostri solo il fotogramma attuale (togliendo i commenti), generando una sorta di effetto stroboscopico.

L'esempio al lavoro.
Per verificare la funzionalitа del sistema и sufficiente creare un oggetto, attribuirgli uno sprite qualsiasi, e far eseguire i due script negli eventi opportuni. Naturalmente, per vedere la scia, l'oggetto in questione dovrа essere mobile.

I Platform Games
Uno dei generi piщ classici di videogioco и senza dubbio il platform. In questo genere di gioco, il personaggio gestito dal giocatore si muove in un ambiente diviso in piani posti a differente altezza. Questi piani prendono il nome di piattaforme (platform, appunto). Le piattaforme possono avere caratteristiche diverse, ma per ora le possiamo suddividere in poche grandi famiglie: possono essere solide, mobili o attraversabili. Oltre al giocatore, altri oggetti devono potersi muovere su o tra di esse.

La struttura di base
Esistono diversi modi di gestire le collisioni tra il giocatore (e gli altri oggetti mobili) con le piattaforme. Da qui in avanti vedremo alcuni sistemi, partendo da quelli meno sofisticati fino ad arrivare a quelli piщ complessi. Prendiamo in esame l'immagine qui sotto: la pallina rappresenta il nostro giocatore, i vari blocchi rossi le piattaforme.



Volendo attribuire alla nostra pallina la capacitа di cadere e feramrsi a contatto della piattaforma, la doteremo dei seguenti script nei relativi eventi:

STEP:

if place_free(x,y+1){
gravity=.5;
}
else gravity=0;

//limite di velocitа
if vspeed>10 then vspeed=10;

Molto semplicemente, se sotto alla pallina non vi sono oggetti, viene applicata una piccola gravitа.

COLLISIONE COI BLOCCHI:

move_contact_solid(270,0);
vspeed=0;

Quando tocca un blocco la vspeed viene azzerata e la posizione spostata a contatto del blocco...

Quindi, и estremamente semplice gestire le collisioni... od almeno sembra! Vediamo perchи questo metodo non и adatto a quasi nessun tipo di gioco. Prima di tutto, non esiste un controllo di direzione della collisione: la pallina si comporterа alla stessa maniera sia che cada su una piattaforma, sia che la tocchi lateralmente, sia che salti dal basso e tocchi la piattaforma da sotto. In secondo luogo, con questo sistema, non и possibile gestire le collisioni con le piattaforme mobili o con qualsiasi altro oggetto di gioco...

Nel prossimo capitolo vedremo come ovviare ad alcuni di questi problemi.

Platform: collisione verso il basso
Come anticipato nel capitolo precedente, in questo genere di gioco и essenziale distinguere da quale parte gli oggetti collidono con lo scenario e tra di loro. Iniziamo quindi a costruire un box di collisione formato da diverse linee, ciascuna delle quali si occuperа di rilevare una sola direzione di collisione. Prendiamo in esame l'immagine qui sotto.



Come nel demo del capitolo precedente abbiamo solo due oggetti in gioco: player e block.
Block и un elemento solido privo di script. In questo capitolo, player verrа reso sensibile solo alla collisione verso il basso.
Per farlo mi servirт della funzione collision_line, che in questo caso attiverа direttamente la gravitа.
STEP:

var cl_x1,cl_x2,cl_y;
cl_x1=x-10;
cl_x2=x+10;
cl_y=y+30+vspeed;


if !collision_line(cl_x1,cl_y,cl_x2,cl_y,block,0,1){
if vspeed<10 vspeed+=1;
}

else vspeed=0;


Vediamo come funziona questo script.
All'inizio vengono dichiarate tre variabili locali, usate per posizionare la linea di collisione sotto a player, ma mentre cl_x1 e cl_x2 sono rigidamente legate alla coordinata x dello sprite, cl_y NON si troverа sempre esattamente sotto allo sprite. Lo precederа sempre nel suo movimento verso il basso perchи la sua distanza и legata anche alla velocitа verticale.

Al difuori di questo, il comportamento rimane simile a quello del demo del capitolo scorso: quando la linea di collisione tocca coi blocchi, la vspeed viene azzerata. Va notato che, quando questo avviene, lo sprite non и ancora realmente a contatto, ma sarа ad una distanza pari a vspeed. Quindi, nello step sucessivo, la distanza tra la collision line e lo sprite sarа azzerata e ricomincerа la caduta verso il basso. Questo procedimento, adatto solo a modeste velocitа verticali, permette di evitare di dover riposizionare lo sprite a contatto coi blocchi.

Ha tuttavia il difetto di generare una fastidiosa scattositа del moto di caduta quando la vspeed diventa notevole: immaginate una distanza dai blocchi di 50 pixel ed una vspeed=50. Ci sarа un primo moto d'arresto, perchи la linea di collisione tocca. Ricomincerа la caduta, ma a breve avremo un'altro arresto ed una nuova ricaduta.

Nel prossimo capitolo vedremo come neutralizzare questo difetto e risolvere definitivamente la collisione verso il basso.

Platform: completiamo la collisione verso il basso
In questo breve capitolo le modifiche apportate al nostro controllo di collisione saranno limitate all'aggiunta di una sola funzione. Ricordate il problema degli scatti durante la discesa? Ne rispiego brevemente la causa: la linea di collisione non si trova esattamente ai piedi dello sprite, ma ad una distanza da questi pari a vspeed. Questo per evitare errori di collisione in caso la distanza tra lo sprite e la piattaforma fosse minore di vspeed stessa.



Andiamo quindi a modificare lo script in step del player come segue:

STEP:

var cl_x1,cl_x2,cl_y;
cl_x1=x-10;
cl_x2=x+10;
cl_y=y+30+vspeed;

if !collision_line(cl_x1,cl_y,cl_x2,cl_y,block,0,0){
if vspeed<10 vspeed+=1;
}

else {
move_contact_all(270, -1);
vspeed=0;
CONTATTO=1;
}


Facendo un confronto noterete che le differenze con la versione precedente sono solo 2, entrambe nel blocco else.
Quando la linea di collisione tocca un blocco, per prima cosa viene eseguita la funzione move_contact_all().

Questa funzione attende due argomenti: direzione (in gradi) e distanza (in pixel). Il valore negativo -1 indica una distanza infinita, ovvero da qualsiasi distanza muove a contatto immediatamente. Tornando all'esempio citato in chiusura del capitolo precedente, se lo sprite fosse a 50 pixel di distanza dalla piattaforma, con una vspeed=50, la linea di collisione sarebbe a contatto e lo sprite verebbe immediatamente posto a contatto col blocco sottostante. Fine degli scatti in caduta, ed un'altro piccolo vantaggio: l'impressione di un'accelerazione ancora migliore.

La seconda differenza и la presenza della variabile CONTATTO. Questa per il momento ignoratela, serve solo nel gruppo comandi per abilitare la possibilitа di saltare. Il suo impiego и visibile nel demo allegato a questa pagina, in cui si mostra anche un primitivo gruppo di controlli.

Nel prossimo capitolo implementeremo le altre linee di collisione.

Platform: box di collisione completo
Partendo da quanto visto nei capitoli precedenti, и giunto il momento di concludere il box di collisione per il nostro personaggio. Nel demo di questo capitolo и stata implementata, oltre alle quattro linee di collisione indispensabili, anche una quinta linea (vedere figura sotto) per semplificare il riconoscimento degli scalini su cui и possibile salire.



Naturalmente il controllo di collisione diventa decisamente piщ corposo:

STEP:

//collisione sotto
var cld_x1,cld_x2,cld_y;
cld_x1=x-5;
cld_x2=x+5;
cld_y=y+30+vspeed;

if !collision_line(cld_x1,cld_y,cld_x2,cld_y,block,0,0){
if vspeed<10 vspeed+=1;
}

else {
move_contact_all(270, -1);
vspeed=0;
CONTATTO=1;
}

//collisione sopra
var clu_x1,clu_x2,clu_y;
clu_x1=x-13;
clu_x2=x+13;
clu_y=y-30+vspeed;

if collision_line(clu_x1,clu_y,clu_x2,clu_y,block,0,0){
/*move_contact_all(270, 1);*/
vspeed*=0.5;
}

//collisione sinistra
var cll_x,cll_y1,cll_y2;
cll_x=x-15-abs(hspeed);
cll_y1=y+8//+abs(hspeed);
cll_y2=y-28//-abs(hspeed);

if collision_line(cll_x,cll_y1,cll_x,cll_y2,block,0,0){
move_contact_all(0, 6);
hspeed=0;
}

//collisione destra
var clr_x,clr_y1,clr_y2;
clr_x=x+15+abs(hspeed);
clr_y1=y+8//+abs(hspeed);
clr_y2=y-28//-abs(hspeed);

if collision_line(clr_x,clr_y1,clr_x,clr_y2,block,0,0){
move_contact_all(180, 6);
hspeed=0;
}

//tastatore gradini
var clg_x1,clg_x2,clg_y;
clg_x1=x-8;
clg_x2=x+8;
clg_y=y+27+vspeed;

if collision_line(clg_x1,clg_y,clg_x2,clg_y,block,0,0) y-=20;



Come potete notare, le linee laterali si comportano in modo simile alla prima, quella sopra agisce solo sulla vspeed, senza riposizionare a contatto, mentre il tastatore degli scalini, in maniera piuttosto ingenua, applica solo una traslazione verso l'alto. Per prevenire eventuali malfunzionamenti, sarebbe opportuno aggiungere un controllo supplementare per impedire di superare ostacoli di una data altezza... ma lo scopo di questa guida и solo quello di mostrare il metodo.

Nel prossimo capitolo vedremo un gioco completo a livello di esempio.

Platform: un gioco ad esempio
Questo sarа un capitolo d'intermezzo, non aggiungerа nulla di nuovo, ma permetterа di vedere in azione gli script visti fin ora (solo leggermente ritoccati), in un gioco completo e funzionante. Obiettivo del capitolo и mostrare come, se non si presta suffciente attenzione nelle parti preliminari, sai facile trovarsi diffronte a bug che richiederebbero una riscrittura pressochи completa del codice per essere eliminati, o, come invece ho fatto io, una infinita serie di (scusate il tecnicismo) tappugli*.

The Prison




Come potrete vedere frugando nell'editabile, il gioco и mosso da 6 script principali e da qualche 'piece of code' negli oggetti secondari. Gli script principali sono richiamati dall'oggetto player, all'interno dello script player_step:

gravit(GRAV_DIR);
collisione();

if SPLAT=0 && BOOM=0 && BURN=0 { comandi();}

if SPLAT=1 {
sprite_index=sp_splat;
if image_index<8 image_index+=1;
else {
if keyboard_check(vk_anykey) room_restart();
}
}

if BOOM=1 {
sprite_index=sp_boom;
if image_index<8 image_index+=1;
else {
if keyboard_check(vk_anykey) room_restart();
}
}

if BURN=1 {
sprite_index=sp_burn;
if image_index<11 image_index+=1;
else {
if keyboard_check(vk_anykey) room_restart();
}
}

if y>room_height+600 room_restart();


Come potete vedere, due di questi, gravitа e collisione, giа visti in precedenza, vengono eseguiti ad ogni step, mentre lo script comandi() non viene eseguito nei tre casi di 'morte' possibili: SPLAT, BOOM e BURN. Il gruppo comandi() и sede della maggior parte dei bug:

if keyboard_check(vk_left) {
image_xscale=-1;
if hspeed>-5 hspeed-=1;
if CONTATTO=1 {
sprite_index=sp_player_run;
image_index+=0.75;
}
else {
sprite_index=sp_player_jump;
image_index=3;
}
}
if keyboard_check(vk_right) {
image_xscale=1;
if hspeed<5 hspeed+=1;
if CONTATTO=1 {
sprite_index=sp_player_run;
image_index+=0.75;
}
else {
sprite_index=sp_player_jump;
image_index=3;
}
}

if keyboard_check_pressed(vk_space) {
sprite_index=sp_player_jump;
if image_index<3 image_index+=1;

if CONTATTO=1 {
CONTATTO=0;
vspeed=-10;
}
}

if keyboard_check(vk_nokey) {
if CONTATTO=1 {
sprite_index=sp_player_stop;
if hspeed<>0 image_index=1;
else image_index=0;
}
else {
sprite_index=sp_player_jump;
image_index=3;
}
}

if SIDE_COL=1 && CONTATTO=0 {

if keyboard_check(vk_up) {
sprite_index=sp_slide;
vspeed=2;
if keyboard_check_pressed(vk_space) jump();
}

}

if keyboard_check(ord('R')) room_restart();
if keyboard_check(vk_escape) room_goto(menu);

Non prendendo in esame tutte le possibili condizioni (ed eccezioni alle condizioni) in cui applicare i vari controlli, specie nell'applicare il salto sulle pareti, genera comportamenti spesso anomali. Di notevole interesse, sempre dal punto di vista della valorizzazione degli errori, la facile scappatoia che ho utilizzato nello script jump() che attua il salto dalle pareti:

vspeed=-10;

if keyboard_check(vk_left) {
image_xscale=1;
hspeed=5;
}

if keyboard_check(vk_right) {
image_xscale=-1;
hspeed=-5;
}

SIDE_COL=0;
CONTATTO=0;

io_clear();


Notate come viene spavaldamente (ed un po a sproposito) richiamata la funzione io_clear(): serve a correggere in modo approssimativo un bug. Questa funzione, come noto, svuota il buffer di tastiera impedendo in qualche modo che venga ripetuta la pressione di un tasto. Se non venisse richiamata, a seguito di un balzo su di una parete, ci troveremmo spesso con lo sprite sbagliato rispetto alla nuova direzione, o viceversa. Questo и un esempio di cattiva programmazione. E' una pezza applicata per non dover riscrivere le condizioni, giа provate e funzionanti, che gestiscono il rapporto tra collisione avvenuta e comando in corso.

Note conclusive


Ovviamente avrei potuto mettere le cose a posto e farvi vedere un codice impeccabile, ma ho ritenuto giusto questo capitolo di relax per introdurre un argomento nuovo e che sarа al centro di una prossima guida: il trattamento degli errori, o debug se preferite. Quello che succede nell'editabile qui presentato и, seppur in scala minore, quello che succede nei videogiochi commerciali: li attendete per 12 anni, li installate, ma non riuscirete a giocarli decentemente fino all'uscita dell'ennesima patch (o fino alla prossima generazione di PC, che и ancora peggio).

Scommetto che pure i meno esperti, con un po di pazienza, riuscirebbero a mettere le cose a posto... и questione di andare a vedere il perchи avviene questo o quel difetto e riscrivere poche linee di codice...

Nel prossimo capitolo, decisamente piщ serio di questo, andremo a vedere gli oggetti che possono essere spostati dal giocatore.