ed

resources/[inventory]/nordi_alctester/server/server.lua

@@ -0,0 +1,205 @@
+local QBCore = exports['qb-core']:GetCoreObject()
+
+-- BAC-Abbaurate (wie viel BAC pro Minute abnimmt)
+local BAC_DECAY_RATE = Config.BACDecayRate
+
+-- Player BAC Cache um übermäßige Datenbankaufrufe zu vermeiden
+local playerBAC = {}
+
+-- Funktion zum Aktualisieren des BAC-Levels eines Spielers
+local function UpdatePlayerBAC(citizenid, addAmount)
+    -- Initialisieren, falls nicht vorhanden
+    if not playerBAC[citizenid] then
+        playerBAC[citizenid] = {
+            bac = 0.0,
+            lastUpdated = os.time()
+        }
+    end
+    
+    -- Zeitbasierten Abbau berechnen
+    local currentTime = os.time()
+    local minutesPassed = (currentTime - playerBAC[citizenid].lastUpdated) / 60
+    
+    -- Abbau anwenden, aber nicht unter 0
+    local decayAmount = BAC_DECAY_RATE * minutesPassed
+    local newBAC = math.max(0.0, playerBAC[citizenid].bac - decayAmount)
+    
+    -- Neuen Alkoholwert hinzufügen
+    newBAC = newBAC + addAmount
+    
+    -- Bei realistischem Maximum begrenzen (0.5% wäre tödlich)
+    newBAC = math.min(0.5, newBAC)
+    
+    -- Cache aktualisieren
+    playerBAC[citizenid] = {
+        bac = newBAC,
+        lastUpdated = currentTime
+    }
+    
+    -- Datenbank aktualisieren
+    MySQL.Async.execute('INSERT INTO player_bac (citizenid, bac_level) VALUES (?, ?) ON DUPLICATE KEY UPDATE bac_level = ?, last_updated = CURRENT_TIMESTAMP', 
+        {citizenid, newBAC, newBAC})
+end
+
+-- Funktion zum Abrufen des aktuellen BAC-Levels eines Spielers mit Abbauberechnung
+local function GetCurrentBAC(citizenid)
+    -- Wenn wir Cache-Daten haben
+    if playerBAC[citizenid] then
+        local currentTime = os.time()
+        local minutesPassed = (currentTime - playerBAC[citizenid].lastUpdated) / 60
+        
+        -- Abbau anwenden, aber nicht unter 0
+        local decayAmount = BAC_DECAY_RATE * minutesPassed
+        local currentBAC = math.max(0.0, playerBAC[citizenid].bac - decayAmount)
+        
+        -- Cache mit abgebautem Wert aktualisieren
+        playerBAC[citizenid] = {
+            bac = currentBAC,
+            lastUpdated = currentTime
+        }
+        
+        -- Datenbank mit neuem abgebautem Wert aktualisieren
+        MySQL.Async.execute('UPDATE player_bac SET bac_level = ?, last_updated = CURRENT_TIMESTAMP WHERE citizenid = ?', 
+            {currentBAC, citizenid})
+            
+        return currentBAC
+    else
+        -- Wenn nicht im Cache, aus Datenbank abrufen
+        local result = MySQL.Sync.fetchAll('SELECT bac_level, last_updated FROM player_bac WHERE citizenid = ?', {citizenid})
+        
+        if result and result[1] then
+            local storedBAC = result[1].bac_level
+            local lastUpdated = result[1].last_updated
+            
+            -- MySQL-Zeitstempel in Unix-Zeitstempel umwandeln
+            local pattern = "(%d+)-(%d+)-(%d+) (%d+):(%d+):(%d+)"
+            local year, month, day, hour, min, sec = lastUpdated:match(pattern)
+            local lastUpdateTime = os.time({year=year, month=month, day=day, hour=hour, min=min, sec=sec})
+            
+            local currentTime = os.time()
+            local minutesPassed = (currentTime - lastUpdateTime) / 60
+            
+            -- Abbau anwenden, aber nicht unter 0
+            local decayAmount = BAC_DECAY_RATE * minutesPassed
+            local currentBAC = math.max(0.0, storedBAC - decayAmount)
+            
+            -- Cache aktualisieren
+            playerBAC[citizenid] = {
+                bac = currentBAC,
+                lastUpdated = currentTime
+            }
+            
+            -- Datenbank mit neuem abgebautem Wert aktualisieren
+            MySQL.Async.execute('UPDATE player_bac SET bac_level = ?, last_updated = CURRENT_TIMESTAMP WHERE citizenid = ?', 
+                {currentBAC, citizenid})
+                
+            return currentBAC
+        else
+            -- Kein Eintrag gefunden, mit 0 initialisieren
+            playerBAC[citizenid] = {
+                bac = 0.0,
+                lastUpdated = os.time()
+            }
+            
+            return 0.0
+        end
+    end
+end
+
+-- Anbindung an das Konsumsystem
+-- Dieses Event sollte ausgelöst werden, wenn ein Spieler ein alkoholisches Item konsumiert
+RegisterNetEvent('qb-alcoholtest:server:alcoholConsumed')
+AddEventHandler('qb-alcoholtest:server:alcoholConsumed', function(itemName, intensity)
+    local src = source
+    local Player = QBCore.Functions.GetPlayer(src)
+    
+    if not Player then return end
+    
+    local citizenid = Player.PlayerData.citizenid
+    local alcoholContent = 0.0
+    
+    -- Prüfen, ob das konsumierte Item alkoholisch ist
+    if Config.AlcoholItems[itemName] then
+        alcoholContent = Config.AlcoholItems[itemName]
+        
+        -- Basierend auf Intensität anpassen, falls angegeben
+        if intensity then
+            alcoholContent = alcoholContent * intensity
+        end
+        
+        -- BAC des Spielers aktualisieren
+        UpdatePlayerBAC(citizenid, alcoholContent)
+        
+        -- Spieler benachrichtigen
+        if Config.Debug then
+            TriggerClientEvent('QBCore:Notify', src, 'Du spürst die Wirkung des Alkohols.', 'primary')
+        end
+    end
+end)
+
+-- Verwendbares Alkoholtester-Item erstellen
+QBCore.Functions.CreateUseableItem('breathalyzer', function(source, item)
+    local src = source
+    TriggerClientEvent('qb-alcoholtest:client:useBreathalyzer', src)
+end)
+
+-- Alkoholtester-Events
+RegisterServerEvent('qb-alcoholtest:server:doBacTest')
+AddEventHandler('qb-alcoholtest:server:doBacTest', function(target)
+    TriggerClientEvent('qb-alcoholtest:client:requestBac', target, source, target)
+end)
+
+RegisterServerEvent('qb-alcoholtest:server:refusedBac')
+AddEventHandler('qb-alcoholtest:server:refusedBac', function(leo, target)
+    TriggerClientEvent('qb-alcoholtest:client:bacRefused', leo, target)
+end)
+
+RegisterServerEvent('qb-alcoholtest:server:acceptedBac')
+AddEventHandler('qb-alcoholtest:server:acceptedBac', function(leo, target)
+    TriggerClientEvent('qb-alcoholtest:client:acceptedBac', leo, target)
+end)
+
+-- Neues Event, um den tatsächlichen BAC-Wert aus dem System zu erhalten
+RegisterServerEvent('qb-alcoholtest:server:getActualBAC')
+AddEventHandler('qb-alcoholtest:server:getActualBAC', function(leo, target)
+    local targetPlayer = QBCore.Functions.GetPlayer(target)
+    
+    if not targetPlayer then return end
+    
+    local citizenid = targetPlayer.PlayerData.citizenid
+    local currentBAC = GetCurrentBAC(citizenid)
+    
+    -- BAC auf 2 Dezimalstellen formatieren
+    local formattedBAC = string.format("%.2f", currentBAC)
+    
+    -- Farbe basierend auf gesetzlichem Limit bestimmen
+    local color = '--color-black'
+    if currentBAC > Config.LegalLimit then
+        color = '--color-red'
+    end
+    
+    -- BAC-Ergebnis an den Beamten senden
+    TriggerClientEvent('qb-alcoholtest:client:displayBac', leo, formattedBAC, color)
+end)
+
+-- Öffentliche Funktion für andere Ressourcen
+exports('GetPlayerBAC', function(citizenid)
+    return GetCurrentBAC(citizenid)
+end)
+
+-- Öffentliche Funktion zum Aktualisieren des BAC-Werts
+exports('UpdatePlayerBAC', function(citizenid, amount)
+    UpdatePlayerBAC(citizenid, amount)
+end)
+
+-- Sicherstellen, dass die Datenbanktabelle existiert, wenn die Ressource startet
+MySQL.ready(function()
+    MySQL.Async.execute([[
+        CREATE TABLE IF NOT EXISTS `player_bac` (
+            `citizenid` varchar(50) NOT NULL,
+            `bac_level` float NOT NULL DEFAULT 0.0,
+            `last_updated` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+            PRIMARY KEY (`citizenid`)
+        );
+    ]])
+end)