The Smoke & Mirrors of Good Countdowns, Parte 2

Cosa starai creando

L'ultima volta, abbiamo esaminato i conti alla rovescia nei giochi, come sono stati configurati e quali elementi è possibile utilizzare per renderli più coinvolgenti. Ci sono molto di più di quanto si possa inserire in un singolo articolo, però!

Questo continuerà dalla prima parte, motivo per cui inizieremo al numero sette.

Pronto? Andiamo!

7: avere una velocità di ticchettio costante diversa

Questo è un trucco semplice che non richiede nemmeno di mentire al giocatore. Dici solo "quando il timer si esaurisce" e mostra un orologio ticchettante. Quello che non si menziona è il unità quello è mostrato.

Se mostri un "10", il giocatore intuirà che questo è 10 secondi, ma il numero può diminuire più lentamente di quanto lo sarebbero i secondi. Se modifichi il valore con a 0.5 moltiplicatore, per esempio, si esaurirà dopo 20 secondi invece di solo 10.

Puoi vedere come funziona nel mio gioco Ludum-Dare, Every Ten Seconds a Kitten Drowns.

Un timer in Ogni dieci secondi un gattino affoga. Il timer è abbastanza lento da dare al giocatore una buona quantità di tempo mentre appare ancora molto basso

Il tema della marmellata lo richiedeva 10 secondi sono usati, ma 10 secondi effettivi sono una quantità di tempo troppo bassa per realizzare qualcosa di significativo.

8: adatta la velocità di ticchettio durante il gioco

Funziona anche meglio se non vengono menzionate le unità di tempo e il giocatore ha appena avuto una vaga idea di "fino a quando ciò non accade".

Se hai una serie di pannelli che si illuminano per mostrare il progresso del timer, non è necessario attivarli alla stessa velocità. In effetti, diventerà più intenso se i primi si accenderanno rapidamente, e questi ultimi avranno più tempo tra loro. Nel calore del gameplay pieno di azione, il giocatore non lo realizzerà e avrà un'esperienza molto più intensa.

Questo non dovrebbe essere utilizzato con unità di tempo effettive, in quanto i giocatori potrebbero sentirsi ingannati e mentire. Non infrangere la fiducia del giocatore nel tuo sistema.

Questo può essere visto in un livello di Starfox 64, dove il giocatore deve difendere una posizione contro una nave gigante in avvicinamento.

Minimappa in Starfox 64. La nave madre attaccante (il cerchio nero) si sta muovendo verso la base nel mezzo, dando al giocatore un ruvido ticchettio di quanto tempo è rimasto per distruggerlo

A prima vista, si ottiene un'idea approssimativa di quanto tempo è rimasto, ma la nave stessa sembra muoversi a velocità diverse e non in linea retta.

Il timer è essenzialmente adattato al volo, il cui processo è nascosto dietro fumo e specchi.

9: Usa suoni

I conti alla rovescia non devono essere puramente ottici! Un segnale acustico ogni pochi secondi migliorerà notevolmente l'immersione.

Una volta ottenuto ciò, è anche possibile adattare la frequenza una volta trascorso un certo periodo di tempo. Se il segnale acustico si verifica ogni cinque secondi, negli ultimi 30 secondi del timer il giocatore verrà avvisato senza dover guardare il numero e calcolare mentalmente quanto rimane.

Allo stesso modo, aiuta anche se un personaggio commenta i progressi. Avere qualcuno dice "Siamo a metà strada!" ti dà un'informazione ben strutturata che è molto più facile da capire che analizzarla da una lettura.

10: utilizza la visualizzazione in scala

Funziona molto bene quando il contatore si avvicina alla fine. Ogni volta che trascorre un altro secondo, ridimensiona l'intero contatore per mezzo secondo.

Oltre al colore e al suono, questo lo renderà molto più divertente.

11: Fai qualcosa quando raggiunge Zero

Assicurati che un timer non vada mai in modo negativo, questo potrebbe confondere un sacco di persone e sembrare un bug, dato che i timer mal progettati e creati male tendono a farlo.

Avere il flash sarebbe un bel tocco, come sottolinea ancora una volta il suo esaurimento.

Se hai un timer positivo, è un elemento divertente lasciarlo continuare a correre e usare quell'elemento come punteggio alto. Il gioco Diavolo diavolo fa una cosa simile, dove l'obiettivo principale è "sopravvivere 500 secondi".

Gameplay da Diavolo diavolo

Cosa non fare che spezzerebbe la fiducia del giocatore

Una volta stabilite le regole di un timer, dovrebbero rimanere approssimativamente coerente, con più margine di manovra consentito meno preciso è un timer. La domanda principale dovrebbe essere: "In che modo questa regola nascosta va a beneficio dell'esperienza?"

Quando rallenti un timer negli ultimi tre secondi, renderà la situazione più tesa e darà al giocatore alcuni secondi effettivi per realizzare le cose. Rallentarlo lentamente a metà, o accelerarlo, infrangerà solo la fiducia del giocatore nelle tue regole.

Costruiamolo

Questo continuerà con il code-base dell'ultimo tutorial e si baserà su di esso. Se non l'hai ancora verificato, fallo ora! Puoi anche scaricare la fonte finita in alto a destra di questo articolo.

Quando abbiamo lasciato il nostro timer, sembrava che questo:

Ora, le nuove aggiunte lo renderanno più interessante. Continueremo con il countdown.cs-script, che dovrebbe assomigliare a questo:

usando UnityEngine; usando System.Collections; conto alla rovescia classe pubblica: MonoBehaviour float timer = 60f; pubblico AudioClip soundBlip; void Update () if (timer> 0f) timer - = Time.deltaTime;  else timer = 0f;  if (timer < 10f)  GetComponent() .color = Color.red;  else if (timer < 20f)  GetComponent() .color = Color.yellow;  GetComponent() .text = timer.ToString ("F2");  

Make It Beep

Facciamo il nostro segnale acustico ogni secondo, in modo che il giocatore sappia che sta diminuendo anche senza guardarlo.

Innanzitutto, abbiamo bisogno di un bel blip effetto sonoro. Puoi trovare un file audio nei file sorgente o crearne uno bello usando lo strumento gratuito BFXR. Una volta che ne hai uno, copialo nella tua cartella delle risorse.

Aggiungi un componente AudioSource al tuo oggetto countdown tramite Componente> Audio> AudioSource. Aggiungi questa variabile allo script del conto alla rovescia:

pubblico AudioClip soundBlip;

È inoltre necessario assegnare il file audio al soundBlip variabile:

E aggiungi questo blocco al Aggiornare funzione:

if (Mathf.Round (timer * 100) / 100% 1f == 0) GetComponent() .PlayOneShot (soundBlip); 

Questo controllerà se il timer è al secondo segno completo, e in tal caso riprodurrà il file audio.

Il funzionamento effettivo di questo codice è un po 'più complicato. Quello che fa è dapprima arrotondare il timer a virgola mobile a due decimali, quindi dividerlo per 1, e vedere se c'è un resto. Se il resto è zero, significa che il timer ha raggiunto il secondo completo e che è possibile riprodurre il suono bip.

Se non lo facciamo, il sistema potrebbe attivarsi molto più spesso, il che non sarà divertente e favorevole a un buon timer.

Velocità diversa

Questo aggiungerà un moltiplicatore che ridurrà o accelererà la velocità del ticchettio dell'orologio. Aggiungi questa variabile all'inizio:

moltiplicatore float = 0,6f;

Ora trova la linea che riduce il timer: è questo:

timer - = Time.deltaTime;

E adattalo per assomigliare a questo:

timer - = Time.deltaTime * moltiplicatore;

Se il moltiplicatore è inferiore 1.0 il timer ora funzionerà più lentamente e se è sopra 1.0 funzionerà più velocemente. Impostandolo a 1.0 non farà nulla.

Prova a sperimentare per trovare un buon valore! Sento una velocità leggermente inferiore, come 0.85f, farà sentire al giocatore l'orologio del ticchettio di più.

Rallenta quando è basso

Ora che abbiamo un componente moltiplicatore, possiamo cambiarlo durante il gameplay!

Vai al blocco di codice che cambia colore:

se (timer < 10f)  GetComponent() .color = Color.red;  else if (timer < 20f)  GetComponent() .color = Color.yellow; 

Qui abbiamo già le condizioni in cui un cambiamento nella velocità del ticchettio sarebbe appropriato, quindi possiamo semplicemente aggiungerlo!

se (timer < 10f)  GetComponent() .color = Color.red; moltiplicatore = 0,6f;  else if (timer < 20f)  GetComponent() .color = Color.yellow; moltiplicatore = 0.8f;  else moltiplicatore = 1.0f; 

Quando il timer diventa giallo a 20 secondi, ora lampeggerà con una velocità dell'80%. Una volta che diventa rosso, scenderà al 60% della velocità normale. Altrimenti, sarà impostato su 100% di velocità.

Ridimensionamento quando è basso

Un altro ottimo modo per far scadere di più un timer è di aumentarlo ogni secondo che passa quando è basso. Poiché abbiamo già un codice che viene attivato ogni secondo, possiamo adattarlo ulteriormente!

Innanzitutto, abbiamo bisogno di una funzione per aumentare e ridurre la dimensione del nostro display. Aggiungi questa funzione:

bool privato isBlinking = false; IEnumerator privato Blink () isBlinking = true; float startScale = transform.localScale.x; transform.localScale = Vector3.one * startScale * 1.4f; yield return new WaitForSeconds (0.3f); transform.localScale = Vector3.one * startScale; isBlinking = false; 

Questo è un IEnumerator, che è un tipo di funzione che può contenere i comandi di attesa. Abbiamo bisogno del isBlinking variabile per assicurarci di non chiamarla più volte.

Una volta avviato, aumenterà le dimensioni dell'oggetto per il fattore 1,4f, attenderà 0,3 secondi e ridimensionerà nuovamente fino alla dimensione originale.

Lo chiamiamo usando questo codice speciale:

if (Mathf.Round (timer * 100) / 100% 1f == 0) GetComponent() .PlayOneShot (soundBlip); se (timer < 10f)  if(!isBlinking)  StartCoroutine(Blink());   

Un IEnumerator deve essere avviato chiamandolo via StartCoroutine, altrimenti non funzionerà.

L'intero blocco verrà chiamato quando passa un secondo, a quel punto possiamo controllare se il timer è abbastanza basso da farlo lampeggiare.

Lampeggia a zero

Facciamo qualcosa quando scade il tempo. Avere semplicemente seduto lì a zero può essere noioso, quindi facciamolo battere le palpebre.

Per prima cosa, ne avremo bisogno di un altro IEnumerator funzione:

bool privato isZeroBlinking = false; IEnumerator privato ZeroBlink () isZeroBlinking = true; GetComponent() .enabled = false; yield return new WaitForSeconds (1.5f); GetComponent() .enabled = true; yield return new WaitForSeconds (1.5f); isZeroBlinking = false; 

Ciò accenderà e spegnerà il timer 1.5-secondi intervalli. Attivalo nel blocco che controlla già se il timer è zero.

if (timer> 0f) timer - = Time.deltaTime * moltiplicatore;  else timer = 0f; if (! isZeroBlinking) StartCoroutine (ZeroBlink ()); 

Prima di eseguirlo, è necessario disattivare il segnale acustico e lampeggiare a zero stesso, altrimenti si scontrano i comportamenti.

Adattare le condizioni nel blocco per verificare se è passato un secondo e anche per verificare se l'ora corrente è maggiore di zero:

if (Mathf.Round (timer * 100) / 100% 1f == 0 && timer> 0f) GetComponent() .PlayOneShot (soundBlip); se (timer < 10f && timer > 0f) if (! IsBlinking) StartCoroutine (Blink ()); 

Ciò assicurerà che il lampeggio regolare e lo zero lampeggio funzionino senza interferire l'uno con l'altro.

L'intero conto alla rovescia lo script dovrebbe assomigliare a questo:

usando UnityEngine; usando System.Collections; conto alla rovescia classe pubblica: MonoBehaviour float timer = 5f; moltiplicatore float = 0,6f; pubblico AudioClip soundBlip; void Update () if (timer> 0f) timer - = Time.deltaTime * moltiplicatore;  else timer = 0f; if (! isZeroBlinking) StartCoroutine (ZeroBlink ());  if (timer < 10f)  GetComponent() .color = Color.red; moltiplicatore = 0,6f;  else if (timer < 20f)  GetComponent() .color = Color.yellow; moltiplicatore = 0.8f;  else moltiplicatore = 1.0f;  if (Mathf.Round (timer * 100) / 100% 1f == 0 && timer> 0f) GetComponent() .PlayOneShot (soundBlip); se (timer < 10f && timer > 0f) if (! IsBlinking) StartCoroutine (Blink ());  GetComponent() .text = timer.ToString ("F2");  private bool isBlinking = false; IEnumerator privato Blink () isBlinking = true; float startScale = transform.localScale.x; transform.localScale = Vector3.one * startScale * 1.4f; yield return new WaitForSeconds (0.3f); transform.localScale = Vector3.one * startScale; isBlinking = false;  private bool isZeroBlinking = false; IEnumerator privato ZeroBlink () isZeroBlinking = true; GetComponent() .enabled = false; yield return new WaitForSeconds (1.5f); GetComponent() .enabled = true; yield return new WaitForSeconds (1.5f); isZeroBlinking = false;  

Questo porterà a termine il lavoro. Ovviamente puoi renderlo più elegante e combinare i comandi in un codice più efficiente.

Conclusione

Il nostro piccolo conto alla rovescia standard è diventato molto più interessante e coinvolgente. Se lo costruisci una volta, puoi usarlo e collegarlo a qualsiasi progetto tu faccia, non importa quanto piccolo.

Ora vai e mettilo in gioco!