Aller au contenu

Feuille de chaleur unité

Unité - Développement de jeux pour Mobile

Unity est un puissant moteur de jeu multiplateforme utilisé pour créer des jeux et simulations 2D, 3D, VR et AR. Cette triche se concentre sur le développement de jeux mobiles avec Unity.

Copier toutes les commandes Générer PDF

Sommaire

  • [Installation] (#installation)
  • [Éditeur d'unité] (#unity-editor)
  • [Concepts de base] (#core-concepts)
  • L'écriture avec C#
  • [Physique] (#physics)
  • [Système UI] (#ui-system)
  • [Animation] (#animation)
  • [Développement mobile] (#mobile-development)
  • [Optimisation du rendement] (#performance-optimization)
  • [Gestion de l'actif] (#asset-management)
  • [Test et débogage] (#testing-debugging)
  • [Déploiement] (#deployment)
  • [Meilleures pratiques] (#best-practices)

Installation

Unité Hub

# Download Unity Hub from unity.com
# Unity Hub manages Unity versions and projects

# Install Unity version
# Open Unity Hub -> Installs -> Add
# Select desired Unity version (e.g., 2021.3 LTS)
# Add modules: Android Build Support, iOS Build Support

# Set environment variables (optional)
# UNITY_HOME=/path/to/unity/version
# PATH=$PATH:$UNITY_HOME/Editor

Configuration Android

# In Unity Hub, add Android Build Support module
# Unity will install required Android SDK & NDK

# Verify setup in Unity Editor
# Edit -> Preferences -> External Tools
# Check Android SDK, NDK, and JDK paths

# For custom SDK/NDK
# Download from developer.android.com
# Set paths in Unity Editor
```_

### Configuration iOS (macOS seulement)
```bash
# In Unity Hub, add iOS Build Support module

# Install Xcode from Mac App Store
# Install Xcode Command Line Tools
xcode-select --install

# Install CocoaPods
sudo gem install cocoapods

# Verify setup in Unity Editor
# Edit -> Preferences -> External Tools
# Check Xcode path
```_

## Éditeur d'unité

### Windows principaux
- **Vue de la scène** : Représentation visuelle du monde du jeu
- **Vue du jeu**: Aperçu du jeu vu par le joueur
- **Hierarchie**: Liste de tous les objets de jeu dans la scène actuelle
- **Projet**: Navigateur pour tous les actifs du projet
- **Inspecteur**: Propriétés de l'objet ou de l'actif sélectionné
- **Console**: Affiche les journaux, les avertissements et les erreurs

### Raccourcis clavier
- **Q** : Outil à main (pan)
- **W** : Outil de déplacement
- **E** : Outil rotatif
- **R** : Outil d'échelle
- **T**: Outil de rect (pour l'assurance-chômage)
- **Ctrl/Cmd + S**: Enregistrer la scène
- **Ctrl/Cmd + P**: Jeu de lecture/pause
- **Ctrl/Cmd + Maj + P**: Cadre d'étape
- **F** : Focus sur l'objet sélectionné
- **Ctrl/Cmd + D**: Dupliquer l'objet sélectionné

### Gestion de projet
```bash
# Create new project
# Unity Hub -> Projects -> New
# Select template (2D, 3D, URP, HDRP)
# Enter project name and location

# Open existing project
# Unity Hub -> Projects -> Add
# Select project folder

# Upgrade project
# Open project in newer Unity version
# Unity will prompt for upgrade

Concepts fondamentaux

Objet du jeu

  • Les objets fondamentaux de l'Unité qui représentent les personnages, accessoires, décors, caméras, etc.
  • Un conteneur pour composants.

Composante

  • Pièces fonctionnelles d'un objet de jeu.
  • Exemples: Transformer, Mesh Renderer, Rigidbody, Collider, Scripts.

Composante transformation

  • Chaque GameObject a un composant Transform.
  • Définit la position, la rotation et l'échelle du GameObject.

Scène

  • Un conteneur pour un ensemble de GameObjects.
  • Représente un niveau, un menu ou une partie du jeu.

Préfab

  • Un objet de jeu réutilisable stocké dans la vue Projet.
  • Vous permet de créer, configurer et stocker un GameObject complet avec tous ses composants, valeurs de propriété, et enfants GameObjects comme un actif réutilisable.

Actifs

  • Tout fichier utilisé dans un projet Unity, comme les modèles, textures, sons, scripts, etc.

Scénario avec C

Création d'un script

// In Project view, right-click -> Create -> C# Script
// Name the script (e.g., PlayerController)
// Attach script to a GameObject by dragging it to the Inspector

Monocomportement Cycle de vie

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    // Called when the script instance is being loaded
    void Awake()
    {
        Debug.Log("Awake called");
    }

    // Called on the frame when a script is enabled before any of the Update methods are called the first time
    void Start()
    {
        Debug.Log("Start called");
    }

    // Called every frame
    void Update()
    {
        // Game logic that needs to run every frame
    }

    // Called every fixed framerate frame
    void FixedUpdate()
    {
        // Physics calculations
    }

    // Called every frame, after all Update functions have been called
    void LateUpdate()
    {
        // Camera movement, etc.
    }

    // Called when the object becomes enabled and active
    void OnEnable()
    {
        Debug.Log("OnEnable called");
    }

    // Called when the object becomes disabled or inactive
    void OnDisable()
    {
        Debug.Log("OnDisable called");
    }

    // Called when the MonoBehaviour will be destroyed
    void OnDestroy()
    {
        Debug.Log("OnDestroy called");
    }
}

Accès aux composants

// Get component on the same GameObject
Rigidbody rb = GetComponent<Rigidbody>();

// Get component on a child GameObject
Transform childTransform = GetComponentInChildren<Transform>();

// Get component on a parent GameObject
PlayerController parentController = GetComponentInParent<PlayerController>();

// Add component to GameObject
BoxCollider collider = gameObject.AddComponent<BoxCollider>();

// Find GameObject by name
GameObject player = GameObject.Find("Player");

// Find GameObject by tag
GameObject enemy = GameObject.FindWithTag("Enemy");

// Find all GameObjects with tag
GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");

Traitement des entrées

// Keyboard input
if (Input.GetKeyDown(KeyCode.Space))
{
    // Jump
}

if (Input.GetKey(KeyCode.A))
{
    // Move left
}

if (Input.GetKeyUp(KeyCode.LeftShift))
{
    // Stop sprinting
}

// Mouse input
if (Input.GetMouseButtonDown(0))
{
    // Left mouse button clicked
}

float mouseX = Input.GetAxis("Mouse X");
float mouseY = Input.GetAxis("Mouse Y");

// Touch input
if (Input.touchCount > 0)
{
    Touch touch = Input.GetTouch(0);

    if (touch.phase == TouchPhase.Began)
    {
        Debug.Log("Touch began");
    }

    if (touch.phase == TouchPhase.Moved)
    {
        Debug.Log("Touch moved");
    }

    if (touch.phase == TouchPhase.Ended)
    {
        Debug.Log("Touch ended");
    }
}

Coroutines

using System.Collections;
using UnityEngine;

public class CoroutineExample : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(Fade());
    }

    IEnumerator Fade()
    {
        Debug.Log("Coroutine started");

        // Wait for 2 seconds
        yield return new WaitForSeconds(2f);

        Debug.Log("After 2 seconds");

        // Wait for the end of the frame
        yield return new WaitForEndOfFrame();

        Debug.Log("End of frame");

        // Wait for another coroutine to finish
        yield return StartCoroutine(AnotherCoroutine());

        Debug.Log("Coroutine finished");
    }

    IEnumerator AnotherCoroutine()
    {
        Debug.Log("Another coroutine started");
        yield return new WaitForSeconds(1f);
        Debug.Log("Another coroutine finished");
    }

    // Stop a coroutine
    public void StopMyCoroutine()
    {
        StopCoroutine(Fade());
        StopAllCoroutines();
    }
}

Gestion des scènes

using UnityEngine.SceneManagement;

// Load a scene by name
SceneManager.LoadScene("Level1");

// Load a scene by index
SceneManager.LoadScene(1);

// Load a scene asynchronously
StartCoroutine(LoadSceneAsync("Level2"));

IEnumerator LoadSceneAsync(string sceneName)
{
    AsyncOperation asyncLoad = SceneManager.LoadSceneAsync(sceneName);

    while (!asyncLoad.isDone)
    {
        float progress = Mathf.Clamp01(asyncLoad.progress / 0.9f);
        Debug.Log("Loading progress: " + (progress * 100) + "%");
        yield return null;
    }
}

// Get the current scene
Scene currentScene = SceneManager.GetActiveScene();
string sceneName = currentScene.name;

Physique

Corps rigide

  • Composant qui permet à un objet de jeu d'être affecté par la physique.
  • Rigidbody: Pour la physique 3D.
  • Rigidbody2D: Pour la physique 2D.
// Get Rigidbody component
Rigidbody rb = GetComponent<Rigidbody>();

// Add force
rb.AddForce(Vector3.forward * 10f, ForceMode.Impulse);

// Add torque (rotation)
rb.AddTorque(Vector3.up * 5f, ForceMode.Force);

// Set velocity
rb.velocity = new Vector3(0, 10, 0);

// Move position (for kinematic rigidbodies)
rb.MovePosition(transform.position + Vector3.forward * Time.deltaTime);

// Move rotation
rb.MoveRotation(transform.rotation * Quaternion.Euler(Vector3.up * 10f * Time.deltaTime));

Collision

  • Définit la forme d'un objet de jeu pour les collisions physiques.
  • BoxCollider, SphereCollider, CapsuleCollider, MeshCollider.
  • Collider de boîte 2D, CircleCollider2D, CapsuleCollider2D.

Détection des collisions

// Called when this collider/rigidbody has begun touching another rigidbody/collider
void OnCollisionEnter(Collision collision)
{
    Debug.Log("Collision entered with: " + collision.gameObject.name);

    if (collision.gameObject.CompareTag("Enemy"))
    {
        // Take damage
    }
}

// Called once per frame for every collider/rigidbody that is touching another rigidbody/collider
void OnCollisionStay(Collision collision)
{
    Debug.Log("Collision staying with: " + collision.gameObject.name);
}

// Called when this collider/rigidbody has stopped touching another rigidbody/collider
void OnCollisionExit(Collision collision)
{
    Debug.Log("Collision exited with: " + collision.gameObject.name);
}

Détection de déclenchement

  • Les collisions peuvent être marquées comme "Is Trigger" pour détecter lorsque les objets entrent dans leur volume sans causer de collision.
// Called when the Collider other enters the trigger
void OnTriggerEnter(Collider other)
{
    Debug.Log("Trigger entered by: " + other.gameObject.name);

    if (other.CompareTag("Player"))
    {
        // Collect item
    }
}

// Called once per frame for every Collider other that is touching the trigger
void OnTriggerStay(Collider other)
{
    Debug.Log("Trigger staying with: " + other.gameObject.name);
}

// Called when the Collider other has stopped touching the trigger
void OnTriggerExit(Collider other)
{
    Debug.Log("Trigger exited by: " + other.gameObject.name);
}

Rayonnement

// Cast a ray from the camera to the mouse position
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;

if (Physics.Raycast(ray, out hit, 100f))
{
    Debug.Log("Ray hit: " + hit.collider.gameObject.name);
    Debug.Log("Hit point: " + hit.point);
}

// Cast a ray from a transform
if (Physics.Raycast(transform.position, transform.forward, out hit, 10f))
{
    Debug.Log("Forward ray hit: " + hit.collider.gameObject.name);
}

// Raycast with layer mask
int layerMask = 1 << 8; // Layer 8
if (Physics.Raycast(transform.position, Vector3.down, out hit, 2f, layerMask))
{
    Debug.Log("Ground detected");
}

Système d'assurance-chômage

Toile

  • L'élément racine pour toute l'interface utilisateur dans une scène.
  • ** Mode de rendu**: Espace écran - Superposition, Espace écran - Caméra, Espace mondial.

Composantes de l'assurance-chômage

  • Texte: affiche le texte.
  • Image: Affiche une image.
  • RawImage: affiche une texture.
  • Button: Un bouton cliquable.
  • Toggle: Une case à cocher.
  • Slider: un slider dragable.
  • Scrollbar: Une barre de défilement.
  • InputField: Un champ de saisie de texte.
  • Panel: Un contenant pour les autres éléments de l'interface utilisateur.
  • Scroll Vue: Une vue défilante.

Transformer rect

  • La composante Transformer pour les éléments d'assurance-chômage.
  • Définit la position, la taille, les ancres et le pivot.

Système d'événements

  • Gérer les événements d'entrée pour les éléments d'interface utilisateur.
  • Nécessite un EventSystem GameObject dans la scène.

Bouton Cliquez sur Événement

using UnityEngine.UI;

public Button myButton;

void Start()
{
    myButton.onClick.AddListener(OnButtonClick);
}

void OnButtonClick()
{
    Debug.Log("Button clicked!");
}

Accès aux composants d'interface utilisateur

using UnityEngine.UI;

public Text scoreText;
public Image healthBar;
public InputField nameInput;

void UpdateScore(int score)
{
    scoreText.text = "Score: " + score;
}

void UpdateHealth(float health)
{
    healthBar.fillAmount = health / 100f;
}

string GetPlayerName()
{
    return nameInput.text;
}

Animation

Composante animateur

  • Contrôle les animations sur un objet de jeu.
  • Utilise un actif Animator Controller pour gérer les états d'animation.

Contrôleur de l'animateur

  • Une machine d'état pour les animations.
  • ** États** : Représenter des animations individuelles (p. ex., Idle, Walk, Run, Jump).
  • Transitions : Définir comment se déplacer entre les états.
  • Paramètres: Variables qui contrôlent les transitions (p. ex., Vitesse, IsJumping).

Clips d'animation

  • Actifs contenant des données d'animation (p. ex., images clés pour le poste, la rotation, l'échelle).

Contrôler les animations de Script

Animator animator = GetComponent<Animator>();

// Set float parameter
animator.SetFloat("Speed", moveSpeed);

// Set bool parameter
animator.SetBool("IsJumping", true);

// Set trigger parameter
animator.SetTrigger("Attack");

// Get current animation state
AnimatorStateInfo stateInfo = animator.GetCurrentAnimatorStateInfo(0);
if (stateInfo.IsName("Attack"))
{
    // In attack animation
}

Événements d'animation

  • Appelez une fonction à un point précis d'un clip d'animation.
  • Ajoutez un événement dans la fenêtre Animation.
// Function to be called by animation event
public void OnAttackAnimationEnd()
{
    Debug.Log("Attack animation finished");
}

Développement mobile

Compilation spécifique à la plate-forme

#if UNITY_ANDROID
    // Android-specific code
#elif UNITY_IOS
    // iOS-specific code
#else
    // Code for other platforms (e.g., Editor)
#endif

Orientation de l'écran

// Set screen orientation
Screen.orientation = ScreenOrientation.LandscapeLeft;

// Allow auto-rotation
Screen.autorotateToPortrait = true;
Screen.autorotateToLandscapeLeft = true;
Screen.autorotateToLandscapeRight = true;
Screen.autorotateToPortraitUpsideDown = false;

Contrôles tactiles

void Update()
{
    if (Input.touchCount > 0)
    {
        Touch touch = Input.GetTouch(0);

        switch (touch.phase)
        {
            case TouchPhase.Began:
                // Handle touch began
                break;

            case TouchPhase.Moved:
                // Handle touch moved
                Vector2 touchDeltaPosition = touch.deltaPosition;
                break;

            case TouchPhase.Ended:
                // Handle touch ended
                break;
        }
    }
}

Accéléromètre

// Get accelerometer data
Vector3 acceleration = Input.acceleration;

// Use accelerometer for movement
float moveHorizontal = acceleration.x;
float moveVertical = acceleration.y;

Gyroscope

// Enable gyroscope
Input.gyro.enabled = true;

// Get gyroscope data
Quaternion rotation = Input.gyro.attitude;
Vector3 rotationRate = Input.gyro.rotationRate;

Vibration du périphérique

// Vibrate device
Handheld.Vibrate();

Données persistantes

// PlayerPrefs for simple data storage
PlayerPrefs.SetInt("HighScore", 100);
PlayerPrefs.SetString("PlayerName", "John");
PlayerPrefs.SetFloat("Volume", 0.8f);

int highScore = PlayerPrefs.GetInt("HighScore", 0);
string playerName = PlayerPrefs.GetString("PlayerName", "Guest");
float volume = PlayerPrefs.GetFloat("Volume", 1.0f);

PlayerPrefs.Save();

// For complex data, use file I/O
string path = Application.persistentDataPath + "/save.dat";
File.WriteAllText(path, "My save data");
string saveData = File.ReadAllText(path);

Optimisation des performances

Profileur

  • Un outil pour analyser et optimiser les performances du jeu.
  • Venteau -> Analyse -> Profiler.
  • CPU Utilisation: Identifier les goulets d'étranglement de performance dans les scripts.
  • ** Utilisation GPU**: Analyser les performances de rendu.
  • Mémorie : Suivre les allocations de mémoire et identifier les fuites de mémoire.

Abattage

  • Bataille statique: Pour les objets non mobiles qui partagent le même matériau.
  • Bataille dynamique: Pour les petits objets mobiles qui partagent le même matériau.

Cuillère

  • Frustum Culling: Automatiquement activé. Les objets en dehors de la vue de la caméra ne sont pas rendus.
  • Occlusion Culling: Empêche le rendu d'objets cachés derrière d'autres objets.

Niveau de détail (LOD)

  • Modèles Renders avec différents niveaux de détail en fonction de leur distance de la caméra.

Compression de texture

  • Utiliser des formats de compression de texture appropriés pour chaque plateforme (par exemple ASTC pour Android/iOS).

Mise en commun des objets

  • Réutiliser les objets au lieu de les injecter et les détruire fréquemment.
public class ObjectPool : MonoBehaviour
{
    public GameObject objectToPool;
    public int amountToPool;
    private List<GameObject> pooledObjects;

    void Start()
    {
        pooledObjects = new List<GameObject>();
        for (int i = 0; i < amountToPool; i++)
        {
            GameObject obj = Instantiate(objectToPool);
            obj.SetActive(false);
            pooledObjects.Add(obj);
        }
    }

    public GameObject GetPooledObject()
    {
        for (int i = 0; i < pooledObjects.Count; i++)
        {
            if (!pooledObjects[i].activeInHierarchy)
            {
                return pooledObjects[i];
            }
        }
        return null;
    }
}

Gestion des biens

Banques d'actifs

  • Archives d'actifs qui peuvent être chargés sur demande.
  • Utilisé pour le contenu téléchargeable (DLC) et la réduction de la taille de l'application initiale.

Actifs éligibles

  • Un système de gestion et de chargement des biens par adresse.
  • Simplifie la gestion et le chargement des actifs.

Dossier ressources

  • Un dossier spécial où les actifs peuvent être chargés par nom à l'exécution.
  • Non recommandé pour les grands projets en raison des répercussions sur le rendement.
// Load asset from Resources folder
Texture2D texture = Resources.Load<Texture2D>("Textures/my_texture");
GameObject prefab = Resources.Load<GameObject>("Prefabs/my_prefab");

Test et débogage

Déboguement

// Log messages to the console
Debug.Log("This is a log message");
Debug.LogWarning("This is a warning");
Debug.LogError("This is an error");

// Draw debug lines in the Scene view
Debug.DrawLine(transform.position, transform.position + transform.forward * 10f, Color.red);
Debug.DrawRay(transform.position, transform.forward * 10f, Color.green);

// Assertions
Debug.Assert(condition, "Assertion failed");

Cadre d'essai d'unité

  • Un cadre pour écrire et exécuter des tests automatisés dans Unity.
  • Venteau -> Généralités Coureur de test.
  • Modifier les tests en mode: Exécutez dans l'éditeur d'unité.
  • Tests en mode jeu: Exécutez dans le jeu pendant qu'il joue.
// Edit Mode Test
using NUnit.Framework;

public class CalculatorTests
{
    [Test]
    public void Add_TwoNumbers_ReturnsSum()
    {
        var calculator = new Calculator();
        var result = calculator.Add(2, 3);
        Assert.AreEqual(5, result);
    }
}

// Play Mode Test
using System.Collections;
using NUnit.Framework;
using UnityEngine.TestTools;

public class PlayerTests
{
    [UnityTest]
    public IEnumerator Player_Jumps_ChangesYPosition()
    {
        var player = new GameObject().AddComponent<Player>();
        float initialY = player.transform.position.y;

        player.Jump();

        yield return new WaitForSeconds(0.5f);

        Assert.Greater(player.transform.position.y, initialY);
    }
}

Déploiement

Configuration des paramètres

  • Dossier -> Construisez les paramètres.
  • Sélectionnez la plateforme cible (Android, iOS).
  • Ajoutez des scènes à la construction.
  • Configurer les paramètres du lecteur.

Paramètres du lecteur

  • Éditer -> Paramètres du projet -> Joueur.
  • ** Nom de la société**, Nom du produit, Version.
  • Icône, Écran de projection.
  • Identificateur du bundle (p. ex., com.company.product).
  • L'écriture du moteur (Mono, IL2CPP).
  • ** Niveau de compatibilité API**.

Construction Android

# In Build Settings, switch to Android platform
# Connect Android device with USB debugging enabled
# Click "Build and Run"

# To create an APK
# Click "Build"
# Save the APK file

# To create an AAB (Android App Bundle)
# Check "Build App Bundle (Google Play)"
# Click "Build"

iOS Construire (macOS seulement)

# In Build Settings, switch to iOS platform
# Click "Build"
# This will generate an Xcode project

# Open the Xcode project
# In Xcode, set up signing and capabilities
# Select target device and run the app

# To create an archive for App Store
# In Xcode, Product -> Archive

Meilleures pratiques

Organisation du projet

Assets/
├── _Project/
│   ├── Scenes/
│   ├── Scripts/
│   │   ├── Core/
│   │   ├── Gameplay/
│   │   └── UI/
│   ├── Prefabs/
│   ├── Materials/
│   ├── Textures/
│   ├── Animations/
│   └── Audio/
├── Plugins/
├── ThirdParty/
└── Resources/

Pratiques de codage

  • Utilisez des espaces de noms pour organiser le code.
  • Suivez une convention de nommage cohérente (p. ex. PascalCase pour les classes, camelCase pour les variables).
  • Cache les références de composants dans Awake ou Start.
  • Évitez d'utiliser GameObject.Find dans Update.
  • Utilisez la mise en commun des objets pour les objets fréquemment créés.
  • Optimiser les boucles et éviter les calculs inutiles.

Conseils de performance

  • Utilisez le Profiler pour identifier les goulets d'étranglement.
  • Utilisez le batchage statique pour les objets statiques.
  • Utilisez LOD pour des modèles complexes.
  • Compresser les textures et l'audio.
  • Utilisez des tondeuses appropriées et évitez les chevauchements.
  • Gardez la hiérarchie aussi plane que possible.

Résumé

Unité est un moteur de jeu polyvalent et puissant pour le développement mobile, offrant un riche ensemble d'outils et de fonctionnalités pour créer des jeux de haute qualité et des expériences interactives.

Avantages clés: - Platforme de choc: Construire pour Android, iOS et d'autres plateformes à partir d'une base de code unique. - Écosystà ̈me de Rich: Grand magasin d'actifs avec des actifs, des outils et des extensions prêts à utiliser. - Éditeur puissant: Éditeur intuitif et flexible pour la conception et la construction de jeux. - Strong Community: Documentation détaillée, tutoriels et soutien communautaire.

Cas de la meilleure utilisation: - Jeux mobiles 2D et 3D de tous genres. - Demandes d'AR et de RR. - Simulations et visualisations interactives - Prototypage et développement rapides.

Considérations: - Peut avoir une courbe d'apprentissage raide pour les débutants. - L'optimisation des performances est cruciale pour les plateformes mobiles. - La taille de la construction peut être grande si elle n'est pas gérée avec soin.

En maîtrisant les concepts fondamentaux d'Unité, les scripts et les fonctionnalités spécifiques au mobile, les développeurs peuvent créer des jeux mobiles attrayants et réussis.