Implement overproduction notification handling in ProduceWorker: Add logic to check for existing notifications and update them if necessary, or create a new notification if none exist. Introduce SQL queries for finding and updating overproduction notifications to enhance database interactions.

YpDaemon/src/worker/user_character.rs

@@ -0,0 +1,881 @@
+use crate::db::{ConnectionPool, DbError, Rows};
+use crate::message_broker::MessageBroker;
+use rand::distributions::{Distribution, Uniform};
+use rand::rngs::StdRng;
+use rand::SeedableRng;
+use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use super::base::{BaseWorker, Worker, WorkerState};
+use crate::worker::sql::{
+    QUERY_GET_USERS_TO_UPDATE,
+    QUERY_UPDATE_CHARACTERS_HEALTH,
+    QUERY_UPDATE_MOOD,
+    QUERY_UPDATE_GET_ITEMS_TO_UPDATE,
+    QUERY_UPDATE_GET_CHARACTER_IDS,
+    QUERY_UPDATE_KNOWLEDGE,
+    QUERY_DELETE_LOG_ENTRY,
+    QUERY_GET_OPEN_CREDITS,
+    QUERY_UPDATE_CREDIT,
+    QUERY_CLEANUP_CREDITS,
+    QUERY_ADD_CHARACTER_TO_DEBTORS_PRISM,
+    QUERY_GET_CURRENT_MONEY,
+    QUERY_GET_HOUSE_VALUE,
+    QUERY_GET_SETTLEMENT_VALUE,
+    QUERY_GET_INVENTORY_VALUE,
+    QUERY_GET_CREDIT_DEBT,
+    QUERY_COUNT_CHILDREN,
+    QUERY_GET_HEIR,
+    QUERY_RANDOM_HEIR,
+    QUERY_SET_CHARACTER_USER,
+    QUERY_UPDATE_USER_MONEY,
+    QUERY_GET_FALUKANT_USER_ID,
+    QUERY_AUTOBATISM,
+    QUERY_GET_PREGNANCY_CANDIDATES,
+    QUERY_INSERT_CHILD,
+    QUERY_INSERT_CHILD_RELATION,
+    QUERY_DELETE_DIRECTOR,
+    QUERY_DELETE_RELATIONSHIP,
+    QUERY_DELETE_CHILD_RELATION,
+    QUERY_DELETE_KNOWLEDGE,
+    QUERY_DELETE_DEBTORS_PRISM,
+    QUERY_DELETE_POLITICAL_OFFICE,
+    QUERY_DELETE_ELECTION_CANDIDATE,
+};
+
+/// Vereinfachtes Abbild eines Characters aus `QUERY_GET_USERS_TO_UPDATE`.
+#[derive(Debug, Clone)]
+struct Character {
+    id: i32,
+    age: i32,
+    health: i32,
+}
+
+pub struct UserCharacterWorker {
+    base: BaseWorker,
+    rng: StdRng,
+    dist: Uniform<f64>,
+    last_hourly_run: Option<Instant>,
+    last_pregnancy_run: Option<Instant>,
+    last_mood_run: Option<Instant>,
+}
+
+// SQL moved to `src/worker/sql.rs`
+
+impl UserCharacterWorker {
+    pub fn new(pool: ConnectionPool, broker: MessageBroker) -> Self {
+        let base = BaseWorker::new("UserCharacterWorker", pool, broker);
+        let rng = StdRng::from_entropy();
+        let dist = Uniform::from(0.0..1.0);
+
+        Self {
+            base,
+            rng,
+            dist,
+            last_hourly_run: None,
+            last_pregnancy_run: None,
+            last_mood_run: None,
+        }
+    }
+
+    fn run_iteration(&mut self, state: &WorkerState) {
+        self.base.set_current_step("UserCharacterWorker iteration");
+
+        self.maybe_run_hourly_tasks();
+        self.maybe_run_mood_updates();
+        self.maybe_run_daily_pregnancies();
+
+        // Entspricht in etwa der 1-Sekunden-Schleife im C++-Code
+        std::thread::sleep(Duration::from_secs(1));
+
+        if let Err(err) = self.recalculate_knowledge() {
+            eprintln!("[UserCharacterWorker] Fehler in recalculateKnowledge: {err}");
+        }
+
+        if !state.running_worker.load(Ordering::Relaxed) {
+            // worker stopping
+        }
+    }
+
+    fn maybe_run_hourly_tasks(&mut self) {
+        let now = Instant::now();
+        let should_run = match self.last_hourly_run {
+            None => true,
+            Some(last) => now.saturating_duration_since(last) >= Duration::from_secs(3600),
+        };
+
+        if !should_run {
+            return;
+        }
+
+        if let Err(err) = self.run_hourly_tasks() {
+            eprintln!("[UserCharacterWorker] Fehler in stündlichen Tasks: {err}");
+        }
+
+        self.last_hourly_run = Some(now);
+    }
+
+    fn run_hourly_tasks(&mut self) -> Result<(), DbError> {
+        self.process_character_events()?;
+        self.handle_credits()?;
+        Ok(())
+    }
+
+    fn maybe_run_daily_pregnancies(&mut self) {
+        let now = Instant::now();
+        let should_run = match self.last_pregnancy_run {
+            None => true,
+            Some(last) => now.saturating_duration_since(last) >= Duration::from_secs(24 * 3600),
+        };
+
+        if !should_run {
+            return;
+        }
+
+        if let Err(err) = self.process_pregnancies() {
+            eprintln!("[UserCharacterWorker] Fehler in processPregnancies: {err}");
+        }
+        self.last_pregnancy_run = Some(now);
+    }
+
+    fn process_character_events(&mut self) -> Result<(), DbError> {
+        self.base.set_current_step("Get character data");
+
+        let rows = self.load_characters_to_update()?;
+        let mut characters: Vec<Character> = rows
+            .into_iter()
+            .filter_map(Self::map_row_to_character)
+            .collect();
+
+        for character in &mut characters {
+            self.update_character_health(character)?;
+        }
+
+        Ok(())
+    }
+
+    fn load_characters_to_update(&mut self) -> Result<Rows, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("get_users_to_update", QUERY_GET_USERS_TO_UPDATE)?;
+        conn.execute("get_users_to_update", &[])
+    }
+
+    fn map_row_to_character(row: crate::db::Row) -> Option<Character> {
+        Some(Character {
+            id: row.get("id")?.parse().ok()?,
+            age: row.get("age")?.parse().ok()?,
+            health: row.get("health")?.parse().ok()?,
+        })
+    }
+
+    fn update_character_health(&mut self, character: &mut Character) -> Result<(), DbError> {
+        let health_change = self.calculate_health_change(character.age);
+        if health_change == 0 {
+            return Ok(());
+        }
+
+        character.health = std::cmp::max(0, character.health + health_change);
+
+        if character.health == 0 {
+            self.handle_character_death(character.id)?;
+            return Ok(());
+        }
+
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare(
+            "update_characters_health",
+            QUERY_UPDATE_CHARACTERS_HEALTH,
+        )?;
+        conn.execute(
+            "update_characters_health",
+            &[&character.health, &character.id],
+        )?;
+
+        Ok(())
+    }
+
+    fn calculate_health_change(&mut self, age: i32) -> i32 {
+        if age < 30 {
+            return 0;
+        }
+
+        if age >= 45 {
+            let probability = (0.1 + (age - 45) as f64 * 0.02).min(1.0);
+            if self.dist.sample(&mut self.rng) < probability {
+                let damage_dist = Uniform::from(1..=10);
+                return -damage_dist.sample(&mut self.rng);
+            }
+            return 0;
+        }
+
+        let probability = (age - 30) as f64 / 30.0;
+        if self.dist.sample(&mut self.rng) < probability {
+            -1
+        } else {
+            0
+        }
+    }
+
+    fn maybe_run_mood_updates(&mut self) {
+        let now = Instant::now();
+        let should_run = match self.last_mood_run {
+            None => true,
+            Some(last) => now.saturating_duration_since(last) >= Duration::from_secs(60),
+        };
+
+        if !should_run {
+            return;
+        }
+
+        if let Err(err) = self.update_characters_mood_randomized() {
+            eprintln!("[UserCharacterWorker] Fehler in updateCharactersMood: {err}");
+        }
+
+        self.last_mood_run = Some(now);
+    }
+
+    /// Setzt die Stimmung einzelner lebender Charaktere zufällig neu.
+    /// Jeder Charakter hat pro Minute eine kleine Chance auf einen Wechsel,
+    /// so dass sich über die Zeit ein individueller, zufälliger Rhythmus entsteht.
+    fn update_characters_mood_randomized(&mut self) -> Result<(), DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("update_mood", QUERY_UPDATE_MOOD)?;
+        conn.execute("update_mood", &[])?;
+        Ok(())
+    }
+
+    fn recalculate_knowledge(&mut self) -> Result<(), DbError> {
+        self.base.set_current_step("recalculate knowledge");
+
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare(
+            "get_items_to_update",
+            QUERY_UPDATE_GET_ITEMS_TO_UPDATE,
+        )?;
+        let update_rows = conn.execute("get_items_to_update", &[])?;
+
+        for update_item in update_rows {
+            let quantity: i32 = match update_item.get("quantity").and_then(|v| v.parse().ok()) {
+                Some(q) => q,
+                None => continue,
+            };
+
+            if quantity < 10 {
+                self.delete_production_log_entry(&mut conn, &update_item)?;
+                continue;
+            }
+
+            self.update_knowledge_for_production(&mut conn, &update_item)?;
+            self.delete_production_log_entry(&mut conn, &update_item)?;
+
+            if let Some(producer_id) = update_item
+                .get("producer_id")
+                .and_then(|v| v.parse::<i32>().ok())
+            {
+                self.send_knowledge_update(producer_id);
+            }
+        }
+
+        Ok(())
+    }
+
+    fn update_knowledge_for_production(
+        &mut self,
+        conn: &mut crate::db::DbConnection,
+        update_item: &crate::db::Row,
+    ) -> Result<(), DbError> {
+        let producer_id = match update_item.get("producer_id").and_then(|v| v.parse::<i32>().ok())
+        {
+            Some(id) => id,
+            None => return Ok(()),
+        };
+
+        let product_id = match update_item.get("product_id").and_then(|v| v.parse::<i32>().ok()) {
+            Some(id) => id,
+            None => return Ok(()),
+        };
+
+        conn.prepare(
+            "get_character_ids",
+            QUERY_UPDATE_GET_CHARACTER_IDS,
+        )?;
+        let characters_data =
+            conn.execute("get_character_ids", &[&producer_id])?;
+
+        conn.prepare("update_knowledge", QUERY_UPDATE_KNOWLEDGE)?;
+
+        for character_row in characters_data {
+            let character_id = match character_row
+                .get("character_id")
+                .and_then(|v| v.parse::<i32>().ok())
+            {
+                Some(id) => id,
+                None => continue,
+            };
+
+            let director_id = character_row
+                .get("director_id")
+                .and_then(|v| v.parse::<i32>().ok())
+                .unwrap_or(0);
+
+            if director_id == 0 {
+                conn.execute(
+                    "update_knowledge",
+                    &[&character_id, &product_id, &2_i32],
+                )?;
+            } else {
+                conn.execute(
+                    "update_knowledge",
+                    &[&character_id, &product_id, &1_i32],
+                )?;
+                conn.execute(
+                    "update_knowledge",
+                    &[&director_id, &product_id, &1_i32],
+                )?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn delete_production_log_entry(
+        &mut self,
+        conn: &mut crate::db::DbConnection,
+        update_item: &crate::db::Row,
+    ) -> Result<(), DbError> {
+        let id = match update_item.get("id").and_then(|v| v.parse::<i32>().ok()) {
+            Some(id) => id,
+            None => return Ok(()),
+        };
+
+        conn.prepare("delete_log_entry", QUERY_DELETE_LOG_ENTRY)?;
+        conn.execute("delete_log_entry", &[&id])?;
+        Ok(())
+    }
+
+    fn send_knowledge_update(&self, producer_id: i32) {
+        let message = format!(r#"{{"event":"knowledge_update","user_id":{}}}"#, producer_id);
+        self.base.broker.publish(message);
+    }
+
+    // Kredit-Logik (portiert aus handleCredits)
+    fn handle_credits(&mut self) -> Result<(), DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("get_open_credits", QUERY_GET_OPEN_CREDITS)?;
+        conn.prepare("update_credit", QUERY_UPDATE_CREDIT)?;
+        conn.prepare("cleanup_credits", QUERY_CLEANUP_CREDITS)?;
+        conn.prepare(
+            "add_character_to_debtors_prism",
+            QUERY_ADD_CHARACTER_TO_DEBTORS_PRISM,
+        )?;
+
+        let credits_rows = conn.execute("get_open_credits", &[])?;
+        for row in credits_rows {
+            if let Some(credit) = Self::map_row_to_credit(&row) {
+                self.process_single_credit(&mut conn, &credit)?;
+            }
+        }
+
+        conn.execute("cleanup_credits", &[])?;
+        Ok(())
+    }
+
+    fn map_row_to_credit(row: &crate::db::Row) -> Option<Credit> {
+        Some(Credit {
+            amount: row.get("amount")?.parse().ok()?,
+            remaining_amount: row.get("remaining_amount")?.parse().ok()?,
+            interest_rate: row.get("interest_rate")?.parse().ok()?,
+            user_id: row.get("user_id")?.parse().ok()?,
+            money: row.get("money")?.parse().ok()?,
+            character_id: row.get("character_id")?.parse().ok()?,
+            prism_started_previously: row
+                .get("prism_started_previously")
+                .map(|v| v == "t" || v == "true")
+                .unwrap_or(false),
+        })
+    }
+
+    fn process_single_credit(
+        &mut self,
+        conn: &mut crate::db::DbConnection,
+        credit: &Credit,
+    ) -> Result<(), DbError> {
+        let Credit {
+            amount,
+            mut remaining_amount,
+            interest_rate,
+            user_id,
+            money,
+            character_id,
+            prism_started_previously,
+            ..
+        } = *credit;
+
+        let pay_rate = amount / 10.0 + amount * interest_rate as f64 / 100.0;
+        remaining_amount -= pay_rate;
+
+        // Kann der User zahlen?
+        if pay_rate <= money - (pay_rate * 3.0) {
+            if let Err(err) = self
+                .base
+                .change_falukant_user_money(user_id, -pay_rate, "credit pay rate")
+            {
+                eprintln!(
+                    "[UserCharacterWorker] Fehler bei change_falukant_user_money (credit pay rate): {err}"
+                );
+            }
+        } else if prism_started_previously {
+            if let Err(err) = self
+                .base
+                .change_falukant_user_money(user_id, pay_rate, "debitor_prism")
+            {
+                eprintln!(
+                    "[UserCharacterWorker] Fehler bei change_falukant_user_money (debitor_prism): {err}"
+                );
+            }
+        } else {
+            conn.execute("add_character_to_debtors_prism", &[&character_id])?;
+        }
+
+        conn.execute("update_credit", &[&remaining_amount, &user_id])?;
+        Ok(())
+    }
+
+    // Schwangerschafts-Logik (portiert aus processPregnancies)
+    fn process_pregnancies(&mut self) -> Result<(), DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("autobatism", QUERY_AUTOBATISM)?;
+        conn.execute("autobatism", &[])?;
+
+        conn.prepare("get_pregnancy_candidates", QUERY_GET_PREGNANCY_CANDIDATES)?;
+        let rows = conn.execute("get_pregnancy_candidates", &[])?;
+
+        conn.prepare("insert_child", QUERY_INSERT_CHILD)?;
+        conn.prepare("insert_child_relation", QUERY_INSERT_CHILD_RELATION)?;
+
+        for row in rows {
+            self.process_single_pregnancy_candidate(&mut conn, &row)?;
+        }
+
+        Ok(())
+    }
+
+    fn process_single_pregnancy_candidate(
+        &mut self,
+        conn: &mut crate::db::DbConnection,
+        row: &crate::db::Row,
+    ) -> Result<(), DbError> {
+        let father_cid = parse_i32(row, "father_cid", -1);
+        let mother_cid = parse_i32(row, "mother_cid", -1);
+        if father_cid < 0 || mother_cid < 0 {
+            return Ok(());
+        }
+
+        let title_of_nobility = parse_i32(row, "title_of_nobility", 0);
+        let last_name = parse_i32(row, "last_name", 0);
+        let region_id = parse_i32(row, "region_id", 0);
+
+        let father_uid = parse_opt_i32(row, "father_uid");
+        let mother_uid = parse_opt_i32(row, "mother_uid");
+
+        let gender = if self.dist.sample(&mut self.rng) < 0.5 {
+            "male"
+        } else {
+            "female"
+        };
+
+        let inserted =
+            conn.execute("insert_child", &[&region_id, &gender, &last_name, &title_of_nobility])?;
+                    let child_cid = inserted
+                        .first()
+            .and_then(|r| r.get("child_cid"))
+            .and_then(|v| v.parse::<i32>().ok())
+            .unwrap_or(-1);
+        if child_cid < 0 {
+            return Ok(());
+        }
+
+        conn.execute(
+            "insert_child_relation",
+            &[&father_cid, &mother_cid, &child_cid],
+        )?;
+
+        if let Some(f_uid) = father_uid {
+            self.send_children_update_and_status(f_uid);
+        }
+        if let Some(m_uid) = mother_uid {
+            self.send_children_update_and_status(m_uid);
+        }
+
+        Ok(())
+    }
+
+    fn send_children_update_and_status(&self, user_id: i32) {
+        let children_update =
+            format!(r#"{{"event":"children_update","user_id":{}}}"#, user_id);
+        self.base.broker.publish(children_update);
+
+        let update_status =
+            format!(r#"{{"event":"falukantUpdateStatus","user_id":{}}}"#, user_id);
+        self.base.broker.publish(update_status);
+    }
+
+    // Todes- und Erb-Logik
+    fn handle_character_death(&mut self, character_id: i32) -> Result<(), DbError> {
+        self.set_heir(character_id)?;
+
+        let death_event = format!(
+            r#"{{"event":"CharacterDeath","character_id":{}}}"#,
+            character_id
+        );
+        self.base.broker.publish(death_event);
+
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("delete_director", QUERY_DELETE_DIRECTOR)?;
+        conn.prepare("delete_relationship", QUERY_DELETE_RELATIONSHIP)?;
+        conn.prepare("delete_child_relation", QUERY_DELETE_CHILD_RELATION)?;
+        conn.prepare("delete_knowledge", QUERY_DELETE_KNOWLEDGE)?;
+        conn.prepare("delete_debtors_prism", QUERY_DELETE_DEBTORS_PRISM)?;
+        conn.prepare("delete_political_office", QUERY_DELETE_POLITICAL_OFFICE)?;
+        conn.prepare("delete_election_candidate", QUERY_DELETE_ELECTION_CANDIDATE)?;
+
+        conn.execute("delete_director", &[&character_id])?;
+        conn.execute("delete_relationship", &[&character_id])?;
+        conn.execute("delete_child_relation", &[&character_id])?;
+        conn.execute("delete_knowledge", &[&character_id])?;
+        conn.execute("delete_debtors_prism", &[&character_id])?;
+        conn.execute("delete_political_office", &[&character_id])?;
+        conn.execute("delete_election_candidate", &[&character_id])?;
+
+        // Character selbst löschen
+        conn.prepare(
+            "delete_character",
+            r#"DELETE FROM falukant_data.character WHERE id = $1"#,
+        )?;
+        conn.execute("delete_character", &[&character_id])?;
+
+        Ok(())
+    }
+
+    fn set_heir(&mut self, character_id: i32) -> Result<(), DbError> {
+        let falukant_user_id = self.get_falukant_user_id(character_id)?;
+        if falukant_user_id < 0 {
+            return Ok(());
+        }
+
+        let mut heir_id = self.get_heir_from_children(character_id)?;
+        let mut new_money = self.calculate_new_money(falukant_user_id, heir_id > 0)?;
+
+        if heir_id < 1 {
+            heir_id = self.get_random_heir(character_id)?;
+            new_money = self.calculate_new_money(falukant_user_id, heir_id > 0)?;
+        }
+
+        if heir_id > 0 {
+            self.set_new_character(falukant_user_id, heir_id)?;
+        }
+        self.set_new_money(falukant_user_id, new_money)?;
+
+        Ok(())
+    }
+
+    fn get_falukant_user_id(&mut self, character_id: i32) -> Result<i32, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("get_falukant_user_id", QUERY_GET_FALUKANT_USER_ID)?;
+        let rows = conn.execute("get_falukant_user_id", &[&character_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("user_id"))
+            .and_then(|v| v.parse::<i32>().ok())
+            .unwrap_or(-1))
+    }
+
+    fn get_heir_from_children(&mut self, deceased_character_id: i32) -> Result<i32, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("get_heir", QUERY_GET_HEIR)?;
+        let rows = conn.execute("get_heir", &[&deceased_character_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("child_character_id"))
+            .and_then(|v| v.parse::<i32>().ok())
+            .unwrap_or(-1))
+    }
+
+    fn get_random_heir(&mut self, deceased_character_id: i32) -> Result<i32, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("random_heir", QUERY_RANDOM_HEIR)?;
+        let rows = conn.execute("random_heir", &[&deceased_character_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("child_character_id"))
+            .and_then(|v| v.parse::<i32>().ok())
+            .unwrap_or(-1))
+    }
+
+    fn set_new_character(
+        &mut self,
+        falukant_user_id: i32,
+        heir_character_id: i32,
+    ) -> Result<(), DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("set_character_user", QUERY_SET_CHARACTER_USER)?;
+        conn.execute(
+            "set_character_user",
+            &[&falukant_user_id, &heir_character_id],
+        )?;
+        Ok(())
+    }
+
+    fn set_new_money(&mut self, falukant_user_id: i32, new_amount: f64) -> Result<(), DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("update_user_money", QUERY_UPDATE_USER_MONEY)?;
+        conn.execute("update_user_money", &[&new_amount, &falukant_user_id])?;
+        Ok(())
+    }
+
+    fn get_current_money(&mut self, falukant_user_id: i32) -> Result<f64, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("get_current_money", QUERY_GET_CURRENT_MONEY)?;
+        let rows = conn.execute("get_current_money", &[&falukant_user_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("sum"))
+            .and_then(|v| v.parse::<f64>().ok())
+            .unwrap_or(0.0))
+    }
+
+    fn get_house_value(&mut self, falukant_user_id: i32) -> Result<f64, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+          conn.prepare("house_value", QUERY_GET_HOUSE_VALUE)?;
+        let rows = conn.execute("house_value", &[&falukant_user_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("sum"))
+            .and_then(|v| v.parse::<f64>().ok())
+            .unwrap_or(0.0))
+    }
+
+    fn get_settlement_value(&mut self, falukant_user_id: i32) -> Result<f64, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+          conn.prepare("settlement_value", QUERY_GET_SETTLEMENT_VALUE)?;
+        let rows = conn.execute("settlement_value", &[&falukant_user_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("sum"))
+            .and_then(|v| v.parse::<f64>().ok())
+            .unwrap_or(0.0))
+    }
+
+    fn get_inventory_value(&mut self, falukant_user_id: i32) -> Result<f64, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+          conn.prepare("inventory_value", QUERY_GET_INVENTORY_VALUE)?;
+        let rows = conn.execute("inventory_value", &[&falukant_user_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("sum"))
+            .and_then(|v| v.parse::<f64>().ok())
+            .unwrap_or(0.0))
+    }
+
+    fn get_credit_debt(&mut self, falukant_user_id: i32) -> Result<f64, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+          conn.prepare("credit_debt", QUERY_GET_CREDIT_DEBT)?;
+        let rows = conn.execute("credit_debt", &[&falukant_user_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("sum"))
+            .and_then(|v| v.parse::<f64>().ok())
+            .unwrap_or(0.0))
+    }
+
+    fn get_child_count(&mut self, deceased_user_id: i32) -> Result<i32, DbError> {
+        let mut conn = self
+            .base
+            .pool
+            .get()
+            .map_err(|e| DbError::new(format!("DB-Verbindung fehlgeschlagen: {e}")))?;
+
+        conn.prepare("count_children", QUERY_COUNT_CHILDREN)?;
+        let rows = conn.execute("count_children", &[&deceased_user_id])?;
+
+        Ok(rows
+            .first()
+            .and_then(|r| r.get("cnt"))
+            .and_then(|v| v.parse::<i32>().ok())
+            .unwrap_or(0))
+    }
+
+    fn calculate_new_money(
+        &mut self,
+        falukant_user_id: i32,
+        has_heir: bool,
+    ) -> Result<f64, DbError> {
+        if !has_heir {
+            return Ok(800.0);
+        }
+
+        let cash = self.get_current_money(falukant_user_id)?;
+        let houses = self.get_house_value(falukant_user_id)?;
+        let settlements = self.get_settlement_value(falukant_user_id)?;
+        let inventory = self.get_inventory_value(falukant_user_id)?;
+        let debt = self.get_credit_debt(falukant_user_id)?;
+
+        let total_assets = cash + houses + settlements + inventory - debt;
+        let child_count = self.get_child_count(falukant_user_id)?;
+        let single = child_count <= 1;
+
+        let heir_share = if single {
+            total_assets
+        } else {
+            total_assets * 0.8
+        };
+
+        let net = heir_share - (houses + settlements + inventory + debt);
+        if net <= 1000.0 {
+            Ok(1000.0)
+        } else {
+            Ok(net)
+        }
+    }
+}
+
+/// Kleine Hilfsfunktionen für robustes Parsen aus `Row`.
+fn parse_i32(row: &crate::db::Row, key: &str, default: i32) -> i32 {
+    row.get(key)
+        .and_then(|v| v.parse::<i32>().ok())
+        .unwrap_or(default)
+}
+
+fn parse_opt_i32(row: &crate::db::Row, key: &str) -> Option<i32> {
+    row.get(key).and_then(|v| v.parse::<i32>().ok())
+}
+
+#[derive(Debug, Clone)]
+struct Credit {
+    amount: f64,
+    remaining_amount: f64,
+    interest_rate: i32,
+    user_id: i32,
+    money: f64,
+    character_id: i32,
+    prism_started_previously: bool,
+}
+
+impl Worker for UserCharacterWorker {
+    fn start_worker_thread(&mut self) {
+        let pool = self.base.pool.clone();
+        let broker = self.base.broker.clone();
+
+        self.base
+            .start_worker_with_loop(move |state: Arc<WorkerState>| {
+                let mut worker = UserCharacterWorker::new(pool.clone(), broker.clone());
+                while state.running_worker.load(Ordering::Relaxed) {
+                    worker.run_iteration(&state);
+                }
+            });
+    }
+
+    fn stop_worker_thread(&mut self) {
+        self.base.stop_worker();
+    }
+
+    fn enable_watchdog(&mut self) {
+        self.base.start_watchdog();
+    }
+}
+
+