#bigbrain

LavendreyBrainLover
2026-01-30
LavendreyBrainLover
2026-01-30
2026-01-29

RE: assortedflotsam.com/@technewsb

Gonna start doing this for all my work meetings...

LavendreyBrainLover
2026-01-25

Brainy Unicorn OC named Lavendrey

LavendreyBrainLover
2026-01-23
LavendreyBrainLover
2026-01-23
Michael Hankemih@mas.to
2025-10-27

And now Berlin for the #bigbrain training day, contributing a workshop on @datalad with @adswa

2025-10-07

Big Brain, btw, is designed to be data-oriented, so I might provide an API that lets you define game AI in .kdl files that look like this. It could also, for example, eventually use a hypothetical node editor (thing Blender Geometry Nodes), to define the same data.

#KDL #Bevy #BigBrain #GameAI

Thinker {
    picker FirstToScore threshold=0.8
    when Thirsty {
        GoToWater
        Drink
    }
    when Hungry {
        Eat
    }
    or Bored Paranoid {
        Thinker {
            when EnemySpotted {
                ShootEnemy
            }
            when FlowersSpotted {
                WalkToFlowers
                PickAFlower
                SmellFlower
            }
            otherwise {
                Parallel {
                    Wander
                    HumATune
                }
            }
        }
    }
}
2025-10-07

Seeking feedback from Bevy and Big Brain users: how does this new API look?

Under the hood, this would be a high-performance, low-overhead API powered by Observers, but this is all you would actually need to write yourself.

I'm pretty sure I can get this to work with Bevy's current featureset, including the Very Fun async actions situation here.

#Bevy #BigBrain #GameAI #Rust #RustLang

#[derive(Debug, Default, Clone, Copy, Component)]
pub struct Thirsty;

#[scorer_for(Thirsty)]
pub fn score_thirsty(score: Score, thirsts: Query<&Thirst>) -> Score {
    score.update(thirsts.get(score.actor()).unwrap().thirst)
}

#[derive(Debug, Clone, Copy, Component)]
pub struct Drink { rate: f32, per: Duration }
impl Default for Drink {
    fn default() -> Self {
        Self { rate: 0.5, per: Duration::from_millis(500), }
    }
}

#[action_for(Drink)]
pub async fn drink_action(
    action: Action<Drink>,
    mut thirsts: Query<&mut Thirst>
) -> Result<(), ActionFailure> {
    while let Ok(mut thirst) = thirsts.get(action.actor()) && thirst.thirst > 10.0 {
        action.check_cancelled()?;
        thirst.thirst -= action.data().rate;
        action.sleep(action.data().per).await;
    }
    Ok(())
}

fn spawn_entity(cmd: &mut Commands) {
    cmd.spawn((
        Thirst(70.0, 2.0),
        Thinker::new()
            .picker(FirstToScore { threshold: 0.8 })
            .when<Thirsty, Drink>(),
    ));
}
2025-10-02

I'm just gonna keep waiting until the Bevy Editor finally comes out to try and write a game with the engine in earnest. I keep getting ideas but I just don't really wanna deal with writing something as complex and difficult as a game, with my hands tied behind my back any more than I have to.

that said, I'll probably be poking around the ecosystem sometime soon, after reading those updates on the observers in 0.17. They would make big-brain so much nicer to use, and probably simplify the implementation a lot (it would probably be a full rewrite?)

#bevy #bigbrain #gamedev #rust #rustlang

Chema Alonso :verified:chemaalonso@ioc.exchange
2025-06-22

Client Info

Server: https://mastodon.social
Version: 2025.07
Repository: https://github.com/cyevgeniy/lmst