1. Epic GamesDeveloper
  3. Utwórz własną postać niezależną medyka

Utwórz własną postać niezależną medyka

Użyj kodu Verse, aby utworzyć niestandardową postać niezależną medyka.

Utwórz własną postać niezależną medyka

Medycy to typowy archetyp postaci często spotykany w wielu grach. Zadanie medyka to leczenie przebywających w pobliżu postaci, medycy pomagają towarzyszom z drużyny w dojściu do siebie po odniesieniu obrażeń. W zależności od gry, medycy pełnią różne role, np. doktorzy obsługują pacjentów w szpitalu, sanitariusze polowi pomagają drużynie w walce i leczeniu rannych, istnieją też stacje neutralne, które leczą wszystkich.

Tworzona w tym przykładzie postać medyka zachowuje się zgodnie z szeregiem reguł logicznych.

  • Bezczynność:
  • Rozpoczęcie leczenia agentów
  • Pętla leczenia
  • Nawigacja do agenta

Medyk rozpoczyna jako bezczynny i patroluje teren, aż do strefy leczenia wejdzie jakiś agent. Ten agent jest dodany do kolejki leczenia u medyka. Medyk musi śledzić agenta, którego ma leczyć w następnej kolejności, a kolejka zawiera strukturę danych przydatną do tego celu, ponieważ kolejki mają strukturę danych typu pierwszy na wejściu - pierwszy na wyjściu. To oznacza, że postać, która wejdzie do strefy leczenia jako pierwsza, zostanie wyleczona jako pierwsza.

Gdy medyk dostanie się do agenta, którego ma wyleczyć w następnej kolejności, najpierw sprawdza, czy zdrowie agenta spadło poniżej progu leczenia. Jeśli tak jest, zaczyna go leczyć z określoną szybkością, dopóki zdrowie agenta nie osiągnie wartości progowej lub dopóki agent nie opuści strefy leczenia. Podczas leczenia medyk będzie próbował pozostawać w pobliżu agenta, stale nawigując w jego kierunku. Gdy zdrowie agenta osiągnie wymaganą wartość progową, medyk przejdzie do kolejnego agenta, którego ma wyleczyć, ponownie rozpoczynając cały proces. Jeśli nie ma żadnych agentów, których trzeba wyleczyć, medyk powróci do stanu bezczynności.

Logikę postaci niezależnej medyka można zwizualizować za pomocą poniższego tzw. automatu skończonego. Aby dowiedzieć się więcej na temat automatów skończonych, przeczytaj stronę Rozumienie zachowań postaci niezależnych.

Automat skończony medyka

Z tego przewodnika dowiesz się, jak tworzyć niestandardową postać medyka przy użyciu skryptu zachowania postaci niezależnej, medyk będzie leczył postacie w pobliżu, gdy ich zdrowie spadnie poniżej określonej wartości progowej. Do celów odniesienia, na końcu tego przewodnika znajduje się kompletny skrypt.

Tworzenie nowego skryptu zachowania postaci niezależnej

Aby rozpocząć tworzenie własnej postaci niezależnej medyka, utwórz nowy skrypt zachowania postaci niezależnej o nazwie medic_example. Więcej informacji na temat tworzenia własnego skryptu zachowania postaci niezależnej można znaleźć na stronie Utwórz własne zachowanie postaci niezależnej. Otwórz plik Verse w Visual Studio Code.

Wykonaj te kroki, aby w UEFN utworzyć skrypt zachowania postaci niezależnej, który spawnuje postać medyka leczącego graczy w jego pobliżu.

Implementowanie kolejki do leczenia

Skrypt zachowania postaci niezależnej rozpoczyna się od kilku wartości używanych do ruchu postaci i wizualizacji debugowania. Nie potrzebujesz w skrypcie ich wszystkich, dlatego usuniesz teraz niepotrzebny kod.

  1. Na początku definicji klasy medic_example usuń wartości przed OnBegin(). Medyk nie będzie czekał na podejście do postaci, zamiast tego będzie podczas leczenia podążał za nimi. W tym przykładzie nie potrzebujesz wartości debugowania, użyjesz innych obiektów do wizualizacji, kiedy twój medyk leczy postacie.

  2. W OnBegin(), po pobraniu interfejsów postaci w pierwszej instrukcji if, usuń kod wewnątrz instrukcji then. Medyk nie musi po zespawnowaniu wchodzić w pętlę między punktami, zamiast tego będzie patrolował teren wokół swojego punktu spawnu, w oczekiwaniu na postacie do wyleczenia.

  3. Usuń funkcje DrawDebugLocation() i DrawDebugLookAt(). W tym przykładzie nie są używane wartości debugowania, dlatego nie potrzebujesz też powiązanych funkcji, które ich używają.

Po usunięciu niepotrzebnego kodu możesz rozpocząć tworzenie postaci medyka.

  1. Na początku definicji klasy medic_example dodaj następujące wartości:

    1. edytowalna wartość float HealingThreshold. Jest to wartość progowa zdrowia, poniżej której muszą się znaleźć postacie, aby otrzymać leczenie.

       # Wartość progowa PZ, poniżej której musi spaść postać, aby można ją było wyleczyć.
 @editable
 HealingThreshold:float = 50.0

    2. Dodaj edytowalną wartość float HealingDelay. Jest to ilość czasu oczekiwania między każdą instancją leczenia podczas leczenia postaci. Zmień ją w zależności od tego, czy chcesz, aby medyk leczył szybciej, czy wolniej.

       # Wartość progowa PZ, poniżej której musi spaść postać, aby można ją było wyleczyć.
 @editable
 HealingThreshold:float = 50.0
    
 # Jak długo czekać między leczeniem postaci
 @editable
 HealingDelay:float = 1.5

    3. Edytowalna wartość float HealingAmount. Jest to ilość zdrowia, o jaką będą leczone postacie w każdej instancji leczenia. Gdy postać niezależna medyka leczy jakąś postać, będzie ją leczyła o określoną ilość HealingAmount co każde HealingDelay liczone w sekundach.

       # Jak długo czekać między leczeniem postaci
 @editable
 HealingDelay:float = 1.5
    
 # O ile punktów leczyć postacie w każdej instancji leczenia
 @editable
 HealingAmount:float = 5.0

    4. Edytowalna strefa mutatora HealVolume. Wolumen, do którego wchodzą postacie, aby otrzymać leczenie. W tym przykładzie użyjesz strefy mutatora, ponieważ strefa mutatora ma zdarzenie AgentEntersEvent, które medyk może zasubskrybować i którego może użyć do sprawdzenia, czy istnieją postacie wymagające leczenia.

       # O ile punktów leczyć postacie w każdej instancji leczenia
 @editable
 HealingAmount:float = 5.0
    
 # Wolumen, do którego wchodzą postacie, aby otrzymać leczenie.
 @editable
 HealVolume:mutator_zone_device = mutator_zone_device{}

    5. Edytowalny generator efektów wizualnych VFXSpawner. Wizualna informacja zwrotna jest ważna, ponieważ pokazuje, czy kod działa, dlatego użyjesz generatora efektów wizualnych, aby spawnować efekty w trakcie leczenia postaci.

       # Wolumen, do którego wchodzą postacie, aby otrzymać leczenie.
 @editable
 HealVolume:mutator_zone_device = mutator_zone_device{}
    
 # Generator efektów wizualnych odtwarzający efekty wizualne w trakcie leczenia postaci.
 @editable
 VFXSpawner:vfx_spawner_device = vfx_spawner_device {}

    6. Zmienny opcjonalny agent o nazwie AgentToFollow. Przechowuje odwołanie do postaci, za którą ma podążać medyk podczas jej leczenia.

       # Generator efektów wizualnych odtwarzający efekty wizualne w trakcie leczenia postaci.
 @editable
 VFXSpawner:vfx_spawner_device = vfx_spawner_device {}
    
 # Agent, za którym ma podążać medyk w trakcie leczenia
 var AgentToFollow:?agent = false

    7. Zmienna kolejka agentów o nazwie AgentsToHeal. Jeśli leczenia potrzebuje wiele postaci, medyk będzie je leczył według kolejności, w jakiej weszły do HealVolume. Kod kolejki skonfigurujesz w następnym kroku. W celu uzyskania dodatkowych informacji na temat struktury danych kolejki przeczytaj stronę stosy i kolejki w Verse.

       # Agent, za którym ma podążać medyk w trakcie leczenia
 var AgentToFollow:?agent = false
        
 # Kolejka agentów do wyleczenia w przypadku, gdy do wolumenu leczenia wchodzi wielu agentów.
 var AgentsToHeal<public>:queue(agent) = queue(agent){}

    8. Zmienna wartość float UpdateRateSeconds. Jest to ilość czasu oczekiwania między aktualizacją pozycji HealVolume i VFXSpawner.

       # Kolejka agentów do wyleczenia w przypadku, gdy do wolumenu leczenia wchodzi wielu agentów.
 var AgentsToHeal<public>:queue(agent) = queue(agent){}
    
 # Używane do określenia, jak szybko aktualizować pozycję HealVolume i VFXSpawner
 UpdateRateSeconds<private>:float = 0.1

  2. Aby zaimplementować kolejkę AgentsToHeal, użyjesz kodu podanego pod koniec tego kroku.

    1. Wróć do Eksploratora Verse, kliknij PPM nazwę projektu i wybierz Dodaj nowy plik Verse do projektu, aby otworzyć okno Utwórz skrypt Verse.
    Dodaj nowy plik Verse do projektu

    1. W oknie Utwórz skrypt Verse kliknij Klasa Verse, aby wybrać ją jako swój skrypt.

    2. Nadaj nazwę klasie Verse, zmieniając tekst w polu Nazwa klasy na queue.

    3. Kliknij opcję Utwórz, aby utworzyć plik Verse.

    4. W Eksploratorze Verse kliknij dwukrotnie nazwę pliku Verse, aby go otworzyć w Visual Studio Code.

    5. Zastąp kod w pliku queue następującym kodem. Ten kod implementuje rodzajową kolejkę typu type przy użyciu struktury danych listy. Jest to przykład typu parametrycznego, ponieważ implementacja kolejki będzie działała niezależnie od typu, z którego się ją utworzy. W przykładzie użyjesz kolejki postaci, dlatego definicja kolejki w medic_example będzie queue(agent).

       list(t:type) := class:
     Data:t
     Next:?list(t)
    
 queue<public>(t:type) := class<internal>:
     Elements<internal>:?list(t) = false
     Size<public>:int = 0
        
     Enqueue<public>(NewElement:t):queue(t) =
         queue(t):
             Elements := option:
                 list(t):
                     Data := NewElement
                     Next := Elements
             Size := Size + 1
    
     Dequeue<public>()<decides><transacts>:tuple(queue(t), t) =
         List := Elements?
         (queue(t){Elements := List.Next, Size := Size - 1}, List.Data)
    
     Front<public>()<decides><transacts>:t = Elements?.Data
    
 CreateQueue<public><constructor>(InData:t where t:type) := queue(t):
     Elements := option:
         list(t):
             Data := InData
             Next := false
     Size := 1

    6. Umieszczenie skryptów Verse w odrębnych folderach pomaga w organizacji pracy oraz umożliwia łatwe odwoływanie się do często używanych plików. Przykładowo, utworzysz folder, w którym będą przechowywane zachowania postaci niezależnej w tym projekcie. W Visual Studio Code naciśnij przycisk Nowy folder, aby utworzyć nowy folder w projekcie UEFN. Folderowi nadaj nazwę npc_behaviors. Przeciągnij plik Verse medic_example do nowego folderu.

Kod w medic_example powinien się teraz prawidłowo skompilować.

Leczenie postaci wewnątrz wolumenu

Gdy do HealVolume wejdzie zraniona postać, medyk powinien zacząć ją leczyć, gdy zdrowie postaci jest mniejsze niż wartość progowa HealingThreshold. Gdy zdrowie postaci przekroczy wartość HealingThreshold, medyk powinien przestać leczyć tę postać i przejść do kolejnej postaci, która wymaga leczenia. W przypadku wielu postaci, medyk powinien je leczyć według kolejności, w której weszły do HealVolume. Wykonaj te kroki, aby leczyć postacie, gdy wejdą do HealVolume.

  1. Wróć do pliku medic_example, w części OnBegin() po instrukcji then rozpocznij pętlę loop. Wewnątrz loop pobierz wynik funkcji Dequeue() z kolejki AgentsToHeal i zapisz go w zmiennej DequeueResult.

     then:
     loop:
         # Pobierz kolejnego agenta z kolejki do leczenia. Jeśli istnieje agent, który ma być wyleczony, wylecz go, wywołując AgentToHeal.
         # Jeśli nie ma agentów do leczenia, poczekaj, aż do HealVolume wejdzie jakiś agent
         if:
             DequeueResult := AgentsToHeal.Dequeue[]

  2. Zmienna DequeueResult jest krotką tuple, która zwraca zarówno kopię kolejki AgentsToHeal z usuniętym pierwszym elementem, jak i agenta na początku kolejki. Zaktualizuj AgentsToHeal, ustawiając ją na pierwszą wartość w krotce, i zapisz drugą wartość jako AgentToHeal.

     if:
     DequeueResult := AgentsToHeal.Dequeue[]
     set AgentsToHeal = DequeueResult(0)
     AgentToHeal := DequeueResult(1)

  3. Gdy masz już agenta do leczenia, musisz zacząć go leczyć, dopóki przebywa w HealVolume. W tym celu zdefiniujesz nową funkcję o nazwie HealCharacter(). Dodaj nową funkcję o nazwie HealCharacter() do definicji klasy medic_example. Ta funkcja przyjmuje AgentToHeal oraz oba interfejsy postaci medyka, Navigatable i Focusable, jako argumenty funkcji. Dodaj do tej funkcji modyfikator <suspends>, ponieważ musi ona wykonywać kilka zadań asynchronicznych podczas leczenia postaci.

     # Wylecz postać, następnie odczekaj ilość czasu określoną przez HealingDelayAmount.
 # Kończy się, gdy zdrowie postaci osiągnie wartość HealingThreshold
 # lub gdy postać opuści HealVolume.
 HealCharacter(AgentToHeal:agent, Navigatable:navigatable, Focusable:focus_interface)<suspends>:void=

  4. W HealCharacter sprawdź, czy AgentToHeal znajduje się wewnątrz wolumenu, wywołując IsInVolume[] i przekazując AgentToHeal jako argument. Jeśli agent znajduje się wewnątrz wolumenu, możesz zacząć go leczyć. Wszyscy możliwi do wyleczenia agenci implementują interfejs healthful, który stanowi część fort_character agenta. Pobierz fort_character agenta i zapisz go w wartości CharacterToHeal.

     HealCharacter(AgentToHeal:agent, Navigatable:navigatable, Focusable:focus_interface)<suspends>:void=
     # Lecz postać tylko, gdy znajduje się wewnątrz HealVolume
     if:
         HealVolume.IsInVolume[AgentToHeal]
         CharacterToHeal := AgentToHeal.GetFortCharacter[]

  5. Gdy postać jest gotowa do leczenia, musisz mieć pewność, że medyk pozostaje w pobliżu leczonej postaci. Utwórz navigation_target z AgentToHeal przy użyciu MakeNavigationTarget i zapisz go w zmiennej NavigationTarget. Następnie w instrukcji branch wywołaj funkcję NavigateTo() przy użyciu interfejsu navigatable postaci niezależnej, aby medyk nawigował do AgentToHeal. Ponadto, w funkcji branch wywołaj funkcję MaintainFocus(), aby mieć pewność, że medyk skupia się na AgentToHeal. Użycie instrukcji branch w tym kontekście pozwala na jednoczesne asynchroniczne wykonanie zarówno NavigateTo(), jak i MaintainFocus() i umożliwia niezwłoczne wykonanie dowolnego kodu po branch. W celu uzyskania dodatkowych informacji o wyrażeniach branch przeczytaj stronę Wyrażenie branch w języku Verse.

     # Lecz postać tylko, gdy znajduje się wewnątrz HealVolume
 if:
     HealVolume.IsInVolume[AgentToHeal]
     CharacterToHeal := AgentToHeal.GetFortCharacter[]
 then:      
     Print("Postać jest wewnątrz wolumenu, rozpoczynanie leczenia")
     NavigationTarget := MakeNavigationTarget(AgentToHeal)
     branch:
         Navigatable.NavigateTo(NavigationTarget)
         Focusable.MaintainFocus(AgentToHeal)

  6. Włącz VFXSpawner, aby odtwarzać efekty wizualne w trakcie leczenia postaci przez medyka. Następnie w wyrażeniu defer wyłącz VFXSpawner. Kod wyłączający VFXSpawner znajduje się w wyrażeniu defer, dlatego nie zostanie wykonany, dopóki nie wyjdziemy z bieżącego zakresu. W danej sytuacji oznacza to, że kod zostanie wykonany tylko, gdy funkcja się zakończy, co gwarantuje, że będzie to ostatnia rzecz zrealizowana w funkcji. W celu uzyskania dodatkowych informacji o wyrażeniach defer przeczytaj stronę defer.

     branch:
     Navigatable.NavigateTo(NavigationTarget)
     Focusable.MaintainFocus(AgentToHeal)
    
 VFXSpawner.Enable()
    
 defer:
     VFXSpawner.Disable()

  7. Podczas leczenia CharacterToHeal, leczenie powinno zostać przerwane, gdy wystąpi jeden z dwóch warunków. Albo postać zostanie wyleczona na tyle, że jej zdrowie przekroczy wartość HealingThreshold, albo postać opuści HealVolume. Aby to osiągnąć, użyjesz wyrażenia race. Skonfiguruj wyrażenie race między loop i Await() w HealVolume.AgentExitsEvent.

     branch:
     Navigatable.NavigateTo(NavigationTarget)
     Focusable.MaintainFocus(AgentToHeal)
 VFXSpawner.Enable()
 defer:
     VFXSpawner.Disable()
 race:
     loop:
     HealVolume.AgentExitsEvent.Await()

  8. Wewnątrz loop pobierz bieżące zdrowie postaci przy użyciu GetHealth() i zapisz je w wartości CurrentHealth. Następnie w instrukcji if sprawdź, czy CurrentHealth plus HealingAmount jest większe niż HealingThreshold. Jeśli tak jest, medyk powinien zakończyć leczenie i wyjść (instrukcja break) z pętli. Jeśli jednak bieżące zdrowie postaci jest tylko trochę niższe niż wartość progowa leczenia, medyk ma kontynuować leczenie aż do jej osiągnięcia. Dodaj drugą instrukcję if wewnątrz pierwszej, która będzie sprawdzała, czy CurrentHealth jest mniejsze niż HealingThreshold. Jeśli tak jest, ustaw zdrowie postaci na HealingThreshold.

     race:
     loop:
         CurrentHealth := CharacterToHeal.GetHealth()
         if(CurrentHealth + HealingAmount > HealingThreshold):
             if (CurrentHealth < HealingThreshold):
                 CharacterToHeal.SetHealth(HealingThreshold)
             PrintNPCB("Postać osiągnęła próg leczenia HealingThreshold, kończenie leczenia")
             break
     HealVolume.AgentExitsEvent.Await()

  9. W przeciwnym razie, jeśli CurrentHealth plus HealingAmount nie jest większe niż HealingThreshold, ustaw zdrowie postaci na Current Health plus HealingAmount.

     if(CurrentHealth + HealingAmount > HealingThreshold):
     if (CurrentHealth < HealingThreshold):
         CharacterToHeal.SetHealth(HealingThreshold)
     PrintNPCB("Postać osiągnęła próg leczenia HealingThreshold, kończenie leczenia")
     break
 else:
     CharacterToHeal.SetHealth(CurrentHealth + HealingAmount)

  10. Na końcu pętli loop, dodaj instrukcję sleep przez długość czasu równą HealingDelay. Bez instrukcji sleep postacie będą uzdrawiane co każdą aktualizację symulacji, opóźnienie HealingDelay zapobiegnie ich natychmiastowemu wyleczeniu. Gotowy kod HealCharacter() powinien wyglądać następująco.

     # Wylecz postać, następnie odczekaj ilość czasu określoną przez HealingDelayAmount.
 # Kończy się, gdy zdrowie postaci osiągnie wartość HealingThreshold
 # lub gdy postać opuści HealVolume.
 HealCharacter(AgentToHeal:agent, Navigatable:navigatable, Focusable:focus_interface)<suspends>:void=
     # Lecz postać tylko, gdy znajduje się wewnątrz HealVolume
     if:
         HealVolume.IsInVolume[AgentToHeal]
         CharacterToHeal := AgentToHeal.GetFortCharacter[]
     then:
         Print("Postać jest wewnątrz wolumenu, rozpoczynanie leczenia")
         NavigationTarget := MakeNavigationTarget(AgentToHeal)
         branch:
             Navigatable.NavigateTo(NavigationTarget)
             Focusable.MaintainFocus(AgentToHeal)
         VFXSpawner.Enable()
         defer:
             VFXSpawner.Disable()
         race:
             loop:
                 CurrentHealth := CharacterToHeal.GetHealth()
                 if(CurrentHealth + HealingAmount > HealingThreshold):
                     if (CurrentHealth < HealingThreshold):
                         CharacterToHeal.SetHealth(HealingThreshold)
                     PrintNPCB("Postać osiągnęła próg leczenia HealingThreshold, kończenie leczenia")
                     break
                 else:
                     CharacterToHeal.SetHealth(CurrentHealth + HealingAmount)
                 Sleep(HealingDelay)
                 HealVolume.AgentExitsEvent.Await()

  11. Wróć do OnBegin(), w wyrażeniu then wewnątrz loop wywołaj HealCharacter(), przekazując AgentToHeal, interfejs Navigatable i interfejs Focusable.

     if:
     DequeueResult := AgentsToHeal.Dequeue[]
     set AgentsToHeal = DequeueResult(0)
     AgentToHeal := DequeueResult(1)
 then:
     Print("Usunięto z kolejki kolejnego agenta do wyleczenia")
     HealCharacter(AgentToHeal, Navigatable, Focusable)

  12. Nie zawsze w pobliżu medyka będzie przebywała postać do wyleczenia, a funkcja Dequeue[] zakończy się niepowodzeniem, jeśli w kolejce AgentsToHeal nie ma agentów. Aby to obsłużyć, dodaj instrukcję else na końcu loop. Wewnątrz tej instrukcji if wywołaj Sleep() przez długość czasu równą HealingDelay, następnie wywołaj Await() z HealVolume.AgentEntersEvent. Dzięki temu medyk nie będzie bez przerwy wywoływał Dequeue[] na kolejce AgentsToHeal, zamiast tego przed ponownym uruchomieniem pętli będzie czekał, aż do HealVolume wejdzie nowa postać. Gotowy kod pętli powinien wyglądać następująco.

     loop:
     # Pobierz kolejnego agenta z kolejki do leczenia. Jeśli istnieje agent, który ma być wyleczony, wylecz go, wywołując AgentToHeal.
     # Jeśli nie ma agentów do leczenia, poczekaj, aż do HealVolume wejdzie jakiś agent
     if:
         DequeueResult := AgentsToHeal.Dequeue[]
         set AgentsToHeal = DequeueResult(0)
         AgentToHeal := DequeueResult(1)
     then:
         Print("Usunięto z kolejki kolejnego agenta do wyleczenia")
         HealCharacter(AgentToHeal, Navigatable, Focusable)
     else:
         Print("Kolejka AgentsToHeal jest pusta!")
         Sleep(HealingDelay)
         HealVolume.AgentEntersEvent.Await()

Śledzenie, kiedy w wolumenie leczenia przebywają postacie

Aby wiedzieć, kiedy postać wchodzi do wolumenu leczenia HealVolume lub go opuszcza, subskrybujesz zarówno AgentEntersEvent, jak i AgentExitsEvent z HealVolume` na nowe funkcje.

  1. Dodaj nową funkcję o nazwie OnAgentEnters() do definicji klasy medic_example. Ta funkcja przyjmuje agenta, który właśnie wszedł do HealVolume, i dodaje go do kolejki AgentsToHeal.

     OnAgentEnters(EnteredAgent:agent):void=
         Print("Agent wszedł do wolumenu leczenia")

  2. W OnAgentEnters() sprawdź, czy agent wewnątrz wolumenu nie jest postacią medyka. Jeśli tak jest, ustaw kolejkę AgentsToHeal na wynik wywołania Enqueue[] z podaniem EnteredAgent. Gotowa funkcja OnAgentEnters() powinna wyglądać następująco:

    OnAgentEnters(EnteredAgent:agent):void=
    Print("Agent wszedł do wolumenu leczenia")
    if (EnteredAgent <> GetAgent[]):
        set AgentsToHeal = AgentsToHeal.Enqueue(EnteredAgent)

  3. Gdy agent opuści HealVolume, nie musisz go usuwać z kolejki AgentsToHeal. Dzieje się tak dlatego, że pętla w OnBegin() już wywołuje Dequeue[] w pętli. Możesz jednak chcieć wykonać kod, gdy agent opuszcza wolumen w twoich przykładach, dlatego teraz napiszesz odpowiednią funkcję. Dodaj nową funkcję o nazwie OnAgentExits() do definicji klasy medic_example.

     OnAgentExits(ExitAgent:agent):void=
     Print("Agent opuścił wolumen leczenia")

  4. W OnBegin() zasubskrybuj AgentEntersEvent i AgentExitsEvent z HealVolume odpowiednio na OnAgentEnters i OnAgentExits. Funkcja powinna się uruchamiać jako wyłączona, dlatego jest to dobre miejsce, aby wywołać Disable() na generatorze postaci.

     OnBegin<override>()<suspends>:void=
     Print("Cześć, SI!")
     VFXSpawner.Disable()
     HealVolume.AgentEntersEvent.Subscribe(OnAgentEnters)
     HealVolume.AgentExitsEvent.Subscribe(OnAgentExits)

Przemieszczanie wolumenu leczenia wraz z medykiem

Gdy postać medyka się przemieszcza, trzeba wraz z nią przemieszczać HealVolume, aby dopasować go do obecnej pozycji medyka. To samo dotyczy również generatora VFXSpawner. W tym celu użyjesz nowej funkcji DeviceFollowCharacter().

  1. Dodaj nową funkcję o nazwie DeviceFollowCharacter() do definicji klasy medic_example. Ta funkcja musi być wykonywana asynchronicznie, aby bez przerwy aktualizować pozycje urządzenia, dlatego dodaj do niej modyfikator <suspends>.

     DeviceFollowCharacter()<suspends>:void=

  2. Wewnątrz funkcji DeviceFollowCharacter() pobierz fort_character medyka, najpierw pobierając agenta przy użyciu GetAgent[], a następnie wywołując GetFortCharater[].

     DeviceFollowCharacter()<suspends>:void=
     if:
         # Pobierz agenta (postać SI), z którym jest powiązane to zachowanie.
         Agent := GetAgent[]
         # Pobierz interfejs fort_character agenta, aby uzyskać dostęp do charakterystycznych dla postaci Fortnite zachowań, zdarzeń, funkcji i interfejsów.
         Character := Agent.GetFortCharacter[]

  3. Teraz musisz ciągle przemieszczać HealVolume i VFXSpawner do pozycji Character. Robi się to, zapętlając MoveTo() na obu urządzeniach. Rozpocznij loop, pobierz przekształcenie Character i zapisz je w zmiennej CharacterTransform.

     if:
     # Pobierz agenta (postać SI), z którym jest powiązane to zachowanie.
     Agent := GetAgent[]
     # Pobierz interfejs fort_character agenta, aby uzyskać dostęp do charakterystycznych dla postaci Fortnite zachowań, zdarzeń, funkcji i interfejsów.
     Character := Agent.GetFortCharacter[]
 then:
     loop:
         CharacterTransform := Character.GetTransform()

  4. Wywołaj MoveTo() zarówno na VFXSpawner, jak i na HealVolume, przemieszczając je do CharacterTransform.Translation i CharacterTransform.Rotation. Ustaw czas trwania na UpdateRateSeconds w sekundach. Na koniec wywołaj Sleep() dla ilości czasu równej UpdateRateSeconds, aby zapobiec aktualizacji pozycji urządzeń co każdą aktualizację symulacji. Aktualizacja pozycji urządzenia co każdą aktualizację symulacji może spowodować rozedrgany ruch na urządzeniach. Gotowy kod DeviceFollowCharacter() powinien wyglądać następująco.

     DeviceFollowCharacter()<suspends>:void=
     if:
         # Pobierz agenta (postać SI), z którym jest powiązane to zachowanie.
         Agent := GetAgent[]
         # Pobierz interfejs fort_character agenta, aby uzyskać dostęp do charakterystycznych dla postaci Fortnite zachowań, zdarzeń, funkcji i interfejsów.
         Character := Agent.GetFortCharacter[]
         then:
             loop:
                 CharacterTransform := Character.GetTransform()
                 VFXSpawner.MoveTo(CharacterTransform.Translation, CharacterTransform.Rotation, UpdateRateSeconds)
                 HealVolume.MoveTo(CharacterTransform.Translation, CharacterTransform.Rotation, UpdateRateSeconds)
                 Sleep(UpdateRateSeconds)

  5. W OnBegin(), po instrukcji if, w której są zapisane interfejsy postaci, ale przed pętlą, zespawnuj instancję DeviceFollowCharacter().

Dodawanie postaci do poziomu

  1. Utwórz definicję postaci niezależnej medyka o nazwie Medic. Kliknij nową definicję postaci niezależnej, aby otworzyć ekran Definicja postaci niezależnej.

  2. Na ekranie Definicja postaci niezależnej zmodyfikuj następujące właściwości:

    1. W Typ postaci niezależnej ustaw Typ na Strażnik. Interfejs strażnika daje dostęp do funkcjonalności charakterystycznych dla postaci strażnika, takich jak zdarzenia, gdy strażnik zostanie zaalarmowany lub coś podejrzewa, umożliwia też wynajmowanie strażników jako sojuszników. Strażnicy mogą też brać broń do ręki, a postacie typu Niestandardowe i Dzikie zwierzęta obecnie nie mogą tego robić. Możesz też zmienić nazwę postaci na karcie Nazwa.

    2. W Zachowanie postaci niezależnej ustaw Zachowanie na Zachowanie Verse. Następnie ustaw Skrypt zachowania postaci niezależnej na medic_example. Postać będzie miała dalej dostęp do funkcjonalności z interfejsu strażnika, ale będzie używała twojego skryptu Verse, aby zdecydować, co robić w trakcie faz OnBegin i OnEnd.

    3. Na karcie Modyfikatory, w pozycji Modyfikator spawnu strażnika, kliknij kartę Elementy kosmetyczne, aby zmienić wygląd kosmetyczny postaci. Możesz wybrać spośród istniejących elementów kosmetycznych lub włączyć Dopasowanie elementów kosmetycznych postaci, aby używać niestandardowego modelu. Uwaga: dopasowania elementów kosmetycznych mogą używać tylko strażnicy i postacie typu Niestandardowe, dzikie zwierzęta nie mogą tego używać. W celu uzyskania dodatkowych informacji o modyfikatorach postaci i o tym, które mają zastosowanie do różnych typów postaci, przeczytaj stronę Definicja postaci.

  3. Zapisz definicję swojej postaci niezależnej. W Przeglądarce zawartości przeciągnij definicję postaci niezależnej do poziomu. Automatycznie utworzy to nowy generator postaci i przypisze do niego twoją definicję postaci niezależnej.

Przeciągnij generator postaci do poziomu

  1. Przeciągnij do poziomu jedną strefę mutatora i jedno urządzenie generatora efektów wizualnych.

  2. Wybierz generator postaci. W Outlinerze w Opcjach użytkownika:

    1. Ustaw Zastąpienie skryptu AIBehavior na swój skrypt medic_example. Zastąpienie skryptu AIBehavior w Outlinerze umożliwia odwoływanie się do urządzeń na poziomie, potrzebujesz tej funkcjonalności, aby przypisywać HealVolume i VFXSpawner.

    2. Ustaw HealVolume na strefę mutatora, a VFXSpawner na generator efektów wizualnych umieszczony na poziomie.

Ustawienia generatora postaci

  1. Wybierz strefę mutatora. W Outlinerze, w Opcjach użytkownika, ustaw Widoczność strefy podczas gry na Prawda. To pomaga zwizualizować, w którym miejscu znajduje się HealVolume i w jaki sposób przemieszcza się wraz z postacią medyka.

  2. Wybierz generator efektów wizualnych. W Outlinerze w Opcjach użytkownika ustaw Efekt wizualny na wybrany efekt. W tym przykładzie zastosowano efekt Bańki, aby pokazywać leczenie, ale możesz chcieć użyć innego efektu, takiego jak fajerwerki lub iskry. Zmień efekt wizualny na taki, który najlepiej pasuje do postaci.

  3. Na pasku narzędzi UEFN kliknij Uruchom sesję, aby przetestować poziom w grze. W trakcie testu gry twoja postać powinna leczyć zranione postacie, które wchodzą do strefy mutatora. Podczas leczenia postaci powinien być odtwarzany efekt wizualny, a medyk powinien podążać za leczoną postacią i utrzymywać na niej skupienie.

Zachowanie wolumenu leczenia

Kompletny skrypt

Poniżej znajduje się kompletny skrypt postaci niezależnej, która leczy postacie, gdy ich punkty zdrowia spadną poniżej określonego progu.

medic_example.verse

using { /Fortnite.com/AI }
using { /Fortnite.com/Characters }
using { /Fortnite.com/Devices }
using { /Verse.org/Colors }
using { /Verse.org/Random }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/SpatialMath }

# Utworzone w Verse zachowanie postaci niezależnej, którego można używać w definicji postaci niezależnej lub w zastąpieniu skryptu zachowania urządzenia generatora postaci.
medic_example<public> := class(npc_behavior):
    # Wartość progowa PZ, poniżej której musi spaść postać, aby można ją było wyleczyć.
    @editable
    HealingThreshold:float = 50.0

    # Jak długo czekać między leczeniem postaci
    @editable
    HealingDelay:float = 1.5

    # O ile punktów leczyć postacie w każdej instancji leczenia
    @editable
    HealingAmount:float = 5.0

    # Wolumen, do którego wchodzą postacie, aby otrzymać leczenie.
    @editable
    HealVolume:mutator_zone_device = mutator_zone_device{}

    # Generator efektów wizualnych odtwarzający efekty wizualne w trakcie leczenia postaci.
    @editable
    VFXSpawner:vfx_spawner_device = vfx_spawner_device {}

    # Agent, za którym ma podążać medyk w trakcie leczenia
    var AgentToFollow:?agent = false

    # Kolejka agentów do wyleczenia w przypadku, gdy do wolumenu leczenia wchodzi wielu agentów.
    var AgentsToHeal<public>:queue(agent) = queue(agent){}

    # Używane do określenia, jak szybko aktualizować pozycję HealVolume i VFXSpawner
    UpdateRateSeconds<private>:float = 0.1

    OnBegin<override>()<suspends>:void=
        VFXSpawner.Disable()
        HealVolume.AgentEntersEvent.Subscribe(OnAgentEnters)
        HealVolume.AgentExitsEvent.Subscribe(OnAgentExits)

        if:

            # Pobierz agenta (postać SI), z którym jest powiązane to zachowanie.
            Agent := GetAgent[]

            # Pobierz interfejs fort_character agenta, aby uzyskać dostęp do charakterystycznych dla postaci Fortnite zachowań, zdarzeń, funkcji i interfejsów.
            Character := Agent.GetFortCharacter[]

            # Pobierz interfejs navigatable postaci, aby ustawić konkretne cele, do których ma się przemieszczać postać.
            Navigatable := Character.GetNavigatable[]

            # Pobierz interfejs focus_interface postaci, aby ustawić konkretne cele, na których postać ma się skupiać, gdy się do nich przemieści.
            Focusable := Character.GetFocusInterface[]

        then:
            # Ustaw HealVolume i VFXSpawner, aby stale podążały za postacią niezależną
            spawn{DeviceFollowCharacter()}
            loop:
                # Pobierz kolejnego agenta z kolejki do leczenia. Jeśli istnieje agent, który ma być wyleczony, wylecz go, wywołując AgentToHeal.
                # Jeśli nie ma agentów do leczenia, poczekaj, aż do HealVolume wejdzie jakiś agent
                if:
                    DequeueResult := AgentsToHeal.Dequeue[]
                    set AgentsToHeal = DequeueResult(0)
                    AgentToHeal := DequeueResult(1)
                then:
                    PrintNPCB("Usunięto z kolejki kolejnego agenta do wyleczenia")
                    HealCharacter(AgentToHeal, Navigatable, Focusable)
                else:
                    PrintNPCB("Kolejka AgentsToHeal jest pusta!")
                    Sleep(HealingDelay)
                    HealVolume.AgentEntersEvent.Await()
        else:
            # Jeśli w tym miejscu kod ulegnie awarii, to znaczy, że coś się nie udało podczas zbierania agenta i jego interfejsów
            PrintNPCB( "Błąd w skrypcie zachowania postaci niezależnej przy konfiguracji postaci niezależnej",
                ?Duration := 6.0,
                ?TextColor := NamedColors.Red )

    # Wylecz postać, następnie odczekaj ilość czasu określoną przez HealingDelayAmount.
    # Kończy się, gdy zdrowie postaci osiągnie wartość HealingThreshold
    # lub gdy postać opuści HealVolume.
    HealCharacter(AgentToHeal:agent, Navigatable:navigatable, Focusable:focus_interface)<suspends>:void=

        # Lecz postać tylko, gdy znajduje się wewnątrz HealVolume
        if:
            HealVolume.IsInVolume[AgentToHeal]
            CharacterToHeal := AgentToHeal.GetFortCharacter[]
        then:
            PrintNPCB("Postać jest wewnątrz wolumenu, rozpoczynanie leczenia")
            NavigationTarget := MakeNavigationTarget(AgentToHeal)
            branch:
                Navigatable.NavigateTo(NavigationTarget)
                Focusable.MaintainFocus(AgentToHeal)
            VFXSpawner.Enable()
            defer:
                VFXSpawner.Disable()
            race:
                loop:
                    CurrentHealth := CharacterToHeal.GetHealth()
                    if(CurrentHealth + HealingAmount > HealingThreshold):
                        if (CurrentHealth < HealingThreshold):
                            CharacterToHeal.SetHealth(HealingThreshold)
                        PrintNPCB("Postać osiągnęła próg leczenia HealingThreshold, kończenie leczenia")
                        break
                    else:
                        CharacterToHeal.SetHealth(CurrentHealth + HealingAmount)
                    Sleep(HealingDelay)
                HealVolume.AgentExitsEvent.Await()

    # Ustawia HealVolume i VFXSpawner, aby stale podążały za postacią poprzez zapętlenie
    # MoveTo do pozycji postaci.
    DeviceFollowCharacter()<suspends>:void=
        if:
            # Pobierz agenta (postać SI), z którym jest powiązane to zachowanie.
            Agent := GetAgent[]

            # Pobierz interfejs fort_character agenta, aby uzyskać dostęp do charakterystycznych dla postaci Fortnite zachowań, zdarzeń, funkcji i interfejsów.
            Character := Agent.GetFortCharacter[]
        then:
            # Zapętl MoveTo na HealVolume i VFXSpawner, aby dopasować ich pozycję do
            # postaci niezależnej
            loop:
                CharacterTransform := Character.GetTransform()
                VFXSpawner.MoveTo(CharacterTransform.Translation, CharacterTransform.Rotation, UpdateRateSeconds)
                HealVolume.MoveTo(CharacterTransform.Translation, CharacterTransform.Rotation, UpdateRateSeconds)
                Sleep(UpdateRateSeconds)

    # Gdy agent wejdzie do HealVolume, dodaj go do
    # kolejki AgentsToHeal, jeśli nie jest postacią niezależną.
    OnAgentEnters(EnteredAgent:agent):void=
        PrintNPCB("Agent wszedł do wolumenu leczenia")
        if (EnteredAgent <> GetAgent[]):
            set AgentsToHeal = AgentsToHeal.Enqueue(EnteredAgent)

    # Gdy agent opuści HealVolume, PrintNPCB w dzienniku
    OnAgentExits(ExitAgent:agent):void=
        PrintNPCB("Agent opuścił wolumen leczenia")

    # Niestandardowa otoka, która zapewnia domyślny czas trwania i kolor.
    PrintNPCB(Msg:string,?Duration:float = 3.0, ?TextColor:color = NamedColors.Green):void =
        Print("[new_npc_behavior] {Msg}", ?Color := TextColor, ?Duration := Duration)

    # Ta funkcja jest uruchamiana, gdy postać niezależna zostaje odspawnowana albo zlikwidowana ze świata.
    OnEnd<override>():void =
        if(Agent := GetAgent[]):
            Print(medic_example_message_module.OnEndMessage(Agent))
        else:
            PrintNPCB("OnEnd")

queue.verse

list(t:type) := class:
    Data:t
    Next:?list(t)

queue<public>(t:type) := class<internal>:
    Elements<internal>:?list(t) = false
    Size<public>:int = 0

    Enqueue<public>(NewElement:t):queue(t) =
        queue(t):
            Elements := option:
                list(t):
                    Data := NewElement
                    Next := Elements
            Size := Size + 1

    Dequeue<public>()<decides><transacts>:tuple(queue(t), t) =
        List := Elements?
        (queue(t){Elements := List.Next, Size := Size - 1}, List.Data)

    Front<public>()<decides><transacts>:t = Elements?.Data

CreateQueue<public><constructor>(InData:t where t:type) := queue(t):
    Elements := option:
        list(t):
            Data := InData
            Next := false
    Size := 1

We własnym zakresie

Dzięki temu przewodnikowi wiesz już, jak utworzyć postać medyka, automatycznie leczącego postacie, których zdrowie spadnie poniżej określonej wartości progowej. Wykorzystując zdobytą wiedzę, spróbuj utworzyć własną postać medyka z własnymi specjalnymi zachowaniami.

  • Czy potrafisz utworzyć medyka, który przechodzi między wolumenami obrażeń i leczenia na podstawie tego, czy w wolumenie znajduje się wróg?

  • A może utworzysz medyka, który do leczenia postaci używa zużywającego się zasobu? W jaki sposób medyk mógłby przywracać ten zasób? Czy może go przywrócić wraz z upływem czasu, czy poprzez atakowanie wrogów?

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page