fae9761f1a
Brugerønske 18/10 18:36: færre traktorer. spareWagons pr. traktor, ADWagonSwap vurderer vognene før hver tur og bruger flowets vognbytte.
172 lines
10 KiB
Lua
172 lines
10 KiB
Lua
-- AD Wagon Swap
|
|
-- Én traktor, flere vogne i samme flow (brugerønske 18/10 18:36: "vil reducere brugen af traktorer og dermed spare
|
|
-- penge"). Flowet husker traktorens AKTIVE vogn (run.wagons) og dens ekstra vogne (run.spareWagons). Før hver tur
|
|
-- (AD spørger efter næste pålæsning) vurderes, hvad hver af traktorens vogne kunne hente; har den aktive intet at
|
|
-- hente — eller haster en anden vare langt mere — bliver den anden vogn aktiv, og flowets eksisterende vognbytte
|
|
-- (ADFlowWagons.beforeStart "swap": tøm, sæt af på P-pladsen, hent ved Connect) udfører skiftet.
|
|
-- Ren logik øverst, spil-adapter nederst.
|
|
|
|
ADWagonSwap = {}
|
|
ADWagonSwap.LOG_PREFIX = "ADSmartPickup: "
|
|
ADWagonSwap.COOLDOWN_MS = 10 * 60 * 1000 -- højst ét skift pr. traktor pr. 10 min (ingen pendulkørsel)
|
|
ADWagonSwap.URGENT_MIN = 30 -- en anden vare "haster" under 30 min til tom
|
|
ADWagonSwap.URGENCY_FACTOR = 3 -- ... og den aktive vogns vare har mindst 3 gange så lang tid
|
|
|
|
-- Skal traktoren skifte vogn? s = {loaded, sinceSwapMs, current = {minutesToEmpty} | nil (intet at hente),
|
|
-- alternatives = {{wagonId, minutesToEmpty}}} -> vognId eller nil.
|
|
-- Lastet: aldrig (læsset skal af først). Den aktive intet at hente: den mest akutte anden vogn. Den aktive har arbejde:
|
|
-- kun når en anden vare haster (< URGENT_MIN) og den aktive vares tid er mindst URGENCY_FACTOR gange længere.
|
|
-- En vare uden tidsmål (stald, lager) regnes som "ikke akut" — men et alternativ uden tid er stadig arbejde.
|
|
function ADWagonSwap.decide(s)
|
|
if s == nil or s.loaded then return nil end
|
|
if s.sinceSwapMs ~= nil and s.sinceSwapMs < ADWagonSwap.COOLDOWN_MS then return nil end
|
|
local best = nil
|
|
for _, alt in ipairs(s.alternatives or {}) do
|
|
local minutes = alt.minutesToEmpty or math.huge
|
|
if best == nil or minutes < (best.minutesToEmpty or math.huge) then best = alt end
|
|
end
|
|
if best == nil then return nil end
|
|
if s.current == nil then return best.wagonId end
|
|
local bestMinutes = best.minutesToEmpty or math.huge
|
|
local currentMinutes = s.current.minutesToEmpty
|
|
if currentMinutes == nil or bestMinutes >= ADWagonSwap.URGENT_MIN then return nil end
|
|
if currentMinutes >= bestMinutes * ADWagonSwap.URGENCY_FACTOR then return best.wagonId end
|
|
return nil
|
|
end
|
|
|
|
-- ---- spil-adapter ----
|
|
|
|
local pending = {} -- traktor -> {runId, tractorId, wagonId}
|
|
local lastSwap = {} -- traktorId -> tid for sidste skift
|
|
local nowMs = 0
|
|
|
|
local function findAnyVehicle(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
|
|
|
|
-- Varer en ekstra vogn vurderes på: pallevognen (Universal Autoload) kun palle-varer, tipvognen kun løsvarer (review:
|
|
-- AutoDrive regner en Autoload-vogn for at kunne bære alle varer med bigbag — korn inklusive — men den læsser kun
|
|
-- paller). ingredients = fyldtype-indeks. -> ny liste
|
|
function ADWagonSwap.goodsFor(wagon, ingredients)
|
|
local autoload = ADPool ~= nil and ADPool.hasAutoload ~= nil and ADPool.hasAutoload(wagon)
|
|
local result = {}
|
|
for _, fillType in ipairs(ingredients or {}) do
|
|
local pallet = ADSources ~= nil and ADSources.isPalletOnlyFillType ~= nil and ADSources.isPalletOnlyFillType(fillType)
|
|
if (autoload and pallet) or (not autoload and not pallet) then table.insert(result, fillType) end
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- Kan vognen hentes nu? Findes, sidder ikke på noget, er ikke reserveret, og har en Connect-markør.
|
|
local function fetchable(adEnv, wagon, wagonId)
|
|
if wagon == nil then return false end
|
|
if wagon.getAttacherVehicle ~= nil and wagon:getAttacherVehicle() ~= nil then return false end
|
|
if ADPool ~= nil and ADPool.isReserved ~= nil and ADPool.isReserved(wagonId) then return false end
|
|
return ADFlowWagons ~= nil and ADFlowWagons.connectFor ~= nil and ADFlowWagons.connectFor(adEnv, wagon) ~= nil
|
|
end
|
|
ADWagonSwap.isFetchable = fetchable
|
|
|
|
-- Har traktorens nuværende vogn en P-plads at blive sat af på? (vognbyttet i ADFlowWagons.beforeStart kræver det —
|
|
-- uden kører traktoren videre med den gamle vogn, mens flowet tror den nye er aktiv: review H1)
|
|
local function rearHasPark(adEnv, driver)
|
|
local rear = ADHitch ~= nil and ADHitch.rearImplementsOf ~= nil and ADHitch.rearImplementsOf(driver)[1] or nil
|
|
local index = rear ~= nil and rear.object.advd ~= nil and rear.object.advd.parkDestination or nil
|
|
if type(index) ~= "number" or index < 1 then return false end
|
|
return adEnv.ADGraphManager ~= nil and adEnv.ADGraphManager:getMapMarkerById(index) ~= nil
|
|
end
|
|
|
|
-- Mindste "minutter til tom" for vognens bedste tur blandt flowets mål; nil = intet at hente. -> har arbejde?, min
|
|
local function bestFor(adEnv, run, cargo)
|
|
local ingredients = ADWagonSwap.goodsFor(cargo, ADRunsController.getRunIngredients(adEnv, run, cargo))
|
|
if #ingredients == 0 then return false, nil end
|
|
local found, best = false, nil
|
|
for _, targetId in ipairs(ADRunsController.getRunTargets(run)) do
|
|
local okChoice, choice = pcall(ADSmartPickup.probeSupplyPickup, adEnv, cargo, ingredients, targetId)
|
|
if okChoice and choice ~= nil then
|
|
found = true
|
|
local minutes = choice.need ~= nil and choice.need.minutesToEmpty or nil
|
|
if minutes ~= nil and (best == nil or minutes < best) then best = minutes end
|
|
end
|
|
end
|
|
return found, best
|
|
end
|
|
|
|
-- Før en tur (ADSmartPickup.choosePickup, forsyningsflow): skal traktoren skifte vogn? currentChoice = turen med den
|
|
-- aktive vogn (nil = intet at hente). -> true når et skift er sat i gang (udføres i tick, uden for AD's opslag).
|
|
function ADWagonSwap.consider(adEnv, driver, run, currentChoice)
|
|
if run == nil or (run.kind or "supply") ~= "supply" or run.stopped or pending[driver] ~= nil then return false end
|
|
local tractorId = ADRunsController.getVehicleId(driver)
|
|
local spares = tractorId ~= nil and (run.spareWagons or {})[tractorId] or nil
|
|
if spares == nil or #spares == 0 then return false end
|
|
-- byttet kræver, at den nuværende vogn kan sættes af på sin P-plads, og at traktoren ikke er lånt ud
|
|
if not rearHasPark(adEnv, driver) then return false end
|
|
if ADFlowWagons ~= nil and ADFlowWagons.isPoolBusy ~= nil and ADFlowWagons.isPoolBusy(driver, tractorId) then return false end
|
|
local restType, restLiters = nil, 0
|
|
if ADUnloadWait ~= nil and ADUnloadWait.getRestLoad ~= nil then restType, restLiters = ADUnloadWait.getRestLoad(adEnv, driver) end
|
|
local alternatives = {}
|
|
for _, wagonId in ipairs(spares) do
|
|
local wagon = findAnyVehicle(wagonId)
|
|
if fetchable(adEnv, wagon, wagonId) then
|
|
local found, minutes = bestFor(adEnv, run, wagon)
|
|
if found then table.insert(alternatives, {wagonId = wagonId, minutesToEmpty = minutes, wagon = wagon}) end
|
|
end
|
|
end
|
|
-- den aktive vogns tur tæller kun, når varen passer til vognens slags: AutoDrive regner en Autoload-vogn for at
|
|
-- kunne bære korn (bigbag), men den skal skifte til tipvognen (review 18/10)
|
|
local rear = ADHitch ~= nil and ADHitch.rearImplementsOf ~= nil and ADHitch.rearImplementsOf(driver)[1] or nil
|
|
if currentChoice ~= nil and currentChoice.fillType ~= nil and rear ~= nil
|
|
and #ADWagonSwap.goodsFor(rear.object, {currentChoice.fillType}) == 0 then
|
|
currentChoice = nil
|
|
end
|
|
local current = currentChoice ~= nil and {minutesToEmpty = currentChoice.need ~= nil and currentChoice.need.minutesToEmpty or nil} or nil
|
|
local since = lastSwap[tractorId] ~= nil and (nowMs - lastSwap[tractorId]) or nil
|
|
local wagonId = ADWagonSwap.decide({loaded = restType ~= nil and (restLiters or 0) >= 100, sinceSwapMs = since,
|
|
current = current, alternatives = alternatives})
|
|
if wagonId == nil then return false end
|
|
pending[driver] = {runId = run.id, tractorId = tractorId, wagonId = wagonId}
|
|
local wagonName = "?"
|
|
for _, alt in ipairs(alternatives) do if alt.wagonId == wagonId then wagonName = ADRuns.vehicleLabel(alt.wagon) end end
|
|
Logging.info(ADWagonSwap.LOG_PREFIX .. "flow '%s': '%s' skifter til vognen '%s' (%s)", tostring(run.name),
|
|
tostring(ADRuns.vehicleLabel(driver)), tostring(wagonName),
|
|
current == nil and "den aktive vogn har intet at hente" or "en anden vare haster mere")
|
|
return true
|
|
end
|
|
|
|
-- Udfør ventende skift: ny aktiv vogn i flowet, AD stoppes, og flowets start (ADFlowWagons.beforeStart) bytter vognen.
|
|
function ADWagonSwap.tick(adEnv, dt)
|
|
nowMs = nowMs + (dt or 0)
|
|
for driver, item in pairs(pending) do
|
|
pending[driver] = nil
|
|
local run = ADRuns.getRun(ADRunsController.store, item.runId)
|
|
if run ~= nil and not run.stopped then
|
|
local oldWagons, oldSpares = run.wagons, run.spareWagons
|
|
run.wagons, run.spareWagons = ADRuns.swapActive(run.wagons, run.spareWagons, item.tractorId, item.wagonId)
|
|
lastSwap[item.tractorId] = nowMs
|
|
ADRunsController.stopIfRunning(driver, "skifter vogn")
|
|
local okStart, result = pcall(ADRunsController.startVehicle, adEnv, run, driver)
|
|
-- byttet er kun i gang, når flowets start henter vognen ("fetchingWagon"); ellers rulles valget tilbage, så
|
|
-- flowet ikke tror en parkeret vogn er aktiv (review H1)
|
|
if not okStart or result == nil or result.reason ~= "fetchingWagon" then
|
|
local current = ADRuns.getRun(ADRunsController.store, item.runId)
|
|
if current ~= nil then current.wagons, current.spareWagons = oldWagons, oldSpares end
|
|
Logging.warning(ADWagonSwap.LOG_PREFIX .. "flow '%s': vogneskiftet for '%s' blev ikke sat i gang (%s) — kører videre med den nuværende vogn",
|
|
tostring(run.name), tostring(ADRuns.vehicleLabel(driver)), tostring(okStart and result ~= nil and result.reason or result))
|
|
if okStart and (result == nil or result.ok) and (result == nil or result.reason ~= "waitingWagon") then
|
|
-- startet med den gamle vogn (ingen bytte): intet mere at gøre
|
|
elseif current ~= nil and not current.stopped then
|
|
pcall(ADRunsController.startVehicle, adEnv, current, driver)
|
|
end
|
|
end
|
|
pcall(ADRunsController.save)
|
|
end
|
|
end
|
|
end
|
|
|
|
function ADWagonSwap.reset()
|
|
pending, lastSwap, nowMs = {}, {}, 0
|
|
end
|