Für das Bewegen deiner Spielfigur benötigst du Einen Character Controller. Ausgangslage bilden eine Umgebung mit Collidern. Desweiteren brauchst du einen Charakter. Der Charakter benötigt einen eigenen Collider. Als nächstes folgt das Hinzufügen eines 2D Rigidbody.

Erstelle für deinen Charakter ein Script und nenne es Character2DController.

Stelle das Script auf private void um:

Für die x-Achse benötigen wir ein Input:

var movement = Input.GetAxis („Horizontal“)

1 steht für die rechte Pfeiltaste und -1 für die linke Pfeiltaste.

Wir benötigen einen neue Vektor 3 für die x-Achse als Inputwert:

transform.position += newVector3(movement, 0, 0) * Time.DeltaTime * MovementSpeed;

Die neue Position berechnet sich asu dem neuen Vektor 3 * Time.DeltaTime * Bewegungsgeschwindigkeit (MovementSpeed)

Deswegen muss die Bewegungsgeschwindigkeit als Variable hinzugefügt werden:

public float MovementSpeed = 1;

Das Script sieht folgendermaßen aus:

Drückst in Unity auf Play, kannst du die Figur jetzt von Links nach Rechts bewegen. Du kannst die Geschwindigkeit erhöhen, wenn die Figur zu langsam ist.

Schaffe jetzt eine Refferenz zum Rigidbody:

private Rigidbody2D Rigidbody;

In die Startkomponente fügst du folgendes ein:

Rigidbody = GetComponent();

Ein weiteres Input wird benötigt:

if(Input.GetButtonDown(„Jump“))

Du benötigst eine Kraft in der y-Achse, die das Springen initiiert: Diese benennst JumpForce:

Rigidbody.AddForce(new Vector3(0, JumpForce));

JumpForce wird als Variable eingefügt:

public float JumpForce = 1;

Die Komponente gibt den Impuls zum Springen:

Rigidbody.AddForce(new Vector3(0, JumpForce), ForceMode2D.Impulse);

Jetzt kann die Y-Achse überprüft werden, um nur einmal zu springen:

if (Input.GetButtonDown(„Jump“) && Mathf.Abs(Rigidbody.velocity.y)

Das fertige Script sieht folgendermaßen aus:

Mit dieser Zusammenstellung kannst du dich erst einmal bewegen. Mit dem folgenden Teil des Tutorials wird das Script komplexer. Dafür musst du die Rigidbody-Komponenten in Rigidbody2D umbenennen.

Für das Ducken benötigst du folgende Variable:

private float CrouchSpeed = .36f;

Zur Glättung der Bewegung gibt es das Movement Smoothing:

private float MovementSmoothing = .05f;

Air Control definiert, ob ein Spieler beim Springen steuern kann oder nicht:

private bool AirControl = false;

WhatIsGround definiert die Untergrund für den Spieler:

private LayerMask WhatIsGround;

Groundcheck überprüft, ob sich der Spieler auf dem Boden befindet oder nicht:

private Transform GroundCheck;

Der CeilingCheck überprüft, ob eine Begrenzung nach oben vorhanden ist:

private Transform CeilingCheck;

CrouchDisableCollider definiert, das der Collider deaktiviert wird, wenn der Spieler sich duckt:

private Collider2D CrouchDisableCollider;

Damit sind die ersten Variablen definiert:

Es werden weitere Variablen benötigt:

const float GroundedRadius = .2f;

definiert den Radius des Überlappungskreises, um festzustellen, ob er sich auf dem definierten Untergrund befindet.

private book Grounded;

gibt an, ob der Spieler sich auf dem Untergrund befindet oder nicht.

const float CeilingRadius = .2f;

ist der Radius des Überlappungskreises, um festzustellen, ob der Spieler aufstehen kann oder sich eine Decke über ihn befindet.

private bool FacingRight = true;

Zum Bestimmen, in welche Richtung sich der Spieler gerade befindet.

private Vector3 Velocity = Vector3.zero;

Als nächstes benötigen wir das Eventsystem von Unity:

Du ergänzt:

using UnityEnginge.Events;

Desweitern wird ein UnityEvent benötigt, um zu erkennen, ob der Charakter nach dem Springen landet oder nicht:

public unityEvent OnLandEvent;

Das BoolEvent bezieht sich auf das Ducken:

public class BoolEvent : UnityEvent { }

public BoolEvent OnCrouchEvent;

private book wasCrouching = false;

Es folgt im Script keine Start- sondern die Awakefunktion:

Start beginnt wenn das Programm startet. Awake bezieht sich auf das Objekt, das innerhalb des Objekts initialisiert wird.

private void Awake ()

{

Rigidbody2D = GetComponent();

if (OnLandEvent == null)

OnLandEvent = new UnityEvent();

if (OnCrouchEvent == null)

OnCrouchEvent = BoolEvent();

}

Als nächstes definieren wir die „Grounded“ Position näher:

Der Spieler ist geerdet, wenn ein definierter Radius auf die Groundcheck-Position trifft, die als Ground bezeichnet wird:

private void FixedUpdate ()

{

bool wasGrounded = Grounded;

Grounded = false;

Collider2D[] colliders = Physics2D.OverlapCircleAll(GroundCheck.position, GroundedRadius, WhatIsGround);

for (int i = 0; i

{

if (colliders[i].gameObject != gameObject)

{

Grounded = true;

if (!wasGrounded)

OnLandEvent.Invoke();

}

}

}

Als nächstes wird überprüft, ob der Charakter, wenn er sich duckt, aufstehen kann. Wenn nicht, soll er sich ducken:

public void Move(float move, bool crouch, bool jump)

{

if (!crouch)

{

Wenn der Charakter eine Decke hat, die ihn am Aufstehen hindert, soll er sich weiter ducken:

if (Physics2D.OverlapCircle(CeilingCheck.position, CeilingRadius, WhatIsGround))

{

crouch = true;

}

}

Der Spieler kann die Figur nur Steuern, wenn sie sich auf dem Untergrund befindet oder airControl eingeschaltet ist:

if (Grounded || AirControl)

{

Wenn die Figur sich duckt:

if (crouch)

{

if (wasCrouching)

{

wasCrouching = true;

OnCrouchEvent.Invoke(true);

}

else if (wasCrouching)

{

wasCrouching = false;

OnCrouchEvent.Invoke(false)

}

Reduziere die Geschwindigkeit mit dem crouchSpeed-Multiplikator:

move *= CrouchSpeed;

Deaktiviere einen der Collider, wenn die Figur sich duckt oder hockt:

if (CrouchDisableCollider != null)

CrouchDisableCollider.enabled = false;

} else

{

Aktiviere den Collider, wenn die Figur nicht hockt oder duckt:

if (CrouchDisableCollider !=null)

CrouchDisableCollider.enabled = true;

if (wasCrouching)

{

wasCrouching = false;

OnCrouchEvent.Invoke(false);

}

}

Bewege den Charakter, indem du die Zielgeschwindigkeit ermittelst:

Vector3 targetVelocity = new Vector2(move * 10f, Rigidbody2D.velocity.y);

Und dann glätte es und wende es auf den Charakter an:

Rigidbody2D.velocity = Vector3.SmoothDamp(m_Rigidbody2D.velocity, targetVelocity, ref Velocity, MovementSmoothing);

Wenn die Eingabe sich nach rechts bewegt und der Player nach links zeigt:

if (move > 0 && !m_FacingRight)

drehe den Spieler um:

Flip();

Andernfalls, wenn sich der Input nach links bewegt und der Spieler nach rechts schaut:

else if (move

drehe den Spieler:

Flip();

Wenn der Spieler springen soll:

if (Grounded && jump)

{

Füge Sie dem Spieler eine vertikale Kraft hinzu.

Grounded = false;

Rigidbody2D.AddForce(new Vector2(0f, JumpForce));

private void Flip()

{

Wechseln Sie die Art und Weise, wie der Spieler als zugewandt gekennzeichnet ist:

FacingRight = !FacingRight;

Multipliziere die lokale x-Skala des Spielers mit -1.

Vector3 theScale = transform.localScale;

theScale.x *= -1;

transform.localScale = theScale;

}

}

Das fertige Script sieht folgendermaßen aus: