Füge UndergroundWorker hinzu und implementiere Logik für unterirdische Aufgaben. Aktualisiere CMakeLists.txt, um neue Quell- und Header-Dateien einzuschließen. Verbessere die Fehlerbehandlung in der Datenbank und sende Benachrichtigungen nach bestimmten Ereignissen. Integriere Hilfsfunktionen zur sicheren Verarbeitung von Daten.

src/character_creation_worker.cpp

@@ -186,6 +186,14 @@ void CharacterCreationWorker::notifyUser(int userId, const std::string &eventTyp
         db.prepare("insert_notification", QUERY_INSERT_NOTIFICATION);
         db.execute("insert_notification", { std::to_string(userId) });
 
+        // Sende falukantUpdateStatus nach dem Einfügen der Benachrichtigung
+        nlohmann::json updateMessage = {
+            {"event", "falukantUpdateStatus"},
+            {"user_id", userId}
+        };
+        broker.publish(updateMessage.dump());
+
+        // Sende auch die ursprüngliche Benachrichtigung
         nlohmann::json message = {
             {"event", eventType},
             {"user_id", userId}

src/database.cpp

@@ -46,6 +46,14 @@ Database::query(const std::string &sql)
 void Database::prepare(const std::string &stmtName, const std::string &sql)
 {
     try {
+        // Versuche zuerst, das alte Statement zu entfernen, falls es existiert
+        try {
+            remove(stmtName);
+        } catch (...) {
+            // Ignoriere Fehler beim Entfernen - das Statement existiert möglicherweise nicht
+        }
+        
+        // Erstelle das neue Statement
         pqxx::work txn(*connection_);
         txn.conn().prepare(stmtName, sql);
         txn.commit();
@@ -55,31 +63,38 @@ void Database::prepare(const std::string &stmtName, const std::string &sql)
     }
 }
 
-Database::FieldList Database::execute(const std::string &stmtName, const std::vector<std::string> &params) {
-    std::vector<std::unordered_map<std::string, std::string>> rows;
+Database::FieldList Database::execute(const std::string& stmtName,
+                                      const std::vector<std::string>& params)
+{
     try {
         pqxx::work txn(*connection_);
-        pqxx::prepare::invocation inv = txn.prepared(stmtName);
-        for (auto &p : params) {
-            inv(p);
-        }
-        pqxx::result r = inv.exec();
-        txn.commit();
-        for (const auto &row : r) {
-            std::unordered_map<std::string, std::string> mapRow;
-            for (pqxx::row::size_type i = 0; i < row.size(); ++i) {
-                std::string colName = r.column_name(i);
-                mapRow[colName] = row[i].c_str() ? row[i].c_str() : "";
-            }
-            rows.push_back(std::move(mapRow));
-        }
-    } 
-    catch (const std::exception &ex) {
-        std::cerr << "[Database] execute-Fehler: " << ex.what()
-                  << "\nStatement: " << stmtName << std::endl;
-    }
 
-    return rows;
+        pqxx::result res;
+        if (params.empty()) {
+            res = txn.exec_prepared(stmtName);
+        } else {
+            pqxx::params p;
+            for (const auto& v : params) p.append(v);
+            res = txn.exec_prepared(stmtName, p);
+        }
+
+        FieldList out;
+        out.reserve(res.size());
+        for (const auto& row : res) {
+            std::unordered_map<std::string, std::string> m;
+            for (const auto& f : row) {
+                m.emplace(f.name(), f.is_null() ? std::string{} : std::string(f.c_str()));
+            }
+            out.emplace_back(std::move(m));
+        }
+
+        txn.commit();
+        return out;
+    } catch (const std::exception& e) {
+        std::cerr << "[Database] execute-Fehler: " << e.what()
+                  << "\n\nStatement: " << stmtName << std::endl;
+        return {};
+    }
 }
 
 void Database::remove(const std::string &stmtName) {

src/main.cpp

@@ -9,6 +9,7 @@
 #include "usercharacterworker.h"
 #include "houseworker.h"
 #include "politics_worker.h"
+#include "underground_worker.h"
 #include "config.h"
 #include <csignal>
 #include <atomic>
@@ -52,6 +53,7 @@ int main() {
         workers.push_back(std::make_unique<UserCharacterWorker>(pool, broker));
         workers.push_back(std::make_unique<HouseWorker>(pool, broker));
         workers.push_back(std::make_unique<PoliticsWorker>(pool, broker));
+        workers.push_back(std::make_unique<UndergroundWorker>(pool, broker));
         websocketServer.setWorkers(workers);
 
         broker.start();

src/politics_worker.cpp

@@ -180,6 +180,15 @@ void PoliticsWorker::notifyOfficeExpirations() {
     signalActivity();
     db.execute("NOTIFY_OFFICE_EXPIRATION");
     signalActivity();
+    
+    // Sende falukantUpdateStatus an alle betroffenen Benutzer
+    db.prepare("GET_USERS_WITH_EXPIRING_OFFICES", QUERY_GET_USERS_WITH_EXPIRING_OFFICES);
+    const auto affectedUsers = db.execute("GET_USERS_WITH_EXPIRING_OFFICES");
+    for (const auto &user : affectedUsers) {
+        int userId = std::stoi(user.at("user_id"));
+        nlohmann::json message = { { "event", "falukantUpdateStatus" } };
+        sendMessageToFalukantUsers(userId, message);
+    }
 }
 
 void PoliticsWorker::notifyElectionCreated(const std::vector<std::pair<int,int>>& elections) {
@@ -192,6 +201,15 @@ void PoliticsWorker::notifyElectionCreated(const std::vector<std::pair<int,int>>
         db.execute("NOTIFY_ELECTION_CREATED", { std::to_string(pr.first) });
         signalActivity();
     }
+    
+    // Sende falukantUpdateStatus an alle betroffenen Benutzer
+    db.prepare("GET_USERS_IN_REGIONS_WITH_ELECTIONS", QUERY_GET_USERS_IN_REGIONS_WITH_ELECTIONS);
+    const auto affectedUsers = db.execute("GET_USERS_IN_REGIONS_WITH_ELECTIONS");
+    for (const auto &user : affectedUsers) {
+        int userId = std::stoi(user.at("user_id"));
+        nlohmann::json message = { { "event", "falukantUpdateStatus" } };
+        sendMessageToFalukantUsers(userId, message);
+    }
 }
 
 void PoliticsWorker::notifyOfficeFilled(const std::vector<std::tuple<int,int,int,int>>& newOffices) {
@@ -205,6 +223,15 @@ void PoliticsWorker::notifyOfficeFilled(const std::vector<std::tuple<int,int,int
         db.execute("NOTIFY_OFFICE_FILLED", { std::to_string(characterId) });
         signalActivity();
     }
+    
+    // Sende falukantUpdateStatus an alle betroffenen Benutzer
+    db.prepare("GET_USERS_WITH_FILLED_OFFICES", QUERY_GET_USERS_WITH_FILLED_OFFICES);
+    const auto affectedUsers = db.execute("GET_USERS_WITH_FILLED_OFFICES");
+    for (const auto &user : affectedUsers) {
+        int userId = std::stoi(user.at("user_id"));
+        nlohmann::json message = { { "event", "falukantUpdateStatus" } };
+        sendMessageToFalukantUsers(userId, message);
+    }
 }
 
 std::vector<std::tuple<int,int,int,int>> PoliticsWorker::processElections() {

src/politics_worker.h

@@ -451,6 +451,59 @@ private:
             ($1, 'notify_office_filled', NOW(), NOW());
     )";
 
+    // ------------------------------------------------------------
+    // QUERY: Hole alle Benutzer, deren Amt in 2 Tagen abläuft
+    // ------------------------------------------------------------
+    static constexpr const char* QUERY_GET_USERS_WITH_EXPIRING_OFFICES = R"(
+        SELECT DISTINCT
+            ch.user_id
+        FROM
+            falukant_data.political_office AS po
+        JOIN
+            falukant_type.political_office_type AS pot
+          ON po.office_type_id = pot.id
+        JOIN
+            falukant_data."character" AS ch
+          ON po.character_id = ch.id
+        WHERE
+            ch.user_id IS NOT NULL
+            AND (po.created_at + (pot.term_length * INTERVAL '1 day'))
+                BETWEEN (NOW() + INTERVAL '2 days')
+                    AND (NOW() + INTERVAL '2 days' + INTERVAL '1 second');
+    )";
+
+    // ------------------------------------------------------------
+    // QUERY: Hole alle Benutzer in Regionen mit neuen Wahlen
+    // ------------------------------------------------------------
+    static constexpr const char* QUERY_GET_USERS_IN_REGIONS_WITH_ELECTIONS = R"(
+        SELECT DISTINCT
+            ch.user_id
+        FROM
+            falukant_data.election AS e
+        JOIN
+            falukant_data."character" AS ch
+          ON ch.region_id = e.region_id
+        WHERE
+            ch.user_id IS NOT NULL
+            AND e."date" >= NOW() - INTERVAL '1 day';
+    )";
+
+    // ------------------------------------------------------------
+    // QUERY: Hole alle Benutzer, deren Amt neu besetzt wurde
+    // ------------------------------------------------------------
+    static constexpr const char* QUERY_GET_USERS_WITH_FILLED_OFFICES = R"(
+        SELECT DISTINCT
+            ch.user_id
+        FROM
+            falukant_data.political_office AS po
+        JOIN
+            falukant_data."character" AS ch
+          ON po.character_id = ch.id
+        WHERE
+            ch.user_id IS NOT NULL
+            AND po.created_at >= NOW() - INTERVAL '1 minute';
+    )";
+
     static constexpr const char* QUERY_PROCESS_ELECTIONS = R"(
         SELECT office_id, office_type_id, character_id, region_id
         FROM falukant_data.process_elections();

src/produce_worker.cpp

@@ -120,6 +120,14 @@ bool ProduceWorker::addToInventory(Database &db,
             {"value", remainingQuantity}
         };
         db.execute("QUERY_ADD_OVERPRODUCTION_NOTIFICATION", {std::to_string(userId), notification.dump()});
+        
+        // Sende falukantUpdateStatus nach dem Einfügen der Benachrichtigung
+        nlohmann::json updateMessage = {
+            {"event", "falukantUpdateStatus"},
+            {"user_id", userId}
+        };
+        broker.publish(updateMessage.dump());
+        
         return true;
     } catch (const std::exception &e) {
         std::cerr << "[ProduceWorker] Fehler in addToInventory: " << e.what() << std::endl;

src/underground_worker.cpp

@@ -0,0 +1,445 @@
+#include "underground_worker.h"
+#include <random>
+#include <algorithm>
+#include <numeric>
+#include <chrono>
+#include <thread>
+
+using json = nlohmann::json;
+
+UndergroundWorker::~UndergroundWorker() = default;
+
+static std::mt19937& rng() {
+    static thread_local std::mt19937 g{std::random_device{}()};
+    return g;
+}
+
+int UndergroundWorker::randomInt(int lo,int hi){
+    std::uniform_int_distribution<int> d(lo,hi);
+    return d(rng());
+}
+
+long long UndergroundWorker::randomLL(long long lo,long long hi){
+    std::uniform_int_distribution<long long> d(lo,hi);
+    return d(rng());
+}
+
+std::vector<size_t> UndergroundWorker::randomIndices(size_t n,size_t k){
+    std::vector<size_t> idx(n);
+    std::iota(idx.begin(),idx.end(),0);
+    std::shuffle(idx.begin(),idx.end(),rng());
+    if(k<idx.size()) idx.resize(k);
+    return idx;
+}
+
+void UndergroundWorker::run(){
+    using namespace std::chrono;
+    while(runningWorker){
+        setCurrentStep("Process underground jobs");
+        signalActivity();
+        tick();
+        setCurrentStep("Idle");
+        for(int i=0;i<60 && runningWorker;++i){
+            std::this_thread::sleep_for(seconds(1));
+            signalActivity();
+        }
+    }
+}
+
+void UndergroundWorker::tick(){
+    setCurrentStep("Fetch pending underground jobs");
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_PENDING",Q_SELECT_PENDING);
+    db.prepare("UG_UPDATE_RESULT",Q_UPDATE_RESULT);
+    const auto rows=db.execute("UG_SELECT_PENDING");
+    for(const auto& r:rows){
+        try{
+            auto res=executeRow(r);
+            int id=std::stoi(r.at("id"));
+            updateResult(id,res);
+            broker.publish(json{{"event","underground_processed"},{"id",id},{"type",r.at("underground_type")}}.dump());
+        }catch(const std::exception& e){
+            try{
+                int id=std::stoi(r.at("id"));
+                updateResult(id,json{{"status","error"},{"message",e.what()}});
+            }catch(...){}
+        }
+    }
+}
+
+std::vector<UndergroundWorker::Row> UndergroundWorker::fetchPending(){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_PENDING",Q_SELECT_PENDING);
+    return db.execute("UG_SELECT_PENDING");
+}
+
+nlohmann::json UndergroundWorker::executeRow(const Row& r){
+    int performerId=std::stoi(r.at("performer_id"));
+    int victimId=std::stoi(r.at("victim_id"));
+    std::string type=r.at("underground_type");
+    std::string params=r.at("parameters");
+    return handleTask(type,performerId,victimId,params);
+}
+
+nlohmann::json UndergroundWorker::handleTask(const std::string& type,int performerId,int victimId,const std::string& paramsJson){
+    json p; try{ p=json::parse(paramsJson);} catch(...){ p=json::object(); }
+    if(type=="spyin")              return spyIn(performerId,victimId,p);
+    if(type=="assassin")           return assassin(performerId,victimId,p);
+    if(type=="sabotage")           return sabotage(performerId,victimId,p);
+    if(type=="corrupt_politician") return corruptPolitician(performerId,victimId,p);
+    if(type=="rob")                return rob(performerId,victimId,p);
+    return {{"status","unknown_type"},{"type",type}};
+}
+
+nlohmann::json UndergroundWorker::spyIn(int performerId,int victimId,const json& p){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_BY_PERFORMER",Q_SELECT_BY_PERFORMER);
+    const auto rows = db.execute("UG_SELECT_BY_PERFORMER",{ std::to_string(victimId) });
+
+    json activities = json::array();
+    for(const auto& r : rows){
+        json params = json::object();
+        try{ params = json::parse(r.at("parameters")); }catch(...){}
+        json result = nullptr;
+        auto it = r.find("result_text");
+        if(it != r.end()){
+            try{ result = json::parse(it->second); }catch(...){}
+        }
+        std::string status = "pending";
+        if(result.is_object()){
+            if(auto s = result.find("status"); s!=result.end() && s->is_string()) status = *s;
+            else status = "done";
+        }
+        activities.push_back({
+            {"id",            std::stoi(r.at("id"))},
+            {"type",          r.at("underground_type")},
+            {"performed_by",  std::stoi(r.at("performer_id"))},
+            {"victim_id",     std::stoi(r.at("victim_id"))},
+            {"created_at",    r.at("created_at")},
+            {"parameters",    params},
+            {"result",        result},
+            {"status",        status}
+        });
+    }
+    return {
+        {"status","success"},
+        {"action","spyin"},
+        {"performer_id", performerId},
+        {"victim_id",    victimId},
+        {"details",      p},
+        {"victim_illegal_activity_count", activities.size()},
+        {"victim_illegal_activities",     activities}
+    };
+}
+
+nlohmann::json UndergroundWorker::assassin(int performerId,int victimId,const json& p){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_CHAR_HEALTH",Q_SELECT_CHAR_HEALTH);
+    db.prepare("UG_UPDATE_CHAR_HEALTH",Q_UPDATE_CHAR_HEALTH);
+    const auto rows=db.execute("UG_SELECT_CHAR_HEALTH",{std::to_string(victimId)});
+    if(rows.empty()) return {{"status","error"},{"action","assassin"},{"performer_id",performerId},{"victim_id",victimId},{"message","victim_not_found"},{"details",p}};
+    int current=std::stoi(rows.front().at("health"));
+    std::uniform_int_distribution<int> dist(0,current);
+    int new_health=dist(rng());
+    db.execute("UG_UPDATE_CHAR_HEALTH",{std::to_string(victimId),std::to_string(new_health)});
+    return {{"status","success"},{"action","assassin"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"previous_health",current},{"new_health",new_health},{"reduced_by",current-new_health}};
+}
+
+nlohmann::json UndergroundWorker::sabotage(int performerId,int victimId,const json& p){
+    const auto target=p.value("target",std::string{});
+    if(target=="house")   return sabotageHouse(performerId,victimId,p);
+    if(target=="storage") return sabotageStorage(performerId,victimId,p);
+    return {{"status","error"},{"action","sabotage"},{"message","unknown_target"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+}
+
+int UndergroundWorker::getUserIdForCharacter(int characterId){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_CHAR_USER",Q_SELECT_CHAR_USER);
+    const auto r=db.execute("UG_SELECT_CHAR_USER",{std::to_string(characterId)});
+    if(r.empty()) return -1;
+    return std::stoi(r.front().at("user_id"));
+}
+
+std::optional<UndergroundWorker::HouseConditions> UndergroundWorker::getHouseByUser(int userId){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_HOUSE_BY_USER",Q_SELECT_HOUSE_BY_USER);
+    const auto r=db.execute("UG_SELECT_HOUSE_BY_USER",{std::to_string(userId)});
+    if(r.empty()) return std::nullopt;
+    HouseConditions h{
+        std::stoi(r.front().at("id")),
+        std::stoi(r.front().at("roof_condition")),
+        std::stoi(r.front().at("floor_condition")),
+        std::stoi(r.front().at("wall_condition")),
+        std::stoi(r.front().at("window_condition"))
+    };
+    return h;
+}
+
+void UndergroundWorker::updateHouse(const HouseConditions& h){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_UPDATE_HOUSE",Q_UPDATE_HOUSE);
+    db.execute("UG_UPDATE_HOUSE",{
+        std::to_string(h.id),
+        std::to_string(std::clamp(h.roof,0,100)),
+        std::to_string(std::clamp(h.floor,0,100)),
+        std::to_string(std::clamp(h.wall,0,100)),
+        std::to_string(std::clamp(h.windowc,0,100))
+    });
+}
+
+nlohmann::json UndergroundWorker::sabotageHouse(int performerId,int victimId,const json& p){
+    int userId=getUserIdForCharacter(victimId);
+    if(userId<0) return {{"status","error"},{"action","sabotage"},{"target","house"},{"message","victim_not_found"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+    auto hopt=getHouseByUser(userId);
+    if(!hopt) return {{"status","error"},{"action","sabotage"},{"target","house"},{"message","house_not_found"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+    auto h=*hopt;
+
+    std::vector<std::string> allow;
+    if(p.contains("conditions") && p["conditions"].is_array())
+        for(const auto& s:p["conditions"]) if(s.is_string()) allow.push_back(s.get<std::string>());
+
+    std::vector<std::pair<std::string,int*>> fields={
+        {"roof_condition",&h.roof},
+        {"floor_condition",&h.floor},
+        {"wall_condition",&h.wall},
+        {"window_condition",&h.windowc}
+    };
+    std::vector<std::pair<std::string,int*>> pool;
+    for(auto& f:fields) if(allow.empty() || std::find(allow.begin(),allow.end(),f.first)!=allow.end()) pool.push_back(f);
+    if(pool.empty()) return {{"status","error"},{"action","sabotage"},{"target","house"},{"message","no_conditions_selected"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+
+    size_t k=static_cast<size_t>(randomInt(1,(int)pool.size()));
+    std::vector<size_t> picks=randomIndices(pool.size(),k);
+
+    json changed=json::array();
+    for(size_t i: picks){
+        int& cur=*pool[i].second;
+        if(cur>0){
+            int red=randomInt(1,cur);
+            cur=std::clamp(cur-red,0,100);
+        }
+        changed.push_back(pool[i].first);
+    }
+
+    updateHouse(h);
+    return {
+        {"status","success"},
+        {"action","sabotage"},
+        {"target","house"},
+        {"performer_id",performerId},
+        {"victim_id",victimId},
+        {"details",p},
+        {"changed_conditions",changed},
+        {"new_conditions",{
+            {"roof_condition",h.roof},
+            {"floor_condition",h.floor},
+            {"wall_condition",h.wall},
+            {"window_condition",h.windowc}
+        }}
+    };
+}
+
+std::vector<UndergroundWorker::Row> UndergroundWorker::selectStockByBranch(int branchId){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_STOCK_BY_BRANCH",Q_SELECT_STOCK_BY_BRANCH);
+    return db.execute("UG_SELECT_STOCK_BY_BRANCH",{std::to_string(branchId)});
+}
+
+std::vector<UndergroundWorker::Row> UndergroundWorker::filterByStockTypes(const std::vector<Row>& rows,const std::vector<int>& allowed){
+    if(allowed.empty()) return rows;
+    std::vector<Row> out;
+    out.reserve(rows.size());
+    for(const auto& r:rows){
+        int t=std::stoi(r.at("stock_type_id"));
+        if(std::find(allowed.begin(),allowed.end(),t)!=allowed.end()) out.push_back(r);
+    }
+    return out;
+}
+
+void UndergroundWorker::updateStockQty(int id,long long qty){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_UPDATE_STOCK_QTY",Q_UPDATE_STOCK_QTY);
+    db.execute("UG_UPDATE_STOCK_QTY",{std::to_string(id),std::to_string(qty)});
+}
+
+nlohmann::json UndergroundWorker::sabotageStorage(int performerId,int victimId,const json& p){
+    if(!p.contains("branch_id") || !p["branch_id"].is_number_integer())
+        return {{"status","error"},{"action","sabotage"},{"target","storage"},{"message","branch_id_required"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+    int branchId=p["branch_id"].get<int>();
+
+    std::vector<int> allowed;
+    if(p.contains("stock_type_ids") && p["stock_type_ids"].is_array())
+        for(const auto& v:p["stock_type_ids"]) if(v.is_number_integer()) allowed.push_back(v.get<int>());
+
+    auto rows=filterByStockTypes(selectStockByBranch(branchId),allowed);
+    if(rows.empty()) return {{"status","success"},{"action","sabotage"},{"target","storage"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"removed_total",0},{"affected_rows",json::array()}};
+
+    long long total=0;
+    for(const auto& r:rows) total+=std::stoll(r.at("quantity"));
+    if(total<=0) return {{"status","success"},{"action","sabotage"},{"target","storage"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"removed_total",0},{"affected_rows",json::array()}};
+
+    long long cap=total/4;
+    if(cap<=0) return {{"status","success"},{"action","sabotage"},{"target","storage"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"removed_total",0},{"affected_rows",json::array()}};
+
+    long long to_remove=randomLL(1,cap);
+    std::shuffle(rows.begin(),rows.end(),rng());
+
+    json affected=json::array();
+    for(const auto& r:rows){
+        if(to_remove==0) break;
+        int id=std::stoi(r.at("id"));
+        long long q=std::stoll(r.at("quantity"));
+        if(q<=0) continue;
+        long long take=randomLL(1,std::min(q,to_remove));
+        long long newq=q-take;
+        updateStockQty(id,newq);
+        to_remove-=take;
+        affected.push_back({{"id",id},{"stock_type_id",std::stoi(r.at("stock_type_id"))},{"previous_quantity",q},{"new_quantity",newq},{"removed",take}});
+    }
+
+    long long removed=0;
+    for(const auto& a:affected) removed+=a.at("removed").get<long long>();
+
+    return {
+        {"status","success"},
+        {"action","sabotage"},
+        {"target","storage"},
+        {"performer_id",performerId},
+        {"victim_id",victimId},
+        {"details",p},
+        {"removed_total",removed},
+        {"affected_rows",affected}
+    };
+}
+
+nlohmann::json UndergroundWorker::corruptPolitician(int performerId,int victimId,const json& p){
+    return {{"status","success"},{"action","corrupt_politician"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+}
+
+nlohmann::json UndergroundWorker::rob(int performerId,int victimId,const json& p){
+    int userId=getUserIdForCharacter(victimId);
+    if(userId<0) return {{"status","error"},{"action","rob"},{"message","victim_not_found"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_SELECT_FALUKANT_USER",Q_SELECT_FALUKANT_USER);
+    const auto fu=db.execute("UG_SELECT_FALUKANT_USER",{std::to_string(userId)});
+    if(fu.empty()) return {{"status","error"},{"action","rob"},{"message","falukant_user_not_found"},{"performer_id",performerId},{"victim_id",victimId},{"details",p}};
+
+    int falukantUserId=std::stoi(fu.front().at("id"));
+    double money=std::stod(fu.front().at("money"));
+    int defaultBranch=std::stoi(fu.front().at("main_branch_region_id"));
+
+    bool stealGoods = (randomInt(0,1)==1);
+    if(stealGoods){
+        int branchId = p.contains("branch_id") && p["branch_id"].is_number_integer()
+                       ? p["branch_id"].get<int>()
+                       : defaultBranch;
+
+        if(branchId<=0){
+            return {{"status","success"},{"action","rob"},{"mode","goods"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"removed_total",0},{"affected_rows",json::array()}};
+        }
+
+        auto rows = selectStockByBranch(branchId);
+        if(rows.empty()){
+            return {{"status","success"},{"action","rob"},{"mode","goods"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"removed_total",0},{"affected_rows",json::array()}};
+        }
+
+        long long total=0;
+        for(const auto& r:rows) total+=std::stoll(r.at("quantity"));
+        if(total<=0){
+            return {{"status","success"},{"action","rob"},{"mode","goods"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"removed_total",0},{"affected_rows",json::array()}};
+        }
+
+        long long cap = std::max<long long>(1, total/2);
+        long long to_remove = randomLL(1, cap);
+
+        std::shuffle(rows.begin(),rows.end(),rng());
+        json affected = json::array();
+        for(const auto& r:rows){
+            if(to_remove==0) break;
+            int id=std::stoi(r.at("id"));
+            long long q=std::stoll(r.at("quantity"));
+            if(q<=0) continue;
+            long long take=randomLL(1,std::min(q,to_remove));
+            long long newq=q-take;
+            updateStockQty(id,newq);
+            to_remove-=take;
+            affected.push_back({
+                {"id",id},
+                {"stock_type_id",std::stoi(r.at("stock_type_id"))},
+                {"previous_quantity",q},
+                {"new_quantity",newq},
+                {"removed",take}
+            });
+        }
+
+        long long removed=0;
+        for(const auto& a:affected) removed+=a.at("removed").get<long long>();
+
+        return {
+            {"status","success"},
+            {"action","rob"},
+            {"mode","goods"},
+            {"performer_id",performerId},
+            {"victim_id",victimId},
+            {"details",p},
+            {"removed_total",removed},
+            {"affected_rows",affected}
+        };
+    } else {
+        if(money<=0.0){
+            return {{"status","success"},{"action","rob"},{"mode","money"},{"performer_id",performerId},{"victim_id",victimId},{"details",p},{"stolen",0.0},{"balance_before",0.0},{"balance_after",0.0}};
+        }
+
+        double rate = randomDouble(0.0,0.18);
+        double amount = std::floor(money * rate * 100.0 + 0.5) / 100.0;
+        if(amount < 0.01) amount = 0.01;
+        if(amount > money) amount = money;
+
+        json msg = {
+            {"event","money_changed"},
+            {"reason","robbery"},
+            {"delta",-amount},
+            {"performer_id",performerId},
+            {"victim_id",victimId}
+        };
+        changeFalukantUserMoney(falukantUserId, -amount, "robbery", msg);
+
+        double after = std::floor((money - amount) * 100.0 + 0.5)/100.0;
+
+        return {
+            {"status","success"},
+            {"action","rob"},
+            {"mode","money"},
+            {"performer_id",performerId},
+            {"victim_id",victimId},
+            {"details",p},
+            {"stolen",amount},
+            {"rate",rate},
+            {"balance_before",money},
+            {"balance_after",after}
+        };
+    }
+}
+
+void UndergroundWorker::updateResult(int id,const nlohmann::json& result){
+    ConnectionGuard g(pool);
+    auto& db=g.get();
+    db.prepare("UG_UPDATE_RESULT",Q_UPDATE_RESULT);
+    db.execute("UG_UPDATE_RESULT",{std::to_string(id),result.dump()});
+}
+
+double UndergroundWorker::randomDouble(double lo,double hi){
+    std::uniform_real_distribution<double> d(lo,hi);
+    return d(rng());
+}

src/underground_worker.h

@@ -0,0 +1,101 @@
+#pragma once
+#include <unordered_map>
+#include <optional>
+#include <nlohmann/json.hpp>
+#include "worker.h"
+
+class UndergroundWorker final: public Worker{
+    using Row = std::unordered_map<std::string,std::string>;
+    struct HouseConditions { int id; int roof; int floor; int wall; int windowc; };
+public:
+    UndergroundWorker(ConnectionPool& pool,MessageBroker& broker):Worker(pool,broker,"UndergroundWorker"){}
+    ~UndergroundWorker() override;
+
+protected:
+    void run() override;
+
+private:
+    void tick();
+    std::vector<Row> fetchPending();
+    nlohmann::json executeRow(const Row& r);
+    nlohmann::json handleTask(const std::string& type,int performerId,int victimId,const std::string& paramsJson);
+    nlohmann::json spyIn(int performerId,int victimId,const nlohmann::json& p);
+    nlohmann::json assassin(int performerId,int victimId,const nlohmann::json& p);
+    nlohmann::json sabotage(int performerId,int victimId,const nlohmann::json& p);
+    nlohmann::json corruptPolitician(int performerId,int victimId,const nlohmann::json& p);
+    nlohmann::json rob(int performerId,int victimId,const nlohmann::json& p);
+    void updateResult(int id,const nlohmann::json& result);
+
+    nlohmann::json sabotageHouse(int performerId,int victimId,const nlohmann::json& p);
+    nlohmann::json sabotageStorage(int performerId,int victimId,const nlohmann::json& p);
+
+    int getUserIdForCharacter(int characterId);
+    std::optional<HouseConditions> getHouseByUser(int userId);
+    void updateHouse(const HouseConditions& h);
+    std::vector<Row> selectStockByBranch(int branchId);
+    std::vector<Row> filterByStockTypes(const std::vector<Row>& rows,const std::vector<int>& allowed);
+    void updateStockQty(int id,long long qty);
+    static int randomInt(int lo,int hi);
+    static long long randomLL(long long lo,long long hi);
+    static std::vector<size_t> randomIndices(size_t n,size_t k);
+    static double randomDouble(double lo,double hi);
+
+private:
+    static constexpr const char* Q_SELECT_BY_PERFORMER=R"SQL(
+        SELECT u.id, t.tr AS underground_type, u.performer_id, u.victim_id,
+               to_char(u.created_at,'YYYY-MM-DD"T"HH24:MI:SS"Z"') AS created_at,
+               COALESCE(u.parameters::text,'{}') AS parameters,
+               COALESCE(u.result::text,'null')   AS result_text
+        FROM falukant_data.underground u
+        JOIN falukant_type.underground t ON t.tr=u.underground_type_id
+        WHERE u.performer_id=$1
+        ORDER BY u.created_at DESC
+    )SQL";
+    static constexpr const char* Q_SELECT_PENDING=R"SQL(
+        SELECT u.id,t.tr AS underground_type,u.performer_id,u.victim_id,COALESCE(u.parameters::text,'{}') AS parameters
+        FROM falukant_data.underground u
+        JOIN falukant_type.underground t ON t.tr=u.underground_type_id
+        WHERE u.result IS NULL AND u.created_at<=NOW()-INTERVAL '1 day'
+        ORDER BY u.created_at ASC
+        LIMIT 200
+    )SQL";
+    static constexpr const char* Q_UPDATE_RESULT=R"SQL(
+        UPDATE falukant_data.underground SET result=$2::jsonb,updated_at=NOW() WHERE id=$1
+    )SQL";
+    static constexpr const char* Q_SELECT_CHAR_USER=R"SQL(
+        SELECT user_id FROM falukant_data."character" WHERE id=$1
+    )SQL";
+    static constexpr const char* Q_SELECT_HOUSE_BY_USER=R"SQL(
+        SELECT id, roof_condition, floor_condition, wall_condition, window_condition
+        FROM falukant_data.user_house
+        WHERE user_id=$1
+        LIMIT 1
+    )SQL";
+    static constexpr const char* Q_UPDATE_HOUSE=R"SQL(
+        UPDATE falukant_data.user_house
+        SET roof_condition=$2, floor_condition=$3, wall_condition=$4, window_condition=$5
+        WHERE id=$1
+    )SQL";
+    static constexpr const char* Q_SELECT_STOCK_BY_BRANCH=R"SQL(
+        SELECT id, stock_type_id, quantity
+        FROM falukant_data.stock
+        WHERE branch_id=$1
+        ORDER BY quantity DESC
+    )SQL";
+    static constexpr const char* Q_UPDATE_STOCK_QTY=R"SQL(
+        UPDATE falukant_data.stock SET quantity=$2 WHERE id=$1
+    )SQL";
+    static constexpr const char* Q_SELECT_CHAR_HEALTH=R"SQL(
+        SELECT health FROM falukant_data."character" WHERE id=$1
+    )SQL";
+    static constexpr const char* Q_UPDATE_CHAR_HEALTH=R"SQL(
+        UPDATE falukant_data."character" SET health=$2, updated_at=NOW() WHERE id=$1
+    )SQL";
+    static constexpr const char* Q_SELECT_FALUKANT_USER=R"SQL(
+        SELECT id, money, COALESCE(main_branch_region_id,0) AS main_branch_region_id
+        FROM falukant_data.falukant_user
+        WHERE user_id=$1
+        LIMIT 1
+    )SQL";
+
+};

src/usercharacterworker.cpp

@@ -5,6 +5,7 @@
 #include <thread>
 #include <vector>
 #include <cmath>
+#include "utils.h"
 
 UserCharacterWorker::UserCharacterWorker(ConnectionPool &pool, MessageBroker &broker)
     : Worker(pool, broker, "UserCharacterWorker"),
@@ -17,8 +18,11 @@ void UserCharacterWorker::run() {
 
     auto lastExecutionTime = steady_clock::now();
     int lastPregnancyDay = -1;
+
     while (runningWorker) {
         signalActivity();
+
+        // 1h-Block
         auto nowSteady = steady_clock::now();
         auto elapsed   = duration_cast<seconds>(nowSteady - lastExecutionTime).count();
         if (elapsed >= 3600) {
@@ -31,20 +35,22 @@ void UserCharacterWorker::run() {
             }
             lastExecutionTime = nowSteady;
         }
-        {
-            auto nowSys = system_clock::now();
-            std::time_t t = system_clock::to_time_t(nowSys);
-            std::tm local_tm;
-            localtime_r(&t, &local_tm);
-            if (local_tm.tm_hour == 6 && local_tm.tm_yday != lastPregnancyDay) {
-                try {
-                    processPregnancies();
-                } catch (const std::exception &e) {
-                    std::cerr << "[UserCharacterWorker] Fehler in processPregnancies: " << e.what() << std::endl;
-                }
-                lastPregnancyDay = local_tm.tm_yday;
+
+        // Schwangerschaftsverarbeitung: initial oder täglich um 06:00 einmal pro Tag
+        auto nowSys = system_clock::now();
+        std::time_t t = system_clock::to_time_t(nowSys);
+        std::tm local_tm;
+        localtime_r(&t, &local_tm);
+
+        if (lastPregnancyDay == -1 || (local_tm.tm_hour == 6 && local_tm.tm_yday != lastPregnancyDay)) {
+            try {
+                processPregnancies();
+            } catch (const std::exception &e) {
+                std::cerr << "[UserCharacterWorker] Fehler in processPregnancies: " << e.what() << std::endl;
             }
+            lastPregnancyDay = local_tm.tm_yday;
         }
+
         std::this_thread::sleep_for(seconds(1));
         recalculateKnowledge();
     }
@@ -225,22 +231,34 @@ void UserCharacterWorker::recalculateKnowledge() {
 void UserCharacterWorker::processPregnancies() {
     ConnectionGuard connGuard(pool);
     auto &db = connGuard.get();
+
     db.prepare("QUERY_AUTOBATISM", QUERY_AUTOBATISM);
     db.execute("QUERY_AUTOBATISM");
+
     db.prepare("get_candidates", QUERY_GET_PREGNANCY_CANDIDATES);
     auto rows = db.execute("get_candidates");
+
     const nlohmann::json message = {
         {"event", "children_update"},
     };
-    for (auto const &row : rows) {
-        int fatherCid       = std::stoi(row.at("father_cid"));
-        int motherCid       = std::stoi(row.at("mother_cid"));
-        int fatherUid       = std::stoi(row.at("father_uid"));
-        int motherUid       = std::stoi(row.at("mother_uid"));
-        int titleOfNobility = std::stoi(row.at("title_of_nobility"));
-        int lastName        = std::stoi(row.at("last_name"));
-        int regionId        = std::stoi(row.at("region_id"));
+
+    for (const auto &row : rows) {
+        int fatherCid = Utils::optionalStoiOrDefault(row, "father_cid", -1);
+        int motherCid = Utils::optionalStoiOrDefault(row, "mother_cid", -1);
+        if (fatherCid < 0 || motherCid < 0) {
+            continue; // ungültige Daten überspringen
+        }
+
+        int titleOfNobility = Utils::optionalStoiOrDefault(row, "title_of_nobility", 0);
+        int lastName = Utils::optionalStoiOrDefault(row, "last_name", 0);
+        int regionId = Utils::optionalStoiOrDefault(row, "region_id", 0);
+
+        auto fatherUidOpt = Utils::optionalUid(row.at("father_uid"));
+        auto motherUidOpt = Utils::optionalUid(row.at("mother_uid"));
+
+        // Geschlecht zufällig
         std::string gender = (dist(gen) < 0.5) ? "male" : "female";
+
         db.prepare("insert_child", QUERY_INSERT_CHILD);
         auto resChild = db.execute("insert_child", {
             std::to_string(regionId),         // $1
@@ -248,16 +266,30 @@ void UserCharacterWorker::processPregnancies() {
             std::to_string(lastName),         // $3
             std::to_string(titleOfNobility)   // $4
         });
-        int childCid = std::stoi(resChild.front().at("child_cid"));
+
+        if (resChild.empty()) continue;
+        int childCid = Utils::optionalStoiOrDefault(resChild.front(), "child_cid", -1);
+        if (childCid < 0) continue;
+
         db.prepare("insert_relation", QUERY_INSERT_CHILD_RELATION);
-        auto resRel = db.execute("insert_relation", {
+        db.execute("insert_relation", {
             std::to_string(fatherCid),
             std::to_string(motherCid),
             std::to_string(childCid)
         });
-        const nlohmann::json message = {{"event", "children_update"}};
-        sendMessageToFalukantUsers(fatherUid, message);
-        sendMessageToFalukantUsers(motherUid, message);
+
+        if (fatherUidOpt) {
+            sendMessageToFalukantUsers(*fatherUidOpt, message);
+            // Sende falukantUpdateStatus nach dem Erstellen des Kindes
+            nlohmann::json updateMessage = { { "event", "falukantUpdateStatus" } };
+            sendMessageToFalukantUsers(*fatherUidOpt, updateMessage);
+        }
+        if (motherUidOpt) {
+            sendMessageToFalukantUsers(*motherUidOpt, message);
+            // Sende falukantUpdateStatus nach dem Erstellen des Kindes
+            nlohmann::json updateMessage = { { "event", "falukantUpdateStatus" } };
+            sendMessageToFalukantUsers(*motherUidOpt, updateMessage);
+        }
     }
 }
 

src/usercharacterworker.h

@@ -134,7 +134,7 @@ private:
                  - 2.638267
                )
             )
-        );
+        ) / 2;  -- Geburtenrate halbiert
     )";
 
     static constexpr char const* QUERY_INSERT_CHILD = R"(

src/utils.cpp

@@ -0,0 +1,94 @@
+#include "utils.h"
+#include <sstream>
+#include <iomanip>
+#include <ctime>
+
+int Utils::optionalStoiOrDefault(const std::unordered_map<std::string, std::string>& row,
+                                 const std::string& key, int def) {
+    auto it = row.find(key);
+    if (it == row.end()) return def;
+    const std::string& val = it->second;
+    if (isNullOrEmpty(val)) return def;
+    try {
+        return std::stoi(val);
+    } catch (...) {
+        return def;
+    }
+}
+
+double Utils::optionalStodOrDefault(const std::unordered_map<std::string, std::string>& row,
+                                    const std::string& key, double def) {
+    auto it = row.find(key);
+    if (it == row.end()) return def;
+    const std::string& val = it->second;
+    if (isNullOrEmpty(val)) return def;
+    try {
+        return std::stod(val);
+    } catch (...) {
+        return def;
+    }
+}
+
+bool Utils::isNullOrEmpty(const std::string& s) {
+    return s.empty() || s == "NULL";
+}
+
+std::optional<std::chrono::system_clock::time_point> Utils::parseTimestamp(const std::string& iso) {
+    std::istringstream ss(iso);
+    std::tm tm = {};
+    ss >> std::get_time(&tm, "%Y-%m-%dT%H:%M:%S");
+    if (ss.fail()) {
+        ss.clear();
+        ss.str(iso);
+        ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
+        if (ss.fail()) return std::nullopt;
+    }
+    std::time_t time_c = std::mktime(&tm);
+    if (time_c == -1) return std::nullopt;
+    return std::chrono::system_clock::from_time_t(time_c);
+}
+
+std::optional<int> Utils::computeAgeYears(const std::string& birthdate_iso) {
+    auto birth_tp = parseTimestamp(birthdate_iso);
+    if (!birth_tp) return std::nullopt;
+    auto now = std::chrono::system_clock::now();
+
+    std::time_t birth_time = std::chrono::system_clock::to_time_t(*birth_tp);
+    std::time_t now_time   = std::chrono::system_clock::to_time_t(now);
+
+    std::tm birth_tm;
+    std::tm now_tm;
+#if defined(_WIN32) || defined(_WIN64)
+    localtime_s(&birth_tm, &birth_time);
+    localtime_s(&now_tm, &now_time);
+#else
+    localtime_r(&birth_time, &birth_tm);
+    localtime_r(&now_time, &now_tm);
+#endif
+
+    int years = now_tm.tm_year - birth_tm.tm_year;
+    if (now_tm.tm_mon < birth_tm.tm_mon ||
+        (now_tm.tm_mon == birth_tm.tm_mon && now_tm.tm_mday < birth_tm.tm_mday)) {
+        years--;
+    }
+    return years;
+}
+
+std::string Utils::buildPgIntArrayLiteral(const std::vector<int>& elems) {
+    std::string res = "{";
+    for (size_t i = 0; i < elems.size(); ++i) {
+        res += std::to_string(elems[i]);
+        if (i + 1 < elems.size()) res += ",";
+    }
+    res += "}";
+    return res;
+}
+
+std::optional<int> Utils::optionalUid(const std::string& val) {
+    if (isNullOrEmpty(val)) return std::nullopt;
+    try {
+        return std::stoi(val);
+    } catch (...) {
+        return std::nullopt;
+    }
+}

src/utils.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <optional>
+#include <chrono>
+
+class Utils {
+public:
+    // Safe conversions with fallback
+    static int optionalStoiOrDefault(const std::unordered_map<std::string, std::string>& row,
+                                     const std::string& key, int def = -1);
+    static double optionalStodOrDefault(const std::unordered_map<std::string, std::string>& row,
+                                        const std::string& key, double def = 0.0);
+
+    static bool isNullOrEmpty(const std::string& s);
+
+    // Parse timestamp from common ISO / SQL formats into time_point
+    static std::optional<std::chrono::system_clock::time_point> parseTimestamp(const std::string& iso);
+
+    // Compute full years age from birthdate string; returns nullopt on parse failure.
+    static std::optional<int> computeAgeYears(const std::string& birthdate_iso);
+
+    // Build Postgres integer array literal "{1,2,3}"
+    static std::string buildPgIntArrayLiteral(const std::vector<int>& elems);
+
+    // Safely parse a nullable integer-like string
+    static std::optional<int> optionalUid(const std::string& val);
+};

src/websocket_server.cpp

@@ -56,6 +56,11 @@ void WebSocketServer::startServer() {
     memset(&info, 0, sizeof(info));
     info.port = port;
     info.protocols = protocols;
+    
+    // Reduziere Log-Level um weniger Debug-Ausgaben zu haben
+    // Setze Umgebungsvariable für Log-Level
+    setenv("LWS_LOG_LEVEL", "0", 1);  // 0 = nur Fehler
+    
     context = lws_create_context(&info);
     if (!context) {
         throw std::runtime_error("Failed to create LWS context");