Voltar para o Blog
Quest Log

Parry na Unity: bloqueio e contra-ataque com janela de tempo

Guerreiro com escudo desviando o golpe de um inimigo no instante exato, com faísca dourada de parry entre as armas

Parry na Unity em C#: janela de parry com Time.time, bloqueio que reduz dano, stagger do inimigo, contra-ataque e feedback com hitstop e Input System.

Ferramenta:Unity

Parry na Unity parece mecânica de jogo grande, mas o núcleo é um timestamp e uma comparação. Quando o jogador aperta defesa, você guarda Time.time. Quando o golpe chega, você mede quanto tempo passou: dentro da janela é parry, fora dela é bloqueio. Neste tutorial eu monto o sistema completo em C#: estados de defesa, bloqueio que reduz dano, parry que anula o golpe e atordoa o inimigo, contra-ataque com dano extra, integração com o Input System e o feedback de hitstop e som que faz o jogador sentir que acertou.

Eu parto do componente Health do tutorial de sistema de vida e dano na Unity, que expõe TakeDamage(int amount, Vector2 hitSource). Se você usa outro script de vida, só troque essa chamada.

Bloquear e dar parry: duas recompensas no mesmo botão

A distinção define o código inteiro:

  • Bloqueio: o jogador segura o botão. Não precisa de timing. O dano cai para uma fração (aqui, 25%), mas ainda entra. É seguro e fácil.
  • Parry: o jogador aperta o botão pouco antes do golpe. A janela é curta, entre 0.1s e 0.25s. Se acertar, dano zero e o inimigo fica atordoado (stagger), aberto para um contra-ataque que tira mais vida.

Os dois ficam no mesmo botão, como em quase todo jogo de ação. Apertar abre a janela de parry; se o golpe não vier a tempo e o botão continuar pressionado, o personagem passa a bloquear. Errar o timing do parry nunca pune com dano cheio, só entrega a recompensa menor. Isso deixa o jogador tentar sem medo, e é o que faz o parry virar hábito. Se quiser a parte de design por trás disso, o post sobre design de combate divertido discute risco e recompensa em detalhe.

Os estados de defesa e a janela com Time.time

Três estados bastam: Idle, ParryWindow e Blocking. A decisão importante é não confiar só no estado para saber se o parry valeu. O Update que troca ParryWindow para Blocking pode rodar depois do golpe no mesmo frame, ou antes, dependendo da ordem de execução. Por isso a janela é checada pelo timestamp na hora em que o golpe chega.

Primeiro, a action. No seu arquivo .inputactions, crie uma action Block do tipo Button, sem interaction (uma interaction Hold atrasaria o evento e comeria a janela). Se você ainda não usa o Input System, o tutorial do New Input System cobre a configuração do zero.

Agora o PlayerDefense.cs:

using System;
using UnityEngine;
using UnityEngine.InputSystem;

public enum DefenseState
{
    Idle,
    ParryWindow,
    Blocking
}

public enum HitResult
{
    Hit,
    Blocked,
    Parried
}

[RequireComponent(typeof(Health))]
public class PlayerDefense : MonoBehaviour
{
    [Header("Input")]
    [SerializeField] private InputActionReference blockAction;

    [Header("Tuning")]
    [SerializeField] private float parryWindow = 0.15f;
    [SerializeField] private float parryCooldown = 0.35f;
    [SerializeField, Range(0f, 1f)] private float blockDamageMultiplier = 0.25f;
    [SerializeField] private bool logTiming = false;

    public event Action<HitResult, EnemyAttack> HitResolved;

    public DefenseState State { get; private set; } = DefenseState.Idle;

    private Health health;
    private float parryPressedTime = -999f;

    private void Awake()
    {
        health = GetComponent<Health>();
    }

    private void OnEnable()
    {
        blockAction.action.started += OnBlockStarted;
        blockAction.action.canceled += OnBlockCanceled;
        blockAction.action.Enable();
    }

    private void OnDisable()
    {
        blockAction.action.started -= OnBlockStarted;
        blockAction.action.canceled -= OnBlockCanceled;
    }

    private void Update()
    {
        if (State == DefenseState.ParryWindow && !IsInParryWindow())
        {
            State = DefenseState.Blocking;
        }
    }

    private void OnBlockStarted(InputAction.CallbackContext context)
    {
        // Apertar de novo logo depois cai direto no bloqueio: sem spam de parry.
        if (Time.time - parryPressedTime < parryCooldown)
        {
            State = DefenseState.Blocking;
            return;
        }

        parryPressedTime = Time.time;
        State = DefenseState.ParryWindow;
    }

    private void OnBlockCanceled(InputAction.CallbackContext context)
    {
        State = DefenseState.Idle;
    }

    private bool IsInParryWindow()
    {
        return State == DefenseState.ParryWindow
            && Time.time - parryPressedTime <= parryWindow;
    }

    public HitResult ReceiveHit(int damage, EnemyAttack attacker)
    {
        Vector2 hitSource = attacker.transform.position;
        HitResult result;

        if (IsInParryWindow())
        {
            attacker.Stagger();
            result = HitResult.Parried;
        }
        else if (State == DefenseState.ParryWindow || State == DefenseState.Blocking)
        {
            int reduced = Mathf.CeilToInt(damage * blockDamageMultiplier);
            health.TakeDamage(reduced, hitSource);
            result = HitResult.Blocked;
        }
        else
        {
            health.TakeDamage(damage, hitSource);
            result = HitResult.Hit;
        }

        if (logTiming)
        {
            float sincePress = Time.time - parryPressedTime;
            Debug.Log($"{result} | {sincePress:F3}s desde o botão (janela {parryWindow:F2}s)");
        }

        HitResolved?.Invoke(result, attacker);
        return result;
    }
}

O que esse script resolve:

  1. Janela por timestamp. IsInParryWindow() compara Time.time com o momento do aperto. Não importa se o Update já rodou neste frame: a resposta é a mesma.
  2. Estado ParryWindow vencido conta como bloqueio. Se a janela acabou mas o Update ainda não trocou o estado, o else if trata como bloqueio. O jogador nunca toma dano cheio segurando o botão.
  3. Cooldown contra spam. Sem ele, martelar o botão abre uma janela nova a cada aperto e o parry vira trivial. Com parryCooldown, só o primeiro aperto vale parry; os seguintes caem direto no bloqueio.
  4. started e canceled. Numa action do tipo Button sem interaction, started dispara no aperto e canceled na soltura. É o par certo para "segurando ou não".

Se o seu player já tem uma máquina de estados (andar, atacar, rolar), PlayerDefense vira um estado dentro dela em vez de um componente solto. O post de máquina de estados na Unity mostra como encaixar, e a regra é a mesma: atacando ou rolando, OnBlockStarted não deve abrir a janela.

O inimigo: golpe, stagger e janela de contra-ataque

O defensor decide o resultado; o atacante só entrega o golpe e reage. Crie EnemyStagger.cs no objeto raiz do inimigo:

using UnityEngine;

public class EnemyStagger : MonoBehaviour
{
    [SerializeField] private Animator animator;
    [SerializeField] private float staggerDuration = 1.2f;

    private float staggeredUntil;

    public bool IsStaggered => Time.time < staggeredUntil;

    public void Stagger()
    {
        staggeredUntil = Time.time + staggerDuration;
        animator.SetTrigger("Stagger");
    }
}

E EnemyAttack.cs no objeto da hitbox do golpe (o collider 2D marcado como trigger que a animação liga no frame ativo):

using UnityEngine;

public class EnemyAttack : MonoBehaviour
{
    [SerializeField] private int damage = 2;
    [SerializeField] private EnemyStagger stagger;
    [SerializeField] private Collider2D hitbox;

    private void OnTriggerEnter2D(Collider2D other)
    {
        if (stagger.IsStaggered)
        {
            return;
        }

        if (other.TryGetComponent(out PlayerDefense defense))
        {
            defense.ReceiveHit(damage, this);
        }
    }

    public void Stagger()
    {
        // Um golpe que levou parry não pode continuar acertando.
        hitbox.enabled = false;
        stagger.Stagger();
    }
}

A IA do inimigo consulta stagger.IsStaggered antes de andar ou atacar. Enquanto for verdadeiro, ele fica parado na animação de atordoado. Assim como o Health do tutorial base, o stagger usa tempo absoluto em vez de coroutine: não tem coroutine para esquecer de parar se o inimigo for desativado.

O contra-ataque é a recompensa que fecha o ciclo. No script da hitbox da arma do player, multiplique o dano quando o alvo estiver atordoado:

using UnityEngine;

public class PlayerWeaponHitbox : MonoBehaviour
{
    [SerializeField] private int damage = 1;
    [SerializeField] private int riposteMultiplier = 3;

    private void OnTriggerEnter2D(Collider2D other)
    {
        if (!other.TryGetComponent(out Health targetHealth))
        {
            return;
        }

        int finalDamage = damage;
        EnemyStagger stagger = other.GetComponentInParent<EnemyStagger>();
        if (stagger != null && stagger.IsStaggered)
        {
            finalDamage *= riposteMultiplier;
        }

        targetHealth.TakeDamage(finalDamage, transform.position);
    }
}

Com staggerDuration em 1.2s, o jogador tem tempo de um ou dois golpes. Menos que isso e o contra-ataque não cabe; muito mais e o parry vira botão de vitória.

Feedback: hitstop curto, som e tremor

Parry sem feedback é invisível. O jogador precisa saber, no mesmo frame, qual dos três resultados aconteceu. Um componente separado escuta o evento HitResolved e cuida disso, mantendo PlayerDefense limpo.

Primeiro o hitstop, que congela o jogo por alguns frames. Crie HitStop.cs num objeto da cena:

using System.Collections;
using UnityEngine;

public class HitStop : MonoBehaviour
{
    private float stopUntil;
    private bool running;

    public void Stop(float duration)
    {
        float end = Time.unscaledTime + duration;
        if (end <= stopUntil)
        {
            return;
        }

        stopUntil = end;
        if (!running)
        {
            StartCoroutine(StopRoutine());
        }
    }

    private IEnumerator StopRoutine()
    {
        running = true;
        float savedScale = Time.timeScale;
        Time.timeScale = 0f;

        while (Time.unscaledTime < stopUntil)
        {
            yield return null;
        }

        Time.timeScale = savedScale;
        running = false;
    }
}

Time.unscaledTime continua andando com timeScale em zero, por isso o loop termina. E dois hitstops seguidos só estendem o mesmo congelamento em vez de brigar pela escala. A lógica é a mesma do hitstop na Godot 4, onde explico em detalhe a versão global e a local.

Agora o DefenseFeedback.cs:

using UnityEngine;

public class DefenseFeedback : MonoBehaviour
{
    [SerializeField] private PlayerDefense defense;
    [SerializeField] private HitStop hitStop;
    [SerializeField] private AudioSource audioSource;
    [SerializeField] private AudioClip parryClip;
    [SerializeField] private AudioClip blockClip;
    [SerializeField] private float parryHitStop = 0.12f;
    [SerializeField] private float blockHitStop = 0.04f;

    private void OnEnable()
    {
        defense.HitResolved += OnHitResolved;
    }

    private void OnDisable()
    {
        defense.HitResolved -= OnHitResolved;
    }

    private void OnHitResolved(HitResult result, EnemyAttack attacker)
    {
        switch (result)
        {
            case HitResult.Parried:
                audioSource.PlayOneShot(parryClip);
                hitStop.Stop(parryHitStop);
                break;
            case HitResult.Blocked:
                audioSource.PlayOneShot(blockClip);
                hitStop.Stop(blockHitStop);
                break;
        }
    }
}

O parry ganha um hitstop maior e um som agudo, metálico, diferente do bloqueio. Esse contraste é o que ensina o jogador a diferenciar os dois sem tutorial. Para completar, dispare um tremor de câmera curto no parry, usando o Impulse do Cinemachine do post de camera shake na Unity. O áudio não para com timeScale em zero, então o som toca inteiro durante o freeze.

Um detalhe: com timeScale em zero, Time.time também para. A janela de parry e o stagger ficam congelados durante o hitstop, o que é justo: o jogador não perde tempo de contra-ataque por causa de um efeito visual. Se você quisesse o contrário, trocaria por Time.unscaledTime.

Até aqui são cinco scripts conversando: vida, defesa, stagger, arma e feedback. E isso é só a defesa. Quando entra combo, esquiva, i-frames e IA de inimigo, o projeto vira uma pilha de componentes que dependem uns dos outros de jeitos que ninguém planejou, e é nesse ponto que a maioria dos projetos de ação para de andar. Sair desse ponto exige base sólida de C# e de arquitetura, não mais um tutorial solto.

Curso de Unity
Quer fazer seu primeiro jogo na Unity?

No curso de Unity 6 da CursoGame.Dev você vai do zero ao primeiro jogo, com um desafio prático em cada level e suporte individual no WhatsApp quando travar.

Conhecer o curso de Unity
Suporte no WhatsAppAcesso vitalícioGarantia de 7 dias

Testes de tuning do parry na Unity: como achar a janela certa

Os números deste post são ponto de partida. A janela certa depende do ritmo do seu inimigo, e o jeito de achar é testar com método.

  • Ligue o logTiming. Cada golpe imprime quantos segundos se passaram desde o aperto. Se o seu playtester erra o parry com 0.18s repetidamente, a janela de 0.15s está apertada para o telegraph desse inimigo.
  • Teste com quem nunca jogou. Você treinou o timing enquanto programava. Sua percepção de "fácil" está calibrada errado.
  • Ajuste o telegraph antes da janela. Se ninguém acerta o parry, o problema costuma ser a animação de preparo do inimigo curta demais, não a janela. Um golpe precisa de uma pose clara antes do frame ativo.
  • Janela por inimigo. Um chefe pode ter janela menor que um inimigo comum. Mover parryWindow para um valor enviado pelo atacante é uma extensão simples quando você chegar lá.
  • Teste em câmera lenta. Time.timeScale = 0.25f no editor mostra se a hitbox liga no frame certo da animação. Hitbox que liga cedo demais faz o parry parecer quebrado.

Se você também desenvolve na Godot, a versão do parry com escudo na Godot faz a mesma mecânica com stamina e guard break, uma boa ideia para levar para esta versão depois.

Resumo

Parry na Unity é um timestamp guardado no aperto e uma comparação na chegada do golpe. Com isso em mãos: estados Idle, ParryWindow e Blocking; bloqueio que reduz dano; parry que anula e atordoa; contra-ataque com dano multiplicado; Input System com started e canceled; e feedback com hitstop e som diferentes para cada resultado. O resto é tuning.

Para mais tutoriais de C# e combate, veja o hub de tutoriais de Unity. E se você está pensando em estudar a engine de forma estruturada, o post sobre se vale a pena um curso de desenvolvimento de jogos com Unity ajuda a decidir.

Perguntas frequentes

Qual a diferença entre bloquear e dar parry?

Bloquear é segurar o botão de defesa: não exige timing e só reduz o dano. Parry é apertar o botão pouco antes do golpe chegar, dentro de uma janela curta. Se acertar, o dano é anulado e o inimigo fica atordoado, aberto para um contra-ataque.

Como fazer a janela de parry na Unity?

Guarde Time.time no momento em que o botão de defesa é pressionado. Quando um golpe chegar, compare: se Time.time menos esse timestamp for menor ou igual à duração da janela (por exemplo 0.15s), é parry. Fora disso, com o botão ainda pressionado, é bloqueio.

Qual o tamanho ideal da janela de parry?

Entre 0.1s e 0.25s. 0.1s é exigente, 0.15s é um bom padrão para jogos de ação indie e 0.2s ou mais deixa a mecânica acessível. Exponha o valor com [SerializeField] e ajuste em playtest com gente que nunca jogou seu jogo.

Por que o parry falha mesmo quando aperto na hora certa?

As causas mais comuns são a janela checada só no Update (o golpe chega no mesmo frame, antes da troca de estado), uma interaction Hold na action do Input System atrasando o evento, ou a hitbox do inimigo ligando antes da animação mostrar o golpe. Checar a janela pelo timestamp dentro do próprio ReceiveHit resolve o primeiro caso.