Проектная работа - WIP

snake-game/.gitignore

@@ -1,2 +1,3 @@
 /target/
 /Cargo.lock
+/*.log

snake-game/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 bevy = "0.18"
 tracing = "0.1"
+tracing-subscriber = "0.3"
 
 [profile.release]
 opt-level = "z"

snake-game/examples/paddle_demo.rs

@@ -0,0 +1,223 @@
+
+use bevy::math::bounding::{Aabb2d, BoundingCircle, BoundingVolume, IntersectsVolume};
+use bevy::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .insert_resource(ClearColor(Color::srgb(0.8, 0.8, 1.0)))
+        .add_systems(Startup, setup)
+        .add_systems(
+            FixedUpdate,
+            (move_paddle, apply_velocity, check_for_collisions),
+        )
+        .run();
+}
+
+const PADDLE_GAP_Y: f32 = 50.0;
+const PADDLE_COLOR: Color = Color::srgb(0.5, 0.5, 1.0);
+const PADDLE_SIZE: Vec2 = Vec2::new(120.0, 20.0);
+const PADDLE_SPEED: f32 = 500.0;
+const PADDLE_PADDING: f32 = 10.0;
+
+const LEFT_WALL: f32 = -600.0;
+const RIGHT_WALL: f32 = 600.0;
+const BOTTOM_WALL: f32 = -300.0;
+const TOP_WALL: f32 = 300.0;
+const WALL_WIDTH: f32 = 20.0;
+
+const BALL_START_POS: Vec2 = Vec2::new(0.0, -100.0);
+const BALL_COLOR: Color = Color::srgb(0.2, 0.5, 0.2);
+const BALL_DIAMETER: f32 = 20.0;
+const INIT_BALL_SPEED: Vec2 = Vec2::new(100.0, 100.0);
+
+#[derive(Component)]
+struct Paddle;
+
+#[derive(Component)]
+struct Ball;
+
+#[derive(Component)]
+struct Collider;
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    commands.spawn(Camera2d);
+
+    let paddle_y = BOTTOM_WALL + PADDLE_GAP_Y;
+    commands.spawn((
+        Sprite::from_color(PADDLE_COLOR, Vec2::ONE),
+        Transform {
+            translation: Vec3::new(0.0, paddle_y, 0.0),
+            scale: PADDLE_SIZE.extend(1.0),
+            ..Default::default()
+        },
+        Paddle,
+        Collider,
+    ));
+
+    commands.spawn((
+        Mesh2d(meshes.add(Circle::default())),
+        MeshMaterial2d(materials.add(BALL_COLOR)),
+        Transform {
+            translation: BALL_START_POS.extend(0.0),
+            scale: Vec3::splat(BALL_DIAMETER),
+            ..Default::default()
+        },
+        Velocity(INIT_BALL_SPEED),
+        Ball,
+    ));
+
+    commands.spawn(Wall::new(WallLocation::Left));
+    commands.spawn(Wall::new(WallLocation::Right));
+    commands.spawn(Wall::new(WallLocation::Top));
+    commands.spawn(Wall::new(WallLocation::Bottom));
+}
+
+fn move_paddle(
+    input: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
+    mut paddle_transform: Single<&mut Transform, With<Paddle>>,
+) {
+    let direction = if input.pressed(KeyCode::ArrowLeft) {
+        -1.0
+    } else if input.pressed(KeyCode::ArrowRight) {
+        1.0
+    } else {
+        0.0
+    };
+
+    let new_pos = paddle_transform.translation.x + direction * PADDLE_SPEED * time.delta_secs();
+
+    const LEFT_BOUND: f32 = LEFT_WALL + WALL_WIDTH / 2.0 + PADDLE_SIZE.x / 2.0 + PADDLE_PADDING;
+    const RIGHT_BOUND: f32 = RIGHT_WALL - WALL_WIDTH / 2.0 - PADDLE_SIZE.x / 2.0 - PADDLE_PADDING;
+
+    paddle_transform.translation.x = new_pos.clamp(LEFT_BOUND, RIGHT_BOUND);
+}
+
+#[derive(Component, Deref, DerefMut)]
+struct Velocity(Vec2);
+
+fn apply_velocity(time: Res<Time>, mut query: Query<(&mut Transform, &Velocity)>) {
+    for (mut transform, velocity) in &mut query {
+        transform.translation += velocity.extend(0.0) * time.delta_secs();
+    }
+}
+
+fn check_for_collisions(
+    ball_query: Single<(&mut Velocity, &Transform), With<Ball>>,
+    collider_query: Query<&Transform, With<Collider>>,
+) {
+    let (mut ball_velocity, ball_transform) = ball_query.into_inner();
+
+    for collider_transform in &collider_query {
+        let collision = ball_collision(
+            BoundingCircle::new(ball_transform.translation.truncate(), BALL_DIAMETER / 2.0),
+            Aabb2d::new(
+                collider_transform.translation.truncate(),
+                collider_transform.scale.truncate() / 2.0,
+            ),
+        );
+
+        if let Some(collision) = collision {
+            let mut reflect_x = false;
+            let mut reflect_y = false;
+
+            match collision {
+                Collision::Left => reflect_x = ball_velocity.x > 0.0,
+                Collision::Right => reflect_x = ball_velocity.x < 0.0,
+                Collision::Top => reflect_y = ball_velocity.y < 0.0,
+                Collision::Bottom => reflect_y = ball_velocity.y > 0.0,
+            };
+
+            if reflect_x {
+                ball_velocity.x *= -1.0;
+            }
+
+            if reflect_y {
+                ball_velocity.y *= -1.0;
+            }
+        }
+    }
+}
+
+enum Collision {
+    Left,
+    Right,
+    Top,
+    Bottom,
+}
+
+fn ball_collision(circle: BoundingCircle, rect: Aabb2d) -> Option<Collision> {
+    if !circle.intersects(&rect) {
+        return None;
+    }
+
+    let closest = rect.closest_point(circle.center());
+    let offset = circle.center() - closest;
+
+    let side = if offset.x.abs() > offset.y.abs() {
+        if offset.x < 0.0 {
+            Collision::Left
+        } else {
+            Collision::Right
+        }
+    } else if offset.y > 0.0 {
+        Collision::Top
+    } else {
+        Collision::Bottom
+    };
+
+    Some(side)
+}
+
+#[derive(Component)]
+#[require(Sprite, Transform)]
+struct Wall;
+
+impl Wall {
+    pub fn new(location: WallLocation) -> (Wall, Sprite, Transform, Collider) {
+        (
+            Wall,
+            Sprite::from_color(Color::srgb(1.0, 0.4, 0.4), Vec2::ONE),
+            Transform {
+                translation: location.position().extend(0.0),
+                scale: location.size().extend(1.0),
+                ..Default::default()
+            },
+            Collider,
+        )
+    }
+}
+
+enum WallLocation {
+    Left,
+    Right,
+    Top,
+    Bottom,
+}
+
+impl WallLocation {
+    fn position(&self) -> Vec2 {
+        match self {
+            WallLocation::Left => Vec2::new(LEFT_WALL, 0.0),
+            WallLocation::Right => Vec2::new(RIGHT_WALL, 0.0),
+            WallLocation::Top => Vec2::new(0.0, TOP_WALL),
+            WallLocation::Bottom => Vec2::new(0.0, BOTTOM_WALL),
+        }
+    }
+
+    fn size(&self) -> Vec2 {
+        match self {
+            WallLocation::Left | WallLocation::Right => {
+                Vec2::new(WALL_WIDTH, TOP_WALL - BOTTOM_WALL)
+            }
+            WallLocation::Top | WallLocation::Bottom => {
+                Vec2::new(RIGHT_WALL - LEFT_WALL, WALL_WIDTH)
+            }
+        }
+    }
+}

snake-game/src/lib.rs

@@ -0,0 +1,51 @@
+/// Инициализация логирования
+pub fn define_log_layer() -> Option<bevy::log::BoxedFmtLayer> {
+    use std::fs::File;
+    use tracing::Level;
+    use tracing_subscriber::{Layer, filter::Targets, fmt::layer};
+
+    let targets = Targets::new()
+        .with_target("bevy_asset", Level::INFO)
+        .with_target("bevy_app", Level::INFO)
+        .with_target("bevy_diagnostic", Level::WARN)
+        .with_target("bevy_render", Level::INFO)
+        .with_target("bevy_shader", Level::INFO)
+        .with_target("bevy_time", Level::INFO)
+        .with_target("bevy_winit", Level::INFO)
+        .with_target("gilrs", Level::INFO)
+        .with_target("naga", Level::INFO)
+        .with_target("wgpu_core", Level::INFO)
+        .with_target("wgpu_hal", Level::WARN)
+        .with_target("offset_allocator", Level::INFO)
+        .with_default(Level::TRACE);
+
+    let stdout = layer()
+        .compact()
+        .with_thread_names(true)
+        .with_file(false)
+        .with_line_number(false)
+        .with_filter(targets.clone())
+        .boxed();
+    let file = match File::options()
+        .write(true)
+        .create(true)
+        .append(true)
+        .open("snake-game.log")
+    {
+        Ok(file) => file,
+        Err(e) => {
+            eprintln!("No access to log file: {:?}", e);
+            return Some(stdout);
+        }
+    };
+    let log_file = layer()
+        .compact()
+        .with_ansi(false)
+        .with_thread_names(true)
+        .with_file(false)
+        .with_line_number(false)
+        .with_writer(file)
+        .with_filter(targets.clone())
+        .boxed();
+    Some(Box::new(vec![stdout, log_file]))
+}

snake-game/src/main.rs

@@ -1,3 +1,30 @@
+use bevy::ecs::system::command::*;
+use bevy::math::bounding::*;
+use bevy::prelude::*;
+
 fn main() {
-    println!("Hello, world!");
+    App::new()
+        .add_plugins(
+            DefaultPlugins
+                .build()
+                .set(bevy::log::LogPlugin {
+                    fmt_layer: |_| snake_game::define_log_layer(),
+                    ..Default::default()
+                })
+                .set(TaskPoolPlugin {
+                    task_pool_options: TaskPoolOptions::with_num_threads(1),
+                }),
+        )
+        .insert_resource(ClearColor(Color::srgb(0.8, 0.8, 1.0)))
+        .add_systems(Startup, setup)
+        // config
+        .run();
+}
+
+fn setup(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    commands.spawn(Camera2d);
 }