Bullet Destruction on Collision not working

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.

CaioM I had the same problem, just increase target position until they are going fast enough. It has something to do with delta.
My projectile has a target positon of (0.0, 0.0, -40.0).