why "wait for sec''' so difficult Is there any others options to delay a func?

Okay, so you want to move a character along a path in steps, with a time delay between the steps.

What kind of node is the character? For example, is it a KinematicBody2D?

Don't do the movement in _ready(). Start the Timer in _ready(). Connect the Timer node's timeout signal to a function, such as _on_timeout(), and do the movement there.

The simplest is sceneTreeTimer:

https://docs.godotengine.org/en/stable/classes/class_scenetreetimer.html

However I don't use it because it's not part your scene and might cause issues. Better to create a Timer, and then "await timer.timeout" (edit: and usually better to put code in the timer callback, than using await, await is more for some situations usually where you are awaiting a special signal). If you build the Timer into your scene with the editor and make a unique name, that will simplify it much more than doing it with code.

TBH Godot should have a time argument to call_deferred() , that would simplify a lot

I agree with @cybereality and @duane that you shouldn't be messing with yield/await if you're a beginner, and instead approach it in the way @DaveTheCoder suggested. That being said, making a coroutine that calls your function periodically may be an elegant way to do it because you see an explicit loop in your code, which is neat:

func call_consecutive(method: Callable, delay: float, number_of_calls: int) -> void:
	while number_of_calls:
		method.call()
		await get_tree().create_timer(delay).timeout
		number_of_calls -= 1
		
func _ready():
	var move_to_next_position = func():
		print("MOVING TO NEXT POSITION")
	
	call_deferred( "call_consecutive", move_to_next_position, .5, 10 )

It could be particularly useful if you want to do something in irregular intervals, or need to check for some conditions in-between the calls:

var some_condition = false

func call_consecutive(method: Callable, delays: Array) -> void:
	for delay in [0] + delays:
		await get_tree().create_timer(delay).timeout
		method.call()
		if some_condition:
			break
		
func _ready():
	var do_the_thing = func():
		print("DOING THE THING")

	call_deferred( "call_consecutive", do_the_thing, [.5, 1.0, .3])

Serhy i'm not fond of pre-baked timers in godot. they can be a bit unwieldy on logic.

What I do is create a manual timer out of frames and use a simple bool logic to stop it. This is also useful as we can get increments slightly faster than a half second. The math isn't as clean as the seconds-based Godot timer but it moves by frame so it's smooth. Surely a "brute force" solution but it works for me.

So something like:

const var _timerRefill = 100 ## your max value here
export var _timerValue : int = 100 ## export total value to editor
export var _timerRate : float = 0.5 ## export rate of total drain
var _isRunning = false ## bool logic to begin


func _process(_delta):
        if _timerValue > 0: ## if it's running, drain the timer
            if _isRunning:
                 _timerValue-=_timerRate
        else:
            _isRunning = false ## flip the bool off and reset when done
            _timerValue = _timerRefill
            ## do something
~~~~

Serhy should move in already created custom path ( L T 2) from angle to angle/ step by step. without user finger help holding a key on keyboard.

This is still stated too vaguely. In coding, problems should be defined and communicated as accurately as possible. How is this path defined? By a list of point coordinates? If so, are points equidistant? Is transition from point to point (a step) instantaneous or gradually animated? Is there an additional pause between transitions? Does this movement sequence needs to be interruptible? What's L T 2? Etc... People on forums don't see your screen and cannot read your mind. You need to write everything down.

Going by your last (imprecise) description, the easiest way to do this would be to just fire a bunch of consecutive tweens. The advantage is that it will work in fire-and-forget manner. You can setup everything at once when mouse is pressed and let the engine's tweening system take care of the timing.

Serhy Here's how to do it with tweens:

extends Node2D

var points = [ Vector2(100,100), Vector2(200, 200), Vector2(200, 100) ] # add more points

var movement_speed = 500.0
var delay = .2

func _input(event):
	if event is InputEventMouseButton and event.is_pressed():
		var t: Tween = get_tree().create_tween()
		var p_prev = position # previous position for calculating movement time
		for p in points: 
			var movement_time = p_prev.distance_to(p) / movement_speed
			t.tween_property(self, "position", p, movement_time)
			t.tween_interval(delay)
			p_prev = p