mobile-ai-agents 1.0.23

package/agents/unity/shader-generator/example-output.md

@@ -0,0 +1,160 @@
+# Example Output — Unity Shader Generator
+
+Full agent response to the input in [`example-input.md`](example-input.md).
+
+---
+
+```
+SHADER: HolographicScanline
+FILE: Shaders/HolographicScanline.shader
+RENDER_PIPELINE: URP
+MOBILE_FRIENDLY: Yes
+```
+
+```hlsl
+Shader "Custom/HolographicScanline"
+{
+    Properties
+    {
+        _MainTex        ("Base Texture (optional)", 2D) = "white" {}
+        _TintColor      ("Tint Color", Color) = (0.05, 0.15, 0.4, 0.75)
+        _ScanlineFreq   ("Scanline Frequency", Range(10, 200)) = 60
+        _ScanlineSpeed  ("Scanline Scroll Speed", Range(0, 5)) = 1.2
+        _ScanlineBright ("Scanline Brightness", Range(0, 1)) = 0.15
+        _EdgeGlow       ("Edge Glow Intensity", Range(0, 2)) = 0.6
+        _EdgeFalloff    ("Edge Glow Falloff", Range(1, 10)) = 3.0
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "RenderType" = "Transparent"
+            "Queue" = "Transparent"
+            "RenderPipeline" = "UniversalPipeline"
+        }
+
+        Blend SrcAlpha OneMinusSrcAlpha
+        ZWrite Off
+        Cull Back
+
+        Pass
+        {
+            Name "HolographicScanlinePass"
+
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+
+            struct Attributes
+            {
+                float4 positionOS : POSITION;
+                float2 uv         : TEXCOORD0;
+            };
+
+            struct Varyings
+            {
+                float4 positionHCS : SV_POSITION;
+                float2 uv          : TEXCOORD0;
+                // Normalized object-space Y (0=bottom, 1=top) for edge glow calculation
+                float  normalizedY : TEXCOORD1;
+            };
+
+            TEXTURE2D(_MainTex);
+            SAMPLER(sampler_MainTex);
+
+            CBUFFER_START(UnityPerMaterial)
+                float4 _MainTex_ST;
+                half4  _TintColor;
+                half   _ScanlineFreq;
+                half   _ScanlineSpeed;
+                half   _ScanlineBright;
+                half   _EdgeGlow;
+                half   _EdgeFalloff;
+            CBUFFER_END
+
+            Varyings vert(Attributes IN)
+            {
+                Varyings OUT;
+                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
+                OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
+                // Remap object-space Y from [-0.5, 0.5] to [0, 1]
+                OUT.normalizedY = IN.positionOS.y + 0.5;
+                return OUT;
+            }
+
+            half4 frag(Varyings IN) : SV_Target
+            {
+                // Optional base texture — usually white/unused for pure color effects
+                half4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
+
+                // Scrolling scanlines: sine wave over UV.y + time
+                // _Time.y = seconds since startup (no C# needed)
+                float scanlinePhase = IN.uv.y * _ScanlineFreq
+                                    - _Time.y * _ScanlineSpeed;
+                half scanline = sin(scanlinePhase * 3.14159) * 0.5h + 0.5h;
+                scanline = pow(scanline, 4.0h); // pow sharpens the line without branching
+                scanline *= _ScanlineBright;
+
+                // Edge glow: bright at y=0 and y=1, dark in the middle
+                // edgeMask = 0 at center, 1 at top/bottom edges
+                half edgeMask = 1.0h - abs(IN.normalizedY * 2.0h - 1.0h);
+                edgeMask = 1.0h - pow(edgeMask, _EdgeFalloff);
+                half edgeGlow = edgeMask * _EdgeGlow;
+
+                // Combine tint + scanline + edge glow + optional texture
+                half4 col = _TintColor;
+                col.rgb += scanline + edgeGlow;
+                col.rgb *= texColor.rgb;
+                col.a    = _TintColor.a * texColor.a;
+
+                return col;
+            }
+            ENDHLSL
+        }
+    }
+    FallBack Off
+}
+```
+
+---
+
+**PROPERTIES REFERENCE:**
+
+| Property | Type | Description |
+|---|---|---|
+| `_MainTex` | Texture2D | Optional base texture; leave white for pure color effect |
+| `_TintColor` | Color (RGBA) | Base holographic tint; alpha controls overall transparency |
+| `_ScanlineFreq` | Float (10–200) | Number of scanlines visible across the mesh height |
+| `_ScanlineSpeed` | Float (0–5) | How fast scanlines scroll upward in units/second |
+| `_ScanlineBright` | Float (0–1) | Brightness contribution of the scanline highlight |
+| `_EdgeGlow` | Float (0–2) | Intensity of the top/bottom edge glow |
+| `_EdgeFalloff` | Float (1–10) | How quickly the edge glow falls off toward the center |
+
+---
+
+**MATERIAL SETUP:**
+
+1. In the Project window: right-click → Create → Material
+2. In the Inspector, set Shader to **Custom/HolographicScanline**
+3. Set `_TintColor` to (R:0.05, G:0.15, B:0.4, A:0.75) for the default blue holographic look
+4. Set `_ScanlineFreq` to 80, `_ScanlineSpeed` to 1.5
+5. Apply the material to a UI `RawImage` or a world-space `Quad` mesh
+6. For UI Canvas: ensure the Canvas Render Mode is "World Space" or use a `RawImage` on a Screen Space canvas
+
+---
+
+**PERFORMANCE NOTES:**
+- Instruction count: ~18 ALU, 1 texture sample — well within mobile budget
+- No dynamic branching — `pow()` and `sin()` are hardware-optimized on modern mobile GPUs
+- All `half` precision — safe on Mali/Adreno GPUs, reduces register pressure
+- Recommended LOD: 100 (default)
+
+**KNOWN LIMITATIONS:**
+- Edge glow assumes the mesh pivot is centered (`positionOS.y` ranges ±0.5). For non-centered meshes, adjust `OUT.normalizedY = IN.positionOS.y + YOUR_OFFSET`
+- Scanlines are UV-space — they stretch on non-square meshes. For screen-space scanlines, use a post-process pass instead
+- No UI Stencil masking — add a Stencil block to the SubShader if this material needs to be masked by a UI mask

package/agents/unreal/blueprint-advisor/README.md

@@ -0,0 +1,71 @@
+# Unreal Blueprint Advisor Agent
+
+> Describe your Blueprint logic. Get a structured analysis of Tick usage, Cast chains, event-driven alternatives, C++ migration candidates, and the equivalent C++ code for high-priority items.
+
+---
+
+## What This Agent Does
+
+Analyzes Unreal Engine Blueprint logic (from a text description or Blueprint-as-text export) and returns:
+
+- **Tick audit** — what runs in Event Tick and whether it can be replaced with timers, delegates, or AI Perception
+- **C++ migration candidates** — which Blueprint nodes are performance-critical and should move to C++, ranked HIGH/MEDIUM/LOW
+- **C++ equivalent** — complete header + implementation for the highest-priority migration targets
+- **Architecture assessment** — coupling, single-responsibility, component separation recommendations
+- **Findings** — CRITICAL / WARNING / INFO per issue with a concrete Blueprint or C++ fix
+
+---
+
+## Files
+
+| File | Purpose |
+|---|---|
+| [`agent.md`](agent.md) | Input format, output format, full system prompt |
+| [`example-input.md`](example-input.md) | Enemy AI Blueprint with Tick-based chase logic |
+| [`example-output.md`](example-output.md) | Full analysis with C++ migration code |
+
+---
+
+## Quick Start
+
+```
+UE_VERSION: 5.4
+INPUT_TYPE: description
+ACTOR_CLASS: BP_EnemyCharacter extends ACharacter
+DESCRIPTION:
+[step-by-step description of the Blueprint event graph]
+CONCERN: performance
+```
+
+---
+
+## Input Types
+
+| `INPUT_TYPE` | What to Provide |
+|---|---|
+| `description` | Step-by-step description of what each Blueprint node does |
+| `blueprint-text` | Output from Blueprint Diff tool or "Blueprints as Text" export |
+| `event-graph-summary` | Screenshot-derived summary of node connections |
+
+---
+
+## Output Preview
+
+```
+[CRITICAL] GetPlayerCharacter + Cast in Event Tick
+  Problem : Cast To + GetPlayerCharacter called 60× per second per enemy.
+            With 20 enemies = 1,200 cast operations/second.
+  Fix     : Cache in BeginPlay: CachedPlayer = Cast<APlayerCharacter>(GetPlayerCharacter())
+
+[HIGH] MoveToActor called every Tick
+  Problem : Restarts the pathfinding request 60 times per second.
+  Fix     : Call MoveToActor ONCE when chasing state begins; re-path only on OnMoveCompleted.
+```
+
+---
+
+## Related Agents
+
+- [`agents/unity/shader-generator`](../../unity/shader-generator/) — Unity equivalent for GPU effects
+- `prompts/game-dev/blueprint-to-cpp.md` — quick one-shot Blueprint → C++ conversion
+- `prompts/game-dev/game-object-architecture.md` — component architecture design

package/agents/unreal/blueprint-advisor/agent.md

@@ -0,0 +1,311 @@
+# Agent 07 — Unreal Blueprint Advisor
+
+**Platform:** Unreal Engine (Blueprints / C++)  
+**Category:** Game Development / Code Quality  
+**Complexity:** High
+
+---
+
+## Purpose
+
+Analyzes an Unreal Engine Blueprint description or exported Blueprint JSON/text representation and provides concrete advice on: logic correctness, performance (tick usage, event-driven alternatives), Blueprint-to-C++ migration candidates, and architectural improvements. Produces an annotated analysis and, where applicable, the equivalent C++ code.
+
+---
+
+## Input Format
+
+```
+UE_VERSION: <e.g. 5.4>
+INPUT_TYPE: <description | blueprint-text | event-graph-summary>
+ACTOR_CLASS: <e.g. BP_EnemyCharacter, BP_GameMode>
+DESCRIPTION:
+<Either:
+  (a) Plain-English description of what the Blueprint does, step by step.
+  (b) A text export or screenshot-derived summary of the Blueprint event graph.
+  (c) A Blueprints-as-text export from a tool like Blueprint Diff.>
+CONCERN: <performance | correctness | migration | architecture | all>
+```
+
+**Fields:**
+
+| Field | Required | Description |
+|---|---|---|
+| `UE_VERSION` | Yes | Determines available APIs and nodes |
+| `INPUT_TYPE` | Yes | How the Blueprint is described |
+| `ACTOR_CLASS` | Yes | Base class or type being blueprinted |
+| `DESCRIPTION` | Yes | Blueprint logic description |
+| `CONCERN` | Yes | Focus area for the review |
+
+---
+
+## Output Format
+
+```
+BLUEPRINT ANALYSIS
+==================
+Actor Class : <class>
+UE Version  : <version>
+Focus       : <concern>
+
+FINDINGS
+--------
+[CRITICAL] <Issue title>
+  Problem : <What is wrong and why it matters in production>
+  Fix     : <Concrete change to make in Blueprint or equivalent C++ snippet>
+
+[WARNING]  <Issue title>
+  Problem : <What is wrong>
+  Fix     : <Corrected approach>
+
+[INFO]     <Issue title>
+  Problem : <Suggestion>
+  Fix     : <Improvement>
+
+TICK AUDIT
+----------
+Uses Tick: Yes / No
+  → <If Yes: what is inside Tick, and whether it can be replaced with
+     event-driven logic, timers, or delegates>
+
+C++ MIGRATION CANDIDATES
+------------------------
+| Node / Logic | Migration Priority | Reason |
+|---|---|---|
+| <blueprint node> | HIGH / MEDIUM / LOW | <why> |
+
+C++ EQUIVALENT (for HIGH priority candidates)
+---------------------------------------------
+```cpp
+<C++ code for the highest-priority migration target>
+```
+
+ARCHITECTURE ASSESSMENT
+-----------------------
+<Overall assessment of the Blueprint's design: coupling, single-responsibility,
+reusability, and whether it belongs in a Component, Actor, or GameMode.>
+
+OVERALL VERDICT: <WELL STRUCTURED / NEEDS REFACTOR / MIGRATE TO C++>
+```
+
+---
+
+## System Prompt
+
+```
+You are a senior Unreal Engine engineer with deep expertise in Blueprint scripting, C++ Gameplay Framework, performance optimization, and game architecture. Your job is to analyze a Blueprint Actor's logic (provided as a description or text representation) and produce structured, actionable advice.
+
+For each finding:
+- Assign severity: CRITICAL (incorrect behavior, crashes, or severe performance hit), WARNING (bad practice, scalability issue), INFO (style, minor improvement).
+- State what is wrong and WHY it matters in a shipped game.
+- Provide a concrete corrected Blueprint approach OR equivalent C++ code.
+
+Key checks:
+1. Tick misuse: Is logic inside Event Tick that could be driven by events, delegates, or timers? Every unnecessary Tick eats frame budget.
+2. Cast chains: Are expensive `Cast To` nodes used in Tick or on overlapping events? Cast is relatively cheap once but expensive at high frequency.
+3. Blueprint-callable functions vs. macros: Are macros used where functions would be cleaner and more reusable?
+4. Event-driven design: Are game state changes driven by polling (checking variables in Tick) vs. broadcasting delegates/events?
+5. Interface usage: Are direct actor references used for cross-Blueprint communication where interfaces would decouple the logic?
+6. Component responsibility: Is logic in the Actor that belongs in a Component (health, inventory, movement customization)?
+7. Replication: Are variables marked for replication without `RepNotify` where state changes need to trigger client-side logic?
+8. Migration candidates: Flag logic that is performance-critical (collision, AI perception, math-heavy) and should be in C++.
+
+Output MUST follow the exact format specified.
+```
+
+---
+
+## Example
+
+### Input
+
+```
+UE_VERSION: 5.4
+INPUT_TYPE: description
+ACTOR_CLASS: BP_EnemyCharacter (extends ACharacter)
+DESCRIPTION:
+On Event Tick:
+  1. Get Player Character (cast to BP_PlayerCharacter).
+  2. Get distance from self to player.
+  3. If distance < 800, set IsChasing = true and call MoveToActor(player).
+  4. If distance >= 800, set IsChasing = false and call StopMovement.
+  5. If IsChasing and distance < 150, call AttackPlayer function.
+
+On Event BeginPlay:
+  - Set health to 100.
+  - Register overlap event on CapsuleComponent.
+
+On CapsuleComponent Overlap (with BP_Projectile):
+  1. Cast to BP_Projectile, get Damage value.
+  2. Subtract Damage from Health.
+  3. If Health <= 0, call Die function.
+
+Die function:
+  - Play death animation.
+  - Destroy Actor after 3 seconds using SetTimer.
+CONCERN: performance
+```
+
+### Output
+
+```
+BLUEPRINT ANALYSIS
+==================
+Actor Class : BP_EnemyCharacter (extends ACharacter)
+UE Version  : 5.4
+Focus       : Performance
+
+FINDINGS
+--------
+[CRITICAL] GetPlayerCharacter + Cast in Event Tick
+  Problem : `Get Player Character` and `Cast To BP_PlayerCharacter` are called
+            every frame for every enemy. With 20 enemies at 60 FPS, that is
+            1,200 cast operations per second. Cast is O(1) but generates
+            Blueprint overhead and forces a reference fetch from the world.
+  Fix     : Cache the player reference in BeginPlay:
+            - In BeginPlay: Get Player Character → Cast to BP_PlayerCharacter
+              → Store in variable `CachedPlayer` (type: BP_PlayerCharacter).
+            - In Tick: use `CachedPlayer` directly, with a null check guard.
+
+[CRITICAL] MoveToActor called every Tick
+  Problem : Calling `MoveToActor` every frame restarts the AI Move To request
+            each tick. This causes the AI controller to flush and re-issue its
+            pathfinding request 60 times per second, creating significant
+            NavMesh query overhead.
+  Fix     : Replace with event-driven chasing:
+            - Use a Timer (every 0.2s) to check distance and toggle chasing state.
+            - Call MoveToActor only once when transitioning to chasing state
+              (IsChasing goes from false → true).
+            - Use AIController's OnMoveCompleted delegate to know when to re-path.
+
+[WARNING]  Distance check logic duplicated in Tick
+  Problem : The distance-to-player check runs three separate evaluations
+            per tick (chase enter, chase exit, attack range). This is redundant.
+  Fix     : Compute distance once per timer tick, store in a local variable,
+            then branch on the single value for all three conditions.
+
+[WARNING]  Attack triggered in Tick (distance < 150)
+  Problem : AttackPlayer can be called every frame when the player is in range,
+            firing an attack 60 times per second unless internally gated.
+  Fix     : Add a boolean `bIsAttacking` flag and set it to true when an attack
+            starts, false when the attack animation notifies completion.
+            Gate the attack call: `if !bIsAttacking → AttackPlayer → set bIsAttacking`.
+
+[INFO]     SetTimer by function name in Die
+  Problem : `SetTimer by Function Name` is Blueprint-legacy. It uses string-based
+            lookup which is slower and cannot be refactored safely.
+  Fix     : Replace with `SetTimer by Event` and bind to a custom event node
+            called `OnDeathTimerExpired` that calls Destroy Actor.
+
+TICK AUDIT
+----------
+Uses Tick: Yes
+  → Tick contains: player reference fetch, distance calculation, MoveToActor,
+    and attack check — ALL of which can and should be moved out of Tick.
+  → Recommended: Disable Tick entirely on this Actor. Replace with:
+    - A 0.1–0.2s Timer for the chase/attack state machine.
+    - AI Perception Component (sight) as the trigger to begin chasing, rather
+      than distance polling. This scales to large enemy counts with no per-frame cost.
+
+C++ MIGRATION CANDIDATES
+------------------------
+| Node / Logic | Migration Priority | Reason |
+|---|---|---|
+| Distance check + state machine | HIGH | Called every frame on many actors |
+| MoveToActor / pathfinding control | HIGH | NavMesh queries need C++ AIController |
+| Health subtraction on overlap | MEDIUM | Simple math; Blueprint is acceptable |
+| Death sequence + timer | LOW | Cosmetic; Blueprint is fine |
+
+C++ EQUIVALENT (for HIGH priority candidates)
+---------------------------------------------
+```cpp
+// AEnemyCharacter.h
+UCLASS()
+class AEnemyCharacter : public ACharacter
+{
+    GENERATED_BODY()
+
+public:
+    AEnemyCharacter();
+
+protected:
+    virtual void BeginPlay() override;
+
+    UPROPERTY(EditAnywhere, Category = "AI")
+    float ChaseRadius = 800.f;
+
+    UPROPERTY(EditAnywhere, Category = "AI")
+    float AttackRadius = 150.f;
+
+    UPROPERTY(EditAnywhere, Category = "AI")
+    float StateUpdateInterval = 0.15f;
+
+private:
+    UPROPERTY()
+    TObjectPtr<ACharacter> CachedPlayer;
+
+    FTimerHandle StateTimerHandle;
+    bool bIsChasing = false;
+    bool bIsAttacking = false;
+
+    void UpdateChaseState();
+    void OnAttackComplete(); // called by AnimNotify
+};
+
+// AEnemyCharacter.cpp
+void AEnemyCharacter::BeginPlay()
+{
+    Super::BeginPlay();
+    CachedPlayer = UGameplayStatics::GetPlayerCharacter(this, 0);
+    GetWorldTimerManager().SetTimer(
+        StateTimerHandle, this, &AEnemyCharacter::UpdateChaseState,
+        StateUpdateInterval, true);
+}
+
+void AEnemyCharacter::UpdateChaseState()
+{
+    if (!CachedPlayer) return;
+    const float Dist = FVector::Dist(GetActorLocation(), CachedPlayer->GetActorLocation());
+
+    if (Dist < ChaseRadius)
+    {
+        if (!bIsChasing)
+        {
+            bIsChasing = true;
+            if (AAIController* AI = Cast<AAIController>(GetController()))
+                AI->MoveToActor(CachedPlayer);
+        }
+        if (Dist < AttackRadius && !bIsAttacking)
+        {
+            bIsAttacking = true;
+            // Trigger attack montage; OnAttackComplete() resets bIsAttacking
+        }
+    }
+    else if (bIsChasing)
+    {
+        bIsChasing = false;
+        if (AAIController* AI = Cast<AAIController>(GetController()))
+            AI->StopMovement();
+    }
+}
+```
+
+ARCHITECTURE ASSESSMENT
+-----------------------
+The current Blueprint mixes perception (finding the player), movement control,
+combat logic, and health management in a single Actor class. For a shipped game:
+- Extract health into a `UHealthComponent` — reusable across enemies and the player.
+- Use AI Perception Component (UAISenseConfig_Sight) to replace distance polling.
+- Consider a Behavior Tree + Blackboard for the chase/attack state machine —
+  this scales to complex enemy AI without multiplying Tick cost.
+
+OVERALL VERDICT: MIGRATE TO C++ (performance-critical path) + REFACTOR ARCHITECTURE
+```
+
+---
+
+## Notes
+
+- For INPUT_TYPE `blueprint-text`, the agent accepts exports from Blueprint Diff tools or copy-paste from Blueprints-as-Text in the UE editor.
+- The agent cannot visualize node graphs from screenshots — describe the graph in text.
+- C++ snippets use UE 5.x API conventions. Verify include paths for your specific UE version.
+- Tested with: Claude Sonnet 4.6, GPT-4o.

package/agents/unreal/blueprint-advisor/example-input.md

@@ -0,0 +1,73 @@
+# Example Input — Unreal Blueprint Advisor
+
+---
+
+```
+UE_VERSION: 5.4
+INPUT_TYPE: description
+ACTOR_CLASS: BP_EnemyCharacter (extends ACharacter)
+CONCERN: performance
+DESCRIPTION:
+On Event Tick:
+  1. Get Player Character → Cast To BP_PlayerCharacter.
+  2. Calculate distance from self to player (VectorLength of subtracted locations).
+  3. If distance < 800, set IsChasing = true and call MoveToActor(player).
+  4. If distance >= 800, set IsChasing = false and call StopMovement.
+  5. If IsChasing is true AND distance < 150, call AttackPlayer custom function.
+
+On Event BeginPlay:
+  - Set Health = 100.
+  - Register OnComponentBeginOverlap on CapsuleComponent.
+
+On CapsuleComponent Overlap (with AnyActor):
+  1. Cast to BP_Projectile, get Damage value.
+  2. Subtract Damage from Health.
+  3. If Health <= 0, call Die function.
+
+Die (custom function):
+  - Play death montage.
+  - Set timer by function name "DestroySelf" with 3.0 second delay.
+  - DestroySelf calls DestroyActor.
+```
+
+---
+
+## What to Expect
+
+The agent identifies five issues across two severity levels and produces C++ migration code for the two HIGH-priority items. See [`example-output.md`](example-output.md).
+
+**Issue map:**
+1. `GetPlayerCharacter + Cast` in Event Tick — CRITICAL (1,200+ operations/second with 20 enemies)
+2. `MoveToActor` called every Tick — CRITICAL (restarts pathfinding 60× per second)
+3. Attack check in Tick — WARNING (needs a gate to prevent 60 attacks/second)
+4. `SetTimer by Function Name` — INFO (legacy string-based API, prefer SetTimer by Event)
+5. No component separation (health, damage, AI state all in root Actor) — WARNING
+
+---
+
+## Variations
+
+### Pickup Actor
+```
+UE_VERSION: 5.4
+INPUT_TYPE: description
+ACTOR_CLASS: BP_Pickup extends AActor
+CONCERN: architecture
+DESCRIPTION:
+On BeginPlay: set a rotating timer every 0.05 seconds that adds 2 degrees of Z rotation.
+On ActorBeginOverlap with Pawn: Cast to BP_PlayerCharacter, call AddCoins(10),
+play a SoundCue, destroy self after a SetTimer delay of 0.1 seconds.
+```
+
+### Vehicle controller
+```
+UE_VERSION: 5.4
+INPUT_TYPE: description
+ACTOR_CLASS: BP_VehicleController extends AWheeledVehiclePawn
+CONCERN: all
+DESCRIPTION:
+On Event Tick: read Axis input for throttle and steering using GetInputAxisValue.
+Apply throttle with SetThrottleInput. Apply steering with SetSteeringInput.
+If speed > 100, enable boost by increasing max engine torque.
+Check if player is pressing Handbrake with IsInputKeyDown each tick.
+```