Files

622 lines
32 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
-- sprederen kun tændt, hvor der ligger sne (brugerønske 21/10 01:28: den saltede foderbordet inde i kostalden).
-- Målefeltet ligger om traktoren, der kører foran sprederen; efter sidste sne bliver den tændt lidt endnu, så
-- sprederen bag traktoren når det sidste stykke med
ADSaltRoute.GROUND_SNOW_M = 0.01 -- sne på jorden (m) der tæller
ADSaltRoute.SNOW_PROBE_M = 3 -- halv side af målefeltet om traktoren (6 x 6 m)
-- parkering/venteplads (brugerønske 21/10 01:30: "den skal heller ikke køre ind på baner hvor der holder køretøjer,
-- wait og parkering, da den så bare kommer til at holde fast der")
ADSaltRoute.SERVICE_CLEAR_M = 15 -- rutepunkt så tæt på en P-/Connect-/Wait-markør springes over
ADSaltRoute.OCCUPIED_M = 12 -- rutepunkt med et andet køretøj så tæt på springes over
ADSaltRoute.SPREAD_HOLD_MS = 1500 -- tændt så længe efter sidste sne under traktoren (sprederen sidder ~1 s bag den)
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
-- Ren: ligger (x, z) inden for radius af et af punkterne {{x, z}}?
function ADSaltRoute.isNear(x, z, points, radius)
if x == nil or z == nil then return false end
local r2 = radius * radius
for _, point in ipairs(points or {}) do
local dx, dz = point.x - x, point.z - z
if dx * dx + dz * dz <= r2 then return true end
end
return false
end
-- Ren: skal sprederen være tændt? groundSnow = sne under traktoren nu, lastSnowAt = sidste gang der var sne
function ADSaltRoute.shouldSpread(groundSnow, nowMs, lastSnowAt, holdMs)
if groundSnow then return true end
return lastSnowAt ~= nil and nowMs - lastSnowAt < (holdMs or ADSaltRoute.SPREAD_HOLD_MS)
end
-- Ligger der sne om punktet? -> true/false, nil = ukendt (intet snesystem/position)
local function snowAtPoint(x, z)
local snow = g_currentMission ~= nil and g_currentMission.snowSystem or nil
if snow == nil or snow.getSnowHeightAtArea == nil or x == nil or z == nil then return nil end
local r = ADSaltRoute.SNOW_PROBE_M
local ok, height = pcall(snow.getSnowHeightAtArea, snow, x - r, z - r, x + r, z - r, x - r, z + r)
if not ok or type(height) ~= "number" then return nil end
return height > ADSaltRoute.GROUND_SNOW_M
end
local function groundSnowAt(vehicle)
local x, z = position(vehicle)
return snowAtPoint(x, z)
end
-- Rutepunkt uden sne (inde i en stald, under tag, allerede saltet) køres der ikke til (brugerønske 21/10 01:29:
-- "2 gange igennem staldene" — foder-markørerne står på foderbordet)
local function pointHasSnow(adEnv, markerId)
local wp = adEnv.ADGraphManager:getWayPointById(markerId)
if wp == nil then return true end
return snowAtPoint(wp.x, wp.z) ~= false
end
-- Sprederen tændt, hvor der er sne (ukendt sne: tændt som før)
local function spreadWhereSnow(current)
local snow = groundSnowAt(current.driver)
if snow == nil then setSpreader(current.spreader, true) return end
if snow then current.lastSnowAt = now() end
setSpreader(current.spreader, ADSaltRoute.shouldSpread(snow, now(), current.lastSnowAt, ADSaltRoute.SPREAD_HOLD_MS))
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
local adActive = module ~= nil and module:isActive()
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
if adActive then
-- salttraktoren kører en AutoDrive-tur uden saltruten (genoptaget efter indlæsning — saltjobbet gemmes ikke,
-- brugerønske 21/10 01:37: "lav det så den overtager"): saltruten tager den, hvis den ellers er fri
if not ADSaltRoute.carriesSpreader(vehicle, attachedObjects, 0) then return false end
if ADRunsController.getRunForVehicle ~= nil and ADRunsController.getRunForVehicle(vehicle) ~= nil then return false end
if ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and (ADFieldJobs.state.assignments or {})[id] ~= nil then return false end
if ADCpBridge ~= nil and ADCpBridge.isWorking ~= nil and ADCpBridge.isWorking(vehicle) then return false end
-- lån/hjemtur/tømning der startede før sprederen blev koblet på, overtages ikke (review)
if ADFieldSilos ~= nil and ADFieldSilos.isLoaned ~= nil and ADFieldSilos.isLoaned(vehicle) then return false end
if ADPool.isReturning ~= nil and ADPool.isReturning(vehicle) then return false end
if ADFlowWagons ~= nil and ADFlowWagons.isEmptying ~= nil and ADFlowWagons.isEmptying(vehicle) then return false end
return true
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, service = {}, {}
for _, marker in pairs(graph:getMapMarkers()) do
if ADBuildings == nil or ADBuildings.isCandidateMarker(marker) then
candidate[marker.id] = true
else
local wayPoint = graph:getWayPointById(marker.id)
if wayPoint ~= nil then table.insert(service, {x = wayPoint.x, z = wayPoint.z}) end
end
end
local points = {}
local function add(id, phase)
if id == nil or not candidate[id] then return end
local wayPoint = graph:getWayPointById(id)
-- ved parkering/ventepladser: ikke et mål (der holder maskiner)
if wayPoint ~= nil and not ADSaltRoute.isNear(wayPoint.x, wayPoint.z, service, ADSaltRoute.SERVICE_CLEAR_M) 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
-- Holder der et andet køretøj ved punktet? (saltrutens egne maskiner tæller ikke)
local function occupied(adEnv, markerId)
local wp = adEnv.ADGraphManager:getWayPointById(markerId)
if wp == nil then return false end
local positions = {}
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
if vehicle ~= job.driver and vehicle ~= job.spreader and vehicle.spec_motorized ~= nil then
local x, z = position(vehicle)
if x ~= nil then table.insert(positions, {x = x, z = z}) end
end
end
return ADSaltRoute.isNear(wp.x, wp.z, positions, ADSaltRoute.OCCUPIED_M)
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]
local busyNow = occupied(adEnv, point.id)
-- holder der en maskine (måske kun forbi): prøv punktet igen én gang til sidst i ruten (review)
if busyNow and not point.retried then table.insert(job.route, {id = point.id, x = point.x, z = point.z, phase = point.phase, retried = true}) end
if pointHasSnow(adEnv, point.id) and not busyNow
and (ADWaitPool == nil or ADWaitPool.hasRouteTo(adEnv, job.driver, point.id)) then
local graph = adEnv.ADGraphManager
local marker = graph.getMapMarkerByWayPointId ~= nil and graph:getMapMarkerByWayPointId(point.id) or nil
logInfo(ADSaltRoute.LOG_PREFIX .. "'%s' salter mod '%s' (%d/%d)", vname(job.driver), tostring(marker ~= nil and marker.name or point.id), job.index, #job.route)
spreadWhereSnow(job)
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()}
local retries = 0
for _, point in ipairs(job.route) do if point.retried then retries = retries + 1 end end
local skipped = #job.route - retries - (job.visited or 0)
goHome(adEnv, string.format("saltruten er færdig (%d steder saltet%s) — '%s' kører hjem", job.visited or 0,
skipped > 0 and string.format(", %d sprunget over: ingen sne, optaget eller ingen vej", skipped) or "", 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))
-- overtaget AutoDrive-tur (genoptaget efter indlæsning): stop den, saltruten sender sine egne mål
local module = job.driver ~= nil and job.driver.ad ~= nil and job.driver.ad.stateModule or nil
if module ~= nil and module:isActive() then
logInfo(ADSaltRoute.LOG_PREFIX .. "'%s' kørte en AutoDrive-tur — saltruten overtager", vname(job.driver))
pcall(job.driver.stopAutoDrive, job.driver)
end
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
spreadWhereSnow(job)
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 = ADUtil.farmId()
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