GameManager.cs

using System.Collections;
using UnityEngine;

public class GameManager : MonoBehaviour
{
    private int turnDuration;
    [SerializeField] private GameObject ballPrefab;
    [SerializeField] private GameObject playerPrefab;
    [SerializeField] private GameObject opponentPrefab;
    [SerializeField] private Transform[] targets;
    [SerializeField] private Transform[] spawPoints;
    [SerializeField] private UnityEngine.UI.Text timer;
    [SerializeField] private UnityEngine.UI.Text score;
    private int maxScore;
    private float currentTime;
    private bool inTurn;
    private bool threw;
    private bool scored;
    private int playerScore;
    private int opponentScore;
    private GameObject ball;
    private GameObject player;
    private PlayerController playerController;
    private GameObject npc;
    private OpponentController npcController;

    private void Start()
    {
        BallController.ballContact += verifyEndTurn;
        BasketController.score += wasScored;

        player = Instantiate(playerPrefab, spawPoints[0].position, spawPoints[0].rotation) as GameObject;
        npc = Instantiate(opponentPrefab, spawPoints[1].position, spawPoints[1].rotation) as GameObject;
        playerController = player.GetComponent<PlayerController>();
        npcController = npc.GetComponent<OpponentController>();
        playerController.setListenner(npcController);
        npcController.setListenner(playerController);
        npc.GetComponent<IAMovementScript>().setPlayerTransform(player.transform);
        FindObjectOfType<ForceBarController>().setPlayer(player);
        playerController.setTarget(targets[0]);
        npcController.setTarget(targets[1]);
        inTurn = true;
        threw = false;
        playerScore = 0;
        opponentScore = 0;
        scored = false;
        maxScore = SettingsPersistance.INSTANCE.maxPoints;
        turnDuration = SettingsPersistance.INSTANCE.turnDuration;
        score.text = "Player " + playerScore + " x " + opponentScore + " NPC";
    }

    private void Update()
    {
        timer.text = System.Math.Round(turnDuration - currentTime, 1).ToString(); 
        if (inTurn)
        {
            currentTime += Time.deltaTime;
        }
    }

    private void FixedUpdate()
    {
        if (currentTime >= turnDuration)
        {
            StartCoroutine(endTurn());
        }
    }

    private IEnumerator endTurn()
    {
        inTurn = false;
        currentTime = 0;
        npcController.enabled = false;
        playerController.enabled = false;
        stopAnimations();
        player.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
        npc.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
        yield return new WaitForSecondsRealtime(1);
        //do something

        verifyEndGame();

        StartCoroutine(setupTurn());
    }

    private IEnumerator setupTurn()
    {
        npcController.enabled = true;
        playerController.enabled = true;
        playerController.moveToPosition(spawPoints[0], spawPoints[2]);
        npcController.moveToPosition(spawPoints[3], spawPoints[1]);
        yield return new WaitForSecondsRealtime(1);
        //do something
        Destroy(ball);
        scored = false;
        StartCoroutine(startTurn());
    }

    private IEnumerator startTurn()
    {
        inTurn = true;
        playerController.changeTurn();
        npcController.changeTurn();
        threw = false;
        yield return null;
    }

    public void shoot(float force, Transform throwPoint, Transform target)
    {
        if (!threw)
        {
            threw = true;
            float xdistance;
            float time = SettingsPersistance.INSTANCE.difficulty.getForce() + force <= 0 ? -force : SettingsPersistance.INSTANCE.difficulty.getForce() + force;
            xdistance = target.position.x - throwPoint.position.x;
            float ydistance;
            ydistance = target.position.y - throwPoint.position.y;

            float throwAngle; 
            throwAngle = Mathf.Atan((ydistance + calculateGravity() * (time * time)) / xdistance);
            float totalVelo = xdistance / (Mathf.Cos(throwAngle) * time);

            float xVelo, yVelo;
            xVelo = totalVelo * Mathf.Cos(throwAngle);
            yVelo = totalVelo * Mathf.Sin(throwAngle);

            GameObject bulletInstance = Instantiate(ballPrefab, throwPoint.position, throwPoint.rotation) as GameObject;
            bulletInstance.GetComponent<Rigidbody2D>().velocity = new Vector2(xVelo, yVelo);
            StartCoroutine(setupEndTurn());
        }
    }

    private IEnumerator setupEndTurn()
    {
        inTurn = false;
        currentTime = 0;
        npcController.enabled = false;
        playerController.enabled = false;
        yield return new WaitUntil(() => currentTime > turnDuration);
    }

    private float calculateGravity()
    {
        return Physics2D.gravity.y / -2;
    }

    public float getCurrentTime()
    {
        return currentTime;
    }

    public float getTurnDuration()
    {
        return turnDuration;
    }

    private void stopAnimations()
    {
        if (player.GetComponent<Animation>() != null)
        {
            player.GetComponent<Animation>().Stop();
        }
        if (npc.GetComponent<Animation>() != null)
        {
            npc.GetComponent<Animation>().Stop();
        }
    }

    public void verifyEndTurn(GameObject obj)
    {
        if (scored)
        {
            if (playerController.isMyturn())
            {
                playerScore += playerController.getShootLocation();
            }
            else
            {
                opponentScore += npcController.getShootLocation();
            }
        }
        score.text = "Player " + playerScore + " x " + opponentScore + " Npc";
        currentTime = turnDuration + 1f;
        ball = obj;
        ball.GetComponent<Collider2D>().enabled = false;
        Rigidbody2D ballRb = ball.GetComponent<Rigidbody2D>();
        ballRb.sharedMaterial.friction = 0;
        ballRb.velocity = Vector2.zero;
        ballRb.gravityScale = 0;
    }

    private void verifyEndGame()
    {
        if (playerScore >= maxScore)
        {
            Debug.Log("Player wins");
            UnityEngine.SceneManagement.SceneManager.LoadScene("Menu");
        }
        if (opponentScore >= maxScore)
        {
            Debug.Log("NPC wins");
            UnityEngine.SceneManagement.SceneManager.LoadScene("Menu");
        }
    }

    private void wasScored()
    {
        scored = true;
    }
}