Fluid Simulation

Umgang mit AI:

• Der Weg ist das Ziel!
• Challenge:
  • Verwende keine AI für die Logik.
  • Lasse dir von AI keinen Code schreiben.
  • Verwende AI höchstens als Tutor, um dir Dinge zu erklären.

Als Vorbereitung versuchen wir zuerst, ein 2D-Fluid aus vielen Teilchen zu simulieren, die sich gegenseitig stossen. Die Grundidee hinter diesem - physikalisch nicht sehr realistischen - Fluid ist wie folgt:

1. Spawning: Erzeuge eine möglichst grosse Anzahl an Teilchen, alle mit identischem Radius und Masse. Visualisiert werden sie als kleine, einfarbige Kreise. Spawne diese z.B. an Zufallspositionen mit zufälligem Anfangsgeschwindigkeitsvektor.
2. Collision Detection: Ermittle, welche Teilchen mit den Wänden und v.a. miteinander kollidieren, also aktuell überlappen. Für diesen Schritt werden wir verschiedene Möglichkeiten anschauen.
3. Collision Handling: Kümmere dich um alle Teilchen, die aktuell gerade kollidieren. Zum Beispiel muss man dafür die neuen Geschwindigkeitsvektoren nach der Kollision berechnen. Für einen gewissen Realismus sollten die Teilchen bei jeder Kollision einen gewissen Anteil ihrer Energie oder Geschwindigkeit verlieren.

1. Erstelle ein GitHub-Repo für alle Projekte in diesem Modul. Nenne es z.B. FluidSimulationsUnity und wähle die passenden Einstellungen (private, gitignore-File). Clone es auf deinen Computer. Arbeite von nun an darin. Add, commit, push selbständig und regelmässig.
   
   
2. Installiere Unity-Hub und darin eine aktuelle Unity-Version.
   
   
3. Erstelle nun ein neues Unity Projekt vom Typ Core: Universal 2D (z.B. FluidParticles).
   
   
4. Implementiere nun das Template-Projekt (siehe unten), welche als Ausgangslage dient. Wird das Projekt ausgeführt, sollte ein farbiges Teilchen erscheinen, welches sich nach oben bewegt. Studiere den Code genau und stelle sicher, dass du diesen verstehst.
   
   
5. Passe den Code nun so an, dass eine grössere Anzahl Teilchen (sagen wir ca. $100$) erzeugt werden. Diese sollen an Zufallspositionen gespawned werden. Dafür werden zwei Arrays benötigt: Eines für die ParticleModels und eines für die ParticleViews.
   
   
6. Implementiere eine erste Dynamik:
   1. Jedes Particle soll eine zufällige Anfangsgeschwindigkeit haben (versch. Richtungen und Speed) und sich entsprechend bewegen.
   2. An den Wänden sollen sie ohne Energieverlust reflektiert werden.
   3. Kollisionen zwischen Teilchen werden noch ignoriert, sie bewegen sich also einfach durch einander hindurch.
      
      
7. Collision Detection V1:
   1. Implementiere nun eine erste Version der Collision Detection: Iteriere über alle Teilchen. Iteriere für jedes Teilchen über alle anderen Teilchen und schaue, ob sie kollidieren. Dafür benötigst du also zwei ineinander verschachtelte Schleifen.
   2. Zwei Teilchen kollidieren dann, wenn deren Abstand kleiner ist als $2\times$ der Radius. Alle Teilchen sollen, während sie miteinander kollidieren, eine andere Farbe annehmen. Siehe Tipps unten.
   3. Für wie viele Teilchen kannst du deine Simulation flüssig laufen lassen? Warum geht nicht mehr? Was ist das Problem mit dieser Art von Collision Detection?

1. Neues 2D Unity-Projekt vom Type Core: Universal 2D
   
   
2. Erstelle unter Assets folgende Unterordner für saubere Struktur: Prefabs, Scripts. Ziehe dann später alle Scripts und Prefabs in den entsprechenden Ordner.
   
   
3. Erstelle ein neues, leeres GameObject z.B. mit Namen Simulation. Hänge diesem das Script MainScript (siehe unten) an. Alternativ könnte man das Scipt auch der MainCamera anhängen.
   
   
4. Füge die Scripts Particle.cs und ParticleView.cs an. Die Idee ist, dass unser Code einer Trennung von Modell (Particle) und Anzeige (ParticleView.cs) folgt.
   
   
5. Particle Prefab:
   1. Erstelle in der Hierarchy eine farbige Kugel (2D Objects / Sprites / Circle), Farbe aussuchen.
   2. Gib Namen Particle.
   3. Hänge ParticleView Script an.
   4. Speichere als Prefab: Einfach aus Hierarchy in Prefab-Ordner ziehen.
   5. Lösche wieder aus Hierarchy.
      
      
6. Der Code sollte nun wie folgt funktionieren: Führt man den Code aus, so erschein in der Mitte des Bildschirms ein farbige Kugel, die sich nach oben bewegt.

Code

using UnityEngine;
 
public class MainScript : MonoBehaviour
{
    [Header("Simulation settings")] // creates header in Unity Inspector
    public GameObject prefabParticle; // drag particle prefab on this field in Inspector
    // and all other game settings
 
    // PRIVARTE FIELDS
    private ParticleModel particleModel;
    private ParticleView particleView;
 
    void Start()
    {
        InitParticles(); // create particles
    }
 
    void InitParticles()
    {
        Debug.Log("Instantiate Particles");
 
        // Check if prefab is assigned
        if (prefabParticle == null)
        {
            Debug.LogError("prefabParticle is not assigned! Please assign a prefab in the Inspector.");
            return;
        }
 
        // CREATE A PARTICLE AND ITS VIEW
 
        // create model for particle
        particleModel = new ParticleModel(new Vector2(0, 0),new Vector2(0, 1),1.0f);
 
        // create game object for particle with prefab as image, will be added to Unity Hierarchy:
        GameObject particleGameObject = Instantiate(prefabParticle, particleModel.position, Quaternion.identity);
 
        if (particleGameObject != null) // check if instantiation successful
        {
            // Try to get ParticleView component, if not found, add it
            particleView = particleGameObject.GetComponent<ParticleView>(); // doesn't work if forgot to assign ParticleView to particle prefab
            if (particleView == null) // add particle view to script via code
            {
                particleView = particleGameObject.AddComponent<ParticleView>();
                Debug.LogWarning("ParticleView component was missing on prefab, automatically added for particle");
            }
 
            particleView.Bind(particleModel);
        }
        else
        {
            Debug.LogError("Failed to instantiate prefab for particle! Make sure prefabParticle is assigned in Inspector.");
        }
    }
 
    void Update()
    {
        Step(); // one simulation step
    }
 
    void Step()
    {
        float dt = Time.deltaTime; // ensures that velocity is independent of frame-rate
        particleModel.position += particleModel.velocity * dt; // change position according to velocity
    }
}

using UnityEngine;
 
public class ParticleModel
{
    public Vector2 position;
    public Vector2 velocity;
    public float mass;
 
    public ParticleModel(Vector2 position, Vector2 velocity, float mass)
    {
        this.position = position;
        this.velocity = velocity;
        this.mass = mass;
    }
}

using UnityEngine;
 
public class ParticleView : MonoBehaviour
{
    ParticleModel particleModel;
 
    void Start() {}
 
    public void Bind(ParticleModel p)
    {
        particleModel = p;
        transform.position = particleModel.position;
    }
 
    void Update()
    {
        // position of view = position of model (of ParticleModel)
        if (particleModel != null)
        {
            transform.position = particleModel.position;
        }
    }
}

• Greife auf SpriteRenderer von particleView-Objekt zu und ändere seine Farbe:

  var spriteRenderer = particleView.GetComponent<SpriteRenderer>();
  spriteRenderer.color = Color.blue;

• Tipp 1: Damit man nicht für jedes Frame für jede particleView den GetComponent()-Befehl wiederholt aufrufen muss, lohnt es sich, ein Array particleRenderers zu erstellen, in dem man die spriteRenderer für die entsprechenden Particles speichert. \\ 
  
• Tipp 2: Passe gegebenenfalls den Code so an, dass die Farbzuweisung ... = Color.blue nur dann ausgeführt wird, wenn sich die Farbe des Teilchens auch ändert. Verwende dazu z.B. ein Flag (bool) changeColor.

someGameObject.transform.localScale = Vector3.one * 0.1f;

UnityEngine.Random.InitState(42); // Zufallszahlen mit Seed (immer gleicher 'Zufall')
UnityEngine.Random.Range(0,10);