Player slightly moving into the wall when trying to move towards the wall

SpicoTheMirrorSpirit

Im trying to make a platformer where the player can fly as an extra ability, similar to Kirby, but i have noticed that the player goes into walls on both sides slightly when trying to move into them, by around 1 pixel. He goes back by 2 pixels or so whenever you let go of the button, aka where he should be to begin with. When a player walks into a wall, i set its general velocity.x value to 0, so it stops moving. This has proven to work when the player is jumping, flying, falling etc. but not when walking. I tried replacing the walking script with the aformentioned 3 states respectively one by one that the player doesnt clip into the wall with, but he still has. I checked every single is_on_floor() statements and where State.FLOOR is used, removed the line that sets the X velocity to 0, but it still has not worked. It really feels like in this State.FLOOR, which handles both the idle and the walking states, it just will clip into the wall no matter what i do. Oh and, oddly enough, when having 2 duplicate movement checking scripts right under each other, the issue fixes itself. How can i stop my player from going into the wall slightly when moving into the wall?

SpicoTheMirrorSpirit

i figured i should give out some of the code when it comes to movement: Floor code: (at least the part that matters, but then again no matter what movement code i put in here it doesnt really work)

	State.FLOOR:
			if direction == -1: # Left
				velocity.x = max(velocity.x - speed, -max_speed)
				if velocity.x < 0:
					sprite.flip_h = true
				else:
					state = States.DRIFT
					animplayer.play("Drift")
					sprite.flip_h = false
			elif direction == 1: # Right
				velocity.x = min(velocity.x + speed, max_speed)
				if velocity.x > 0:
					sprite.flip_h = false
				else:
					state = States.DRIFT
					animplayer.play("Drift")
					sprite.flip_h = true
			else:
				velocity.x = lerp(velocity.x, 0, lerp_amount)

Movement code:

func movement(): # is in _physics_process(delta)
	if state == States.FLY or state == States.GUST:
		if not (Input.is_action_pressed("fly") or Input.is_action_pressed("jump")):
			velocity.y = min(velocity.y + (gravity / 1.5), (max_gravity / 3))
	else:
		velocity.y = min(velocity.y + gravity, max_gravity)
	var _collision = move_and_slide(velocity, Vector2.UP)
	if is_on_floor() or is_on_ceiling():
		velocity.y = 0
	if is_on_wall():
		velocity.x = 0

SpicoTheMirrorSpirit

A little update on this, i tried removing gravity, and when i did remove gravity, the issue was present on even the fall animations, so maybe its releated to that somewhat? This issue also happens when the player is in the floating state, but is also touching the ground while trying to ram into a wall, but otherwise while on air, nothing outside of whats supposed to happen is happening I, again, checked every single is on floor variable to see if i can disable something, i disabled every is on floor lines of code, the issue persisted I also tried putting the State.FLOOR code into a different states code, but the problem was the same as before,

The only thing i noticed thats worth noting, is that the players Y position also decreases when ramming a wall, meaning the player also floats up from the ground a bit, it seems to be the same amount of how much it digs into the wall

Still havent found a way to fix it, though

SnapCracklins

You may want to try using a clamp function. You can limit how far to go on the x and y axes and that can solve your problem. This does this using the viewport size as a reference. You could theoretically use the length of your scene and hard code that into the pixels too.

var screen_size


func _ready():
	screen_size = get_viewport_rect().size

position.x = clamp(position.x, 0, screen_size.x)

And you can play with those values until you get the margin you want between wall and player.

SpicoTheMirrorSpirit

@SnapCracklins said: You may want to try using a clamp function. You can limit how far to go on the x and y axes and that can solve your problem. This does this using the viewport size as a reference. You could theoretically use the length of your scene and hard code that into the pixels too.
var screen_size


func _ready():
	screen_size = get_viewport_rect().size

position.x = clamp(position.x, 0, screen_size.x)
And you can play with those values until you get the margin you want between wall and player.

Thanks for the reply! Apologies for my own slow reply though, im recently jumping from project to project releatively fast.

What im trying to do wasnt with the screen itself, it was with other staticbody2ds that i experienced this with. Although i managed to fix it by setting the players y velocity to around 2, weird fix but it did the trick for me.