GDevelop, l’engine senza programmazione!

L’industria dei videogiochi sta fiorendo a ritmi elevati. Ci sono miliardi di giocatori in tutto il mondo che cercano sempre videogiochi eccitanti e divertenti. D’altra parte, ci sono una serie di software di sviluppo di videogiochi che forniscono agli sviluppatori un ambiente completo e strumenti di sviluppo di giochi per sviluppare giochi avanzati e affascinanti. In passato, gli sviluppatori di giochi erano abituati a scrivere il codice sorgente del gioco riga per riga. È stato un metodo di sviluppo molto lungo e i giocatori hanno dovuto aspettare mesi per una nuova versione. Pertanto, la comunità open source ha sviluppato Game engine facili e gratuiti per i principianti.

Questi motori di gioco gratuiti non solo aiutano a fornire versioni di gioco veloci, ma sono anche dotati di funzionalità che migliorano la qualità e la robustezza del gioco. Inoltre, questi progettisti di giochi 3D offrono un’interfaccia utente drag & drop ed eliminano la necessità di avere conoscenze di programmazione per creare giochi. Tuttavia, questo è un tutorial di GDevelop in cui impareremo cos’è GDevelop e come configurarlo localmente coprendo il punto seguente.

Cos’è GDevelop?

GDevelop è un software di sviluppo di videogiochi open source gratuito, disponibile per Windows, Linux e Mac, è self-hosted e offre funzionalità avanzate per lo sviluppo di giochi 2D. Tuttavia, è disponibile il supporto per gli oggetti 3D. Gli utenti non hanno bisogno di alcun tipo di abilità di programmazione per sviluppare e pubblicare giochi per più piattaforme. È altamente estensibile e facile da configurare in quanto richiede semplici requisiti per ospitare autonomamente questo motore di gioco gratuito. C’è un’interfaccia utente intuitiva con funzionalità di trascinamento della selezione. Questo strumento gratuito offre animazioni di alta classe, effetti video/audio, touchscreen e multi-touch, anteprima dal vivo e molti altri. Inoltre, questo designer di giochi 3D offre potenti funzionalità di prototipazione che aiutano gli sviluppatori a sviluppare un ottimo prodotto basato sul prototipo.

Inoltre, questo facile creatore di giochi open source è altamente configurabile e supporta integrazioni con librerie di terze parti. Soprattutto, fornisce supporto per Xbox e PlayStation che sono popolari console per videogiochi. GDevelop è scritto in C++, JavaScript e TypeScript. È disponibile una documentazione dettagliata relativa alla distribuzione e allo sviluppo. GDevelop ha una comunità di sviluppatori molto vivace che risponde attivamente a bug e domande. Pertanto, tutto il codice sorgente è disponibile su Github.

https://wiki.gdevelop.io/gdevelop5/documentation
https://github.com/4ian/GDevelop

Come creo un gioco?

Primo passo: Crea un nuovo progetto

1. Avvia GDevelop.
2. Seleziona Crea un nuovo progetto.
3. Scegli una cartella per il progetto.
4. Seleziona Gioco vuoto.

Secondo passo: Aggiungi una nuova scena

1. Espandi il pannello Scene (se non è già espanso).
2. Seleziona Fare clic per aggiungere una scena.

Terzo passo: Aggiungiamo un nuovo oggetto

Una scena è composta da oggetti. Ogni cosa che l’utente vede o con cui interagisce è un oggetto, inclusi il personaggio giocabile, i nemici e parti dell’ambiente.

GDevelop fornisce diversi tipi di oggetti che puoi aggiungere a un gioco. Ogni tipo di oggetto ha caratteristiche e casi d’uso unici. Il tipo di oggetto più comune è l’oggetto Sprite, che ti consente di creare un elemento grafico che puoi (opzionalmente) scegliere di animare.

Per creare un oggetto:

1. Nel pannello Oggetti, fai clic su Aggiungi un nuovo oggetto.
2. Seleziona Sprite.
3. Nel campo Nome oggetto, digita “Cloud”.
4. Quando si apre l’editor di oggetti, fare clic su Aggiungi un’animazione. Anche se l’etichetta dice Aggiungi un’animazione, gli oggetti Sprite non devono essere animati.
5. Fare clic su Aggiungi.
6. Seleziona la risorsa “cloud2.png”.
7. Seleziona Applica.

Quindi trascina una o più copie dell’oggetto “Cloud” nella scena.

Quarto passo: Aggiungiamo uno sfondo

Le nuvole bianche non stanno benissimo sullo sfondo grigio.

Per cambiare il colore di sfondo della scena:

1. Fare clic con il pulsante destro del mouse sullo sfondo della scena.
2. Seleziona Proprietà scena.
3. Fare clic su Colore di sfondo della scena.
4. Scegli una bella sfumatura di blu.

Puoi inserire un esadecimale (Es: #00000) o un nome del colore (Es: Nero)

Quinto passo: Vediamo un anteprima

È bene prendere l’abitudine di visualizzare regolarmente in anteprima i tuoi giochi. Quindi, quando qualcosa si rompe, è più facile capire il problema.

Per avviare un’anteprima del gioco, fai clic sul pulsante Anteprima nella barra degli strumenti.

Per interrompere l’anteprima, chiudere la finestra di anteprima.

Sesto passo: Salva il gioco

È anche bene prendere l’abitudine di salvare regolarmente i tuoi giochi. Puoi salvare il gioco tramite il menu File o utilizzando una scorciatoia da tastiera:

CTRL + S su Windows e Linux
CMD+S su macOS

Settimo passo: Crea un’oggetto

Il primo passo è creare un oggetto che rappresenti il personaggio giocabile. Se hai seguito la prima parte di questo tutorial, questo dovrebbe essere un processo familiare.

Per creare un oggetto per il personaggio giocabile:

1. Crea un oggetto Sprite chiamato “Giocatore”.
2. Usa la risorsa “p1_stand.png” come unico fotogramma dell’animazione.
3. Assegna un nome di “Idle” all’animazione.
4. Trascina un’istanza dell’oggetto nella scena.

Ottavo passo: Aggiungi un comportamento all’oggetto

Se visualizzi l’anteprima del gioco, non puoi controllare l’oggetto “Giocatore”. Questo perché, per impostazione predefinita, gli oggetti non fanno nulla. Per fare in modo che gli oggetti facciano qualcosa, devi assegnare loro uno o più comportamenti.

GDevelop viene fornito con un’ampia libreria di comportamenti che puoi aggiungere agli oggetti in pochi clic. Uno di questi comportamenti è il comportamento del personaggio Platform, che ti consente di controllare un oggetto come personaggio giocabile.

Per aggiungere il comportamento del personaggio Platform all’oggetto:

Fare clic con il pulsante destro del mouse sull’oggetto Player.
Seleziona Modifica oggetto.
Passa alla scheda Comportamenti.
Fare clic su Aggiungi un comportamento all’oggetto.
Seleziona il personaggio platform.
Fare clic su Applica.

Se visualizzi l’anteprima del gioco, puoi controllare il giocatore con i tasti freccia. C’è però un effetto collaterale: un oggetto con il comportamento del personaggio Platform è influenzato dalla gravità, quindi in questo caso il personaggio giocabile cade rapidamente fuori dall’inquadratura.

Nono passo: segui un oggetto con la fotocamera

Per evitare che il personaggio esca dall’inquadratura, il gioco ha bisogno di piattaforme e una telecamera che segua il giocatore. La parte successiva del tutorial riguarda le piattaforme, quindi questa sezione riguarda la fotocamera.

Per fare in modo che la telecamera segua il giocatore, devi creare un evento. In GDevelop, gli eventi ti consentono di definire causa ed effetto, quindi quando succede qualcosa (causa) puoi attivare qualcos’altro (effetto).

Gli eventi sono composti da due parti: condizioni e azioni. La condizione è ciò che determina quando si verifica l’evento e l’azione è ciò che accade quando si verifica l’evento.

GDevelop ha una vasta libreria di condizioni e azioni che aggiungono tutti i tipi di funzionalità a un gioco. Una parte importante dell’apprendimento di GDevelop è scoprire le opzioni disponibili. In questo caso, il gioco necessita dell’azione Centra la telecamera su un oggetto.

Per aggiungere l’azione Centra la telecamera su un oggetto:

1. Apre l’editor degli eventi.
2. Fai clic su Aggiungi un nuovo evento.
3. Senza specificare una condizione, fare clic su Aggiungi azione. Non specificando una condizione, l’azione viene eseguita in ogni fotogramma. Pertanto, se il gioco viene eseguito a 60 fotogrammi al secondo, l’azione viene eseguita 60 volte al secondo.
4. Fare clic su Altre azioni.
5. Espandi Livelli e telecamere.
6. Selezionare Centra la telecamera su un oggetto.
7. Seleziona l’oggetto “Giocatore”.
8. Fare clic su OK.

Se visualizzi l’anteprima del gioco, il giocatore cade comunque – non ci sono ancora piattaforme, dopotutto – ma anche la telecamera segue il giocatore. Di conseguenza, il giocatore rimane all’interno dell’inquadratura.

Decimo passo: Crea una piattaforma

1. Nel pannello Oggetti, fai clic su Aggiungi un nuovo oggetto.
2. Seleziona Sprite tile.
3. Nel campo Nome oggetto, digita “GrassPlatform”.
4. Fare clic su Seleziona un’immagine.
5. Fare clic su Scegli una nuova immagine.
6. Quando si apre il selettore file, seleziona la risorsa “grassHalfMid”.
7. Fare clic su Applica.

Quindi trascina alcune istanze dell’oggetto nella scena e varia la larghezza di queste istanze per creare piattaforme di diverse lunghezze.

Undicesimo passo: Aggiungi un comportamento alla piattaforma

La semplice aggiunta di una piattaforma alla scena non è sufficiente. Devi anche aggiungere un comportamento all’oggetto per renderlo qualcosa su cui il personaggio giocabile può camminare. Convenientemente, GDevelop fornisce un comportamento chiamato Platform behavior che fa questo per te.

Per aggiungere il comportamento della piattaforma all’oggetto:

1. Apri la scheda Comportamenti per l’oggetto “GrassPlatform”.
2. Seleziona Comportamento piattaforma.
3. Fare clic su Applica.

Se visualizzi l’anteprima del gioco, il giocatore può spostarsi sulla superficie della piattaforma.

Dodicesimo passo: Crea un tipo diverso di piattaforma

GDevelop fornisce anche il comportamento della piattaforma Jumpthru. Questo comportamento crea una piattaforma su cui il giocatore può saltare da sotto di essa. Questo aggiunge più varietà al livello.

Per creare una piattaforma con il comportamento della piattaforma Jumpthru:

1. Crea un oggetto sprite Tiled chiamato “SmallBridge”.
2. Usa la risorsa “bridgeLogs.png” come immagine dell’oggetto.
3. Apri la scheda Comportamenti.
4. Seleziona Comportamento piattaforma.
5. Dal menu a discesa Tipo, seleziona la piattaforma Jumpthru.
6. Fare clic su Applica.

Quindi trascina alcune istanze dell’oggetto nella scena.

Tredicesimo passo: Aggiungi un’animazione di salto al giocatore

Per aggiungere un’animazione di salto all’oggetto “Giocatore”:

1. Nel pannello Oggetti, fai clic con il pulsante destro del mouse sull’oggetto “Giocatore”.
2. Seleziona Modifica oggetto.
3. Fare clic su Aggiungi un’animazione.
4. Assegna un nome di “Salto” all’animazione.
5. Fare clic su Aggiungi.
6. Dal selettore di file, seleziona l’asset “p1_jump.png”.

Ma mentre l’animazione è collegata all’oggetto, non verrà riprodotta a meno che qualcosa non lo attivi.

Attiva l’animazione “Salto”.

Per attivare l’animazione “Salto”:

1. Passa all’editor degli eventi.
2. Crea un nuovo evento.
3. Aggiungi la condizione Sta saltando all’oggetto “Giocatore”.
4. Aggiungi l’azione Modifica l’animazione (per nome) all’evento.
5. Nel campo Nome animazione, inserisci il nome dell’animazione “Salto”. Devi racchiudere questo nome tra virgolette doppie (es. “Salto”).
6. Fare clic su OK.

Sulla base di queste modifiche, il salto attiva l’animazione.

Quattordicesimo passo: aggiungi un’animazione inattiva al lettore

C’è un problema con l’animazione del salto: non si ripristina quando il giocatore ha finito di saltare. Per risolvere questo problema, attiva l’animazione “Idle” quando il giocatore torna sulla piattaforma.

Rileva quando il giocatore è a terra

Crea un nuovo evento.
Aggiungi la condizione È sul pavimento all’oggetto “Giocatore”.

Ha senso l’animazione “Idle quando il giocatore è fermo, poiché lo spostamento del giocatore dovrebbe muovere l’animazione “Running” (spiegata nel passaggio successivo).

Per quando il giocatore non si muove:

1. Aggiungi la condizione È in movimento all’oggetto “Giocatore”.
2. Attiva o disattiva l’opzione Inverti condizione.

L’opzione Inverti condizione inverte il modo in cui funziona una condizione. Ciò significa che la condizione È in movimento diventa la condizione Non è in movimento.

Attiva l’animazione “Idle”.

Quando entrambe le condizioni precedenti sono soddisfatte, attiva l’animazione “Idle” dell’oggetto:

1. Aggiungi l’azione Modifica l’animazione (per nome).
2. Nel campo Nome animazione, inserisci il nome dell’animazione “Idle”. Devi racchiudere questo nome tra virgolette doppie (ad esempio “Idle”).

1. Add the Change the animation (by name) action.
2. In the Animation name field, enter the name of the “Idle” animation. You must wrap this name in double quotes (i.e. "Idle").

Se visualizzi l’anteprima del gioco, l’oggetto “Giocatore” torna all’animazione “Inattivo” dopo il salto.

Quindicesimo passo: Aggiungi un’animazione in esecuzione al giocatore

Aggiungi l’animazione “Running” all’oggetto “Player”.

1. Aggiungi un’animazione denominata “Running” all’oggetto “Player”.
2. Dal selettore file, seleziona tutte le seguenti risorse: – p1walk03.png – p1walk04.png – p1walk05.png – p1walk06.png – p1_walk07.png
3. Abilita l’opzione Ciclo. Se abilitata, l’animazione viene riprodotta continuamente per tutto il tempo in cui è attiva (invece di essere riprodotta una volta e interrompersi).
4. Fare clic su Applica.

Attiva l’animazione “corsa”.

1. Crea un nuovo evento.
2. Aggiungi la condizione È sul pavimento all’oggetto “Giocatore”.
3. Aggiungi la condizione È in movimento all’oggetto “Giocatore”.
4. Aggiungi l’azione Modifica l’animazione (per nome) all’evento.
5. Nel campo Nome animazione, inserisci il nome dell’animazione “In esecuzione”. Devi racchiudere questo nome tra virgolette doppie (ad es. “In esecuzione”).
6. Fare clic su O

Se visualizzi l’anteprima del gioco, l’animazione “In esecuzione” viene riprodotta mentre il giocatore si muove.

Sedicesimo passo: Crea una moneta raccoglibile

Il primo passo è creare una moneta che il giocatore può raccogliere. Puoi dividere questo passaggio in due parti: creare un oggetto per la moneta e quindi rendere la moneta collezionabile utilizzando un evento per rilevare quando il giocatore si scontra con essa.

Crea un oggetto per la moneta

Crea un oggetto chiamato “Coin”.
Per l’immagine dell’oggetto, utilizza la risorsa “coin.png”.
Trascina una o più istanze dell’oggetto nella scena.

Rendi la moneta da collezione

Crea un nuovo evento.
Aggiungi una condizione di Collisione all’evento che verifica se l’oggetto “Giocatore” è entrato in collisione con l’oggetto “Moneta”.
Aggiungi un’azione Elimina un oggetto all’evento e configura l’azione per eliminare l’oggetto “Moneta”.
Aggiungi un’azione Riproduci un’azione sonora all’evento che riproduce un effetto sonoro quando il giocatore raccoglie una moneta. (Puoi usare la risorsa “coin.wav” per l’effetto sonoro.)

Se visualizzi l’anteprima del gioco, la collisione con una moneta cancella la moneta e riproduce un suono.

Diciassettesimo passo: tieni traccia delle monete raccolte

Ogni volta che un utente raccoglie una moneta, il gioco deve tenere traccia del numero di monete che il giocatore ha raccolto. Per fare ciò, il gioco ha bisogno di una variabile.

Una variabile è un contenitore che può memorizzare dati. Se hai mai fatto algebra, allora hai familiarità con le variabili, poiché lettere come “x” e “y” sono spesso usate come variabili.

In GDevelop, ci sono tre tipi di variabili:

 Variabili oggetto
 Variabili di scena
 Variabili globali

Una spiegazione di ciascun tipo di variabile va oltre lo scopo di questo tutorial, ma le differenze vengono esplorate in Ambito delle variabili. In questo caso, le variabili di scena sono le più rilevanti. Queste sono variabili che esistono per la durata di una scena.

Per creare una variabile di scena che tenga traccia del numero di monete raccolte:

1. Aggiungere un valore di un’azione di una variabile di scena all’evento creato in precedenza.
2. Nel campo Variabile, digita “Punteggio”. Questo è un nome per la variabile.
3. Dal menu a discesa del segno di modifica, selezionare + (aggiungi).
4. Nel campo Valore, digita “1” (senza virgolette).
5. Fare clic su OK.

Questo tiene traccia del numero di monete raccolte dal giocatore, ma questo numero non appare (ancora) sullo schermo.

Diciottesimo passo: visualizza il numero di monete raccolte

1. Crea un oggetto di testo chiamato “Punteggio”.
2. Nel campo Testo iniziale da visualizzare, digita “Punteggio: 0”. Questo è il testo predefinito da visualizzare all’interno dell’oggetto.
3. Fare clic su Applica.
4. Trascina un’istanza dell’oggetto nella scena.

Aggiorna l’oggetto “Punteggio” con il numero di monete raccolte

Prima di poter aggiornare il testo renderizzato con il numero di monete raccolte, è importante avere un’ampia comprensione delle espressioni.

In GDevelop, le espressioni sono simili alle formule o alle funzioni di un foglio di calcolo in un linguaggio di programmazione. Puoi passare un valore in un’espressione e ricevere un valore.

Ad esempio, l’espressione Variabile può recuperare il valore della variabile “Punteggio”:

Variable(punteggio)

Poiché la variabile “score” contiene un numero, questa espressione restituisce un numero. Puoi convertire quel numero in una stringa con l’espressione ToString:

ToString(Variable(Score))

Le espressioni sono uno dei concetti più avanzati – e uno dei più potenti – in GDevelop, quindi non preoccuparti se ci vuole del tempo per avvolgerli. Il trucco è seguire i tutorial e usare le espressioni. L’esperienza pratica è fondamentale.

Per aggiornare l’oggetto “Punteggio” con il numero di monete raccolte:

1. Crea un nuovo evento.
2. Senza specificare una condizione, aggiungere l’azione Modifica il testo all’oggetto “Punteggio”. Poiché una condizione non è specificata, questa azione viene eseguita in ogni fotogramma. Ciò garantisce che il punteggio visualizzato sia sempre accurato.
3. Dal menu a discesa del segno di modifica, selezionare = (imposta).
4. Nel campo Valore, digita “Punteggio: ” + ToString(Variable(Score)). Questo valore usa le espressioni ToString e Variable per convertire il numero di monete raccolte in una stringa. Utilizza anche l’operatore + per combinare due stringhe in un’unica stringa.
5. Fare clic su OK.

Se visualizzi l’anteprima del gioco, sullo schermo viene visualizzato il numero di monete raccolte.

Sposta il testo su un livello diverso

C’è un problema con l’oggetto “Punteggio”: il numero di monete raccolte è visibile solo se il giocatore è in piedi in determinate posizioni.

Per risolvere questo problema, sposta l’oggetto “Punteggio” su un livello diverso:

1. Fare clic sull’icona Apri l’editor dei livelli.
2. Fare clic su Aggiungi un livello.
3. Per il nome del livello, digita “UI”.
4. Seleziona l’oggetto “Punteggio”.
5. Dal menu a tendina Layer, seleziona “UI”.

Fare clic sull’icona Apri l’editor dei livelli.
Fare clic su Aggiungi un livello.
Per il nome del livello, digita “UI”.
Seleziona l’oggetto “Punteggio”.
Dal menu a tendina Layer, seleziona “UI”.

Se visualizzi in anteprima il gioco, il punteggio rimane in una posizione fissa.

Diciannovesimo passo: crea un oggetto per il nemico

Crea un oggetto Sprite chiamato “Slime”.
Aggiungi un’animazione all’oggetto che utilizza le seguenti risorse: – slimeWalk1.png – slimeWalk2.png
Abilita l’opzione Ciclo.
Trascina un’istanza dell’oggetto nella scena.

Se visualizzi l’anteprima del gioco, sullo schermo appare un nemico animato.

Ventesimo passo: Fai muovere il nemico.

La parte precedente di questo tutorial menzionava che esistevano tre tipi di variabili:

 Oggetto
 Scena
 Globale

Una variabile oggetto è legata a un oggetto specifico. Ciò significa che la variabile contiene un valore che è disponibile solo per – e rilevante solo per – l’oggetto associato.

Per aggiungere una variabile oggetto all’oggetto “Slime”:

1. Fare clic con il pulsante destro del mouse sull’oggetto “Slime”.
2. Seleziona Modifica variabili oggetto.
3. Aggiungi una variabile denominata “direzione” con un valore di “destra”. Questo è il valore predefinito della variabile.
4. Fare clic su Applica.

Questa variabile “direzione” tiene traccia della direzione attuale del nemico. In un passaggio successivo, sarai in grado di cambiare la direzione del nemico cambiando il valore della variabile.

Per spostare il nemico a destra, crea un evento:

1. Apri l’editor degli eventi.
2. Crea un nuovo evento.
3. Aggiungi il testo della condizione variabile di un oggetto all’oggetto “Slime”.
4. Nel campo Variabile, digita “direzione”.
5. Nel campo Segno del test, selezionare = (uguale a).
6. Nel campo Valore da confrontare, digita “destra” (incluse le virgolette).
7. Fare clic su OK.

Quindi aggiungi un’azione all’evento:

1. Apri l’editor degli eventi.
2. Crea un nuovo evento.
3. Aggiungi il testo della condizione variabile di un oggetto all’oggetto “Slime”.
4. Nel campo Variabile, digita “direzione”.
5. Nel campo Segno del test, selezionare = (uguale a).
6. Nel campo Valore da confrontare, digita “destra” (incluse le virgolette).
7. Fare clic su OK.

Ecco come appare l’evento completo:

In base a questo evento, mentre il valore della variabile “direction” è “right”, l’oggetto “Slime” si sposta a destra. Poiché l’oggetto non cambia mai direzione, cade inevitabilmente dal bordo della piattaforma.

Ventunesimo passo: Cambia la direzione del nemico.

Per far cambiare direzione al nemico, aggiungi due oggetti invisibili alla scena – uno chiamato “Sinistra” e uno chiamato “Destra” – e posizionali dall’altra parte del nemico.

Quindi, quando il nemico si scontra con uno degli oggetti, puoi capovolgerli e spostarli nell’altra direzione. Questo crea l’illusione che il nemico segua un percorso prestabilito.

Questo passaggio si concentra sulla creazione dell’oggetto “Sinistra”. Quando il nemico si scontra con questo oggetto, cambierà direzione da sinistra a destra. (Il passaggio che segue si concentra sull’oggetto “Destra”.)

1. Crea un oggetto Sprite chiamato “Sinistra”.
2. Come sprite predefinito, usa la risorsa “left.png”.
3. Trascina un’istanza di oggetto nella scena (a destra del nemico).

Rileva quando il nemico si scontra con l’oggetto “Sinistra”.

Crea un nuovo evento.
Aggiungi una condizione di collisione che controlla se l’oggetto “melma” è in collisione con l’oggetto “sinistra”.

Modificare il valore della variabile “direzione”.

Aggiungere l’azione Modifica il testo di una variabile di un oggetto all’evento.
Nel campo Variabile, digita “direzione”.
Dal menu a discesa del segno di modifica, seleziona = (imposta su).
Nel campo Valore, digita “sinistra” (tra virgolette).

Capovolgi l’oggetto “Slime”.

1. Aggiungi l’azione Capovolgi l’oggetto orizzontalmente all’evento.
2. Imposta l’opzione Attiva capovolgimento su Sì.

Ciò garantisce che l’oggetto “Slime” cambi e sia rivolto in una direzione diversa, anziché semplicemente cambiare direzione.

1. Aggiungi l’azione Aggiungi una forza (angolo) all’evento.
2. Nel campo Oggetto, seleziona “Slime”.
3. Nel campo Angolo, digita “180”.
4. Nel campo Velocità, digita “100”.
5. Abilita l’opzione Istantaneo.
6. Fare clic su OK.

Se visualizzi l’anteprima del gioco, il nemico cambia direzione quando si scontra con l’oggetto “Sinistra”.

Nascondi l’oggetto “Sinistra”.

1. Crea un nuovo evento.
2. Aggiungere la condizione All’inizio della scena all’evento.
3. Aggiungi l’azione Nascondi all’oggetto “Sinistra”.

Se visualizzi l’anteprima del gioco, il nemico sembra cambiare direzione secondo la propria “scelta”.

Ventiduesimo passo: uccidi il giocatore

Quando il giocatore si scontra con un nemico, il giocatore dovrebbe morire. Un modo semplice per “uccidere” il giocatore è eliminare l’oggetto “Giocatore” se si scontra con un nemico.

Per eliminare l’oggetto “Giocatore” se si scontra con un nemico:

1. Crea un nuovo evento.
2. Aggiungi una condizione di collisione che controlla se l’oggetto “Giocatore” è in collisione con l’oggetto “melma”.
3. Aggiungi la condizione È sul pavimento all’oggetto “Giocatore”. Ciò garantisce che il giocatore muoia solo se si trova sulla piattaforma (cioè non saltando).
4. Aggiungi l’azione Elimina un oggetto all’evento che elimina l’oggetto “Giocatore”.

Se visualizzi l’anteprima del gioco, imbatterti nel nemico ti ucciderà.

Ventitreesimo passo: uccidi il nemico.

Se un giocatore salta su un nemico, il nemico dovrebbe morire. Simile al passaggio precedente, “morte” in questo caso significa eliminare l’oggetto “Slime”.

Per eliminare l’oggetto “Slime” quando un giocatore ci salta sopra:

Crea un nuovo evento.
Aggiungi una condizione di collisione che controlla se l’oggetto “Giocatore” è in collisione con l’oggetto “melma”.
Aggiungi la condizione Sta cadendo all’oggetto “Giocatore”. Ciò garantisce che il nemico muoia solo se il giocatore sta saltando (cioè non sulla piattaforma).
Aggiungi l’azione Elimina un oggetto all’evento che elimina l’oggetto “Slime”.

Se visualizzi l’anteprima del gioco, puoi saltare sul nemico per ucciderlo.

Ventiquattresimo passo: rimbalza sulla testa del nemico.

In molti giochi platform, quando il giocatore salta su un nemico, il giocatore rimbalza sulla testa del nemico. Questo rende l’uccisione di un nemico più fluido. Per far rimbalzare il giocatore sulla testa del nemico:

• Aggiungi l’azione Consenti di nuovo di saltare all’oggetto “Giocatore”.
• Aggiungi l’azione Simula la pressione del tasto di salto all’oggetto “Giocatore”.

Se visualizzi l’anteprima del gioco, rimbalzerai sulla testa del nemico quando lo ucciderai.

Ventiquattresimo passo: Crea un oggetto per il checkpoint

Il primo passo è creare un oggetto “Checkpoint”. A questo punto del tutorial, questo dovrebbe essere un processo familiare. Se hai bisogno di un aggiornamento, fai riferimento a Oggetti.

Per creare un oggetto per il checkpoint:

1. Crea un oggetto Sprite chiamato “Checkpoint”.
2. Usa la risorsa “bush.png” come immagine per il checkpoint.
3. Trascina una o più istanze dell’oggetto nella scena.

Salva le coordinate del giocatore quando raggiunge un checkpoint

Quando il giocatore raggiunge un checkpoint, puoi usare le variabili per salvare le coordinate di quel checkpoint. Quindi, quando il giocatore muore, puoi rimandarlo a quelle coordinate.

È possibile accedere alle coordinate X e Y di un oggetto con la seguente sintassi:

ObjectName.X()
ObjectName.Y()

Queste affermazioni sono entrambi esempi di espressioni.

Per salvare le coordinate dell’oggetto “Player” quando raggiungono un checkpoint:

1. Crea un nuovo evento.
2. Crea una condizione di Collisione che controlli se l’oggetto “Giocatore” è entrato in collisione con l’oggetto “Punto di controllo”.
3. Crea un valore di un’azione di variabile di scena che crea una variabile “CheckpointX” con un valore di Checkpoint.X().
4. Crea un valore di un’azione di variabile di scena che crea una variabile “CheckpointY” con un valore di Checkpoint.Y().

Venticinquesimo passo: Manda il giocatore al checkpoint precedente

Quando l’oggetto “Player” entra in collisione con l’oggetto “Slime”, l’azione Elimina un oggetto elimina l’oggetto “Player” dalla scena. Ma dal momento che il gioco ha ora dei checkpoint, non ha senso eliminare l’oggetto “Giocatore”.

Per rimandare l’oggetto “Player” al checkpoint precedente:

1. Rimuovere l’azione Elimina un oggetto.
2. Crea una posizione di un’azione dell’oggetto per l’oggetto “Giocatore”.
3. Per ciascuno dei campi del segno di modifica, selezionare = (impostare su).
4. Impostare la coordinata della posizione X su Variabile (CheckpointX).
5. Impostare la coordinata della posizione Y su Variabile (CheckpointY).

Se visualizzi l’anteprima del gioco, morire dopo aver raggiunto un checkpoint ti rimanda al checkpoint.

Ventiseiesimo passo: Imposta le coordinate predefinite del giocatore

Le variabili CheckpointX e CheckpointY non esistono finché il giocatore non raggiunge un checkpoint, quindi se un giocatore muore prima di raggiungere un checkpoint, GDevelop rimanda il giocatore alle coordinate predefinite di “0,0”.

Ciò potrebbe causare un problema se:

• Esiste qualcos’altro alle coordinate predefinite (come un nemico).
• Non c’è una piattaforma sotto le coordinate predefinite.

Per risolvere questo problema, impostare il valore delle variabili CheckpointX e CheckpointY sulle coordinate iniziali dell’oggetto “Player”. Quindi le coordinate predefinite sono definite da dove posizioni l’oggetto “Player” nell’editor delle scene.

Per impostare le coordinate predefinite:

1. Crea un nuovo evento.
2. Aggiungere la condizione All’inizio della scena all’evento.
3. Crea un valore di un’azione di variabile di scena che crea una variabile “CheckpointX” con un valore di Player.X().
4. Crea un valore di un’azione di una variabile di scena che crea una variabile “CheckpointY” con un valore di Player.Y().}}

Hai raggiunto la fine di questo tutorial. Congratulazioni!

linktree

Dlive l’alternativa di Twich pagante