ed

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

@@ -0,0 +1,260 @@
+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
+local function DoesVehicleBelongToPlayer(plate)
+    -- Verwende jg-advanced-garage Export
+    local vehicleData = exports['jg-advancedgarages']:GetVehicleByPlate(plate)
+    return vehicleData ~= nil
+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
+                    -- Prüfe ob Fahrzeug nicht zu nah an einer Garage ist
+                    local nearGarage = exports['jg-advancedgarages']:IsNearGarage(vehicleCoords, Config.MinGarageDistance)
+                    
+                    if not nearGarage 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
+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
+            -- Prüfe ob Position nicht in einer Garage ist
+            local nearGarage = exports['jg-advancedgarages']:IsNearGarage(vector3(position.x, position.y, position.z), Config.MinGarageDistance)
+            
+            if not nearGarage 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)
+            else
+                -- Entferne aus Datenbank da es zu nah an einer Garage ist
+                TriggerServerEvent('vehicle-persistence:server:removeVehicle', vehicleData.plate)
+            end
+        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)