Creare un gioco 2D con Unity 4.3 - Parallax Scrolling

Ora che l'astronave è in grado di volare e sparare rendiamo più realistica l'animazione facendo scorrere lo sfondo di gioco.
La tecnica che adopereremo è chiamata Parallax Scrolling. Concettualmente è molto semplice. Gli oggetti più vicini, nel nostro caso i pianeti,  scorrono più velocemente rispetto a quelli più lontani, le stelle. Questo da l'impressione di muoversi in un ambiente molto realistico. Praticamente è quello che succede quando da un treno osserviamo dal finestrino. Gli alberi al bordo dei binari sfrecciano velcemente, mentre e le montagne in lontananza si muovono lentamente.
In un gioco 3d l'effetto è automatico semplicemente adottando l'accorgimento di impostare opportunamente la coordinata z degli oggetti. Tuttavia nel nostro gioco 2D  stiamo utilizzando una camera ortografica, quindi ci dovremo occupare manualmente di creare l'effetto di scorrimento tramite script.
Un' altra funzionalità che includeremo nello script, è quella di riposozionare lo sfondo con tutti gli oggetti contenuti in esso in maniera ciclica. In questo modo continuerà a scorre come se fosse infinito.



using System.Collections.Generic;
using System.Linq;
using UnityEngine;

/// 
/// Parallax scrolling script that should be assigned to a layer
/// 
public class ScrollingScript : MonoBehaviour
{
 /// 
 /// Scrolling speed
 /// 
 public Vector2 speed = new Vector2(1, 1);
 
 /// 
 /// Moving direction
 /// 
 public Vector2 direction = new Vector2(-1, 0);
 
 /// 
 /// Movement should be applied to camera
 /// 
 public bool isLinkedToCamera = false;
 
 /// 
 /// 1 - Background is infinite
 /// 
 public bool isLooping = false;

 /// 
 /// 2 - Looping Gap
 /// 
 public float loopingGap = 0;

 private float screenWidth = 0 ;
 
 /// 
 /// 2 - List of children with a renderer.
 /// 
 private List backgroundPart;
 
 // 3 - Get all the children
 void Start()
 {

  // For infinite background only
  if (isLooping)
  {
   // Get all the children of the layer with a renderer
   backgroundPart = new List();
   
   for (int i = 0; i < transform.childCount; i++)
   {
    Transform child = transform.GetChild(i);
    
    // Add only the visible children
    if (child.renderer != null)
    {
     backgroundPart.Add(child);    
    }
   }


   // Sort by position.
   // Note: Get the children from left to right.
   // We would need to add a few conditions to handle
   // all the possible scrolling directions.
   backgroundPart = backgroundPart.OrderBy(
    t => t.position.x
    ).ToList();

   Transform firstChild = backgroundPart.FirstOrDefault();
   Transform lastChild = backgroundPart.LastOrDefault();
    
   screenWidth =  lastChild.renderer.bounds.max.x - firstChild.renderer.bounds.min.x;
  } 
 }
 
 void Update()
 {
  // Movement
  Vector3 movement = new Vector3(
   speed.x * direction.x,
   speed.y * direction.y,
   0);
  
  movement *= Time.deltaTime;
  transform.Translate(movement);
  
  // Move the camera
  if (isLinkedToCamera)
  {
   Camera.main.transform.Translate(movement);
  }
  
  // 4 - Loop
  if (isLooping)
  {
   // Get the first object.
   // The list is ordered from left (x position) to right.
   Transform firstChild = backgroundPart.FirstOrDefault();
   
   if (firstChild != null)
   {
    // Check if the child is already (partly) before the camera.
    // We test the position first because the IsVisibleFrom
    // method is a bit heavier to execute.
    if (firstChild.position.x < Camera.main.transform.position.x)
    {
     // If the child is already on the left of the camera,
     // we test if it's completely outside and needs to be
     // recycled.
     if (firstChild.renderer.IsVisibleFrom(Camera.main) == false)
     {
      // Set the position of the recyled one to be AFTER
      // the last child.
      // Note: Only work for horizontal scrolling currently.
      firstChild.position = new Vector3(screenWidth + firstChild.position.x + 
                                                             loopingGap, firstChild.position.y, firstChild.position.z);
      
      // Set the recycled child to the last position
      // of the backgroundPart list.
      backgroundPart.Remove(firstChild);
      backgroundPart.Add(firstChild);
     }
    }
   }
  }
 }
}


using UnityEngine;

public static class RendererExtensions
{
 public static bool IsVisibleFrom(this Renderer renderer, Camera camera)
 {
  Plane[] planes = GeometryUtility.CalculateFrustumPlanes(camera);
  return GeometryUtility.TestPlanesAABB(planes, renderer.bounds);
 }
}



Aggiungiamo al background ed al middleground lo script ScrollingScript. Per il Background impostiamo i seguenti valori:
  1. Speed X: 0.2
  2. SpeedY: 0
  3. Direction X: -1
  4. Direction Y: 0 
  5. Is Looping: Selezionato
  6. Looping Gap : 0

Per il Middleground invece 
  1. Speed X: 0.2
  2. SpeedY: 0
  3. Direction X: -1
  4. Direction Y: 0 
  5. Is Looping: Selezionato
  6. Looping Gap : 0

Lo script posiziona lo sprite appena fuoriscito dalla sinistra dello schermo direttamente dopo l'ultimo sprite alla destra. Se impostiamo LoopingGap a 0 i vari sprite combacieranno  perfettamente l'uno all'altro, in sequenza, come un unico sprite. Quindi imposteremo LoopingGap a 0 nel caso delle immagini di sfondo come lo spazio, mentre imposteremo un LoopingGap a piacimento per il Middleground dei pianeti.

Per funzionare correttamente lo script necessita che le immagini di Background siano almeno due. Occorrerà quindi duplicare lo sprite space posizionando un secondo sfondo accanto al primo.

Per far funzionare lo ScrollingScript necessita uno script di utilità che abbiamo chiamato RendererHelper. Non occorre aggiungere questo script agli oggetti di gioco.

Se vogliamo rendere il nostro gioco ancora più realistico, possiamo creare un ulteriore  livello tra il Foreground ed il Middleground. Nel Middleground posizioneremo i pianeti scalati di un fattore tra lo 0.2 e lo 0.4. mentre nel nuovo livello invece lasceremo i pianeti della dimensione originale o scalati tra 0.8 e 1.2.



Regoliamo quindi le velocità dei tre livelli in maniera tale che i pianeti più grandi e vicini scorrano più velocemente rispetto a quelli lontani.

L'effetto finale dovrebbe essere all'incirca il seguente.



Unity 3D - Introduzione

Unity è uno strumento di authoring integrato multipiattaforma per la creazione di videogiochi 3D o altri contenuti interattivi, quali visualizzazioni architettoniche o animazioni 3D in tempo reale.
 
Unity gira sia su Microsoft Windows sia su Mac OS X, ed i giochi che produce possono essere eseguiti su Windows, Mac, Linux, Xbox 360, PlayStation 3, Wii, iPad, iPhone, Android e, nel corso dell'anno 2014, Xbox One.
Può anche produrre giochi per browser web che utilizzano il plugin Unity web player, supportate su Mac e Windows. Il web player viene utilizzato anche per la distribuzione come i widget negli Apple Macintosh. Unity ha anche la possibilità di esportare giochi alle funzionalità 3D di Adobe stage in Flash, ma alcune caratteristiche supportati dal web player non sono utilizzabili a causa di limitazioni in Flash.



Unity consente di utilizzare sia un editor per lo sviluppo / progettazione di contenuti sia un motore di gioco per l'esecuzione del prodotto finale. Unity è simile al Director, Blender game engine, Virtools, Torque Game Builder e Gamestudio, è inoltre possibile utilizzare un ambiente grafico integrato come metodo primario di sviluppo. Il 12 Novembre 2013 è stata rilasciata la versione 4.3 che permette lo sviluppo facilitato di giochi bidimensionali e un notevole tool-kit per la creazione di GUI personalizzate.[1]
 
Unity non si classifica al primo posto per performance o qualità del rendering, ma è indubbiamente un software flessibile che permette di realizzare qualunque genere di gioco con poco sforzo. Unity è disponibile in due versioni (Free e Pro) e con diversi plugin che possono essere acquistati in maniera indipendente.
La versione Free contiene una gran quantità di funzioni, e permette di realizzare un gioco completo e  pronto ad essere distribuito o messo in vendita.
 
 

Alternative ad Unity 3D

 
Tra i principali concorrenti di Unity 3D troviamo UDK e Cry Engine:
 
L'Unreal Engine è un motore grafico sviluppato da Epic Games. La prima versione è stata realizzata per lo sparatutto in prima persona Unreal, pubblicato nel 1998 per Microsoft Windows, Linux e Mac OS; nel corso degli anni lo sviluppo è continuato, adattando il software alle potenzialità degli hardware disponibili e portandolo ad altre piattaforme. Attualmente è disponibile la terza generazione del motore; tuttavia nel 2013 è stata annunciata l'Unreal Engine 4[1]




CryENGINE è il motore grafico sviluppato da Crytek per lo sparatutto in prima persona Far Cry. Fu originariamente sviluppato come dimostrativo per la tecnologia NVIDIA ma, una volta intuitone il potenziale, ne fu sviluppato un gioco destinato alla vendita.



Pubblicato nel 2004, con Far Cry, offre pieno supporto alle librerie OpenGL e DirectX8.1; tramite successive patch sono state introdotte features proprie delle DirectX9, come l'HDRI. Il gioco di Far Cry veniva spesso utilizzato per i benchmark di sistemi e schede video.
Malgrado l'ottima resa grafica che il CryENGINE era in grado di offrire, è stato acquistato in licenza da una sola società, NCsoft, per il MMORPG Aion: Tower of Eternity; questo è dovuto alle iniziali critiche per le eccessive richieste hardware per garantire una certa fluidità nella resa e alla concorrenza dei rivali Source Engine di Valve Software, id Tech 4 di id Software e l'Unreal Engine che erano in grado di garantire una migliore resa dei dettagli ed una migliore fluidità del rendering.[1]

Scegliere tra C#, Javascript e Boo

Unity consente di sviluppare i propri script di gioco indifferentemente in tre linguaggi di programmazione: C#, JavScript e Boo.

Cerchiamo di capire quali sono le differenze tra i tre, e quale linguaggio conviene scegliere quando si decide di iniziare a sviluppare con Unity 3d.

Innanzi tutto facciamo una premessa: tutti e tre i linguaggi sono equivalenti in termini di funzionalità e non presentano alcuna differenza sostanziale in termini di performance del gioco finale. La decisione è quindi una scelta del tutto personale che può essere presa sia in considerazione delle osservazioni che andiamo ad effettuare sia dalla consoscenza pregressa di uno dei linguaggi di programmazione.
C# - Questo linguaggio, molto diffuso in ambito Windows, è molto conosciuto e documentato. È molto semplice trovare esempi di codice, forum, documentazione, nonché amici o conoscenti in grado di dare suggerimenti  su questo linguaggio. Molto nutriti sono anche gli esempi di codice e gli script Unity già realizzati.
Questo linguaggio rientra nella categoria degli strict languages,  questo rende la stesura più pesante, ma ci evita non pochi errori a runtime.

UnityScript (Non proprio JavaScript) -  È un linguaggio di facile apprendimento. Presenta gli stessi vantaggi del c# dal punto di vista della documentazione e degli esempi di codice. La differenza sostanziale sta nel fatto che non essendo un linguaggio strict può nascondere degli errori che vengono rilevati solo in fase di esecuzione.
Boo -   È un linguaggio molto potente e dalla sintassi elegante. Tuttavia, non essendo un linguaggio molto diffuso al di fuori di Unity, non è così semplice reperire esempi di codice o documentazione come per i due linguaggi precedenti.

"Linguaggi Lazy e Strict - Nella programmazione, la valutazione lazy o pigra è una tecnica che consiste nel ritardare una computazione finché il risultato non è richiesto effettivamente.

I benefici della valutazione pigra includono: aumento delle prestazioni per evitare calcoli non necessari, evitare condizioni di errore nella valutazione di espressioni composte, capacità di costruire strutture dati potenzialmente infinite, capacità di definire strutture di controllo come astrazioni invece che come primitive.

I linguaggi che effettuano una valutazione lazy possono essere ulteriormente suddivisi in linguaggi che utilizzano una strategia di valutazione call-by-name e quelli che utilizzano una strategia call-by-need. I linguaggi lazy più realistici, quali l'Haskell, utilizzano call-by-need per ragioni di prestazioni, mentre linguaggi più teorici fanno uso della strategia call-by-name per questioni di semplicità.

L'opposto della valutazione lazy è la valutazione eager, a volte nota come valutazione stretta (strict evaluation). La valutazione eager mira a determinare il valore di una computazione il prima possibile, anche se esso non è richiesto in quel momento. Questo è il comportamento tipico della maggior parte dei linguaggi di programmazione."