Unity fournit des API robustes pour capturer et traiter les interactions utilisateur, qu’il s’agisse de gestes tactiles sur appareils mobiles ou d’événements clavier sur plateformes desktop. Ces mécanismes sont fondamentaux pour implémenter des contrôles réactifs, intuitifs et multiplateformes.

Entrées tactiles : détection et traitmeent

Sur les systèmes embarqués (iOS, Android), chaque contact avec l’écran génère une séquence d’états appelée phase tactile. Unity expose ces états via la structure Touch et la propriété Input.touchCount, permettant une analyse fine du comportement utilisateur.

Les phases courantes incluent :

• TouchPhase.Began — déclenché au premier point de contact ; utile pour initier une action (ex. : saut, sélection).
• TouchPhase.Moved — émis à chaque déplacement du doigt ; idéal pour le glissement ou le contrôle analogique.
• TouchPhase.Stationary — indique un contact maintenu sans déplacement significatif.
• TouchPhase.Ended — signalé lors du relâchement du doigt ; souvent utilisé pour valider une action.
• TouchPhase.Canceled — survient en cas d’interruption système (ex. : appel entrant, passage en arrière-plan).

Voici une implémentation modulaire qui distingue les gestes simples tout en évitant les appels redondants :

public class InputHandler : MonoBehaviour { private Vector2? _initialTouchPosition; private float _dragThreshold = 15f;

void Update()
{
    if (Input.touchCount == 1)
    {
        Touch currentTouch = Input.GetTouch(0);

        switch (currentTouch.phase)
        {
            case TouchPhase.Began:
                _initialTouchPosition = currentTouch.position;
                Debug.Log("Contact détecté");
                break;

            case TouchPhase.Moved:
                if (_initialTouchPosition.HasValue && 
                    Vector2.Distance(currentTouch.position, _initialTouchPosition.Value) > _dragThreshold)
                {
                    Debug.Log("Glissement détecté");
                    _initialTouchPosition = null; // Réinitialiser après détection
                }
                break;

            case TouchPhase.Ended:
                if (_initialTouchPosition.HasValue)
                {
                    Debug.Log("Clic tap effectué");
                }
                _initialTouchPosition = null;
                break;
        }
    }
}

}

</div>Entrées clavier : gestion des états dynamiques
----------------------------------------------

Pour les plateformes PC/macOS, Unity propose plusieurs méthodes pour interroger l’état des touches :

- `Input.GetKeyDown()` — vrai uniquement pendant la frame où la touche est pressée (déclencheur ponctuel).
- `Input.GetKey()` — vrai tant que la touche reste enfoncée (utile pour les mouvements continus).
- `Input.GetKeyUp()` — vrai uniquement lors du relâchement (idéal pour les actions terminales).

L’exemple suivant illustre une approche plus souple, basée sur un tableau de raccourcis configurables :

<div>```
using UnityEngine;

public class KeyboardController : MonoBehaviour
{
    [Header("Raccourcis clavier")]
    public KeyCode jumpKey = KeyCode.Space;
    public KeyCode moveLeftKey = KeyCode.A;
    public KeyCode moveRightKey = KeyCode.D;
    public KeyCode pauseKey = KeyCode.Escape;

    private bool _isPaused;

    void Update()
    {
        if (Input.GetKeyDown(pauseKey))
        {
            _isPaused = !_isPaused;
            Time.timeScale = _isPaused ? 0f : 1f;
        }

        if (!_isPaused)
        {
            if (Input.GetKeyDown(jumpKey))
            {
                Debug.Log("Saut initié");
            }

            if (Input.GetKey(moveLeftKey))
            {
                transform.Translate(Vector3.left * Time.deltaTime * 4f);
            }

            if (Input.GetKey(moveRightKey))
            {
                transform.Translate(Vector3.right * Time.deltaTime * 4f);
            }
        }
    }
}