Legacy-Chat-System

Hierarchie

Das Legacy-Chat-System verwendet das client-server-modell. Server-seitige Chat-Modul-Komponenten ChatChannel und ChatSpeaker werden von der 1> ChatService-Schaltfläche1> auf dem Server verwaltet, während der Client für die Eingabe und die Anzeige von Nachrichten verantwortlich ist. Die Kommunikation zwischen dem Server und Clients wird automatisch mit <

Der Chat Motor-Dienst selbst ist die notwendige Lagerungseinheit für das Chat-System: Wenn ein Roblox-Ort geladen wird (either im Client oder in Studio, wenn Sie ausführen oder spielen), werden die folgenden Komponenten automatisch in den Chat Dienst geladen, wenn Chat.LoadDefaultChat wahr ist.

• ChatModule — Dieser Folder ist eine Sammlung von Modulen, die vom ChatServiceRunner erforderlich sind. Alle Inhalte dieses Ordners werden vom Skript erforderlich und werden verwendet, um benutzerdefiniertes Verhalten auf dem Server zu erstellen.
• ClientChatModule — Dieser Ordner enthält verschiedene ModuleScripts , die vom ChatScript erforderlich sind.

  • CommandModule — Enthält Module, die clientseitige Chat-Befehle implementieren.
  • MessageCreatorModule — Enthält Module, die Nachrichten verarbeiten und formatieren.
  • ChatCommands — Enthält Konstanten, die vom Server und dem Client geteilt werden.
  • ChatSettings — Speichert verschiedene Einstellungen, um verschiedene Aspekte des ChatWindows zu konfigurieren.
• ChatLocalization — Datenstruktur, die Text-Übersetzungen speichert.
• ChatServiceRunner — Dies Script läuft den Server-Komponenten des Chats. Im Allgemeinen muss dies nicht geändert werden, um benutzerdefinierte Chat-Verhalten und Funktionen zu erstellen.
• BubbleChat — Zeigt Benutzer-Chat-Nachrichten über ihrem In-Game-Avatar an (wenn aktiviert).
• ChatScript — Dieser LocalScript läuft den Client-Komponenten des Chats. Wie ChatServiceRunner sollte dies nicht modifiziert werden, um den Chat anzupassen. Wenn das Spiel dies automatisch in die StarterPlayerScripts kopiert, wird es automatisch in die 0> Class.LocalPlayerScripts0> kopiert.

Modifizieren des Chat-Systems

Um das Legacy-Chat-System zu modifizieren oder anzupassen, musst du zuerst eine Kopie der Hierarchie oben erstellen.

1. In dem Explorer-Fenster ', suchen Sie TextChatService . Dann, in dem Eigenschaften-Fenster ', setzen Sie die 1> ChatVersion 1> -Eigenschaft auf 4> LegacyChatService 4> .

   

2. Laufen Sie das Erlebnis mit der Spielen Schaltfläche ( F5 ).

3. Wählen Sie und kopieren Sie ( CtrlC oder ⌘C ) die Objekte, die zu 2> Class.Chat2> hinzugefügt werden.

   

4. Stoppen Sie die Erfahrung mit der Stopp -Schaltfläche ( ShiftF5 ).

5. Wählen Sie Chat und fügen Sie in ( Ctrl 0> Shift 0> 2> V2> oder 5> ⌘ 5> 7> Shift 7> 9> V9> ) die kopierten Objekte (sie müssen El

6. Stellen Sie sicher, dass Chat.LoadDefaultChat aktiviert ist.

Chat-Workflow

Bevor Sie Module zum Anpassen des Chats erstellen, ist es wichtig zu verstehen, durch den Chat-Nachrichten fließen. Mit dem Senden von Textnachrichten gibt es verschiedene Befehle, die in das Chat-System integriert sind, so dass jede Nachricht überprüft werden muss, um zu sehen, ob sie als Befehl oder nur als Textnachricht interpretiert werden müssen. Textnachrichten können sogar in der Bearbeitung modifiziert und gefiltert werden.

Nachdem ein Benutzer sich in der Chat-Eingabe konzentriert hat und einen Charakter eingegeben hat, werden mehrere Checks sofort auf dem Client ausgeführt. Wenn der Charakter Esc ist, schließt sich die Kanalund keine Aktion

Auf der Client-Seite des Chats gibt es zwei Arten von Prozessoren: In-Progress und Completed. Der erste bewertet nach jedem Zeichen, während der letztere nur bewertet, wenn der Benutzer fertig mit dem Schreiben ist und Enter gedrückt hat.

Wenn der Benutzer fertig mit dem Schreiben fertig ist und auf Enter den Text tippt, wird der Text durch mehrere weitere Kommando-Verarbeiter gesendet. Wenn ein In-Progress-Kommando mit einem benutzerdefinierten Chat-Status abgeschlossen ist, prüft der Chat den Zustand, um zu sehen, ob eine endg

Sobald die Nachricht dem Server erreicht, wird sie durch einen weiteren Reihe von Kommando-Verarbeitern durchgeführt. Wie die Completed -Prozessoren auf dem Client, wenn eines dieser Prozessoren zurückkehren, dann wird die Nachricht aufgehört, ausgeführt zu werden. Andernfalls wird die Nachricht an alle Kanäle und die entsprechenden Sprecher gesendet.

Server-Module

Module, die in ChatModule eingebaut sind, können für eine Vielzahl von Anwendungsfällen verwendet werden. Diese Module können verwendet werden, um Chat-Kanäle und Sprecher zu verwalten, Filter und Befehlsfunktionen hinzuzufügen, Chat-Bots zu verwalten oder alles andere, was auf dem Server behandelt werden muss. Um mit dem Chat-System zu interagieren, wird jedem Modul ein ChatService -Objekt zugewiesen.

Wenn der ChatServiceRunner startet, erfordert jedes Modul innerhalb von ChatModule . Es erwartet, dass jedes Modul eine Funktion zurückgibt, da es dann jedes der Modul in Turn hinzufügt, indem es sein ChatService -Objekt an jede Funktion weitergibt. Unabhängig davon, was das Modul tun soll (denken Sie an einen Bot, fügen Sie einen Filter-Funktion hinz

Beispiel-Modul-Rahmen
local function Run(ChatService)
	-- Code hier hin
end

return Run

Kanäle hinzufügen

Eine der einfachsten Dinge, die ein Chat-Modul tun kann, ist es, Kanäle zu verwalten. Kanall对象 können mit der Methode AddChannel() von AddChannel() oder 2>ChatSpeakers2> erstellt werden. Beachten Sie, dass das Kanall-Objekt nur verwendet werden muss

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

return Run

Grundlegende Kanal-Konfiguration

Kanäle haben mehrere Eigenschaften, mit denen sie leicht modifiziert werden können. Zum Beispiel erstellt dieses Modul einen Kanal und setzt die Willkommensnachricht und verursacht, dass Benutzer automatisch dem Kanal beitreten, wenn sie das Erlebnis betreten.

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

-- Setzen Sie die Nachricht, die angezeigt wird, wenn ein Benutzer dem Kanal beitritt
	myChannel.WelcomeMessage = "Welcome to my channel!"
	-- Lässt Spieler automatisch dem Kanal beitreten, wenn sie das Spiel betreten
	myChannel.AutoJoin = true
end

return Run

Kanal-Ereignisse

Kanäle haben mehrere Ereignisse, denen sie abonnieren können. Diese Ereignisse werden ausgelöst, wenn ein ChatMessage an den Kanal geschickt wird, wenn ein ChatSpeaker verlässt oder beitritt, oder wenn ein Speaker stummgeschaltet oder nicht stummgeschaltet wird. Zum Beispiel wird dieses Modul ein Kanal mit dem Namen MyChannel

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

Befehlsfunktionen

Eine weitere mächtige Sache, die ChatModule kann, sind Chat Befehle . Wenn eine Nachricht an den Server gesendet wird, sendet der Chat die Nach

Command-Funktionen werden oft verwendet, um Admin-Befehle zu implementieren, die Text-Befehle sind, die bestimmte Benutzer verwenden können, um den Zustand der Erfahrung durch den Anruf bestimmter Texts im Chat zu manipulieren.

In diesem Beispiel wird ein Chat-Modul verwendet, um ein Part zu erstellen, wenn ein Benutzer in den Chat tippt /part, wenn eine Part erstellt wird. Beachten Sie, dass diese Funktion wahr ist, wenn eine Part erstellt wird, die die Nachricht stoppt, und keine Nachricht angezeigt wird. Wenn eine Part nicht erstellt wird, muss diese Funktion falsch sein, damit die Nachricht weiter funktion

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

Sowohl ChatChannels als auch ChatService selbst können Chat-Befehle haben. ChatService -Befehlsverarbeitungsprozesse laufen auf jede Nachricht, die an den Server gesendet wird, während die Kanal-Befehle nur auf dem Kanal registrierte Befehle ausführen.

Filter-Funktionen

Nachrichten, die nicht durch eine Command-Funktion aufgehalten werden, gehen durch alle Filterfunktionen, die in der ChatService und relevanten Kanälen registriert sind. Jede Filterfunktion wird durch den Lautsprecher, das Objektund den Kanalnamen zurückgegeben. Alle Änderungen am Nachrichtenobjekt bleiben bestehen und jede folgende Filterfunktion wird die aktualisierte Nachricht sehen. Beachten Sie, dass Filterfunktionen keinen Wert zurückgeben müssen

In diesem Beispiel ist eine einfache Filter-Funktion registriert, um jede Nachricht in der Tiefe zu erscheinen.

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

	ChatService:RegisterFilterMessageFunction("makeLowercase", makeLowercase)
end

return Run

Client-Module

Module, die in ClientChatModule eingebaut sind, können verwendet werden, um benutzerdefinierte Verhaltensweisen für Clients zu erstellen. Diese Module sind in zwei verschiedene Ordner unterteilt: Kommando-Module und Nachrichten-Ersteller-Module.

Befehlsmodule

Command-Module arbeiten sehr ähnlich wie Modul auf dem Server, die Command-Funktionen registrieren. Diese Module definieren Funktionen, die nach dem Eingeben von Text ausgelöst werden. Dieser Text kann gelesen werden und der Befehl entweder den Nachrichten durch den Server senden oder den Fortsch

In beiden Arten von Befehlen muss das Modul ein Wörterbuch zurückgeben, das sagt, welche Art von Prozessor der Befehl verwenden soll, und welche Funktion auszuführen ist, wenn der Prozessor aufgerufen wird. Zum Beispiel muss ein fertiggestellter Nachricht-Prozessor die Form annehmen:

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
}

Beachten Sie, dass die KEY_COMMAND_PROCESSOR_TYPE-Liste im Util ModuleScript innerhalb der 1>CommandModuleScript1>-Ordner definiert ist.

Abgeschlossene Nachrichten-Befehle

Completed Message Commands werden ausgeführt, wenn der Benutzer fertig mit dem Schreiben fertig ist und auf Enter gedrückt hat. Die Funktion des Prozessors wird über das Objekt ChatMessage und das Client-Chat-Fenster 0> ChatSettings0> übergeben. Wenn die Funktion wahr

Zum Beispiel entfernt der folgende Prozessor die älteste Nachricht in dem aktuellen Kanal, wenn der Benutzer den Befehl /last eingibt.

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
}

In-Progress-Befehle

In-进行命令 werden jedes Mal ausgeführt, wenn ein Benutzer einen Charakter in die Chat-Eingabe eingibt. Zum Beispiel spielt der folgende Code nach jedem Tastenklick ein Clack, damit es wie der Benutzer auf einem Schreibmaschinen-Typwriter schreibt:

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
}

In-进度命令 часто verwendet werden, um einen benutzerdefinierten Zustand für den Chat zu erstellen, anstatt nur den aktuellen Kanal zu senden. Zum Beispiel überprüfen die Whisper- und Team-Chat-Systeme, ob der Benutzer /whisper oder /team eingegeben hat, und senden das fertiggestellte Nachricht an die entsprechenden Benutzer.

Ein benutzerdefinierter Zustand sollte mit den folgenden Funktionen auf der Tabelle sein:

• TextUpdated() — Aufgerufen, wenn der Text in der Eingabefeld geändert wird.
• GetMessage() — Aufrufen, nachdem der Benutzer die Nachricht eingegeben hat und auf Enter klickt. Diese Funktion sollte eine Stringzurückgeben.
• ProcessCompletedMessage() — Wird als das Messter wird verarbeitet. Ein benutzerdefinierter Zustandsprozessor wird immer ausgeführt, bevor die abgeschickten Nachrichten verarbeitet werden. Wie andere Prozessoren sollte diese Funktion immer wahr zurückkehren, wenn die Nachricht nicht mehr gesendet wird, sonst sollte sie immer falsch zurückkehren.
• Destroy() — Aufgerufen, nachdem die Nachricht gesendet wurde. Sol sollte verwendet werden, um alles aufzuräumen, was vom benutzerdefinierten Zustand eingerichtet wurde.

Um einen benutzerdefinierten Zustand zu verwenden, muss die ProcessMessage() Funktion des Befehlsmoduls den Zustand zurückgeben. Ein grundlegender benutzerdefinierter Zustand würde die folgende Form annehmen:

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
}

Ein der Hauptvorteile der Verwendung eines benutzerdefinierten Zustands ist, dass ein Modul die Chat-Bar und ihren Inhalt anzeigen und Text enthalten kann, während der Benutzer sowohl in Bezug auf die Funktion als auch auf das Aussehen tippt, und dann leicht zurückgesetzt werden kann (einmal gesendete Nachrichten werden automatisch entfernt und alles zurückgesetzt). Zum Be

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
}

Wie oben erwähnt, wird ein benutzerdefinierter Zustand, sobald eine Nachricht gesendet wird, entfernt, und der Chat wird auf die Standardzustands-Chat-Chat zurückgesetzt. Wenn es erforderlich ist, um einen benutzerdefinierten Zustand vor dem Senden der Nachricht zurückzusetzen, kann der Zustand mit ChatBar:ResetCustomState() zurückgesetzt werden. Beachten Sie, dass dies auch den Fokus aus der Chat-Textbox entfernt.

Nachrichten-Creator-Module

Ein weiterer Modultyp, der im Client-Komponenten verwendet werden kann, ist ein Nachrichten-Ersteller-Modul -Modul. Dieser Modultyp wird verwendet, um die GUI-Elemente im Chat-Fenster anzuzeigen, um die Nachricht anzuzeigen. Jeder Arten von Nachrichten-Ersteller definiert einen neuen eingeben, so dass verschiedene Nachrichten mit verschiedenen Formulierungen erstellt werden können. Darüber hinaus können GUI-Elemente zum Anzeigen von Nachricht

Diese Module erfordern die Konfiguration in mehreren Orten. Für jeden eingebenmuss ein ModuleScript in MessageCreatorModule sein. Darüber hinaus muss der Chat -Betreiber, der den neuen eingebenanbietet, in 1>ChatConstructModule1> bearbeitet werden, um den neuen eingebenzu enthalten. Zudem müssen Modul-Betre

Das folgende Beispiel wird durch die Erstellung eines Bots, der die Zeit alle 5 Sekunden sagt, und der Nachricht, die gesendet wird, mit einem roten Hintergrund gehen.

Um zu starten, muss der ChatCommands ModuleScript ein Feld für die neue Art von Nachricht hinzufügen.

-- Chat-Konstanten
local module = {}

--– [[Nachrichtenarten ]]
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

Der Bot selbst wird in einem neuen ChatModule auf dem Server erstellt. Beachten Sie, dass eine Filterfunktion verwendet wird, um dem neuen Nachrichtentyp die Nachrichten hinzuzufügen, die der Bot sendet.

-- Neues ModulScript wird in ChatModulen platziert
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

Schließlich muss ein Nachrichten-Ersteller-Modul erstellt werden. Dieses Modul muss ein Wörterbuch mit zwei Elementen zurückgeben: die Art der Nachricht, mit KEY_MESSAGE_TYPE , und die Funktion, die aufgerufen wird, wenn das Nachrichten-GUI-Element mit KEY_CREATOR_FUNCTION aufgerufen wird.

Die Funktion, die von KEY_CREATOR_FUNCTION gespeichert ist, muss ein Wörterbuch mit mehreren Komponenten zurückgeben. Zuerst muss es ein Frame und ein Class

-- neues ModulScript in der Nachrichten-Creator-Module
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)
	-- Erstellen Sie die GUI-Objekte für die Frame und TextLabel, um die Nachricht zu enthalten
	local BaseFrame, BaseMessage = util:CreateBaseMessage("", ChatSettings.DefaultFont, ChatSettings.ChatWindowTextSize, ChatSettings.DefaultMessageColor)

	-- Ändern Sie den Hintergrund des Frames zu rot
	BaseFrame.BackgroundColor3 = Color3.new(1,0,0)
	BaseFrame.BackgroundTransparency = 0

	-- Behandeln Sie die Aktualisierung des Platzhalter-Nachrichtentexts
	local function UpdateTextFunction(messageObject)
        if messageObject.IsFiltered then
		   BaseMessage.Text = messageObject.Message
        end
	end
	UpdateTextFunction(messageData)

	-- Verwenden Sie die Funktion util, um die Höhe des Rahmens zu bestimmen
	local function GetHeightFunction(xSize)
		return util:GetMessageHeight(BaseMessage, BaseFrame, xSize)
	end

	-- Erstellen Sie Verblasst-Funktionen, die aufgerufen werden, wenn das Chat-Fenster verblasst
	local FadeParameters = {}
	FadeParameters[BaseMessage] = {
		TextTransparency = {FadedIn = 0, FadedOut = 1},
		TextStrokeTransparency = {FadedIn = 0.75, FadedOut = 1}
	}
	local FadeInFunction, FadeOutFunction, UpdateAnimFunction = util:CreateFadeFunctions(FadeParameters)

	-- Kehre das Wörterbuch zurück, das die Beschriftungdefiniert
	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
}