776 lines
46 KiB
Lua
776 lines
46 KiB
Lua
-- AD Unload Wait
|
||
-- Holder en traktor med rest-læs ved en fuld stald AutoDrive i dag stille ved
|
||
-- aflæsningspunktet "til den er tømt på en eller anden måde" — og spærrer for
|
||
-- de næste i køen. Her omdirigeres den i stedet til nærmeste ledige Wait-punkt
|
||
-- (markør i en mappe med ordet "Wait" i navnet, fx "Cow Wait"), og når målet igen
|
||
-- har plads til HELE resten, sendes den tilbage og læsser af.
|
||
--
|
||
-- Kun den aktuelle aflæsningsopgaves destination ændres; AutoDrives mål,
|
||
-- rotation og loop-tæller røres ikke.
|
||
|
||
|
||
-- Flowet der styrer traktoren nu (et stoppet flow styrer intet — ADRunsController.getActiveRunForVehicle)
|
||
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
|
||
local function logInfo(...) return (ADLog or Logging).info(...) end
|
||
|
||
local function activeRunOf(vehicle)
|
||
local controller = ADRunsController
|
||
if controller == nil or controller.getRunForVehicle == nil then return nil end
|
||
local run = controller.getRunForVehicle(vehicle)
|
||
if run ~= nil and run.stopped then return nil end
|
||
return run
|
||
end
|
||
|
||
ADUnloadWait = {}
|
||
|
||
-- Under dette regnes vognen som tom (AutoDrive selv bruger 0,1 l).
|
||
ADUnloadWait.MIN_REST_LITERS = 100
|
||
-- Kan målet tage mindre end dette, regnes det som fuldt (aflæsning starter ikke).
|
||
ADUnloadWait.MIN_FREE_TO_UNLOAD = 100
|
||
ADUnloadWait.LOG_PREFIX = "ADSmartPickup: "
|
||
|
||
-- køretøj -> {task, homeDestinationID, waitMarker, fillType, rest}
|
||
local waits = setmetatable({}, {__mode = "k"})
|
||
local warnedNoWaitPoint = setmetatable({}, {__mode = "k"})
|
||
local dripMarks = setmetatable({}, {__mode = "k"}) -- køretøj -> {rest, at}: læsset da den kom til målet
|
||
|
||
-- Tømmer vognen kun dråbevis? Et mål med lidt plads, der kun æder lidt ad gangen (gæringssilo, oliemølle), tømmer en
|
||
-- stor vogn aldrig — og vognene bag holder (in-game 19/10 12:35: 8280 TTV ved Large Steel Silo Input, 1.300 l af på
|
||
-- 7 min med 511.000 l på vognen). s = {dropped, heldMs, rest, minMs, etaMs}: efter minMs ved målet tømmer den
|
||
-- langsommere end DRIP_RATE_LPM OG ville være tom senere end etaMs -> true = behandles som fuldt mål. Fartgrænsen er
|
||
-- absolut (review 19/10: et ETA-krav alene ramte store vogne, der tømte helt normalt — 941.000 l ved 12.000 l/min)
|
||
ADUnloadWait.DRIP_MIN_MS = 3 * 60 * 1000
|
||
ADUnloadWait.DRIP_ETA_MS = 30 * 60 * 1000
|
||
ADUnloadWait.DRIP_RATE_LPM = 2000
|
||
ADUnloadWait.DRIP_GAP_MS = 15000 -- så længe væk fra målet (AD's tippe-flag blinker) før vinduet starter forfra
|
||
ADUnloadWait.DRIP_RETURN_MS = 10 * 60 * 1000 -- dråbevis mål: tidligst tilbage efter så lang tid ved Wait
|
||
function ADUnloadWait.isDripping(s)
|
||
if (s.heldMs or 0) < (s.minMs or ADUnloadWait.DRIP_MIN_MS) then return false end
|
||
local dropped = s.dropped or 0
|
||
if dropped <= 0 then return true end
|
||
local perMinute = dropped * 60000 / s.heldMs
|
||
return perMinute < ADUnloadWait.DRIP_RATE_LPM and (s.rest or 0) * s.heldMs / dropped > (s.etaMs or ADUnloadWait.DRIP_ETA_MS)
|
||
end
|
||
local isInstalled = false
|
||
|
||
-- Den vare og mængde der er tilbage på vognen (største fyldte aflæsselige enhed).
|
||
local function getRestLoad(adEnv, vehicle)
|
||
local bestFillType, bestLevel = nil, 0
|
||
for _, unit in ipairs(adEnv.AutoDrive.getAllDischargeableUnits(vehicle) or {}) do
|
||
local object = unit.object
|
||
if object ~= nil and object.getFillUnitFillLevel ~= nil then
|
||
local level = object:getFillUnitFillLevel(unit.fillUnitIndex) or 0
|
||
if level > bestLevel then
|
||
bestLevel = level
|
||
bestFillType = object.getFillUnitFillType ~= nil and object:getFillUnitFillType(unit.fillUnitIndex) or nil
|
||
end
|
||
end
|
||
end
|
||
return bestFillType, bestLevel
|
||
end
|
||
|
||
local function getWaitPoolGroup(vehicle)
|
||
local run = ADRunsController ~= nil and activeRunOf(vehicle) or nil
|
||
return run ~= nil and run.waitPoolGroup or nil
|
||
end
|
||
|
||
-- Rutetjek, reservationer og omdirigering deles med udkørsels-modulet (adWaitPool).
|
||
-- Kun "til punktet" ved silo-aflæsning: næste tur er AD's egen rute fra siloen.
|
||
local function hasRouteTo(adEnv, vehicle, wayPointId)
|
||
return ADWaitPool.hasRouteTo(adEnv, vehicle, wayPointId)
|
||
end
|
||
|
||
local function hasRouteBothWays(adEnv, vehicle, waitWayPointId, homeWayPointId)
|
||
return ADWaitPool.hasRouteBothWays(adEnv, vehicle, waitWayPointId, homeWayPointId)
|
||
end
|
||
|
||
local function redirect(task, destinationID)
|
||
ADWaitPool.redirect(task, destinationID)
|
||
end
|
||
|
||
-- køretøj -> AD's oprindelige 2. markør (waypoint-id) mens der læsses af i en silo
|
||
local pendingTargetRestore = setmetatable({}, {__mode = "k"})
|
||
|
||
-- Aflæsning ved en ANDEN destination end AD's mål: AD tipper kun når vognen er tæt på
|
||
-- AD's egen 2. markør (getDistanceToUnloadPosition), så den skiftes midlertidigt til
|
||
-- siloen og gendannes når opgaven er færdig.
|
||
local function redirectForUnload(task, destinationID)
|
||
local vehicle = task.vehicle
|
||
local stateModule = vehicle.ad.stateModule
|
||
local current = stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
|
||
if current ~= nil and current.id ~= destinationID and stateModule.setSecondMarkerByWayPointId ~= nil then
|
||
pendingTargetRestore[vehicle] = pendingTargetRestore[vehicle] or current.id
|
||
stateModule:setSecondMarkerByWayPointId(destinationID)
|
||
end
|
||
redirect(task, destinationID)
|
||
end
|
||
|
||
local function restoreTarget(vehicle)
|
||
local homeId = pendingTargetRestore[vehicle]
|
||
if homeId == nil then
|
||
return
|
||
end
|
||
pendingTargetRestore[vehicle] = nil
|
||
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
||
if stateModule ~= nil and stateModule.setSecondMarkerByWayPointId ~= nil then
|
||
stateModule:setSecondMarkerByWayPointId(homeId)
|
||
end
|
||
end
|
||
|
||
local function release(vehicle)
|
||
if waits[vehicle] ~= nil then
|
||
ADWaitPool.releaseVehicle(vehicle)
|
||
end
|
||
waits[vehicle] = nil
|
||
if ADLoadSwap ~= nil then
|
||
ADLoadSwap.clearWarning(vehicle)
|
||
end
|
||
end
|
||
|
||
-- "Fremme ved målet": AD stopper vognen så snart den står i aflæsningstriggeren — ofte
|
||
-- 5–10 m FØR markøren, så isTargetReached() bliver aldrig sand (set ved sukkerfabrikken).
|
||
-- Derfor tæller også AD's eget mål for tipning (afstand til aflæsningsstedet inden for
|
||
-- AD's trigger-afstand) og at AD er i gang med at tippe.
|
||
-- AD's aflæsningsmål for tilstanden: "Lever til" aflæsser ved 1. markør, "Hent og aflever" ved 2. (in-game 19/10 01:09: rest-læsset
|
||
-- til TMR Silo Farma kørte "Lever til", men 2. markør stod stadig på læssevognens gamle silo — og målet blev "rettet" dertil)
|
||
function ADUnloadWait.isDeliverTo(adEnv, vehicle)
|
||
local stateModule = vehicle.ad.stateModule
|
||
return adEnv ~= nil and adEnv.AutoDrive ~= nil and adEnv.AutoDrive.MODE_DELIVERTO ~= nil and stateModule.getMode ~= nil
|
||
and stateModule:getMode() == adEnv.AutoDrive.MODE_DELIVERTO
|
||
end
|
||
|
||
function ADUnloadWait.unloadTarget(adEnv, vehicle)
|
||
local stateModule = vehicle.ad.stateModule
|
||
if ADUnloadWait.isDeliverTo(adEnv, vehicle) then return stateModule.getFirstMarker ~= nil and stateModule:getFirstMarker() or nil end
|
||
return stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
|
||
end
|
||
|
||
local function isAtUnloadTarget(adEnv, vehicle)
|
||
if vehicle.ad.drivePathModule:isTargetReached() then
|
||
return true
|
||
end
|
||
local trailerModule = vehicle.ad.trailerModule
|
||
if trailerModule ~= nil and trailerModule.isUnloading then
|
||
return true
|
||
end
|
||
local autoDrive = adEnv.AutoDrive
|
||
if autoDrive.getDistanceToUnloadPosition ~= nil and autoDrive.getMaxTriggerDistance ~= nil then
|
||
local ok, distance = pcall(autoDrive.getDistanceToUnloadPosition, vehicle)
|
||
local okMax, maxDistance = pcall(autoDrive.getMaxTriggerDistance, vehicle)
|
||
if ok and okMax and type(distance) == "number" and type(maxDistance) == "number" then
|
||
return distance <= maxDistance
|
||
end
|
||
end
|
||
return false
|
||
end
|
||
|
||
-- Står køretøjet ved målet med rest-læs, som målet ikke kan tage? Så find et Wait-punkt.
|
||
ADUnloadWait.MIN_FREE_FOR_OTHER_TARGET = 1000
|
||
|
||
-- Tager triggeren ved markøren varen? Caches MARKER_TAKES_CACHE_MS pr. markør+vare (startWaiting kører hvert tick).
|
||
ADUnloadWait.MARKER_TAKES_CACHE_MS = 1000
|
||
local markerTakesCache = {} -- "markør:vare:farm" -> {value, at}
|
||
local loggedMarkerRejects = setmetatable({}, {__mode = "k"}) -- køretøj -> "markør:vare" allerede logget
|
||
|
||
local function markerTakes(adEnv, vehicle, targetId, fillType)
|
||
if ADSmartPickup.markerTriggerAccepts == nil then return true end
|
||
local farmId = ADSmartPickup.getFarmId(vehicle)
|
||
local key = tostring(targetId) .. ":" .. tostring(fillType) .. ":" .. tostring(farmId)
|
||
local now = g_currentMission ~= nil and type(g_currentMission.time) == "number" and g_currentMission.time or 0
|
||
local cached = markerTakesCache[key]
|
||
if cached ~= nil and now - cached.at < ADUnloadWait.MARKER_TAKES_CACHE_MS then return cached.value end
|
||
local ok, accepts = pcall(ADSmartPickup.markerTriggerAccepts, adEnv, targetId, fillType, farmId)
|
||
local value = not ok or accepts
|
||
markerTakesCache[key] = {value = value, at = now}
|
||
return value
|
||
end
|
||
ADUnloadWait.markerTakes = markerTakes -- ADFlowSleep: vækning af en vogn parkeret med læs
|
||
|
||
local resolvedAt = {} -- runId -> ms for sidste genopslag af målene
|
||
local RESOLVE_INTERVAL_MS = 25000 -- lidt under tjek-intervallet (30 s), så et tjek ikke springer genopslaget over
|
||
|
||
-- Er stallens trug under tærsklen (ADSettings "troughRefillPercent", pr. bygning)? Ikke-stalde og 100 % (standard): altid ja.
|
||
-- Kun foder i et fælles trug — samme trug-andel som turplanlægningen (review: varens egen "kapacitet" var kun pladsen
|
||
-- til netop den vare; halm og vand er ikke trug).
|
||
function ADUnloadWait.troughAllows(adEnv, vehicle, targetId, fillType)
|
||
if ADSettings == nil or ADSupplyPlanner == nil or ADSupplyPlanner.troughNeedsRefill == nil or ADSmartPickup.troughScore == nil then return true end
|
||
local farmId = ADSmartPickup.getFarmId(vehicle)
|
||
local station = ADSmartPickup.getUnloadStationAtWayPointId ~= nil and ADSmartPickup.getUnloadStationAtWayPointId(adEnv, targetId, farmId) or nil
|
||
if station == nil then return true end
|
||
local score = ADSmartPickup.troughScore(station, fillType)
|
||
if score == nil then return true end
|
||
local placeable = station.owningPlaceable
|
||
local buildingId = placeable ~= nil and ADBuildings ~= nil and ADBuildings.getId ~= nil and ADBuildings.getId(placeable) or nil
|
||
local threshold = ADSettings.get("troughRefillPercent", buildingId) or 100
|
||
return ADSupplyPlanner.troughNeedsRefill(score, threshold)
|
||
end
|
||
|
||
-- Det af run'ets ANDRE mål der tager varen og har mest fri plads (≥ MIN_FREE_FOR_OTHER_TARGET) og vej.
|
||
-- diag (valgfri tabel): én tekst pr. andet mål med fri plads / trigger / vej — til loggen når intet findes
|
||
local function findOtherTargetForRest(adEnv, vehicle, fillType, currentId, diag)
|
||
local run = ADRunsController ~= nil and ADRunsController.getRunForVehicle ~= nil and activeRunOf(vehicle) or nil
|
||
if run == nil or (run.kind or "supply") ~= "supply" or vehicle.ad.stateModule.setSecondMarkerByWayPointId == nil then
|
||
if diag ~= nil then table.insert(diag, "intet forsyningsflow") end
|
||
return nil
|
||
end
|
||
-- målene følger markørnavnene: spilleren kan have flyttet/genoprettet en markør, mens vognen venter (in-game 16/10:
|
||
-- "Cattle Barn 2 Feed" flyttet ind i stalden — ellers ses den nye placering først ved næste start)
|
||
local now = g_currentMission ~= nil and type(g_currentMission.time) == "number" and g_currentMission.time or 0
|
||
if ADRunsController.resolveMarkers ~= nil and now - (resolvedAt[run.id] or -math.huge) >= RESOLVE_INTERVAL_MS then
|
||
resolvedAt[run.id] = now
|
||
pcall(ADRunsController.resolveMarkers, adEnv, run)
|
||
end
|
||
-- hjemmet kan have fået et nyt vejpunkt-id ved genopslaget: sammenlign også på markørnavnet
|
||
local graph = adEnv.ADGraphManager
|
||
local homeMarker = currentId ~= nil and graph.getMapMarkerByWayPointId ~= nil and graph:getMapMarkerByWayPointId(currentId) or nil
|
||
local homeName = homeMarker ~= nil and homeMarker.name or nil
|
||
local best, bestFree = nil, ADUnloadWait.MIN_FREE_FOR_OTHER_TARGET - 1
|
||
for _, targetId in ipairs(ADRunsController.getRunTargets(run)) do
|
||
local targetMarker = graph.getMapMarkerByWayPointId ~= nil and graph:getMapMarkerByWayPointId(targetId) or nil
|
||
local isHome = targetId == currentId or (homeName ~= nil and targetMarker ~= nil and targetMarker.name == homeName)
|
||
if not isHome then
|
||
local free = ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType, false, targetId)
|
||
-- trug-tærsklen gælder også resten (brugerønske 19/10 01:21: "holde og vente til der er under 50 % i truget" —
|
||
-- vognene med ~1 mio. l TMR kørte ellers i ring efter 14.000 l fri plads i fulde stalde)
|
||
if free ~= nil and not ADUnloadWait.troughAllows(adEnv, vehicle, targetId, fillType) then free = 0 end
|
||
local marker = adEnv.ADGraphManager.getMapMarkerByWayPointId ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(targetId) or nil
|
||
local name = marker ~= nil and marker.name or tostring(targetId)
|
||
-- triggeren ved markøren skal tage varen, ikke bare stationen (foder til en halm-markør, in-game 14/10)
|
||
local enough = free ~= nil and free > bestFree
|
||
local takes = enough and markerTakes(adEnv, vehicle, targetId, fillType)
|
||
-- diagnose: hvorfor siger triggeren nej (bygning + triggere med afstand)
|
||
local triggerWhy = ""
|
||
if diag ~= nil and enough and not takes and ADSmartPickup.markerTriggerAccepts ~= nil then
|
||
local why = {}
|
||
pcall(ADSmartPickup.markerTriggerAccepts, adEnv, targetId, fillType, ADSmartPickup.getFarmId(vehicle), why)
|
||
triggerWhy = #why > 0 and (" [" .. table.concat(why, ", ") .. "]") or ""
|
||
end
|
||
local route = takes and hasRouteTo(adEnv, vehicle, targetId)
|
||
if diag ~= nil then
|
||
table.insert(diag, string.format("%s: fri %s, trigger %s%s, vej %s", name, free ~= nil and string.format("%.0f l", free) or "ukendt",
|
||
enough and tostring(takes) or "-", triggerWhy, takes and tostring(route) or "-"))
|
||
end
|
||
if route then
|
||
best, bestFree = {id = targetId, name = name}, free
|
||
end
|
||
end
|
||
end
|
||
return best, bestFree
|
||
end
|
||
|
||
-- Opgavens mål afviger fra AD's 2. markør: forældet id (intet markør på vejpunktet) eller et bevidst læs-bytte (silo)?
|
||
function ADUnloadWait.isStaleDestination(taskDestination, targetId, hasMarkerAtDestination)
|
||
return taskDestination ~= targetId and not hasMarkerAtDestination
|
||
end
|
||
|
||
-- Er ventetiden ved Wait udløbet? minutes = 0 slår reglen fra.
|
||
-- Ventende vogn: værd at forlade Wait for et af run'ets andre mål? Det andet mål skal kunne tage hele resten eller
|
||
-- mindst MIN_FREE_TO_LEAVE_WAIT, og have mere plads end hjemmet (ellers kører den frem og tilbage for småportioner).
|
||
ADUnloadWait.MIN_FREE_TO_LEAVE_WAIT = 20000
|
||
ADUnloadWait.OTHER_TARGET_CHECK_MS = 30000
|
||
function ADUnloadWait.isWorthLeavingWait(otherFree, homeFree, rest)
|
||
if otherFree == nil or rest == nil or rest <= 0 then return false end
|
||
return otherFree >= math.min(rest, ADUnloadWait.MIN_FREE_TO_LEAVE_WAIT) and otherFree > (homeFree or 0)
|
||
end
|
||
|
||
function ADUnloadWait.waitHomeDue(waitedMs, minutes)
|
||
local limit = tonumber(minutes) or 0
|
||
return limit > 0 and (waitedMs or 0) >= limit * 60000
|
||
end
|
||
|
||
-- Skal den læssede vogn ved Wait parkeres på sin egen P-plads (ADSettings "parkLoadedMinutes", brugerønske 19/10)?
|
||
-- minutes = 0 slår reglen fra. Eget ur (parkMs): waitedMs nulstilles af "kør resten hjem".
|
||
function ADUnloadWait.parkLoadedDue(parkMs, minutes)
|
||
local limit = tonumber(minutes) or 0
|
||
return limit > 0 and (parkMs or 0) >= limit * 60000
|
||
end
|
||
|
||
local function startWaiting(adEnv, task)
|
||
local vehicle = task.vehicle
|
||
-- Kun "fremme ved målet". At AD stadig regner vognen som aflæssende (isActiveAtTrigger)
|
||
-- tæller IKKE med: ved et fuldt fodertrug bliver isUnloading stående for evigt, selv om
|
||
-- intet løber — og så blokerede traktoren stalden i stedet for at køre til Wait.
|
||
if not isAtUnloadTarget(adEnv, vehicle) then
|
||
return -- dryp-vinduet ryddes ikke her (tippe-flaget blinker); et gammelt vindue forkastes ved næste tjek
|
||
end
|
||
-- Efter et bytte er opgavens mål en silo, ikke AD's rigtige aflæsningsmål (anden markør);
|
||
-- der skal AD bare læsse af som normalt, uden Wait-logik.
|
||
local target = ADUnloadWait.unloadTarget(adEnv, vehicle)
|
||
if target == nil then return end
|
||
if task.destinationID ~= target.id then
|
||
-- peger opgaven på et vejpunkt UDEN markør, er id'et forældet (AutoDrive omnummererede vejpunkterne) — ikke et
|
||
-- læs-bytte. In-game 10/10: Cow Barn 1 Food and Straw stod i stalden med 943.000 l halm (mål 10189, AD's 10188).
|
||
local hasMarker = adEnv.ADGraphManager.getMapMarkerByWayPointId ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(task.destinationID) ~= nil
|
||
if not ADUnloadWait.isStaleDestination(task.destinationID, target.id, hasMarker) then return end
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s': opgavens mål %s er et vejpunkt uden markør (forældet id) — rettet til '%s' (%s)",
|
||
tostring(ADRuns.vehicleLabel(vehicle)), tostring(task.destinationID), tostring(target.name), tostring(target.id))
|
||
task.destinationID = target.id
|
||
end
|
||
-- "Lever til" (rest-læs, flow-vogne, lån): kun målet rettes — ingen Wait-logik, som før (review 19/10: ellers fik alle
|
||
-- "Lever til"-ture Wait/bytte, hvis skrivning til 2. markør ikke virker i den tilstand)
|
||
if ADUnloadWait.isDeliverTo(adEnv, vehicle) then return end
|
||
local fillType, rest = getRestLoad(adEnv, vehicle)
|
||
if fillType == nil then
|
||
return
|
||
end
|
||
if rest < ADUnloadWait.MIN_REST_LITERS then
|
||
-- En lille rest som målet ikke kan tage: AutoDrive venter ellers for evigt i triggeren
|
||
-- ("til den er tømt") og spærrer for de næste. Regn vognen som tom og kør videre.
|
||
local smallFree = ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType)
|
||
if rest > 0 and (smallFree == nil or smallFree < rest) and task.finished ~= nil then
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s': %.0f l %s rest kan ikke komme af — regnes som tom, kører videre", tostring(ADRuns.vehicleLabel(vehicle)), rest, g_fillTypeManager ~= nil and tostring(g_fillTypeManager:getFillTypeNameByIndex(fillType)) or tostring(fillType))
|
||
task:finished()
|
||
end
|
||
return
|
||
end
|
||
local free, capacity = ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType)
|
||
-- nil = målet tager slet ikke varen (forkert last fra et tidligere run): som "fuldt"
|
||
local isRejected = free == nil and ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType, true) == false
|
||
-- stationen har plads, men triggeren ved markøren tager ikke varen (TMR ved halm-triggeren): også "fuldt"
|
||
if free ~= nil and not markerTakes(adEnv, vehicle, target.id, fillType) then
|
||
isRejected = true
|
||
local logKey = tostring(target.id) .. ":" .. tostring(fillType)
|
||
if loggedMarkerRejects[vehicle] ~= logKey then
|
||
loggedMarkerRejects[vehicle] = logKey
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s': triggeren ved %s tager ikke %s — finder et andet mål eller Wait", tostring(ADRuns.vehicleLabel(vehicle)),
|
||
tostring(target.name), g_fillTypeManager ~= nil and tostring(g_fillTypeManager:getFillTypeNameByIndex(fillType)) or tostring(fillType))
|
||
end
|
||
end
|
||
if isRejected then
|
||
free = 0
|
||
end
|
||
local dripping = false
|
||
local tipping = vehicle.ad.trailerModule ~= nil and vehicle.ad.trailerModule.isUnloading == true
|
||
if free ~= nil and free >= ADUnloadWait.MIN_FREE_TO_UNLOAD and not tipping then
|
||
-- tipper slet ikke (vognen står forkert): fremrulning/skub tager sig af det — ikke Wait (in-game 19/10 15:17:
|
||
-- 'Unloader F7' blev sendt til Wait, fordi den stod 1,5 m ved siden af triggeren, ikke fordi siloen var fuld)
|
||
dripMarks[vehicle] = nil
|
||
return
|
||
end
|
||
if free ~= nil and free >= ADUnloadWait.MIN_FREE_TO_UNLOAD then
|
||
-- plads, men tømmer den overhovedet? (dråbevis = som fuldt; ellers lad AD tippe)
|
||
local nowMs = ADUtil.now()
|
||
local mark = dripMarks[vehicle]
|
||
-- nyt vindue: første gang, andet mål/vare, mere læs på, eller væk fra målet over DRIP_GAP_MS (review 19/10)
|
||
if mark == nil or mark.targetId ~= target.id or mark.fillType ~= fillType or rest > mark.rest
|
||
or nowMs - (mark.seen or mark.at) > ADUnloadWait.DRIP_GAP_MS then
|
||
dripMarks[vehicle] = {rest = rest, at = nowMs, seen = nowMs, targetId = target.id, fillType = fillType}
|
||
return
|
||
end
|
||
mark.seen = nowMs
|
||
local heldMs = nowMs - mark.at
|
||
if not ADUnloadWait.isDripping({dropped = mark.rest - rest, heldMs = heldMs, rest = rest}) then
|
||
-- tømmer for alvor (eller endnu for tidligt at sige): nyt vindue, når det gamle er brugt
|
||
if heldMs >= ADUnloadWait.DRIP_MIN_MS then
|
||
dripMarks[vehicle] = {rest = rest, at = nowMs, seen = nowMs, targetId = target.id, fillType = fillType}
|
||
end
|
||
return
|
||
end
|
||
dripMarks[vehicle] = nil
|
||
dripping = true
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' tømmer kun dråbevis ved %s (%.0f l på %d min, %.0f l tilbage) — behandles som fuldt mål",
|
||
tostring(ADRuns.vehicleLabel(vehicle)), tostring(target.name), mark.rest - rest, math.floor(heldMs / 60000), rest)
|
||
elseif free == nil then
|
||
return
|
||
end
|
||
|
||
-- Run med flere mål: resten køres til det af run'ets andre mål der har mest plads til varen,
|
||
-- før der ventes (en 2,4M l-vogn kan ellers aldrig komme af med resten ved én svinesti)
|
||
local other, otherFree = findOtherTargetForRest(adEnv, vehicle, fillType, target.id)
|
||
-- dråbevis: målet har måske mere plads end det andet — kun videre, når det betaler sig (ellers frem og tilbage)
|
||
if other ~= nil and dripping and not ADUnloadWait.isWorthLeavingWait(otherFree, free, rest) then other = nil end
|
||
if other ~= nil then
|
||
vehicle.ad.stateModule:setSecondMarkerByWayPointId(other.id)
|
||
redirect(task, other.id)
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s': %s er fuld — resten (%.0f l %s) køres til %s (%.0f l fri)", tostring(ADRuns.vehicleLabel(vehicle)), tostring(target.name), rest,
|
||
g_fillTypeManager ~= nil and tostring(g_fillTypeManager:getFillTypeNameByIndex(fillType)) or tostring(fillType), tostring(other.name), otherFree)
|
||
return
|
||
end
|
||
|
||
local isReachable = function(candidate)
|
||
return hasRouteBothWays(adEnv, vehicle, candidate.marker.id, task.destinationID)
|
||
end
|
||
local pool = getWaitPoolGroup(vehicle)
|
||
local candidate = ADWaitPool.pickFree(adEnv, vehicle, pool, isReachable)
|
||
-- egen pulje fuld: låner nærmeste ledige Wait-punkt fra en anden pulje frem for at spærre målet (in-game 9/10:
|
||
-- mælkebiler og gylle holdt alle fire Cow Wait, og foderet til køerne blev stående i stalden — dyrene først)
|
||
if candidate == nil and pool ~= nil and pool ~= "" then
|
||
candidate = ADWaitPool.pickFree(adEnv, vehicle, "", isReachable)
|
||
if candidate ~= nil then
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s': puljen '%s' er fuld — låner %s (%s)", tostring(ADRuns.vehicleLabel(vehicle)), pool,
|
||
tostring(candidate.marker.name), tostring(candidate.marker.group))
|
||
end
|
||
end
|
||
if candidate == nil then
|
||
if not warnedNoWaitPoint[vehicle] then
|
||
warnedNoWaitPoint[vehicle] = true
|
||
local poolText = pool ~= nil and pool ~= "" and (" i puljen '" .. pool .. "'") or ""
|
||
Logging.warning(ADUnloadWait.LOG_PREFIX .. "'%s' har %.0f l rest, og målet er fuldt — intet ledigt Wait-punkt%s med vejnet til OG fra målet (markør i en mappe med 'Wait' i navnet), så AutoDrive venter ved målet", tostring(ADRuns.vehicleLabel(vehicle)), rest, poolText)
|
||
end
|
||
return
|
||
end
|
||
warnedNoWaitPoint[vehicle] = nil
|
||
ADWaitPool.claim(candidate.marker.id, vehicle)
|
||
-- dråbevis: målet melder plads, men tager næsten intet — ikke straks tilbage (ellers frem og tilbage mellem Wait og målet)
|
||
waits[vehicle] = {task = task, homeDestinationID = task.destinationID, waitMarker = candidate.marker, fillType = fillType, rest = rest,
|
||
dripHoldMs = dripping and 0 or nil}
|
||
-- AD tipper (og holder vognen stille) så længe den står nær sit EGET mål — også i små
|
||
-- portioner, når målet forbruger løbende. Derfor peger AD's mål på Wait-punktet imens.
|
||
redirectForUnload(task, candidate.marker.id)
|
||
local fillTypeName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
|
||
if dripping then
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' venter ved %s (markør %s): %.0f l %s rest — målet tager kun dråbevis imod (melder %.0f l fri); tidligst tilbage om %d min",
|
||
tostring(ADRuns.vehicleLabel(vehicle)), tostring(candidate.marker.name), tostring(candidate.marker.markerIndex or candidate.marker.id), rest,
|
||
tostring(fillTypeName), free, math.floor(ADUnloadWait.DRIP_RETURN_MS / 60000))
|
||
else
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' venter ved %s (markør %s): %.0f l %s rest, målet har kun %.0f l fri", tostring(ADRuns.vehicleLabel(vehicle)), tostring(candidate.marker.name), tostring(candidate.marker.markerIndex or candidate.marker.id), rest, tostring(fillTypeName), free)
|
||
end
|
||
end
|
||
|
||
-- Ventende køretøj: er der nu plads til hele resten, køres tilbage til målet.
|
||
local function updateWaiting(adEnv, task, wait, dt)
|
||
local vehicle = task.vehicle
|
||
if wait.task ~= task then
|
||
release(vehicle)
|
||
return
|
||
end
|
||
local fillType, rest = getRestLoad(adEnv, vehicle)
|
||
if fillType == nil or rest < ADUnloadWait.MIN_REST_LITERS then
|
||
release(vehicle)
|
||
return
|
||
end
|
||
-- Friske tal til evt. bytte og til tilbage-loggen — ikke dem fra da ventningen startede.
|
||
wait.fillType, wait.rest = fillType, rest
|
||
local home = wait.homeDestinationID
|
||
local free, capacity = ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType, nil, home)
|
||
local isRejected = free == nil and ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType, true, home) == false
|
||
-- stationen har plads, men triggeren ved markøren tager ikke varen: ellers Wait -> hjem -> Wait i ring
|
||
or (free ~= nil and not markerTakes(adEnv, vehicle, home, fillType))
|
||
if isRejected then
|
||
free = 0
|
||
end
|
||
wait.isRejected = isRejected
|
||
-- ventetid ved Wait (ADSettings "waitHomeMinutes", pr. stald): udløbet -> resten køres hjem i gårdens lager
|
||
wait.waitedMs = (wait.waitedMs or 0) + (dt or 0)
|
||
local homeBuilding = ADBuildings ~= nil and ADBuildings.byMarker ~= nil and ADBuildings.byMarker(adEnv, ADUtil.farmId(), home, "unload") or nil
|
||
local waitMinutes = ADSettings ~= nil and ADSettings.get("waitHomeMinutes", homeBuilding ~= nil and homeBuilding.id or nil) or 0
|
||
if ADUnloadWait.waitHomeDue(wait.waitedMs, waitMinutes) and ADLoadSwap ~= nil and ADLoadSwap.findDumpMarker ~= nil then
|
||
local marker = ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, rest, home, function(markerId) return hasRouteTo(adEnv, vehicle, markerId) end)
|
||
if marker ~= nil then
|
||
release(vehicle)
|
||
redirectForUnload(task, marker.id)
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' har ventet %d min ved %s — kører resten (%.0f l) hjem i %s", tostring(ADRuns.vehicleLabel(vehicle)), math.floor(wait.waitedMs / 60000), tostring(wait.waitMarker.name), rest, tostring(marker.name))
|
||
return
|
||
end
|
||
wait.waitedMs = 0 -- intet lager tager resten lige nu: prøv igen efter endnu en periode
|
||
end
|
||
-- læsset vogn ved Wait (ADSettings "parkLoadedMinutes", pr. stald): udløbet -> vognen parkeres med læsset på sin
|
||
-- P-plads, og flowet sover. Kun en anmodning: AD stoppes ikke midt i opgavens update (ADFlowWagons.tick udfører)
|
||
wait.parkMs = (wait.parkMs or 0) + (dt or 0)
|
||
local parkMinutes = ADSettings ~= nil and ADSettings.get("parkLoadedMinutes", homeBuilding ~= nil and homeBuilding.id or nil) or 0
|
||
if ADUnloadWait.parkLoadedDue(wait.parkMs, parkMinutes) and ADFlowWagons ~= nil and ADFlowWagons.requestParkLoaded ~= nil then
|
||
wait.parkMs = 0 -- kan vognen ikke parkeres nu (fx de andre traktorer kører), prøves igen efter endnu en periode
|
||
local run = ADRunsController ~= nil and activeRunOf(vehicle) or nil
|
||
if run ~= nil and ADFlowWagons.requestParkLoaded(adEnv, run, vehicle) then return end
|
||
end
|
||
-- run'ets "kør hjem under X %" (fri ≥ (100-X) % af kapaciteten), ellers standardreglen
|
||
local run = ADRunsController ~= nil and activeRunOf(vehicle) or nil
|
||
local freeFraction = run ~= nil and run.returnBelowPercent ~= nil and (1 - run.returnBelowPercent / 100) or nil
|
||
if wait.dripHoldMs ~= nil then wait.dripHoldMs = wait.dripHoldMs + (dt or 0) end
|
||
local dripHold = wait.dripHoldMs ~= nil and wait.dripHoldMs < ADUnloadWait.DRIP_RETURN_MS
|
||
if dripHold or free == nil or not ADSupplyPlanner.canUnloadRest(free, rest, capacity, freeFraction) then
|
||
-- et af run'ets andre mål har plads: kør resten derhen i stedet for at vente på hjemmet (in-game 15/10:
|
||
-- 941.000 l TMR ventede i timevis ved Farm Wait 1 på Kostald 1, mens Kostald 2 stod uden foder)
|
||
wait.otherCheckMs = (wait.otherCheckMs or ADUnloadWait.OTHER_TARGET_CHECK_MS) + (dt or 0)
|
||
if wait.otherCheckMs >= ADUnloadWait.OTHER_TARGET_CHECK_MS then
|
||
wait.otherCheckMs = 0
|
||
-- første tjek pr. ventetur: hvorfor blev de andre mål valgt fra (in-game 16/10: Kostald 2 tom, men ikke valgt)
|
||
local diag = not wait.otherDiagLogged and {} or nil
|
||
local other, otherFree = findOtherTargetForRest(adEnv, vehicle, fillType, home, diag)
|
||
if diag ~= nil then
|
||
wait.otherDiagLogged = true
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' ved %s — andre mål til resten (%.0f l): %s", tostring(ADRuns.vehicleLabel(vehicle)),
|
||
tostring(wait.waitMarker.name), rest, #diag > 0 and table.concat(diag, "; ") or "ingen andre mål")
|
||
end
|
||
if other ~= nil and ADUnloadWait.isWorthLeavingWait(otherFree, free, rest) then
|
||
release(vehicle)
|
||
pendingTargetRestore[vehicle] = nil
|
||
vehicle.ad.stateModule:setSecondMarkerByWayPointId(other.id)
|
||
redirect(task, other.id)
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' forlader %s — resten (%.0f l %s) køres til %s (%.0f l fri)", tostring(ADRuns.vehicleLabel(vehicle)),
|
||
tostring(wait.waitMarker.name), rest, g_fillTypeManager ~= nil and tostring(g_fillTypeManager:getFillTypeNameByIndex(fillType)) or tostring(fillType),
|
||
tostring(other.name), otherFree)
|
||
return
|
||
end
|
||
end
|
||
if ADLoadSwap ~= nil then
|
||
local isReachable = function(markerId)
|
||
return hasRouteTo(adEnv, vehicle, markerId)
|
||
end
|
||
ADLoadSwap.tryFromWait(adEnv, task, wait, dt, redirectForUnload, release, isReachable)
|
||
end
|
||
return
|
||
end
|
||
release(vehicle)
|
||
restoreTarget(vehicle)
|
||
redirect(task, home)
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' kører tilbage fra %s og læsser %.0f l af (målet har %.0f l fri)", tostring(ADRuns.vehicleLabel(vehicle)), tostring(wait.waitMarker.name), rest, free)
|
||
end
|
||
|
||
-- Diagnose (midlertidig): mens en traktor holder ved sit mål med last, logges hvert 15. s hvad
|
||
-- AD ser — vognens indhold, målets fri plads, AD's aflæsningstilstand og vognens dischargeState.
|
||
ADUnloadWait.DEBUG_INTERVAL_MS = 15000
|
||
local debugTimers = setmetatable({}, {__mode = "k"})
|
||
local debugStuck = setmetatable({}, {__mode = "k"}) -- vehicle -> {level, since}: læsset uændret siden
|
||
local debugLogged = setmetatable({}, {__mode = "k"}) -- vehicle -> {destination, rest}: sidst loggede DEBUG-linje
|
||
ADUnloadWait.STUCK_WITH_ROOM_MS = 30000
|
||
|
||
local function debugAtTarget(adEnv, task, dt)
|
||
local vehicle = task.vehicle
|
||
local targetReached = vehicle.ad.drivePathModule:isTargetReached()
|
||
debugTimers[vehicle] = (debugTimers[vehicle] or ADUnloadWait.DEBUG_INTERVAL_MS) + (dt or 0)
|
||
if debugTimers[vehicle] < ADUnloadWait.DEBUG_INTERVAL_MS then
|
||
return
|
||
end
|
||
debugTimers[vehicle] = 0
|
||
local fillType, rest = getRestLoad(adEnv, vehicle)
|
||
if fillType == nil or rest < ADUnloadWait.MIN_REST_LITERS then
|
||
return
|
||
end
|
||
local free, capacity = ADSmartPickup.getTargetFreeCapacity(adEnv, vehicle, fillType)
|
||
-- ved målet MED plads, men læsset falder ikke (in-game 29/9: EDK 650 ved TMR Unload/Biogas Drop) — også det
|
||
-- vil vi se. Ellers kun: målet fuldt/afvist, og traktoren venter ikke ved et Wait-punkt.
|
||
local stuck = debugStuck[vehicle]
|
||
if stuck == nil or rest < stuck.level - 1 then
|
||
stuck = {level = rest, since = g_time or 0}
|
||
debugStuck[vehicle] = stuck
|
||
end
|
||
local stuckWithRoom = targetReached and (g_time or 0) - stuck.since >= ADUnloadWait.STUCK_WITH_ROOM_MS
|
||
if waits[vehicle] ~= nil or (free ~= nil and free >= ADUnloadWait.MIN_FREE_TO_UNLOAD and not stuckWithRoom) then
|
||
return
|
||
end
|
||
local trailerModule = vehicle.ad.trailerModule
|
||
local states = {}
|
||
for _, unit in ipairs(adEnv.AutoDrive.getAllDischargeableUnits(vehicle) or {}) do
|
||
local object = unit.object
|
||
local state = object ~= nil and object.getDischargeState ~= nil and object:getDischargeState() or "?"
|
||
local canDischarge = "?"
|
||
if object ~= nil and object.getCanDischargeToObject ~= nil and object.getCurrentDischargeNode ~= nil then
|
||
local ok, value = pcall(function() return object:getCanDischargeToObject(object:getCurrentDischargeNode()) end)
|
||
canDischarge = ok and tostring(value) or "err"
|
||
end
|
||
-- AD's porte for at starte tømningen (ADTrailerModule:lookForPossibleUnloadTrigger): autoload-tolkning, vognens
|
||
-- afstand til aflæsningspunktet og AD's egen vurdering (in-game 10/10: BOSS ALPIN ved Cow 3 Silo tippede aldrig)
|
||
local hasAL = object ~= nil and adEnv.AutoDrive.hasAL ~= nil and tostring(select(2, pcall(adEnv.AutoDrive.hasAL, adEnv.AutoDrive, object))) or "?"
|
||
local unitDistance = object ~= nil and adEnv.AutoDrive.getDistanceToUnloadPosition ~= nil and select(2, pcall(adEnv.AutoDrive.getDistanceToUnloadPosition, object)) or nil
|
||
local adTrigger = "?"
|
||
if trailerModule ~= nil and trailerModule.lookForPossibleUnloadTrigger ~= nil and object ~= nil then
|
||
local okT, trigger = pcall(trailerModule.lookForPossibleUnloadTrigger, trailerModule, object)
|
||
adTrigger = okT and tostring(trigger ~= nil) or "err"
|
||
end
|
||
table.insert(states, string.format("%s: dischargeState=%s canDischargeToObject=%s hasAL=%s vognAfstand=%s adFinderTrigger=%s",
|
||
tostring(object ~= nil and object.getName ~= nil and object:getName() or "?"), tostring(state), canDischarge, hasAL,
|
||
type(unitDistance) == "number" and string.format("%.1f", unitDistance) or "?", adTrigger))
|
||
end
|
||
local maxTrigger = adEnv.AutoDrive.getMaxTriggerDistance ~= nil and select(2, pcall(adEnv.AutoDrive.getMaxTriggerDistance, vehicle)) or nil
|
||
local mode = vehicle.ad.stateModule.getCurrentMode ~= nil and vehicle.ad.stateModule:getCurrentMode() or nil
|
||
local shouldUnload = mode ~= nil and mode.shouldUnloadAtTrigger ~= nil and tostring(select(2, pcall(mode.shouldUnloadAtTrigger, mode))) or "?"
|
||
table.insert(states, string.format("AD: fillLevel=%s triggerAfstand=%s shouldUnloadAtTrigger=%s rotateTrigger=%s inRange=%s",
|
||
tostring(trailerModule ~= nil and trailerModule.fillLevel), tostring(maxTrigger), shouldUnload,
|
||
tostring(trailerModule ~= nil and trailerModule.lastUnloadRotateTrigger ~= nil),
|
||
adEnv.AutoDrive.isInRangeToLoadUnloadTarget ~= nil and tostring(select(2, pcall(adEnv.AutoDrive.isInRangeToLoadUnloadTarget, vehicle))) or "?"))
|
||
local fillTypeName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
|
||
local distance = adEnv.AutoDrive.getDistanceToUnloadPosition ~= nil and adEnv.AutoDrive.getDistanceToUnloadPosition(vehicle) or -1
|
||
local secondMarker = ADUnloadWait.unloadTarget(adEnv, vehicle) -- AD's aflæsningsmål (1. markør ved "Lever til")
|
||
-- én gang pr. mål og læs (17/10: linjen kom hvert 15. s hele vejen til et fuldt mål)
|
||
local logged = debugLogged[vehicle]
|
||
if logged ~= nil and logged.destination == task.destinationID and math.abs(logged.rest - rest) < 1 then return end
|
||
debugLogged[vehicle] = {destination = task.destinationID, rest = rest}
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "DEBUG '%s': targetReached=%s taskDest=%s adMål=%s; %.0f l %s på vognen; målet fri=%s/kap=%s; AD isUnloading=%s isLoading=%s afstandTilAflæsning=%.1f; venter=%s; %s", tostring(ADRuns.vehicleLabel(vehicle)), tostring(targetReached), tostring(task.destinationID), tostring(secondMarker ~= nil and secondMarker.id or nil), rest, tostring(fillTypeName), tostring(free), tostring(capacity), tostring(trailerModule ~= nil and trailerModule.isUnloading), tostring(trailerModule ~= nil and trailerModule.isLoading), tonumber(distance) or -1, tostring(waits[vehicle] ~= nil), table.concat(states, " | "))
|
||
end
|
||
|
||
function ADUnloadWait.beforeUpdate(adEnv, task, dt)
|
||
-- Udkørsels-traktorer: plads i målet er tjekket før turen, og målet skiftes pr. tur — ingen Wait-logik.
|
||
if ADOutbound ~= nil and ADOutbound.isOutboundVehicle ~= nil and ADOutbound.isOutboundVehicle(task.vehicle) then
|
||
return
|
||
end
|
||
-- Tømning efter stop (ADFlowWagons): ingen Wait-pulje eller læs-bytte — den skal tømme og hjem
|
||
-- (in-game 29/9: Goat Food blev sendt til Cow Wait efter Stop alt)
|
||
if ADFlowWagons ~= nil and ADFlowWagons.isEmptying ~= nil and ADFlowWagons.isEmptying(task.vehicle) then
|
||
if waits[task.vehicle] ~= nil then release(task.vehicle) end
|
||
return
|
||
end
|
||
pcall(debugAtTarget, adEnv, task, dt)
|
||
local wait = waits[task.vehicle]
|
||
if wait ~= nil then
|
||
updateWaiting(adEnv, task, wait, dt)
|
||
else
|
||
startWaiting(adEnv, task)
|
||
end
|
||
end
|
||
|
||
-- Efter en genindlæsning er ventetilstanden (kun i hukommelsen) væk, men AutoDrives gemte mål
|
||
-- peger stadig på Wait-punktet, og traktoren står der med rest-læs — uden dette ville den blive
|
||
-- stående for evigt. Her genoptages ventningen for aktive traktorer i et forsynings-run hvis
|
||
-- aflæsningsopgave peger på en Wait-markør: hjem = run'ets mål, og reservationen sættes igen.
|
||
-- Kaldes fra ADSmartPickup:update (throttlet).
|
||
ADUnloadWait.ADOPT_INTERVAL_MS = 5300
|
||
local adoptTimerMs = ADUnloadWait.ADOPT_INTERVAL_MS
|
||
|
||
function ADUnloadWait.adoptOrphans(adEnv)
|
||
if ADRunsController == nil or ADRunsController.getFarmVehicles == nil then
|
||
return
|
||
end
|
||
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
|
||
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
||
local isActive = stateModule ~= nil and stateModule.isActive ~= nil and stateModule:isActive()
|
||
local run = isActive and waits[vehicle] == nil and activeRunOf(vehicle) or nil
|
||
if run ~= nil and (run.kind or "supply") == "supply" and stateModule.getSecondMarker ~= nil then
|
||
local marker = stateModule:getSecondMarker()
|
||
local task = vehicle.ad.taskModule ~= nil and vehicle.ad.taskModule.getActiveTask ~= nil and vehicle.ad.taskModule:getActiveTask() or nil
|
||
if marker ~= nil and marker.id ~= nil and ADSupplyPlanner.isWaitMarker(marker) and task ~= nil and task.destinationID == marker.id and task.trailers ~= nil then
|
||
local fillType, rest = getRestLoad(adEnv, vehicle)
|
||
local homeId = ADRunsController.chooseTarget ~= nil and ADRunsController.chooseTarget(adEnv, run, vehicle) or run.targetWayPointId
|
||
if fillType ~= nil and rest >= ADUnloadWait.MIN_REST_LITERS and homeId ~= nil then
|
||
ADWaitPool.claim(marker.id, vehicle)
|
||
pendingTargetRestore[vehicle] = homeId
|
||
waits[vehicle] = {task = task, homeDestinationID = homeId, waitMarker = marker, fillType = fillType, rest = rest}
|
||
local fillTypeName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
|
||
logInfo(ADUnloadWait.LOG_PREFIX .. "'%s' genoptager ventning ved %s efter genindlæsning: %.0f l %s rest, hjem = markør %s", tostring(ADRuns.vehicleLabel(vehicle)), tostring(marker.name), rest, tostring(fillTypeName), tostring(homeId))
|
||
end
|
||
end
|
||
end
|
||
end
|
||
end
|
||
|
||
function ADUnloadWait.adoptOrphansThrottled(adEnv, dt)
|
||
adoptTimerMs = adoptTimerMs + (dt or 0)
|
||
if adoptTimerMs < ADUnloadWait.ADOPT_INTERVAL_MS then
|
||
return
|
||
end
|
||
adoptTimerMs = 0
|
||
local ok, err = pcall(ADUnloadWait.adoptOrphans, adEnv)
|
||
if not ok then
|
||
Logging.warning(ADUnloadWait.LOG_PREFIX .. "kunne ikke genoptage ventende traktorer: %s", tostring(err))
|
||
end
|
||
end
|
||
|
||
-- Kaldes fra ADSmartPickup:update — standsede køretøjer slipper deres Wait-punkt.
|
||
function ADUnloadWait.releaseInactive()
|
||
for vehicle in pairs(waits) do
|
||
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
||
if stateModule == nil or stateModule.isActive == nil or not stateModule:isActive() then
|
||
release(vehicle)
|
||
end
|
||
end
|
||
for vehicle in pairs(pendingTargetRestore) do
|
||
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
||
if stateModule == nil or stateModule.isActive == nil or not stateModule:isActive() then
|
||
restoreTarget(vehicle)
|
||
end
|
||
end
|
||
end
|
||
|
||
function ADUnloadWait.getPendingTargetRestore(vehicle)
|
||
return pendingTargetRestore[vehicle]
|
||
end
|
||
|
||
-- Ved Start med forkert last: AD's mål peger på siloen indtil aflæsningen er færdig;
|
||
-- det oprindelige mål gendannes af finished-hook'en.
|
||
function ADUnloadWait.setDumpTarget(vehicle, dumpWayPointId)
|
||
local stateModule = vehicle.ad.stateModule
|
||
local current = stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
|
||
if current ~= nil and current.id ~= dumpWayPointId then
|
||
pendingTargetRestore[vehicle] = pendingTargetRestore[vehicle] or current.id
|
||
end
|
||
if stateModule.setSecondMarkerByWayPointId ~= nil then
|
||
stateModule:setSecondMarkerByWayPointId(dumpWayPointId)
|
||
end
|
||
end
|
||
|
||
-- Hvem holder hvor (GUI'ets Wait-puljer-visning). Sorteret på mappe, dernæst markør-id.
|
||
-- Vognens indhold (største enhed) og evt. Wait-tilstand — til overblikket i fanen.
|
||
function ADUnloadWait.hasRouteBothWays(adEnv, vehicle, toWayPointId, homeWayPointId)
|
||
return hasRouteBothWays(adEnv, vehicle, toWayPointId, homeWayPointId)
|
||
end
|
||
|
||
function ADUnloadWait.hasRouteTo(adEnv, vehicle, wayPointId)
|
||
return hasRouteTo(adEnv, vehicle, wayPointId)
|
||
end
|
||
|
||
function ADUnloadWait.getRestLoad(adEnv, vehicle)
|
||
return getRestLoad(adEnv, vehicle)
|
||
end
|
||
|
||
function ADUnloadWait.getWaitFor(vehicle)
|
||
local wait = waits[vehicle]
|
||
if wait == nil then
|
||
return nil
|
||
end
|
||
return {markerName = wait.waitMarker ~= nil and wait.waitMarker.name or nil, fillType = wait.fillType, rest = wait.rest}
|
||
end
|
||
|
||
-- Alle reservationer i puljen (også udkørsels-traktorer der holder).
|
||
function ADUnloadWait.getClaims(adEnv)
|
||
return ADWaitPool.getClaims(adEnv)
|
||
end
|
||
|
||
ADUnloadWait.TIP_CHECK_MS = 2000
|
||
local tipChecked = setmetatable({}, {__mode = "k"})
|
||
|
||
function ADUnloadWait.install(adEnv)
|
||
local task, autoDrive = adEnv.UnloadAtDestinationTask, adEnv.AutoDrive
|
||
if isInstalled or task == nil or task.update == nil or autoDrive == nil or autoDrive.getSetting == nil then
|
||
return
|
||
end
|
||
isInstalled = true
|
||
ADUnloadWait.STATE_DRIVING = task.STATE_DRIVING or 2
|
||
ADWaitPool.STATE_DRIVING = ADUnloadWait.STATE_DRIVING
|
||
|
||
local originalUpdate, originalFinished, originalGetSetting = task.update, task.finished, autoDrive.getSetting
|
||
|
||
task.update = function(self, dt)
|
||
-- alle aflæsningsture (også udkørsel og tømning): tipvognen på en side AD må aflæsse fra (EDK 650, 29/9)
|
||
if ADTipSide ~= nil and self.vehicle ~= nil then
|
||
local now = g_time or 0
|
||
if (tipChecked[self.vehicle] or -math.huge) + ADUnloadWait.TIP_CHECK_MS <= now then
|
||
tipChecked[self.vehicle] = now
|
||
local okTip, errTip = pcall(ADTipSide.ensure, self.vehicle)
|
||
if not okTip then Logging.warning(ADUnloadWait.LOG_PREFIX .. "tip-side: %s", tostring(errTip)) end
|
||
end
|
||
end
|
||
local ok, err = pcall(ADUnloadWait.beforeUpdate, adEnv, self, dt)
|
||
if not ok then
|
||
Logging.warning(ADUnloadWait.LOG_PREFIX .. "fejl i Wait-punkt-logik, AutoDrive fortsætter selv: %s", tostring(err))
|
||
release(self.vehicle)
|
||
end
|
||
return originalUpdate(self, dt)
|
||
end
|
||
|
||
if originalFinished ~= nil then
|
||
task.finished = function(self)
|
||
release(self.vehicle)
|
||
restoreTarget(self.vehicle)
|
||
-- læsset er afleveret: tæller ikke længere som "på vej" for de andre traktorer
|
||
if ADSmartPickup ~= nil and ADSmartPickup.clearEnRoute ~= nil then
|
||
ADSmartPickup.clearEnRoute(self.vehicle)
|
||
end
|
||
-- en vogn parkeret med læs er tømt: flaget ryddes (en rest falder tilbage til Wait-logikken)
|
||
if ADFlowWagons ~= nil and ADFlowWagons.clearParkedIfEmpty ~= nil then
|
||
local okClear, errClear = pcall(ADFlowWagons.clearParkedIfEmpty, adEnv, self.vehicle)
|
||
if not okClear then Logging.warning(ADUnloadWait.LOG_PREFIX .. "parkeret læs: %s", tostring(errClear)) end
|
||
end
|
||
return originalFinished(self)
|
||
end
|
||
end
|
||
|
||
-- Ved "rotér aflæsning" kører AutoDrive straks videre fra et mål den ikke kan læsse
|
||
-- af ved — også fra Wait-punktet. Ventende køretøjer ser derfor rotationen som slået fra.
|
||
autoDrive.getSetting = function(settingName, vehicle)
|
||
if settingName == "rotateTargets" and vehicle ~= nil and waits[vehicle] ~= nil then
|
||
return autoDrive.RT_NONE
|
||
end
|
||
return originalGetSetting(settingName, vehicle)
|
||
end
|
||
end
|