Share
Nel tutorial precedente, abbiamo integrato un sistema di rilevamento match di base nel nostro gioco Match-3. Mentre siamo sulla buona strada per avere un gioco giocabile, ci sono ancora alcuni elementi di gioco importanti di cui abbiamo bisogno prima che possiamo davvero definire ciò che abbiamo un "gioco". Questo articolo si concentrerà sulla compilazione di alcuni di questi dettagli mancanti e ci avvicina molto al nostro prodotto finale.
Ecco una demo del gioco a cui stiamo lavorando in questa serie:
Stiamo andando a coprire i punti prima di iniziare a migliorare il sistema di matching, perché sarà molto più facile vedere il primo problema nel nostro attuale sistema di matching se implementiamo un sistema di punti.
Il sistema di punti nel nostro gioco sarà molto semplice, per ogni blocco utilizzato per formare un determinato gruppo, il giocatore riceverà 10 punti. In un tutorial successivo aggiungeremo anche un sistema che consente al giocatore di guadagnare più punti incatenando più gruppi, ma per ora ci concentreremo solo sull'introduzione di un semplice sistema di punti per il giocatore.
Prima di iniziare a modificare gli eventi, dobbiamo aggiungere un display Punti, quindi prima vai Layout 1 e fai quanto segue:
Accentsconagua
491, 383.Calibri, grassetto, 22 utilizzando il menu a discesa.ScoreText bianca o 255, 255, 255 419, 398.200, 50.0.Layout 1 ora dovrebbe assomigliare a questo:
Ora che abbiamo qualcosa da dire al giocatore che cosa significa il testo dei punti, e un oggetto di testo con cui visualizzare il punteggio del giocatore, possiamo passare a dare effettivamente i punti del giocatore. Vai a Scheda evento 1 e creare un nuovo Variabile globale.
Nome variabile globale: "Punteggio" Tipo = Numero Valore = 0
La variabile dovrebbe apparire così:
Questa è la variabile che modificheremo ogni volta che daremo i punti giocatore. Successivamente, creeremo una nuova funzione che, quando chiamata, rileverà quanti blocchi il giocatore ha abbinato in gruppi, e darà loro il numero appropriato di punti.
Evento: Condizione: Funzione> On Function Name = "GivePoints" Condizione: Sistema> Per ogni oggetto = Condizione blocco: Blocco> Variabile istanza booleana Imposta variabile istanza = IsMatched Azione: Sistema> Aggiungi a variabile = Valore punteggio = 10 Azione: ScoreText > Imposta testo Testo = Punteggio
Il tuo codice dovrebbe assomigliare a questo:
Quindi, per ribadire, questo evento riguarda ogni singolo blocco. Ogni volta che trova un blocco che ha IsMatched impostato vero - il che significa che è stato confermato essere parte di un gruppo - fornisce al giocatore 10 punti per quel blocco e aggiorna il testo del punteggio.
Se testerai il tuo gioco a questo punto, sembrerà che la funzione non funzioni. Il motivo è che non abbiamo effettivamente chiamato la funzione in nessun punto del codice, quindi i punti non vengono mai incrementati e il testo non viene mai aggiornato. Vai al tuo FindMatches funzione e aggiungere una nuova azione all'inizio dell'evento secondario finale per questa funzione.
Azione: Funzione> Call function Name = "GivePoints"
Il tuo FindMatches la funzione dovrebbe ora assomigliare a questa:
Nota: assicurarsi di aver aggiunto questa nuova azione all'inizio del sotto-evento. Se aggiungi questa azione fino alla fine, non funzionerà poiché tutti i blocchi abbinati saranno stati distrutti prima del GivePoints la funzione è chiamata. Ciò significa che, quando cerca i blocchi abbinati, non ne troverà nessuno e quindi il giocatore non riceverà alcun punto.
A questo punto puoi testare di nuovo il tuo gioco e dovresti vedere l'aggiornamento del testo dei punti e che il giocatore riceve il numero corretto di punti per ogni partita che fanno.
Ora che abbiamo il sistema di punti, voglio che tu esegua il gioco e crei lo scenario mostrato di seguito.
Ora scambia i blocchi che ho evidenziato qui e guarda il tuo punteggio per vedere quanti punti ottieni.
Quando hai formato questa partita, avresti dovuto vedere che hai guadagnato 50 punti. Questo perché, attualmente, il sistema di punti dà al giocatore 10 punti per ogni blocco contrassegnato come IsMatched, al contrario di dare al giocatore 10 punti per ogni blocco Usato in ogni partita, come il sistema che ho descritto sopra.
Se il sistema di punti funzionasse correttamente, darebbe al giocatore 60 punti: 30 per il gruppo verticale di tre Blocchi e 30 per il gruppo orizzontale di tre Blocchi. Questo problema deriva dal fatto che il sistema di corrispondenza non ha alcun modo di segnare quando un blocco è abbinato sia orizzontalmente e verticalmente; sa solo se il blocco è stato abbinato.
Per risolvere questo problema, aggiungeremo due nuovi Variabili di istanza al nostro oggetto Block, MatchedX e MatchedY.
Variabile di istanza: Nome = MatchedX Tipo = Booleano Valore iniziale = falso Variabile di istanza: Nome = TipoY abbinato = Valore iniziale booleano = falso
Le tue variabili dovrebbero assomigliare a questo:
Queste variabili saranno usate insieme a IsMatched per dire al sistema quando il blocco è parte di orizzontale, o X, gruppi, e quando il blocco fa parte dei gruppi verticali, o Y,. Ora che abbiamo le variabili, modificheremo il CheckMatches funzione in modo che quando si etichetta un blocco IsMatched poiché ha trovato un gruppo abbastanza grande, etichetterà anche tale blocco come parte di un gruppo X o Y a seconda che il parametro 3 o il parametro 4 sia 1.
Vai al CheckMatches funzione e sostituire l'originale NumMatchesFound controlla con questi due nuovi sotto-eventi:
Sotto-evento: Condizione: Sistema> Confronta due valori Primo valore = Funzione.Param (3) Confronto = Uguale a Secondo valore = 1 Condizione: Sistema> Confronta variabile Variabile = NumMatchesFondo Confronto = Maggiore o uguale Valore = 3 Azione: Blocco> Imposta Variabile istanza booleana = IsMatched Valore = True Action: Block> Imposta variabile booleana = MatchedX Value = True Sotto-evento: Condizione: Sistema> Confronta due valori Primo valore = Funzione.Param (4) Confronto = Uguale a Secondo valore = 1 Condizione : Sistema> Confronta variabile Variabile = NumMatchesFound Confronto = Maggiore o uguale Valore = 3 Azione: Blocca> Imposta variabile dell'istanza booleana = IsMatched Valore = True Azione: Blocca> Imposta variabile dell'istanza booleana = Valore MatchedY = True
Il tuo CheckMatches la funzione dovrebbe ora assomigliare a questa:
Quindi la nuova versione di CheckMatches funziona allo stesso modo del precedente, tranne che ora controlla anche se il blocco è stato trovato come una corrispondenza in un gruppo verticale o in un gruppo orizzontale ed etichetta il blocco di conseguenza con le nuove variabili MatchedX e MatchedY.
Ora che abbiamo un modo per determinare quando un blocco è abbinato verticalmente, abbinato orizzontalmente e abbinato in entrambe le direzioni, al contrario di sapere solo che è stato abbinato in un gruppo, dobbiamo aggiungere un sotto-evento al GivePoints funzione che distribuirà 10 punti extra per un blocco che ha entrambi MatchedX e MatchedY impostato su true.
Vai al GivePoints funzione e aggiungi questo sotto-evento:
Sotto-evento: Condizione: Blocco> È una variabile di istanza booleana impostata Variabile di istanza = AbbinataX Condizione: Blocco> È una variabile di istanza booleana impostata Variabile di istanza = CorrettoY Azione: Sistema> Aggiungi a variabile = Valore punteggio = 10 Azione: Testo> Imposta testo Valore = Punto
Il tuo GivePoints la funzione dovrebbe ora assomigliare a questa:
Se esegui il gioco e crei nuovamente lo scenario illustrato sopra, il tuo punteggio dovrebbe ora aumentare di 60 punti.
Ora che abbiamo implementato un sistema Points e abbiamo aggiornato il sistema di matching, inizieremo a migliorare un altro aspetto importante del gameplay. Se hai passato del tempo a giocare con il gioco fino a questo punto, saprai che uno dei maggiori problemi è che quando i Blocchi vengono distrutti, non succede nulla ai Blocchi sopra di loro. Nello specifico, i blocchi sopra gli spazi vuoti non cadono per riempire quegli spazi.
Questo va bene nei test, ma nella versione finale sarebbe dannoso per il gameplay lasciare le cose come sono, quindi la prossima cosa che andremo ad aggiungere è "gravity" che farà cadere e riempire i Blocks spazi vuoti quando altri blocchi vengono distrutti.
Il modo in cui implementeremo questo sistema è in realtà abbastanza semplice. Effettueremo un controllo usando il Blocco> Si sovrappone all'offset evento per vedere se c'è un blocco sotto il blocco che stiamo guardando. Se scopriamo che non esiste un blocco, sposteremo il blocco che stiamo osservando in basso per riempire lo spazio vuoto; altrimenti, non faremo nulla.
Per fare questo, creeremo un nuovo evento:
Evento: Condizione: INVERTI> Blocco> Si sovrappone all'offset Oggetto = Blocchetto Offset X = 0 Offset Y = 8 Azione: Blocca> Sposta ad angolo Angolo = 90 Distanza = (Block.Width + 2) / 2
Il tuo codice dovrebbe assomigliare a questo:
Se esegui il gioco in questo momento, vedrai che non appena il gioco inizia, tutti i blocchi cadono dallo schermo! Il motivo è che non abbiamo inserito nulla nel codice per indicare dove si trova il "piano" del campo di gioco.
Quindi in sostanza, i Blocchi nella riga inferiore realizzano che non ci sono blocchi sotto di loro e cadono di conseguenza. Quindi, una volta che la fila più bassa di blocchi è caduta, la riga successiva più in basso vede che ora non ci sono blocchi sotto di loro, e anche loro cadono. Questo processo continua fino a quando tutti i blocchi non sono caduti e lascia lo schermo completamente vuoto.
Puoi vedere una versione leggermente rallentata di questo in azione nella GIF di seguito:
Per risolvere questo problema, aggiungeremo una seconda condizione all'evento.
Evento: Condizione: Blocco> Confronta confronto Y = minore o uguale Y = SPAWNY - 1
Il tuo codice dovrebbe ora apparire come questo:
Aggiungendo questa nuova condizione ci assicuriamo che solo i Blocchi che si trovano sopra la posizione Y della riga più bassa sono influenzati dalla nostra "gravità". Nonostante questa correzione, abbiamo ancora alcuni problemi.
Il problema principale è che l'evento che guarda se c'è uno spazio vuoto sotto un blocco non ha nulla da dire che è inattivo quando il giocatore sta trascinando un blocco. Ciò significa che, se trascini un Blocco troppo lontano senza lasciarlo, i Blocchi nella posizione in alto da cui lo hai trascinato cadranno nello spazio lasciato dal Blocco che hai trascinato. Inoltre, il blocco che stai trascinando avrà anche un problema se lo fai uscire dal campo di gioco, e inizierà a cadere dal cursore del mouse poiché non ci sono blocchi sotto di esso.
Per risolvere questo problema, dobbiamo aggiungere una nuova variabile globale per dire al sistema quando stiamo spostando un blocco, una nuova azione per il blocco che trascina e rilascia gli eventi per impostare questa variabile globale e una terza condizione per l'evento gravitazionale in modo da questa variabile in considerazione prima di attivarla.
Innanzitutto, facciamo la variabile globale:
Variabile globale: Nome = BlockBeingMoved Tipo = Numero Valore iniziale = 0
La tua variabile dovrebbe apparire così:
Ora vai al Su DragDrop trascinare l'inizio evento e aggiungere una nuova azione:
Azione: Sistema> Imposta variabile valore = Valore BlockBeingMoved = 1
Inoltre, vai al Alla caduta di DragDrop evento e aggiungere una nuova azione all'evento principale:
Azione: Sistema> Imposta variabile valore = Valore BlockBeingMoved = 0
Con le linee aggiunte, i tuoi eventi DragDrop dovrebbero ora assomigliare a questo:
Infine, vai all'evento Gravity e aggiungi una nuova condizione:
Condizione: Sistema> Confronta variabile variabile = BlockBeingMoved Confronto = Uguale a Valore = 0
Il tuo codice di gravità dovrebbe ora apparire come questo:
La nuova variabile che abbiamo creato, BlockBeingMoved, è usato per dire al sistema quando un blocco viene mosso dal giocatore. Se la variabile è uguale 0 significa che nessun blocco viene spostato e può eseguire gli script di gravità normalmente. Se la variabile è uguale 1, significa un blocco è essere spostati e gli script di gravità non dovrebbero essere eseguiti.
Se esegui il gioco a questo punto, vedrai che non importa dove muovi il Blocco mentre lo stai trascinando, non si verificano problemi.
Ora abbiamo solo un ultimo problema da affrontare per quanto riguarda il sistema gravitazionale. Esegui il gioco e crea uno scenario simile a questo:
Ora, fai lo scambio che ho evidenziato in questa prossima immagine.
Dovresti notare che quando il gruppo di Green / Star Blocks viene distrutto, un Orange / Hexagon Block cade e forma un gruppo di tre Blocks, ma non viene distrutto.
Il motivo per cui questi blocchi non vengono distrutti è perché non abbiamo mai chiamato il FindMatches funzione una seconda volta per vedere se si sono formate nuove corrispondenze quando i Blocchi sono caduti per riempire gli spazi vuoti. Per risolvere questo problema, vai all'evento che controlla gli spazi vuoti sotto i blocchi e aggiungi questo altro evento:
Evento: Condizione: Sistema> Altrimenti Azione: Funzione> Funzione chiamata Nome = "FindMatches"
Il tuo codice dovrebbe assomigliare a questo:
Questa istruzione else significa che, ogni volta che trova non ci sono spazi vuoti, eseguirà un controllo per vedere se ci sono gruppi da distruggere. Questo evento verrà eseguito automaticamente ogni volta che Blocchi cadrà in nuove posizioni poiché viene attivato da un'istruzione Else collegata a quel controllo e verrà attivata solo quando sarà sicuro che tutti i blocchi sono caduti in posizione.
Se esegui il gioco a questo punto, scoprirai che ora puoi creare catene di blocchi distruggendo i blocchi in modo che i gruppi si formino quando i blocchi rimanenti cadono. Oltre a ciò, scoprirai anche che quando avvii per la prima volta il gioco, anche i gruppi che vengono generati inizialmente verranno distrutti. Come ho detto nel precedente tutorial, elimineremo le corrispondenze pre-create, quindi alla fine questo problema non avrà importanza.
Infine, dobbiamo fare un'altra cosa prima di poter considerare completo il nostro sistema gravitazionale. A seconda di dove hai posizionato lo sprite Block iniziale quando hai completato il primo tutorial, potresti notare che quando inizi il gioco cade e diventa visibile.
Se non sai cosa intendo, vai a Layout 1, imposta la posizione del tuo Block sprite a 521, -32, ed esegui il gioco. Quando giochi, dovresti vedere il Terreno originale nella posizione che ho evidenziato nell'immagine qui sotto:
Come puoi vedere nell'immagine sopra, il Blocco iniziale cade dalla sua posizione fuori dallo schermo e diventa visibile. Non vogliamo questo perché ci causerà solo problemi in seguito. Per risolvere questo piccolo problema, aggiungeremo un'azione al All'inizio del layout evento che distruggerà tutti i blocchi presenti nel layout quando viene caricato inizialmente.
Azione: Blocca> Distruggi
Il tuo evento dovrebbe ora assomigliare a questo:
Ora quando esegui il gioco, non dovresti più vedere il Blocco. Forse ti starai chiedendo perché non abbiamo eliminato il blocco dal layout, quindi non dobbiamo preoccuparci di questo problema. Il motivo per cui non lo abbiamo fatto è che Construct 2 non può creare copie di alcun tipo di oggetto con Eventi, a meno che non ci sia già un'istanza di quel tipo di oggetto nel gioco quando viene caricato per la prima volta. Eliminandolo all'interno di un evento, lo rimuoviamo in modo che non diventi un problema più tardi, e rendiamo possibile generare tutti i blocchi di cui abbiamo bisogno attraverso il codice.
Abbiamo trattato molti argomenti in questo tutorial, e mentre c'è altro che potremmo fare, penso che sia importante prendersi una pausa e lasciare che queste informazioni affondino. Nella prossima puntata, sistemeremo un paio di piccoli problemi, faremo il fantastico testo a virgola mobile che potresti aver notato si trova nella demo finale e imposta il sistema di concatenazione.
Spero che tu abbia ottenuto molto da questa parte della serie, e ti vedrò di nuovo qui la prossima settimana.
