Concepts Unity & C# : Utilité et Exemples
1. Git
Sert à sauvegarder l'historique complet de ton projet à différentes étapes, à travailler à plusieurs
en même temps sans écraser le travail des autres, et à tester des fonctionnalités risquées sur une
branche séparée sans casser la version jouable principale.
git init
git add .
git commit -m "Initial commit"
git branch feature-inventory
git checkout feature-inventory
2. L'import de packages
Sert à ajouter de nouveaux outils de développement ou des systèmes préconçus (comme un
nouveau système d'input, de l'animation cinématique, ou des assets 3D) au sein du moteur sans
alourdir les fichiers par défaut de ton projet de base.
{
"dependencies": {
"[Link]": "2.9.5",
"[Link]": "1.7.0",
"[Link]": "3.2.2"
}
}
3. Le filtrage par layers
Sert à optimiser les calculs du moteur physique et de rendu en excluant délibérément certains
objets des collisions ou de l'affichage. Cela permet par exemple de s'assurer que l'arme du joueur
ne collisionne pas avec la capsule du joueur lui-même.
using UnityEngine;
public class LayerCollision : MonoBehaviour
{
[SerializeField] private LayerMask targetLayer;
[SerializeField] private float detectionRadius = 5f;
private void Update()
{
Collider[] hitColliders = [Link]([Link], detectionRadius, tar
foreach (Collider hit in hitColliders)
{
[Link](false);
}
}
}
4. Les navmeshes
Sert à définir l'espace géométrique sur lequel une intelligence artificielle a le droit de marcher. Le
système calcule automatiquement la trajectoire la plus courte pour qu'une entité atteigne sa cible
en évitant les murs et les obstacles.
using UnityEngine;
using [Link];
[RequireComponent(typeof(NavMeshAgent))]
public class EnemyNavigation : MonoBehaviour
{
[SerializeField] private Transform playerTarget;
private NavMeshAgent navAgent;
private void Awake()
{
navAgent = GetComponent<NavMeshAgent>();
}
private void Update()
{
if (playerTarget != null)
{
[Link]([Link]);
}
}
}
5. Les coroutines
Sert à créer des séquences temporelles, des délais ou à étaler des calculs lourds sur plusieurs
secondes, tout en laissant le jeu tourner de manière fluide. Parfait pour gérer un fondu au noir,
l'apparition progressive d'ennemis ou des minuteurs.
using UnityEngine;
using [Link];
public class FadeEffect : MonoBehaviour
{
[SerializeField] private CanvasGroup interfaceGroup;
[SerializeField] private float fadeDuration = 2f;
private void Start()
{
StartCoroutine(ExecuteFade());
}
private IEnumerator ExecuteFade()
{
float elapsedTime = 0f;
while (elapsedTime < fadeDuration)
{
elapsedTime += [Link];
[Link] = [Link](1f, 0f, elapsedTime / fadeDuration);
yield return null;
}
[Link] = 0f;
}
}
6. Les raycasts
Sert à propulser un vecteur (une ligne mathématique) depuis un point donné pour savoir s'il
heurte une surface physique dans la scène. Utilisé pour gérer les mécaniques de tir, s'assurer
qu'un personnage touche le sol avant de sauter, ou interagir avec des portes et des objets.
using UnityEngine;
public class RaycastShooter : MonoBehaviour
{
[SerializeField] private float weaponRange = 50f;
[SerializeField] private LayerMask impactMask;
private void Update()
{
if ([Link]("Fire1"))
{
ExecuteShot();
}
}
private void ExecuteShot()
{
Ray aimingRay = new Ray([Link], [Link]);
if ([Link](aimingRay, out RaycastHit impactInfo, weaponRange, impactMask))
{
Destroy([Link]);
}
}
}
7. Le random
Sert à injecter de l'imprévisibilité contrôlée dans le comportement du jeu. C'est ce qui permet de
générer des éléments procéduraux de taille, de couleur ou de position différentes à chaque fois,
ou encore de déterminer les chances d'obtenir un objet rare.
using UnityEngine;
public class RandomSpawner : MonoBehaviour
{
[SerializeField] private GameObject[] spawnableEntities;
[SerializeField] private float spawnRadius = 10f;
private void Start()
{
SpawnEntity();
}
private void SpawnEntity()
{
if ([Link] == 0) return;
int randomIndex = [Link](0, [Link]);
Vector2 randomCircle = [Link] * spawnRadius;
Vector3 spawnPosition = [Link] + new Vector3(randomCircle.x, 0, randomCircle
Instantiate(spawnableEntities[randomIndex], spawnPosition, [Link]);
}
}
8. Les attributes
Sert à manipuler le fonctionnement interne du code vis-à-vis du moteur de jeu. Cela permet de
restructurer visuellement un script dans l'Inspecteur, de créer des curseurs de réglage, de
protéger des variables, ou d'obliger un objet à posséder d'autres composants spécifiques.
using UnityEngine;
[RequireComponent(typeof(Rigidbody))]
[RequireComponent(typeof(BoxCollider))]
public class CharacterData : MonoBehaviour
{
[Header("Core Attributes")]
[SerializeField] private string characterName;
[Range(1f, 100f)]
[SerializeField] private float movementSpeed;
[Space(15)]
[Tooltip("Indicates if the character can jump")]
[SerializeField] private bool isJumpingEnabled;
[HideInInspector]
public bool isGrounded;
}
9. La localization
Sert à détacher définitivement les textes affichés à l'écran du code source, afin que ces textes
puissent être chargés dynamiquement depuis des bases de données selon les préférences
linguistiques du joueur, facilitant grandement la traduction du jeu fini.
using UnityEngine;
using [Link];
using [Link];
using TMPro;
public class LanguageManager : MonoBehaviour
{
[SerializeField] private LocalizedString greetingKey;
[SerializeField] private TextMeshProUGUI targetTextElement;
private void OnEnable()
{
[Link] += UpdateTextUI;
}
private void OnDisable()
{
[Link] -= UpdateTextUI;
}
private void UpdateTextUI(string localizedString)
{
[Link] = localizedString;
}
}
10. La consultation de la documentation
Sert à vérifier instantanément les capacités exactes fournies par le moteur. C'est le réflexe qui
permet de s'assurer des paramètres requis par une fonction, de découvrir des raccourcis
mathématiques existants et d'apprendre comment une classe est construite afin de ne jamais
réinventer la roue.
using UnityEngine;
[HelpURL("[Link]
public class DocumentedScript : MonoBehaviour
{
private void Start()
{
[Link]("[Link]
}
}