Unity is a [[gameengine|game engine]] that can be written in [[coding:csharp|C#]].


  * Basic Physics https://www.degruyter.com/view/journals/jib/15/2/article-20180009.xml
  * Movement (3d) https://www.youtube.com/watch?v=ixM2W2tPn6c

=====Transform=====

====transform.position====

Mit "transform.position += ..." änderst du direkt die Position des Objekts im globalen (Welt-)Koordinatensystem. Es bewegt sich um den angegebenen Vektor im globalen Raum.

<code csharp>
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float moveSpeed = 5.0f;

    void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        Vector3 movement = new Vector3(horizontal, 0, vertical) * moveSpeed * Time.deltaTime;
        transform.position += movement;
    }
}
</code>

====transform.Translate()====
Mit "transform.Translate(movement, Space.World)" verschiebst du das Objekt relativ zum globalen Koordinatensystem. Das bedeutet, dass die Verschiebung im globalen Raum stattfindet, unabhängig von der Ausrichtung des Objekts.

Mit "transform.Translate(movement, Space.Local)" verschiebst du das Objekt relativ zu seinem eigenen lokalen Koordinatensystem. Die Verschiebung erfolgt entlang der lokalen Achsen des Objekts, unabhängig von seiner Ausrichtung im Weltraum.

<code csharp>
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float moveSpeed = 5.0f;

    void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        Vector3 movement = new Vector3(horizontal, 0, vertical) * moveSpeed * Time.deltaTime;
        transform.Translate(movement, Space.World);
    }
}
</code>

=====Bodies=====

In Unity, gibt es verschiedene Arten von Körpern (Bodies), die verwendet werden können, um die physikalischen Eigenschaften von Objekten in einer Spielwelt zu simulieren. Hier sind einige der wichtigsten Körperarten in Unity:

  * Rigidbody: Ein Rigidbody ist ein dynamischer Körper, der von der Physik-Engine beeinflusst wird. Er reagiert auf Kräfte wie Schwerkraft und Kollisionen mit anderen Körpern. Rigidbody-Objekte können sich aufgrund von Kräften bewegen und rotieren.
  * Collider: Ein Collider ist ein Körper, der nur dazu dient, Kollisionen zu erkennen, aber nicht von der Physik-Engine beeinflusst wird. Es gibt verschiedene Arten von Collidern in Unity, darunter Box Collider, Sphere Collider, Capsule Collider, Mesh Collider und mehr.
  * CharacterController: Dies ist ein spezialisierter Körper für die Steuerung von Charakteren. Er bietet eine einfache Möglichkeit, die Bewegung von Charakteren zu steuern, ohne die volle Physiksimulation zu verwenden.
  * Terrain Collider: Ein spezialisierter Collider für die Kollisionserkennung auf Terrain-Oberflächen.
  * Wheel Collider: Wird verwendet, um die Physik von Rädern in einem Fahrzeug zu simulieren.
  * Spring Joint: Ein Gelenk, das dazu verwendet wird, eine Art von Feder- oder Dämpfungsverhalten zwischen zwei Objekten zu simulieren.
  * Fixed Joint: Ein Gelenk, das zwei Objekte fest miteinander verbindet, so dass sie sich nicht relativ zueinander bewegen können.
  * Hinge Joint: Ein Gelenk, das eine Art von Drehbewegung zwischen zwei Objekten ermöglicht.
  * Slider Joint: Ein Gelenk, das eine Art von linearer Bewegung zwischen zwei Objekten ermöglicht.
  * Configurable Joint: Ein vielseitiges Gelenk, das verschiedene Arten von Bewegungen zwischen zwei Objekten ermöglicht.

=====Rigidbody=====

Wenn ein GameObject eine Rigidbody Komponente hat, kannst du die physikalischen Kräfte nutzen, um es zu bewegen. 

<box green>Physikalische Objekte sollten immer in FixedUpdate() verarbeitet werden!</box>

Um ein GameObject mit einer Rigidbody-Komponente in Unity zu bewegen, gibt es mehrere Möglichkeiten.

  * AddForce zur Anwendung von Kräften auf das Rigidbody.
  * velocity zur direkten Änderung der Geschwindigkeit des Rigidbody.
  * MovePosition zur sofortigen Platzierung des Rigidbody an einer neuen Position.

====AddForce====
Du kannst die AddForce() Methode verwenden, um eine Kraft auf das Rigidbody anzuwenden. Dies eignet sich gut für die Simulation von physikalischen Bewegungen.

<code csharp>
Rigidbody rb = GetComponent<Rigidbody>();
rb.AddForce(Vector3.forward * forceAmount, ForceMode.Impulse);
</code>

====velocity====
Du kannst die velocity Eigenschaft direkt setzen, um die Geschwindigkeit des Rigidbody zu ändern. Dies überschreibt eventuelle bestehende Kräfte.

<code csharp>
Rigidbody rb = GetComponent<Rigidbody>();
rb.velocity = new Vector3(x, y, z);
</code>

====MovePosition====
Mit der MovePosition() Methode kannst du den Rigidbody sofort an eine neue Position setzen. Dies kann nützlich sein, wenn du sicherstellen möchtest, dass das GameObject an einem bestimmten Punkt endet. Beachte, dass diese Methode keine Kollisionserkennung enthält und möglicherweise durch andere Objekte hindurchgehen kann.

<code csharp>
Rigidbody rb = GetComponent<Rigidbody>();
rb.MovePosition(new Vector3(x, y, z));
</code>
=====CharacterController=====

Der CharacterController ist eine spezialisierte Komponente für die Bewegung von Charakteren in Spielen. Sie ermöglicht die einfache Steuerung von Charakteren, die sich in der Szene bewegen müssen. 

====Move====
Die Move() Methode bewegt den Charakter relativ zu seiner aktuellen Position, wobei **Kollisionen mit anderen Objekten automatisch behandelt** werden.

<code>
using UnityEngine;

public class MoveController : MonoBehaviour
{
    public float moveSpeed = 3.0f;
    public float rotationSpeed = 120.0f;
    public float jumpForce = 5.0f;
    public float crouchHeight = 0.5f;
    public float standingHeight = 2.0f;

    private CharacterController characterController;
    private bool isCrouching = false;

    void Start()
    {
        characterController = GetComponent<CharacterController>();
    }

    void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        Vector3 moveDirection = transform.forward * vertical;
        float turnAmount = horizontal * rotationSpeed * Time.deltaTime;
        transform.Rotate(0, turnAmount, 0);

        // Jumping
        if (Input.GetButtonDown("Jump") && characterController.isGrounded)
        {
            moveDirection.y = jumpForce;
        }

        // Crouching
        if (Input.GetKeyDown(KeyCode.C))
        {
            if (isCrouching)
            {
                characterController.height = standingHeight;
                isCrouching = false;
            }
            else
            {
                characterController.height = crouchHeight;
                isCrouching = true;
            }
        }

        characterController.Move(moveDirection * moveSpeed * Time.deltaTime);
    }
}
</code>

====SimpleMove====
Du kannst auch die integrierte Schwerkraft und Geschwindigkeit des CharacterController verwenden, um ihn zu bewegen.
<code>
using UnityEngine;

public class SimpleMoveController : MonoBehaviour
{
    public float moveSpeed = 3.0f;
    public float jumpForce = 5.0f;
    public float crouchHeight = 0.5f;
    public float standingHeight = 2.0f;

    private CharacterController characterController;
    private bool isCrouching = false;

    void Start()
    {
        characterController = GetComponent<CharacterController>();
    }

    void Update()
    {
        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        Vector3 moveDirection = new Vector3(horizontal, 0, vertical);
        moveDirection = transform.TransformDirection(moveDirection);
        moveDirection *= moveSpeed;

        // Jumping
        if (Input.GetButtonDown("Jump") && characterController.isGrounded)
        {
            moveDirection.y = jumpForce;
        }

        // Crouching
        if (Input.GetKeyDown(KeyCode.C))
        {
            if (isCrouching)
            {
                characterController.height = standingHeight;
                isCrouching = false;
            }
            else
            {
                characterController.height = crouchHeight;
                isCrouching = true;
            }
        }

        characterController.SimpleMove(moveDirection);
    }
}
</code>

====Springen====
Um den CharacterController zum Springen zu bringen, kannst du die Move-Methode mit einer zusätzlichen y-Komponente verwenden.
<code>
if (characterController.isGrounded)
{
    velocity.y = jumpForce;
}

characterController.Move(velocity * Time.deltaTime);
</code>

=====FPS Controller=====

Bei einem FPS Controller werden Bewegungen und Drehungen meißt separat behandelt.

====PlayerMovement====
<code csharp>
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerMovement : MonoBehaviour
{
    public float walkSpeed = 5.0f;
    public float runSpeed = 10.0f;
    public float crouchSpeed = 2.0f;
    public float jumpForce = 8.0f;

    private CharacterController controller;
    private bool isCrouching = false;

    void Start()
    {
        controller = GetComponent<CharacterController>();
    }

    void Update()
    {
        float moveSpeed = walkSpeed;

        if (Input.GetKey(KeyCode.LeftShift))
        {
            moveSpeed = runSpeed;
        }

        if (isCrouching)
        {
            moveSpeed = crouchSpeed;
        }

        float horizontal = Input.GetAxis("Horizontal");
        float vertical = Input.GetAxis("Vertical");

        Vector3 move = transform.right * horizontal + transform.forward * vertical;
        controller.Move(move * moveSpeed * Time.deltaTime);

        if (Input.GetButtonDown("Jump") && controller.isGrounded)
        {
            controller.Move(Vector3.up * jumpForce * Time.deltaTime);
        }

        if (Input.GetKeyDown(KeyCode.LeftControl))
        {
            ToggleCrouch();
        }
    }

    void ToggleCrouch()
    {
        if (isCrouching)
        {
            controller.height = 2.0f;
            isCrouching = false;
        }
        else
        {
            controller.height = 1.0f;
            isCrouching = true;
        }
    }
}
</code>

====PlayerController====
<code csharp>
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    public float mouseSensitivity = 100.0f;
    public Transform playerBody;
    private float xRotation = 0.0f;

    void Start()
    {
        Cursor.lockState = CursorLockMode.Locked;
    }

    void Update()
    {
        float mouseX = Input.GetAxis("Mouse X") * mouseSensitivity * Time.deltaTime;
        float mouseY = Input.GetAxis("Mouse Y") * mouseSensitivity * Time.deltaTime;

        xRotation -= mouseY;
        xRotation = Mathf.Clamp(xRotation, -90.0f, 90.0f);

        transform.localRotation = Quaternion.Euler(xRotation, 0.0f, 0.0f);
        playerBody.Rotate(Vector3.up * mouseX);
    }
}
</code>

{{160721_jens_fakesch_ma_1_.pdf}}

SceneAssetBundle https://stackoverflow.com/questions/54787943/how-to-load-a-scene-from-asset-bundle-in-unity-2018

[[https://www.raywenderlich.com/5671826-introduction-to-shaders-in-unity|Shader basdics]]

[[https://www.youtube.com/watch?v=JfC_ye23MvY|Shader Tutorial]]

[[https://www.youtube.com/playlist?list=PLX2vGYjWbI0RS_lkb68ApE2YPcZMC4Ohz|Shader tutorial Advanced Playlist]]

[[https://www.youtube.com/watch?v=VW58CT27LsM|CrossPlatformInputManager implementation]]