Tetris

Example
Board
Piece
Data
Ghost
Tetromino
Copy
using UnityEngine;
using UnityEngine.Tilemaps;
using UnityEngine.UI;
using TMPro;
using UnityEngine.Networking;
using System.Collections;

[DefaultExecutionOrder(-1)]
public class Board : MonoBehaviour
{
    // --- Komponenty Planszy i Aktywne Elementy ---
    public Tilemap tilemap { get; private set; }
    public Piece activePiece { get; private set; } // Aktualnie spadająca figura.

    // --- Konfiguracja i Ustawienia ---
    public TetrominoData[] tetrominoes;             // Definicje wszystkich możliwych bloków.
    public Vector2Int boardSize = new Vector2Int(10, 20); // Standardowy rozmiar planszy Tetrisa.
    public Vector3Int spawnPosition = new Vector3Int(-1, 8, 0); // Pozycja, z której spadają nowe figury.

    // --- Punktacja i UI ---
    public int score { get; private set; } = 0;
    public TextMeshProUGUI scoreText;

    public RectInt Bounds
    {
        // [BLOK KOMENTARZY: Właściwość Określająca Granice Planszy]
        // Oblicza granice (min/max X i Y) planszy, co jest kluczowe do sprawdzania,
        // czy figura nie wyszła poza obszar gry.
        get
        {
            Vector2Int position = new Vector2Int(-boardSize.x / 2, -boardSize.y / 2);
            return new RectInt(position, boardSize);
        }
    }

    private void Awake()
    {
        // [BLOK KOMENTARZY: Inicjalizacja]
        // Pobiera komponenty (Tilemap, Piece) i inicjalizuje dane wszystkich Tetromino.
        tilemap = GetComponentInChildren<Tilemap>();
        activePiece = GetComponentInChildren<Piece>();

        for (int i = 0; i < tetrominoes.Length; i++) {
            tetrominoes[i].Initialize();
        }
    }

    private void Start()
    {
        // [BLOK KOMENTARZY: Uruchomienie Gry]
        // Zeruje wynik i rozpoczyna generowanie pierwszej figury.
        UpdateScore(0); 
        SpawnPiece();
    }

    // --- Logika Spawnowania i Zakończenia Gry ---
    public void SpawnPiece()
    {
        // [BLOK KOMENTARZY: Generowanie Nowej Figury]
        // 1. Losuje następny blok (Tetromino) z dostępnych typów.
        int random = Random.Range(0, tetrominoes.Length);
        TetrominoData data = tetrominoes[random];

        // 2. Inicjalizuje aktywną figurę na pozycji startowej.
        activePiece.Initialize(this, spawnPosition, data);

        // 3. Sprawdza, czy figura może w ogóle się pojawić (czy górne pole jest puste).
        if (IsValidPosition(activePiece, spawnPosition)) {
            Set(activePiece); // Jeśli tak, rysuje ją.
        } else {
            GameOver(); // Jeśli nie, koniec gry.
        }
    }

    public void GameOver()
    {
        // [BLOK KOMENTARZY: Koniec Gry]
        // 1. Wysyła wynik gracza na zewnętrzny serwer.
        StartCoroutine(
        SendScore(
            20,      // id
            score    // score
        )
        );
        // 2. Czyści całą planszę (usuwa wszystkie bloki).
        tilemap.ClearAllTiles();
    }

    // --- Rysowanie i Usuwanie Bloków ---
    public void Set(Piece piece)
    {
        // [BLOK KOMENTARZY: Rysowanie Figury na Tilemapie]
        // Rysuje wszystkie 4 komórki aktywnej figury na planszy.
        for (int i = 0; i < piece.cells.Length; i++)
        {
            Vector3Int tilePosition = piece.cells[i] + piece.position;
            tilemap.SetTile(tilePosition, piece.data.tile);
        }
    }

    public void Clear(Piece piece)
    {
        // [BLOK KOMENTARZY: Usuwanie Figury z Tilemapy]
        // Czyści wszystkie 4 komórki aktywnej figury. Zawsze wywoływane przed jej przesunięciem.
        for (int i = 0; i < piece.cells.Length; i++)
        {
            Vector3Int tilePosition = piece.cells[i] + piece.position;
            tilemap.SetTile(tilePosition, null);
        }
    }

    // --- Logika Kolizji ---
    public bool IsValidPosition(Piece piece, Vector3Int position)
    {
        // [BLOK KOMENTARZY: Sprawdzanie Ważności Pozycji]
        RectInt bounds = Bounds;

        // Sprawdza każdą komórkę figury:
        for (int i = 0; i < piece.cells.Length; i++)
        {
            Vector3Int tilePosition = piece.cells[i] + position;

            // 1. Sprawdzenie granic: Czy figura nie wyszła poza krawędź planszy.
            if (!bounds.Contains((Vector2Int)tilePosition)) {
                return false;
            }

            // 2. Sprawdzenie zajętości: Czy w docelowej pozycji nie ma już innego bloku.
            if (tilemap.HasTile(tilePosition)) {
                return false;
            }
        }

        return true;
    }

    // --- Logika Usuwania Linii ---
    public void ClearLines()
    {
        // [BLOK KOMENTARZY: Wykrywanie i Usuwanie Pełnych Linii]
        RectInt bounds = Bounds;
        int row = bounds.yMin;
        int linesCleared = 0;

        // Iteruje od najniższego rzędu do najwyższego.
        while (row < bounds.yMax)
        {
            if (IsLineFull(row))
            {
                // Jeśli linia pełna, usuwa ją i nie przechodzi do następnego rzędu
                // (ponieważ nowa linia spadła w to samo miejsce).
                LineClear(row);
                linesCleared++;
            }
            else
            {
                // Jeśli linia niepełna, przechodzi do następnego rzędu.
                row++;
            }
        }

        // Nalicza punkty za usunięte linie.
        if (linesCleared > 0)
        {
            UpdateScore(linesCleared * 100);
        }
    }

    public bool IsLineFull(int row)
    {
        // [BLOK KOMENTARZY: Sprawdzenie Pełnej Linii]
        // Iteruje przez wszystkie kolumny w danym rzędzie. Jeśli znajdzie choć jedną pustą komórkę,
        // oznacza to, że linia nie jest pełna.
        RectInt bounds = Bounds;
        for (int col = bounds.xMin; col < bounds.xMax; col++)
        {
            Vector3Int position = new Vector3Int(col, row, 0);
            if (!tilemap.HasTile(position)) {
                return false;
            }
        }
        return true;
    }

    public void LineClear(int row)
    {
        // [BLOK KOMENTARZY: Usuwanie Linii i Przesuwanie Bloków]
        RectInt bounds = Bounds;

        // 1. Czyści usuwaną linię.
        for (int col = bounds.xMin; col < bounds.xMax; col++)
        {
            Vector3Int position = new Vector3Int(col, row, 0);
            tilemap.SetTile(position, null);
        }

        // 2. Przesuwa wszystkie bloki znajdujące się powyżej usuniętej linii w dół o jeden rząd.
        while (row < bounds.yMax)
        {
            for (int col = bounds.xMin; col < bounds.xMax; col++)
            {
                // Kopiuje Tile z rzędu wyżej (row + 1).
                Vector3Int position = new Vector3Int(col, row + 1, 0);
                TileBase above = tilemap.GetTile(position);

                // Wkleja Tile do aktualnego rzędu (row).
                position = new Vector3Int(col, row, 0);
                tilemap.SetTile(position, above);
            }
            row++;
        }
    }

    // --- Aktualizacja Wyniku i Komunikacja Sieciowa ---
    public void UpdateScore(int points)
    {
        // [BLOK KOMENTARZY: Aktualizacja Wyniku]
        // Dodaje punkty do wyniku i aktualizuje tekst w UI (formatuje na 4 cyfry).
        score += points;
        if (scoreText != null)
        {
            scoreText.text = score.ToString("D4");
        }
    }

    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
                ? "Wynik przesłany: " + r.downloadHandler.text
                : "BŁĄD WYSYŁANIA WYNIKU: " + r.error);
        }
    }
}