644 lines
21 KiB
Lua
644 lines
21 KiB
Lua
local spawnedVehicles = {}
|
|
local preExitCoords = nil
|
|
|
|
currentlyInGarage = nil
|
|
ShellGarages = {}
|
|
existKey = nil
|
|
CurrentShellGarage = nil
|
|
|
|
local function ClearSpawnedVehicles()
|
|
for _, vehicle in pairs(spawnedVehicles) do
|
|
RemoveVehicle(vehicle)
|
|
end
|
|
spawnedVehicles = {}
|
|
end
|
|
|
|
CreateThread(function()
|
|
while "activePlayers" do
|
|
activePlayers = GetPlayers()
|
|
Wait(2000)
|
|
end
|
|
end)
|
|
|
|
RegisterNetEvent("advancedgarages:SetShellData")
|
|
AddEventHandler("advancedgarages:SetShellData", function(shellData)
|
|
currentlyShellData = shellData
|
|
end)
|
|
|
|
local function GetNextFreeVehicleSlot()
|
|
if not currentlyShellData or not currentlyShellData.vehicleCoords then return false, 0 end
|
|
for index, slot in pairs(currentlyShellData.vehicleCoords) do
|
|
if not slot.vehicle then
|
|
return slot.coords, index
|
|
end
|
|
end
|
|
return false, 0
|
|
end
|
|
|
|
local function DeleteVehicleAtSpawnCoords(coords)
|
|
for _, vehicle in pairs(GetGamePool("CVehicle")) do
|
|
local dist = #(GetEntityCoords(vehicle) - vec3(coords.x, coords.y, coords.z))
|
|
if dist < 1.0 then
|
|
Debug("Found vehicle in spawn coords, deleting it")
|
|
RemoveVehicle(vehicle)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function SpawnShellVehicles(vehicleList)
|
|
ClearSpawnedVehicles()
|
|
local playerIdentifier = GetPlayerIdentifier()
|
|
|
|
Debug("Spawning vehicles", json.encode(vehicleList))
|
|
|
|
if not currentlyShellData or not currentlyShellData.vehicleCoords or #currentlyShellData.vehicleCoords == 0 then
|
|
return Warning("No vehicle coords found for this garage")
|
|
end
|
|
|
|
local firstSlotCoords = currentlyShellData.vehicleCoords[1].coords
|
|
ClearAreaOfVehicles(firstSlotCoords.x, firstSlotCoords.y, firstSlotCoords.z, 1000.0, false, false, false, false, false)
|
|
|
|
for _, vehicleEntry in pairs(vehicleList) do
|
|
local slotCoords, slotIndex = GetNextFreeVehicleSlot()
|
|
if not slotCoords then
|
|
Notification(i18n.t("no_garage_slots"), "error")
|
|
return
|
|
end
|
|
|
|
local vehicleData = json.decode(vehicleEntry.vehicle)
|
|
if not vehicleData or not vehicleData.model then goto continue end
|
|
|
|
DeleteVehicleAtSpawnCoords(slotCoords)
|
|
|
|
local spawnPos = vec4(slotCoords.x, slotCoords.y, slotCoords.z, slotCoords.w)
|
|
local spawnedVehicle = LocalSpawnVehicle(vehicleData, spawnPos)
|
|
|
|
if vehicleEntry.owner ~= playerIdentifier then
|
|
SetVehicleDoorsLocked(spawnedVehicle, 2)
|
|
SetVehicleDoorsLockedForAllPlayers(spawnedVehicle, true)
|
|
SetVehicleDoorsLockedForPlayer(spawnedVehicle, PlayerId(), true)
|
|
SetVehicleDoorsLockedForNonScriptPlayers(spawnedVehicle, true)
|
|
end
|
|
|
|
if vehicleEntry.owner == playerIdentifier and Config.Vehiclekeys and Config.Vehiclekeys ~= "none" then
|
|
local plate = GetPlate(spawnedVehicle)
|
|
AddVehiclekeys(spawnedVehicle, plate, false)
|
|
Debug("Vehiclekeys enabled on [SpawnVehicles], keys were delivered using:", Config.Vehiclekeys, "plate:", plate)
|
|
end
|
|
|
|
table.insert(spawnedVehicles, spawnedVehicle)
|
|
|
|
if currentlyShellData then
|
|
currentlyShellData.vehicleCoords[slotIndex].vehicle = spawnedVehicle
|
|
end
|
|
|
|
::continue::
|
|
end
|
|
|
|
for i, vehicleA in pairs(spawnedVehicles) do
|
|
for j, vehicleB in pairs(spawnedVehicles) do
|
|
if i ~= j then
|
|
SetEntityNoCollisionEntity(vehicleA, vehicleB, false)
|
|
SetEntityNoCollisionEntity(vehicleB, vehicleA, false)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function TeleportPlayerToCoords(coords, vehicleData, returnCoords)
|
|
if not coords then return end
|
|
|
|
local pedPos = GetEntityCoords(cache.ped)
|
|
local pedHeading = GetEntityHeading(cache.ped)
|
|
|
|
if returnCoords then
|
|
preExitCoords = vec4(returnCoords.x, returnCoords.y, returnCoords.z, returnCoords.w)
|
|
else
|
|
preExitCoords = vec4(pedPos.x, pedPos.y, pedPos.z, pedHeading)
|
|
end
|
|
|
|
RequestCollisionAtCoord(coords.x, coords.y, coords.z)
|
|
while not HasCollisionLoadedAroundEntity(cache.ped) do
|
|
RequestCollisionAtCoord(coords.x, coords.y, coords.z)
|
|
Wait(0)
|
|
end
|
|
|
|
DoScreenFadeOut(950)
|
|
Wait(2000)
|
|
|
|
SetEntityCoords(cache.ped, coords.x, coords.y, coords.z, false, false, false, false)
|
|
SetEntityHeading(cache.ped, coords.w)
|
|
|
|
if GARAGE_SHELL then
|
|
DeleteEntity(GARAGE_SHELL)
|
|
GARAGE_SHELL = nil
|
|
if RemoveShellExit then RemoveShellExit() end
|
|
end
|
|
|
|
if not vehicleData then
|
|
DoScreenFadeIn(3000)
|
|
return
|
|
end
|
|
|
|
RemoveVehicle(cache.vehicle)
|
|
|
|
local decodedVehicle = json.decode(vehicleData.vehicle)
|
|
if not decodedVehicle then
|
|
DoScreenFadeIn(3000)
|
|
return
|
|
end
|
|
|
|
Wait(200)
|
|
|
|
local spawnedVehicle = DriveVehicle(decodedVehicle, coords)
|
|
if not spawnedVehicle then
|
|
DoScreenFadeIn(3000)
|
|
return
|
|
end
|
|
|
|
Wait(500)
|
|
|
|
local vehicleModel = GetDisplayNameFromVehicleModel(GetEntityModel(cache.vehicle))
|
|
local vehiclePlate = GetVehicleNumberPlateText(cache.vehicle)
|
|
|
|
if Config.Vehiclekeys and Config.Vehiclekeys ~= "none" then
|
|
AddVehiclekeys(vehicleModel, vehiclePlate, true)
|
|
end
|
|
|
|
if Config.Framework == "qb" then
|
|
Debug("Vehicle goes to state 0 (OUT)")
|
|
TriggerServerEvent("advancedgarages:server:updateVehicleState", 0, vehiclePlate)
|
|
end
|
|
|
|
DoScreenFadeIn(3000)
|
|
end
|
|
|
|
function ExitGarage(targetPlate)
|
|
if not currentlyShellData then
|
|
return Debug("No data found for that garage")
|
|
end
|
|
|
|
if currentlyShellData and currentlyShellData.vehicleCoords then
|
|
for _, slot in pairs(currentlyShellData.vehicleCoords) do
|
|
slot.vehicle = nil
|
|
end
|
|
end
|
|
|
|
if CloseGarageMenu then
|
|
CloseGarageMenu()
|
|
end
|
|
|
|
decorate:destroyObjects()
|
|
Wait(500)
|
|
|
|
if not preGarageCoords then
|
|
local garageConfig = Config.Garages[currentlyInGarage] or Config.JobGarages[currentlyInGarage]
|
|
if garageConfig then
|
|
local mc = garageConfig.coords.menuCoords
|
|
preGarageCoords = vec4(mc.x, mc.y, mc.z, 0.0)
|
|
else
|
|
-- Dernier recours : position par défaut sécurisée
|
|
preGarageCoords = vec4(215.0, -1000.0, -99.0, 0.0)
|
|
end
|
|
end
|
|
|
|
if not targetPlate then
|
|
currentlyInGarage = nil
|
|
currentlyShellData = nil
|
|
ClearSpawnedVehicles()
|
|
TeleportPlayerToCoords(preGarageCoords)
|
|
return
|
|
end
|
|
|
|
local vehicleData = lib.callback.await("advancedgarages:GetVehicleFromPlate", false, targetPlate)
|
|
TeleportPlayerToCoords(preGarageCoords, vehicleData)
|
|
|
|
TriggerServerEvent("advancedgarages:leaveShellgarage", currentlyInGarage)
|
|
preGarageCoords = nil
|
|
currentlyInGarage = nil
|
|
currentlyShellData = nil
|
|
|
|
SetTimeout(1500, function()
|
|
ClearSpawnedVehicles()
|
|
end)
|
|
|
|
if not vehicleData then
|
|
Notification(i18n.t("no_vehicle_data"), "error")
|
|
return
|
|
end
|
|
|
|
if Config.Vehiclekeys == "qs-vehiclekeys" then
|
|
exports["qs-vehiclekeys"]:disableHotwire(false)
|
|
end
|
|
end
|
|
|
|
function GotoGarage(garageId, spawnCoords, shellConfig)
|
|
if not garageId then
|
|
return Debug("No garage found")
|
|
end
|
|
|
|
if currentlyInGarage then
|
|
return Notification(i18n.t("you_are_already_in_garage"), "error")
|
|
end
|
|
|
|
preGarageCoords = vec4(GetEntityCoords(cache.ped), GetEntityHeading(cache.ped))
|
|
|
|
if type(shellConfig) ~= "table" then
|
|
local garageData = Config.Garages[garageId]
|
|
if garageData then
|
|
if garageData.shell then
|
|
shellConfig = garageData.shell
|
|
end
|
|
else
|
|
local shellGarage = ShellGarages[garageId]
|
|
if shellGarage and shellGarage.shell then
|
|
shellConfig = shellGarage.shell
|
|
elseif spawnCoords then
|
|
SetEntityCoords(cache.ped, spawnCoords.x, spawnCoords.y, spawnCoords.z, false, false, false, false)
|
|
local heading = spawnCoords.w or 0.0
|
|
SetEntityHeading(cache.ped, heading)
|
|
TriggerServerEvent("advancedgarages:RoutePlayerDefault", garageId)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
local interiorType = "ipl"
|
|
if shellConfig and shellConfig.exitCoords ~= nil then
|
|
interiorType = "shell"
|
|
end
|
|
|
|
Debug("You entered the shell id:", json.encode(shellConfig))
|
|
|
|
customGarageId = shellConfig and shellConfig.shell or 1
|
|
|
|
if interiorType == "shell" then
|
|
local shellModelData = Config.Shells[shellConfig.shell]
|
|
if not shellModelData then
|
|
return Notification(i18n.t("shell_not_found"), "error")
|
|
end
|
|
end
|
|
|
|
TriggerServerEvent("advancedgarages:RoutePlayer", garageId)
|
|
Wait(150)
|
|
currentlyInGarage = garageId
|
|
|
|
if not nearbyGarageType then
|
|
local gData = Config.Garages[garageId]
|
|
nearbyGarageType = (gData and gData.type) or "vehicle"
|
|
end
|
|
|
|
if interiorType == "shell" then
|
|
local shellModelData = Config.Shells[shellConfig.shell]
|
|
if not shellModelData then
|
|
Notification(i18n.t("shell_not_found"), "error")
|
|
end
|
|
|
|
currentlyShellData = {
|
|
entry = shellConfig.exitCoords,
|
|
vehicleCoords = shellConfig.vehicleCoords
|
|
}
|
|
|
|
local shellModel = shellModelData.model
|
|
local shellObject = CreateShell(shellConfig.coords, shellConfig.exitCoords, shellModel)
|
|
GARAGE_SHELL = shellObject
|
|
|
|
CreateThread(function()
|
|
while GARAGE_SHELL do
|
|
Wait(0)
|
|
end
|
|
end)
|
|
|
|
if InitShellExit then
|
|
InitShellExit(shellConfig.exitCoords)
|
|
else
|
|
local exitText = i18n.t("drawtext.back_garage")
|
|
CreateThread(function()
|
|
while GARAGE_SHELL do
|
|
if not shellConfig or not shellConfig.exitCoords then break end
|
|
|
|
local waitTime = 500
|
|
local pedPos = GetEntityCoords(cache.ped)
|
|
local exitCoords = vec3(shellConfig.exitCoords.x, shellConfig.exitCoords.y, shellConfig.exitCoords.z)
|
|
local distToExit = #(pedPos - exitCoords)
|
|
|
|
if distToExit <= 5 then
|
|
waitTime = 0
|
|
DrawText3D(shellConfig.exitCoords.x, shellConfig.exitCoords.y, shellConfig.exitCoords.z + 0.5, exitText, "exit_garage", "E")
|
|
-- Touche E (38), ESC (200) ou BACKSPACE (177) pour sortir
|
|
if IsControlJustPressed(0, 38) or IsControlJustPressed(0, 200) or IsControlJustPressed(0, 177) then
|
|
ExitGarage()
|
|
end
|
|
end
|
|
|
|
Wait(waitTime)
|
|
end
|
|
end)
|
|
end
|
|
else
|
|
local showroomData = Config.VehicleShowRooms[nearbyGarageType]
|
|
currentlyShellData = showroomData[customGarageId]
|
|
TeleportPlayerToCoords(currentlyShellData.entry, nil, spawnCoords)
|
|
end
|
|
|
|
TriggerServerEvent("advancedgarages:enterShellgarage", garageId, spawnCoords, customGarageId)
|
|
|
|
local vehicleList = lib.callback.await("advancedgarages:GetShellVehicleList", false, garageId)
|
|
if not vehicleList then vehicleList = {} end
|
|
|
|
if Config.Vehiclekeys == "qs-vehiclekeys" then
|
|
exports["qs-vehiclekeys"]:disableHotwire(true)
|
|
end
|
|
|
|
SpawnShellVehicles(vehicleList)
|
|
decorate:getObjects(currentlyInGarage)
|
|
end
|
|
|
|
function GotoShellGarage(garageId, spawnCoords, shellConfig)
|
|
if not garageId then return end
|
|
if currentlyInGarage then
|
|
return Notification(i18n.t("you_are_already_in_garage"), "error")
|
|
end
|
|
GotoGarage(garageId, spawnCoords, shellConfig)
|
|
end
|
|
|
|
RegisterNetEvent("advancedgarages:enterShellGarage")
|
|
AddEventHandler("advancedgarages:enterShellGarage", GotoShellGarage)
|
|
|
|
AddEventHandler("onResourceStop", function(resourceName)
|
|
if resourceName ~= GetCurrentResourceName() then return end
|
|
ClearPedTasks(cache.ped)
|
|
ClearSpawnedVehicles()
|
|
end)
|
|
|
|
CreateThread(function()
|
|
Wait(1251)
|
|
if Config.Weather and Config.Weather ~= "none" then return end
|
|
TriggerEvent("advancedgarages:GetWeatherSync", false)
|
|
end)
|
|
|
|
local function TriggerExitGarage(plate)
|
|
ExitGarage(plate)
|
|
end
|
|
|
|
CreateThread(function()
|
|
local function CheckVehicleExitTrigger(vehicle)
|
|
if cache.vehicle ~= vehicle then return end
|
|
if GetEntitySpeed(vehicle) > 1.0 then
|
|
local plate = GetPlate(vehicle)
|
|
if lib.callback.await("advancedgarages:checkTimeout", false) then
|
|
Warning("You can not take out the vehicle, Another player is taking out a vehicle from the garage")
|
|
return
|
|
end
|
|
TriggerExitGarage(plate)
|
|
Wait(2000)
|
|
end
|
|
end
|
|
|
|
while true do
|
|
local waitTime = 500
|
|
if preExitCoords and cache.vehicle then
|
|
waitTime = 20
|
|
for _, vehicle in pairs(spawnedVehicles) do
|
|
CheckVehicleExitTrigger(vehicle)
|
|
end
|
|
end
|
|
Wait(waitTime)
|
|
end
|
|
end)
|
|
|
|
function GetNearbyShellGarage()
|
|
local pedCoords = GetEntityCoords(cache.ped)
|
|
for garageId, garageData in pairs(ShellGarages) do
|
|
local dist = #(pedCoords - vec3(garageData.takeVehicle.x, garageData.takeVehicle.y, garageData.takeVehicle.z))
|
|
if dist < 5.0 then
|
|
return garageId
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local isInfoCardVisible = false
|
|
local currentInfoVehicle = false
|
|
|
|
function CloseUI()
|
|
if not isInfoCardVisible then return end
|
|
isInfoCardVisible = false
|
|
currentInfoVehicle = false
|
|
SendReactMessage("toggle_info_card", { visible = false })
|
|
end
|
|
|
|
CreateThread(function()
|
|
local function UpdateInfoCard(vehicle)
|
|
if not DoesEntityExist(vehicle) or not cache.vehicle then
|
|
CloseUI()
|
|
return
|
|
end
|
|
|
|
local vehicleCoords = GetEntityCoords(vehicle)
|
|
local pedCoords = GetEntityCoords(cache.ped)
|
|
local dist = #(vehicleCoords - pedCoords)
|
|
|
|
if dist > 2.5 then
|
|
if isInfoCardVisible and currentInfoVehicle == vehicle then
|
|
CloseUI()
|
|
end
|
|
return
|
|
end
|
|
|
|
if IsPauseMenuActive() then
|
|
if isInfoCardVisible then CloseUI() end
|
|
return
|
|
end
|
|
|
|
if isInfoCardVisible then return end
|
|
|
|
local stats = GetVehicleStats(vehicle)
|
|
if not isInfoCardVisible then
|
|
isInfoCardVisible = true
|
|
currentInfoVehicle = vehicle
|
|
SendReactMessage("toggle_info_card", { visible = true, stats = stats })
|
|
end
|
|
|
|
if currentInfoVehicle ~= vehicle then
|
|
SendReactMessage("toggle_info_card", { visible = true, stats = stats })
|
|
Debug("Vehicle changed, sending new stats", "currentlyVisibleVehicle", currentInfoVehicle, "vehicle", vehicle)
|
|
end
|
|
|
|
currentInfoVehicle = vehicle
|
|
end
|
|
|
|
while true do
|
|
local waitTime = 100
|
|
if #spawnedVehicles > 0 then
|
|
for _, vehicle in pairs(spawnedVehicles) do
|
|
UpdateInfoCard(vehicle)
|
|
end
|
|
end
|
|
Wait(waitTime)
|
|
end
|
|
end)
|
|
|
|
nearbyElevator = nil
|
|
|
|
if not Config.UseTarget or Config.UseTarget == "none" or Config.UseTarget == "qb-radialmenu" then
|
|
local exitText = i18n.t("drawtext.back_garage")
|
|
|
|
CreateThread(function()
|
|
local function CheckNearbyElevator()
|
|
local waitTime = 500
|
|
if not nearbyGarageType or nearbyGarageType == "boat" then
|
|
return waitTime
|
|
end
|
|
|
|
local showrooms = Config.VehicleShowRooms[nearbyGarageType]
|
|
local pedCoords = GetEntityCoords(cache.ped)
|
|
|
|
for _, showroom in pairs(showrooms) do
|
|
local dist = #(pedCoords - vec3(showroom.entry.x, showroom.entry.y, showroom.entry.z))
|
|
if dist <= 20.0 then
|
|
waitTime = 0
|
|
if dist <= 3.0 then
|
|
if Config.UseTarget ~= "qb-radialmenu" then
|
|
DrawText3D(showroom.entry.x, showroom.entry.y, showroom.entry.z + 0.5, exitText, "back_garage", "E")
|
|
if IsControlJustPressed(0, Keys.E) then
|
|
ExitGarage()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return waitTime
|
|
end
|
|
|
|
nearbyElevator = CheckNearbyElevator
|
|
|
|
while true do
|
|
local waitTime = nearbyElevator()
|
|
Wait(waitTime)
|
|
end
|
|
end)
|
|
end
|
|
|
|
CreateThread(function()
|
|
DoScreenFadeIn(500)
|
|
end)
|
|
|
|
RegisterNetEvent("advancedgarages:SetShellGarageData")
|
|
AddEventHandler("advancedgarages:SetShellGarageData", function(garageId, hasKey)
|
|
Debug("haskey", hasKey)
|
|
CurrentShellGarage = garageId
|
|
existKey = hasKey
|
|
end)
|
|
|
|
RegisterNetEvent("advancedgarages:GetShellGarageData")
|
|
AddEventHandler("advancedgarages:GetShellGarageData", function(shellGarages)
|
|
ShellGarages = shellGarages
|
|
if Config.UseTarget and Config.UseTarget ~= "none" and Config.UseTarget ~= "qb-radialmenu" then
|
|
InitShellGarages()
|
|
end
|
|
end)
|
|
|
|
RegisterNetEvent("advancedgarages:AddShellGarage")
|
|
AddEventHandler("advancedgarages:AddShellGarage", function(garageId, garageData)
|
|
Debug("Housing shell added", json.encode(garageData))
|
|
ShellGarages[garageId] = garageData
|
|
if Config.UseTarget and Config.UseTarget ~= "none" and Config.UseTarget ~= "qb-radialmenu" then
|
|
InitShellGarages()
|
|
end
|
|
end)
|
|
|
|
function CreateGarage(garageId, garageData)
|
|
if not garageId or not garageData then
|
|
return Warning("Invalid garage data")
|
|
end
|
|
if not garageData.coords then
|
|
return Warning("You must create a coords for garage")
|
|
end
|
|
if not garageData.coords.menuCoords or not garageData.coords.spawnCoords then
|
|
return Warning("Invalid garage data")
|
|
end
|
|
if not garageData.type then
|
|
garageData.type = "vehicle"
|
|
Warning("Garage type not found, setted to default (vehicle)")
|
|
end
|
|
if not garageData.shell then
|
|
garageData.shell = { shell = 1 }
|
|
Warning("Garage shell not found, setted to default (1)")
|
|
end
|
|
if not garageData.price then
|
|
garageData.price = 0
|
|
Warning("Garage price not found, setted to default (0)")
|
|
end
|
|
if not garageData.isImpound then
|
|
garageData.isImpound = false
|
|
Warning("Garage isImpound not found, setted to default (false)")
|
|
end
|
|
if not garageData.available then
|
|
garageData.available = true
|
|
Warning("Garage available not found, setted to default (true)")
|
|
end
|
|
|
|
if Config.Garages[garageId] then
|
|
return Error("Garage already exists")
|
|
end
|
|
|
|
Debug("Creating garage", garageData)
|
|
TriggerServerEvent("advancedgarages:AddGarage", garageId, garageData)
|
|
end
|
|
exports("CreateGarage", CreateGarage)
|
|
|
|
if not Config.UseTarget or Config.UseTarget == "none" or Config.UseTarget == "qb-radialmenu" then
|
|
local storeText = i18n.t("drawtext.store_vehicle")
|
|
local enterText = i18n.t("drawtext.enter_garage")
|
|
|
|
CreateThread(function()
|
|
local function CheckNearbyGarage()
|
|
local waitTime = 500
|
|
if not CurrentShellGarage or not existKey then return waitTime end
|
|
if not ShellGarages then return waitTime end
|
|
|
|
local shellData = ShellGarages[CurrentShellGarage]
|
|
if not shellData then return waitTime end
|
|
|
|
local takeVehicleCoords = shellData.takeVehicle
|
|
local shellId = shellData.shell
|
|
if not takeVehicleCoords or not takeVehicleCoords.x then return waitTime end
|
|
|
|
local pedCoords = GetEntityCoords(cache.ped)
|
|
local dist = #(pedCoords - vec3(takeVehicleCoords.x, takeVehicleCoords.y, takeVehicleCoords.z))
|
|
|
|
if dist > 6.0 then return waitTime end
|
|
waitTime = 0
|
|
|
|
if Config.UseTarget ~= "qb-radialmenu" then
|
|
if cache.vehicle then
|
|
DrawMarkerZone(takeVehicleCoords.x, takeVehicleCoords.y, takeVehicleCoords.z - 1)
|
|
DrawText3D(takeVehicleCoords.x, takeVehicleCoords.y, takeVehicleCoords.z + 0.5, storeText, "store_vehicle", "E")
|
|
if IsControlJustPressed(0, 38) then
|
|
nearbyGarageType = "vehicle"
|
|
SaveVehicle(CurrentShellGarage, true)
|
|
end
|
|
else
|
|
DrawText3D(takeVehicleCoords.x, takeVehicleCoords.y, takeVehicleCoords.z + 0.5, enterText, "enter_garage", "E")
|
|
if IsControlJustPressed(0, 38) then
|
|
nearbyGarageType = "vehicle"
|
|
local heading = takeVehicleCoords.h or takeVehicleCoords.w
|
|
GotoGarage(CurrentShellGarage, vec4(takeVehicleCoords.x, takeVehicleCoords.y, takeVehicleCoords.z, heading), shellId)
|
|
end
|
|
end
|
|
end
|
|
|
|
return waitTime
|
|
end
|
|
|
|
CheckNearbyGarage = CheckNearbyGarage
|
|
|
|
while true do
|
|
local waitTime = CheckNearbyGarage()
|
|
Wait(waitTime)
|
|
end
|
|
end)
|
|
end
|