Share
Siamo ora a metà di questa serie, e finora abbiamo coperto molto. Nel precedente tutorial, abbiamo aggiunto un sistema di punti al nostro gioco, abbiamo finalmente applicato la "gravità" ai blocchi e abbiamo migliorato il nostro sistema di corrispondenza. In questo tutorial faremo alcuni piccoli miglioramenti al nostro sistema di scambio, aggiungiamo il testo di punti fluttuanti che puoi vedere nella versione finale del gioco, e finiamo il nostro sistema di abbinamento una volta per tutte.
Ecco una demo del gioco a cui stiamo lavorando in questa serie:
In questo momento, il gioco ha implementato una meccanica di scambio molto semplice. Mentre il sistema che utilizziamo per eseguire questi swap è molto efficace, ci sono due problemi che potresti incontrare mentre giochi, ed entrambi dovrebbero essere risolti prima di andare avanti.
Questi problemi derivano dalla stessa idea: che il sistema di scambio non tiene conto dei confini del campo di gioco.
Cosa significa esattamente? Bene, in primo luogo, se lo si desidera, è possibile spostare un blocco al di fuori del campo di gioco a sinistra oa destra, effettuando uno scambio come quello illustrato di seguito:
Se entri nel gioco e fai lo scambio, vedrai che il gioco non fa nulla per fermarti e agisce come se il campo di gioco continuasse per sempre in una direzione orizzontale. La ragione di questo è che, proprio ora, il campo di gioco fa continuare per sempre orizzontalmente.
Dato che non abbiamo mai definito dove sono i bordi sinistro e destro del campo di gioco, o anche che il campo di gioco ha i bordi sinistro e destro, il gioco non tenta mai di impedire al giocatore di spostare il blocco più in là. Questo problema si verifica anche quando ti sposti dall'altro lato del campo di gioco.
Per risolvere questo problema, aggiungeremo alcune nuove condizioni al Block> On DragDrop drop Evento. Vai a questo evento e aggiungi questa condizione al Sub-Evento che controlla gli swap a sinistra:
Condizione: LeftBlock> Confronto X Confronto = Maggiore o uguale X = SPAWNX
Ora aggiungi questa condizione al Sub-Evento che controlla gli swap a destra:
Condizione: RightBlock> Confronto X Confronto = minore o uguale X = SPAWNX + Block.Width * 8
I tuoi eventi di scambio sinistro e destro ora dovrebbero assomigliare a questo:
Queste nuove condizioni che abbiamo aggiunto vengono utilizzate dagli eventi di swap come controllo per garantire che lo scambio sia all'interno dei bordi orizzontali del campo di gioco. Il primo assicura che la posizione in cui il blocco verrebbe scambiato non è più a sinistra dei Blocchi di sinistra, e il secondo assicura che la posizione in cui il blocco viene scambiato non sia più a destra di quella di destra. la maggior parte dei blocchi.
Con il secondo, ho usato una formula con Block.Width per trovare dove sono i blocchi più a destra per garantire che, se la dimensione dei blocchi fosse cambiata, non impedirebbe a questa condizione di funzionare.
Se esegui il gioco non dovresti più essere in grado di fare swap orizzontali che metterebbero blocchi fuori dall'area di gioco.
L'altro problema che abbiamo è che il gioco non ti impedisce di scambiare un blocco sotto il campo di gioco. Apri il gioco e prova a fare uno scambio come quello che ho illustrato in questa immagine:
Dopo aver effettuato questo scambio, avresti dovuto vedere il blocco essenzialmente scomparire dietro il pezzo inferiore del campo di gioco, ei blocchi che erano sopra di esso dovrebbero essere caduti per riempire lo spazio ora vuoto. Di nuovo, questo problema è perché non abbiamo mai definito dove si trova il bordo inferiore del campo.
Nel tutorial precedente abbiamo dichiarato che i blocchi dovrebbero smettere di cadere dopo aver raggiunto una certa altezza, ma non abbiamo mai detto se fosse ok se un blocco andasse sotto quell'altezza quando si esegue uno swap.
Risolvere questo sarà semplice come i due problemi precedenti. Vai all'evento secondario che verifica gli swap verso il basso e aggiungi questa condizione:
Condizione: BottomBlock> Confronta confronto Y = minore o uguale Y = SPAWNY
Il tuo codice per questa sezione dovrebbe ora assomigliare a questo:
Proprio come la condizione precedente, ciò garantisce che lo scambio non metta il blocco in un'area al di fuori del campo di gioco. In questo caso, guarda l'area sotto il campo di gioco.
Se testi il tuo gioco a questo punto, non dovresti riuscire a fare swap che mettono il blocco sotto la base del campo di gioco.
A questo punto, abbiamo risolto i problemi con il sistema di scambio e possiamo passare a migliorare ulteriormente il nostro sistema di punti.
In questo momento, il nostro sistema di punti è piuttosto efficace. Funziona come volevamo e mostra già tutto correttamente. Nonostante ciò, però, se hai dato il gioco a un giocatore e li hai fatti accomodare, potrebbero non essere in grado di dire esattamente quanti punti stavano ottenendo da ogni gruppo che hanno fatto, poiché il gioco può muoversi velocemente.
Per risolvere questo problema, aggiungeremo dei pop-up di testo che mostrano quanti punti il giocatore fa da ogni gruppo che formano. Ciò aggiungerà un tocco visivo al gioco, e renderà chiaro al giocatore quanto possono essere preziosi i gruppi più grandi.
Prima di poter aggiungere la funzionalità, dobbiamo creare un nuovo oggetto che fungerà da pop-up di testo, quindi segui questi passaggi.
Accentsconagua
FloatingPointsText Campo di gioco 616, 250 127, 43 0 Calibri, grassetto, 24 255, 255, 255 1.25.L'oggetto che abbiamo appena creato verrà utilizzato per creare il testo mobile che indica al giocatore quanti punti darà un determinato gruppo. Ora che abbiamo questo oggetto, dobbiamo implementarlo in modo che quando il giocatore fa una corrispondenza, genererà una nuova istanza dell'oggetto e cambierà il testo per mostrare il numero appropriato di punti.
Per generare il testo dei punti aggiungeremo due nuove azioni al NumMatchesFound controlla in FindMatches funzione.
Vai al FindMatches funzione e aggiungi queste due azioni alla fine di ciascuna NumMatchesFound> 3 dai un'occhiata:
Azione: Sistema> Crea oggetto Object = FloatingPointsText Layer = 2 X = Block.X - Block.Width / 2 Y = Block.Y - Block.Width / 2 Azione: FloatingPointsText> Imposta testo Text = NumMatchesFound * 10
Il tuo FindMatches la funzione dovrebbe ora assomigliare a questa:
Quindi cosa stanno facendo queste azioni? La prima azione crea il FloatingPointsText oggetto sopra il primo blocco nel gruppo e il secondo moltiplica il numero di blocchi nel gruppo per 10, proprio come fa la nostra formula punti e imposta il testo del nuovo oggetto su quel numero.
Se esegui il gioco a questo punto, dovresti notare che il testo non si muove affatto. Per risolvere questo problema aggiungeremo un nuovo evento al nostro gioco.
Ritornare a Scheda evento 1 e aggiungi un nuovo evento:
Condizione: Sistema> Ogni zecca Azione: FloatingPointsText> Sposta ad angolo = = 90 Distanza = 0,25
Il tuo nuovo evento dovrebbe assomigliare a questo:
Se esegui il gioco ora, vedrai che il testo si muove.
A questo punto, il nostro FloatingPointsText funziona come vorremmo, ma potresti aver notato un leggero problema ora che il sistema è a posto. Il problema deriva dal modo in cui funziona il sistema di matching, e ora che possiamo vedere che c'è ancora un problema con la corrispondenza, possiamo impostare la risoluzione di questo problema finale e mettere a sistema il nostro sistema di abbinamento.
Se non sai ancora di quale argomento sto parlando, entra nel gioco e crea un gruppo che contiene quattro blocchi. Una volta creato il tuo gruppo, dovresti vedere qualcosa di simile a ciò che ho nell'immagine qui sotto:
Come puoi vedere, lo abbiamo davvero Due istanze degli oggetti di testo mobili. Se crei un gruppo con cinque blocchi, il problema peggiora e vedrai effettivamente tre istanze del testo dei punti.
Il motivo di questo problema si basa sul modo in cui vengono rilevate le corrispondenze. In questo momento, il nostro sistema di corrispondenza guarda individualmente ogni blocco, e guarda nella direzione giusta, e nella direzione verso il basso, per trovare le corrispondenze. Per questo motivo, il sistema di matching sta effettivamente trovando tre gruppi di dimensioni diverse qui, anche se in realtà è solo un grande gruppo.
Il primo gruppo verrà trovato quando inizia con il blocco A e conterrà cinque blocchi:
Il secondo gruppo verrà trovato quando inizia con il blocco B e conterrà quattro blocchi:
E il terzo gruppo verrà trovato quando inizia con il blocco C e conterrà tre blocchi:
Quindi, in questo momento, il nostro sistema di matching è molto inefficiente - e rotto - dal momento che sta controllando gli stessi blocchi più volte e registrando più gruppi di quelli effettivamente disponibili.
Risolvere questo problema è in realtà molto più semplice di quanto possa sembrare all'inizio.
Il problema qui deriva principalmente dal fatto che il sistema di corrispondenza non ha modo di sapere se il blocco con cui sta iniziando è in realtà l'inizio del gruppo. Se potessimo garantire che abbiamo guardato solo i Blocks che erano i più lontani a destra, o quelli più in alto, all'interno dei gruppi a cui appartenevano, allora il sistema di matching sarebbe stato efficace così com'è.
Quindi, tutto ciò che dobbiamo fare è aggiungere una condizione o evento che assicuri che non ci siano blocchi corrispondenti sopra, o alla sinistra del blocco con cui iniziamo, e per dire alla funzione quando ha eseguito questo controllo, in modo che possa procedi normalmente se il blocco che sta guardando è l'inizio del gruppo.
La prima cosa che aggiungeremo è un nuovo parametro per il CheckMatches funzione. Questo parametro sarà un numero intero e lo sarà anche 1 o 0.
Se il parametro è 1, indicherà alla funzione che ha bisogno di eseguire il controllo per assicurarsi che stia guardando il blocco iniziale nel gruppo; se è 0, indicherà la funzione che ha già eseguito questo controllo e può procedere normalmente per determinare se il gruppo è composto da tre o più blocchi.
Quindi, iniziare andando al FindMatches funzione. In questa funzione chiami CheckMatches due volte. Poiché questa è la prima volta che chiami CheckMatches per qualunque blocco tu stia guardando, devi aggiungere un nuovo parametro a ciascuna di queste chiamate di funzione e impostarlo su 1 in modo che verificherà se il blocco che sta guardando è l'inizio di un gruppo.
Il tuo FindMatches la funzione dovrebbe ora assomigliare a questo e ho evidenziato le due dichiarazioni modificate per comodità:
Ora che stiamo dicendo CheckMatches quando è necessario eseguire questo nuovo controllo, è necessario aggiungere effettivamente il nuovo controllo da eseguire. Vai al tuo CheckMatches funzione e aggiungi questo nuovo sotto-evento come primo sotto-evento:
Evento: Blocca> Confronta X Comaprison = Uguale a X = Funzione.Param (0) - ((Block.Width + 2) * Funzione.Param (3)) Condizione: Blocco> Confronta Y Comaprison = Uguale a Y = Funzione.Param (1) - ((Block.Width + 2) * Function.Param (4)) Condizione: Funzione> Confronto parametri Indice = 5 Confronto = Uguale a Valore = 1
Prima di completare la modifica di CheckMatches funzione è anche necessario aggiungere un'istruzione Else all'inizio dell'evento originale per il CheckMatches funzione, ed è necessario aggiungere il nuovo parametro al CheckMatches chiamata di funzione e impostarlo su 0.
Il nuovo codice per la funzione CheckMatch dovrebbe assomigliare a questo:
L'evento che abbiamo aggiunto fa esattamente quello che ho descritto sopra. Per prima cosa, guarda il blocco sopra, o alla sinistra di, il blocco iniziale che passi.
Se quel blocco è dello stesso colore di quello che hai passato, non fa nulla poiché sa che il blocco che hai passato non è il primo Blocco di quel gruppo.
D'altra parte, se lo è non lo stesso colore del blocco che hai passato, il controllo originale si verifica a causa dell'istruzione Else che abbiamo appena aggiunto, e cerca un gruppo di tre o più blocchi nel modo in cui normalmente sarebbe.
Se testi il gioco a questo punto e crei un gruppo con più di tre blocchi, dovresti vedere solo un oggetto di testo mobile che ti dice quanti punti quel gruppo valeva.
Ora che abbiamo finito di sistemare tutte queste funzionalità e abbiamo finalmente completato il nostro sistema di matching, siamo pronti ad implementare il sistema di movimento. Dato che abbiamo già fatto molto in questo tutorial, e dal momento che il sistema di movimento ci richiede di realizzare sistemi complessi multipli, aspetterò fino al prossimo articolo per avviare il sistema di movimento.
Se sei ansioso di iniziare a lavorarci, prendi in considerazione alcune di queste cose. Ovviamente la prima cosa che devi fare è implementare il movimento stesso. Per questo, prova a utilizzare un sistema simile a quello che abbiamo usato quando si fanno galleggiare gli oggetti di testo punti. Da lì, inizia a considerare come cambieresti la velocità con cui si muovono. Infine, come genererai nuove file di Blocchi per il giocatore, e come lo saprai quando per generare nuove righe?
Prenditi un po 'di tempo per considerare queste cose, e ti vedrò di nuovo qui la prossima settimana per la prossima grande puntata della serie.
