450 lines
23 KiB
Lua
450 lines
23 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.
|
|
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 (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
|
|
|
|
-- 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
|
|
|
|
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 idleSince = {} -- runId -> ms
|
|
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 = ADOutboundPlanner.plan(ADOutbound.buildPlanInput(adEnv, run, cargo))
|
|
return trip ~= nil, trip ~= nil and string.format("%s til %s, vogn '%s'", table.concat(trip.names or {}, "+"),
|
|
tostring(trip.targetName or "?"), tostring(ADRuns.vehicleLabel(cargo))) or nil
|
|
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)))
|
|
end
|
|
end
|
|
return false, nil
|
|
end
|
|
|
|
local function positionOf(vehicle)
|
|
if vehicle == nil or vehicle.rootNode == nil then return nil, nil end
|
|
local x, _, z = getWorldTranslation(vehicle.rootNode)
|
|
return x, z
|
|
end
|
|
|
|
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
|
|
|
|
local function wake(adEnv, run, byId, why)
|
|
run.sleeping = nil
|
|
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
|
|
|
|
local function sleep(adEnv, run, byId)
|
|
logTrucksWithoutPark(adEnv, run, byId)
|
|
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)
|
|
run.sleeping = true
|
|
idleSince[run.id] = nil
|
|
lastCheck[run.id] = nowMs()
|
|
Logging.info(ADFlowSleep.LOG_PREFIX .. "'%s' sover — intet at lave i %d min; traktor og vogn er ledige til andet%s",
|
|
tostring(run.name), math.floor(ADFlowSleep.SLEEP_AFTER_MS / 60000), 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
|
|
|
|
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 = false, nil
|
|
if id ~= nil then hasWork, why = ADFlowSleep.hasWork(adEnv, run, byId, id) 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
|
|
|
|
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)
|
|
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
|
|
idleSince[run.id] = ADFlowSleep.track(idleSince[run.id], ADFlowSleep.isIdle({stopped = run.stopped, vehicles = vehicles}), now)
|
|
if ADFlowSleep.shouldSleep(idleSince[run.id], now) then
|
|
sleep(adEnv, run, byId)
|
|
return
|
|
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()
|
|
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
|