233 lines
8.4 KiB
GDScript
233 lines
8.4 KiB
GDScript
extends SceneTree
|
|
|
|
## Regression gate for authored wall running and physical grapple posing.
|
|
##
|
|
## Wall running must select side-specific authored performances, never a ground
|
|
## run under another name. Grapple must keep its authored airborne base while
|
|
## the live arm constraint lands the palm on the cable ray and body alignment
|
|
## responds to pendulum energy.
|
|
|
|
const SETTLE_FRAMES := 90
|
|
const SAMPLE_FRAMES := 30
|
|
const WALL_RUN_SPEED := 13.0
|
|
const WALL_RUN_REFERENCE_SPEED := 8.25
|
|
|
|
var _failures := 0
|
|
|
|
|
|
func _initialize() -> void:
|
|
call_deferred("_run")
|
|
|
|
|
|
func _run() -> void:
|
|
await process_frame
|
|
var args := OS.get_cmdline_user_args()
|
|
var path: String = args[0] if not args.is_empty() \
|
|
else "res://assets/characters/skins/taila.glb"
|
|
|
|
var scene := Node3D.new()
|
|
root.add_child(scene)
|
|
current_scene = scene
|
|
var model := SkinnedPlayerModel.new()
|
|
model.model_path = path
|
|
scene.add_child(model)
|
|
|
|
for _frame in 60:
|
|
await process_frame
|
|
if not model.loaded or model.skeleton == null:
|
|
_expect(false, "the authored character loads")
|
|
_done()
|
|
return
|
|
|
|
var foot := model._role_bone("foot.L", ["foot.L", "LeftFoot", "Left ankle"])
|
|
var hips := model._role_bone("hips", ["hips", "Hips", "pelvis"])
|
|
var left_hand := model._role_bone("hand.L", ["hand.L", "LeftHand", "hand_l"])
|
|
var right_hand := model._role_bone("hand.R", ["hand.R", "RightHand", "hand_r"])
|
|
_expect(foot >= 0, "a foot bone resolves")
|
|
_expect(hips >= 0 and left_hand >= 0 and right_hand >= 0,
|
|
"hips and both hands resolve")
|
|
|
|
model.set_wall_side(-1.0)
|
|
model.set_wall_run_motion(Vector3(13.0, 0.0, 0.0))
|
|
await _settle(model, "wall_run", WALL_RUN_SPEED)
|
|
_expect(model.current_clip_debug() == "WallRunLeft",
|
|
"left wall selects the authored WallRunLeft performance")
|
|
var wall_scale := float(model._anim_tree.get("parameters/loco_scale/scale"))
|
|
_expect(absf(wall_scale - WALL_RUN_SPEED / WALL_RUN_REFERENCE_SPEED) < 0.02,
|
|
"wall-run cadence tracks %.1f m/s (%.3fx)"
|
|
% [WALL_RUN_SPEED, wall_scale])
|
|
var wall_foot_motion := await _sample_foot_motion(
|
|
model, foot, "wall_run", WALL_RUN_SPEED)
|
|
_expect(wall_foot_motion > 0.30,
|
|
"wall-run has a full wall-stride leg cycle (%.3f rad)"
|
|
% wall_foot_motion)
|
|
var wall_forward := model.wall_run_forward_debug()
|
|
_expect(wall_forward.dot(Vector3.RIGHT) > 0.97,
|
|
"wall-run model faces along wall-tangent velocity (dot %.3f)"
|
|
% wall_forward.dot(Vector3.RIGHT))
|
|
model.set_wall_side(1.0)
|
|
await _settle(model, "wall_run", WALL_RUN_SPEED)
|
|
_expect(model.current_clip_debug() == "WallRunRight",
|
|
"right wall selects the authored WallRunRight performance")
|
|
_expect(not model.clip_names_debug().has("WallRun"),
|
|
"the relabelled ground-run WallRun clip is absent")
|
|
|
|
# The imported performance must own the unarmed silhouette. A target rig's
|
|
# crossed/T-pose rest arms used to survive every clip because only relative
|
|
# bone rotations were copied.
|
|
model.set_weapon("")
|
|
model.set_locomotion(0.0, 0.0, 0.0)
|
|
await _settle(model, "idle", 0.0)
|
|
var left_shoulder := model._role_bone(
|
|
"shoulder.L", ["shoulder.L", "LeftShoulder", "clavicle_l"])
|
|
var right_shoulder := model._role_bone(
|
|
"shoulder.R", ["shoulder.R", "RightShoulder", "clavicle_r"])
|
|
var idle_drop := minf(
|
|
model.skeleton.get_bone_global_pose(left_shoulder).origin.y
|
|
- model.skeleton.get_bone_global_pose(left_hand).origin.y,
|
|
model.skeleton.get_bone_global_pose(right_shoulder).origin.y
|
|
- model.skeleton.get_bone_global_pose(right_hand).origin.y,
|
|
)
|
|
_expect(idle_drop > 0.22,
|
|
"unarmed idle hands hang below the shoulders (drop %.3f m)"
|
|
% idle_drop)
|
|
|
|
# A real backward capture turns/leans the whole body. The old fabricated
|
|
# version rotated only hips and legs by 180 degrees, leaving the first
|
|
# spine joint facing forward and creating an abdominal corkscrew.
|
|
model.set_locomotion(0.0, -1.0, 0.0)
|
|
await _settle(model, "ground", 8.25)
|
|
var spine_names: Array = model._rig_info.get("roles", {}).get("spine", [])
|
|
var first_spine := model.skeleton.find_bone(String(spine_names[0])) \
|
|
if not spine_names.is_empty() else -1
|
|
_expect(first_spine >= 0, "the first spine bone resolves")
|
|
if first_spine >= 0:
|
|
var hips_pose := model.skeleton.get_bone_global_pose(hips) \
|
|
.basis.get_rotation_quaternion()
|
|
var hips_rest := model.skeleton.get_bone_global_rest(hips) \
|
|
.basis.get_rotation_quaternion()
|
|
var spine_pose := model.skeleton.get_bone_global_pose(first_spine) \
|
|
.basis.get_rotation_quaternion()
|
|
var spine_rest := model.skeleton.get_bone_global_rest(first_spine) \
|
|
.basis.get_rotation_quaternion()
|
|
var hips_delta := hips_pose * hips_rest.inverse()
|
|
var spine_delta := spine_pose * spine_rest.inverse()
|
|
var abdomen_twist := hips_delta.angle_to(spine_delta)
|
|
_expect(abdomen_twist < 1.45,
|
|
"backward capture keeps hips and abdomen coherent (%.3f rad)"
|
|
% abdomen_twist)
|
|
|
|
var anchor := model.global_position + Vector3(3.0, 7.0, -6.0)
|
|
await _settle_grapple(model, anchor, Vector3(1.0, 0.0, 0.0))
|
|
_expect(model.current_clip_debug() == "Grapple",
|
|
"grapple selects the authored Grapple clip")
|
|
var grapple_scale := float(model._anim_tree.get("parameters/loco_scale/scale"))
|
|
_expect(absf(grapple_scale - 1.0) < 0.001,
|
|
"grapple holds its authored pose at 1.0x")
|
|
var grapple_foot_motion := await _sample_grapple_foot_motion(
|
|
model, foot, anchor, Vector3(1.0, 0.0, 0.0))
|
|
_expect(grapple_foot_motion < 0.06,
|
|
"grapple legs stay held instead of swimming (%.3f rad)"
|
|
% grapple_foot_motion)
|
|
|
|
var low: Dictionary = model.grapple_debug()
|
|
print(" grapple slow debug: ", low)
|
|
_expect(float(low.get("line_error", 1.0)) < 0.035,
|
|
"slow grapple palm lies on the cable ray (%.1f mm error)"
|
|
% (float(low.get("line_error", 1.0)) * 1000.0))
|
|
_expect(float(low.get("alignment", 1.0)) < 0.20,
|
|
"slow grapple hangs under gravity (alignment %.3f)"
|
|
% float(low.get("alignment", 1.0)))
|
|
var low_body: Quaternion = low.get(
|
|
"body_rotation", Quaternion.IDENTITY)
|
|
|
|
await _settle_grapple(model, anchor, Vector3(18.0, 2.0, 4.0))
|
|
var medium: Dictionary = model.grapple_debug()
|
|
print(" grapple medium debug: ", medium)
|
|
_expect(float(medium.get("alignment", 1.0)) < 0.60,
|
|
"medium grapple still reads as hanging (alignment %.3f)"
|
|
% float(medium.get("alignment", 1.0)))
|
|
|
|
await _settle_grapple(model, anchor, Vector3(32.0, 4.0, 8.0))
|
|
var fast: Dictionary = model.grapple_debug()
|
|
print(" grapple high-speed debug: ", fast)
|
|
_expect(float(fast.get("line_error", 1.0)) < 0.035,
|
|
"high-speed grapple palm stays on the cable ray (%.1f mm error)"
|
|
% (float(fast.get("line_error", 1.0)) * 1000.0))
|
|
_expect(float(fast.get("alignment", 0.0)) > 0.85,
|
|
"only high-speed grapple aligns the body (alignment %.3f)"
|
|
% float(fast.get("alignment", 0.0)))
|
|
var fast_body: Quaternion = fast.get(
|
|
"body_rotation", Quaternion.IDENTITY)
|
|
_expect(low_body.angle_to(fast_body) > 0.20,
|
|
"body orientation physically changes with swing energy (%.3f rad)"
|
|
% low_body.angle_to(fast_body))
|
|
|
|
model.queue_free()
|
|
_done()
|
|
|
|
|
|
func _settle(model: SkinnedPlayerModel, state: String, speed: float) -> void:
|
|
for _frame in SETTLE_FRAMES:
|
|
model.update_state(state, speed, false)
|
|
await process_frame
|
|
|
|
|
|
func _sample_foot_motion(
|
|
model: SkinnedPlayerModel,
|
|
foot: int,
|
|
state: String,
|
|
speed: float,
|
|
) -> float:
|
|
if foot < 0:
|
|
return 0.0
|
|
var start := model.skeleton.get_bone_pose_rotation(foot)
|
|
var greatest := 0.0
|
|
for _frame in SAMPLE_FRAMES:
|
|
model.update_state(state, speed, false)
|
|
await process_frame
|
|
greatest = maxf(greatest, start.angle_to(
|
|
model.skeleton.get_bone_pose_rotation(foot)))
|
|
return greatest
|
|
|
|
|
|
func _settle_grapple(model: SkinnedPlayerModel, anchor: Vector3,
|
|
velocity: Vector3) -> void:
|
|
for _frame in SETTLE_FRAMES:
|
|
model.update_state("grapple", velocity.length(), false)
|
|
model.set_grapple_target(anchor, velocity)
|
|
await process_frame
|
|
|
|
|
|
func _sample_grapple_foot_motion(
|
|
model: SkinnedPlayerModel,
|
|
foot: int,
|
|
anchor: Vector3,
|
|
velocity: Vector3,
|
|
) -> float:
|
|
if foot < 0:
|
|
return 0.0
|
|
var start := model.skeleton.get_bone_pose_rotation(foot)
|
|
var greatest := 0.0
|
|
for _frame in SAMPLE_FRAMES:
|
|
model.update_state("grapple", velocity.length(), false)
|
|
model.set_grapple_target(anchor, velocity)
|
|
await process_frame
|
|
greatest = maxf(greatest, start.angle_to(
|
|
model.skeleton.get_bone_pose_rotation(foot)))
|
|
return greatest
|
|
|
|
|
|
func _expect(ok: bool, description: String) -> void:
|
|
if ok:
|
|
print(" OK: ", description)
|
|
else:
|
|
printerr(" FAIL: ", description)
|
|
_failures += 1
|
|
|
|
|
|
func _done() -> void:
|
|
print("\n=== AUTHORED TRAVERSAL SUMMARY ===")
|
|
print("Failures: %d" % _failures)
|
|
quit(1 if _failures > 0 else 0)
|