1179 lines
35 KiB
Lua
1179 lines
35 KiB
Lua
|
|
local SPAWN_TIMEOUT = 10000
|
|
local SPAWN_DISTANCE = 200
|
|
|
|
-- optimize Lua functions
|
|
local math_floor = math.floor
|
|
local table_concat = table.concat
|
|
local os_time, os_difftime, os_nanotime = os.time, os.difftime, os.nanotime
|
|
local json_encode, json_decode = json.encode, json.decode
|
|
|
|
-- optimize natives
|
|
local GetAllVehicles, GetGameTimer, DoesEntityExist, CreateVehicleServerSetter, DeleteEntity, NetworkGetEntityOwner, NetworkGetNetworkIdFromEntity, NetworkGetEntityFromNetworkId,
|
|
GetEntityRoutingBucket, SetEntityRoutingBucket, SetEntityOrphanMode, GetEntityCoords, GetEntityRotation, GetVehicleDoorLockStatus,
|
|
GetEntityType, GetVehicleType, GetVehicleNumberPlateText, IsEntityPositionFrozen, GetPlayerIdentifierByType, GetEntityFromStateBagName, GetInvokingResource =
|
|
GetAllVehicles, GetGameTimer, DoesEntityExist, CreateVehicleServerSetter, DeleteEntity, NetworkGetEntityOwner, NetworkGetNetworkIdFromEntity, NetworkGetEntityFromNetworkId,
|
|
GetEntityRoutingBucket, SetEntityRoutingBucket, SetEntityOrphanMode, GetEntityCoords, GetEntityRotation, GetVehicleDoorLockStatus,
|
|
GetEntityType, GetVehicleType, GetVehicleNumberPlateText, IsEntityPositionFrozen, GetPlayerIdentifierByType, GetEntityFromStateBagName, GetInvokingResource
|
|
|
|
-- list of all detected state bags on vehicle entities
|
|
local stateBagList = {}
|
|
|
|
-- list of vehicles that fail to spawn and how often it happened
|
|
local failedSpawnList = {}
|
|
|
|
local Ox = GetResourceState("ox_core") == "started" and exports["ox_core"] or nil
|
|
|
|
|
|
|
|
-- script start up
|
|
CreateThread(function()
|
|
CreateAndReadFromStorage()
|
|
|
|
if (Cleanup.onScriptStart) then
|
|
CleanupProcess()
|
|
end
|
|
|
|
StartMainLoop()
|
|
end)
|
|
|
|
-- get all vehicles from the database
|
|
function CreateAndReadFromStorage()
|
|
Storage.Create()
|
|
|
|
local rows = Storage.GetAllVehicles()
|
|
|
|
Log("Found %s saved vehicles in database.", #rows)
|
|
|
|
local loadedVehicles = GetLoadedVehiclesWithId(GetAllVehicles())
|
|
|
|
for i, row in ipairs(rows) do
|
|
local tuning = json_decode(row.tuning)
|
|
if (not tuning) then
|
|
LogDebug("Vehicle \"%s\" has no tuning defined, skipping.", row.id)
|
|
goto skipEntry
|
|
end
|
|
if (not tuning[1] or tuning[1]:len() < 8) then
|
|
LogDebug("Vehicle \"%s\" has an invalid plate defined, skipping.", row.id)
|
|
goto skipEntry
|
|
end
|
|
if (not row.model) then
|
|
LogDebug("Vehicle \"%s\" (\"%s\") has no model defined, skipping.", row.id, tuning[1])
|
|
goto skipEntry
|
|
end
|
|
if (not row.type) then
|
|
LogDebug("Vehicle \"%s\" (\"%s\") has no type defined, skipping.", row.id, tuning[1])
|
|
goto skipEntry
|
|
end
|
|
local status = json_decode(row.status)
|
|
if (not status) then
|
|
LogDebug("Vehicle \"%s\" (\"%s\") has no status defined, skipping.", row.id, tuning[1])
|
|
goto skipEntry
|
|
end
|
|
local position = vector3(row.posX, row.posY, row.posZ)
|
|
if (#(vector3(0,0,0) - position) < 1.0) then
|
|
LogDebug("Vehicle \"%s\" (\"%s\") detected at origin, skipping.", row.id, tuning[1])
|
|
goto skipEntry
|
|
end
|
|
|
|
savedVehicles[row.id] = {
|
|
handle = nil,
|
|
model = row.model,
|
|
type = row.type,
|
|
status = status,
|
|
tuning = tuning,
|
|
extraValues = json_decode(row.extraValues),
|
|
stateBags = ChangeTablesToVector(json_decode(row.stateBags)),
|
|
bucket = row.bucket,
|
|
--attachedTo = json_decode(row.attachedTo),
|
|
--attachedVehicles = {},
|
|
position = position,
|
|
rotation = vector3(row.rotX, row.rotY, row.rotZ),
|
|
lastUpdate = row.lastUpdate,
|
|
initialPlayer = row.initialPlayer,
|
|
lastPlayer = row.lastPlayer,
|
|
spawning = false
|
|
}
|
|
|
|
if (loadedVehicles[row.id]) then
|
|
-- if vehicle exists, add handle
|
|
savedVehicles[row.id].handle = loadedVehicles[row.id]
|
|
|
|
LogDebug("Found vehicle \"%s\" (\"%s\") at %s", row.id, tuning[1], RoundVector3(GetEntityCoords(savedVehicles[row.id].handle), 2))
|
|
else
|
|
-- ... otherwise add to spawn queue
|
|
spawnQueue[row.id] = true
|
|
end
|
|
|
|
-- add state bags to list
|
|
for bagName, _ in pairs(savedVehicles[row.id].stateBags) do
|
|
if (not stateBagList[bagName]) then
|
|
stateBagList[bagName] = true
|
|
end
|
|
end
|
|
|
|
::skipEntry::
|
|
end
|
|
|
|
-- handle attached vehicles
|
|
--for id, vehicleData in pairs(savedVehicles) do
|
|
-- if (vehicleData.attachedTo[1]) then
|
|
-- table_insert(savedVehicles[vehicleData.attachedTo[1]].attachedVehicles, { id, vehicleData.attachedTo[2], vehicleData.attachedTo[3] })
|
|
-- end
|
|
--end
|
|
end
|
|
|
|
-- main loop for spawning and updating vehicles
|
|
function StartMainLoop()
|
|
CreateThread(function()
|
|
while (true) do
|
|
Wait(5000)
|
|
|
|
local players = GetPlayers()
|
|
if (#players > 0) then
|
|
local playerPedsWithHandlers = GetAllPlayerPedsWithHandles(players)
|
|
local playerPeds = GetAllPlayerPeds()
|
|
|
|
SpawnVehicles(players, playerPedsWithHandlers)
|
|
UpdateVehicles(players, playerPedsWithHandlers, playerPeds)
|
|
end
|
|
end
|
|
end)
|
|
end
|
|
|
|
-- try spawning vehicles
|
|
function SpawnVehicles(players, playerPedsWithHandlers)
|
|
-- check if any vehicle needs respawning
|
|
for id, _ in pairs(spawnQueue) do
|
|
if (not savedVehicles[id].spawnTime and savedVehicles[id].handle == nil and GetClosestPlayer(savedVehicles[id].position, SPAWN_DISTANCE, players, playerPedsWithHandlers, savedVehicles[id].bucket)) then
|
|
-- vehicle not found, spawn it when player is close
|
|
CreateThread(function()
|
|
SpawnVehicle(id, savedVehicles[id])
|
|
end)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- update vehicles
|
|
function UpdateVehicles(players, playerPedsWithHandlers, playerPeds)
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
local exists = vehicleData.handle and DoesEntityExist(vehicleData.handle)
|
|
if (exists and GetClosestPlayer(vehicleData.position, 150.0, players, playerPedsWithHandlers, vehicleData.bucket) and NetworkGetEntityOwner(vehicleData.handle) ~= -1) then
|
|
TryUpdateVehicle(id, vehicleData, playerPeds)
|
|
elseif (not exists and not spawnQueue[id]) then
|
|
spawnQueue[id] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
|
|
-- handle removal of entities if not from AP itself
|
|
AddEventHandler("entityRemoved", function(entity)
|
|
if (GetEntityType(entity) ~= 2) then return end
|
|
|
|
local position = GetEntityCoords(entity)
|
|
local rotation = GetEntityRotation(entity)
|
|
|
|
local id = Entity(entity)?.state?.ap_id
|
|
if (not id or not savedVehicles[id]) then return end
|
|
|
|
savedVehicles[id].position = position
|
|
savedVehicles[id].rotation = rotation
|
|
|
|
savedVehicles[id].handle = nil
|
|
savedVehicles[id].spawnTime = nil
|
|
|
|
spawnQueue[id] = true
|
|
|
|
UpdateVehicleInDB(id, savedVehicles[id], "entityRemoved event")
|
|
end)
|
|
|
|
local function IsInBounds(value, min, max)
|
|
return value >= min and value <= max
|
|
end
|
|
|
|
-- check if update is necessary and update
|
|
function TryUpdateVehicle(id, vehicleData, playerPeds, ignorePlayerInside)
|
|
local vehicle = vehicleData.handle
|
|
|
|
if ((not ignorePlayerInside and IsAnyPlayerInsideVehicle(vehicle, playerPeds)) or Entity(vehicle)?.state?.ap_trailer) then return end
|
|
|
|
if (GetVehicleNumberPlateText(vehicle) ~= vehicleData.tuning[1]) then
|
|
LogDebug("Faulty data on vehicle \"%s\" (\"%s\"). Respawning with correct data.", id, vehicleData.tuning[1])
|
|
|
|
DeleteEntity(vehicle)
|
|
savedVehicles[id].handle = nil
|
|
spawnQueue[id] = true
|
|
return
|
|
end
|
|
|
|
if (forceUnfreezeVehicles and not vehicleData.isFrozen and IsEntityPositionFrozen(vehicle)) then
|
|
FreezeEntityPosition(vehicle, false)
|
|
LogDebug("Unfreezing vehicle \"%s\" (\"%s\")", id, vehicleData.tuning[1])
|
|
end
|
|
|
|
local newPos = RoundVector3(GetEntityCoords(vehicle), 2)
|
|
local newRot = RoundVector3(GetEntityRotation(vehicle), 2)
|
|
local newLockStatus = GetVehicleDoorLockStatus(vehicle)
|
|
--local attachedToEntity = GetEntityAttachedTo(vehicle)
|
|
|
|
local status = vehicleData.status
|
|
|
|
local posChange = not vehicleData.extraValues.boatAnchor and #(vehicleData.position - newPos) > 1.0
|
|
local rotChange = GetRotationDifference(vehicleData.rotation, newRot) > 15.0
|
|
local lockChange = newLockStatus ~= status[7] and not ((newLockStatus == 0 and status[7] == 1) or (newLockStatus == 1 and status[7] == 0))
|
|
--local attachmentChange = attachedToEntity ~= vehicleData.attachedTo[1]
|
|
|
|
--if (attachmentChange and attachedToEntity and DoesEntityExist(attachedToEntity)) then
|
|
-- local attachedTo_Id = Entity(attachedToEntity).state.ap_id
|
|
-- if (attachedTo_Id and savedVehicles[attachedTo_Id]) then
|
|
-- if (not savedVehicles[attachedTo_Id].attachedVehicles) then
|
|
-- savedVehicles[attachedTo_Id].attachedVehicles = {}
|
|
-- end
|
|
--
|
|
-- table_insert(savedVehicles[attachedTo_Id].attachedVehicles, { id, newPos, newRot })
|
|
-- end
|
|
--end
|
|
|
|
if (posChange or rotChange or lockChange or attachmentChange) then
|
|
local reasons = { "Server side:" }
|
|
if (posChange) then reasons[#reasons + 1] = (" - Position from %s to %s"):format(vehicleData.position, newPos) end
|
|
if (rotChange) then reasons[#reasons + 1] = (" - Rotation from %s to %s"):format(vehicleData.rotation, newRot) end
|
|
if (lockChange) then reasons[#reasons + 1] = (" - Door lock state from %s to %s"):format(status[7], newLockStatus) end
|
|
--if (attachmentChange) then reasons[#reasons + 1] = ("Attached from: \"%s\" to \"%s\""):format(vehicleData.attachedTo, attachedToEntity) end
|
|
|
|
vehicleData.position = newPos
|
|
vehicleData.rotation = newRot
|
|
vehicleData.status[7] = newLockStatus
|
|
--vehicleData.attachedTo = attachedToEntity
|
|
|
|
vehicleData.lastUpdate = os_time()
|
|
|
|
UpdateVehicleInDB(id, vehicleData, table_concat(reasons, "\n"))
|
|
end
|
|
end
|
|
|
|
local function AddVehicleToFailedSpawns(id)
|
|
if (not failedSpawnList[id]) then
|
|
failedSpawnList[id] = 1
|
|
else
|
|
failedSpawnList[id] += 1
|
|
end
|
|
|
|
if (failedSpawnList[id] >= 5) then
|
|
failedSpawnList[id] = nil
|
|
LogWarning("There seems to be an issue spawning vehicle \"%s\" (\"%s\")", id, savedVehicles[id].tuning[1])
|
|
end
|
|
end
|
|
|
|
-- spawn a vehicle from its data
|
|
function SpawnVehicle(id, vehicleData)
|
|
if (vehicleData.model == nil) then return end
|
|
|
|
LogDebug("Creating vehicle \"%s\" (\"%s\") at %s", id, vehicleData.tuning[1], vehicleData.position)
|
|
|
|
vehicleData.spawnTime = os_nanotime()
|
|
|
|
local vehicle = nil
|
|
if (Ox and vehicleData.extraValues.oxId) then
|
|
vehicle = Ox:SpawnVehicle(vehicleData.extraValues.oxId, vehicleData.position, vehicleData.rotation.z)?.entity
|
|
|
|
if (not vehicle) then
|
|
LogDebug("OxVehicle %s does not exist anymore. Deleting from data.", vehicleData.extraValues.oxId)
|
|
DeleteVehiclesFromDB(id)
|
|
savedVehicles[id] = nil
|
|
spawnQueue[id] = nil
|
|
return
|
|
end
|
|
else
|
|
vehicle = CreateVehicleServerSetter(vehicleData.model, vehicleData.type, vehicleData.position.x, vehicleData.position.y, vehicleData.position.z, vehicleData.rotation.z)
|
|
end
|
|
|
|
local timer = GetGameTimer()
|
|
if (not WaitUntilVehicleExists(vehicle, 5000)) then
|
|
LogDebug("Vehicle didn't exist after spawning \"%s\" (\"%s\")", id, vehicleData.tuning[1])
|
|
|
|
vehicleData.spawnTime = nil
|
|
|
|
AddVehicleToFailedSpawns(id)
|
|
|
|
return
|
|
end
|
|
if (not WaitUntilVehicleHasPlateData(vehicle, 5000)) then
|
|
LogDebug("No plate set while spawning \"%s\" (\"%s\")", id, vehicleData.tuning[1])
|
|
if (DoesEntityExist(vehicle)) then
|
|
DeleteEntity(vehicle)
|
|
end
|
|
|
|
vehicleData.spawnTime = nil
|
|
|
|
AddVehicleToFailedSpawns(id)
|
|
|
|
return
|
|
end
|
|
|
|
if (vehicleData.bucket) then
|
|
SetEntityRoutingBucket(vehicle, vehicleData.bucket)
|
|
elseif (DEFAULT_BUCKET ~= 0) then
|
|
SetEntityRoutingBucket(vehicle, DEFAULT_BUCKET)
|
|
end
|
|
|
|
LogDebug("Setting properties and state bags for vehicle \"%s\" (\"%s\")", id, vehicleData.tuning[1])
|
|
|
|
-- apply state bags
|
|
local state = Entity(vehicle).state
|
|
|
|
state.ap_id = id
|
|
state.ap_data = { vehicleData.tuning, vehicleData.status, vehicleData.extraValues, vehicleData.position, vehicleData.rotation }--, vehicleData.attachedTo }
|
|
|
|
state.ap_spawned = false
|
|
|
|
for bagName, bagData in pairs(vehicleData.stateBags) do
|
|
state:set(bagName, bagData, true)
|
|
|
|
if (not stateBagList[bagName]) then
|
|
stateBagList[bagName] = true
|
|
end
|
|
end
|
|
|
|
vehicleData.handle = vehicle
|
|
|
|
spawnQueue[id] = nil
|
|
|
|
local plate = savedVehicles[id].tuning[1]
|
|
|
|
local endTime = GetGameTimer() + SPAWN_TIMEOUT
|
|
while (GetGameTimer() < endTime) do
|
|
Wait(0)
|
|
|
|
if (not savedVehicles[id]) then
|
|
LogDebug("Data was deleted before vehicle \"%s\" (\"%s\") was fully created!", id, plate)
|
|
break
|
|
end
|
|
|
|
if (not DoesEntityExist(vehicle)) then
|
|
LogDebug("Vehicle \"%s\" (\"%s\") was removed during creation process!", id, plate)
|
|
break
|
|
end
|
|
|
|
if (GetVehicleNumberPlateText(vehicle) == plate and savedVehicles[id].spawnTime) then
|
|
LogDebug("Vehicle creation was successful for \"%s\" (\"%s\")! Took %.2fms", id, plate, (os_nanotime() - savedVehicles[id].spawnTime) * 0.000001)
|
|
|
|
savedVehicles[id].spawnTime = nil
|
|
Entity(vehicle).state.ap_data = nil
|
|
|
|
TriggerEvent("AP:vehicleSpawned", savedVehicles[id].handle)
|
|
|
|
return
|
|
end
|
|
end
|
|
|
|
LogDebug("Failed setting properties for vehicle \"%s\" (\"%s\")", id, plate)
|
|
|
|
AddVehicleToFailedSpawns(id)
|
|
|
|
if (DoesEntityExist(vehicle)) then
|
|
DeleteEntity(vehicle)
|
|
end
|
|
if (savedVehicles[id]) then
|
|
savedVehicles[id].handle = nil
|
|
spawnQueue[id] = true
|
|
end
|
|
end
|
|
|
|
-- triggered from client side to either update or insert a vehicle
|
|
RegisterNetEvent("AP:updateVehicle", function(networkId, model, tuning, status, extraValues, reason)
|
|
local src = source
|
|
|
|
if (not networkId or type(networkId) ~= "number") then
|
|
LogDebug("Tried to save vehicle with invalid \"networkId\"!")
|
|
return
|
|
end
|
|
if (not model or type(model) ~= "number") then
|
|
LogDebug("Tried to save vehicle with invalid \"model\"!")
|
|
return
|
|
end
|
|
if (not tuning or type(tuning) ~= "table") then
|
|
LogDebug("Tried to save vehicle with invalid \"tuning\" data!")
|
|
return
|
|
end
|
|
if (not tuning[1] or type(tuning[1]) ~= "string" or tuning[1]:len() ~= 8) then
|
|
LogDebug("Tried to save vehicle with invalid \"plate\"!")
|
|
return
|
|
end
|
|
if (not status or type(status) ~= "table") then
|
|
LogDebug("Tried to save vehicle with invalid \"status\" data!")
|
|
return
|
|
end
|
|
if (not extraValues or type(extraValues) ~= "table") then
|
|
LogDebug("Tried to save vehicle with invalid \"extraValues\" data!")
|
|
return
|
|
end
|
|
|
|
local vehicle = NetworkGetEntityFromNetworkId(networkId)
|
|
if (not DoesEntityExist(vehicle)) then
|
|
LogDebug("Tried to save entity that does not exist on server side (yet)!")
|
|
return
|
|
end
|
|
|
|
if (saveOnlyOwnedVehicles and not reason:find("Resource") and not IsOwnedVehicle(tuning[1], vehicle)) then
|
|
LogDebug("Tried to save unowned vehicle!")
|
|
return
|
|
end
|
|
|
|
local bucket = GetEntityRoutingBucket(vehicle)
|
|
if (not multiBucketSupport and bucket ~= DEFAULT_BUCKET) then
|
|
LogDebug("Tried to save vehicle from non-default routing bucket %s!", bucket)
|
|
return
|
|
end
|
|
|
|
local id = Entity(vehicle).state.ap_id
|
|
if (id and savedVehicles[id]) then
|
|
local oxId = savedVehicles[id].extraValues["oxId"]
|
|
|
|
-- already exists
|
|
savedVehicles[id].status = status
|
|
savedVehicles[id].tuning = tuning
|
|
savedVehicles[id].extraValues = extraValues
|
|
savedVehicles[id].stateBags = GetVehicleStateBags(vehicle)
|
|
savedVehicles[id].bucket = bucket
|
|
savedVehicles[id].position = RoundVector3(GetEntityCoords(vehicle), 2)
|
|
savedVehicles[id].rotation = RoundVector3(GetEntityRotation(vehicle), 2)
|
|
savedVehicles[id].lastUpdate = os_time()
|
|
savedVehicles[id].lastPlayer = GetPlayerIdentifierByType(src, "license")
|
|
|
|
if (oxId) then
|
|
savedVehicles[id].extraValues["oxId"] = oxId
|
|
end
|
|
|
|
UpdateVehicleInDB(id, savedVehicles[id], reason)
|
|
else
|
|
-- does not exist
|
|
if (preventDuplicateVehicles) then
|
|
local oldId = GetVehicleIdentifierUsingPlate(tuning[1])
|
|
if (oldId) then
|
|
DeleteVehicleUsingIdentifier(oldId)
|
|
end
|
|
end
|
|
|
|
-- enable persistence (for client spawned vehicles)
|
|
SetEntityOrphanMode(vehicle, 2)
|
|
|
|
id = GetNewVehicleIdentifier()
|
|
|
|
Entity(vehicle).state.ap_id = id
|
|
|
|
local playerIdentifier = GetPlayerIdentifierByType(src, "license")
|
|
|
|
if (Ox) then
|
|
extraValues["oxId"] = Ox:GetVehicle(vehicle).id
|
|
end
|
|
|
|
savedVehicles[id] = {
|
|
handle = vehicle,
|
|
model = model,
|
|
type = GetVehicleType(vehicle),
|
|
status = status,
|
|
tuning = tuning,
|
|
extraValues = extraValues,
|
|
stateBags = GetVehicleStateBags(vehicle),
|
|
bucket = bucket,
|
|
position = RoundVector3(GetEntityCoords(vehicle), 2),
|
|
rotation = RoundVector3(GetEntityRotation(vehicle), 2),
|
|
lastUpdate = os_time(),
|
|
initialPlayer = playerIdentifier,
|
|
lastPlayer = playerIdentifier,
|
|
spawning = false
|
|
}
|
|
|
|
InsertVehicleInDB(id, savedVehicles[id], reason)
|
|
end
|
|
end)
|
|
|
|
-- insert vehicle into database
|
|
function InsertVehicleInDB(id, vehicleData, reason)
|
|
assert(id ~= nil and type(id) == "string", "Parameter \"id\" must be a string!")
|
|
|
|
LogDebug("Inserting new vehicle \"%s\" (\"%s\") (Reason: %s)", id, vehicleData.tuning[1], reason)
|
|
|
|
Storage.InsertVehicle({
|
|
id,
|
|
vehicleData.model,
|
|
vehicleData.type,
|
|
json_encode(vehicleData.status),
|
|
json_encode(vehicleData.tuning),
|
|
json_encode(vehicleData.extraValues),
|
|
json_encode(vehicleData.stateBags),
|
|
vehicleData.bucket,
|
|
vehicleData.position.x, vehicleData.position.y, vehicleData.position.z,
|
|
vehicleData.rotation.x, vehicleData.rotation.y, vehicleData.rotation.z,
|
|
vehicleData.lastUpdate,
|
|
vehicleData.initialPlayer, vehicleData.lastPlayer
|
|
})
|
|
end
|
|
|
|
-- update vehicle in database
|
|
function UpdateVehicleInDB(id, vehicleData, reason)
|
|
assert(id ~= nil and type(id) == "string", "Parameter \"id\" must be a string!")
|
|
|
|
LogDebug("Updating vehicle \"%s\" (\"%s\") (Reason: %s)", id, vehicleData.tuning[1], reason)
|
|
|
|
Storage.UpdateVehicle({
|
|
json_encode(vehicleData.status),
|
|
json_encode(vehicleData.tuning),
|
|
json_encode(vehicleData.extraValues),
|
|
json_encode(vehicleData.stateBags),
|
|
vehicleData.bucket,
|
|
--json_encode(vehicleData.attachedTo),
|
|
vehicleData.position.x, vehicleData.position.y, vehicleData.position.z,
|
|
vehicleData.rotation.x, vehicleData.rotation.y, vehicleData.rotation.z,
|
|
vehicleData.lastUpdate,
|
|
vehicleData.lastPlayer,
|
|
id
|
|
})
|
|
end
|
|
|
|
-- delete vehicle(s) from database
|
|
function DeleteVehiclesFromDB(...)
|
|
local idList = {...}
|
|
|
|
if (type(idList[1]) == "table") then
|
|
idList = idList[1]
|
|
end
|
|
if (#idList == 0) then
|
|
return
|
|
end
|
|
|
|
local str = json_encode(idList)
|
|
str = str:sub(2, str:len() - 1)
|
|
|
|
Storage.DeleteByIds(str)
|
|
end
|
|
|
|
-- delete vehicles that are still being spawned before actually stopping the resource
|
|
AddEventHandler("onResourceStop", function(name)
|
|
if (name ~= GetCurrentResourceName()) then
|
|
return
|
|
end
|
|
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (vehicleData.spawnTime and DoesEntityExist(vehicleData.handle)) then
|
|
LogDebug("Deleted vehicle \"%s\" because it was still spawning", id)
|
|
DeleteEntity(vehicleData.handle)
|
|
end
|
|
end
|
|
end)
|
|
|
|
local function DeleteVehicleUsingData(identifier, networkId, plate, keepInWorld, resourceName)
|
|
if (identifier == nil and (networkId == nil or networkId == 0) and plate == nil) then
|
|
LogWarning("Tried to delete vehicle without \"id\", \"netId\" and \"plate\"! (Resource: \"%s\")", resourceName)
|
|
return false
|
|
end
|
|
|
|
if (identifier and DeleteVehicleUsingIdentifier(identifier, keepInWorld)) then
|
|
LogDebug("Deleting vehicle (id \"%s\"; Resource: \"%s\")", identifier, resourceName)
|
|
return true
|
|
end
|
|
if (networkId and DeleteVehicleUsingNetworkId(networkId, keepInWorld)) then
|
|
LogDebug("Deleting vehicle (netId \"%s\"; Resource: \"%s\")", networkId, resourceName)
|
|
return true
|
|
end
|
|
if (plate and DeleteVehicleUsingPlate(plate, keepInWorld)) then
|
|
LogDebug("Deleting vehicle (plate \"%s\"; Resource: \"%s\")", plate, resourceName)
|
|
return true
|
|
end
|
|
|
|
LogDebug("Deleting vehicle failed (id \"%s\", netId \"%s\", plate \"%s\"; Resource: \"%s\")", identifier, networkId, plate, resourceName)
|
|
return false
|
|
end
|
|
exports("DeleteVehicleUsingData", function(identifier, networkId, plate, keepInWorld)
|
|
return DeleteVehicleUsingData(identifier, networkId, plate, keepInWorld, GetInvokingResource())
|
|
end)
|
|
|
|
local function DeleteVehicle(vehicle, keepInWorld, resourceName)
|
|
if (not DoesEntityExist(vehicle)) then
|
|
LogWarning("Tried to delete vehicle that does not exist! (Entity \"%s\"; Resource: \"%s\")", vehicle, resourceName)
|
|
return false
|
|
end
|
|
|
|
return DeleteVehicleUsingData(Entity(vehicle).state.ap_id, NetworkGetNetworkIdFromEntity(vehicle), GetVehicleNumberPlateText(vehicle), keepInWorld, resourceName)
|
|
end
|
|
exports("DeleteVehicle", function(vehicle, keepInWorld)
|
|
return DeleteVehicle(vehicle, keepInWorld, GetInvokingResource())
|
|
end)
|
|
|
|
-- delete vehicle from client side using identifier, network id or plate
|
|
RegisterNetEvent("AP:deleteVehicle", function(identifier, networkId, plate, keepInWorld, resourceName)
|
|
DeleteVehicleUsingData(identifier, networkId, plate, keepInWorld, resourceName)
|
|
end)
|
|
|
|
-- delete vehicle using identifier
|
|
function DeleteVehicleUsingIdentifier(id, keepInWorld)
|
|
if (not savedVehicles[id]) then
|
|
return false
|
|
end
|
|
|
|
if (not keepInWorld and savedVehicles[id].handle and DoesEntityExist(savedVehicles[id].handle)) then
|
|
DeleteEntity(savedVehicles[id].handle)
|
|
end
|
|
|
|
local result, error = pcall(DeleteVehiclesFromDB, id)
|
|
if (not result) then
|
|
LogError("Error occured while calling \"DeleteVehiclesFromDB\" inside \"DeleteVehicleUsingIdentifier\"!")
|
|
LogError("Full error: %s", error)
|
|
end
|
|
|
|
savedVehicles[id] = nil
|
|
spawnQueue[id] = nil
|
|
|
|
return true
|
|
end
|
|
|
|
-- delete vehicle using network id
|
|
function DeleteVehicleUsingNetworkId(networkId, keepInWorld)
|
|
local vehicle = NetworkGetEntityFromNetworkId(networkId)
|
|
if (not DoesEntityExist(vehicle)) then
|
|
return false
|
|
end
|
|
|
|
local id = Entity(vehicle)?.state?.ap_id
|
|
if (id and savedVehicles[id]) then
|
|
if (not keepInWorld) then
|
|
DeleteEntity(vehicle)
|
|
end
|
|
|
|
DeleteVehiclesFromDB(id)
|
|
|
|
savedVehicles[id] = nil
|
|
spawnQueue[id] = nil
|
|
|
|
return true
|
|
end
|
|
|
|
if (not keepInWorld) then
|
|
DeleteEntity(vehicle)
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-- delete vehicle using plate
|
|
function DeleteVehicleUsingPlate(plate, keepInWorld)
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (vehicleData.tuning[1] == plate or Trim(vehicleData.tuning[1]) == plate) then
|
|
if (not keepInWorld and vehicleData.handle and DoesEntityExist(vehicleData.handle)) then
|
|
DeleteEntity(vehicleData.handle)
|
|
end
|
|
|
|
DeleteVehiclesFromDB(id)
|
|
|
|
savedVehicles[id] = nil
|
|
spawnQueue[id] = nil
|
|
|
|
return true
|
|
end
|
|
end
|
|
|
|
if (not keepInWorld) then
|
|
local vehicle = TryGetLoadedVehicleFromPlate(plate, GetAllVehicles())
|
|
if (vehicle and DoesEntityExist(vehicle)) then
|
|
DeleteEntity(vehicle)
|
|
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
-- update a vehicles state bags in database
|
|
function UpdateVehicleStateBagsInDB(id, stateBags)
|
|
assert(id ~= nil and type(id) == "string", "Parameter \"id\" must be a string!")
|
|
|
|
LogDebug("Updating state bags of vehicle \"%s\" (\"%s\") in database", id, savedVehicles[id].tuning[1])
|
|
|
|
Storage.UpdateStateBags({
|
|
json_encode(stateBags),
|
|
id
|
|
})
|
|
end
|
|
|
|
function GetVehicleStateBags(vehicle)
|
|
local stateBags = {}
|
|
|
|
local vehicleStateBags = Entity(vehicle).state
|
|
|
|
for bagName, _ in pairs(stateBagList) do
|
|
if (vehicleStateBags[bagName]) then
|
|
stateBags[bagName] = vehicleStateBags[bagName]
|
|
end
|
|
end
|
|
|
|
return stateBags
|
|
end
|
|
|
|
-- state bag change handler for detecting changes on a vehicle
|
|
AddStateBagChangeHandler(nil, nil, function(bagName, key, value, _unused, replicated)
|
|
if (key:find("ap_")) then return end
|
|
|
|
if (ignoreStateBags) then
|
|
for i = 1, #ignoreStateBags do
|
|
if (key:find(ignoreStateBags[i])) then return end
|
|
end
|
|
end
|
|
|
|
local entity = GetEntityFromStateBagName(bagName)
|
|
if (entity == 0 or GetEntityType(entity) ~= 2) then return end
|
|
|
|
if (not stateBagList[key]) then
|
|
stateBagList[key] = true
|
|
end
|
|
|
|
local id = Entity(entity).state.ap_id
|
|
if (not id or not savedVehicles[id]) then return end
|
|
|
|
if (IsAnyPlayerInsideVehicle(entity, GetAllPlayerPeds())) then return end
|
|
|
|
if (savedVehicles[id].stateBags[key] == nil or not TableEquals(savedVehicles[id].stateBags[key], value)) then
|
|
-- new state bag OR update
|
|
savedVehicles[id].stateBags[key] = value
|
|
|
|
if (preventStateBagAutoUpdate) then
|
|
for i = 1, #preventStateBagAutoUpdate do
|
|
if (key:find(preventStateBagAutoUpdate[i])) then return end
|
|
end
|
|
end
|
|
|
|
UpdateVehicleStateBagsInDB(id, savedVehicles[id].stateBags)
|
|
|
|
LogDebug(" Reason: Updating entity state bag \"%s\" for \"%s\". Value: %s", key, id, value)
|
|
end
|
|
end)
|
|
|
|
-- forces a vehicle to update to the database
|
|
function ForceVehicleUpdateInDB(id)
|
|
if (not id or not savedVehicles[id]) then
|
|
return
|
|
end
|
|
|
|
savedVehicles[id].lastUpdate = os_time()
|
|
UpdateVehicleInDB(id, savedVehicles[id], "Resource forced: \"" .. GetInvokingResource() .. "\"")
|
|
end
|
|
exports("ForceVehicleUpdateInDB", ForceVehicleUpdateInDB)
|
|
|
|
-- DEPRECATED: ensures a state bag is saved on the vehicle
|
|
function EnsureStateBag()
|
|
LogWarning("Executing the \"EnsureStateBag\" export is no longer necessary. Remove it from \"" .. GetInvokingResource() .. "\"!")
|
|
|
|
return false
|
|
end
|
|
exports("EnsureStateBag", EnsureStateBag)
|
|
|
|
-- returns a vehicle handle from a given state bag value
|
|
function GetVehicleFromStateBagValue(key, value)
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (TableEquals(vehicleData.stateBags[key], value)) then
|
|
return vehicleData.handle
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|
|
exports("GetVehicleFromStateBagValue", GetVehicleFromStateBagValue)
|
|
|
|
-- returns all saved state bags from a vehicle
|
|
function GetStateBagsFromVehicle(vehicle)
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (vehicleData.handle == vehicle) then
|
|
return vehicleData.stateBags
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|
|
exports("GetStateBagsFromVehicle", GetStateBagsFromVehicle)
|
|
|
|
-- returns all saved state bags from a vehicle with plate X
|
|
function GetStateBagsFromPlate(plate)
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (vehicleData.tuning[1] == plate) then
|
|
return vehicleData.stateBags
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|
|
exports("GetStateBagsFromPlate", GetStateBagsFromPlate)
|
|
|
|
-- returns all of AP's vehicle data of a specific Vehicle
|
|
function GetVehicleData(vehicle)
|
|
if (not DoesEntityExist(vehicle)) then return nil end
|
|
|
|
local id = Entity(vehicle).state.ap_id
|
|
if (not id) then return nil end
|
|
|
|
return savedVehicles[id]
|
|
end
|
|
exports("GetVehicleData", GetVehicleData)
|
|
|
|
-- returns all of AP's saved vehicle data of a specific Vehicle
|
|
function GetVehicleTuningFromData(vehicle)
|
|
if (not DoesEntityExist(vehicle)) then return nil end
|
|
|
|
local id = Entity(vehicle).state.ap_id
|
|
if (not id) then return nil end
|
|
|
|
return savedVehicles[id]?.tuning
|
|
end
|
|
exports("GetVehicleTuningFromData", GetVehicleTuningFromData)
|
|
|
|
-- getting a vehicle position using its plate
|
|
local function GetVehiclePosition(plate, resourceName)
|
|
if (plate == nil or type(plate) ~= "string") then
|
|
LogError("Parameter \"plate\" must be a string! (Export: \"GetVehiclePosition\"; Resource: \"%s\")", resourceName)
|
|
return
|
|
end
|
|
|
|
LogDebug("Position request for \"%s\" (Resource: \"%s\")", plate, resourceName)
|
|
|
|
plate = plate:upper()
|
|
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (vehicleData.tuning and (plate == vehicleData.tuning[1] or plate == Trim(vehicleData.tuning[1]))) then
|
|
return vehicleData.handle and DoesEntityExist(vehicleData.handle) and GetEntityCoords(vehicleData.handle) or vehicleData.position
|
|
end
|
|
end
|
|
|
|
local vehicles = GetAllVehicles()
|
|
for i = 1, #vehicles do
|
|
if (DoesEntityExist(vehicles[i])) then
|
|
local vehPlate = GetVehicleNumberPlateText(vehicles[i])
|
|
if (plate == vehPlate or plate == Trim(vehPlate)) then
|
|
return GetEntityCoords(vehicles[i])
|
|
end
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|
|
exports("GetVehiclePosition", function(plate)
|
|
return GetVehiclePosition(plate, GetInvokingResource())
|
|
end)
|
|
|
|
-- getting vehicle positions using more than one plate
|
|
local function GetVehiclePositions(plates, resourceName)
|
|
if (plates == nil or type(plates) ~= "table") then
|
|
LogError("Parameter \"plates\" must be a table! (Export: \"GetVehiclePositions\"; Resource: \"%s\")", resourceName)
|
|
return {}
|
|
end
|
|
|
|
for i = 1, #plates do
|
|
if (plates[i] == nil or type(plates[i]) ~= "string") then
|
|
LogError("Parameter \"plate\" (at index %s) must be a string! (Export: \"GetVehiclePositions\"; Resource: \"%s\")", i, resourceName)
|
|
return {}
|
|
end
|
|
|
|
plates[i] = plates[i]:upper()
|
|
end
|
|
|
|
LogDebug("Position request for \"%s\" (Resource: \"%s\")", table_concat(plates, "\", \""), resourceName)
|
|
|
|
local platePositions = {}
|
|
|
|
-- check all loaded vehicles first
|
|
local vehicles = GetAllVehicles()
|
|
for i = 1, #vehicles do
|
|
if (DoesEntityExist(vehicles[i])) then
|
|
local vehPlate = GetVehicleNumberPlateText(vehicles[i])
|
|
local trimmedVehPlate = Trim(vehPlate)
|
|
|
|
for j = 1, #plates do
|
|
if (plates[j] == vehPlate or plates[j] == trimmedVehPlate) then
|
|
platePositions[ plates[j] ] = GetEntityCoords(vehicles[i])
|
|
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- then search missing vehicles in APs saved vehicles
|
|
for i = 1, #plates do
|
|
if (platePositions[ plates[i] ] == nil) then
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
local trimmedVehPlate = Trim(vehicleData.tuning[1])
|
|
|
|
if (vehicleData.tuning and (plates[i] == vehicleData.tuning[1] or plates[i] == trimmedVehPlate)) then
|
|
platePositions[ plates[i] ] = vehicleData.position
|
|
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return platePositions
|
|
end
|
|
exports("GetVehiclePositions", function(plates)
|
|
return GetVehiclePositions(plates, GetInvokingResource())
|
|
end)
|
|
|
|
-- callbacks for client side getting of vehicle position(s)
|
|
local CB = exports["kimi_callbacks"]
|
|
CB:Register("AP:getVehiclePosition", function(source, plate, resourceName)
|
|
return GetVehiclePosition(plate, resourceName)
|
|
end)
|
|
CB:Register("AP:getVehiclePositions", function(source, plates, resourceName)
|
|
return GetVehiclePositions(plates, resourceName)
|
|
end)
|
|
|
|
-- command to delete ALL vehicles from the database table. Needs to be executed twice for security reason.
|
|
local deleteSavedVehicles = false
|
|
RegisterCommand("deleteSavedVehicles", function(source, args, raw)
|
|
if (deleteSavedVehicles) then
|
|
Storage.DeleteAllVehicles()
|
|
|
|
savedVehicles = {}
|
|
spawnQueue = {}
|
|
|
|
Log("Deleted all vehicles from the vehicle_parking table.")
|
|
else
|
|
Log("Are you sure that you want to delete all vehicles from the parking list?\nIf yes, execute the command a second time!")
|
|
end
|
|
|
|
deleteSavedVehicles = not deleteSavedVehicles
|
|
end, true)
|
|
|
|
-- command to delete ALL vehicles from the database table. Needs to be executed twice for security reason.
|
|
local deleteAndStore = false
|
|
RegisterCommand("deleteandstore", function(source, args, raw)
|
|
if (deleteAndStore) then
|
|
local ids = {}
|
|
local playerPeds = GetAllPlayerPeds()
|
|
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (vehicleData.handle and DoesEntityExist(vehicleData.handle)) then
|
|
if (IsAnyPlayerInsideVehicle(vehicleData.handle, playerPeds)) then
|
|
goto skipVeh
|
|
end
|
|
|
|
DeleteEntity(vehicleData.handle)
|
|
end
|
|
|
|
StoreVehicle(vehicleData.tuning[1], vehicleData.handle)
|
|
|
|
savedVehicles[id] = nil
|
|
spawnQueue[id] = nil
|
|
|
|
ids[#ids + 1] = id
|
|
|
|
::skipVeh::
|
|
end
|
|
|
|
DeleteVehiclesFromDB(ids)
|
|
|
|
Log("Deleted all vehicles from the vehicle_parking table.")
|
|
else
|
|
Log("Are you sure that you want to delete all vehicles from the parking list and store them?\nIf yes, execute the command a second time!")
|
|
end
|
|
|
|
deleteAndStore = not deleteAndStore
|
|
end, true)
|
|
|
|
RegisterCommand("apdv", function(src, args, raw)
|
|
local id = args[1]
|
|
if (not id) then
|
|
LogError("First argument needs to be a plate or identifier!")
|
|
return
|
|
end
|
|
|
|
local success = false
|
|
|
|
-- interpret first param as id or plate
|
|
if (id:len() == 16) then
|
|
success = DeleteVehicleUsingData(id, nil, nil, false, "Command \"apdv\"")
|
|
else
|
|
success = DeleteVehicleUsingData(nil, nil, id, false, "Command \"apdv\"")
|
|
end
|
|
|
|
if (success) then
|
|
Log("Vehicle \"%s\" deleted through command \"apdv\".", id)
|
|
else
|
|
Log("Vehicle \"%s\" could not be deleted through command \"apdv\".", id)
|
|
end
|
|
end, true)
|
|
|
|
RegisterCommand("apbring", function(playerId, args, raw)
|
|
if (playerId == 0) then
|
|
LogError("Command \"apbring\" can only be executed from client side!")
|
|
return
|
|
end
|
|
|
|
local id = args[1]
|
|
if (not id) then
|
|
LogError("Command \"apbring\": First argument needs to be a plate or identifier!")
|
|
return
|
|
end
|
|
|
|
-- check first arg if it is a plate
|
|
if (id:len() == 8) then
|
|
id = GetVehicleIdentifierUsingPlate(id)
|
|
end
|
|
|
|
if (not id or not savedVehicles[id]) then
|
|
LogError("Command \"apbring\": Vehicle could not be found!")
|
|
return
|
|
end
|
|
|
|
local ped = GetPlayerPed(playerId)
|
|
if (not DoesEntityExist(ped)) then
|
|
LogError("Command \"apbring\": Could not find ped to spawn vehicle at!")
|
|
return
|
|
end
|
|
|
|
if (savedVehicles[id].handle and DoesEntityExist(savedVehicles[id].handle)) then
|
|
DeleteEntity(savedVehicles[id].handle)
|
|
Wait(100)
|
|
end
|
|
|
|
savedVehicles[id].handle = nil
|
|
savedVehicles[id].position = GetEntityCoords(ped) + vector3(2.0, 3.0, 0.0)
|
|
savedVehicles[id].rotation = vector3(0.0, 0.0, 0.0)
|
|
|
|
Log("Vehicle \"%s\" teleported through command \"apbring\".", id)
|
|
end, true)
|
|
|
|
|
|
|
|
function UpdatePlate(networkId, newPlate, oldPlate)
|
|
if (networkId == nil) then
|
|
LogError("\"networkId\" was nil while trying to update a plate!")
|
|
return
|
|
end
|
|
if (newPlate == nil or newPlate:len() > 8) then
|
|
LogError("\"newPlate\" was nil or too long while trying to update a plate!")
|
|
return
|
|
end
|
|
|
|
-- format plates
|
|
newPlate = Trim(newPlate:upper())
|
|
if (oldPlate) then
|
|
oldPlate = Trim(oldPlate:upper())
|
|
end
|
|
|
|
-- change plate on vehicle
|
|
local vehicle = NetworkGetEntityFromNetworkId(networkId)
|
|
if (DoesEntityExist(vehicle)) then
|
|
SetVehicleNumberPlateText(vehicle, newPlate)
|
|
|
|
local found = false
|
|
while (not found) do
|
|
Wait(0)
|
|
|
|
found = Trim(GetVehicleNumberPlateText(vehicle)) == newPlate
|
|
end
|
|
|
|
newPlate = GetVehicleNumberPlateText(vehicle)
|
|
end
|
|
|
|
-- search for plate
|
|
for id, vehicleData in pairs(savedVehicles) do
|
|
if (vehicle == vehicleData.handle) then
|
|
local old = vehicleData.tuning[1]
|
|
vehicleData.tuning[1] = newPlate
|
|
|
|
UpdateVehicleInDB(id, vehicleData, "\"UpdatePlate\" export")
|
|
|
|
return
|
|
end
|
|
end
|
|
|
|
-- search for plate by using oldPlate
|
|
if (oldPlate) then
|
|
newPlate = FillPlateWithSpaces(newPlate)
|
|
|
|
for id, vehicleData in pairs(vehicles) do
|
|
if (Trim(vehicleData.tuning[1]) == oldPlate) then
|
|
vehicleData.tuning[1] = newPlate
|
|
|
|
UpdateVehicleInDB(id, vehicleData, "\"UpdatePlate\" export")
|
|
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
LogDebug("No vehicle found to change plate to \"%s\"", newPlate)
|
|
end
|
|
exports("UpdatePlate", UpdatePlate)
|
|
|
|
RegisterNetEvent("AP:updatePlate", function(networkId, newPlate)
|
|
UpdatePlate(networkId, newPlate)
|
|
end)
|
|
|
|
|
|
|
|
RegisterNetEvent("AP:enteredTrailer", function(trailerNetId)
|
|
local trailer = NetworkGetEntityFromNetworkId(trailerNetId)
|
|
if (not DoesEntityExist(trailer)) then return end
|
|
|
|
Entity(trailer).state:set("ap_trailer", true, true)
|
|
end)
|
|
|
|
RegisterNetEvent("AP:leftTrailer", function(trailerNetId)
|
|
local trailer = NetworkGetEntityFromNetworkId(trailerNetId)
|
|
if (not DoesEntityExist(trailer)) then return end
|
|
|
|
Entity(trailer).state:set("ap_trailer", nil, true)
|
|
end)
|
|
|
|
|
|
|
|
-- export and event for force freezing vehicles
|
|
if (forceUnfreezeVehicles) then
|
|
local function FreezeVehicle(vehicle, freeze)
|
|
local id = Entity(vehicle)?.state?.ap_id
|
|
if (id and savedVehicles[id]) then
|
|
savedVehicles[id].isFrozen = freeze
|
|
end
|
|
|
|
FreezeEntityPosition(vehicle, freeze)
|
|
end
|
|
exports("FreezeVehicle", FreezeVehicle)
|
|
|
|
RegisterNetEvent("AP:freezeVehicle", function(networkId, freeze)
|
|
local vehicle = NetworkGetEntityFromNetworkId(networkId)
|
|
if (not DoesEntityExist(vehicle)) then return end
|
|
|
|
FreezeVehicle(vehicle, freeze)
|
|
end)
|
|
end
|
|
|
|
AddEventHandler("onEntityBucketChange", function(entity, newBucket, oldBucket)
|
|
if (GetEntityType(entity) ~= 2) then return end
|
|
|
|
local id = Entity(entity).state.ap_id
|
|
if (not id or not savedVehicles[id]) then return end
|
|
if (savedVehicles[id].bucket == newBucket) then return end
|
|
|
|
savedVehicles[id].bucket = newBucket
|
|
|
|
LogDebug("Updating vehicle \"%s\" (\"%s\") (Reason: %s)", id, savedVehicles[id].tuning[1], ("Routing bucket from %s to %s"):format(oldBucket, newBucket))
|
|
|
|
Storage.UpdateBucket(newBucket, id)
|
|
end)
|
|
|
|
RegisterNetEvent("AP:onVehicleDamage", function(networkId, status)
|
|
local vehicle = NetworkGetEntityFromNetworkId(networkId)
|
|
if (not DoesEntityExist(vehicle)) then return end
|
|
|
|
local id = Entity(vehicle).state.ap_id
|
|
if (not id or not savedVehicles[id]) then return end
|
|
|
|
savedVehicles[id].status = status
|
|
|
|
LogDebug("Updating status for vehicle \"%s\" (\"%s\") (Reason: %s)", id, savedVehicles[id].tuning[1], "Vehicle damage")
|
|
|
|
Storage.UpdateStatus(json_encode(status), id)
|
|
end)
|