329 lines
16 KiB
Lua
329 lines
16 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 sover aldrig (intet at frigive). 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 = 1 -- mindre end dette på vognen = tom
|
|
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, cargo} | false}} (false = traktoren findes ikke) -> tomgang?
|
|
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.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
|
|
|
|
-- ---- 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
|
|
|
|
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), 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)
|
|
for _, tractorId in ipairs(run.vehicleIds or {}) do
|
|
local wagon = findVehicle((run.wagons or {})[tractorId])
|
|
if wagon ~= nil then return wagon end
|
|
if byId[tractorId] ~= nil and hasCargoWagon(byId[tractorId]) then return byId[tractorId] end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Har det sovende flow en tur nu? -> bool, begrundelse
|
|
function ADFlowSleep.hasWork(adEnv, run, byId)
|
|
local cargo = cargoVehicleOf(run, byId)
|
|
if cargo == nil then return true, "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)
|
|
if vehicle == nil then return false end
|
|
-- egen hjemtur efter dvalen: startVehicle afbryder den (ADFlowWagons.abortHomeTripOnStart)
|
|
if ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowSleep.isOwnTrip(ADFlowWagons.statusOf(vehicle)) then return true end
|
|
if ADPool ~= nil and ADPool.isFreeFromFlows ~= nil and not ADPool.isFreeFromFlows(vehicle) then return false end
|
|
if ADFieldWork ~= nil and ADFieldWork.isBusyVehicle ~= nil and ADFieldWork.isBusyVehicle(vehicle, tractorId) then return false end
|
|
return not (ADFlowWagons ~= nil and ADFlowWagons.isPoolBusy ~= nil and ADFlowWagons.isPoolBusy(vehicle, tractorId))
|
|
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]
|
|
if not isOwnFree(own, tractorId) then
|
|
local wagon = findVehicle((run.wagons or {})[tractorId])
|
|
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
|
|
|
|
local function sleep(adEnv, run)
|
|
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 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) end
|
|
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
|