Unity a un bon système pour créer une interface utilisateur UI Canvas. De nombreux supports de formation y ont été écrits, mais la plupart des guides ne vous indiquent que sur quels boutons appuyer et quel code écrire pour le faire fonctionner. À titre d'exemples, une petite interface se compose généralement d'une paire de fenêtres: le menu principal, les paramètres. Cependant, dans les jeux, il y a beaucoup plus de fenêtres et quand il y en a déjà au moins une douzaine, le besoin d'une sorte d'organisation se fait sentir. Dans le cadre de cet article, je souhaite expliquer comment résoudre ce problème.

Vous devez d'abord sélectionner des fenêtres individuelles dans votre interface. Par fenêtre, je veux dire un panneau avec quelques contrôles.


Chaque fenêtre doit avoir un objet racine qui contiendra tous les contrôles. Cet objet représentera la fenêtre dans son ensemble. Par exemple, il y a un panneau sur lequel se trouvent les contrôles, il est logique de rendre ces éléments enfant par rapport au panneau. Un composant est attaché à chaque fenêtre, qui est le descendant de la classe abstraite Window.

Fenêtre

La fenêtre est écrite en supposant que les fenêtres peuvent avoir des fenêtres enfants, c'est-à-dire ces fenêtres qui peuvent être ouvertes à partir de la fenêtre actuelle en même temps en même temps qu'une fenêtre enfant peut être ouverte, et tout le reste doit être fermé. À cet effet, la classe contient la propriété CurrentWindow dans laquelle le lien vers la fenêtre actuellement ouverte est stocké. Et il y a aussi un événement OnOpen qui signale l'ouverture d'une fenêtre. La méthode ChangeCurrentWindow () peut être abonnée à cet événement près des fenêtres enfants, de sorte qu'à tout moment une fenêtre enfant soit ouverte, elle ferme la fenêtre enfant ouverte et change le lien vers la fenêtre ouverte actuelle, ci-dessous je vais donner un exemple d'implémentation. Également dans la classe, il existe des méthodes SelfClose () et SelfOpen (), ces méthodes sont responsables de la façon dont la fenêtre s'ouvrira et se fermera. Dans la méthode Awake (), la fenêtre est enregistrée dans UIManager, c'est-à-dire un lien vers la fenêtre est ajouté.

public abstract class Window : MonoBehaviour { public bool IsOpen { get; private set; } public Window CurrentWindow { get; protected set; } = null; public delegate void OpenEventHandler(Window sender); public event OpenEventHandler OnOpen; void Awake() { UIManager.Instance.Windows.Add(this.gameObject); } public void Open() { IsOpen = true; if (OnOpen != null) OnOpen(this); SelfOpen(); } protected abstract void SelfOpen(); public void Close() { IsOpen = false; if (CurrentWindow != null) CurrentWindow.Close(); SelfClose(); } protected abstract void SelfClose(); protected void ChangeCurrentWindow(Window sender) { if (CurrentWindow != null) CurrentWindow.Close(); CurrentWindow = sender; } } 

UIManager

Ensuite, nous passons à la classe UIManager, il s'agit d'une classe sigleton afin que toutes les fenêtres puissent y accéder si nécessaire. Comme vous pouvez le voir, il a une liste de fenêtres Windows, il stocke des liens vers toutes les fenêtres de la scène. InitUI () est nécessaire pour initialiser quelque chose, par exemple, si vous souhaitez créer des fenêtres à partir de préfabriqués, vous pouvez ici faire leurs instances.
Dans la méthode Start (), vous pouvez ouvrir des fenêtres qui devraient être ouvertes dès le début, ou vice versa, fermer les fenêtres inutiles. La méthode Get () vous permet d'obtenir un lien vers une fenêtre spécifique.

 using System.Collections; using System.Collections.Generic; using UnityEngine; using System; public class UIManager : MonoBehaviour { public static UIManager Instance = null; public List<GameObject> Windows; void Awake() { if (Instance == null) Instance = this; else if (Instance != this) Destroy(gameObject); InitUI(); } private void InitUI() { //to do } void Start() { foreach(var window in Windows) { var windowComponent = window.GetComponent<Window>(); if (windowComponent is StartWindow) windowComponent.Open(); else windowComponent.Close(); } } public Window Get<T> () where T : Window { foreach(var window in Windows) { var windowComponent = window.GetComponent<Window>(); if (windowComponent is T) return windowComponent; } return null; } } 

ParamètresWindow

À titre d'exemple, je vais vous donner mon implémentation de la fenêtre des paramètres:

 using System.Collections; using System.Collections.Generic; using UnityEngine; public class SettingsWindow : Window { private VideoSettingsWindow videoSettingsWindow; private LanguageSettingsWindow languageSettingsWindow; private AudioSettingsWindow audioSettingsWindow; private ControlSettingsWindow controlSettingsWindow; public void Start() { videoSettingsWindow = UIManager.Instance.GetWindow<VideoSettingsWindow>(); languageSettingsWindow = UIManager.Instance.GetWindow<LanguageSettingsWindow>(); audioSettingsWindow = UIManager.Instance.GetWindow<AudioSettingsWindow>(); controlSettingsWindow = UIManager.Instance.GetWindow<ControlSettingsWindow>(); videoSettingsWindow.OnOpen += ChangeCurrentWindow; languageSettingsWindow.OnOpen += ChangeCurrentWindow; audioSettingsWindow.OnOpen += ChangeCurrentWindow; controlSettingsWindow.OnOpen += ChangeCurrentWindow; } protected override void SelfOpen() { this.gameObject.SetActive(true); } protected override void SelfClose() { this.gameObject.SetActive(false); } public void Apply() { } public void VideoSettings() { videoSettingsWindow.Open(); } public void LanguageSettings() { languageSettingsWindow.Open(); } public void AudioSettings() { audioSettingsWindow.Open(); } public void ControlSettings() { controlSettingsWindow.Open(); } } 

À partir de la fenêtre des paramètres, je peux ouvrir 4 autres fenêtres afin qu'une seule fenêtre soit ouverte, je signe la méthode ChangeCurrentWindow () de la fenêtre des paramètres aux événements OnOpen des fenêtres enfants, donc les fenêtres ouvertes sont fermées lorsque d'autres s'ouvrent. Les implémentations SelfOpen () et SelfClose () activent ou désactivent simplement la fenêtre.

Ainsi, un système d'interface utilisateur facilement extensible est obtenu, il n'est pas nécessaire d'ajouter manuellement des liens vers des fenêtres dans l'inspecteur ou ailleurs; pour ajouter une nouvelle fenêtre, il vous suffit de créer la classe appropriée et de l'hériter de Window. Un tel système a quelques inconvénients, que plus il y aura de fenêtres, plus il faudra créer de classes et le fait que la recherche d'un lien vers la fenêtre se fasse en triant le tableau de liens, mais à mon avis, ces lacunes sont payantes.

Lien vers le référentiel