Ajoutez de l'audio 3D | Documentation

L'audio 3D est un son directionnel qui émet d'un emplacement particulier dans l'espace 3D, augmentant ou diminuant en volume selon la distance et l'orientation entre l'émetteur audio et l'auditeur. Cela signifie qu'à mesure que les auditeurs ou les émetteurs se déplacent dans l'environnement, les joueurs peuvent entendre cet audio de différentes directions et niveaux de volume.

En utilisant le fichier Gingerbread House - Start .rbxl comme point de départ et Gingerbread House - Complete Audio comme référence, ce tutoriel vous montre comment ajouter à la fois de l'audio 3D en boucle et en une seule fois à vos expériences, y compris des conseils sur :

Les sons environnementaux en boucle qui se jouent dès que les joueurs se connectent au serveur.
Le déclenchement de l'audio pour informer les joueurs des événements clés de la situation qui sont importants pour leur gameplay.
L'activation de l'audio pour fournir un retour audio aux joueurs lorsqu'ils interagissent avec des objets 3D.
La diffusion de fragments sonores des personnages qui engagent et guident les joueurs vers des points d'intérêt dans leur environnement.

Si à un moment donné vous vous sentez bloqué dans le processus, vous pouvez utiliser Gingerbread House - Complete Audio comme référence pour comparer vos progrès.

Si vous souhaitez ajouter de l'audio non positionnel à votre expérience, tel que de la musique de fond, des sons d'interaction de l'UI ou des dialogues de coupure vocal, consultez Ajoutez de l'audio 2D.

Objets audio

Pour créer de l'audio directionnel, il est important de comprendre les objets audio avec lesquels vous allez travailler tout au long de ce tutoriel. Il existe six types principaux d'objets audio pour l'audio 3D :

L'objet AudioPlayer charge et joue le fichier audio.
L'objet AudioEmitter est un haut-parleur virtuel qui émet de l'audio dans l'environnement 3D.
L'objet AudioListener est un microphone virtuel qui capte l'audio de l'environnement 3D.
L'objet AudioDeviceOutput est un dispositif matériel physique dans le monde réel, tel qu'un haut-parleur ou un casque.
L'objet AudioDeviceInput est un microphone physique dans le monde réel.
Wires transportent les flux audio d'un objet à un autre.

Tous ces objets audio fonctionnent ensemble pour émettre du son tout comme leurs équivalents dans le monde réel. Examinons comment cela fonctionne en pratique à l'aide d'un exemple d'un joueur portant un casque tout en jouant une expérience sur son ordinateur portable :

L'AudioPlayer charge l'ID de l'actif audio 1516791621 dans l'expérience pour une piste de pluie.
L'AudioEmitter émet un flux de l'audio de la piste de pluie dans l'environnement 3D.
Un Wire transporte le flux de l'AudioPlayer à l'AudioEmitter afin que le flux sorte du haut-parleur 3D.
L'objet enfant AudioListener du personnage écoute ce son dans l'environnement 3D et le renvoie vers son casque.
L'objet AudioDeviceOutput transporte le son de l'AudioListener vers le haut-parleur physique du joueur, ou dans ce cas, ses écouteurs.
L'objet AudioDeviceInput capture le son du monde réel et le renvoie dans l'expérience pour le chat vocal.

Représentations des objets dans l'expérience

Représentations des objets dans le monde réel

Les sections suivantes plongeront plus profondément et feront référence à ces objets au fur et à mesure que vous apprendrez à jouer à la fois de l'audio 3D en boucle et en une seule fois. En passant en revue ces objets avec les prochaines techniques, vous pouvez prédire plus précisément comment capturer et transmettre le son de l'expérience au joueur et vice-versa.

Audio en boucle

L'audio 3D en boucle, ou audio directionnel qui se répète sans interruption dès que les joueurs se connectent au serveur, est une technique commune de conception sonore pour améliorer l'atmosphère de l'espace 3D en lui donnant une sensation de vie et de dynamisme. De plus, l'audio 3D en boucle maintient vos sources sonores environnantes cohérentes, comme le statique d'une télévision ou le rugissement d'une cascade ; si ces sons devaient soudainement s'arrêter, l'environnement semblerait irréaliste.

Pour démontrer ce concept, examinez comment les 3D audio pour deux grandes cascades s'arrêtent dès que la piste audio non bouclée est terminée. Bien que les sons de l'eau immergent initialement les joueurs dans l'environnement extérieur, le changement auditif soudain est choquant et artificiel par rapport à la façon dont une cascade se comporte dans le monde réel.

Pour créer une boucle sans couture, vous devez parfaitement faire correspondre les points de fin et de début de votre piste audio afin que les joueurs ne puissent pas détecter sa répétition. Ce processus nécessite un logiciel de montage audio tiers tel que Reaper ou Audacity afin que vous puissiez trouver un croisement zéro et effectuer une coupe soigneusement chronométrée. Pour des instructions étape par étape sur ces méthodes, consultez Créer des boucles audio parfaites.

De même, l'échantillon utilise cette technique pour la cascade de chocolat qui coule, et ajuste son volume en fonction de la distance du joueur par rapport à l'émetteur audio. Lorsque le joueur se trouve à moins de 20 studs, l'émetteur émet le son à volume maximum. Au fur et à mesure que le joueur s'éloigne, l'audio de l'eau diminuera de volume tous les 20 studs éloignés de l'émetteur audio. Cela imite le son du monde réel qui diminue en volume plus vous êtes éloigné de la source.

Pour recréer l'audio 3D en boucle dans le fichier d'emplacement d'échantillon Gingerbread House - Complete Audio :

Activez un écouteur par défaut qui est attaché à votre personnage joueur.
1. Dans la fenêtre Explorer, sélectionnez SoundService.
2. Dans la fenêtre Propriétés, définissez DefaultListenerLocation sur Character. Lorsque vous exécutez l'expérience, le moteur crée automatiquement :
  - Un AudioListener sous Humanoid.RootPart de chaque personnage joueur afin que vous puissiez entendre les sons se déplacer dans vos haut-parleurs du monde réel en fonction de la position et de l'échelle des sources sonores dans l'expérience.
  - Un AudioDeviceOutput sous SoundService.
Dans la fenêtre Explorer, naviguez vers Workspace ⟩ WaterfallAudioObject, puis :
1. Insérez un objet AudioPlayer pour créer une source audio pour la cascade.
2. Insérez un objet AudioEmitter pour émettre un flux positionnel à partir de WaterfallAudioObject.
3. Insérez un objet Wire pour transporter le flux de l'audio player à l'audio emitter.
Sélectionnez l'AudioPlayer, puis dans la fenêtre Propriétés,
1. Définissez AssetID sur rbxassetid://1516791621 pour jouer une piste audio de pluie.
2. Activez Looping afin que l'audio se répète de manière transparente.
Sélectionnez l'AudioEmitter, puis dans la fenêtre Propriétés, définissez DistanceAttenuation sur {0: 1}, {20: 0.8}, {40: 0.4}, {80: 0} afin que le son diminue progressivement en volume tous les 20 studs éloignés de l'émetteur audio.
Sélectionnez le Wire, puis dans la fenêtre Propriétés,
1. Définissez SourceInstance sur votre nouvel AudioPlayer pour spécifier que vous souhaitez que le fil transporte l'audio de ce joueur audio spécifique.
2. Définissez TargetInstance sur votre nouvel AudioEmitter pour spécifier que vous souhaitez que le fil transporte l'audio vers cet émetteur audio spécifique à l'intérieur de la cascade.
De retour dans la fenêtre Explorer, insérez un Script dans WaterfallAudioObject, renommez-le en LoopWaterfallMusic, définissez sa propriété RunContext sur Client, puis collez le code suivant dans le script :
```
local audioPlayer = script.Parent
audioPlayer:Play()
```
Explication du code
Le script commence par déclarer une variable pour représenter le parent du script AudioPlayer. Le script définit ensuite la source audio pour jouer dès que le joueur rejoint l'expérience jusqu'au moment où il quitte l'expérience.
Testez l'expérience pour entendre le son de la pluie au chocolat lorsque votre avatar est près de la cascade. Lorsque vous faites pivoter la tête de votre personnage pour regarder dans une autre direction, le son se déplace dynamiquement dans vos haut-parleurs du monde réel en fonction de la position de l'émetteur dans l'espace 3D.

Audio en une seule fois

L'audio 3D en une seule fois, ou audio directionnel qui se joue une seule fois à un moment et à un endroit spécifiques à moins qu'un joueur ne le déclenche à nouveau, fournit aux joueurs des informations sur leurs actions, l'environnement et les personnages qui les entourent. Utiliser ce type de retour audio dans vos expériences est essentiel car cela permet aux joueurs de prendre des décisions stratégiques comme éviter les ennemis entrants ou ramasser des objets utiles.

Les sections suivantes fournissent des détails de mise en œuvre pour des scénarios de gameplay courants dans lesquels les joueurs ont besoin d'un retour directionnel et opportun, y compris des événements de gameplay situationnels, des interactions d'objets et des dialogues de personnages non jouables.

Retour d'événements

Alors que les joueurs déclenchent des événements situationnels clés au sein de leur environnement, tels que le déverrouillage de nouvelles zones de gameplay ou l'appel d'un tir ennemi, il est essentiel qu'ils comprennent où dans l'espace 3D ils doivent diriger leur concentration et leur attention. S'ils ne reçoivent pas de retour auditif immédiat, ils peuvent manquer des informations importantes pour leur gameplay, ce qui peut conduire à de la frustration en n'ayant pas de repère sur où aller ou quoi faire ensuite.

Pour démontrer pourquoi ceci est important, examinons l'audio 3D en une seule fois du modèle Laser Tag qui se joue à partir du blaster de chaque joueur :

Un son de pop profond se joue pour chaque tir que le joueur effectue avec son blaster.
Un son de clic et de biper robotique se joue chaque fois que le joueur recharge son blaster avec une nouvelle cartouche.

Ces deux sons fournissent une conscience situationnelle en alertant tous les joueurs à proximité de la direction d'où proviennent les tirs afin qu'ils puissent prendre des décisions éclairées pour soit profiter du plaisir, soit éviter un danger potentiel.

L'échantillon utilise cette même technique pour fournir aux joueurs un retour situationnel concernant leur récompense pour avoir terminé l'objectif principal dans l'expérience. Après avoir collecté les trois bonbons, la porte de la maison en pain d'épices s'ouvre pour permettre aux joueurs d'accéder au présent à l'intérieur.

Comme il n'y a pas d'ordre spécifique que les joueurs doivent suivre pour collecter les bonbons, il est important que les joueurs soient au courant de l'ouverture de la porte peu importe le bonbon qu'ils collectent en dernier. Le son positionnel rend cela possible afin que les joueurs prennent conscience de leur succès et de l'endroit où ils doivent aller ensuite, quel que soit leur distance relative et leur direction par rapport à la porte.

Pour recréer l'audio 3D de retour d'événements en une seule fois dans le fichier d'emplacement d'échantillon Gingerbread House - Complete Audio :

Dans la fenêtre Explorer, naviguez vers Workspace ⟩ Door, puis :
1. Insérez un objet AudioPlayer pour créer une source audio pour la volume.
2. Insérez un objet AudioEmitter pour émettre un flux positionnel à partir de Door.
3. Insérez un objet Wire pour transporter le flux de l'audio player à l'audio emitter.
Sélectionnez l'AudioPlayer, puis dans la fenêtre Propriétés, définissez AssetID sur rbxassetid://5930776613 pour jouer une piste audio de porte en métal glissant.
Sélectionnez le Wire, puis dans la fenêtre Propriétés,
1. Définissez SourceInstance sur votre nouvel AudioPlayer pour spécifier que vous souhaitez que le fil transporte l'audio de ce joueur audio spécifique.
2. Définissez TargetInstance sur votre nouvel AudioEmitter pour spécifier que vous souhaitez que le fil transporte l'audio vers cet émetteur audio spécifique à l'intérieur de la volume.

De retour dans la fenêtre Explorer, naviguez vers ServerScriptService, puis insérez un Script, renommez-le en GumdropService, définissez sa propriété RunContext sur Server, puis collez le code suivant dans le script :


-- Initialisation des variables
local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")
local TweenService = game:GetService("TweenService")

-- Modules
local Leaderboard = require(ServerStorage.Leaderboard)
local PlayerData = require(ServerStorage.PlayerData)

-- Variables
local gumdropsFolder = Workspace.Gumdrops
local gumdrops = gumdropsFolder:GetChildren()

local GUMDROP_KEY_NAME = PlayerData.GUMDROP_KEY_NAME
local GUMDROP_AMOUNT_TO_ADD = 1

local function updatePlayerGumdrops(player, updateFunction)
   -- Met à jour la table des bonbons
   local newGumdropAmount = PlayerData.updateValue(player, GUMDROP_KEY_NAME, updateFunction)

   -- Met à jour le classement des bonbons
   Leaderboard.setStat(player, GUMDROP_KEY_NAME, newGumdropAmount)
 
   -- Vérifie si le joueur a collecté trois bonbons
   if newGumdropAmount >= 3 then
 	
      -- Joue l'audio de l'événement de porte lorsque le joueur collecte trois bonbons
      local audioPlayer = Workspace.Door.AudioPlayer
      audioPlayer:Play()
 	
      -- Anime la porte pour descendre
      local doorPart = Workspace.Door
      local tweenInfo = TweenInfo.new(2, Enum.EasingStyle.Linear)
      local tween = TweenService:Create(doorPart, tweenInfo, {Position = doorPart.Position + Vector3.new(0, -15, 0)})
      tween:Play()
   end
end

-- Définition du gestionnaire d'événements
local function onGumdropTouched(otherPart, gumdrop)
   if gumdrop:GetAttribute("Enabled") then
      local character = otherPart.Parent
      local player = Players:GetPlayerFromCharacter(character)
      if player then
         -- Le joueur a touché un bonbon
 		
         local audioPlayer = gumdrop.AudioPlayer
         audioPlayer:Play()
 		
         gumdrop.Transparency = 1
         gumdrop:SetAttribute("Enabled", false)
         updatePlayerGumdrops(player, function(oldGumdropAmount)
            oldGumdropAmount = oldGumdropAmount or 0
            return oldGumdropAmount + GUMDROP_AMOUNT_TO_ADD
         end)
         print("Le joueur a collecté un bonbon")
      end
   end
end

-- Configuration des écouteurs d'événements
for _, gumdrop in gumdrops do
   gumdrop:SetAttribute("Enabled", true)
   gumdrop.Touched:Connect(function(otherPart)
      onGumdropTouched(otherPart, gumdrop)
   end)
end

Explication du code

Ce script gère des fonctionnalités supplémentaires en dehors du déclenchement de l'audio positionnel, telles que la mise à jour du classement et le déclenchement d'un son non positionnel chaque fois qu'un joueur collecte un bonbon. Ceci est important pour le gameplay de l'échantillon, mais ce n'est pas crucial pour comprendre comment mettre en œuvre l'audio 2D, donc cette explication gardera ces sections à un niveau élevé.

Le script commence par initialiser les services Workspace, Players, ServerStorage, et TweenService afin de pouvoir faire référence à leurs enfants et fonctionnalités. Ensuite, il requiert les modules Leaderboard et PlayerData dans ServerStorage ; ces modules sont responsables de la création et de la mise à jour d'un classement dans le coin supérieur droit de l'écran qui suit la quantité de bonbons qu'un joueur collecte dans l'environnement.

La fonction updatePlayerGumdrops du script est là où la plupart du travail se déroule pour déclencher l'audio 3D pour le retour d'événements, et elle prend deux arguments :

player - Un joueur qui collecte un bonbon.
updateFunction - Une fonction de rappel qui met à jour le montant de bonbons collectés par le joueur.

Lorsqu'un joueur entre en collision avec un bonbon, le script :

Obtient la nouvelle valeur de collecte de bonbons du joueur en appelant la fonction PlayerData.updateValue.
Met à jour le classement avec ce nouveau montant en appelant la fonction Leaderboard.setStat.
Vérifie si le montant est supérieur ou égal à 3.

Lorsque cette valeur est supérieure ou égale à 3, le script :

Joue la piste audio 3D depuis le joueur audio vers l'émetteur audio.
Déplace la porte de manière linéaire 15 studs en dessous de sa position actuelle.

Le reste du script est principalement en charge de détecter tout ce qui entre en collision avec le bonbon en tant que joueur afin de pouvoir déclencher un son non positionnel pour un retour de collecte. Pour plus d'informations sur ce parti du script, voir Ajoutez de l'audio 2D - Retour de gameplay.

Testez l'expérience pour entendre le son de la porte glissante après avoir collecté les trois bonbons dans l'environnement. Lorsque vous pivotez la caméra, le son se déplace dynamiquement dans vos haut-parleurs du monde réel afin que vous l'entendiez en fonction de la position de l'émetteur dans l'espace 3D.

Interaction d'objets

Lorsque les joueurs interagissent avec des objets 3D au sein de leur environnement, tels que l'activation d'un interrupteur ou la prise d'une arme, il est important de fournir un retour instantané afin qu'ils comprennent intuitivement comment ils interagissent avec l'objet. L'association d'un retour visuel et auditif renforce la relation de cause à effet entre les actions du joueur et la réponse de l'environnement.

Pour élargir ce concept, examinons le son audio 3D en une fois suivant de l'échantillon Plant pour le flux utilisateur du jardinage d'un chou :

Un son de cliquetis doux se joue lorsque le joueur plante une graine.
Un son humide, similaire à un éclaboussement se joue lorsque le joueur arrose sa plante en croissance.
Un son de découpe se joue lorsque le joueur récolte la plante pleine.
Un doux son de bruit sourd se joue lorsque le joueur place le chou dans la charrette.

Tous ces sons renforcent les prompts de proximité du joueur sur les interactions clés de l'objet changeant de forme dans l'espace 3D. Pour les joueurs ayant des déficiences visuelles, où les changements de couleur ou les animations sont plus difficiles à discerner par eux-mêmes, fournir ces multiples formes de retour sensoriel aide vos interactions d'objets 3D à rester accessibles et intuitives pour le plus grand nombre possible de joueurs.

Pour donner un autre exemple de comment vous pouvez configurer l'interaction d'objet avec plusieurs formes de retour sensoriel, l'échantillon fournit à la fois un retour visuel et auditif chaque fois que les joueurs marchent sur le bouton 3D de menthe poivrée dans la maison en pain d'épices. Lorsque les joueurs n'interagissent pas avec le bouton, il apparaît comme un bonbon de menthe poivrée typique, mais lorsqu'ils appuient sur le bouton, l'échantillon :

Joue une piste audio de jingle de célébration.
Teinte les côtés du bouton avec une nuance verte.
Déplace le bouton dans le sol.

À partir de là, vous pouvez relier cette interaction à toutes sortes d'actions de gameplay uniques, telles que le déverrouillage d'un objet ou le déclenchement d'une capacité spéciale.

Pour recréer l'audio d'interaction d'objet en une seule fois dans le fichier d'emplacement d'échantillon Gingerbread House - Complete Audio :

Dans la fenêtre Explorer, naviguez vers Workspace ⟩ 3DAudioButton, puis :
1. Insérez un objet AudioPlayer pour créer une source audio pour le bouton.
2. Insérez un objet AudioEmitter pour émettre un flux positionnel depuis 3DAudioButton.
3. Insérez un objet Wire pour transporter le flux de l'audio player à l'audio emitter.
Sélectionnez l'AudioPlayer, puis dans la fenêtre Propriétés, définissez AssetID sur rbxassetid://1846248593 pour jouer une piste audio joyeuse et célébratoire.
Sélectionnez le Wire, puis dans la fenêtre Propriétés,
1. Définissez SourceInstance sur votre nouvel AudioPlayer pour spécifier que vous souhaitez que le fil transporte l'audio de ce joueur audio spécifique.
2. Définissez TargetInstance sur votre nouvel AudioEmitter pour spécifier que vous souhaitez que le fil transporte l'audio vers cet émetteur audio spécifique dans le bouton.

De retour dans la fenêtre Explorer, insérez un Script dans 3DAudioButton, renommez-le en PlayAudioWhenPressed, puis collez le code suivant dans le script :


local TweenService = game:GetService("TweenService")

local buttonModel = script.Parent.Parent
local buttonPart = buttonModel.ButtonPart
local buttonPressedAudioPlayer = buttonModel.ButtonPressedAudioPlayer

local tweenInfo = TweenInfo.new(.2, Enum.EasingStyle.Exponential)

local buttonTweenByIsPressed = {
   -- Pressé
   [true] = TweenService:Create(buttonPart, tweenInfo, {
      Size = buttonPart.Size / Vector3.new(2, 1, 1),
      Color = Color3.fromRGB(75, 151, 75),
   }),
 
   -- Par défaut
   [false] = TweenService:Create(buttonPart, tweenInfo, {
      Size = buttonPart.Size,
      Color = Color3.fromRGB(196, 40, 28),
   }),
}

local function onIsPlayingChanged()
   local isPlaying = buttonPressedAudioPlayer.IsPlaying
   local tween = buttonTweenByIsPressed[isPlaying]
   tween:Play()
   end
   
onIsPlayingChanged()
buttonPressedAudioPlayer:GetPropertyChangedSignal("IsPlaying"):Connect(onIsPlayingChanged)
buttonPressedAudioPlayer.Ended:Connect(onIsPlayingChanged)

buttonPart.Touched:Connect(function(_hit)
buttonPressedAudioPlayer:Play()
end)

Explication du code

Ce script gère des fonctionnalités supplémentaires en dehors du simple fait de jouer de l'audio 3D pour les interactions d'objets, comme l'animation de la couleur et de la position du bouton. Cela est important pour fournir plusieurs sources de retour sensoriel, mais les exigences de conception de votre cas d'utilisation peuvent nécessiter seulement un retour auditif. Si vous souhaitez juste jouer de l'audio lorsque les joueurs touchent le modèle, vous pouvez supprimer la fonctionnalité d'animation.

Le script commence par obtenir :

Le TweenService afin qu'il puisse animer la partie du bouton qui dépasse du sol.
Le modèle 3DAudioButton du parent du script.
La partie du bouton qui dépasse du sol.
Le joueur audio pertinent avec votre piste audio de célébration.

Le script définit ensuite :

Un objet TweenInfo qui spécifie que l'animation du bouton jouera avec un style d'animation exponentielle.
Deux animations qui représentent l'état du bouton pressé ou non pressé.
- L'état pressé true déplace légèrement le bouton vers le bas dans le sol et teint les côtés de la partie d'une nuance verte.
- L'état non pressé false ramène le bouton à sa position d'origine et retire la teinte précédente.

Le reste du script est là où la majorité du travail de retour d'interaction d'objet se déroule, alors examinons comment la fonction onIsPlayingChanged et les écouteurs d'événements interagissent :

buttonPart.Touched écoute pour qu'un joueur touche le bouton, puis appelle la fonction Play() pour commencer à jouer l'audio associé à partir du joueur audio. Ce processus change la propriété AudioPlayer.IsPlaying de false à true.
buttonPressedAudioPlayer:GetPropertyChangedSignal("IsPlaying") écoute le changement de la propriété IsPlaying du joueur audio, puis appelle la fonction onIsPlayingChanged.
La fonction onIsPlayingChanged utilise cette information pour déclencher l'animation qui change son apparence visuelle dans l'espace 3D.
Pour empêcher le joueur de redémarrer accidentellement l'audio s'il sautait rapidement sur le bouton de manière répétée, buttonPressedAudioPlayer.Ended écoute que le joueur audio ait terminé de jouer avant d'appeler à nouveau la fonction onIsPlayingChanged.

Il est important de noter que l'événement onIsPlayingChanged ne se déclenche que lorsque l'on passe de false à true, ce qui signifie qu'il ne se déclenche pas lors d'un passage de true à false. C'est un comportement voulu en raison des complications liées au chronométrage de la réplication des propriétés du serveur vers le client. Grâce à cela, l'événement Ended est fourni et écouté dans cet exemple pour couvrir les deux cas.

Testez l'expérience pour entendre le son de célébration lorsque votre personnage joueur touche le bouton 3D dans la maison en pain d'épices. Lorsque vous vous éloignez du bouton, le volume du son diminue.

Dialogue de personnage

Fournir de l'audio directionnel de vos personnages non jouables (PNJ) est utile pour guider les joueurs vers des points d'intérêt dans leur environnement et ajouter de la profondeur à leurs interactions avec d'autres personnages. En fait, dans les expériences axées sur la narration, de nombreux concepteurs utilisent stratégiquement le dialogue de personnage pour enseigner indirectement aux joueurs quelque chose sur leur personnage, les alliés et les ennemis, ou le monde lui-même.

Des exemples courants de cette technique incluent :

Style de dialogue pour établir le ton de votre expérience.
Banter pour enseigner aux joueurs les relations entre les personnages.
Conversations d'ennemis pour avouer des motivations ou leur position par rapport au joueur.
Personnages-joueurs exprimant leurs pensées à voix haute pour guider doucement le joueur sur ce qu'il devrait faire ensuite, comme se soigner, se déplacer à un autre endroit, ou trouver un objet.
Personnages alliés parlant avec le personnage joueur pour révéler des détails sur le monde dans l'expérience, comme son histoire, sa culture et ses enjeux sociaux.

Pour démontrer à quoi cela peut ressembler en pratique, examinons l'audio 3D en une seule fois suivant de Beyond the Dark qui se joue périodiquement lorsque les joueurs sont dans la zone principale du hall de la station spatiale.

En utilisant la station spatiale comme un personnage, cet extrait de dialogue fournit aux joueurs des informations importantes et des histoires concernant le cadre général. Par exemple, à partir de cette seule phrase, les joueurs apprennent :

Qu'ils sont dans l'espace, plus précisément sur une station spatiale nommée Kerr-Newman Deep Space Relay 14.
Que leur environnement est futuriste et accueillant.
Qu'ils sont des visiteurs et qu'ils quitteront probablement bientôt.

Ces détails ensemble immergent les joueurs dans leur environnement et ajoutent un sens d'urgence à leur mission. Cependant, si les joueurs ne savent pas ce qu'est leur mission principale, vous pouvez également utiliser le dialogue de personnage pour informer les joueurs de ce que vous voulez qu'ils fassent dans votre expérience.

Pour illustrer, l'échantillon utilise un volume, ou région invisible au sein de l'espace 3D, pour déclencher le dialogue de personnage du bonhomme de neige afin de guider les joueurs à collecter trois bonbons pour ouvrir la porte de sa maison. Étant l'une des premières choses que les joueurs voient en rejoignant l'expérience, les joueurs sont plus susceptibles de déclencher le dialogue et de savoir ce qu'ils doivent faire pour réussir.

Le volume autour du bonhomme de neige utilise un retour de collision pour jouer de l'audio lorsque les joueurs entrent dans la région 3D.

Pour recréer l'audio de dialogue de personnage en une seule fois dans le fichier d'emplacement d'échantillon Gingerbread House - Complete Audio :

Dans la fenêtre Explorer, naviguez vers Workspace ⟩ DialogueVolume, puis :
1. Insérez un objet AudioPlayer pour créer une source audio pour le volume.
2. Insérez un objet AudioEmitter pour émettre un flux positionnel depuis DialogueVolume.
3. Insérez un objet Wire pour transporter le flux de l'audio player à l'audio emitter.
Sélectionnez l'AudioPlayer, puis dans la fenêtre Propriétés, définissez AssetID sur rbxassetid://92917410841704 pour jouer une piste audio instructive pour l'objectif de l'expérience.
Sélectionnez le Wire, puis dans la fenêtre Propriétés,
1. Définissez SourceInstance sur votre nouvel AudioPlayer pour spécifier que vous souhaitez que le fil transporte l'audio de ce joueur audio spécifique.
2. Définissez TargetInstance sur votre nouvel AudioEmitter pour spécifier que vous souhaitez que le fil transporte l'audio vers cet émetteur audio spécifique au sein du volume.

De retour dans la fenêtre Explorer, naviguez vers StarterPlayer ⟩ StarterCharacterScripts, insérez un LocalScript, renommez-le en PlayAudioWhenInVolume, et collez le code suivant dans le script local :


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

local humanoid = script.Parent:WaitForChild("Humanoid")
local volumeDetector = Workspace.DialogueVolume
local trigger = humanoid:WaitForChild("Animator")
local debounce = false
local localPlayer = Players.LocalPlayer

volumeDetector.Touched:Connect(function(hit)
   if debounce then 
      return
   end

   local hitCharacter = hit:FindFirstAncestorWhichIsA("Model")
   local hitPlayer = Players:GetPlayerFromCharacter(hitCharacter)
 
   if hitPlayer ~= localPlayer then
      return
   end

   debounce = true
 
   local audioPlayer = Workspace.DialogueVolume.AudioPlayer
   audioPlayer:Play()
   audioPlayer.Ended:Wait()

   debounce = false
end)

Explication du code

Ce script commence par obtenir les services de Workspace et de Players afin de pouvoir faire référence à leurs enfants et leur fonctionnalité. Pour chaque personnage joueur qui se charge ou réapparaît dans l'expérience, le script attend :

Le Humanoid du personnage et les objets Animator.
L'objet de volume dans l'espace de travail nommé DialogueVolume.

Lorsque quoi que ce soit entre en collision avec le volume, la fonction de gestionnaire d'événements Touched obtient le premier ancêtre qui est un Model, qui devrait être le personnage si la BasePart qui a percuté le volume est un descendant d'un modèle de personnage. Si c'est le cas, la fonction :

Définit debounce sur true.
Joue et attend que l'audio se termine.
Rétablit debounce sur false.

Définir debounce de false à true puis à false à nouveau après que l'audio ait fini de jouer est un schéma de debounce qui empêche l'audio de se déclencher à plusieurs reprises à mesure que les joueurs percent en continu le volume. Pour plus d'informations sur ce schéma de debounce, voir Debounce - Détecter les collisions.

Testez l'expérience pour entendre le dialogue instructif du personnage lorsque votre personnage joueur touche le volume autour du bonhomme de neige.