Sprachchat hinzufügen

Sprachchat ist eine auf Nähe basierende Chat-Funktion, die realistische Kommunikation simuliert, indem sie die Lautstärke der sprechenden Spieler anpasst, während sie sich näher oder weiter voneinander im 3D-Raum bewegen. Indem Spieler mit ihren Mikrofonen miteinander sprechen, können sie in Echtzeit weltweit sozial interagieren und strategisieren, um die Ziele deines Spiels zu erreichen.

Anhand der Gingerbread Island - Sprachchat .rbxl-Datei als Referenz zeigt dieses Tutorial, wie du verschiedene Formen von Sprachchat in dein Gameplay integrieren kannst, einschließlich Anleitungen zu:

• Das Sortieren von Spielern in Teams, die nur mit ihren Teamkollegen Sprachchat nutzen können.
• Das vorübergehende Aktivieren des Mikrofons durch die Spieler, während sie eine bestimmte Taste auf ihrem Gerät drücken.
• Das Konfigurieren von Zeiträumen, in denen Sprachchat entweder aktiviert oder deaktiviert ist.

Während du die folgenden Abschnitte zusammen mit dem Beispiel durchgehst, kannst du jedes Codebeispiel anpassen, um besser auf die Anforderungen deines eigenen Sprachchats einzugehen.

Einstellungen konfigurieren

Damit Team-Chat, Push-to-Chat oder zeitbasierter Chat ordnungsgemäß funktionieren, musst du deine Sprachchat-Einrichtung konfigurieren, um Sprachchat zu aktivieren und die entsprechenden Audioobjekte zu erstellen, die notwendig sind, um Audio im 3D-Umfeld aufzunehmen und auszugeben.

Wenn Spieler deinem Spiel beitreten, wird deine Sprachchat-Einrichtung nun:

• Erlaubt es sprachberechtigten Spielern, ihre Mikrofone zu verwenden.
• Erstellt und fügt ein AudioDeviceInput-Objekt unter jedem sprachberechtigten Player-Objekt hinzu.
• Erstellt und fügt ein AudioEmitter-Objekt unter jedem sprachberechtigten Player.Character hinzu.
• Erstellt und fügt einen AudioListener unter der Workspace.CurrentCamera hinzu.

Die folgenden Abschnitte beschreiben drei einzigartige Sprachchat-Konfigurationen unter Verwendung dieser Einstellungen. Während du dem Beispiel Gingerbread Island - Sprachchat folgst, kannst du das entsprechende deaktivierte Skript im Explorer-Fenster aktivieren, um dessen Verhalten zu testen. Um sicherzustellen, dass jedes Skript ordnungsgemäß funktioniert, stelle sicher, dass du das Skript wieder deaktivierst, bevor du zur nächsten Konfiguration übergehst.

Team-Chat hinzufügen

Team-Chat ist eine Sprachchat-Konfiguration, bei der nur Spieler im selben Team miteinander sprechen oder einander hören können. Die Integration von Team-Chat in dein Gameplay ist nützlich, wenn du möchtest, dass Spieler zusammenarbeiten und strategisieren, um Probleme im Spiel zu lösen, wie z.B. Informationen über die Positionen, Ressourcen und Aufgaben des gegnerischen Teams zu koordinieren.

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

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

2. 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 abzurufen, damit es deren Funktionen nutzen kann, um Spieler sofort in Teams zu sortieren, sobald sie dem Spiel beitreten. Zum Beispiel kümmert sich der Teams-Dienst ohne zusätzlichen Programmieraufwand um Aktionen wie:

   • Das Sortieren und Ausbalancieren von Spielern gleichmäßig in jedes Team.
   • Das Gruppieren von Spielern unter ihrem Team auf der Bestenliste.
   • Das Färben der Spielernamen im 3D-Raum in die entsprechende Teamfarbe.

   Mit diesem Dienst erstellt das Skript zwei unterschiedliche Team-Objekte mit verschiedenen Color-Eigenschaftswerten, um jedes Team darzustellen: 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 zur 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 ein physisches Mikrofon eines Spielers in der realen Welt.
   • updateTeam - Ruft alle Benutzer-IDs von getUserIds ab, iteriert über die AudioDeviceInput-Objekte von getDevices, setzt deren Enum.AccessModifierType-Eigenschaft auf Erlauben, sodass nur die Benutzer-IDs in jedem Team von den Mikrofonen ihrer Teamkollegen hören dürfen, 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 Spiel beitritt, überprüft das Skript, ob der Spieler ein Mikrofon hat, und aktualisiert sein 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 Spiel beitreten oder es verlassen, verbindet sich das Skript mit den PlayerAdded- und PlayerRemoved-Ereignissen, um die Einstellungen jedes Teams zu aktualisieren.

3. Teste das Spiel mit ein paar Freunden, um zu überprüfen, ob Teamkollegen aus jedem Team nur über Sprachchat einander hören können.

Push-to-Chat hinzufügen

Push-to-Chat ist eine Sprachchat-Konfiguration, bei der Spieler ihr Mikrofon im Spiel nur aktivieren können, während sie eine bestimmte Taste auf ihrem Gerät drücken und halten. Die Integration von Push-to-Chat in dein Gameplay ist nützlich, wenn du möchtest, dass Spieler mehr Privatsphäre und Kontrolle haben, wenn sie über andere Spieler und Umgebungsgeräusche gehört werden möchten.

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

1. Füge im Explorer-Fenster ein Skript in ReplicatedStorage ein.

2. Setze im Eigenschaften-Fenster RunContext auf Client, damit das Skript nur das Mikrofon des lokalen Spielers steuert.

3. 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, Folgendes abzurufen:

   • Den Players-Dienst, damit es auf alle Spieler im Spiel zugreifen kann.
   • Den UserInputService-Dienst, damit es überprüfen kann, wann ein Spieler Tasten auf seinem 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 drücken und halten muss, um in sein Mikrofon zu sprechen.
   • Stummschaltet das Mikrofon des Spielers.

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

4. Teste das Spiel, um zu überprüfen, ob 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 miteinander sprechen und einander hören können. Die Integration von zeitbasiertem Chat in dein Gameplay ist nützlich, wenn du möchtest, dass Spieler sorgfältig planen, wie sie während bestimmter Phasen miteinander kommunizieren, wie z.B. während rundenbasierter Diskussionen oder nach Zwischensequenzen.

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

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

2. 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 erlauben, dass die Leute sprechen, oder sie daran hindern
   end

   Code-Erklärung

   Dieses Skript beginnt damit, den Players-Dienst abzurufen, damit es dessen Funktionalität zur Verwaltung aller Spieler im Spiel nutzen kann. 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:

   • Sie beginnt damit, alle Spieler im Spiel mit Players.GetPlayers zu durchlaufen.
   • Für jeden Spieler überprüft sie, ob er ein Kind-AudioDeviceInput-Objekt oder ein physisches Mikrofon auf seinem Gerät hat.
   • Wenn ja, setzt die Funktion die AudioDeviceInput-Objekts Muted-Eigenschaft auf den Wert von muteAll. Wenn muteAll also 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 alle 15 Sekunden wartet, um alle AudioDeviceInput-Objekte zu stummschalten und wieder zu aktivieren.

3. Teste das Spiel, um zu überprüfen, ob Spieler einander nur über Sprachchat in 15-Sekunden-Intervallen hören können.