3be3a5aa52
- adRunsController.stopAllAndPark: run.sleeping = nil (sovende flow blev gemt som stoppet+sovende og vækkede sig selv). - adFlowSleep: keepsSleepAfterLoad (ren) + engangsoprydning ved indlæsning, når moden er på pause; venter på ADFieldJobs.loaded; ingen vækning før da. Ingen pause-vagt pr. tick (spillerstartede flows må sove/vågne). In-game 18/10 01:19: 'Slurry' vågnede og sendte tre 1050 Vario'er efter deres vogne før 'Start alle'. - Tests MW1-MW5, C21-udvidelse; manualer + changelog.
626 lines
33 KiB
Lua
626 lines
33 KiB
Lua
-- AD Flow Sleep
|
|
-- Dvale for flows: har alle et flows traktorer holdt ved Wait uden noget at lave i SLEEP_AFTER_MS (tomme, med vogn
|
|
-- bagpå), stoppes flowet som med Stop-knappen — vognen sættes på sin parkering og traktoren kører hjem, så begge er
|
|
-- ledige for maskinpuljen/markarbejdet — og markeres run.sleeping. Hvert WAKE_CHECK_MS spørges flowets planlægning
|
|
-- (udkørsel: ADOutboundPlanner; forsyning: ADSmartPickup.findSupplyPickup) med den parkerede vogn som "køretøj", om
|
|
-- der er en tur. Så vækkes flowet: er traktoren lånt ud, tager den nærmeste ledige traktor der kan trække vognen
|
|
-- dens plads. Lastbiler med eget lad (mælkebil, pallebil) sover også: de kører til deres egen parkering i stedet for
|
|
-- at holde ved Wait, og vækkes på samme måde (aldrig byttet ud). Spilleren der trykker Start/Stop sletter dvalen.
|
|
-- Ren logik øverst (testes med luajit), spil-adapter nederst.
|
|
|
|
ADFlowSleep = {}
|
|
ADFlowSleep.LOG_PREFIX = "ADSmartPickup: dvale: "
|
|
ADFlowSleep.SLEEP_AFTER_MS = 10 * 60 * 1000 -- tomgang så længe før flowet sover
|
|
ADFlowSleep.WAKE_CHECK_MS = 60 * 1000 -- så tit et sovende flow tjekkes for arbejde
|
|
ADFlowSleep.TICK_MS = 1000
|
|
ADFlowSleep.MIN_CARGO_LITERS = 100 -- mindre end dette på vognen = tom (som ADFlowWagons.EMPTY_MIN_LITERS)
|
|
ADFlowSleep.MAX_CHECK_FAILURES = 3 -- arbejdstjek der fejler så mange gange i træk vækker flowet alligevel
|
|
|
|
-- ---- ren logik ----
|
|
|
|
-- s = {stopped, vehicles = {{holding, hasWagon, ownBody, cargo} | false}} (false = traktoren findes ikke) -> tomgang?
|
|
-- ownBody = lastbil med eget lad: tæller som traktor med vogn.
|
|
-- allowCargo: last på vognen er i orden (gødningsreserven: gyllen på vognen er netop det, markerne skal have)
|
|
function ADFlowSleep.isIdle(s)
|
|
if s.stopped or #(s.vehicles or {}) == 0 then return false end
|
|
for _, vehicle in ipairs(s.vehicles) do
|
|
if not vehicle or not vehicle.holding or not (vehicle.hasWagon or vehicle.ownBody)
|
|
or (not s.allowCargo and (vehicle.cargo or 0) >= ADFlowSleep.MIN_CARGO_LITERS) then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Tomgangsuret: starter ved første tomgang, nulstilles (nil) så snart flowet laver noget.
|
|
function ADFlowSleep.track(since, isIdle, nowMs)
|
|
if not isIdle then return nil end
|
|
return since or nowMs
|
|
end
|
|
|
|
function ADFlowSleep.shouldSleep(since, nowMs)
|
|
return since ~= nil and nowMs - since >= ADFlowSleep.SLEEP_AFTER_MS
|
|
end
|
|
|
|
-- Holdes et salgs-flow tilbage af gødningsreserven ("… reserveret til markerne (183 ha)")? Så er der intet at
|
|
-- vente på ved Wait: flowet sover straks, og traktor + gyllevogn er ledige til gødningen (brugerønske 17/10:
|
|
-- "de skal jo ikke sælge gylle imens der gødes"). reasons = planlæggerens grunde (ADOutbound.getRunStatus).
|
|
ADFlowSleep.RESERVE_SLEEP_GRACE_MS = 60 * 1000 -- idle så længe før reserve-dvalen (ikke straks efter en opvågning)
|
|
function ADFlowSleep.heldForFields(reasons)
|
|
for _, reason in ipairs(reasons or {}) do
|
|
if type(reason) == "string" and string.find(reason, "reserveret til markerne", 1, true) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Pause før næste vågn-tjek efter falske opvågninger (vågnede, men sov igen uden en tur): 10 -> 30 -> 60 min.
|
|
ADFlowSleep.FALSE_WAKE_BACKOFF_MS = {10 * 60 * 1000, 30 * 60 * 1000, 60 * 60 * 1000}
|
|
function ADFlowSleep.wakeBackoffMs(falseWakes)
|
|
if (falseWakes or 0) <= 0 then return ADFlowSleep.WAKE_CHECK_MS end
|
|
local steps = ADFlowSleep.FALSE_WAKE_BACKOFF_MS
|
|
return steps[math.min(falseWakes, #steps)]
|
|
end
|
|
|
|
function ADFlowSleep.isCheckDue(lastCheck, nowMs, falseWakes)
|
|
return lastCheck == nil or nowMs - lastCheck >= ADFlowSleep.wakeBackoffMs(falseWakes)
|
|
end
|
|
|
|
-- Falske opvågninger i træk efter en ny dvale. previous = tælleren hvis flowet er vækket af dvalen (nil = første
|
|
-- dvale); hadTrip = flowet har haft last på siden opvågningen.
|
|
function ADFlowSleep.falseWakesAfterSleep(previous, hadTrip)
|
|
if previous == nil or hadTrip then return 0 end
|
|
return previous + 1
|
|
end
|
|
|
|
-- ---- hvorfor sover flowet? (in-game 17/10: 'Coop Egg Pickup' stod "sleeping" med fulde hønsehuse, fordi ægprisen
|
|
-- lå på 86 % af top mod krævet 90 — men det stod ingen steder) ----
|
|
|
|
ADFlowSleep.REASON_LOG_MS = 60 * 60 * 1000 -- samme grund logges højst så tit pr. flow
|
|
|
|
-- Grundtekst til oversigt/log: planlæggerens grund, ellers en kort standard pr. flowtype.
|
|
function ADFlowSleep.sleepReasonText(why, kind)
|
|
if why ~= nil and why ~= "" then return why end
|
|
if kind == "outbound" then return "intet at køre ud med" end
|
|
return "intet at hente til målene"
|
|
end
|
|
|
|
-- Skal grunden logges nu? last = {ms, text} fra sidste logning (nil = aldrig). Ny tekst logges straks, samme tekst
|
|
-- igen først efter REASON_LOG_MS.
|
|
-- Kort form til oversigtens smalle statuscelle: første grund, uden "af top" og uden lager-delen
|
|
-- ("EGG 86 % af top (kræver 90), lager 100 %; MILK …" -> "EGG 86 % (kræver 90)"). Hele teksten står i loggen.
|
|
function ADFlowSleep.shortReason(text)
|
|
if text == nil then return nil end
|
|
local first = string.match(text, "^(.-);") or text
|
|
first = string.gsub(first, " af top", "")
|
|
first = string.gsub(first, ",%s*lager [^,]*$", "")
|
|
return first
|
|
end
|
|
|
|
function ADFlowSleep.reasonLogDue(last, nowMs, text)
|
|
if last == nil or last.text ~= text then return true end
|
|
return nowMs - (last.ms or 0) >= ADFlowSleep.REASON_LOG_MS
|
|
end
|
|
|
|
local function nearest(list, x, z)
|
|
local best, bestDistance = nil, math.huge
|
|
for _, item in ipairs(list or {}) do
|
|
local d = ((item.x or 0) - (x or 0)) ^ 2 + ((item.z or 0) - (z or 0)) ^ 2
|
|
if d < bestDistance then best, bestDistance = item, d end
|
|
end
|
|
return best
|
|
end
|
|
|
|
-- Traktor ved opvågning. s = {own, ownFree, candidates, wagon = {x, z, neededHp}, bestFit?(candidates, wagon)}:
|
|
-- egen hvis ledig; ellers bedste ledige (bestFit, ellers nærmeste vognen); ellers egen (startes og venter på den).
|
|
function ADFlowSleep.chooseTractor(s)
|
|
if s.own ~= nil and s.ownFree then return s.own end
|
|
local wagon = s.wagon or {}
|
|
local other = nil
|
|
if #(s.candidates or {}) > 0 then
|
|
other = s.bestFit ~= nil and s.bestFit(s.candidates, wagon) or nearest(s.candidates, wagon.x, wagon.z)
|
|
end
|
|
return other or s.own
|
|
end
|
|
|
|
-- Ny vehicleIds-liste og vogntabel hvor newId tager oldId's plads og vogn. Originalen røres ikke.
|
|
function ADFlowSleep.swapTractor(run, oldId, newId)
|
|
local ids, wagons = {}, {}
|
|
for _, id in ipairs(run.vehicleIds or {}) do table.insert(ids, id == oldId and newId or id) end
|
|
for tractorId, wagonId in pairs(run.wagons or {}) do wagons[tractorId] = wagonId end
|
|
if oldId ~= newId then
|
|
wagons[newId] = wagons[oldId]
|
|
wagons[oldId] = nil
|
|
end
|
|
return ids, wagons
|
|
end
|
|
|
|
-- Arbejdstjekket fejlede: én fejl mere -> ny tæller, vækkes nu? Et tjek der altid fejler må ikke efterlade flowet
|
|
-- sovende for altid, men én fejl må heller ikke vække det (ellers vågner og sover det hvert 11. minut).
|
|
function ADFlowSleep.onCheckError(failures)
|
|
local count = (failures or 0) + 1
|
|
return count, count >= ADFlowSleep.MAX_CHECK_FAILURES
|
|
end
|
|
|
|
-- Fik opvågningen mindst én traktor i gang? results = ADRunsController.startRun's poster {ok, reason}.
|
|
function ADFlowSleep.anyStarted(results)
|
|
for _, result in ipairs(results or {}) do
|
|
if result.ok then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Flowets egen hjemtur efter dvale (tømmer/kører hjem) — traktoren er ikke lånt ud, den skal bare bruges igen.
|
|
function ADFlowSleep.isOwnTrip(wagonStatus)
|
|
return wagonStatus == "homing" or wagonStatus == "emptying"
|
|
end
|
|
|
|
-- Må flowets egen traktor køre turen? s = {exists, lentOut, onOwnTrip, carriesOwnWagon}. Kun lånt ud (markopgave,
|
|
-- Courseplay, marksilo, et andet flow) er optaget; flowets egen vogn på eller egen hjemtur er netop rigtigt.
|
|
function ADFlowSleep.ownUsable(s)
|
|
return s.exists == true and not s.lentOut
|
|
end
|
|
|
|
-- Ledig traktor i et KØRENDE flow (ikke stoppet, ikke i dvale, uendelige runder): AutoDrive slukket, ikke lånt ud og
|
|
-- ingen spiller bag rattet. Den første returneres (én start pr. tjek). members = {{id, active, usable, controlled}}.
|
|
-- (in-game 15/10: '130 Cow Food and Straw' 2 og 3 holdt stille i timevis, mens nr. 1 ventede med fuldt læs — flowet
|
|
-- "kørte", så hverken dvale eller "Start alle" rørte dem)
|
|
function ADFlowSleep.pickIdleMember(run, members)
|
|
if run == nil or run.stopped or run.sleeping or (run.loops or 0) > 0 then return nil end
|
|
for _, member in ipairs(members or {}) do
|
|
if not member.active and member.usable and not member.controlled then return member.id end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Pause efter en start der ikke lykkedes (fx ingen vogn) eller som venter på/henter vognen, så loggen ikke fyldes.
|
|
ADFlowSleep.RESTART_FAILED_BACKOFF_MS = 10 * 60 * 1000
|
|
-- Har spilleren siddet i traktoren for nylig, er den stoppet med vilje: lad den stå så længe.
|
|
ADFlowSleep.MANUAL_GRACE_MS = 10 * 60 * 1000
|
|
-- Ingen genstart lige efter indlæsning: AutoDrive genoptager selv aktive traktorer de første sekunder.
|
|
ADFlowSleep.RESTART_STARTUP_DELAY_MS = 60 * 1000
|
|
|
|
function ADFlowSleep.restartNeedsBackoff(result)
|
|
return result == nil or not result.ok or result.reason == "waitingWagon" or result.reason == "fetchingWagon"
|
|
end
|
|
|
|
-- ---- spil-adapter ----
|
|
|
|
local sleepReason = {} -- runId -> grund fra seneste vågn-tjek uden tur (vises i oversigten)
|
|
local reasonLogged = {} -- runId -> {ms, text} for seneste loggede grund
|
|
local idleSince = {} -- runId -> ms
|
|
local reserveIdleSince = {} -- runId -> ms: tomgang (last tilladt) mens gødningsreserven holder salget
|
|
local lastCheck = {} -- runId -> ms
|
|
local checkFailures = {} -- runId -> fejlede arbejdstjek i træk
|
|
local wakeState = {} -- runId -> {falseWakes, woke (vækket af dvalen), hadTrip (last siden opvågningen)}
|
|
local loggedErrors = {}
|
|
local timerMs = 0
|
|
|
|
local function nowMs()
|
|
if g_currentMission ~= nil and type(g_currentMission.time) == "number" then return g_currentMission.time end
|
|
return os.clock() * 1000
|
|
end
|
|
|
|
local function logOnce(key, text)
|
|
if loggedErrors[key] then return end
|
|
loggedErrors[key] = true
|
|
Logging.warning(ADFlowSleep.LOG_PREFIX .. "%s", tostring(text))
|
|
end
|
|
|
|
-- Alle køretøjer (også frakoblede vogne, som ikke står i AutoDrives liste).
|
|
local function findVehicle(id)
|
|
if id == nil then return nil end
|
|
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
|
|
if ADRunsController.getVehicleId(vehicle) == id then return vehicle end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function cargoOf(adEnv, vehicle)
|
|
local autoDrive = adEnv.AutoDrive
|
|
if autoDrive == nil or autoDrive.getAllUnits == nil or autoDrive.getAllFillLevels == nil then return 0 end
|
|
local level = autoDrive.getAllFillLevels(autoDrive.getAllUnits(vehicle))
|
|
return type(level) == "number" and level or 0
|
|
end
|
|
|
|
local function hasCargoWagon(vehicle)
|
|
for _, implement in ipairs(ADHitch.rearImplementsOf(vehicle)) do
|
|
local object = implement.object
|
|
if object ~= nil and (object.spec_fillUnit ~= nil or object.spec_trailer ~= nil) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Lastbil med eget lad (samme kriterie som ADPool.isPuller's ownBody).
|
|
local function hasOwnBody(vehicle)
|
|
return vehicle ~= nil and (vehicle.spec_trailer ~= nil or vehicle.spec_dischargeable ~= nil)
|
|
end
|
|
|
|
local function vehicleState(adEnv, vehicle)
|
|
local held = ADOutbound ~= nil and ADOutbound.getHoldFor ~= nil and ADOutbound.getHoldFor(vehicle) ~= nil
|
|
-- venter med rest-last ved et fuldt mål (ADUnloadWait) er ikke tomgang
|
|
local waitingWithLoad = ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) ~= nil
|
|
return {holding = held and not waitingWithLoad, hasWagon = hasCargoWagon(vehicle), ownBody = hasOwnBody(vehicle),
|
|
cargo = cargoOf(adEnv, vehicle)}
|
|
end
|
|
|
|
-- Vognen (eller lastbilen selv) som planlægningen kan regne med: kapacitet og varer den kan bære.
|
|
local function cargoVehicleOf(run, byId, onlyTractorId)
|
|
for _, tractorId in ipairs(run.vehicleIds or {}) do
|
|
if onlyTractorId == nil or tractorId == onlyTractorId then
|
|
local wagon = findVehicle((run.wagons or {})[tractorId])
|
|
if wagon ~= nil then return wagon end
|
|
local tractor = byId[tractorId]
|
|
if tractor ~= nil and (hasCargoWagon(tractor) or hasOwnBody(tractor)) then return tractor end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Har flowet en tur nu? -> bool, begrundelse. onlyTractorId: regn med netop den traktors vogn (ledig traktor i et
|
|
-- kørende flow — en anden traktors fulde vogn ville aldrig give en tur).
|
|
function ADFlowSleep.hasWork(adEnv, run, byId, onlyTractorId)
|
|
local cargo = cargoVehicleOf(run, byId, onlyTractorId)
|
|
if cargo == nil then return onlyTractorId == nil, "ingen vogn at regne med" end
|
|
if run.kind == "outbound" then
|
|
local trip, reasons = ADOutboundPlanner.plan(ADOutbound.buildPlanInput(adEnv, run, cargo))
|
|
if trip == nil then
|
|
-- planlæggerens grunde ("EGG 86 % af top (kræver 90), lager 100 %") — det er dem, spilleren skal se
|
|
return false, #(reasons or {}) > 0 and table.concat(reasons, "; ") or nil
|
|
end
|
|
return true, string.format("%s til %s, vogn '%s'", table.concat(trip.names or {}, "+"),
|
|
tostring(trip.targetName or "?"), tostring(ADRuns.vehicleLabel(cargo)))
|
|
end
|
|
local ingredients = ADRunsController.getRunIngredients(adEnv, run, cargo)
|
|
for _, targetId in ipairs(ADRunsController.getRunTargets(run)) do
|
|
local choice = ADSmartPickup.findSupplyPickup(adEnv, cargo, ingredients, targetId)
|
|
if choice ~= nil then
|
|
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(choice.fillType) or tostring(choice.fillType)
|
|
return true, string.format("hent %s ved %s (%.0f l der, mål mangler %.0f l), vogn '%s'", tostring(name),
|
|
tostring(choice.markerName), choice.level or -1, choice.need ~= nil and choice.need.freeSpace or -1,
|
|
tostring(ADRuns.vehicleLabel(cargo))), choice, targetId
|
|
end
|
|
end
|
|
return false, nil
|
|
end
|
|
|
|
local positionOf = ADUtil.positionOf
|
|
|
|
local function isOwnFree(vehicle, tractorId, run)
|
|
if vehicle == nil then return false end
|
|
local status = ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) or nil
|
|
local onOwnTrip = ADFlowSleep.isOwnTrip(status)
|
|
local otherRun = ADRunsController.getRunForVehicle(vehicle)
|
|
local lentOut = (otherRun ~= nil and otherRun ~= run)
|
|
or (ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.assignments ~= nil and ADFieldJobs.state.assignments[tractorId] ~= nil)
|
|
or (ADCpBridge ~= nil and ADCpBridge.isWorking ~= nil and ADCpBridge.isWorking(vehicle) == true)
|
|
or (ADFieldSilos ~= nil and ADFieldSilos.isLoaned ~= nil and ADFieldSilos.isLoaned(vehicle) == true)
|
|
or (not onOwnTrip and ADPool ~= nil and ADPool.isReturning ~= nil and ADPool.isReturning(vehicle) == true)
|
|
return ADFlowSleep.ownUsable({exists = true, lentOut = lentOut, onOwnTrip = onOwnTrip})
|
|
end
|
|
|
|
-- Ledige puljetraktorer der ikke hører til noget flow (heller ikke et sovende/stoppet) og ikke er reserveret.
|
|
local function freeTractors(adEnv, taken)
|
|
local _, tractors = ADPool.collect(adEnv, function(vehicle) return ADFieldWork.isBusyVehicle(vehicle, ADRunsController.getVehicleId(vehicle)) end)
|
|
local blocked = ADPool.blocked(nowMs())
|
|
local result = {}
|
|
for _, tractor in ipairs(tractors or {}) do
|
|
if not blocked[tractor.id] and not taken[tractor.id] and not tractor.offNetwork
|
|
and ADRunsController.getRunForVehicle(tractor.vehicle) == nil then
|
|
table.insert(result, tractor)
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- Seneste vågn-tjeks grund for et sovende flow: planlæggerens tekst, false = ingen tur uden nærmere grund (GUI'et
|
|
-- oversætter selv efter flowtype), nil = intet vågn-tjek endnu.
|
|
function ADFlowSleep.getSleepReason(runId)
|
|
return sleepReason[runId]
|
|
end
|
|
|
|
local function noteNoWork(run, why, now)
|
|
local text = ADFlowSleep.sleepReasonText(why, run.kind)
|
|
sleepReason[run.id] = (why ~= nil and why ~= "") and why or false
|
|
if run.kind == "outbound" and why ~= nil and ADOutbound ~= nil and ADOutbound.setRunReasons ~= nil then
|
|
pcall(ADOutbound.setRunReasons, run.id, {why})
|
|
end
|
|
if ADFlowSleep.reasonLogDue(reasonLogged[run.id], now, text) then
|
|
reasonLogged[run.id] = {ms = now, text = text}
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' sover videre: %s", tostring(run.name), text)
|
|
end
|
|
end
|
|
|
|
-- Sættet (traktor med flowets vogn på) er lånt ud til markarbejde (gøder): flowet må ikke vækkes, før det er
|
|
-- færdigt — en anden traktor kan ikke tage vognen, og flowet ville stå "tændt" og vente (review 17/10)
|
|
local function lentOutWithWagon(run, byId)
|
|
for _, tractorId in ipairs(run.vehicleIds or {}) do
|
|
local own = byId[tractorId]
|
|
local wagonId = (run.wagons or {})[tractorId]
|
|
if own ~= nil and wagonId ~= nil then
|
|
for _, implement in ipairs(ADHitch.rearImplementsOf(own)) do
|
|
if ADRunsController.getVehicleId(implement.object) == wagonId and not isOwnFree(own, tractorId, run) then
|
|
return ADRuns.vehicleLabel(own)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function wake(adEnv, run, byId, why)
|
|
local busySet = lentOutWithWagon(run, byId)
|
|
if busySet ~= nil then
|
|
local text = string.format("sættet '%s' er lånt ud (gøder)", tostring(busySet))
|
|
if ADFlowSleep.reasonLogDue(reasonLogged[run.id], nowMs(), text) then
|
|
reasonLogged[run.id] = {ms = nowMs(), text = text}
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' har arbejde, men %s — sover videre", tostring(run.name), text)
|
|
end
|
|
return
|
|
end
|
|
run.sleeping = nil
|
|
sleepReason[run.id] = nil
|
|
reasonLogged[run.id] = nil
|
|
-- dvale-tjekkets gamle grunde må ikke sende flowet i dvale igen, før planlæggeren har kørt (review 17/10)
|
|
if run.kind == "outbound" and ADOutbound ~= nil and ADOutbound.setRunReasons ~= nil then pcall(ADOutbound.setRunReasons, run.id, {}) end
|
|
local taken = {}
|
|
for _, tractorId in ipairs(run.vehicleIds or {}) do
|
|
local own = byId[tractorId]
|
|
local wagonId = (run.wagons or {})[tractorId]
|
|
local wagonOnOwn = false
|
|
for _, implement in ipairs(own ~= nil and ADHitch.rearImplementsOf(own) or {}) do
|
|
if wagonId ~= nil and ADRunsController.getVehicleId(implement.object) == wagonId then wagonOnOwn = true end
|
|
end
|
|
-- vognen sidder på den egne traktor: aldrig byt (en anden traktor ville vente på vognen for evigt)
|
|
-- lastbil med eget lad: aldrig byt (en traktor kan ikke tage dens tur)
|
|
if not wagonOnOwn and not hasOwnBody(own) and not isOwnFree(own, tractorId, run) then
|
|
local wagon = findVehicle(wagonId)
|
|
local x, z = positionOf(wagon or own)
|
|
local okHp, neededHp = pcall(ADPool.readNeededHp, wagon)
|
|
local okFree, candidates = pcall(freeTractors, adEnv, taken)
|
|
local chosen = ADFlowSleep.chooseTractor({own = own ~= nil and {id = tractorId} or nil, ownFree = false,
|
|
candidates = okFree and candidates or {}, wagon = {x = x, z = z, neededHp = okHp and neededHp or nil},
|
|
bestFit = function(list, implement) return ADPool.bestFit(list, implement, "unloader") end})
|
|
if chosen ~= nil and chosen.id ~= tractorId then
|
|
run.vehicleIds, run.wagons = ADFlowSleep.swapTractor(run, tractorId, chosen.id)
|
|
taken[chosen.id] = true
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': '%s' er optaget — '%s' tager turen", tostring(run.name),
|
|
own ~= nil and tostring(ADRuns.vehicleLabel(own)) or tostring(tractorId), tostring(chosen.name or chosen.id))
|
|
end
|
|
end
|
|
end
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' vågner (%s)", tostring(run.name), tostring(why or "arbejde"))
|
|
local results = ADRunsController.startRun(adEnv, run.id)
|
|
if not ADFlowSleep.anyStarted(results) then
|
|
-- ingen traktor kunne starte (fx ugyldig markør): tilbage i dvale, ellers står flowet "tændt" uden at køre
|
|
local reasons = {}
|
|
for _, result in ipairs(results or {}) do table.insert(reasons, tostring(result.reason)) end
|
|
ADRunsController.stopRun(adEnv, run.id)
|
|
run.sleeping = true
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' kunne ikke starte (%s) — sover videre", tostring(run.name), table.concat(reasons, ", "))
|
|
end
|
|
end
|
|
|
|
-- Lastbiler uden parkering bliver holdende ved Wait, når flowet sover — skriv det i loggen.
|
|
local function logTrucksWithoutPark(adEnv, run, byId)
|
|
for _, id in ipairs(run.vehicleIds or {}) do
|
|
local vehicle = byId[id]
|
|
local okPark, park = pcall(ADFieldWork.parkMarkerId, adEnv, vehicle)
|
|
if vehicle ~= nil and hasOwnBody(vehicle) and not (okPark and park ~= nil) then
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' har ingen parkering — bliver stående ved Wait (giv den en P-plads i AutoDrive)",
|
|
tostring(ADRuns.vehicleLabel(vehicle)))
|
|
end
|
|
end
|
|
end
|
|
|
|
-- keepWagons: sættet bliver samlet, hvor det står (gødningsreserven) — markflåden tager det som gødningsmaskine
|
|
local function sleep(adEnv, run, byId, why, keepWagons)
|
|
if not keepWagons then logTrucksWithoutPark(adEnv, run, byId) end
|
|
local state = wakeState[run.id] or {}
|
|
local falseWakes = ADFlowSleep.falseWakesAfterSleep(state.woke and (state.falseWakes or 0) or nil, state.hadTrip == true)
|
|
wakeState[run.id] = {falseWakes = falseWakes}
|
|
ADRunsController.stopRun(adEnv, run.id, keepWagons)
|
|
run.sleeping = true
|
|
idleSince[run.id] = nil
|
|
lastCheck[run.id] = nowMs()
|
|
-- ny dvale: ingen gammel grund i oversigten, og første vågn-tjek må logge sin grund igen
|
|
sleepReason[run.id] = nil
|
|
reasonLogged[run.id] = nil
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' sover — %s; %s%s",
|
|
tostring(run.name), why or string.format("intet at lave i %d min", math.floor(ADFlowSleep.SLEEP_AFTER_MS / 60000)),
|
|
keepWagons and "sættet bliver samlet og er ledigt til markflåden (gødning)" or "traktor og vogn er ledige til andet", falseWakes > 0
|
|
and string.format(" (vågnede uden tur %d gang(e) i træk — næste tjek om %d min)", falseWakes, math.floor(ADFlowSleep.wakeBackoffMs(falseWakes) / 60000)) or "")
|
|
end
|
|
|
|
local function farmVehiclesById(adEnv)
|
|
local byId = {}
|
|
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
|
|
local id = ADRunsController.getVehicleId(vehicle)
|
|
if id ~= nil then byId[id] = vehicle end
|
|
end
|
|
return byId
|
|
end
|
|
|
|
local restartDue = {} -- runId -> ms hvor næste tjek for ledige traktorer må køre
|
|
local restartWaiting = {} -- runId -> true mens en ledig traktor med arbejde står i udsendelsesportens kø
|
|
local lastControlled = setmetatable({}, {__mode = "k"}) -- køretøj -> ms hvor spilleren sidst sad i den
|
|
|
|
-- Ren: skal endnu en traktor ud? Kun når målet mangler mere end flowets andre vogne allerede har med (in-game 16/10:
|
|
-- 'Cow Food 2' sendt ud efter 14.583 l, mens 'Cow Food 1' ventede ved Wait med 157.921 l af samme foder).
|
|
function ADFlowSleep.needsMoreThanCarried(freeSpace, carriedByOthers)
|
|
if freeSpace == nil then return true end
|
|
return freeSpace > (carriedByOthers or 0)
|
|
end
|
|
|
|
-- Liter af varen som flowets ANDRE traktorer har med uden at være meldt "på vej" til målet (fx en rest ved Wait).
|
|
-- Meldt på vej er allerede trukket fra målets behov (findSupplyPickup/getPending) — ikke to gange (review 16/10).
|
|
local function carriedByOthers(adEnv, run, byId, exceptId, fillType, targetId)
|
|
local total = 0
|
|
if ADSmartPickup.carriedLiters == nil or fillType == nil then return total end
|
|
for _, id in ipairs(run.vehicleIds or {}) do
|
|
local vehicle = byId[id]
|
|
if id ~= exceptId and vehicle ~= nil then
|
|
local route = ADSmartPickup.getEnRoute ~= nil and ADSmartPickup.getEnRoute(vehicle) or nil
|
|
local carried = ADSmartPickup.carriedLiters(adEnv, vehicle, fillType) or 0
|
|
local counted = route ~= nil and route.fillType == fillType and (targetId == nil or route.wayPointId == targetId)
|
|
-- meldt på vej: kun det den har med ud over det meldte (planlagt mængde kan være mindre end lasten)
|
|
if counted then carried = math.max(0, carried - (tonumber(route.liters) or 0)) end
|
|
total = total + carried
|
|
end
|
|
end
|
|
return total
|
|
end
|
|
|
|
local function restartIdleMember(adEnv, run, byId, now)
|
|
local members = {}
|
|
for _, id in ipairs(run.vehicleIds or {}) do
|
|
local vehicle = byId[id]
|
|
if vehicle ~= nil and vehicle.getIsControlled ~= nil and vehicle:getIsControlled() == true then lastControlled[vehicle] = now end
|
|
end
|
|
if restartDue[run.id] == nil then restartDue[run.id] = now + ADFlowSleep.RESTART_STARTUP_DELAY_MS end
|
|
if now < restartDue[run.id] then return end
|
|
local gateName = "flow:" .. tostring(run.id)
|
|
-- står allerede i portens kø: regn ikke det hele igen hvert sekund, før det er vores tur
|
|
if restartWaiting[run.id] and ADLaunchGate ~= nil and not ADLaunchGate.isOpen(gateName) then return end
|
|
restartWaiting[run.id] = nil
|
|
for _, id in ipairs(run.vehicleIds or {}) do
|
|
local vehicle = byId[id]
|
|
if vehicle ~= nil then
|
|
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
|
-- vogn-logikken er i gang (henter, venter på, tømmer eller kører hjem): ikke vores at starte
|
|
local wagonBusy = ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) ~= nil
|
|
local recentlyDriven = lastControlled[vehicle] ~= nil and now - lastControlled[vehicle] < ADFlowSleep.MANUAL_GRACE_MS
|
|
-- står i "Start alle"-køen: køen starter den (in-game 16/10: Cow Food 3 blev startet uden om køen)
|
|
local queued = ADRunsController.isQueuedToStart ~= nil and ADRunsController.isQueuedToStart(id)
|
|
table.insert(members, {id = id, active = module ~= nil and module.isActive ~= nil and module:isActive(),
|
|
usable = not wagonBusy and not queued and isOwnFree(vehicle, id, run), controlled = recentlyDriven})
|
|
end
|
|
end
|
|
local id = ADFlowSleep.pickIdleMember(run, members)
|
|
local hasWork, why, choice, choiceTarget = false, nil, nil, nil
|
|
if id ~= nil then hasWork, why, choice, choiceTarget = ADFlowSleep.hasWork(adEnv, run, byId, id) end
|
|
-- de andre vogne har allerede nok med til det målet mangler: ingen ekstra tur
|
|
if hasWork and choice ~= nil and choice.need ~= nil then
|
|
local carried = carriedByOthers(adEnv, run, byId, id, choice.fillType, choiceTarget)
|
|
if not ADFlowSleep.needsMoreThanCarried(choice.need.freeSpace, carried) then hasWork = false end
|
|
end
|
|
if not hasWork then
|
|
restartDue[run.id] = now + ADFlowSleep.WAKE_CHECK_MS
|
|
if ADLaunchGate ~= nil then ADLaunchGate.done(gateName) end
|
|
return
|
|
end
|
|
-- fælles udsendelsesport: står i kø og prøver igen ved næste tick (uden at skubbe minut-tjekket)
|
|
if ADLaunchGate ~= nil and not ADLaunchGate.isOpen(gateName) then
|
|
restartWaiting[run.id] = true
|
|
return
|
|
end
|
|
restartDue[run.id] = now + ADFlowSleep.WAKE_CHECK_MS
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': '%s' holder stille i det kørende flow — startes (%s)", tostring(run.name),
|
|
tostring(ADRuns.vehicleLabel(byId[id])), tostring(why))
|
|
local result = ADRunsController.startVehicle(adEnv, run, byId[id])
|
|
if ADLaunchGate ~= nil then
|
|
if result ~= nil and result.ok then ADLaunchGate.markLaunched(gateName) else ADLaunchGate.done(gateName) end
|
|
end
|
|
if ADFlowSleep.restartNeedsBackoff(result) then restartDue[run.id] = now + ADFlowSleep.RESTART_FAILED_BACKOFF_MS end
|
|
end
|
|
|
|
-- Overlever dvalen en genindlæsning? Ikke når moden er sat på pause ("Stop alt og parkér" — intet starter før
|
|
-- "Start alle"): et gem fra før 1.62.334 kan holde et flow som stoppet+sovende, og det vækkede sig selv (18/10 01:19).
|
|
-- Kun ved indlæsning — et flow spilleren starter under pausen må gerne sove og vågne. s = {sleeping, stopped, paused}
|
|
function ADFlowSleep.keepsSleepAfterLoad(s)
|
|
if s == nil or not s.sleeping or not s.stopped then return false end
|
|
return s.paused ~= true
|
|
end
|
|
|
|
local function modPaused()
|
|
return ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.paused == true
|
|
end
|
|
|
|
local loadChecked = false
|
|
local function cancelSleepIfPaused()
|
|
if loadChecked then return end
|
|
-- pause-flaget læses først i ADFieldJobs.load (ca. 1 s efter start) — vent på det (review)
|
|
if ADFieldJobs == nil or not ADFieldJobs.loaded then return end
|
|
if ADRunsController.store == nil or ADRunsController.store.runs == nil then return end
|
|
loadChecked = true
|
|
local paused = modPaused()
|
|
for _, run in ipairs(ADRunsController.store.runs or {}) do
|
|
if run.sleeping and not ADFlowSleep.keepsSleepAfterLoad({sleeping = run.sleeping, stopped = run.stopped, paused = paused}) then
|
|
run.sleeping = nil
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s': dvalen aflyst ved indlæsning (moden er sat på pause med Stop alt)", tostring(run.name))
|
|
end
|
|
end
|
|
end
|
|
|
|
local function tickRun(adEnv, run, byId, now)
|
|
if run.sleeping and run.stopped then
|
|
if not ADFlowSleep.isCheckDue(lastCheck[run.id], now, (wakeState[run.id] or {}).falseWakes) then return end
|
|
lastCheck[run.id] = now
|
|
local ok, hasWork, why = pcall(ADFlowSleep.hasWork, adEnv, run, byId)
|
|
if ok then
|
|
checkFailures[run.id] = nil
|
|
else
|
|
logOnce("hasWork:" .. tostring(run.id), string.format("'%s': arbejdstjek fejlede: %s", tostring(run.name), tostring(hasWork)))
|
|
local wakeNow
|
|
checkFailures[run.id], wakeNow = ADFlowSleep.onCheckError(checkFailures[run.id])
|
|
hasWork, why = wakeNow, "arbejdstjekket fejlede " .. tostring(checkFailures[run.id]) .. " gange"
|
|
if wakeNow then checkFailures[run.id] = nil end
|
|
end
|
|
if hasWork then
|
|
local state = wakeState[run.id] or {}
|
|
wakeState[run.id] = {falseWakes = state.falseWakes or 0, woke = true, hadTrip = false}
|
|
wake(adEnv, run, byId, why)
|
|
else
|
|
noteNoWork(run, why, now)
|
|
end
|
|
return
|
|
end
|
|
-- startet af spilleren (fx "Start alle") mens det sov
|
|
if run.sleeping and not run.stopped then run.sleeping = nil end
|
|
local vehicles = {}
|
|
local state = wakeState[run.id]
|
|
for index, id in ipairs(run.vehicleIds or {}) do
|
|
local vehicle = byId[id]
|
|
vehicles[index] = vehicle ~= nil and vehicleState(adEnv, vehicle) or false
|
|
-- last på efter opvågningen = opvågningen var ægte
|
|
if state ~= nil and state.woke and vehicles[index] and (vehicles[index].cargo or 0) >= ADFlowSleep.MIN_CARGO_LITERS then
|
|
state.hadTrip = true
|
|
end
|
|
end
|
|
local idle = ADFlowSleep.isIdle({stopped = run.stopped, vehicles = vehicles})
|
|
idleSince[run.id] = ADFlowSleep.track(idleSince[run.id], idle, now)
|
|
if ADFlowSleep.shouldSleep(idleSince[run.id], now) then
|
|
sleep(adEnv, run, byId)
|
|
return
|
|
end
|
|
-- gødningsreserven holder salget: sov efter kort tomgang med vognen på (også med gylle i), så sættet kan gøde
|
|
-- samlet (ikke 10 min ved Wait, ingen tur hjem)
|
|
if run.kind == "outbound" and ADOutbound ~= nil and ADOutbound.getRunStatus ~= nil
|
|
and ADFlowSleep.heldForFields(ADOutbound.getRunStatus(run.id).reasons) then
|
|
local idleWithCargo = ADFlowSleep.isIdle({stopped = run.stopped, vehicles = vehicles, allowCargo = true})
|
|
reserveIdleSince[run.id] = ADFlowSleep.track(reserveIdleSince[run.id], idleWithCargo, now)
|
|
if reserveIdleSince[run.id] ~= nil and now - reserveIdleSince[run.id] >= ADFlowSleep.RESERVE_SLEEP_GRACE_MS then
|
|
reserveIdleSince[run.id] = nil
|
|
sleep(adEnv, run, byId, "gyllen er reserveret til markerne", true)
|
|
return
|
|
end
|
|
else
|
|
reserveIdleSince[run.id] = nil
|
|
end
|
|
restartIdleMember(adEnv, run, byId, now)
|
|
end
|
|
|
|
function ADFlowSleep.tick(adEnv, dt)
|
|
timerMs = timerMs + (dt or 0)
|
|
if timerMs < ADFlowSleep.TICK_MS then return end
|
|
timerMs = 0
|
|
if adEnv == nil or ADRunsController == nil or ADRunsController.store == nil then return end
|
|
local byId = farmVehiclesById(adEnv)
|
|
local now = nowMs()
|
|
pcall(cancelSleepIfPaused)
|
|
if not loadChecked then return end -- ingen vækning, før gemmets pause-flag er læst
|
|
for _, run in ipairs(ADRunsController.store.runs or {}) do
|
|
local ok, err = pcall(tickRun, adEnv, run, byId, now)
|
|
if not ok then logOnce("tick:" .. tostring(run.id), string.format("'%s': %s", tostring(run.name), tostring(err))) end
|
|
end
|
|
end
|