Evasion & Bones

Wall/backdash evasion state and world-space bone coordinates.

getEvasionState

getEvasionState()

Returns one table of UE world data for post-hit evasion (walls, bounds, clearance). Same source as the minimap overlay. Call once per tick in combat.

• Returns: table — EvasionState. valid=true only when the radar snapshot succeeds (requires overlayReady and locatable fighters). When unavailable: { valid = false, battleActive = ..., overlayReady = ... } — diagnostic fields are still set.

local s = getEvasionState()
if not s.valid then return end

local me = s.fighters[s.localSlot]
local opp = s.fighters[3 - s.localSlot]

if me.backToWall then
    -- backed against wall
end
if me.edgeDist < 80 then
    -- near ring-out boundary
end
if me.clearance.left < 50 then
    -- not enough space to sidestep left
end

SDK2 helpers (recommended):

local Sdk2 = require("_SDK.sdk2")
local s = Sdk2.utils.getEvasionState()
local me = Sdk2.utils.getLocalEvasionFighter(s)
if Sdk2.utils.isBackToWall(me) then ... end

EvasionState (root)

Field	Type	Description
valid	boolean	UE data available
battleActive	boolean	In battle main flow
overlayReady	boolean	UE SDK ready
localSlot	integer	Local slot (1 or 2)
stageId	integer	Stage ID
stageName	string	Stage internal name
stageModelNo	integer	Stage model number
layer	integer	Floor layer index
floorHeight	number	Floor height (world Z)
cameraYawDeg	number	Camera yaw (degrees)
wallsValid	boolean	Wall geometry parsed
wallCount	integer	Wall count
bounds	table	Activity bounds (below)
walls	table	1-based wall array
fighters	table	1-based fighters [1]=P1, [2]=P2
distanceBetween	number	2D distance between fighters; -1 if invalid

bounds

Field	Type	Description
valid	boolean	Bounds calibrated
minX	number	Min X
maxX	number	Max X
minY	number	Min Y
maxY	number	Max Y
centerX	number	Center X
centerY	number	Center Y
halfX	number	Half-width X
halfY	number	Half-width Y

walls[i]

Field	Type	Description
cx,cy,cz	number	Wall AABB center
halfX/Y/Z	number	Half-extents
breakable	boolean	Destructible
broken	boolean	Destroyed / no HP
hp	integer	Current HP (breakable)
maxHp	integer	Max HP (breakable)
name	string	UE actor name

fighters[i]

Field	Type	Description
valid	boolean	Data valid
x,y,z	number	UE world position
facingYawDeg	number	Facing yaw (degrees)
edgeDist	number	Distance to nearest boundary edge (negative = out of bounds)
nearestWallDist	number	Distance to nearest wall; -1 if none
nearestWall	table	{index,dist,dx,dy,name,breakable,broken}
backToWall	boolean	Nearest wall within 100 units behind character
clearance	table	{forward,back,left,right} walkable distance (broken walls ignored)

getFighterBoneWorld

getFighterBoneWorld(slot, nameSub)

Engine globals for UE skeletal-mesh bone world positions (same pipeline as the bone overlay). Used for precise evasion: read an attacking limb world position to compute the real attack line instead of relying only on facing yaw.

getFighterBoneWorld(slot, nameSub)

• Parameters:
  • slot (integer, 1-based): 1 = P1, 2 = P2 — same indexing as EvasionState.fighters / localSlot. For the opponent use 3 - s.localSlot (not a fixed 2).
  • nameSub (string): case-insensitive substring; returns the first matching main-joint bone (core torso/limbs; IK/finger/face/fluff bones excluded). Examples: "hand_r", "foot_l", "pelvis", "head". Empty string → not found.
• Returns: always a table (never nil).
  • { valid = true, x, y, z } — UE world coordinates.
  • { valid = false } — invalid slot, mesh unavailable, cache not ready, no match, or implausible coordinates.

local s = getEvasionState()
if not s.valid then return end
local oppSlot = 3 - s.localSlot

local limb = getFighterBoneWorld(oppSlot, "hand_r")
if limb.valid then
    -- limb.x / limb.y / limb.z are UE world coords
end

local Sdk2 = require("_SDK.sdk2")
local name = Sdk2.utils.attackBoneName(getOpponentAttackBonesType())  -- 9→hand_r, 13→hand_l, 16→foot_r, 19→foot_l

getFighterBoneWorlds

getFighterBoneWorlds(slot)

getFighterBoneWorlds(slot)

• Parameters: slot — same as above.
• Returns: table — { [boneName] = { x, y, z }, ... } for all drawable main joints; {} if slot invalid or lookup fails. Per-bone entries have no valid field; keys are full UE bone names.

Sdk2.utils.getFighterBoneWorld / getFighterBoneWorlds delegate to the globals above; the wrappers return nil / {} only when the engine API is unavailable.

SDK2 helper: Sdk2.utils.getOpponentAttackLimbWorld(enemy?) — uses enemy.AttackBonesType when provided and non-zero, otherwise getOpponentAttackBonesType(); requires getEvasionState().valid. Returns:

• nil — unsupported AttackBonesType (not 9/13/16/19) or evasion data unavailable.
• { valid = true, x, y, z } or { valid = false } — same as getFighterBoneWorld on the opponent slot.

Demo:

local s = getEvasionState()
if s.valid then
    local bones = getFighterBoneWorlds(3 - s.localSlot)
    print("Bone count:", #bones)
end