File size: 14,640 Bytes
a54e6a7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 | """Combat moves built from the motion primitives. Each move edits a Track over a frame range and keeps feet planted
(or stepping) so the validator's foot-slide and floor checks pass without per-shot hand tuning.
Conventions: frame ranges are [t0, t1); world xy targets in cm; humanoid moves assume the BOSSV2V 17-joint layout with
the weapon in hand_r; quadruped moves assume the `quadruped`/`dragon` joint names.
"""
import numpy as np
from .geometry import rot_axis, rot_z, UP
from .motion import ease
flat = lambda v: np.array([v[0], v[1], 0.0])
unit = lambda v: np.asarray(v, float) / np.linalg.norm(v)
def _clip01(x):
return float(np.clip(x, 0.0, 1.0))
# ------------------------------------------------------------------------------------------------------ feet control
def plant(tr, t0, t1, targets=None, pole_up=0.3):
"""IK every leg to fixed world feet over [t0, t1). targets: {chain: xyz}; default = feet at t0 dropped to z=0."""
chains = tr.legs()
targets = targets or {c: flat(tr.poses[t0, tr.j(c[2])]) for c in chains}
for t in range(t0, min(t1, tr.T)):
for c in chains:
tr.two_bone_ik(t, *c, target=targets[c], pole=tr.forward(t) + UP * pole_up)
return targets
def step_to(tr, t0, t1, end_targets, lead=None, lift=None, pole_up=0.3, start_targets=None):
"""Move each foot from its t0 position to end_targets[chain] with a lifted step, leading legs in the first 60 %
of the range and trailing legs in the last 60 %; feet are planted otherwise. The body must already be where it
should be for these frames (translate/turn first)."""
chains = tr.legs()
lead = lead or ("front" if any(c[0].startswith("front") for c in chains) else "thigh_l")
lift = lift if lift is not None else 0.12 * tr.sk.height
start = start_targets or {c: flat(tr.poses[t0, tr.j(c[2])]) for c in chains}
for t in range(t0, min(t1, tr.T)):
u = (t - t0) / max(1, t1 - t0 - 1)
for c in chains:
s = _clip01(u / 0.6) if c[0].startswith(lead) else _clip01((u - 0.4) / 0.6)
k = ease(s)
target = start[c] * (1 - k) + end_targets[c] * k + UP * lift * np.sin(np.pi * s)
tr.two_bone_ik(t, *c, target=target, pole=tr.forward(t) + UP * pole_up)
return end_targets
def body_feet_offsets(tr, t):
"""Feet relative to the root in the body frame at frame t (for re-planting after moves)."""
R = rot_z(-tr.yaw[t]); root = flat(tr.poses[t, 0])
return {c: (flat(tr.poses[t, tr.j(c[2])]) - root) @ R.T for c in tr.legs()}
def feet_at(tr, t, offsets):
R = rot_z(tr.yaw[t]); root = flat(tr.poses[t, 0])
return {c: flat(root + o @ R.T) for c, o in offsets.items()}
# ----------------------------------------------------------------------------------------------------- body moves
def step_shift(tr, t0, t1, vec, hold_until=None, lead=None, extra=None):
"""Shift the body by vec (world cm) over [t0, t1) with stepping feet; hold the new position afterwards (until the
end of the track or hold_until). extra(t, u) can rotate subtrees before the feet are solved."""
vec = np.asarray(vec, float); end = tr.T if hold_until is None else hold_until
offs = body_feet_offsets(tr, t0); start = {c: flat(tr.poses[t0, tr.j(c[2])]) for c in tr.legs()}
for t in range(t0, end):
u = ease(_clip01((t - t0) / max(1, t1 - t0)))
tr.translate(t, t + 1, vec * u)
if extra:
extra(t, u)
ends = {c: start[c] + flat(vec) for c in start}
step_to(tr, t0, t1, ends, lead=lead, start_targets=start)
plant(tr, t1, end, ends)
_ = offs
def turn_in_place(tr, t0, t1, dyaw, hold_until=None):
"""Turn about the root by dyaw (rad) with stepping feet, holding the new facing afterwards."""
start = {c: flat(tr.poses[t0, tr.j(c[2])]) for c in tr.legs()}
offs = body_feet_offsets(tr, t0)
tr.turn(t0, t1, dyaw, hold=True)
end = tr.T if hold_until is None else hold_until
ends = feet_at(tr, min(t1, tr.T - 1), offs)
step_to(tr, t0, t1, ends, start_targets=start)
plant(tr, t1, end, ends)
def turn_toward(tr, t0, t1, target_xy, hold_until=None):
d = flat(np.asarray(target_xy, float)[:2].tolist() + [0]) - flat(tr.poses[t0, 0])
want = np.arctan2(d[1], d[0]); dy = (want - tr.yaw[t0] + np.pi) % (2 * np.pi) - np.pi
turn_in_place(tr, t0, t1, dy, hold_until)
def crouch(tr, t0, t1, depth, hold_until=None, release=None):
"""Lower the body by depth cm (eased) with planted feet; hold until hold_until, then rise over release frames."""
feet = {c: flat(tr.poses[t0, tr.j(c[2])]) for c in tr.legs()}
end = tr.T if hold_until is None else hold_until
for t in range(t0, min(tr.T, end + (release or 0))):
if t < t1:
u = ease((t - t0) / max(1, t1 - t0))
elif t < end:
u = 1.0
else:
u = 1 - ease((t - end) / release)
tr.translate(t, t + 1, -UP * depth * u)
plant(tr, t0, min(tr.T, end + (release or 0)), feet)
# ------------------------------------------------------------------------------------------------ quadruped moves
def pounce(tr, t0, t_takeoff, t_land, target_xy, height=120.0, crouch_depth=None, recover=14, bite=0.5):
"""Quadruped leap: crouch [t0, t_takeoff), fly to put the front paws at target_xy, land and stand back up.
Front legs reach forward and hind legs stretch back in the air; the head dips to bite on the way down."""
H = tr.sk.meta.get("shoulder_height", tr.sk.height * 0.5)
crouch_depth = crouch_depth if crouch_depth is not None else 0.2 * H
crouch(tr, t0, t_takeoff, crouch_depth, hold_until=t_takeoff)
offs = body_feet_offsets(tr, t0)
fwd = tr.forward(t_takeoff)
# a wyvern's forelimbs are its wings, so it has no "front" legs and lands on its hind feet instead
front_feet = [c for c in tr.legs() if c[0].startswith("front")] or list(tr.legs())
front_off = np.mean([offs[c] for c in front_feet], axis=0) # body-frame front-paw centroid
root0 = tr.poses[t_takeoff, 0].copy()
land_root_xy = np.asarray(target_xy, float)[:2] - (rot_z(tr.yaw[t_takeoff]) @ front_off)[:2]
delta = np.array([land_root_xy[0] - root0[0], land_root_xy[1] - root0[1], 0.0])
leg_len = np.mean([tr.sk.bone_lengths[tr.j(c[1])] + tr.sk.bone_lengths[tr.j(c[2])] for c in tr.legs()])
for t in range(t_takeoff, tr.T):
u = _clip01((t - t_takeoff) / max(1, t_land - t_takeoff))
z = 4 * height * u * (1 - u) - crouch_depth * (1 - ease(_clip01(u * 4))) # rise out of the crouch smoothly
tr.translate(t, t + 1, delta * ease(u) + UP * (z if t < t_land else 0.0))
for t in range(t_takeoff, t_land):
u = (t - t_takeoff) / max(1, t_land - t_takeoff)
if bite:
tr.rotate_subtree(t, "neck_01", rot_axis(tr.right(t), bite * np.sin(np.pi * u)))
for c in tr.legs():
hip = tr.poses[t, tr.j(c[0])]
if c[0].startswith("front"):
target = hip + fwd * 0.55 * leg_len - UP * 0.55 * leg_len
else:
target = hip - fwd * 0.6 * leg_len - UP * 0.45 * leg_len
tr.two_bone_ik(t, *c, target=target, pole=fwd + UP * 0.3)
land_feet = feet_at(tr, min(t_land, tr.T - 1), offs)
crouch(tr, t_land, t_land + 3, 0.15 * H, hold_until=t_land + 3, release=recover)
plant(tr, t_land, tr.T, land_feet)
# ------------------------------------------------------------------------------------------------- humanoid moves
LEGS_H = (("thigh_l", "calf_l", "foot_l"), ("thigh_r", "calf_r", "foot_r"))
def stance_targets(tr, t, front_local=(58.0, -12.0), back_local=(-58.0, 12.0), front="l"):
"""World feet of a lunge stance for the root and facing at frame t; *_local are body-frame (forward, right) cm."""
R = rot_z(tr.yaw[t]); root = flat(tr.poses[t, 0])
loc = {front: front_local, ("r" if front == "l" else "l"): back_local}
return {c: flat(root + R @ np.array([loc[c[0][-1]][0], loc[c[0][-1]][1], 0.0])) for c in LEGS_H}
def stance_offsets(front_local=(58.0, -12.0), back_local=(-58.0, 12.0), front="l"):
"""The same stance as body-frame offsets per leg chain (for Track.gait(foot_offsets=...))."""
loc = {front: front_local, ("r" if front == "l" else "l"): back_local}
return {c: np.array([loc[c[0][-1]][0], loc[c[0][-1]][1], 0.0]) for c in LEGS_H}
def stance(tr, t0, t1, planted=True, from_current=False, **kw):
"""Humanoid lunge stance over [t0, t1): feet planted at their t0 stance positions (or following the root).
from_current plants the feet where they already are at t0 - 1 (continuity after a gait or another move)."""
fixed = ({c: flat(tr.poses[max(t0 - 1, 0), tr.j(c[2])]) for c in LEGS_H} if from_current and t0 > 0
else stance_targets(tr, t0, **kw))
for t in range(t0, min(t1, tr.T)):
tg = fixed if planted else stance_targets(tr, t, **kw)
for c in LEGS_H:
tr.two_bone_ik(t, *c, target=tg[c], pole=tr.forward(t) + UP * 0.2)
def _airborne_legs(tr, t0, t1, start, land, tuck_fn):
"""Feet through a jump: blend from the take-off feet to the tucked pose in the first 25 %, tucked in the middle,
blend to the landing stance in the last 25 %; never below the floor."""
def mix(a, b, kh, kv):
return np.array([a[0] * (1 - kh) + b[0] * kh, a[1] * (1 - kh) + b[1] * kh, a[2] * (1 - kv) + b[2] * kv])
for t in range(t0, t1):
u = (t - t0) / max(1, t1 - t0 - 1) # reaches 1 on the last airborne frame
for i, c in enumerate(LEGS_H):
tuck = tuck_fn(t, u, i, c)
if u < 0.25: # take-off: lift first, then draw the foot in
k = u / 0.25; tg = mix(start[c], tuck, ease(_clip01((k - 0.4) / 0.6)), ease(_clip01(k / 0.4)))
if tg[2] < 8.0: # still touching the ground: no horizontal travel yet
tg[:2] = start[c][:2]
elif u > 0.75: # landing: line up over the landing spot, then put it down
k = (u - 0.75) / 0.25; tg = mix(tuck, land[c], ease(_clip01(k / 0.6)), ease(_clip01((k - 0.6) / 0.4)))
if tg[2] < 8.0: # touching down: already over the landing spot
tg[:2] = land[c][:2]
else:
tg = tuck.copy()
tg[2] = max(tg[2], 0.0)
tr.two_bone_ik(t, *c, target=tg, pole=tr.forward(t))
def side_hop(tr, t0, t1, offset_xy, height=35.0, tilt=0.45, stance_kw=None):
"""Dodge hop with a sideways body roll, landing back into a planted stance."""
stance_kw = stance_kw or {}
start = {c: flat(tr.poses[t0, tr.j(c[2])]) for c in LEGS_H}
tr.jump(t0, t1, height=height, offset=offset_xy)
off = np.array([offset_xy[0], offset_xy[1], 0.0]); side = np.sign(off @ tr.right(t0)) or 1.0
leg = tr.sk.bone_lengths[tr.j("calf_l")] + tr.sk.bone_lengths[tr.j("foot_l")]
land = stance_targets(tr, min(t1, tr.T - 1), **stance_kw)
for t in range(t0, t1):
u = (t - t0) / max(1, t1 - t0)
tr.rotate_subtree(t, "spine_01", rot_axis(tr.forward(t), -side * tilt * np.sin(np.pi * u)))
_airborne_legs(tr, t0, t1, start, land,
lambda t, u, i, c: tr.poses[t, tr.j(c[0])] - UP * leg * (0.95 - 0.4 * np.sin(np.pi * u)) + tr.forward(t) * 10)
stance(tr, t1, tr.T, **stance_kw)
def arm_arc(tr, t0, t1, axis, angles, joint="upperarm_r"):
"""Rotate an arm subtree about a body axis ('right', 'up', 'forward' or a vector) following keyframed angles:
angles = [(u, rad), ...] with u in [0, 1] over [t0, t1); held weapons follow."""
us = np.array([a[0] for a in angles]); vs = np.array([a[1] for a in angles])
for t in range(t0, min(t1, tr.T)):
u = (t - t0) / max(1, t1 - t0 - 1)
k = np.searchsorted(us, u, side="right") - 1; k = min(max(k, 0), len(us) - 2)
w = ease(_clip01((u - us[k]) / max(us[k + 1] - us[k], 1e-6)))
a = vs[k] * (1 - w) + vs[k + 1] * w
ax = {"right": tr.right(t), "forward": tr.forward(t), "up": UP}[axis] if isinstance(axis, str) else axis
tr.rotate_subtree(t, joint, rot_axis(ax, a))
def slash(tr, t0, t1, direction="rl", arc=1.8, twist=0.45, recover=10):
"""Horizontal sword slash: wind back, shoulder sweep with a torso twist, back to guard over `recover` frames."""
s = -1.0 if direction == "rl" else 1.0
x = (t1 - t0) / (t1 - t0 + recover)
arm_arc(tr, t0, t1 + recover, "up", [(0.0, 0.0), (0.3 * x, -s * 0.6), (x, s * arc), (1.0, 0.0)])
arm_arc(tr, t0, t1 + recover, "up", [(0.0, 0.0), (0.3 * x, -s * 0.2), (x, s * twist), (1.0, 0.0)], joint="spine_01")
def jump_attack(tr, t0, t_land, target_xy, height=70.0, windup=6, recover=10, stance_kw=None):
"""Leaping overhead chop: crouch windup, fly to target_xy with the sword raised overhead, chop down through the
landing into a planted lunge stance."""
stance_kw = stance_kw or {}
t_take = t0 + windup
start = {c: flat(tr.poses[max(t0 - 1, 0), tr.j(c[2])]) for c in LEGS_H} # take off from where the feet are
root0 = tr.poses[t_take, 0].copy()
d = np.array([target_xy[0] - root0[0], target_xy[1] - root0[1], 0.0])
for t in range(t0, t_take):
tr.translate(t, t + 1, -UP * 12 * ease((t - t0) / max(1, windup)))
for t in range(t_take, tr.T):
u = _clip01((t - t_take) / max(1, t_land - t_take))
z = 4 * height * u * (1 - u) - 12 * (1 - ease(_clip01(u * 3))) # leave the 12 cm windup crouch smoothly
tr.translate(t, t + 1, d * ease(u) + UP * (z if t < t_land else 0.0))
leg = tr.sk.bone_lengths[tr.j("calf_l")] + tr.sk.bone_lengths[tr.j("foot_l")]
for t in range(t0, t_take):
for c in LEGS_H:
tr.two_bone_ik(t, *c, target=start[c], pole=tr.forward(t) + UP * 0.2)
land = stance_targets(tr, min(t_land, tr.T - 1), **stance_kw)
_airborne_legs(tr, t_take, t_land, start, land,
lambda t, u, i, c: tr.poses[t, tr.j(c[0])] - UP * leg * (0.95 - 0.45 * np.sin(np.pi * u))
+ tr.forward(t) * ((18 if i == 0 else -12) * np.sin(np.pi * u)))
stance(tr, t_land, tr.T, **stance_kw)
total = (t_land + recover) - t0
arm_arc(tr, t0, t_land + recover, "right",
[(0.0, 0.0), ((t_take - t0 + 0.55 * (t_land - t_take)) / total, -3.3), ((t_land + 2 - t0) / total, -0.9), (1.0, 0.0)])
arm_arc(tr, t_take, t_land + recover, "right", [(0.0, 0.0), (0.5, -0.25), ((t_land + 2 - t_take) / (t_land + recover - t_take), 0.35), (1.0, 0.0)], joint="spine_01")
|