Altes Chat-System

Hierarchie

Das veraltete Chat-System verwendet das Client-Server-Modell.Komponenten des Server-seitigen Chatmoduls ChatChannel und ChatSpeaker werden vom ChatService auf dem Server verwaltet, während der Client für die Eingabe und Anzeige von Nachrichten verantwortlich ist.Die Kommunikation zwischen dem Server und den Clients wird automatisch mit RemoteEvents verwaltet.

Der Chat Engine-Service selbst ist die wesentliche Speicherungseinheit für das Chat-System: Wenn ein Roblox-Ort geladen wird (entweder im Client oder in Studio beim Laufen oder Spielen), werden die folgenden Komponenten automatisch in den Chat Service geladen, wenn Chat.LoadDefaultChat wahr ist.

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

  • Befehlmodule — Enthält Module, die verwendet werden, um Client-seitige Chat-Befehle zu implementieren.
  • MessageCreatorModule — Enthält Module, die zur Bearbeitung und Formulierung von Nachrichten verwendet werden.
  • Chat\-Standards — Enthält Konstanten, die vom Server und Client geteilt werden.
  • ChatSettings — Speichert verschiedene Einstellungen, um verschiedene Aspekte des Chatfensters zu konfigurieren.
• ChatLocalization — Datenstruktur, die Textübersetzungen speichert.
• ChatServiceRunner — Dieser Script führt die Serverkomponente des Chats aus.Im Allgemeinen muss dies nicht modifiziert werden, um benutzerdefiniertes Chat-Verhalten und -Funktionalität zu erstellen.
• BubbleChat — Zeigt Benutzer-Chatnachrichten über ihren Avatar im Spiel an (wenn aktiviert).
• ChatScript — Dieses LocalScript führt die Clientkomponente des Chats aus.Wie ChatServiceRunner sollte dies nicht modifiziert werden müssen, um den Chat anzupassen.Wenn das Spiel ausgeführt wird, wird dies automatisch in die StarterPlayerScripts geklont.

Modifizieren des Chat-Systems

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

1. Im Explorer-Fenster suchen Sie nach TextChatService .Dann, im Eigenschaften-Fenster, setze die ChatVersion -Eigenschaft auf LegacyChatService .

   

2. Führe das Erlebnis mit der Spiel -Taste aus (F5).

3. Wählen und kopieren ( CtrlC oder ⌘C ) die Objekte, die zu Chat hinzugefügt werden.

   

4. Stoppe das Erlebnis mit der Schaltfläche Stopp ( ShiftF5 ).

5. Wählen Sie Chat und paste into ( CtrlShiftV oder ⌘ShiftV ) die kopierten Objekte (sie müssen zu Chat als sie während der Erfahrung liefen übernommen werden).

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

Chat-Workflow

Bevor du Module erstellst, um den Chat anzupassen, ist es wichtig, den Workflow zu verstehen, durch den eine Chatnachricht geht.Neben dem Versenden von Textnachrichten gibt es verschiedene Befehle, die in das Chat-System eingebaut sind, sodass jede Nachricht überprüft werden muss, um zu sehen, ob sie als Befehl oder nur als Textnachricht interpretiert werden muss.Sogar Textnachrichten können im Prozess modifiziert und gefiltert werden.

Nachdem ein Benutzer den Fokus auf die Chat-Eingabe gelegt und einen Charakter eingegeben hat, werden sofort mehrere Überprüfungen auf dem Client durchgeführt.Wenn der Charakter Esc ist, schließt sich die Eingabebox und es werden keine Aktionen ausgeführt.Wenn der Charakter etwas anderes als Enter ist, wird der Text durch In-Progress-Befehlsverarbeiter durchlaufen.Diese werden verwendet, um den Text zu bewerten, um zu sehen, ob eine Aktion erforderlich ist.Zum Beispiel, wenn ein Benutzer mit dem /whisper-Befehl flüstern beginnt, sobald ein Benutzername nach dem Befehl eingegeben wurde, ändert sich die Eingabebox, um anzuzeigen, dass der Benutzer sich jetzt in einem Kanalbefindet.

Auf der Client-Seite des Chats gibt es zwei Arten von Prozessoren: Im Gange und Abgeschlossen.Die erste wird ausgeführt, nachdem jeder Zeichen eingegeben wurde, während die letztere nur ausgeführt wird, wenn der Benutzer fertig mit dem Eingeben von Zeichen ist und Enter erreicht hat.

Wenn der Benutzer mit dem Tippen fertig ist und auf Enter den Text trifft, wird seine Eingabe durch mehrere weitere Befehlverarbeiter gesendet.Wenn ein In-Progress-Befehl einen benutzerdefinierten Chat-Zustand erstellt hat, überprüft der Chat den Zustand, um zu sehen, ob ein letzter Befehl ausgeführt werden soll und ob die Nachricht fortgesetzt werden soll.Wenn die Nachricht fortgesetzt werden darf, wird der Text durch eine weitere Reihe von Prozessoren namens Abgeschlossene Prozessoren gesendet.Wenn einer dieser Prozessoren true zurückgibt, wird die Nachricht nicht mehr gesendet.Ansonsten wird die Nachricht an den Server gesendet.

Sobald die Nachricht dem Server erreicht, geht sie durch eine weitere Reihe von Befehlverarbeitern.Genau wie die Abgeschlossenen Prozessoren auf dem Client, wenn einer dieser Prozessoren true zurückgibt, stoppt die Nachricht die Ausführung.Ansonsten wird die Nachricht durch eine Reihe von Filtern geleitet (einschließlich des Standard-Roblox-Chat-Filters).Sobald all dies erledigt ist, wird die Nachricht an alle Kanäle und geeignete Sprecher gesendet.

Server-Module

Module, die in ChatModule platziert werden, können für eine Vielzahl von Zwecken verwendet werden.Diese Module können verwendet werden, um Chat-Kanäle und Lautsprecher zu verwalten, Filter- und Befehl-Funktionen hinzuzufügen, Chatbots auszuführen oder alles andere, was auf dem Server bearbeitet werden muss.Um mit dem Chat-System zu interagieren, wird jedem Modul ein ChatService-Objekt übergeben.

Wenn der ChatServiceRunner startet, benötigt er jedes Modul innerhalb von ChatModule .Es erwartet, dass jedes Modul eine Funktion zurückgibt, wenn es dann jedes der Module nacheinander aufruft, indem es sein ChatService-Objekt an jede Funktion übermittelt.Unabhängig davon, was das Modul tun soll (einen Bot ausführen, eine Filterfunktion hinzufügen usw.), muss es dieser Form folgen, um zu arbeiten.

Beispielmodul-Framework
local function Run(ChatService)
	-- Code geht hier
end

return Run

Kanäle hinzufügen

Eines der einfachsten Dinge, die ein Chatmodul tun kann, ist die Verwaltung von Kanälen .Kanalobjekte können mit der AddChannel() -Methode von ChatService erstellt werden.Beachte, dass das Kanalobjekt nur verwendet werden muss, wenn Mitglieder dieses Kanals aufgerufen werden (z. B. seine Eigenschaften und Funktionen).Wenn auf Kanäle aus dem Kontext von ChatService oder ChatSpeakers verwiesen wird, wird der Name des Kanals verwendet, um auf ihn zu verweisen.

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

return Run

Grundkanal-Konfiguration

Kanäle haben mehrere Eigenschaften, mit denen sie leicht modifiziert werden können.Dieses Modul erstellt zum Beispiel einen Kanal und legt die Begrüßungsnachricht fest und veranlasst Benutzer, automatisch dem Kanal beizutreten, wenn sie die Erlebnisbetreten.

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

-- Legen Sie die Nachricht fest, 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

Kanalereignisse

Kanäle haben mehrere Ereignisse, die abonniert werden können.Diese Ereignisse werden ausgelöst, wenn eine Chatnachricht in den Kanal gepostet wird, wenn ein Chat-Lautsprecher verlässt oder beitritt oder wenn ein Lautsprecher stummgeschaltet oder entstummt wird.Zum Beispiel wird dieses Modul einen Kanal mit dem Namen MyChannel erstellen.Wann immer ein Sprecher dem Kanal beitritt oder ihn verlässt, wird eine Systemnachricht an alle Sprecher im Kanal gesendet, die sie über das Ereignis informiert.

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

Befehl-Funktionen

Eine weitere mächtige Sache, die ChatModule machen können, sind Chat Befehle .Wenn eine Nachricht an den Server gesendet wird, sendet der Chat die Nachricht über jede Befehl-Funktion, die für den ChatService und den relevanten Kanal registriert wurde.Diese Funktionen werden dem Lautsprecher, der Nachricht und dem Kanal gesendet, an den die Nachricht gesendet wird.Die Funktion kann jede Aktion ausführen, die sie benötigt, und dann wahr oder falsch zurückgeben.Wenn die Funktion true zurückgibt, wird die Nachricht vom Chat-System nicht mehr verarbeitet.Es wird nicht an weitere Befehlsfunktionen gesendet oder im Chat-Fenster angezeigt.Wenn die Funktion false zurückgibt, geht die Nachricht durch alle anderen Befehl-Funktionen weiter.Wenn keine der Befehlsfunktionen true zurückgibt, wird die Nachricht dann durch Filter geschickt und dann angezeigt.

Befehl-Funktionen werden oft verwendet, um Admin-Befehle umzusetzen, die Textbefehle sind, die bestimmte Benutzer verwenden können, um den Erfahrungsstatus durch bestimmten Text im Chat zu manipulieren.

In diesem Beispiel wird ein Chatmodul verwendet, um ein Part zu erstellen, wenn ein Benutzer /part im Chat eingibt.Beachten Sie, dass diese Funktion true zurückgibt, wenn ein Teil erstellt wurde, das die Nachricht stoppt und keine Nachricht angezeigt wird.Wenn ein Teil nicht erstellt wird, muss diese Funktion false zurückgeben, damit die Nachricht weiter durch das System arbeiten kann.

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

Sowohl Chat-Kanäle als auch ChatService selbst können Chat-Befehle haben. ChatService -Befehlverarbeiter laufen auf jeder Nachricht, die an den Server gesendet wird, während Kanalbefehle nur ausgeführt werden, wenn die Nachricht an den Kanal gesendet wurde, auf den der Befehl registriert ist.

Filterfunktionen

Nachrichten, die nicht durch eine Befehl-Funktion gestoppt werden, gehen durch alle Filterfunktionen, die für den ChatService und die relevanten Kanäle registriert sind.Jede Filterfunktion wird dem Lautsprecher, der Nachricht-Objekt und der Kanalname übergeben.Alle Änderungen am Nachrichtenobjekt bleiben bestehen, und jede nachfolgende Filterfunktion sieht die aktualisierte Nachricht.Beachten Sie, dass Filterfunktionen keinen Wert zurückgeben müssen.

In diesem Beispiel wird eine einfache Filterfunktion registriert, um jede Nachricht in Großbuchstaben zu erscheinen zu lassen.

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 platziert werden, können verwendet werden, um benutzerdefiniertes Verhalten für Clients zu erstellen.Diese Module sind in zwei verschiedene Ordner unterteilt: Befehl-Module und Nachrichten-Ersteller-Module.

Befehl-Module

Befehl-Module arbeiten sehr ähnlich wie Module auf dem Server, die Befehl-Funktionen registrieren.Diese Module definieren Funktionen, die nachdem der Benutzer Text eingegeben hat, abgefeuert werden.Dieser Text kann gelesen werden, und das Kommando kann entweder die Nachricht zum Server durchlassen oder den Fortschritt der Nachricht stoppen.Befehle, die am Ende der Nachricht ausgeführt werden, werden mit COMPLETED_MESSAGE_PROCESSOR markiert, während Befehle, die nach jedem Zeichen ausgeführt werden, mit IN_PROGRESS_MESSAGE_PROCESSOR markiert werden.

In beiden Arten von Befehlen muss das Modul eine Diktion zurückgeben, die sagt, welche Art von Prozessor der Befehl verwenden soll und welche Funktion ausgeführt werden soll, wenn der Prozessor aufgerufen wird.Zum Beispiel sollte ein abgeschlossener Nachrichtenprozessor 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 Enumeration im Util Inneren der CommandModule Ordner definiert ist.

Abgeschlossene Nachrichtenbefehle

Abgeschlossene Nachrichtenbefehle werden bewertet, wenn der Benutzer fertig mit der Eingabe ist und auf Enter getippt hat.Die Funktion des Prozessors wird dem ChatMessage-Objekt, dem ChatWindow des Clients und der ChatSettings-Tabelle übergeben.Wenn die Funktion true zurückgibt, wird die Nachricht nicht mehr verarbeitet und wird nicht an den Server gesendet.Ansonsten wird es durch alle anderen Prozessoren geschickt und schließlich an den Server, wenn keiner der anderen Prozessoren es stoppt.

Zum Beispiel wird der folgende Prozessor die älteste Nachricht im aktuellen Kanal entfernen, 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
}

Laufende Befehle

Laufende Befehle werden jedes Mal bewertet, wenn ein Benutzer einen Zeichen in die Chat-Eingabe eingibt.Zum Beispiel spielt der folgende Code einen Clack nach jedem Tastendruck, um es so zu klingen lassen, als würde der Benutzer auf einer Schreibmaschine tippen:

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
}

Fortgeschrittene Befehle werden oft verwendet, um einen benutzerdefinierten Zustand für den Chat zu erstellen, der Nachrichten an bestimmte Benutzer sendet, anstatt nur an den aktuellen Kanal.Zum Beispiel überprüfen die Whisper- und Team-Chat-Systeme, ob der Benutzer /whisper oder /team jeweils eingegeben hat, und senden die fertige Nachricht nur an die entsprechenden Benutzer.

Es wird erwartet, dass ein benutzerdefinierter Zustand Tabelle mit den folgenden Funktionen ist:

• TextUpdated() — Aufgerufen, wenn sich der Text in der Eingabebox ändert.
• GetMessage() — Aufgerufen, nachdem der Benutzer die Nachricht eingegeben und Enter getroffen hat. Diese Funktion wird erwartet, eine Stringzurückzugeben.
• ProcessCompletedMessage() — Aufgerufen, wenn die Nachricht verarbeitet wird.Ein benutzerdefinierter Zustandsprozessor wird immer vor den abgeschlossenen Nachrichtenprozessoren feuern.Wie andere Prozessoren sollte diese Funktion true zurückgeben, wenn die Nachricht aufhören sollte gesendet zu werden, sonst sollte sie false zurückgeben.
• Destroy() — Nach der Sende der Nachricht aufgerufen. Sollte verwendet werden, um alles zu löschen, was vom benutzerdefinierten Zustand konfiguriert wurde.

Um einen benutzerdefinierten Zustand zu verwenden, muss die ProcessMessage()-Funktion des Befehlmoduls den Zustand zurückgeben.Ein einfacher 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
}

Einer der Hauptvorteile der Verwendung eines benutzerdefinierten Zustands ist, dass ein Modul die Chatleiste und ihren enthaltenen Text bearbeiten kann, während der Benutzer beide in Bezug auf Funktion und Aussehen eingibt, und danach leicht zurücksetzt ( sobald eine Nachricht gesendet wird, wird ein benutzerdefinierter Zustand automatisch entfernt und alles wird auf normale Weise zurückgesetzt).Zum Beispiel legt dieser Code einen benutzerdefinierten Zustand fest, der nur 20 Zeichen zeigt, die gleichzeitig in der Textbox angezeigt werden können.Wenn der Benutzer weiterhin tippt, werden Zeichen am Beginn der Zeichenkette vorübergehend entfernt.Wenn der Benutzer die Nachricht sendet, werden alle entfernten Zeichen wieder in die Nachricht eingefügt.

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 bereits erwähnt, wird einmal, wenn eine Nachricht gesendet wurde, jeder benutzerdefinierte Zustand entfernt und der Chat auf normale Weise wiederhergestellt.Wenn es erforderlich ist, einen benutzerdefinierten Zustand vor dem Versenden der Nachricht zurückzusetzen, kann der Zustand mit ChatBar:ResetCustomState() zurückgesetzt werden.Beachten Sie, dass dies auch den Fokus aus der Textbox der Chatleiste entfernt.

Nachrichtenersteller-Module

Eine andere Art von Modul, die im Client-Komponent verwendet werden kann, ist ein Nachrichtenersteller -Modul.Dieser Typ von Modul wird verwendet, um die GUI-Elemente im Chat-Fenster zu erstellen, um die Nachricht anzuzeigen.Jeder Typ von Nachrichtenersteller definiert einen neuen eingeben, so dass verschiedene Nachrichten mit unterschiedlicher Formatierung erstellt werden können.Darüber hinaus können GUI-Elemente auf diese Weise zum Anzeigen von Nachrichten hinzugefügt werden, was Bilder, Schaltflächen und mehr ermöglicht.

Diese Module müssen in mehreren verschiedenen Orten eingerichtet werden.Für jede eingebenmuss es ein ModuleScript innerhalb von MessageCreatorModule geben.Außerdem müssen die Chatฌisten ModuleScript bearbeitet werden, um den neuen eingebeneinzuschließen.Zuletzt werden Module nur verwendet, wenn eine Serverkomponente von Chat eine neue Nachricht mit dem angegebenen eingebenerstellt.

Das folgende Beispiel geht durch die Erstellung eines Bots, der die Zeit alle 5 Sekunden sagt, und die Nachricht, die gesendet wird, erhält einen roten Hintergrund.

Um zu starten, müssen die ChatConstants ModuleScript ein Feld für die neue Art von Nachricht hinzufügen.

-- ChatConstants
local module = {}

--[[Nachrichtentypen]]
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 Chatmodul auf dem Server erstellt.Beachte, dass eine Filterfunktion verwendet wird, um den neuen Nachrichtentyp zu den Nachrichten hinzuzufügen, die der Bot sendet.

-- Neues Modulskript, das in ChatModule platziert werden soll
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

Zuletzt muss ein Modul zum Nachrichtenersteller erstellt werden.Dieses Modul muss ein Wörterbuch mit zwei Elementen zurückgeben: die Art der Nachricht, indexiert mit KEY_MESSAGE_TYPE , und die Funktion, die beim Erstellen von Nachricht-GUI-Elementen aufgerufen wird, indexiert mit KEY_CREATOR_FUNCTION .

Die von KEY_CREATOR_FUNCTION gespeicherte Funktion muss ein Wörterbuch mit mehreren Komponenten zurückgeben.Zuerst muss es eine Frame und TextLabel enthalten, die im Chat-Fenster angezeigt werden.Diese können mit der Funktion util:CreateBaseMessage() erstellt werden.Das Wörterbuch muss auch eine Funktion enthalten, die ausgeführt wird, wenn der Text der Nachricht aktualisiert wird.Wenn Nachrichten zum ersten Mal im Client erscheinen, haben sie leeren Platzhaltertext, während die Nachricht verarbeitet und gefiltert wird, so müssen Nachrichtenobjekte wie diese handhaben, was passiert, wenn sie einen Anruf zum Aktualisieren erhalten.Als Nächstes muss das Wörterbuch eine Funktion enthalten, um die Höhe des Rahmens zu bestimmen.Diese Funktion ruft oft die Funktion util:GetMessageHeight() auf.Zuletzt muss das Wörterbuch mehrere Funktionen enthalten, die definieren, wie die Elemente verschwinden sollen, wenn das Fenster verschwindet (die Funktion für diese ist util:CreateFadeFunctions() ).

-- neues ModuleScript, das in MessageCreatorModules enthalten sein soll
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)
	-- Erstelle die GUI-Objekte für den Rahmen und das TextLabel, um die Nachricht zu halten
	local BaseFrame, BaseMessage = util:CreateBaseMessage("", ChatSettings.DefaultFont, ChatSettings.ChatWindowTextSize, ChatSettings.DefaultMessageColor)

	-- Ändere den Hintergrund des Rahmens auf rot
	BaseFrame.BackgroundColor3 = Color3.new(1,0,0)
	BaseFrame.BackgroundTransparency = 0

	-- Griff aktualisieren Platzhalter-Nachrichtentext
	local function UpdateTextFunction(messageObject)
        if messageObject.IsFiltered then
		   BaseMessage.Text = messageObject.Message
        end
	end
	UpdateTextFunction(messageData)

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

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

	-- Zurückgabe-Wörterbuch, das das 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
}