Sistema de chat legado

jerarquía

El sistema de chat legado utiliza el modelo cliente-servidor.Los componentes del módulo de chat del lado del servidor se manejan en el servidor con el canal de chat y orador de chat gestión, mientras que el cliente es responsable de la entrada y la visualización de mensajes.La comunicación entre el servidor y los clientes se maneja automáticamente usando RemoteEvents .

El propio servicio del motor Chat es la unidad de almacenamiento esencial para el sistema de chat: cuando se carga un lugar de Roblox (ya sea en el cliente o en Studio al ejecutarse o jugar), los siguientes componentes se cargan automáticamente en el servicio Chat si Chat.LoadDefaultChat es cierto.

• Módulos de chat — Este Folder es una colección de módulos que son requeridos por el ChatServiceRunner .Todo el contenido de esta carpeta es requerido por el script y se usa para crear comportamiento personalizado en el servidor.
• ClientChatModules — Este directorio contiene varios ModuleScripts requeridos por el ChatScript .

  • CommandModules — Contiene módulos utilizados para implementar comandos de chat del lado del cliente.
  • MessageCreatorModules — Contiene módulos utilizados para manejar y formatear mensajes.
  • Estados de chat — Contiene constantes compartidas por el servidor y el cliente.
  • Configuración de chat — Almacena varias configuraciones para configurar diferentes aspectos de la ventana de chat.
• Localización de chat — Estructura de datos que almacena traducciones de texto.
• ChatServiceRunner — Este Script ejecuta el componente del servidor del chat.En general, esto no necesita ser modificado para crear un comportamiento y funcionalidad de chat personalizados.
• BubbleChat — Muestra mensajes de chat del usuario por encima de su avatar en el juego (si está habilitado).
• ChatScript — Este LocalScript ejecuta el componente del cliente del chat.Al igual que ChatServiceRunner, esto no debería necesitar modificarse para personalizar el chat.Cuando el juego se ejecuta, esto se clona automáticamente al StarterPlayerScripts .

Modificar el sistema de chat

Para modificar o personalizar el sistema de chat legado, primero debes hacer una copia de la jerarquía anterior.

1. En la ventana Explorador, localiza TextChatService .Luego, en la ventana Propiedades, establece la propiedad ChatVersion a LegacyChatService .

   

2. Ejecuta la experiencia usando el botón Jugar (F5).

3. Seleccione y copie ( CtrlC o ⌘C ) los objetos que se agreguen a Chat .

   

4. Detenga la experiencia usando el botón Detener ( ShiftF5 ).

5. Seleccione Chat y pegue en ( CtrlShiftV o ⌘ShiftV ) los objetos copiados (deben ser padreados a Chat como estaban mientras la experiencia se ejecutaba).

6. Asegúrate de que Chat.LoadDefaultChat esté habilitado.

Flujo de trabajo de chat

Antes de crear módulos para personalizar el chat, es importante comprender el flujo de trabajo que sigue un mensaje de chat.Además de enviar mensajes de texto, hay varios comandos integrados en el sistema de chat, por lo que cada mensaje debe ser revisado para ver si debe interpretarse como un comando o simplemente un mensaje de texto.Incluso los mensajes de texto se pueden modificar y filtrar en el proceso.

Después de que un usuario se centre en la entrada de chat y ingrese un personaje, se realizan varias comprobaciones de inmediato en el cliente.Si el personaje es Esc, la caja de entrada se cierra y no se toman acciones.Si el personaje es cualquier cosa además de Enter, el texto se pasa a través de los procesadores de comando En curso.Se utilizan para evaluar el texto para ver si se necesita tomar alguna acción.Por ejemplo, cuando un usuario empieza a susurrar con el comando /whisper, tan pronto como se ha introducido el nombre de usuario después del comando, la caja de entrada cambia para indicar que el usuario ahora está entrando en un canal de susurro.

En el lado del cliente del chat, hay dos tipos de procesadores: En curso y Completado.El primero se ejecuta después de que cada personaje se haya escrito, mientras que el último solo se ejecuta cuando el usuario haya terminado de escribir y haya alcanzado Enter .

Cuando el usuario termina de escribir y presiona Enter el texto, su entrada se envía a través de varios procesadores de comandos más.Si un comando En curso hace un estado de chat personalizado, el chat verifica el estado para ver si debe ejecutarse un comando final y si la mensajería debe continuar.Si se permite que el mensaje continúe, se envía el texto a través de otro conjunto de procesadores llamados procesadores completados.Si alguno de estos procesadores devuelve verdadero, el mensaje deja de enviarse.De lo contrario, el mensaje se envía al servidor.

Una vez que el mensaje llega al servidor, pasa por otro conjunto de procesadores de comandos.Al igual que los procesadores completados en el cliente, si alguno de estos procesadores devuelve verdadero, la mensajería deja de ejecutarse.De lo contrario, el mensaje se pasa a través de un conjunto de filtros (incluido el filtro de chat predeterminado de Roblox).Una vez que todo esto se haya hecho, el mensaje se envía a todos los canales y oradores apropiados.

Módulos del servidor

Los módulos puestos en ChatModule se pueden usar para una variedad de propósitos.Estos módulos se pueden utilizar para administrar canales de chat y oradores, agregar funciones de filtro y comando, ejecutar chatbots o cualquier otra cosa que deba manejarse en el servidor.Para interactuar con el sistema de chat, se le pasa a cada módulo un objeto Servicio de chat.

Cuando el ChatServiceRunner se inicia, requiere cada módulo dentro de ChatModules .Se espera que cada módulo devuelva una función a medida que luego llama a cada uno de los módulos en turno, pasando su objeto Servicio de chat a cada función.Independientemente de lo que el módulo está destinado a hacer (ejecutar un bot, agregar una función de filtro, etc), debe seguir este formulario para funcionar.

Marco de muestra de módulos
local function Run(ChatService)
	-- El código va aquí
end

return Run

Añadir canales

Una de las cosas más simples que un módulo de chat puede hacer es administrar canales .Los objetos de canal se pueden crear con el método AddChannel() de ChatService.Tenga en cuenta que el objeto de canal solo debe usarse cuando se llaman a los miembros de ese canal (como sus propiedades y funciones).Al referirse a canales desde el contexto de Servicio de chat o Oradores de chat, el nombre del canal se usa para referenciarlo.

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

return Run

Configuración básica del canal

Los canales tienen varias propiedades que se pueden utilizar para modificarlos ligeramente.Por ejemplo, este módulo crea un canal y establece el mensaje de bienvenida y hace que los usuarios se unan automáticamente al canal cuando ingresan a la experiencia.

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

-- Establecer el mensaje que se muestra cuando un usuario se une al canal
	myChannel.WelcomeMessage = "Welcome to my channel!"
	-- Hace que los jugadores se unan automáticamente al canal cuando ingresan al juego
	myChannel.AutoJoin = true
end

return Run

Eventos de canal

Los canales tienen varios eventos a los que se puede suscribir.Estos eventos se disparan cuando se publica un mensaje de chat en el canal, cuando un orador de chat se va o se une, o cuando un orador se silencia o se desilencia.Por ejemplo, este módulo creará un canal con el nombre MyChannel .Cada vez que un orador se una o salga del canal, se enviará un mensaje del sistema a todos los oradores del canal para informarles del 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

Funciones de comando

Otra cosa poderosa que ChatModule puede hacer son los comandos de chat >.Cuando se envía un mensaje al servidor, el chat enviará el mensaje a través de cada función de comando que se ha registrado en el Servicio de chat y en el canal relevante.Estas funciones se envían al bocina, mensaje y canal al que se envía el mensaje.La función puede tomar cualquier acción que necesite y luego devolver verdadero o falso.Si la función devuelve verdadero, entonces el mensaje deja de ser procesado por el sistema de chat.No se enviará a ninguna función de comando más ni se mostrará en la ventana de chat.Si la función devuelve false, entonces el mensaje continúa a través de todas las otras funciones de comando.Si ninguna de las funciones de comando devuelve verdadero, el mensaje se enviará a través de filtros y luego se mostrará.

Las funciones de comando se usan a menudo para implementar comandos de administrador, que son comandos de texto que ciertos usuarios pueden usar para manipular el estado de la experiencia a través de un texto específico dicho en el chat.

En este ejemplo, se usa un módulo de chat para crear un Part si un usuario escribe /part en el chat.Tenga en cuenta que esta función devuelve verdadero si se creó una parte que detendrá el mensaje de seguir y no se mostrará ningún mensaje.Si una parte no se crea, esta función debe devolver false para que el mensaje pueda seguir trabajando a través del 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

Ambos canales de chat y el propio servicio de chat pueden tener comandos de chat. Los procesadores de comandos de servicio de chat se ejecutarán en cada mensaje que se envíe al servidor, mientras que los comandos de canal solo se ejecutarán si el mensaje se envió al canal al que está registrado el comando.

Funciones de filtrado

Los mensajes que no son interceptados por una función de comando se enviarán a través de todas las funciones de filtro que están registradas en el ChatService y los canales relevantes.Cada función de filtro se pasa el bocina, el objeto de mensaje y el nombre del canal.Cualquier cambio realizado al objeto de mensaje persistirá y cada función de filtro siguiente verá el mensaje actualizado.Tenga en cuenta que las funciones de filtro no necesitan devolver un valor.

En este ejemplo, una simple función de filtro se registra para hacer que cada mensaje aparezca en minúsculas.

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

	ChatService:RegisterFilterMessageFunction("makeLowercase", makeLowercase)
end

return Run

Módulos de cliente

Los módulos puestos en ClientChatModules se pueden usar para crear comportamiento personalizado para los clientes.Estos módulos se dividen en dos carpetas diferentes: Módulos de comando y Módulos creadores de mensajes.

Módulos de comando

Módulos de comando trabajan de manera muy similar a los módulos en el servidor que registran funciones de comando.Estos módulos definen funciones que se activarán después de que el usuario haya introducido texto.Ese texto se puede leer y el comando puede dejar pasar el mensaje al servidor o detener el progreso del mensaje.Los comandos que se evaluan al final del mensaje se etiquetan con COMPLETED_MESSAGE_PROCESSOR mientras que los comandos que se evaluan después de cada personaje se etiquetan con IN_PROGRESS_MESSAGE_PROCESSOR .

En ambos tipos de comandos, el módulo debe devolver un diccionario que diga qué tipo de procesador debe usar el comando y qué función ejecutar cuando se llame al procesador.Por ejemplo, un procesador de mensajes completado debería tomar 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
}

Tenga en cuenta que el enum se define en el Util dentro de la carpeta CommandModules .

Comandos de mensajes completados

Comandos de mensaje completados se evaluan cuando el usuario ha terminado de escribir y ha presionado Enter.La función del procesador se pasa el objeto Mensaje de chat del cliente, la ventana de chat del cliente y la tabla de configuración de chat.Si la función devuelve verdadero, entonces el mensaje deja de procesarse y no se enviará al servidor.De lo contrario, se enviará a través de todos los otros procesadores y finalmente al servidor si ninguno de los otros procesadores lo detiene.

Por ejemplo, el siguiente procesador eliminará el mensaje más antiguo en el canal actual si el usuario ingresa el 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
}

Comandos en curso

Los comandos en curso se evaluan cada vez que un usuario escribe un personaje en la entrada de chat .Por ejemplo, el siguiente código reproduce un clic después de cada tecla para hacer que suene como si el usuario estuviera escribiendo en una máquina de escribir:

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
}

Los comandos en curso se usan a menudo para crear un estado personalizado para que el chat envíe mensajes a usuarios específicos en lugar del canal actual .Por ejemplo, los sistemas de chat de susurro y de equipo verifican si el usuario ha escrito /whisper o /team respectivamente y envían el mensaje terminado solo a los usuarios apropiados.

Se espera que un estado personalizado sea una tabla con las siguientes funciones:

• TextUpdated() — Se llama cuando el texto en el cuadro de entrada cambia.
• GetMessage() — Se llama después de que el usuario haya terminado de ingresar el mensaje y golpee Enter. Esta función se espera que devuelva una cadena.
• ProcessCompletedMessage() — Se llama cuando se está procesando el mensaje.Un procesador de estado personalizado siempre se disparará antes que los procesadores de mensajes completados.Al igual que otros procesadores, esta función debe devolver verdadero si el mensaje debe dejar de enviarse, de lo contrario debería devolver falso.
• Destroy() — Se llama después de que se haya enviado el mensaje. Debe usarse para limpiar cualquier cosa que haya sido configurada por el estado personalizado.

Para usar un estado personalizado, la función ProcessMessage() de la función de comando debe devolver el estado.Un estado personalizado básico tomaría la siguiente 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
}

Una de las principales ventajas de usar un estado personalizado es que un módulo puede editar la barra de chat y su texto contenido mientras el usuario está escribiendo tanto en términos de función como de apariencia, y luego restablecer fácilmente después (una vez que se envíe un mensaje, se elimina automáticamente un estado personalizado y todo se restablece a la normalidad).Por ejemplo, este código configura un estado personalizado que solo permite mostrar 20 caracteres en el cuadro de texto a la vez.Si el usuario sigue escribiendo, los caracteres al comienzo de la cadena se eliminan temporalmente.Cuando el usuario envía el mensaje, todos los caracteres eliminados se agregan de nuevo al mensaje.

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
}

Como se mencionó antes, una vez que se haya enviado un mensaje, se elimina cualquier estado personalizado y se restaura el chat a la normalidad.Si es necesario restablecer un estado personalizado antes de enviar el mensaje, el estado se puede restablecer con ChatBar:ResetCustomState() .Tenga en cuenta que esto también eliminará el enfoque de la caja de texto de la barra de chat.

Módulos creadores de mensajes

Otro tipo de módulo que se puede utilizar en el componente del cliente es un módulo Creador de mensajes .Este tipo de módulo se usa para crear los elementos de la interfaz de usuario en la ventana de chat para mostrar el mensaje.Cada tipo de creador de mensajes define un nuevo introducirde mensaje, por lo que se pueden crear mensajes diferentes con diferentes formatos.Además, los elementos de interfaz de usuario se pueden agregar al mostrador de mensajes de esta manera que permite imágenes, botones y más.

Estos módulos requieren la configuración en varios lugares diferentes.Para cada introducirde mensaje, debe haber un ModuleScript dentro de MessageCreatorModules .También, el Espacios de chat ModuleScript debe ser editado para incluir el nuevo introducirde mensaje.Por último, los módulos solo se usan si un componente del servidor de chat crea un nuevo mensaje con el introducirde mensaje dado.

El siguiente ejemplo pasará por hacer un bot que diga la hora cada 5 segundos, y el mensaje que se envía obtendrá un fondo rojo.

Para iniciar, el ChatConstants ModuleScript necesita agregar un campo para el nuevo tipo de mensaje

-- Constantes de chat
local module = {}

--[[ tipos de mensaje ]]
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

El propio bot se crea en un nuevo ChatModule en el servidor.Tenga en cuenta que se usa una función de filtro para agregar el nuevo tipo de mensaje a los mensajes que envía el bot.

-- Nuevo ModuleScript para ser colocado en 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

Por último, se debe crear un módulo de creador de mensajes.Este módulo debe devolver un diccionario con dos elementos: el tipo de mensaje, indexado con KEY_MESSAGE_TYPE , y la función para llamar al crear los elementos de la interfaz de usuario del mensaje, indexados con KEY_CREATOR_FUNCTION .

La función almacenada por KEY_CREATOR_FUNCTION necesita devolver un diccionario con varios componentes.Primero, debe incluir un Frame y TextLabel que se mostrará en la ventana de chat.Estas se pueden crear con la función util:CreateBaseMessage().El diccionario también debe incluir una función para ejecutarse si el texto del mensaje se actualiza.Cuando los mensajes aparecen por primera vez en el cliente, tienen texto de marcador vacío mientras se procesa y filtra el mensaje, por lo que los objetos de mensajes como este deben manejar lo que sucede cuando reciben una llamada para actualización.A continuación, el diccionario debe incluir una función para determinar la altura del marco.Esta función a menudo llama a la función util:GetMessageHeight().Por último, el diccionario debe incluir varias funciones que definen cómo deben desaparecer los elementos cuando la ventana desaparece (la función de utilidad para esto es util:CreateFadeFunctions() ).

-- nuevo ModuleScript para incluir en 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 los objetos de la interfaz de usuario para el marco y la etiqueta de texto para contener el mensaje
	local BaseFrame, BaseMessage = util:CreateBaseMessage("", ChatSettings.DefaultFont, ChatSettings.ChatWindowTextSize, ChatSettings.DefaultMessageColor)

	-- Cambiar el fondo del marco a rojo
	BaseFrame.BackgroundColor3 = Color3.new(1,0,0)
	BaseFrame.BackgroundTransparency = 0

	-- Manija actualización del texto del mensaje de marcador
	local function UpdateTextFunction(messageObject)
        if messageObject.IsFiltered then
		   BaseMessage.Text = messageObject.Message
        end
	end
	UpdateTextFunction(messageData)

	-- Usa la función util para determinar la altura del marco
	local function GetHeightFunction(xSize)
		return util:GetMessageHeight(BaseMessage, BaseFrame, xSize)
	end

	-- Crear funciones de desaparición que se llaman cuando la ventana de chat desaparece
	local FadeParameters = {}
	FadeParameters[BaseMessage] = {
		TextTransparency = {FadedIn = 0, FadedOut = 1},
		TextStrokeTransparency = {FadedIn = 0.75, FadedOut = 1}
	}
	local FadeInFunction, FadeOutFunction, UpdateAnimFunction = util:CreateFadeFunctions(FadeParameters)

	-- Devolver diccionario que define la etiqueta de mensaje
	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
}