512 lines
26 KiB
Lua
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
|