"""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")