"""Skeletons for the condition proxy: a joint tree, per-joint part ids, a rest pose, and capsule sizing. Part ids (1..30) reuse the BOSSV2V humanoid vocabulary where the anatomy matches so a quadruped's front legs look like arms and its hind legs like legs to the model; new structures get new ids: 1 pelvis/root 2 spine_01 3 spine_02/chest 4 neck 5 head 6/7/8 upperarm/lowerarm/hand L 9/10/11 R 12/13/14 thigh/calf/foot L 15/16/17 R 18 weapon 19-22 tail segments 23-25 wing L 26-28 wing R 29-30 extra limbs Rest poses are in a local frame: root above the origin, facing +X, UE axes (Y = right, so the LEFT side is -Y), cm. Links are drawn with the CHILD joint's part id (dataset rule). """ from dataclasses import dataclass, field import numpy as np HUMANOID_JOINTS = ["pelvis", "spine_01", "spine_02", "neck_01", "head", "upperarm_l", "lowerarm_l", "hand_l", "upperarm_r", "lowerarm_r", "hand_r", "thigh_l", "calf_l", "foot_l", "thigh_r", "calf_r", "foot_r"] HUMANOID_PARENTS = ["", "pelvis", "spine_01", "spine_02", "neck_01", "neck_01", "upperarm_l", "lowerarm_l", "neck_01", "upperarm_r", "lowerarm_r", "pelvis", "thigh_l", "calf_l", "pelvis", "thigh_r", "calf_r"] LINE_RATIO, JOINT_RATIO, HEAD_RATIO = 0.006, 0.012, 0.018 # of body height, as in condition_profile.json WEAPON_PART = 18 @dataclass class Weapon: hand: str # joint the grip follows length: float # cm radius: float # cm (dataset: player 1.75, boss 5.5) grip_offset: float = 0.0 # cm from the grip end to the hand along the shaft (butt sticks out behind the hand) @dataclass class Skeleton: name: str joints: list parents: list # parent joint name per joint ("" for the root) parts: list # part id per joint rest: np.ndarray # (J, 3) local rest positions, facing +X, root at index 0 height: float # body size used for capsule radii (cm) weapon: Weapon = None family: str = "custom" meta: dict = field(default_factory=dict) def __post_init__(self): self.rest = np.asarray(self.rest, float) assert len(self.joints) == len(self.parents) == len(self.parts) == len(self.rest) assert self.parents[0] == "" and all(p in self.joints for p in self.parents[1:]) assert all(1 <= p <= 30 for p in self.parts) self.index = {n: i for i, n in enumerate(self.joints)} self.parent_idx = [-1] + [self.index[p] for p in self.parents[1:]] assert all(self.parent_idx[i] < i for i in range(1, len(self.joints))), "joints must be topologically ordered" @property def bone_lengths(self): return np.array([0.0] + [np.linalg.norm(self.rest[i] - self.rest[self.parent_idx[i]]) for i in range(1, len(self.joints))]) def descendants(self, joint): """Indices of `joint` and every joint below it.""" root = self.index[joint]; out = [root] for i in range(root + 1, len(self.joints)): if self.parent_idx[i] in out: out.append(i) return out def place(self, root_pos, yaw=0.0): """Rest pose moved so the root sits at root_pos and the body faces yaw (rad about +Z; 0 = +X).""" from .geometry import rot_z return np.asarray(root_pos, float) + (self.rest - self.rest[0]) @ rot_z(yaw).T def capsules(self, pose, slot, weapon_ends=None): """Capsules for one frame: links (child part), joint spheres, weapon stick.""" caps = [] size = self.height for i in range(1, len(self.joints)): caps.append((pose[self.parent_idx[i]], pose[i], size * LINE_RATIO, slot * 32 + self.parts[i])) for i, n in enumerate(self.joints): r = HEAD_RATIO if self.parts[i] == 5 else JOINT_RATIO caps.append((pose[i], pose[i], size * r, slot * 32 + self.parts[i])) if weapon_ends is not None and self.weapon is not None: caps.append((weapon_ends[0], weapon_ends[1], self.weapon.radius, slot * 32 + WEAPON_PART)) return caps # ----------------------------------------------------------------------------------------------------------- families def humanoid(height=180.0, shoulder=0.13, hip=0.055, weapon=None, name="humanoid", lengths=None): """Proportional humanoid in the BOSSV2V 17-joint layout, standing, arms slightly out. `lengths` (joint -> bone cm) overrides the proportional defaults (use humanoid_from_states for a measured character).""" H = height z_pelvis = 0.53 * H rest = { "pelvis": [0, 0, z_pelvis], "spine_01": [0, 0, z_pelvis + 0.07 * H], "spine_02": [0, 0, z_pelvis + 0.17 * H], "neck_01": [0, 0, z_pelvis + 0.30 * H], "head": [0, 0, z_pelvis + 0.40 * H], "upperarm_l": [0, -shoulder * H, z_pelvis + 0.29 * H], "lowerarm_l": [0, -shoulder * H - 0.05 * H, z_pelvis + 0.13 * H], "hand_l": [0.03 * H, -shoulder * H - 0.07 * H, z_pelvis - 0.02 * H], "upperarm_r": [0, shoulder * H, z_pelvis + 0.29 * H], "lowerarm_r": [0, shoulder * H + 0.05 * H, z_pelvis + 0.13 * H], "hand_r": [0.03 * H, shoulder * H + 0.07 * H, z_pelvis - 0.02 * H], "thigh_l": [0, -hip * H, z_pelvis - 0.02 * H], "calf_l": [0.01 * H, -hip * H, 0.28 * H], "foot_l": [0, -hip * H, 0.0], "thigh_r": [0, hip * H, z_pelvis - 0.02 * H], "calf_r": [0.01 * H, hip * H, 0.28 * H], "foot_r": [0, hip * H, 0.0], } pts = np.array([rest[j] for j in HUMANOID_JOINTS], float) sk = Skeleton(name, HUMANOID_JOINTS, HUMANOID_PARENTS, list(range(1, 18)), pts, H, weapon, "humanoid") if lengths: sk = with_bone_lengths(sk, lengths) return sk def with_bone_lengths(sk, lengths): """Rescale individual bones (joint -> new length from its parent) keeping rest directions.""" rest = sk.rest.copy(); rel = sk.rest - np.r_[[sk.rest[0]], sk.rest[sk.parent_idx[1:]]] for i in range(1, len(sk.joints)): d = rel[i]; L = np.linalg.norm(d) new_L = lengths.get(sk.joints[i], L) rest[i] = rest[sk.parent_idx[i]] + (d / L * new_L if L > 1e-6 else d) return Skeleton(sk.name, sk.joints, sk.parents, sk.parts, rest, sk.height, sk.weapon, sk.family, dict(sk.meta)) def _chain(prefix, start, direction, n, seg_len, parent, parts): names, parents, pts, pids = [], [], [], [] d = np.asarray(direction, float); d = d / np.linalg.norm(d) prev, p = parent, np.asarray(start, float) for k in range(n): p = p + d * seg_len nm = f"{prefix}_{k + 1}" names.append(nm); parents.append(prev); pts.append(p.copy()); pids.append(parts[min(k, len(parts) - 1)]) prev = nm return names, parents, pts, pids def quadruped(body_length=300.0, shoulder_height=150.0, neck=80.0, head=50.0, tail_segments=4, tail_length=200.0, name="quadruped", wings=0.0, belly=None, leg_spread=0.18): """Four-legged beast facing +X. Front legs use the arm part ids, hind legs the leg part ids. wings > 0 adds two 3-segment wings of that span (cm) at the shoulders (dragon).""" Hs = shoulder_height; half = body_length / 2; lat = leg_spread * body_length belly = Hs * 0.62 if belly is None else float(belly) # chest/elbow line: the legs hang from here, not from the back # trunk height above ground: short-legged beasts sit low names = ["pelvis", "spine_01", "spine_02", "neck_01", "head"] parents = ["", "pelvis", "spine_01", "spine_02", "neck_01"] withers = Hs # the back rides at the nominal shoulder height; the drop pts = [[-half, 0, Hs * 0.94], [0, 0, Hs * 0.97], [half, 0, withers], # from here down to `belly` is the chest depth [half + neck * 0.55, 0, withers + neck * 0.35], [half + neck * 0.55 + head * 0.9, 0, withers + neck * 0.18]] parts = [1, 2, 3, 4, 5] def leg(prefix, hip_joint, x, y, ids, bend): """bend -1: elbow folds back (front legs); +1: stifle points forward (hind legs) -> animal, not table.""" nonlocal names, parents, pts, parts upper = [x, y, belly] knee = [x + bend * 0.28 * belly, y, belly * 0.48] foot = [x - bend * 0.08 * belly, y, 0.0] names += [f"{prefix}_upper", f"{prefix}_lower", f"{prefix}_foot"] parents += [hip_joint, f"{prefix}_upper", f"{prefix}_lower"] pts += [upper, knee, foot]; parts += list(ids) leg("front_l", "spine_02", half, -lat, (6, 7, 8), -1); leg("front_r", "spine_02", half, lat, (9, 10, 11), -1) leg("hind_l", "pelvis", -half, -lat, (12, 13, 14), 1); leg("hind_r", "pelvis", -half, lat, (15, 16, 17), 1) if tail_segments: n, pa, pp, pi = _chain("tail", pts[0], [-1, 0, -0.15], tail_segments, tail_length / tail_segments, "pelvis", [19, 20, 21, 22]) names += n; parents += pa; pts += [list(x) for x in pp]; parts += pi if wings > 0: arm = wings / 2 * 0.42 # shoulder -> raised wrist finger = wings / 2 * 0.58 # wrist -> tip, fingers sweep down and back into an arc for side, sgn, ids in (("wing_l", -1, [23, 24, 25]), ("wing_r", 1, [26, 27, 28])): root_pt = [half * 0.75, sgn * lat * 0.45, belly * 1.05] nm, pa, pp, pi = _chain(side, root_pt, [0.05, sgn * 0.8, 0.62], 2, arm / 2, "spine_02", ids[:2]) names += nm; parents += pa; pts += [list(x) for x in pp]; parts += pi wrist = np.asarray(pp[-1], float); wrist_name = nm[-1] # graded finger lengths with the outer half curling down: a swept membrane edge, not three straight spokes for k, (d, frac) in enumerate((([0.45, sgn * 0.85, -0.25], 1.00), ([-0.15, sgn * 0.92, -0.32], 0.86), ([-0.70, sgn * 0.62, -0.30], 0.64))): d = np.asarray(d, float); d /= np.linalg.norm(d) d2 = d + np.array([0.0, 0.0, -0.55]); d2 /= np.linalg.norm(d2) a = wrist + d * finger * frac * 0.55 b = a + d2 * finger * frac * 0.45 names += [f"{side}f{k + 1}_1", f"{side}f{k + 1}_2"] parents += [wrist_name, f"{side}f{k + 1}_1"] pts += [list(a), list(b)]; parts += [ids[2], ids[2]] size = max(body_length, Hs) return Skeleton(name, names, parents, parts, np.array(pts, float), size, None, "dragon" if wings > 0 else "quadruped", dict(body_length=body_length, shoulder_height=Hs)) def dragon(body_length=500.0, shoulder_height=260.0, wingspan=1200.0, **kw): return quadruped(body_length, shoulder_height, neck=kw.pop("neck", 220.0), head=kw.pop("head", 110.0), tail_segments=kw.pop("tail_segments", 4), tail_length=kw.pop("tail_length", 450.0), wings=wingspan, name=kw.pop("name", "dragon"), **kw) def wyvern(body_length=380.0, hip_height=185.0, shoulder_height=375.0, neck=150.0, head=90.0, wingspan=1230.0, wing_rise=210.0, stance_width=315.0, tail_segments=5, tail_length=280.0, name="wyvern"): """Two-legged winged dragon facing +X: the wings ARE the forelimbs, so there are NO front legs. This is WildWorld's most common monster body plan (2 legs + 2 wings = 4874 of 15226 windows; 4 legs + 2 wings is only 520), and it is what concept art calls a dragon. quadruped(wings=...) draws four legs plus wings and produces a ten-limbed creature. Every size here is meant to be MEASURED off the first frame (hip and shoulder height, body length, wingspan), never guessed.""" half = body_length / 2; hs = shoulder_height; half_span = wingspan / 2; lat = stance_width / 2 names = ["pelvis", "spine_01", "spine_02", "neck_01", "head"] parents = ["", "pelvis", "spine_01", "spine_02", "neck_01"] pts = [[-half, 0, hip_height], # reared trunk: hips low, shoulders high [0, 0, (hip_height + hs) / 2], [half, 0, hs], [half + neck * 0.55, 0, hs * 0.97], [half + neck * 0.55 + head, 0, hs * 0.88]] # head carried forward and a little below the back parts = [1, 2, 3, 4, 5] for side, sgn, ids in (("hind_l", -1, (12, 13, 14)), ("hind_r", 1, (15, 16, 17))): names += [f"{side}_upper", f"{side}_lower", f"{side}_foot"] parents += ["pelvis", f"{side}_upper", f"{side}_lower"] pts += [[-half, sgn * lat, hip_height * 0.98], [-half + 0.30 * hip_height, sgn * lat, hip_height * 0.46], # stifle forward, bird-like [-half - 0.06 * hip_height, sgn * lat, 0.0]] parts += list(ids) if tail_segments: n, pa, pp, pi = _chain("tail", pts[0], [-1, 0, -0.25], tail_segments, tail_length / tail_segments, "pelvis", [19, 20, 21, 22]) names += n; parents += pa; pts += [list(x) for x in pp]; parts += pi for side, sgn, ids in (("wing_l", -1, [23, 24, 25]), ("wing_r", 1, [26, 27, 28])): root = np.array([half * 0.75, sgn * lat * 0.35, hs * 0.98]) wrist = np.array([root[0] + 0.06 * half_span, sgn * 0.40 * half_span, root[2] + 0.62 * wing_rise]) elbow = root + 0.5 * (wrist - root) + np.array([0.0, 0.0, 0.12 * wing_rise]) names += [f"{side}_1", f"{side}_2"]; parents += ["spine_02", f"{side}_1"] pts += [list(elbow), list(wrist)]; parts += ids[:2] # leading finger carries the claw high, middle finger sets the span, trailing finger drops behind for k, (fx, fy, fz) in enumerate(((0.28, 0.48, 0.87), (-0.02, 1.00, 0.00), (-0.42, 0.66, -0.30))): tip = np.array([root[0] + fx * half_span, sgn * fy * half_span, root[2] + fz * wing_rise]) mid = wrist + 0.5 * (tip - wrist) + np.array([0.0, 0.0, 0.03 * wing_rise]) names += [f"{side}f{k + 1}_1", f"{side}f{k + 1}_2"] parents += [f"{side}_2", f"{side}f{k + 1}_1"] pts += [list(mid), list(tip)]; parts += [ids[2], ids[2]] return Skeleton(name, names, parents, parts, np.array(pts, float), max(body_length, hs), None, "dragon", dict(body_length=body_length, shoulder_height=hs, wingspan=wingspan)) def serpent(length=1200.0, segments=10, girth_height=60.0, head_raise=120.0, name="serpent", s_curve=0.55): """Snake/worm facing +X: root at the front of the body, neck and head rearing forward, body segments trailing -X.""" seg = length / segments # Reared front: the neck rises and leans back, then the head comes forward again -> the S the reference art shows. names = ["pelvis", "neck_01", "neck_02", "neck_03", "neck_04", "head"] parents = ["", "pelvis", "neck_01", "neck_02", "neck_03", "neck_04"] # five joints trace a smooth S (scaled by the rear-up, not by one body segment): rise forward, ease back # over the coil, then the head thrusts out again. Three joints made it read as a hard Z. k = s_curve / 0.55 prof = ((0.22 * k, 0.25), (0.31 * k, 0.52), (0.19 * k, 0.74), (0.17 * k, 0.96), (0.56, 0.90)) pts = [[0.0, 0.0, girth_height]] + [[head_raise * fx, 0.0, girth_height + head_raise * fz] for fx, fz in prof] parts = [1, 3, 3, 4, 4, 5] prev = "pelvis" for k in range(1, segments): names.append(f"body_{k}"); parents.append(prev); prev = f"body_{k}" pts.append([-k * seg, 0.0, girth_height]); parts.append(2 if k < segments / 3 else (3 if k < 2 * segments / 3 else 19 + min(3, k % 4))) return Skeleton(name, names, parents, parts, np.array(pts, float), max(length / 4, girth_height + head_raise), None, "serpent", dict(length=length, segments=segments)) def spider(leg_count=8, body_length=200.0, body_height=90.0, leg_span=350.0, name="spider"): """Arachnid/insect: thorax + abdomen + head, leg_count legs (even) spread along the body, 3 segments each.""" names = ["pelvis", "spine_01", "spine_02", "neck_01", "head"] parents = ["", "pelvis", "spine_01", "spine_02", "neck_01"] L = body_length pts = [[-0.4 * L, 0, body_height], [-0.1 * L, 0, body_height], [0.15 * L, 0, body_height], [0.3 * L, 0, body_height * 1.02], [0.45 * L, 0, body_height * 0.95]] parts = [1, 2, 3, 4, 5] pairs = leg_count // 2 id_sets = [((6, 7, 8), (9, 10, 11)), ((12, 13, 14), (15, 16, 17)), ((29, 7, 8), (30, 10, 11)), ((29, 13, 14), (30, 16, 17))] for k in range(pairs): x = 0.2 * L - k * (0.35 * L / max(1, pairs - 1)) for side, sgn, ids in (("l", -1, id_sets[k % 4][0]), ("r", 1, id_sets[k % 4][1])): pre = f"leg{k + 1}_{side}" hip = [x, sgn * 0.12 * L, body_height] knee = [x + 0.05 * L * (1.5 - k), sgn * leg_span * 0.3, body_height * 1.6] foot = [x + 0.12 * L * (1.5 - k), sgn * leg_span * 0.5, 0.0] names += [f"{pre}_hip", f"{pre}_knee", f"{pre}_foot"] parents += ["spine_01", f"{pre}_hip", f"{pre}_knee"] pts += [hip, knee, foot]; parts += list(ids) return Skeleton(name, names, parents, parts, np.array(pts, float), max(body_length, leg_span) * 0.8, None, "spider", dict(leg_count=leg_count)) def humanoid_from_states(states_path, entity, weapon_radius=None, name=None): """Measured humanoid (BOSSV2V entity 0 = player, 1 = boss): median bone lengths over the clip on the proportional rest directions, plus the measured weapon length and grip offset from the right hand.""" z = np.load(states_path) Jw = z["joints_world_cm"][:, entity]; Ww = z["weapon_endpoints_world_cm"][:, entity] base = humanoid(height=float(np.median(Jw[:, 4, 2] - np.minimum(Jw[:, 13, 2], Jw[:, 16, 2]))) * 1.08) lengths = {} for i in range(1, 17): lengths[HUMANOID_JOINTS[i]] = float(np.median(np.linalg.norm(Jw[:, i] - Jw[:, base.parent_idx[i]], axis=1))) wlen = float(np.median(np.linalg.norm(Ww[:, 1] - Ww[:, 0], axis=1))) grip = float(np.median(np.linalg.norm(Ww[:, 0] - Jw[:, 10], axis=1))) radius = weapon_radius if weapon_radius is not None else (1.75 if entity == 0 else 5.5) height = 180.0 if entity == 0 else 460.0 # the dataset's fixed sizing constants sk = with_bone_lengths(humanoid(height=height), lengths) sk.weapon = Weapon("hand_r", wlen, radius, grip) sk.name = name or ("player" if entity == 0 else "boss"); sk.height = height return sk