Adicionar áudio 3D

Áudio 3D é som direcional que emite de um determinado local no espaço 3D, aumentando ou diminuindo de volume dependendo da distância e orientação entre o emissor de áudio e o ouvinte. Isso significa que, à medida que ouvintes ou emissores se movem pelo ambiente, os jogadores podem ouvir esse áudio dinamicamente de diferentes direções e níveis de volume.

Usando o arquivo Gingerbread House - Start .rbxl como ponto de partida e Gingerbread House - Complete Audio como referência, este tutorial mostra como adicionar tanto áudio 3D contínuo quanto de uma única execução às suas experiências, incluindo orientações sobre:

• Sons ambientais em loop que tocam assim que os jogadores se conectam ao servidor.
• Acionamento de áudio para informar os jogadores sobre eventos situacionais-chave que são importantes para seu jogo.
• Ativação de áudio para fornecer feedback auditivo aos jogadores quando eles interagem com objetos 3D.
• Execução de trechos sonoros de personagens que envolvem e orientam os jogadores em direção a pontos de interesse dentro de seu ambiente.

Se em algum momento você ficar preso no processo, pode usar Gingerbread House - Complete Audio como referência para comparar seu progresso.

Objetos de áudio

Para criar áudio direcional, é importante entender os objetos de áudio com os quais você trabalhará ao longo deste tutorial. Existem seis tipos principais de objetos de áudio para áudio 3D:

• O objeto AudioPlayer carrega e reproduz o arquivo de áudio.
• O objeto AudioEmitter é um alto-falante virtual que emite áudio no ambiente 3D.
• O objeto AudioListener é um microfone virtual que capta áudio do ambiente 3D.
• O objeto AudioDeviceOutput é um dispositivo de hardware físico no mundo real, como um alto-falante ou fones de ouvido.
• O objeto AudioDeviceInput é um microfone físico no mundo real.
• Wires transporta fluxos de áudio de um objeto para outro.

Todos esses objetos de áudio trabalham juntos para emitir som, assim como seus equivalentes no mundo real. Vamos dar uma olhada em como isso funciona na prática usando um exemplo de um jogador usando um fone de ouvido enquanto toca uma experiência em seu laptop:

• O AudioPlayer carrega o ID do ativo de áudio 1516791621 na experiência para uma trilha sonora de chuva.
• O AudioEmitter emite um fluxo do áudio da trilha sonora de chuva no ambiente 3D.
• Um Wire transporta o fluxo do AudioPlayer para o AudioEmitter para que o fluxo saia do alto-falante 3D.
• O objeto filho AudioListener do personagem escuta esse som no ambiente 3D e o envia de volta para o fone de ouvido.
• O objeto AudioDeviceOutput transporta o som do AudioListener para o alto-falante físico do jogador, ou, neste caso, seus fones de ouvido.
• O objeto AudioDeviceInput captura som do mundo real e o envia de volta para a experiência para chat de voz.

As seções seguintes exploram mais a fundo e fazem referência a esses objetos enquanto você aprende a tocar tanto áudio 3D em loop quanto de uma única execução. Ao revisar esses objetos com as técnicas que virão, você poderá prever mais com precisão como capturar e enviar som da experiência para o jogador e vice-versa.

Áudio em loop

Áudio 3D em loop, ou áudio direcional que repete continuamente assim que os jogadores se conectam ao servidor, é uma técnica comum de design de som para melhorar a atmosfera do espaço 3D, fazendo-o parecer vivo e dinâmico. Além disso, o áudio 3D em loop mantém suas fontes de som ambiental consistentes, como o estático de uma televisão ou o rugido de uma cachoeira; se esses sons pararem de repente, o ambiente pareceria irrealista.

Para demonstrar esse conceito, reveja como o áudio 3D para duas grandes cachoeiras pára assim que a trilha sonora não em loop é concluída. Enquanto os sons da água imergem inicialmente os jogadores no ambiente ao ar livre, a mudança auditiva repentina é chocante e não natural em relação ao comportamento de uma cachoeira no mundo real.

Da mesma forma, o exemplo usa essa técnica para a cachoeira de chocolate fluente e ajusta seu volume de acordo com a distância do jogador em relação ao emissor de áudio. Quando o jogador está a menos de 20 studs de distância, o emissor emite o som na volumetria total. À medida que o jogador se afasta, o áudio do borbulhar diminui em volume a cada 20 studs de distância do emissor de áudio. Isso emula o som do mundo real que diminui de volume quanto mais longe você está da fonte.

Para recriar o áudio 3D em loop no arquivo de lugar Gingerbread House - Complete Audio:

1. Ative um ouvinte padrão que está conectado ao seu personagem jogador.

   1. Na janela Explorer, selecione o SoundService.
   2. Na janela Properties, defina DefaultListenerLocation como Character. Quando você executar a experiência, o motor cria automaticamente:

      • Um AudioListener sob a Humanoid.RootPart de cada personagem jogador para que você possa ouvir sons se deslocando em seus alto-falantes do mundo real de acordo com a posição e escala das fontes de som dentro da experiência.
      • Um AudioDeviceOutput sob o SoundService.

2. Na janela Explorer, navegue até Workspace ⟩ WaterfallAudioObject, então:

   1. Insira um objeto AudioPlayer para criar uma fonte de áudio para a cachoeira.
   2. Insira um objeto AudioEmitter para emitir um fluxo posicional do WaterfallAudioObject.
   3. Insira um objeto Wire para transportar o fluxo do reprodutor de áudio para o emissor de áudio.

   

3. Selecione o AudioPlayer, então, na janela Properties,

   1. Defina AssetID como rbxassetid://1516791621 para tocar uma trilha sonora de áudio chuvoso.
   2. Ative Looping para que o áudio se repita continuamente.

4. Selecione o AudioEmitter, então, na janela Properties, defina DistanceAttenuation como {0: 1}, {20: 0.8}, {40: 0.4}, {80: 0} para que o som diminua progressivamente de volume a cada 20 studs de distância do emissor de áudio.

5. Selecione o Wire, então, na janela Properties,

   1. Defina SourceInstance para seu novo AudioPlayer para especificar que você quer que o fio transporte áudio deste reprodutor de áudio específico.
   2. Defina TargetInstance para seu novo AudioEmitter para especificar que você quer que o fio transporte áudio para este emissor de áudio específico dentro da cachoeira.

6. De volta à janela Explorer, insira um Script no WaterfallAudioObject, renomeie-o para LoopWaterfallMusic, defina sua propriedade RunContext como Client, então cole o seguinte código no script:

   local audioPlayer = script.Parent
   audioPlayer:Play()

   Explicação do código

   O script começa declarando uma variável para representar o AudioPlayer pai do script. O script então define a fonte de áudio para tocar desde o momento em que o jogador ingressa na experiência até o momento em que ele sai da experiência.

7. Teste a experiência para ouvir o som da chuva contínua de chocolate quando seu avatar estiver perto da cachoeira. Quando você girar a cabeça de seu personagem para olhar em uma direção diferente, o som mudará dinamicamente em seus alto-falantes do mundo real de acordo com a posição do emissor no espaço 3D.

Áudio de uma única execução

Áudio 3D de uma única execução, ou áudio direcional que toca uma vez em um tempo e posição específicos, a menos que um jogador o acione novamente, fornece aos jogadores contexto sobre suas ações, o ambiente e quaisquer personagens ao seu redor. Usar esse tipo de feedback auditivo em suas experiências é essencial, pois permite que os jogadores tomem decisões estratégicas, como evitar inimigos que se aproximam ou pegar itens úteis.

As seções seguintes fornecem detalhes de implementação para cenários comuns de jogabilidade em que os jogadores precisam de feedback direcional e oportuno, incluindo eventos de jogabilidade situacionais, interação com objetos e diálogos de personagens não jogáveis.

Feedback de eventos

À medida que os jogadores acionam eventos situacionais-chave em seu ambiente, como desbloquear novas áreas de jogabilidade ou solicitar fogo inimigo, é essencial que eles entendam onde no espaço 3D precisam direcionar seu foco e atenção. Se eles não receberem feedback auditivo imediato, podem perder informações importantes para sua jogabilidade, levando à frustração por não saber onde ir ou o que fazer a seguir.

Para demonstrar por que isso é importante, vamos revisar o áudio 3D de uma única execução do template Laser Tag que toca de cada blaster dos jogadores:

• Um som profundo de estouro toca para cada tiro que o jogador dispara de seu blaster.
• Um som de clique e beep robótico toca cada vez que o jogador recarrega seu blaster com uma nova rodada.

Ambos os sons proporcionam consciência situacional ao alertar todos os jogadores próximos sobre a direção de onde os disparos estão vindo, para que possam tomar decisões informadas, como entrar na diversão ou evitar potenciais perigos.

O exemplo usa essa mesma técnica para fornecer aos jogadores consciência situacional sobre sua recompensa por completar o objetivo principal dentro da experiência. Depois de coletar todos os três gummis, a porta da casa de gengibre se abre para permitir que os jogadores tenham acesso ao presente dentro dela.

Como não há uma ordem específica que os jogadores precisam seguir para coletar os gummis, é importante que os jogadores estejam cientes da porta se abrindo, independentemente de qual gummi eles coletam por último. O som posicional torna isso possível, para que os jogadores estejam cientes de seu sucesso e de onde precisam ir a seguir, independentemente de sua distância relativa e direção em relação à porta.

Para recriar o áudio 3D de feedback de evento de uma única execução no arquivo de lugar Gingerbread House - Complete Audio:

1. Na janela Explorer, navegue até Workspace ⟩ Door, então:

   1. Insira um objeto AudioPlayer para criar uma fonte de áudio para o volume.
   2. Insira um objeto AudioEmitter para emitir um fluxo posicional da Door.
   3. Insira um objeto Wire para transportar o fluxo do reprodutor de áudio para o emissor de áudio.

   

2. Selecione o AudioPlayer, então, na janela Properties, defina AssetID como rbxassetid://5930776613 para tocar uma trilha sonora de porta de metal deslizante.

3. Selecione o Wire, então, na janela Properties,

   1. Defina SourceInstance para o seu novo AudioPlayer para especificar que você quer que o fio transporte áudio deste reprodutor de áudio específico.
   2. Defina TargetInstance para o seu novo AudioEmitter para especificar que você quer que o fio transporte áudio para este emissor de áudio específico dentro do volume.

4. De volta à janela Explorer, navegue até ServerScriptService, então insira um Script, renomeie-o para GumdropService, defina sua propriedade RunContext como Server, então cole o seguinte código no script:

   -- Inicializando variáveis
   local Workspace = game:GetService("Workspace")
   local Players = game:GetService("Players")
   local ServerStorage = game:GetService("ServerStorage")
   local TweenService = game:GetService("TweenService")
   
   -- Módulos
   local Leaderboard = require(ServerStorage.Leaderboard)
   local PlayerData = require(ServerStorage.PlayerData)
   
   -- Variáveis
   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)
      -- Atualiza a tabela de gummis
      local newGumdropAmount = PlayerData.updateValue(player, GUMDROP_KEY_NAME, updateFunction)
   
      -- Atualiza o leaderboard de gummis
      Leaderboard.setStat(player, GUMDROP_KEY_NAME, newGumdropAmount)
    
      -- Verifica se o jogador coletou três gummis
      if newGumdropAmount >= 3 then
    	
         -- Toca o áudio do evento da porta quando o jogador coleta três gummis
         local audioPlayer = Workspace.Door.AudioPlayer
         audioPlayer:Play()
    	
         -- Anima a porta para se mover para baixo
         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
   
   -- Definindo o manipulador de eventos
   local function onGumdropTouched(otherPart, gumdrop)
      if gumdrop:GetAttribute("Enabled") then
         local character = otherPart.Parent
         local player = Players:GetPlayerFromCharacter(character)
         if player then
            -- O jogador tocou um gummi
    		
            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("Jogador coletou gummi")
         end
      end
   end
   
   -- Configurando ouvintes de eventos
   for _, gumdrop in gumdrops do
      gumdrop:SetAttribute("Enabled", true)
      gumdrop.Touched:Connect(function(otherPart)
         onGumdropTouched(otherPart, gumdrop)
      end)
   end

   Explicação do código

   Este script lida com funcionalidade adicional além de acionar o áudio posicional, como atualizar o leaderboard e acionar um som não-posicional toda vez que um jogador coleta um gummi. Isso é importante para a jogabilidade do exemplo, mas não é importante para entender como implementar áudio 2D, então esta explicação manterá essas seções em um nível alto.

   Este script começa inicializando os serviços Workspace, Players, ServerStorage e TweenService para que ele possa referenciar suas crianças e funcionalidade. Em seguida, requer os módulos Leaderboard e PlayerData no ServerStorage; esses módulos são responsáveis por criar e atualizar um leaderboard no canto superior direito da tela que rastreia a quantidade de gummis que um jogador coleta no ambiente.

   A função updatePlayerGumdrops do script é onde a maior parte do trabalho ocorre para acionar o áudio 3D para feedback de eventos, e ela leva dois argumentos:

   • player - Um jogador que coleta um gummi.
   • updateFunction - Uma função de retorno de chamada que atualiza a quantidade de gummis coletados pelo jogador.

   Quando um jogador colide com um gummi, o script:

   • Obtém o novo valor de quantidade de gummis coletados do jogador chamando a função PlayerData.updateValue.
   • Atualiza o leaderboard com esse novo valor chamando a função Leaderboard.setStat.
   • Verifica se a quantidade é maior ou igual a 3.

   Quando esse valor é maior ou igual a 3, o script:

   • Toca a trilha de áudio 3D do reprodutor de áudio para o emissor de áudio.
   • Move a porta linearmente 15 studs para baixo de sua posição atual.

   O restante do script é em grande parte responsável por detectar qualquer colisão com o gummi que seja um jogador, para que ele possa acionar um som não-posicional para feedback de coleta. Para mais informações sobre esta parte do script, veja Adicionar áudio 2D - Feedback de jogabilidade.

5. Teste a experiência para ouvir o som da porta deslizante depois de coletar todos os três gummis no ambiente. Quando você gira a câmera, o som muda dinamicamente em seus alto-falantes do mundo real para que você o ouça de acordo com a posição do emissor no espaço 3D.

Interação com objetos

Quando os jogadores interagem com objetos 3D dentro de seu ambiente, como ligar um interruptor de luz ou pegar uma arma, é importante fornecer feedback instantâneo para que eles entendam intuitivamente como estão interagindo com o objeto. A combinação de feedback visual e auditivo reforça a relação de causa e efeito entre as ações do jogador e a resposta do ambiente.

Para ampliar esse conceito, vamos revisar o seguinte áudio 3D de uma única execução do exemplo Plant para o fluxo de usuário de jardinagem de um repolho:

• Um som suave de clique toca quando o jogador planta uma semente.
• Um som molhado, semelhante a um splash, toca quando o jogador rega sua planta em crescimento.
• Um som de corte toca quando o jogador coleta a planta completamente crescida.
• Um som suave de thud toca quando o jogador coloca o repolho na carroça.

Todos esses sons reforçam as principais interações do jogador com o objeto mudando de forma no espaço 3D. Para jogadores com deficiência visual, em que mudanças de cor ou animações são mais difíceis de decifrar sozinhos, fornecer essas formas múltiplas de feedback sensorial ajuda suas interações de objetos 3D a permanecerem acessíveis e intuitivas para o maior número possível de jogadores.

Para dar um exemplo diferente de como você pode configurar interações com objetos com múltiplas formas de feedback sensorial, o exemplo fornece tanto feedback visual quanto auditivo sempre que os jogadores pisam no botão de 3D de hortelã dentro da casa de gengibre. Quando os jogadores não estão interagindo com o botão, ele aparece como um doce típico de hortelã, mas quando pisam no botão, o exemplo:

• Toca uma trilha sonora de jingle celebratório de áudio.
• Tinge os lados do botão com um tom verde.
• Move o botão para dentro do chão.

A partir daqui, você pode conectar essa interação a todo tipo de ações únicas de jogabilidade, como desbloquear um item ou acionar uma habilidade especial.

Para recriar o áudio 3D de interação de objeto de uma única execução no arquivo de lugar Gingerbread House - Complete Audio:

1. Na janela Explorer, navegue até Workspace ⟩ 3DAudioButton, então:

   1. Insira um objeto AudioPlayer para criar uma fonte de áudio para o botão.
   2. Insira um objeto AudioEmitter para emitir um fluxo posicional do 3DAudioButton.
   3. Insira um objeto Wire para transportar o fluxo do reprodutor de áudio para o emissor de áudio.

   

2. Selecione o AudioPlayer, então, na janela Properties, defina AssetID como rbxassetid://1846248593 para tocar uma trilha sonora de áudio celebratória e alegre.

3. Selecione o Wire, então, na janela Properties,

   1. Defina SourceInstance para seu novo AudioPlayer para especificar que você quer que o fio transporte áudio deste reprodutor de áudio específico.
   2. Defina TargetInstance para seu novo AudioEmitter para especificar que você quer que o fio transporte áudio para este emissor de áudio específico dentro do botão.

4. De volta à janela Explorer, insira um Script no 3DAudioButton, renomeie-o para PlayAudioWhenPressed, então cole o seguinte código no 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 = {
      -- Pressionado
      [true] = TweenService:Create(buttonPart, tweenInfo, {
         Size = buttonPart.Size / Vector3.new(2, 1, 1),
         Color = Color3.fromRGB(75, 151, 75),
      }),
    
      -- Padrão
      [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)

   Explicação do código

   Este script lida com funcionalidade adicional além de apenas tocar áudio 3D para interações com objetos, como mudar a cor e a posição do botão. Isso é importante para fornecer múltiplas fontes de feedback sensorial, mas os requisitos de design para seu caso de uso podem exigir apenas feedback auditivo. Se você só quiser tocar áudio quando os jogadores tocarem o modelo, pode remover a funcionalidade de tween.

   O script começa obtendo:

   • O TweenService para que ele possa animar a parte do botão que se destaca do chão.
   • O modelo pai do script 3DAudioButton.
   • A parte do botão que se destaca do chão.
   • O reprodutor de áudio relevante com sua trilha sonora de som de celebração.

   O script então define:

   • Um objeto TweenInfo que especifica que a animação do botão seguirá um estilo de animação exponencial.
   • Dois tweens que representam o estado pressionado ou não do botão.

     • O estado pressionado true move o botão levemente para baixo no chão e tinge os lados da parte com um tom verde.
     • O estado não pressionado false move o botão de volta para sua posição original e remove a cor anterior.

   O restante do script é onde a maior parte do trabalho ocorre para o feedback da interação do objeto, então vamos revisar como a função onIsPlayingChanged e os ouvintes de eventos funcionam juntos:

   1. buttonPart.Touched escuta um jogador tocar o botão, então chama a função Play() para começar a tocar o áudio associado do reprodutor de áudio. Esse processo muda a propriedade AudioPlayer.IsPlaying de false para true.
   2. buttonPressedAudioPlayer:GetPropertyChangedSignal("IsPlaying") escuta a mudança da propriedade IsPlaying do reprodutor de áudio e então chama a função onIsPlayingChanged.
   3. A função onIsPlayingChanged usa essa informação para disparar a animação que altera sua aparência visual no espaço 3D.
   4. Para evitar que o jogador acidentalmente reinicie o áudio se eles pularem rapidamente sobre o botão em rápida sucessão, buttonPressedAudioPlayer.Ended escuta o término da execução do áudio antes de chamar novamente a função onIsPlayingChanged.

   É importante notar que o evento onIsPlayingChanged é acionado apenas quando muda de false para true, o que significa que não é acionado quando muda de true para false. Este é o comportamento pretendido devido a complicações com o tempo de replicação de propriedades do servidor para o cliente. Por causa disso, o evento Ended é fornecido e escutado neste exemplo para cobrir ambos os casos.

5. Teste a experiência para ouvir o som de celebração quando seu personagem jogador tocar o botão 3D na casa de gengibre. Quando você se afasta do botão, o volume do som diminui.

Diálogo de personagens

Fornecer áudio direcional dos seus personagens não jogáveis (NPC) é útil para guiar os jogadores em direção a pontos de interesse dentro de seu ambiente e adicionar profundidade às suas interações com outros personagens. Na verdade, em experiências guiadas por narrativas, muitos designers usam estrategicamente o diálogo dos personagens para ensinar indiretamente aos jogadores sobre seu personagem, aliados e inimigos, ou o próprio mundo.

Exemplos comuns dessa técnica incluem:

• Estilo de diálogo para definir o tom da sua experiência.
• Conversas para ensinar aos jogadores sobre relacionamentos entre personagens.
• Conversas de inimigos para confessar motivações ou suas posições em relação ao jogador.
• Personagens jogáveis expressando seus pensamentos em voz alta para guiar suavemente o jogador sobre o que eles devem fazer a seguir, como se curar, se mover para outro local ou encontrar um item.
• Personagens aliados conversando com o personagem jogador para revelar detalhes do mundo na experiência, como sua história, cultura e questões sociais.

Para demonstrar como isso pode parecer na prática, vamos revisar o seguinte áudio 3D de uma única execução do showcase Beyond the Dark que toca periodicamente quando os jogadores estão na área principal do saguão da estação espacial.

Usando a estação espacial como um personagem, esse clipe de diálogo fornece aos jogadores informações contextuais importantes e a lore sobre o cenário geral. Por exemplo, a partir dessa única frase, os jogadores aprendem:

• Eles estão no espaço exterior, especificamente em uma estação espacial chamada Kerr-Newman Deep Space Relay 14.
• Seu ambiente é futurista e acolhedor.
• Eles são visitantes e provavelmente deixarão em breve.

Esses detalhes juntos imergem os jogadores em seu ambiente e adicionam um senso de urgência à sua missão. No entanto, se os jogadores não souberem qual é sua missão principal, você também pode usar o diálogo dos personagens para informar os jogadores sobre o que você deseja que eles façam dentro de sua experiência.

Para ilustrar, o exemplo usa uma volume, ou região invisível dentro do espaço 3D, para acionar o diálogo do personagem do boneco de neve para guiar os jogadores a coletar três gummis para abrir a porta de sua casa. Como uma das primeiras coisas que os jogadores veem ao entrar na experiência, os jogadores têm mais chances de acionar o diálogo e saber o que precisam fazer para ter sucesso.

Para recriar o áudio 3D de diálogo de personagem de uma única execução no arquivo de lugar Gingerbread House - Complete Audio:

1. Na janela Explorer, navegue até Workspace ⟩ DialogueVolume, então:

   1. Insira um objeto AudioPlayer para criar uma fonte de áudio para o volume.
   2. Insira um objeto AudioEmitter para emitir um fluxo posicional do DialogueVolume.
   3. Insira um objeto Wire para transportar o fluxo do reprodutor de áudio para o emissor de áudio.

   

2. Selecione o AudioPlayer, então, na janela Properties, defina AssetID como rbxassetid://92917410841704 para tocar uma trilha sonora instrucional para o objetivo da experiência.

3. Selecione o Wire, então, na janela Properties,

   1. Defina SourceInstance para seu novo AudioPlayer para especificar que você quer que o fio transporte áudio deste reprodutor de áudio específico.
   2. Defina TargetInstance para seu novo AudioEmitter para especificar que você quer que o fio transporte áudio para este emissor de áudio específico dentro do volume.

4. De volta à janela Explorer, navegue até StarterPlayer ⟩ StarterCharacterScripts, insira um LocalScript, renomeie-o para PlayAudioWhenInVolume, e cole o seguinte código no 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)

   Explicação do código

   Este script começa obtendo os serviços Workspace e Players para que possa referenciar suas crianças e funcionalidade. Para cada personagem jogador que carrega ou renasce na experiência, o script espera por:

   • O Humanoid e Animator do personagem.
   • O objeto de volume no espaço chamado DialogueVolume.

   Quando qualquer coisa colide com o volume, a função manipuladora do evento Touched obtém o primeiro ancestral que é um Model, que deve ser o personagem se a BasePart que colidiu com o volume for um descendente do modelo do personagem. Se for, a função então:

   • Define debounce como true.
   • Toca e espera o áudio terminar.
   • Define debounce de volta para false.

   Definir debounce de false para true e de volta para false após o fim do áudio é um padrão de debounce que impede que o áudio seja acionado repetidamente à medida que os jogadores colidem continuamente com o volume. Para mais informações sobre esse padrão de debounce, veja Debounce - Detectar colisões.

5. Teste a experiência para ouvir o diálogo instrucional do personagem quando seu personagem jogador tocar o volume ao redor do boneco de neve.