Système de chat hérité

Hiérarchie

Le système de chat hérité utilise le modèle client-serveur .Les composants du module de chat côté serveur ChatChannel et ChatSpeaker sont gérés par le ChatService sur le serveur, tandis que le client est responsable de l'entrée et de l'affichage des messages.La communication entre le serveur et les clients est gérée automatiquement en utilisant RemoteEvents .

Le service moteur Chat lui-même est l'unité de stockage essentielle pour le système de chat : lorsqu'un lieu Roblox se charge (que ce soit dans le client ou dans Studio lors de l'exécution ou du jeu), les composants suivants sont automatiquement chargés dans le service Chat si Chat.LoadDefaultChat est vrai.

• Modules de chat — Cette Folder est une collection de modules qui sont requis par le ChatServiceRunner .Tout le contenu de ce dossier est requis par le script et est utilisé pour créer un comportement personnalisé sur le serveur.
• ClientChatModules — Ce dossier contient divers ModuleScripts requis par le ChatScript .

  • CommandModules — Contient des modules utilisés pour implémenter les commandes de chat côté client.
  • MessageCreatorModules — Contient des modules utilisés pour gérer et formater les messages.
  • États de chat — Contient des constantes partagées par le serveur et le client.
  • Paramètres de chat — Stocke divers paramètres pour configurer différents aspects de la fenêtre de chat.
• ChatLocalization — Structure de données qui stocke les traductions de texte.
• ChatServiceRunner — Ce Script exécute la composante du serveur du chat.En général, cela n'a pas besoin d'être modifié pour créer un comportement et une fonctionnalité de chat personnalisés.
• BubbleChat — Affiche les messages de chat de l'utilisateur au-dessus de leur avatar dans le jeu (si activé).
• ChatScript — Ce LocalScript exécute la composante client du chat.Comme ChatServiceRunner, cela ne devrait pas avoir besoin d'être modifié pour personnaliser le chat.Lorsque le jeu s'exécute, cela se fait automatiquement cloner à la StarterPlayerScripts .

Modifier le système de chat

Pour modifier ou personnaliser le système de chat hérité, vous devez d'abord faire une copie de la hiérarchie ci-dessus.

1. Dans la fenêtre Explorateur, localisez TextChatService .Ensuite, dans la fenêtre Propriétés, définissez la propriété ChatVersion à LegacyChatService .

   

2. Exécutez l'expérience en utilisant le bouton Jouer (F5).

3. Sélectionnez et copiez ( CtrlC ou ⌘C ) les objets qui sont ajoutés à Chat .

   

4. Arrêtez l'expérience en utilisant le bouton Arrêter ( ShiftF5 ).

5. Sélectionnez Chat et collez dans ( CtrlShiftV ou ⌘ShiftV ) les objets copiés (ils doivent être parentés à Chat comme ils l'étaient pendant que l'expérience était en cours d'exécution).

6. Assurez-vous que Chat.LoadDefaultChat est activé.

Workflow de chat

Avant de créer des modules pour personnaliser le chat, il est important de comprendre le flux de travail qu'un message de chat traverse.En plus d'envoyer des messages texte, il existe diverses commandes intégrées au système de chat, de sorte que chaque message doit être vérifié pour voir s'il doit être interprété comme une commande ou simplement comme un message texte.Même les messages texte peuvent être modifiés et filtrés dans le processus.

Après que l'utilisateur ait le focus dans l'entrée de chat et ait entré un caractère, plusieurs vérifications sont effectuées immédiatement sur le client.Si le personnage est Esc, la boîte de saisie se ferme et aucune action n'est entreprise.Si le personnage est autre que Enter, le texte est transmis à travers les processeurs de commande en cours de traitement.Ceux-ci sont utilisés pour évaluer le texte pour voir si une action doit être prise.Par exemple, lorsqu'un utilisateur commence à chuchoter avec la commande /whisper, dès que le nom d'utilisateur a été entré après la commande, la boîte de saisie change pour indiquer que l'utilisateur entre maintenant dans un chat (chat privé)de chuchotement.

Du côté client du chat, il y a deux types de processeurs : en cours et terminé.Le premier évalue après que chaque caractère ait été saisi, tandis que le dernier ne se évalue que lorsque l'utilisateur a terminé de saisir et a atteint Enter .

Lorsque l'utilisateur a terminé de taper et a appuyé sur Enter le texte, son entrée est envoyée à travers plusieurs autres processeurs de commandes.Si une commande en cours a créé un état de chat personnalisé, le chat vérifie l'état pour voir si une commande finale doit être exécutée et si le message doit se poursuivre.Si le message est autorisé à se poursuivre, le texte est envoyé à travers un autre ensemble de processeurs appelé terminé processeurs.Si l'un de ces processeurs renvoie vrai, le message cesse d'être envoyé.Sinon, le message est envoyé au serveur.

Une fois le message arrivé sur le serveur, il passe à travers un autre ensemble de processeurs de commande.Tout comme les processeurs terminés sur le client, si l'un de ces processeurs renvoie vrai, le message cesse d'être exécuté.Sinon, le message est transmis à travers une série de filtres (y compris le filtre de chat par défaut de Roblox).Une fois tout cela fait, le message est envoyé à tous les canaux et aux orateurs appropriés.

Modules serveur

Les modules mis en modules de chat peuvent être utilisés à diverses fins.Ces modules peuvent être utilisés pour gérer les canaux de chat et les orateurs, ajouter des fonctions de filtre et de commande, exécuter des chatbots ou tout autre chose qui doit être traitée sur le serveur.Pour interagir avec le système de chat, chaque module est passé à un objet ChatService.

Lorsque le ChatServiceRunner démarre, il nécessite chaque module à l'intérieur de ChatModules .Il s'attend à ce que chaque module retourne une fonction comme il appelle ensuite chacun des modules à son tour, en passant son objet ChatService à chaque fonction.Indépendamment de ce que le module est destiné à faire (exécuter un bot, ajouter une fonction de filtre, etc), il doit suivre cette forme pour fonctionner.

Framework de module d'échantillon
local function Run(ChatService)
	-- Le code va ici
end

return Run

Ajouter des canaux

Une des choses les plus simples qu'un module de chat peut faire est de gérer les canaux .Les objets de canal peuvent être créés avec la méthode AddChannel() de ChatService.Notez que l'objet de canal ne doit être utilisé que lorsque vous appelez des membres de ce canal (tels que ses propriétés et ses fonctions).Lorsque vous faites référence aux canaux dans le contexte de ChatService ou de ChatSpeakers, le nom du chat (chat privé)est utilisé pour le référencer.

local function Run(ChatService)
	local myChannel = ChatService:AddChannel("MyChannel")
end

return Run

Configuration de canal basique

Les canaux ont plusieurs propriétés qui peuvent être utilisées pour les modifier légèrement.Par exemple, ce module crée un canal et définit le message d'accueil et fait en sorte que les utilisateurs rejoignent automatiquement le canal lorsqu'ils entrent dans l'expérience.

local function Run(ChatService)
	local myChannel = ChatService:AddChannel("MyChannel")

-- Définir le message qui s'affiche lorsqu'un utilisateur rejoint le chat (chat privé)
	myChannel.WelcomeMessage = "Welcome to my channel!"
	-- Fait que les joueurs rejoignent automatiquement le canal lorsqu'ils entrent dans le jeu
	myChannel.AutoJoin = true
end

return Run

Événements de canal

Les canaux ont plusieurs événements auxquels vous pouvez vous abonner.Ces événements se déclenchent lorsqu'un message de chat est publié sur le chat (chat privé), lorsqu'un orateur de chat quitte ou rejoint, ou lorsqu'un orateur est muet ou démuet.Par exemple, ce module créera un canal avec le nom MyChannel .Chaque fois qu'un orateur rejoint ou quitte le chat (chat privé), un message système sera envoyé à tous les orateurs du canal pour les informer de l'événement.

local function Run(ChatService)
	local myChannel = ChatService:AddChannel("MyChannel")

	local function onSpeakerJoined(speakerName)
		myChannel:SendSystemMessage(speakerName .. " has joined the channel.")
	end

	local function onSpeakerLeft(speakerName)
		myChannel:SendSystemMessage(speakerName .. " has left the channel.")
	end

	myChannel.SpeakerJoined:Connect(onSpeakerJoined)
	myChannel.SpeakerLeft:Connect(onSpeakerLeft)
end

return Run

Fonctions de commande

Une autre chose puissante que ChatModules peut faire sont les commandes de chat . .Lorsqu'un message est envoyé au serveur, le chat enverra le message à travers chaque fonction de commande qui a été enregistrée au service de chat et au chat (chat privé)pertinent.Ces fonctions sont envoyées au enceinte, au message et au canal auquel le message est envoyé.La fonction peut prendre toute action dont elle a besoin, puis retourner vrai ou faux.Si la fonction renvoie true, le message cesse d'être traité par le système de chat.Il ne sera envoyé à aucune autre fonction de commande et ne sera pas affiché dans la fenêtre de chat.Si la fonction renvoie false, le message se poursuit à travers toutes les autres fonctions de commande.Si aucune des fonctions de commande ne renvoie de vrai, le message sera ensuite envoyé à travers des filtres et sera ensuite affiché.

Les fonctions de commande sont souvent utilisées pour implémenter commandes d'administration, qui sont des commandes de texte que certains utilisateurs peuvent utiliser pour manipuler l'état de l'expérience via un texte spécifique dit dans le chat.

Dans cet exemple, un ChatModule est utilisé pour créer un Part si un utilisateur tape /part dans le chat.Notez que cette fonction renvoie true si une partie a été créée ce qui arrêtera le message de se poursuivre et aucun message ne sera affiché.Si une partie n'est pas créée, cette fonction doit retourner false afin que le message puisse continuer à fonctionner à travers le système.

local Workspace = game:GetService("Workspace")

local function Run(ChatService)
	local function createPart(speakerName, message, channelName)
		if string.sub(message, 1, 5) == "/part" then
			local newPart = Instance.new("Part")
			newPart.Parent = Workspace
			return true
		end
		return false
	end

	ChatService:RegisterProcessCommandsFunction("createPart", createPart)
end

return Run

Les deux canaux de chat et service de chat eux-mêmes peuvent avoir des commandes de chat.Les processeurs de commande de service de chat s'exécuteront sur chaque message envoyé au serveur, tandis que les commandes de canal s'exécuteront seulement si le message a été envoyé au canal auquel la commande est enregistrée.

Fonctions de filtrage

Les messages qui ne sont pas arrêtés par une fonction de commande seront transmis à travers toutes les fonctions de filtre enregistrées dans le service de chat et les canaux pertinents.Chaque fonction de filtre est transmise au enceinte, à l'objet de message et au nom du canal.Toute modification apportée à l'objet de message persistera et chaque fonction de filtre suivante verra le message mis à jour.Notez que les fonctions de filtre n'ont pas besoin de retourner une valeur.

Dans cet exemple, une fonction de filtre simple est enregistrée pour faire apparaître chaque message en minuscules.

local function Run(ChatService)
	local function makeLowercase(sender, messageObject, channelName)
		messageObject.Message = string.lower(messageObject.Message)
	end

	ChatService:RegisterFilterMessageFunction("makeLowercase", makeLowercase)
end

return Run

Modules de client

Les modules mis en ClientChatModules peuvent être utilisés pour créer un comportement personnalisé pour les clients.Ces modules sont divisés en deux dossiers différents : modules de commande et modules créateurs de messages.

Modules de commande

Modules de commande fonctionnent de manière très similaire aux modules sur le serveur qui enregistrent fonctions de commande.Ces modules définissent des fonctions qui seront déclenchées après que l'utilisateur ait saisi du texte.Ce texte peut être lu et la commande peut soit laisser le message passer au serveur, soit arrêter la progression du message.Les commandes qui sont évaluées à la fin du message sont étiquetées avec COMPLETED_MESSAGE_PROCESSOR alors que les commandes qui sont évaluées après chaque caractère sont étiquetées avec IN_PROGRESS_MESSAGE_PROCESSOR .

Dans les deux types de commandes, le module doit retourner un dictionnaire qui indique le type de processeur que la commande doit utiliser et la fonction à exécuter lorsque le processeur est appelé.Par exemple, un processeur de message terminé devrait prendre la forme :

local util = require(script.Parent:WaitForChild("Util"))

function ProcessMessage(message, ChatWindow, ChatSettings)

end

return {
	[util.KEY_COMMAND_PROCESSOR_TYPE] = util.COMPLETED_MESSAGE_PROCESSOR,
	[util.KEY_PROCESSOR_FUNCTION] = ProcessMessage
}

Notez que l'enumérité est définie dans le dossier Util à l'intérieur du dossier CommandModules .

Commandes de message terminées

Les commandes de message terminées sont évaluées lorsque l'utilisateur a terminé de taper et a frappé Enter.La fonction du processeur est transmise à l'objet ChatMessage du client, à la fenêtre ChatWindow du client et à la table ChatSettings.Si la fonction renvoie true, le message cesse d'être traité et ne sera pas envoyé au serveur.Sinon, il sera envoyé à travers tous les autres processeurs et finalement au serveur s'il aucun des autres processeurs ne l'arrête.

Par exemple, le processeur suivant supprime le message le plus ancien dans le canal actuel si l'utilisateur entre la commande /last.

local util = require(script.Parent:WaitForChild("Util"))

function ProcessMessage(message, ChatWindow, ChatSettings)
	if string.sub(message, 1, 5) == "/last" then
		local currentChannel = ChatWindow:GetCurrentChannel()
		if currentChannel then
			currentChannel:RemoveLastMessageFromChannel()
		end
		return true
	end
	return false
end

return {
	[util.KEY_COMMAND_PROCESSOR_TYPE] = util.COMPLETED_MESSAGE_PROCESSOR,
	[util.KEY_PROCESSOR_FUNCTION] = ProcessMessage
}

Commandes en cours de traitement

Les commandes en cours d'exécution sont évaluées à chaque fois qu'un utilisateur saisit un caractère dans l'entrée de chat. Par exemple, le code suivant joue un claquement après chaque pression de touche pour faire croire que l'utilisateur tape sur une machine à écrire :

local util = require(script.Parent:WaitForChild("Util"))
local keyEffect = Instance.new("Sound")
keyEffect.SoundId = "rbxassetid://12221976"
keyEffect.Parent = script

function ProcessMessage(message, ChatWindow, ChatBar, ChatSettings)
	keyEffect:Play()
end

return {
	[util.KEY_COMMAND_PROCESSOR_TYPE] = util.IN_PROGRESS_MESSAGE_PROCESSOR,
	[util.KEY_PROCESSOR_FUNCTION] = ProcessMessage
}

Les commandes en cours d'exécution sont souvent utilisées pour créer un état personnalisé pour le chat pour envoyer des messages à des utilisateurs spécifiques au lieu du chat (chat privé)actuel.Par exemple, les systèmes de chat Whisper et d'équipe vérifient si l'utilisateur a tapé /whisper ou /team respectivement et envoient le message terminé à seulement les utilisateurs appropriés.

Un état personnalisé est attendu pour être une table avec les fonctions suivantes :

• TextUpdated() — Appelé lorsque le texte dans la boîte de saisie change.
• GetMessage() — Appelé après que l'utilisateur ait terminé l'entrée du message et ait frappé Enter. Cette fonction est attendue pour retourner une chaîne.
• ProcessCompletedMessage() — Appelé lorsque le message est traité.Un processeur d'état personnalisé sera toujours tiré avant les processeurs de message terminés.Comme d'autres processeurs, cette fonction doit retourner vrai si le message doit cesser d'être envoyé, sinon elle doit retourner faux.
• Destroy() — Appelé après l'envoi du message. Doit être utilisé pour nettoyer tout ce qui a été configuré par l'État personnalisé.

Pour utiliser un état personnalisé, la fonction ProcessMessage() du module de commande doit retourner l'état.Un état personnalisé de base prendrait la forme suivante :

local util = require(script.Parent:WaitForChild("Util"))

local oneLineState = {}
oneLineState.__index = oneLineState

function oneLineState:TextUpdated()
	local text = self.TextBox.Text
	local length = string.len(text)
	if length > 20 then
		local chopLength = length - 20
		local addToPrefix = string.sub(text, 1, chopLength)
		self.Prefix = self.Prefix .. addToPrefix
		self.TextBox.Text = string.sub(text, chopLength + 1)
	end
end

function oneLineState:GetMessage()
	local fullString = self.Prefix .. self.TextBox.Text
	return fullString
end

function oneLineState:ProcessCompletedMessage()
	return false
end

function oneLineState:Destroy()
	self.Destroyed = true
end

function oneLineState.new(ChatWindow, ChatBar, ChatSettings)
	local obj = {}
	setmetatable(obj, oneLineState)

	obj.Destroyed = false
	obj.ChatWindow = ChatWindow
	obj.ChatBar = ChatBar
	obj.ChatSettings = ChatSettings
	obj.TextBox = ChatBar:GetTextBox()
	obj.MessageModeLabel = ChatBar:GetMessageModeTextLabel()

	obj.Prefix = ""

	return obj
end

local function ProcessMessage(message, ChatWindow, ChatBar, ChatSettings)
	return oneLineState.new(ChatWindow, ChatBar, ChatSettings)
end

return {
	[util.KEY_COMMAND_PROCESSOR_TYPE] = util.IN_PROGRESS_MESSAGE_PROCESSOR,
	[util.KEY_PROCESSOR_FUNCTION] = ProcessMessage
}

L'un des principaux avantages de l'utilisation d'un état personnalisé est que le module peut modifier la barre de chat et son texte contenant tout en même temps que l'utilisateur tape à la fois en termes de fonction et d'apparence, puis la réinitialiser facilement ensuite (une fois qu'un message est envoyé, l'état personnalisé est automatiquement supprimé et tout est réinitialisé à la normale).Par exemple, ce code configure un état personnalisé qui ne permet de montrer que 20 caractères dans le champ de texte à la fois.Si l'utilisateur continue d'écrire, les caractères au début de la chaîne sont temporairement supprimés.Lorsque l'utilisateur envoie le message, tous les caractères supprimés sont ajoutés de nouveau au message.

local util = require(script.Parent:WaitForChild("Util"))

local oneLineState = {}
oneLineState.__index = oneLineState

function oneLineState:TextUpdated()
	local text = self.TextBox.Text
	local length = string.len(text)
	if length > 20 then
		local chopLength = length - 20
		local addToPrefix = string.sub(text, 1, chopLength)
		self.Prefix = self.Prefix .. addToPrefix
		self.TextBox.Text = string.sub(text, chopLength + 1)
	end
end

function oneLineState:GetMessage()
	local fullString = self.Prefix .. self.TextBox.Text
	return fullString
end

function oneLineState:ProcessCompletedMessage()
	return false
end

function oneLineState:Destroy()
	self.Destroyed = true
end

function oneLineState.new(ChatWindow, ChatBar, ChatSettings)
	local obj = {}
	setmetatable(obj, oneLineState)

	obj.Destroyed = false
	obj.ChatWindow = ChatWindow
	obj.ChatBar = ChatBar
	obj.ChatSettings = ChatSettings
	obj.TextBox = ChatBar:GetTextBox()
	obj.MessageModeLabel = ChatBar:GetMessageModeTextLabel()

	obj.Prefix = ""

	return obj
end

local function ProcessMessage(message, ChatWindow, ChatBar, ChatSettings)
	return oneLineState.new(ChatWindow, ChatBar, ChatSettings)
end

return {
	[util.KEY_COMMAND_PROCESSOR_TYPE] = util.IN_PROGRESS_MESSAGE_PROCESSOR,
	[util.KEY_PROCESSOR_FUNCTION] = ProcessMessage
}

Comme mentionné précédemment, une fois qu'un message a été envoyé, tout état personnalisé est supprimé et le chat est restauré à la normale.Si il est nécessaire de réinitialiser un état personnalisé avant d'envoyer le message, l'état peut être réinitialisé avec ChatBar:ResetCustomState() .Notez que cela supprimera également le focus de la boîte de texte de la barre de chat.

Modules créateurs de messages

Un autre type de module pouvant être utilisé dans le composant client est un module créateur de messages .Ce type de module est utilisé pour créer les éléments de l'interface graphique dans la fenêtre de chat pour afficher le message.Chaque type de créateur de message définit un nouveau taperde message, de sorte que différents messages peuvent être créés avec différents formats.De plus, des éléments GUI peuvent être ajoutés à l'affichage des messages de cette façon qui permet d'ajouter des images, des boutons et plus encore.

Ces modules nécessitent une configuration dans plusieurs endroits différents.Pour chaque taperde message, il doit y avoir un ModuleScript à l'intérieur de MessageCreatorModules .De plus, le Chat Становья doit être modifié pour inclure le nouveau taperde message.Enfin, les modules ne sont utilisés que si une composante du serveur de chat crée un nouveau message avec le taperde message donné.

L'exemple suivant traite la création d'un bot qui dit l'heure toutes les 5 secondes, et le message envoyé obtient un arrière-plan rouge.

Pour commencer, le Chat Становления doit ajouter un champ pour le nouveau type de message.

-- ChatConstants
local module = {}

--[[ types de message ]]
module.MessageTypeDefault = "Message"
module.MessageTypeSystem = "System"
module.MessageTypeMeCommand = "MeCommand"
module.MessageTypeWelcome = "Welcome"
module.MessageTypeSetCore = "SetCore"
module.MessageTypeWhisper = "Whisper"
module.MessageTypeTime = "Time"

module.MajorVersion = 0
module.MinorVersion = 2

return module

Le bot lui-même est créé dans un nouveau ChatModule sur le serveur.Notez qu'une fonction de filtre est utilisée pour ajouter le nouveau type de message aux messages que le bot envoie.

-- Nouveau module de script à placer dans les modules de chat
local Chat = game:GetService("Chat")
local ReplicatedModules = Chat:WaitForChild("ClientChatModules")
local ChatConstants = require(ReplicatedModules:WaitForChild("ChatConstants"))

local function Run(ChatService)
	local timeBot = ChatService:AddSpeaker("TimeBot")
	timeBot:JoinChannel("All")

	local function addMessageType(speaker, messageObject, channelName)
		if speaker == "TimeBot" then
			messageObject.MessageType = ChatConstants.MessageTypeTime
		end
	end

	ChatService:RegisterFilterMessageFunction("TimeBotFilter", addMessageType)

	task.spawn(function()
		while task.wait(5) do
			timeBot:SayMessage("The current time is: " .. os.time(), "All", {})
		end
	end)
end

return Run

Enfin, un module de créateur de message doit être fait.Ce module doit retourner un dictionnaire avec deux éléments : le type du message, indexé avec KEY_MESSAGE_TYPE , et la fonction à appeler lors de la création des éléments de l'interface utilisateur du message, indexés avec KEY_CREATOR_FUNCTION .

La fonction stockée par KEY_CREATOR_FUNCTION doit retourner un dictionnaire avec plusieurs composants.Tout d'abord, il doit inclure un Frame et TextLabel qui sera affiché dans la fenêtre de chat.Ces derniers peuvent être créés avec la fonction util:CreateBaseMessage().Le dictionnaire doit également inclure une fonction à exécuter si le texte du message est mis à jour.Lorsque les messages apparaissent pour la première fois dans le client, ils ont un texte de remplacement vide pendant que le message est traité et filtré, de sorte que les objets de message comme celui-ci doivent gérer ce qui se produit lorsqu'ils reçoivent un appel de mise à jour.Ensuite, le dictionnaire doit inclure une fonction pour déterminer la hauteur du cadre.Cette fonction appelle souvent la fonction util:GetMessageHeight().Enfin, le dictionnaire doit inclure plusieurs fonctions qui définissent comment les éléments devraient disparaître lorsque la fenêtre disparaît (la fonction d'utilité pour cela est util:CreateFadeFunctions() ).

-- nouveau ModuleScript à inclure dans MessageCreatorModules
local messageCreatorModules = script.Parent
local util = require(messageCreatorModules:WaitForChild("Util"))
local clientChatModules = messageCreatorModules.Parent

local ChatSettings = require(clientChatModules:WaitForChild("ChatSettings"))
local ChatConstants = require(clientChatModules:WaitForChild("ChatConstants"))


local function CreateMessageLabel(messageData, channelName)
	-- Créer les objets GUI pour le cadre et le TextLabel pour contenir le message
	local BaseFrame, BaseMessage = util:CreateBaseMessage("", ChatSettings.DefaultFont, ChatSettings.ChatWindowTextSize, ChatSettings.DefaultMessageColor)

	-- Changer le fond du cadre en rouge
	BaseFrame.BackgroundColor3 = Color3.new(1,0,0)
	BaseFrame.BackgroundTransparency = 0

	-- Gérer le texte du message de mise à jour du paramètre
	local function UpdateTextFunction(messageObject)
        if messageObject.IsFiltered then
		   BaseMessage.Text = messageObject.Message
        end
	end
	UpdateTextFunction(messageData)

	-- Utilisez la fonction util pour déterminer la hauteur du cadre
	local function GetHeightFunction(xSize)
		return util:GetMessageHeight(BaseMessage, BaseFrame, xSize)
	end

	-- Créer des fonctions de disparition qui sont appelées lorsque la fenêtre de chat disparaît
	local FadeParameters = {}
	FadeParameters[BaseMessage] = {
		TextTransparency = {FadedIn = 0, FadedOut = 1},
		TextStrokeTransparency = {FadedIn = 0.75, FadedOut = 1}
	}
	local FadeInFunction, FadeOutFunction, UpdateAnimFunction = util:CreateFadeFunctions(FadeParameters)

	-- Retourner le dictionnaire qui définit l'étiquette de message
	return {
		[util.KEY_BASE_FRAME] = BaseFrame,
		[util.KEY_BASE_MESSAGE] = BaseMessage,
		[util.KEY_UPDATE_TEXT_FUNC] = UpdateTextFunction,
		[util.KEY_GET_HEIGHT] = GetHeightFunction,
		[util.KEY_FADE_IN] = FadeInFunction,
		[util.KEY_FADE_OUT] = FadeOutFunction,
		[util.KEY_UPDATE_ANIMATION] = UpdateAnimFunction
	}
end

return {
	[util.KEY_MESSAGE_TYPE] = ChatConstants.MessageTypeTime,
	[util.KEY_CREATOR_FUNCTION] = CreateMessageLabel
}