krippenspiele/Assets/AblaufKleinerStern1.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering.Universal;
using UnityEngine.SceneManagement;

public class AblaufKleinerStern1 : MonoBehaviour
{
    public GameObject kleinerStern;

    public GameObject grosserStern;

    public GameObject globalLight;

    public GameObject sternenhimmel;

    public GameObject hintergrund;

    private enum Step {GROSSE_AUFREGUNG, AUFTRITT_KLEINER_STERN, AUFTRITT_GROSSER_STERN, ABGANG_GROSSER_STERN, KLEINER_STERN_FAELLT}

    private Step nextStep;

    private class Task {
        public readonly float time;
        public readonly Action action;

        public Task(float time, Action action) {
            this.time = time;
            this.action = action;
        }
    }

    private List<Task> taskList;

    private Camera cameraComponent;

    private SternBewegung kleinerSternBewegung;

    private SternBewegung grosserSternBewegung;

    // Start is called once before the first execution of Update after the MonoBehaviour is created
    void Start()
    {
        nextStep = Step.GROSSE_AUFREGUNG;
        taskList = new List<Task>();
        globalLight.GetComponent<Light2D>().intensity = 0;
        cameraComponent = GetComponent<Camera>();
        kleinerSternBewegung = kleinerStern.GetComponent<SternBewegung>();
        grosserSternBewegung = grosserStern.GetComponent<SternBewegung>();
    }

    // Update is called once per frame
    void Update()
    {
        List<Task> doneList = new List<Task>();
        foreach (Task t in taskList) {
            if (Time.time >= t.time) {
                doneList.Add(t);
                t.action();
            }
        }
        foreach (Task t in doneList) {
            taskList.Remove(t);
        }
        if (Input.GetKeyDown(KeyCode.Space)){
            switch (nextStep) {
                case Step.GROSSE_AUFREGUNG:
                GrosseAufregung();
                nextStep = Step.AUFTRITT_KLEINER_STERN;
                break;
                case Step.AUFTRITT_KLEINER_STERN:
                AuftrittKleinerStern();
                nextStep = Step.AUFTRITT_GROSSER_STERN;
                break;
                case Step.AUFTRITT_GROSSER_STERN:
                AuftrittGrosserStern();
                nextStep = Step.ABGANG_GROSSER_STERN;
                break;
                case Step.ABGANG_GROSSER_STERN:
                AbgangGrosserStern();
                nextStep = Step.KLEINER_STERN_FAELLT;
                break;
                case Step.KLEINER_STERN_FAELLT:
                KleinerSternFaellt();
                break;
            }
        }
        
    }

    private void GrosseAufregung(){
        globalLight.GetComponent<Lichtsteuerung>().FadeToIntensity(1, 2);
        kleinerSternBewegung.GoToPosition(new Vector2(-12, -3.5f), 0f);
        grosserSternBewegung.GoToPosition(new Vector2(12, -3.5f), 0f);
    }

    private void AuftrittKleinerStern(){
        kleinerSternBewegung.GoToPosition(new Vector2(-3, -2f), 2f);
    }

    private void AuftrittGrosserStern(){
        kleinerSternBewegung.randomnessIntensity = .01f;
        kleinerSternBewegung.wobblingAngle = 2f;
        kleinerSternBewegung.wobblingDuration = 1.5f;
        grosserSternBewegung.GoToPosition(new Vector2(3, -2f), 2.4f);
    }

    private void AbgangGrosserStern(){
        grosserStern.GetComponent<SpriteRenderer>().flipX = true;
        grosserSternBewegung.GoToPosition(new Vector2(12, 0), 2);
        kleinerSternBewegung.randomnessIntensity = 1;
        kleinerSternBewegung.wobblingAngle = 10;
        kleinerSternBewegung.wobblingDuration = .6f;
    }

    private void KleinerSternFaellt(){
        kleinerSternBewegung.angularVelocity = 300;
        kleinerSternBewegung.GoToPosition(new Vector2(-4, -6), 1);
        kleinerSternBewegung.randomnessIntensity = 0.01f;
        doDelayed(1.0f, delegate(){
            globalLight.GetComponent<Lichtsteuerung>().FadeToIntensity(0, .5f);
            kleinerSternBewegung.GoToPosition(new Vector2(1, 6.5f), 0);
        });
        doDelayed(1.5f, delegate(){
            hintergrund.GetComponent<SpriteRenderer>().color = Color.black;
            sternenhimmel.SetActive(false);
            globalLight.GetComponent<Lichtsteuerung>().FadeToIntensity(1, 0);
            kleinerSternBewegung.GoToPosition(new Vector2(-1, -6.5f), 3);
        });
        doDelayed(4.6f, delegate(){
            SceneManager.LoadScene("kleiner_Stern_2");
        });
    }

    private void doDelayed(float delay, Action task) {
        taskList.Add(new Task(Time.time + delay, task));
    }
}