diff --git a/Cargo.lock b/Cargo.lock
index bc931ef..da17a5a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1101,6 +1101,25 @@ dependencies = [
  "winit",
 ]
 
+[[package]]
+name = "big-brain"
+version = "0.18.0"
+source = "git+https://github.com/PlagueAutomata/big-brain?rev=aed238e#aed238e65625a22816441351f9755854db661365"
+dependencies = [
+ "bevy",
+ "big-brain-derive",
+]
+
+[[package]]
+name = "big-brain-derive"
+version = "0.18.0"
+source = "git+https://github.com/PlagueAutomata/big-brain?rev=aed238e#aed238e65625a22816441351f9755854db661365"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.43",
+]
+
 [[package]]
 name = "bindgen"
 version = "0.69.1"
@@ -2357,6 +2376,7 @@ version = "0.1.0"
 dependencies = [
  "bevy",
  "bevy_egui",
+ "big-brain",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index a9ef53b..987cb7d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,3 +25,4 @@ bevy = { version = "0.12.1", features = [
     "wayland",
 ] }
 bevy_egui = "0.24"
+big-brain = { git = "https://github.com/PlagueAutomata/big-brain", rev = "aed238e" }
diff --git a/src/character.rs b/src/character.rs
index 99d4291..0704aa7 100644
--- a/src/character.rs
+++ b/src/character.rs
@@ -1,64 +1,59 @@
+use crate::mechanics::*;
 use crate::{game_state::GameState, selectable::Selectable};
 use bevy::prelude::*;
+use big_brain::prelude::*;
+
+mod inventory;
+mod movement;
+
+pub use self::{
+    inventory::Inventory,
+    movement::{CachedFinder, FindAndMove},
+};
+
+pub const DEFAULT_COLOR: Color = Color::BLACK;
+pub const SLEEP_COLOR: Color = Color::BLUE;
+pub const FARM_COLOR: Color = Color::YELLOW;
 
 pub struct CharacterPlugin;
 
 impl Plugin for CharacterPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<SpawnCharacter>()
+        app.add_plugins((BigBrainPlugin::new(PreUpdate),))
+            .add_event::<SpawnCharacter>()
             .add_systems(PreUpdate, spawner_system)
             .add_systems(
                 Update,
-                (read_target_position, move_character)
-                    .chain()
-                    .run_if(in_state(GameState::Playing)),
+                sync_character_color.run_if(in_state(GameState::Playing)),
             );
     }
 }
 
 #[derive(Component)]
 pub struct CharacterController {
-    pub target: Option<Vec3>,
-    pub velocity: Vec3,
     pub speed: f32,
+    pub color: Color,
+    pub is_sleeping: bool,
 }
 
-#[derive(Component)]
-pub struct MovementTarget(pub Entity);
-
-pub fn read_target_position(
-    transforms: TransformHelper,
-    mut query: Query<(&mut CharacterController, &MovementTarget)>,
-) {
-    for (mut ctrl, &MovementTarget(target)) in query.iter_mut() {
-        ctrl.target = transforms
-            .compute_global_transform(target)
-            .map(|transform| transform.translation())
-            .ok();
-    }
-}
-
-pub fn move_character(
-    time: Res<Time>,
-    mut query: Query<(&mut CharacterController, &mut Transform), Without<Parent>>,
+pub fn sync_character_color(
+    query: Query<(&CharacterController, &Children)>,
+    material_query: Query<&Handle<StandardMaterial>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    for (mut ctrl, mut transform) in query.iter_mut() {
-        ctrl.velocity = match ctrl.target {
-            Some(target) => (target - transform.translation).normalize_or_zero() * ctrl.speed,
-            None => Vec3::ZERO,
-        };
-        transform.translation += ctrl.velocity * time.delta_seconds();
-
-        if ctrl.velocity.length() > 0.0 {
-            // TODO: remove pitch/roll
-            *transform = transform.looking_to(ctrl.velocity, Vec3::Y);
+    for (ctrl, children) in &query {
+        let child = children.first();
+        let material_id = child.and_then(|&entity| material_query.get(entity).ok());
+        let material = material_id.and_then(|id| materials.get_mut(id));
+        if let Some(material) = material {
+            material.base_color = ctrl.color;
         }
     }
 }
+
 #[derive(Event, Default)]
 pub struct SpawnCharacter {
     pub transform: Transform,
-    pub target: Option<Entity>,
     pub model: CharacterModel,
 }
 
@@ -84,29 +79,41 @@ pub fn spawner_system(
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
-    for SpawnCharacter {
-        transform,
-        target,
-        model,
-    } in events.drain()
-    {
+    for SpawnCharacter { transform, model } in events.drain() {
         let mut entity = commands.spawn((
             SpatialBundle {
                 transform,
                 ..default()
             },
+            Selectable {},
             CharacterController {
-                target: None,
-                velocity: Vec3::ZERO,
-                speed: 3.0,
+                speed: 5.0,
+                color: DEFAULT_COLOR,
+                is_sleeping: false,
             },
-            Selectable {},
+            Fatigue {
+                current: 0.0,
+                change: 8.0,
+            },
+            Inventory {
+                money: 0,
+                items: 0.0,
+            },
+            Thinker::first_to_score(0.6)
+                .when(
+                    FatigueScorer::default(),
+                    Sequence::step((FindAndMove::<House>::new(0.1), Sleep::new(10.0, 30.0))),
+                )
+                .when(
+                    WorkNeedScorer,
+                    Sequence::step((FindAndMove::<Field>::new(0.1), Farm::new(10.0, 30.0))),
+                )
+                .when(
+                    SellNeedScorer,
+                    Sequence::step((FindAndMove::<Market>::new(0.1), Sell)),
+                ),
         ));
 
-        if let Some(target) = target {
-            entity.insert(MovementTarget(target));
-        }
-
         entity.with_children(|builder| {
             let capsule = shape::Capsule {
                 depth: model.height,
@@ -117,7 +124,11 @@ pub fn spawner_system(
             builder.spawn(PbrBundle {
                 mesh: meshes.add(Mesh::from(capsule)),
                 material: materials.add(Color::YELLOW.into()),
-                transform: Transform::from_translation(Vec3::new(0.0, model.height / 2.0, 0.0)),
+                transform: Transform::from_translation(Vec3::new(
+                    0.0,
+                    model.height / 2.0 + model.radius,
+                    0.0,
+                )),
                 ..default()
             });
 
@@ -130,7 +141,7 @@ pub fn spawner_system(
                 material: materials.add(Color::RED.into()),
                 transform: Transform::from_translation(Vec3::new(
                     0.0,
-                    model.height - model.face_height / 2.0,
+                    model.height - model.face_height / 2.0 + model.radius,
                     -model.radius,
                 )),
                 ..default()
diff --git a/src/character/inventory.rs b/src/character/inventory.rs
new file mode 100644
index 0000000..4279fa5
--- /dev/null
+++ b/src/character/inventory.rs
@@ -0,0 +1,11 @@
+use bevy::prelude::*;
+
+#[derive(Component, Reflect)]
+pub struct Inventory {
+    pub money: u32,
+    pub items: f32,
+}
+
+impl Inventory {
+    pub const MAX_ITEMS: f32 = 20.0;
+}
diff --git a/src/character/movement.rs b/src/character/movement.rs
new file mode 100644
index 0000000..38b7d98
--- /dev/null
+++ b/src/character/movement.rs
@@ -0,0 +1,99 @@
+use super::CharacterController;
+use bevy::prelude::*;
+use big_brain::prelude::*;
+
+// TODO: radius maybe readed from world
+
+#[derive(Component, Clone, ActionSpawn)]
+pub struct FindAndMove<T: Component + Clone> {
+    radius: f32,
+    finder: CachedFinder,
+    marker: std::marker::PhantomData<T>,
+}
+
+impl<T: Component + Clone> FindAndMove<T> {
+    pub fn new(radius: f32) -> Self {
+        Self {
+            radius,
+            finder: CachedFinder { target: None },
+            marker: std::marker::PhantomData,
+        }
+    }
+
+    pub fn system(
+        time: Res<Time>,
+        query: Query<(Entity, &Transform), With<T>>,
+        mut actors: Query<(&mut Transform, &CharacterController), Without<T>>,
+        mut actions: Query<(ActionQuery, &mut Self)>,
+    ) {
+        for (mut action, mut move_to) in actions.iter_mut() {
+            if action.is_executing() {
+                let (mut transform, ctrl) = actors.get_mut(action.actor()).unwrap();
+
+                let Some(goal) = move_to.finder.find(&query, transform.translation) else {
+                    action.failure();
+                    continue;
+                };
+
+                let delta = goal.translation - transform.translation;
+                let distance = delta.length();
+
+                trace!("Distance to {:?}: {}", std::any::type_name::<T>(), distance);
+
+                if distance > move_to.radius {
+                    let step = (ctrl.speed * time.delta_seconds()).min(distance);
+                    transform.translation += delta.normalize_or_zero() * step;
+                    transform.look_to(delta, Vec3::Y);
+                } else {
+                    debug!("Reached {:?}", std::any::type_name::<T>());
+                    action.success()
+                }
+            }
+
+            if action.is_cancelled() {
+                debug!("Movement to {:?} is cancelled", std::any::type_name::<T>());
+
+                // cleanup just for sure
+                let _ = move_to.finder.take_target();
+                action.failure();
+            }
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+pub struct CachedFinder {
+    target: Option<Entity>,
+}
+
+impl CachedFinder {
+    pub fn target(&self) -> Option<Entity> {
+        self.target
+    }
+
+    #[must_use]
+    pub fn take_target(&mut self) -> Option<Entity> {
+        self.target.take()
+    }
+
+    pub fn find<T: Component>(
+        &mut self,
+        query: &Query<(Entity, &'_ Transform), With<T>>,
+        translation: Vec3,
+    ) -> Option<Transform> {
+        let (entity, transform) = if let Some(entity) = self.target {
+            query.get(entity).ok()
+        } else {
+            debug!("Try find {:?}", std::any::type_name::<T>());
+            query.iter().min_by(|(_, a), (_, b)| {
+                let a = (a.translation - translation).length_squared();
+                let b = (b.translation - translation).length_squared();
+                f32::total_cmp(&a, &b)
+            })
+        }?;
+
+        self.target = Some(entity);
+
+        Some(*transform)
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index 93be438..242a760 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,17 +1,17 @@
+use crate::character::SpawnCharacter;
+use crate::raycast::PlaneRaycast;
+use crate::selectable::{CurrentlySelected, Selectable};
+use bevy::input::mouse::*;
 use bevy::{
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     prelude::*,
     window::PresentMode,
 };
 
-use crate::character::SpawnCharacter;
-use crate::raycast::PlaneRaycast;
-use crate::selectable::{CurrentlySelected, Selectable};
-use bevy::input::mouse::*;
-
 mod character;
 mod game_state;
 mod main_menu;
+mod mechanics;
 mod raycast;
 mod selectable;
 mod splash_screen;
@@ -50,6 +50,7 @@ fn main() {
         bevy_egui::EguiPlugin,
         crate::splash_screen::SplashScreenPlugin,
         crate::main_menu::MainMenuPlugin,
+        crate::mechanics::MechanicsPlugin,
         crate::character::CharacterPlugin,
         crate::raycast::RaycastPlugin,
     ));
@@ -74,17 +75,8 @@ fn setup(
         ..default()
     });
 
-    // cube
-    let cube = commands.spawn(PbrBundle {
-        mesh: meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
-        material: materials.add(Color::rgb_u8(124, 144, 255).into()),
-        transform: Transform::from_xyz(0.0, 0.5, 0.0),
-        ..default()
-    });
-
     spawner.send(SpawnCharacter {
-        transform: Transform::from_translation(Vec3::new(20.0, 0.0, 30.0)),
-        target: Some(cube.id()),
+        transform: Transform::from_translation(Vec3::new(0.0, 0.0, 0.0)),
         ..default()
     });
 
diff --git a/src/mechanics.rs b/src/mechanics.rs
new file mode 100644
index 0000000..664b774
--- /dev/null
+++ b/src/mechanics.rs
@@ -0,0 +1,80 @@
+mod field;
+mod house;
+mod market;
+
+pub use self::{
+    field::{Farm, Field, WorkNeedScorer},
+    house::{Fatigue, FatigueScorer, House, Sleep},
+    market::{Market, Sell, SellNeedScorer},
+};
+
+use crate::game_state::GameState;
+use bevy::prelude::*;
+
+pub const FIELD_COLOR: Color = Color::YELLOW;
+pub const HOUSE_COLOR: Color = Color::BLUE;
+pub const MARKET_COLOR: Color = Color::RED;
+
+pub struct MechanicsPlugin;
+
+impl Plugin for MechanicsPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_plugins((
+            self::field::FieldPlugin,
+            self::house::HousePlugin,
+            self::market::MarketPlugin,
+        ))
+        .add_systems(OnEnter(GameState::Playing), spawn_scene)
+        .add_systems(OnExit(GameState::Playing), despawn_scene);
+    }
+}
+
+pub fn spawn_scene(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let rotation = Transform::from_rotation(Quat::from_rotation_x(-std::f32::consts::FRAC_PI_2));
+    let model = meshes.add(shape::Circle::new(0.5).into());
+
+    // farm field
+    commands.spawn(Field).insert(PbrBundle {
+        mesh: model.clone(),
+        material: materials.add(FIELD_COLOR.into()),
+        transform: rotation.with_translation(Vec3::new(-5.0, 0.0, 0.0)),
+        ..default()
+    });
+
+    // sleeping house
+    commands.spawn(House).insert(PbrBundle {
+        mesh: model.clone(),
+        material: materials.add(HOUSE_COLOR.into()),
+        transform: rotation.with_translation(Vec3::new(5.0, 0.0, -5.0)),
+        ..default()
+    });
+
+    // marketplace
+    commands.spawn(Market).insert(PbrBundle {
+        mesh: model,
+        material: materials.add(MARKET_COLOR.into()),
+        transform: rotation.with_translation(Vec3::new(0.0, 0.0, 5.0)),
+        ..default()
+    });
+}
+
+pub fn despawn_scene(
+    mut commands: Commands,
+    fields: Query<Entity, With<Field>>,
+    houses: Query<Entity, With<House>>,
+    markets: Query<Entity, With<Market>>,
+) {
+    for entity in &fields {
+        commands.entity(entity).despawn_recursive();
+    }
+    for entity in &houses {
+        commands.entity(entity).despawn_recursive();
+    }
+    for entity in &markets {
+        commands.entity(entity).despawn_recursive();
+    }
+}
diff --git a/src/mechanics/field.rs b/src/mechanics/field.rs
new file mode 100644
index 0000000..a9501f1
--- /dev/null
+++ b/src/mechanics/field.rs
@@ -0,0 +1,81 @@
+use crate::{
+    character::{CharacterController, FindAndMove, Inventory, DEFAULT_COLOR, FARM_COLOR},
+    game_state::GameState,
+};
+use bevy::prelude::*;
+use big_brain::prelude::*;
+
+#[derive(Component, Clone)]
+pub struct Field;
+
+pub struct FieldPlugin;
+
+impl Plugin for FieldPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(
+            PreUpdate,
+            (
+                (farm_action, FindAndMove::<Field>::system).in_set(BigBrainSet::Actions),
+                work_need_scorer.in_set(BigBrainSet::Scorers),
+            )
+                .run_if(in_state(GameState::Playing)),
+        );
+    }
+}
+
+/// Farming 🚜
+#[derive(Component, Clone, ActionSpawn)]
+pub struct Farm {
+    pub until: f32,
+    pub per_second: f32,
+}
+
+impl Farm {
+    pub fn new(until: f32, per_second: f32) -> Self {
+        Self { until, per_second }
+    }
+}
+
+pub fn farm_action(
+    time: Res<Time>,
+    mut actors: Query<(&mut Inventory, &mut CharacterController)>,
+    mut query: Query<(ActionQuery, &Farm)>,
+) {
+    for (mut action, farm) in &mut query {
+        let (mut inventory, mut ctrl) = actors.get_mut(action.actor()).unwrap();
+
+        if action.is_executing() {
+            //debug!("Time to farm!");
+
+            trace!("Farming...");
+            inventory.items += farm.per_second * time.delta_seconds();
+            ctrl.color = FARM_COLOR;
+
+            if inventory.items >= Inventory::MAX_ITEMS {
+                debug!("Inventory full!");
+                ctrl.color = DEFAULT_COLOR;
+                action.success();
+            }
+        }
+
+        if action.is_cancelled() {
+            debug!("Farming was interrupted. Still need to work.");
+            ctrl.color = DEFAULT_COLOR;
+            action.failure();
+        }
+    }
+}
+
+#[derive(Component, Clone, Default, ScorerSpawn)]
+pub struct WorkNeedScorer;
+
+pub fn work_need_scorer(
+    actors: Query<&Inventory>,
+    mut query: Query<ScorerQuery, With<WorkNeedScorer>>,
+) {
+    for mut score in &mut query {
+        let inventory = actors.get(score.actor());
+        let need_more = inventory.map_or(false, |inv| inv.items < Inventory::MAX_ITEMS);
+        score.set(if need_more { 0.6 } else { 0.0 });
+    }
+}
diff --git a/src/mechanics/house.rs b/src/mechanics/house.rs
new file mode 100644
index 0000000..f7a8e67
--- /dev/null
+++ b/src/mechanics/house.rs
@@ -0,0 +1,114 @@
+use crate::{
+    character::{CharacterController, FindAndMove, DEFAULT_COLOR, SLEEP_COLOR},
+    game_state::GameState,
+};
+use bevy::prelude::*;
+use big_brain::prelude::*;
+
+#[derive(Component, Clone)]
+pub struct House;
+
+pub struct HousePlugin;
+
+impl Plugin for HousePlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(Update, fatigue_system).add_systems(
+            PreUpdate,
+            (
+                (sleep_action, FindAndMove::<House>::system).in_set(BigBrainSet::Actions),
+                fatigue_scorer.in_set(BigBrainSet::Scorers),
+            )
+                .run_if(in_state(GameState::Playing)),
+        );
+    }
+}
+
+/// Sleepiness 😴
+#[derive(Component)]
+pub struct Fatigue {
+    pub change: f32,
+    pub current: f32,
+}
+
+pub fn fatigue_system(time: Res<Time>, mut parameters: Query<&mut Fatigue>) {
+    for mut param in &mut parameters {
+        param.current = (param.current + param.change * time.delta_seconds()).clamp(0.0, 100.0);
+    }
+}
+
+#[derive(Component, Clone, ActionSpawn)]
+pub struct Sleep {
+    pub until: f32,
+    pub per_second: f32,
+}
+
+impl Sleep {
+    pub fn new(until: f32, per_second: f32) -> Self {
+        Self { until, per_second }
+    }
+}
+
+pub fn sleep_action(
+    time: Res<Time>,
+    mut actors: Query<(&mut Fatigue, &mut CharacterController)>,
+    mut query: Query<(ActionQuery, &Sleep)>,
+) {
+    for (mut action, sleep) in &mut query {
+        let (mut fatigue, mut ctrl) = actors.get_mut(action.actor()).unwrap();
+
+        if action.is_executing() {
+            if !ctrl.is_sleeping {
+                debug!("Time to sleep!");
+                ctrl.is_sleeping = true;
+            }
+
+            trace!("Sleeping...");
+
+            fatigue.current -= sleep.per_second * time.delta_seconds();
+            ctrl.color = SLEEP_COLOR;
+
+            if fatigue.current <= sleep.until {
+                debug!("Woke up well-rested!");
+                ctrl.color = DEFAULT_COLOR;
+                ctrl.is_sleeping = false;
+                action.success();
+            }
+        }
+
+        if action.is_cancelled() {
+            debug!("Sleep was interrupted. Still tired.");
+            ctrl.color = DEFAULT_COLOR;
+            ctrl.is_sleeping = false;
+            action.failure();
+        }
+    }
+}
+
+#[derive(Component, Clone, Default, ScorerSpawn)]
+pub struct FatigueScorer {
+    last_score: Option<f32>,
+}
+
+pub fn fatigue_scorer(
+    actors: Query<(&Fatigue, &CharacterController)>,
+    mut query: Query<(ScorerQuery, &mut FatigueScorer)>,
+) {
+    for (mut score, mut scorer) in &mut query {
+        if let Ok((fatigue, sleeping)) = actors.get(score.actor()) {
+            let new_score = fatigue.current / 100.0;
+
+            if sleeping.is_sleeping {
+                score.set(*scorer.last_score.get_or_insert(new_score));
+            } else {
+                scorer.last_score.take();
+                score.set(new_score);
+                if fatigue.current >= 80.0 {
+                    trace!(
+                        "Fatigue above threshold! Score: {}",
+                        fatigue.current / 100.0
+                    )
+                }
+            }
+        }
+    }
+}
diff --git a/src/mechanics/market.rs b/src/mechanics/market.rs
new file mode 100644
index 0000000..8aef3f7
--- /dev/null
+++ b/src/mechanics/market.rs
@@ -0,0 +1,60 @@
+use crate::{
+    character::{FindAndMove, Inventory},
+    game_state::GameState,
+};
+use bevy::prelude::*;
+use big_brain::prelude::*;
+
+#[derive(Component, Clone)]
+pub struct Market;
+
+pub struct MarketPlugin;
+
+impl Plugin for MarketPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(
+            PreUpdate,
+            (
+                (sell_action, FindAndMove::<Market>::system).in_set(BigBrainSet::Actions),
+                sell_need_scorer.in_set(BigBrainSet::Scorers),
+            )
+                .run_if(in_state(GameState::Playing)),
+        );
+    }
+}
+
+/// Selling 💰
+#[derive(Component, Clone, ActionSpawn)]
+pub struct Sell;
+
+pub fn sell_action(mut actors: Query<&mut Inventory>, mut query: Query<ActionQuery, With<Sell>>) {
+    for mut action in &mut query {
+        let mut inventory = actors.get_mut(action.actor()).unwrap();
+
+        if action.is_executing() {
+            inventory.money += inventory.items as u32;
+            inventory.items = 0.0;
+            debug!("Sold! Money: {}", inventory.money);
+            action.success();
+        }
+
+        if action.is_cancelled() {
+            debug!("Selling was interrupted. Still need to work.");
+            action.failure();
+        }
+    }
+}
+
+#[derive(Component, Clone, Default, ScorerSpawn)]
+pub struct SellNeedScorer;
+
+pub fn sell_need_scorer(
+    actors: Query<&Inventory>,
+    mut query: Query<ScorerQuery, With<SellNeedScorer>>,
+) {
+    for mut score in &mut query {
+        let inventory = actors.get(score.actor());
+        let has_enough = inventory.map_or(false, |inv| inv.items >= Inventory::MAX_ITEMS);
+        score.set(if has_enough { 0.6 } else { 0.0 });
+    }
+}