Solium - personal research and development

kuligs2

Dad3353 can you explain from your example with only outgoing, how do you connect the incomming?

Dad3353

I'll not go through all the permutations; one simple sequence should be enough, I think. From 'Start', there can be only one outcome : 'Idle_90'. From there, amongst the possible outcomes, let's suppose 'Crouch_90' was chosen. Here, too, there are several possibilities; maybe 'Idle_90' was the path taken..? The only options now open are the outgoings from 'Idle_90' again. Whichever one is chosen, that action will have a certain number of options. Maybe 'Run_16' this time, which has as an option ''Walk_Stop' This may, in turn, lead back to 'Idle_90'. All we have to consider, at each action, is the choice of destination, not how we got here. The 'incoming' is of no interest once an action has been triggered, only the choice of 'outgoing' needs to be considered. That's how I see things; I may be wrong. Does tis help..?

kuligs2

Dad3353 not sure if this helps... still wrapping my head around.. i need to readjust the code logic based on what you provide.

been hooking up all other states similarly but it got too messy..

The return paths sometimes are important, as such like going from midair to some other state bypassing idle..

Dad3353

kuligs2

I'm just thinking as if handling each action independently. All that counts is 'what to do next'. If any action has an immediate return option (as does 'Crouch_90', back to 'Idle_90'...), then it matters not whether Crouch_90 came from there or not. 'Crouch_90' could have come from 'Jump_Landed_9'. It hasn't an option to get back to there, but can go to 'Idle_90' (or any of its other possible outgoings...). Unless there's a reason for knowing what triggered an action (and that could be handled outside of this 'logic'...), it has no bearing on what to do once an action has been triggered. I find it very much easier (and, to me, more correct...) than the knitting pattern trying to show all possible options at once. That's just me, though.

kuligs2

hmm..

This doesnt seem right.. now im thinking maybe i should layout all the animations around the start and connect them from start?
This way i dont have to define the same condition for each transition like Run > Walk and Idle > Walk. Because the condition is the same (walking/moving)

Something like this (not tested)

EDIT:
It sounded so good to be true.. it dont work..
Problem in this scenario, is that there is no trigger to tell anim_tree that animation is done, even tho it was played. So in the case of going from midair > landed the character stays in landed animation at the last frame and does not transition to any other state and the signal state_finished is not emitted. Connecting landed to End Resets the animations and it does transition to idle state but idle state is not being played.

EDIT2:
Kinda works but not sure if im doing it correctly:
Each state needs this in the enter() and exit() functions;

extends StateInterface

class_name IdleState

var character: Player

func enter(_prev_state: String = "")-> void:

	if character.movement_playback != null:
		character.movement_playback.travel("Idle_90")

	character.animation_tree.set("parameters/StateMachineMovement/conditions/idle",true)


func exit() -> void:
	character.animation_tree.set("parameters/StateMachineMovement/conditions/idle",false)

The movement_playback is of class AnimationNodeStateMachinePlayback

But from limited testing i still get physics frame with 0.0 velocity upon transition..

State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
Unblocked state
Changing state to: walk
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.882 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0) <<<<<<<<<
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)

I swear this will get me killed from rage and stress.. its so frustrating..

kuligs2

alright.. none of the forum posts or youtube videos helped me figured this out but a smelly old LLM..

And importantly, don't overwrite velocity with zero if root motion returns zero for a transition frame.

For example:

var root_motion := character.animation_tree.get_root_motion_position()

if root_motion.length_squared() > 0.000001:
    character.velocity = (
        character.animation_tree
        .get_root_motion_rotation_accumulator()
        .inverse()
        * character.get_quaternion()
    ) * root_motion / delta

This would prevent:

normal velocity
normal velocity
ZERO          <-- transition frame
normal velocity

from being generated by your code.

Well maybe its obvious in hindsight but it works for now using animationtree

State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk_start Velocity: 1.255 RM: (0.0, 0.0, 0.0)
Unblocked state
Changing state to: walk
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.255 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.882 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.882 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.0)

Now need to finish up all the states so that it works as intended. And finally move on to the next step.. hopefully? man..

Am i autistic to ask this much in a project? how are others doing it faster? i dont get it...

Where is xyz? is he ded?

MikeCL

kuligs2 I can't speak for everyone else, but I'm having a hard time following what you are asking. There's just so much information and I'm trying to scroll up and find a concrete question to an issue you are trying to solve.

Just a tip that has worked well for me. Use your character node in the Advance Expression Base Node. This way the animation tree can access all the variables coming from that node. Including your own variables and the things that come with the node, like Velocity.

So then, if you manage your states to your needs, you can just let the travel expression do the checking and transition/flow for you, without you having to do that manually, which can get messy.

I have an Animation manager that should handle any animation states, there I store the different animation states in enums, set the current state to my needs, then the Animation tree just looks at that (and whatever other value I need it to keep track of), and it just does its thing.

enum PLAYER_STATE {DEFAULT, SPRINT, WALL_RUN_LEFT, WALL_RUN_RIGHT, CROUCH, AIM, JUMP, RELOAD, DEAD, SLIDE, SLIP, THROW}

var current_state: PLAYER_STATE = PLAYER_STATE.DEFAULT

func change_state(new_state: PLAYER_STATE) -> void:
    {...}

Keeps the code a lot cleaner than having to trigger the Animation Tree manually

fire7side

kuligs2
Where is xyz? is he ded?
He must have moved on. Kind of miss having him around. He really knew his stuff.

kuligs2

MikeCL i dont know how to define the problem in simple terms for someone who never had this problem 😃.

My journey started using animation_player to play animations directly when the state changes/enters. Ok. this works, and i have buffed out all the bugs i have encountered and i have a workflow that makes sense to me, to use as a base to create what i need.

Alright but then i came across - what if i need to filter out bones, like foot movement and upper body movement and blend multiple animations.. here is where the fun began.

Logically they say use AnimationTree.

Sure.. yeah.. and then end up with

and

and then try to remember managing all the transitions and conditions.

Ok, then simplify:

alright this is manageable but then i loose the xfade thing, as there is no path that leads to next state. And i end up with something that is worse than animation_player but hey, i get to use the filter me bones thing.. tho i loose animation blending.

On top of all this, underlying things for me was that root_motion was resetting my character velocity and not honouring the previous velocity from previous animation when switching to the next animation. this introduced jerky movement visually. and i was chasing solution to this problem.

Now

MikeCL Advance Expression Base Node.

Using this i didnt think of. But how does your statemachinenode looks? is its like all the states are connected to each other on and it all look messy? Maybe this is exactly what i was looking for.. well maybe i could deal with wiring up something super messy once and then forget about it.

MikeCL

kuligs2 Using this i didnt think of. But how does your statemachinenode looks? is its like all the states are connected to each other on and it all look messy? Maybe this is exactly what i was looking for.. well maybe i could deal with wiring up something super messy once and then forget about it.

Do you mean the animation tree? Here's how the player tree looks like. It's a bit too messy for my liking and I will probably clean it up at some point.

Here's how the FPS Arms look like, here you can see that I've started organizing the animation nodes a bit more. I group each "base" animation together, and I'm not afraid to reuse duplicates if it means I can get the tree more organized and manageable. As long as it flows correctly.

Worth mentioning though is that I do not use root motion.

kuligs2 Alright but then i came across - what if i need to filter out bones, like foot movement and upper body movement and blend multiple animations.. here is where the fun began.

So you can create a BlendTree node as a state for those specific states.

kuligs2 alright this is manageable but then i loose the xfade thing, as there is no path that leads to next state. And i end up with something that is worse than animation_player but hey, i get to use the filter me bones thing.. tho i loose animation blending.

Not sure why you would loose the xfade thing? You can set the xfade on each travel connection. Between what nodes in the tree do you loose the fading?

kuligs2

MikeCL Thanks for the insight.

I tried to set up the animationtree your way, with that advanced expression. It works the way i want it to work, also with transitions. And with root motion.

Thanks!!!

Oh and yeah, you cant avoid the node noodles:

Quick setup looks like this:

And the transition conditions are bound to the "code" statemachine states.

Need to iron out all states and clean up, but from limited testing it looks what i needed..

Good enhancement on the UI part is that you can copy and paste values on them transition connections..

Im contenplating also if should i keep using root motion or not. One reason for the use is that you dont have to guestimate the foot movement to match the character speed to get rid of the sliding feet sickness. Ofc this works with root motion only if your animation does not slide either 🙂

But the nonsliding feet makes the world feel more real.

MikeCL

kuligs2 Nice!

kuligs2 Oh and yeah, you cant avoid the node noodles:

Well, that's why I just add the same animation nodes closer to where it's needed, so I don't have to drag connections across the entire screen.

Yeah. Root motion definitely has its advantages when it comes for motion to feel more natural and grounded. But that often also comes at the cost of the controls not feeling as responsive (depends on your animations though). So whatever requirements your project has, go with that. Don't think there's a right or wrong answer to that, just whatever works best for the project.

kuligs2

MikeCL well im in the stage of finding out what works and what does not, and how to put it all together. This is the sole reason for this project.

kuligs2

Alright more discoveries..

So the problem now i faced was when i have one_sot animations that need to be played throughout and then at the end it needs to be switched to the next state/animation, it would not do it if i had the switch mode "At end" and expression filled out.

When i have not filled out expression and have multiple paths such as from Jump_landed -> idle and Jump_landed -> walk, at the end of animation it sometimes plays the wron path.. like if there are no inputs it should go to idle but it plays walk for a second then to idle.

THis is a limitation in godot unfortunately as LLM tries to convince me. THe animation_finished and animation_state_finished signals never get emmited if i have Switch - at end, Expression -> filled with data.

This is crucial as i need to recieve the finished signal to unblock my code statemachine and decide the next state.

Here come the timer.

So in my coded state for jump_landed i add timer fluff and set the timeout to be the animation length.

And on timeout i unblock the state as per usual.

And so in the example of when i am in midair and press walk button and when i land and play animation for jump landed, afterwards i start walking.

State: jump_midair_90 Velocity: 7.353 RM: (0.0, 0.0, 0.0) | CA: Jump_midair_90
State: jump_midair_90 Velocity: 7.517 RM: (0.0, 0.0, 0.0) | CA: Jump_midair_90
State: jump_midair_90 Velocity: 7.680 RM: (0.0, 0.0, 0.0) | CA: Jump_midair_90
State: jump_midair_90 Velocity: 7.843 RM: (0.0, 0.0, 0.0) | CA: Jump_midair_90
Changing state to: jump_landed_9
State: jump_landed_9 Velocity: 0.000 RM: (0.0, 0.0, 0.0) | CA: Jump_midair_90
State: jump_landed_9 Velocity: 0.000 RM: (0.0, 0.0, 0.0) | CA: Jump_landed_9
Landed state finished: timer
Changing state to: walk
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0) | CA: Jump_landed_9  #### < - wrong animation for the state.
State: walk Velocity: 0.000 RM: (0.0, 0.0, 0.0) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019655) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654) | CA: Walk_32

CA - current animation in AnimationNodeStateMachinePlayback.get_current_node()

but then i end up with few frames where current animation is the wrong one in the current state. such as walk state starts with jump_landed animation

one thing comes to mind is to reprogramm every coded state with .travel("current_animation") during the state enter function. Then i wonder why use.. hmm.. that is a problem for me next week 🙂

MikeCL

kuligs2 When using AnimationTree , the animation_finished signal from AnimationPlayer doesn't emit.

What I do is insert a function call in the AnimationPlayer at the end of the animation. This function call does get triggered by the AnimationPlayer (I include the animation name as a string argument). That way, you can add whatever logic you need when an animation finishes playing (e.g., change state, etc.) that the travel connection uses to switch animation states.

kuligs2

MikeCL i was too lazy to explain in detail. yes when using anim tree, anim_finished on anim_player is not being triggered, instead on anim_tree playback object :

there is state_finished signal that acts almost like anim_finished but it can send wrong signal sometimes, like when the previous anim has finished during current anim. so that need to be worked around.

anyway, the problem was that even this wasnt being triggered when anim is finished.

And yes, i could use function call but who got time to set it up every time when you are testing different animations. its not like i know what im doing so remembering and redoing these thngs over and over is a drag...

Right now im thinking of a coded way to connect all them animations in the anim_tree state machine and then add the timer code for one shot states. Seems straight forward.. gotta devote some time to do it tho 🙂

kuligs2

Alright, somewhat work in progress.
The anim_tree statemachine is coded so there is no spaghetti connections.

Created animation_slaver.gd

extends RefCounted

class_name AnimationSlaver

const ANIMATION_STATE_MACHINE_NAME : StringName = "StateMachineMovement"
const ANIMATION_XFADE_TIME := 0.1
const ANIMATION_STATES : Dictionary = {
	"idle": {
		"animation": "Idle_90",
		"one_shot": false,
	},

	"walk": {
		"animation": "Walk_32",
		"one_shot": false,
	},

	"Jump_ascend_9": {
		"animation": "Jump_ascend_9",
		"one_shot": true,
	},

	"Jump_landed_9": {
		"animation": "Jump_landed_9",
		"one_shot": true,
	},

	"Jump_midair_90": {
		"animation": "Jump_midair_90",
		"one_shot": false,
	},

	"Run_16": {
		"animation": "Run_16",
		"one_shot": false,
	},

	"Crouch_90": {
		"animation": "Crouch_90",
		"one_shot": false,
	},

	"Crouch_walk_32": {
		"animation": "Crouch_walk_32",
		"one_shot": false,
	},

	"walk_stop": {
		"animation": "Walk_stop",
		"one_shot": true,
	},

	"walk_start": {
		"animation": "Walk_start",
		"one_shot": true,
	},
}


const EXCLUDED_TRANSITIONS : Array = [
	# "Idle_90->Walk_stop",
	# "Walk_stop->Jump_ascend_9",
]

func setup_animation_tree(animation_tree) -> void:

	var blend_tree : AnimationNodeBlendTree = animation_tree.tree_root

	if blend_tree == null:
		push_error("AnimationTree root is not an AnimationNodeBlendTree.")
		return


	var anim_state_machine : AnimationNodeStateMachine = blend_tree.get_node(
		ANIMATION_STATE_MACHINE_NAME
	) 

	if anim_state_machine == null:
		push_error(
			"Could not find AnimationNodeStateMachine: "
			+ str(ANIMATION_STATE_MACHINE_NAME)
		)
		return


	animation_tree.active = true
	#animation_tree.advance_expression_base_node = advance_expression_base_node

	anim_state_machine.allow_transition_to_self = false


	for state in ANIMATION_STATES:

		var animation_name: String = (
			ANIMATION_STATES[state]["animation"]
		)

		if anim_state_machine.has_node(animation_name):
			continue

		var animation_node : AnimationNodeAnimation = AnimationNodeAnimation.new()

		animation_node.animation = animation_name

		anim_state_machine.add_node(
			animation_name,
			animation_node,
			Vector2.ZERO
		)

	var playback : AnimationNodeStateMachinePlayback = animation_tree.get(
		"parameters/%s/playback" % ANIMATION_STATE_MACHINE_NAME
	) 

	if playback == null:
		push_error("Could not get AnimationNodeStateMachinePlayback.")
		return

	playback.start("Idle_90")


	for from_state in ANIMATION_STATES:
		var from_animation: String = ANIMATION_STATES[from_state]["animation"]
		var from_one_shot: bool = bool(
			ANIMATION_STATES[from_state]["one_shot"]
		)

		for to_state in ANIMATION_STATES:
			var to_animation: String = ANIMATION_STATES[to_state]["animation"]

			if from_animation == to_animation:
				continue

			var transition_name := "%s->%s" % [
				from_animation,
				to_animation
			]

			if transition_name in EXCLUDED_TRANSITIONS:
				continue

			var transition :AnimationNodeStateMachineTransition = AnimationNodeStateMachineTransition.new()

			transition.xfade_time = ANIMATION_XFADE_TIME

			transition.advance_mode = (
				AnimationNodeStateMachineTransition.ADVANCE_MODE_AUTO
			)

			transition.advance_expression = (
				'state_machine.current_state_name == "%s"'
				% String(to_state).to_lower()
			)

			if from_one_shot:
				transition.switch_mode = (
					AnimationNodeStateMachineTransition.SWITCH_MODE_AT_END
				)
			else:
				transition.switch_mode = (
					AnimationNodeStateMachineTransition.SWITCH_MODE_IMMEDIATE
				)

			transition.reset = true

			anim_state_machine.add_transition(
				from_animation,
				to_animation,
				transition
			)

			print(
				"TRANSITION: ",
				from_animation,
				" -> ",
				to_animation,
				" Adv: ",
				transition.advance_expression,
				" Mode: ",
				transition.switch_mode
			)

Here you define your animations and how they connect. In my case i connect everything with everything.

This creates this output:

TRANSITION: Idle_90 -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 0
TRANSITION: Idle_90 -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 0
TRANSITION: Idle_90 -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 0
TRANSITION: Idle_90 -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 0
TRANSITION: Idle_90 -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 0
TRANSITION: Idle_90 -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 0
TRANSITION: Idle_90 -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 0
TRANSITION: Idle_90 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 0
TRANSITION: Idle_90 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 0
TRANSITION: Walk_32 -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 0
TRANSITION: Walk_32 -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 0
TRANSITION: Walk_32 -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 0
TRANSITION: Walk_32 -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 0
TRANSITION: Walk_32 -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 0
TRANSITION: Walk_32 -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 0
TRANSITION: Walk_32 -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 0
TRANSITION: Walk_32 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 0
TRANSITION: Walk_32 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 0
TRANSITION: Jump_ascend_9 -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 2
TRANSITION: Jump_ascend_9 -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 2
TRANSITION: Jump_ascend_9 -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 2
TRANSITION: Jump_ascend_9 -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 2
TRANSITION: Jump_ascend_9 -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 2
TRANSITION: Jump_ascend_9 -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 2
TRANSITION: Jump_ascend_9 -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 2
TRANSITION: Jump_ascend_9 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 2
TRANSITION: Jump_ascend_9 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 2
TRANSITION: Jump_landed_9 -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 2
TRANSITION: Jump_landed_9 -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 2
TRANSITION: Jump_landed_9 -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 2
TRANSITION: Jump_landed_9 -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 2
TRANSITION: Jump_landed_9 -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 2
TRANSITION: Jump_landed_9 -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 2
TRANSITION: Jump_landed_9 -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 2
TRANSITION: Jump_landed_9 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 2
TRANSITION: Jump_landed_9 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 2
TRANSITION: Jump_midair_90 -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 0
TRANSITION: Jump_midair_90 -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 0
TRANSITION: Jump_midair_90 -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 0
TRANSITION: Jump_midair_90 -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 0
TRANSITION: Jump_midair_90 -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 0
TRANSITION: Jump_midair_90 -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 0
TRANSITION: Jump_midair_90 -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 0
TRANSITION: Jump_midair_90 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 0
TRANSITION: Jump_midair_90 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 0
TRANSITION: Run_16 -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 0
TRANSITION: Run_16 -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 0
TRANSITION: Run_16 -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 0
TRANSITION: Run_16 -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 0
TRANSITION: Run_16 -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 0
TRANSITION: Run_16 -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 0
TRANSITION: Run_16 -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 0
TRANSITION: Run_16 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 0
TRANSITION: Run_16 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 0
TRANSITION: Crouch_90 -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 0
TRANSITION: Crouch_90 -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 0
TRANSITION: Crouch_90 -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 0
TRANSITION: Crouch_90 -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 0
TRANSITION: Crouch_90 -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 0
TRANSITION: Crouch_90 -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 0
TRANSITION: Crouch_90 -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 0
TRANSITION: Crouch_90 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 0
TRANSITION: Crouch_90 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 0
TRANSITION: Crouch_walk_32 -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 0
TRANSITION: Crouch_walk_32 -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 0
TRANSITION: Crouch_walk_32 -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 0
TRANSITION: Crouch_walk_32 -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 0
TRANSITION: Crouch_walk_32 -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 0
TRANSITION: Crouch_walk_32 -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 0
TRANSITION: Crouch_walk_32 -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 0
TRANSITION: Crouch_walk_32 -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 0
TRANSITION: Crouch_walk_32 -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 0
TRANSITION: Walk_stop -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 2
TRANSITION: Walk_stop -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 2
TRANSITION: Walk_stop -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 2
TRANSITION: Walk_stop -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 2
TRANSITION: Walk_stop -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 2
TRANSITION: Walk_stop -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 2
TRANSITION: Walk_stop -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 2
TRANSITION: Walk_stop -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 2
TRANSITION: Walk_stop -> Walk_start Adv: state_machine.current_state_name == "walk_start" Mode: 2
TRANSITION: Walk_start -> Idle_90 Adv: state_machine.current_state_name == "idle" Mode: 2
TRANSITION: Walk_start -> Walk_32 Adv: state_machine.current_state_name == "walk" Mode: 2
TRANSITION: Walk_start -> Jump_ascend_9 Adv: state_machine.current_state_name == "jump_ascend_9" Mode: 2
TRANSITION: Walk_start -> Jump_landed_9 Adv: state_machine.current_state_name == "jump_landed_9" Mode: 2
TRANSITION: Walk_start -> Jump_midair_90 Adv: state_machine.current_state_name == "jump_midair_90" Mode: 2
TRANSITION: Walk_start -> Run_16 Adv: state_machine.current_state_name == "run_16" Mode: 2
TRANSITION: Walk_start -> Crouch_90 Adv: state_machine.current_state_name == "crouch_90" Mode: 2
TRANSITION: Walk_start -> Crouch_walk_32 Adv: state_machine.current_state_name == "crouch_walk_32" Mode: 2
TRANSITION: Walk_start -> Walk_stop Adv: state_machine.current_state_name == "walk_stop" Mode: 2

In player class i define:

Oneshot animations have this code in their respecive statemachine code:

extends StateInterface

class_name JumpAscendState

var character: Player

func enter(_prev_state: String = "")-> void:
	character = state_machine.owner

	character.animation_play_timer.one_shot = true
	character.animation_play_timer.wait_time = character.animation_player.get_animation("Jump_ascend_9").length
	character.animation_play_timer.timeout.connect(on_timer_finished)
	character.animation_play_timer.start()
	
	character.is_root_motion = false

func physics_update(_delta: float) -> void:
	if character.direction:
		var up := Vector3.UP
		# For root motion
		var forward : Vector3 = character.direction # Check this value if its in correct way
		var right := up.cross(forward).normalized()
		var corrected_up := forward.cross(right).normalized()
		var target_basis := Basis(right, corrected_up, forward).orthonormalized() 
		var a = character.transform.basis.get_rotation_quaternion()
		var b = target_basis.get_rotation_quaternion()
		var c = a.slerp(b,0.3)
		character.transform.basis = Basis(c).orthonormalized()

	character.velocity.x = character.current_root_motion_velocity.x
	character.velocity.z = character.current_root_motion_velocity.z
	character.move_and_slide()

func on_timer_finished():
	print("Ascend state finished: timer")
	character.animation_play_timer.timeout.disconnect(on_timer_finished)
	state_machine.change_state("Jump_midair_90")

Some states have decider functions:

extends StateInterface

class_name JumpLandedState

var character: Player
var is_blocking:bool = false

func enter(_prev_state: String = "")-> void:
	character = state_machine.owner

	character.animation_play_timer.one_shot = true
	character.animation_play_timer.wait_time = character.animation_player.get_animation("Jump_landed_9").length
	character.animation_play_timer.timeout.connect(on_timer_finished)
	character.animation_play_timer.start()
	
	character.is_root_motion = false
	is_blocking = true

func physics_update(_delta: float) -> void:	
	if not character.is_on_floor():
		state_machine.change_state("Jump_midair_90")
		return

	character.velocity = (character.animation_tree.get_root_motion_rotation_accumulator().inverse() * character.get_quaternion()) * character.animation_tree.get_root_motion_position() / _delta
	character.move_and_slide()
	
	if not is_blocking:
		_decide_next_state()

func on_timer_finished():
	print("Landed state finished: timer")
	character.animation_play_timer.timeout.disconnect(on_timer_finished)
	is_blocking = false

func _decide_next_state():
	if Input.get_vector("k_left", "k_right", "k_forward", "k_backward"):
		if Input.is_action_pressed("k_sprint"):
			state_machine.change_state("Run_16")
			return
		if Input.is_action_pressed("k_crouch"):
			state_machine.change_state("Crouch_walk_32")
			return
		state_machine.change_state("walk")
		return
		
	if Input.is_action_just_pressed("k_jump") and character.is_on_floor():
		state_machine.change_state("Jump_ascend_9")
		return
		
	if Input.is_action_pressed("k_crouch"):
		state_machine.change_state("Crouch_90")
		return
			
	state_machine.change_state("idle")
	return

Need to iron out some quirks, but so far this looks usable in my case. I can always specify special cases for animation connections..

Making the "upper body" animation states and then using filters and blending will be another headache for another time..

EDIT:
Ehh.. need to investigate why the velocity drops upon switch.. 🙁((

Walk stop state finished: timer
Changing state to: idle
State: idle Velocity: 1.179 RM: (0.0, 0.0, 0.016301) | CA: Walk_stop
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.016301) | CA: Idle_90
State: idle Velocity: 0.000 RM: (0.0, 0.0, 0.0) | CA: Idle_90
Changing state to: walk_start
State: walk_start Velocity: 0.000 RM: (0.0, 0.0, 0.0) | CA: Idle_90
State: walk_start Velocity: 0.000 RM: (0.0, 0.0, 0.0) | CA: Walk_start
State: walk_start Velocity: 0.376 RM: (0.0, 0.0, 0.006264) | CA: Walk_start
State: walk_start Velocity: 0.564 RM: (0.0, 0.0, 0.009396) | CA: Walk_start
State: walk_start Velocity: 0.752 RM: (0.0, 0.0, 0.012528) | CA: Walk_start
State: walk_start Velocity: 0.940 RM: (0.0, 0.0, 0.015661) | CA: Walk_start
State: walk_start Velocity: 1.128 RM: (0.0, 0.0, 0.018793) | CA: Walk_start
Walk start state finished: timer
Changing state to: walk
State: walk Velocity: 1.128 RM: (0.0, 0.0, 0.018793) | CA: Walk_start
State: walk Velocity: 1.128 RM: (0.0, 0.0, 0.018793) | CA: Walk_32
State: walk Velocity: 1.128 RM: (0.0, 0.0, 0.0) | CA: Walk_32
State: walk Velocity: 0.393 RM: (0.0, 0.0, 0.006551) | CA: Walk_32
State: walk Velocity: 0.590 RM: (0.0, 0.0, 0.009827) | CA: Walk_32
State: walk Velocity: 0.786 RM: (0.0, 0.0, 0.013103) | CA: Walk_32
State: walk Velocity: 0.983 RM: (0.0, 0.0, 0.016379) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019655) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019655) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019655) | CA: Walk_32
State: walk Velocity: 1.179 RM: (0.0, 0.0, 0.019654) | CA: Walk_32

kuligs2

My observations lead me to believe that xfade_time is cursed. If i eliminate the xfade_time at all, i dont loose velocity when switching animations, but when i use xfade time the longer it is, the more close it set the velocity to zero..

I was hoping that it would fade into the next animation with the next animation root velocity values and not go to zero first then set the next animation velocities.

This make me confused.. and discouraged again..

ATM i dont know how to get around this, unless i either set every fade time to zero and then manually doctor each animation starting and ending keyframes, and have inbetween transitional animations for each set of animations:

lets say Idle to walk animation would have this.

Idle -> Idle to walk transition -> Walk

I kinda already have this with walk_start animation .. so this was a bad example 😃..

lets say walk to run

walk - run start from walk - run

and then i would need to have: run start from idle, run start from crouch etc.. animations.. that have matching root motion velocities..
This is too much work..

« Previous Page