Cette section va vous montrer comment configurer des effets sonores, comme des barks, et des effets visuels, comme des bougés de caméra, pour créer un gameplay captivant.
Appareil Lecteur audio
Vous pouvez configurer l'appareil Lecteur audio afin de définir les lignes de dialogue des gardes. Dans le domaine du développement de jeux, on les appelle souvent des barks.

Les éléments audio importés se trouvent dans le répertoire "Dossier du projet" > Barks. Cliquez sur l'icône de lecture pour écouter le fichier audio, puis faites-le glisser sur votre île.

Vous pouvez placer un Lecteur audio sur votre île en y faisant glisser un fichier audio. Cet appareil est relié à un appareil Verse pour lire une série de messages personnalisés des gardes. Ces messages réagissent à différents événements, notamment lorsque le joueur est repéré ou subit des dégâts.
Placez un lecteur audio pour chaque élément audio distinct que vous souhaitez lire. Ce tutoriel utilise 14 barks différents pour 14 appareils de lecture audio différents.
Pour configurer ces appareils, personnalisez les paramètres suivants :

Option | Valeur | Explication |
---|---|---|
Volume | 4,0 | Ce paramètre peut varier en fonction de votre enregistrement. |
Relancer le son à l'activation | True | Cet élément audio est lu dès le début lorsqu'il est activé. |
Activation à l'impact | False | Cet appareil ne joue pas d'élément audio en cas de collision avec un joueur. |
Emplacement du son | Joueur instigateur | La lecture de l'élément audio se fait en fonction de l'emplacement du joueur instigateur et non en fonction de l'emplacement de l'appareil. |
Activer l'atténuation du volume | Désactivé | Le volume est modifié en fonction de la distance par rapport à l'appareil ou au garde configuré pour le lire. Pour ce tutoriel, le joueur peut entendre l'audio quelle que soit la distance à laquelle il se trouve. |
Ensuite, configurez le script Verse pour qu'il gère la logique de déclenchement des appareils Lecteur audio pendant le jeu, puis placez l'appareil Verse. Pour ce tutoriel, l'appareil est nommé Gestionnaire des barks de la forteresse.
Collez le script Verse suivant.
using { /Fortnite.com/Devices }
using { /Fortnite.com/Game }
using { /Fortnite.com/Characters }
using { /Verse.org/Random }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
# Bark audio lisible sur un PNJ
audio_npc_bark := class<concrete>:
# Appareil audio pour la lecture des barks
@editable
BarkDevice:audio_player_device := audio_player_device{}
# Option autorisant les PNJ à répéter le bark
@editable
CanRepeat:logic = true
# Délai entre l'événement et le début du bark
@editable
Delay:float = 0.0
# Délai avant la répétition de ce bark
@editable
Cooldown:float = 5.0
# Nom du bark pour la journalisation
@editable
BarkID:string = "Missing ID"
# Le délai de récupération est-il écoulé ?
var<private> IsInCooldown:logic = false
# Événement pour arrêter le bark
StopBarkEvent<private>:event() = event(){}
PlayBark(Agent:agent)<suspends>:void=
var IsPlaying:logic = false;
defer:
if (IsPlaying?):
set IsPlaying = false
set IsInCooldown = false
BarkDevice.Stop(Agent)
race:
block:
StopBarkEvent.Await()
return
block:
AwaitAgentDown(Agent)
return
block:
if (Delay > 0.0):
Sleep(Delay)
if (IsInCooldown?):
return
BarkDevice.Play(Agent)
set IsPlaying = true
set IsInCooldown = true
Sleep(2.0)
set IsPlaying = false
if (CanRepeat?):
Sleep(Cooldown)
set IsInCooldown = false
StopBark():void=
StopBarkEvent.Signal()
AwaitAgentDown<private>(Agent:agent)<suspends>:void=
if (Character := Agent.GetFortCharacter[]):
loop:
if (Character.GetHealth() <= 0.0):
return
Character.DamagedEvent().Await()
# Script qui gère les barks des gardes
stronghold_bark_manager := class(creative_device):
# Référence au gestionnaire de jeu pour surveiller les événements de perception
@editable
StrongholdGameManager:stronghold_game_manager := stronghold_game_manager{}
# Appareils Lecteur audio
@editable
BarkNPCDown:audio_npc_bark = audio_npc_bark{BarkID := "Un homme à terre", Delay := 0.3}
@editable
BarkFallback:audio_npc_bark = audio_npc_bark{BarkID := "Repli", CanRepeat := false, Delay := 3.0}
@editable
BarkNeedBackup:audio_npc_bark = audio_npc_bark{BarkID := "Besoin de renforts", CanRepeat := false, Delay := 2.0}
@editable
BarkGoToLeash:audio_npc_bark = audio_npc_bark{BarkID := "Renforts en route", CanRepeat := false, Delay := 4.0}
@editable
BarkDamageTaken:audio_npc_bark = audio_npc_bark{BarkID := "A subi des dégâts", Delay := 0.2}
@editable
BarkDamagePlayer:audio_npc_bark = audio_npc_bark{BarkID := "Joueur touché", Delay := 0.2}
@editable
BarkEliminatedPlayer:audio_npc_bark = audio_npc_bark{BarkID := "Joueur éliminé", Delay := 0.3}
@editable
BarkPlayerSpotted:audio_npc_bark = audio_npc_bark{BarkID := "Joueur repéré", CanRepeat := false}
@editable
BarkPlayerLost:audio_npc_bark = audio_npc_bark{BarkID := "Joueur perdu", Cooldown := 10.0}
@editable
BarkGuardSuspicious:audio_npc_bark = audio_npc_bark{BarkID := "Suspect", Cooldown := 10.0}
@editable
BarkGuardUnaware:audio_npc_bark = audio_npc_bark{BarkID := "Non alerté", Cooldown := 10.0}
# Variable permettant de savoir si les gardes étaient à la recherche de cibles
var<private> HasLostTarget:logic := false
# S'exécute à l'activation de l'appareil dans une partie en cours.
OnBegin<override>()<suspends>:void=
ConfigureBarks()
sync:
AwaitReinforcements()
AwaitFallback()
PlayAwarenessBarks()
PlayBark(Bark:audio_npc_bark, Guard:agent):void=
spawn {Bark.PlayBark(Guard)}
# Joue un bark lorsque des renforts sont appelés
AwaitReinforcements<private>()<suspends>:void=
AlertedGuard := StrongholdGameManager.ReinforcementsCalledEvent.Await()
PlayBark(BarkNeedBackup, AlertedGuard)
# Jouer un bark lorsque les gardes se regroupent dans la forteresse
AwaitFallback<private>()<suspends>:void=
StrongholdGameManager.FallbackEvent.Await()
if:
Guard := StrongholdGameManager.AlertedGuards[0]
then:
PlayBark(BarkFallback, Guard)
PlayAwarenessBarks<private>()<suspends>:void=
loop:
race:
PlayGuardsSuspiciousBark()
PlayPlayerSpottedBark()
PlayPlayerLostBark()
PlayGuardsUnawareBark()
PlayPlayerSpottedBark<private>()<suspends>:void=
Guard:=StrongholdGameManager.PlayerDetectedEvent.Await();
set HasLostTarget = false
PlayBark(BarkPlayerSpotted, Guard)
PlayPlayerLostBark<private>()<suspends>:void=
Guard:=StrongholdGameManager.PlayerLostEvent.Await();
set HasLostTarget = true
PlayBark(BarkPlayerLost, Guard)
PlayGuardsSuspiciousBark<private>()<suspends>:void=
Guard:=StrongholdGameManager.GuardsSuspiciousEvent.Await();
PlayBark(BarkGuardSuspicious, Guard)
PlayGuardsUnawareBark<private>()<suspends>:void=
Guard:=StrongholdGameManager.GuardsUnawareEvent.Await();
if (HasLostTarget?):
set HasLostTarget = false
if (not StrongholdGameManager.FallbackTriggered?):
PlayBark(BarkGuardUnaware, Guard)
SubscribeToGuardSpawnerEvents(GuardSpawnerDevice:guard_spawner_device):void =
GuardSpawnerDevice.DamagedEvent.Subscribe(OnGuardDamaged)
GuardSpawnerDevice.EliminatedEvent.Subscribe(OnGuardEliminated)
GuardSpawnerDevice.EliminatingEvent.Subscribe(OnPlayerEliminated)
# Configurer tous les barks
ConfigureBarks():void=
# S'abonner à l'événement Dégâts aux joueurs
AllPlayers := GetPlayspace().GetPlayers()
for (StrongholdPlayer : AllPlayers, StrongholdPC := StrongholdPlayer.GetFortCharacter[]):
StrongholdPC.DamagedEvent().Subscribe(OnPlayerDamaged)
# Parcourir la liste des générateurs de gardes à partir du gestionnaire de forteresse et s'abonner à tous les événements clés.
for (GuardSpawner : StrongholdGameManager.GuardsInitialSpawners):
SubscribeToGuardSpawnerEvents(GuardSpawner)
for (GuardSpawner : StrongholdGameManager.GuardsReinforcementSpawners):
SubscribeToGuardSpawnerEvents(GuardSpawner)
# Prévoir un cas séparé pour l'apparition des renforts
if:
FirstReinforcementSpawner := StrongholdGameManager.GuardsReinforcementSpawners[0]
then:
FirstReinforcementSpawner.SpawnedEvent.Subscribe(HandleReinforcementSpawned)
# Lorsque le garde est abattu, essayer de lire un bark sur le garde alerté le plus proche
OnGuardEliminated(InteractionResult:device_ai_interaction_result):void=
if (EliminatedGuard := InteractionResult.Target?):
# Trouver le garde vivant le plus proche pour lire ce bark
var ClosestGuard:?agent = false
if:
set ClosestGuard = option{StrongholdGameManager.AlertedGuards[0]}
EliminatedGuardCharacter := EliminatedGuard.GetFortCharacter[]
then:
for (AlertedGuard : StrongholdGameManager.AlertedGuards, AlertedGuardCharacter := AlertedGuard.GetFortCharacter[]):
if:
not ClosestGuard? = AlertedGuard
ClosestGuardCharacter := ClosestGuard?.GetFortCharacter[]
DistanceSquaredToAlertedGuard := DistanceSquared(AlertedGuardCharacter.GetTransform().Translation, EliminatedGuardCharacter.GetTransform().Translation)
DistanceSquaredToClosestGuard := DistanceSquared(ClosestGuardCharacter.GetTransform().Translation, EliminatedGuardCharacter.GetTransform().Translation)
DistanceSquaredToAlertedGuard < DistanceSquaredToClosestGuard
then:
set ClosestGuard = option{AlertedGuard}
if (Guard := ClosestGuard?):
spawn {BarkNPCDown.PlayBark(Guard)}
# Essayer de lire un bark lorsque le garde est touché, mais pas éliminé
OnGuardDamaged(InteractionResult:device_ai_interaction_result):void=
if (Guard := InteractionResult.Target?):
spawn {BarkDamageTaken.PlayBark(Guard)}
# Lorsque le joueur est touché, essayer de lire un bark sur le garde qui lui a infligé des dégâts
OnPlayerDamaged(DamageResult:damage_result):void=
if:
fort_character[DamageResult.Target].GetHealth() > 0.0
Guard := DamageResult.Instigator?.GetInstigatorAgent[]
then:
spawn {BarkDamagePlayer.PlayBark(Guard)}
# Lorsque le joueur est éliminé, essayer de lire un bark sur le garde qui l'a éliminé
OnPlayerEliminated(InteractionResult:device_ai_interaction_result):void=
if (Guard := InteractionResult.Source?):
spawn {BarkEliminatedPlayer.PlayBark(Guard)}
HandleReinforcementSpawned(Guard:agent):void=
spawn {BarkGoToLeash.PlayBark(Guard)}
Ce script stocke une référence à chaque Lecteur audio et répertorie l'appareil Verse Gestionnaire de jeu de forteresse comme intermédiaire pour ses références aux générateurs de gardes.
Lumières personnalisables

En plus de recevoir les retours audio des gardes contrôlés par l'IA, vous pouvez également donner aux joueurs des retours visuels provenant de l'environnement.
Ce tutoriel utilise deux ensembles d'appareils [Lumière personnalisable] (https://dev.epicgames.com/documentation/fr-fr/fortnite-creative/using-customizable-light-devices-in-fortnite-creative) autour de la forteresse. Une lumière rouge indique un état de détection, tandis qu'une lumière orange indique un état d'alerte.
Pour configurer ces appareils, personnalisez les paramètres suivants :
Option | Valeur | Explication |
---|---|---|
État de départ | False | Détermine l'état initial de la lumière lorsque l'appareil est activé. |
Taille de la lumière | 100,00 | Détermine la taille, la portée et la puissance de l'éclat lumineux. |
Ombres projetées | True | Permet à la lumière de projeter des ombres. |
Activé pendant la phase | Partie | Les lumières ne seront activées que pendant le gameplay. |
Intensité de la lumière | 30,0 | Définit l'intensité de la lumière. |
Durée du rythme | x8 | Définit le multiplicateur de temps du préréglage de rythme. |
Force de l'assombrissement | 100,0 | Définit le degré d'assombrissement lors de l'utilisation des contrôles de canal. |
Durée d'assombrissement | 0,1 | Définit la durée de l'assombrissement en secondes. |
Créateur d'effets visuels

Ce tutoriel utilise également un créateur d'effets visuels au-dessus de la base afin de servir de fusée éclairante pour les renforts lors de la première détection des joueurs. Cette fusée est contrôlée par l'appareil Verse et s'allume en même temps que les lumières d'angle lorsque les gardes sont en état d'alerte, pour afficher clairement leur position.
Pour configurer ces appareils, personnalisez les paramètres suivants :

Option | Valeur | Explication |
---|---|---|
Exécuter les effets à l'activation | False | Définit si l'appareil exécute les effets quand il est activé. |
Taille de sprite | 2,0 | Définit la taille initiale des sprites d'effet. |
Durée de l'effet | 5,0 | Définit la durée d'apparition de chaque sprite. |
Couleur principale | Rouge | Définit la couleur principale des effets. |
Luminosité de la couleur principale | 200,0 | Définit la luminosité de la couleur principale. |
Vitesse du sprite | 100,0 | Définit la vitesse à laquelle les sprites d'effets commencent à se déplacer. |
Gravité de l'effet | 15,0 | Définit la vitesse à laquelle les sprites d'effet peuvent tomber. |
Imprévisibilité | 100,0 | Détermine le caractère aléatoire du mouvement et ajoute une variation à la taille. |
Conserver la taille | False | Détermine si les sprites conservent leur taille ou s'ils utilisent une taille personnalisée qui change au fil du temps. |
Quantité d'effets générée | 4,0 | Définit le nombre de sprites d'effets générés. |
Forme de la zone à l'apparition | Point | Détermine la forme de l'espace où les sprites apparaissent d'abord. |
Taille de la zone à l'apparition | 0,05 | Définit la taille de la forme d'apparition en tuiles. |
Activé pendant la phase | Partie | Détermine les phases de jeu pendant lesquelles l'appareil sera activé. |
Boucle | Jamais | Détermine si l'effet est joué une seule fois, s'il est joué en boucle indéfiniment ou s'il est joué un certain nombre de fois. |
Appareil radio
Ce tutoriel utilise deux radios](https://dev.epicgames.com/documentation/fr-fr/fortnite-creative/using-radio-devices-in-fortnite-creative) : l'un pour la musique de combat en alerte élevée et l'autre pour la musique de prudence.
La musique tendue utilise : Radio > Music Loops > Music_StW_Low_Combat01_Cue'.
La musique de combat en cas de détection de joueur utilise Radio > Music Loops > Music_StW_High_Combat01_Cue'.
Créez un script Verse que vous pouvez appeler Stronghold_Alert_Manager pour écouter les événements de détection de joueurs par un garde ou lorsque tous les gardes ont perdu la trace du joueur, pour alterner entre les deux états de la forteresse.
Collez le script Verse suivant.
using { /Verse.org/Simulation }
using { /Verse.org/Simulation/Tags }
using { /Verse.org/Colors }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /Fortnite.com/Devices }
# balises pour les lumières personnalisables
alerted_lights_tag := class(tag){}
combat_lights_tag := class(tag){}
# Script qui gère la musique et allume les lumières lorsque les gardes sont alertés
stronghold_alert_manager := class(creative_device):
# Référence au gestionnaire de jeu pour surveiller les événements de perception
@editable
StrongholdGameManager:stronghold_game_manager := stronghold_game_manager{}
# Référence à la radio qui joue la musique de combat
@editable
RadioCombat:radio_device := radio_device{}
# Référence à la radio qui joue la musique d'alerte
@editable
RadioAlerted:radio_device := radio_device{}
# Effets visuels à jouer lorsque l'alarme est déclenchée ou la fusée allumée
@editable
FlareAlarmVFXCreator:vfx_creator_device := vfx_creator_device{}
# Données de classe
var<private> CustomizableLightDevicesAlerted: []customizable_light_device = array{}
var<private> CustomizableLightDevicesCombat: []customizable_light_device = array{}
# Faire passer le camp en état d'alerte lorsque le joueur est tué ou que l'on a perdu sa trace
WaitForAlerted()<suspends>:void=
# ne pas revenir à l'état d'alerte après le repli
if (StrongholdGameManager.FallbackTriggered?):
Sleep(Inf)
StrongholdGameManager.GuardsUnawareEvent.Await()
Sleep(3.0)
SetAlertedMood()
# Faire passer le camp en état de combat lorsqu'un joueur est repéré
WaitForCombat()<suspends>:void=
race:
StrongholdGameManager.PlayerDetectedEvent.Await()
StrongholdGameManager.FallbackEvent.Await()
Sleep(2.0)
SetCombatMood()
# S'exécute à l'activation de l'appareil dans une partie en cours.
OnBegin<override>()<suspends>:void=
FindLightsWithTag()
MonitorStrongholdAlertStatus()
# Vérification par la boucle principale de l'état de combat ou d'alerte de la forteresse
MonitorStrongholdAlertStatus()<suspends>:void=
loop:
WaitForCombat()
WaitForAlerted()
# Fait passer la base en mode Combat en allumant des lumières rouges et en jouant une musique intense.
SetCombatMood():void=
# Placer les lumières de combat en boucle et les allumer
for(LightsToTurnOn: CustomizableLightDevicesCombat):
LightsToTurnOn.TurnOn()
# Placer les lumières d'alerte en boucle et les éteindre
for(LightsToTurnOff: CustomizableLightDevicesAlerted):
LightsToTurnOff.TurnOff()
# Activer l'audio de combat et désactiver l'audio d'alerte
RadioCombat.Play()
RadioAlerted.Stop()
FlareAlarmVFXCreator.Toggle()
# Placer la base en état d'alerte en allumant les lumières jaunes et en jouant une musique tendue
SetAlertedMood():void=
for(LightsToTurnOn: CustomizableLightDevicesAlerted):
LightsToTurnOn.TurnOn()
for(LightsToTurnOff: CustomizableLightDevicesCombat):
LightsToTurnOff.TurnOff()
RadioCombat.Stop()
RadioAlerted.Play()
# Placer les appareils du mode Créatif en boucle pour les lumières avec cette balise Verse spécifique et les enregistrer dans une liste
FindLightsWithTag() : void=
TaggedAlertedLightDevices := GetCreativeObjectsWithTag(alerted_lights_tag{})
TaggedCombatLightDevices := GetCreativeObjectsWithTag(combat_lights_tag{})
for(AlertedLight : TaggedAlertedLightDevices, CustomizableLight := customizable_light_device[AlertedLight] ):
CustomizableLight.TurnOff()
set CustomizableLightDevicesAlerted += array{CustomizableLight}
for(CombatLight : TaggedCombatLightDevices, CustomizableLight := customizable_light_device[CombatLight] ):
CustomizableLight.TurnOff()
set CustomizableLightDevicesCombat += array{CustomizableLight}
Vous venez de créer un jeu d'infiltration en forteresse.