My player is dying twice

Help Physics
, ,
1

Godot Version

4.5

Question

Why is my player dying twice?

I’m working on a simple platformer game and whenever the player collides with a Spike Area2D,
it runs the die() function on the player.

func die() -> void:
	$CollisionShape2D.set_deferred("disabled", true)

	is_in_control = false
	sprite.play("die")
	await sprite.animation_finished
	position = player_spawn_point.position
	sprite.stop()
	if health > 0:
		set_health.emit(health - 1)
		health -= 1
	is_in_control = true

	$CollisionShape2D.set_deferred("disabled", false)

Here’s the remote scene tree:

root
>   Main: Node
    >   Level: TileMapLayer
       >   Spike: Area2D #Imagine a load more Spikes below in Level
           >   Sprite2D
           >   CollisionShape2D
    >   Player: CharacterBody2D
        >   AnimatedSprite2D
        >   CollisionShape2D
        >   Camera2D

If you need more info, please ask!

2

Do you call die() from process?

1 Like
3

No, it’s called from the Spike:

extends Area2D # spike.gd



func _on_body_entered(body: CharacterBody2D) -> void:
	if body.name == "Player":
		body.die()
4

See how many times you call it.
Cntrl+F shows it in one script and cntrl+Shift+F will search all scripts in your resources

1 Like
5

Also, it could be because you shut off the collision shape and then reenable it. It might be triggering the function twice

6

You’re calling these both in the same script.

The first one disables the CollisionShape2D at the end of the frame. The second one enables the CollisionShape2D at the end of the frame.

So what’s happening is all your other die code is running, then at the end of the frame you’re disabling and re-enabling the CollisionShape2D before anything else happens, which triggers a second collision. So the code runs again.

For whatever reason, that run probably sets them to run at the end of the next from and at that point, the player has been moved. So the cycle stops.

Easiest solution is to not defer those calls. Since you’re not in a _process() or _physics_process() function, you should be ok.

7

There’s an await sprite.animation_finished between disabling and re-enabling the collision shape, so it shouldn’t happen at the same time.

Also, there has been another topic recently, where disabling a collision shape without set_deferred() was fine inside _physics_process(), but not in response to a signal, so I definitely wouldn’t recommend omitting it here.

For solving the issue: Maybe the player is hitting two different spike objects during the same _physics_process()? That should call die() multiple times.

1 Like
8

I’ve tested it on just a singular spike and it still dies twice.

My theory

It’s calling the die() function twice. The die() function is called from the Spike scene whenever the player enters it. Unfold below for spike.gd script.

spike.gd 
extends Area2D # spike.gd


# connected to body_entered signal
func _on_body_entered(body: CharacterBody2D) -> void: 
	if body.name == "Player":
		body.die()

Therefore, Spike.body_entered is being emitted twice.

9

I tried this. It worked… the first time. Not the second.
EDIT: Now it’s working all the time. My brain hurts.
EDIT 2: Now it’s not working. I see why people recommend set_deferred().

10

Well, for preventing the function to run twice I guess it should be enough to check the current animation:

func die() -> void:
	
	if sprite.animation == "die":
		return
	
	# original code block

For properly solving the source of this issue, I’m pretty much out of ideas. I had been thinking about if this could be caused by the spike’s signal being connected to an additional spike instance (both of them calling die() once), but then removing set_deferred() shouldn’t change anything?

It could also be related to the player (and his movement), but then I wouldn’t expect it to happen consistently, but only occasionally. Though I think this would be the most likely possibility left.

1 Like
11

It is only dying twice occasionally. I will try that out. :godot:
EDIT: I have tried that out. It worked, but it’s a bit of an ad hoc solution :cry:

12

Add a breakpoint on this line, and trace back once it stops there. You’ll hopefully see and understand what’s happenning when the player dies more than once.

13

This works, but I always fix it with a flag, flags for the win.

#At top of player with other variables:
# Flags
var isAlreadyDead := false ## Death flag, set by die(), could also set it elsewhere for immortality buff.

func die() -> void:
    # Flag check, if the function runs once it will stop here.
    if isAlreadyDead:
        return
    # Flag set, immediately so the await doesn't allow for another frame's of damage to come through
    isAlreadyDead = true
	$CollisionShape2D.set_deferred("disabled", true)

	is_in_control = false
	sprite.play("die")
	await sprite.animation_finished
	position = player_spawn_point.position
	sprite.stop()
	if health > 0:
		set_health.emit(health - 1)
		health -= 1
	is_in_control = true

	$CollisionShape2D.set_deferred("disabled", false)

This better solves the problem if the animation is done playing and yet somehow despite the collision being disabled, which it could not be due to the await, the second will stop.

2 Likes
14

This topic was automatically closed 30 days after the last reply. New replies are no longer allowed.