Cette section décrit comment ajouter le script Verse et placer l'appareil Verse pour personnaliser le gameplay.

Accédez à Verse > Explorateur Verse pour créer un script Verse.

Ensuite, faites un clic droit sur le nom du fichier de votre projet et sélectionnez Ajouter un nouveau fichier Verse au projet.

Sélectionnez Appareil Verse, nommez l'appareil et cliquez sur Créer. Dans ce tutoriel, l'appareil Verse est appelé Stronghold_Game_Manager.

Double-cliquez sur le fichier Verse de l'appareil pour afficher le script Verse. Copiez et collez le code ci-dessous.
using { /Fortnite.com/AI }
using { /Fortnite.com/Characters }
using { /Fortnite.com/Devices }
using { /Fortnite.com/Game }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Verse.org/Simulation }
using { /Verse.org/Verse }
# La forteresse est un mode de jeu dans lequel l'objectif des joueurs est d'éliminer tous les ennemis hostiles d'une forteresse lourdement gardée
# L'appareil Verse Gestionnaire de jeu de forteresse permet de gérer, de surveiller et de contrôler les IA de la forteresse.
stronghold_game_manager := class(creative_device):
# Référence à l'appareil générateur de gardes pour suivre les éliminations
@editable
GuardsInitialSpawners:[]guard_spawner_device := array{}
# Référence à l'appareil générateur de gardes pour suivre les éliminations en vue des ajustements multijoueurs
@editable
GuardsInitialSpawnersAdditional:[]guard_spawner_device := array{}
# Référence à l'appareil générateur de gardes de renfort à déclencher lorsqu'un des gardes de la forteresse est en état d'alerte
@editable
GuardsReinforcementSpawners:[]guard_spawner_device := array{}
# Référence à l'appareil générateur de gardes de renfort à déclencher lorsque l'un des gardes de la forteresse est en état d'alerte en vue des ajustements multijoueurs
@editable
GuardsReinforcementSpawnersAdditional:[]guard_spawner_device := array{}
# Référence d'appareil pour l'affichage et le suivi des objectifs
@editable
ObjectiveTracker:tracker_device := tracker_device{}
# Référence d'appareil pour l'affichage du message relatif aux renforts dans le jeu
@editable
MessageDeviceReinforcement:hud_message_device := hud_message_device{}
# Référence d'appareil pour l'affichage du message de repli dans le jeu
@editable
MessageDeviceFallback:hud_message_device := hud_message_device{}
# Référence d'appareil permettant de terminer la partie par une victoire si les joueurs prennent le contrôle de la forteresse sans se faire repérer
@editable
EndGameVictoryDeviceUndetected:end_game_device := end_game_device{}
# Référence d'appareil permettant de terminer la partie par une victoire si les joueurs prennent le contrôle de la forteresse bien qu'ils aient été repérés
@editable
EndGameVictoryDeviceDetected:end_game_device := end_game_device{}
# Référence d'appareil permettant de terminer la partie par un échec si les joueurs n'ont plus de tentatives restantes.
@editable
EndGameFailDevice:end_game_device := end_game_device{}
# Nombre réglable de vies des joueurs
@editable
var PlayerRetries:int = 2
# Appareil permettant de référencer la position de laisse de la forteresse
@editable
ReinforcementLeashReference:stronghold_leash_position := stronghold_leash_position{}
# Appareil permettant de référencer la position de laisse de repli
@editable
FallbackLeashReference:stronghold_leash_position := stronghold_leash_position{}
# Laisses à désactiver après le repli
@editable
LeashesToDisableForFallback:[]stronghold_leash_position := array{}
# Appareil pour l'explosion
@editable
ExplosiveDevice:explosive_device := explosive_device{}
# La perception des gardes est surveillée par ce script ; les autres scripts peuvent s'abonner à ces événements.
# Événement diffusé lorsqu'un garde appelle des renforts
ReinforcementsCalledEvent:event(agent) = event(agent){}
# Événement diffusé lorsque des gardes défendent le centre de la forteresse
FallbackEvent:event() = event(){}
# Événement diffusé lorsqu'un garde devient méfiant
GuardsSuspiciousEvent:event(agent) = event(agent){}
# Événement diffusé lorsqu'aucun garde n'est en état d'alerte
GuardsUnawareEvent:event(agent) = event(agent){}
# Événement diffusé lorsqu'un joueur est détecté
PlayerDetectedEvent:event(agent) = event(agent){}
# Événement diffusé lorsque tous les gardes ont perdu leur cible
PlayerLostEvent:event(agent) = event(agent){}
# Listes de gardes dans un état d'alerte spécifique pour surveiller les changements de perception
# Variable permettant de stocker les gardes de renfort
var<private> NumGuardsSpawned:int := 0
# Variable permettant de stocker tous les gardes de la forteresse
var<private> StrongholdGuards:[]agent := array{}
# Variable permettant de stocker les gardes de renfort
var<private> ReinforcementGuards:[]agent := array{}
# Liste des gardes actuellement méfiants
var<private> SuspiciousGuards : []agent = array{}
# Liste des gardes actuellement en alerte
var<private> AlertedGuards : []agent = array{}
# Liste des gardes effectuant des recherches
var<private> InvestigatingGuards : []agent = array{}
# Les générateurs de gardes d'origine, y compris les générateurs supplémentaires avec session multijoueurs
var<private> GuardsInitialSpawnersInternal:[]guard_spawner_device = array{}
# Les générateurs de gardes de renfort, y compris les générateurs supplémentaires avec session multijoueurs
var<private> GuardsReinforcementSpawnersInternal:[]guard_spawner_device = array{}
# Variables de logique de jeu
# Variable permettant de suivre le nombre d'éliminations de tous les générateurs de gardes de la forteresse.
var<private> GuardsEliminated:int := 0
# Variable permettant de savoir si des renforts ont été appelés ou non
var<private> ReinforcementTriggered:logic := false
# Variable permettant de savoir si le repli a été déclenché
var<private> FallbackTriggered:logic := false
# Variable permettant de stocker le premier agent joueur détecté par les gardes
var<private> DetectedPlayer:?player := false
# S'exécute lorsque l'appareil est démarré dans une partie en cours.
OnBegin<override>()<suspends>:void=
# Contrôler les joueurs actifs pour ajuster la difficulté
AllPlayers := GetPlayspace().GetPlayers()
NumberOfActivePlayers := AllPlayers.Length
set GuardsInitialSpawnersInternal = GuardsInitialSpawners
set GuardsReinforcementSpawnersInternal = GuardsReinforcementSpawners
# Ajouter un générateur de gardes supplémentaire lorsqu'il y a plus de 2 joueurs
if (NumberOfActivePlayers > 2):
set GuardsInitialSpawnersInternal += GuardsInitialSpawnersAdditional
set GuardsReinforcementSpawnersInternal += GuardsReinforcementSpawnersAdditional
var NumInitialGuards:int = 0
for (GuardSpawner : GuardsInitialSpawnersInternal):
GuardSpawner.Enable()
SubscribeToGuardSpawnerEvents(GuardSpawner);
set NumInitialGuards += GuardSpawner.GetSpawnLimit()
ObjectiveTracker.SetTarget(NumInitialGuards)
for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
SubscribeToGuardSpawnerEvents(GuardReinforcementSpawner);
# Abonnement à un événement généré par les renforts
GuardReinforcementSpawner.SpawnedEvent.Subscribe(OnReinforcementSpawned)
GuardReinforcementSpawner.AlertedEvent.Subscribe(OnReinforcementAlerted)
GuardReinforcementSpawner.UnawareEvent.Subscribe(OnReinforcementUnaware)
# Abonnement à l'événement d'élimination de joueurs
for (StrongholdPlayer : AllPlayers, StrongholdPC := StrongholdPlayer.GetFortCharacter[]):
StrongholdPC.EliminatedEvent().Subscribe(OnPlayerEliminated)
StartGameplay()
SubscribeToGuardSpawnerEvents(SpawnerDevice:guard_spawner_device):void =
SpawnerDevice.SpawnedEvent.Subscribe(OnGuardSpawned)
SpawnerDevice.EliminatedEvent.Subscribe(OnGuardEliminated)
SpawnerDevice.SuspiciousEvent.Subscribe(OnGuardSuspicious)
SpawnerDevice.AlertedEvent.Subscribe(OnGuardAlerted)
SpawnerDevice.TargetLostEvent.Subscribe(OnGuardLostTarget)
SpawnerDevice.UnawareEvent.Subscribe(OnGuardUnaware)
# Commencer à suivre les gardes éliminés et déclencher l'explosion
StartGameplay()<suspends>:void =
ObjectiveTracker.AssignToAll()
Sleep(3.0)
if (FirstPlayer:=GetPlayspace().GetPlayers()[0]):
ExplosiveDevice.Explode(FirstPlayer)
# S'exécute lorsque le générateur de gardes reçoit un événement d'alerte et ne prend en compte que le premier événement d'alerte.
OnGuardAlerted(InteractionResult:device_ai_interaction_result):void=
if:
not ReinforcementTriggered?
set DetectedPlayer = option{player[InteractionResult.Target?]}
Guard:=InteractionResult.Source?
then:
var NumGuards:int = ObjectiveTracker.GetTarget()
# L'activation de l'appareil générateur de gardes de renfort nous permet de nous assurer que nous générons le nombre de gardes configuré dans l'appareil générateur de gardes.
for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
GuardReinforcementSpawner.Enable()
set NumGuards += GuardReinforcementSpawner.GetSpawnLimit()
ObjectiveTracker.SetTarget(NumGuards)
# Affichage d'un message dans le jeu en cas de détection et d'arrivée de renforts
MessageDeviceReinforcement.Show()
set ReinforcementTriggered = true
# Signaler l'événement d'appel de renforts
ReinforcementsCalledEvent.Signal(Guard)
# Ajouter le garde à la liste des gardes en alerte s'il n'y figurait pas déjà
if(Guard:=InteractionResult.Source?):
if (not AlertedGuards.Find[Guard]):
set AlertedGuards += array{Guard}
option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[Guard]}
option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[Guard]}
# Diffuser l'événement de détection de joueur lorsqu'un garde est en état d'alerte
if (AlertedGuards.Length = 1):
PlayerDetectedEvent.Signal(Guard)
# S'exécute lorsque le générateur de gardes de renfort reçoit un événement d'alerte
OnReinforcementAlerted(InteractionResult:device_ai_interaction_result):void=
if:
not FallbackTriggered?
Guard:=InteractionResult.Source?
then:
# Désactiver la laisse de renfort en cas d'alerte afin qu'ils attaquent leur cible.
ReinforcementLeashReference.ClearLeashOnGuard(Guard)
# S'exécute lorsque le générateur de gardes de renfort reçoit un événement d'absence d'état d'alerte
OnReinforcementUnaware(Guard:agent):void=
if (not FallbackTriggered?):
# Remettre la laisse en place
ReinforcementLeashReference.ApplyLeashOnGuard(Guard)
# S'exécute lorsque le générateur de gardes reçoit un événement d'absence d'état d'alerte
OnGuardSuspicious(Guard:agent):void=
if (not SuspiciousGuards.Find[Guard]):
set SuspiciousGuards += array{Guard}
# Diffuser l'événement de méfiance lorsqu'un garde devient méfiant
if:
SuspiciousGuards.Length = 1
AlertedGuards.Length = 0
InvestigatingGuards.Length = 0
then:
GuardsSuspiciousEvent.Signal(Guard)
# S'exécute lorsque le générateur de gardes reçoit un événement d'absence d'état d'alerte
OnGuardUnaware(Guard:agent):void=
option {set AlertedGuards = AlertedGuards.RemoveFirstElement[Guard]}
option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[Guard]}
option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[Guard]}
# Diffuser l'événement d'absence d'état d'alerte lorsqu'aucun garde n'est méfiant, en état d'alerte ou en train d'effectuer des recherches
if:
SuspiciousGuards.Length = 0
AlertedGuards.Length = 0
InvestigatingGuards.Length = 0
then:
GuardsUnawareEvent.Signal(Guard)
# Retirer un garde de la liste des gardes en état d'alerte lorsqu'il perd la trace du joueur et signaler l'événement lorsque tous les gardes ont perdu la trace du joueur
OnGuardLostTarget(InteractionResult:device_ai_interaction_result):void=
if (Guard := InteractionResult.Source?):
if (not InvestigatingGuards.Find[Guard]):
set InvestigatingGuards += array{Guard}
# Diffuser l'événement Joueur perdu de vue lorsqu'aucun garde n'est en état d'alerte
if (set AlertedGuards = AlertedGuards.RemoveFirstElement[Guard]):
if (AlertedGuards.Length = 0):
PlayerLostEvent.Signal(Guard)
# S'exécute lorsqu'un garde de renfort est généré. Tous les gardes doivent attaquer le joueur qui a mis la forteresse en état d'alerte
OnReinforcementSpawned(Guard:agent):void=
set ReinforcementGuards += array{Guard}
ReinforcementLeashReference.ApplyLeashOnGuard(Guard)
# Désigne comme cible le joueur qui a mis les gardes de la forteresse en état d'alerte
if (Target := DetectedPlayer?):
for (GuardReinforcementSpawner : GuardsReinforcementSpawnersInternal):
GuardReinforcementSpawner.ForceAttackTarget(Target, ?ForgetTime:=30.0)
# S'exécute à toute apparition d'un garde de la forteresse
OnGuardSpawned(Guard:agent):void=
set StrongholdGuards += array{Guard}
set NumGuardsSpawned += 1
# S'exécute lorsque les générateurs de gardes initiaux ou de renfort reçoivent une élimination
OnGuardEliminated(InteractionResult:device_ai_interaction_result):void=
set GuardsEliminated += 1
if (EliminatedAgent := InteractionResult.Target?):
# Supprimer le garde éliminé de la liste des gardes en alerte
option {set AlertedGuards = AlertedGuards.RemoveFirstElement[EliminatedAgent]}
option {set SuspiciousGuards = SuspiciousGuards.RemoveFirstElement[EliminatedAgent]}
option {set InvestigatingGuards = InvestigatingGuards.RemoveFirstElement[EliminatedAgent]}
option {set StrongholdGuards = StrongholdGuards.RemoveFirstElement[EliminatedAgent]}
if (EliminationAgent := InteractionResult.Source?):
# Augmentation de la valeur de progression de l'appareil de suivi à chaque élimination
ObjectiveTracker.Increment(EliminationAgent)
if (ReinforcementTriggered?):
if (NumGuardsSpawned - GuardsEliminated = 3):
StartFallback()
# Met fin au mode de jeu si tous les gardes ont été éliminés sans les renforts
if (GuardsEliminated >= NumGuardsSpawned):
EndGameVictoryDeviceDetected.Activate(EliminationAgent)
else:
# Met fin au mode de jeu si tous les gardes ont été éliminés avec les renforts
if (GuardsEliminated >= NumGuardsSpawned):
EndGameVictoryDeviceUndetected.Activate(EliminationAgent)
# Attribue une nouvelle laisse de repli lorsqu'il ne reste plus que quelques gardes en alerte pour défendre le centre de la forteresse
StartFallback():void=
# Affichage d'un message dans le jeu pour les gardes qui battent en retraite à l'intérieur du bâtiment de la forteresse
MessageDeviceFallback.Show()
set FallbackTriggered = true
for (LeashDevice : LeashesToDisableForFallback):
LeashDevice.DisableLeashAndPatrolPaths()
FallbackLeashPosition := FallbackLeashReference.GetTransform().Translation
FallbackEvent.Signal()
for (Guard : StrongholdGuards):
FallbackLeashReference.ApplyLeashOnGuard(Guard)
# S'exécute à la réception d'un événement d'élimination de joueur
OnPlayerEliminated(EliminationResult:elimination_result):void=
set PlayerRetries -= 1
if (PlayerRetries = 0, Agent := EliminationResult.EliminatedCharacter.GetAgent[]):
EndGameFailDevice.Activate(Agent)

Ensuite, rejoignez Verse > Générer le code Verse pour compiler le script Verse.

Accédez à All/"Nom du projet"/CreativeDevices/ et sélectionnez votre appareil Verse.

Faites ensuite glisser votre appareil Verse sur votre carte. Il n'apparaîtra qu'une fois le script Verse compilé.
Une fois votre appareil Verse sélectionné, accédez au panneau Détails et mettez à jour les Options utilisateur comme indiqué ci-dessous.

Option | Valeur | Explication |
---|---|---|
Visible pendant le jeu | False | Cet appareil ne sera pas visible pendant la partie. |
Guards_InitialSpawners | 3 éléments de matrice | Cliquez sur le signe plus (+) pour ajouter trois éléments à ce paramètre. |
0 | Générateur de gardes | Il s'agit d'une matrice de tous les appareils utilisés pour faire apparaître les premiers gardes dans la forteresse. |
1 | Générateur de gardes - Tour de sniper 1 | Il s'agit d'une matrice de tous les appareils utilisés pour faire apparaître les premiers gardes dans la forteresse. |
2 | Générateur de gardes - Tour de sniper 2 | Il s'agit d'une matrice de tous les appareils utilisés pour faire apparaître les premiers gardes dans la forteresse. |
Guards_ReinforcementSpawner | Générateur de gardes de renfort | Fait apparaître les gardes de renfort. |
Traqueur d'objectif | Traqueur | Affiche les objectifs de la forteresse et le nombre d'éliminations. |
MessageDeviceReinforcement | Appareil de message d'ATH - Renforts | Affiche à l'écran le message relatif aux renforts. |
MessageDeliverFallback | Appareil de message d'ATH - Repli | Affiche le message de repli à l'écran. |
EndGameVictoryDeviceUndetected | Appareil de fin de partie - Non-détection | Affiche l'écran de victoire et de non-détection. |
EndGameVictoryDeviceDetected | Appareil de fin de partie - Détection | Affiche l'écran de victoire malgré la détection. |
EndGameFailDevice | Appareil de fin de partie - Échec | Affiche le message d'échec parce que le joueur a épuisé toutes ses vies. |
EliminationCount | 6 | Détermine le nombre d'éliminations de gardes nécessaires pour prendre le contrôle de la forteresse sans se faire repérer. |
EliminationCountWithReinforcement | 10 | Détermine le nombre d'éliminations de gardes nécessaires pour prendre le contrôle de la forteresse avec déclenchement de renforts. |
PlayerRetries | 2 | Détermine le nombre de vies dont dispose le joueur pour tenter de prendre le contrôle de la forteresse. Si le joueur n'a plus de vies, cela constitue un échec. |
StrongholdLeashReferernce | Position de laisse - Forteresse | L'appareil Position de laisse utilise sa position comme origine de la laisse de forteresse. |
FallbackLeashReference | Position de laisse - Repli | L'appareil Position de laisse utilise sa position comme origine de la laisse de repli. |
StrongholdLeashInnerRadius | 2400,0 | Définit le rayon intérieur de la laisse de la forteresse (en centimètres). Doit être inférieur au rayon extérieur. |
StrongholdLeashOuterRadius | 2500,0 | Définit le rayon extérieur de la laisse de la forteresse. |
DefendFallbackLeashInnerRadius | 700,0 | Définit le rayon intérieur de la laisse de repli pour la défense (en centimètres). Doit être inférieur au rayon extérieur. |
DefendFallbackLeashOuterRadius | 750,0 | Définit le rayon extérieur de la laisse de repli pour la défense (en centimètres). |
Section suivante
%verse-stronghold-template-4-add-devices-in-unreal-editor-for-fortnite:topic%