Rustで学ぶECSパターン：hecsとspecsの応用例を徹底解説

[dependencies]
hecs = "0.10"

use hecs::{World, Entity};

fn main() {
    // ワールドを作成
    let mut world = World::new();

    // エンティティを追加
    let entity = world.spawn(("Player", 100)); // 名前とHPを持つエンティティ

    // コンポーネントの取得と操作
    if let Ok((name, hp)) = world.get::<(&str, i32)>(entity) {
        println!("Entity: {}, HP: {}", name, hp);
    }

    // コンポーネントの変更
    if let Ok(mut hp) = world.get_mut::<i32>(entity) {
        *hp += 10;
        println!("HP after healing: {}", hp);
    }
}

fn heal_system(world: &mut World) {
    for (_, hp) in &mut world.query::<&mut i32>() {
        *hp += 10; // 全てのエンティティのHPを10回復
    }
}

fn main() {
    let mut world = World::new();

    // 複数のエンティティを追加
    world.spawn(("Player1", 50));
    world.spawn(("Player2", 30));

    // システムを実行
    heal_system(&mut world);

    // 結果を確認
    for (id, (name, hp)) in &world.query::<(&str, &i32)>() {
        println!("Entity {}: {}, HP: {}", id, name, hp);
    }
}

[dependencies]
specs = "0.17"
specs-derive = "0.4"

use specs::prelude::*;
use specs::Component;
use specs_derive::Component;

#[derive(Component, Debug)]
struct Position {
    x: f32,
    y: f32,
}

#[derive(Component, Debug)]
struct Velocity {
    dx: f32,
    dy: f32,
}

struct MovementSystem;

impl<'a> System<'a> for MovementSystem {
    type SystemData = (
        WriteStorage<'a, Position>,
        ReadStorage<'a, Velocity>,
    );

    fn run(&mut self, (mut positions, velocities): Self::SystemData) {
        for (pos, vel) in (&mut positions, &velocities).join() {
            pos.x += vel.dx;
            pos.y += vel.dy;
            println!("Moved to position: {:?}", pos);
        }
    }
}

fn main() {
    let mut world = World::new();

    // コンポーネントを登録
    world.register::<Position>();
    world.register::<Velocity>();

    // エンティティを作成
    world.create_entity()
        .with(Position { x: 0.0, y: 0.0 })
        .with(Velocity { dx: 1.0, dy: 1.0 })
        .build();

    world.create_entity()
        .with(Position { x: 5.0, y: 5.0 })
        .with(Velocity { dx: -1.0, dy: -1.0 })
        .build();

    // ディスパッチャを構築
    let mut dispatcher = DispatcherBuilder::new()
        .with(MovementSystem, "movement_system", &[])
        .build();

    // システムを実行
    dispatcher.dispatch(&world);
}

use hecs::{World, Entity};

#[derive(Debug)]
struct Position {
    x: f32,
    y: f32,
}

#[derive(Debug)]
struct Velocity {
    dx: f32,
    dy: f32,
}

fn move_system(world: &mut World) {
    for (_, (pos, vel)) in &mut world.query::<(&mut Position, &Velocity)>() {
        pos.x += vel.dx;
        pos.y += vel.dy;
        println!("Moved to position: {:?}", pos);
    }
}

fn main() {
    let mut world = World::new();

    // プレイヤーのエンティティ
    world.spawn((
        Position { x: 0.0, y: 0.0 },
        Velocity { dx: 1.0, dy: 0.0 },
    ));

    // 敵のエンティティ
    world.spawn((
        Position { x: 5.0, y: 5.0 },
        Velocity { dx: -0.5, dy: -0.5 },
    ));

    // 移動システムの実行
    move_system(&mut world);
}

use specs::prelude::*;
use specs_derive::Component;

#[derive(Component, Debug)]
struct Position {
    x: f32,
    y: f32,
}

#[derive(Component, Debug)]
struct Velocity {
    dx: f32,
    dy: f32,
}

struct MovementSystem;

impl<'a> System<'a> for MovementSystem {
    type SystemData = (
        WriteStorage<'a, Position>,
        ReadStorage<'a, Velocity>,
    );

    fn run(&mut self, (mut positions, velocities): Self::SystemData) {
        for (pos, vel) in (&mut positions, &velocities).join() {
            pos.x += vel.dx;
            pos.y += vel.dy;
            println!("Moved to position: {:?}", pos);
        }
    }
}

struct AiSystem;

impl<'a> System<'a> for AiSystem {
    type SystemData = WriteStorage<'a, Velocity>;

    fn run(&mut self, mut velocities: Self::SystemData) {
        for vel in (&mut velocities).join() {
            vel.dx = -vel.dx;
            vel.dy = -vel.dy;
            println!("AI adjusted velocity: {:?}", vel);
        }
    }
}

fn main() {
    let mut world = World::new();

    world.register::<Position>();
    world.register::<Velocity>();

    // エンティティを作成
    world.create_entity()
        .with(Position { x: 0.0, y: 0.0 })
        .with(Velocity { dx: 1.0, dy: 0.0 })
        .build();

    world.create_entity()
        .with(Position { x: 5.0, y: 5.0 })
        .with(Velocity { dx: -0.5, dy: -0.5 })
        .build();

    let mut dispatcher = DispatcherBuilder::new()
        .with(MovementSystem, "movement_system", &[])
        .with(AiSystem, "ai_system", &["movement_system"])
        .build();

    dispatcher.dispatch(&world);
}

use hecs::{World, Entity};
use rand::Rng;

#[derive(Debug)]
struct Position {
    x: f32,
    y: f32,
}

#[derive(Debug)]
struct Energy {
    value: f32,
}

fn movement_system(world: &mut World) {
    let mut rng = rand::thread_rng();
    for (_, (pos, energy)) in &mut world.query::<(&mut Position, &mut Energy)>() {
        if energy.value > 0.0 {
            pos.x += rng.gen_range(-1.0..1.0);
            pos.y += rng.gen_range(-1.0..1.0);
            energy.value -= 1.0;
            println!("Entity moved to position: {:?}, Energy: {:?}", pos, energy.value);
        }
    }
}

fn cleanup_system(world: &mut World) {
    let to_remove: Vec<Entity> = world
        .query::<&Energy>()
        .iter()
        .filter_map(|(entity, energy)| if energy.value <= 0.0 { Some(entity) } else { None })
        .collect();

    for entity in to_remove {
        world.despawn(entity).expect("Failed to remove entity");
        println!("Entity removed due to low energy");
    }
}

fn main() {
    let mut world = World::new();

    // エンティティを作成
    for _ in 0..10 {
        world.spawn((
            Position { x: 0.0, y: 0.0 },
            Energy { value: 10.0 },
        ));
    }

    // システムを繰り返し実行
    for _ in 0..10 {
        movement_system(&mut world);
        cleanup_system(&mut world);
    }
}

use specs::prelude::*;
use specs_derive::Component;
use rand::Rng;

#[derive(Component, Debug)]
struct Position {
    x: f32,
    y: f32,
}

#[derive(Component, Debug)]
struct Energy {
    value: f32,
}

struct MovementSystem;

impl<'a> System<'a> for MovementSystem {
    type SystemData = (
        WriteStorage<'a, Position>,
        WriteStorage<'a, Energy>,
    );

    fn run(&mut self, (mut positions, mut energies): Self::SystemData) {
        let mut rng = rand::thread_rng();
        for (pos, energy) in (&mut positions, &mut energies).join() {
            if energy.value > 0.0 {
                pos.x += rng.gen_range(-1.0..1.0);
                pos.y += rng.gen_range(-1.0..1.0);
                energy.value -= 1.0;
                println!("Entity moved to position: {:?}, Energy: {:?}", pos, energy.value);
            }
        }
    }
}

struct CleanupSystem;

impl<'a> System<'a> for CleanupSystem {
    type SystemData = (
        Entities<'a>,
        ReadStorage<'a, Energy>,
    );

    fn run(&mut self, (entities, energies): Self::SystemData) {
        for (entity, energy) in (&entities, &energies).join() {
            if energy.value <= 0.0 {
                entities.delete(entity).expect("Failed to delete entity");
                println!("Entity removed due to low energy");
            }
        }
    }
}

fn main() {
    let mut world = World::new();
    world.register::<Position>();
    world.register::<Energy>();

    for _ in 0..10 {
        world.create_entity()
            .with(Position { x: 0.0, y: 0.0 })
            .with(Energy { value: 10.0 })
            .build();
    }

    let mut dispatcher = DispatcherBuilder::new()
        .with(MovementSystem, "movement_system", &[])
        .with(CleanupSystem, "cleanup_system", &["movement_system"])
        .build();

    for _ in 0..10 {
        dispatcher.dispatch(&world);
    }
}