Shooting projectiles

[desert widget]

Hey I wanted to shoot projectiles at a certain speed however it doesn't work, I can shoot the projectile but it doesn't move, (like it just spawns the sprite lol) can someone hel me, any help would be appreciated

#[derive(Component, Resource)]
pub struct VelocityLaser {
    pub x: f32,
    pub y: f32,
}

#[derive(Component, Default)]
struct PositionPlayer(Vec3);

fn main() {
    App::new()
        
        .insert_resource(LaserPos {
            x: 0.0,
            y: 0.0,
        })
        .insert_resource(VelocityLaser {
            x: 10.0,
            y: 10.0,
        })
       
}

pub fn find_player_position(
    mut query: Query<(&Transform, &Player)>,
    mut query2: Query<(&Transform, &Laser)>,
    mut cam_transform: Query<&mut Transform, (With<Camera>, Without<Player>, Without<Laser>)>,
    mut player_pos: ResMut<PlayerPos>,
    mut laser_pos: ResMut<LaserPos>,
    mut velocity_laser: ResMut <VelocityLaser>,
)
{
    player_pos.x = 0.0;
    player_pos.y = 0.0;
    for (transform, _player) in &mut query {
        player_pos.x = transform.translation.x;
        player_pos.y = transform.translation.y;
        // laser_pos.x = transform.translation.x;
        // laser_pos.y = transform.translation.y;
    }
    for (transform, _laser) in &mut query2 {
        for i in 0..100 {
            laser_pos.x = transform.translation.x + velocity_laser.x;
            laser_pos.y = transform.translation.y + velocity_laser.y;
        }
        println!("LASER POS: {}, {}", laser_pos.x, laser_pos.y);
        println!("LASER VEL: {}, {}", velocity_laser.x, velocity_laser.y);
    }

```rust
pub fn shooting_lasers (
    mut commands: Commands,
    mut query: Query<&mut Transform, With<Player>>,
    asset_server: Res<AssetServer>,
    keyboard: Res<Input<KeyCode>>,
    player_pos: ResMut<PlayerPos>,
    laser_pos: ResMut<LaserPos>,
) {
    if keyboard.just_pressed(KeyCode::Space) {
        let (x, y) = (player_pos.x, player_pos.y);
        let x_offset = PLAYER_SIZE.1 / 2.0 * SPRITE_SCALE / 2.0;
        
        let mut spawn_laser = |x_offset: f32| {
            commands.spawn(SpriteBundle {
                texture: asset_server.load("laser_b_01.png"),
                transform: Transform::from_translation(Vec3::new(x + x_offset, y + 15.0, 1.0)),
                ..default()
            })
        .insert(Laser)
        .insert(RigidBody::Dynamic)
        .insert(ExternalForce {
            force: Vec2::ZERO,
            torque: 0.0,
        })
        .insert(Damping {
            linear_damping: 20.0,
            angular_damping: 20000.0,
        })
        .insert(Restitution::coefficient(1.0))
        .insert(VelocityLaser { x: 100., y: 10. });
        };
        spawn_laser(x_offset - 10.0);
    }
}```

this is my shooting laser fucntion in case you need it too

I cannot paste the entire main function but it works, since my smooth follow camera works 🙂

[buoyant flicker]

What happens if you remove the damping?

[burnt gull]

@desert widget make the laser a RigidBody::KinematicPositionBased

setting the position directly can cause weird issues with dynamic rigid bodies

actually wait

you have it all backwards

set the translation of the transform, not laser_pos

laser pos isn't used by anything

[hazy pelican]

if you just want an object that moves at a constant speed, all you need is Transform + RigidBody + Collider + Velocity (you might even be able to omit Collider, haven't tested)

let direction = Vec2::new(1.0, 1.0);
let SPEED = 200.0;
commands.spawn((
  // SpriteBundle provides a Transform component
  SpriteBundle { ... }
  RigidBody::Dynamic,
  Collider::ball(10.0),
  Velocity::linear(direction * SPEED),
  // Adding this means it doesn't push other objects around
  Sensor
));

I've made this a Sensor as well because I think that makes sense for light projectiles, being a sensor means you can check for intersections with other colliders but it doesn't have contact forces.