Main/resources/[carscripts]/nordi_antidespawn/client/main.lua

local QBCore = exports['qb-core']:GetCoreObject()
local trackedVehicles = {}
local playerVehicles = {}

-- Funktion um zu prüfen ob Fahrzeugklasse erlaubt ist
local function IsVehicleClassAllowed(vehicle)
    local vehicleClass = GetVehicleClass(vehicle)
    for _, allowedClass in pairs(Config.AllowedVehicleClasses) do
        if vehicleClass == allowedClass then
            return true
        end
    end
    return false
end

-- Funktion um Fahrzeugmods zu erhalten
local function GetVehicleMods(vehicle)
    local mods = {}
    
    -- Basis Mods
    for i = 0, 49 do
        mods[tostring(i)] = GetVehicleMod(vehicle, i)
    end
    
    -- Extras
    mods.extras = {}
    for i = 1, 12 do
        if DoesExtraExist(vehicle, i) then
            mods.extras[tostring(i)] = IsVehicleExtraTurnedOn(vehicle, i)
        end
    end
    
    -- Farben
    local primaryColor, secondaryColor = GetVehicleColours(vehicle)
    local pearlescentColor, wheelColor = GetVehicleExtraColours(vehicle)
    
    mods.colors = {
        primary = primaryColor,
        secondary = secondaryColor,
        pearlescent = pearlescentColor,
        wheels = wheelColor
    }
    
    -- Neon
    mods.neon = {
        left = IsVehicleNeonLightEnabled(vehicle, 0),
        right = IsVehicleNeonLightEnabled(vehicle, 1),
        front = IsVehicleNeonLightEnabled(vehicle, 2),
        back = IsVehicleNeonLightEnabled(vehicle, 3)
    }
    
    local r, g, b = GetVehicleNeonLightsColour(vehicle)
    mods.neonColor = {r = r, g = g, b = b}
    
    return mods
end

-- Funktion um Fahrzeugmods zu setzen
local function SetVehicleMods(vehicle, mods)
    if not mods then return end
    
    -- Basis Mods
    for i = 0, 49 do
        if mods[tostring(i)] then
            SetVehicleMod(vehicle, i, mods[tostring(i)], false)
        end
    end
    
    -- Extras
    if mods.extras then
        for i = 1, 12 do
            if mods.extras[tostring(i)] ~= nil then
                SetVehicleExtra(vehicle, i, not mods.extras[tostring(i)])
            end
        end
    end
    
    -- Farben
    if mods.colors then
        SetVehicleColours(vehicle, mods.colors.primary or 0, mods.colors.secondary or 0)
        SetVehicleExtraColours(vehicle, mods.colors.pearlescent or 0, mods.colors.wheels or 0)
    end
    
    -- Neon
    if mods.neon then
        SetVehicleNeonLightEnabled(vehicle, 0, mods.neon.left or false)
        SetVehicleNeonLightEnabled(vehicle, 1, mods.neon.right or false)
        SetVehicleNeonLightEnabled(vehicle, 2, mods.neon.front or false)
        SetVehicleNeonLightEnabled(vehicle, 3, mods.neon.back or false)
    end
    
    if mods.neonColor then
        SetVehicleNeonLightsColour(vehicle, mods.neonColor.r, mods.neonColor.g, mods.neonColor.b)
    end
end

-- Prüfe ob Fahrzeug einem Spieler gehört (vereinfachte Version)
local function DoesVehicleBelongToPlayer(plate)
    -- Da der Export nicht existiert, prüfen wir über QB-Core
    local Player = QBCore.Functions.GetPlayerData()
    if not Player or not Player.citizenid then return false end
    
    -- Hier könntest du eine eigene Logik implementieren oder
    -- einfach alle Fahrzeuge tracken die nicht NPC Fahrzeuge sind
    local vehicle = GetVehicleByPlate(plate)
    if vehicle then
        -- Prüfe ob es ein NPC Fahrzeug ist
        local driver = GetPedInVehicleSeat(vehicle, -1)
        if driver and IsPedAPlayer(driver) then
            return true
        elseif not driver then
            -- Kein Fahrer = wahrscheinlich Spielerfahrzeug
            return true
        end
    end
    
    return false
end

-- Hauptloop für Fahrzeugtracking
CreateThread(function()
    while true do
        Wait(Config.SaveInterval)
        
        local playerPed = PlayerPedId()
        local playerCoords = GetEntityCoords(playerPed)
        
        -- Finde alle Fahrzeuge in der Nähe
        local vehicles = GetGamePool('CVehicle')
        
        for _, vehicle in pairs(vehicles) do
            if DoesEntityExist(vehicle) and IsVehicleClassAllowed(vehicle) then
                local plate = QBCore.Functions.GetPlate(vehicle)
                local vehicleCoords = GetEntityCoords(vehicle)
                local distance = #(playerCoords - vehicleCoords)
                
                -- Prüfe ob Fahrzeug einem Spieler gehört
                if DoesVehicleBelongToPlayer(plate) then
                    -- Speichere Fahrzeugdaten
                    local vehicleData = {
                        plate = plate,
                        model = GetDisplayNameFromVehicleModel(GetEntityModel(vehicle)),
                        position = {x = vehicleCoords.x, y = vehicleCoords.y, z = vehicleCoords.z},
                        rotation = {x = 0.0, y = 0.0, z = GetEntityHeading(vehicle)},
                        engineHealth = GetVehicleEngineHealth(vehicle),
                        bodyHealth = GetVehicleBodyHealth(vehicle),
                        fuel = exports['LegacyFuel']:GetFuel(vehicle) or 100, -- Anpassen je nach Fuel System
                        mods = GetVehicleMods(vehicle)
                    }
                    
                    TriggerServerEvent('vehicle-persistence:server:saveVehiclePosition', vehicleData)
                    trackedVehicles[plate] = vehicle
                    
                    -- Verhindere Despawn
                    SetEntityAsMissionEntity(vehicle, true, true)
                    SetVehicleHasBeenOwnedByPlayer(vehicle, true)
                    
                    if Config.Debug then
                        print(string.format("Tracking vehicle: %s at distance: %.2f", plate, distance))
                    end
                end
            end
        end
    end
end)

-- Spawne gespeicherte Fahrzeuge
RegisterNetEvent('vehicle-persistence:client:spawnSavedVehicles', function(vehicles)
    for _, vehicleData in pairs(vehicles) do
        local position = json.decode(vehicleData.position)
        local rotation = json.decode(vehicleData.rotation)
        
        -- Prüfe ob Fahrzeug bereits existiert
        local existingVehicle = GetVehicleByPlate(vehicleData.plate)
        if not existingVehicle then
            -- Spawne Fahrzeug
            local modelHash = GetHashKey(vehicleData.model)
            
            RequestModel(modelHash)
            while not HasModelLoaded(modelHash) do
                Wait(100)
            end
            
            local vehicle = CreateVehicle(modelHash, position.x, position.y, position.z, rotation.z, true, false)
            
            if DoesEntityExist(vehicle) then
                -- Setze Fahrzeugdaten
                SetVehicleNumberPlateText(vehicle, vehicleData.plate)
                SetVehicleEngineHealth(vehicle, vehicleData.engine_health)
                SetVehicleBodyHealth(vehicle, vehicleData.body_health)
                
                -- Setze Fuel (anpassen je nach System)
                if exports['LegacyFuel'] then
                    exports['LegacyFuel']:SetFuel(vehicle, vehicleData.fuel)
                end
                
                -- Setze Mods
                if vehicleData.mods then
                    local mods = json.decode(vehicleData.mods)
                    SetVehicleMods(vehicle, mods)
                end
                
                -- Verhindere Despawn
                SetEntityAsMissionEntity(vehicle, true, true)
                SetVehicleHasBeenOwnedByPlayer(vehicle, true)
                
                trackedVehicles[vehicleData.plate] = vehicle
                
                if Config.Debug then
                    print(string.format("Spawned saved vehicle: %s", vehicleData.plate))
                end
            end
            
            SetModelAsNoLongerNeeded(modelHash)
        end
    end
end)

-- Hilfsfunktion um Fahrzeug anhand Kennzeichen zu finden
function GetVehicleByPlate(plate)
    local vehicles = GetGamePool('CVehicle')
    for _, vehicle in pairs(vehicles) do
        if QBCore.Functions.GetPlate(vehicle) == plate then
            return vehicle
        end
    end
    return nil
end

-- Lade Fahrzeuge beim Spawn
RegisterNetEvent('QBCore:Client:OnPlayerLoaded', function()
    Wait(5000) -- Warte bis alles geladen ist
    TriggerServerEvent('vehicle-persistence:server:loadVehicles')
end)

-- jg-advanced-garage Events
RegisterNetEvent('jg-advancedgarages:client:vehicle-stored', function(data)
    -- Entferne aus Tracking wenn Fahrzeug gespeichert wird
    if data and data.plate and trackedVehicles[data.plate] then
        trackedVehicles[data.plate] = nil
        if Config.Debug then
            print(string.format("Vehicle stored, removed from tracking: %s", data.plate))
        end
    end
end)

RegisterNetEvent('jg-advancedgarages:client:vehicle-spawned', function(data)
    -- Entferne aus Tracking da Fahrzeug jetzt über Garage gespawnt wurde
    if data and data.plate and trackedVehicles[data.plate] then
        trackedVehicles[data.plate] = nil
        if Config.Debug then
            print(string.format("Vehicle spawned from garage, removed from tracking: %s", data.plate))
        end
    end
end)

-- Cleanup beim Disconnect
AddEventHandler('onResourceStop', function(resourceName)
    if resourceName == GetCurrentResourceName() then
        -- Cleanup Code hier falls nötig
        trackedVehicles = {}
    end
end)