@drawcall/acta 0.1.7 → 0.1.8

package/dist/behavior.d.ts

@@ -23,6 +23,7 @@ export type CharacterBehaviorEvents = {
 export declare class CharacterBehavior extends EventDispatcher<CharacterBehaviorEvents> {
     private readonly model;
     applyMove?: ((worldMoveVelocity: Vector3, delta: number) => void) | undefined;
+    applyJump?: (() => void) | undefined;
     properties: Partial<Record<string, boolean>>;
     private readonly computedProperties;
     worldHeadDirection: Vector3 | undefined;
@@ -48,7 +49,10 @@ export declare class CharacterBehavior extends EventDispatcher<CharacterBehavior
     private readonly gltfLoader;
     private moveStatus;
     private isAiming;
-    constructor(behavior: Behavior, animationUrls: Record<string, string>, audioUrls: Record<string, string>, model: CharacterModel, applyMove?: ((worldMoveVelocity: Vector3, delta: number) => void) | undefined, loadingManager?: LoadingManager);
+    private currentBodyYaw;
+    private readonly currentSpineQuat;
+    private readonly currentNeckEuler;
+    constructor(behavior: Behavior, animationUrls: Record<string, string>, audioUrls: Record<string, string>, model: CharacterModel, applyMove?: ((worldMoveVelocity: Vector3, delta: number) => void) | undefined, applyJump?: (() => void) | undefined, loadingManager?: LoadingManager);
     private init;
     private loadMoveAnimations;
     private loadBaseAimAnimation;

package/dist/behavior.js

@@ -9,6 +9,10 @@ const ZeroVector = new Vector3();
 const ForwardVector = new Vector3(0, 0, 1);
 const UpVector = new Vector3(0, 1, 0);
 const SpineAimYawOffset = -0.5;
+// Lerp speed constants for smooth rotation interpolation
+const BodyRotationSpeed = 10; // radians/sec
+const SpineRotationSpeed = 8; // factor for slerp
+const NeckRotationSpeed = 8; // factor for slerp
 const quaternionHelper = new Quaternion();
 const parentQuaternionInvHelper = new Quaternion();
 const localQuaternionHelper = new Quaternion();
@@ -16,11 +20,10 @@ const eulerHelper = new Euler();
 const directionHelper = new Vector3();
 const vectorHelper = new Vector3();
 //TODO: support direction AND position targets for head and aim
-//TODO: lerp everything (spine rotation etc)
-//TODO: jumping support
 export class CharacterBehavior extends EventDispatcher {
     model;
     applyMove;
+    applyJump;
     properties = {};
     computedProperties = {
         isMoving: () => this.worldMoveVelocity.length() > 0,
@@ -49,10 +52,15 @@ export class CharacterBehavior extends EventDispatcher {
     gltfLoader;
     moveStatus = 'none';
     isAiming = false;
-    constructor(behavior, animationUrls, audioUrls, model, applyMove, loadingManager) {
+    // Current rotation state for lerping
+    currentBodyYaw = 0;
+    currentSpineQuat = new Quaternion();
+    currentNeckEuler = new Euler(0, 0, 0, 'YXZ');
+    constructor(behavior, animationUrls, audioUrls, model, applyMove, applyJump, loadingManager) {
         super();
         this.model = model;
         this.applyMove = applyMove;
+        this.applyJump = applyJump;
         if (model instanceof VRM) {
             throw new Error(`not supported yet`);
         }
@@ -123,16 +131,21 @@ export class CharacterBehavior extends EventDispatcher {
     }
     async loadAudio(name, url) { }
     update(delta) {
+        // Compute target body yaw based on movement/aim/head direction
+        let targetBodyYaw = this.currentBodyYaw;
         if (this.moveStatus === 'fullbody' && this.worldMoveVelocity.lengthSq() > 0) {
             // Signed angle from forward (0,0,1) to move direction on XZ plane
-            this.model.scene.rotation.y = Math.PI + Math.atan2(this.worldMoveVelocity.x, this.worldMoveVelocity.z);
+            targetBodyYaw = Math.PI + Math.atan2(this.worldMoveVelocity.x, this.worldMoveVelocity.z);
         }
         else if (this.worldAimDirection != null && this.isAiming) {
-            this.model.scene.rotation.y = Math.PI + Math.atan2(this.worldAimDirection.x, this.worldAimDirection.z);
+            targetBodyYaw = Math.PI + Math.atan2(this.worldAimDirection.x, this.worldAimDirection.z);
         }
         else if (this.worldHeadDirection != null) {
-            this.model.scene.rotation.y = Math.PI + Math.atan2(this.worldHeadDirection.x, this.worldHeadDirection.z);
+            targetBodyYaw = Math.PI + Math.atan2(this.worldHeadDirection.x, this.worldHeadDirection.z);
         }
+        // Lerp body yaw with angle wrapping
+        this.currentBodyYaw = lerpAngle(this.currentBodyYaw, targetBodyYaw, BodyRotationSpeed * delta);
+        this.model.scene.rotation.y = this.currentBodyYaw;
         this.updateTimeline?.(undefined, delta);
         this.model.mixer.update(delta);
         // Stabilize spine during aiming to face the aim direction
@@ -140,13 +153,16 @@ export class CharacterBehavior extends EventDispatcher {
             const spineBone = this.model.scene.getObjectByName('spine');
             // Extract yaw from aim direction and add PI offset for model facing
             const aimYaw = this.model.scene.rotation.y + Math.PI + SpineAimYawOffset;
-            // Create quaternion with just the yaw (no pitch/roll)
+            // Create target quaternion with just the yaw (no pitch/roll)
             eulerHelper.set(0, aimYaw, 0, 'YXZ');
             quaternionHelper.setFromEuler(eulerHelper);
             // Transform to spine's local space
             spineBone.parent.getWorldQuaternion(parentQuaternionInvHelper).invert();
             localQuaternionHelper.copy(parentQuaternionInvHelper).multiply(quaternionHelper);
-            spineBone.quaternion.copy(localQuaternionHelper);
+            // Slerp toward target (frame-rate independent)
+            const slerpFactor = 1 - Math.exp(-SpineRotationSpeed * delta);
+            this.currentSpineQuat.slerp(localQuaternionHelper, slerpFactor);
+            spineBone.quaternion.copy(this.currentSpineQuat);
             spineBone.updateMatrixWorld();
         }
         if (this.worldHeadDirection != null) {
@@ -154,12 +170,18 @@ export class CharacterBehavior extends EventDispatcher {
             // Transform worldHeadDirection to neck's parent local space
             neckBone.parent.getWorldQuaternion(quaternionHelper).invert();
             directionHelper.copy(this.worldHeadDirection).applyQuaternion(quaternionHelper);
-            // Compute the local rotation that aligns (0,0,1) with the local target direction
+            // Compute target rotation that aligns (0,0,1) with the local target direction
             quaternionHelper.setFromUnitVectors(ForwardVector, directionHelper);
-            neckBone.rotation.setFromQuaternion(quaternionHelper, 'YXZ');
-            neckBone.rotation.z = 0;
-            neckBone.rotation.y = clamp(neckBone.rotation.y, -Math.PI / 2, Math.PI / 2);
-            neckBone.rotation.x = clamp(neckBone.rotation.x, -Math.PI / 2, Math.PI / 2);
+            eulerHelper.setFromQuaternion(quaternionHelper, 'YXZ');
+            // Compute target neck euler with clamping
+            const targetNeckY = clamp(eulerHelper.y, -Math.PI / 2, Math.PI / 2);
+            const targetNeckX = clamp(eulerHelper.x, -Math.PI / 2, Math.PI / 2);
+            // Lerp each axis independently (frame-rate independent)
+            const lerpFactor = 1 - Math.exp(-NeckRotationSpeed * delta);
+            this.currentNeckEuler.x += (targetNeckX - this.currentNeckEuler.x) * lerpFactor;
+            this.currentNeckEuler.y += (targetNeckY - this.currentNeckEuler.y) * lerpFactor;
+            this.currentNeckEuler.z = 0;
+            neckBone.rotation.copy(this.currentNeckEuler);
         }
         this.applyMove?.(this.moveStatus === 'none' ? ZeroVector : this.worldMoveVelocity, delta);
     }
@@ -324,17 +346,33 @@ export class CharacterBehavior extends EventDispatcher {
         const layer = computeAnimationLayers(mask);
         const self = this;
         return async function* () {
-            if (name)
-                self.dispatchEvent({ type: 'animationStarted', name });
+            if ((name === 'Jump_Loop' || name === 'Jump_Start' || name === 'Jump_Land') && mask != 'upperbody') {
+                self.moveStatus = mask ?? 'fullbody';
+            }
+            self.dispatchEvent({ type: 'animationStarted', name });
             try {
                 yield* action({
-                    init: () => startAnimation(animationAction, self.model.currentAnimations, { layer }),
-                    until: animationFinished(animationAction),
+                    init: () => startAnimation(animationAction, self.model.currentAnimations, { layer, paused: name === 'Jump_Start' }),
+                    until: name === 'Jump_Land' ? timePassed(150, 'milliseconds') : animationFinished(animationAction),
+                    update: name === 'Jump_Start'
+                        ? (_, _clock, actionTime) => {
+                            if (actionTime > 0.2 && animationAction.paused) {
+                                animationAction.paused = false;
+                                self.applyJump?.();
+                            }
+                            if (actionTime > 0.5 && self.properties['isGrounded'] === true) {
+                                //canceling
+                                return false;
+                            }
+                        }
+                        : undefined,
                 });
             }
             finally {
-                if (name)
-                    self.dispatchEvent({ type: 'animationFinished', name });
+                if ((name === 'Jump_Loop' || name === 'Jump_Start' || name === 'Jump_Land') && mask != 'upperbody') {
+                    self.moveStatus = 'none';
+                }
+                self.dispatchEvent({ type: 'animationFinished', name });
             }
         };
     }
@@ -363,8 +401,7 @@ export class CharacterBehavior extends EventDispatcher {
         const layer = computeAnimationLayers(mask, false);
         const self = this;
         return async function* () {
-            if (name)
-                self.dispatchEvent({ type: 'animationStarted', name });
+            self.dispatchEvent({ type: 'animationStarted', name });
             self.isAiming = true;
             try {
                 yield* action({
@@ -394,8 +431,7 @@ export class CharacterBehavior extends EventDispatcher {
             }
             finally {
                 self.isAiming = false;
-                if (name)
-                    self.dispatchEvent({ type: 'animationFinished', name });
+                self.dispatchEvent({ type: 'animationFinished', name });
             }
         };
     }
@@ -444,6 +480,14 @@ function computeAnimationLayers(mask, includeAim = true) {
         result.push('lowerbody');
     return result;
 }
+function lerpAngle(current, target, t) {
+    let diff = target - current;
+    while (diff > Math.PI)
+        diff -= 2 * Math.PI;
+    while (diff < -Math.PI)
+        diff += 2 * Math.PI;
+    return current + diff * Math.min(1, t);
+}
 function evaluateCondition(condition, properties, computedProperties) {
     switch (condition.type) {
         case 'isTrue':

package/dist/types.d.ts

@@ -17,6 +17,12 @@ export type Condition = {
  * @returns Array of unique property names
  */
 export declare function getProperties(behavior: Behavior): string[];
+/**
+ * Extracts all animation names used in a behavior tree.
+ * @param behavior - The behavior to extract animations from
+ * @returns Set of animation names (excluding 'Move' which is handled separately)
+ */
+export declare function extractUsedAnimations(behavior: Behavior): Set<string>;
 export type Behavior = {
     type: 'animation';
     name: string;

package/dist/types.js

@@ -8,10 +8,9 @@ export function getProperties(behavior) {
     function collectFromCondition(condition) {
         switch (condition.type) {
             case 'isTrue':
-                if (condition.property === 'isMoving') {
-                    break;
+                if (condition.property != 'isMoving' && condition.property != 'isGrounded') {
+                    properties.add(condition.property);
                 }
-                properties.add(condition.property);
                 break;
             case 'not':
                 collectFromCondition(condition.condition);
@@ -48,3 +47,37 @@ export function getProperties(behavior) {
     collectFromBehavior(behavior);
     return Array.from(properties);
 }
+/**
+ * Extracts all animation names used in a behavior tree.
+ * @param behavior - The behavior to extract animations from
+ * @returns Set of animation names (excluding 'Move' which is handled separately)
+ */
+export function extractUsedAnimations(behavior) {
+    const used = new Set();
+    function traverse(b) {
+        switch (b.type) {
+            case 'animation':
+                if (b.name === 'Move') {
+                    break;
+                }
+                used.add(b.name);
+                break;
+            case 'loop':
+                traverse(b.behavior);
+                break;
+            case 'split':
+                traverse(b.upperBodyBehavior);
+                traverse(b.lowerBodyBehavior);
+                break;
+            case 'sequential':
+            case 'parallel':
+                b.behaviors.forEach(traverse);
+                break;
+            case 'graph':
+                Object.values(b.states).forEach((state) => traverse(state.behavior));
+                break;
+        }
+    }
+    traverse(behavior);
+    return used;
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@drawcall/acta",
   "type": "module",
   "main": "dist/index.js",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "author": "Bela Bohlender",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://drawcall.ai",
@@ -15,7 +15,7 @@
   "dependencies": {
     "@pixiv/three-vrm": "3.4.4",
     "@pmndrs/timeline": "^0.3.7",
-    "@pmndrs/viverse": "^0.2.12"
+    "@pmndrs/viverse": "^0.2.16"
   },
   "peerDependencies": {
     "three": "*"