doctorbin

Unity Addendum Personaggio

May 10th, 2021
668
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. // all'inizio dobbiamo specificare quali librerie usare
  2. // come vedete in grigio sono librerie che abbiamo specificato ma NON abbiamo utilizzato
  3. using System.Collections;
  4. using System.Collections.Generic;
  5. using UnityEngine;
  6.  
  7. // ogni programma C# definisce UNA classe, il nome minuscolo/maiuscolo deve coincidere con il nome
  8. // del file. In questo caso il file che contiene questo testo DEVE chiamarsi Player.cs
  9. // MonoBehaviour e' un pezzo di UnityEngine che SA come gestire le funzionalita' dei GameObject
  10. // nel nostro esempio noi utilizzeremo le callback Start, FixedUpdate
  11. // useremo override quando le callback hanno gia' una implementazione in MonoBehaviour
  12. //           nostra classe
  13. //           v        classe di Unity Engine
  14. //           v        v
  15. public class Player : MonoBehaviour
  16. {
  17.     #region parameters
  18.     // i parametri PUBLIC si vedranno nell'inspector
  19.     [Header("Impostazione velocita' movimento")]
  20.     public float speed = 10;
  21.     [Header("Impostazione sensibilita' mouse")]
  22.     public float mousesensitivity = 3;
  23.     [Header("Qui dovete trascinare la camera")]
  24.     public GameObject fpsCamera;
  25.     private Animator m_Animator;
  26.     #endregion
  27.     #region variables
  28.     private Rigidbody rb;
  29.     // contiene l'angolo corrente di inclinazione della camera
  30.     // che viene modificato dal mouse up and down
  31.     private float currentCameraUpRot = 0;
  32.     #endregion
  33.  
  34.     void Start()
  35.     {
  36.         // questo script deve essere messo nel gameobject in cui abbiamo messo il componente rigidbody
  37.         // ecco perche' questa funzione riesce a trovare il rigidbody associato
  38.         rb = this.GetComponent<Rigidbody>();
  39.         m_Animator = GetComponent<Animator>();
  40.        
  41.     }
  42.  
  43.    
  44.     // FixedUpdate da usarsi per i movimenti che includono interazioni fisiche
  45.     // Update quando solo la parte di rendering visuale e' coinvolta (no rigid body)
  46.     private void FixedUpdate()
  47.     {
  48.         MovePlayer();
  49.         RotatePlayer();
  50.         UpDownCamera();
  51.        
  52.     }
  53.  
  54.     // gestione del movimento con AWSD o freccie
  55.     // W o ^ per muovere su z+ (avanti) senso positivo freccia blu
  56.     // S o v per muovere su z- (indietro)
  57.     // A o < per muovere su x- (sinistra)
  58.     // D o > per muovere su x+ (destra) senso positivo freccia rossa
  59.     private void MovePlayer()
  60.     {
  61.         float x = Input.GetAxis("Horizontal"); // AD o <>
  62.         float z = Input.GetAxis("Vertical"); // WS o ^v
  63.  
  64.         // applica orizzontale su destra sinistra sinistra = valori negativi
  65.         // transform right e' il vettore "rosso" locale che tiene conto della posizione del player
  66.         Vector3 HorizontalMovement = transform.right * x;
  67.         // applica verticale per avanti indietro avanti = valore positivi
  68.         // transform forward e' il vettore "blu" locale che tiene conto della posizione del player
  69.         Vector3 VerticalMovement = transform.forward * z;
  70.  
  71.         // calcola movimento complessivo
  72.         Vector3 movement = (HorizontalMovement + VerticalMovement);
  73.  
  74.         // solo se c'e' qualcosa da muovere
  75.         if (movement != Vector3.zero)
  76.         {
  77.             // normalizza su un vettore lungo esattamente 1
  78.             // nel caso in cui ci siano movimenti contemporanei fa in modo che sia
  79.             // sempre lineare
  80.             movement.Normalize();
  81.  
  82.             // applica movimento tenendo conto
  83.             // * della velocita' impostata nell'inspector
  84.             // * del fixedDeltaTime che serve a "normalizzare" il movimento in modo da renderlo fluido.
  85.             rb.MovePosition(rb.transform.position + movement * Time.fixedDeltaTime * speed);
  86.  
  87.             // animation
  88.             float m_TurnAmount = Mathf.Atan2(movement.x, movement.z);
  89.             float m_ForwardAmount = movement.z;
  90.             m_Animator.SetFloat("Forward", 1f, 0.1f, Time.fixedDeltaTime);
  91.             // end animation
  92.            
  93.         } else
  94.         {   // animation
  95.             m_Animator.SetFloat("Forward", 0f, 0.1f, Time.fixedDeltaTime);
  96.             m_Animator.SetFloat("Turn", 0f, 0.1f, Time.fixedDeltaTime);
  97.             // end animation
  98.         }
  99.  
  100.        
  101.     }
  102.  
  103.     // gestione della rotazione del giocatore (mouse sinistra / destra)
  104.     private void RotatePlayer()
  105.     {
  106.         // ottiene il valore di scostamento del mouse - per sx + per destra
  107.         float mx = Input.GetAxis("Mouse X");
  108.  
  109.         // la rotazione deve essere applicata all'asse Y verticale il secondo numero
  110.         // mouse sensitivity serve per poter controllare la velocita' di rotazione del player
  111.         Vector3 rotation = new Vector3(0, mx, 0) * mousesensitivity;
  112.  
  113.         // in matematica aggiungere una rotazione ad una rotazione gia' presente
  114.         // [ le rotazioni vengono rappresentate da Quaternioni, ma noi usiamo una rappresentazione
  115.         // detta "di Eulero" che e' piu' semplice in cui si indicano i gradi di rotazione attorno
  116.         // agli assi X, Y, Z dove Y e' la rotazione che ci interessa.
  117.         // dobbiamo quindi convertire il valore precedente rotation che era espresso in termini
  118.         // di Eulero in modo che sia una rotazione valida. Ecco perche' lo trasformiamo in Quaternione]
  119.         rb.MoveRotation(rb.transform.rotation * Quaternion.Euler(rotation));
  120.         // animation
  121.         m_Animator.SetFloat("Turn", mx, 0.1f, Time.fixedDeltaTime);
  122.         // end animation
  123.  
  124.     }
  125.  
  126.     // gestiamo la rotazione che in termine tecnico si chiama "tilt" che indica la pendenza
  127.     // usiamo il mouse lungo la direzione verticale in alto alza la telecamera = riduce il tilt
  128.     // per questo motivo mettiamo -= updown
  129.     // ci memorizziamo un angolo di partenza currentCameraUpRot che poi andremo a modificare
  130.     // ottenendo l'angolo Euleriano
  131.     private void UpDownCamera()
  132.     {
  133.         float my = Input.GetAxis("Mouse Y");
  134.         float updown = my * mousesensitivity;
  135.         // computa il nuovo angolo invertendo il valore di Y
  136.         currentCameraUpRot -= updown;
  137.  
  138.         // fortunatamente possiamo impostare l'angolo della camera usando un semplice vettore Euleriano
  139.         // notate che ruotiamo la camera girandola attorno al suo asse X rosso
  140.         fpsCamera.transform.localEulerAngles = new Vector3(currentCameraUpRot, 0, 0);
  141.     }
  142. }
  143.  
RAW Paste Data