A!leys Galerie

using System.Collections.Generic;
using UnityEngine;

/// <summary>
/// Ein robustes Object-Pooling-System für Unity.
/// Verwaltet eine Sammlung von wiederverwendbaren Objekten, um Speicherallokationen zu minimieren.
/// </summary>
public class SmartPool : MonoBehaviour
{
    [Header("Pool Settings")]
    [SerializeField] private GameObject prefab;
    [SerializeField] private int initialPoolSize = 10;
    [SerializeField] private int maxPoolSize = 50;
    [SerializeField] private float respawnDelay = 2.0f;

    [Header("Pool Stats")]
    [SerializeField] private TextMeshProUGUI statsText;

    private Queue<GameObject> pool = new Queue<GameObject>();
    private List<GameObject> activeObjects = new List<GameObject>();

    private void Awake()
    {
        InitializePool();
    }

    private void InitializePool()
    {
        for (int i = 0; i < initialPoolSize; i++)
        {
            CreateNewObject();
        }
        UpdateStats();
    }

    private GameObject CreateNewObject()
    {
        if (pool.Count == 0)
        {
            GameObject obj = Instantiate(prefab, transform.position, transform.rotation);
            obj.name = $"Pooled_{obj.name}_{pool.Count}";
            pool.Enqueue(obj);
        }
        return pool.Dequeue();
    }

    public GameObject GetObject()
    {
        if (pool.Count == 0)
        {
            if (activeObjects.Count < maxPoolSize)
            {
                GameObject obj = Instantiate(prefab, transform.position, transform.rotation);
                obj.name = $"Pooled_{obj.name}_{activeObjects.Count}";
                activeObjects.Add(obj);
                return obj;
            }
            else
            {
                Debug.LogWarning("Max pool size reached!");
                return null;
            }
        }

        GameObject obj = pool.Dequeue();
        activeObjects.Add(obj);
        return obj;
    }

    public void ReturnObject(GameObject obj)
    {
        if (activeObjects.Contains(obj))
        {
            activeObjects.Remove(obj);
            ResetObject(obj);
            pool.Enqueue(obj);
            UpdateStats();
        }
    }

    private void ResetObject(GameObject obj)
    {
        // Hier kannst du spezifische Reset-Logik hinzufügen, z.B. Geschwindigkeit, Farbe, etc.
        obj.SetActive(false);
    }

    private void UpdateStats()
    {
        if (statsText != null)
        {
            statsText.text = $"Pool: {pool.Count} | Active: {activeObjects.Count}";
        }
    }

    private void OnDestroy()
    {
        foreach (var obj in pool)
        {
            Destroy(obj);
        }
        foreach (var obj in activeObjects)
        {
            Destroy(obj);
        }
    }
}

extends CharacterBody2D
class_name NeonRunner

# --- KONFIGURATION ---
@export_group("Movement")
@export var speed: float = 300.0
@export var jump_force: float = -500.0
@export var gravity: float = 1200.0
@export var acceleration: float = 1500.0
@export var friction: float = 1200.0

@export_group("Feel")
@export var coyote_time: float = 0.15
@export var jump_buffer_time: float = 0.15

# --- INTERNE VARIABLEN ---
var coyote_timer: float = 0.0
var jump_buffer_timer: float = 0.0
var is_grounded: bool = false

# --- ANIMATION ---
@onready var sprite: Sprite2D = $Sprite2D
@onready var animation_player: AnimationPlayer = $AnimationPlayer

func _ready():
	# Initialisiere die Ladeanimation
	if animation_player:
		animation_player.play("load_complete")
		# Warte kurz, um den Effekt zu zeigen
		await get_tree().create_timer(1.0).timeout
		animation_player.stop()
		print("Neon Runner bereit!")

func _physics_process(delta: float):
	# Schwerkraft anwenden
	if not is_grounded:
		velocity.y += gravity * delta
	else:
		coyote_timer += delta
		if coyote_timer > coyote_time:
			coyote_timer = coyote_time

	# Input verarbeiten
	var input_dir = Input.get_axis("ui_left", "ui_right")
	
	# Bewegung berechnen
	if input_dir != 0:
		velocity.x = move_toward(velocity.x, input_dir * speed, acceleration * delta)
	else:
		velocity.x = move_toward(velocity.x, 0, friction * delta)

	# Springen mit Buffer und Coyote-Time
	if Input.is_action_just_pressed("ui_accept"):
		jump_buffer_timer += delta
		if jump_buffer_timer > jump_buffer_time:
			jump_buffer_timer = jump_buffer_time

	if jump_buffer_timer > 0 and coyote_timer > 0:
		velocity.y = jump_force
		jump_buffer_timer = 0
		coyote_timer = 0
		# Spring-Animation triggern
		if animation_player:
			animation_player.play("jump")

	# Boden-Check
	if is_on_floor():
		is_grounded = true
		coyote_timer = 0
	else:
		is_grounded = false

	move_and_slide()

# --- ANIMATIONS-LOGIK ---
func _process(_delta: float):
	if animation_player:
		match velocity.x:
			var v = velocity.x
			if v > 10:
				animation_player.play("run")
			elif v < -10:
				animation_player.play("run_reverse")
			else:
				animation_player.play("idle")