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

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.
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:
- Janela por timestamp.
IsInParryWindow()comparaTime.timecom o momento do aperto. Não importa se oUpdatejá rodou neste frame: a resposta é a mesma. - Estado
ParryWindowvencido conta como bloqueio. Se a janela acabou mas oUpdateainda não trocou o estado, oelse iftrata como bloqueio. O jogador nunca toma dano cheio segurando o botão. - 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. startedecanceled. Numa action do tipo Button sem interaction,starteddispara no aperto ecanceledna 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.
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
parryWindowpara um valor enviado pelo atacante é uma extensão simples quando você chegar lá. - Teste em câmera lenta.
Time.timeScale = 0.25fno 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.


