FiveM-Krankenhaus- und Rettungsdienstsystem: Realistische medizinische Berufe per Script

Architektur des Krankenhaussystems

Ein Krankenhaus- und EMS-System verändert, wie Spieler Gesundheit und Verletzungen auf einem FiveM-Roleplay-Server erleben. Statt nach einer Bewusstlosigkeit einfach wiederzubeleben, durchlaufen Spieler einen medizinischen Roleplay-Ablauf: EMS stabilisiert sie vor Ort, transportiert sie mit dem Krankenwagen, meldet sie im Krankenhaus an, stellt eine Diagnose, behandelt sie und stellt die Leistungen in Rechnung. Die Systemarchitektur besteht aus vier miteinander verbundenen Ebenen: dem Verletzungssystem, das erfasst, was dem Spieler zugestoßen ist und welche Körperstellen betroffen sind, den EMS-Tools für Disposition und Einsatz vor Ort, dem Ablauf für Anmeldung und Behandlung im Krankenhaus sowie dem Abrechnungssystem, das die medizinische Versorgung mit der Serverwirtschaft verknüpft. Jede Ebene kommuniziert über Server-Events, damit der behandelnde Arzt genau sehen kann, welche Verletzungen der EMS-Einsatzkraft bei der Erstversorgung bereits dokumentiert wurden. Wenn du das als einheitliches System statt als separate Skripte entwickelst, fließen Patientendaten nahtlos vom Notruf bis zu dem Moment, an dem der Patient mit der Rechnung in der Hand das Krankenhaus verlässt.

Verletzungstyp-System

Ein detailliertes Verletzungssystem ersetzt den einfachen Zustand „lebendig oder tot“ durch ein Spektrum an Verletzungen, die unterschiedliche Behandlungen erfordern. Erfasse Verletzungen nach Körperregion, Schweregrad und Ursache, damit EMS und Ärzte realistische medizinische Situationen ausspielen können. Erleidet ein Spieler Schaden, ermittle anhand des Waffen- oder Todesursachen-Hashes den Verletzungstyp und ordne ihn der entsprechenden Körperregion zu. Schusswunden am Oberkörper sind schwerwiegender als ein Schlag auf den Arm, und jeder Verletzungstyp erfordert eine bestimmte Behandlung, die Ärzte befolgen müssen:

Config.InjuryTypes = {
    gunshot = {
        label = 'Gunshot Wound',
        severity = { min = 60, max = 100 },
        bleedRate = 2.5,
        treatments = {'clean_wound', 'remove_bullet', 'stitch', 'bandage'},
        requiredItems = {'tweezers', 'suture_kit', 'bandage'},
        healTime = 120,
    },
    stabbing = {
        label = 'Stab Wound',
        severity = { min = 40, max = 80 },
        bleedRate = 1.8,
        treatments = {'clean_wound', 'stitch', 'bandage'},
        requiredItems = {'suture_kit', 'bandage'},
        healTime = 90,
    },
    blunt = {
        label = 'Blunt Force Trauma',
        severity = { min = 20, max = 60 },
        bleedRate = 0.5,
        treatments = {'examine', 'ice_pack', 'painkillers'},
        requiredItems = {'ice_pack', 'painkillers'},
        healTime = 60,
    },
    burn = {
        label = 'Burn Injury',
        severity = { min = 30, max = 90 },
        bleedRate = 0,
        treatments = {'cool_burn', 'apply_cream', 'bandage'},
        requiredItems = {'burn_cream', 'bandage'},
        healTime = 100,
    },
    fracture = {
        label = 'Bone Fracture',
        severity = { min = 50, max = 70 },
        bleedRate = 0,
        treatments = {'x_ray', 'set_bone', 'apply_cast'},
        requiredItems = {'splint', 'cast_material'},
        healTime = 180,
    },
    vehicle_crash = {
        label = 'Vehicle Collision Injury',
        severity = { min = 30, max = 95 },
        bleedRate = 1.0,
        treatments = {'examine', 'clean_wound', 'stitch', 'bandage', 'painkillers'},
        requiredItems = {'suture_kit', 'bandage', 'painkillers'},
        healTime = 110,
    },
}

Config.BodyRegions = {
    'head', 'torso', 'left_arm', 'right_arm', 'left_leg', 'right_leg'
}

-- Severity multipliers per body region
Config.RegionMultipliers = {
    head = 1.5,
    torso = 1.3,
    left_arm = 0.8,
    right_arm = 0.8,
    left_leg = 0.9,
    right_leg = 0.9,
}

EMS-Disposition und Einsatz vor Ort

Das EMS-Dispositionssystem verbindet bewusstlose Spieler mit diensthabenden medizinischen Einsatzkräften. Wird ein Spieler bewusstlos, kann er den Notruf 911 wählen. Dadurch wird ein Einsatzalarm ausgelöst, den alle diensthabenden EMS-Mitarbeiter sehen. Der Alarm enthält die GPS-Koordinaten des Anrufers, eine kurze Beschreibung auf Basis der Verletzungsdaten und eine nach Schweregrad der Verletzungen festgelegte Priorität. EMS-Einsatzkräfte können den Auftrag über eine Dispositions-UI annehmen. Dadurch wird der Auftrag als übernommen markiert und die GPS-Navigation zum Patienten gestartet. Implementiere einen Reaktionszeit-Timer, der erfasst, wie lange es von der Erstellung eines Auftrags bis zum Kontakt mit dem Patienten dauert. Damit kannst du die EMS-Leistung auswerten und den Personalbedarf anpassen. Die Erstversorgung ist eine vereinfachte Version der Krankenhausbehandlung: EMS kann Patienten mit einfachen Hilfsmitteln wie Verbänden, Tourniquets und Adrenalinspritzen stabilisieren, um ihren Tod während des Transports zu verhindern:

-- Server-side dispatch handler
local activeDispatches = {}

RegisterNetEvent('hospital:server:call911', function(description)
    local src = source
    local Player = QBCore.Functions.GetPlayer(src)
    if not Player then return end

    local ped = GetPlayerPed(src)
    local coords = GetEntityCoords(ped)
    local injuries = Player.Functions.GetMetaData('injuries') or {}

    -- Determine priority from injury severity
    local maxSeverity = 0
    for _, injury in ipairs(injuries) do
        if injury.severity > maxSeverity then
            maxSeverity = injury.severity
        end
    end

    local priority = maxSeverity >= 80 and 'CRITICAL' or maxSeverity >= 50 and 'URGENT' or 'STANDARD'

    local dispatch = {
        id = #activeDispatches + 1,
        callerId = src,
        citizenid = Player.PlayerData.citizenid,
        callerName = Player.PlayerData.charinfo.firstname .. ' ' .. Player.PlayerData.charinfo.lastname,
        coords = { x = coords.x, y = coords.y, z = coords.z },
        description = description or GenerateInjuryDescription(injuries),
        priority = priority,
        injuries = injuries,
        timestamp = os.time(),
        status = 'pending',
        responderId = nil,
    }

    table.insert(activeDispatches, dispatch)

    -- Notify all on-duty EMS
    local emsPlayers = QBCore.Functions.GetQBPlayers()
    for _, emsPlayer in pairs(emsPlayers) do
        if emsPlayer.PlayerData.job.name == 'ambulance' and emsPlayer.PlayerData.job.onduty then
            TriggerClientEvent('hospital:client:newDispatch', emsPlayer.PlayerData.source, dispatch)
        end
    end
end)

RegisterNetEvent('hospital:server:acceptDispatch', function(dispatchId)
    local src = source
    local Player = QBCore.Functions.GetPlayer(src)
    if not Player or Player.PlayerData.job.name ~= 'ambulance' then return end

    for i, dispatch in ipairs(activeDispatches) do
        if dispatch.id == dispatchId and dispatch.status == 'pending' then
            dispatch.status = 'responding'
            dispatch.responderId = src
            dispatch.responseTime = os.time()

            -- Notify caller
            TriggerClientEvent('QBCore:Notify', dispatch.callerId, 'EMS is on the way!', 'success')
            -- Set GPS blip for responder
            TriggerClientEvent('hospital:client:setDispatchGPS', src, dispatch.coords)
            break
        end
    end
end)

Anmelde- und Behandlungs-UI des Krankenhauses

Das Krankenhaus-Anmeldesystem verwaltet den Patientenfluss von der Ankunft bis zur Entlassung. Wenn eine EMS-Einsatzkraft einen Patienten ins Krankenhaus bringt oder ein Spieler selbst hineingeht, meldet er sich am Empfang bei einem NPC oder über einen Target-Punkt an. Bei der Anmeldung wird ein Patientenprofil mit den aktuellen Verletzungen und Vitalwerten sowie einer eindeutigen Besuchs-ID für die Abrechnung erstellt. Diensthabende Ärzte sehen neue Patienten in einer NUI-Übersicht für die Krankenhausverwaltung. Sie zeigt die Warteschlange, die Triage-Priorität jedes Patienten und die dokumentierten Verletzungen. Wählt ein Arzt einen Patienten aus, öffnet sich die Behandlungs-UI mit einer Körpergrafik des Patienten, auf der die verletzten Stellen hervorgehoben sind. Der Arzt klickt auf eine Verletzung, um die erforderlichen Behandlungsschritte anzusehen, und führt diese der Reihe nach aus. Dabei werden Animationen ausgelöst und medizinische Gegenstände aus dem Inventar verbraucht. Jeder Behandlungsschritt hat einen Fortschrittsbalken und eine Erfolgsprüfung, die von den Skill-Metadaten des Arztes abhängt. So entsteht ein Fortschrittssystem für das medizinische Roleplay.

Behandlungsablauf

Gestalte den Behandlungsablauf als Schritt-für-Schritt-Prozess, bei dem jede Verletzung bestimmte Aktionen in der richtigen Reihenfolge erfordert. Eine Schusswunde am Oberkörper muss beispielsweise gereinigt, die Kugel mit einer Pinzette entfernt, mit einem Nahtset genäht und anschließend verbunden werden. Bei jedem Schritt wird der passende Gegenstand aus dem Inventar des Arztes verbraucht und eine Behandlungsanimation abgespielt. Werden Schritte übersprungen oder in der falschen Reihenfolge ausgeführt, sollte die Behandlung entweder fehlschlagen oder weniger wirksam sein. So förderst du realistisches medizinisches Roleplay. Nach der Behandlung aller Verletzungen beginnt eine Genesungsphase, in der sich die Gesundheit mit der Zeit erholt, statt sofort vollständig wiederhergestellt zu werden:

RegisterNetEvent('hospital:server:treatInjury', function(patientId, injuryIndex, treatmentStep)
    local src = source
    local Doctor = QBCore.Functions.GetPlayer(src)
    local Patient = QBCore.Functions.GetPlayer(patientId)

    if not Doctor or not Patient then return end
    if Doctor.PlayerData.job.name ~= 'ambulance' or not Doctor.PlayerData.job.onduty then
        TriggerClientEvent('QBCore:Notify', src, 'You must be on duty', 'error')
        return
    end

    local injuries = Patient.Functions.GetMetaData('injuries') or {}
    local injury = injuries[injuryIndex]
    if not injury then return end

    local injuryConfig = Config.InjuryTypes[injury.type]
    if not injuryConfig then return end

    -- Validate treatment step order
    local expectedStep = injury.currentStep or 1
    if treatmentStep ~= expectedStep then
        TriggerClientEvent('QBCore:Notify', src, 'Complete previous treatment steps first', 'error')
        return
    end

    local stepName = injuryConfig.treatments[treatmentStep]
    if not stepName then return end

    -- Check required item
    local requiredItem = Config.TreatmentItems[stepName]
    if requiredItem then
        local hasItem = Doctor.Functions.GetItemByName(requiredItem.name)
        if not hasItem or hasItem.amount < 1 then
            TriggerClientEvent('QBCore:Notify', src, 'Missing: ' .. requiredItem.label, 'error')
            return
        end
        Doctor.Functions.RemoveItem(requiredItem.name, 1)
    end

    -- Apply treatment
    injury.currentStep = treatmentStep + 1
    injury.treated = treatmentStep >= #injuryConfig.treatments

    if injury.treated then
        injury.bleedRate = 0
        injury.healStartTime = os.time()
    end

    injuries[injuryIndex] = injury
    Patient.Functions.SetMetaData('injuries', injuries)

    -- Notify both parties
    TriggerClientEvent('QBCore:Notify', src, 'Treatment step complete: ' .. stepName, 'success')
    TriggerClientEvent('QBCore:Notify', patientId, 'You received treatment: ' .. stepName, 'success')
    TriggerClientEvent('hospital:client:updateInjuries', patientId, injuries)
end)

Dienst- und Pausensystem

Das Dienstsystem legt fest, wann EMS und Krankenhauspersonal aktiv sind und Dispositionsaufträge erhalten können. Wenn sich ein Spieler mit dem Job Ambulance an einem Dienstpunkt im Krankenhaus einstempelt, erhält er Zugriff auf medizinische Befehle, Dispositionsbenachrichtigungen und erscheint in der aktiven EMS-Liste, die für andere Mitarbeiter sichtbar ist. Falls dein Server automatische Gehaltszahlungen nutzt, sollte das Dienstsystem Ein- und Ausstempelzeiten für die Gehaltsabrechnung erfassen. Implementiere im EMS-Job verschiedene Dienstrollen wie Sanitäter, Arzt und Chirurg, die jeweils Zugriff auf unterschiedliche Behandlungsmöglichkeiten haben. Ein Sanitäter kann Patienten vor Ort stabilisieren und einfache Behandlungen durchführen, ein Arzt übernimmt übliche Krankenhausbehandlungen und ein Chirurg kann komplexe Eingriffe wie das Entfernen von Kugeln und das Richten von Knochen durchführen. Speichere die Dienstliste in einem gemeinsamen Server-State, damit das Dispositionssystem die verfügbaren Einsatzkräfte korrekt zählen und den Auto-Respawn-Timer für bewusstlose Spieler je nach EMS-Verfügbarkeit anpassen kann.

Medizinisches Abrechnungssystem

Die medizinische Abrechnung verknüpft das Krankenhaussystem mit der Serverwirtschaft und schafft finanzielle Folgen für riskantes Verhalten. Nach der Behandlung eines Patienten erstellt das System eine detaillierte Rechnung mit allen durchgeführten Behandlungen, verbrauchten Hilfsmitteln und anfallenden Gebühren. Rechnungen können beim Verlassen des Krankenhauses am Empfang bezahlt, direkt vom Bankkonto des Patienten abgebucht oder als Zahlungsaufforderung verschickt werden, die der Patient innerhalb einer festgelegten Frist begleichen muss. Implementiere ein Krankenversicherungssystem, in dem Spieler Versicherungspolicen erwerben können, die einen Teil ihrer Behandlungskosten übernehmen und so die finanzielle Belastung häufiger Krankenhausbesuche verringern. Versicherungsprämien können regelmäßig abgebucht werden und so zur Wirtschaftssimulation des Servers beitragen. Für Spieler, die nicht zahlen können, kannst du ein medizinisches Schuldensystem einführen, bei dem sich auf unbezahlte Rechnungen Zinsen ansammeln. Das kann schließlich Folgen wie Lohnpfändungen bei Gehaltszahlungen oder eingeschränkten Zugriff auf bestimmte Leistungen haben, bis die Schulden beglichen sind. Speichere alle Abrechnungen zur Überprüfung durch Admins und verknüpfe sie mit dem Transaktionsprotokoll, damit sich der Geldfluss vom Patienten zum Krankenhaus nachverfolgen lässt.

Krankenwagen und Ausrüstung

Der Krankenwagen sollte mehr sein als nur ein schnelles Auto mit Sirene. Implementiere fahrzeugspezifische Funktionen, die den Krankenwagen zu einer mobilen Behandlungsstation machen. Öffnet eine EMS-Einsatzkraft über eine Fahrzeuginteraktion die Hecktüren, erhält sie Zugriff auf ein mobiles Behandlungsmenü mit einigen Krankenhausfunktionen, etwa Verbände anlegen, Schmerzmittel verabreichen, Schienen anlegen und einen Defibrillator verwenden. Lagere medizinische Hilfsmittel im Kofferrauminventar des Krankenwagens, damit Einsatzkräfte zwischen den Aufträgen im Krankenhaus Vorräte auffüllen müssen. Der Defibrillator ist ein spezieller Gegenstand, mit dem sich Spieler wiederbeleben lassen, die den Todeszustand erreicht haben. Dafür sollte aber ein Minispiel mit zeitabhängigen Eingaben erforderlich sein, das eine korrekte CPR-Technik simuliert. Implementiere ein Tragensystem, mit dem EMS einen bewusstlosen Spieler auf eine am Krankenwagen befestigte Trage legen kann. Während des Transports wird der Patient dadurch in einer liegenden Animation im Fahrzeug fixiert. Verwende AttachEntityToEntity für die Platzierung der Trage und SetPedIntoVehicle für das Einladen des Patienten.

Integration und Komfortfunktionen

Dein Krankenhaussystem sollte in die Telefon-Resource des Servers integriert sein, damit Spieler direkt über die Telefon-App 911 anrufen, ihre Krankengeschichte und offene Rechnungen einsehen und die EMS-Wartezeiten prüfen können, bevor sie entscheiden, ob sie Hilfe rufen oder sich mit einfachen Mitteln aus der Apotheke selbst behandeln. Verknüpfe das Verletzungssystem mit Bewegungseinschränkungen, damit Beinverletzungen die Bewegungsgeschwindigkeit verringern und Armverletzungen die Zielgenauigkeit beeinträchtigen. So entstehen spürbare Gameplay-Folgen, die Spieler dazu motivieren, sich behandeln zu lassen, statt ihre Verletzungen zu ignorieren. Implementiere ein medizinisches Aktenführungssystem im Krankenhaus-MDT, über das Ärzte die vollständige Behandlungshistorie eines Patienten, von anderen Ärzten vermerkte Allergien und aktuelle Medikamente einsehen können. Exportiere deine Verletzungs- und Behandlungsfunktionen, damit andere Resources wie Drogeneffekte, Lebensmittelvergiftungen oder Umweltgefahren in denselben medizinischen Ablauf integriert werden können. Ergänze ein Auto-Respawn-System mit einem konfigurierbaren Timer, das aktiviert wird, wenn keine EMS-Mitarbeiter Dienst haben. So bleiben Spieler nie unbegrenzt bewusstlos, während medizinisches Roleplay durch Spieler Vorrang hat, wenn Personal verfügbar ist.