Comment ajouter un chat en temps réel à votre jeu Unity
Published: 2024-05-16 21:29:53

Le chat en temps réel ou le chat dans le jeu augmente l'engagement des joueurs et favorise la fidélisation des utilisateurs. Le chat en temps réel permet aux joueurs de communiquer entre eux, ce qui favorise le sentiment d'appartenance à une communauté et offre une plateforme d'interaction sociale qui rend l'expérience de jeu plus agréable.

Intégrer le chat en temps réel est plus facile à dire qu'à faire. Si l'on part de zéro, il faut beaucoup de ressources pour construire, maintenir et faire évoluer le système lorsque le nombre de joueurs augmente. Heureusement, PubNub a rendu plus facile que jamais l'injection de fonctionnalités en temps réel dans les jeux Unity grâce à notre plateforme API en temps réel et à faible latence. Que vous développiez pour Windows, Mac, iOS, Android, des systèmes de réalité virtuelle tels qu'Oculus et Meta Quest, ou que vous soyez multiplateforme, notre [SDK Unity](https://www.pubnub.com/docs/sdks/unity?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) vous couvre.

Continuez à lire pour apprendre comment ajouter un chat en temps réel à votre jeu vidéo Unity avec PubNub, en commençant par comprendre comment configurer différents modèles de canaux, apprendre comment envoyer/recevoir des messages, puis améliorer/sécuriser votre chat dans le jeu avec d'autres fonctionnalités telles que la modération, les emojis, les réactions et les GIFs.

Démarrer avec PubNub
--------------------

Avant de commencer à comprendre comment mettre en place votre chat dans le jeu, vous devez comprendre la plateforme PubNub et comment configurer votre application pour profiter des fonctionnalités de la plateforme.

### Vue d'ensemble

PubNub est basé sur le modèle Pub/Sub (Publier/S'abonner). Un utilisateur [publie](https://www.pubnub.com/docs/general/messages/publish?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) un message, qui est essentiellement une charge utile contenant toutes les informations pertinentes, sur le réseau PubNub. Les utilisateurs qui souhaitent recevoir ou écouter le message [s'abonneront](https://www.pubnub.com/docs/general/messages/receive?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) au réseau PubNub et analyseront le message. Le message peut contenir tout ce que vous voulez, tant qu'il ne dépasse pas 32 Ko (et de préférence en JSON).

Pour s'assurer que le message parvient aux bons destinataires, des [canaux](https://www.pubnub.com/docs/general/channels/overview?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) sont utilisés comme mécanisme de transmission des données d'un appareil à l'autre. Les canaux sont nécessaires chaque fois qu'un appareil souhaite publier et s'abonner au réseau PubNub. Alors qu'un utilisateur ne peut publier qu'un seul message à la fois, un utilisateur peut s'abonner à plusieurs canaux différents à la fois, en écoutant un assortiment de messages.

Alors que vous devez spécifier le nom exact du canal lorsque vous publiez un message, vous pouvez vous abonner à plusieurs canaux à la fois via le [multiplexage](https://www.pubnub.com/docs/general/channels/subscribe#channel-multiplexing?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr), qui consiste à s'abonner à un ou plusieurs canaux en fournissant les noms des canaux sous la forme d'un tableau de chaînes de caractères.

Pourquoi ces informations sont-elles nécessaires ? L'ensemble de votre système de messagerie dans le jeu sera basé sur le concept des canaux : la _façon dont vous formatez et sécurisez le nom du modèle de canal détermine le type de chat que vous souhaitez_.

### Installer et configurer le SDK PubNub Unity

Pour commencer, vous devrez configurer le SDK Unity de PubNub pour connecter votre application au réseau PubNub. Veuillez vous référer à la [documentation du SDK Un](https://www.pubnub.com/docs/sdks/unity?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) ity pour plus de détails, mais à titre indicatif, vous devrez :

1.  Ajouter le package Unity via le [Package Manager](https://www.pubnub.com/docs/sdks/unity#install-via-package-manager?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr).
2.  Créer un [compte PubNub gratuit](https://admin.pubnub.com/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) et obtenir vos clés PubNub. Il est essentiel d'activer les fonctionnalités de votre jeu de clés dont votre application a besoin - pour la fonctionnalité essentielle Pub/Sub, vous aurez simplement besoin d'activer Stream Controller. Nous nous assurerons de couvrir tous les autres paramètres que vous pourriez avoir besoin de configurer pour les fonctionnalités avancées.
3.  Fournissez à Unity les clés de publication et d'abonnement que vous avez obtenues à l'étape précédente pour [configurer le](https://www.pubnub.com/docs/sdks/unity#configure-pubnub?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) GameObject PubNub. Vous devez également fournir un UserId, car chaque objet PubNub a besoin d'un identifiant unique pour établir une connexion avec PubNub. Une fois cela fait, initialisez l'objet PubNub :

```js
using PubnubApi;
using PubnubApi.Unity;
…
PubNub pubnub = new Pubnub(pnConfiguration);
```

4.  Ajoutez des [récepteurs d'événements](https://www.pubnub.com/docs/sdks/unity#add-event-listeners?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) pour que votre jeu réagisse aux événements et aux messages. Il existe différents écouteurs d'événements permettant d'implémenter une logique personnalisée pour répondre à chaque type de message ou d'événement, mais pour la fonctionnalité principale d'échange de messages de chat, vous aurez simplement besoin de l'écouteur d'événements Message (vous apprendrez comment ajouter des fonctionnalités supplémentaires à votre chat en temps réel pour le rendre plus attrayant plus loin dans ce guide) :

```js
var listener = new SubscribeCallbackListener();
pubnub.AddListener(listener);
listener.onMessage += OnPnMessage;
…
private void OnPnMessage(Pubnub pn, PNMessageResult<object> result) {
    Debug.Log($"Message received: {result.Message}");
}
```

Avant de commencer à publier pour envoyer des messages à d'autres appareils et à vous abonner pour recevoir des messages des éditeurs, vous devez définir le nom de votre canal. N'oubliez pas : la façon dont vous mettez en forme votre modèle de canal détermine le type de chat que vous souhaitez mettre en œuvre.

Définition des différents modèles de chat
-----------------------------------------

Vous devrez réfléchir aux types de chat que vous devrez mettre en place pour votre jeu. Cette section traite du modèle de canal à suivre, et non de l'ensemble de la configuration permettant d'obtenir les informations requises de la part de votre jeu ou de vos utilisateurs. Si vous souhaitez voir les différents modèles de chat dans un projet Unity qui utilise PubNub, consultez notre [Unity Showcase Game](https://github.com/PubNubDevelopers/unity-multiplayer-shooter).

### Chat global

Le chat global permet à tous les joueurs d'un jeu de communiquer entre eux. Vous pouvez mettre en place un chat général en publiant et en vous abonnant à des messages sur un canal commun auquel tous les joueurs sont abonnés. Vous pouvez configurer la structure du canal pour les joueurs globaux :

```js
string allChat = “global”;
```

Chaque client s'abonne alors au canal et veille à ce que tout le monde reçoive les mêmes messages en temps réel, créant ainsi une expérience de discussion partagée à laquelle tout le monde peut participer.

### Chat privé/chuchotage

Le chat privé ou chuchotage permet aux joueurs d'avoir des conversations en tête-à-tête, où seuls les deux joueurs concernés peuvent discuter entre eux et personne d'autre. Dans un modèle de canal de chat privé ou chuchotage, chaque utilisateur s'abonne à une structure de canal destinée aux conversations privées :

```js
string privateChatBase= “chat.private.*”;
```

Cette structure utilise le concept de [Wildcard Subscribe](https://www.pubnub.com/docs/general/channels/subscribe#wildcard-subscribe?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr). Cette fonctionnalité peut être utilisée pour s'abonner à une liste hiérarchique de canaux, ce qui permet de s'abonner à de nombreux canaux avec une seule déclaration de nom.

Par exemple, lorsqu'un utilisateur est sur le point d'envoyer un message privé à un autre utilisateur, vous devez concaténer l'ID utilisateur PubNub actuel (ou UUID/uuid), qui représente l'identifiant unique permettant d'identifier l'utilisateur dans le réseau PubNub, et l'ID utilisateur du destinataire du message. Bien que vous puissiez toujours obtenir l'ID utilisateur de l'utilisateur actuel (via pubnub.GetCurrentUserId()), vous devez obtenir l'ID utilisateur du destinataire prévu. Une fois que vous avez l'ID utilisateur du destinataire, vous pouvez concaténer le canal comme suit :

```js
string privateChatMessage = “chat.private.user-a-uuid&user-b-uuid”;
```

Puisque vous spécifiez un motif de canal joker comme chat.private.\*, votre application s'abonnera à tous les noms de canaux qui correspondent à ce motif. Ainsi, vous n'avez pas besoin de connaître le nom du canal au moment de l'exécution. Enfin, l'utilisation des identifiants d'utilisateur garantit que le nom du canal est unique et que la conversation reste entre les deux utilisateurs.

### Chat entre amis

La création d'une discussion entre amis permet aux joueurs de communiquer en privé avec des joueurs spécifiques avec lesquels ils souhaitent établir une connexion plus étroite, qu'il s'agisse de joueurs nouvellement rencontrés ou d'amis en dehors du jeu.

Dans une discussion entre amis, vous devez créer un modèle de canal unique pour chaque appareil ou joueur, de la même manière que vous construisez un modèle de canal de discussion privée en y ajoutant votre identifiant d'utilisateur :

```js
string chanFriendChat = "chat.friends.” + pubnub.GetCurrentUserId();”
```

Vous devez ensuite répéter cette opération pour chaque utilisateur avec lequel vous souhaitez être ami : vous devez remplacer leur ID utilisateur dans la chaîne chanFriendChat par celui de pubnub.GetCurrentUserId(). Bien que vous ayez maintenant le modèle de canal en place, vous ne pouvez pas simplement vous abonner en utilisant un motif joker tel que chat.friends.\* ; au lieu de cela, vous aurez besoin d'un mécanisme pour déterminer quels joueurs sont amis.

Une solution à ce problème est le [groupe de canaux de](https://www.pubnub.com/docs/general/channels/subscribe#channel-groups?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) PubNub, qui vous permet de gérer un grand nombre de canaux à la fois. Les groupes de canaux sont essentiellement un pointeur vers une liste de canaux ; dans ce cas, le groupe de canaux est unique au joueur et contient une référence à tous les amis du joueur :

```js
string chanGroupFriendChat = "chanGroupFriendChat_" + pubnub.GetCurrentUserId();
```

Remarque : les noms des groupes de chaînes suivent les mêmes conventions que les noms de chaînes, mais ils [ne peuvent pas contenir de points](https://www.pubnub.com/docs/general/channels/subscribe#channel-group-names?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) dans leur nom, d'où la différence de structure.

Comme pour l'abonnement aux chaînes avec l'objet pubnub (expliqué dans la section suivante), vous pouvez également vous abonner aux groupes de chaînes en même temps. Cela signifie que puisque le joueur est abonné à son groupe de canaux d'amis, chaque fois qu'un nouvel ami est ajouté, le chanFriendChat de cet ami est ajouté au groupe de canaux d'amis du joueur et recevra des messages dans l'écouteur d'événements Message chaque fois que l'un de ces canaux publiera un message. Bien que vous ne puissiez pas publier dans un groupe de canaux, vous pouvez simplement publier un message dans n'importe quel canal affilié au groupe de canaux et chaque abonné (ami) recevra ce message.

En utilisant l'[API Channel Groups pour le SDK PubNub Unity](https://www.pubnub.com/docs/sdks/unity/api-reference/channel-groups?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr), vous pouvez ajouter, lister et supprimer des amis/canaux des Channel Groups pour lesquels vous avez l'autorisation de le faire. La fonction Groupes de canaux est également utilisée pour déterminer quand les amis sont également en ligne/hors ligne, ce qui est connu sous le nom de Présence. Ce point sera abordé en détail dans notre [guide Comment ajouter une liste d'amis dans Unity](https://www.pubnub.com/how-to/add-friend-list-to-your-unity-game/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr).

### Chat de guilde/d'alliance/de plan

Dans les jeux comportant des guildes, des alliances ou des clans, un environnement de discussion dédié peut grandement favoriser la coordination et la camaraderie au sein de l'équipe. Ce type de chat de groupe permet la communication entre plusieurs utilisateurs, ce qui favorise la collaboration et le travail d'équipe entre un plus grand nombre de joueurs que vos seuls amis. Un chat Guilde/Alliance/Clan permet aux membres d'un même groupe de planifier des stratégies, de partager des succès, ou simplement de se rapprocher pour former une communauté plus personnelle au sein du jeu.

La mise en place de ce type de chat avec PubNub se fait de la même manière que pour le Friend/Buddy Chat. Vous devez créer des groupes de canaux pour chaque type, vous abonner à ces groupes de canaux et ajouter des amis à ces groupes de canaux lorsque vous y êtes autorisé. Tout message publié sur un canal associé à ces groupes de canaux déclenchera l'écoute de l'événement et vous pourrez afficher le chat de manière appropriée.

Les groupes de canaux sont un excellent moyen de gérer de grands groupes, car le groupe de canaux de chaque joueur peut [gérer 2 000 canaux](https://www.pubnub.com/docs/general/channels/subscribe#channel-groups?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) (dans ce cas, des joueurs), ce qui est plus que suffisant pour les plus grandes guildes des jeux en ligne massifs. Mieux encore, chaque client individuel connecté au réseau PubNub peut avoir 10 groupes de canaux, ce qui signifie que vous pouvez vous abonner à 20 000 canaux si nécessaire.

### Chat Party/Lobby

Les chats de groupe ou de lobby s'adressent à de petits groupes temporaires formés pour une session de jeu ou une mission particulière. Bien que ces styles de discussion aient des objectifs différents, leur mise en œuvre est similaire au modèle de création d'un canal de discussion privé/chuchoté.

Tout d'abord, créez une chaîne de base pour chacun des types de chat de groupe. Lorsque vous vous abonnez à votre tableau de canaux (voir l'étape suivante), vous utilisez le caractère générique subscribe pour écouter toutes les requêtes :

```js
string chanChatParty = “chat.party.” + “*”;
string chanChatLobby= “chat.lobby.” + “*”;
```

Lorsque le lobby ou la partie est formé, un joueur est désigné comme le leader ou le propriétaire du groupe, qu'il ait initié le groupe ou qu'il ait été déterminé en fonction de sa connexion Internet et de sa région. Ces types de joueurs sont appelés chefs de partie ou hôtes. Vous concaténerez alors l'ID utilisateur du joueur hôte avec une chaîne de base, créant ainsi un modèle de canal unique. Tout nouveau joueur invité à rejoindre la partie ou le lobby s'abonnera dynamiquement à ces canaux, ce qui lui permettra de rejoindre le groupe. Le canal peut ensuite être supprimé une fois la fête ou le lobby terminé ou dissous.

Mise en place de l'ensemble
---------------------------

Une fois que vous avez déterminé les types de discussion que vous souhaitez intégrer à votre jeu en fonction du modèle de canal, il est temps d'envoyer et de recevoir des messages en temps réel en publiant et en vous abonnant à ces canaux.

### Publier des messages

Le processus commence par l'élaboration de la charge utile du message. Il peut s'agir d'un simple chat textuel ou de structures de données plus complexes, en fonction des besoins de votre jeu Unity. Une fois que la charge utile est prête, il est temps de publier le message.

L'[API de publication](https://www.pubnub.com/docs/sdks/unity/api-reference/publish-and-subscribe#publish?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) est utilisée pour envoyer un message à tous les abonnés du canal de discussion spécifié. Bien que vous ne puissiez publier que sur un seul canal à la fois, la publication est effectuée de manière asynchrone, de sorte qu'elle ne bloque pas l'exécution du reste de votre code (bien que vous puissiez toujours publier de manière synchrone si vous le souhaitez).

Par exemple, si vous souhaitez envoyer un message de chat à la partie, vous devez effectuer l'appel suivant pour non seulement publier, mais aussi déterminer si l'appel PubNub a été effectué avec succès (et gérer l'échec de l'appel) :

```js
PNResult<PNPublishResult> publishResponse = await pubnub.Publish()
  .Message(“Ready to go!”)
  .Channel(chanChatParty )
  .ExecuteAsync();
PNPublishResult publishResult = publishResponse.Result;
PNStatus status = publishResponse.Status;
Debug.Log("pub timetoken: " + publishResult.Timetoken.ToString());
Debug.Log("pub status code : " + status.StatusCode.ToString());
```

### S'abonner aux messages

Lorsque des messages sont publiés, nous devons nous [abonner](https://www.pubnub.com/docs/sdks/unity/api-reference/publish-and-subscribe#receive-messages?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) aux canaux appropriés pour recevoir tous les messages et événements entrants. Vous pouvez vous abonner à plusieurs canaux de discussion et groupes de canaux en un seul appel :

```js
pubnub.Subscribe<string>()
  .Channels(new List<string>() {
    chanChatAll,
    chanPrivateChat,
    chanChatParty + "*",
    chanChatLobby + "*"               
})
  .ChannelGroups(new List<string>() {
    chanFriendGroupChat + userId,
    chanGuildGroupChat + userId,
    chanAllianceGroupChat + userId
})
.Execute();
```

Le lecteur est maintenant connecté au réseau PubNub et les [auditeurs d'événements](https://www.pubnub.com/docs/sdks/unity#add-event-listeners?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) attendent qu'un événement se produise (dans ce cas, l'arrivée d'un nouveau message) et exécutent ensuite le code associé à cet événement.

Lorsqu'un message arrive, l'écouteur déclenche un rappel, exécutant le code que vous avez écrit pour gérer les messages entrants. Il peut s'agir simplement d'afficher le message dans un salon de discussion, ou de quelque chose de plus complexe, comme le déclenchement d'événements dans le jeu en fonction des messages de discussion.

Fonctionnalités avancées pour rendre le chat dans le jeu attrayant
------------------------------------------------------------------

Vous avez réussi à intégrer le chat dans votre jeu Unity pour permettre aux joueurs d'envoyer et de recevoir des messages en temps réel ! Bien que cela crée déjà un espace pour que les joueurs s'engagent les uns avec les autres, la fonctionnalité mise en œuvre n'est que la partie émergée de l'iceberg - il y a beaucoup de fonctionnalités que vous devriez envisager d'implémenter pour rendre les chats en jeu plus engageants pour vos joueurs.

### Charger l'historique des messages : Persistance des messages

Dans un jeu, les joueurs peuvent avoir besoin de revenir sur des conversations antérieures ou de rattraper des chats manqués. C'est là qu'intervient la [persistance des](https://www.pubnub.com/docs/general/storage?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) messages, qui permet de sauvegarder et de récupérer l'historique des messages de chat. La mise en œuvre de l'API de persistance des messages dans votre jeu Unity vous permet de stocker et de récupérer les messages de chat, les actions de message et les fichiers en cas de besoin :

```js
PNResult<PNFetchHistoryResult> fetchHistoryResponse = await pubnub.FetchHistory()
  .Channels(new string[] { chanPrivateChat })
  .IncludeMeta(true)
  .MaximumPerChannel(25)
  .ExecuteAsync();
```

Nous offrons également la possibilité de contrôler la durée de stockage des messages, ce qui vous permet de gérer le stockage en fonction des besoins et des ressources spécifiques de votre jeu. Pour pouvoir utiliser la persistance des messages, vous devez activer la fonctionnalité dans le [portail d'administration](https://admin.pubnub.com/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) de vos clés. Vous pouvez en savoir plus sur cette fonctionnalité ainsi que sur la façon de l'activer en suivant notre [guide pratique sur la persistance des messages](https://www.pubnub.com/how-to/admin-portal-persistence/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr).

### Notifier les joueurs des messages manqués : Notifications push sur mobile

Avec les jeux mobiles, les joueurs sont souvent en train d'entrer et de sortir de l'application et peuvent manquer des messages cruciaux de leur équipe ou des mises à jour du jeu. C'est là que les [notifications push mobiles](https://www.pubnub.com/docs/general/push/send?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) entrent en jeu. Elles permettent d'informer les joueurs des messages de chat manqués, des mises à jour du jeu ou d'autres notifications importantes, même lorsqu'ils ne sont pas en train de jouer.

Avec l'[API de notifications push mobiles](https://www.pubnub.com/docs/sdks/unity/api-reference/mobile-push?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr), nous fournissons une API unifiée pour envoyer des notifications push aux appareils iOS et Android. Cela simplifie le processus et vous permet d'envoyer un seul appel API pour notifier tous les appareils, quelle que soit la plateforme. Vous pouvez également personnaliser vos notifications push, par exemple en envoyant des notifications personnalisées à des joueurs individuels ou en diffusant un message à tous les joueurs. Cette flexibilité vous permet de communiquer efficacement avec vos joueurs, en les gardant engagés et informés.

Pour pouvoir utiliser les notifications push mobiles avec PubNub, vous devez activer les notifications push mobiles en suivant notre [guide pratique](https://www.pubnub.com/how-to/push-notifications/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) dans le [portail d'administration](https://admin.pubnub.com/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr). Nous avons également des guides plus spécifiques et détaillés pour les Notifications Push Mobiles [FCM](https://www.pubnub.com/how-to/admin-portal-push-notifications-android/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) et [APNs](https://www.pubnub.com/how-to/admin-portal-push-notifications-apns/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr).

### Plus que des mots : Emojis

Les émojis servent de langage universel des émotions dans la communication numérique. Ils permettent aux joueurs d'exprimer leurs sentiments et leurs réactions d'une manière amusante et colorée, rendant le chat plus interactif et engageant.

Avec PubNub, vous pouvez facilement implémenter le support des emojis dans votre jeu Unity en demandant aux joueurs de publier des [signaux](https://www.pubnub.com/docs/general/messages/publish#send-signals?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) plutôt que des messages. Les signaux sont destinés à l'envoi de petits morceaux de données, car ils sont beaucoup plus rapides et moins coûteux que les messages. Comme les emojis sont généralement très petits en termes de taille de données, c'est un moyen parfait d'envoyer rapidement les données.

Vous pouvez utiliser l ['API Signals de PubNub](https://www.pubnub.com/docs/sdks/unity/api-reference/publish-and-subscribe#signal?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) pour publier des emojis dans un chat spécifique. Par exemple, si un joueur souhaite envoyer un emoji de signe de la main au chat global, le code suivant sera exécuté lorsqu'il appuiera sur Envoyer :

```js
Dictionary<string, string> myMessage = new Dictionary<string, string>();
myMessage.Add("emoji", ":wave:");
pubnub.Signal()
  .Message(myMessage)
  .Channel("global")
  .Execute((result, status) => {
    if (status.Error) {
      Debug.Log(status.ErrorData.Information);
    } else {
      Debug.Log(result.Timetoken);
    }
  });
```

Les joueurs destinataires recevront le signal s'ils sont abonnés au canal spécifié. Dans ce cas, comme il s'agit du canal global, tout le monde recevra l'emoji. Pour pouvoir écouter les signaux, abonnez-vous à l'événement listener :

```js
listener.onSignal += OnPnSignal;
private void OnPnSignal(Pubnub pn, PNSignalResult<object> result) {
    // Handle the emoji by looking up the value and displaying the result.
}
```

Vous devez vous assurer que la valeur de l'emoji représente un emoji réel défini dans Unity. Ces emojis peuvent être stockés et récupérés dans le réseau PubNub via [App Context](https://www.pubnub.com/docs/sdks/unity/api-reference/objects?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) (anciennement connu sous le nom d'Objects) afin que tous les emojis auxquels le lecteur a accès puissent être récupérés à partir d'un stockage sans serveur. Pour en savoir plus sur l'implémentation d'App Context dans votre jeu Unity, consultez notre guide pratique.

### Répondre aux messages : Réactions aux messages

Les[réactions aux](https://www.pubnub.com/docs/sdks/unity/api-reference/message-actions?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) messages, telles que les likes, les cœurs, les pouces en l'air, les autocollants ou les réactions personnalisées spécifiques au jeu, offrent aux joueurs un moyen rapide et facile de répondre aux messages de chat. Elles ajoutent non seulement de l'interactivité au chat, mais favorisent également le sens de la communauté en permettant aux joueurs de reconnaître les messages des autres et de s'y intéresser.

Vous pouvez utiliser l'[API Message Actions de](https://www.pubnub.com/docs/sdks/unity/api-reference/message-actions?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) PubNub pour créer des fonctions telles que des réactions et des accusés de réception, ou pour associer des métadonnées personnalisées aux messages. Tout comme les applications de chat telles que Discord ont des réactions et des emojis différents selon les serveurs, il en va de même pour vos différents types de chat. Vous pouvez récupérer les réactions aux messages disponibles pour le canal de discussion spécifié à l'aide de l'appel suivant lors du chargement de la discussion :

```js
pubnub.GetMessageActions()
  .Channel(chanChatLobby)
  .Execute(new PNGetMessageActionsResult((result, status) => 
  {
    //result is of type PNGetMessageActionsResult.
  }));
```

Lorsqu'un joueur est sur le point de répondre à un message par une réaction, vous pouvez le faire en ajoutant une réaction à un message publié :

```js
pubnub.AddMessageAction()
  .Channel(chanChatLobby)
  .MessageTimetoken(5610547826969050)
  .Action(new PNMessageAction { Type = "reaction", Value = "smiley_face" })
  .Execute(new PNAddMessageActionResult((result, status) =>
  {
    //result is of type PNAddMessageActionResult.
  }));
```

PubNub utilise des jetons de temps pour savoir précisément quand un message a été publié dans le réseau. Lorsque vous recevez des messages, le temps écoulé est également inclus dans la charge utile. Vous pouvez alors fournir la valeur appropriée du jeton de temps dans l'argument MessageTimetoken() afin de pouvoir réagir au message.

Pour pouvoir écouter la réaction et avertir le lecteur qui a envoyé le message original, vous devez ajouter un auditeur et gérer la réaction dans la méthode OnPNMessageAction :

```js
listener.onMessageAction += OnPnMessageAction;
…
private void OnPnMessageAction(Pubnub pn, PNMessageActionEventResult result) {
   //Handle Message Reaction
}
```

Comme pour les emojis, vous pouvez utiliser [App Context](https://www.pubnub.com/docs/sdks/unity/api-reference/objects?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) pour récupérer et stocker la façon dont ces réactions sont représentées visuellement dans votre jeu. Pour pouvoir utiliser les réactions aux messages, vous devez vous assurer que la [persistance des messages](https://www.pubnub.com/how-to/admin-portal-persistence/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) est activée pour vos clés dans le [portail d'administration](https://admin.pubnub.com/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr).

### GIFs et autres multimédias

Le partage de fichiers multimédias est une autre fonctionnalité importante qui améliore l'expérience du chat. Qu'il s'agisse de partager des GIF, des captures d'écran de moments drôles ou même des ressources de jeu, le partage de fichiers apporte un autre niveau d'interaction à votre jeu.

La mise en œuvre de ces types de fichiers multimédias utilise l'[API de partage de fichiers PubNub](https://www.pubnub.com/docs/sdks/unity/api-reference/files?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr). Grâce à cette fonctionnalité, les joueurs peuvent charger, télécharger et supprimer les fichiers auxquels ils ont accès. Pour pouvoir envoyer un fichier, vous devez effectuer l'appel suivant :

```js
PNResult<PNFileUploadResult> fileUploadResponse = await pubnub.SendFile()
  .Channel(string chanFriendChatSamantha)
  .File("cat_picture.jpg") //checks the bin folder if no path is provided
  .Message("Look at this photo!")
  .ExecuteAsync();
PNFileUploadResult fileUploadResult = fileUploadResponse.Result;
PNStatus fileUploadStatus = fileUploadResponse.Status;
if (!fileUploadStatus.Error && fileUploadResult != null)
{
  Debug.Log(pubnub.JsonPluggableLibrary.SerializeToJsonString(fileUploadResult));
}
else
{
  // Handle File Upload Error.
}
```

Pour que les abonnés écoutent le fichier, vous devez ajouter l'écouteur d'événement et gérer l'affichage du fichier dans la méthode OnPNFile :

```js
listener.onFile += OnPnFile;
…
private void OnPnFile(Pubnub pn, PNFileEventResult result) {
    //Handle how to display the file received
}
```

Vous pouvez également obtenir, répertorier des informations et supprimer n'importe quel fichier associé à différents canaux de discussion. Vous devrez vous assurer d'activer la fonction de partage de fichiers dans le portail d'administration, ainsi que la persistance des messages. Pour en savoir plus, consultez notre [guide pratique sur l'activation des fichiers](https://www.pubnub.com/how-to/admin-portal-enabling-files/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr).

### Sécurisez vos canaux de discussion : Gestionnaire d'accès

Dans tout environnement de jeu, il est primordial d'assurer la sécurité des canaux de discussion. Qu'il s'agisse de protéger les joueurs des messages indésirables ou de protéger les discussions stratégiques sensibles, le système de chat de votre jeu Unity doit être conçu avec la sécurité à l'esprit.

C'est là que le [gestionnaire d'accès](https://www.pubnub.com/docs/sdks/unity/api-reference/access-manager?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) de PubNub entre en jeu. Il fournit un cadre robuste et flexible pour sécuriser vos canaux de discussion. Avec Access Manager, vous pouvez contrôler qui peut publier ou s'abonner à chacun de vos canaux, ajoutant ainsi une couche supplémentaire de sécurité au système de chat de votre jeu Unity.

Le gestionnaire d'accès vous permet d'accorder des autorisations au niveau de l'utilisateur, du canal ou même au niveau des clés individuelles. Vous pouvez spécifier si un utilisateur peut lire, écrire ou gérer un canal, et ces permissions peuvent être mises à jour dynamiquement en fonction des besoins de votre jeu. Par exemple, dans une discussion privée entre deux joueurs, vous pouvez accorder à ces deux seuls joueurs les permissions de lecture et d'écriture pour leur canal privé. De même, dans une discussion de guilde, vous pouvez accorder des droits de lecture et d'écriture à tous les membres de la guilde, tout en n'accordant des droits de gestion qu'au chef de la guilde.

Access Manager prend également en charge l'authentification par jeton, ce qui vous permet d'authentifier les utilisateurs en toute sécurité et de leur accorder les autorisations appropriées. Ainsi, seuls les joueurs autorisés peuvent accéder aux canaux de discussion de votre jeu, ce qui protège la communauté de votre jeu contre les menaces potentielles.

Vous devez vous assurer que vous avez activé le gestionnaire d'accès dans le [portail d'administration](https://admin.pubnub.com/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) pour pouvoir utiliser cette fonctionnalité. Vous pouvez en savoir plus sur la façon de procéder en suivant cette [page d'assistance](https://support.pubnub.com/hc/en-us/articles/360051974791-How-do-I-enable-add-on-features-for-my-keys-?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) sur l'activation de cette fonctionnalité complémentaire.

Prochaines étapes
-----------------

Dans ce guide pratique, vous avez appris à ajouter un système de chat en temps réel robuste à votre jeu Unity. Nous avons tout abordé, de l'initialisation d'un objet PubNub dans votre environnement à la mise en place d'un modèle de chat représentant les différents types de chat, en passant par l'envoi et la réception de messages. Vous avez même appris à mettre en œuvre des fonctionnalités avancées comme les emojis, les réactions aux messages et le partage de fichiers, ainsi que les aspects importants de tout bon système de chat avec la persistance des messages, les notifications push mobiles et la sécurité des canaux.

Que vous soyez un développeur indépendant travaillant sur votre premier jeu ou un développeur chevronné cherchant à améliorer votre jeu multijoueur, la fonctionnalité en temps réel de PubNub peut servir d'infrastructure pour soutenir votre chat en jeu, afin que vous puissiez vous concentrer sur ce qui compte le plus.

Pour en savoir plus, consultez les ressources suivantes :

-   Lisez notre [documentation Unity](https://www.pubnub.com/docs/sdks/unity?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) pour apprendre tout ce que vous devez savoir sur l'ajout d'un chat en temps réel à votre jeu.
-   Comprenez comment ajouter une [liste d'amis](https://www.pubnub.com/how-to/add-friend-list-to-your-unity-game/?utm_source=devto&utm_medium=syndication&utm_campaign=off_domain&utm_content=fr) grâce à notre guide Unity.
-   Découvrez comment notre [jeu de démonstration Unity](https://github.com/PubNubDevelopers/unity-multiplayer-shooter) utilise des modèles de chat pour gérer les salons de discussion et bien plus encore.
-   Plongez dans le [code source du SDK Unity](https://github.com/pubnub/unity).

N'hésitez pas à contacter l'équipe chargée des relations avec les développeurs à l'[adresse devrel@pubnub.com](mailto:devrel@pubnub.com) si vous avez des questions ou des préoccupations.