W tym artykule kontynuujemy prace nad opracowaniem kontrolera postaci do gry platformowej 2D w środowisku Unity, szczegółowo analizując każdy etap konfiguracji i optymalizacji sterowania. W poprzednim artykule „ ” szczegółowo omówiliśmy, jak stworzyć fundament postaci, w tym jej zachowanie fizyczne i podstawowe ruchy. Teraz czas przejść do bardziej zaawansowanych aspektów, takich jak obsługa danych wejściowych i dynamiczne podążanie za kamerą. Jak stworzyć kontroler postaci 2D w Unity: część 1 W tym artykule zajmiemy się konfiguracją nowego systemu wprowadzania danych Unity, tworzeniem aktywnych akcji do sterowania postacią, włączaniem skakania i zapewnianiem właściwych reakcji na polecenia gracza. Jeśli chcesz samodzielnie zaimplementować wszystkie zmiany opisane w tym artykule, możesz pobrać gałąź repozytorium „ ”, która zawiera fundament dla tego artykułu. Alternatywnie możesz pobrać gałąź „ ” z końcowym wynikiem. Character Body Character Controller Konfigurowanie systemu wejściowego Zanim zaczniemy pisać kod do sterowania naszą postacią, musimy skonfigurować system wprowadzania danych w projekcie. Do naszej platformówki wybraliśmy nowy system wprowadzania danych Unity, wprowadzony kilka lat temu, który pozostaje istotny ze względu na swoje zalety w porównaniu z tradycyjnym systemem. System wejściowy oferuje bardziej modułowe i elastyczne podejście do obsługi danych wejściowych, umożliwiając programistom łatwą konfigurację elementów sterujących dla różnych urządzeń i obsługę bardziej złożonych scenariuszy wprowadzania danych bez dodatkowych nakładów na implementację. Najpierw zainstaluj pakiet Input System. Otwórz Menedżera pakietów z menu głównego, wybierając Okno → Menedżer pakietów. W sekcji Unity Registry znajdź pakiet „Input System” i kliknij „Instaluj”. Następnie przejdź do ustawień projektu za pomocą menu Edycja → Ustawienia projektu. Wybierz kartę Odtwarzacz, znajdź sekcję Aktywne przetwarzanie danych wejściowych i ustaw ją na „Pakiet systemu wejściowego (nowy). Po wykonaniu tych kroków Unity poprosi Cię o ponowne uruchomienie. Po ponownym uruchomieniu wszystko będzie gotowe do skonfigurowania elementów sterujących dla naszego kapitana. Tworzenie akcji wejściowych W folderze utwórz Akcje wejściowe za pomocą menu głównego: . Nazwij plik „Kontrolki”. Ustawienia Zasoby → Utwórz → Akcje wejściowe Unity's Input System to potężne i elastyczne narzędzie do zarządzania danymi wejściowymi, które pozwala deweloperom konfigurować elementy sterujące postaci i elementów gry. Obsługuje różne urządzenia wejściowe. Tworzone przez Ciebie akcje wejściowe zapewniają scentralizowane zarządzanie danymi wejściowymi, upraszczając konfigurację i czyniąc interfejs bardziej intuicyjnym. Kliknij dwukrotnie plik , aby otworzyć go do edycji, i dodaj dla kontrolki postaci o nazwie „Postać”. Controls Mapę akcji Mapa akcji w Unity to zbiór akcji, które można połączyć z różnymi kontrolerami i klawiszami, aby wykonywać określone zadania w grze. To wydajny sposób na organizowanie elementów sterujących, umożliwiający deweloperom przydzielanie i dostosowywanie danych wejściowych bez przepisywania kodu. Aby uzyskać więcej szczegółów, zapoznaj się z oficjalną . dokumentacją Input System Pierwsza akcja będzie nazywać się „Ruch”. Ta akcja określi kierunek ruchu postaci. Ustaw na „Wartość”, a na „Wektor2”, aby umożliwić ruch w czterech kierunkach. typ akcji typ kontroli Przypisz powiązania do tej akcji, wybierając opcję Dodaj kompozyt w górę/w dół/w prawo/w lewo i przypisując znane klawisze WASD do odpowiednich kierunków. Nie zapomnij zapisać ustawień, klikając . Ta konfiguracja zapewnia, że możesz ponownie przypisać powiązania dla akcji „Move”, na przykład do klawiszy strzałek lub nawet joysticka gamepada. Save Asset Następnie dodaj nową akcję — „Skok”. Pozostaw jako „Przycisk”, ale dodaj nową — „Naciśnij” i ustaw na „Naciśnij i puść”, ponieważ musimy uchwycić zarówno naciśnięcie, jak i puszczenie przycisku. typ akcji interakcję zachowanie wyzwalacza To kończy schemat kontroli postaci. Następnym krokiem jest napisanie komponentu do obsługi tych akcji. Przesuwanie postaci w lewo i prawo Czas połączyć akcje wejściowe, które utworzyliśmy na potrzeby sterowania postacią, z komponentem , umożliwiając postaci aktywne poruszanie się po scenie zgodnie z naszymi poleceniami sterowania. CharacterBody Aby to zrobić, utworzymy skrypt odpowiedzialny za sterowanie ruchem i nazwiemy go dla przejrzystości. W tym skrypcie najpierw zdefiniujemy kilka podstawowych pól. Dodamy odwołanie do komponentu , , który będzie bezpośrednio kontrolowany przez skrypt. CharacterController CharacterBody _characterBody Ustawimy również parametry prędkości ruchu postaci ( ) i wysokości skoku ( ). Dodatkowo zdefiniujemy cel pola . _speed _jumpHeight _stopJumpFactor Być może zauważyłeś, że w wielu platformówkach 2D wysokość skoku może być kontrolowana. Im dłużej przycisk skoku jest przytrzymywany, tym wyżej postać skacze. Zasadniczo początkowa prędkość w górę jest stosowana na początku skoku, a prędkość ta jest zmniejszana po zwolnieniu przycisku. określa, o ile prędkość w górę maleje po zwolnieniu przycisku skoku. _stopJumpFactor Oto przykład kodu, który napiszemy: // CharacterController.cs public class CharacterController : MonoBehaviour { [SerializeField] private CharacterBody _characterBody; [Min(0)] [SerializeField] private float _speed = 5; [Min(0)] [SerializeField] private float _jumpHeight = 2.5f; [Min(1)] [SerializeField] private float _stopJumpFactor = 2.5f; } Następnie zaimplementujemy możliwość poruszania postacią w lewo i prawo. Podczas przytrzymywania przycisku ruchu postać powinna utrzymywać określoną prędkość ruchu niezależnie od przeszkód. Aby to osiągnąć, dodamy zmienną w skrypcie, aby przechowywać bieżącą prędkość ruchu wzdłuż powierzchni (lub po prostu poziomo, gdy postać jest w powietrzu): // CharacterController.cs private float _locomotionVelocity; W komponencie wprowadzimy metodę ustawiającą tę prędkość: CharacterBody // CharacterBody.cs public void SetLocomotionVelocity(float locomotionVelocity) { Velocity = new Vector2(locomotionVelocity, _velocity.y); } Ponieważ nasza gra nie zawiera pochyłych powierzchni, ta metoda jest dość prosta. W bardziej złożonych scenariuszach musielibyśmy uwzględnić stan ciała i nachylenie powierzchni. Na razie po prostu zachowujemy pionową składową prędkości, modyfikując jedynie poziomą współrzędną . x Następnie ustawimy tę wartość w metodzie w każdej klatce: Update // CharacterController.cs private void Update() { _characterBody.SetLocomotionVelocity(_locomotionVelocity); } Zdefiniujemy metodę obsługi sygnałów z akcji wejściowej : Move // CharacterController.cs public void OnMove(InputAction.CallbackContext context) { var value = context.ReadValue<Vector2>(); _locomotionVelocity = value.x * _speed; } Ponieważ akcja jest zdefiniowana jako , kontekst zapewni wartość wektora w zależności od tego, które klawisze zostaną naciśnięte lub zwolnione. Na przykład naciśnięcie klawisza spowoduje, że metoda otrzyma wektor (1, 0). Jednoczesne naciśnięcie i spowoduje (1, 1). Zwolnienie wszystkich klawiszy spowoduje uruchomienie z wartością (0, 0). Move Vector2 D OnMove D W OnMove Dla klawisza wektor będzie (-1, 0). W metodzie bierzemy składową poziomą otrzymanego wektora i mnożymy ją przez określoną prędkość ruchu, . A OnMove _speed Nauka skakania Najpierw musimy nauczyć komponent obsługi skoków. Aby to zrobić, dodamy metodę odpowiedzialną za skok: CharacterBody // CharacterBody.cs public void Jump(float jumpSpeed) { Velocity = new Vector2(_velocity.x, jumpSpeed); State = CharacterState.Airborne; } W naszym przypadku ta metoda jest prosta: ustawia prędkość pionową i natychmiast zmienia stan postaci na . Airborne Następnie musimy określić prędkość, z jaką postać powinna skoczyć. Określiliśmy już wysokość skoku i wiemy, że grawitacja stale działa na ciało. Na tej podstawie można obliczyć początkową prędkość skoku za pomocą wzoru: Gdzie to wysokość skoku, a to przyspieszenie grawitacyjne. Uwzględnimy również mnożnik grawitacyjny obecny w komponencie . Dodamy nowe pole, aby zdefiniować początkową prędkość skoku i obliczymy ją w następujący sposób: h g CharacterBody // CharacterController.cs private float _jumpSpeed; private void Awake() { _jumpSpeed = Mathf.Sqrt(2 * Physics2D.gravity.magnitude * _characterBody.GravityFactor * _jumpHeight); } Będziemy potrzebować kolejnego pola, aby śledzić, czy postać aktualnie skacze, dzięki czemu będziemy mogli ograniczyć prędkość skoku w odpowiednim momencie. Dodatkowo, jeśli gracz przytrzyma przycisk skoku do lądowania, powinniśmy sami zresetować tę flagę. Zostanie to zrobione w metodzie : Update // CharacterController.cs private bool _isJumping; private void Update() { if (_characterBody.State == CharacterState.Grounded) { _isJumping = false; } //... } Teraz napiszmy metodę obsługującą akcję : Jump // CharacterController.cs public void OnJump(InputAction.CallbackContext context) { if (context.started) { Jump(); } else if (context.canceled) { StopJumping(); } } Ponieważ akcja jest przyciskiem, możemy określić na podstawie kontekstu, czy naciśnięcie przycisku zostało rozpoczęte ( ) czy zakończone ( ). Na tej podstawie inicjujemy lub zatrzymujemy skok. Jump context.started context.canceled Oto metoda wykonania skoku: // CharacterController.cs private void Jump() { if (_characterBody.State == CharacterState.Grounded) { _isJumping = true; _characterBody.Jump(_jumpSpeed); } } Przed skokiem sprawdzamy, czy postać jest na ziemi. Jeśli tak, ustawiamy flagę i sprawiamy, że ciało skacze za pomocą . _isJumping _jumpSpeed Teraz zaimplementujmy zachowanie polegające na zatrzymaniu skoku: // CharacterController.cs private void StopJumping() { var velocity = _characterBody.Velocity; if (_isJumping && velocity.y > 0) { _isJumping = false; _characterBody.Velocity = new Vector2( velocity.x, velocity.y / _stopJumpFactor); } } Zatrzymujemy skok tylko wtedy, gdy flaga jest aktywna. Innym ważnym warunkiem jest to, że postać musi poruszać się w górę. Zapobiega to ograniczeniu prędkości spadania, jeśli przycisk skoku zostanie zwolniony podczas poruszania się w dół. Jeśli wszystkie warunki są spełnione, resetujemy flagę i zmniejszamy prędkość pionową o współczynnik . _isJumping _isJumping _stopJumpFactor Ustawianie postaci Teraz, gdy wszystkie komponenty są gotowe, dodaj komponenty i do obiektu w scenie. Upewnij się, że wybierasz komponent , który utworzyliśmy, a nie standardowy komponent Unity przeznaczony do sterowania postaciami 3D. PlayerInput CharacterController Captain CharacterController W przypadku przypisz istniejący komponent z postaci. W przypadku ustaw wcześniej utworzone w polu . CharacterController CharacterBody PlayerInput Controls Actions Następnie skonfiguruj komponent PlayerInput, aby wywołać odpowiednie metody z CharacterController. Rozwiń sekcje Events i Character w edytorze i połącz odpowiednie metody z akcjami Move i Jump. Teraz wszystko jest gotowe, aby uruchomić grę i sprawdzić, jak wszystkie skonfigurowane komponenty ze sobą współpracują. Ruch kamery Teraz musimy sprawić, by kamera podążała za postacią, gdziekolwiek się uda. Unity zapewnia potężne narzędzie do zarządzania kamerą — . Cinemachine Cinemachine to rewolucyjne rozwiązanie do sterowania kamerą w Unity, które oferuje deweloperom szeroki zakres możliwości tworzenia dynamicznych, dobrze dostrojonych systemów kamer, które dostosowują się do potrzeb rozgrywki. To narzędzie ułatwia implementację złożonych technik kamerowych, takich jak śledzenie postaci, automatyczna regulacja ostrości i wiele innych, dodając witalności i bogactwa każdej scenie. Najpierw zlokalizuj obiekt w scenie i dodaj do niego komponent . Main Camera CinemachineBrain Następnie utwórz nowy obiekt w scenie o nazwie . Będzie to kamera podążająca za kapitanem, tak jak profesjonalny kamerzysta. Dodaj do niej komponent . Ustaw pole na kapitana, wybierz dla pola i ustaw parametr na 4. CaptainCamera CinemachineVirtualCamera Follow Framing Transposer Body Lens Ortho Size Dodatkowo będziemy potrzebować innego komponentu, aby zdefiniować przesunięcie kamery względem postaci — . Ustaw wartość na 1,5, a wartość na -15. CinemachineCameraOffset Y Z Sprawdźmy teraz jak kamera podąża za naszą postacią. Myślę, że wyszło całkiem nieźle. Zauważyłem, że kamera czasami lekko się zacina. Aby to naprawić, ustawiłem pole Blend Update Method obiektu Main Camera na FixedUpdate. Ulepszanie skoków Przetestujmy zaktualizowaną mechanikę. Spróbuj biegać i skakać bez przerwy. Doświadczeni gracze mogą zauważyć, że skoki nie zawsze są rejestrowane. W większości gier nie jest to problemem. Okazuje się, że trudno przewidzieć dokładny czas lądowania, aby ponownie nacisnąć przycisk skoku. Musimy sprawić, aby gra była bardziej wyrozumiała, pozwalając graczom na lekkie naciśnięcie przycisku skoku przed lądowaniem i sprawić, aby postać skoczyła natychmiast po lądowaniu. To zachowanie jest zgodne z tym, do czego gracze są przyzwyczajeni. Aby to wdrożyć, wprowadzimy nową zmienną , która reprezentuje okno czasowe, w którym skok może zostać uruchomiony, jeśli nadarzy się ku temu okazja. _jumpActionTime // CharacterController.cs [Min(0)] [SerializeField] private float _jumpActionTime = 0.1f; Dodałem pole , które oznacza koniec okna akcji skoku. Innymi słowy, dopóki nie zostanie osiągnięty, postać będzie skakać, jeśli nadarzy się okazja. Zaktualizujmy również obsługę akcji . _jumpActionEndTime _jumpActionEndTime Jump // CharacterController.cs private float _jumpActionEndTime; public void OnJump(InputAction.CallbackContext context) { if (context.started) { if (_characterBody.State == CharacterState.Grounded) { Jump(); } else { _jumpActionEndTime = Time.unscaledTime + _jumpActionTime; } } else if (context.canceled) { StopJumping(); } } Gdy przycisk skoku zostanie naciśnięty, jeśli postać jest na ziemi, skacze natychmiast. W przeciwnym razie przechowujemy okno czasowe, w którym skok może być nadal wykonany. Usuńmy sprawdzanie stanu z samej metody . Grounded Jump // CharacterController.cs private void Jump() { _isJumping = true; _characterBody.Jump(_jumpSpeed); } Zaadaptujemy również metodę stop-jumping. Jeśli przycisk został zwolniony przed lądowaniem, nie powinno dojść do żadnego skoku, więc resetujemy . _jumpActionEndTime // CharacterController.cs private void StopJumping() { _jumpActionEndTime = 0; //... } Kiedy powinniśmy sprawdzić, czy postać wylądowała i wyzwolić skok? Stan jest przetwarzany w , podczas gdy przetwarzanie akcji następuje później. Niezależnie od tego, czy jest to czy , może wystąpić opóźnienie jednej klatki między lądowaniem a skokiem, co jest zauważalne. CharacterBody FixedUpdate Update FixedUpdate Dodamy zdarzenie do aby natychmiast zareagować na lądowanie. Pierwszy argument będzie poprzednim stanem, a drugi bieżącym stanem. StateChanged CharacterBody // CharacterBody.cs public event Action<CharacterState, CharacterState> StateChanged; Dostosujemy zarządzanie stanem, aby wywołać zdarzenie zmiany stanu i przepiszemy . FixedUpdate // CharacterBody.cs [field: SerializeField] private CharacterState _state; public CharacterState State { get => _state; private set { if (_state != value) { var previousState = _state; _state = value; StateChanged?.Invoke(previousState, value); } } } Udoskonaliłem również sposób obsługi w . surfaceHit FixedUpdate // CharacterBody.cs private void FixedUpdate() { //... if (_velocity.y <= 0 && slideResults.surfaceHit) { var surfaceHit = slideResults.surfaceHit; Velocity = ClipVector(_velocity, surfaceHit.normal); if (surfaceHit.normal.y >= _minGroundVertical) { State = CharacterState.Grounded; return; } } State = CharacterState.Airborne; } W zasubskrybujemy zdarzenie i dodamy procedurę jego obsługi. CharacterController StateChanged // CharacterController.cs private void OnEnable() { _characterBody.StateChanged += OnStateChanged; } private void OnDisable() { _characterBody.StateChanged -= OnStateChanged; } private void OnStateChanged(CharacterState previousState, CharacterState state) { if (state == CharacterState.Grounded) { OnGrounded(); } } Usuniemy sprawdzanie stanu z i przeniesiemy je do . Grounded Update OnGrounded // CharacterController.cs private void Update() { _characterBody.SetLocomotionVelocity(_locomotionVelocity); } private void OnGrounded() { _isJumping = false; } Teraz dodaj kod sprawdzający, czy skok powinien zostać wywołany. // CharacterController.cs private void OnGrounded() { _isJumping = false; if (_jumpActionEndTime > Time.unscaledTime) { _jumpActionEndTime = 0; Jump(); } } Jeśli jest większe od bieżącego czasu, oznacza to, że przycisk skoku został niedawno naciśnięty, więc resetujemy i wykonujemy skok. _jumpActionEndTime _jumpActionEndTime Teraz spróbuj ciągle skakać z postacią. Zauważysz, że przycisk skoku jest bardziej responsywny, a sterowanie postacią staje się płynniejsze. Jednak zauważyłem, że w pewnych sytuacjach, takich jak narożnik pokazany na poniższej ilustracji, stan doświadcza niewielkiego opóźnienia, przerywając łańcuch skoków. Grounded Aby temu zaradzić, ustawiłem pole w komponencie na 0,05 zamiast 0,01. Wartość ta reprezentuje minimalną odległość od powierzchni, po której ciało przechodzi w stan . Surface Anchor CharacterBody Grounded Skoki z klifu Być może zauważyłeś, że próba skoku podczas biegu z pionowych powierzchni nie zawsze działa. Czasami może się wydawać, że przycisk skoku nie reaguje. To jedna z subtelności w tworzeniu do platformówek 2D. Gracze muszą mieć możliwość skakania, nawet jeśli są nieco spóźnieni z naciśnięciem przycisku skoku. Choć ta koncepcja może wydawać się dziwna, tak właśnie działa większość platformówek. Rezultatem jest postać, która wydaje się odpychać powietrze, jak pokazano na poniższej animacji. kontrolera postaci Zaimplementujmy tę mechanikę. Wprowadzimy nowe pole do przechowywania okna czasowego (w sekundach), w którym postać może nadal skakać po utracie stanu . Grounded // CharacterController.cs [Min(0)] [SerializeField] private float _rememberGroundTime = 0.1f; Dodamy również kolejne pole, w którym będzie przechowywany znacznik czasu, po upływie którego stan zostanie „zapomniany”. Grounded // CharacterController.cs private float _lostGroundTime; Ten stan będzie śledzony za pomocą zdarzenia . W tym celu dostosujemy handler . CharacterBody OnStateChanged // CharacterController.cs private void OnStateChanged(CharacterState previousState, CharacterState state) { if (state == CharacterState.Grounded) { OnGrounded(); } else if (previousState == CharacterState.Grounded) { _lostGroundTime = Time.unscaledTime + _rememberGroundTime; } } Ważne jest, aby rozróżnić, czy postać straciła stan z powodu celowego skoku, czy z innego powodu. Mamy już flagę , która jest wyłączana za każdym razem, gdy wywoływana jest aby zapobiec zbędnym akcjom. Grounded _isJumping StopJumping Postanowiłem nie wprowadzać kolejnej flagi, ponieważ redundantne anulowanie skoku nie wpływa na rozgrywkę. Eksperymentuj swobodnie. Flaga będzie teraz czyszczona tylko wtedy, gdy postać wyląduje po skoku. Zaktualizujmy kod odpowiednio. _isJumping // CharacterController.cs private void StopJumping() { _jumpActionEndTime = 0; var velocity = _characterBody.Velocity; if (_isJumping && velocity.y > 0) { _characterBody.Velocity = new Vector2( velocity.x, velocity.y / _stopJumpFactor); } } Na koniec powtórzymy metodę . OnJump // CharacterController.cs public void OnJump(InputAction.CallbackContext context) { if (context.started) { if (_characterBody.State == CharacterState.Grounded || (!_isJumping && _lostGroundTime > Time.unscaledTime)) { Jump(); } else { _jumpActionEndTime = Time.unscaledTime + _jumpActionTime; } } else if (context.canceled) { StopJumping(); } } Teraz skakanie z pionowych powierzchni nie zakłóca już rytmu rozgrywki i wydaje się o wiele bardziej naturalne, pomimo pozornej absurdalności. Postać może dosłownie odepchnąć się od powietrza, pokonując dystans większy niż wydaje się to logiczne. Ale to jest dokładnie to, czego potrzeba do naszej platformówki. Zmiana postaci Ostatnim szlifem jest ustawienie postaci twarzą w kierunku ruchu. Wdrożymy to w najprostszy sposób — zmieniając skalę postaci wzdłuż osi x. Ustawienie wartości ujemnej sprawi, że nasz kapitan będzie zwrócony twarzą w przeciwnym kierunku. Najpierw zapiszmy oryginalną skalę na wypadek, gdyby różniła się od 1. // CharacterController.cs public class CharacterController : MonoBehaviour { //... private Vector3 _originalScale; private void Awake() { //... _originalScale = transform.localScale; } } Teraz, przy poruszaniu się w lewo lub w prawo, zastosujemy skalę dodatnią lub ujemną. // CharacterController.cs public class CharacterController : MonoBehaviour { public void OnMove(InputAction.CallbackContext context) { //... // Change character's direction. if (value.x != 0) { var scale = _originalScale; scale.x = value.x > 0 ? _originalScale.x : -_originalScale.x; transform.localScale = scale; } } } Sprawdźmy wynik. Podsumowanie Artykuł okazał się dość szczegółowy, ale udało nam się omówić wszystkie istotne aspekty sterowania postacią w platformówce 2D. Jako przypomnienie, możesz sprawdzić końcowy wynik w gałęzi „ ” repozytorium. Character Controller Jeśli podobał Ci się lub uznałeś ten i poprzedni artykuł za pomocne, docenię polubienia i gwiazdki na GitHub. Nie wahaj się skontaktować, jeśli napotkasz jakiekolwiek problemy lub znajdziesz błędy. Dziękuję za uwagę!
