Share
Nel tutorial precedente abbiamo finalmente spostato il nostro gioco e aggiunto movimento ai nostri blocchi. Inoltre, abbiamo creato un sistema di difficoltà rudimentale per rendere il gioco più difficile man mano che il giocatore gioca più a lungo.
Con entrambe queste funzionalità nel gioco, siamo pronti per implementare il sistema che eliminerà le partite pre-fatte dal tabellone. Anche se questo non è l'ultimo articolo della serie, questo è l'ultimo grande sistema che dobbiamo implementare - quindi mettiti comodo, perché abbiamo il nostro lavoro tagliato fuori per noi.
Ecco una demo del gioco a cui stiamo lavorando in questa serie:
Prima di iniziare con la parte principale di questo tutorial, voglio dedicare un minuto alla correzione di due problemi che ho scoperto mentre stavo scrivendo il tutorial precedente.
Il primo numero a cui mi riferisco si presenta nello scenario che puoi vedere di seguito:
In questa situazione, se trascini Blocco B sul punto verde, dovrebbe cadere a causa degli spazi vuoti sotto il punto e alla fine atterrare nel punto etichettato C. Nella maggior parte degli scenari, ciò avverrà e il gioco funzionerà normalmente, ma in alcuni scenari il gioco rileverà invece una partita nel breve momento in cui Blocco B è vicino al gruppo UN e finirà per distruggere tutti e tre i blocchi.
Questo problema non è esclusivo di quello scenario sopra e può anche presentarsi quando fai la stessa cosa nello scenario che ho evidenziato di seguito.
Se non risolviamo questo problema, il giocatore riceverà credito e punti per un numero di partite che non ha mai inteso fare e potrebbe anche confondersi sul motivo per cui così tanti blocchi stanno scomparendo inaspettatamente.
Per fortuna, però, questo è un problema semplice da risolvere. Per risolvere questo problema creeremo un nuovo Variabile globale chiamato MatchesPossible che determinerà se le partite possono essere fatte e un nuovo evento che rileverà quando un blocco sta "cadendo" e si modificherà MatchesPossible per fare in modo che non si possano fare match mentre questo sta accadendo.
Per prima cosa creeremo la variabile globale:
Variabile globale: MatchesPossible Type = Number Initial Value = 1
La tua nuova variabile dovrebbe apparire così:
Ora creeremo l'evento che ascolterà quando cadrà un blocco:
Evento: Condizione: Inverti: Blocca> Si sovrappone all'offset Oggetto = Blocchetto Offset X = 0 Offset Y = 8 Condizione: Blocca> Confronto Confronto Y = Minore o uguale Coordinata Y = SPAWNY Azione: Sistema> Imposta valore Variabile = MatchesPossibile Valore = 1
Questo evento fa in modo che quando si trova un blocco abbia uno spazio vuoto al di sotto di esso MatchesPossible è impostato per 1, significa che le partite non sono possibili. Noterai anche che controlla la posizione Y del blocco. Questo per garantire che il blocco non si trovi sulla fila di blocchi più bassa che avrà sempre uno spazio vuoto al di sotto di esso.
Successivamente, abbiamo bisogno di un evento che imposta MKatchesPossible di nuovo a 0 quando nessun blocco ha uno spazio vuoto sotto di loro. Questo secondo evento sarà basato su una condizione di Else:
Evento: Condizione: Sistema> Altrimenti Azione: Sistema> Imposta valore Variabile = Corrisponde Valore possibile = 0
Assicurati che questo evento segua immediatamente il primo evento in modo che l'istruzione Else sia utilizzata correttamente.
I tuoi due nuovi eventi dovrebbero assomigliare a questo:
Infine, aggiungeremo una nuova condizione a CheckMatches in modo che guardi MatchesPossible per determinare se una partita può essere fatta. Aggiungi questa condizione alla chiamata della funzione iniziale di CheckMatches Evento.
Condizione: Sistema> Confronta variabile Variabile = Corrispondenze Confronto possibile = Uguale a Vale = 0
Con la condizione aggiunta, la tua CheckMatches L'evento dovrebbe ora assomigliare a questo:
Diversamente dalla maggior parte dei problemi che abbiamo riscontrato fino a questo punto, questo problema si presenta su una base abbastanza incoerente. Ciò significa che non possiamo realmente verificare se abbiamo risolto il problema, possiamo solo verificare se abbiamo causato altri problemi. Se giochi ora, dovresti vedere che nessun problema è stato causato da questa condizione.
Il secondo problema che volevo risolvere prima di aggiungere qualcosa di nuovo riguarda il sistema Points.
Mentre stavo lavorando al progetto per questo tutorial, ho notato che qualcosa che facevo faceva sì che il sistema Points si comportasse in modo strano e dava al giocatore quattro o cinque volte più punti di quelli che dovrebbero ottenere per ogni partita. Anche se non sono stato in grado di determinare quale cambiamento ho fatto ha causato che questo accada, ho scoperto che la radice del problema era che il GivePoints la funzione veniva effettivamente chiamata più volte da quando i blocchi non venivano distrutti immediatamente. Per fortuna, come il nostro ultimo numero, questo può essere risolto facilmente.
Per risolvere questo problema creeremo una nuova variabile che dirà al sistema se può dare punti. Quindi, ogni volta che stiamo per usare il GivePoints funzione modificheremo anche la variabile per garantire che l'evento si attivi solo una volta. Alla fine, una volta che i punti sono stati assegnati, cambieremo la variabile ancora una volta in modo che non ci sia un problema la prossima volta che proviamo a dare punti.
Per prima cosa, crea una variabile globale chiamata PointsGiven:
Variabile globale: Tipo PointsGiven = Numero Valore iniziale = 0
La tua variabile dovrebbe essere così:
Successivamente modificheremo la parte del FindMatches funzione che dà effettivamente i punti aggiungendo una nuova condizione e due nuove azioni.
Condizione: Sistema> Confronta variabile Variabile = PointsGiven Confronto = Uguale a Valore = 0
Ora aggiungi questa azione all'inizio dell'elenco delle azioni:
Azione: Sistema> Imposta valore Variabile = Valore punti calcolato = 1
Infine, aggiungi questa azione alla fine dell'elenco delle azioni:
Azione: Sistema> Imposta valore Variabile = Valore punti calcolato = 0
L'evento dovrebbe ora assomigliare a questo:
Con queste modifiche abbiamo fatto in modo che l'evento che chiama GivePoints funzionerà solo quando il PointsGiven la variabile è 0. Dal momento che stiamo impostando immediatamente il valore su 1 quando iniziamo l'Evento, questo impedisce all'Evento di sparare più di una volta e assicura al giocatore di ricevere il numero corretto di punti.
Se esegui il gioco a questo punto dovresti ricevere il numero corretto di punti per ogni partita che fai, anche se non avevi questo problema per cominciare.
Ora che abbiamo risolto questi problemi, possiamo passare alla creazione del sistema che eliminerà le corrispondenze generate dal sistema quando assegna casualmente i colori ai blocchi che crea.
Il problema che abbiamo ora è che, poiché i colori del blocco sono del tutto casuali, non è insolito iniziare il gioco e vedere subito un gruppo di partite. Questo è un problema perché potrebbe rendere i primi secondi del gioco molto confusi per qualcuno che non ha mai giocato prima, e perché sta dando ai giocatori punti che non hanno guadagnato.
Per risolvere il problema, creeremo una funzione che esaminerà ciascun blocco e quindi vedrà se quel blocco è dello stesso colore di uno qualsiasi dei suoi vicini. Se è dello stesso colore di uno dei suoi vicini, continuerà a cambiare il colore di quel blocco finché non corrisponde più a nessuno dei blocchi che lo circondano.
Per far funzionare questo sistema dovremo anche creare più funzioni di supporto ed eventi, e aggiungere una nuova variabile di istanza a Bloccare oggetto.
Innanzitutto, crea una nuova variabile di istanza per il Bloccare oggetto:
Variabile di istanza: BlockID Tipo = Numero Valore iniziale = 0
Questa variabile è ciò che useremo per identificare facilmente un blocco in modo che possiamo dire alcune delle funzioni che stiamo andando a fare esattamente quale blocco vogliamo guardare, indipendentemente dalla sua posizione.
Prima di procedere, dobbiamo anche iniziare a utilizzare questa variabile. Vai al All'inizio del layout Evento che crea i blocchi e aggiunge una nuova Azione prima dell'Azione che aumenta NumBlocks:
Azione: Blocco> Imposta valore Variabile istanza = BlockID Valore = NumBlocks
L'evento di generazione dei blocchi dovrebbe ora apparire come questo:
Quindi dobbiamo creare una funzione che includa la posizione X e Y di un blocco e dicci di che colore è quel blocco:
Evento: Condizione: Funzione> On function Name = "GetBlockColor" Evento secondario: Condition: Block> Compare X Comparison = Equal to X coordinate = Function.Param (0) Condizione: Block> Compare Y Comparison = Equal to Y co -ordinate = Function.Param (0) Azione: Funzione> Imposta valore di ritorno Valore = Block.Color Evento secondario: Sistema> Else Azione: Funzione> Imposta valore di ritorno Valore = -1
La funzione dovrebbe apparire così quando è terminata:
Ora che abbiamo una funzione che può dirci il colore di qualsiasi blocco, creeremo la funzione che effettivamente guarderà un blocco e determinerà se ha blocchi vicini dello stesso colore.
Il modo in cui funziona questa funzione è abbastanza semplice.
Prima di poter realizzare questo evento, dobbiamo creare una nuova variabile globale. Nella funzione useremo un ciclo While per determinare se il colore del blocco deve essere cambiato. La variabile che stiamo per creare è la variabile utilizzata da While Loop per determinare se è necessario continuare a eseguire:
Variabile globale: HasMatchingNeighbor Type = Number Initial Value = 0
Mancia:L'evento che stiamo per realizzare contiene un evento basato su Or. Se non hai mai creato un blocco Eventi con un attributo Or tutto ciò che devi fare è creare il blocco eventi come faresti normalmente, quindi fare clic con il pulsante destro del mouse sull'intero blocco e scegliere Crea 'O' Block. A differenza di un blocco eventi standard che richiede che tutte le condizioni vengano riempite prima che esploda, un blocco O sparerà se qualunque condizione è soddisfatta.
Quindi, facciamo l'evento:
Accentsconagua
Evento: Condizione: Funzione> On function Name = "RemoveSpawnedMatches" Evento secondario: Condition: Block> Confronta variabile di istanza Variabile di istanza = BlockID Comparison = Equal to Value = Function.param (0) Azione: Sistema> Imposta valore Variable = HasMatchingNeighbor Value = 1 Sotto-evento: Condizione: Sistema> While Condizione: Sistema> Confronta variabile Variabile = HasMatchingNeighbor Confronto = Uguale a Valore = 1 Sotto-evento: Condizione: Blocco> Confronta variabile istanza Variabile istanza = Confronto colore = Uguale a Valore = Funzione. Chiama ("GetBlockColor", Block.X - (Block.Width + 2), Block.Y) Azione: Blocco> Imposta valore Variabile istanza = Colore Valore = piano (Random (1,7)) Azione: Sistema> Imposta valore Variabile = HasMatchingNeighbor Value = 1 Sub-Event: Condizione: System> Else Condition: Block> Confronta istanza variabile Instance variable = Color Comparison = Equal to Value = Function.Call ("GetBlockColor", Block.X + (Block.Width + 2) , Block.Y) Azione: Blocco> Imposta valore Variabile istanza = Colore Valore = piano (Random (1,7)) Azione: Sistema> Imposta valore Variabile = HasMatchingNeighbor Valore = 1 Sottoevento: Condizione: Sistema> Altro Condizione: Blocco> Confronta variabile di istanza Variabile di istanza = Confronto colore = Uguale a Valore = Funzione.Chiave ("GetBlockColor", Block.X, Block.Y - (Block.Width + 2)) Azione: Block> Imposta valore Instance variable = Color Value = floor (Random (1,7)) Azione: Sistema> Imposta valore Variable = HasMatchingNeighbor Value = 1 Sotto-evento: Condition : Sistema> Else Condizione: Blocco> Confronta variabile di istanza Variabile di istanza = Confronto colore = Uguale a Valore = Funzione.Chiave ("GetBlockColor", Block.X, Block.Y + (Block.Width + 2)) Azione: Blocca> Imposta valore Istanza variabile = Colore Valore = piano (Random (1,7)) Azione: Sistema> Imposta valore Variabile = HasMatchingNeighbor Valore = 1 Sotto-evento: Condizione: Sistema> Altro azione: Sistema> Imposta valore Variabile = Valore HasMatchingNeighbor = 0 Il tuo evento dovrebbe assomigliare a questo:
Quindi, come funziona esattamente questa funzione?
La prima cosa che fa è controllare a Bloccare con il BlockID che il sistema è passato. Quando lo individua Bloccare imposta il valore di HasMatchingNeighbors a 1 e quindi esegue il ciclo While.
Poiché il ciclo While verrà eseguito solo quando HasMatchingNeighbors è 1, questo è il valore a cui lo imposta. Durante il ciclo While, verifica se c'è un vicino Bloccare a sinistra, a destra, sopra o sotto che è dello stesso colore del Bloccare stiamo guardando. Se trova una corrispondenza Bloccare nel qualunque di queste posizioni, assegna casualmente un nuovo colore al Bloccare e quindi esegue nuovamente il test assicurando HasMatchingNeighbors è impostato per 1. Quando finalmente trova un colore per il Bloccare che non corrisponde a nessuno dei suoi vicini, cambia il valore di HasMatchingNeighbors a 0 in modo che il ciclo While termini e il programma possa proseguire.
Ora dobbiamo implementare questa funzione nel gioco; per fare questo dovremo creare due nuove variabili e due nuove funzioni. Iniziamo con le variabili.
Variabile globale: CheckStartingMatches Tipo = Numero Valore = 0
Variabile globale: CheckNewestRow Type = Number Value = 0
Le tue variabili dovrebbero assomigliare a questo:
Le due variabili che abbiamo appena creato verranno utilizzate per attivare i due eventi che stiamo per creare. Gli eventi stessi verranno utilizzati per scorrere i blocchi immediatamente dopo la loro creazione e inviare ogni blocco nel RemoveSpawnedMatches funzione.
La ragione per cui non stiamo solo chiamando il RemoveSpawnedMatches la funzione immediatamente dopo aver creato il blocco è perché la griglia dei blocchi deve essere completa affinché la funzione funzioni correttamente. Quindi, invece di chiamare la funzione direttamente quando vengono creati i blocchi, verrà invece attivato un evento che può attraversare i blocchi e chiamare la funzione da sola dopo che la griglia è stata generata.
Il primo evento sarà specificamente per iterare attraverso il gruppo iniziale di blocchi:
Evento: Condizione: Sistema> Confronta variabile Istanza variabile = CheckStartingMatches Confronto = Uguale a Valore = 1 Condizione: Sistema> Per Nome = "Blocchi" Inizio indice = 0 Fine indice = NumBlocks-1 Azione: Funzione> Funzione chiamata Nome = "RimuoviSpawnedMatches" Parametro 0 = loopindex ("Blocks") SubEvent: Condizione: Sistema> Confronta due valori First value = loopindex ("Blocks") Comparison = Equal to Second value = NumBlocks-1 Azione: System> Imposta variabile Instance variable = CheckStartingMatches Value = 0 Questo dovrebbe essere il tuo evento:
Il secondo evento sarà specifico per il controllo di nuove righe di blocchi quando vengono creati:
Evento: Condizione: Sistema> Confronta variabile Variabile di istanza = CheckNewestRow Confronto = Uguale a Valore = 1 Condizione: Sistema> Per Nome = "Blocchi" Indice iniziale = NumBlocks-9 Indice finale = NumBlocks-1 Azione: Funzione> Funzione chiamata Nome = " RemoveSpawnedMatches "Parametro 0 = loopindex (" Blocks ") SubEvent: Condizione: Sistema> Confronta due valori First value = loopindex (" Blocks ") Comparison = Equal to Second value = NumBlocks-1 Azione: System> Imposta variabile Instance variable = CheckNewestRow Value = 0 Questo è come dovrebbe apparire il secondo Evento:
Con entrambe queste funzioni in atto, ora abbiamo solo bisogno di implementarle. Vai all'evento iniziale che crea i blocchi, il All'inizio del layout Evento. Aggiungeremo un sotto-evento a questo che dirà al CheckStartingMatches Evento da attivare.
Sotto-evento: Condizione: Sistema> Confronta due valori Primo valore = loopindex ("X") Confronto Secondo valore: 7 Condizione: Sistema> Confronta due valori Primo valore = loopindex ("Y") Confronto Secondo valore: 3 Azione: Sistema> Imposta valore Variabile istanza = Valore CheckStartingMatches = 1 Il tuo evento dovrebbe ora assomigliare a questo:
Questo sotto-evento è in ascolto quando termina il ciclo nidificato di For e quindi cambia il valore di CheckStartingMatches variabile per attivare l'evento appropriato.
Ora faremo quasi lo stesso identico sotto-evento e lo collegheremo al SpawnNewBlocks funzione.
Sotto-evento: Condizione: Sistema> Confronta due valori Primo valore = loopindex ("X") Confronto Secondo valore: 7 Azione: Sistema> Imposta valore Variabile istanza = Valore CheckNewestRow = 1 SpawnNewBlocks ora dovrebbe assomigliare a questo:
Questo Sub-Evento fa la stessa cosa del precedente tranne che attiva l'altro Evento che abbiamo creato. Se esegui il gioco a questo punto dovresti vedere che quando inizi il gioco non ci sono più partite che si verificano automaticamente.
In questo tutorial, non abbiamo apportato troppe modifiche al gioco, ma quelle che abbiamo realizzato erano molto importanti.
A questo punto, penso che sia meglio per noi fermarci per ora e salvare gli ultimi due elementi del gioco per il prossimo tutorial, dove tratteremo le catene / combo e lo schermo Game Over. Questa sarà la parte finale della serie, quindi parlerò anche di alcune meccaniche di gioco che non tratteremo in questi tutorial e ti fornirò alcuni consigli su come potresti realizzare quei sistemi da solo.
Se vuoi ottenere un vantaggio sui contenuti della prossima settimana, inizia a guardare come potresti scoprire quando la schermata Game Over dovrebbe apparire, in base alla posizione o all'altezza di alcuni dei blocchi. In alternativa, inizia a pensare a come puoi rilevare quando il giocatore fa una reazione a catena che causa la formazione di più di un gruppo.
Qualunque cosa tu faccia, spero di rivederti qui la prossima settimana per l'ultima puntata della serie.
