====== Spielfigur ======

Beginnen wir mit einer einfachen Spielfigur auf einem zweidimensionalen Feld, welche wir mit den Tasten w-a-s-d entsprechend steuern wollen. Bei Hindernissen soll die Spielfigur stehenbleiben und das Hindernis benennen.

Wir benötigen also eine Basis-Node welche sich bewegen lässt. Also ein KinematicBody2D. Diesen finden wir unter:
Node => CanvasItem => Node2D => CollisionsObject2D => PhysicsBody2D =>  KinematicBody2D

Damit wir diesen Node auch später sehen können, erweitern wir diesen Zweig mit einem Sprite.
Node => CanvasItem => Node2D => Sprite

Dieser Node kann eine Grafik aufnehmen und die wollen wir gleich auswählen.
Im Szene-Baum sollte noch der Node(Sprite) selektiert sein. Im Inspektor suchen wir nun den Parameter Texture mit dem Wert =null.

Aus dem Dateisystem können wir jetzt eine Grafik per Drag&Drop auf eben diesen Wert null ziehen.

----

Nach dem Erstellen eines neuen Projektes erzeugen wir zunächst eine eigene Szene für die Spielfigur.

Als Root-Node nutzen wir ein **KinematicBody2D** um mit der Spielfigur später auf Kollisionen reagieren zu können.

Hierunter legen wir das Node **Sprite**, in das wir im Inspektor unter Sprite => Textur eine Grafik bestimmen. Am einfachsten geht dies indem wir aus dem Dateisystem die entsprechende Datei mit gedrückt gehaltener Maus in das entsprechende Inspektor-Feld ziehen.

Für die Kollision benötigen wir noch ein Node **CollisionsShape2D** mit welchen wir im Inspektor unter CollisionsShape2D => Shape eine Form bestimmen. Diese Form ziehen wir danach auf die Größe des Sprites mit den innen liegenden Anfassern.

Mit dem Button (verhindern der Auswahl von Unterobjekten) aus dem 2D-Fenstermenü verhindern wir ein unterschiedliches Verschieben der jeweiligen Objekte

Als letztes fügen wir dem KinematicBody2D eins der folgenden Skripte zu:

====== Bewegung in X und Y Richtung ======

<code gdskript>
extends KinematicBody2D

var velocity = Vector2(0, 0)
var x=0
var y=0

func _physics_process(delta):
	if Input.is_key_pressed(KEY_W):
		y = -50
	elif Input.is_key_pressed(KEY_S):
		y = 50
	else:
		y = 0
	if Input.is_key_pressed(KEY_D):
		x = 50
	elif Input.is_key_pressed(KEY_A):
		x = -50
	else:
		x = 0
	velocity = Vector2(x, y)
	var collision_info = move_and_collide(velocity * delta)
	if collision_info:
		var objekt = collision_info.collider
		print(objekt.get_index())
		print(objekt.name) 
</code>


====== Bewegung in Sichtrichtung ======


<code gdskript>
extends KinematicBody2D

var dreh_geschw = 1
var schritt_geschw = 100
var drehung = 0

func _process(delta):
	var schritt = 0 # muss nach jedem durchlauf = 0 sein
	if Input.is_action_pressed("ui_up"):
		schritt = schritt_geschw * delta
	if Input.is_action_pressed("ui_down"):
		schritt = -schritt_geschw * delta
	if Input.is_action_pressed("ui_right"):
		drehung += dreh_geschw * delta
	if Input.is_action_pressed("ui_left"):
		drehung += -dreh_geschw * delta
	var vec = Vector2(0,schritt).rotated(drehung)
	var collision_info = move_and_collide(vec)
	if collision_info:
		var objekt = collision_info.collider
		print(objekt.get_index())
		print(objekt.name)
	# angabe in bogenmaß 2 * pi = 360°
	rotation = drehung
</code>


====== Jump & Run ======

<code gdskript>
extends KinematicBody2D

var motion = Vector2()

const up = Vector2(0,-1)
const gravity = 100
const speed = 200
const jump = -1000

func _physics_process(delta):
	if Input.is_action_pressed("ui_right"):
		motion.x = speed
	elif Input.is_action_pressed("ui_left"):
		motion.x = -speed
	else:
		motion.x = 0
	if is_on_floor():
		if Input.is_action_pressed("ui_up"):
			motion.y = jump
		else:
			motion.y += gravity
	move_and_slide(motion, up)

</code>

Über den Richtungsvektor up definieren wir welche Seite einer Kollision ein Auftreffen auf dem Boden(floor) ist. Eine Kollision mit einer Wand kann mit der Funktion is_on_wall() ermittelt werden.

Bei der Funktion move_and_slide() wird bereits intern der delta-Wert eingerechnet.