main.rs

use bevy::math::bounding::Aabb2d;
use bevy::math::bounding::IntersectsVolume;
use bevy::prelude::*;
use bevy::window::PrimaryWindow;

use crate::enemy::Enemy;
use crate::enemy::EnemyPlugin;
use crate::player::Player;
use crate::player::PlayerPlugin;

mod enemy;
mod player;

// region: Game Constants

const BASE_SPEED: f32 = 5.;
const PLAYER_MAX: u8 = 1;
const ENEMY_MAX: u8 = 5;

// endregion: Game Constants

// region: Resource

#[derive(Resource)]
pub struct WinSize {
    pub w: f32,
    pub h: f32,
}

#[derive(Resource)]
struct PlayerCount(u8);

#[derive(Resource)]
struct EnemyCount(u8);

// endregion: Resource

// region: Components

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

#[derive(Component)]
pub struct Movable {
    pub auto_despawn: bool,
}

#[derive(Component)]
pub struct Laser;

#[derive(Component)]
pub struct SpriteSize(pub Vec2);

impl From<(f32, f32)> for SpriteSize {
    fn from(val: (f32, f32)) -> Self {
        SpriteSize(Vec2::new(val.0, val.1))
    }
}

#[derive(Component)]
pub struct FromPlayer;

#[derive(Component)]
pub struct FromEnemy;

// endregion: Components

fn main() {
    App::new()
        // アプリケーションの背景色を指定します。
        .insert_resource(ClearColor(Color::srgb(0.04, 0.04, 0.04)))
        // ウィンドウのタイトルと解像度を指定します。
        .add_plugins(DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                title: "Invaders".into(),
                resolution: (600, 800).into(),
                ..Default::default()
            }),
            ..Default::default()
        }))
        .add_plugins(EnemyPlugin)
        .add_plugins(PlayerPlugin)
        .add_systems(Startup, setup)
        .add_systems(Update, movable_system)
        .add_systems(Update, player_laser_hit_enemy_system)
        .add_systems(Update, enemy_laser_hit_player_system)
        .run();
}

fn setup(mut commands: Commands, query: Query<&Window, With<PrimaryWindow>>) {
    // 2D カメラを設置
    commands.spawn(Camera2d);

    // ウィンドウのサイズを取得
    let Ok(primary) = query.single() else {
        return;
    };
    let (win_w, win_h) = (primary.width(), primary.height());

    // ウィンドウのサイズをリソースとして保存
    let win_size = WinSize { w: win_w, h: win_h };
    commands.insert_resource(win_size);

    // プレイヤーとエネミーのカウントをリソースとして保存
    commands.insert_resource(PlayerCount(0));
    commands.insert_resource(EnemyCount(0));
}

fn movable_system(
    mut commands: Commands,
    win_size: Res<WinSize>,
    mut query: Query<(Entity, &Velocity, &mut Transform, &Movable)>,
) {
    for (entity, velocity, mut transform, movable) in query.iter_mut() {
        let translation = &mut transform.translation;
        translation.x += velocity.x * BASE_SPEED;
        translation.y += velocity.y * BASE_SPEED;

        if movable.auto_despawn {
            const MARGIN: f32 = 200.;
            if translation.y > win_size.h / 2. + MARGIN
                || translation.y < -win_size.h / 2. - MARGIN
                || translation.x > win_size.w / 2. + MARGIN
                || translation.x < -win_size.w / 2. - MARGIN
            {
                // println!("Despawned an entity {:?}", entity);
                commands.entity(entity).despawn();
            }
        }
    }
}

fn player_laser_hit_enemy_system(
    mut commands: Commands,
    mut enemy_count: ResMut<EnemyCount>,
    mut laser_query: Query<(Entity, &Transform, &SpriteSize), (With<Laser>, With<FromPlayer>)>,
    mut enemy_query: Query<(Entity, &Transform, &SpriteSize), With<Enemy>>,
) {
    for (laser_entity, laser_transform, laser_size) in laser_query.iter_mut() {
        let laser_pos = laser_transform.translation;
        let laser_scale = laser_transform.scale.xy();

        for (enemy_entity, enemy_transform, enemy_size) in enemy_query.iter_mut() {
            let enemy_pos = enemy_transform.translation;
            let enemy_scale = enemy_transform.scale.xy();

            // determine if collision
            let collision =
                Aabb2d::new(laser_pos.truncate(), (laser_size.0 * laser_scale) / 2.).intersects(
                    &Aabb2d::new(enemy_pos.truncate(), (enemy_size.0 * enemy_scale) / 2.),
                );

            // perform collision
            if collision {
                // remove the enemy
                commands.entity(enemy_entity).despawn();
                enemy_count.0 -= 1;

                // remove the laser
                commands.entity(laser_entity).despawn();
            }
        }
    }
}

fn enemy_laser_hit_player_system(
    mut commands: Commands,
    mut player_count: ResMut<PlayerCount>,
    mut laser_query: Query<(Entity, &Transform, &SpriteSize), (With<Laser>, With<FromEnemy>)>,
    mut player_query: Query<(Entity, &Transform, &SpriteSize), With<Player>>,
) {
    if let Ok((player_entity, player_transform, player_size)) = player_query.single_mut() {
        let player_pos = player_transform.translation;
        let player_scale = player_transform.scale.xy();

        for (laser_entity, laser_transform, laser_size) in laser_query.iter_mut() {
            let laser_pos = laser_transform.translation;
            let laser_scale = laser_transform.scale.xy();

            // determine if collision
            let collision =
                Aabb2d::new(laser_pos.truncate(), (laser_size.0 * laser_scale) / 2.).intersects(
                    &Aabb2d::new(player_pos.truncate(), (player_size.0 * player_scale) / 2.),
                );

            // perform collision
            if collision {
                // remove the player
                commands.entity(player_entity).despawn();
                player_count.0 -= 1;

                // remove the laser
                commands.entity(laser_entity).despawn();
            }
        }
    }
}