From f02158833cda468ba1a57c919bd7ae75af92e59d Mon Sep 17 00:00:00 2001
From: Rendo <geometicalplayer@gmail.com>
Date: Sun, 16 Nov 2025 13:36:11 +0500
Subject: [PATCH] Asteroids

---
 Cargo.lock                  |   1 +
 Cargo.toml                  |   1 +
 assets/asteroid2.png        | Bin 0 -> 187 bytes
 assets/enemy_projectile.png | Bin 0 -> 143 bytes
 assets/tileset.png          | Bin 471 -> 653 bytes
 src/asteroid.rs             |  96 ++++++++++++++++++++++++++++++++++++
 src/main.rs                 |  25 +++++++++-
 src/ships/player.rs         |   7 ++-
 src/velocity.rs             |  22 +++++++++
 9 files changed, 150 insertions(+), 2 deletions(-)
 create mode 100644 assets/asteroid2.png
 create mode 100644 assets/enemy_projectile.png
 create mode 100644 src/asteroid.rs

diff --git a/Cargo.lock b/Cargo.lock
index 5f11b37..b65ec0d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4092,6 +4092,7 @@ name = "spacorium"
 version = "0.1.0"
 dependencies = [
  "bevy",
+ "rand",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index e57ae1e..c4aeaac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,3 +5,4 @@ edition = "2024"
 
 [dependencies]
 bevy = "0.17.2"
+rand = "0.9.2"
diff --git a/assets/asteroid2.png b/assets/asteroid2.png
new file mode 100644
index 0000000000000000000000000000000000000000..b7f114a09f351be9c2b98b82d1cf9897bed8a6e3
GIT binary patch
literal 187
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`O`a}}Ar`$$CwcQ7P~dQpe7yGN
zshuxRx#`T8N^hNS?h|mqf90xkQVjQgiQMz8V(T-sdyvJ&@OH`S^5yHhxjtOUOHf)=
z#=M_XtFvSGe7=pBYTN>hnAaN{&+Zpd>qzSE$h?v9d)B-emNv!@UfBq{Y?#@Y&ctw2
lxScIfiC>S`W^!#D|Gi0GyREdeMS!kh@O1TaS?83{1ORv?L*oDd

literal 0
HcmV?d00001

diff --git a/assets/enemy_projectile.png b/assets/enemy_projectile.png
new file mode 100644
index 0000000000000000000000000000000000000000..5c9154211441c7b29fb435bc33f6b4d20fc59425
GIT binary patch
literal 143
zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`VV*9IAr`&K2@<SRnoZr@{$H1n
z{Hq>5k2CV&*$*iqttX@kB@a~?+x-0h^!D?IOuJUKNpyWUX}pkIN&DC`&e(Z^H*da}
sr1<=t;iFGNW|cdXyqHQwCNMI*Ja2Si`IflDKpPl5UHx3vIVCg!0OgN0NdN!<

literal 0
HcmV?d00001

diff --git a/assets/tileset.png b/assets/tileset.png
index 7ebc17c150fb5cc0c98201e2593878f716193df2..ba0e6b12521c987d5b88bb32d29b25bdf893dc4a 100644
GIT binary patch
delta 629
zcmV-*0*d|D1C0fcBYy%^Nkl<Zc%1E-J95G>5QcX>TqQ}BBIYX0(9v)VDB%{NAx)Se
zS1|<@!(o&LF|w?E_<?Ph{VHtvq5qd;?Jnq?a{vH{h|qw`eCYrHJ`TG^_owiE3TfIu
z35;J>_eI_SPa7jr!advVwsgE+uRAfMV!*vYX+&&*r>+ro#D9CbFd?Iax*O61&ev1&
z{AIp$lsRJ}17Wl^Mo=ce6Bv>CAJUYUjNnWF!3fFV)oR5)8}`n@UY@NfCgA}hlHUXm
zw`-iQC-{8(VqX~V8k%Ls^`+F0lnD!dV9E8b?Zn@7S~(|~5c2-}t-dz=82VX(KkD0)
zOcdAjMoM6axPKHHP?-VR(f3pDnCGSIwWA*|fz(!~5sZk)uKzkqKqEe0`=J3E@o{|M
zoO9GZ4+;}X1_)wP+;;&<Jl>$%CGj7J9j1b#PD0!TViWP;zX6<hO$RygUFHZeU6_|~
zp>P}V)QG336VhUU_8#_mV@ifLn@#Ci@%n#6Mu=Qsqkp06bl98Fhj^d@p%mdvc~obH
zKqaKl0!81jkzl+gLn?9jlaf&lnxLpnA~P25GvF1(G$DhQ;*WXm;(VY^`_PbqP+g9B
zUMYBl!pCX?TL6*LQ$)neeCfh!P%1Ly+8-GzYal;@65$RIib|Enr1l|U%TiR19*PgA
zeJpNP6mDedoN6Be(f}z(r(ysvk`gDi_l;N<hnl6RSy3P-PHOKPvLfVX044qvqCntk
zf>Me6Weo^v`@i8cAPQ+)Ffk0nFbu;m48t%C!!QiPFbu;m48t%C!x)->ouzAul3v2I
P00000NkvXXu0mjfB<dr6

delta 446
zcmeBWz0N#Axt?*Jr;B4q#hka-t&0vB2(Uef<q!8<5yZmh?0(qr&82;=86LuElQstg
z7|Nt&3MikRRF*5!mhx}?qlfL^rl*|LQF3xQa>hq^PMEZ!(yaH}C!gyt%>Cq>JHPGl
z?B2Z-xex4A?}&KlcfEA)d*90<oGAha-ts34Br=@4p>Ry({S=P+g<hgs;kQ`(o;!c}
zemP5dWx+g8SFil&CXZH!dWDWtwHMm<h`H#o1T|e?TKC$jI`>xR1wZ+<hQ|N7jn(IK
z`sH1<n8*L++oySZ6L(}qEQ?&HySMC!Q^a#?Gt2*Ldw)dgvG31R{1La`?#%ID{LbcD
zKQ7l)T{%;5=I{}&FDru+o9Yj8Z1}cMy6S$n>-&oA_wB(7+pa`%rKO!a_unx1Kv0dv
z_rDA}N85ih3r@UZ<=-Yy#i()g*qt!OwH5ok{;n6bzn^cp%~EUA(O6@D&3Si>6~gx{
zZQS|Dd!KTPS4;TQZHK;#%zyQ9hGBHnw}|s6<KEAVYrD1WZLId3|NB3>o!HsiYwr5;
ldZPFt<t}yxtf1llOD5$%_cuH`@^%(Tfv2mV%Q~loCIFL%&e{L~

diff --git a/src/asteroid.rs b/src/asteroid.rs
new file mode 100644
index 0000000..be65918
--- /dev/null
+++ b/src/asteroid.rs
@@ -0,0 +1,96 @@
+use bevy::prelude::*;
+use rand::{prelude::*, rng};
+
+use crate::{
+    FIRST_CORNER_X, FIRST_CORNER_Y, SECOND_CORNER_X, SECOND_CORNER_Y,
+    collision::{Collided, Collider},
+    damagable::Damagable,
+    projectile::Projectile,
+    velocity::Velocity,
+};
+
+const ASTEROID_BUMP_STRENGTH: f32 = 10.0;
+
+pub struct AsteroidPlugin;
+
+impl Plugin for AsteroidPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Startup, setup_asteroids)
+            .add_systems(FixedUpdate, rotate_asteroid);
+    }
+}
+
+#[derive(Component)]
+pub struct Asteroid(f32);
+
+pub fn setup_asteroids(mut commands: Commands, asset_server: Res<AssetServer>) {
+    let sprite1: Handle<Image> = asset_server.load("asteroid.png");
+    let sprite2: Handle<Image> = asset_server.load("asteroid2.png");
+    let mut random = rng();
+
+    for _ in 0..50 {
+        let position = Vec3::new(
+            random.random_range(FIRST_CORNER_X..SECOND_CORNER_X),
+            random.random_range(FIRST_CORNER_Y..SECOND_CORNER_Y),
+            0.,
+        );
+        let sprite = if random.random_bool(0.5) {
+            sprite1.clone()
+        } else {
+            sprite2.clone()
+        };
+        let tau = f64::to_radians(360.);
+        let rotation = random.random_range((-tau)..tau) as f32;
+
+        commands
+            .spawn((
+                Asteroid(rotation),
+                Sprite::from(sprite),
+                Transform::from_translation(position),
+                Collider::new(8.),
+                Damagable::new(20),
+            ))
+            .observe(bump);
+    }
+}
+
+pub fn rotate_asteroid(time: Res<Time>, query: Query<(&mut Transform, &Asteroid)>) {
+    for (mut transform, asteroid) in query {
+        transform.rotate_z(asteroid.0 * time.delta_secs());
+    }
+}
+
+pub fn bump(
+    collision: On<Collided>,
+    asteroid_query: Query<&Transform, (With<Asteroid>, Without<Projectile>)>,
+    mut collision_query: Query<
+        (&mut Transform, Option<&Velocity>),
+        (Without<Asteroid>, Without<Projectile>),
+    >,
+    time: Res<Time>,
+) {
+    let Ok(asteroid_transform) = asteroid_query.get(collision.entity) else {
+        return;
+    };
+    let Ok((mut collided_transform, velocity_option)) = collision_query.get_mut(collision.with)
+    else {
+        return;
+    };
+    let identity = Velocity::identity();
+    let velocity = velocity_option.unwrap_or(&identity);
+
+    let dir_to_asteroid = asteroid_transform.translation - collided_transform.translation;
+    let collided_direction = collided_transform.rotation * Vec3::X;
+    let collided_side = collided_transform.rotation * Vec3::Y;
+
+    let angle_to_direction = collided_direction.angle_between(-dir_to_asteroid);
+    let proporiton = velocity.linear_speed / velocity.max_linear_speed;
+
+    collided_transform.rotate_z(
+        angle_to_direction
+            * time.delta_secs()
+            * ASTEROID_BUMP_STRENGTH
+            * collided_side.dot(-dir_to_asteroid).signum()
+            * proporiton,
+    );
+}
diff --git a/src/main.rs b/src/main.rs
index d143aa6..1ad221e 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,24 +1,47 @@
 use bevy::prelude::*;
+use bevy::window::WindowResolution;
 
+use crate::asteroid::AsteroidPlugin;
 use crate::collision::CollisionPlugin;
 use crate::damagable::DamagablePlugin;
 use crate::projectile::ProjectilePlugin;
 use crate::ships::ShipsPlugin;
 use crate::velocity::VelocityPlugin;
 
+mod asteroid;
 mod collision;
 mod damagable;
 mod projectile;
 mod ships;
 mod velocity;
 
+const FIRST_CORNER_X: f32 = -512.;
+const FIRST_CORNER_Y: f32 = -512.;
+const SECOND_CORNER_X: f32 = 512.;
+const SECOND_CORNER_Y: f32 = 512.;
+
 fn main() {
     App::new()
-        .add_plugins(DefaultPlugins)
+        .add_plugins(
+            DefaultPlugins
+                .set(WindowPlugin {
+                    primary_window: Some(Window {
+                        resolution: WindowResolution::new(
+                            (FIRST_CORNER_X.abs() + SECOND_CORNER_X.abs()) as u32,
+                            (FIRST_CORNER_Y.abs() + SECOND_CORNER_Y.abs()) as u32,
+                        )
+                        .with_scale_factor_override(1.0),
+                        ..default()
+                    }),
+                    ..default()
+                })
+                .set(ImagePlugin::default_nearest()),
+        )
         .add_plugins(VelocityPlugin)
         .add_plugins(CollisionPlugin)
         .add_plugins(ShipsPlugin)
         .add_plugins(DamagablePlugin)
         .add_plugins(ProjectilePlugin)
+        .add_plugins(AsteroidPlugin)
         .run();
 }
diff --git a/src/ships/player.rs b/src/ships/player.rs
index 19922b9..3339ae7 100644
--- a/src/ships/player.rs
+++ b/src/ships/player.rs
@@ -6,6 +6,7 @@ use crate::{
     velocity::Velocity,
 };
 use bevy::prelude::*;
+use rand::random_range;
 
 #[derive(Component)]
 #[require(Velocity)]
@@ -112,10 +113,14 @@ pub fn player_shooting_system(
         return;
     }
 
+    let five_degrees = f32::to_radians(5.);
+    let mut bullet_transform = transform.clone();
+    bullet_transform.rotate_z(random_range(-five_degrees..five_degrees));
+
     spawn_projectile(
         &mut commands,
         projectile_sprite,
-        transform.clone(),
+        bullet_transform,
         gun.damage,
         Factions::PlayerFaction,
     );
diff --git a/src/velocity.rs b/src/velocity.rs
index c6af27e..eb245c5 100644
--- a/src/velocity.rs
+++ b/src/velocity.rs
@@ -1,6 +1,8 @@
 use bevy::prelude::*;
 use std::default::Default;
 
+use crate::{FIRST_CORNER_X, FIRST_CORNER_Y, SECOND_CORNER_X, SECOND_CORNER_Y};
+
 pub struct VelocityPlugin;
 
 impl Plugin for VelocityPlugin {
@@ -48,6 +50,14 @@ impl Velocity {
             max_rotation_speed: max_rotation_speed,
         }
     }
+    pub fn identity() -> Velocity {
+        Velocity {
+            linear_speed: 1.,
+            rotation_speed: 1.,
+            max_linear_speed: 1.0,
+            max_rotation_speed: 1.0,
+        }
+    }
 }
 
 impl Default for Velocity {
@@ -71,5 +81,17 @@ fn movement_system(time: Res<Time>, query: Query<(&Velocity, &mut Transform)>) {
         transform.translation += translation_delta;
 
         //TODO: Loop on bounds
+        if transform.translation.x < FIRST_CORNER_X {
+            transform.translation.x += SECOND_CORNER_X * 2.;
+        }
+        if transform.translation.y < FIRST_CORNER_Y {
+            transform.translation.y += SECOND_CORNER_Y * 2.;
+        }
+        if transform.translation.x > SECOND_CORNER_X {
+            transform.translation.x += FIRST_CORNER_X * 2.;
+        }
+        if transform.translation.y > SECOND_CORNER_Y {
+            transform.translation.y += FIRST_CORNER_X * 2.;
+        }
     }
 }