1 files changed, 510 insertions, 149 deletions

diff --git a/scene/animation/animation_node_state_machine.cpp b/scene/animation/animation_node_state_machine.cpp
index 5ea7f4b7d9..fe08e849a1 100644
--- a/scene/animation/animation_node_state_machine.cpp
+++ b/scene/animation/animation_node_state_machine.cpp
@@ -68,6 +68,34 @@ StringName AnimationNodeStateMachineTransition::get_advance_condition_name() con
 	return advance_condition_name;
 }
 
+void AnimationNodeStateMachineTransition::set_advance_expression(const String &p_expression) {
+	advance_expression = p_expression;
+
+	String advance_expression_stripped = advance_expression.strip_edges();
+	if (advance_expression_stripped == String()) {
+		expression.unref();
+		return;
+	}
+
+	if (expression.is_null()) {
+		expression.instantiate();
+	}
+
+	expression->parse(advance_expression_stripped);
+}
+
+String AnimationNodeStateMachineTransition::get_advance_expression() const {
+	return advance_expression;
+}
+
+void AnimationNodeStateMachineTransition::set_advance_expression_base_node(const NodePath &p_expression_base_node) {
+	advance_expression_base_node = p_expression_base_node;
+}
+
+NodePath AnimationNodeStateMachineTransition::get_advance_expression_base_node() const {
+	return advance_expression_base_node;
+}
+
 void AnimationNodeStateMachineTransition::set_xfade_time(float p_xfade) {
 	ERR_FAIL_COND(p_xfade < 0);
 	xfade = p_xfade;
@@ -115,11 +143,22 @@ void AnimationNodeStateMachineTransition::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_priority", "priority"), &AnimationNodeStateMachineTransition::set_priority);
 	ClassDB::bind_method(D_METHOD("get_priority"), &AnimationNodeStateMachineTransition::get_priority);
 
+	ClassDB::bind_method(D_METHOD("set_advance_expression", "text"), &AnimationNodeStateMachineTransition::set_advance_expression);
+	ClassDB::bind_method(D_METHOD("get_advance_expression"), &AnimationNodeStateMachineTransition::get_advance_expression);
+
+	ClassDB::bind_method(D_METHOD("set_advance_expression_base_node", "path"), &AnimationNodeStateMachineTransition::set_advance_expression_base_node);
+	ClassDB::bind_method(D_METHOD("get_advance_expression_base_node"), &AnimationNodeStateMachineTransition::get_advance_expression_base_node);
+
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "xfade_time", PROPERTY_HINT_RANGE, "0,240,0.01,suffix:s"), "set_xfade_time", "get_xfade_time");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "priority", PROPERTY_HINT_RANGE, "0,32,1"), "set_priority", "get_priority");
+	ADD_GROUP("Switch", "");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "switch_mode", PROPERTY_HINT_ENUM, "Immediate,Sync,At End"), "set_switch_mode", "get_switch_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_advance"), "set_auto_advance", "has_auto_advance");
+	ADD_GROUP("Advance", "advance_");
 	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "advance_condition"), "set_advance_condition", "get_advance_condition");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "xfade_time", PROPERTY_HINT_RANGE, "0,240,0.01"), "set_xfade_time", "get_xfade_time");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "priority", PROPERTY_HINT_RANGE, "0,32,1"), "set_priority", "get_priority");
+	ADD_PROPERTY(PropertyInfo(Variant::STRING, "advance_expression", PROPERTY_HINT_EXPRESSION, ""), "set_advance_expression", "get_advance_expression");
+	ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "advance_expression_base_node"), "set_advance_expression_base_node", "get_advance_expression_base_node");
+	ADD_GROUP("Disabling", "");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "disabled"), "set_disabled", "is_disabled");
 
 	BIND_ENUM_CONSTANT(SWITCH_MODE_IMMEDIATE);
@@ -185,27 +224,29 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 		return true; //nothing to do
 	}
 
-	loops_current = 0; // reset loops, so fade does not happen immediately
-
 	Vector2 current_pos = p_state_machine->states[current].position;
 	Vector2 target_pos = p_state_machine->states[p_travel].position;
 
-	Map<StringName, AStarCost> cost_map;
+	HashMap<StringName, AStarCost> cost_map;
 
 	List<int> open_list;
 
 	//build open list
 	for (int i = 0; i < p_state_machine->transitions.size(); i++) {
-		if (p_state_machine->transitions[i].from == current) {
+		if (p_state_machine->transitions[i].transition->is_disabled()) {
+			continue;
+		}
+
+		if (p_state_machine->transitions[i].local_from == current) {
 			open_list.push_back(i);
-			float cost = p_state_machine->states[p_state_machine->transitions[i].to].position.distance_to(current_pos);
+			float cost = p_state_machine->states[p_state_machine->transitions[i].local_to].position.distance_to(current_pos);
 			cost *= p_state_machine->transitions[i].transition->get_priority();
 			AStarCost ap;
 			ap.prev = current;
 			ap.distance = cost;
-			cost_map[p_state_machine->transitions[i].to] = ap;
+			cost_map[p_state_machine->transitions[i].local_to] = ap;
 
-			if (p_state_machine->transitions[i].to == p_travel) { //prematurely found it! :D
+			if (p_state_machine->transitions[i].local_to == p_travel) { //prematurely found it! :D
 				path.push_back(p_travel);
 				return true;
 			}
@@ -224,8 +265,8 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 		float least_cost = 1e20;
 
 		for (List<int>::Element *E = open_list.front(); E; E = E->next()) {
-			float cost = cost_map[p_state_machine->transitions[E->get()].to].distance;
-			cost += p_state_machine->states[p_state_machine->transitions[E->get()].to].position.distance_to(target_pos);
+			float cost = cost_map[p_state_machine->transitions[E->get()].local_to].distance;
+			cost += p_state_machine->states[p_state_machine->transitions[E->get()].local_to].position.distance_to(target_pos);
 
 			if (cost < least_cost) {
 				least_cost_transition = E;
@@ -233,34 +274,38 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 			}
 		}
 
-		StringName transition_prev = p_state_machine->transitions[least_cost_transition->get()].from;
-		StringName transition = p_state_machine->transitions[least_cost_transition->get()].to;
+		StringName transition_prev = p_state_machine->transitions[least_cost_transition->get()].local_from;
+		StringName transition = p_state_machine->transitions[least_cost_transition->get()].local_to;
 
 		for (int i = 0; i < p_state_machine->transitions.size(); i++) {
-			if (p_state_machine->transitions[i].from != transition || p_state_machine->transitions[i].to == transition_prev) {
+			if (p_state_machine->transitions[i].transition->is_disabled()) {
+				continue;
+			}
+
+			if (p_state_machine->transitions[i].local_from != transition || p_state_machine->transitions[i].local_to == transition_prev) {
 				continue; //not interested on those
 			}
 
-			float distance = p_state_machine->states[p_state_machine->transitions[i].from].position.distance_to(p_state_machine->states[p_state_machine->transitions[i].to].position);
+			float distance = p_state_machine->states[p_state_machine->transitions[i].local_from].position.distance_to(p_state_machine->states[p_state_machine->transitions[i].local_to].position);
 			distance *= p_state_machine->transitions[i].transition->get_priority();
-			distance += cost_map[p_state_machine->transitions[i].from].distance;
+			distance += cost_map[p_state_machine->transitions[i].local_from].distance;
 
-			if (cost_map.has(p_state_machine->transitions[i].to)) {
+			if (cost_map.has(p_state_machine->transitions[i].local_to)) {
 				//oh this was visited already, can we win the cost?
-				if (distance < cost_map[p_state_machine->transitions[i].to].distance) {
-					cost_map[p_state_machine->transitions[i].to].distance = distance;
-					cost_map[p_state_machine->transitions[i].to].prev = p_state_machine->transitions[i].from;
+				if (distance < cost_map[p_state_machine->transitions[i].local_to].distance) {
+					cost_map[p_state_machine->transitions[i].local_to].distance = distance;
+					cost_map[p_state_machine->transitions[i].local_to].prev = p_state_machine->transitions[i].local_from;
 				}
 			} else {
 				//add to open list
 				AStarCost ac;
-				ac.prev = p_state_machine->transitions[i].from;
+				ac.prev = p_state_machine->transitions[i].local_from;
 				ac.distance = distance;
-				cost_map[p_state_machine->transitions[i].to] = ac;
+				cost_map[p_state_machine->transitions[i].local_to] = ac;
 
 				open_list.push_back(i);
 
-				if (p_state_machine->transitions[i].to == p_travel) {
+				if (p_state_machine->transitions[i].local_to == p_travel) {
 					found_route = true;
 					break;
 				}
@@ -286,7 +331,7 @@ bool AnimationNodeStateMachinePlayback::_travel(AnimationNodeStateMachine *p_sta
 	return true;
 }
 
-double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_state_machine, double p_time, bool p_seek) {
+double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_state_machine, double p_time, bool p_seek, bool p_seek_root) {
 	//if not playing and it can restart, then restart
 	if (!playing && start_request == StringName()) {
 		if (!stop_request && p_state_machine->start_node) {
@@ -350,9 +395,8 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 			current = p_state_machine->start_node;
 		}
 
-		len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, 1.0, AnimationNode::FILTER_IGNORE, false);
+		len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, p_seek_root, 1.0, AnimationNode::FILTER_IGNORE, true);
 		pos_current = 0;
-		loops_current = 0;
 	}
 
 	if (!p_state_machine->states.has(current)) {
@@ -376,10 +420,10 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 		}
 	}
 
-	float rem = p_state_machine->blend_node(current, p_state_machine->states[current].node, p_time, p_seek, fade_blend, AnimationNode::FILTER_IGNORE, false);
+	float rem = p_state_machine->blend_node(current, p_state_machine->states[current].node, p_time, p_seek, p_seek_root, fade_blend, AnimationNode::FILTER_IGNORE, true);
 
 	if (fading_from != StringName()) {
-		p_state_machine->blend_node(fading_from, p_state_machine->states[fading_from].node, p_time, p_seek, 1.0 - fade_blend, AnimationNode::FILTER_IGNORE, false);
+		p_state_machine->blend_node(fading_from, p_state_machine->states[fading_from].node, p_time, p_seek, p_seek_root, 1.0 - fade_blend, AnimationNode::FILTER_IGNORE, true);
 	}
 
 	//guess playback position
@@ -388,12 +432,8 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 	}
 
 	{ //advance and loop check
-
 		float next_pos = len_current - rem;
-
-		if (next_pos < pos_current) {
-			loops_current++;
-		}
+		end_loop = next_pos < pos_current;
 		pos_current = next_pos; //looped
 	}
 
@@ -404,7 +444,11 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 
 	if (path.size()) {
 		for (int i = 0; i < p_state_machine->transitions.size(); i++) {
-			if (p_state_machine->transitions[i].from == current && p_state_machine->transitions[i].to == path[0]) {
+			if (p_state_machine->transitions[i].transition->is_disabled()) {
+				continue;
+			}
+
+			if (p_state_machine->transitions[i].local_from == current && p_state_machine->transitions[i].local_to == path[0]) {
 				next_xfade = p_state_machine->transitions[i].transition->get_xfade_time();
 				switch_mode = p_state_machine->transitions[i].transition->get_switch_mode();
 				next = path[0];
@@ -413,17 +457,39 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 	} else {
 		float priority_best = 1e20;
 		int auto_advance_to = -1;
+
 		for (int i = 0; i < p_state_machine->transitions.size(); i++) {
-			bool auto_advance = false;
-			if (p_state_machine->transitions[i].transition->has_auto_advance()) {
-				auto_advance = true;
+			if (p_state_machine->transitions[i].transition->is_disabled()) {
+				continue;
 			}
-			StringName advance_condition_name = p_state_machine->transitions[i].transition->get_advance_condition_name();
-			if (advance_condition_name != StringName() && bool(p_state_machine->get_parameter(advance_condition_name))) {
-				auto_advance = true;
+
+			// handles end_node: when end_node is reached in a sub state machine, find and activate the current_transition
+			if (force_auto_advance) {
+				if (p_state_machine->transitions[i].from == current_transition.from && p_state_machine->transitions[i].to == current_transition.to) {
+					auto_advance_to = i;
+					force_auto_advance = false;
+					break;
+				}
 			}
 
-			if (p_state_machine->transitions[i].from == current && auto_advance) {
+			// handles start_node: if previous state machine is pointing to a node inside the current state machine, starts the current machine from start_node to prev_local_to
+			if (p_state_machine->start_node == current && p_state_machine->transitions[i].local_from == current) {
+				if (p_state_machine->prev_state_machine != nullptr) {
+					Ref<AnimationNodeStateMachinePlayback> prev_playback = p_state_machine->prev_state_machine->get_parameter("playback");
+
+					if (prev_playback.is_valid()) {
+						StringName prev_local_to = String(prev_playback->current_transition.next).replace_first(String(p_state_machine->state_machine_name) + "/", "");
+
+						if (p_state_machine->transitions[i].to == prev_local_to) {
+							auto_advance_to = i;
+							prev_playback->current_transition.next = StringName();
+							break;
+						}
+					}
+				}
+			}
+
+			if (p_state_machine->transitions[i].from == current && _check_advance_condition(p_state_machine, p_state_machine->transitions[i].transition)) {
 				if (p_state_machine->transitions[i].transition->get_priority() <= priority_best) {
 					priority_best = p_state_machine->transitions[i].transition->get_priority();
 					auto_advance_to = i;
@@ -432,26 +498,69 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 		}
 
 		if (auto_advance_to != -1) {
-			next = p_state_machine->transitions[auto_advance_to].to;
+			next = p_state_machine->transitions[auto_advance_to].local_to;
+			Transition tr;
+			tr.from = String(p_state_machine->state_machine_name) + "/" + String(p_state_machine->transitions[auto_advance_to].from);
+			tr.to = String(p_state_machine->transitions[auto_advance_to].to).replace_first("../", "");
+			tr.next = p_state_machine->transitions[auto_advance_to].to;
+			current_transition = tr;
 			next_xfade = p_state_machine->transitions[auto_advance_to].transition->get_xfade_time();
 			switch_mode = p_state_machine->transitions[auto_advance_to].transition->get_switch_mode();
 		}
 	}
 
+	if (next == p_state_machine->end_node) {
+		AnimationNodeStateMachine *prev_state_machine = p_state_machine->prev_state_machine;
+
+		if (prev_state_machine != nullptr) {
+			Ref<AnimationNodeStateMachinePlayback> prev_playback = prev_state_machine->get_parameter("playback");
+
+			if (prev_playback.is_valid()) {
+				if (next_xfade) {
+					prev_playback->current_transition = current_transition;
+					prev_playback->force_auto_advance = true;
+
+					return rem;
+				}
+				float priority_best = 1e20;
+				int auto_advance_to = -1;
+
+				for (int i = 0; i < prev_state_machine->transitions.size(); i++) {
+					if (prev_state_machine->transitions[i].transition->is_disabled()) {
+						continue;
+					}
+
+					if (current_transition.next == prev_state_machine->end_node && _check_advance_condition(prev_state_machine, prev_state_machine->transitions[i].transition)) {
+						if (prev_state_machine->transitions[i].transition->get_priority() <= priority_best) {
+							priority_best = prev_state_machine->transitions[i].transition->get_priority();
+							auto_advance_to = i;
+						}
+					}
+				}
+
+				if (auto_advance_to != -1) {
+					if (prev_state_machine->transitions[auto_advance_to].transition->get_xfade_time()) {
+						return rem;
+					}
+				}
+			}
+		}
+	}
+
 	//if next, see when to transition
 	if (next != StringName()) {
 		bool goto_next = false;
 
 		if (switch_mode == AnimationNodeStateMachineTransition::SWITCH_MODE_AT_END) {
-			goto_next = next_xfade >= (len_current - pos_current) || loops_current > 0;
-			if (loops_current > 0) {
+			goto_next = next_xfade >= (len_current - pos_current) || end_loop;
+			if (end_loop) {
 				next_xfade = 0;
 			}
 		} else {
 			goto_next = fading_from == StringName();
 		}
 
-		if (goto_next) { //loops should be used because fade time may be too small or zero and animation may have looped
+		if (goto_next) { //end_loop should be used because fade time may be too small or zero and animation may have looped
 
 			if (next_xfade) {
 				//time to fade, baby
@@ -468,28 +577,71 @@ double AnimationNodeStateMachinePlayback::process(AnimationNodeStateMachine *p_s
 			}
 			current = next;
 			if (switch_mode == AnimationNodeStateMachineTransition::SWITCH_MODE_SYNC) {
-				len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, 0, AnimationNode::FILTER_IGNORE, false);
+				len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, p_seek_root, 0, AnimationNode::FILTER_IGNORE, true);
 				pos_current = MIN(pos_current, len_current);
-				p_state_machine->blend_node(current, p_state_machine->states[current].node, pos_current, true, 0, AnimationNode::FILTER_IGNORE, false);
+				p_state_machine->blend_node(current, p_state_machine->states[current].node, pos_current, true, p_seek_root, 0, AnimationNode::FILTER_IGNORE, true);
 
 			} else {
-				len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, 0, AnimationNode::FILTER_IGNORE, false);
+				len_current = p_state_machine->blend_node(current, p_state_machine->states[current].node, 0, true, p_seek_root, 0, AnimationNode::FILTER_IGNORE, true);
 				pos_current = 0;
 			}
 
 			rem = len_current; //so it does not show 0 on transition
-			loops_current = 0;
 		}
 	}
 
-	//compute time left for transitions by using the end node
-	if (p_state_machine->end_node != StringName() && p_state_machine->end_node != current) {
-		rem = p_state_machine->blend_node(p_state_machine->end_node, p_state_machine->states[p_state_machine->end_node].node, 0, true, 0, AnimationNode::FILTER_IGNORE, false);
+	// time left must always be 1 because the end node don't length to compute
+	if (p_state_machine->end_node != current) {
+		rem = 1;
+	} else {
+		Ref<AnimationNodeStateMachinePlayback> prev_playback = p_state_machine->prev_state_machine->get_parameter("playback");
+
+		if (prev_playback.is_valid()) {
+			prev_playback->current_transition = current_transition;
+			prev_playback->force_auto_advance = true;
+		}
 	}
 
 	return rem;
 }
 
+bool AnimationNodeStateMachinePlayback::_check_advance_condition(const Ref<AnimationNodeStateMachine> state_machine, const Ref<AnimationNodeStateMachineTransition> transition) const {
+	if (transition->has_auto_advance()) {
+		return true;
+	}
+
+	StringName advance_condition_name = transition->get_advance_condition_name();
+
+	if (advance_condition_name != StringName() && bool(state_machine->get_parameter(advance_condition_name))) {
+		return true;
+	}
+
+	if (transition->expression.is_valid()) {
+		AnimationTree *tree_base = state_machine->get_animation_tree();
+		ERR_FAIL_COND_V(tree_base == nullptr, false);
+
+		NodePath advance_expression_base_node_path;
+		if (!transition->advance_expression_base_node.is_empty()) {
+			advance_expression_base_node_path = transition->advance_expression_base_node;
+		} else {
+			advance_expression_base_node_path = tree_base->get_advance_expression_base_node();
+		}
+
+		Node *expression_base = tree_base->get_node_or_null(advance_expression_base_node_path);
+		if (expression_base) {
+			Ref<Expression> exp = transition->expression;
+			bool ret = exp->execute(Array(), tree_base, false, Engine::get_singleton()->is_editor_hint()); // Avoids allowing the user to crash the system with an expression by only allowing const calls.
+			if (!exp->has_execute_failed()) {
+				if (ret) {
+					return true;
+				}
+			}
+		}
+	}
+
+	return false;
+}
+
 void AnimationNodeStateMachinePlayback::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("travel", "to_node"), &AnimationNodeStateMachinePlayback::travel);
 	ClassDB::bind_method(D_METHOD("start", "node"), &AnimationNodeStateMachinePlayback::start);
@@ -521,6 +673,23 @@ void AnimationNodeStateMachine::get_parameter_list(List<PropertyInfo> *r_list) c
 	for (const StringName &E : advance_conditions) {
 		r_list->push_back(PropertyInfo(Variant::BOOL, E));
 	}
+
+	// for (const KeyValue<StringName, State> &E : states) {
+	// 	if (E->node == ansm) {
+	// 		for (int i = 0; i < E->node->transitions.size(); i++) {
+	// 			StringName ac = E->node->transitions[i].transition->get_advance_condition_name();
+	// 			if (ac != StringName() && advance_conditions.find(ac) == nullptr) {
+	// 				advance_conditions.push_back(ac);
+	// 			}
+	// 		}
+
+	// 		advance_conditions.sort_custom<StringName::AlphCompare>();
+
+	// 		for (const StringName &E : advance_conditions) {
+	// 			r_list->push_back(PropertyInfo(Variant::BOOL, E));
+	// 		}
+	// 	}
+	// }
 }
 
 Variant AnimationNodeStateMachine::get_parameter_default_value(const StringName &p_parameter) const {
@@ -544,6 +713,13 @@ void AnimationNodeStateMachine::add_node(const StringName &p_name, Ref<Animation
 
 	states[p_name] = state;
 
+	Ref<AnimationNodeStateMachine> anodesm = p_node;
+
+	if (anodesm.is_valid()) {
+		anodesm->state_machine_name = p_name;
+		anodesm->prev_state_machine = this;
+	}
+
 	emit_changed();
 	emit_signal(SNAME("tree_changed"));
 
@@ -570,6 +746,14 @@ void AnimationNodeStateMachine::replace_node(const StringName &p_name, Ref<Anima
 	p_node->connect("tree_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 }
 
+bool AnimationNodeStateMachine::can_edit_node(const StringName &p_name) const {
+	if (states.has(p_name)) {
+		return !(states[p_name].node->is_class("AnimationNodeStartState") || states[p_name].node->is_class("AnimationNodeEndState"));
+	}
+
+	return true;
+}
+
 Ref<AnimationNode> AnimationNodeStateMachine::get_node(const StringName &p_name) const {
 	ERR_FAIL_COND_V(!states.has(p_name), Ref<AnimationNode>());
 
@@ -610,36 +794,24 @@ bool AnimationNodeStateMachine::has_node(const StringName &p_name) const {
 void AnimationNodeStateMachine::remove_node(const StringName &p_name) {
 	ERR_FAIL_COND(!states.has(p_name));
 
-	{
-		Ref<AnimationNode> node = states[p_name].node;
-
-		ERR_FAIL_COND(node.is_null());
-
-		node->disconnect("tree_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed));
+	if (!can_edit_node(p_name)) {
+		return;
 	}
 
-	states.erase(p_name);
-	//path.erase(p_name);
-
 	for (int i = 0; i < transitions.size(); i++) {
-		if (transitions[i].from == p_name || transitions[i].to == p_name) {
-			transitions.write[i].transition->disconnect("advance_condition_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed));
-			transitions.remove_at(i);
+		if (transitions[i].local_from == p_name || transitions[i].local_to == p_name) {
+			remove_transition_by_index(i);
 			i--;
 		}
 	}
 
-	if (start_node == p_name) {
-		start_node = StringName();
-	}
-
-	if (end_node == p_name) {
-		end_node = StringName();
+	{
+		Ref<AnimationNode> node = states[p_name].node;
+		ERR_FAIL_COND(node.is_null());
+		node->disconnect("tree_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed));
 	}
 
-	/*if (playing && current == p_name) {
-		stop();
-	}*/
+	states.erase(p_name);
 
 	emit_changed();
 	emit_signal(SNAME("tree_changed"));
@@ -648,39 +820,73 @@ void AnimationNodeStateMachine::remove_node(const StringName &p_name) {
 void AnimationNodeStateMachine::rename_node(const StringName &p_name, const StringName &p_new_name) {
 	ERR_FAIL_COND(!states.has(p_name));
 	ERR_FAIL_COND(states.has(p_new_name));
+	ERR_FAIL_COND(!can_edit_node(p_name));
 
 	states[p_new_name] = states[p_name];
 	states.erase(p_name);
 
+	Ref<AnimationNodeStateMachine> anodesm = states[p_new_name].node;
+	if (anodesm.is_valid()) {
+		anodesm->state_machine_name = p_new_name;
+	}
+
 	for (int i = 0; i < transitions.size(); i++) {
-		if (transitions[i].from == p_name) {
-			transitions.write[i].from = p_new_name;
+		if (transitions[i].local_from == p_name) {
+			_rename_transition(transitions[i].from, String(transitions[i].from).replace_first(p_name, p_new_name));
 		}
 
-		if (transitions[i].to == p_name) {
-			transitions.write[i].to = p_new_name;
+		if (transitions[i].local_to == p_name) {
+			_rename_transition(transitions[i].to, String(transitions[i].to).replace_first(p_name, p_new_name));
 		}
 	}
 
-	if (start_node == p_name) {
-		start_node = p_new_name;
-	}
+	emit_signal("tree_changed");
+}
 
-	if (end_node == p_name) {
-		end_node = p_new_name;
+void AnimationNodeStateMachine::_rename_transition(const StringName &p_name, const StringName &p_new_name) {
+	if (updating_transitions) {
+		return;
 	}
 
-	/*if (playing && current == p_name) {
-		current = p_new_name;
-	}*/
+	updating_transitions = true;
+	for (int i = 0; i < transitions.size(); i++) {
+		if (transitions[i].from == p_name) {
+			Vector<String> path = String(transitions[i].to).split("/");
+			if (path.size() > 1) {
+				if (path[0] == "..") {
+					prev_state_machine->_rename_transition(String(state_machine_name) + "/" + p_name, String(state_machine_name) + "/" + p_new_name);
+				} else {
+					((Ref<AnimationNodeStateMachine>)states[transitions[i].local_to].node)->_rename_transition("../" + p_name, "../" + p_new_name);
+				}
+			}
 
-	//path.clear(); //clear path
-	emit_signal(SNAME("tree_changed"));
+			transitions.write[i].from = p_new_name;
+		}
+
+		if (transitions[i].to == p_name) {
+			Vector<String> path = String(transitions[i].from).split("/");
+			if (path.size() > 1) {
+				if (path[0] == "..") {
+					prev_state_machine->_rename_transition(String(state_machine_name) + "/" + p_name, String(state_machine_name) + "/" + p_new_name);
+				} else {
+					((Ref<AnimationNodeStateMachine>)states[transitions[i].local_from].node)->_rename_transition("../" + p_name, "../" + p_new_name);
+				}
+			}
+
+			transitions.write[i].to = p_new_name;
+		}
+
+		updating_transitions = false;
+	}
 }
 
 void AnimationNodeStateMachine::get_node_list(List<StringName> *r_nodes) const {
 	List<StringName> nodes;
 	for (const KeyValue<StringName, State> &E : states) {
+		if (E.key == end_node && prev_state_machine == nullptr) {
+			continue;
+		}
+
 		nodes.push_back(E.key);
 	}
 	nodes.sort_custom<StringName::AlphCompare>();
@@ -690,9 +896,16 @@ void AnimationNodeStateMachine::get_node_list(List<StringName> *r_nodes) const {
 	}
 }
 
+AnimationNodeStateMachine *AnimationNodeStateMachine::get_prev_state_machine() const {
+	return prev_state_machine;
+}
+
 bool AnimationNodeStateMachine::has_transition(const StringName &p_from, const StringName &p_to) const {
+	StringName from = _get_shortest_path(p_from);
+	StringName to = _get_shortest_path(p_to);
+
 	for (int i = 0; i < transitions.size(); i++) {
-		if (transitions[i].from == p_from && transitions[i].to == p_to) {
+		if (transitions[i].from == from && transitions[i].to == to) {
 			return true;
 		}
 	}
@@ -700,32 +913,148 @@ bool AnimationNodeStateMachine::has_transition(const StringName &p_from, const S
 }
 
 int AnimationNodeStateMachine::find_transition(const StringName &p_from, const StringName &p_to) const {
+	StringName from = _get_shortest_path(p_from);
+	StringName to = _get_shortest_path(p_to);
+
 	for (int i = 0; i < transitions.size(); i++) {
-		if (transitions[i].from == p_from && transitions[i].to == p_to) {
+		if (transitions[i].from == from && transitions[i].to == to) {
 			return i;
 		}
 	}
 	return -1;
 }
 
+bool AnimationNodeStateMachine::_can_connect(const StringName &p_name, Vector<AnimationNodeStateMachine *> p_parents) {
+	if (p_parents.is_empty()) {
+		AnimationNodeStateMachine *prev = this;
+		while (prev != nullptr) {
+			p_parents.push_back(prev);
+			prev = prev->prev_state_machine;
+		}
+	}
+
+	if (states.has(p_name)) {
+		Ref<AnimationNodeStateMachine> anodesm = states[p_name].node;
+
+		if (anodesm.is_valid() && p_parents.find(anodesm.ptr()) != -1) {
+			return false;
+		}
+
+		return true;
+	}
+
+	String name = p_name;
+	Vector<String> path = name.split("/");
+
+	if (path.size() < 2) {
+		return false;
+	}
+
+	if (path[0] == "..") {
+		if (prev_state_machine != nullptr) {
+			return prev_state_machine->_can_connect(name.replace_first("../", ""), p_parents);
+		}
+	} else if (states.has(path[0])) {
+		Ref<AnimationNodeStateMachine> anodesm = states[path[0]].node;
+		if (anodesm.is_valid()) {
+			return anodesm->_can_connect(name.replace_first(path[0] + "/", ""), p_parents);
+		}
+	}
+
+	return false;
+}
+
+StringName AnimationNodeStateMachine::_get_shortest_path(const StringName &p_path) const {
+	// If p_path is something like StateMachine/../StateMachine2/State1,
+	// the result will be StateMachine2/State1. This avoid duplicate
+	// transitions when using add_transition. eg, this two calls is the same:
+	//
+	// add_transition("State1", "StateMachine/../State2", tr)
+	// add_transition("State1", "State2", tr)
+	//
+	// but the second call must be invalid because the transition already exists
+
+	Vector<String> path = String(p_path).split("/");
+	Vector<String> new_path;
+
+	for (int i = 0; i < path.size(); i++) {
+		if (i > 0 && path[i] == ".." && new_path[i - 1] != "..") {
+			new_path.remove_at(i - 1);
+		} else {
+			new_path.push_back(path[i]);
+		}
+	}
+
+	String result;
+	for (int i = 0; i < new_path.size(); i++) {
+		result += new_path[i] + "/";
+	}
+	result.remove_at(result.length() - 1);
+
+	return result;
+}
+
 void AnimationNodeStateMachine::add_transition(const StringName &p_from, const StringName &p_to, const Ref<AnimationNodeStateMachineTransition> &p_transition) {
-	ERR_FAIL_COND(p_from == p_to);
-	ERR_FAIL_COND(!states.has(p_from));
-	ERR_FAIL_COND(!states.has(p_to));
+	if (updating_transitions) {
+		return;
+	}
+
+	StringName from = _get_shortest_path(p_from);
+	StringName to = _get_shortest_path(p_to);
+	Vector<String> path_from = String(from).split("/");
+	Vector<String> path_to = String(to).split("/");
+
+	ERR_FAIL_COND(from == end_node || to == start_node);
+	ERR_FAIL_COND(from == to);
+	ERR_FAIL_COND(!_can_connect(from));
+	ERR_FAIL_COND(!_can_connect(to));
 	ERR_FAIL_COND(p_transition.is_null());
 
 	for (int i = 0; i < transitions.size(); i++) {
-		ERR_FAIL_COND(transitions[i].from == p_from && transitions[i].to == p_to);
+		ERR_FAIL_COND(transitions[i].from == from && transitions[i].to == to);
+	}
+
+	if (path_from.size() > 1 || path_to.size() > 1) {
+		ERR_FAIL_COND(path_from[0] == path_to[0]);
 	}
 
+	updating_transitions = true;
+
+	StringName local_from = String(from).get_slicec('/', 0);
+	StringName local_to = String(to).get_slicec('/', 0);
+	local_from = local_from == ".." ? "Start" : local_from;
+	local_to = local_to == ".." ? "End" : local_to;
+
 	Transition tr;
-	tr.from = p_from;
-	tr.to = p_to;
+	tr.from = from;
+	tr.to = to;
+	tr.local_from = local_from;
+	tr.local_to = local_to;
 	tr.transition = p_transition;
 
 	tr.transition->connect("advance_condition_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed), varray(), CONNECT_REFERENCE_COUNTED);
 
 	transitions.push_back(tr);
+
+	// do recursive
+	if (path_from.size() > 1) {
+		StringName local_path = String(from).replace_first(path_from[0] + "/", "");
+		if (path_from[0] == "..") {
+			prev_state_machine->add_transition(local_path, String(state_machine_name) + "/" + to, p_transition);
+		} else {
+			((Ref<AnimationNodeStateMachine>)states[path_from[0]].node)->add_transition(local_path, "../" + to, p_transition);
+		}
+	}
+	if (path_to.size() > 1) {
+		StringName local_path = String(to).replace_first(path_to[0] + "/", "");
+		if (path_to[0] == "..") {
+			prev_state_machine->add_transition(String(state_machine_name) + "/" + from, local_path, p_transition);
+		} else {
+			((Ref<AnimationNodeStateMachine>)states[path_to[0]].node)->add_transition("../" + from, local_path, p_transition);
+		}
+	}
+
+	updating_transitions = false;
 }
 
 Ref<AnimationNodeStateMachineTransition> AnimationNodeStateMachine::get_transition(int p_transition) const {
@@ -748,44 +1077,52 @@ int AnimationNodeStateMachine::get_transition_count() const {
 }
 
 void AnimationNodeStateMachine::remove_transition(const StringName &p_from, const StringName &p_to) {
+	StringName from = _get_shortest_path(p_from);
+	StringName to = _get_shortest_path(p_to);
+
 	for (int i = 0; i < transitions.size(); i++) {
-		if (transitions[i].from == p_from && transitions[i].to == p_to) {
-			transitions.write[i].transition->disconnect("advance_condition_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed));
-			transitions.remove_at(i);
+		if (transitions[i].from == from && transitions[i].to == to) {
+			remove_transition_by_index(i);
 			return;
 		}
 	}
-
-	/*if (playing) {
-		path.clear();
-	}*/
 }
 
-void AnimationNodeStateMachine::remove_transition_by_index(int p_transition) {
+void AnimationNodeStateMachine::remove_transition_by_index(const int p_transition) {
 	ERR_FAIL_INDEX(p_transition, transitions.size());
+	Transition tr = transitions[p_transition];
 	transitions.write[p_transition].transition->disconnect("advance_condition_changed", callable_mp(this, &AnimationNodeStateMachine::_tree_changed));
 	transitions.remove_at(p_transition);
-	/*if (playing) {
-		path.clear();
-	}*/
-}
 
-void AnimationNodeStateMachine::set_start_node(const StringName &p_node) {
-	ERR_FAIL_COND(p_node != StringName() && !states.has(p_node));
-	start_node = p_node;
-}
+	Vector<String> path_from = String(tr.from).split("/");
+	Vector<String> path_to = String(tr.to).split("/");
 
-String AnimationNodeStateMachine::get_start_node() const {
-	return start_node;
-}
+	List<Vector<String>> paths;
+	paths.push_back(path_from);
+	paths.push_back(path_to);
+
+	for (List<Vector<String>>::Element *E = paths.front(); E; E = E->next()) {
+		if (E->get()[0].size() > 1) {
+			if (E->get()[0] == "..") {
+				prev_state_machine->_remove_transition(tr.transition);
+			} else if (states.has(E->get()[0])) {
+				Ref<AnimationNodeStateMachine> anodesm = states[E->get()[0]].node;
 
-void AnimationNodeStateMachine::set_end_node(const StringName &p_node) {
-	ERR_FAIL_COND(p_node != StringName() && !states.has(p_node));
-	end_node = p_node;
+				if (anodesm.is_valid()) {
+					anodesm->_remove_transition(tr.transition);
+				}
+			}
+		}
+	}
 }
 
-String AnimationNodeStateMachine::get_end_node() const {
-	return end_node;
+void AnimationNodeStateMachine::_remove_transition(const Ref<AnimationNodeStateMachineTransition> p_transition) {
+	for (int i = 0; i < transitions.size(); i++) {
+		if (transitions[i].transition == p_transition) {
+			remove_transition_by_index(i);
+			return;
+		}
+	}
 }
 
 void AnimationNodeStateMachine::set_graph_offset(const Vector2 &p_offset) {
@@ -796,17 +1133,29 @@ Vector2 AnimationNodeStateMachine::get_graph_offset() const {
 	return graph_offset;
 }
 
-double AnimationNodeStateMachine::process(double p_time, bool p_seek) {
+double AnimationNodeStateMachine::process(double p_time, bool p_seek, bool p_seek_root) {
 	Ref<AnimationNodeStateMachinePlayback> playback = get_parameter(this->playback);
 	ERR_FAIL_COND_V(playback.is_null(), 0.0);
 
-	return playback->process(this, p_time, p_seek);
+	return playback->process(this, p_time, p_seek, p_seek_root);
 }
 
 String AnimationNodeStateMachine::get_caption() const {
 	return "StateMachine";
 }
 
+bool AnimationNodeStateMachine::has_local_transition(const StringName &p_from, const StringName &p_to) const {
+	StringName from = _get_shortest_path(p_from);
+	StringName to = _get_shortest_path(p_to);
+
+	for (int i = 0; i < transitions.size(); i++) {
+		if (transitions[i].local_from == from && transitions[i].local_to == to) {
+			return true;
+		}
+	}
+	return false;
+}
+
 Ref<AnimationNode> AnimationNodeStateMachine::get_child_by_name(const StringName &p_name) {
 	return get_node(p_name);
 }
@@ -839,12 +1188,6 @@ bool AnimationNodeStateMachine::_set(const StringName &p_name, const Variant &p_
 			add_transition(trans[i], trans[i + 1], trans[i + 2]);
 		}
 		return true;
-	} else if (name == "start_node") {
-		set_start_node(p_value);
-		return true;
-	} else if (name == "end_node") {
-		set_end_node(p_value);
-		return true;
 	} else if (name == "graph_offset") {
 		set_graph_offset(p_value);
 		return true;
@@ -860,7 +1203,7 @@ bool AnimationNodeStateMachine::_get(const StringName &p_name, Variant &r_ret) c
 		String what = name.get_slicec('/', 2);
 
 		if (what == "node") {
-			if (states.has(node_name)) {
+			if (states.has(node_name) && can_edit_node(node_name)) {
 				r_ret = states[node_name].node;
 				return true;
 			}
@@ -874,22 +1217,21 @@ bool AnimationNodeStateMachine::_get(const StringName &p_name, Variant &r_ret) c
 		}
 	} else if (name == "transitions") {
 		Array trans;
-		trans.resize(transitions.size() * 3);
-
 		for (int i = 0; i < transitions.size(); i++) {
-			trans[i * 3 + 0] = transitions[i].from;
-			trans[i * 3 + 1] = transitions[i].to;
-			trans[i * 3 + 2] = transitions[i].transition;
+			String from = transitions[i].from;
+			String to = transitions[i].to;
+
+			if (from.get_slicec('/', 0) == ".." || to.get_slicec('/', 0) == "..") {
+				continue;
+			}
+
+			trans.push_back(from);
+			trans.push_back(to);
+			trans.push_back(transitions[i].transition);
 		}
 
 		r_ret = trans;
 		return true;
-	} else if (name == "start_node") {
-		r_ret = get_start_node();
-		return true;
-	} else if (name == "end_node") {
-		r_ret = get_end_node();
-		return true;
 	} else if (name == "graph_offset") {
 		r_ret = get_graph_offset();
 		return true;
@@ -911,8 +1253,6 @@ void AnimationNodeStateMachine::_get_property_list(List<PropertyInfo> *p_list) c
 	}
 
 	p_list->push_back(PropertyInfo(Variant::ARRAY, "transitions", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
-	p_list->push_back(PropertyInfo(Variant::STRING_NAME, "start_node", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
-	p_list->push_back(PropertyInfo(Variant::STRING_NAME, "end_node", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
 	p_list->push_back(PropertyInfo(Variant::VECTOR2, "graph_offset", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NO_EDITOR));
 }
 
@@ -920,10 +1260,24 @@ void AnimationNodeStateMachine::reset_state() {
 	states.clear();
 	transitions.clear();
 	playback = "playback";
-	start_node = StringName();
-	end_node = StringName();
+	start_node = "Start";
+	end_node = "End";
 	graph_offset = Vector2();
 
+	Ref<AnimationNodeStartState> s;
+	s.instantiate();
+	State start;
+	start.node = s;
+	start.position = Vector2(200, 100);
+	states[start_node] = start;
+
+	Ref<AnimationNodeEndState> e;
+	e.instantiate();
+	State end;
+	end.node = e;
+	end.position = Vector2(900, 100);
+	states[end_node] = end;
+
 	emit_changed();
 	emit_signal(SNAME("tree_changed"));
 }
@@ -963,15 +1317,22 @@ void AnimationNodeStateMachine::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("remove_transition_by_index", "idx"), &AnimationNodeStateMachine::remove_transition_by_index);
 	ClassDB::bind_method(D_METHOD("remove_transition", "from", "to"), &AnimationNodeStateMachine::remove_transition);
 
-	ClassDB::bind_method(D_METHOD("set_start_node", "name"), &AnimationNodeStateMachine::set_start_node);
-	ClassDB::bind_method(D_METHOD("get_start_node"), &AnimationNodeStateMachine::get_start_node);
-
-	ClassDB::bind_method(D_METHOD("set_end_node", "name"), &AnimationNodeStateMachine::set_end_node);
-	ClassDB::bind_method(D_METHOD("get_end_node"), &AnimationNodeStateMachine::get_end_node);
-
 	ClassDB::bind_method(D_METHOD("set_graph_offset", "offset"), &AnimationNodeStateMachine::set_graph_offset);
 	ClassDB::bind_method(D_METHOD("get_graph_offset"), &AnimationNodeStateMachine::get_graph_offset);
 }
 
 AnimationNodeStateMachine::AnimationNodeStateMachine() {
+	Ref<AnimationNodeStartState> s;
+	s.instantiate();
+	State start;
+	start.node = s;
+	start.position = Vector2(200, 100);
+	states[start_node] = start;
+
+	Ref<AnimationNodeEndState> e;
+	e.instantiate();
+	State end;
+	end.node = e;
+	end.position = Vector2(900, 100);
+	states[end_node] = end;
 }