Next-Gen Game Automation Architecture

Next-Generation E2E Automation
for Unreal Engine 5

Write fast, auto-retrying, multi-client game tests in TypeScript powered by Playwright and native Unreal Engine telemetry.

Book a Technical Demo Explore Docs

specter-trace-viewer // ue5-editor-session

Platform Capabilities Overview

Built for Modern AAA QA Engineering

Specter replaces brittle C++ Gauntlet scripts with type-safe TypeScript and native Unreal Engine telemetry.

Playwright-Native Syntax

Engine-aware auto-retrying matchers like expect(actor).toHavePropertyValue('Health', 0) that eliminate flaky setTimeout sleeps.

GAS & Gameplay Systems

Direct C++ subsystem hooks to trigger Gameplay Abilities, inspect tags (toHaveGameplayTag), check effects, and evaluate AI behavior trees.

Network Lag Emulation

Simulate real-world network conditions directly from code using setEmulatedLatency(150) and setPacketLoss(5).

Procedural Input Engine

Stream 60 FPS analog thumbstick vectors (injectAxis), joystick circles, sweeps, and fighting game combos with microsecond precision.

Multi-Client Testing

Orchestrate a Dedicated Server alongside an arbitrary number of game clients (client1, client2, client3...) simultaneously inside a single Playwright test script.

3D Visual Telemetry

Render 3D cyan bounding boxes and state labels (actor.highlight("Phase 2")) directly inside your level viewport during live test execution.

Flagship Unreal Editor Plugin

In-Engine Trace Viewer & Test Explorer

No context switching. Specter parses your Playwright suite directly inside an Unreal Editor Utility Widget with real-time test execution controls and live step telemetry.

Native Test Tree Explorer

Parses Playwright test files directly into an in-editor TreeView with live pass/fail/running status badges and instant rerun triggers.

One-Click VS Code Navigation

Click any failing test node or assertion step inside the Unreal Editor to jump directly to the exact file and line number in VS Code.

Live Telemetry & Step Streamer

Watch Playwright steps execute frame-by-frame in real-time with green/red status indicators and live console log streaming inside PIE.

Tracked Variable Timeline

Inspect historical property changes, GAS attribute fluctuations, and gameplay tag updates on a visual, frame-accurate timeline.

Engine-Aware Matchers

Playwright-Native API & Engine-Aware Assertions

Games are asynchronous environments. Specter introduces engine-aware auto-retrying assertions that listen to state events and eliminate brittle manual delays.

Auto-Retrying Matchers

expect(actor).toHavePropertyValue('Health', 0) and expect(actor).toBeVisible() poll/listen to engine ticks until conditions pass.

Playwright HTML Reports & Trace Viewer

Captures automated viewport screenshots, console logs, and action timelines directly into standard Playwright HTML test reports.

health-assertion.spec.ts

AUTO-RETRYING

import { test, expect } from '@specter/test';

test('Boss health drops on impact', async ({ world }) => {
  const boss = world.actor('BP_Boss_C');

  // Triggers damage event
  await world.actor('BP_Player').pressKey('SpaceBar');

  // Engine-Aware Assertion: Auto-retries until condition is met
  await expect(boss).toHavePropertyValue('Health', 0, {
    operator: '<=',
    timeout: 5000
  });

  // Asserts UMG visibility
  await expect(world.widget('WBP_VictoryScreen')).toBeVisible();
});

High-Precision Targeting

Smart Selectors & Query Pipeline

Locate 3D Actors and UMG Widgets effortlessly across complex levels using class names, tags, components, and spatial proximity.

Smart Selector Strategies

world.actor('BP_Enemy_C')Locates actors by Blueprint or C++ class basename.
world.actor('Tag:Enemy.Boss')Queries actors by Gameplay Tags or native Unreal Tags.
.getByComponent('AbilitySystem')Narrows down locators by attached UActorComponent types.
.withinRadius(1000, origin)Filters matching targets by 3D spatial distance.

Fluent Chaining & Indexing

.first() / .last() / .nth(i)Selects specific zero-indexed instances from queried sets.
.all()Resolves matching query sets to an array of locators for for...of loop iteration.
.or() / .and()Combines multiple locator queries into logical union or intersection sets.

High-Resolution Controller Input

Analog Input & Procedural Sequence Engine

Bypass coarse digital keystrokes. Specter lets you stream 60 FPS analog thumbstick vectors, 2D/3D Action Vectors, and parametric mathematical curves directly to Unreal Engine 5's Enhanced Input Actions (UInputAction / IA_Move) and native input subsystems.

✓

UE5 Enhanced Input & Parametric Curves: Stream 2D/3D Action Vectors (IA_Move) or custom parametric mathematical curves (addParametricCurve) with frame-accurate timing.

✓

Procedural Timelines & Combos: Use SpecterInputSequence to generate 60 FPS joystick circles (addAxisCircle), parametric sweeps, and fighting game combos.

✓

Key Holding & Analog Triggers: Fine-grained control with down(), up(), duration-based pressKey('E', 2000), and analog trigger sweeps.

parametric-curves.spec.ts60 FPS TIMELINE

import { test, expect, SpecterInputSequence } from '@specter/test';

test('Simultaneous parametric movement curves on 3 clients', async ({ world, client2, client3 }) => {
  const p1 = world.actor(GameAssets.Characters.Marshmallow).isLocallyControlled();
  const p2 = client2.actor(GameAssets.Characters.Marshmallow).isLocallyControlled();
  const p3 = client3.actor(GameAssets.Characters.Marshmallow).isLocallyControlled();

  // Pattern 1: True Dual-Loop Figure-Eight
  const fig8Seq = new SpecterInputSequence().addParametricCurve((progress) => {
    const currentProgress = (progress * 2) % 1.0;
    const theta = (currentProgress / 0.5) * Math.PI * 2;
    return {
      actions: {
        IA_Move: {
          x: currentProgress < 0.5 ? Math.sin(theta) : -Math.sin(theta),
          y: Math.cos(theta)
        }
      }
    };
  }, 0, 4000, 30);

  // Pattern 2: Smooth Zig-Zag Wave
  const zigZagSeq = new SpecterInputSequence().addParametricCurve((progress) => {
    const currentProgress = (progress * 2) % 1.0;
    return {
      actions: {
        IA_Move: {
          x: Math.cos(currentProgress * Math.PI * 16) * 1.25,
          y: Math.sin(currentProgress * Math.PI * 2)
        }
      }
    };
  }, 0, 4000, 30);

  // Pattern 3: Straight Back and Forth
  const backAndForthSeq = new SpecterInputSequence().addParametricCurve((progress) => {
    const currentProgress = (progress * 2) % 1.0;
    return { actions: { IA_Move: { x: 0.0, y: Math.sin(currentProgress * Math.PI * 2) } } };
  }, 0, 4000, 30);

  // Play all 3 sequences SIMULTANEOUSLY across 3 clients
  await Promise.all([
    p1.playSequence(fig8Seq),
    p2.playSequence(zigZagSeq),
    p3.playSequence(backAndForthSeq)
  ]);
});

Deep Engine Subsystem Hooks

Gameplay Systems & GAS Integration

Built specifically for Unreal Engine. Specter integrates directly into GAS, AI Behavior Trees, and Animation Skeleton Montages out of the box.

GAS

Gameplay Ability System

Trigger abilities directly by Gameplay Tag (triggerAbilityByTag), inspect active tags (toHaveGameplayTag), check Gameplay Effects, and assert attribute sets.

AI & Behavior Trees

Inspect AI Controllers, assert Blackboard values (toHaveBlackboardValue), evaluate StateTrees, and verify line-of-sight checks (hasLineOfSightTo).

ANIM

Skeleton & Montages

Verify AnimMontage playback states (isPlayingMontage), active animation sections, and listen for AnimNotifies during combat execution.

gas-ability.spec.tsGAS NATIVE

import { test, expect } from '@specter/test';

test('Hero casts ultimate and triggers AI flee state', async ({ world }) => {
  const hero = world.actor('BP_Hero_Steel');
  const enemyAI = world.actor('BP_Enemy_AI');

  // Trigger GAS Ability by Gameplay Tag
  await hero.triggerAbilityByTag('Ability.Hero.Ultimate');

  // Assert Gameplay Tag presence & Blackboard state
  await expect(hero).toHaveGameplayTag('State.Casting');
  await expect(enemyAI).toHaveBlackboardValue('BehaviorState', 'Flee');

  // Assert AnimMontage playback section
  await expect(hero).isPlayingMontage('AM_Steel_Slam', { section: 'Impact' });
});

Multi-Client & Server Testing

Multiplayer & Network Emulation

Test Dedicated Servers and multiple client viewports simultaneously inside a single Playwright script. Specter makes multiplayer replication testing painless.

✓

Multi-Client Orchestration: Use createWorld({ launchClient: true }) to spin up and control multiple client viewports on distinct ports.

✓

Network Condition Emulation: Simulate real-world network lag directly from code with setEmulatedLatency(150) and setPacketLoss(5).

multiplayer-replication.spec.tsMULTI-CLIENT

test('Replication under lag', async ({ world, client1, client2 }) => {
  // Simulate 150ms ping & 5% packet loss on Client 1
  await client1.network.setEmulatedLatency(150);
  await client1.network.setPacketLoss(5);

  // Client 1 (Steel) attacks Client 2 (Enemy)
  await client1.actor('BP_Hero_Steel').pressKey('Q');

  // Server authority verification and client replication on enemy
  await expect(client2.actor('BP_Hero_Enemy')).toHavePropertyValue('Health', 80);
  await expect(world.actor('BP_Hero_Enemy')).toHavePropertyValue('Health', 80);
});

In-Viewport Debugging

3D Visual Telemetry & Assertion Overlays

Never guess what an actor is doing in PIE. Calling actor.highlight("Phase 2") renders 3D cyan bounding boxes, state labels, and visual assertion overlays directly inside your level viewport during live test execution.

Ready to Automate Your UE5 Suite?

Book a 1-on-1 technical walkthrough or inquire about our 30-Day Studio Proof of Concept ($2,500).

Book a Technical Demo Explore Documentation

Next-Generation E2E Automation for Unreal Engine 5