Sprachchat hinzufügen | Dokumentation

Sprachchat ist eine auf Nähe basierende Chat-Funktion, die realistische Kommunikation simuliert, indem die Lautstärke der spielenden Spieler angepasst wird, während sie sich näher oder weiter voneinander im 3D-Raum bewegen. Indem Spieler mit ihren Mikrofonen miteinander reden können, sind sie in der Lage, in Echtzeit weltweit zu sozialisieren und zusammenzuarbeiten, um die Ziele deines Erlebnisses zu erreichen.

Mit der .rbxl-Datei Gingerbread Island - Sprachchat als Referenz zeigt dieses Tutorial, wie man verschiedene Formen des Sprachchats in dein Gameplay integriert, einschließlich Anleitungen zu:

Spieler in Teams einzuteilen, die nur mit ihren Teamkollegen über Sprachchat kommunizieren können.
Spielern zu erlauben, ihr Mikrofon vorübergehend zu aktivieren, während sie eine bestimmte Taste auf ihrem Gerät gedrückt halten.
Zeiträume zu konfigurieren, in denen Sprachchat entweder aktiviert oder deaktiviert ist.

Wenn du die folgenden Abschnitte zusammen mit dem Beispiel durchgehst, kannst du jeden Codeabschnitt anpassen, um besser auf die Bedürfnisse deines eigenen Sprachchats einzugehen.

Der Sprachchat ist nur für Spieler verfügbar, die mindestens 13 Jahre alt sind und ihr Konto entweder über eine Telefonnummer oder einen von der Regierung ausgestellten Ausweis verifiziert haben, abhängig von ihrem Land. Für eine vollständige Liste der Verifizierungsanforderungen für Länder siehe Sprachchat.

Einstellungen konfigurieren

Damit Team-Chat, Push-to-Chat oder zeitbasierter Chat ordnungsgemäß funktioniert, musst du deine Sprachchat-Einrichtung konfigurieren, um Sprachchat zu aktivieren und die erforderlichen Audioobjekte zu erstellen, die notwendig sind, um Audio innerhalb der 3D-Umgebung aufzunehmen und auszugeben.

Wenn Spieler deinem Erlebnis beitreten, wird deine Sprachchat-Einrichtung jetzt:

Erlaubt es sprachberechtigten Spielern, ihre Mikrofone zu nutzen.
Erstellt und verknüpft ein AudioDeviceInput-Objekt unter jedem sprachberechtigten Player-Objekt.
Erstellt und verknüpft ein AudioEmitter-Objekt unter jedem sprachberechtigten Player.Character.
Erstellt und verknüpft ein AudioListener unter der Workspace.CurrentCamera.

Die folgenden Abschnitte erläutern drei einzigartige Sprachchat-Konfigurationen unter Verwendung dieser Einstellungen. Während du mit der Beispiel-Datei Gingerbread Island - Sprachchat arbeitest, kannst du das entsprechende deaktivierte Skript im Explorer-Fenster aktivieren, um deren Verhalten zu testen. Um sicherzustellen, dass jede davon richtig funktioniert, stelle sicher, dass das Skript wieder deaktiviert wird, bevor du zur nächsten Konfiguration übergehst.

Deaktivierte Skripte im Explorer-Fenster

Team-Chat hinzufügen

Team-Chat ist eine Sprachchat-Konfiguration, in der nur Spieler im selben Team miteinander sprechen oder sich gegenseitig hören können. Die Integration von Team-Chat in dein Gameplay ist nützlich, wenn du möchtest, dass Spieler zusammenarbeiten und Strategien entwickeln, um Probleme innerhalb des Erlebnisses zu lösen, wie z.B. Informationen zu den Positionen des gegnerischen Teams, Ressourcen und Aufgaben abzustimmen.

Um den Team-Sprachchat in der Beispiel-Datei Gingerbread Island - Sprachchat nachzustellen:

Füge im Explorer-Fenster ein Skript in ServerScriptService ein.

Benenne das Skript in TeamChat um und füge den folgenden Code in das Skript ein:


local Teams = game:GetService("Teams")
local Players = game:GetService("Players")

local redTeam = Instance.new("Team", Teams)
redTeam.TeamColor = BrickColor.new("Bright red")
redTeam.AutoAssignable = true
redTeam.Name = "Rotes Team"

local blueTeam = Instance.new("Team", Teams)
blueTeam.TeamColor = BrickColor.new("Bright blue")
blueTeam.AutoAssignable = true
blueTeam.Name = "Blaues Team"

local function getUserIds(team : Team) : {number}
    local userIds = {}
    for _, player : Player in team:GetPlayers() do
 	   table.insert(userIds, player.UserId)
    end
    return userIds
end

local function getDevices(team : Team) : {AudioDeviceInput}
    local devices = {}
    for _, player : Player in team:GetPlayers() do
 	   local device : AudioDeviceInput = player:FindFirstChild("AudioDeviceInput")
 	   if not device then
 		   continue
 	   end
 	   table.insert(devices, device)
    end
    return devices
end

local function updateTeam(team : Team)
    local users = getUserIds(team)
    for _, device in getDevices(team) do
 	   device.AccessType = Enum.AccessModifierType.Allow
 	   device:SetUserIdAccessList(users)
    end
end

local function onDeviceAdded(device : AudioDeviceInput)
    local player : Player = device.Parent
    if player.Team then
 	   updateTeam(player.Team)
    end
end

local function onPlayerAdded(player : Player)
    local device = player:FindFirstChild("AudioDeviceInput")
    if device then
 	   onDeviceAdded(device)
    end
    player.ChildAdded:Connect(function(child)
 	   if child.Name == "AudioDeviceInput" then
 		   onDeviceAdded(child)
 	   end
    end)
end

updateTeam(blueTeam)
updateTeam(redTeam)

for _, player in Players:GetPlayers() do
    onPlayerAdded(player)
end

Players.PlayerAdded:Connect(onPlayerAdded)
blueTeam.PlayerAdded:Connect(function() updateTeam(blueTeam) end)
blueTeam.PlayerRemoved:Connect(function() updateTeam(blueTeam) end)
redTeam.PlayerAdded:Connect(function() updateTeam(redTeam) end)
redTeam.PlayerRemoved:Connect(function() updateTeam(redTeam) end)

Code-Erklärung

Das Skript beginnt damit, die Teams und Players Dienste zu erhalten, damit es deren Funktionen nutzen kann, um Spieler in Teams zu sortieren, sobald sie dem Erlebnis beitreten. Zum Beispiel, ohne zusätzliche Skriptanstrengungen, übernimmt der Teams-Dienst Aktionen wie:

Spieler gleichmäßig in jedes Team zu sortieren und auszugleichen.
Spieler unter ihrem Team auf der Rangliste zu gruppieren.
Die Spielernamen im 3D-Raum in der entsprechenden Teamfarbe zu färben.

Mithilfe dieses Dienstes erstellt das Skript zwei verschiedene Team Objekte mit unterschiedlichen Color Eigenschaften, um jedes Team zu repräsentieren: leuchtend rot für ein Team und leuchtend blau für das andere.

Das Skript definiert dann drei Funktionen, in denen der Großteil der Arbeit für die Einrichtung der Team-Sprachchat-Konfiguration erfolgt:

getUserIds - Gibt ein Array von Benutzer-IDs für alle Spieler in einem Team zurück.
getDevices - Gibt ein Array von AudioDeviceInput-Objekten für alle Spieler in einem Team zurück. Jedes Class.AudioDeviceInput-Objekt repräsentiert das physische Mikrofon eines Spielers in der realen Welt.
updateTeam - Ruft alle Benutzer-IDs von getUserIds ab, durchläuft die AudioDeviceInput-Objekte von getDevices, setzt ihre Enum.AccessModifierType-Eigenschaft auf Allow, sodass nur die Benutzer-IDs jedes Teams berechtigt sind, die Mikrofone ihrer Teamkollegen zu hören, und aktualisiert dann die SetUserIdAccessList mit den Benutzer-IDs des Teams.

Der Rest des Skripts steuert, wie diese Funktionen und Ereignis-Listener zusammenarbeiten:

Wenn ein neuer Spieler dem Erlebnis beitritt, überprüft das Skript, ob der Spieler ein Mikrofon hat, und aktualisiert ihr Team.
Wenn das Skript ein neues AudioDeviceInput-Objekt erkennt, ruft es updateTeam für das jeweilige rote oder blaue Team auf.
Während Spieler dem Erlebnis beitreten oder es verlassen, verbindet sich das Skript mit den Ereignissen PlayerAdded und PlayerRemoved, um die Einstellungen jedes Teams zu aktualisieren.

Teste das Erlebnis mit ein paar Freunden, um zu überprüfen, dass Teamkollegen nur über Sprachchat miteinander hören können.

Push-to-Chat hinzufügen

Push-to-Chat ist eine Sprachchat-Konfiguration, bei der Spieler nur in der Lage sind, ihr Mikrofon innerhalb eines Erlebnisses zu aktivieren, während sie eine bestimmte Taste auf ihrem Gerät gedrückt halten. Die Integration von Push-to-Chat in dein Gameplay ist nützlich, wenn du möchtest, dass Spieler mehr Privatsphäre und Kontrolle darüber haben, wann sie über andere Spieler und Umgebungsgeräusche gehört werden wollen.

Um den Push-to-Voice-Chat in der Beispiel-Datei Gingerbread Island - Sprachchat nachzustellen:

Füge im Explorer-Fenster ein Skript in ReplicatedStorage ein.
Setze im Eigenschaften-Fenster RunContext auf Client, damit das Skript nur das Mikrofon des lokalen Spielers steuert.

Benenne das Skript in PushToChat um und füge den folgenden Code in das Skript ein:


local Players = game:GetService("Players")
local UserInputService = game:GetService("UserInputService")

local audioIn: AudioDeviceInput = Players.LocalPlayer:WaitForChild("AudioDeviceInput")
local pushToTalkKey = Enum.KeyCode.V

audioIn.Muted = true

UserInputService.InputBegan:Connect(function(input: InputObject)
    if input.KeyCode == pushToTalkKey then
        audioIn.Muted = false
    end
end)

UserInputService.InputEnded:Connect(function(input: InputObject)
    if input.KeyCode == pushToTalkKey then
        audioIn.Muted = true
    end
end)

Code-Erklärung

Das Skript beginnt damit,:

Den Players-Dienst zu erhalten, sodass es auf alle Spieler innerhalb des Erlebnisses verweisen kann.
Den UserInputService-Dienst zu erhalten, damit es überprüfen kann, wann ein Spieler die Tasten auf ihrem Gerät drückt.
Das AudioDeviceInput-Objekt des lokalen Spielers, oder das physische Mikrofon auf ihrem Gerät.

Das Skript dann:

Setzt die V-Taste als die Taste, die der Spieler gedrückt halten muss, um in ihr Mikrofon zu sprechen.
Stummt das Mikrofon des Spielers.

Der Rest des Skripts richtet zwei Ereignis-Listener für InputBegan und InputEnded aus UserInputService ein. Wenn sie die V-Taste gedrückt halten, hebt das Ereignis InputBegan die Stummschaltung des Mikrofons des Spielers auf, und wenn sie die V-Taste loslassen, mute das Ereignis InputEnded ihr Mikrofon erneut.

Teste das Erlebnis, um zu überprüfen, dass Spieler einander nur über Sprachchat hören können, wenn sie die V-Taste drücken.

Zeitbasierten Chat hinzufügen

Zeitbasierter Chat ist eine Sprachchat-Konfiguration, bei der Spieler nur während eines festgelegten Zeitraums sprechen und einander hören können. Die Integration von zeitbasiertem Chat in dein Gameplay ist nützlich, wenn du möchtest, dass die Spieler sorgfältig planen, wie sie während spezifischer Phasen miteinander kommunizieren, z.B. während rundenbasierter Diskussionen oder nach Zwischensequenzen.

Um den zeitbasierten Sprachchat in der Beispiel-Datei Gingerbread Island - Sprachchat nachzustellen:

Füge im Explorer-Fenster ein Skript in ServerScriptService ein.

Benenne das Skript in TimeBasedChat um und füge den folgenden Code in das Skript ein:


local Players = game:GetService("Players")
local muteAll = false

local function toggleMuteAll()
    muteAll = not muteAll
    for _, player in Players:GetPlayers() do
 	   local device : AudioDeviceInput = player:FindFirstChild("AudioDeviceInput")
 	   if not device then
 		   continue
 	   end
 	   device.Muted = muteAll
    end
end

while true do
    task.wait(15) -- alle 15 Sekunden
    toggleMuteAll() -- entweder dürfen die Leute sprechen oder werden daran gehindert
end

Code-Erklärung

Dieses Skript beginnt damit, den Players-Dienst zu erhalten, damit es auf seine Funktionalität zugreifen kann, um alle Spieler im Erlebnis zu verwalten. Es setzt dann ein Flag muteAll auf false, das die folgende Funktion toggleMuteAll verwendet, um den Sprachchat ein- und auszuschalten.

Lassen Sie uns die Funktion toggleMuteAll überprüfen:

Es beginnt damit, über alle Spieler im Erlebnis zu iterieren, indem es Players.GetPlayers verwendet.
Für jeden Spieler überprüft es, ob er ein Kindobjekt AudioDeviceInput, oder physisches Mikrofon auf ihrem Gerät hat.
Wenn sie dies tun, setzt die Funktion die AudioDeviceInput-Objekt-Eigenschaft Muted auf den Wert von muteAll. Zum Beispiel, wenn muteAll true ist, wird das Mikrofon des Spielers deaktiviert, und wenn muteAll false ist, wird das Mikrofon des Spielers aktiviert.

Das Skript tritt dann in eine Endlosschleife ein, die 15 Sekunden wartet, um alle AudioDeviceInput-Objekte stumm zu schalten und wieder zu aktivieren.

Teste das Erlebnis, um zu überprüfen, dass Spieler einander über Sprachchat nur in 15-Sekunden-Intervalle hören können.