Bullet Destruction on Collision not working

Hello again. In FPS there are two methods of firing: hitscan and projectiles.
hitscan is the simplest, you put a raycast on the player and whatever it hits when pressing the fire button will take damage, then you spawn a decal of a bullet hole and particles.
the second depends on physics, it can be used for rocket launchers, or to create realistic weapon firing, but it's only worth at long distances or for things like rocket launchers and blasters.
there is virtually no difference between the two, hitscan is better for games that need to run on low end devices, require fast accurate response, or for games where you don't care about bullet drop and delay.
projectiles I would only use whenever needed (rocket launcher) or if the game is trying to be some kind of simulator like Arma3.
projectile is much more difficult. you can use a physics object, but too fast and it will always pass through walls. An alternative I kind of invented is to shoot a raycast. the raycast has a range equal to the distance the bullet has to move the next frame (it runs in the physics_process which is locked to 60 frames), then the bullet teleports to the next position (I think it was basis * speed + global_position). if the raycast hits, just do the same as with hitscan: particle effects, bullet hole decal, damage.
So, the first question is, which one is it? are you making an arcade or a simulation game?

@onready var ray = $RayCast3D

func _process(delta):
...
     if ray.is_colliding():
          mesh.visible = false
          await get_tree().create_timer(1.0).timeout
          queue_free()

first there's no need for await. second, you are running this in process, which is tied to your game's framerate. it should run on physics_process which is locked at 60 FPS.

I should probably post some of the code from my FPS, here, you will have to figure a few things out though. This is C_Projectile:

extends RayCast3D

@onready var assetmang : Asset_manager = get_node("/root/AssetManager")#ignore this
var tim : float = 0.0
@export var lifetime : float = 10.0
@export var weaponPower : float = 0.2#also ignore this

func _physics_process(delta):
	#projectile self destructs after lifetime ends
	if tim < lifetime:
		tim += delta
	else:
		selfDestruct()
	#projectile hits something
	if self.is_colliding():
		SpawnFX(self.get_collision_point()) #here you spawn particles, decals, etc
		selfDestruct()
	#projectile DOESN'T hit something
	else:
		self.translate_object_local(self.target_position * delta) #move the projectile

func selfDestruct():
	queue_free()

target position of the raycast is then the distance the projectile must travel in a frame. at 60 FPS, a muzzle velocity of, say 600 m/s, would be a target_position of, say, Vector3(0.0, 0.0, -10.0).

CaioM i don't know how to put the code in the "black screen"

``` 
code 
``` 

CaioM

CaioM The first is my answer if it's an arcade or simulation, and i guess it's really inclined for an arcade, so i don't actually expect something really accurate to reality.

If it's an arcade you should use a hitscan, the code is similar, simpler. Parent a raycast to the camera, when you press the fire button it checks if it hits, and then it deals damage and spawns particles on the collision point. No need to destroy the raycast. For other things like grenades you can use physics objects because they tend to move slower. I used the projectiles for the shotgun and misiles.

The second is that all of this is done on the script of the bullet, maybe i should do it somewhere else?

On the bullet is correct. But have it be a raycast with a graphic parented to it, like a meshinstance3D. Look at my code.

Third is that, even if it actually destroys the bullet, my main problem is that a bullet travels really far and really quick, so the speed should be high, but if the speed is high, the chances of destroying on collision is really low because it just phases everything.

With my script the raycast checks for collisions in the frame and then moves, there should be NO phasing, unless its some problem with the physics engine, like a bug or bad colliders.

Let's look at your code:

extends Node3D #use a raycast instead

const SPEED = 100.0

var tim : float = 0.0
var lifetime : float = 10.0

#you don't need these
@onready var mesh = $MeshInstance3D
@onready var ray = $RayCast3D

#this should be in physics process. Might be why it phases. But it's not needed because you are doing it again in physics process. Just delete it.
#func _process(delta):
#	position += transform.basis * Vector3(0,0, -SPEED) * delta

func _physics_process(delta):
	#projectile self destructs after lifetime ends
	if tim < lifetime:
		tim += delta
	else:
		selfDestruct()
	#projectile hits something
	if ray.is_colliding():
		print ("ray is colliding")
		#Create particles with add_sibling() (instead of add_child()) and put scripts on them to self destruct. Keep it simple, keep it separate. There's no effect on performance.
		get_tree().create_timer(0.0).timeout
		selfDestruct()
	else:
		ray.translate_object_local(ray.target_position * delta) #move the projectile

func _on_timer_timeout():
	#No need for this
	queue_free()

func selfDestruct():
	queue_free()

CaioM maybe it's my fault for not explaining well enough, I'll try to go slower.
This is what you are going to do:
1 - Click on BulletMusket, right click change type and make it a RayCast3D. It HAS to be a raycast.
2 - I don't understand what you are trying to do with Timers, forget about Timers, delete all of them, disconnect them, you DON'T NEED THEM.
3 - you will be left with TWO nodes: BulletMusket, which will be a RayCast3D, and your MeshInstance3D.
4 - Yes, the script that extends RayCast3D must be on a RayCast3D, this is VERY important.
5 - delete const SPEED, you don't need it.
6 - delete process, don't add it again. code should go in physics_process anyway. process is dependent on you PCs framerate, physics is locked at 60 FPS. this means it will always run 60 times per second.

We use the target_position of the raycast3D for speed and movement. This is a property on the RayCast3D node that determines both the direction and reach of the raycast. make sure it's pointing forward.
the way the projectile works is this:

• during the frame, the raycast detects if it hits something.
• if it doesn't, it moves in the direction and distance covered by the ray.
• repeat on next frame.

so the target_position of raycast is also the SPEED of the projectile.

7 - if tim < lifetime: time += delta else: selfDestruct() destroys the node after lifetime is reached. No Timers required.
8 - remove create timer. I don't think it's doing anything. If you need some special effect to happen, you do it on a different scene with code and spawn it with add_sibling. We keep the code separate which makes it easier to debug and extend, it is modular.
9 -
self.translate_object_local(self.target_position * delta) #as of now, i am yet to see this do anything
that's because your raycast must be the root of the instanced scene, not a children. The raycast moves, the mesh moves with it.

CaioM #oh, and having no timer makes the bullet not disappear, i think i actually have to have a timer

you don't need timers. the code should selfDestruct the projectile after 10 seconds.

code should look like this:

extends RayCast3D

var tim : float = 0.0 #this is our Timer. do not touch it.
var lifetime : float = 10.0 #this is the lifetime of the projectile. it will selfDestruct after 10.0 seconds. you can export it if you want.

func _physics_process(delta):

	if tim < lifetime:
		tim += delta
	else:
		selfDestruct()
	#projectile hits something
	if self.is_colliding():
		print ("ray is colliding")
		selfDestruct()
	else:
		self.translate_object_local(self.target_position * delta) 

func selfDestruct():
	queue_free() 

CaioM should i delete RayCast3D that is the children of the now Raycast3D, that is, BulletMusket? I think not, but tell me what you think, and if so, what should i do once i delete raycast3d child)

Yes. BulletMusket is the raycast now.

CaioM so i don't know if it's going in the same direction of where i'm looking

Bullets are fast, you will only notice them at long distances or if they are moving slow. At short distances they will not move at all, just hit.

CaioM that 1 time where it does not appear, the bullet just spawns and slowly but surely goes down very awkwardly.

Weird. Make sure:
1 - it's pointing forward. In my case it's negative Z.
2 - check a property in transform so that it doesn't inherit parent transforms. It's called top level.
3 - set your collision layers. Put player, world and bullets on different layers, make sure the bullets can't interact with player.
4 - clear rotations for BulletMusket.