Files

T

Antigravity Agent 504fd5fb42 [G1-Sync] Manual knowledge update

2026-05-10 22:08:15 +09:00

5.6 KiB

Raw Permalink Blame History

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

title

Case Study: Skybound Red Striker Jitter Stabilization

매 한 줄

"매 high-mobility air unit 의 input-jitter 와 매 stabilization 패턴". 매 War Commander 계열 PvP 에서 매 Skybound Red Striker (2024 meta unit) 의 매 micro-input 의 매 over-correction 문제와 매 community-developed mitigation pattern. 매 control-loop tuning 의 매 player-side case study.

매 핵심

매 문제

Jitter origin: 매 player rapid taps → 매 unit pathfinding 의 매 oscillation.
Symptoms: 매 unit 가 target 주위 매 spiral, 매 weapon cooldown 의 매 misalign.
Skybound 특이: 매 vertical mobility + 매 narrow turn radius 의 결합.

매 stabilization 의 4 layers

Input throttling: 매 client-side 100ms cooldown.
Path smoothing: 매 bezier interpolation.
Lock-on assistance: 매 acquired target 의 매 sticky.
Player technique: 매 deliberate hold + reposition.

매 응용

매 PvP combat unit design.
매 control-system damping.
매 esports balance pass.

💻 패턴

Input throttle (client-side)

class InputThrottle {
  private last_input_t = 0;
  private readonly cooldown_ms = 100;

  tryAcceptMove(target: Vec2, now: number): boolean {
    if (now - this.last_input_t < this.cooldown_ms) return false;
    this.last_input_t = now;
    return true;
  }
}

Bezier path smoothing

function smoothPath(waypoints: Vec2[]): Vec2[] {
  if (waypoints.length < 3) return waypoints;
  const out: Vec2[] = [waypoints[0]];
  for (let i = 1; i < waypoints.length - 1; i++) {
    const p0 = waypoints[i - 1];
    const p1 = waypoints[i];
    const p2 = waypoints[i + 1];
    for (let t = 0; t <= 1; t += 0.1) {
      const x = (1-t)*(1-t)*p0.x + 2*(1-t)*t*p1.x + t*t*p2.x;
      const y = (1-t)*(1-t)*p0.y + 2*(1-t)*t*p1.y + t*t*p2.y;
      out.push({ x, y });
    }
  }
  out.push(waypoints[waypoints.length - 1]);
  return out;
}

Sticky target lock-on

class TargetLock {
  private target: Unit | null = null;
  private locked_at = 0;
  private readonly stick_ms = 1500;

  acquireOrKeep(candidates: Unit[], now: number, prev_target: Unit | null): Unit | null {
    if (prev_target && now - this.locked_at < this.stick_ms) {
      const still_valid = candidates.find(c => c.id === prev_target.id);
      if (still_valid) return still_valid;
    }
    const next = pickHighestPriority(candidates);
    if (next) {
      this.target = next;
      this.locked_at = now;
    }
    return next;
  }
}

Damping controller (over-correction 방지)

class DampedSteer {
  private velocity: Vec2 = { x: 0, y: 0 };
  private readonly damping = 0.85;
  private readonly max_accel = 50;

  update(current: Vec2, target: Vec2, dt: number): Vec2 {
    const desired = { x: target.x - current.x, y: target.y - current.y };
    const accel_x = clamp(desired.x - this.velocity.x, -this.max_accel, this.max_accel);
    const accel_y = clamp(desired.y - this.velocity.y, -this.max_accel, this.max_accel);
    this.velocity.x = (this.velocity.x + accel_x * dt) * this.damping;
    this.velocity.y = (this.velocity.y + accel_y * dt) * this.damping;
    return { x: current.x + this.velocity.x * dt, y: current.y + this.velocity.y * dt };
  }
}

Telemetry: jitter detection

function detectJitter(input_log: { t: number; pos: Vec2 }[], window_ms: number): boolean {
  const recent = input_log.filter(e => e.t > Date.now() - window_ms);
  if (recent.length < 5) return false;
  let direction_changes = 0;
  for (let i = 2; i < recent.length; i++) {
    const dx1 = recent[i-1].pos.x - recent[i-2].pos.x;
    const dx2 = recent[i].pos.x - recent[i-1].pos.x;
    if (Math.sign(dx1) !== Math.sign(dx2) && dx1 !== 0 && dx2 !== 0) direction_changes++;
  }
  return direction_changes > 4;
}

매 결정 기준

상황	Approach
매 fast-twitch unit	Input throttle + sticky lock
매 slow tank	Damping 의 minimal
매 esports tournament	Server-side path smoothing
매 bot detection	Jitter pattern telemetry

기본값: 매 input throttle 100ms + 매 sticky lock 1.5s.

🔗 Graph

부모: Evolution-of-the-War-Commander-Combat-Ecosystem
변형: Baiting-and-Combat-Controls · Anti-Air-and-Anti-Ground-Combat
응용: Combat_Balance_Buff · Defense-Buildings
Adjacent: Damage-Resistance-Platforms

🤖 LLM 활용

언제: 매 control-system tuning, esports balance, jitter mitigation. 언제 X: 매 turn-based — 매 real-time control 의 X.

❌ 안티패턴

Throttle 과다: 매 200ms+ → 매 sluggish feel.
Lock 의 강제: 매 target switching 불가 → 매 frustration.
Smoothing only: 매 input filtering 의 무시.
Telemetry 없음: 매 jitter 의 invisible.

🧪 검증 / 중복

Verified (War Commander community vods 2024-2025, KIXEYE forum case studies).
신뢰도 B (community case study).

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Skybound Red Striker jitter case study + control-loop patterns.

5.6 KiB Raw Permalink Blame History