Реализация функций таймера и отмены хода для игры "Три в ряд или Match3"

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
 
public class Tile : MonoBehaviour {
    private static Color selectedColor = new Color(.5f, .5f, .5f, 1.0f);
    private static Tile previousSelected = null;
 
    private SpriteRenderer render;
    private bool isSelected = false;
 
    private Vector2[] adjacentDirections = new Vector2[] { Vector2.up, Vector2.down, Vector2.left, Vector2.right };
 
    void Awake() {
        render = GetComponent<SpriteRenderer>();
    }
 
    private void Select() {
        isSelected = true;
        render.color = selectedColor;
        previousSelected = gameObject.GetComponent<Tile>();
        SFXManager.instance.PlaySFX(Clip.Select);
    }
 
    private void Deselect() {
        isSelected = false;
        render.color = Color.white;
        previousSelected = null;
    }
 
    void OnMouseDown() {
        // Not Selectable conditions
        if (render.sprite == null || BoardManager.instance.IsShifting) {
            return;
        }
 
        if (isSelected) { // Is it already selected?
            Deselect();
        } else {
            if (previousSelected == null) { // Is it the first tile selected?
                Select();
            } else {
                if (GetAllAdjacentTiles().Contains(previousSelected.gameObject)) { // Is it an adjacent tile?
                    SwapSprite(previousSelected.render);
                    previousSelected.ClearAllMatches();
                    previousSelected.Deselect();
                    ClearAllMatches();
                } else {
                    previousSelected.GetComponent<Tile>().Deselect();
                    Select();
                }
            }
        }
    }
 
    public void SwapSprite(SpriteRenderer render2) {
        if (render.sprite == render2.sprite) {
            return;
        }
 
        Sprite tempSprite = render2.sprite;
        render2.sprite = render.sprite;
        render.sprite = tempSprite;
        SFXManager.instance.PlaySFX(Clip.Swap);
        GUIManager.instance.MoveCounter--; // Add this line here
    }
 
    private GameObject GetAdjacent(Vector2 castDir) {
        RaycastHit2D hit = Physics2D.Raycast(transform.position, castDir);
        if (hit.collider != null) {
            return hit.collider.gameObject;
        }
        return null;
    }
 
    private List<GameObject> GetAllAdjacentTiles() {
        List<GameObject> adjacentTiles = new List<GameObject>();
        for (int i = 0; i < adjacentDirections.Length; i++) {
            adjacentTiles.Add(GetAdjacent(adjacentDirections[i]));
        }
        return adjacentTiles;
    }
 
    private List<GameObject> FindMatch(Vector2 castDir) {
        List<GameObject> matchingTiles = new List<GameObject>();
        RaycastHit2D hit = Physics2D.Raycast(transform.position, castDir);
        while (hit.collider != null && hit.collider.GetComponent<SpriteRenderer>().sprite == render.sprite) {
            matchingTiles.Add(hit.collider.gameObject);
            hit = Physics2D.Raycast(hit.collider.transform.position, castDir);
        }
        return matchingTiles;
    }
 
    private void ClearMatch(Vector2[] paths) {
        List<GameObject> matchingTiles = new List<GameObject>();
        for (int i = 0; i < paths.Length; i++) { matchingTiles.AddRange(FindMatch(paths[i])); }
        if (matchingTiles.Count >= 2) {
            for (int i = 0; i < matchingTiles.Count; i++) {
                matchingTiles[i].GetComponent<SpriteRenderer>().sprite = null;
            }
            matchFound = true;
        }
    }
 
    private bool matchFound = false;
    public void ClearAllMatches() {
        if (render.sprite == null)
            return;
 
        ClearMatch(new Vector2[2] { Vector2.left, Vector2.right });
        ClearMatch(new Vector2[2] { Vector2.up, Vector2.down });
        if (matchFound) {
            render.sprite = null;
            matchFound = false;
            StopCoroutine(BoardManager.instance.FindNullTiles()); //Add this line
            StartCoroutine(BoardManager.instance.FindNullTiles()); //Add this line
            SFXManager.instance.PlaySFX(Clip.Clear);
        }
    }
 
}

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
 
public class BoardManager : MonoBehaviour {
    public static BoardManager instance;
    public List<Sprite> characters = new List<Sprite>();
    public GameObject tile;
    public int xSize, ySize;
 
    private GameObject[,] tiles;
 
    public bool IsShifting { get; set; }
 
    void Start () {
        instance = GetComponent<BoardManager>();
 
        Vector2 offset = tile.GetComponent<SpriteRenderer>().bounds.size;
        CreateBoard(offset.x, offset.y);
    }
 
    private void CreateBoard (float xOffset, float yOffset) {
        tiles = new GameObject[xSize, ySize];
 
        float startX = transform.position.x;
        float startY = transform.position.y;
 
        Sprite[] previousLeft = new Sprite[ySize]; // Add this line
        Sprite previousBelow = null; // Add this line
 
        for (int x = 0; x < xSize; x++) {
            for (int y = 0; y < ySize; y++) {
                GameObject newTile = Instantiate(tile, new Vector3(startX + (xOffset * x), startY + (yOffset * y), 0), tile.transform.rotation);
                tiles[x, y] = newTile;
                newTile.transform.parent = transform; // Add this line
 
                List<Sprite> possibleCharacters = new List<Sprite>();
                possibleCharacters.AddRange(characters);
 
                possibleCharacters.Remove(previousLeft[y]);
                possibleCharacters.Remove(previousBelow);
 
                Sprite newSprite = possibleCharacters[Random.Range(0, possibleCharacters.Count)];
                newTile.GetComponent<SpriteRenderer>().sprite = newSprite;
                previousLeft[y] = newSprite;
                previousBelow = newSprite;
            }
        }
    }
 
    public IEnumerator FindNullTiles() {
        for (int x = 0; x < xSize; x++) {
            for (int y = 0; y < ySize; y++) {
                if (tiles[x, y].GetComponent<SpriteRenderer>().sprite == null) {
                    yield return StartCoroutine(ShiftTilesDown(x, y));
                    break;
                }
            }
        }
 
        for (int x = 0; x < xSize; x++) {
            for (int y = 0; y < ySize; y++) {
                tiles[x, y].GetComponent<Tile>().ClearAllMatches();
            }
        }
    }
 
    private IEnumerator ShiftTilesDown(int x, int yStart, float shiftDelay = .03f) {
        IsShifting = true;
        List<SpriteRenderer> renders = new List<SpriteRenderer>();
        int nullCount = 0;
 
        for (int y = yStart; y < ySize; y++) {
            SpriteRenderer render = tiles[x, y].GetComponent<SpriteRenderer>();
            if (render.sprite == null) {
                nullCount++;
            }
            renders.Add(render);
        }
 
        for (int i = 0; i < nullCount; i++) {
            GUIManager.instance.Score += 50; // Add this line here
            yield return new WaitForSeconds(shiftDelay);
            for (int k = 0; k < renders.Count - 1; k++) {
                renders[k].sprite = renders[k + 1].sprite;
                renders[k + 1].sprite = GetNewSprite(x, ySize - 1);
            }
        }
        IsShifting = false;
    }
 
    private Sprite GetNewSprite(int x, int y) {
        List<Sprite> possibleCharacters = new List<Sprite>();
        possibleCharacters.AddRange(characters);
 
        if (x > 0) {
            possibleCharacters.Remove(tiles[x - 1, y].GetComponent<SpriteRenderer>().sprite);
        }
        if (x < xSize - 1) {
            possibleCharacters.Remove(tiles[x + 1, y].GetComponent<SpriteRenderer>().sprite);
        }
        if (y > 0) {
            possibleCharacters.Remove(tiles[x, y - 1].GetComponent<SpriteRenderer>().sprite);
        }
 
        return possibleCharacters[Random.Range(0, possibleCharacters.Count)];
    }
 
 
}

public bool CombinationExists()
{
    var horizontal = new[] { Vector2.left, Vector2.right };
    var vertical = new[] { Vector2.up, Vector2.down };
 
    List<GameObject> matchingTiles = new List<GameObject>();
 
    for (int i = 0; i < horizontal.Length; i++)
        matchingTiles.AddRange(FindMatch(horizontal[i]));
 
    if (matchingTiles.Count >= 2)
        return true;
 
    matchingTiles.Clear();
    for (int i = 0; i < vertical.Length; i++)
        matchingTiles.AddRange(FindMatch(vertical[i]));
 
    if (matchingTiles.Count >= 2)
        return true;
 
    return false;
 
}

void OnMouseDown()
{
    // Not Selectable conditions
    if (render.sprite == null || BoardManager.instance.IsShifting)
    {
        return;
    }
 
    // Is it already selected?
    if (isSelected)
    {
        Deselect();
        return;
    }
 
 
    // Is it the first tile selected?
    if (previousSelected == null)
    {
        Select();
        return;
    }
 
 
    // Is it an adjacent tile?
    if (GetAllAdjacentTiles().Contains(previousSelected.gameObject))
    {
        Sprite prev = previousSelected.render.sprite;
        Sprite current = render.sprite;
 
        previousSelected.render.sprite = current;
        render.sprite = prev;
 
        if (CombinationExists() || previousSelected.CombinationExists())
        {
            //print("exist");
            previousSelected.render.sprite = prev;
            render.sprite = current;
 
            SwapSprite(previousSelected.render);
            previousSelected.ClearAllMatches();
            previousSelected.Deselect();
            ClearAllMatches();
        }
        else
        {
            //print("not exist");
            previousSelected.render.sprite = prev;
            render.sprite = current;
 
            previousSelected.GetComponent<Tile>().Deselect();
            Select();
        }
    }
    else
    {
        previousSelected.GetComponent<Tile>().Deselect();
        Select();
    }
 
}