Aperçu de la discussion de texte

Roblox offre un messagerie texte entre les joueurs dans des sessions en direct à travers TextChatService .Ce service a sa fonctionnalité standard, mais fournit également un ensemble de méthodes et d'événements pour étendre et personnaliser le chat, tels que la livraison de messages en fonction de exigences personnalisées, l'ajout de permissions spéciales ou de modération à des joueurs spécifiques, et la création de commandes personnalisées pour exécuter des actions spécifiques.

Les sections suivantes résument les classes et les instances principales que vous pouvez utiliser pour personnaliser le système de chat.

Configuration de haut niveau

La classe singleton TextChatService est responsable de la gestion du système de chat global, y compris la filtration, la modération et les permissions des utilisateurs du chat.Utilisez des propriétés comme CreateDefaultTextChannels et CreateDefaultCommands pour activer ou désactiver les canaux et les commandes de chat par défaut.

Configuration d'interface utilisateur par défaut

TextChatService fournit une interface utilisateur par défaut qui peut être personnalisée pour répondre aux besoins de votre expérience.Chacune de ces configurations peut être désactivée pour masquer l'élément d'interface associé et peut être remplacée par des interfaces personnalisées si vous le souhaitez

• ChatWindowConfiguration — Représente l'interface utilisateur du chat par défaut, y compris son apparence et son comportement. Désactivez-la pour masquer la fenêtre de chat.
• ChatInputBarConfiguration — Représente l'interface utilisateur de la barre de saisie de chat par défaut, y compris son apparence et son comportement.
• BubbleChatConfiguration — Représente l'interface utilisateur par défaut de chat à bulles, y compris son apparence et son comportement

Canaux, messages et commandes

• TextChannel — Représente un canal de chat texte qui transmet les messages de chat envoyés par l'utilisateur du client au serveur, qui les affiche ensuite à d'autres utilisateurs en fonction des permissions.Ces instances doivent être parentées à TextChatService pour fonctionner.

  Si TextChatService.CreateDefaultTextChannels est défini sur true, le service crée automatiquement deux canaux de texte, RBXGeneral et RBXSystem.Vous pouvez créer manuellement des instances supplémentaires TextChannel et les parent à TextChatService également.

• TextSource — Représente un utilisateur dans un TextChannel .Ces instances sont directement parentées à la TextChannel lorsque AddUserAsync() est appelée.Les sources de texte contiennent des permissions détaillées d'un utilisateur dans le canal, telles que sa capacité à envoyer des messages.Un seul utilisateur peut être associé à plusieurs sources de texte si elles ont été ajoutées à plusieurs canaux de texte.

• TextChatMessage — Représente un seul message de chat dans un canal de texte, avec des informations de base telles que l'expéditeur du message, le message original, le message filtré et la date d'expiration de création.

• TextChatCommand — Permet aux utilisateurs d'exécuter des actions ou des comportements spécifiques en envoyant des messages qui correspondent à PrimaryAlias ou SecondaryAlias .Ces instances doivent être parentées à TextChatService pour fonctionner.

  Si TextChatService.CreateDefaultCommands est défini sur true, les commandes de chat par défaut seront créées automatiquementVous pouvez créer manuellement des instances supplémentaires TextChatCommand et les parenter à TextChatService, également.

Diagramme du flux de chat

Le chat texte utilise le modèle client-serveur , avec un client d'envoi , le serveur et les clients de réception .

1. Un joueur envoie un message à partir de son appareil local, déclenchant la méthode TextChannel:SendAsync().Cette méthode traite le message et détermine si c'est une commande de chat ou un message de chat régulier.

   • Si le message est une commande de chat, il déclenche l'événement TextChatCommand.Triggered pour exécuter l'action définie. Aucune autre étape n'est requise.

   • Si le message est un message de chat régulier, il déclenche l'événement TextChatService.SendingMessage pour afficher le message au destinataire sur le client d'envoi.En même temps, TextChannel:SendAsync() transmet le message au serveur.

2. Le serveur lance TextChannel.ShouldDeliverCallback pour déterminer si il doit envoyer le message à d'autres joueurs en fonction des permissions et des exigences de filtrage de la communauté Roblox.

3. Si TextChannel.ShouldDeliverCallback détermine que ce message est éligible à être livré à d'autres joueurs, le serveur applique tous les filtres et tire TextChannel.OnIncomingMessage deux fois :

   1. La première fois est sur le client d'envoi et indique que le serveur traite le message via l'événement TextChatService.MessageReceived.Cet événement remplace le message local sur le client expéditeur par le message traité du serveur.Le message est identique si l'original n'a pas nécessité de filtrage.

   2. La deuxième fois est sur les clients récepteurs, ce qui déclenche l'événement TextChatService.MessageReceived pour afficher le message à d'autres joueurs.

Crochets et rappels de chat textuel

L'API TextChatService encourage une séparation claire sur l'apparence et la livraison des messages de chat.Plusieurs instances du système de chat texte fournissent des crochets et des rappels pour former dans des endroits centralisés et clairs.

| Appel de rappel | Valeur de retour | | ----------------------------------------- | ----------------------------------- | | | boolean | | | | | | | | | | | | | | |

Livrer conditionnellement des messages

Le rappel TextChannel.ShouldDeliverCallback doit être défini uniquement sur le serveur.Le rappel est déclenché pour chaque TextSource enfant du canal de texte lorsqu'un message est envoyé pour déterminer si le message doit être livré.Ce rappel peut être utilisé pour implémenter une logique de livraison de message personnalisée qui peut dépendre d'un contexte de jeu supplémentaire, tel que :

• Chat basé sur la proximité où les utilisateurs ne peuvent envoyer des messages qu'aux personnes proches d'eux.
• Empêcher les utilisateurs avec certains attributs d'envoyer des messages à d'autres.

Personnaliser l'affichage du message

L'interface utilisateur par défaut TextChatService fait appel à du texte enrichi pour formater et personnaliser la façon dont les messages sont affichés.Vous pouvez utiliser les rappels suivants pour formater les messages avant qu'ils ne soient affichés aux utilisateurs, par exemple pour ajouter des couleurs ou balises de chat aux noms d'utilisateur ou pour formater le contenu du message.

Les appels suivants sont effectués à chaque TextChatMessage qui est sur le point d'être affiché, ce qui vous permet de personnaliser l'apparence de la fenêtre de chat en fonction du contenu TextChannel, TextSource ou TextChatMessage.Lorsqu'un client envoie un message, ces rappels sont appelés une fois que le message est envoyé au serveur et la valeur TextChatMessage.Status sera Enum.TextChatMessageStatus.Sending.Une fois le message reçu par le serveur et livré à d'autres utilisateurs, le client expéditeur reçoit le message à nouveau avec une valeur mise à jour de Enum.TextChatMessageStatus .

• TextChatService.OnIncomingMessage — Ce rappel doit être défini uniquement sur le client.Le rappel est déclenché lorsqu'un message est reçu, du serveur ou si le client local vient d'envoyer un message.Le rappel est appelé à chaque TextChatMessage reçu de toutes les TextChannel instances et est le premier à traiter le message avant qu'il ne soit affiché à l'utilisateur.
• TextChannel.OnIncomingMessage — Ce rappel doit être défini uniquement sur le client.Le rappel est déclenché lorsque le serveur reçoit un message.Le rappel est appelé à chaque TextChatMessage reçu de la part du TextChannel.Les instances par défaut TextChannel créées à partir de TextChatService.CreateDefaultTextChannels ont ce rappel défini et peuvent être remplacées.
• TextChatService.OnBubbleAdded — Ce rappel doit être défini uniquement sur le client.Utilisez-le pour personnaliser l'apparence des bulles de chat indépendamment de l'apparence du message dans l'interface de la fenêtre de discussion.
• TextChatService.OnChatWindowAdded — Ce rappel doit être défini uniquement sur le client.Utilisez-le pour personnaliser l'apparence des messages de chat dans l'interface utilisateur de la fenêtre de chat indépendamment de l'apparence du message dans les bulles de chat.

Migrer du chat hérité

Cette section vous aide à migrer du système de chat hérité en fournissant des méthodes alternatives pour implémenter des fonctionnalités et des comportements de chat communs en utilisant .

1. Dans la fenêtre Explorateur, sélectionnez TextChatService.

2. Dans la fenêtre Propriétés, trouvez le menu déroulant ChatVersion et sélectionnez TextChatService.

   

Fonctionnalités de base

Bien que les deux systèmes partagent les mêmes fonctionnalités de chat de base, les implémentations TextChatService sont en général plus durables et plus faciles à itérer.

Filtrage des messages

TextChatService filtre automatiquement les messages de chat en fonction de l'information sur le compte de chaque joueur, vous n'avez donc pas besoin de mettre en œuvre manuellement un filtrage de texte pour tous les types de messages de chat.

Discussion de fenêtre et de bulle

Les comportements et les options de personnalisation du fenêtre de discussion et du chat bulle sont identiques à ceux du système de chat hérité.Comme le système de chat hérité ne permet que la personnalisation à l'aide de modules de chat ou du conteneur Players, le service fournit des classes dédiées ( ChatWindowConfiguration et BubbleChatConfiguration ) pour gérer toutes les propriétés de fenêtre et de bulles de chat.De plus, vous pouvez facilement ajuster et prévisualiser l'apparence et le comportement de votre chat bulle en utilisant les paramètres de Studio au lieu d'avoir à les programmer tous.

Migrer les données supplémentaires du haut-parleur

Le système de chat Lua hérité a permis aux développeurs d'utiliser SetExtraData sur la classe Speaker.Ces données ont été utilisées pour formater la couleur du nom, la couleur du chat ou pour appliquer des balises de nom pour un orateur donné.

Système de chat hérité SetExtraData
-- Exemple de définition de données supplémentaires sur un orateur dans le système de chat hérité
ChatService.SpeakerAdded:Connect(function(playerName)
	local speaker = ChatService:GetSpeaker(playerName)
	speaker:SetExtraData("NameColor", Color3.fromRGB(255, 255, 55))
	speaker:SetExtraData("ChatColor", Color3.fromRGB(212, 175, 55))
	speaker:SetExtraData("Tags", {{TagText = "YourTagName", TagColor = Color3.fromRGB(0, 255, 0)}, {TagText = "OtherTagName", TagColor = Color3.fromRGB(255, 0, 0)}})
end)

TextChatService n'a pas d'équivalent direct à SetExtraData.Au lieu de cela, utilisez rappels tels que OnWindowAdded pour personnaliser l'apparence des messages en utilisant du texte enrichi en fonction du TextSource du message

Ce qui suit est un exemple d'émulation des « données supplémentaires » du chat Lua hérité en accédant aux attributs sur Player objets :

TextChatService Définir les attributs
local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	player:SetAttribute("NameColor", Color3.fromRGB(255, 255, 55))
	player:SetAttribute("ChatColor", Color3.fromRGB(212, 175, 55))
	player:SetAttribute("isYourTag", true)
	player:SetAttribute("isOtherTag", true)
end)

Vous pouvez ensuite utiliser le rappel OnChatWindowAdded pour personnaliser l'apparence de la fenêtre de chat en fonction des attributs définis sur le joueur :

TextChatService sur ChatWindowAdded
local TextChatService = game:GetService("TextChatService")
local Players = game:GetService("Players")

TextChatService.OnChatWindowAdded = function(textChatMessage)
	local textSource = textChatMessage.TextSource
	if textSource then
		local player = Players:GetPlayerByUserId(textSource.UserId)
		if player then
			local overrideProperties = TextChatService.ChatWindowConfiguration:DeriveNewMessageProperties()
			overrideProperties.PrefixText = textChatMessage.PrefixText
			overrideProperties.Text = textChatMessage.Text

			local nameColor = player:GetAttribute("NameColor")
			if nameColor and typeof(nameColor) == "Color3" then
				overrideProperties.PrefixTextProperties.TextColor3 = nameColor
			end

			local chatColor = player:GetAttribute("ChatColor")
			if chatColor and typeof(chatColor) == "Color3" then
				overrideProperties.TextColor3 = chatColor
			end

			local isYourTag = player:GetAttribute("isYourTag")
			if isYourTag == true then
				overrideProperties.PrefixText = `<font color='rgb(0, 255, 0)'>[YourTag]</font> {overrideProperties.PrefixText}`
			end

			local isOtherTag = player:GetAttribute("isOtherTag")
			if isOtherTag == true then
				overrideProperties.PrefixText = `<font color='rgb(255, 0, 0)'>[OtherTag]</font> {overrideProperties.PrefixText}`
			end

			return overrideProperties
		end
	end

	return nil
end