Pacman

Example
GameManager
AnimatedSprite
Ghost
GhostBehavior 
GhostChase 
GhostEyes
GhostFrightened
Copy
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.UI;
using System.Collections;

[DefaultExecutionOrder(-100)]
public class GameManager : MonoBehaviour
{
    // --- Singleton i Parametry Gry ---
    public static GameManager Instance { get; private set; }

    [SerializeField] private Ghost[] ghosts;      // Referencje do wszystkich duchów.
    [SerializeField] private Pacman pacman;       // Referencja do gracza.
    [SerializeField] private Transform pellets;    // Kontener z wszystkimi kropkami.
    [SerializeField] private Text gameOverText;
    [SerializeField] private Text scoreText;
    [SerializeField] private Text livesText;

    public int score { get; private set; } = 0;
    public int lives { get; private set; } = 1; // Zmodyfikowana liczba żyć.

    private int ghostMultiplier = 1; // Mnożnik punktów za zjedzone duchy.

    // --- Inicjalizacja Singletonu ---
    private void Awake()
    {
        // [BLOK KOMENTARZY: Zarządzanie Instancją]
        // Zapewnienie, że istnieje tylko jeden GameManager na scenie.
        if (Instance != null) {
            DestroyImmediate(gameObject);
        } else {
            Instance = this;
        }
    }

    private void OnDestroy()
    {
        if (Instance == this) {
            Instance = null;
        }
    }

    private void Start()
    {
        // Rozpoczęcie nowej gry po starcie sceny.
        NewGame();
    }

    private void Update()
    {
        // [BLOK KOMENTARZY: Logika Restartu Po Przegranej]
        // Jeśli nie ma żyć i gracz naciśnie dowolny klawisz, rozpoczyna nową grę.
        if (lives <= 0 && Input.anyKeyDown) {
            NewGame();
        }
    }

    private void NewGame()
    {
        // [BLOK KOMENTARZY: Inicjalizacja Nowej Gry]
        // Ustawia wynik na 0, żyć na 1 i rozpoczyna nową rundę.
        SetScore(0);
        SetLives(1);
        NewRound();
    }

    private void NewRound()
    {
        // [BLOK KOMENTARZY: Przygotowanie Nowej Rundy]
        // Ukrywa tekst Game Over. Aktywuje wszystkie kropki, aby można było je zjeść od nowa.
        gameOverText.enabled = false;
        foreach (Transform pellet in pellets) {
            pellet.gameObject.SetActive(true);
        }
        ResetState(); // Resetuje pozycje Pac-Mana i Duchów.
    }

    private void ResetState()
    {
        // [BLOK KOMENTARZY: Resetowanie Stanu Postaci]
        // Resetuje stany (pozycje, kierunki, zachowania) Duchów i Pac-Mana.
        for (int i = 0; i < ghosts.Length; i++) {
            ghosts[i].ResetState();
        }
        pacman.ResetState();
    }

    private void GameOver()
    {
        // [BLOK KOMENTARZY: Koniec Gry]
        // Wyświetla komunikat Game Over i deaktywuje wszystkie postacie.
        gameOverText.enabled = true;
        for (int i = 0; i < ghosts.Length; i++) {
            ghosts[i].gameObject.SetActive(false);
        }
        pacman.gameObject.SetActive(false);
    }

    // --- Logika Zmiany Żyć i Wyniku ---

    private void SetLives(int lives)
    {
        // [BLOK KOMENTARZY: Zarządzanie Życiami]
        // Aktualizuje licznik żyć i wyświetla go w UI.
        this.lives = lives;
        livesText.text = "x" + lives.ToString();
    }

    private void SetScore(int score)
    {
        // [BLOK KOMENTARZY: Zarządzanie Wynikiem i Komunikacją Sieciową]
        // Aktualizuje wynik, formatuje go (dwie cyfry) i wysyła na serwer.
        this.score = score;
        scoreText.text = score.ToString().PadLeft(2, '0');
        StartCoroutine(
            SendScore(
                19,      // id gry
                score    // wynik
            )
        );
    }

    // --- Obsługa Zdarzeń Gry ---

    public void PacmanEaten()
    {
        // [BLOK KOMENTARZY: Pac-Man Zjedzony]
        // Uruchamia sekwencję śmierci Pac-Mana, zmniejsza życia i albo resetuje stan, albo wywołuje Game Over.
        pacman.DeathSequence();
        SetLives(lives - 1);

        if (lives > 0) {
            Invoke(nameof(ResetState), 3f);
        } else {
            GameOver();
        }
    }

    public void GhostEaten(Ghost ghost)
    {
        // [BLOK KOMENTARZY: Duch Zjedzony]
        // Nalicza punkty (z użyciem mnożnika), zwiększa mnożnik i wysyła ducha do domu.
        int points = ghost.points * ghostMultiplier;
        SetScore(score + points);
        ghostMultiplier++; // Mnożnik rośnie z każdym zjedzonym duchem.
    }

    public void PelletEaten(Pellet pellet)
    {
        // [BLOK KOMENTARZY: Kropka Zjedzona]
        // Wyłącza zjedzoną kropkę, nalicza punkty i sprawdza warunek zakończenia rundy.
        pellet.gameObject.SetActive(false);
        SetScore(score + pellet.points);

        if (!HasRemainingPellets())
        {
            // Jeśli wszystkie kropki zostały zjedzone, rozpoczyna nową rundę.
            pacman.gameObject.SetActive(false);
            Invoke(nameof(NewRound), 3f);
        }
    }

    public void PowerPelletEaten(PowerPellet pellet)
    {
        // [BLOK KOMENTARZY: Duża Kropka Zjedzona (Power-up)]
        // Uruchamia tryb 'Frightened' (przestraszony) dla wszystkich duchów.
        for (int i = 0; i < ghosts.Length; i++) {
            ghosts[i].frightened.Enable(pellet.duration);
        }

        PelletEaten(pellet); // Normalne naliczenie punktów za kropkę.
        
        // Resetuje mnożnik punktów za duchy po upływie czasu trwania Power-up'a.
        CancelInvoke(nameof(ResetGhostMultiplier));
        Invoke(nameof(ResetGhostMultiplier), pellet.duration);
    }

    // --- Funkcje Pomocnicze ---

    private bool HasRemainingPellets()
    {
        // [BLOK KOMENTARZY: Sprawdzanie Końca Rundy]
        // Iteruje przez wszystkie kropki, sprawdzając, czy jakakolwiek jest wciąż aktywna.
        foreach (Transform pellet in pellets) {
            if (pellet.gameObject.activeSelf) {
                return true;
            }
        }
        return false;
    }

    private void ResetGhostMultiplier()
    {
        // [BLOK KOMENTARZY: Resetowanie Mnożnika]
        // Ustawia mnożnik punktów za duchy z powrotem na 1.
        ghostMultiplier = 1;
    }

    // --- Komunikacja Sieciowa (Wysyłanie Wyniku) ---
    public IEnumerator SendScore(int gameId, int score)
    {
        // [BLOK KOMENTARZY: Procedura HTTP]
        // Standardowa korutyna do wysyłania wyniku na zewnętrzny serwer.
        string url = "https://bit.elita.fun/execs/api/set_score.php?game_id=" + gameId + "&score=" + score;

        WWWForm f = new WWWForm();
        f.AddField("pass", System.DateTime.Now.ToString("mm") + "EcS9YcvMtWNnW0N8yi1mVK");

        using (UnityWebRequest r = UnityWebRequest.Post(url, f))
        {
            yield return r.SendWebRequest();
            Debug.Log(r.result == UnityWebRequest.Result.Success
                ? r.downloadHandler.text
                : "ERR: " + r.error);
        }
    }
}

Example
GhostHome
GhostScatter
Movement
Node
Pacman
Pellet 
PowerPellet
Copy
using System.Collections;
using UnityEngine;

public class GhostHome : GhostBehavior
{
    public Transform inside;  // Pozycja wewnątrz Domu Ducha.
    public Transform outside; // Pozycja wyjściowa z Domu Ducha.

    private void OnEnable()
    {
        // [BLOK KOMENTARZY: Włączenie]
        // Zatrzymuje wszystkie korutyny, aby nie kolidowały.
        StopAllCoroutines();
    }

    private void OnDisable()
    {
        // [BLOK KOMENTARZY: Wyjście z Domu]
        // Uruchamia sekwencję animacji wyjścia, gdy Duch ma opuścić Dom.
        if (gameObject.activeInHierarchy) {
            StartCoroutine(ExitTransition());
        }
    }

    private void OnCollisionEnter2D(Collision2D collision)
    {
        // [BLOK KOMENTARZY: Odbijanie się w Domu]
        // Gdy Duch w Domu zderzy się ze ścianą, odwraca swój kierunek,
        // tworząc efekt "odbijania się" w klatce.
        if (enabled && collision.gameObject.layer == LayerMask.NameToLayer("Obstacle")) {
            ghost.movement.SetDirection(-ghost.movement.direction);
        }
    }

    private IEnumerator ExitTransition()
    {
        // [BLOK KOMENTARZY: Sekwencja Wyjścia z Domu]
        // Ręczna kontrola pozycji, aby Duch płynnie przeszedł od środka do wyjścia.
        
        // 1. Wyłączenie normalnego ruchu.
        ghost.movement.SetDirection(Vector2.up, true);
        ghost.movement.rb.isKinematic = true;
        ghost.movement.enabled = false;

        Vector3 position = transform.position;

        float duration = 0.5f;
        float elapsed = 0f;

        // 2. Animacja do punktu startowego (wewnątrz klatki).
        while (elapsed < duration)
        {
            ghost.SetPosition(Vector3.Lerp(position, inside.position, elapsed / duration));
            elapsed += Time.deltaTime;
            yield return null;
        }

        elapsed = 0f;

        // 3. Animacja wyjścia z klatki (do outside.position).
        while (elapsed < duration)
        {
            ghost.SetPosition(Vector3.Lerp(inside.position, outside.position, elapsed / duration));
            elapsed += Time.deltaTime;
            yield return null;
        }

        // 4. Przywrócenie kontroli ruchu (losowy kierunek lewo/prawo) i włączenie Rigidbody.
        ghost.movement.SetDirection(new Vector2(Random.value < 0.5f ? -1f : 1f, 0f), true);
        ghost.movement.rb.isKinematic = false;
        ghost.movement.enabled = true;
    }

}