Example #1
0
    public void spawnParticle(playerPlataformerController otherPlayer, int placeStruck)
    {
        var currentBlood = Instantiate(blood, otherPlayer.transform.root.GetChild(2).GetChild(placeStruck).GetComponent <BoxCollider2D>().transform.position, Quaternion.identity);

        currentBlood.transform.localScale = new Vector3(transform.root.GetChild(0).transform.localScale.x, 1, 1);

        ParticleSystem.ShapeModule editableShape = currentBlood.shape;
        editableShape.position = new Vector3(Random.Range(-1.0f, 1.0f), 0, Random.Range(-1.0f, 1.0f));

        ParticleSystem.EmissionModule editableCount = currentBlood.emission;
        editableCount.SetBurst(0, new ParticleSystem.Burst(0, damage / 2));

        ParticleSystem.VelocityOverLifetimeModule editableSpeed = currentBlood.velocityOverLifetime;
        editableSpeed.speedModifier = Mathf.Ceil(pushBackStrengh / 12f);

        if (placeStruck == 0)
        {
            Instantiate(hitSplash, new Vector3(otherPlayer.transform.position.x, otherPlayer.transform.position.y + 4f, 0), Quaternion.identity);
        }
        else if (placeStruck == 1)
        {
            Instantiate(hitSplash, new Vector3(otherPlayer.transform.position.x, otherPlayer.transform.position.y + 2f, 0), Quaternion.identity);
        }
        else
        {
            Instantiate(hitSplash, new Vector3(otherPlayer.transform.position.x, otherPlayer.transform.position.y - 1.5f, 0), Quaternion.identity);
        }
    }
 private void RoundUp(playerPlataformerController winner)
 {
     if (roundCount)
     {
         winner.roundsWon++;
         roundCount = false;
     }
 }
 public void PlayWinningQuote(playerPlataformerController winningPlayer)
 {
     if (!narratorLine)
     {
         PlaySound(mode16bit ? winningPlayer.narrator16bit : winningPlayer.narrator);
         audioSource.clip = mode16bit ? narratorLines16bit[4] : narratorLines[4];
         audioSource.PlayDelayed(mode16bit ? winningPlayer.narrator16bit.length + 0.25f : winningPlayer.narrator.length + 0.25f);
         narratorLine = true;
     }
 }
    void PlayerVictoryRound(playerPlataformerController losingPlayerScript, playerPlataformerController winningPlayerScript)
    {
        // Fecha os comandos
        gameRunning = false;

        if (winningPlayerScript.grounded && !winningPlayerScript.currentlyAttacking)
        {
            StopPlayer(winningPlayerScript);
            winningPlayerScript.won = true;
        }

        if (losingPlayerScript.grounded && !losingPlayerScript.currentlyAttacking)
        {
            StopPlayer(losingPlayerScript);
            losingPlayerScript.lost = true;
        }

        if (coroutineRound)
        {
            StartCoroutine(RestartRound(winningPlayerScript));
            coroutineRound = false;
        }
    }
    public void TDEEffect(playerPlataformerController player)
    {
        // Start
        gameRunning = false;
        timeFreeze  = true;

        leftPlayerScript.animator.speed  = 0;
        rightPlayerScript.animator.speed = 0;

        var particle1 = Instantiate(particles[4], new Vector3(player.transform.position.x, player.transform.position.y + 2.5f), Quaternion.identity);
        var particle2 = Instantiate(particles[5], new Vector3(player.transform.position.x, player.transform.position.y + 2.5f), Quaternion.identity);

        ParticleSystem.MainModule color1 = particle1.main;
        ParticleSystem.MainModule color2 = particle2.main;

        color1.startColor = player.mainColor;
        color2.startColor = player.mainColor;

        Vector2 leftTargetV = Vector2.zero;
        Vector2 leftV       = Vector2.zero;

        Vector2 rightTargetV = Vector2.zero;
        Vector2 rightV       = Vector2.zero;

        if (leftPlayerScript.lastHitStun > 0)
        {
            leftPlayerScript.hitStunPause   = true;
            leftPlayerScript.targetVelocity = Vector2.zero;
            leftPlayerScript.velocity       = Vector2.zero;
        }

        if (rightPlayerScript.lastHitStun > 0)
        {
            rightPlayerScript.hitStunPause   = true;
            rightPlayerScript.targetVelocity = Vector2.zero;
            rightPlayerScript.velocity       = Vector2.zero;
        }

        if (leftPlayerScript.jumping && rightPlayerScript.jumping)
        {
            if (!velocityCheck)
            {
                leftTargetV = leftPlayerScript.targetVelocity;
                leftV       = leftPlayerScript.velocity;

                rightTargetV = rightPlayerScript.targetVelocity;
                rightV       = rightPlayerScript.velocity;

                leftPlayerScript.targetVelocity  = Vector2.zero;
                leftPlayerScript.velocity        = Vector2.zero;
                rightPlayerScript.targetVelocity = Vector2.zero;
                rightPlayerScript.velocity       = Vector2.zero;

                velocityCheck = true;
            }

            leftPlayerScript.graityModified  = 0f;
            rightPlayerScript.graityModified = 0f;
        }
        else if (leftPlayerScript.jumping)
        {
            if (!velocityCheck)
            {
                leftTargetV = leftPlayerScript.targetVelocity;
                leftV       = leftPlayerScript.velocity;

                leftPlayerScript.targetVelocity = Vector2.zero;
                leftPlayerScript.velocity       = Vector2.zero;

                velocityCheck = true;
            }

            leftPlayerScript.graityModified = 0f;
        }
        else if (rightPlayerScript.jumping)
        {
            if (!velocityCheck)
            {
                rightTargetV = rightPlayerScript.targetVelocity;
                rightV       = rightPlayerScript.velocity;

                rightPlayerScript.targetVelocity = Vector2.zero;
                rightPlayerScript.velocity       = Vector2.zero;

                velocityCheck = true;
            }

            rightPlayerScript.graityModified = 0f;
        }

        sceneCamera.transform.DOMove(new Vector3(player.transform.position.x, player.transform.position.y + 5, sceneCamera.transform.position.z), 0.5f);

        transform.GetChild(3).GetComponent <SpriteRenderer>().DOColor(Color.black, 0.25f).OnPlay(() => {
            transform.GetChild(3).GetComponent <SpriteRenderer>().color = Color.clear;
        }).OnComplete(() => {
            transform.GetChild(3).GetComponent <SpriteRenderer>().color = Color.black;
        });


        // Finish
        sceneCamera.transform.DOMove(new Vector3((leftPlayerScript.posX + rightPlayerScript.posX) / 2, sceneCamera.transform.position.y, sceneCamera.transform.position.z), 0.5f).SetDelay(1f).OnComplete(() => {
            gameRunning = true;
            timeFreeze  = false;

            leftPlayerScript.animator.speed  = 1;
            rightPlayerScript.animator.speed = 1;

            if (leftPlayerScript.lastHitStun > 0)
            {
                leftPlayerScript.hitStunPause = false;
            }

            if (rightPlayerScript.lastHitStun > 0)
            {
                rightPlayerScript.hitStunPause = false;
            }

            if (leftPlayerScript.jumping && rightPlayerScript.jumping)
            {
                leftPlayerScript.targetVelocity = leftTargetV;
                leftPlayerScript.velocity       = leftV;

                rightPlayerScript.targetVelocity = rightTargetV;
                rightPlayerScript.velocity       = rightV;

                leftPlayerScript.graityModified  = 10f;
                rightPlayerScript.graityModified = 10f;
            }
            else if (leftPlayerScript.jumping)
            {
                leftPlayerScript.targetVelocity = leftTargetV;
                leftPlayerScript.velocity       = leftV;

                leftPlayerScript.graityModified = 10f;
            }
            else if (rightPlayerScript.jumping)
            {
                rightPlayerScript.targetVelocity = rightTargetV;
                rightPlayerScript.velocity       = rightV;

                rightPlayerScript.graityModified = 10f;
            }

            velocityCheck = false;
        });

        transform.GetChild(3).GetComponent <SpriteRenderer>().DOColor(Color.clear, 0.25f).OnComplete(() => {
            transform.GetChild(3).GetComponent <SpriteRenderer>().color = Color.clear;
        }).OnPlay(() => {
            transform.GetChild(3).GetComponent <SpriteRenderer>().color = Color.black;
        }).SetDelay(1f);
    }
    IEnumerator RestartRound(playerPlataformerController winner)
    {
        yield return(new WaitForSeconds(1));

        FadeOut();

        yield return(new WaitForSeconds(1));

        winningChance = true;

        timeLeft         = totalTime;
        uiTexts[10].text = timeLeft.ToString("0");

        leftPlayerScript.won  = false;
        leftPlayerScript.lost = false;

        rightPlayerScript.won  = false;
        rightPlayerScript.lost = false;

        rounds++;

        leftPlayerScript.health  = leftPlayerScript.maxHealth;
        rightPlayerScript.health = rightPlayerScript.maxHealth;

        leftPlayerScript.MoveTo(spawnPoints[0].transform.position);
        rightPlayerScript.MoveTo(spawnPoints[1].transform.position);

        rightPlayerScript.isLeft = false;
        leftPlayerScript.isLeft  = true;

        rightPlayerScript.flipCharacterLeft();
        leftPlayerScript.flipCharacterRight();

        // Faz a camera ficar entre os dois personages
        sceneCamera.transform.position = new Vector3((leftPlayer.transform.position.x + rightPlayer.transform.position.x) / 2, sceneCamera.transform.position.y, sceneCamera.transform.position.z);

        // Pega a difereça dos dois players
        float diffPos = Math.Abs(leftPlayerScript.posX - rightPlayerScript.posX);

        // Se a difereça for maior que 30 a camera muda de tamanho
        if (diffPos >= 30)
        {
            sceneCamera.GetComponent <Camera>().orthographicSize = diffPos / 3f;
        }
        else
        {
            sceneCamera.GetComponent <Camera>().orthographicSize = 10;
        }

        yield return(new WaitForSeconds(1));

        RoundUp(winner);
        if (leftPlayerScript.roundsWon == 1)
        {
            uiTexts[6].gameObject.SetActive(true);
        }

        if (rightPlayerScript.roundsWon == 1)
        {
            uiTexts[8].gameObject.SetActive(true);
        }

        FadeIn();

        yield return(new WaitForSeconds(1));

        uiTexts[4].enabled = true;
        uiTexts[4].text    = "Round " + rounds;
        if (rounds == 1)
        {
            PlaySound(mode16bit ? narratorLines16bit[1] : narratorLines[1]);
        }
        else if (rounds == 2)
        {
            PlaySound(mode16bit ? narratorLines16bit[2] : narratorLines[2]);
        }
        else if (rounds == 3)
        {
            PlaySound(mode16bit ? narratorLines16bit[3] : narratorLines[3]);
        }

        yield return(new WaitForSeconds(1));

        uiTexts[4].enabled = false;

        yield return(new WaitForSeconds(0.5f));

        coroutineRound     = true;
        roundCount         = true;
        uiTexts[4].enabled = true;
        gameRunning        = true;
        PlaySound(mode16bit ? narratorLines16bit[0] : narratorLines[0]);
        uiTexts[4].text = "FIGHT!";

        yield return(new WaitForSeconds(0.5f));

        uiTexts[4].enabled = false;
    }
    void PlayerVictory(playerPlataformerController losingPlayerScript, playerPlataformerController winningPlayerScript)
    {
        // Fecha os comandos
        gameRunning = false;

        // Faz o efeito final e congela a animação
        if (!GetComponent <PostProcessing>().doneEffect)
        {
            GetComponent <PostProcessing>().DeathVignette(true);
        }
        else
        {
            GetComponent <PostProcessing>().DeathVignette(false);
        }

        // Faz o efeito final da camera
        if (!doneCameraEffect)
        {
            GameObject.FindWithTag("MainCamera").transform.DOMove(new Vector3(losingPlayerScript.posX, ((leftPlayerScript.posY + rightPlayerScript.posY) / 2) + 2, GameObject.FindWithTag("MainCamera").transform.position.z), GetComponent <PostProcessing>().startSpeed).OnComplete(() => {
                doneCameraEffect = true;
                leftPlayerScript.animator.speed  = 0;
                rightPlayerScript.animator.speed = 0;
                StartCoroutine(HitStopStart(120f, 0.05f));
            });
            if (losingPlayerScript.isLeft)
            {
                GameObject.FindWithTag("MainCamera").transform.DORotate(new Vector3(0, 0, 5), GetComponent <PostProcessing>().startSpeed);
            }
            else
            {
                GameObject.FindWithTag("MainCamera").transform.DORotate(new Vector3(0, 0, -5), GetComponent <PostProcessing>().startSpeed);
            }
        }
        else
        {
            GameObject.FindWithTag("MainCamera").transform.DOMove(new Vector3((leftPlayerScript.posX + rightPlayerScript.posX) / 2, 0f, sceneCamera.transform.position.z), 1f).SetDelay(0.1f);
            GameObject.FindWithTag("MainCamera").transform.DORotate(new Vector3(0, 0, 0), 1f).OnPlay(() => {
                if (winningPlayerScript.roundsWon == 1)
                {
                    RoundUp(winningPlayerScript);
                }

                if (leftPlayerScript.roundsWon == 2)
                {
                    uiTexts[7].gameObject.SetActive(true);
                }
                if (rightPlayerScript.roundsWon == 2)
                {
                    uiTexts[9].gameObject.SetActive(true);
                }

                if (winningPlayerScript.grounded && !winningPlayerScript.currentlyAttacking)
                {
                    StopPlayer(winningPlayerScript);
                    winningPlayerScript.won = true;
                }

                if (losingPlayerScript.grounded && !losingPlayerScript.currentlyAttacking)
                {
                    StopPlayer(losingPlayerScript);
                    losingPlayerScript.lost = true;
                }

                PlayWinningQuote(winningPlayerScript);
            }).SetDelay(0.1f);
        }

        // Da o hitstop longo
        uiTexts[4].enabled = true;
        uiTexts[4].text    = winningPlayerScript.characterName + " wins";

        // Termina o jogo
        StartCoroutine(EndCondition());
    }
    void Start()
    {
        // Coloca o mapa
        var arenaAtual = Instantiate(arenas[Random.Range(0, arenas.Length)]);

        arenaAtual.GetComponent <ArenaScript>().SpawnInteractable(spawnPoints[2].transform.position);
        arenaAtual.GetComponent <ArenaScript>().SpawnInteractable(spawnPoints[3].transform.position);

        timeLeft         = totalTime;
        uiTexts[10].text = timeLeft.ToString();

        audioSource = GetComponent <AudioSource>();

        // Arrumas os player
        leftPlayerChosen  = Mensageiro.leftPlayerIndex;
        rightPlayerChosen = Mensageiro.rightPlayerIndex;

        var leftPlayerPreFab = Instantiate(players[leftPlayerChosen]);

        leftPlayer                      = leftPlayerPreFab.transform.GetChild(0).gameObject;
        leftPlayerScript                = leftPlayerPreFab.transform.GetChild(0).GetComponent <playerPlataformerController>();
        leftPlayerScript.isPlayer1      = true;
        leftPlayerScript.gameController = this;

        var rightPlayerPreFab = Instantiate(players[rightPlayerChosen]);

        rightPlayer                      = rightPlayerPreFab.transform.GetChild(0).gameObject;
        rightPlayerScript                = rightPlayerPreFab.transform.GetChild(0).GetComponent <playerPlataformerController>();
        rightPlayerScript.isPlayer1      = false;
        rightPlayerScript.gameController = this;

        // Acha a camera
        sceneCamera = GameObject.FindWithTag("MainCamera");

        // Pega os scripts dos players
        leftPlayerScript  = leftPlayer.transform.root.GetChild(0).GetComponent <playerPlataformerController>();
        rightPlayerScript = rightPlayer.transform.root.GetChild(0).GetComponent <playerPlataformerController>();

        leftPlayerScript.MoveTo(spawnPoints[0].transform.position);
        rightPlayerScript.MoveTo(spawnPoints[1].transform.position);

        // Vira os personagens
        rightPlayerScript.isLeft = false;
        leftPlayerScript.isLeft  = true;

        rightPlayerScript.flipCharacterLeft();
        leftPlayerScript.flipCharacterRight();

        // Coloca os nomes
        uiTexts[0].text = leftPlayerScript.characterName;
        uiTexts[1].text = rightPlayerScript.characterName;

        // Desativa pause e vitória
        uiTexts[4].enabled = false;
        uiTexts[5].enabled = false;

        uiTexts[6].gameObject.SetActive(false);
        uiTexts[7].gameObject.SetActive(false);
        uiTexts[8].gameObject.SetActive(false);
        uiTexts[9].gameObject.SetActive(false);

        uiTexts[2].gameObject.SetActive(false);
        uiTexts[3].gameObject.SetActive(false);

        // Colocam a cor
        uiImages[0].color = leftPlayerScript.mainColor;
        uiTexts[0].color  = leftPlayerScript.mainColor;
        uiTexts[2].color  = leftPlayerScript.mainColor;
        uiImages[6].color = leftPlayerScript.mainColor;

        uiTexts[1].color   = rightPlayerScript.mainColor;
        uiTexts[3].color   = rightPlayerScript.mainColor;
        uiImages[3].color  = rightPlayerScript.mainColor;
        uiImages[10].color = rightPlayerScript.mainColor;


        transform.GetChild(2).GetComponent <SpriteRenderer>().color = Color.black;

        // Coloca o sangue nos prefabs
        AttachParticles();

        StartCoroutine(StartCondition());

        /*// Start settings
         * camera.GetComponent<Camera>().orthographicSize = 15;
         * foreach (var text in uiTexts){
         *  text.GetComponent<CanvasRenderer>().SetAlpha(0);
         * }
         * foreach (var images in uiImages){
         *  images.GetComponent<CanvasRenderer>().SetAlpha(0);
         * }
         * uiImages[2].rectTransform.localScale = new Vector3(0, uiImages[2].rectTransform.localScale.y, uiImages[2].rectTransform.localScale.z);
         * uiImages[1].rectTransform.localScale = new Vector3(0, uiImages[1].rectTransform.localScale.y, uiImages[1].rectTransform.localScale.z);
         *
         * uiImages[5].rectTransform.localScale = new Vector3(0, uiImages[5].rectTransform.localScale.y, uiImages[5].rectTransform.localScale.z);
         * uiImages[4].rectTransform.localScale = new Vector3(0, uiImages[4].rectTransform.localScale.y, uiImages[4].rectTransform.localScale.z);*/
    }
 void StopPlayer(playerPlataformerController player)
 {
     player.StopAllAttack();
     player.targetVelocity = Vector2.zero;
     player.StopInput();
 }
 void Start()
 {
     ownPlayer      = transform.root.GetChild(0).GetComponent <playerPlataformerController>();
     totalThreshold = threshold;
 }