How to return the node to its original position?

Tudor

Hello! I want to return a node to its original position. For this, I saved its original position in one variable, and then I use this variable for interpolation to its original position. But, for whatever reason, the node covers only part of the distance, it does not reach its original position.

I tried to use global position, but this doesn't change anything.

How could I fix this?

fire7side

There's a page here on transform interpolation, which is down a few sections from the top.
https://docs.godotengine.org/en/stable/tutorials/math/interpolation.html#transform-interpolation

Tudor

Thanks for the reply, but I mean linear interpolation from point A to point B, and then back to point A.

The problem is that the interpolation from point B back to point A is not done to the end. Specifically, it doesn't interpolate to the right point.

xyz

@Tudor it'd be helpful if you post a minimal setup that causes the problem - scene hierarchy and code.

fire7side

@Tudor said: Thanks for the reply, but I mean linear interpolation from point A to point B, and then back to point A.

The problem is that the interpolation from point B back to point A is not done to the end. Specifically, it doesn't interpolate to the right point.

Going back is just reversing t from 1 to 0 rather than 0 to 1. Every vector has a linear_interpolate function and there was example code on the page I referenced. It's straight forward. A lot of people use linear interpolation incorrectly. It's just sliding a t value from 0 to 1 at whatever speed you choose but at a constant rate.

Tudor

@xyz said: @Tudor it'd be helpful if you post a minimal setup that causes the problem - scene hierarchy and code.

Sure, this is the scene hierarchy:

And here is the code:

The line of code that should interpolate the ”Class_Collection” node to its initial position is at the end.

extends Node2D

#Explanations:

#Phase 1 - starts with the beginning of the game and ends with the element class chosen and clicked. 
#          The clicked element class is interpolated on the right side of the screen, while the other 
#          element classes are moved on the left side of the screen.

#Phase 2 - starts with the chosen element class on the right side of the screen.


#Variables - phase 1
var interpolation_velocity = 0.05
var interpolating = false
var air_class_interpolating = false
var earth_class_interpolating = false
var fire_class_interpolating = false
var water_class_interpolating = false

#Initial positions:
#We use 'onready var' whenever we need to assign a node path to a variable
onready var air_class_initial_position = get_node("Air_Class2").position
onready var earth_class_initial_position = get_node("Earth_Class2").position
onready var fire_class_initial_position = get_node("Fire_Class2").position
onready var water_class_initial_position = get_node("Water_Class2").position

var class_collection_initial_position = Vector2(0,0)

#Variables - phase 2
var air_class_is_chosen = false
var earth_class_is_chosen = false
var fire_class_is_chosen = false
var water_class_is_chosen = false

var air_class_reverse_interpolation = false
var earth_class_reverse_interpolation = false
var fire_class_reverse_interpolation = false
var water_class_reverse_interpolation = false

#Position initialization
func _ready():
	$Class_Collection.position = get_viewport_rect().size / 2
	print("Class collection position: ", $Class_Collection.position)
	
	$Air_Class2.position = $Class_Collection.position + $Class_Collection/Air_Class.position
	$Earth_Class2.position = $Class_Collection.position + $Class_Collection/Earth_Class.position
	$Fire_Class2.position = $Class_Collection.position + $Class_Collection/Fire_Class.position
	$Water_Class2.position = $Class_Collection.position + $Class_Collection/Water_Class.position

	air_class_initial_position = $Air_Class2.position
	earth_class_initial_position = $Earth_Class2.position
	fire_class_initial_position = $Fire_Class2.position
	water_class_initial_position = $Water_Class2.position
	
	class_collection_initial_position = $Class_Collection.global_position
	print("Class collection initial position: ", class_collection_initial_position)
	
	
func _process(_delta):
	
	if (Input.is_action_just_pressed("ui_cancel")): #ui_cancel is ESC key
		Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)
		get_tree().quit() #quit the game
		
	if (Input.is_action_just_pressed("restart")):
		get_tree().reload_current_scene()
	
	#Phase 1:
	#If an element class is clicked
	#'Click' state is activated
	if ($Class_Collection/Air_Class.click == true or 
		$Class_Collection/Earth_Class.click == true or 
		$Class_Collection/Fire_Class.click == true or 
		$Class_Collection/Water_Class.click == true):
		print ("Element")
		interpolating = true
	
	#Turning all other element classes invisible
	if $Class_Collection/Air_Class.click == true:
		air_class_interpolating = true
		$Earth_Class2.visible = false
		$Fire_Class2.visible = false
		$Water_Class2.visible = false 
	if $Class_Collection/Earth_Class.click == true:
		earth_class_interpolating = true 
		$Air_Class2.visible = false
		$Fire_Class2.visible = false
		$Water_Class2.visible = false
	if $Class_Collection/Fire_Class.click == true:
		fire_class_interpolating = true
		$Air_Class2.visible = false
		$Earth_Class2.visible = false
		$Water_Class2.visible = false
	if $Class_Collection/Water_Class.click == true:
		water_class_interpolating = true
		$Air_Class2.visible = false
		$Earth_Class2.visible = false
		$Fire_Class2.visible = false
	
	#'Click' state is disabled	
	$Class_Collection/Air_Class.click = false
	$Class_Collection/Earth_Class.click = false
	$Class_Collection/Fire_Class.click = false
	$Class_Collection/Water_Class.click = false
	
	#Moving the other element class to the left side of the screen (viewport)
	if interpolating == true:
		$Class_Collection.position = $Class_Collection.position.linear_interpolate(Vector2(200, $Class_Collection.position.y), interpolation_velocity)
	
	#Moving the clicked element class to the right side of the screen (viewport)
	if air_class_interpolating == true:
		$Air_Class2.position = $Air_Class2.position.linear_interpolate(Vector2(1250, $Air_Class2.position.y), interpolation_velocity)		
	if earth_class_interpolating == true:
		$Earth_Class2.position = $Earth_Class2.position.linear_interpolate(Vector2(1250, $Earth_Class2.position.y), interpolation_velocity)
	if fire_class_interpolating == true:
		$Fire_Class2.position = $Fire_Class2.position.linear_interpolate(Vector2(1250, $Fire_Class2.position.y), interpolation_velocity)
	if water_class_interpolating == true:
		$Water_Class2.position = $Water_Class2.position.linear_interpolate(Vector2(1250, $Water_Class2.position.y), interpolation_velocity)	

	#Stopping interpolations	
	if $Class_Collection.position.x == 200:
		interpolating == false

	#We use 'position.x > 1245' instead of 'position.x == 1250', because due to interpolation, the position is 
	#never 1250, instead it is a position that tends to 1250. 
	if $Air_Class2.position.x > 1245:
		air_class_interpolating = false
		air_class_is_chosen = true
	if $Earth_Class2.position.x > 1245:
		earth_class_interpolating = false
		earth_class_is_chosen = true
	if $Fire_Class2.position.x > 1245:
		fire_class_interpolating = false
		fire_class_is_chosen = true
	if $Water_Class2.position.x > 1245:
		water_class_interpolating = false
		water_class_is_chosen = true

	#Phase 2:
	#Second click
	if $Air_Class2.click == true and air_class_is_chosen == true:
		air_class_reverse_interpolation = true
	if $Earth_Class2.click == true and earth_class_is_chosen == true:
		earth_class_reverse_interpolation = true
		
	
	if air_class_reverse_interpolation == true:
		#Here is the line of code that should interpolate the ”Class_collection” node back to its initial position:
		$Class_Collection.position = $Class_Collection.position.linear_interpolate(Vector2(class_collection_initial_position.x, $Class_Collection.position.y), interpolation_velocity)
		$Air_Class2.position = $Air_Class2.position.linear_interpolate(Vector2(air_class_initial_position.x, $Air_Class2.position.y), interpolation_velocity)
	
	#Disabling click state
	$Air_Class2.click = false
	air_class_is_chosen = false

fire7side

Vector2 linear_interpolate ( Vector2 to, float weight )

Returns the result of the linear interpolation between this vector and to by amount weight. weight is on the range of 0.0 to 1.0, representing the amount of interpolation.

You are giving it a constant velocity. You have a t value which starts at 0 and you add the velocity to it each pass until you reach a value of 1. A weight of .5 will put the object half way between the two points.

func _physics_process(delta):
    t += delta * 0.4

    $Sprite.position = $A.position.linear_interpolate($B.position, t)

$A is the start position and $B is the end position, the sprite position is the return value.

xyz

@Tudor You posted too much code and your scene is too big, containing scripts you didn't post. This diminishes a chance that somebody on the forum will actually tackle it. That's why I said to post minimal case that still causes the problem. Try to reproduce the problem with as little as possible - like 2 nodes and 1 script doing just the problematic thing. This is a standard approach when resolving issues that appear in complex settings, either by help of others on forums or by yourself. So create such minimal case and post it. And/or try to analyze it yourself.

But what can be said from the posted code is that you're doing it in a too complicated way. This type of thing is best handled with tweens.

@fire7side Yeah, it's a weird way of doing it but it may still somewhat work as the current position is updated, and then used as an interpolation argument in next frame. So total range gets smaller and smaller while interpolation parameter is constant. It'll look like some kind of easing but may actually never reach the exact target position. This may or may not be the cause of the problem. Since there is a bunch of scripts in the scene, and we don't know what they're doing, it could be other things too. Hard to tell as there's too many unknowns.

Tudor

Thank you, guys, for your advices!

I changed the interpolation implementations to have the 't' parameter being updated at every time segment (by using 't += delta * 0.2'), but this didn't solve the problem.

Then, I changed the interpolations with tweens, and this way, I messed up the whole game.

Now, I think this game needs to be made from the beginning, with the code being specially adapted to tweens.

This project has been a learning exercise for me: building a clone of an existing game, for learning purposes, in order to gain insight and experience of developing games.

For now, I will put this project on pause, and continue to develop a platform game (my own project) I started this summer.

So, I continue game development in Godot, but this time, on another project, on my own project.

Thanks again for the great explanations and knowledge sharing!