Share
Cosa starai creandoIn questo tutorial, costruiremo un semplice gioco in cui il giocatore può riavvolgere progresso nell'unità (può anche essere adattato per funzionare in altri sistemi). Questa prima parte entrerà nelle basi del sistema, e la parte successiva lo arricchirà e lo renderà molto più versatile.
Innanzitutto, daremo un'occhiata a ciò che i giochi usano. Poi esamineremo gli altri usi per questa configurazione tecnica, prima di creare un gioco di piccole dimensioni che possiamo riavvolgere, che dovrebbe darti una base per il tuo.
Una demonstation della funzionalità di baseAvrai bisogno della versione più recente di Unity per questo, e dovresti avere un po 'di esperienza con esso. Il codice sorgente è disponibile anche per il download se si desidera verificare i propri progressi contro di esso.
Pronto? Andiamo!
Prince of Persia: Le sabbie del tempo è uno dei primi giochi a integrare una meccanica del riavvolgimento nel suo gameplay. Quando muori non devi solo ricaricare, ma puoi piuttosto riavvolgere il gioco per qualche secondo fino a dove eri di nuovo vivo, e riprovare immediatamente.
Prince of Persia: The Forgotten Sands. Il Sands Of Time Trilogy integra splendidamente il riavvolgimento del tempo nel suo gameplay ed evita la ricarica rapida in immersione.Questa meccanica non è solo integrata nel gameplay, ma anche nella narrativa e nell'universo, ed è menzionata in tutta la storia.
Gli altri giochi che impiegano questi sistemi sono Treccia, per esempio, che è anche centrato attorno all'avvolgimento del tempo. L'eroe Tracer in Overwatch ha un potere che la riporta in una posizione pochi secondi fa, essenzialmente riavvolgimento il suo tempo, anche in una partita multiplayer. Il GRIGLIA-La serie di giochi di corse ha anche una meccanica istantanea, in cui si ha una piccola riserva di riavvolgimenti durante una gara, alla quale è possibile accedere quando si verifica un arresto critico. Ciò impedisce la frustrazione causata da incidenti vicino alla fine della gara, che possono essere particolarmente esasperanti.
Ma questo sistema non può essere utilizzato solo per sostituire il risparmio rapido. Un altro modo in cui viene utilizzato è il ghosting nei giochi di corse e il multiplayer asincrono.
I replay sono un altro modo divertente di utilizzare questa funzione. Questo può essere visto in giochi come superhot, il Worms serie, e praticamente la maggior parte dei giochi sportivi.
I replay sportivi funzionano allo stesso modo in cui vengono presentati in TV, dove viene mostrata di nuovo un'azione, possibilmente da una diversa angolazione. Per questo non viene registrato un video, ma piuttosto le azioni dell'utente, consentendo al replay di impiegare diversi angoli e inquadrature della telecamera. I giochi Worms lo usano in modo divertente, dove uccisioni molto comiche o efficaci sono mostrate in un Instant Replay.
SUPERHOT registra anche i tuoi movimenti. Quando hai terminato di giocare, i tuoi progressi vengono poi riprodotti, mostrando i pochi secondi di movimento effettivo che si sono verificati.
Super Meat Boy lo usa in modo divertente. Quando finisci un livello vedi un replay di tutti i tuoi precedenti tentativi messi l'uno sopra l'altro, che culmina con il tuo run finale essendo l'ultimo a sinistra.
La riproduzione di fine livello in Super Meat Boy. Ognuno dei tuoi tentativi precedenti viene registrato e quindi riprodotto allo stesso tempo.Race-ghosting è una tecnica in cui gareggia per il miglior tempo su una pista vuota. Ma allo stesso tempo, corri contro un fantasma, che è un'auto spettrale e trasparente, che guida esattamente il modo in cui hai corso prima nel tuo miglior tentativo. Non puoi scontrarti, il che significa che puoi ancora concentrarti per ottenere il miglior tempo.
Invece di guidare da solo, puoi arrivare competere contro te stesso, il che rende le prove a tempo molto più divertenti. Questa funzione si presenta nella maggior parte dei giochi di corse, dal Bisogno di velocità serie a Diddy Kong Racing.
Correre un fantasma in Trackmania Nations. Questo ha la difficoltà d'argento, nel senso che otterrò la medaglia d'argento se li batto. Nota la sovrapposizione nei modelli di auto, mostrando che il fantasma non è corporeo e può essere guidato attraverso.Asincrono Multiplayer: Ghosting è un altro modo di utilizzare questa configurazione. In questa caratteristica raramente utilizzata, le partite multiplayer vengono eseguite registrando i dati di un giocatore, che poi invia la propria corsa a un altro giocatore, che può successivamente combattere contro il primo giocatore. I dati vengono applicati allo stesso modo di un fantasma a cronometro, solo che stai gareggiando contro un altro giocatore.
Una forma di questo si presenta nel Trackmania-giochi, dove è possibile correre contro certe difficoltà. Questi corridori registrati ti daranno un avversario da battere per una certa ricompensa.
Pochi giochi lo offrono fin dall'inizio, ma se usato correttamente può essere uno strumento divertente.Team Fortress 2 offre un replay-editor integrato, con il quale è possibile creare le proprie clip.
L'editor di replay di Team Fortress 2. Una volta registrata, una partita può essere vista da qualsiasi prospettiva, non solo da quella del giocatore.Una volta che la funzione è stata attivata, puoi registrare e guardare le partite precedenti. L'elemento vitale è quello qualunque cosa è registrato, non solo la tua vista. Ciò significa che puoi muoverti nel mondo di gioco registrato, vedere dove sono tutti, e avere il controllo nel tempo.
Per testare questo sistema, abbiamo bisogno di un semplice gioco in cui possiamo testarlo. Creiamo uno!
Crea un cubo nella tua scena, questo sarà il nostro personaggio-giocatore. Quindi creare una nuova chiamata C # -script Player.cs e adattare il Aggiornare()-funzione per assomigliare a questo:
Accentsconagua
void Update () transform.Translate (Vector3.forward * 3.0f * Time.deltaTime * Input.GetAxis ("Vertical")); transform.Rotate (Vector3.up * 200.0f * Time.deltaTime * Input.GetAxis ("Horizontal")); Questo gestirà il movimento semplice tramite i tasti freccia. Allega questo script al cubo del giocatore. Quando ora giochi, dovresti già essere in grado di muoverti.
Quindi inclina la fotocamera in modo che veda il cubo dall'alto, con spazio sul lato dove possiamo spostarlo. Infine, crea un piano per agire come pavimento e assegnare alcuni materiali diversi a ciascun oggetto, in modo che non lo stiamo spostando all'interno di un vuoto. Dovrebbe sembrare come questo:
Provalo e dovresti essere in grado di spostare il tuo cubo usando WSAD e i tasti freccia.
Ora crea un nuovo C # -script chiamato TimeController.cs e aggiungilo a un nuovo GameObject vuoto. Questo gestirà la registrazione effettiva e il successivo riavvolgimento del gioco.
Per fare questo, registreremo il movimento del personaggio del giocatore. Quando poi premiamo il tasto rewind, adatteremo le coordinate del giocatore. Per farlo, inizia creando una variabile per tenere il giocatore, in questo modo:
lettore pubblico di GameObject;
E assegna l'oggetto giocatore allo slot risultante sul TimeController, in modo che possa accedere al giocatore e ai suoi dati.
Quindi dobbiamo creare una matrice per contenere i dati del giocatore:
public ArrayList playerPositions; void Start () playerPositions = new ArrayList ();
Quello che faremo dopo sarà continuamente registrare la posizione del giocatore. Avremo la posizione memorizzata di dove si trovava il giocatore nell'ultimo fotogramma, la posizione in cui il giocatore era 6 fotogrammi fa e la posizione in cui il giocatore era 8 secondi fa (o comunque a lungo lo imposterai per registrare). Quando in seguito premiamo un pulsante, torneremo indietro attraverso la nostra serie di posizioni e le assegneremo fotogramma per fotogramma, risultando in una funzione di riavvolgimento del tempo.
Innanzitutto, salviamo i dati:
void FixedUpdate () playerPositions.Add (player.transform.position);
Nel FixedUpdate ()-funzione registriamo i dati. FixedUpdate () viene utilizzato quando viene eseguito a una velocità costante di 50 cicli al secondo (o qualsiasi altra cosa venga impostata su), il che consente a un intervallo fisso di registrare e impostare i dati. Il Aggiornare()-nel frattempo, la funzione viene eseguita in base al numero di frame gestiti dalla CPU, il che renderebbe le cose più difficili.
Questo codice memorizzerà la posizione del giocatore di ciascun fotogramma nell'array. Ora dobbiamo applicarlo!
Aggiungeremo un segno di spunta per verificare se il pulsante di riavvolgimento è stato premuto. Per questo, abbiamo bisogno di una variabile booleana:
public bool isReversing = false;
E un assegno in Aggiornare()-funzione per impostarlo in base al fatto che vogliamo riavvolgere il gameplay:
void Update () if (Input.GetKey (KeyCode.Space)) isReversing = true; else isReversing = false;
Per far funzionare il gioco arretrato, applicheremo i dati invece di registrare. Il nuovo codice per la registrazione e l'applicazione della posizione del giocatore dovrebbe assomigliare a questo:
void FixedUpdate () if (! isReversing) playerPositions.Add (player.transform.position); else player.transform.position = (Vector3) playerPositions [playerPositions.Count - 1]; playerPositions.RemoveAt (playerPositions.Count - 1);
E il tutto TimeController-script come questo:
usando UnityEngine; usando System.Collections; public class TimeController: MonoBehaviour public GameObject player; public ArrayList playerPositions; public bool isReversing = false; void Start () playerPositions = new ArrayList (); void Update () if (Input.GetKey (KeyCode.Space)) isReversing = true; else isReversing = false; void FixedUpdate () if (! isReversing) playerPositions.Add (player.transform.position); else player.transform.position = (Vector3) playerPositions [playerPositions.Count - 1]; playerPositions.RemoveAt (playerPositions.Count - 1);
Inoltre, non dimenticare di aggiungere un assegno al giocatore-classe per vedere se il TimeController è in fase di riavvolgimento o meno e si muove solo quando non è in retromarcia. In caso contrario, potrebbe creare comportamenti buggy:
usando UnityEngine; usando System.Collections; public class Player: MonoBehaviour timeController timeController privato; void Start () timeController = FindObjectOfType (typeof (TimeController)) come TimeController; void Update () if (! timeController.isReversing) transform.Translate (Vector3.forward * 3.0f * Time.deltaTime * Input.GetAxis ("Vertical")); transform.Rotate (Vector3.up * 200.0f * Time.deltaTime * Input.GetAxis ("Horizontal")); Queste nuove linee troveranno automaticamente il TimeController-oggetto nella scena all'avvio e controllalo durante il runtime per vedere se stiamo attualmente giocando o riavvolgendolo. Possiamo controllare il personaggio solo quando al momento non stiamo invertendo il tempo.
Ora dovresti essere in grado di muoverti per il mondo e riavvolgere il movimento premendo lo spazio. Se si scarica il pacchetto di build allegato a questo articolo e aperto TimeRewindingFunctionality01 puoi provarlo!
Ma aspetta, perché il nostro semplice giocatore-cubo continua a guardare nell'ultima direzione in cui li abbiamo lasciati? Perché non siamo riusciti a registrare anche la sua rotazione!
Per questo è necessario un altro array per mantenere i suoi valori di rotazione, per istanziarlo all'inizio e per salvare e applicare i dati nello stesso modo in cui abbiamo gestito i dati di posizione.
usando UnityEngine; usando System.Collections; public class TimeController: MonoBehaviour public GameObject player; public ArrayList playerPositions; pubblico ArrayList playerRotations; public bool isReversing = false; void Start () playerPositions = new ArrayList (); playerRotations = new ArrayList (); void Update () if (Input.GetKey (KeyCode.Space)) isReversing = true; else isReversing = false; void FixedUpdate () if (! isReversing) playerPositions.Add (player.transform.position); playerRotations.Add (player.transform.localEulerAngles); else player.transform.position = (Vector3) playerPositions [playerPositions.Count - 1]; playerPositions.RemoveAt (playerPositions.Count - 1); player.transform.localEulerAngles = (Vector3) playerRotations [playerRotations.Count - 1]; playerRotations.RemoveAt (playerRotations.Count - 1);
Provalo! TimeRewindingFunctionality02 è la versione migliorata. Ora il nostro cubo giocatore può spostarsi indietro nel tempo, e avrà lo stesso aspetto di quando era in quel momento.
Abbiamo costruito un semplice prototipo di gioco con un sistema di riavvolgimento del tempo già utilizzabile, ma non è ancora finito. Nella parte successiva di questa serie lo renderemo molto più stabile e versatile e aggiungeremo alcuni effetti accurati.
Ecco cosa dobbiamo ancora fare:
Daremo anche un'occhiata a come estendere questo sistema oltre il solo personaggio-giocatore:
