Share
Nel precedente articolo di questa serie, abbiamo dedicato del tempo a impostare il nostro gioco in modo da disporre di tutte le immagini necessarie e generare casualmente una griglia di blocchi per il giocatore. Con quei sistemi in atto, ora lavoreremo sulle funzionalità di base e daremo al giocatore la possibilità di manipolare il campo di gioco.
Ecco una demo del gioco a cui stiamo lavorando in questa serie:
Abbiamo terminato il tutorial precedente dopo aver reso ogni blocco visualizzato come un colore diverso. Ho pensato che sarebbe stato bello riprendere da quel punto esatto e iniziare aggiungendo l'animazione ai blocchi in modo che le immagini cambino in base a ciò che il giocatore fa o ha fatto. La prima animazione che aggiungeremo è un evento mouse-over.
Innanzitutto, aggiungi un topo oggetto a Layout 1. Quindi, torna a Scheda evento 1 e aggiungere un nuovo Evento.
Evento: Mouse> Il cursore è sull'oggetto Object = Blocca Azione: Blocca> Imposta valore frame = (Block.Color-1) * 3 + 2
Ora, se entri in gioco, l'immagine dei blocchi dovrebbe cambiare quando passi il mouse su di loro e tornare indietro quando sposti il cursore.
Abbiamo un altro evento di animazione da fare:
Evento: Blocco> È una variabile di istanza booleana impostata Variabile di istanza = IsMatched Azione: Blocca> Imposta valore fotogramma = (Block.Color-1) * 3 + 3
Dobbiamo anche assicurarci che quando passi il mouse sopra un blocco abbinato, l'immagine non cambi, quindi aggiungi un'altra condizione all'evento di passaggio del mouse che abbiamo fatto:
Condizione: Inverti: Blocca> È la variabile di istanza booleana impostata Variabile di istanza = IsMatched
Invertire questo significa che l'immagine al passaggio del mouse viene utilizzata solo se il blocco non fa parte di una corrispondenza. Dato che non abbiamo un sistema di corrispondenza in atto, non dovresti vedere alcuna modifica, ma man mano che andiamo avanti questo evento entrerà in gioco.
Con tutti e tre questi eventi in atto, il tuo foglio evento dovrebbe ora assomigliare a questo:
La prossima cosa su cui lavoreremo è dare al giocatore la possibilità di scambiare blocchi vicini. Per far funzionare questo sistema useremo una combinazione di matrici e funzioni, quindi se non li hai già utilizzati in C2, consulta il manuale per saperne di più.
Prima di spiegare come realizzare il sistema, voglio che tu veda ciò che stiamo facendo e spieghi brevemente come funziona. Per vedere come sarà il sistema, riproduci la demo qui sotto. Per scambiare blocchi, è sufficiente fare clic e trascinarli in cima a uno spot vicino in una delle quattro direzioni cardinali.
Clicca per caricare la demo. Dovresti notare che quando inizi a trascinare un blocco, quattro quadrati colorati appariranno in cima ai blocchi che sono direttamente accanto ad esso. Quando lasci andare il blocco, c'è un evento che verifica se il blocco si sovrappone a uno di questi quadrati colorati.
Se il blocco si sovrappone a uno dei quadrati colorati, scambia il blocco che hai spostato con il blocco su cui è stato disegnato il quadrato colorato o semplicemente riposiziona il tuo blocco spostato nella nuova posizione. Se il tuo blocco non si sovrappone a uno dei quadrati colorati, non fa nulla. Inoltre non fa nulla se il blocco si sovrappone a più quadrati colorati.
Il motivo per cui stiamo usando questo sistema, piuttosto che verificare se il blocco stesso si sovrapponga a un altro blocco, è che non abbiamo un modo semplice per verificare dove i due blocchi sono relativi l'uno all'altro. Rimettendo i quadrati colorati nelle posizioni valide e poi usandoli come base per i nostri assegni, abbiamo un'idea molto migliore di ciò che il giocatore intendeva fare quando hanno provato a fare uno scambio.
Ora che capiamo cosa sta succedendo, possiamo iniziare a implementarlo. Vai a Layout 1 e aggiungere un Funzione oggetto, e un schieramento oggetto. Lasciare il Funzione nome dell'oggetto come Funzione, ma rinomina il schieramento a BlockPositions. Il Funzione oggetto ci permetterà di usare funzioni all'interno del nostro codice, e il schieramento è ciò che useremo per memorizzare le posizioni dei blocchi che stiamo scambiando. Abbiamo anche bisogno di impostare il Altezza e Profondità della matrice a 2.
Dopo averlo fatto, crea quattro nuovi sprite da usare come i nostri quadrati colorati:
Accentsconagua
BottomBlock.LeftBlock.RightBlock.Topblock.I colori in realtà non contano, ma l'uso di questi colori li rende diversi in modo che siano facili da identificare e rende più facile seguirli poiché è quello che ho fatto. Questi sprite devono essere posizionati all'esterno del layout in modo che il giocatore non possa vederli.
Si dovrebbe anche impostare la dimensione di ciascuno di questi a 30,30 e dagli a ciascuno un Opacità di 0. Nella demo sopra, sono tutti solo leggermente trasparenti perché volevo che tu potessi vedere cosa stava succedendo, ma nel gioco reale il giocatore non dovrebbe essere in grado di vederli affatto.
Infine, seleziona il tuo attuale Bloccare oggetto e aggiungi il Trascina e rilascia comportamento ad esso.
Ora torna a Scheda evento 1 e creare un nuovo Evento con sei Azioni.
Evento: Block> On DragDrop trascina avvio Azione: BlockPositions> Imposta a XY X = 0 Y = 0 Valore = Block.X Azione: BlockPositions> Imposta a XY X = 0 Y = 1 Valore = Block.Y Azione: BottomBlock> Imposta posizione X = Block.XY = Block.Y - (Block.Width + 2) Azione: TopBlock> Imposta posizione X = Block.XY = Block.Y + (Block.Width + 2) Azione: LeftBlock> Imposta posizione X = Block. X - (Block.Width + 2) Y = Block.Y Azione: RightBlock> Imposta posizione X = Block.X + (Block.Width + 2) Y = Block.Y
Questo evento memorizza la posizione iniziale del blocco che hai spostato e sposta i quadrati colorati in modo che siano nella posizione corretta rispetto al blocco che viene spostato.
Il tuo evento dovrebbe assomigliare a questo:
Il prossimo evento che aggiungeremo eseguirà il controllo per vedere cosa lo swap sta tentando di fare.
Per prima cosa, l'evento ascolterà quando il giocatore "lascia" il blocco che stanno muovendo. Quindi eseguirà una serie di controlli per vedere quale quadrato colorato, se presente, il blocco è in collisione con, e o eseguire lo scambio appropriato, o semplicemente ripristinare la posizione del blocco spostato.
Evento: Block> On DragDrop drop Sottoeventi: Blocco> Si sovrappone BottomBlock Azione: BlockPositions> Imposta a XY X = 1 Y = 0 Valore = BottomBlock.X Azione: BlockPositions> Imposta a XY X = 1 Y = 1 Valore = BottomBlock .Y Azione: Blocco> Imposta posizione X = BlockPositions.At (0,0) Y = BlockPositions.At (0,1)
Ecco come dovrebbe apparire così lontano:
In questo momento, il Evento conta solo gli swap con il Bloccare sotto quello che viene spostato. Per aggiungere gli altri, fare clic con il tasto destro del mouse sull'evento secondario e aggiungere un Altro. Quindi, copia la condizione dal primo evento secondario nell'evento Else ma cambia il target da BottomBlock a Topblock.
Ora, copia il Azioni dall'evento secondario originale all'evento Else e modificare di nuovo qualsiasi istanza di BottomBlock a Topblock. Fallo altre due volte con LeftBlock e RightBlock, in modo da avere quattro eventi secondari totali e in modo che la configurazione dell'evento assomigli a questa:
Infine, aggiungi un altro evento Else:
Sotto-evento: Altrimenti Azione: Blocco> Imposta posizione X = BlockPositions.At (0,0) Y = BlockPositions.At (0,1)
Da qui implementeremo la meccanica di scambio stessa. Per scambiare i blocchi, sposteremo prima il blocco che il giocatore ha trascinato in una posizione fuori dallo schermo.
Lo facciamo perché dobbiamo localizzare i blocchi in base alle loro posizioni prima di poterli manipolare - se iniziassimo ponendo entrambi i blocchi nella posizione memorizzata dell'altro blocco, li metterebbe entrambi nello stesso punto e li renderebbe molto difficili da separati gli uni dagli altri. Spostando il blocco in una posizione specifica in cui non ci sono altri blocchi, evitiamo che entrambi i blocchi si trovino nella stessa posizione di un altro blocco e impediscano al sistema di avere un problema nel determinare quale blocco vogliamo.
Sposteremo quindi il blocco che hanno scambiato originale bloccare con la posizione del blocco originale. Infine, sposteremo il blocco originale nella posizione del secondo blocco dalla sua posizione fuori dallo schermo e reimposterà le informazioni nell'array su 0.
Evento: Funzione> On function Nome: Sub-Event "SwapBlocks": Condition: Block> Compare XX = BlockPositions.At (0,0) Condizione: Block> Compare YY = BlockPositions.At (0,1) Azione: Block> Set posizione X = -80 Y = -80 Sotto-evento: Condizione: Blocco> Confronta XX = BlockPositions.At (1,0) Condizione: Blocco> Confronta YY = BlockPositions.At (1,1) Azione: Blocco> Imposta posizione X = BlockPositions.At (0,0) Y = BlockPositions.At (0,1) Sotto-evento: Condizione: Blocco> Confronta XX = -80 Condizione: Blocco> Confronta YY = -80 Azione: Blocco> Imposta posizione X = BlockPositions .At (1,0) Y = BlockPositions.At (1,1) Azione: BlockPositions> Imposta a XY X = 0 Y = 0 Valore = 0 Azione: BlockPositions> Imposta a XY X = 0 Y = 1 Valore = 0 Azione : BlockPositions> Set a XY X = 1 Y = 0 Value = 0 Action: BlockPositions> Set a XY X = 1 Y = 1 Value = 0
Il tuo Evento foglio per quello dovrebbe assomigliare a questo:
Ora, torniamo ai quattro controlli che abbiamo fatto in precedenza che hanno determinato quale quadrato colorato con cui il blocco trascinato era in collisione, e aggiungetelo Azione alla fine del Azioni lista per tutti e quattro:
Azione: Funzione> Funzione chiamata Nome: "SwapBlocks"
Se esegui il gioco ora, funzionerà quasi perfettamente. L'unica cosa che non fa ancora è controllare se il blocco si sovrappone a più quadrati colorati. (Se lo è, non vogliamo che accada qualcosa perché significa che la mossa potrebbe essere un errore.)
Attualmente controlla i quadrati colorati nell'ordine Parte inferiore, Superiore, Sinistra, Destra, e qualunque cosa trovi prima, scambia con. Per risolvere questo problema dobbiamo aggiungere due condizioni invertite per ogni controllo.
Al Superiore e Parte inferiore controlla, aggiungi queste condizioni:
Condizione: Invertito: Blocco> Si sovrappone a un altro oggetto Oggetto: LeftBlock Condizione: Invertito: Blocco> Si sovrappone a un altro oggetto Oggetto: RightBlock
Al Destra e Sinistra controlla, aggiungi queste condizioni:
Condizione: Invertito: Blocca> Si sovrappone a un altro oggetto Oggetto: TopBlock Condizione: Invertito: Blocca> Si sovrappone a un altro oggetto Oggetto: BottomBlock
Poiché i quadrati sono solo 30x30px, è impossibile che il blocco si sovrapponga contemporaneamente a due estremità opposte. Questi controlli ci permettono di assicurarci che il movimento di trascinamento non sia inclinato troppo da entrambi i lati, e assicura che il giocatore abbia un movimento prevalentemente rettilineo, quindi è chiaro che stiamo rilevando il giusto tipo di scambio.
Il tuo Evento foglio dovrebbe ora assomigliare a questo:
Ed ecco una demo del nostro gioco nel suo stato attuale:
Clicca per caricare la demo. Ora abbiamo una meccanica di scambio completamente funzionale. Nel prossimo tutorial creeremo un sistema di rilevamento delle partite forte e inizieremo davvero a vedere il gameplay in azione.
Se vuoi continuare a lavorare da solo, dovresti vedere in che modo puoi rilevare quando due blocchi sono dello stesso colore e in che modo sapresti se sono uno accanto all'altro e se formano un gruppo completo. Un buon punto di partenza sarebbe con a Sistema> Per ciascuno evento con il Bloccare oggetto, ed eseguire qualche tipo di controllo su ciascuno Bloccare individualmente.
Spero che questo tutorial ti sia piaciuto e che stia godendo la serie finora; assicurati di tornare presto per la prossima puntata.
