GameManager.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameManager : MonoBehaviour
{
    [SerializeField] private int turnDuration;
    [SerializeField] private GameObject ball;
    [SerializeField] private GameObject playerPrefab;
    [SerializeField] private GameObject opponentPrefab;
    [SerializeField] private Transform[] targets;
    [SerializeField] private Transform[] spawPoints;
    private float currentTime;
    private bool inTurn;
    private bool threw;
    private GameObject player;
    private PlayerController playerController;
    private GameObject npc;
    private OpponentController npcController;

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

        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;
    }

    private void Update()
    {
        if (inTurn)
        {
            currentTime += Time.deltaTime;
            //Debug.Log(currentTime);
        }
        //Debug.Log(1.0f/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
        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
        StartCoroutine(startTurn());
    }

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

    public void shoot(float force, Transform throwPoint, Transform target)
    {
        if (!threw)
        {
            threw = true;
            float xdistance;
            float time = 0.8f + 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(ball, 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;
        stopAnimations();
        player.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
        npc.GetComponent<Rigidbody2D>().velocity = Vector2.zero;
        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 ball)
    {
        //do something
        //verificar se fez ponto
        //alterar placar
        currentTime = 50f;
        //Destroy(ball);
    }
}