VATS: Visual Assisted Targeting System
Status: initial research, 2026-11-14, with the owner’s play design added the same day; nothing built. A mod idea from the owner: during combat, scan an enemy, zoom in with another button, and pick one of its body parts to target: head, torso, left arm, right arm, left leg, right leg. This page covers the first part, body part targeting: can REDengine highlight the parts itself, or does REDnode draw them over the game? It lives in REDnode’s docs while the parts it needs are REDnode’s; the mod may get its own repository later.
Sources: the 2.5 game API dump (gameapi/2.5/rtti.json), the game’s files read through REDbridge, and a decompile of the game’s scripts from an earlier version (2.5 may differ). Everything below is unverified in the game unless it says otherwise.
The short answer
Both, split by job. The engine knows exactly where each body part is and can aim at it, zoom the camera and slow time. It has no built-in way to outline one limb, because a body is one mesh. So the first build has REDnode draw the six parts over the game, placed by the plugin each frame as world pins are. A spike tries to draw parts in the engine’s own picture instead, with small glowing shapes attached to the bones.
How VATS plays
The owner’s design, 2026-11-14.
| Step | What happens |
|---|---|
| Scanning | The game’s scanner works as it does today |
| Enter VATS | While scanning, the VATS button: the camera zooms onto the scanned enemy, time slows far more than the scanner’s own slow motion, and the body part targeting and highlights take over |
| In VATS | The player picks an enemy (the camera moves easily from one enemy to another) and a body part, then attacks it with quickhacks or a smart gun. The quickhack wheel is the game’s own; in VATS only the VATS quickhacks (made with EDGEhack) are enabled |
| Body part quickhacks | The owner, 2026-11-14: a VATS quickhack is sent to one of the six parts, and each part can take one separately. They can be started only in VATS, but an upload goes on after VATS ends, in real time, and its effect lands on that part as usual |
| Leave VATS | The VATS button again, with the scanner button still held: back to normal scanning |
| Cancel | Letting go of the scanner cancels VATS too. VATS also has a timed duration: when it runs out, VATS ends, back to scanning, or out of scanning if the scanner is no longer held |
On a controller
The owner’s addition, 2026-11-14. The game’s scanner already zooms, but only while the quickhack wheel is not showing; that zoom stays as it is for surveillance. VATS takes the triggers while the scanner is held:
| Input, while scanning | What happens |
|---|---|
| Right trigger | Enter VATS, with its own zoom: the view frames the enemy so their whole body is large and centred on screen |
| Left trigger | Leave VATS entirely: the camera goes back to the setting it had before |
The framing keeps the view on V’s own line of sight, so what the player sees is what V’s rays see (exposure and the crosshair’s part stay true). Recommended: keep the camera where it is, turn the view onto the enemy and narrow the field of view until the body fills about 80 % of the screen’s height (field of view = 2 x atan(body height / (2 x 0.8 x distance)); a 1.8 m body 15 m away needs about 8.6 degrees). Moving the camera nearer the enemy would show what V cannot see. To agree with the owner.
As states:
| State | VATS button | Scanner released | Timer runs out |
|---|---|---|---|
| Not scanning | Nothing | ||
| Scanning | Enter VATS | Not scanning | |
| VATS | Back to scanning (scanner still held) | Not scanning (VATS ends with it) | Scanning if the scanner is held, else not scanning |
What each part of it needs
| Part | Engine side | Notes and unknowns |
|---|---|---|
| Knowing the scanner is up | The player’s vision mode (PlayerVisionModeController, the scanner’s blackboard UI_Scanner, gameVisionModeSystem) |
Which signal tells “scanner held” most reliably is unverified |
| The VATS button | The mod’s own redscript input listener, until REDnode’s I3 Input | One button enters and leaves; the scanner button is the game’s own |
| Zoom onto the enemy | The player’s camera: SetFOV/SetZoom (spike V3) |
Turning the view onto the enemy, and on to the next one, is the targeting system’s LookAt or the camera itself (unverified). “Moves easily between enemies” suggests snapping to the next enemy with a key or stick, not free aiming |
| Deeper slow motion | TimeSystem.SetTimeDilation (the world) with SetIgnoreTimeDilationOnLocalPlayerZero or SetTimeDilationOnLocalPlayerZero for V; per object SetIndividualTimeDilation |
The scanner’s own slow motion was never found in the global dilation (REDnode’s sound spike), so how VATS’s dilation stacks with it is unverified. The Sandevistan sets the world’s to 0.3 and leaves V at 1: VATS could go much lower, such as 0.05 (to try) |
| Only VATS quickhacks in VATS | The game’s own wheel. Its list is built by TranslateChoicesIntoQuickSlotCommands, which EDGEhack’s scripts can wrap to mark every other quickhack unusable while VATS is on (decided with the owner, 2026-11-14: no wheel of its own, and EDGEhack’s scripts handle it). The VATS quickhacks are usable only in VATS |
REDnode needs nothing new. REDnode’s quickhack functions (Quickhack functions, #42) wrap the same function, and redscript chains wraps, so both run (unverified together). A REDnode package’s own VATS hacks could also use quickhacks.define’s canUse and disabledText (“VATS only”) |
| A quickhack on a body part | A quickhack lands on the whole target. The part is VATS’s own choice: VATS records target, hack and part when the upload starts, and the hack’s effect reads it when it lands (onLand in quickhacks.define knows the target and the hack, not the part). The record must outlive VATS, since the upload goes on in real time after it |
Uploads to several parts of one enemy at once: the game greys out a hack already uploading on a target, and allows one upload at a time unless a perk queues them, so separate parts may need one hack record per part (Arm Short Circuit, Leg Short Circuit) or the queue (spike V11, unverified) |
| The upload icon on its part | The owner, 2026-11-14: each part’s upload shows at that part, on its slot (the hidden shape), not above the head. Two ways: the game’s own bar: UploadProgramProgressEvent (the event that starts an upload’s progress bar) carries a slotName beside its duration, icon and stat pool, so the game may place the bar on a named slot of the target. If so, VATS sets it to the part’s slot (LeftArm). REDnode’s own icon: a world pin on the part’s slot, its progress read from the target’s QuickHackUpload stat pool |
That the game’s bar follows slotName is a lead from the type data only (spike V12, unverified). REDnode’s way works today at a few updates a second from the mod; after VATS, in real time on a moving enemy, a pin that follows a slot in the plugin (as WP2’s pins follow an entity) would keep up every frame: a small REDnode addition |
| The smart gun on a body part | Smart gun targets already carry a bone: gamesmartGunUITargetParameters.attachedBoneName, with lock events (gamesmartGunSmartGunLockEvent) and target sorting in TweakDB (SmartGunTargetSortData records) |
Steering its lock to the chosen part’s bone is unverified (spike V6) |
| The duration | A timer that ends VATS | On which clock: in a slowed world, a real-time timer feels right for a player’s budget, while game time would stretch it. REDnode’s proposed game-time timers would offer both |
| Ending cleanly | Every change undone: camera zoom, time dilation, the quickhacks switched off, the highlights | Also when the player dies, a scene starts or a menu opens during VATS |
What the engine already has
Every NPC has body part shapes
Shots are not tested against the visible mesh. They hit hit shapes: capsules, spheres and boxes attached to the skeleton (gameHitRepresentationComponent, data in a .hitrepresentation file). The game has 42 such files. The one for ordinary human NPCs, base\characters\base_entities\npc_base\npc_base.hitrepresentation, holds 15 shapes. Each one names a bone slot, a hit reaction zone and a dismemberment part:
| Shape (and slot) | Hit reaction zone | VATS part |
|---|---|---|
| Head | Head | Head |
| Chest | ChestRight | Torso |
| LeftTorso | ChestLeft | Torso |
| RightShoulder | ChestRight | Torso |
| Belly | Abdomen | Torso |
| LeftArm | ArmLeft | Left arm |
| LeftForeArm | HandLeft | Left arm |
| RightArm | ArmRight | Right arm |
| RightForeArm | HandRight | Right arm |
| LeftUpLeg, LeftLeg, LeftFoot | LegLeft | Left leg |
| RightUpLeg, RightLeg, RightFoot | LegRight | Right leg |
The LeftArm capsule, for example, is 0.08 m in radius and 0.25 m long, centred on its slot. Group shapes by name or hit reaction zone, not by the dismemberment part: that field puts LeftTorso under LEFT_ARM and Chest under RIGHT_ARM.
Each shape’s data is a HitShapeUserDataBase: its type (Flesh, Metal, Cyberware, Armor), whether it is a protection layer or a weak spot, and a damage modifier (hitShapeDamageMod). VATS can show this per part, such as “armored” or “x2 damage”. Bosses, mechs and big NPCs have their own files (Adam Smasher, the Chimera with separate weak spot files). Whether women and other body types share npc_base is unverified.
Other parts that help
| Need | What the game has |
|---|---|
| Where a part is now | The shapes’ slots are the NPC’s slots (entSlot: a slot name on a bone). AIActionHelper.GetTargetSlotPosition(target, n"Chest", out pos) is how the game’s scripts read one. entSlotComponent.GetSlotTransform reads any slot, natively: through REDnode’s api, the script helper answers true but leaves its out parameter at 0, 0, 0 (2026-11-14), so read the slots from the NPC’s GetHitRepresantationSlotComponent() (the game’s spelling) |
| Which part the crosshair is on | TargetingSystem: GetComponentClosestToCrosshair, GetTargetParts, GetBestComponentOnTargetObject; aim assist uses them. GetLookAtComponent answers the whole gameHitRepresentationComponent (“HitRepresentation”), the same for head and leg (2026-11-14): it does not name the shape |
| What a shot hit | hitEvent carries the hit shape (GetHitShape, GetHitShapeUserDataBase); the game’s hit reactions read its name |
| Switch a part’s hit shape off or on | Static functions HitShapeUserDataBase.DisableHitShape(object, shapeName, hierarchical) and HitShapeUserDataBase.EnableHitShape(...), and the event gamehitRepresentationEventsToggleHitShapeEvent |
| Zoom | The player’s camera (gameCameraComponent): SetFOV, SetZoom, and fovOverrideWeight/fovOverrideValue. Whether the scanner leaves them alone is unverified |
| Slow time | TimeSystem’s time dilation; the Sandevistan sets the world’s to 0.3 (seen in REDnode’s sound spike) |
| Highlights | The scanner’s outlines (FocusForcedHighlightData, gameVisionModeSystem), weak spot highlights on bosses (ToggleWeakspotHighlightEvent: weak spots are objects of their own, so they light up alone), and entRenderHighlightEvent with fillIndex, outlineIndex, opacity, seeThroughWalls and a componentName |
| Wounds | EWoundedBodyPart (wounded or dismembered arm or leg) for effects such as a crippled leg |
What it lacks
A highlight for one limb. A body is one mesh (base\characters\common\base_bodies\man_average\t0_000_ma_base__full.mesh), with the head and clothes as other components. So entRenderHighlightEvent’s componentName could light up the head, a shirt or trousers at best, never a left arm alone, and never a bare limb (unverified: no game script sends this event with a component, and whether it honours one is untested). Boss weak spots light up alone only because each is an object of its own.
Three ways to draw the parts
| Way | How | Looks | Cost and risk |
|---|---|---|---|
| A. Shapes in the engine’s picture | Attach a small glowing mesh per part (a capsule like the hit shape, or a ring) to the NPC’s bone slots, and give it the game’s outline with a highlight event | Part of the 3D picture: hidden behind cover, lit and outlined in the game’s colours | Needs something attached to a bone at runtime: a spawned entity on a slot, or a component added to the NPC (Codeware may allow it; unverified). Six to eleven objects per target. A capsule is not the body’s outline |
| B. REDnode draws over the game (recommended first) | The plugin reads the target’s slots each frame, projects each shape to the screen (the world pins’ projection: about 7 us a frame for 100 points, WP1) and draws an outline, fill and label per part, as pins are drawn | A HUD layer, like the game’s own scanner. Labels (part, hit chance, damage, armour) are easy | Drawn over everything, so cover needs ray casts as pins do (WP2). The part’s shape on screen is the projected capsules, not the body’s outline |
| C. Ink (the game’s UI) | The same projection, but placed as ink widgets on the HUD layer | Engine-drawn 2D, in the game’s own fonts | Ink changes through the bridge cost a frame each (I1), so per-frame placement would need a native driver like the pins’. No gain over B for a first build |
The owner’s look, 2026-11-14: in VATS no labels as the spike draws them, only a red outline of the body part. That changes what each way must draw:
| Way | A red outline of a part |
|---|---|
| A | The game’s own outline, in red, on a shape attached to the part’s bone: it follows the bone every frame with no work from REDnode and hides behind cover like the game’s scanner outline. The shape is a capsule, not the limb. The head may be the exception: NPC heads are their own mesh (the body is one), so entRenderHighlightEvent with componentName on the head component may outline the real head (unverified, in V2) |
| B | The part’s capsules projected to the screen and drawn as one red outline (a rounded shape per capsule, merged). REDnode’s pins draw labels and posts only, so this needs a new primitive in the plugin: shapes placed from slots each frame, as pins are from points. Drawn over everything, so cover would need the exposure rays to hide what is behind it |
| C | No gain over B |
With each part’s hit chance as a callout (the owner, the same day): a small red box in the game’s look, outside the body, with the value inside (“72%”), and a line from the box to the part, like a callout in an infographic.
| Piece | How |
|---|---|
| The box | REDnode’s pin label in the game’s look (MainColors.Red from the game’s style sheet, as I2b’s game look reads it), drawn on the labels page like any pin |
| Where it goes | The owner, 2026-11-14: the head’s box above the head; the limbs’ and the torso’s boxes off to the side, at about the height of their part, so their lines run across to it rather than down through the body. A part’s side is the side of the screen it is on, from the body’s middle, not its name: an enemy facing V shows its left arm on the right. The torso’s box goes on the side with more room. Placed in screen space each frame, the boxes kept clear of the body’s outline and of each other |
| The line | Horizontal for the side boxes: from the box’s inner edge across to the part’s outline, at the part’s height (a short bend if boxes on one side have to be spread apart). Vertical and short for the head’s box. Straight pieces only, as pin posts are drawn; a bend needs two |
| What REDnode needs | A callout pin: a label placed beside or above its point in screen space, with a horizontal or vertical leader line (an elbow when spread). Today a pin’s label sits straight above its point with a vertical post. The side and spread are worked out per frame from the body’s projected outline, in the plugin |
The game’s own map pins (the mappin system attaches a widget to an object’s slot and the engine places it each frame) could give a truly native box, but VATS would need its own ink widget for them, through Codeware (unverified; a later spike).
Neither can trace the true outline of an arm or a leg, since the body is one mesh: both outline the hit shapes, which is also what a shot can hit.
Recommendation: B first, with A as a spike. B reuses what world pins already do and puts all six parts on screen soonest. The scanner’s own outline of the whole enemy stays as it is. If A’s spike shows bone-attached shapes are cheap and look right, VATS can move its highlights into the engine and keep REDnode’s labels.
A VATS tab in the scanner’s panel
The owner’s idea, 2026-11-14, which would replace the callouts: while scanning, the panel on the right has two tabs, Data and Hacking. Add a VATS tab after Data, listing the scanned enemy’s body parts with their hit chances.
What the game has (read from the 2.5 type list and basegameplayguiwidgetsscanningscandetails.inkwidget, read only):
| Piece | What it is |
|---|---|
| The panel | scannerDetailsGameController, a script class: GetAvailablesTabs(), SetTab(tab), RefreshLayout(), UpdateTabBottomLine(), OnScannerTabChangeEvent, currentTab, scannedObject |
| Its tabs | The script enum ScannerDetailTab: Data 0, Hacking 1, TwinTone 2. TwinTone is the vehicle paint tab (2.1), shown only when scanning a car (ShouldDisplayTwintoneTab) |
| The header | tabsHolder > tabs: tab01, space01, tab02, space02, tab03, each tab with an a and a b state; bottom lines for two tabs (twoTabs01, twoTabs02) and for three (threeTabs01 to 03) |
| The bodies | scannerCountainer (Data), quickhackContainer (Hacking), twintoneContainer (TwinTone) |
So the panel already has a three-tab layout, and for an NPC its third slot is always empty. A new enum member cannot be added from redscript, but VATS can take the TwinTone slot whenever the scanned object is an NPC:
| Step | How (redscript, wrapping scannerDetailsGameController) |
|---|---|
| Show the tab | GetAvailablesTabs adds TwinTone for an NPC while VATS is on |
| Call it VATS | Set the third tab’s label text to “VATS” (and back to TwinTone for a car) |
| After Data | Move tab03 (and a spacer) to sit after tab01 in tabs, and give GetAvailablesTabs the order Data, VATS, Hacking, so the Switch Tab key cycles in that order (unverified that the cycle follows the array) |
| Its body | For an NPC, hide the TwinTone body’s own widgets in twintoneContainer and fill it with a list: each part’s name and its hit chance |
| The numbers | Kept by a small script class with a static setter (VATSPanel.SetPart(name, chance)), which the Node mod calls through api after each exposure read; the panel redraws from it |
Unverified: everything in the right column (no script has run yet); whether the header’s layout gives three tabs room at every resolution. The game’s own panel script (read from game 2.5’s scripts, not kept) shows Switch Tab cycling through GetAvailablesTabs() in its order, and that vanilla never shows three tabs: Data, then Hacking or TwinTone. Spike V13.
VATS is its own drop-in REDnode mod (the owner, 2026-11-14), needing REDnode only; its quickhacks are made with EDGEhack, which it does not need to run. Its repo is Edgemodders/VATS: the design in its docs/design.md, and V13’s script in scripts/VATS/Panel.reds (compile-checked against 2.5’s scripts alone and beside Codeware, no other installed mod touches the panel). The spike app 0.5.0 feeds it: Panel test values, Exposure, and right trigger VATS about once a second.
V13 test
VATS’s scripts in r6/scripts/VATS (the VATS repo’s tools/deploy.ps1), VATS spike 0.5.3 (0.5.0 with VATS’s two sounds and ways to make the outline stand out: VATS fill, See through walls, Outline strength, Pulse), REDnode 0.65.1, game 2.5.
| Step | Do | Expect, and what to note |
|---|---|---|
| 1 | Start the game and load a save | No VATS line in r6/logs/redscript_rCURRENT.log errors (Claude reads it after) |
| 2 | Scan an NPC who can be hacked | The panel’s tabs read Data, Hacking, VATS (VATS last since the first run). Note whether each header lights over its own body, and how the bottom line under the open tab looks |
| 3 | Press Switch Tab a few times | Data, Hacking, VATS, Data. Note anything odd |
| 4 | Open the VATS tab | Six rows: HEAD, TORSO, LEFT ARM, RIGHT ARM, LEFT LEG, RIGHT LEG, each with -- in a column of its own, clear of the panel’s edges |
| 5 | In F10, in VATS spike, press Panel test values; scan again and open VATS | 80%, 75%, 100%, 20%, 33%, 7% |
| 6 | Switch on Right trigger VATS; hold the scanner, hold the right trigger on an enemy, open the VATS tab | The numbers change about once a second as you move. Move to another enemy: they go back to --, then fill again |
| 6b | The outline can be faint (the owner, 2026-11-14). First try: VATS fill changed the outline’s colour and filled nothing (the game’s own scripts never set fillIndex; its fills come from the vision mode code). From 0.5.3 try, holding the right trigger on an enemy after each: See through walls on; Outline strength at 200 % and 400 %; Pulse on |
Note which makes the part stand out, and whether see-through shows a fill where the part is hidden |
| 6c | Hold the right trigger on an enemy, move the crosshair over the parts, let go; repeat | The zoom sound as VATS zooms in, the select sound each time a new part lights (the owner’s sounds, in the VATS repo’s assets/sounds). Note whether they play at once and at their normal speed under the slow motion |
| 7 | Scan an NPC who cannot be hacked (a civilian) | Data, VATS |
| 8 | Scan a car that is not yours | The game’s own TwinTone tab, with its own name and paint options |
| 9 | Scan a device (a camera, a vending machine) | Data, and Hacking where the game has it; no VATS |
Claude then reads redscript_rCURRENT.log and the [vats-spike] lines in rednode-mods.log.
First run, 2026-11-14 (the owner, dev PC, two screenshots): the VATS tab showed, with the six parts and their chances fed by the spike app (100, 90, 30, 100, 60, 100). With its header moved after Data, the bodies were crossed: the Hacking body (the quickhack’s description) opened under the VATS header, and VATS’s list under the Hacking header; the bottom lines were off; the list touched the panel’s edges. Cause (from the screenshots): the game’s tab animations find the headers by place, not by name. Fixed in the VATS repo the same day: the headers stay in the game’s order, VATS last (Data, Hacking, VATS), and the game’s own three-tab bottom lines apply once both extra tabs are counted; the list has a margin and the chances their own column. Steps 2 to 4 above are for the retest.
Picking a part
| Where | How |
|---|---|
| In the world | No cursor, as in the game. The part nearest the crosshair is the pick (the game’s GetComponentClosestToCrosshair, or REDnode’s own projection), and mapped keys or controller buttons cycle between parts. This is the semi-native apps’ “mapped inputs in the world” (spike S3 in Semi-native apps) |
| Paused | If VATS stops the world while the player picks (semi-native S6, a paused mode with the cursor), the player clicks a part |
Keys: REDnode has no game input API yet (I3). Until then the mod’s own redscript can listen for its keys, as other mods do.
Hitting the chosen part (part 2, later)
Not researched yet. Candidates, each unverified:
| Way | How |
|---|---|
| Aim at it | Turn the camera or the shot toward the part’s slot (the targeting system’s LookAt and AimSnap, or the camera itself) and let the player fire |
| Only that part can be hit | Switch off every other hit shape on the target for the shot (DisableHitShape), then back on |
| A scripted hit | Apply the attack to the part’s shape directly, as the game’s own effects do |
Hit chance from exposure
The owner’s idea, 2026-11-14, not a priority yet: each part’s hit chance follows how much of it V can see. An NPC facing left in V’s view shows its left arm (90 to 100 %) and hides its right arm behind its own body (a chance by how much of it shows). Nothing found so far prevents it; it would come in a build phase once the spikes pass.
How it could work: cast rays from the camera to a few points on each part and count the ones that reach it unblocked.
| Step | How |
|---|---|
| Points on each part | Every hit shape is a capsule, sphere or box of a known size (the shape file: the LeftArm capsule is 0.08 m by 0.25 m) on a slot. GetTargetSlotTransform(target, slot, out transform) gives a slot’s place and orientation, so each shape’s points (its ends, middle and sides) can be placed in the world |
| Blocked by the world | A ray from the camera to each point through SpatialQueriesSystem.SyncRaycastByCollisionGroup, as world pins test walls (REDnode’s RaycastStatic, WP2: 17 to 33 us a ray). "Static" catches walls and cover; which groups also catch cars, crates and other NPCs is unverified |
| Blocked by its own body | Physics rays do not see hit shapes, and the far arm hides behind the NPC’s own torso. So test each ray against the target’s other capsules with plain maths (a ray against a capsule, in the mod, no game call). Other NPCs in the way can be tested the same way, with their slots read too |
| The chance | A part’s exposure is the share of its rays that reach it. The hit chance is exposure times the mod’s own factors (distance, the weapon’s spread, the player’s skill), a formula to design |
| Cost | Six parts by six to eight points is 36 to 48 rays, about 1 to 1.5 ms of the game thread if done at once. Spread over frames, or done only when the target, V or the camera moves, a few times a second is enough for a label |
| When | Only in VATS, under its deep slow motion (the owner, 2026-11-14); never in real-time play. That makes the spike’s 205 ms for 54 rays much less of a problem: at a dilation of 0.05 it is about 10 ms of game time, so the labels can lag a frame or two of real time while the world barely moves. Faster is still better, since the camera can move between enemies at normal speed |
The spike’s first run (2026-11-14): exposure read right side-on, with 54 rays in 205 ms (above, “Spike test: first run”).
Legs (the owner, 2026-11-14): both legs light together, because trousers (l1_) and shoes (s1_) are single meshes for both legs; arm meshes often name their side (_l, _r, left, right), leg meshes seen so far do not. The game’s outline cannot single out one leg on such meshes; the floating label (V15) names it, and a shape on the bone or a drawn outline could single it out later.
Unverified: the slots’ orientation (which axis a capsule runs along), the collision groups for moving things, and whether the game’s own bullets agree with the capsules (they hit the same hit shapes, so they should).
Spikes
| Spike | Question | How |
|---|---|---|
| V1 Parts on screen | Can REDnode follow an enemy’s 15 slots each frame and draw the six parts in place? At what cost? | Read the slot positions from the plugin for a targeted NPC (GetSlotTransform or the game’s GetTargetSlotPosition), project them with the pins’ code, draw outlines and labels. Log the cost per frame |
| V2 Parts in the engine | Can a glowing shape ride a bone and take the game’s outline? | Attach a small mesh to an NPC’s Head and LeftArm slots, send it entRenderHighlightEvent; also try componentName on the NPC’s own head and garments |
| V3 Zoom while scanning | Does SetFOV or SetZoom on the player’s camera hold while the scanner is up? |
Call them from the Console while scanning; read them back |
| V4 The crosshair’s part | Does the game report which part the crosshair is on? | GetComponentClosestToCrosshair and GetTargetParts on a scanned enemy, from the Console |
| V5 Deep slow motion | How low can the world’s dilation go while scanning, with V and the camera at normal speed, and how does it stack with the scanner’s own? | SetTimeDilation and the local-player calls from the Console while scanning; undo with UnsetTimeDilation |
| V6 The smart gun’s part | Can the smart gun lock onto a chosen bone? | Watch attachedBoneName on its targets; try its target sorting, or the lock events |
| V7 Only VATS quickhacks | Can EDGEhack’s scripts switch every other quickhack off while VATS is on, and back after, beside REDnode’s own wrap of the same function? | In EDGEhack: wrap TranslateChoicesIntoQuickSlotCommands behind a VATS switch, mark the others unusable with a reason; check the wheel, its keys and REDnode’s quickhack test together |
| V9 The triggers while scanning | Can a mod read the right and left triggers while the scanner is held, and keep the game from using them (the scanner’s own zoom, aiming, shooting) while VATS has them? | A redscript input listener on the triggers’ actions in the scanner’s context, and REDnode’s I3 Input when it comes; check what the game still does with them |
| V10 Framing | Can VATS turn the view onto an enemy and frame the whole body, then put the camera back exactly? | Turn the view (the player’s orientation, or the camera’s own rotation: which one works is the question) and set the field of view from the body’s height and distance (from the slots); keep the field of view and zoom from before to restore |
| V11 One enemy, several parts | Can one enemy take VATS quickhacks on several parts, started in VATS and uploading on after it? | Start two VATS hacks on one target in VATS, leave VATS, watch both upload and land; try the same hack on two parts, and the queue perk. Check that the part recorded at the start reaches onLand |
| V12 The upload icon on a part | Does the game’s upload bar move to the slot named in UploadProgramProgressEvent.slotName? |
Start a quickhack, find where the event is sent (EDGEhack’s scripts can wrap it) and set slotName to LeftArm; see where the bar shows. If not, REDnode’s pin on the slot with the QuickHackUpload stat pool’s value |
| V13 A VATS tab | Can the scanner panel show a third tab, VATS, after Data for an NPC, with the parts and hit chances in its body? | A redscript wrap of scannerDetailsGameController (above), first only showing the TwinTone slot for an NPC with the label “VATS”, then the order, then the body filled from a script setter called through api. The UI Workbench’s Inspect tab can confirm the header’s widgets live while scanning |
| V14 Dismember a part | Can VATS take off the chosen part, by a quickhack or a bullet, and does a living enemy keep going? | The game’s own gameDismembermentComponent.RequestDismemberment(npc, part, wound, position, critical), as its ForceDismembermentEffector calls it, from the spike app (Cut buttons, wound Coarse, Clean or Hole). Bullets: the game dismembers the hit part only when the shot kills or downs (its DismembermentConditions), unless the attack carries hitFlag.ForceDismember; with the other hit shapes off, a killing shot lands on the chosen part |
| V15 The floating label | Can the lit part’s name and chance float beside the body, fixed on screen, with a line that bends at a joint and follows the part? | A HUD page of the spike’s own over the whole screen (labels.html), fed by the mod about ten times a second with the part’s place and the camera; the page projects the point and eases the line’s end. The game’s ProjectPoint is logged beside it once a second, to learn its form (no game script calls it) |
| V16 Reactions to VATS’s cut | Can VATS cut first (its own decision) and still get the game’s reactions: pain, voice, combat, the AI’s limb-loss behaviour? | After the request, the game’s own follow-ups from ProcessWoundsAndDismemberment: the Dismembered<zone> status effect, the crippled bark, hostility and V as the threat; the Pain hit reaction (it needs a hit) to find |
| V17 VATS decides a shot’s cut | Can VATS answer the game’s own dismember check for its shots, so its roll (with VATS perks, such as a “Dismember Shot” at 100 %) decides the cut and the game carries out the rest of the hit? | A wrap of HitReactionComponent.DismembermentConditions() in the VATS repo’s scripts: for a hit by V on VATS’s target and part while a VATS decision stands, answer it; otherwise the game’s own answer. Then the game does the damage, the cut and its wound, the status effect, the bark, the pain reaction and combat in its own order |
| V8 Exposure (not a priority) | Can each part’s exposure be measured from the camera, against the world and the NPC’s own body, cheaply enough? | Read the slots’ transforms (GetTargetSlotTransform), place points on the capsules, cast rays against the world with SyncRaycastByCollisionGroup, test them against the other capsules in the mod; compare with where shots land |
V1 and V3 decide whether the first build goes ahead as drawn here. V5 and V7 decide the rest of the play. V8 waits until those pass. V9 and V10 are the controller design’s.
Open questions
| Question | Recommendation |
|---|---|
| Six parts or more (hands, feet)? | Six, as the owner described. The table above already groups the 15 shapes |
| Time while targeting | Slowed far below the scanner’s slow motion (the owner, 2026-11-14); how low is V5’s question |
| The duration’s clock | Real time, so the player’s budget stays the same however slow the world is. To decide with the owner |
| Moving between enemies | Snap to the next or previous enemy with a key or stick, nearest first. To decide with the owner |
| VATS’s zoom | Frame the enemy from V’s own camera (turn and narrow the field of view), not a camera moved nearer: the owner’s “within the raycast from V’s camera”. To agree with the owner |
| Enemies VATS covers | Human NPCs on npc_base first; bosses, mechs and drones later, each with its own shape file |
| What VATS shows on a part | Decided by the owner, 2026-11-14: a red outline, and the hit chance in a red callout box outside the body with a line to the part. Which parts show (all six, with the picked one brighter, or only the one under the crosshair) is to agree |
The spike app
Built on 2026-11-14: the VATS spike app (packages/overlay/apps/vats-spike, a Node mod). It goes through api and world pins only, so REDnode itself is unchanged and it runs on REDnode 0.62.4 or later. Each button calls the game and logs what it answered and how long it took, in its window, the Mod log and red4ext/logs/rednode-mods.log.
| Section | What it calls | Answers |
|---|---|---|
| Target | TargetingSystem.GetLookAtObject: what V looks at becomes the target |
|
| Read slots | GetSlotTransform(slot, out worldTransformOut) on the target’s hit representation slot component, positions in the game’s fixed point (17 fraction bits). 0.2.0 called AIActionHelper.GetTargetSlotPosition as a global and was refused; 0.2.1 called it by its class and read 0, 0, 0 for every slot (a script function’s out parameter does not come back) for the 15 hit shape slots, grouped into the six parts |
V1: which slots an NPC has, and the cost |
| Show parts | The same reads a few times a second (1 to 15, a slider), a pin per part at the middle of its slots (screen scale, no post) |
V1: do six labels follow a moving enemy, and what does it cost |
| Crosshair (V4) | TargetingSystem.GetLookAtComponent, with its component’s name; from 0.2.3 also the part, by a ray from the camera along GetActiveCameraForward against the 15 shapes (as balls, with half a capsule’s length as their reach) |
V4 |
| Zoom (V3) | The player’s camera (GetFPPCameraComponent): SetFOV to a half or a quarter, SetZoom, Back |
V3 |
| Slow motion (V5) | TimeSystem.SetTimeDilation with a reason and a duration (2 to 30 s, a slider), so it always runs out on its own; Keep V at normal speed adds SetIgnoreTimeDilationOnLocalPlayerZero; Normal undoes both |
V5 |
| Watch | Twice a second, a line when the active dilation, the field of view or the zoom changes | What the scanner itself changes |
| Exposure (V8) | Five points across each shape (its slot, and its capsule’s radius to the camera’s right, left, up and down). A point is behind the target’s own body if the line from the camera passes through another of its shapes, each taken as a sphere of its capsule’s radius at its slot (an approximation). The rest get a ray each from the camera (GetActiveCameraWorldTransform, SyncRaycastByCollisionGroup with "Static"), all sent at once so they share a frame; a hit more than 0.15 m short is the world in the way. Chance on the labels shows each part’s share on its pin while Show parts is on |
V8: do the shares match what the player sees, and what do 40 to 70 rays cost |
| Right trigger VATS (round 3, from 0.4.0, REDnode 0.65.0) | The owner’s design on a controller, held: with the switch on, the right trigger pressed while the scanner is up (the player state machine’s Vision reads 1, Focus) frames what V looks at as Frame (camera) does, then every 150 ms finds the part under the crosshair (a ray against the shapes) and outlines the meshes worn there (head h0_, heb_, hh_, h1_; torso t1_, t2_; arms g1_, a0_; legs l1_, s1_) in VATS colour (1 first, to find green). Letting go of the trigger or the scanner takes the outline off and puts the camera back. The trigger comes from REDnode’s new input.onGamepad (the plugin reads the controller with XInput) |
The owner’s play test of the whole loop; which colour is green; whether the game also does something with the right trigger while scanning (V9) |
| Outline (V2, from 0.3.0) | List components: Codeware’s GetComponents() on the target, each mesh component logged with its type and name. Outline: entRenderHighlightEvent (made with api.$new, sent with QueueEvent) with the typed componentName (empty: the whole NPC), the colour from a slider (the event’s outlineIndex, 1 to 7), no fill; Clear sends it again with no outline |
V2: can the game outline one part (the head, a garment) in red |
| Frame (V10, from 0.3.0) | The body’s middle, height and distance from its slots; the field of view that makes it fill a share of the screen’s height (Body fills, 40 to 95 %). Frame (camera) turns the first-person camera’s own local orientation (SetLocalOrientation, keeping what its parent adds); Frame (turn V) teleports V where V stands, facing the body, with yaw and pitch. Each reads the camera’s forward direction after and logs how far the view is off the body’s middle (the camera way at once and after 1 s, to see whether the game writes over it). Camera back restores the orientation, field of view and zoom |
V10: which way turns the view, and whether it holds |
| Only one part can be hit | HitShapeUserDataBase.DisableHitShape on the target’s other shapes, EnableHitShape after 6 s (from 0.3.0 a slider, 3 to 30 s) |
Part 2: can a shot be made to land on one part |
A package has no stop hook, so nothing it changes outlives it unattended: slow motion runs out by its duration, the hit shapes come back after 6 s, and the zoom has Back (unverified whether a save load also resets it).
Checked in the mock game (scratchpad vats/check.mjs, its stand-in plugin vats/mock.mjs with the game’s answers in vats/answer.mjs, which since 0.2.1 answers the slot and hit shape calls only by their class and, like the game, leaves the script helper’s out parameter at zero): 40 checks from 0.2.3, every button, the calls’ arguments as the 2.5 types want them, six pins placed again and again and gone when switched off (the check found an update in flight putting them back after the switch; fixed), and the hit shapes back on. App 0.2.0 adds Exposure: with the mock’s camera at the NPC’s left side and a kerb below 0.3 m, the left arm read 100 %, the right arm 10 % (9 of 10 points behind the torso), the right leg 20 % (its foot behind the kerb); 43 rays went out within 1 ms.
Spike test
In the game, on open ground near enemies who are not fighting yet (a gang’s hangout, from a distance). The overlay pauses the game while it is interactive, so the scanner cannot be held while clicking: each step sets something up with F10, then leaves interactive mode (F10 again) to play.
| Step | Do | Expect, and what to note |
|---|---|---|
| 1 | Press F10 and switch on VATS spike in the launcher (it asks for no permission) | Its window opens on the left: “VATS spike ready” |
| 2 | Look at an enemy and press Target | “Target: NPCPuppet …” with their name |
| 3 | Press Read slots | “15 of 15 slots” (or which are missing) and the time it took |
| 4 | Switch on Show parts, then leave interactive mode and watch the enemy walk | Six coloured labels (Head, Torso, Left arm, Right arm, Left leg, Right leg) on their body. Note whether they keep up, and whether left and right are the enemy’s own |
| 5 | Back in F10, move Updates a second to 15, and watch again; then switch Show parts off | Smoother at 15. Note the cost lines (“Parts: … ms each”) |
| 6 | Switch on Watch the dilation and the camera, leave interactive mode, hold the scanner for a few seconds, let go | Watch lines show what the scanner changes: the dilation and the field of view, or nothing |
| 7 | In F10, press x2, leave interactive mode, and hold the scanner | The view zoomed. Note whether it stays zoomed while scanning and after. Then Back in F10 |
| 8 | In F10, with Keep V at normal speed on, press 0.05, then leave interactive mode at once and move V, turn the camera, hold the scanner | For 8 s the world crawls. Note whether V and the camera move normally, and what Watch logs while scanning |
| 9 | Repeat step 8 with Keep V at normal speed off, then with 0.01 | Note the differences |
| 10 | Aim at the enemy’s head and press Crosshair (V4) (F10 shows the cursor, but the crosshair stays where V aims). Repeat aiming at a leg | Which component is under the crosshair each time (0.2.2 and before: the whole hit representation, for any part). From 0.2.3 the line ends “the crosshair is on the Head (Head, …)”: note whether head, torso, an arm and a leg each read right |
| 11 | Stand so the target is side-on to you (facing left or right in your view) and press Exposure (V8) | A share per part. The arm and leg nearer you should read high, the far ones low (“behind its own body”). Note whether that matches what you see |
| 12 | Move so a low wall, a car or a crate hides part of the target, and press Exposure again. Then switch on Chance on the labels and Show parts, walk round the target, and switch both off | Parts behind the cover read lower (“behind the world”); a car or crate may not count (which collision groups catch them is the question). The labels show “Left arm 90%” and change as you move. Note the cost lines |
| 13 | Press Left arm under “Only one part can be hit”, leave interactive mode and shoot the enemy’s torso and head within 6 s, then the left arm | Note whether torso and head shots pass through or miss, and whether the arm takes hits. After 6 s the log says every hit shape is back on |
| 14 | Switch the app off | Its pins go; nothing stays slowed |
Claude then reads rednode-mods.log for the [vats-spike] lines, the costs and the answers, and writes the results here and into the game API notes (gameapi/notes/), since other mods can use them too.
Spike test: round 2
App 0.3.0, on REDnode 0.64.0, game 2.5, Codeware. Every line now also goes to red4ext/logs/rednode-mods.log, so nothing needs pasting. As before, set each step up in F10, then leave interactive mode to look.
| Step | Do | Expect, and what to note |
|---|---|---|
| 1 | In the launcher, switch VATS spike off and on (its log says “VATS spike ready”). Find an enemy who is not fighting yet, look at them and press Target | “Target: NPCPuppet …” |
| 2 | Under Outline (V2), press List components | A line per mesh component, with its type and name; the summary counts them. Note which looks like the head (h0_...), the body (t0_...) and the garments |
| 3 | Type the head’s name into the box (click out of it), press Outline, leave F10 and look at the enemy, without and with the scanner | Note whether only the head is outlined, its colour, and whether it shows without the scanner |
| 4 | Move Outline colour through 1 to 7, pressing Outline after each (F10 in between) | Note each number’s colour: which one is the game’s red |
| 5 | Try a garment’s name, the body’s name, then an empty box (the whole NPC), pressing Outline each time; then Clear | Note what each outlines. Clear should take the outline off |
| 6 | Under Frame (V10), press Frame (camera), then leave F10 | The view turns onto the enemy and their body fills about 80 % of the screen’s height. The log says how far off the view is, at once and after 1 s. Note whether it stays, whether you can still look around, and whether the crosshair and your aim follow the turned view. Back in F10, press Camera back |
| 7 | Press Frame (turn V), leave F10 | V turns to face the enemy. Note whether looking up or down (the pitch) also took, and the log’s “degrees off”. Then Camera back |
| 8 | Set Body fills to 60 % and press Frame (camera) again; then Camera back | A looser frame |
| 9 | Round 1’s steps 6 to 9 again (Watch with the scanner held; x2 while scanning; 0.05 with Keep V at normal speed on, then off, then 0.01) | Nothing to note: their answers are in the log this time |
| 10 | Save the game first. Under Only one part can be hit, set the seconds to 15 and press Left arm. Leave F10 and shoot the enemy’s torso and head with a weapon that is not smart (a power pistol), then the left arm, until the log says the shapes are back | Note whether torso and head shots do damage (the damage numbers), and whether the arm does. Load the save after if the fight goes badly |
| 11 | Switch the app off | Nothing stays outlined, turned, zoomed or slowed |
Claude then reads the [vats-spike] lines in rednode-mods.log.
Spike test: round 3
App 0.4.2 on REDnode 0.65.1 (the plugin reads the controller: Xbox pads through XInput, and from 0.65.1 Sony pads from their HID reports), game 2.5, Codeware, a controller.
First try, 2026-11-14 on 0.65.0 with a DualSense over USB: nothing happened. The plugin log had “XInput loaded” and no controller: a DualSense is no XInput pad, and with the game’s own DualSense support Steam Input does not stand in for one. 0.65.1 reads Sony pads from their HID input reports; a probe run beside the game (which holds the pad) opened it shared and parsed 1,251 reports in 5 s (USB, report 0x01, 64 bytes, 250 a second), so the game does not keep it to itself.
Quick try on 0.65.1, 2026-11-14 (app 0.4.0): the trigger worked, the view framed the enemy and the part under the crosshair lit, as fast as the player moved it (every 150 ms in the log). Two findings, fixed in app 0.4.1: the zoom crawled, since the game eases the field of view in game time and the scanner holds the world at 0.03 (0.4.1 leaves V, whose camera it is, out of the slow motion while VATS is on, SetIgnoreTimeDilationOnLocalPlayerZero, switch Camera at normal speed, and logs the field of view 0.25, 0.5 and 1 s after; unverified that the camera follows V); and only the enemy under the crosshair when the trigger went down lit while it stayed down (another enemy was found again only by letting go and pressing again, as Luna Bernardes at 20:23:18): 0.4.1 asks what V looks at on every update and moves the outline to it, which is what the owner wants (any enemy looked at during the scan). Leaving V out of the slow motion was taken out again in 0.4.2: it would be a free Sandevistan (the owner), and the scanner’s own zoom (D-pad up, by the optics installed) runs at normal speed without it, through V’s animation (the player state machine’s zoom states send AnimFeature_Zoom). 0.4.2 offers four ways to zoom, chosen with buttons (a dropdown is to come in the ui builder): the camera’s zoom override (zoomOverrideWeight and zoomOverrideValue, the default) and field of view override (fovOverrideWeight, fovOverrideValue), eased by the app over 0.3 s of real time, SetZoom likewise, and SetFOV as before; each logs what the camera reads 0.25, 0.5 and 1 s after, to show whether the game writes over it. V’s time is never touched. The log also showed arm and hand meshes naming their side (nails_r, gloves__fingerless_l, cyberarm_l1121, shoulders_left, full_ag_right7382), so 0.4.1 lights the left or right ones for each arm and both for a mesh that names no side.
| Step | Do | Expect, and what to note |
|---|---|---|
| 1 | Load a save. In the launcher, switch VATS spike on (or off and on); switch on Right trigger VATS | The log: “Right trigger VATS: on”, and the plugin’s log has “Gamepad: reading DualSense (product 0CE6, 64-byte reports)” |
| 2 | Leave F10. Without the scanner, press the right trigger once | The log: “the scanner is not up: nothing to do”. Note whether the game did something with the trigger (fired) |
| 3 | Hold the scanner, aim at an enemy who is not fighting yet, and hold the right trigger | The view frames the enemy; the part under the crosshair is outlined. Note the colour, and how fast it came |
| 4 | Still holding both, move the crosshair over the head, the torso, the arms and the legs | The outline follows the part. Note how quickly it changes, and that arms and legs light both sides (gloves and trousers cover both) |
| 5 | Let go of the right trigger | The outline goes and the camera is back as before |
| 6 | Hold the trigger again while scanning, then let go of the scanner first | The same: off, camera back |
| 7 | If the outline was not green: in F10, move VATS colour to 4, 6 or 7 and repeat step 3 | Note which number is green |
| 7b | Under Right trigger VATS, the zoom starts on Zoom override. Repeat step 3 with each of FOV override, SetZoom and SetFOV | Note which zooms smoothly at normal speed while scanning, and which does not zoom at all (the log says what the camera read after) |
| 8 | Switch the app off | Nothing stays outlined or turned |
Claude then reads the [vats-spike] lines in rednode-mods.log and the plugin’s Gamepad: lines.
V14 and V15 test
VATS spike 0.6.3 (REDnode 0.65.1), the overlay in passive mode (not F10’s hidden mode). Save first: V14 leaves enemies hurt or angry.
| Step | Do | Expect, and what to note |
|---|---|---|
| 1 | In F10, switch VATS spike off and on. Look at an enemy who is not fighting, press Target | Target logged |
| 2 | Press Cut left arm (wound Coarse), leave F10 | Note whether the arm comes off, how it looks, and whether the enemy lives (the log says after 1 s) and what it does next |
| 3 | On other enemies: Cut left leg, Cut right leg, then Clean and Hole with an arm | Note each: does a legless enemy crawl, do the wound types differ |
| 4 | Cut head and Cut torso on two more | Note whether they die and how |
| 5 | Switch on Right trigger VATS; hold the scanner and the right trigger on an enemy, and move the crosshair over the parts | A green label off to the side (above for the head) with the part’s name and chance, a line under it running towards the body that bends and follows the part. Note whether the text stays still, whether the line keeps up, and whether the line’s end lands on the part (it may be off if the camera’s field of view is not what the page assumes) |
| 6 | Let go | The label goes |
| 7 | Switch on Bullets dismember (V’s CanForceDismbember) (the log reads the stat as 1). Get into a fight with one enemy, press Left arm under “Only one part can be hit” with the seconds at 15, and shoot | The arm comes off through the game’s own hit: note the pain reaction, voice lines and what the enemy does after. Note whether a first shot from stealth does it (the game’s code says only in combat) |
| 8 | Switch it off | The stat reads 0 |
| 9 | With Cut with reactions on (V16), Cut left arm on an enemy who is not fighting, then Cut right leg on another | Note whether each screams, turns on V and fights, and how it moves after (an arm gone, a leg gone). The log lists what was applied |
Claude then reads the [vats-spike] lines, including the game’s ProjectPoint answers.
V14 first run, 2026-11-14 (the owner): Cut takes each part off cleanly, but the enemy does not react: the direct request skips the game’s hit (no damage, no hit event, no stimulus), so no pain animation, no voice, no combat. What VATS needs instead (V14b):
| Way | How | What it brings |
|---|---|---|
| Bullets | While VATS is on, give V the game’s own CanForceDismbember stat (RPGManager.CreateStatModifier, StatsSystem.AddModifier; taken off after). The game’s DamageManager then flags V’s ranged and melee hits ForceDismember, and with the other hit shapes off the hit lands on VATS’s part |
The whole hit pipeline: damage, the pain and hit reactions, voice, combat AI, the game’s dismemberment and wound. Only in combat: out of combat the code flags a first shot a stealth hit instead (unverified in game) |
| Quickhacks | A VATS quickhack (made with EDGEhack) that is itself a hostile act, so the target reacts and the trace starts as with any quickhack, and whose landing takes the part off: the game’s ForceDismembermentEffector (fixed part per record) or VATS’s own request with the chosen part from onLand. A damage effect in the same hack would add the hit reaction |
The quickhack’s own reactions; whether a pain reaction and voice come with the cut is to see |
V14b’s switch is in 0.6.2 (step 7 above).
The owner’s rule, 2026-11-14: for VATS quickhacks and VATS perks the cut comes before any damage: VATS’s own code decides it, so the game’s damage-based dismember chance (incoming damage, the perks) must not apply. VATS still needs the game’s reactions. The game’s DamageManager.ProcessWoundsAndDismemberment shows them after its own cut: the request, NotifyAboutDismembermentInstigated (for V’s perks), the status effect BaseStatusEffect.Dismembered<zone> (DismemberedArmLeft, ArmRight, LegLeft, LegRight, HandLeft, HandRight in TweakDB, each with stat changes), a bark (vo_enemy_reaction_crippled_arm, or _leg for a leg), and a Pain hit reaction. V16 (app 0.6.3, Cut with reactions, on by default): after its request VATS applies the status effect, plays the bark, makes the target hostile (AIActionHelper.TryChangingAttitudeToHostile) and injects V as its threat (TargetTrackingExtension.InjectThreat). The Pain hit reaction needs a hit and is not there yet: what the status effect and combat bring on their own is the test.
Second try, 2026-11-14 (app 0.6.3, passive mode, the owner’s screenshot): still no label, though the mod sent 154 updates and the page drew 400 to 665 frames each 10 s (cause unknown; the green text on the scanner’s green view is a guess). The owner’s better idea: the part and chance under the scanned enemy’s name above the crosshair, in the game’s own UI. That name is the quickhack list’s scanner_target_name (in a row, scanner_container, in the list’s screen-sized Root canvas; read from quickhacks.inkwidget); the VATS repo’s PartLine.reds puts a line of its own under it, placed as the row is and one row lower, set by VATSPanelSystem.SetCurrentPart(name, chance). App 0.7.0 sends it on each part change and chance update and clears it when VATS ends; the floating label is now behind its own switch, off by default.
First try, 2026-11-14 (app 0.6.0): no label showed. The mod sent it about ten times a second for every lit part, and the page drew (the host sent 400 to 660 frames every 10 s), but the overlay was in F10’s hidden mode from 21:47:15, which hides every REDnode page, HUD ones too: test in passive mode. (A real VATS label cannot vanish in hidden mode: the semi-native apps’ design, or a native widget.) The game’s ProjectPoint answers X and Y from -1 to 1, 0 at the centre, Y up, and follows the zoom (game API notes), so 0.6.1’s page takes the game’s projection rather than its own. Also found: with the VATS tab open the quickhack list and the cyberdeck’s RAM vanished, because the game’s QuickhacksListGameController.IsPanelBlocked() hides them for TwinTone; fixed in the VATS repo by a wrap (needs a game restart).
Spike test: round 2 results
2026-11-14, by the owner, dev PC, game 2.5, REDnode 0.64.0, app 0.3.0, all 11 steps (step 7 last). Numbers from rednode-mods.log.
| Step | Result |
|---|---|
| 2 List components | A Dogtown resident: 139 components, 21 meshes, every one an entGarmentSkinnedMeshComponent but the hair’s shadow and AppearanceProxyMesh. Names carry the slot prefix and a number: body t0_000_ma__c_base_full9394, head in three meshes (h0_032_ma_c__young528, ...8366, ...4166), eyebrows heb_, hair hh_, headwear h1_ (phones, balaclava), outer top t2_, gloves g1_, trousers l1_, shoes s1_, add-ons i1_, a0_. 60 ms |
| 3 to 5 Outline | Passed: the game outlines one component on its own, visible without the scanner. Of the three h0_ meshes the first (...528) was the head and the other two accessories worn on it. Colours 2, 5 and 3 (sent in that order) showed blue, white and red; which number is red is to confirm. Sent to the trousers, the body and the whole NPC too, about 90 ms a send. While scanning, the game’s own red outline covers a hostile’s whole body (the scanner’s, not the spike’s), so a red part outline would not stand out in VATS: its colour is the owner’s to decide |
| 6 and 8 Frame (camera) | Passed: the view 0.0 degrees off the body’s middle at once and after 1 s, so the game does not write over the camera’s local orientation; shots fired with the view framed landed where aimed (the owner, retried the same day). A 1.70 m body 7.6 m away: field of view 51 to 15.8 (80 %), 20.8 at 60 %. About 1.4 s a press |
| 7 Frame (turn V) | Half: Teleport took the yaw (-2.4) and not the pitch (-7.1): the view stayed 7.2 degrees high, so at a 13.4 degree field of view the body was out of frame (“pitched up a little”, the owner). VATS turns the camera, not V |
| Field of view | The game eases SetFOV over about a second: x2 asked 25.5 and read 49.5, then 31.5, then 25.5; Camera back read 24.3 on its way to 51 |
| 9 The scanner | Holding the scanner eases the world’s dilation through 0.47 to 0.03 (2.5; on 2.31 the scanner’s slow motion was not found in it, so 2.5 changed it or a mod of the owner’s does) and nudges the zoom to 1.00013. In menus the dilation reads 0 |
| 9 Slow motion | 0.05 and 0.01 held while scanning: VATS’s reason wins over the scanner’s 0.03 (0.05 stayed 0.05); when its time ran out, the scanner’s 0.03 came back. Both runs had Keep V at normal speed on; the run with it off is not in the log (open) |
| 10 Only one part can be hit | Passed: with every shape but the left arm’s off, torso shots showed no damage numbers, and the enemy then acted as if its left arm was wounded (the game’s wounded-limb reaction). Whether torso shots passed through to what is behind is open. Aiming down sights read a dilation of 0.75 and a zoom of 1.7 (a perk or the weapon, unverified) |
| 11 Switch off | Passed |
Found: after a save load the app’s Watch kept polling with no world, about two errors a second until the world came back; the next app update waits for it quietly.
What it decides:
| Question | Answer |
|---|---|
| V10 Framing | Turn the first-person camera’s own local orientation and narrow the field of view; it holds. Turning V takes the yaw only. The field of view eases in over about a second |
| V5 Slow motion against the scanner | VATS’s own dilation reason holds while scanning, below or above the scanner’s 0.03 |
| Part 2 One part hit | Switching the other hit shapes off makes shots land only on the chosen part |
| V2 The game’s outline on a part | Works on one mesh at a time, without the scanner. A part is the meshes worn there, picked by their name’s prefix: head h0_ (all of them, with what is worn on it), heb_, hh_, h1_; torso the tops t1_, t2_; arms g1_, a0_; legs l1_, s1_. The body t0_ is one mesh for every part, and tops cover the arms too, so a bare arm or a shirt’s sleeve cannot be outlined apart from the rest (a shape on the bone, or REDnode’s drawn outline, for those) |
Spike test: first run
2026-11-14, by the owner, dev PC, game 2.5, REDnode 0.64.0. The app went from 0.2.0 to 0.2.3 during the run (each copied into the game while it ran; the host restarted the app on its own). The owner: after the fixes, every step worked as written. The app’s lines went only to its window up to 0.2.3, so the numbers below are the ones the owner pasted; 0.2.4 also writes them to rednode-mods.log.
| Step | Result |
|---|---|
| 3 Read slots | 0.2.0: refused, “no game function GetTargetSlotPosition” (a static of AIActionHelper). 0.2.1: 15 of 15 found, every one at 0, 0, 0 (a script function’s out parameter does not come back through api). 0.2.2: read from the NPC’s hit representation slot component (GetSlotTransform, native): passed |
| 4 and 5 Show parts | Passed after 0.2.2 (at 0.2.1 the labels went to the map’s origin). 0.2.1’s cost lines, with the script helper: 25 to 27 ms an update at 5 a second, slot reads 9 to 19 ms |
| 6 to 9 Watch, zoom, slow motion | Worked as written (no numbers pasted) |
| 10 Crosshair (V4) | GetLookAtComponent answers the whole gameHitRepresentationComponent “HitRepresentation” for head and leg alike, in 170 to 178 ms: the game does not name the part. 0.2.3 finds it with a ray along the camera against the shapes: passed, aimed at a Dogtown resident’s head 4.5 m away it read “the crosshair is on the Head (Head, 0.02 m off its middle)”, in 271 ms for the whole button (the slot reads, the camera and the targeting calls one after another) |
| 11 Exposure, side-on (V8) | Passed: head 80 %, torso 75 %, near (left) arm 100 %, far (right) arm 20 % (8 of 10 points behind its own body), left leg 33 % (10 of 15 behind the world), right leg 7 % (7 behind its body, 7 behind the world). 54 rays in 205 ms: far slower than one frame, so the rays do not share frames as hoped (unverified why). The legs’ “behind the world” likely includes the ground: points at or under the floor, with 0.15 m of slack |
| 12 Exposure behind cover | Worked as written (no numbers pasted) |
| 13 Only one part can be hit | Inconclusive: shooting aggroed the enemies, and with a smart pistol where hits land could not be told (it may aim for the game’s own target capsule). Retest with a weapon that is not smart, on an enemy that cannot fight back |
| 14 Switch off | Worked as written |
What it decides:
| Question | Answer |
|---|---|
| V1 Can REDnode read and follow the 15 shapes? | Yes, through the native GetSlotTransform; labels at 5 and 15 updates a second kept up |
| V4 Does the game name the part under the crosshair? | No, only the whole hit representation. VATS finds the part itself, by a ray against the shapes |
| V8 Exposure | Works side-on. Too slow to run live as it is (205 ms for 54 rays); fewer points, a ground cut-off, and finding why the rays do not share a frame come first |
| For REDnode | api.$out works on native functions only; documented on api.$out and in the game API notes (AIActionHelper, entSlotComponent, gametargetingTargetingSystem). A package whose mod.mjs and manifest change together is restarted twice by the host (hot reload and the package rescan), harmless since the runner keeps one worker per mod |