Category Archives: –MANUALE–

FAQ 2

Come semplificare la gestione delle collisioni e del movimento?

  1. Passa alla modalità avanzata, File > Advanced Mode
  2. Apri il pannello delle proprietà della sprite, tramite doppio clic
  3. In Collision Checking deseleziona Precise collision checking e Separate collision masks
  4. Seleziona Modify Mask
  5. In Bounding box imposta Full image
  6. In Shape imposta Rectangle.

 

Come caricare più immagini per la stessa sprite?

  1. Apri il pannello delle proprietà della sprite, tramite doppio clic
  2. Apri il pannello di modifica tramite Edit Sprite
  3. Scegli la voce di menu File > Add from File
  4. Nella finestra Open a Sprite Image seleziona un’immagine e apparirà a destra di quelle già presenti nel pannello

 

Come fare in modo che un oggetto appaia sopra un altro oggetto?

L’ordine di apparizione delle istanze degli oggetti è: dal valore più alto al valore più basso della proprietà Depth degli oggetti

  1. Passa alla modalità avanzata, File > Advanced mode
  2. Apri la finestra delle proprietà dell’oggetto che vuoi che appaia sempre al di sopra degli altri
  3. Imposta la sua proprietà Depth a un valore molto basso, -10, -100, …
  4. Analogamente puoi impostare la stessa proprietà per tutti gli altri oggetti ma utilizza -1, -2, -3, …

 

Quali tasti utilizzo per controllare il gioco?

La combinazione consigliata da Game Maker è

  1. UPDOWNLEFTRIGHT per i movimenti
  2. SPACEZXC per altre azioni
  3. P pausa
  4. ESC uscita

FAQ 1

Come raggruppare i livelli del gioco?

  1. Nel pannello di gestione delle risorse apri il menu contestuale di Rooms (tramite il pulsante destro del mouse)
  2. Seleziona Create Group e assegna un nome al nuovo gruppo di livelli
  3. Trascinalo nell’ordine che preferisci rispetto ai livelli/gruppi già esistenti
  4. Trascina all’interno del gruppo dei livelli già esistenti o creane di nuovi

Come inserire più oggetti nella stessa cella?

  1. Apri la finestra delle proprietà del livello (doppio clic sul nome del livello)
  2. Nell’angolo in basso a sinistra disattiva la casella Delete underlying
  3. Inserisci più istanze in una cella
  4. Riattiva la casella Delete underlying.

Effetti di transizione

Nell’azione di passaggio da un livello al successivo Next Room è possibile scegliere un effetto di transizionetransition.
Prova quelli disponibili nell’elenco a discesa e scegli quello che preferisci.

Puoi aggiungere un effetto personalizzato sfruttando le azioni

Sprite Action Change sprite into …
Move Action 1 Start moving in a direction
Destroy Action Destroy the instance

per cambiare / muovere /eliminare le sprite.

Tra un’azione e l’altra aggiungi opportunamente delle azioni

Sleep Action Sleep … milliseconds

altrimenti non ci sarà, apparentemente, nessun effetto!

Ripetere un livello?

L’utente può riprovare lo stesso livello.

<Canc>

image Restart Room

 

Prossimo livello?

L’utente può passare al livello successivo, se esiste, oppure ricominciare da capo.

<Page Down>

If Next Room If next room exists

Begin Start of block
Next Room Go to next room
End End of block

Else Action Else

Begin Start of block
Restart Game Restart the game
End End of block

 

Livello precedente?

L’utente può passare al livello precedente, se esiste.

<Page Up>

If Previous Room If previous room exists

Begin Start of block
image Go to previous room
End End of block

Presentazione del linguaggio – 3

Funzioni

Una funzione ha la forma di un nome di funzione, seguito da zero o più argomenti tra parentesi, separati da virgole.

<funzione>(<arg1>,<arg2>,...)

Ci sono due tipi di funzioni

  • Prima di tutto, c’è un numero enorme di funzioni incorporate, per controllare tutti gli aspetti del gioco.
  • E poi, qualsiasi script che definisci nel tuo gioco può essere utilizzato come una funzione.

Note

  • Devi utilizzare le parentesi anche per le funzioni senza argomenti.
  • Alcune funzioni restituiscono un valore e possono essere utilizzate nelle espressioni.
  • Altre semplicemente eseguono comandi.

Non è possibile utilizzare una funzione come lato sinistro di un’assegnazione.
Per esempio, non puoi scrivere

instance_nearest(x, y, obj).speed = 0

Invece devi scrivere

(instance_nearest(x, y, obj)).speed = 0

Script

Quando realizzi uno script, vuoi accedere agli argomenti che gli sono stati passati (sia quando utilizzi l’azione script, sia quando chiami lo script come una funzione da un programma, oppure da un altro o dallo stesso script).
Gli argomenti sono memorizzati nelle variabili argument0argument1, …, argument15.
Quindi ci sono al massimo 16 argomenti.
Osserva che quando chiami lo script da un’azione puoi specificare solo i primi 5.
Puoi anche utilizzare la forma argument[0], …

Anche gli script possono restituire un valore e quindi possono essere utilizzati nelle espressioni.
Per quesco scopo utilizza l’istruzione return:

return <espressione>

L’esecuzione di uno script termina con l’esecuzione dell’istruzione return.

Esempio

Ecco la definizione di un piccolo script che calcola il quadrato dell’argomento:

{
    return (argument0*argument0);
}

Per chiamare uno script da una porzione di codice, si fa come con le chiamate di funzione.
Cioè, si scrive il nome dello script con i valori degli argomenti tra parentesi.

Istruzione with

Come detto prima, è possibile leggere e cambiare il valore delle variabili in altre istanze.
Ma in certi casi vuoi fare più cose con le altre istanze.

Per esempio, immagina di voler muovere tutte le palle in giù di 8 pixel.
Potresti pensare di ottenerlo con la porzione di codice seguente

ball.y = ball.y + 8;

Ma non è corretto.
Il lato destro dell’assegnazione prende il valore della coordinata y della prima palla e gli aggiunge 8.
Poi questo nuovo valore viene assegnato alla coordinata y di tutte le palle.
Quindi il risultato è che tutte le palle avranno la stessa coordinata y.
L’istruzione

ball.y += 8;

avrà esattamente lo stesso effetto perché essa è semplicemente un’abbreviazione della prima.
Allora come possiamo fare?
A questo scopo esiste l’istruzione with.
La sua forma generica è

with (<espressione>) <istruzione>

espressione indica una o più istanze.
Per questo puoi utilizzare un id, il nome di un oggetto (per indicare tutte le istanze dell’oggetto) oppure uno degli oggetti speciali (allselfothernoone).

istruzione viene eseguita per ciascuna delle istanze specificate come se fossero l’istanza attuale (self).
Allora, per muovere tutte le palle giù di 8 pixel, puoi scrivere.

with (ball) y += 8;

Se vuoi eseguire istruzioni multiple, racchiudile tra parentesi graffe.
Allora per esempio, per muovere tutte le palle a una posizione casuale, puoi utilizzare

with (ball)
{
  x = random(room_width);
  y = random(room_height);
}

Osserva che, all’interno delle istruzioni, l’istanza specificata diventa l’istanza self.

All’interno delle istruzioni l’istanza originale self diventa l’istanza other.
Quindi per esempio, per muovere tutte le palle alla posizione dell’istanza corrente, puoi scrivere

with (ball)
{
    x = other.x;
    y = other.y;
}

L’uso dell’istruzione with è estremamente potente.
Facciamo ancora degli esempi.

Per distruggere tutte le palle scrivi

with (ball) instance_destroy();

Se una bomba esplode e vuoi distruggere tutte le istanze vicine puoi scrivere

with (all)
{
    if (distance_to_object(other) < 50)
        instance_destroy();
}

Commenti

Puoi aggiungere commenti ai tuoi programmi.
Tutto quello che c’è su una linea dopo // non viene letto.
Puoi fare anche dei commenti multilinea inserendo il testo tra /* e */.
L’evidenziazione del codice potrebbe non funzionare correttamente… premi F12 per ricolorare il testo se c’è un errore.

Funzioni e variabili in GML

GML contiene un gran numero di funzioni e variabili.
Con queste puoi controllare qualsiasi aspetto del gioco.
Per tutte le azioni ci sono le funzioni corrispondenti quindi non hai alcuna necessità di usare le azioni se preferisci il codice.
Ma ci sono molte più funzioni e variabili che controllano aspetti del gioco che non possono essere affrontati soltanto con le azioni.
Quindi se vuoi realizzare giochi avanzati sei avvisato che devi leggere attentamente le prossime pagine per avere una panoramica di tutto ciò che è possibile.
Osserva inoltre che queste variabili e funzioni possono essere usate per dare valori alle azioni.
Quindi, anche se non intendi utilizzare codice o scrivere script, avrai comunque beneficio da queste informazioni.

Utilizzeremo le seguenti convenzioni

  • I nomi delle variabili marcati con * sono di sola lettura, cioè i loro valori non possono essere cambiati.
  • I nomi delle variabili seguiti da [0..n] sono array, l’intervallo dei possibili indici è dato.

Presentazione del linguaggio – 2

Istruzione if

Un’istruzione if assume la forma

if (<espressione>) <istruzione>

oppure

if (<espressione>) <istruzione> else <istruzione>

L’istruzione può essere anche un blocco.

L’espressione verrà valutata.
Se il valore (arrotondato) è <=0 (false) viene eseguita l’istruzione dopo else, altrimenti (true) viene eseguita l’altra.

È una buona abitudine racchiudere sempre tra prentesi graffe l’istruzione dopo l’if.
Quindi è meglio utilizzare

if (<espressione>)
{
    <istruzione>
}
else
{
    <istruzione>
}

 

Esempio

Il programma seguente muove l’oggetto verso il centro (x=200) dello schermo.

{
    if (x<200) { x += 4     } else { x -= 4 };
}

Istruzione repeat

Un’istruzione repeat ha la forma

repeat (<espressione>) <istruzione>

L’istruzione è ripetuta il numero di volte specificato dal valore arrotondato dell’espressione.

Esempio

Il programma seguente crea cinque palle in posizioni casuali.

{
    repeat (5) instance_create(random(400), random(400), ball);
}

Istruzione while

Un’istruzione while ha la forma

while (<espressione>) <istruzione>

Finché l’espressione è true, l’istruzione (che può essere anche un blocco) viene eseguita.

Presta cura al tuo ciclo while.
Puoi facilmente realizzare un ciclo infinito, nel qual caso il tuo gioco si bloccherà e non reagirà più ad alcun input.

Esempio

Il programma seguente cerca di sistemare l’oggetto corrente in una posizione libera (si tratta della stessa azione di muovere un oggetto in una posizione casuale).

{
    while (!place_free(x, y))
    {
        x = random(room_width);
        y = random(room_height);
    }
}

Costrutto do

Un’istruzione do ha la forma

do <istruzione> until(<espressione>)

L’istruzione (che può essere anche un blocco) viene eseguita finché l’espressione non è vera.
L’istruzione viene eseguita almeno una volta.

Presta cura al tuo ciclo do.
Puoi facilmente realizzare un ciclo infinito, nel qual caso il tuo gioco si bloccherà e non reagirà più ad alcun input.

Esempio

Il programma seguente cerca di sistemare l’oggetto corrente in una posizione libera (si tratta della stessa azione di muovere un oggetto in una posizione casuale).

{
    do
    {
        x = random(room_width);
        y = random(room_height);
    }
    until (place_free(x, y))
}

Costrutto for

Un’istruzione for ha la forma

for (<istruzione1> ; <espressione> ;<istruzione2>)
    <istruzione3>

Funziona come segue..

  • Prima viene eseguita istruzione1.
  • Poi viene valutata l’espressione.
  • Se è true, viene eseguita l’istruzione3; poi l’istruzione2 e poi viene valutata di nuovo l’espressione.
  • Questo continua finché l’espressione non diventa false.

Sembra abbastanza complicato… interpretalo come segue.

  • L’istruzione1 inizializza il ciclo for.
  • L’espressione controlla se il ciclo deve terminare o meno.
  • istruzione2 è il passo che porta alla prossima valutazione del ciclo.

L’uso più comune è quello di un contatore che percorre un certo intervallo.

Esempio

Il programma seguente inizializza un array di lunghezza 10 con i valori da 1 a 10.

{
    for (i=0; i <= 9; i+=1)
        list[i] = i+1;
}

Istruzione switch

In certe situazioni vuoi che le azioni dipendano da un particolare valore.
Puoi farlo utilizzando un certo numero di if ma è più facile utilizzare l’istruzione switch.
Un’istruzione switch ha la forma seguente:

switch (<espressione>)
{
    case <espressione1>: <istruzione1>; ... ; break;
    case <espressione2>: <istruzione2>; ... ; break;
    ...
    default: <istruzione>; ...
}

Funziona come segue.

  • Prima viene calcolata l’espressione.
  • Poi viene confrontata con i valori delle diverse espressioni dopo le istruzioni case.
  • L’esecuzione continua dopo la prima istruzione case con il valore corretto finché non si incontra un’istruzione break.
  • Se nessuna istruzione case ha il valore giusto, l’esecuzione passa a quella dopo l’istruzione default.

Osserva

  • L’istruzione default non è obbligatoria.
  • Diverse istruzioni case possono essere previste per la stessa istruzione.
  • Anche l’istruzione break non è obbligatoria.
    Se non c’è l’istruzione break l’esecuzione continua semplicemente con il codice della prossima istruzione case.

 

Esempio

Il programma seguente esegue un’azione in funzione del tasto che è stato premuto.

switch (keyboard_key)
{
    case vk_left:
    case vk_numpad4:
        x -= 4; break;
    case vk_right:
    case vk_numpad6:
        x += 4; break;
}

Istruzione break

L’istruzione break assume la forma

break

È utilizzata nei cicli for while repeat e nelle istruzioni switch with e ne interrompe l’esecuzione.
Se invece è utilizzata fuori da queste istruzioni termina il programma (non il gioco).

Istruzione continue

L’istruzione continue assume la forma

continue

Se utilizzata nei cicli for while repeat e nelle istruzioni switch with fa passare l’elaborazione al prossimo valore (del ciclo o della with.

Istruzione exit

L’istruzione exit assume la forma

exit

Semplicemente termina l’esecuzione dello script o porzione di codice.
Non termina l’esecuzione del gioco… per questo ti serve la funzione game_end().

Presentazione del linguaggio – 1

Un programma

Un programma consiste di un insieme di istruzioni, statement.
Un programma deve iniziare con il simbolo { e finire con il simbolo }.
Tra questi due simboli ci sono le istruzioni.
Le istruzioni devono essere separate con un simbolo ;.

Quindi la struttura generale di ogni programma è:

{
  <istruzione>;
  <istruzione>;
  ...
}

C’è un certo numero di tipi diversi di istruzioni, che saranno trattati in seguito.

Variabili

Come tutti i linguaggi di programmazione GML ha le variabili.
Le variabili sono celle di memoria che mantengono informazioni.
Esse hanno un nome, in modo che si possa fare riferimento a esse.
In GML una variabile può memorizzare un numero reale oppure una stringa.
Le variabili non hanno bisogno di essere dichiarate come in molti altri linguaggi.
C’è un gran numero di variabili già presenti nel linguaggio.
Alcune sono di uso generale, come mouse_x e mouse_y che indicano la posizione attuale del mouse, mentre altre sono locali all’istanza dell’oggetto (…), come x e y che indicano la posizione attuale della istanza.
Una variabile ha un nome che deve iniziare con una lettera e può contenere soltanto lettere, numeri, e underscore, _.
La lunghezza massima è 64 simboli.

Quando utilizzi una nuova variabile questa è locale all’istanza corrente e non è visibile nei programmi delle altre istanze (anche dello stesso oggetto).
Si può, comunque, fare riferimento alle variabili di altre istanze; leggi più avanti.

Assegnazioni

Un’assegnazione memorizza un valore in una variabile.
Un’assegnazione ha la forma:

<variabile> = <espressione>;

Un’espressione può essere un semplice valore ma può anche essere molto più complicata.
Invece di assegnare un valore a una variabile, si può anche aggiungere un valore al valore attuale della variabile utilizzando +=.
Allo stesso modo, puoi

  • sottrarlo, -=
  • moltiplicarlo, *=
  • dividerlo, /=
  • oppure utilizzare gli operatori sui bit, |=&=^=.

 

Espressioni

Le espressioni possono essere

  • numeri reali, come 3.4
  • numeri esadecimali che iniziano con un segno $, come $00FFAA
  • stringhe tra apici singoli o doppi, come ‘hello’ oppure “hello”

o espressioni più complicate.

Per le espressioni, esistono i seguenti operatori binari (in ordine di priorità):

  • && || ^^ per i valori logici (and, or, xor)
  • < <= == != > >= confronti, si ottiene true (1) oppure false (0)
  • | & ^ operatori bit a bit (or, and, xor)
  • << >> operatori di shift (shift left, shift right)
  • + – addizione, sottrazione
  • * / div mod moltiplicazione, divisione, divisione intera, modulo

Osserva che il valore di x div y è il valore di x/y arrotondato in direzione dello zero all’intero più vicino. L’operatore modrestituisce il resto che si ottiene dalla divisione degli operandi.
In altre parole

x mod y = x - (x div y) * y.

Inoltre, ci sono i seguenti operatori unari:

  • ! not, trasforma true in false e false in true
  •  nega il valore successivo
  • ~ nega il valore successivo, bit a bit.

Come valori si possono usare numeri, variabili o funzioni che restituiscono un valore.
Le sottoespressioni possono essere racchiuse tra parentesi tonde.
Tutti gli operatori funzionano con valori reali.
I confronti funzionano anche con stringhe e + concatena le stringhe.
Attenzione, al contrario di certi linguaggi, entrambi gli argomenti di un operatore logico sono sempre valutati, anche quando il primo argomento determina in anticipo il risultato.

Esempio

Ecco un esempio con delle assegnazioni

{
  x = 23;
  color = $FFAA00;
  str = 'hello world';
  y += 5;
  x *= y;
  x = y << 2;
  x = 23*((2+4) / sin(y));
  str = 'hello' + " world";
  b = (x < 5) && !(x==2 || x==4);
}

 

Variabili aggiuntive

Si creano nuove variabili assegnando loro un valore (non è necessario dichiararle prima!).
Semplicemente se usi il nome di una variabile, la variabile sarà memorizzata insieme all’istanza dell’oggetto attuale.
Quindi non ti aspettare di ritrovarla quando dopo utilizzi un altro oggetto (o un’altra istanza dello stesso oggetto).
Puoi assegnare e leggere variabili in altri oggetti accompagnandole con il nome dell’oggetto e un punto prima del nome della variabile.

Per creare variabili globali, cioè visibili alle istanze di tutti gli oggetti, aggiungi all’inizio la parola global e un punto.

Per esempio si scrive:

{
  if (global.ok)
  {
    // succede qualcosa...
    global.ok = false;
  }
}

In alternativa si possono dichiarare le variabili come globali.
Questa dichiarazione sarà simile alla seguente

globalvar <varname1>,<varname2>,<varname3>, ... ;

Dopo che la dichiarazione è stata eseguita, la variabile sarà trattata sempre come globale senza il bisogno di aggiungere davantiglobal..
Necessita soltanto di essere dichiarata una volta in una pezzo di codice che viene eseguito.
Dopo, in qualunque altro posto la variabile viene trattata come globale.

A volte vuoi variabili soltanto all’interno del codice o script attuale.
In questo modo non sprechi memoria e sei sicuro che non ci siano conflitti tra i nomi.
È anche più veloce dell’uso di variabili globali.
Per questo devi dichiarare le variabili all’inizio della porzione di codice utilizzando la parola chiave var.
Questo tipo di dichiarazione somiglia alla seguente

var <varname1>,<varname2>,<varname3>, … ;

Per esempio, scrivi

{
    var xx, yy;
    xx = x+10;
    yy = y+10;
    crea_istanza(xx, yy, ball);
}

 

Far riferimento a variabili di altre istanze

Come detto prima, si assegna un valore a una variabile della stessa istanza utilizzando un costrutto come

x = 3;

Ma in certi casi vuoi far riferimento a variabili in altre istanze.
Per esempio, potresti voler fermare il movimento di tutte le palle, oppure muovere il personaggio principale in una certa posizione, oppure, in caso di collisione, impostare la sprite delle altre istanze coinvolte.
Puoi ottenerlo precedendo il nome della variabile con il nome di un oggetto e un punto.

Per esempio, puoi scrivere

ball.speed = 0;

In questo modo cambierà la velocità di tutte le istanze dell’oggetto palla.

C’è un certo numero di oggetti speciali.

  • self: L’istanza attuale per la quale si sta eseguendo l’azione
  • other: L’altra istanza coinvolta in un evento di collisione
  • all: Tutte le istanze
  • noone: Nessuna istanza (probabilmente suonerà strano ma ritornerà utile come vedremo in seguito)
  • global: Non è un’istanza, ma un contenitore per le variabili globali

Allora, per esempio, puoi utilizzare i seguenti tipi di istruzione:

other.sprite_index = sprite5;
all.speed = 0;
global.messaggio = 'A good result';
global.x = palla.x;

Adesso potresti stupirti per per quello che fa l’ultima assegnazione nel caso ci siano più palle.
Bene, prende la prima e assegna il suo valore x alla variabile globale. 

Ma se vuoi impostare la velocità di una particolare palla piuttosto che di tutte?

  • Questo è leggermente più difficile.
Ogni istanza ha un id unico.
Quando inserisci le istanze nel livello, l’id dell’istanza è visibile se passi il mouse sull’istanza.
Si tratta di numeri >= 100.000.
  • Questo numero puoi utilizzarlo anche a sinistra del punto.
Stai attento… il punto verrà interpretato come il separatore della parte decimale del numero.
Per evitarlo racchiudilo tra parentesi.
Per esempio, supponiamo che l’id della palla sia 100032, allora puoi scrivere:

(100032).speed = 0;
    • Quando crei un’istanza nel programma, la chiamata restituisce l’id.
    • Allora una porzione di codice valida è la seguente:
{
    nnn = instance_create(100, 100, ball);
    nnn.speed = 8;
}
In questo modo si crea una palla e si imposta la sua velocità
  • Osserva che abbiamo assegnato l’id dell’istanza a una variabile e poi abbiamo utilizzato questa variabile insieme con il punto.
Tutto questo è valido.
Cerchiamo di essere più precisi.
Un punto è a tutti gli effetti un operatore.
Dati i due argomenti, a sinistra e a destra, restituisce l’indirizzo di una variabile all’interno di un oggetto o istanza.
Tutti i nomi degli oggetti e gli oggetti speciali rappresentano dei valori e possono essere trattati come qualsiasi altro valore.
Per esempio, il prossimo codice è valido:

{
    obj[0] = ball;
    obj[1] = flag;
    obj[0].alarm[4] = 12;
    obj[1].id.x = 12;
}

L’ultima istruzione dovrebbe essere letta come segue.
Prendiamo l’id del primo flag.
Impostiamo a 12 la coordinata x dell’istanza con questo id.

  • I nomi degli oggetti, gli oggetti speciali gli id delle istanze possono essere inoltre utilizzati in un certo numero di funzioni.
I programmi li trattano come costanti.

 

Array

In GML puoi utilizzare array monodimensionali e bidimensionali.
Semplicemente metti l’indice tra le parentesi quadre per gli array monodimensionali, e i due indici separati da una virgola per gli array bidimensionali.
Nel momento in cui utilizzi un indice viene generato l’array.
Ciascun array inizia con l’indice 0.
Presta attenzione all’uso di indici grandi perché sarà riservata memoria per un array grande…
Non utilizzare mai indici negativi.
Il sistema pone un limite di 32000 per ciascun indice e di 1.000.000 per la dimensione totale.

Quindi puoi scrivere per esempio come segue:

{
    a[0] = 1;
    i = 1;
    while (i < 10)
    {
        a[i] = 2*a[i-1];
        i += 1;
    }
    b[4, 6] = 32;
}

 

Risorse – Background

Le funzioni seguenti forniscono informazioni su uno sfondo:

background_exists() ind Dato l’indice di un sottofondo restituisce: esiste?, il nome, la larghezza, l’altezza, trasparente?, smoothed?, preloaded?
background_get_name() ind
background_get_width() ind
background_get_height() ind
background_get_transparent() ind
background_get_smooth() ind
background_get_preload() ind

In alcune situazioni potresti voler salvare su file la bitmap corrispondente allo sfondo.

Per questo puoi utilizzare la funzione seguente:

background_save ind
fname
Standard Edition
Salva lo sfondo ind sul file fname.
Deve essere un file .png.

 

Modificare sfondi

The following routines can be used to create new backgrounds and to remove them.

background_duplicate(ind) Creates a duplicate of the background with the given index. It returns the index of the new background. When an error occurs -1 is returned.
background_assign(ind,back) Assigns the indicated background to background ind. So this makes a copy of the background.
background_add(fname,removeback,smooth) Adds the image stored in the file fname to the set of background resources. Many different types of images can be dealt with. When the image has an alpha channel, this is used for transparency. removeback indicates whether to make all pixels with the background color (left-bottom pixel) transparent. smooth indicates whether to smooth the boundaries. The function returns the index of the new background that you can then use to draw it or to assign it to the variable background_index[0] to make it visible in the current room. When an error occurs -1 is returned.
background_replace(ind,fname,removeback,smooth) Same as above but in this case the background with index ind is replaced. The function returns whether it is successful. When the background is currently visible in the room it wil be replaced also.
background_add_background(fname) Adds the background stored the file fname to the set of background resources. The file must be a .gmbck file that is saved in the background property form in GameMaker. As this file contains all background settings, no further arguments are required. The function returns the index of the new background that you can then use to draw it or to assign it to the variable background_index[0] to make it visible in the current room. When an error occurs -1 is returned.
background_replace_background(ind,fname) Same as above but in this case the background with index ind is replaced. The function returns whether it is successful. When the background is currently visible in the room it wil be replaced also.
background_create_color(w,h,col) Creates a background of the given size and with the given color. It returns the index of the new background. When an error occurs -1 is returned.
background_create_gradient(w,h,col1,col2,kind) Creates a gradient filled background of the given size. col1 and col2 indicate the two colors. kind is a number between 0 and 5 indicating the kind of gradient: 0=horizontal 1=vertical, 2= rectangle, 3=ellipse, 4=double horizontal, 5=double vertical. It returns the index of the new background. When an error occurs -1 is returned.
background_create_from_screen(x,y,w,h,removeback,smooth) Creates a background by copying the given area from the screen. removeback indicates whether to make all pixels with the background color (left-bottom pixel) transparent. smooth indicates whether to smooth the boundaries. This function makes it possible to create any background you want. Draw the image on the screen using the drawing functions and next create a background from it. (If you don’t do this in the drawing event you can even do it in such a way that it is not visible on the screen by not refreshing the screen.) The function returns the index of the new background. A work of caution is required here. Even though we speak about the screen, it is actually the drawing region that matters. The fact that there is a window on the screen and that the image might be scaled in this window does not matter.
background_create_from_surface(id,x,y,w,h,removeback,smooth) Creates a background by copying the given area from the surface with the given id. removeback indicates whether to make all pixels with the background color (left-bottom pixel) transparent. smooth indicates whether to smooth the boundaries. This function makes it possible to create any background you want. Draw the image on the surface using the drawing functions and next create a background from it. Note that alpha values are maintained in the background.
background_delete(ind) Deletes the background from memory, freeing the memory used.

The following routine exists to change the appearance of a background.

background_set_alpha_from_background(ind,back) Changes the alpha (transparancy) values in the background with index ind using the intensity values in the background back. This cannot be undone.

Risorse – Path

Le funzioni seguenti forniscono informazioni su un percorso:

path_exists() ind Dato l’indice di un percorso restituisce: esiste?, il nome, la lunghezza, il tipo di connessione (0=straight, 1=smooth), chiuso?, la precisione, il numero di punti
path_get_name() ind
path_get_length() ind
path_get_kind() ind
path_get_closed() ind
path_get_precision() ind
path_get_number() ind
path_get_point_x() ind
n
Dato l’indice di un percorso e l’indice di un punto (o per il primo punto) restituisce: la coordinata x, la coordinata y, il fattore di velocità
path_get_point_y() ind
n
path_get_point_speed() ind
n
path_get_x() ind
pos
Dato l’indice di un percorso e la posizione pos (compresa tra 0 e 1) restituisce: la coordinata x, la coordinata y, il fattore di velocità
path_get_y() ind
pos
path_get_speed() ind
pos

 

Modificare Script

It is possible to create paths and to add points to paths.
However, never change a path that is being used by an instance.
This can lead to unexpected results.

The following functions exist:

path_set_kind() ind
val
Sets the kind of connections of the path with the given index (0=straight, 1=smooth).
path_set_closed() ind
closed
Sets whether the path must be closed (true) or open (false).
path_set_precision() ind
prec
Sets the precision with which the smooth path is calculated (should lie between 1 and 8).
path_add() Adds a new empty paths.
The index of the path is returned.
path_delete() ind Deletes the path with the given index.
path_duplicate() ind Creates a duplicate copy of the path with the given index.
Returns the index of the copy.
path_assign() ind
path
Assigns the indicated path to path ind.
So this makes a copy of the path.
In this way you can easily set an existing path to a different, e.g. new path.
path_append() ind
path
Appends the indicated path to path ind.
path_add_point() ind
x
y
speed
Adds a point to the path with the given index, at position (x,y) and with the given speed factor.
Remember that a factor of 100 corresponds to the actual speed.
Lower values mean slowing down and higher mean speeding up.
path_insert_point() ind
n
x
y
speed
Inserts a point in the path with the given index before point n, at position (x,y) and with the given speed factor.
path_change_point() ind
n
x
y
speed
Changes the point n in the path with the given index to position (x,y) and the given speed factor.
path_delete_point() ind
n
Deletes the point n in the path with the given index.
path_clear_points() ind Clears all the points in the path, turning it into an empty path.
path_reverse() ind Reverses the path.
path_mirror() ind Mirrors the path horizontally (with respect to its center).
path_flip() ind Flips the path vertically (with respect to its center).
path_rotate() ind
angle
Rotates the path counter clockwise over angle degrees (around its center).
path_scale() ind
xscale
yscale
Scales the path with the given factors (from its center).
path_shift() ind
xshift
yshift
Shifts the path over the given amount.

Risorse – Sound

Le funzioni seguenti forniscono informazioni su un suono:

sound_exists() ind Dato l’indice di un suono restituisce: esiste?, il nome, tipo (0=normal, 1=background, 2=3d, 3=mmplayer), preload?
sound_get_name() ind
sound_get_kind() ind
sound_get_preload() ind

I suoni impiegano molte risorse e molti sistemi possono memorizzare e suonare solo un numero limitato di suoni.
Se realizzi un gioco grande hai bisogno di avere un maggior controllo su quali suoni sono caricati in memoria e in quale momento.
Puoi disabilitare l’opzione preload dei suoni per essere sicuro che i suoni siano caricati solo quando sono utilizzati.
Questo tuttavia presenta il problema che potresti ottenere un piccolo singhiozzo quando il suono viene utilizzato la prima volta.
Inoltre, i suoni non sono automaticamente scaricati quando non ne hai più bisogno.

Per un controllo maggiore puoi utilizzare le funzioni seguenti:

sound_discard() ind Libera la memoria utilizzata per il suono specificato.
sound_restore() ind Ricarica in memoria il suono specificato per l’ascolto immediato.

 

Modificare Sound

The following routines can be used to create new sounds and to remove them.

sound_add() fname
kind
preload
Adds a sound resource to the game.
fname is the name of the sound file.
kind indicates the kind of sound (0=normal, 1=background, 2=3d, 3=mmplayer) preload indicates whether the sound should immediately be stored in audio memory (true or false).
The function returns the index of the new sound, which can be used to play the sound. (-1 if an error occurred, e.g. the file does not exist).
sound_replace() index
fname
kind
preload
Same as the previous function but this time a new sound is not created but the existing sound index is replaced, freeing the old sound.
Returns whether correct.
sound_delete() index Deletes the indicated sound, freeing all memory associated with it.
It can no longer be restored.

File

L’uso di file esterni nei giochi è molto utile.
Per esempio, potresti creare un file che descrive in quale momento devono succedere certe cose.
Oppure vuoi probabilmente salvare informazioni per la prossima volta che il gioco sarà eseguito (per esempio, il livello attuale).

Esistono le funzioni seguenti per leggere e scrivere dati su file di testo:

file_text_open_read() fname Apre in lettura il file indicato.
La funzione restituisce l’id del file che dovrà essere utilizzato in altre funzioni.
Si possono aprire più file contemporaneamente (al massimo 32).
Non bisogna dimenticarsi di chiuderli quando si è finito con essi.
file_text_open_write() fname Apre in scrittura il file indicato, creandolo se non esiste.
La funzione restituisce l’id del file che dovrà essere utilizzato in altre funzioni.
file_text_open_append() fname Apre in append (per aggiungere dati alla fine) il file indicato, creandolo se non esiste.
La funzione restituisce l’id del file che dovrà essere utilizzato in altre funzioni.
file_text_close() fileid Chiude il file con l’id dato.
file_text_write_string() fileid
str
Scrive la stringa nel file con l’id dato.
file_text_write_real() fileid
x
Scrive il valore reale nel file con l’id dato.
file_text_writeln() fileid Scrive un carattere newline nel file.
file_text_read_string() fileid Legge una stringa dal file con l’id dato e restituisce questa stringa. Una stringa termina alla fine della linea.
file_text_read_real() fileid Legge un valore reale dal file e restituisce questo valore.
file_text_readln() fileid Salta il resto della linea nel file e si posiziona all’inizio della prossima linea.
file_text_eof() fileid Restituisce se è stata raggiunta la fine del file.

Per manipolare i file nel file system si possono usare le funzioni seguenti:

file_exists() fname Restituisce se il file con il nome dato esiste (true) o no (false).
file_delete() fname Elimina il file con il nome dato.
file_rename() oldname
newname
Rinomina il file con il nome oldname, in newname.
file_copy() fname
newname
Copia il file fname in newname.
directory_exists() dname Restituisce se la cartella indicata esiste.
Il nome deve includere il percorso completo, non un percorso relativo.
directory_create() dname Crea una cartella con il nome dato (compreso il percorso in avanti) se non esiste.
Il nome deve includere il percorso completo, non un percorso relativo.
file_find_first() mask
attr
Restituisce il nome del primo file che soddisfa la maschera mask e gli attributi attr. Se tale file non esiste, restituisce una stringa vuota.
La maschera può contenere un percorso e può contenere carattery jolly, per esempio'C:\temp\*.doc'.
Gli attributi danno i file aggiuntivi che si vogliono vedere.
(Perchè i file normali sono sempre restituiti quando soddisfano la maschera.)
Si possono aggiungere le seguenti costanti per cedere i file del tipo desiderato: fa_readonly fa_hidden fa_sysfile fa_volumeid fa_directory fa_archive.
file_find_next() Restituisce il nome del prossimo file che soddisfa la maschera e gli attributi dati precedentemente.
Se tale file non esiste, restituisce una stringa vuota.
file_find_close() Deve essere chiamata dopo aver gestito tutti i file per liberare memoria.
file_attributes() fname
attr
Restituisce se il file ha tutti gli attributi dati con attr.
Utilizza una combinazione delle costanti specificate prima.

Le funzioni seguenti possono essere usate per cambiare i nomi dei file.
Da notare che queste funzioni non intervengono sui file attuali, si occupano solo delle stringhe.

filename_name() fname Restituisce il nome del nome di file specificato, con l’estensione ma senza percorso.
filename_path() fname Restituisce il percorso del nome di file specificato, compreso il backslash alla fine.
filename_dir() fname Restituisce la cartella del nome di file specificato, che normalmente corrisponde al percorso escluso il carattere backslash finale.
filename_drive() fname Restituisce l’unità logica, drive, del nome di file specificato.
filename_ext() fname Restituisce l’estensione del nome di file specificato, compreso il punto iniziale.
filename_change_ext() fname
newext
Restituisce il nome, del nome di file specificato, con l’estensione modificata alla nuova estensione newext.
Utilizzando una stringa vuota come nuova estensione si elimina l’estensione attuale.

In rare situations you might need to read data from binary files.
The following low-level routines exist for this:

file_bin_open() fname
mod
Opens the file with the indicated name.
The mode indicates what can be done with the file: 0 = reading, 1 = writing, 2 = both reading and writing).
When the file does not exist it is created.
The function returns the id of the file that must be used in the other functions.
You can open multiple files at the same time (32 max).
Don’t forget to close them once you are finished with them.
file_bin_rewrite() fileid Rewrites the file with the given file id, that is, clears it and starts writing at the start.
file_bin_close() fileid Closes the file with the given file id.
file_bin_size() fileid Returns the size (in bytes) of the file with the given file id.
file_bin_position() fileid Returns the current position (in bytes; 0 is the first position) of the file with the given file id.
file_bin_seek() fileid
pos
Moves the current position of the file to the indicated position.
To append to a file move the position to the size of the file before writing.
file_bin_write_byte() fileid
byte
Writes a byte of data to the file with the given file id.
file_bin_read_byte() fileid Reads a byte of data from the file and returns this.

If the player has checked secure mode in his preferences, for a number of these routines, you are not allowed to specify a path, and only files in the application folder can e.g. be written.

If you included files in the game executable and did not automatically export them at the start of the game, you can use the following functions to do this.

export_include_file() fname Exports the included file with the name fname.
This must be a string variable, so don’t forget the quotes.
export_include_file_location() fname
location
Exports the included file with the name fname to the given location.
Location must contain the path and the filename.
discard_include_file() fname Discard the included file with the name fname, freeing the memory used.
This must be a string variable, so don’t forget the quotes.

The following four read-only variables can be useful:

game_id Unique identifier for the game.
You can use this if you need a unique file name.
working_directory Working directory for the game.
(Not including the final backslash.)
program_directory Directory in which the game executable is stored.
(Not including the final backslash.)
When you run a standalone game this is normally the same as the working directory unless the game e.g. opens a file using the file selector.
Note that when testing a game you are creating the program and working directory will be different.
In that case the working directory is the place where the editable version is stored while the program directory is a temporary directory for testing.
temp_directory Temporary directory created for the game.
(Not including the final backslash.)
You can store temporary files here.
They will be removed at the end of the game.

In certain situations you might want to give players the possibility of providing command line arguments to the game they are running (for example to create cheats or special modes).
To get these arguments you can use the following two routines

parameter_count() Returns the number of command-line parameters.
The actual parameters can be retrieved with the following function.
parameter_string(n) Returns command-line parameters n.
The first parameter has index 1.
The last one has index parameter_count().
Index 0 is a special one.
It is the filename of the game executable (including the path).

You can read the value of environment variables using the following function:

environment_get_variable() name Returns the value (a string) of the environment variable with the given name.

Finally, if you are interested in the size of the disk and the free space, you can use the following functions:

disk_size() drive Returns the size of the indicated drive in bytes.
drive must be a capital letter, e.g. ‘C’.
If you do not provide the drive, the drive of the current working directory is used.
disk_free() drive Returns the amount of free space on the indicated drive in bytes.
drive must be a capital letter, e.g. ‘C’.
If you do not provide the drive, the drive of the current working directory is used.

Risorse – Object

Le funzioni seguenti forniscono informazioni su un oggetto:

object_exists() ind Dato l’indice di un oggetto restituisce: esiste?, il nome, l’indice della sprite di default, solido di default?, visibile di default?, il livello, persistente?, l’indice della maschera (-1 se non ha una maschera speciale), l’indice dell’oggetto genitore (un valore negativo se non ha genitore),
object_get_name() ind
object_get_sprite() ind
object_get_solid() ind
object_get_visible() ind
object_get_depth() ind
object_get_persistent() ind
object_get_mask() ind
object_get_parent() ind
object_is_ancestor ind1
ind2
Restituisce se l’oggetto ind2 è un progenitore dell’oggetto ind1

 

Modificare Object

Also objects can be manipulated and created during the game play.
NEVER change or delete an object for which there are instances.
This can lead to unexpected effects as certain object properties are stored with the instance and, hence, changing them in the object will not have the desired effect.

object_set_sprite(ind,spr) Sets the sprite of the object with the given index. Use -1 to remove the current sprite from the object.
object_set_solid(ind,solid) Sets whether instances created of the object must default be solid (true or false).
object_set_visible(ind,vis) Sets whether instances created of the object must default be visible (true or false).
object_set_depth(ind,depth) Sets the default depth of instances created of the object.
object_set_persistent(ind,pers) Sets whether instances created of the object must default be persistent (true or false).
object_set_mask(ind,spr) Sets the sprite mask of the object with the given index. Use -1 to set the mask to be the sprite of the object.
object_set_parent(ind,obj) Sets the parent of the object. Use -1 to not have a parent. Changing the parent changes the behavior of instances of the object.

The following routines are useful for creating objects on the fly. As with all resource changing routines, be very careful that you don’t create new objects all the time.

object_add() Adds a new object. It returns the index of the object. You can now use this index in the routines above to set certain properties of the object and then you can use the index to create instances of the object.
object_delete(ind) Deletes the object with the given index. Make sure no instances of the object exist in any of the rooms.
object_event_add(ind,evtype,evnumb,codestr) To give the object a behavior we must define events for the object. You can only add code actions to events. You need to specify the object, the event type, the event number (use the constants that have been specified before for the event_perform() function). Finally you provide the code string that must be executed. You can add multiple code actions to each event.
object_event_clear(ind,evtype,evnumb) You can use this function to clear all the actions for a particular event.

Creating objects is in particular useful when you are designing scripts or action libraries. For example, an initialization script can create an object to display a text and another script can add such an object with a particular text. In this way you have a simple mechanism to display texts without the need to create objects using the standard interface.