Ajouter un chat vocal

Le chat vocal est une fonctionnalité de chat basée sur la proximité qui simule une communication réaliste en ajustant le volume des joueurs qui parlent à mesure qu'ils se rapprochent ou s'éloignent les uns des autres dans l'espace 3D. En permettant aux joueurs de se parler avec leurs microphones, ils peuvent socialiser et élaborer des stratégies ensemble en temps réel à travers le monde pour atteindre les objectifs de votre jeu.

En utilisant le fichier .rbxl Gingerbread Island - Voice Chat comme référence, ce tutoriel vous montre comment incorporer différentes formes de chat vocal dans votre gameplay, y compris des conseils sur :

• Le tri des joueurs en équipes qui ne peuvent utiliser le chat vocal qu'avec leurs coéquipiers.
• La possibilité pour les joueurs d'activer temporairement leur microphone pendant qu'ils appuient sur un bouton spécifique de leur appareil.
• La configuration de périodes où le chat vocal est soit activé, soit désactivé.

En examinant les sections suivantes avec l'exemple, vous pouvez ajuster chaque exemple de code pour mieux répondre aux besoins de votre propre chat vocal.

Configurer les paramètres

Pour que le chat d'équipe, le push-to-chat ou le chat basé sur le temps fonctionnent correctement, vous devez configurer votre installation de chat vocal pour activer le chat vocal et créer les objets audio appropriés nécessaires pour capter et émettre de l'audio dans l'environnement 3D.

Lorsque les joueurs rejoignent votre jeu, votre installation de chat vocal :

• Permet aux joueurs éligibles au chat vocal d'utiliser leurs microphones.
• Crée et parent un objet AudioDeviceInput sous chaque objet Player éligible au chat vocal.
• Crée et parent un objet AudioEmitter sous chaque Player.Character éligible au chat vocal.
• Crée et parent un AudioListener sous le Workspace.CurrentCamera.

Les sections suivantes détaillent trois configurations uniques de chat vocal utilisant ces paramètres. En suivant l'exemple du fichier de lieu Gingerbread Island - Voice Chat, vous pouvez activer le script désactivé correspondant dans la fenêtre Explorer pour tester leur comportement. Pour vous assurer que chacun fonctionne correctement, assurez-vous de désactiver à nouveau le script avant de passer à la configuration suivante.

Ajouter un chat d'équipe

Le chat d'équipe est une configuration de chat vocal dans laquelle seuls les joueurs de la même équipe peuvent se parler ou s'entendre dans un jeu. Intégrer le chat d'équipe dans votre gameplay est utile lorsque vous souhaitez que les joueurs collaborent et élaborent des stratégies ensemble pour résoudre des problèmes dans le jeu, comme coordonner des informations sur les positions de l'équipe ennemie, les ressources et les missions.

Pour recréer le chat vocal d'équipe dans le fichier de lieu Gingerbread Island - Voice Chat :

1. Dans la fenêtre Explorer, insérez un Script dans ServerScriptService.

2. Renommez le script en TeamChat, puis collez le code suivant dans le script :

   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 = "Équipe Rouge"
   
   local blueTeam = Instance.new("Team", Teams)
   blueTeam.TeamColor = BrickColor.new("Bright blue")
   blueTeam.AutoAssignable = true
   blueTeam.Name = "Équipe Bleue"
   
   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)

   Explication du code

   Le script commence par obtenir les services Teams et Players afin de pouvoir utiliser leur fonctionnalité intégrée pour trier les joueurs en équipes dès qu'ils rejoignent le jeu. Par exemple, sans aucun effort de script supplémentaire, le service Teams gère des actions telles que :

   • Trier et équilibrer les joueurs de manière égale dans chaque équipe.
   • Regrouper les joueurs sous leur équipe sur le tableau des scores.
   • Teinter les noms des joueurs dans l'espace 3D de la couleur de leur équipe correspondante.

   En utilisant ce service, le script crée deux objets Team distincts avec des valeurs de propriétés Color différentes pour représenter chaque équipe : rouge vif pour une équipe et bleu vif pour l'autre.

   Le script définit ensuite trois fonctions où se déroule la majeure partie du travail pour configurer le chat vocal d'équipe :

   • getUserIds - Renvoie un tableau des userIDs de tous les joueurs d'une équipe.
   • getDevices - Renvoie un tableau des objets AudioDeviceInput pour tous les joueurs d'une équipe. Chaque objet AudioDeviceInput représente le microphone physique d'un joueur dans le monde réel.
   • updateTeam - Récupère tous les userIDs de getUserIds, itère sur les objets AudioDeviceInput de getDevices, définit leur propriété Enum.AccessModifierType sur Allow afin que seuls les userIDs de chaque équipe soient autorisés à entendre les microphones de leurs coéquipiers, puis met à jour la SetUserIdAccessList avec les userIDs de l'équipe.

   Le reste du script contrôle comment ces fonctions et écouteurs d'événements fonctionnent ensemble :

   • Lorsqu'un nouveau joueur rejoint le jeu, le script vérifie si le joueur a un microphone et met à jour son équipe.
   • Lorsque le script détecte un nouvel objet AudioDeviceInput, il appelle updateTeam pour leur équipe rouge ou bleue respective.
   • À mesure que les joueurs rejoignent ou quittent le jeu, le script se connecte aux événements PlayerAdded et PlayerRemoved pour mettre à jour les paramètres de chaque équipe.

3. Testez le jeu avec quelques amis pour vérifier que les coéquipiers de chaque équipe ne peuvent s'entendre que par le chat vocal.

Ajouter le push-to-chat

Le push-to-chat est une configuration de chat vocal dans laquelle les joueurs ne peuvent activer leur microphone dans un jeu que lorsqu'ils appuient et maintiennent un bouton spécifique sur leur appareil. Intégrer le push-to-chat dans votre gameplay est utile lorsque vous souhaitez que les joueurs aient plus de confidentialité et de contrôle sur le moment où ils veulent être entendus par rapport aux autres joueurs et au bruit ambiant.

Pour recréer le chat vocal push-to-chat dans le fichier de lieu Gingerbread Island - Voice Chat :

1. Dans la fenêtre Explorer, insérez un Script dans ReplicatedStorage.

2. Dans la fenêtre Propriétés, définissez RunContext sur Client afin que le script ne contrôle que le microphone du joueur local.

3. Renommez le script en PushToChat, puis collez le code suivant dans le script :

   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)

   Explication du code

   Le script commence par obtenir :

   • Le service Players afin de pouvoir référencer tous les joueurs dans le jeu.
   • Le service UserInputService afin de pouvoir vérifier quand un joueur appuie sur des boutons de son appareil.
   • L'objet AudioDeviceInput du joueur local, ou le microphone physique sur son appareil.

   Le script :

   • Définit la touche V comme le bouton que le joueur doit appuyer et maintenir pour parler dans son microphone.
   • Met le microphone du joueur en sourdine.

   Le reste du script met en place deux écouteurs d'événements pour InputBegan et InputEnded à partir de UserInputService. Lorsqu'ils appuient sur la touche V, l'événement InputBegan désactive la sourdine du microphone du joueur, et lorsqu'ils relâchent la touche V, l'événement InputEnded remet le microphone en sourdine.

4. Testez le jeu pour vérifier que les joueurs ne peuvent s'entendre que par le chat vocal lorsqu'ils appuient sur la touche V.

Ajouter un chat basé sur le temps

Le chat basé sur le temps est une configuration de chat vocal dans laquelle les joueurs ne peuvent se parler et s'entendre que pendant une période définie. Intégrer le chat basé sur le temps dans votre gameplay est utile lorsque vous souhaitez que les joueurs planifient soigneusement comment ils communiquent entre eux pendant des phases spécifiques, comme lors de discussions basées sur des tours ou après des cinématiques.

Pour recréer le chat vocal basé sur le temps dans le fichier de lieu Gingerbread Island - Voice Chat :

1. Dans la fenêtre Explorer, insérez un Script dans ServerScriptService.

2. Renommez le script en TimeBasedChat, puis collez le code suivant dans le script :

   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) -- toutes les 15 secondes
       toggleMuteAll() -- soit permettre aux gens de parler, soit les empêcher de parler
   end

   Explication du code

   Ce script commence par obtenir le service Players afin de pouvoir référencer sa fonctionnalité pour gérer tous les joueurs dans le jeu. Il définit ensuite un indicateur muteAll sur false, que la fonction suivante toggleMuteAll utilise pour activer et désactiver le chat vocal.

   Examinons la fonction toggleMuteAll :

   • Elle commence par boucler à travers tous les joueurs dans le jeu en utilisant Players.GetPlayers.
   • Pour chaque joueur, elle vérifie s'il a un objet enfant AudioDeviceInput, ou microphone physique sur son appareil.
   • S'ils en ont, la fonction définit la propriété Muted de l'objet AudioDeviceInput sur la valeur de muteAll. Par exemple, si muteAll est true, le microphone du joueur est désactivé, et si muteAll est false, le microphone du joueur est activé.

   Le script entre ensuite dans une boucle infinie, attendant 15 secondes pour couper et rétablir tous les objets AudioDeviceInput.

3. Testez le jeu pour vérifier que les joueurs ne peuvent s'entendre que par le chat vocal par intervalles de 15 secondes.