Panoramica della chat di testo

Roblox offre messaggi di testo tra i giocatori nelle sessioni dal vivo attraverso TextChatService .Questo servizio ha la sua funzionalità standard, ma fornisce anche un insieme di metodi e eventi per estendere e personalizzare la chat, come la consegna di messaggi in base a requisiti personalizzati , l'aggiunta di permessi speciali o moderazione a giocatori specifici e la creazione di comandi personalizzati per eseguire azioni specifiche.

Le seguenti sezioni riassumono le classi e le istanze primarie che puoi utilizzare per personalizzare il sistema di chat.

Configurazione di alto livello

La classe singleton TextChatService è responsabile della gestione del sistema di chat generale, inclusa la filtrazione, la moderazione e le autorizzazioni degli utenti.Usa proprietà come CreateDefaultTextChannels e CreateDefaultCommands per abilitare o disabilitare i canali e i comandi di chat predefiniti.

Configurazione UI predefinita

TextChatService fornisce un'interfaccia utente predefinita che può essere personalizzata per soddisfare le esigenze della tua esperienza.Ognuna di queste configurazioni può essere disabilitata per nascondere l'elemento UI associato e può essere sostituita con interfacce personalizzate se desiderato.

• ChatWindowConfiguration — Rappresenta l'interfaccia utente della finestra di chat predefinita, inclusa la sua apparenza e il suo comportamento. Disabilitalo per nascondere la finestra di chat.
• ChatInputBarConfiguration — Rappresenta l'interfaccia utente della barra di input di chat predefinita, inclusa la sua apparenza e il suo comportamento.
• BubbleChatConfiguration — Rappresenta l'interfaccia utente predefinita di bubble chat, inclusa la sua apparenza e il suo comportamento.

Canali, messaggi e comandi

• TextChannel — Rappresenta un canale di chat di testo che passa i messaggi di chat inviati dall'utente dal client al server, che li visualizza poi ad altri utenti in base alle autorizzazioni.Queste istanze devono essere genitori di TextChatService per funzionare.

  Se TextChatService.CreateDefaultTextChannels è impostato su true , il servizio crea automaticamente due canali di testo, RBXGeneral e RBXSystem .Puoi creare manualmente ulteriori TextChannel istanze e affidarle a TextChatService , così come.

• TextSource — Rappresenta un utente in un TextChannel .Queste istanze sono direttamente parented alla TextChannel quando AddUserAsync() viene chiamata.Le fonti di testo contengono permessi dettagliati di un utente nel canale, come la loro capacità di inviare messaggi.Un singolo utente può essere associato a più fonti di testo se sono state aggiunte a più canali di testo.

• TextChatMessage — Rappresenta un singolo messaggio di chat in un canale di testo, con informazioni di base come il mittente del messaggio, il messaggio originale, il messaggio filtrato e il timestamp di creazione.

• TextChatCommand — Consente agli utenti di invocare azioni o comportamenti specifici inviando messaggi che corrispondono a PrimaryAlias o SecondaryAlias .Queste istanze devono essere genitori di TextChatService per funzionare.

  Se TextChatService.CreateDefaultCommands è impostato su true, i comandi di chat predefiniti verranno creati automaticamente.Puoi creare manualmente ulteriori TextChatCommand istanze e affidarle a TextChatService , così pure.

Diagramma di flusso di chat

La chat di testo utilizza il modello client-server , con un cliente di invio , il server e clienti di ricezione .

1. Un giocatore invia un messaggio dal suo dispositivo locale, attivando il metodo TextChannel:SendAsync() .Questo metodo elabora il messaggio e determina se è un comando di chat o un messaggio di chat regolare.

   • Se il messaggio è un comando di chat, attiva l'evento TextChatCommand.Triggered per eseguire l'azione definita. Non sono necessari ulteriori passaggi.

   • Se il messaggio è un messaggio di chat regolare, attiva l'evento TextChatService.SendingMessage per visualizzare il messaggio al mittente sul client di invio.Allo stesso tempo, TextChannel:SendAsync() passa il messaggio al server.

2. Il server lancia TextChannel.ShouldDeliverCallback per determinare se consegnare il messaggio ad altri giocatori in base alle autorizzazioni e ai requisiti di filtraggio della comunità Roblox.

3. Se TextChannel.ShouldDeliverCallback determina che il messaggio è idoneo a essere consegnato ad altri giocatori, il server applica qualsiasi filtro e lancia TextChannel.OnIncomingMessage due volte:

   1. La prima volta è sul client di invio e segnala che il server sta elaborando il messaggio attraverso l'evento TextChatService.MessageReceived .Questo evento sostituisce il messaggio locale sul client di invio con il messaggio elaborato dal server.Il messaggio è identico se l'originale non richiedeva filtraggio.

   2. La seconda volta è sui client di ricezione, che attiva l'evento TextChatService.MessageReceived per visualizzare il messaggio ad altri giocatori.

Ganci e richiami di chat di testo

L'API TextChatService incoraggia una separazione chiara sull'aspetto e sulla consegna dei messaggi di chat.Numerose istanze del sistema di chat di testo forniscono ganci e richiami per formattare in luoghi centralizzati e chiari.

| Callback | Return Value | | ----------------------------------------- | ----------------------------------- | | | boolean | | | | | | | | | | | | | | | | |

Consegnare messaggi condizionalmente

Il richiamo TextChannel.ShouldDeliverCallback deve essere definito solo sul server.Il richiamo viene eseguito per ogni TextSource figlio del canale di testo quando viene inviato un messaggio per determinare se il messaggio debba essere consegnato.Questo callback può essere utilizzato per implementare una logica di consegna del messaggio personalizzata che può dipendere da un contesto di gioco aggiuntivo, come:

• Chat basata sulla vicinanza in cui gli utenti possono inviare messaggi solo a quelli vicini a loro.
• Prevenire gli utenti con determinati attributi di inviare messaggi ad altri.

Personalizza la visualizzazione del messaggio

L'interfaccia utente predefinita TextChatService dipende da testo ricco per formattare e personalizzare come vengono visualizzati i messaggi.Puoi usare i seguenti richiami per formattare i messaggi prima che vengano visualizzati agli utenti, ad esempio per aggiungere colori o tag di chat ai nomi degli utenti o per formattare il contenuto del messaggio.

I seguenti richiami vengono chiamati ogni TextChatMessage che è about to essere displayed, che ti consente di personalizzare l'aspetto della finestra di chat in base al contenuto TextChannel, TextSource o TextChatMessage.Quando un client invia un messaggio, questi richiami vengono chiamati una volta quando il messaggio viene inviato al server e il valore TextChatMessage.Status sarà Enum.TextChatMessageStatus.Sending.Una volta che il messaggio viene ricevuto dal server e viene consegnato ad altri utenti, il cliente mittente riceve nuovamente il messaggio con un valore aggiornato Enum.TextChatMessageStatus.

• TextChatService.OnIncomingMessage — Questo callback deve essere definito solo sul client.Il richiamo viene eseguito quando viene ricevuto un messaggio, dal server o se il client locale ha appena inviato un messaggio.Il richiamo viene eseguito ogni TextChatMessage ricevuto da tutte le TextChannel istanze e è il primo a elaborare il messaggio prima che venga visualizzato all'utente.
• TextChannel.OnIncomingMessage — Questo callback deve essere definito solo sul client.Il richiamo viene eseguito quando viene ricevuto un messaggio dal server.Il richiamo viene eseguito ogni TextChatMessage ricevuto dal TextChannel.Le istanze predefinite TextChannel create da TextChatService.CreateDefaultTextChannels hanno questo callback definito e possono essere sovrascritte.
• TextChatService.OnBubbleAdded — Questo callback deve essere definito solo sul client.Usa questo per personalizzare l'aspetto delle bolle di chat indipendentemente dall'aspetto del messaggio nella finestra di chat UI.
• TextChatService.OnChatWindowAdded — Questo callback deve essere definito solo sul client.Usa questo per personalizzare l'aspetto dei messaggi di chat nella finestra di chat indipendentemente dall'aspetto del messaggio nelle bolle di chat.

Migra dalla chat legacy

Questa sezione ti aiuta a migrare dal sistema di chat legacy fornendo metodi alternativi per implementare le comuni funzionalità e i comportamenti di chat utilizzando TextChatService .

1. Nella finestra Explorer, seleziona TextChatService.

2. Nella finestra Proprietà, trova il menu a discesa ChatVersion e seleziona TextChatService .

   

Funzionalità di base

Sebbene entrambi i sistemi condividano le stesse funzionalità di chat di base, le implementazioni TextChatService sono in generale più sostenibili e più facili da iterare.

Filtro messaggi

TextChatService filtra automaticamente i messaggi di chat in base alle informazioni sull'account di ciascun giocatore, quindi non è necessario implementare manualmente il filtraggio del testo per tutti i tipi di messaggi di chat.

Chat di finestre e bolle

Sia il comportamento e le opzioni di personalizzazione della finestra di chat e della chat a bolle sono identici a quelli del sistema di chat legacy.Poiché il sistema di chat legacy consente solo la personalizzazione utilizzando moduli di chat o il contenitore Players, il servizio fornisce classi dedicate ( ChatWindowConfiguration e BubbleChatConfiguration ) per gestire tutte le proprietà di chat window e bubble chat.Inoltre, puoi facilmente regolare e visualizzare le proprietà di apparizione e comportamento della chat della bolla usando le impostazioni di Studio invece di doverle scrivere tutte.

Migra il relatore "dati extra"

Il sistema di chat Lua legacy ha permesso agli sviluppatori di utilizzare SetExtraData sulla classe Speaker.Questi dati sono stati utilizzati per formattare il colore del nome, il colore della chat o per applicare etichette di nome per un oratore dato.

Set di dati extra del sistema di chat legacy SetExtraData
-- Un esempio di impostazione di dati supplementari su un oratore nel sistema di chat legacy
ChatService.SpeakerAdded:Connect(function(playerName)
	local speaker = ChatService:GetSpeaker(playerName)
	speaker:SetExtraData("NameColor", Color3.fromRGB(255, 255, 55))
	speaker:SetExtraData("ChatColor", Color3.fromRGB(212, 175, 55))
	speaker:SetExtraData("Tags", {{TagText = "YourTagName", TagColor = Color3.fromRGB(0, 255, 0)}, {TagText = "OtherTagName", TagColor = Color3.fromRGB(255, 0, 0)}})
end)

TextChatService non ha un equivalente diretto a SetExtraData.Invece, usa callback come OnWindowAdded per personalizzare l'aspetto dei messaggi utilizzando il testo ricco in base al TextSource del messaggio.

Il seguente è un esempio di emulazione dei "dati aggiuntivi" della chat Lua legacy accedendo agli attributi su Player oggetti:

TextChatService SetAttributes
local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	player:SetAttribute("NameColor", Color3.fromRGB(255, 255, 55))
	player:SetAttribute("ChatColor", Color3.fromRGB(212, 175, 55))
	player:SetAttribute("isYourTag", true)
	player:SetAttribute("isOtherTag", true)
end)

Quindi puoi usare il richiamo OnChatWindowAdded per personalizzare l'aspetto della finestra di chat in base agli attributi impostati sul giocatore:

TextChatService Aggiunto a OnChatWindow
local TextChatService = game:GetService("TextChatService")
local Players = game:GetService("Players")

TextChatService.OnChatWindowAdded = function(textChatMessage)
	local textSource = textChatMessage.TextSource
	if textSource then
		local player = Players:GetPlayerByUserId(textSource.UserId)
		if player then
			local overrideProperties = TextChatService.ChatWindowConfiguration:DeriveNewMessageProperties()
			overrideProperties.PrefixText = textChatMessage.PrefixText
			overrideProperties.Text = textChatMessage.Text

			local nameColor = player:GetAttribute("NameColor")
			if nameColor and typeof(nameColor) == "Color3" then
				overrideProperties.PrefixTextProperties.TextColor3 = nameColor
			end

			local chatColor = player:GetAttribute("ChatColor")
			if chatColor and typeof(chatColor) == "Color3" then
				overrideProperties.TextColor3 = chatColor
			end

			local isYourTag = player:GetAttribute("isYourTag")
			if isYourTag == true then
				overrideProperties.PrefixText = `<font color='rgb(0, 255, 0)'>[YourTag]</font> {overrideProperties.PrefixText}`
			end

			local isOtherTag = player:GetAttribute("isOtherTag")
			if isOtherTag == true then
				overrideProperties.PrefixText = `<font color='rgb(255, 0, 0)'>[OtherTag]</font> {overrideProperties.PrefixText}`
			end

			return overrideProperties
		end
	end

	return nil
end