fix the issue where the prefab doesn't change the color of the prefab child sprite, (it should change the color of the redblock which is the child prefab of the teromino block prefab)

```
using UnityEngine;
using TMPro;

// note for self, nekad vairāk nerakstit 400 liniju script, ja tas nav needed.

// !TODO add color changing after each level.

public class TetrisBlock : MonoBehaviour
{
    public static byte LinesCleared;
    public static int height = 21;
    public static int width = 10;
    public static float fallTimeDecrease;
    public static float minFallTime = 0.1f;
    public static float fallTime;
    public static float CurrentFallTime { get; private set; } = 1f;
    public static byte linesPerLevel = 10;
    public static bool gameOver = false;

    private float initialFallTime = 1f;
    private float previousTime;
    private static int level = 0;

    private GameManager gameManager;
    private SpawnTetromino spawnTetromino;
    private static TextMeshProUGUI linesClearedText;
    private static TextMeshProUGUI levelText;
    private AudioSource audioSource;
    public Vector3 rotationPoint;
    
    private static TetrisBlock instance;
    
    private static Color[] levelColors = new Color[]
    {
        Color.cyan,
        Color.yellow,
        Color.magenta,
        Color.red,
        Color.green,
        Color.blue,
        Color.white
    };

    public AudioClip moveSound;

    void Awake()
    {
        gameManager = FindObjectOfType<GameManager>();
        spawnTetromino = FindObjectOfType<SpawnTetromino>();
        linesClearedText = GameObject.Find("Lines_Cleared").GetComponent<TextMeshProUGUI>();
        levelText = GameObject.FindWithTag("Text_Level").GetComponent<TextMeshProUGUI>();
        fallTime = CurrentFallTime;
        
        if (levelText == null)
        {
            Debug.LogError("No level text found");
        }
        
        Debug.Log(SceneController.noFunPressed);

        ResetGame();
        SetupAudioSource();
        CalculateFallDecrement();

        instance = this;
        moveSound = AudioManager.Instance.audioClips[0];
        
    }

    private void Update()
    {
        if (gameManager.StartMenu != null && !gameManager.StartMenu.activeSelf)
        {
            HandleInput();
        }
    }

    void CalculateFallDecrement()
    {
        if (SceneController.noFunPressed)
        {
            fallTimeDecrease = 0.9f;
        } 
        else if (SceneController.sweatPressed)
        {
            fallTimeDecrease = 0.4f;
        }
        else if (SceneController.hardPressed)
        {
            fallTimeDecrease = 0.2f;
        }
        else if (SceneController.SkillIssuePressed)
        {
            fallTimeDecrease = 0.05f;
        }
        else
        {
            fallTimeDecrease = 0.1f;
        }
    }

    private void ResetGame()
    {
        if (SceneController.hasRestartedScene)
        {
            gameManager.StartMenu.SetActive(false);
            CurrentFallTime = initialFallTime;
            level = 0;
            LinesCleared = 0;
            UpdateUi();
            SceneController.hasRestartedScene = false;
            Debug.Log($"The current fall time is: {CurrentFallTime}");
        }
    }

    private void HandleInput()
    {
        if (Input.GetKeyDown(KeyCode.LeftArrow) || Input.GetKeyDown(KeyCode.A))
        {
            MoveHorizontal(-1);
        }
        else if (Input.GetKeyDown(KeyCode.RightArrow) || Input.GetKeyDown(KeyCode.D))
        {
            MoveHorizontal(1);
        }
        else if (Input.GetKeyDown(KeyCode.X))
        {
            Rotate();
        }
        if (Time.time - previousTime > (Input.GetKey(KeyCode.DownArrow) || Input.GetKey(KeyCode.S) ? fallTime / 10 : fallTime))
        {
            MoveDown();
        }
    }

    private void MoveHorizontal(int direction)
    {
        AudioManager.Instance.PlayMoveSound();
        transform.position += new Vector3(direction, 0, 0);
        if (!ClearLine.ValidMove(transform))
            transform.position -= new Vector3(direction, 0, 0);
    }

    private void Rotate()
    {
        AudioManager.Instance.PlayRotateSound();
        transform.RotateAround(transform.TransformPoint(rotationPoint), Vector3.forward, 90);
        if (!ClearLine.ValidMove(transform))
            transform.RotateAround(transform.TransformPoint(rotationPoint), Vector3.forward, -90);
    }

    private void MoveDown()
    {
        transform.position += Vector3.down;
        if (!ClearLine.ValidMove(transform))
        {
            transform.position -= Vector3.down;
            ClearLine.AddToGrid(transform);
            ClearLine.CheckForLines();
            this.enabled = false;

            if (!ClearLine.isLineClearAnimationInProgress && !gameOver)
            {
                spawnTetromino.NewTetromino();
            }
        }
        previousTime = Time.time;
    }

    public static void UpdateUi()
    {
        if (linesClearedText != null)
        {
            linesClearedText.text = "Lines Cleared: " + LinesCleared.ToString();
        }
        if (levelText != null)
        {
            levelText.text = "Level: " + level.ToString();
        }
        else
        {
            Debug.LogError("Level TextMeshProUGUI component not found!");
        }
    }

    

    public static void LevelUp()
    {
        AudioManager.Instance.LevelUpSound();
        int newLevel = LinesCleared / linesPerLevel;
        
        if (newLevel > level)
        {
            int levelDifference = newLevel - level;
            for (int i = 0; i < levelDifference; i++)
            {
                CurrentFallTime = Mathf.Max(CurrentFallTime - fallTimeDecrease, minFallTime);
            }
            
            UpdateBlockColor(newLevel);
            UpdateUi();
            level = newLevel;
            
            if (newLevel == 157)
            {
                GameManager.Instance.WaitWhat();
            }
        }
        Debug.Log(CurrentFallTime);
        Debug.Log(level);
    }

    public static void ResetStaticVariables()
    {
        ClearLine.ResetGrid();
        LinesCleared = 0;
        gameOver = false;
    }

    private void SetupAudioSource()
    {
        if (audioSource == null)
        {
            audioSource = gameObject.AddComponent<AudioSource>();
        }

        audioSource.clip = moveSound;
        audioSource.playOnAwake = false;
    }
    
    private static void UpdateBlockColor(int newLevel)
    {
        float hueShift = (newLevel * 0.1f) % 1f;
        
        SpawnTetromino spawnTetromino = FindObjectOfType<SpawnTetromino>();

        if (spawnTetromino == null)
        {
            Debug.LogError("SpawnTetromino instance not found!");
            return;
        }

        foreach (GameObject tetrominoPrefab in spawnTetromino.Tetrominoes)
        {
            UpdateTetrominoColor(tetrominoPrefab, hueShift);
        }
        
        if (spawnTetromino.GetNextTetromino() != null)
        {
            UpdateTetrominoColor(spawnTetromino.GetNextTetromino().gameObject, hueShift);
        }
        
        foreach (Transform block in FindObjectsOfType<Transform>())
        {
            if (block.CompareTag("Block"))
            {
                UpdateSpriteColor(block, hueShift);
            }
        }
    }

    public static void UpdateTetrominoColor(GameObject tetromino, float hueShift)
    {
        SpriteRenderer[] childSprites = tetromino.GetComponentsInChildren<SpriteRenderer>();
        foreach (SpriteRenderer spriteRenderer in childSprites)
        {
            UpdateSpriteColor(spriteRenderer.transform, hueShift);
        }
    }

    private static void UpdateSpriteColor(Transform block, float hueShift)
    {
        SpriteRenderer spriteRenderer = block.GetComponent<SpriteRenderer>();
        if (spriteRenderer != null)
        {
            Color.RGBToHSV(spriteRenderer.color, out float h, out float s, out float v);
            h = (h + hueShift) % 1f;
            spriteRenderer.color = Color.HSVToRGB(h, s, v);
        }
    }

}

```
```
using UnityEngine;
using Random = UnityEngine.Random;
public class SpawnTetromino : MonoBehaviour
{
    public static SpawnTetromino Instance { get; private set; }

    public GameObject[] Tetrominoes;
    public Transform previewTransform;
    private GameObject previewPiece;
    private int currentIndex;
    private int nextIndex;
    public GameObject GameOverScreen;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void Start()
    {
        currentIndex = Random.Range(0, Tetrominoes.Length);
        nextIndex = Random.Range(0, Tetrominoes.Length);

        CreatePreview();
        SpawnCurrentPiece();

        GameOverScreen.SetActive(false);
    }

    private void SpawnCurrentPiece()
    {
        if (!TetrisBlock.gameOver)
        {
            GameObject spawnedTetromino = Instantiate(Tetrominoes[currentIndex], transform.position, Quaternion.identity);
            spawnedTetromino.AddComponent<ClearLine>();
            
            float hueShift = (TetrisBlock.LinesCleared / TetrisBlock.linesPerLevel * 0.1f) % 1f;
            TetrisBlock.UpdateTetrominoColor(spawnedTetromino, hueShift);
        }
    }

    public void NewTetromino()
    {
        if (!TetrisBlock.gameOver && !ClearLine.isLineClearAnimationInProgress)
        {
            currentIndex = nextIndex;
            nextIndex = Random.Range(0, Tetrominoes.Length);

            SpawnCurrentPiece();

            if (previewPiece != null)
            {
                Destroy(previewPiece);
            }
            CreatePreview();
        }
    }

    private void CreatePreview()
    {
        switch (nextIndex)
        {
            case 0:
                previewPiece = Instantiate(Tetrominoes[nextIndex], new Vector3(12.5f, 16.73f, 1), Quaternion.identity);
                break;
            case 3:
                previewPiece = Instantiate(Tetrominoes[nextIndex], new Vector3(12.5f, 15.73f, 1), Quaternion.identity);
                break;
            case 2:
            case 6:
                previewPiece = Instantiate(Tetrominoes[nextIndex], new Vector3(12, 16.73f, 1), Quaternion.identity);
                break;
            case 5:
                previewPiece = Instantiate(Tetrominoes[nextIndex], new Vector3(13, 15.73f, 1), Quaternion.identity);
                break;
            default:
                previewPiece = Instantiate(Tetrominoes[nextIndex], previewTransform.position, Quaternion.identity);
                break;
        }

        TetrisBlock previewBlock = previewPiece.GetComponent<TetrisBlock>();
        if (previewBlock != null)
        {
            previewBlock.enabled = false;
        }
        
        float hueShift = (TetrisBlock.LinesCleared / TetrisBlock.linesPerLevel * 0.1f) % 1f;
        TetrisBlock.UpdateTetrominoColor(previewPiece, hueShift);
    }
    
    public Transform GetNextTetromino()
    {
        return previewPiece != null ? previewPiece.transform : null;
    }

    public void GameOver()
    {
        TetrisBlock.gameOver = true;
        GameOverScreen.SetActive(true);
        AudioManager.Instance.backGroundAudioSource.Stop();
        Debug.Log("Game Over");
    }
}

```