Back and Front

Odin

I have a tank in my TOP-DOWN game,I want when it is shot it will be pushed back, so how do you determine which is the back of it when it keeps turning sometimes left, sometimes right. I mean it is the body of it (not the cannon). How do I code to do that. Please help me. Sorry for the bad English. thank you very much.

cybereality

You can use the basis.z to determine the forward and back of an object.

var back_vec = Vector3(0.0, 0.0, 1.0)
var basis = get_transform().basis
var back = basis.xform(back_vec)

Odin

Excuse me ! My 2D game is only Vector2. "transform" still applies to this, my Mod?

cybereality

Oh, sorry. That code is for 3D. Let me see if I can convert it into 2D.

cybereality

extends Sprite

export var speed = 90

func _process(delta):
	var front_vec = Vector2(1.0, 0.0)
	var back_vec = Vector2(-1.0, 0.0)
	var front = get_transform().basis_xform(front_vec)
	var back = get_transform().basis_xform(back_vec)
	
	if Input.is_action_pressed("front"):
		position += front * speed * delta
	if Input.is_action_pressed("back"):
		position += back * speed * delta

TwistedTwigleg

If you have the rotation of the object, you can get the forward, back, left, and right directions using cos and sin:

extends Sprite
func _process(delta):
	var front_dir = Vector2(cos(global_rotation), sin(global_rotation))
	var right_angle = global_rotation + (PI * 0.5) # add a 90 degree offset
	var right_dir = Vector2(cos(right_angle), sin(right_angle))
	
	if Input.is_action_pressed("front"):
		position += front_dir * 400 * delta
	if Input.is_action_pressed("back"):
		position -= front_dir * 400 * delta
	if Input.is_action_pressed("right"):
		position += right_dir * 400 * delta
	if Input.is_action_pressed("left"):
		position -= right_dir * 400 * delta

This code assumes that rotation 0 has the visuals pointing upwards when calculating it's angles though. If your sprite faces a different direction when the rotation is 0, then you'll need to apply an offset.

# for example, if the visuals face to the right:
var front_angle = global_rotation + (PI * 0.5)
var front_dir = Vector2(cos(front_angle), sin(front_angle))
var right_angle = front_angle + (PI * 0.5)
var right_dir = Vector2(cos(right_angle), sin(right_angle))

Odin

I mean when my tank is hit by bullets it has to be pushed back to the surface of the bullets,. Isthis code is for movement only? Can you guide me for that, my admin-my mod?

cybereality

That was just for example to test the code. You can call it when the tank is hit no problem.

Odin

Wonderful ! My tank is knocked back ! These lines of code are really effective and also concise, very easy to understand. Thank you, my Admin and my Mod! Because without your help, the game I would have missed this detail, and it would have lost its fun. Once again , thank you so much !

cybereality

Awesome! I'm so happy it works.

Odin

But I have one thing I would like to ask you : " if i want to identify and distinguish 4 directions of the tank" so that i can code accordingly. For example, if my tank is shot on the left, it will be thrown to the right.And when it is hit on the right, it will be knock to the left. So how do i code that?

TwistedTwigleg

If you know the position of where the tank shot, then you can calculate the direction using a dot product. I'm writing this off memory, so it might need a little adjusting, but the code should be something like this:

# shot_pos = position of the impact to the tank

# convert the shot position to a position relative to the tank
var local_shot_pos = get_global_transform.xform_inv(shot_pos)

# normalize the local position so it has a length of 1
local_shot_pos = local_shot_pos.normalized()

# cache the results of half of PI (90 degrees) for conditions
# later in the code
var half_pi = PI * 0.5

# using a dot product, we can tell how far of an angle we would need
# to get from one direction to another. This will tells us how 'close' to the
# direction the shot is, allowing us to tell which direction it came from
#
# NOTE - the dot does not tell direction, just distance, so that is why we are using 90
# degrees instead of 180, as we want to detect angles 90 degrees on either side of the direction
#
# is the shot above/below
if (Vector2(0, 1).dot(local_shot_pos) <= half_pi):
	print ("Shot was above!")
elif (Vector2(0, -1).dot(local_shot_pos) <= half_pi):
	print ("Shot was below!")

# is the shot left/right (might be flipped)
if (Vector2(1, 0).dot(local_shot_pos) <= half_pi):
	print ("Shot was right!")
elif (Vector2(-1, 0).dot(local_shot_pos) <= half_pi):
	print ("Shot was left!")

The code should detect if it's above or below, and whether it's right or left. To detect just left, right, up, or down, you would need something like this:

# shot_pos = position of the impact to the tank

# convert the shot position to a position relative to the tank
var local_shot_pos = get_global_transform.xform_inv(shot_pos)

# normalize the local position so it has a length of 1
local_shot_pos = local_shot_pos.normalized()

# cache the results of a quarter of PI (45 degrees) for conditions
# later in the code
var quarter_pi = PI * 0.25

if (Vector2(0, 1).dot(local_shot_pos) <= quarter_pi ):
	print ("Shot was above!")
elif (Vector2(1, 0).dot(local_shot_pos) <= quarter_pi):
	print ("Shot was right")
elif (Vector2(0, -1).dot(local_shot_pos) <= quarter_pi ):
	print ("Shot was below!")
else:
	print ("Show was left")

I haven't tried the code though, I just wrote it from memory, so it might need adjustments before it works fully.

Odin

Looks like a long one. But to identify the 4 sides of the tank, we have to draw 4 collision faces, right my Admin?

TwistedTwigleg

You can use 4 collision faces and detect the collision that way. It depends on how you have your collision setup. The code I wrote assumed that the object is covered by a single collision shape and then uses the position of the impact to determine the side/direction the collision occurred at.

If you are using multiple Area2D nodes, one for each direction, then its easier as you can determine which side was hit by which Area2D detected the overlap.

If you are using a single Area2D/RigidBody2D/KinematicBody2D node though, then you will need to determine the direction based on the collision itself, as I do not think there is a way to get which shape was hit if a physics node is composed of multiple shapes.

Odin

So if I use the method like the attached picture, that's the easiest and most effective way right? That includes Node KinematicBody2D + 4 faces = 4 area2D corresponding to 4 collision faces. Isn't that right, Admin?

TwistedTwigleg

It would be slightly less efficient from a computer memory and CPU performance perspective, but it would make it MUCH easier to tell which direction the collision came from. It depends on your project and personal preference on which to go for, as there are pros and cons for both.

Personally, I'd probably use the 4 Area2D nodes with 4 collision faces. It makes the code easier to write and debug, and it only has a minor performance cost. What is nice about using the simpler and less-code solution initially too is that if you need to adjust it in the future for better performance, it should be relatively easy to adjust for performance at that point :smile:

Odin

Ok I see. When I have a chance, I will try the way you instructed me. At that time I will not use 4 collisions and will use your method to see how. I think your way is also quite good, but since I am a newbie, I have to use the other way. Hope for your understanding.Once again, thank you my Admin !