Files
fs25-adsmartpickup/FS25_ADSmartPickup/adSaltRoute.lua
T

512 lines
26 KiB
Lua

-- AD Salt Route
-- Fuldautomatisk saltning i sne (brugerønske 21/10: "lav den fuldautomatisk" — salt alle gårde først, så de AD-veje
-- flowene bruger). Indstillingen autoSalt (Generelt). Når der ligger ny sne, tager moden gårdens saltspreder (selvkørende,
-- eller et redskab på en lånt traktor via P + Connect som kreaturvognene), fylder vejsalt, hvis der er under en fjerdedel
-- tilbage, og kører AD-markør for markør med sprederen tændt: først markørerne ved gårdens egne bygninger, så flowenes
-- kilder, mål, lagre og fodringsbygninger — hver gruppe som nærmeste-nabo-rute. Bagefter hjem. Ét saltjob ad gangen.
-- Ren logik øverst (testes med luajit), spil-adapter nederst. Intet gemmes: efter en genindlæsning saltes én gang til.
local function logInfo(...) return (ADLog or Logging).info(...) end
ADSaltRoute = {}
ADSaltRoute.LOG_PREFIX = "ADSmartPickup: salt: "
ADSaltRoute.SNOW_MIN_M = 0.02 -- så meget sne (verdens snehøjde) før der saltes
ADSaltRoute.SNOW_RISE_M = 0.05 -- ny saltning samme dag kun når sneen er steget så meget siden sidst
ADSaltRoute.REFILL_BELOW = 0.25 -- fyld vejsalt, når sprederen har under så stor en del tilbage
ADSaltRoute.REFILL_DONE = 0.9 -- påfyldningen er færdig ved så stor en del
ADSaltRoute.SPACING_M = 25 -- markører tættere end dette på en valgt markør køres ikke for sig (samme gårdsplads)
ADSaltRoute.ARRIVE_M = 25 -- fremme ved markøren
ADSaltRoute.CHECK_MS = 60 * 1000 -- så ofte undersøges det, om der skal saltes
ADSaltRoute.STEP_MS = 1000 -- så ofte følges det kørende job
ADSaltRoute.LEG_TIMEOUT_MS = 10 * 60 * 1000
ADSaltRoute.REFILL_TIMEOUT_MS = 15 * 60 * 1000
ADSaltRoute.START_GRACE_MS = 10 * 1000
ADSaltRoute.LOST_MS = 20 * 1000
ADSaltRoute.FAIL_COOLDOWN_MS = 30 * 60 * 1000
-- ---- ren logik ----
-- Skal der saltes? snowHeight = verdens snehøjde (m), last = {height, day} fra sidste færdige rute | nil, day = spildagen
function ADSaltRoute.shouldStart(snowHeight, last, day)
if (snowHeight or 0) < ADSaltRoute.SNOW_MIN_M then return false end
if last == nil then return true end
if day ~= nil and last.day ~= nil and day ~= last.day then return true end
return snowHeight > (last.height or 0) + ADSaltRoute.SNOW_RISE_M
end
-- Skal sprederen fyldes før/under ruten? level/capacity i liter
function ADSaltRoute.needsRefill(level, capacity)
if (capacity or 0) <= 0 then return false end
return (level or 0) / capacity < ADSaltRoute.REFILL_BELOW
end
-- Rækkefølgen: gruppe 1 (gårdene) før gruppe 2 (flowenes markører), hver som nærmeste-nabo fra det sidst valgte punkt.
-- points = {{id, x, z, phase}}; samme id én gang (laveste gruppe); punkter inden for spacing af et valgt punkt
-- springes over (samme gårdsplads saltes på vejen). -> ny liste
function ADSaltRoute.orderRoute(points, startX, startZ, spacing)
local byId = {}
for _, point in ipairs(points or {}) do
local known = byId[point.id]
if point.id ~= nil and point.x ~= nil and (known == nil or (point.phase or 2) < (known.phase or 2)) then byId[point.id] = point end
end
local phases = {}
for _, point in pairs(byId) do
local phase = point.phase or 2
phases[phase] = phases[phase] or {}
table.insert(phases[phase], point)
end
local phaseKeys = {}
for phase in pairs(phases) do table.insert(phaseKeys, phase) end
table.sort(phaseKeys)
local route, x, z = {}, startX or 0, startZ or 0
local spacing2 = (spacing or 0) ^ 2
local function nearChosen(point)
for _, chosen in ipairs(route) do
if (chosen.x - point.x) ^ 2 + (chosen.z - point.z) ^ 2 < spacing2 then return true end
end
return false
end
for _, phase in ipairs(phaseKeys) do
local left = phases[phase]
table.sort(left, function(a, b) return a.id < b.id end) -- fast rækkefølge ved lige afstand
while #left > 0 do
local bestIndex, bestDistance = nil, math.huge
for index, point in ipairs(left) do
local distance = (point.x - x) ^ 2 + (point.z - z) ^ 2
if distance < bestDistance then bestIndex, bestDistance = index, distance end
end
local point = table.remove(left, bestIndex)
if not nearChosen(point) then
table.insert(route, point)
x, z = point.x, point.z
end
end
end
return route
end
-- ---- spil-adapter ----
local function call(object, method, ...)
if object == nil or object[method] == nil then return nil end
local ok, result = pcall(object[method], object, ...)
return ok and result or nil
end
local function now() return ADUtil.now() end
local function vname(v) return ADRuns ~= nil and tostring(ADRuns.vehicleLabel(v)) or tostring(call(v, "getName") or "?") end
local function notify(text, critical)
logInfo(ADSaltRoute.LOG_PREFIX .. "%s", text)
if ADFieldJobs ~= nil and ADFieldJobs.notify ~= nil then pcall(ADFieldJobs.notify, text, critical == true) end
end
local warnedOnce = {}
local function warnOnce(key, text)
if warnedOnce[key] then return end
warnedOnce[key] = true
logInfo(ADSaltRoute.LOG_PREFIX .. "%s", text)
end
local function position(vehicle)
if vehicle == nil or vehicle.rootNode == nil or getWorldTranslation == nil then return nil end
local ok, x, _, z = pcall(getWorldTranslation, vehicle.rootNode)
if not ok then return nil end
return x, z
end
local job = nil -- det kørende saltjob
local busyVehicles = setmetatable({}, {__mode = "k"}) -- spreder/traktor -> job
local failedUntil = setmetatable({}, {__mode = "k"}) -- spreder -> ms
local checkTimer, stepTimer = 0, 0
ADSaltRoute.lastDone = nil -- {height, day} for den sidste færdige rute
-- Ren: har maskinen (eller noget koblet på den, to led ned) en saltspreder? attachedOf(v) -> liste af redskaber
function ADSaltRoute.carriesSpreader(vehicle, attachedOf, depth)
if type(vehicle) ~= "table" then return false end
if vehicle.spec_saltSpreader ~= nil then return true end
if (depth or 0) >= 2 then return false end
for _, implement in ipairs(attachedOf(vehicle) or {}) do
if ADSaltRoute.carriesSpreader(implement, attachedOf, (depth or 0) + 1) then return true end
end
return false
end
local function attachedObjects(vehicle)
local list = {}
if vehicle.getAttachedImplements == nil then return list end
local ok, implements = pcall(vehicle.getAttachedImplements, vehicle)
for _, implement in ipairs(ok and implements or {}) do
if type(implement) == "table" and implement.object ~= nil then table.insert(list, implement.object) end
end
return list
end
-- Låst til saltruten (brugerønske 21/10): en traktor med saltsprederen koblet på er kun til saltning — puljen, dyreture,
-- flow-vogne og markarbejde låner den ikke. Saltruten selv spørger med ownCheck (sin egen ledig-regel).
local ownCheck = false
function ADSaltRoute.isDedicated(vehicle)
if ownCheck or vehicle == nil then return false end
local ok, carries = pcall(ADSaltRoute.carriesSpreader, vehicle, attachedObjects, 0)
return ok and carries == true
end
function ADSaltRoute.isBusy(vehicle)
return vehicle ~= nil and (busyVehicles[vehicle] ~= nil or ADSaltRoute.isDedicated(vehicle))
end
local function snowHeight()
local snow = g_currentMission ~= nil and g_currentMission.snowSystem or nil
return snow ~= nil and (snow.height or 0) or 0
end
local function currentDay()
local environment = g_currentMission ~= nil and g_currentMission.environment or nil
return environment ~= nil and environment.currentDay or nil
end
local function roadSalt()
if g_fillTypeManager == nil or g_fillTypeManager.getFillTypeIndexByName == nil then return nil end
return g_fillTypeManager:getFillTypeIndexByName("ROADSALT")
end
-- Sprederens vejsalt: niveau, kapacitet
local function saltLevel(spreader)
local spec = spreader.spec_saltSpreader
local index = spec ~= nil and spec.fillUnitIndex or 1
return call(spreader, "getFillUnitFillLevel", index) or 0, call(spreader, "getFillUnitCapacity", index) or 0
end
-- Tænd/sluk sprederen (tændes kun med salt i — spillet siger ellers nej)
local function setSpreader(spreader, on)
if spreader == nil or spreader.setIsTurnedOn == nil then return end
local isOn = call(spreader, "getIsTurnedOn") == true
if on == isOn then return end
if on and (saltLevel(spreader) <= 0 or call(spreader, "getCanBeTurnedOn") ~= true) then return end
pcall(spreader.setIsTurnedOn, spreader, on)
end
-- Kan traktoren/den selvkørende spreder bruges nu? (samme optaget-regler som dyreturene)
local function driverFree(vehicle)
if vehicle == nil or vehicle.ad == nil or busyVehicles[vehicle] ~= nil then return false end
local id = ADRunsController.getVehicleId(vehicle)
if id == nil or ADPool.isReserved(id) then return false end
if ADPool.skipBroken ~= nil and ADPool.skipBroken(vehicle) then return false end
local module = vehicle.ad.stateModule
if module ~= nil and module:isActive() then return false end
if vehicle.getIsControlled ~= nil and vehicle:getIsControlled() then return false end
if ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle) then return false end
if ADHitch.isBusy ~= nil and ADHitch.isBusy(vehicle) then return false end
-- markarbejdets optaget-regel uden saltlåsen (ellers var vores egen salttraktor altid "optaget")
ownCheck = true
local ok, busy = pcall(function() return ADFieldWork ~= nil and ADFieldWork.isBusyVehicle ~= nil and ADFieldWork.isBusyVehicle(vehicle, id) end)
ownCheck = false
return ok and not busy
end
local function freeTractor(adEnv, implement)
local ok, _, tractors = pcall(ADPool.collect, adEnv, function(v) return ADFieldWork.isBusyVehicle(v, ADRunsController.getVehicleId(v)) end)
if not ok then return nil end
local blocked = ADPool.blocked(now())
local candidates = {}
for _, tractor in ipairs(tractors or {}) do
if not blocked[tractor.id] and not tractor.offNetwork and ADRunsController.getRunForVehicle(tractor.vehicle) == nil
and busyVehicles[tractor.vehicle] == nil then
table.insert(candidates, tractor)
end
end
local x, z = position(implement)
local okHp, neededHp = pcall(ADPool.readNeededHp, implement)
return ADPool.bestFit(candidates, {x = x, z = z, neededHp = okHp and neededHp or nil}, "unloader")
end
-- Gårdens saltsprederes muligheder: {spreader, id, driver (selvkørende/koblet på en ledig traktor) | connectId}
local function findSpreaders(adEnv, farmId)
local list = {}
local markers = adEnv.ADGraphManager:getMapMarkers()
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
if vehicle.spec_saltSpreader ~= nil and call(vehicle, "getOwnerFarmId") == farmId and busyVehicles[vehicle] == nil
and (failedUntil[vehicle] or 0) <= now()
and not (ADPool.skipBroken ~= nil and ADPool.skipBroken(vehicle))
and not (ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle)) then
local id = ADRunsController.getVehicleId(vehicle)
local attacher = call(vehicle, "getAttacherVehicle")
if id ~= nil and not ADPool.isReserved(id) then
if vehicle.spec_motorized ~= nil and vehicle.ad ~= nil then
if driverFree(vehicle) then table.insert(list, {spreader = vehicle, id = id, driver = vehicle}) end
elseif vehicle.spec_motorized ~= nil then
warnOnce("noAd:" .. tostring(id), string.format("saltsprederen '%s' kan ikke køres af AutoDrive — bruges ikke", vname(vehicle)))
elseif attacher ~= nil then
local root = call(attacher, "getRootVehicle") or attacher
if driverFree(root) then table.insert(list, {spreader = vehicle, id = id, driver = root, attached = true}) end
else
local parkIndex = vehicle.advd ~= nil and vehicle.advd.parkDestination or nil
local park = type(parkIndex) == "number" and parkIndex >= 1 and adEnv.ADGraphManager:getMapMarkerById(parkIndex) or nil
local connect = park ~= nil and ADPool.connectFor(park.name, markers) or nil
if connect ~= nil then
table.insert(list, {spreader = vehicle, id = id, connectId = connect.id})
else
warnOnce("noConnect:" .. tostring(id), string.format("saltsprederen '%s' har ingen P-plads med Connect-markør — bruges ikke", vname(vehicle)))
end
end
end
end
end
-- en klar spreder (selvkørende/koblet på) før en, der skal hentes
table.sort(list, function(a, b) return (a.driver ~= nil) and (b.driver == nil) end)
return list
end
-- Rutens punkter: gruppe 1 = gårdens bygningers markører, gruppe 2 = flowenes kilder, mål, lagre og fodringsbygninger
local function routePoints(adEnv, farmId)
local graph = adEnv.ADGraphManager
local candidate = {}
for _, marker in pairs(graph:getMapMarkers()) do
if ADBuildings == nil or ADBuildings.isCandidateMarker(marker) then candidate[marker.id] = true end
end
local points = {}
local function add(id, phase)
if id == nil or not candidate[id] then return end
local wayPoint = graph:getWayPointById(id)
if wayPoint ~= nil then table.insert(points, {id = id, x = wayPoint.x, z = wayPoint.z, phase = phase}) end
end
local function addBuilding(building, phase)
if building == nil then return end
for _, role in ipairs({"load", "unload"}) do
for _, marker in ipairs(ADBuildings.getMarkers(building, role)) do add(marker.id, phase) end
end
end
for _, building in ipairs(ADBuildings ~= nil and ADBuildings.list(adEnv, farmId) or {}) do
if building.kind ~= "sell" then addBuilding(building, 1) end
end
local store = ADRunsController ~= nil and ADRunsController.store or nil
for _, run in ipairs(store ~= nil and store.runs or {}) do
for _, id in ipairs(run.sourceWayPointIds or {}) do add(id, 2) end
for _, id in ipairs(run.targetWayPointIds or {}) do add(id, 2) end
for _, key in ipairs({"storeBuildingIds", "feedBuildingIds"}) do
for _, buildingId in ipairs(run[key] or {}) do addBuilding(ADBuildings.find(adEnv, farmId, buildingId), 2) end
end
end
return points
end
local function distanceTo(adEnv, vehicle, markerId)
local wayPoint = adEnv.ADGraphManager:getWayPointById(markerId)
local x, z = position(vehicle)
if wayPoint == nil or x == nil then return math.huge end
return math.sqrt((wayPoint.x - x) ^ 2 + (wayPoint.z - z) ^ 2)
end
local function finish(text, critical)
if job == nil then return end
local done = job
job = nil
if text ~= nil then notify(text, critical) end
setSpreader(done.spreader, false)
-- et hængende hente-/hjemtur-job må ikke kalde tilbage på et afsluttet job (som dyreturene)
if done.driver ~= nil and ADHitch.isBusy ~= nil and ADHitch.isBusy(done.driver) then ADHitch.cancel(done.driver) end
ADPool.release(done)
for vehicle, owner in pairs(busyVehicles) do
if owner == done then busyVehicles[vehicle] = nil end
end
end
local function goHome(adEnv, text, critical)
if job == nil then return end
setSpreader(job.spreader, false)
if text ~= nil then notify(text, critical) end
job.phase, job.since = "home", now()
if job.driver == job.spreader then
-- selvkørende spreder: AD til egen parkering, jobbet slutter med det samme (ingen redskab at sætte af)
local parkId = ADFieldWork.parkMarkerId ~= nil and ADFieldWork.parkMarkerId(adEnv, job.driver) or nil
if parkId ~= nil then pcall(ADFieldWork.startAd, adEnv, job.driver, adEnv.AutoDrive.MODE_DRIVETO, parkId, nil) end
finish(nil)
return
end
local ok, started = pcall(ADHitch.returnHome, adEnv, job.driver, function() finish(nil) end)
if ok and started then return end
-- spreder der sad på traktoren uden egen P/Connect (review): traktoren kører med den til sin egen parkering
local parkId = ADFieldWork.parkMarkerId ~= nil and ADFieldWork.parkMarkerId(adEnv, job.driver) or nil
if parkId ~= nil and pcall(ADFieldWork.startAd, adEnv, job.driver, adEnv.AutoDrive.MODE_DRIVETO, parkId, nil) then
finish(nil)
return
end
finish(string.format("'%s' kunne ikke køre saltsprederen hjem — gør det selv", vname(job.driver)), true)
end
local function fail(adEnv, text)
if job ~= nil then failedUntil[job.spreader] = now() + ADSaltRoute.FAIL_COOLDOWN_MS end
goHome(adEnv, text, true)
end
-- Næste rutepunkt der kan nås; ingen flere = ruten er færdig
local function nextLeg(adEnv)
while job.index <= #job.route do
local point = job.route[job.index]
if ADWaitPool == nil or ADWaitPool.hasRouteTo(adEnv, job.driver, point.id) then
setSpreader(job.spreader, true)
job.phase, job.since, job.markerId, job.restarted = "route", now(), point.id, false
ADFieldWork.startAd(adEnv, job.driver, adEnv.AutoDrive.MODE_DRIVETO, point.id, nil)
return
end
job.index = job.index + 1
end
ADSaltRoute.lastDone = {height = snowHeight(), day = currentDay()}
goHome(adEnv, string.format("saltruten er færdig (%d af %d steder nået) — '%s' kører hjem", job.visited or 0, #job.route, vname(job.driver)))
end
local function refill(adEnv)
setSpreader(job.spreader, false)
local fillType = roadSalt()
local x, z = position(job.driver)
local marker = fillType ~= nil and x ~= nil and ADFieldWork.findRefillMarker(adEnv, job.driver, fillType, x, z, false) or nil
if marker == nil then
fail(adEnv, "intet sted at købe eller hente vejsalt med AD-markør — saltruten stopper")
return
end
job.phase, job.since, job.markerId, job.restarted = "refill", now(), marker, false
ADFieldWork.startAd(adEnv, job.driver, adEnv.AutoDrive.MODE_LOAD, marker, marker, fillType)
logInfo(ADSaltRoute.LOG_PREFIX .. "'%s' henter vejsalt", vname(job.driver))
end
local function beginRoute(adEnv)
-- slået fra eller sneen væk, mens redskabet blev hentet (review): ingen tur
if snowHeight() < ADSaltRoute.SNOW_MIN_M or (ADSettings ~= nil and ADSettings.get("autoSalt") ~= 1) then
goHome(adEnv, nil)
return
end
local level, capacity = saltLevel(job.spreader)
if ADSaltRoute.needsRefill(level, capacity) then refill(adEnv) else nextLeg(adEnv) end
end
local function startJob(adEnv, info, tractor, route)
job = {spreader = info.spreader, driver = info.driver or (tractor ~= nil and tractor.vehicle or nil), route = route, index = 1,
phase = "fetch", since = now()}
busyVehicles[job.spreader], busyVehicles[job.driver] = job, job
local driverId = ADRunsController.getVehicleId(job.driver)
ADPool.reserve(job, {info.id, driverId})
notify(string.format("der ligger sne — '%s' salter %d steder (gårdene først)", vname(info.spreader), #route))
if info.connectId == nil then
beginRoute(adEnv)
return
end
local current = job
ADHitch.fetch(adEnv, job.driver, info.connectId, function(_, ok, detail)
if job == nil or job ~= current then return end -- et afsluttet (eller nyere) job: intet at gøre
local okStep, err = pcall(function()
if ok and detail ~= nil and detail ~= job.spreader then ok, detail = false, "et andet redskab blev koblet på" end
if not ok then
failedUntil[job.spreader] = now() + ADSaltRoute.FAIL_COOLDOWN_MS
finish(string.format("'%s' kunne ikke koble saltsprederen på (%s)", vname(job.driver), tostring(detail)), true)
return
end
beginRoute(adEnv)
end)
if not okStep then finish(string.format("saltrute med '%s' fejlede: %s", vname(job.driver), tostring(err)), true) end
end)
end
-- Ét skridt for det kørende job
local function stepJob(adEnv)
local module = job.driver.ad ~= nil and job.driver.ad.stateModule or nil
local driving = module ~= nil and module:isActive()
local controlled = job.driver.getIsControlled ~= nil and job.driver:getIsControlled() and not driving
local paused = ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.paused
if controlled or paused then
-- "Stop alt": dette snefald tæller som klaret (ellers startede en ny rute, så snart pausen slutter — review)
if paused then ADSaltRoute.lastDone = {height = snowHeight(), day = currentDay()} end
finish(string.format("saltrute med '%s' sluppet (%s)", vname(job.driver), paused and "Stop alt" or "du kører den"))
return
end
if job.phase == "fetch" or job.phase == "home" then
if now() - job.since > ADSaltRoute.LEG_TIMEOUT_MS then finish(string.format("saltrute med '%s' gav op (%s tog for lang tid)", vname(job.driver), job.phase), true) return end
if ADHitch.isBusy ~= nil and not ADHitch.isBusy(job.driver) and not driving then
job.lostSince = job.lostSince or now()
if now() - job.lostSince > ADSaltRoute.LOST_MS then finish(nil) end
else
job.lostSince = nil
end
return
end
-- sneen er væk eller saltningen slået fra: hjem
if snowHeight() < ADSaltRoute.SNOW_MIN_M or (ADSettings ~= nil and ADSettings.get("autoSalt") ~= 1) then
goHome(adEnv, string.format("saltruten stoppes (%s) — '%s' kører hjem", snowHeight() < ADSaltRoute.SNOW_MIN_M and "sneen er væk" or "slået fra", vname(job.driver)))
return
end
local level, capacity = saltLevel(job.spreader)
if job.phase == "route" then
if level <= 0 then refill(adEnv) return end -- løbet tør undervejs: fyld, og fortsæt fra samme punkt
if driving then
setSpreader(job.spreader, true)
if now() - job.since > ADSaltRoute.LEG_TIMEOUT_MS then
pcall(job.driver.stopAutoDrive, job.driver)
job.index = job.index + 1 -- springes over; næste punkt
nextLeg(adEnv)
end
return
end
if now() - job.since < ADSaltRoute.START_GRACE_MS then return end
if distanceTo(adEnv, job.driver, job.markerId) > ADSaltRoute.ARRIVE_M and not job.restarted then
job.restarted, job.since = true, now()
ADFieldWork.startAd(adEnv, job.driver, adEnv.AutoDrive.MODE_DRIVETO, job.markerId, nil)
return
end
job.index = job.index + 1
job.visited = (job.visited or 0) + 1
nextLeg(adEnv)
elseif job.phase == "refill" then
if capacity > 0 and level / capacity >= ADSaltRoute.REFILL_DONE then nextLeg(adEnv) return end
if now() - job.since > ADSaltRoute.REFILL_TIMEOUT_MS then
if level > 0 then nextLeg(adEnv) else fail(adEnv, string.format("'%s' fik intet vejsalt — saltruten stopper", vname(job.driver))) end
return
end
if driving or now() - job.since < ADSaltRoute.START_GRACE_MS then return end
-- AD er færdig ved salget/lageret: noget fik den
if level > 0 then nextLeg(adEnv) else fail(adEnv, string.format("'%s' fik intet vejsalt ved påfyldningen — saltruten stopper", vname(job.driver))) end
end
end
local function plan(adEnv)
if ADSettings == nil or ADSettings.get("autoSalt") ~= 1 then return end
if not ADSaltRoute.shouldStart(snowHeight(), ADSaltRoute.lastDone, currentDay()) then return end
local farmId = g_currentMission:getFarmId()
local spreaders = findSpreaders(adEnv, farmId)
if #spreaders == 0 then
warnOnce("noSpreader", "der ligger sne, men ingen ledig saltspreder (købt, med P-plads og Connect-markør) — der saltes ikke")
return
end
for _, info in ipairs(spreaders) do
local tractor = nil
if info.driver == nil then
tractor = freeTractor(adEnv, info.spreader)
if tractor == nil then warnOnce("noTractor", "der ligger sne, men ingen ledig traktor til saltsprederen") end
end
if info.driver ~= nil or tractor ~= nil then
local x, z = position(info.driver or tractor.vehicle)
local route = ADSaltRoute.orderRoute(routePoints(adEnv, farmId), x, z, ADSaltRoute.SPACING_M)
if #route == 0 then
warnOnce("noRoute", "der ligger sne, men ingen AD-markører ved gårdene eller flowene at salte")
return
end
startJob(adEnv, info, tractor, route)
return
end
end
end
function ADSaltRoute.tick(adEnv, dt)
if adEnv == nil or g_currentMission == nil or ADPool == nil or ADHitch == nil or ADFieldWork == nil then return end
if g_currentMission.getIsServer ~= nil and not g_currentMission:getIsServer() then return end
stepTimer = stepTimer + (dt or 0)
if job ~= nil and stepTimer >= ADSaltRoute.STEP_MS then
stepTimer = 0
local ok, err = pcall(stepJob, adEnv)
if not ok then
Logging.warning(ADSaltRoute.LOG_PREFIX .. "saltrute: %s", tostring(err))
finish(nil)
end
end
checkTimer = checkTimer + (dt or 0)
if checkTimer < ADSaltRoute.CHECK_MS then return end
checkTimer = 0
if job ~= nil or (ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.paused) then return end
local ok, err = pcall(plan, adEnv)
if not ok then Logging.warning(ADSaltRoute.LOG_PREFIX .. "planlægning: %s", tostring(err)) end
end