Charakterbewegung konfigurieren

Bevor du beginnst

Stellen Sie sicher, dass Sie die folgenden Ziele im vorherigen Abschnitt, Einen Spieler-Charakter mit Input-Actions erstellen, abgeschlossen haben:

• Eine C++- Character-Klasse erstellt. 

• Gelernt, wie Input-Actions und Input-Mapping-Kontexte funktionieren.

Lernen Sie, Input und Bewegung zu verknüpfen

Erkunden Sie einen Beispiel-Charakter-Blueprint, um zu lernen, wie Input-Actions, Input-Mapping-Kontexte und Code kombiniert werden, um Bewegung zu erzeugen. Lernen Sie anschließend, diese Funktionalität im Code umzusetzen.

Input in Blueprints visualisieren

Die BP_FirstPersonCharacter-Klasse, die in der First-Person-Vorlage enthalten ist, zeigt ein gutes Beispiel für die Interaktion von Blueprints und Input-Actions.

Navigieren Sie im Inhaltsbrowser-Asset-Baum zu Inhalt > FirstPerson > Blueprints. Doppelklicken Sie auf die Klasse BP_FirstPersonCharacter, um sie im Blueprint-Editor zu öffnen.

Der EventGraph des Blueprints befindet sich in der Mitte des Blueprint-Editors. Der EventGraph ist ein Knoten-Diagramm, das Events und Funktionsaufrufe verwendet, um eine geordnete Reihe von Actions in Reaktion auf das Gameplay auszuführen. In diesem Diagramm gibt es Knoten für Kamera-Input, Bewegungs-Input und Sprung-Input. 

Die Sprung-Input-Logik verstehen

Zoomen Sie in die Sprung-Input-Gruppe hinein. Der EnhancedInputAction-IA_Jump-Knoten repräsentiert das IA_Jump-Input-Action-Asset, das Sie im letzten Schritt erkundet haben.

Wenn die Input-Action ausgelöst wird, löst sie die Events Gestartet und Ausgelöst aus. Das Gestartet-Event des Knotens führt zu einem Funktionsknoten namens Springen. Die Parent-Charakter-Klasse dieses Blueprints hat eine eingebaut Sprung-Funktionalität. Die Funktion wird immer dann abgerufen, wenn IA_Jump durch Drücken einer Schaltfläche ausgelöst wird.

Wenn der Sprung beendet ist, löst der Knoten ein Abgeschlossen-Event aus. Dieses Event führt zu einem weiteren Funktionsknoten, Sprung stoppen, den es ebenfalls aus der Charakter-Klasse übernimmt.

Die Bewegungs-Input-Logik verstehen

Schauen Sie sich als Nächstes die Bewegungs-Input-Gruppe an. Diese Gruppe beginnt außerdem mit einem Knoten, der einer Input-Action entspricht, IA_Move.

Der Knoten IA_Move hat ein Ausgelöst-Event, das ausgelöst wird, wenn eine an IA_Move gebundene Schaltfläche gedrückt wird.

IA_Move enthält auch Action-Wert X und Action-Wert Y, also die X- und Y-Bewegungswerte, die durch Spieler-Input produziert werden. Da die X- und Y-Werte separate Werte sind, müssen Sie jeden von ihnen einzeln auf den Charakter anwenden.

Der Bewegen-Knoten ist ein benutzerdefinierter Funktionsknoten, der Bewegung auf den Charakter anwendet. Sie können am Knoten und im Details-Panel sehen, dass er zwei Inputs namens Links/Rechts und Vorwärts/Rückwärts verwendet und die X- und Y-Bewegungswerte von IA_Move an diese Inputs weitergegeben werden. 

Doppelklicken Sie auf den Bewegen-Knoten oder klicken Sie auf den Tab Bewegen über dem Diagramm, um die Logik innerhalb der Funktion anzuzeigen.

Die Funktion beginnt mit einem Funktionseingangsknoten mit seinen Input-Werten.    

Die Links/Rehts-Knotengruppe enthält einen Funktionsknoten Bewegungs-Input hinzufügen, der dem Charakter eine Bewegung basierend auf zwei Werten hinzufügt: Weltrichtung und Maßstabswert.

Weltrichtung ist die Richtung, der der Charakter in der Welt zugewendet ist, und der Maßstabswert ist die Menge an Bewegung, die angewendet werden soll. Da dieser Knoten die Links/Rechts-Bewegung steuert, verwendet er den Funktionsknoten Actor Rechts-Vektor abrufen, um zuerst den Rechts-Vektor der Position des Charakters in der Welt zu erhalten, und verwendet dann den Links/Rechts-Input (oder den X-Wert der Input-Action) als Maßstabswert, um eine Bewegung entlang dieses Vektors anzuwenden.

Wenn Links/Rechts positiv ist, bewegt sich der Charakter entlang der X-Achse nach oben oder nach rechts. Wenn Links/Rechts negativ ist, bewegt sich der Charakter entlang der X-Achse nach unten oder nach links.

Die Vorwärts/Rückwärts-Gruppe hatdenselben Aufbau wie die Links/Rechts-Gruppe, verwendet aber stattdessen den Vorwärts/Rückwärts-Input (den Y-Wert der Input-Action), um den Maßstab entlang des Vorwärts-Vektors des Actors zu bestimmen.

Das Replizieren dieser Knoten im Code erfordert etwas mehr Aufwand, ermöglicht aber eine präzise Kontrolle darüber, wie und wohin sich der Charakter bewegt.

Einem Spieler mit einem PlayerController Input zuweisen

Der Input-Mapping-Kontext ordnet den Spieler-Input den Input-Actions zu, aber Sie müssen diesen Input-Kontext noch mit dem Spieler verbinden. Der Standard-Spieler macht das mithilfe der PlayerController-Klasse und des Input-Subsystems.

Das PlayerController-Asset agiert als Brücke zwischen dem menschlichen Spieler und den In-game-Pawns, die er steuert. Es nimmt den Spieler-Input entgegen, verarbeitet diesen Input und übersetzt diesen in Befehle. Der Pawn erhält diese Befehle und bestimmt, wie er die Bewegung in der Spielwelt ausführt. Sie können denselben PlayerController verwenden, um verschiedene Pawns zu steuern.

Der PlayerController kann außerdem:

• Input während Zwischensequenzen oder Menüs deaktivieren.

• Punktestände oder andere Spielerdaten verfolgen.

• UI-Elemente spawnen oder ausblenden

Die Trennung zwischen PlayerController und Charakter ermöglicht Flexibilität und Datenpersistenz. Beispielsweise ist es möglich, Charaktere zu wechseln (zum Beispiel, wenn ein Spieler stirbt), ohne Spielerdaten oder Input-Logik zu verlieren, da diese im PlayerController verbleibt.

Um zu sehen, wie Sie das in Blueprints einrichten können, öffnen Sie im Ordner Blueprints im Inhaltsbrowser den Blueprint BP_FirstPersonPlayerController.

PlayerController-Klassen haben ein erweitertes Input-Subsystem für lokale Spieler. Das Subsystem ist mit einem bestimmten lokalen Spieler verbunden und verwaltet den Input-Kontext und die Mappings dieses Spielers zur Laufzeit. Damit können Sie verwalten, welche Inputs aktiv sind, und zur Laufzeit zwischen Input-Kontexten wechseln. Mehr Informationen zu UE-Subsystemen finden Sie hier:Programming Subsystems

Wenn das Spiel beginnt, und das Erweiterte Input-Subsystem für lokale Spieler gültig ist, ruft es Mapping-Kontext hinzufügen auf, um den Input-Mapping-Kontext IMC_Default an das Input-Subsystem des Spielers zu binden. Mit anderen Worten, diese Gruppe von Knoten aktiviert diesen Satz an Inputs für den Spieler.

Ihre Charakter-Klasse einrichten 

Nun, da Sie gesehen haben, wie Bewegung in Blueprints funktioniert, ist es an der Zeit, sie im Code einzubauen und anschließend die Bewegung Ihres Charakters durch das Level zu testen! Sie beginnen damit, alle nötigen Module und #include-Anweisungen hinzuzufügen, und deklarieren dann die Klassen, Funktionen und Eigenschaften, die Sie zur Implementierung der Charakterbewegung benötigen.

Erweitertes Eingabesystem hinzufügen

Sie haben bereits sichergestellt, dass das Erweiterte Eingabesystem im Unreal Editor aktiviert ist, allerdings müssen Sie es noch manuell in der Datei Build.cs Ihres Projekts deklarieren, um bestimmte Komponenten zu Ihrer Charakterklasse hinzuzufügen. 

Um das Erweiterte Eingabesystem in Ihrem C++-Projekt zu verwenden, befolgen Sie diese Schritte:

1. Öffnen Sie Ihr Projekt in Visual Studio und öffnen Sie dann [Projektname].Build.cs (zu finden im Source-Ordner zusammen mit den anderen Klassendateien Ihres Projekts).   

   Diese Datei sagt der Unreal Engine, welche Module Sie zum Erstellen Ihres Projekts benötigen.

2. Fügen Sie im Funktionsaufruf von PublicDependencyModuleNames  “EnhancedInput” zur Modulliste hinzu:    

   C++

   PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "EnhancedInput" });

   Copy full snippet(1 line long)

3. Speichern und schließen Sie die Build.cs- Datei.  

Befolgen Sie diese Schritte, um Komponenten des erweiterten Eingabesystems zu Ihrer Charakterklasse hinzuzufügen:

1. Öffnen Sie die .h-Datei Ihres Charakters. Fügen Sie oben in der Datei die folgenden include-Anweisungen hinzu:

   • #include “EnhancedInputComponent.h” fügt das Enhanced-Input-Modul hinzu.  

   • #include “InputActionValue.h” Ermöglicht den Zugang zu den Input-Action-Werten, die von Ihren Input-Actions produziert wurden.  

   • #include “EnhancedInputSubsystems.h” aktiviert den Zugriff auf das Subsystem des lokalen Spielers.  

   C++

   // Copyright Epic Games, Inc. All Rights Reserved.
   
   #pragma once
   
   #include "CoreMinimal.h"
   #include "GameFramework/Character.h"
   #include "EnhancedInputComponent.h"
   #include "EnhancedInputSubsystems.h" 
   #include "InputActionValue.h"
   #include "AdventureCharacter.generated.h"

   Copy full snippet(10 lines long)

   Stellen Sie sicher, dass alle #include-Anweisungen, die Sie hinzufügen, vor der AdventureCharacter.generated.h- Anweisung stehen. Damit Ihr Code die Funktionseigenschaft besitzt, muss diese Anweisung in der Liste der Inputs die letzte sein.  

2.   Deklarieren Sie nach den #include-Anweisungen drei neue Klassen:   

   • UInputMappingContext

   • UInputAction

   • UInputComponent

   Diese Klassen existieren bereits im Enhanced-Input-Modul. Die Deklaration eines existierenden Objekts wie dieses wird Vorwärts-Deklaration genannt und sagt dem Compiler, dass die Klasse existiert und dass man sie verwenden wird.  

   C++

   // Copyright Epic Games, Inc. All Rights Reserved.
   
   #pragma once
   
   #include "CoreMinimal.h"
   #include "GameFramework/Character.h"
   #include "EnhancedInputComponent.h"
   #include "EnhancedInputSubsystems.h" 
   #include "InputActionValue.h"
   #include "AdventureCharacter.generated.h"
   
   Expand code Copy full snippet(14 lines long)

Einen InputMappingContext-Zeiger deklarieren

Fügen Sie im protected Abschnitt der .h Datei Ihres Charakters unter Verwendung von TObjectPtr einen neuen UInputMappingContext-Pointer mit dem Namen FirstPersonContext hinzu. Dies ist ein Pointer auf den Import-Mapping-Kontext, der Ihre Input-Actions mit dem Drücken von Schaltflächen verknüpft.

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
TObjectPtr<UInputMappingContext> FirstPersonContext;

Das UPROPERTY()-Makro, das vor einer Variable steht, informiert die Unreal Engine über diese Variable. Das Unreal Header Tool verwendet das Makro, um Informationen über Ihren Code zu verarbeiten und zu steuern, wo auf die Variable zugegriffen werden kann, wie sie im Editor erscheint und mehr.  

Dieser Zeiger hat die folgenden UPROPERTY-Werte:

• EditAnywhere: Macht die Eigenschaft für den Unreal Editor im Details-Panel der Klasse verfügbar.

• BlueprintReadOnly: Blueprints können auf diese Eigenschaft zugreifen, sie aber nicht bearbeiten.

• Category = Input: Die Eigenschaft erscheint unter einem Abschnitt namens Input im Details-Panel der Klasse. Kategorien sind nützlich, um Ihren Code zu organisieren, und können die Navigation im Editor wesentlich vereinfachen.

Springen- und Bewegen-InputAction-Zeiger deklarieren

Fügen Sie außerdem im protected-Abschnitt zwei UInputAction-Zeiger hinzu, die MoveAction und JumpAction heißen. Dabei handelt es sich um Zeiger auf die Input-Actions IA_Jump und IA_Move.

Geben Sie diesen das gleiche UPROPERTY()-Makro wie UInputMappingContext. 

protected:
	// Called when the game starts or when spawned
	virtual void BeginPlay() override;

	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
	TObjectPtr<UInputMappingContext> FirstPersonContext;

	// Move Input Actions
	UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Input)
	TObjectPtr<UInputAction> MoveAction;

Die Move()-Funktion deklarieren

Ihre Input-Actions erzeugen Input-Action-Werte, und Sie geben diese Werte an eine neue Funktion weiter, die diese Werte verwendet, um Bewegung auf Ihren Charakter anzuwenden.

Deklarieren Sie im public-Abschnitt der Datei eine neue Funktion namens Move(), die eine konstante FInputActionValue-Referenz namens Value entgegennimmt.

// Handles 2D Movement Input
UFUNCTION()
void Move(const FInputActionValue& Value);

Das UFUNCTION()-Makro, das vor der Deklaration der Funktion steht, macht das Unreal Header Tool auf die Funktion aufmerksam.

Speichern Sie die Datei. Die Header-Datei Ihres Charakters sollte nun so aussehen:

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"
#include "AdventureCharacter.generated.h"

class UInputMappingContext;

Bewegungsfunktionen implementieren

Nun haben Sie die Eigenschaften, die Sie für die Bewegung benötigen, in der .cpp-Datei Ihres Charakters festgelegt. Jetzt werden Sie Ihre Funktionen so anlegen, dass sie die Funktionalität imitieren, die Sie im Blueprint des Standard-Charakters gesehen haben. 

Die Move()-Funktion einrichten

Öffnen Sie die .cpp- Klasse Ihres Charakters und fügen Sie eine neue Funktionsdefinition für Move() hinzu, um die in Ihrer .h -Datei deklarierte zu implementieren. 

void AAdventureCharacter::Move(const FInputActionValue& Value)
{
) 

Beim Erkunden der Input-Actions des Standard-Charakters haben Sie gesehen, dass IA_Move einen Wertetyp von Axis2D (Vector2D) hat, sodass es bei der Auslösung einen FVector2D-Wert zurückgibt.

Rufen Sie innerhalb von Move() den Wert von FInputActionValue ab und speichern Sie ihn in einem neuen FVector2D mit dem Namen MovementValue:

void AAdventureCharacter::Move(const FInputActionValue& Value)
{
	// 2D Vector of movement values returned from the input action
	const FVector2D MovementValue = Value.Get<FVector2D>();
}

Fügen Sie als Nächstes eine if-Anweisung hinzu, um zu prüfen, ob der Controller gültig ist. Controller ist ein Zeiger auf den Controller, der diesen Actor besitzt, und muss gültig sein, damit die Bewegung funktioniert. 

void AAdventureCharacter::Move(const FInputActionValue& Value)
{

	// 2D Vector of movement values returned from the input action
	const FVector2D MovementValue = Value.Get<FVector2D>();

	// Check if the controller possessing this Actor is valid
	if (Controller)
	{
	}

2D-Bewegungs-Input mit Move() hinzufügen

Um im Charakter-Blueprint Bewegung nach links, rechts, vorwärts und rückwärts zu erzeugen, fügte der Event-Diagramm Bewegungs-Input hinzu, indem es Action-Wert X und Action-Wert Y von IA_Move mit dem Rechts-Vektor und Vorwärts-Vektor des Actors kombinierte. Sie implementieren dies im Code innerhalb der Move()-Funktion.

Rufen Sie innerhalb der if-Anweisung GetActorRightVector() auf, um den Rechts-Vektor des Actor in einem neuen FVector namens Rechts zu speichern.

const FVector Right = GetActorRightVector();

Rufen Sie dann AddMovementInput() auf, um dem Charakter eine Bewegung hinzuzufügen, und übergeben Sie Rechts und MovementValue.X. 

AddMovementInput(Right, MovementValue.X);

Wiederholen Sie diesen Vorgang für die Vorwärts- und Rückwärtsbewegung mit GetActorForwardVector(), wobei Sie dieses Mal MovementValue.Y übergeben.

Ihre fertige Move()-Funktion sollte so aussehen:

void AAdventureCharacter::Move(const FInputActionValue& Value)
{
	// 2D Vector of movement values returned from the input action
	const FVector2D MovementValue = Value.Get<FVector2D>();

	// Check if the controller posessing this Actor is valid
	if (Controller)
	{
		// Add left and right movement
		const FVector Right = GetActorRightVector();

Bewegung mit SetupPlayerInputComponent an Input binden

Verknüpfen Sie nun Ihre Move-Funktion mit dem FirstPersonContext-Input-Mapping-Kontext, den Sie zuvor deklariert haben.

Die Funktion dafür, SetupPlayerInputComponent(), ist bereits in der .cpp- Datei Ihres Charakters definiert, da sie von ACharacter geerbt wurde. Diese Funktion verwendet eine UInputComponent, um den Spieler-Input einzurichten.

Auf eine Enhanced-Input-Komponente prüfen

Standardmäßig beginnt diese Funktion mit einem Aufruf der Funktion SetupPlayerInputComponent() von ACharacter, die überprüft, ob eine Input-Komponente für den Charakter existiert. 

// Called to bind functionality to input
void AAdventure::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	Super::SetupPlayerInputComponent(PlayerInputComponent);
}

Dies prüft nur, ob eine reguläre Input-Komponente für den Charakter existiert. Sie müssen stattdessen prüfen, ob eine Enhanced-Input-Komponente vorhanden ist. Löschen Sie also den Aufruf der Funktion SetupPlayerInputComponent() der Parent-Klasse.

Bestimmen Sie stattdessen in einer if-Anweisung einen neuen UEnhancedInputComponent-Zeiger namens EnhancedInputComponent. Setzen Sie dies auf das Ergebnis des Aufrufs von CastChecked() für die PlayerInputComponent, die an diese Funktion übergeben wurde, während sie zu UEnhancedInputComponent gecastet wird.

if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
{

}

Bewegungs-Actions binden

Rufen Sie innerhalb der if-Anweisung die BindAction()-Funktion der EnhancedInputComponent auf. 

Übergeben Sie die folgenden Argumente an die Funktion: 

• MoveAction: Eine Input-Action, die gebunden werden soll (deklariert in der .h- Datei des Charakters).

• Ausgelöstes Event von ETriggeredEvent: Der Auslösertyp für das Event.

• this: Der Charakter, an den gebunden werden soll.

• Move(): Eine Referenz auf die Funktion, die Sie binden wollen.

if (TObjectPtr<UEnhancedInputComponent> EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
{
	// Bind Movement Actions
	EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AAdventureCharacter::Move);
}

Wenn IA_Move nun ausgelöst wird, ruft es die Move()-Funktion auf, um Ihrem Charakter Bewegung zu verleihen!

Sprung-Actions binden

Fügen Sie als Nächstes zwei Bindungen zu IA_Jump hinzu, eine, um das Springen zu starten, und eine, um das Springen zu stoppen.

Sie verwenden die folgenden Argumente:

• JumpAction, der Input-Action-Zeiger auf IA_Jump, den Sie in der .h- Datei deklariert haben.

• Gestartet- und Abgeschlossen-Trigger-Events.

• Jump- und StopJumping-Funktionen werden von der ACharacter-Parent-Klasse übernommen und sind in ihr definiert.

// Bind Jump Actions
EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Started, this, &ACharacter::Jump);
EnhancedInputComponent->BindAction(JumpAction, ETriggerEvent::Completed, this, &ACharacter::StopJumping);

Ihre SetupPlayerInputComponent()-Funktion sollte nun so aussehen: 

// Called to bind functionality to input
void AAdventureCharacter::SetupPlayerInputComponent(UInputComponent* PlayerInputComponent)
{
	// Check the UInputComponent passed to this function and cast it to an UEnhancedInputComponent
	if (UEnhancedInputComponent* EnhancedInputComponent = CastChecked<UEnhancedInputComponent>(PlayerInputComponent))
	{
		// Bind Movement Actions
		EnhancedInputComponent->BindAction(MoveAction, ETriggerEvent::Triggered, this, &AAdventureCharacter::Move);
		
		// Bind Jump Actions

Input-Mapping an den Charakter binden

Sie haben Ihre Inputs an Funktionen gebunden, müssen aber noch immer Ihren Input-Mapping-Kontext an Ihren Charakter binden. Das können Sie in der BeginPlay()-Funktion Ihres Charakters tun, damit der Input eingerichtet wird, wenn das Spiel startet.

Prüfen Sie in BeginPlay(), ob der globale Engine-Zeiger null ist, bevor Sie fortfahren.

check(GEngine != nullptr);

Erstellen Sie in einer if-Anweisung einen neuen APlayerController-Zeiger namens PlayerController. Setzen Sie sie auf das Ergebnis des Wirkens von Controller auf APlayerController.

// Get the player controller for this character
if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
{

}

Die if-Anweisung stellt sicher, dass die Ausführung nur dann fortgesetzt wird, wenn der Zeiger nicht null ist.

Jetzt müssen Sie das erweiterte Input-Subsystem für lokale Spieler abrufen und den FirstPersonContext-Input-Mapping-Kontext (deklariert in Ihrer .h -Datei) zum Subsystem hinzufügen.

Erstellen Sie in einer weiteren if-Anweisung einen neuen UEnhancedInputLocalPlayerSubsystem-Zeiger namens Subsystem, indem Sie ULocalPlayer::GetSubsystem() abrufen und den aktuellen Spieler übergeben. Sie können den aktuellen Spieler abrufen, indem Sie PlayerController->GetLocalPlayer() aufrufen.

if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
{
  if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
  {

  }
}

Fügen Sie den Mapping-Kontext zum Subsystem hinzu, indem Sie AddMappingContext() aufrufen und den Mapping-Kontext sowie eine Priorität von 0 übergeben, um diesem Mapping-Kontext die höchste Priorität zu geben. 

// Get the enhanced input local player subsystem and add a new input mapping context to it
if (UEnhancedInputLocalPlayerSubsystem* Subsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(PlayerController->GetLocalPlayer()))
{
	Subsystem->AddMappingContext(FirstPersonContext, 0);
}

Fügen Sie abschließend eine neue Debug-Nachricht hinzu, um zu überprüfen, ob Ihre benutzerdefinierte Charakter-Klasse verwendet wird.

Ihre BeginPlay()-Funktion sollte so aussehen:

// Called when the game starts or when spawned
void AAdventureCharacter::BeginPlay()
{
	Super::BeginPlay();

	check(GEngine != nullptr);

	// Get the player controller for this character
	if (APlayerController* PlayerController = Cast<APlayerController>(Controller))
	{

Speichern Sie Ihre .h- Header- und .cpp- Implementierungsdateien in Visual Studio und klicken Sie dann auf Build, um Ihr Projekt zu kompilieren.

Variablen im Charakter-Blueprint festlegen

Um die Einstellung dieser Bewegungssteuerelemente abzuschließen, verwenden Sie den Blueprint Ihres Charakters, um den Variablen, die Sie im Code deklariert haben, Assets zuzuweisen.

Befolgen Sie diese Schritte, um die neuen Eigenschaften Ihres Charakters mit Assets zu bevölkern:

1. Öffnen Sie im Unreal Editor Ihren Charakter-Blueprint im Blueprint-Editor, falls er noch nicht offen ist.

2. Legen Sie im Details-Panel unter Input die folgenden Eigenschaften fest:

   • Setzen Sie den First-Person-Kontext auf IMC_Adventure.

   • Setzen Sie Bewegungs-Action auf IA_Move.

   • Setzen Sie Sprung-Action auf IA_Jump.

3. Speichern Sie Ihren Blueprint und klicken Sie auf Kompilieren, um ihn zu kompilieren.

Charakter-Bewegung testen

Klicken Sie auf Spielen in der Symbolleiste des Level-Editors, um den Modus Im Editor spielen zu starten. Wenn das Spiel startet, sollte „Hallo Welt!“ und „Wir verwenden AdventureCharacter“ auf dem Bildschirm erscheinen. Sie sollten sich mit WASD oder Pfeiltasten bewegen und mit der Leertaste springen können.

Als Nächstes

Sie haben einen sich bewegenden Charakter, aber ihm fehlen noch das richtige Mesh und die Kamera. Im nächsten Abschnitt erfahren Sie, wie Sie eine Kamera-Komponente erstellen, an Ihren Charakter binden und Skelett-Meshs hinzufügen, um eine echte First-Person Perspektive zu erhalten!

First-Person Kamera, Mesh und Animation hinzufügen

Lernen Sie, wie Sie mit C++ Mesh- und Kamera-Komponenten an einem First-Person-Charakter ankoppeln.

Vollständiger Code

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "EnhancedInputComponent.h"
#include "EnhancedInputSubsystems.h" 
#include "InputActionValue.h"
#include "AdventureCharacter.generated.h"

class UInputMappingContext;

#include "AdventureCharacter.h"

// Sets default values
AAdventureCharacter::AAdventureCharacter()
{
	// Set this character to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
	PrimaryActorTick.bCanEverTick = true;

}

// Fill out your copyright notice in the Description page of Project Settings.

using UnrealBuildTool;

public class AdventureGame : ModuleRules
{
	public AdventureGame(ReadOnlyTargetRules Target) : base(Target)
	{
		PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;