Dois-je utiliser des événements dans un jeu XNA?

J'ai créé une classe de boutons qui dessine un bouton sur l'écran. Lorsque je clique dessus, je veux voir quelque chose se produire. Dans WinForm, j'utiliserais simplement l'événement OnClick du bouton. Et XNA?

Dois-je ajouter un événement OnClick à ma classe de boutons? Est-ce une bonne pratique? Sinon, comment gérez-vous les événements dans votre boucle de jeu?

La seule raison contre l'utilisation eventdans un jeu est que la création d'un délégué à attacher au gestionnaire d'événements crée un objet tas qui peut provoquer un garbage collection qui peut provoquer un hoquet de fréquence d'images sur Xbox 360 (et peut-être WP7, n'a pas testé il).

En général, cela ne devrait pas être pertinent pour une interface utilisateur de jeu que vous avez configurée une fois et que vous laissez simplement s'exécuter.

En outre, appeler un gestionnaire d'événements est un tout petit, petit, petit peu plus lent que certaines autres méthodes disponibles. Et cela est également absolument hors de propos pour une interface utilisateur. (Il n'entre en jeu que pour le calcul numérique optimisé).

Donc, tant que vous ne courez pas autour de l'attribution de gestionnaires d'événements, bon gré mal gré, le choix d'utiliser un eventdans un jeu n'est pas différent du choix d'en utiliser un dans une application régulière.

Copier la conception de WinForms pour votre interface utilisateur de jeu est parfaitement bien.

(Il convient de souligner une mise en garde des événements est qu'ils sont des références fortes "cachées" qui peuvent involontairement garder des objets en vie si vous ne supprimez pas le gestionnaire. Cela est pertinent pour les jeux et les applications régulières)

Il est parfaitement acceptable d'utiliser des événements pour gérer des choses comme les clics et autres interactions avec l'interface de votre bouton; c'est certainement une méthode supérieure à celle qui implique de sous-classer le Buttontype pour implémenter un comportement personnalisé.

Une autre alternative peu courante consiste à attacher des scripts aux boutons et autres éléments de l'interface utilisateur, mais cela est plus complexe (à moins que vous n'ayez déjà un système de script robuste en place) et pas nécessairement mieux de toute façon.

Vous voudrez peut-être également examiner le concept de " GUI en mode immédiat ", qui offrent une autre façon de gérer les entrées.

Il y a trois approches courantes que j'ai vues dans les moteurs de jeu, je ne suis pas sûr que XNA supporte les trois mais les voici:

1. vous pouvez hériter une classe de votre classe de bouton et remplacer OnClickFunction dans votre classe CustomButton. L'avantage est que vous n'avez pas à vérifier si le bouton est enfoncé, il vous a informé chaque fois qu'il est cliqué, mais il peut entraîner une utilisation excessive de l'héritage.

2. vous pouvez définir une fonction OnClick et la passer à la classe butten OnClickEvent (tout comme la gestion normale des événements c #). cela a le même avantage que le précédent et vous n'avez pas à vous soucier de la surutilisation de l'héritage.

3. vous devez vérifier dans votre boucle principale si ce bouton est cliqué ou non. dans cette méthode, ce n'est pas vraiment un événement. donc l'inconvénient est que vous devez vous vérifier chaque fois que vous devez faire quelque chose en fonction des entrées de bouton, mais il a l'avantage de pouvoir contrôler où les boutons sont réellement vérifiés et prennent effet.

J'ai cessé d'utiliser les événements .net et j'ai commencé à stocker tous mes événements et modifications dans le tampon:

public sealed class GameStateData
{
    public bool IsEmpty = true;
    public List<EventData> EventDatas = new List<EventData>();
    public List<ChangeData> ChangeDatas = new List<ChangeData>();
    ...//your additional data

    public void Reset()
    {
        IsEmpty = true;
        ManifoldDatas.Count = 0;
        ChangeDatas.Count = 0;
    }
}

public struct ChangeData
{
    public Node Sender;
    public short PropertyIndex; // predefined property index (f.e. (short)MyIndexEnum.Life)
    public object OldValue;
    public object NewValue;
    public object AdditionalData;
}

Avantages:

1. Pour la prise en charge du multithreading, la seule chose dont vous avez besoin est d'échanger des tampons et de traiter tous les événements et modifications dans le thread de rendu.
2. Chaque changement de gamestep sera sauvegardé, donc toute logique de jeu peut être basée sur une combinaison d'événements. Vous pouvez même implémenter l'inversion du temps.
3. Vous n'avez pas besoin de créer des champs d'événement augmentant la taille d'un seul objet. Dans la plupart des cas, la logique de jeu ne nécessite qu'un seul abonné rare.
4. Il n'y a presque pas d'allocation de mémoire supplémentaire (à l'exception des cas de boxe) (WP7, XBox et autres micro-framework critiques).
5. Différents ensembles d'événements peuvent gérer un objet GameStateData prédéfini.

Les inconvénients:

1. Plus de dépenses en mémoire, bien que vous n'ayez besoin que de 3 tampons (jeu, échange et rendu).
2. Écriture de code supplémentaire au démarrage pour implémenter les fonctionnalités nécessaires.

BTW parfois j'utilise les deux: modèle d'événement et modèle de tampon.