extends RefCounted # Distance-driven runway gait. Stance feet are fixed in world space, including turns. const FLOOR_Y=0.012 const START_PHASE=0.25 var actor: Node3D var skeleton: Skeleton3D var bones={} var feet=[] var base_hip=Vector3.ZERO var last_position=Vector3.ZERO var phase=START_PHASE var walk_weight=0.0 var distance_walked=0.0 var last_speed=0.0 var initialized=false var moving=false var stride=1.55 var last_direction=Vector3.ZERO var stride_min=1.25 var stride_max=1.65 var track_width=.065 var swing_height=.15 func setup(owner_actor): actor=owner_actor;skeleton=actor.find_children("*","Skeleton3D",true,false)[0] for i in range(skeleton.get_bone_count()):bones[skeleton.get_bone_name(i)]=i base_hip=actor.to_local(point("root")) for side in ["L","R"]: var foot="foot."+side var p=actor.to_local(point(foot)) var q=actor.global_basis.orthonormalized().get_rotation_quaternion().inverse()*global_rotation(foot) feet.append({"side":side,"offset":0.0 if side=="L" else .5,"rest":p,"rotation":q,"anchor":Vector3.ZERO,"target":Vector3.ZERO,"start":Vector3.ZERO,"landing":Vector3.ZERO,"start_phase":.5,"grounded":true,"last_phase":0.0,"yaw":0.0}) reset() func point(bone):return skeleton.to_global(skeleton.get_bone_global_pose(bones[bone]).origin) func global_rotation(bone):return skeleton.global_basis.orthonormalized().get_rotation_quaternion()*skeleton.get_bone_global_pose(bones[bone]).basis.orthonormalized().get_rotation_quaternion() func ground_height(foot):return actor.get_parent().global_position.y+FLOOR_Y+foot.rest.y*actor.global_basis.get_scale().y func reset(): phase=START_PHASE;walk_weight=0;last_speed=0;moving=false;last_direction=Vector3.ZERO last_position=actor.global_position for f in feet: f.anchor=actor.to_global(f.rest);f.anchor.y=ground_height(f);f.target=f.anchor f.start=f.anchor;f.landing=f.anchor;f.grounded=true;f.last_phase=fposmod(phase+f.offset,1) f.yaw=actor.global_rotation.y initialized=true func rotate_world(bone,axis,angle): set_rotation(bone,Quaternion(axis.normalized(),angle)*global_rotation(bone)) func set_rotation(bone,world_rotation): var i=bones[bone];var parent=skeleton.get_bone_parent(i) var q=skeleton.global_basis.orthonormalized().get_rotation_quaternion().inverse()*world_rotation if parent>=0:q=skeleton.get_bone_global_pose(parent).basis.orthonormalized().get_rotation_quaternion().inverse()*q skeleton.set_bone_pose_rotation(i,q);skeleton.force_update_all_bone_transforms() func aim(bone,child,target): var from=point(child)-point(bone);var to=target-point(bone) if from.length_squared()<.00001 or to.length_squared()<.00001:return set_rotation(bone,Quaternion(from.normalized(),to.normalized())*global_rotation(bone)) func leg(f,target): var upper="upperleg01."+f.side;var lower="lowerleg01."+f.side;var end="foot."+f.side var a=point(upper);var b=point(lower);var c=point(end) var l1=a.distance_to(b);var l2=b.distance_to(c);var direction=(target-a).normalized() var length=clampf(a.distance_to(target),absf(l1-l2)+.001,l1+l2-.001) var along=(l1*l1-l2*l2+length*length)/(2*length) var forward=actor.global_basis.z.normalized() var bend=(forward-direction*forward.dot(direction)).normalized() var knee=a+direction*along+bend*sqrt(maxf(0,l1*l1-along*along)) aim(upper,lower,knee);aim(lower,end,target) func landing(f,progress,travel_direction): var scale_y=actor.global_basis.get_scale().y # Narrow catwalk track, with enough clearance for the boots to pass each other. var side=1.0 if f.side=="L" else -1.0 var destination=actor.global_position+travel_direction*((1.0-progress)*stride+stride*.25) destination+=actor.global_basis.x.normalized()*side*track_width*scale_y destination.y=ground_height(f) return destination func update(dt): if not initialized:return var displacement=actor.global_position-last_position;displacement.y=0 last_position=actor.global_position if displacement.length()>1.0:reset();displacement=Vector3.ZERO var distance=displacement.length() last_speed=distance/maxf(dt,.0001) var was_moving=moving;moving=distance>.00015 and dt>0 var scale_y=actor.global_basis.get_scale().y # Longer steps at higher upgrade speeds; phase still follows the actual distance. stride=lerpf(stride_min,stride_max,clampf((last_speed/scale_y-1.3)/2.0,0,1))*scale_y walk_weight=move_toward(walk_weight,1.0 if moving else 0.0,dt*7) if moving: distance_walked+=distance;phase=fposmod(phase+distance/stride,1.0) var travel_direction=displacement.normalized() if moving else actor.global_basis.z.normalized() if moving and last_direction.length_squared()>.5 and travel_direction.dot(last_direction)<.65: # A corner starts a short pivot step on the current support foot. var support=0 if feet[0].grounded else 1 phase=.25 if support==0 else .75 var swing=feet[1-support];swing.start=swing.target;swing.start_phase=.75;swing.grounded=false walk_weight=minf(walk_weight,.8) if moving:last_direction=travel_direction for f in feet: var p=fposmod(phase+f.offset,1.0) if moving: if p>=.5: if f.grounded: f.start=f.target;f.start_phase=p if not was_moving else .5;f.grounded=false f.landing=landing(f,p,travel_direction) var u=clampf((p-f.start_phase)/maxf(.01,1.0-f.start_phase),0,1) var ease=u*u*(3-2*u) f.target=f.start.lerp(f.landing,ease) f.target.y=ground_height(f)+sin(u*PI)*swing_height*scale_y else: if not f.grounded: f.anchor=f.landing;f.anchor.y=ground_height(f);f.yaw=actor.global_rotation.y;f.grounded=true f.target=f.anchor else: # An interrupted swing settles vertically; support feet never skate to idle. f.target.y=move_toward(f.target.y,ground_height(f),dt*.9*scale_y) if absf(f.target.y-ground_height(f))<.0001:f.anchor=f.target;f.grounded=true f.last_phase=p # Keep the pelvis at a reachable height instead of lifting the whole mesh. var sway=sin(phase*TAU)*.042*walk_weight var bob=(-.05-cos(phase*TAU*2)*.05)*walk_weight var desired_hip=base_hip+Vector3(sway,bob+FLOOR_Y/scale_y,0) # During stopping, retain enough leg reach for the last planted stride. var reach_drop=0.0 for f in feet: var local=actor.to_local(f.target) reach_drop=maxf(reach_drop,clampf((absf(local.z)-.12)*.28,0,.12)) desired_hip.y=minf(desired_hip.y,base_hip.y+FLOOR_Y/scale_y-reach_drop) skeleton.set_bone_pose_position(bones["root"],skeleton.to_local(actor.to_global(desired_hip))) skeleton.force_update_all_bone_transforms() if not actor.striking: rotate_world("root",actor.global_basis.z,sin(phase*TAU)*.045*walk_weight) rotate_world("spine02",actor.global_basis.z,-sin(phase*TAU)*.045*walk_weight) rotate_world("spine02",Vector3.UP,-sin(phase*TAU)*.045*walk_weight) for side in ["L","R"]: var sign_x=1.0 if side=="L" else -1.0 rotate_world("upperarm01."+side,actor.global_basis.x,sign_x*sin(phase*TAU)*.14*walk_weight) rotate_world("lowerarm01."+side,actor.global_basis.x,-.06*walk_weight) # Solve pelvis height from both leg reaches, including sideways steps on turns. var lower_by=0.0 for f in feet: var hip=point("upperleg01."+f.side);var knee=point("lowerleg01."+f.side);var ankle=point("foot."+f.side) var reach=hip.distance_to(knee)+knee.distance_to(ankle)-.006*scale_y var horizontal=Vector2(hip.x-f.target.x,hip.z-f.target.z).length_squared() var available=sqrt(maxf(.01,reach*reach-horizontal)) lower_by=maxf(lower_by,hip.y-f.target.y-available) if lower_by>0: var root_position=point("root")-Vector3.UP*lower_by skeleton.set_bone_pose_position(bones["root"],skeleton.to_local(root_position));skeleton.force_update_all_bone_transforms() for f in feet: leg(f,f.target) set_rotation("foot."+f.side,foot_orientation(f,dt)) func foot_orientation(f,_dt): var yaw=f.yaw if f.grounded else actor.global_rotation.y var orientation=Quaternion(Vector3.UP,yaw)*f.rotation if not f.grounded:orientation=Quaternion(actor.global_basis.x.normalized(),sin(maxf(0,f.last_phase-.5)*TAU)*-.12)*orientation return orientation