Sistema di chat legacy

Giarchia

Il sistema di chat legacy utilizza il modello client-server .I componenti del modulo di chat lato server ChatChannel e ChatSpeaker sono gestiti dal ChatService sul Server, mentre il client è responsabile dell'input e della visualizzazione dei messaggi.La comunicazione tra il server e i client è gestita automaticamente utilizzando RemoteEvents .

Il servizio motore Chat stesso è l'unità di storage essenziale per il sistema di chat: quando un luogo Roblox si carica (sia nel client o in Studio durante l'esecuzione o il gioco), i seguenti componenti vengono caricati automaticamente nel servizio Chat se Chat.LoadDefaultChat è vero.

• Moduli di chat — Questo Folder è una raccolta di moduli richiesti dal ChatServiceRunner .Tutto il contenuto di questa cartella è richiesto dallo script e viene utilizzato per creare un comportamento personalizzato sul Server.
• Moduli di chat del cliente — Questa cartella contiene diversi ModuleScripts richiesti dal ChatScript .

  • CommandModule — Contiene moduli utilizzati per implementare comandi di chat lato client.
  • MessageCreatorModules — Contiene moduli utilizzati per gestire e formattare i messaggi.
  • ChatConstants — Contiene costanti condivise dal server e dal client.
  • Impostazioni di chat — Memorizza varie impostazioni per configurare diversi aspetti della finestra di chat.
• Localizzazione di chat — Struttura dei dati che memorizza traduzioni di testo.
• ChatServiceRunner — Questo Script esegue la componente del server della chat.In generale, questo non deve essere modificato per creare un comportamento e una funzionalità di chat personalizzata.
• BubbleChat — Mostra i messaggi di chat dell'utente sopra il loro avatar in gioco (se abilitato).
• ChatScript — Questo LocalScript esegue la componente client del chat.Come ChatServiceRunner, questo non dovrebbe essere modificato per personalizzare la chat.Quando il gioco viene eseguito, questo viene clonato automaticamente al StarterPlayerScripts .

Modifica il sistema di chat

Per modificare o personalizzare il sistema di chat legacy, devi prima fare una copia della gerarchia sopra.

1. Nella finestra Explorer, individua TextChatService .Quindi, nella finestra Proprietà, imposta la proprietà ChatVersion a LegacyChatService .

   

2. Esegui l'esperienza utilizzando il pulsante Gioca ( F5 ).

3. Seleziona e copia ( CtrlC o ⌘C ) gli oggetti che vengono aggiunti a Chat .

   

4. Interrompi l'esperienza utilizzando il pulsante Stop ( ShiftF5 ).

5. Seleziona Chat e incolla in ( CtrlShiftV o ⌘ShiftV ) gli oggetti copiati (devono essere parentizzati a Chat come lo sono stati mentre l'esperienza era in esecuzione).

6. Assicurati che Chat.LoadDefaultChat sia Abilitato.

Workflow di chat

Prima di creare moduli per personalizzare la chat, è importante comprendere il flusso di lavoro che un messaggio di chat attraversa.Oltre a inviare messaggi di testo, ci sono vari comandi costruiti nel sistema di chat, quindi ogni messaggio deve essere controllato per vedere se deve essere interpretato come un comando o solo un messaggio di Messaggio.Persino i messaggi di testo possono essere modificati e filtrati nel processo.

Dopo che un utente ha il focus nell'input della chat e inserisce un personaggio, vengono eseguiti diversi controlli immediatamente sul client.Se il personaggio è Esc, la casella di input si chiude e non vengono intraprese azioni.Se il personaggio è qualcosa di diverso da Enter , il testo viene passato attraverso i processori di comando In-Progress.Vengono utilizzati per valutare il testo per vedere se è necessario intraprendere qualsiasi azione.Ad esempio, quando un utente inizia a sussurare con il comando /whisper, non appena è stato inserito il nome utente dopo il comando, la casella di input cambia per indicare che l'utente sta ora entrando in un canale di sussurro.

Sul lato client della chat, ci sono due tipi di processori: In corso e Completato.Il primo viene eseguito dopo che ogni personaggio è stato digitato, mentre l'ultimo viene eseguito solo quando l'utente ha finito di digitare e ha raggiunto Enter .

Quando l'utente finisce di digitare e colpisce Enter il testo, il suo input viene inviato attraverso diversi processori di input ulteriori.Se un comando In corso ha creato uno stato di chat personalizzato, la chat controlla lo stato per vedere se un comando finale deve essere eseguito e se il messaggio debba continuare.Se al messaggio è consentito di continuare, il testo viene inviato attraverso un altro set di processori chiamati Completati processori.Se uno qualsiasi di questi processori restituisce vero, il messaggio smette di essere inviato.Altrimenti, il messaggio viene inviato al Server.

Una volta che il messaggio raggiunge il Server, passa attraverso un altro set di processori di comando.Proprio come i processori Completati sul client, se uno di questi processori restituisce vero, il messaggio smette di essere eseguito.Altrimenti il messaggio viene passato attraverso una serie di filtri (incluso il Filtrodi chat predefinito di Roblox).Una volta che tutto questo è stato fatto, il messaggio viene inviato a tutti i canali e ai relatori appropriati.

Moduli del server

I moduli messi in ChatModule possono essere utilizzati per una varietà di scopi.Questi moduli possono essere utilizzati per gestire i canali di chat e gli oratori, aggiungere funzioni filtro e comando, eseguire bot di chat o qualsiasi altra cosa debba essere gestita sul Server.Per interagire con il sistema di chat, ogni modulo viene passato un oggetto ChatService.

Quando il ChatServiceRunner si avvia, richiede ogni modulo all'interno di ChatModules .Si aspetta che ogni modulo restituisca una funzione come poi chiama ciascuno dei moduli a sua volta, passando il suo oggetto ChatService ad ogni funzione.Indipendentemente da ciò che il modulo è destinato a fare (eseguire un bot, aggiungere una funzione filtro, ecc.), deve seguire questa forma per funzionare.

Framework modulo di esempio
local function Run(ChatService)
	-- Il codice va qui
end

return Run

Aggiungi canali

Una delle cose più semplici che un ChatModule può fare è quella di gestire canali .Gli oggetti del canale possono essere creati con il metodo AddChannel() di ChatService.Si noti che l'oggetto del canale deve essere utilizzato solo quando si chiamano i membri di quel canale (come le sue proprietà e le funzioni).Quando si fa riferimento ai canali dal contesto di ChatService o ChatSpeakers, il nome del canale viene utilizzato per farvi riferimento.

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

return Run

Configurazione del canale di base

I canali hanno diverse proprietà che possono essere utilizzate per modificarli leggermente.Ad esempio, questo modulo crea un canale e imposta il messaggio di benvenuto e fa in modo che gli utenti si uniscano automaticamente al canale quando entrano nell'esperienza.

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

-- Imposta il messaggio che viene mostrato quando un utente si unisce al canale
	myChannel.WelcomeMessage = "Welcome to my channel!"
	-- Fa in modo che i giocatori si uniscano automaticamente al canale quando entrano nel Gioco
	myChannel.AutoJoin = true
end

return Run

Eventi di canale

I canali hanno diversi eventi a cui è possibile iscriversi.Questi eventi si attivano quando viene pubblicato un Messaggio di chat nel canale, quando un Speaker di chat esce o si unisce, o quando uno Speaker viene disattivato o sbloccato.Ad esempio, questo modulo creerà un canale con il nome MyChannel .Ogni volta che un oratore si unisce o lascia il canale, verrà inviato un messaggio di sistema a tutti gli oratori nel canale per informarli dell'evento.

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

Funzioni di comando

Un'altra cosa potente che ChatModule può fare sono i comandi di chat **** .Quando un messaggio viene inviato al Server, la chat invierà il messaggio attraverso ogni funzione di comando che è stata registrata al ChatService e al canale pertinente.Queste funzioni vengono inviate all'oratore, al Messaggioe al canale a cui viene inviato il messaggio.La funzione può prendere qualsiasi azione di cui abbia bisogno e quindi restituire vero o falso.Se la funzione restituisce vero, il messaggio smette di essere elaborato dal sistema di chat.Non verrà inviato a nessuna funzione di comando in più né verrà visualizzato nella finestra di chat.Se la funzione restituisce false, il messaggio continua attraverso tutte le altre funzioni di comando.Se nessuna delle funzioni di comando restituisce vero, il messaggio verrà quindi inviato attraverso i filtri e poi visualizzato.

Le funzioni di comando sono spesso utilizzate per implementare Comandi di amministratore, che sono comandi di testo che alcuni utenti possono utilizzare per manipolare lo stato dell'esperienza attraverso un testo specifico detto nella chat.

In questo esempio un ChatModule viene utilizzato per creare un Part se un utente digita /part nella chat.Nota che questa funzione restituisce vero se una parte è stata creata che impedirà al messaggio di procedere e non verrà visualizzato alcun messaggio.Se una parte non viene creata, questa funzione deve restituire false in modo che il messaggio possa continuare a lavorare attraverso il sistema.

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

Sia ChatChannels che ChatService stesso possono avere comandi di chat. I processori di comando del servizio di chat eseguiranno su ogni messaggio inviato al Server, mentre i comandi dei canali saranno eseguiti solo se il messaggio è stato inviato al canale al quale è registrato il comando.

Funzioni di filtro

I messaggi che non vengono interrotti da una funzione di comando non passeranno attraverso tutte le funzioni di filtro che sono registrate al ChatService e ai canali pertinenti.Ogni funzione del filtro viene passata al relatore, all'oggetto del messaggio e al nome del canale.Qualsiasi modifica apportata all'oggetto messaggio persisterà e ogni funzione filtro successiva vedrà il Messaggioaggiornato.Nota che le funzioni di filtro non hanno bisogno di restituire un valore.

In questo esempio, una semplice funzione di filtro viene registrata per far apparire ogni messaggio in minuscolo.

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

	ChatService:RegisterFilterMessageFunction("makeLowercase", makeLowercase)
end

return Run

Moduli del client

I moduli messi in ClientChatModules possono essere utilizzati per creare un comportamento personalizzato per i client.Questi moduli sono divisi in due cartelle diverse: Moduli di comando e Moduli creatori di messaggi.

Moduli di comando

Moduli di comando lavorano molto similmente ai moduli sul server che registrano funzioni di comando.Questi moduli definiscono funzioni che verranno eseguite dopo che l'utente ha inserito del testo.Quel testo può essere letto e il comando può far passare il messaggio al server o fermare il progresso del Messaggio.I comandi che vengono valutati alla fine del messaggio sono contrassegnati con COMPLETED_MESSAGE_PROCESSOR mentre i comandi che vengono valutati dopo ogni carattere sono contrassegnati con IN_PROGRESS_MESSAGE_PROCESSOR .

In entrambi i tipi di comandi, il modulo deve restituire un dizionario che dice quale tipo di processore il comando deve utilizzare e quale funzione eseguire quando il processore viene chiamato.Ad esempio, un processore di messaggi completato dovrebbe assumere la forma:

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
}

Nota che l'enumerazione è definita all'interno della cartella Util dentro la cartella CommandModule .

Comandi di messaggio completati

Comandi del messaggio completati vengono valutati quando l'utente ha finito di digitare e ha colpito Enter .La funzione del processore viene passata all'oggetto ChatMessage, alla finestra di chat del cliente ChatWindow, e alla tabella ChatSettings.Se la funzione restituisce vero, il messaggio smette di essere elaborato e non verrà inviato al Server.Altrimenti verrà inviato attraverso tutti gli altri processori e alla fine al server se nessuno degli altri processori lo ferma.

Ad esempio, il seguente processore rimuoverà il messaggio più vecchio nel canale attuale se l'utente inserisce il comando /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
}

Comandi in corso di esecuzione

Comandi in corso d'esecuzione vengono valutati ogni volta che un utente digita un personaggio nell'input della chat.Ad esempio, il seguente codice riproduce un clack dopo ogni pressione della tastiera per far sembrare che l'utente sta digitando su una macchina da scrivere:

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
}

I comandi in corso sono spesso utilizzati per creare un stato personalizzato per la chat per inviare messaggi a utenti specifici invece del solo canale attuale.Ad esempio, i sistemi Whisper e Team Chat controllano se l'utente ha digitato /whisper o /team rispettivamente e inviano il messaggio finito solo agli utenti appropriati.

Si prevede che uno stato personalizzato sia un tavolo con le seguenti funzioni:

• TextUpdated() — Chiamato quando il testo nella casella di input cambia.
• GetMessage() — Chiamato dopo che l'utente ha finito di inserire il messaggio e colpisce Enter . Questa funzione è prevista per restituire una Stringa.
• ProcessCompletedMessage() — Chiamato quando il messaggio viene elaborato.Un processore di stato personalizzato verrà sempre attivato prima dei processori di messaggio completati.Come altri processori, questa funzione dovrebbe restituire vero se il messaggio dovesse smettere di essere inviato, altrimenti dovrebbe restituire falso.
• Destroy() — Chiamato dopo che il messaggio è stato inviato. Dovrebbe essere utilizzato per pulire tutto ciò che è stato configurato dallo stato personalizzato.

Per utilizzare uno stato personalizzato, la funzione ProcessMessage() del modulo di comando deve restituire lo stato.Uno stato personalizzato di base avrebbe la seguente forma:

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
}

Uno dei principali vantaggi dell'utilizzo di uno stato personalizzato è che un modulo può modificare la barra di chat e il suo testo contenente mentre l'utente digita sia in termini di funzione che di aspetto, e poi lo ripristina facilmente in seguito (una volta inviato un messaggio lo stato personalizzato viene automaticamente rimosso e tutto viene ripristinato alla normalità).Ad esempio, questo codice configura uno stato personalizzato che consente di mostrare solo 20 caratteri alla volta nella casella di testo.Se l'utente continua a digitare, i caratteri all'inizio della stringa vengono temporaneamente rimossi.Quando l'utente invia il Messaggio, tutti i caratteri rimossi vengono aggiunti nuovamente al Messaggio.

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
}

Come accennato prima, una volta inviato un messaggio viene rimosso qualsiasi stato personalizzato e la chat viene ripristinata alla normalità.Se è necessario reimpostare uno stato personalizzato prima di inviare il Messaggio, lo stato può essere ripristinato con ChatBar:ResetCustomState() .Nota che questo rimuoverà anche il focus dalla casella di testo della barra di chat.

Moduli creatori di messaggi

Un altro tipo di modulo che può essere utilizzato nella componente client è un modulo Creatore di messaggi .Questo tipo di modulo viene utilizzato per creare gli elementi GUI nella finestra di chat per visualizzare il Messaggio.Ogni tipo di creatore di messaggi definisce un nuovo inserisci / scrividi messaggio, quindi messaggi diversi possono essere creati con formattazioni diverse.Inoltre, gli elementi GUI possono essere aggiunti alla visualizzazione dei messaggi in questo modo che consente immagini, pulsanti e altro ancora.

Questi moduli richiedono l'attivazione in più luoghi diversi.Per ogni tipo di messaggio, deve esserci un ModuleScript dentro MessageCreatorModules .Inoltre, il ChatNamespace ModuleScript deve essere modificato per includere il nuovo tipo di messaggio.Infine, i moduli vengono utilizzati solo se una componente del server di chat crea un nuovo messaggio con il inserisci / scrividi messaggio specificato.

L'esempio seguente passerà attraverso la creazione di un bot che dice l'ora ogni 5 secondi e il messaggio che viene inviato ottiene uno sfondo rosso.

Per Iniziare, cominciare, il ChatNamespace ModuleScript deve aggiungere un campo per il nuovo tipo di Messaggio.

-- Statistiche di chat
local module = {}

--[[ Tipi di messaggio ]]
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

Il bot stesso viene creato in un nuovo ChatModule sul Server.Nota che una funzione di filtro viene utilizzata per aggiungere il nuovo tipo di messaggio ai messaggi che il bot invia.

-- Nuovo ModuleScript da posizionare nei ChatModules
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

Infine, deve essere creato un modulo creatore di messaggi.Questo modulo deve restituire un dizionario con due elementi: il tipo del Messaggio, indicizzato con KEY_MESSAGE_TYPE , e la funzione da chiamare quando si creano gli elementi GUI del messaggio, indicizzati con KEY_CREATOR_FUNCTION .

La funzione memorizzata da KEY_CREATOR_FUNCTION deve restituire un dizionario con diversi componenti.Innanzitutto, deve includere un Frame e TextLabel che verranno visualizzati nella finestra di chat.Questi possono essere creati con la funzione util:CreateBaseMessage() .Il dizionario deve anche includere una funzione da eseguire se il testo del messaggio viene aggiornato.Quando i messaggi appaiono per la prima volta nel client, hanno un testo di riempimento vuoto mentre il messaggio viene elaborato e filtrato, quindi gli oggetti di messaggio come questo devono gestire ciò che accade quando ricevono una chiamata di aggiornamento.Successivamente, il dizionario deve includere una funzione per determinare l'altezza del frame.Questa funzione chiama spesso la funzione util:GetMessageHeight() .Infine, il dizionario deve includere diverse funzioni che definiscono come gli elementi dovrebbero scomparire quando la finestra scompare (la funzione di utilità per questo è util:CreateFadeFunctions() ).

-- nuovo ModuleScript da includere nei 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)
	-- Crea gli oggetti GUI per il Frame e TextLabel per contenere il Messaggio
	local BaseFrame, BaseMessage = util:CreateBaseMessage("", ChatSettings.DefaultFont, ChatSettings.ChatWindowTextSize, ChatSettings.DefaultMessageColor)

	-- Cambia lo sfondo del Frame a rosso
	BaseFrame.BackgroundColor3 = Color3.new(1,0,0)
	BaseFrame.BackgroundTransparency = 0

	-- Maneggiare il messaggio di aggiornamento del segnaposto
	local function UpdateTextFunction(messageObject)
        if messageObject.IsFiltered then
		   BaseMessage.Text = messageObject.Message
        end
	end
	UpdateTextFunction(messageData)

	-- Usa la funzione util per determinare l'altezza del frame
	local function GetHeightFunction(xSize)
		return util:GetMessageHeight(BaseMessage, BaseFrame, xSize)
	end

	-- Crea funzioni di dissolvenza che vengono chiamate quando la finestra di chat scompare
	local FadeParameters = {}
	FadeParameters[BaseMessage] = {
		TextTransparency = {FadedIn = 0, FadedOut = 1},
		TextStrokeTransparency = {FadedIn = 0.75, FadedOut = 1}
	}
	local FadeInFunction, FadeOutFunction, UpdateAnimFunction = util:CreateFadeFunctions(FadeParameters)

	-- Restituisci il dizionario che definisce l'Etichettadel messaggio
	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
}