feat: én traktor, flere vogne i samme flow — skifter vogn mellem ture; kæden laver kombinerede flows (1.62.337)
Brugerønske 18/10 18:36: færre traktorer. spareWagons pr. traktor, ADWagonSwap vurderer vognene før hver tur og bruger flowets vognbytte.
This commit is contained in:
@@ -147,7 +147,9 @@ end
|
||||
-- traktor og vogn (brugerønske 18/10 18:34), så de lægges aldrig i samme flow.
|
||||
function ADChainActions.chainRunFor(runs, consumer, kind, kindOf)
|
||||
for _, run in ipairs(runs or {}) do
|
||||
if isChainRun(run) and contains(run.targetBuildingIds, consumer) and (kindOf == nil or kindOf(run) == kind) then return run.id end
|
||||
local runKind = kindOf ~= nil and kindOf(run) or nil
|
||||
-- et kombineret flow (én traktor, tipvogn + pallevogn: "mixed") tager begge slags
|
||||
if isChainRun(run) and contains(run.targetBuildingIds, consumer) and (kindOf == nil or runKind == kind or runKind == "mixed") then return run.id end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
@@ -49,6 +49,20 @@ function ADChainRun.choosePair(implements, tractors, fillTypeIndex, used, blocke
|
||||
return nil
|
||||
end
|
||||
|
||||
-- Kun en pallevogn (Universal Autoload) fra puljen — rene pallevogne først, ikke en allerede brugt. -> redskab eller nil
|
||||
function ADChainRun.chooseAutoloadWagon(implements, used, blocked)
|
||||
used, blocked = used or {}, blocked or {}
|
||||
for _, pureFirst in ipairs({true, false}) do
|
||||
for _, implement in ipairs(implements or {}) do
|
||||
if implement.autoload == true and not used[implement.id] and not blocked[implement.id]
|
||||
and (not pureFirst or not isUnloader(implement)) then
|
||||
return implement
|
||||
end
|
||||
end
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
-- ---- marker ----
|
||||
|
||||
local function fieldById(fields, id)
|
||||
@@ -159,6 +173,63 @@ local function startWithPair(adEnv, run, runId, pair, used, verb)
|
||||
return started
|
||||
end
|
||||
|
||||
local undoStaffing -- defineret ved staffIdleFlows (slipper traktoren igen, når en start afvises)
|
||||
|
||||
-- Én traktor, tipvogn + pallevogn (brugerønske 18/10 18:36: "vil reducere brugen af traktorer og dermed spare
|
||||
-- penge"): flowet får traktor + løsvare-vogn som aktiv og en pallevogn som ekstra vogn (ADWagonSwap skifter mellem
|
||||
-- ture). -> true når det lykkedes (ellers kører varerne i hvert sit flow).
|
||||
local function staffCombined(adEnv, run, runId, bulkIndex, pool, used, verb)
|
||||
if pool.implements == nil then pool.implements, pool.tractors = collectPool(adEnv) end
|
||||
if pool.blocked == nil then pool.blocked = ADPool.blocked(ADFieldJobs.now or 0) end
|
||||
local pair = ADChainRun.choosePair(pool.implements, pool.tractors, bulkIndex, used, pool.blocked, false)
|
||||
if pair == nil then return false end
|
||||
local probe = {}
|
||||
for id in pairs(used) do probe[id] = true end
|
||||
probe[pair.implement.id], probe[pair.tractor.id] = true, true
|
||||
local spare = ADChainRun.chooseAutoloadWagon(pool.implements, probe, pool.blocked)
|
||||
if spare == nil then return false end
|
||||
used[spare.id] = true
|
||||
local started = startWithPair(adEnv, run, runId, pair, used, verb)
|
||||
local fresh = ADRuns.getRun(ADRunsController.store, runId)
|
||||
if started == 0 or fresh == nil then
|
||||
-- start afvist: traktoren slippes igen (review H2 — ellers holdt et dødt flow den)
|
||||
used[spare.id] = nil
|
||||
undoStaffing(adEnv, runId, pair)
|
||||
return false
|
||||
end
|
||||
local spares = ADRuns.copySpares(fresh.spareWagons)
|
||||
spares[pair.tractor.id] = {spare.id}
|
||||
fresh.spareWagons = spares
|
||||
log("flow '%s': '%s' skifter mellem '%s' og pallevognen '%s' (én traktor)", tostring(fresh.name), tostring(pair.tractor.name),
|
||||
tostring(pair.implement.name), tostring(spare.name))
|
||||
return true
|
||||
end
|
||||
|
||||
-- Nyt kombineret flow (løsvarer + paller, én traktor) til en bygning uden kædeflows. -> true når oprettet og bemandet.
|
||||
local function createCombinedFlow(adEnv, data, group, bulk, pallets, pool, used)
|
||||
local goods = {}
|
||||
for _, name in ipairs(bulk) do table.insert(goods, name) end
|
||||
for _, name in ipairs(pallets) do table.insert(goods, name) end
|
||||
local bulkIndex = data.fillIndex[bulk[1]]
|
||||
if bulkIndex == nil then return false end
|
||||
-- prøv først uden at oprette noget: findes traktor + tipvogn + pallevogn?
|
||||
if pool.implements == nil then pool.implements, pool.tractors = collectPool(adEnv) end
|
||||
if pool.blocked == nil then pool.blocked = ADPool.blocked(ADFieldJobs.now or 0) end
|
||||
local pair = ADChainRun.choosePair(pool.implements, pool.tractors, bulkIndex, used, pool.blocked, false)
|
||||
local probe = {}
|
||||
for id in pairs(used) do probe[id] = true end
|
||||
if pair ~= nil then probe[pair.implement.id], probe[pair.tractor.id] = true, true end
|
||||
if pair == nil or ADChainRun.chooseAutoloadWagon(pool.implements, probe, pool.blocked) == nil then return false end
|
||||
local created = ADRunsController.createRun(ADChain.flowName(flowTitle(data, goods), group.consumerName or group.consumer), "supply")
|
||||
ADRunsController.updateRun(created.id, {targetBuildingIds = {group.consumer}, ingredientMode = "manual", ingredients = goods,
|
||||
waitPoolGroup = ADChain.waitPoolFor(ADRunsController.store.runs, group.consumer), chain = group.rootKey})
|
||||
local run = ADRuns.getRun(ADRunsController.store, created.id)
|
||||
if staffCombined(adEnv, run, created.id, bulkIndex, pool, used, "oprettet med") then return true end
|
||||
-- start afvist: flowet bliver stående som tomt kædeflow (deles og bemandes senere)
|
||||
createStopped(ADRuns.getRun(ADRunsController.store, created.id), "noVehicle", "ingen ledig traktor + vogne til %s", tostring(created.name))
|
||||
return true
|
||||
end
|
||||
|
||||
local function createGroupFlow(adEnv, data, group, fillTypes, pool, used)
|
||||
local title = flowTitle(data, fillTypes)
|
||||
local created = ADRunsController.createRun(ADChain.flowName(title, group.consumerName or group.consumer), "supply")
|
||||
@@ -215,11 +286,25 @@ end
|
||||
function ADChainRun.splitMixedFlows(adEnv, data, active)
|
||||
local kindOf, isPalletName = kindOfFor(data)
|
||||
local split = 0
|
||||
local pool, used = nil, nil
|
||||
for _, run in ipairs(ADChain.runsView(ADRunsController.store.runs)) do
|
||||
if run.chain ~= nil and run.chain ~= "" and #(run.vehicleIds or {}) == 0 and (active or {})[run.chain]
|
||||
and kindOf(run) == "mixed" then
|
||||
local bulk, pallets = {}, {}
|
||||
local bulk, pallets = {}, {}
|
||||
local mixed = run.chain ~= nil and run.chain ~= "" and #(run.vehicleIds or {}) == 0 and (active or {})[run.chain]
|
||||
and kindOf(run) == "mixed"
|
||||
if mixed then
|
||||
for _, name in ipairs(run.ingredients or {}) do table.insert(isPalletName(name) and pallets or bulk, name) end
|
||||
-- først: én traktor med tipvogn + pallevogn (flowet beholder alle varer)
|
||||
pool = pool or {}
|
||||
used = used or {}
|
||||
local full = ADRuns.getRun(ADRunsController.store, run.id)
|
||||
if full ~= nil and data.fillIndex[bulk[1]] ~= nil and staffCombined(adEnv, full, run.id, data.fillIndex[bulk[1]], pool, used, "får traktor") then
|
||||
local fresh = ADRuns.getRun(ADRunsController.store, run.id)
|
||||
if fresh ~= nil then fresh.chainIdle = nil end
|
||||
mixed = false
|
||||
split = split + 1
|
||||
end
|
||||
end
|
||||
if mixed then
|
||||
ADRunsController.updateRun(run.id, {ingredients = bulk})
|
||||
local consumerName = tostring(run.name or ""):match("→%s*(.+)$") or tostring((run.targetBuildingIds or {})[1])
|
||||
local created = ADRunsController.createRun(ADChain.flowName(flowTitle(data, pallets), consumerName), "supply")
|
||||
@@ -298,7 +383,7 @@ end
|
||||
|
||||
-- Bemandingen lykkedes ikke (valideringen afviste traktor/vogn): traktoren slippes igen, flowet stoppes og venter
|
||||
-- (review: ellers holdt det traktor + vogn uden at køre og blev aldrig prøvet igen).
|
||||
local function undoStaffing(adEnv, runId, pair)
|
||||
undoStaffing = function(adEnv, runId, pair)
|
||||
pcall(ADRunsController.unassignVehicle, pair.tractor.vehicle)
|
||||
local run = ADRuns.getRun(ADRunsController.store, runId)
|
||||
if run ~= nil then
|
||||
@@ -306,6 +391,9 @@ local function undoStaffing(adEnv, runId, pair)
|
||||
local wagons = ADRuns.copyWagons(run.wagons)
|
||||
wagons[pair.tractor.id] = nil
|
||||
run.wagons = wagons
|
||||
local spares = ADRuns.copySpares(run.spareWagons)
|
||||
spares[pair.tractor.id] = nil
|
||||
run.spareWagons = spares
|
||||
end
|
||||
warn("flow '%s': '%s' + '%s' kunne ikke starte — prøver igen senere", tostring(run ~= nil and run.name or runId),
|
||||
tostring(pair.tractor.name), tostring(pair.implement.name))
|
||||
@@ -379,7 +467,14 @@ function ADChainRun.createFlows(adEnv, data, edges)
|
||||
end
|
||||
local kindOf = kindOfFor(data)
|
||||
local ok, err = pcall(function()
|
||||
-- løsvarer og paller i hvert sit flow (hver sin traktor + vogn)
|
||||
-- begge slags og intet kædeflow til bygningen endnu: helst ét flow med én traktor (tipvogn + pallevogn)
|
||||
if #bulk > 0 and #pallets > 0 and ADChainActions.chainRunFor(runs, group.consumer, "bulk", kindOf) == nil
|
||||
and ADChainActions.chainRunFor(runs, group.consumer, "pallet", kindOf) == nil
|
||||
and createCombinedFlow(adEnv, data, group, bulk, pallets, pool, used) then
|
||||
count = count + 1
|
||||
return
|
||||
end
|
||||
-- ellers løsvarer og paller i hvert sit flow (hver sin traktor + vogn)
|
||||
for _, part in ipairs({{kind = "bulk", goods = bulk}, {kind = "pallet", goods = pallets}}) do
|
||||
if #part.goods > 0 then
|
||||
local existing = ADChainActions.chainRunFor(runs, group.consumer, part.kind, kindOf)
|
||||
|
||||
@@ -69,7 +69,7 @@ end
|
||||
local RUN_FIELDS = {
|
||||
"id", "name", "kind", "sourceBuildingIds", "targetBuildingIds", "storeBuildingIds", "products",
|
||||
"ingredientMode", "ingredients", "sellAtPercent", "storeAbovePercent", "sellAbovePercent", "minSourcePercent", "collectRound", "loops",
|
||||
"returnBelowPercent", "waitPoolGroup", "vehicleIds", "wagons", "chain",
|
||||
"returnBelowPercent", "waitPoolGroup", "vehicleIds", "wagons", "chain", "spareWagons",
|
||||
}
|
||||
|
||||
local function draftFrom(run, isNew)
|
||||
@@ -88,6 +88,7 @@ local function draftFrom(run, isNew)
|
||||
draft.loops = draft.loops or 0
|
||||
draft.waitPoolGroup = draft.waitPoolGroup or ""
|
||||
draft.wagons = draft.wagons or {}
|
||||
draft.spareWagons = draft.spareWagons or {}
|
||||
draft.collectRound = draft.collectRound == true
|
||||
draft.isNew = isNew == true
|
||||
draft.showAllBuildings = false
|
||||
@@ -146,6 +147,10 @@ function ADFlowGuide.assignWagons(draft, context)
|
||||
for _, id in ipairs(draft.vehicleIds or {}) do chosen[id] = true end
|
||||
for _, wagon in ipairs((context or {}).wagons or {}) do offered[wagon.id] = true end
|
||||
local wagons, used = {}, {}
|
||||
-- ekstra vogne er optaget (én traktor, flere vogne): de gives ikke til en anden traktor
|
||||
for tractorId, list in pairs(draft.spareWagons or {}) do
|
||||
if chosen[tractorId] then for _, id in ipairs(list) do used[id] = true end end
|
||||
end
|
||||
for tractorId, wagonId in pairs(draft.wagons or {}) do
|
||||
local valid = chosen[tractorId] and (not solo[tractorId] or offered[wagonId])
|
||||
if valid and not used[wagonId] then
|
||||
@@ -204,6 +209,15 @@ function ADFlowGuide.choose(guide, id, value)
|
||||
elseif id == "wagon" then
|
||||
draft.wagons = ADGuide.deepCopy(draft.wagons or {})
|
||||
draft.wagons[value.item] = value.value
|
||||
-- valgt som aktiv: ikke længere ekstra
|
||||
draft.spareWagons = ADGuide.deepCopy(draft.spareWagons or {})
|
||||
local list = {}
|
||||
for _, spareId in ipairs(draft.spareWagons[value.item] or {}) do if spareId ~= value.value then table.insert(list, spareId) end end
|
||||
draft.spareWagons[value.item] = list
|
||||
elseif id == "spareWagon" then
|
||||
-- én ekstra vogn pr. traktor i guiden ("" = ingen); traktoren skifter mellem ture (ADWagonSwap)
|
||||
draft.spareWagons = ADGuide.deepCopy(draft.spareWagons or {})
|
||||
draft.spareWagons[value.item] = (value.value ~= nil and value.value ~= "") and {value.value} or {}
|
||||
elseif id == "buildings" then
|
||||
local key = draft.kind == "outbound" and "sourceBuildingIds" or "targetBuildingIds"
|
||||
draft[key] = ADGuide.toggleItem(draft[key], value.item, value.on)
|
||||
@@ -385,6 +399,10 @@ local function rowWagon(guide, tractorId, ownWagon)
|
||||
for otherId, wagonId in pairs(wagons) do
|
||||
if otherId ~= tractorId then usedByOthers[wagonId] = true end
|
||||
end
|
||||
-- andre traktorers ekstra vogne er også optaget
|
||||
for otherId, list in pairs(guide.draft.spareWagons or {}) do
|
||||
if otherId ~= tractorId then for _, id in ipairs(list) do usedByOthers[id] = true end end
|
||||
end
|
||||
local options = {}
|
||||
-- vognen der hænger på traktoren nu står først (vælg en anden for at bytte ved næste start)
|
||||
if ownWagon ~= nil and ownWagon.id ~= nil then table.insert(options, {label = T(tostring(ownWagon.label)), value = ownWagon.id}) end
|
||||
@@ -398,6 +416,25 @@ local function rowWagon(guide, tractorId, ownWagon)
|
||||
return choice("wagon", L("spu_guide_flow_wagon"), options, current, tractorId)
|
||||
end
|
||||
|
||||
-- Ekstra vogn under en traktor med vogn (én traktor, flere vogntyper): "ingen" + ledige vogne, der hverken er en
|
||||
-- traktors aktive vogn eller en anden traktors ekstra vogn. nil = ingen ledige at vælge imellem.
|
||||
local function rowSpare(guide, tractorId, ownWagon)
|
||||
local draft = guide.draft
|
||||
local taken = {}
|
||||
for _, wagonId in pairs(draft.wagons or {}) do taken[wagonId] = true end
|
||||
if ownWagon ~= nil and ownWagon.id ~= nil then taken[ownWagon.id] = true end
|
||||
for otherId, list in pairs(draft.spareWagons or {}) do
|
||||
if otherId ~= tractorId then for _, id in ipairs(list) do taken[id] = true end end
|
||||
end
|
||||
local options = {{label = L("spu_guide_flow_noSpare"), value = ""}}
|
||||
for _, wagon in ipairs(guide.context.wagons or {}) do
|
||||
if not taken[wagon.id] then table.insert(options, {label = T(tostring(wagon.label)), value = wagon.id}) end
|
||||
end
|
||||
if #options == 1 then return nil end
|
||||
local current = ((draft.spareWagons or {})[tractorId] or {})[1] or ""
|
||||
return choice("spareWagon", L("spu_guide_flow_spareWagon"), options, current, tractorId)
|
||||
end
|
||||
|
||||
-- Traktorer: flowets egne først, så de ledige. Traktorer i andre flows og blokerede (vognen passer ikke)
|
||||
-- skjules med en linje hver.
|
||||
local function rowsTractors(guide)
|
||||
@@ -428,6 +465,11 @@ local function rowsTractors(guide)
|
||||
if entry.state == "in" and (solo[entry.id] or own ~= nil) then
|
||||
local wagonRow = rowWagon(guide, entry.id, own)
|
||||
if wagonRow ~= nil then table.insert(rows, wagonRow) end
|
||||
-- kun forsyningsflows skifter vogn mellem ture
|
||||
if not isOut(guide) and wagonRow ~= nil and wagonRow.type == "choice" then
|
||||
local spareRow = rowSpare(guide, entry.id, own)
|
||||
if spareRow ~= nil then table.insert(rows, spareRow) end
|
||||
end
|
||||
end
|
||||
end
|
||||
if #rows == 0 then table.insert(rows, text("spu_guide_flow_noTractors")) end
|
||||
@@ -571,7 +613,8 @@ function ADFlowGuide.result(guide)
|
||||
}
|
||||
if draft.name ~= nil and draft.name:match("%S") then changes.name = draft.name end
|
||||
return {isNew = draft.isNew == true, runId = draft.id, name = draft.name, kind = draft.kind, changes = changes,
|
||||
vehicleIds = ADGuide.deepCopy(draft.vehicleIds), wagons = ADFlowGuide.resultWagons(draft)}
|
||||
vehicleIds = ADGuide.deepCopy(draft.vehicleIds), wagons = ADFlowGuide.resultWagons(draft),
|
||||
spareWagons = ADFlowGuide.resultSpares(draft)}
|
||||
end
|
||||
|
||||
-- Vogne for de valgte traktorer (til run.wagons ved gem).
|
||||
@@ -583,6 +626,15 @@ function ADFlowGuide.resultWagons(draft)
|
||||
return wagons
|
||||
end
|
||||
|
||||
-- Ekstra vogne for de valgte traktorer (til run.spareWagons ved gem); tomme lister udelades.
|
||||
function ADFlowGuide.resultSpares(draft)
|
||||
local chosen, spares = chosenSet(draft.vehicleIds), {}
|
||||
for tractorId, list in pairs(draft.spareWagons or {}) do
|
||||
if chosen[tractorId] and #list > 0 then spares[tractorId] = ADGuide.deepCopy(list) end
|
||||
end
|
||||
return spares
|
||||
end
|
||||
|
||||
-- Traktorer der skal tildeles/fjernes efter gem.
|
||||
function ADFlowGuide.vehicleChanges(oldIds, newIds)
|
||||
local old, new = chosenSet(oldIds), chosenSet(newIds)
|
||||
|
||||
@@ -134,6 +134,16 @@ function ADFlowSleep.swapTractor(run, oldId, newId)
|
||||
return ids, wagons
|
||||
end
|
||||
|
||||
-- Ekstra vogne flyttes fra den gamle traktor til den nye. -> ny tabel
|
||||
function ADFlowSleep.swapSpares(spares, oldId, newId)
|
||||
local copy = ADRuns.copySpares(spares)
|
||||
if oldId ~= newId and copy[oldId] ~= nil then
|
||||
copy[newId] = copy[oldId]
|
||||
copy[oldId] = nil
|
||||
end
|
||||
return copy
|
||||
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)
|
||||
@@ -270,14 +280,32 @@ function ADFlowSleep.hasWork(adEnv, run, byId, onlyTractorId)
|
||||
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
|
||||
-- den aktive vogn først, så traktorernes ekstra vogne (ADWagonSwap: én traktor, flere vogne) — har en af dem en
|
||||
-- tur, har flowet arbejde (traktoren skifter vogn ved start)
|
||||
local cargos = {cargo}
|
||||
for tractorId, list in pairs(run.spareWagons or {}) do
|
||||
if onlyTractorId == nil or tractorId == onlyTractorId then
|
||||
for _, wagonId in ipairs(list) do
|
||||
local spare = findVehicle(wagonId)
|
||||
-- kun en vogn traktoren faktisk kan hente (ikke udlånt, reserveret eller uden Connect — review)
|
||||
if spare ~= nil and spare ~= cargo and (ADWagonSwap == nil or ADWagonSwap.isFetchable(adEnv, spare, wagonId)) then
|
||||
table.insert(cargos, spare)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
for index, candidate in ipairs(cargos) do
|
||||
local ingredients = ADRunsController.getRunIngredients(adEnv, run, candidate)
|
||||
if index > 1 and ADWagonSwap ~= nil then ingredients = ADWagonSwap.goodsFor(candidate, ingredients) end
|
||||
for _, targetId in ipairs(ADRunsController.getRunTargets(run)) do
|
||||
local choice = index == 1 and ADSmartPickup.findSupplyPickup(adEnv, candidate, ingredients, targetId)
|
||||
or ADSmartPickup.probeSupplyPickup(adEnv, candidate, 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(candidate))), choice, targetId
|
||||
end
|
||||
end
|
||||
end
|
||||
return false, nil
|
||||
@@ -382,6 +410,8 @@ local function wake(adEnv, run, byId, why)
|
||||
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)
|
||||
-- ekstra vogne følger med til den nye traktor (ADWagonSwap)
|
||||
run.spareWagons = ADFlowSleep.swapSpares(run.spareWagons, 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))
|
||||
|
||||
@@ -149,9 +149,10 @@ function ADFlowWagons.rankWagons(runName, candidates)
|
||||
return ranked
|
||||
end
|
||||
|
||||
-- Flowet der ejer vognen — som aktiv vogn eller som ekstra vogn (ADWagonSwap: én traktor, flere vogne).
|
||||
function ADFlowWagons.ownerOf(runs, wagonId)
|
||||
for _, run in ipairs(runs or {}) do
|
||||
for _, id in pairs(run.wagons or {}) do
|
||||
for _, id in ipairs(ADRuns.wagonIdsOf(run)) do
|
||||
if id == wagonId then return run end
|
||||
end
|
||||
end
|
||||
@@ -257,6 +258,11 @@ local function connectOf(adEnv, wagon)
|
||||
return marker ~= nil and marker.id or nil
|
||||
end
|
||||
|
||||
-- Vognens Connect-markør (hentepunkt) eller nil — til ADWagonSwap.
|
||||
function ADFlowWagons.connectFor(adEnv, wagon)
|
||||
return wagon ~= nil and connectOf(adEnv, wagon) or nil
|
||||
end
|
||||
|
||||
-- Traktorer i stoppede flows er ledige i puljen; traktorer i kørende flows aldrig.
|
||||
-- s = {hasRun, stopped, carriesFlowWagon, homeTrip} -> må puljen/markarbejde/marksilo låne traktoren?
|
||||
function ADFlowWagons.tractorFree(s)
|
||||
@@ -354,7 +360,7 @@ end
|
||||
-- Frakoblede vogne med parkering, som intet kørende flow holder, og som flowet ikke allerede har givet en traktor.
|
||||
local function guessFor(adEnv, run, vehicle, tractorId)
|
||||
local taken = {}
|
||||
for _, id in pairs(run.wagons or {}) do taken[id] = true end
|
||||
for _, id in ipairs(ADRuns.wagonIdsOf(run)) do taken[id] = true end
|
||||
local candidates = {}
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
for _, any in pairs(g_currentMission.vehicleSystem.vehicles) do
|
||||
@@ -479,11 +485,20 @@ function ADFlowWagons.beforeStart(adEnv, run, vehicle)
|
||||
local current = ADRuns.getRun(ADRunsController.store, runId)
|
||||
if current == nil or current.stopped then ADHitch.returnHome(adEnv, tractor) return end
|
||||
if ok then
|
||||
fetchRetries[tractor] = nil
|
||||
local result = ADRunsController.startVehicle(adEnv, current, tractor)
|
||||
if result ~= nil and not result.ok then ADFlowWagons.dropHereAndHome(adEnv, tractor) end
|
||||
else
|
||||
Logging.warning(ADFlowWagons.LOG_PREFIX .. "flow '%s': '%s' kunne ikke bytte vogn (%s)", tostring(current.name),
|
||||
elseif ADFlowWagons.retryFetch(detail, fetchRetries[tractor]) then
|
||||
-- byttet er nu automatisk (ADWagonSwap): ét nyt forsøg som ved hentning, så traktoren ikke bliver stående
|
||||
fetchRetries[tractor] = (fetchRetries[tractor] or 0) + 1
|
||||
waiting[tractor] = runId
|
||||
Logging.warning(ADFlowWagons.LOG_PREFIX .. "flow '%s': '%s' kunne ikke bytte vogn (%s) — prøver igen", tostring(current.name),
|
||||
tostring(ADRuns.vehicleLabel(tractor)), tostring(detail))
|
||||
else
|
||||
fetchRetries[tractor] = nil
|
||||
Logging.warning(ADFlowWagons.LOG_PREFIX .. "flow '%s': '%s' kunne ikke bytte vogn (%s) — sætter af og kører hjem", tostring(current.name),
|
||||
tostring(ADRuns.vehicleLabel(tractor)), tostring(detail))
|
||||
ADFlowWagons.dropHereAndHome(adEnv, tractor)
|
||||
end
|
||||
end) end)
|
||||
if not okSwap then fetching[vehicle] = nil return true, {vehicle = vehicle, ok = false, reason = "error"} end
|
||||
@@ -619,15 +634,28 @@ local function isCargoWagon(object)
|
||||
return ADFlowWagons.isCargoObject(object)
|
||||
end
|
||||
|
||||
-- Gør vognen til traktorens aktive vogn i flowet. Er den en af traktorens ekstra vogne (ADWagonSwap), byttes de, så
|
||||
-- samme vogn aldrig står både som aktiv og ekstra. -> true når noget ændrede sig.
|
||||
local function setActiveWagon(run, tractorId, wagonId)
|
||||
for _, spareId in ipairs((run.spareWagons or {})[tractorId] or {}) do
|
||||
if spareId == wagonId then
|
||||
run.wagons, run.spareWagons = ADRuns.swapActive(run.wagons, run.spareWagons, tractorId, wagonId)
|
||||
return true
|
||||
end
|
||||
end
|
||||
local updated = ADFlowWagons.remember(run.wagons, tractorId, wagonId)
|
||||
if updated == run.wagons then return false end
|
||||
run.wagons = updated
|
||||
return true
|
||||
end
|
||||
|
||||
local function rememberWagonOf(vehicle)
|
||||
local run = ADRunsController.getRunForVehicle(vehicle)
|
||||
local rear = run ~= nil and ADHitch.rearImplementsOf(vehicle) or {}
|
||||
local tractorId = ADRunsController.getVehicleId(vehicle)
|
||||
local wagonId = rear[1] ~= nil and isCargoWagon(rear[1].object) and ADRunsController.getVehicleId(rear[1].object) or nil
|
||||
if wagonId == nil or tractorId == nil then return end
|
||||
local updated = ADFlowWagons.remember(run.wagons, tractorId, wagonId)
|
||||
if updated ~= run.wagons then
|
||||
run.wagons = updated
|
||||
if setActiveWagon(run, tractorId, wagonId) then
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "flow '%s': '%s' har vognen '%s'", tostring(run.name),
|
||||
tostring(ADRuns.vehicleLabel(vehicle)), tostring(ADRuns.vehicleLabel(rear[1].object)))
|
||||
end
|
||||
@@ -835,9 +863,7 @@ local function rememberAll(adEnv)
|
||||
local chosenVehicle = chosen ~= nil and findAnyVehicle(chosen) or nil
|
||||
local keepChoice = chosen ~= wagonId and chosenVehicle ~= nil and not ADFlowWagons.isWorkTool(chosenVehicle)
|
||||
if wagonId ~= nil and not keepChoice and fetching[vehicle] == nil and emptying[vehicle] == nil then
|
||||
local updated = ADFlowWagons.remember(run.wagons, vehicleId, wagonId)
|
||||
if updated ~= run.wagons then
|
||||
run.wagons = updated
|
||||
if setActiveWagon(run, vehicleId, wagonId) then
|
||||
Logging.info(ADFlowWagons.LOG_PREFIX .. "flow '%s': '%s' har vognen '%s'", tostring(run.name),
|
||||
tostring(ADRuns.vehicleLabel(vehicle)), tostring(ADRuns.vehicleLabel(rear[1].object)))
|
||||
end
|
||||
|
||||
@@ -89,6 +89,62 @@ function ADRuns.parseWagons(text)
|
||||
return wagons
|
||||
end
|
||||
|
||||
-- Ekstra vogne pr. traktor (én traktor, flere vogntyper i samme flow — brugerønske 18/10 18:36): run.wagons er den
|
||||
-- AKTIVE vogn, run.spareWagons = {[traktorId] = {vognId, ...}} de andre, traktoren kan skifte til mellem ture.
|
||||
function ADRuns.copySpares(spares)
|
||||
local copy = {}
|
||||
for tractorId, list in pairs(spares or {}) do
|
||||
local ids = {}
|
||||
for _, id in ipairs(list) do table.insert(ids, id) end
|
||||
copy[tractorId] = ids
|
||||
end
|
||||
return copy
|
||||
end
|
||||
|
||||
-- "t1=w2,w3;t2=w4" (traktorer sorteret; tomme lister udelades)
|
||||
function ADRuns.serializeSpares(spares)
|
||||
local keys = {}
|
||||
for tractorId, list in pairs(spares or {}) do if #list > 0 then table.insert(keys, tractorId) end end
|
||||
table.sort(keys)
|
||||
local parts = {}
|
||||
for _, tractorId in ipairs(keys) do table.insert(parts, tractorId .. "=" .. table.concat(spares[tractorId], ",")) end
|
||||
return table.concat(parts, ";")
|
||||
end
|
||||
|
||||
function ADRuns.parseSpares(text)
|
||||
local spares = {}
|
||||
for tractorId, list in string.gmatch(tostring(text or ""), "([^=;]+)=([^;]+)") do
|
||||
local ids = {}
|
||||
for id in string.gmatch(list, "[^,]+") do table.insert(ids, id) end
|
||||
if #ids > 0 then spares[tractorId] = ids end
|
||||
end
|
||||
return spares
|
||||
end
|
||||
|
||||
-- Gør newId til traktorens aktive vogn: den hidtidige aktive bliver ekstra, newId fjernes fra de ekstra.
|
||||
-- -> nye tabeller (wagons, spares)
|
||||
function ADRuns.swapActive(wagons, spares, tractorId, newId)
|
||||
local newWagons = ADRuns.copyWagons(wagons)
|
||||
local newSpares = ADRuns.copySpares(spares)
|
||||
local old = newWagons[tractorId]
|
||||
local list = {}
|
||||
for _, id in ipairs(newSpares[tractorId] or {}) do if id ~= newId then table.insert(list, id) end end
|
||||
if old ~= nil and old ~= newId then table.insert(list, old) end
|
||||
newWagons[tractorId] = newId
|
||||
newSpares[tractorId] = list
|
||||
return newWagons, newSpares
|
||||
end
|
||||
|
||||
-- Alle flowets vogne (aktive og ekstra) som liste.
|
||||
function ADRuns.wagonIdsOf(run)
|
||||
local ids = {}
|
||||
for _, id in pairs((run or {}).wagons or {}) do table.insert(ids, id) end
|
||||
for _, list in pairs((run or {}).spareWagons or {}) do
|
||||
for _, id in ipairs(list) do table.insert(ids, id) end
|
||||
end
|
||||
return ids
|
||||
end
|
||||
|
||||
local function copyRun(run)
|
||||
return {
|
||||
id = run.id,
|
||||
@@ -119,6 +175,7 @@ local function copyRun(run)
|
||||
wagons = ADRuns.copyWagons(run.wagons),
|
||||
chain = run.chain or "",
|
||||
chainIdle = run.chainIdle == true or nil, -- kæden oprettede flowet uden traktor (bemandes senere)
|
||||
spareWagons = ADRuns.copySpares(run.spareWagons),
|
||||
}
|
||||
end
|
||||
|
||||
@@ -382,6 +439,7 @@ function ADRuns.unassignVehicle(store, vehicleId)
|
||||
end
|
||||
-- traktoren forlader flowet: dens huskede vogn hører ikke længere til flowet
|
||||
if run.wagons ~= nil then run.wagons[vehicleId] = nil end
|
||||
if run.spareWagons ~= nil then run.spareWagons[vehicleId] = nil end
|
||||
end
|
||||
return new
|
||||
end
|
||||
@@ -507,6 +565,7 @@ function ADRuns.toRecords(store)
|
||||
wagons = ADRuns.serializeWagons(run.wagons),
|
||||
chain = run.chain or "",
|
||||
chainIdle = run.chainIdle and 1 or 0,
|
||||
spareWagons = ADRuns.serializeSpares(run.spareWagons),
|
||||
}
|
||||
end
|
||||
return records
|
||||
@@ -567,6 +626,7 @@ function ADRuns.fromRecords(records)
|
||||
wagons = ADRuns.parseWagons(record.wagons),
|
||||
chain = record.chain or "",
|
||||
chainIdle = ADRuns.parseChainIdle(record),
|
||||
spareWagons = ADRuns.parseSpares(record.spareWagons),
|
||||
})
|
||||
store.nextId = math.max(store.nextId, id + 1)
|
||||
end
|
||||
|
||||
@@ -284,8 +284,18 @@ end
|
||||
-- Varer køretøjet kan bære. En frakoblet vogn (dvale-tjekket regner med flowets parkerede vogn) har ingen AutoDrive-
|
||||
-- tilstand (.ad), og så giver AD's opslag en tom liste for alt andet end autoload-vogne — læs vognens egne fyldenheder.
|
||||
function ADRunsController.getCarriableFillTypes(adEnv, vehicle)
|
||||
if vehicle ~= nil and vehicle.ad == nil and vehicle.getFillUnits ~= nil then
|
||||
return ADRunsController.fillTypesOfUnits(vehicle)
|
||||
if vehicle ~= nil and vehicle.ad == nil then
|
||||
-- parkeret vogn med Universal Autoload: som AutoDrive ser den påkoblet (paller/baller, ikke tanken) —
|
||||
-- ADWagonSwap og dvalen spørger den parkerede pallevogn, hvad den kunne hente
|
||||
local AD = adEnv ~= nil and adEnv.AutoDrive or nil
|
||||
if AD ~= nil and AD.hasAL ~= nil and AD.getALFillTypes ~= nil and AD:hasAL(vehicle) then
|
||||
local result = {}
|
||||
for _, fillType in ipairs(AD:getALFillTypes(vehicle) or {}) do
|
||||
if type(fillType) == "table" and fillType.fillTypeID ~= nil then table.insert(result, fillType.fillTypeID) end
|
||||
end
|
||||
if #result > 0 then return result end
|
||||
end
|
||||
if vehicle.getFillUnits ~= nil then return ADRunsController.fillTypesOfUnits(vehicle) end
|
||||
end
|
||||
return adEnv.AutoDrive.getSupportedFillTypesOfAllUnitsAlphabetically(vehicle) or {}
|
||||
end
|
||||
|
||||
@@ -58,6 +58,7 @@ function ADRunsStorage.writeRecords(xmlFile, records)
|
||||
xmlFile:setString(key .. "#wagons", record.wagons or "")
|
||||
xmlFile:setString(key .. "#chain", record.chain or "")
|
||||
xmlFile:setInt(key .. "#chainIdle", record.chainIdle or 0)
|
||||
xmlFile:setString(key .. "#spareWagons", record.spareWagons or "")
|
||||
for vehicleIndex, vehicleId in ipairs(record.vehicleIds) do
|
||||
xmlFile:setString(string.format("%s.vehicle(%d)#id", key, vehicleIndex - 1), vehicleId)
|
||||
end
|
||||
@@ -95,6 +96,7 @@ function ADRunsStorage.readRecords(xmlFile)
|
||||
wagons = xmlFile:getString(key .. "#wagons"),
|
||||
chain = xmlFile:getString(key .. "#chain"),
|
||||
chainIdle = xmlFile:getInt(key .. "#chainIdle"), -- nil i gemme fra før feltet
|
||||
spareWagons = xmlFile:getString(key .. "#spareWagons"),
|
||||
vehicleIds = {},
|
||||
}
|
||||
xmlFile:iterate(key .. ".vehicle", function(_, vehicleKey)
|
||||
|
||||
@@ -501,6 +501,7 @@ end
|
||||
-- Behov pr. vare lige nu (til retfærdig fordeling): køretøj -> {free, at}
|
||||
local demandRegistry = {}
|
||||
ADSmartPickup.DEMAND_FRESH_MS = 10 * 60 * 1000
|
||||
local probing = false -- ADSmartPickup.probeSupplyPickup: kun spørge, intet registreres
|
||||
local function registerDemand(fillType, driver, freeSpace)
|
||||
local now = g_currentMission ~= nil and g_currentMission.time or 0
|
||||
demandRegistry[fillType] = demandRegistry[fillType] or {}
|
||||
@@ -1215,6 +1216,16 @@ function ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint,
|
||||
return nil
|
||||
end
|
||||
|
||||
-- Hvad kunne vognen hente? Som findSupplyPickup, men uden at registrere et behov (til parkerede vogne:
|
||||
-- ADWagonSwap og dvale-tjekket). -> valg eller nil
|
||||
function ADSmartPickup.probeSupplyPickup(adEnv, cargo, ingredients, targetWayPointId)
|
||||
probing = true
|
||||
local ok, choice = pcall(ADSmartPickup.findSupplyPickup, adEnv, cargo, ingredients, targetWayPointId)
|
||||
probing = false
|
||||
if not ok then error(choice, 0) end
|
||||
return choice
|
||||
end
|
||||
|
||||
function ADSmartPickup.findSupplyPickup(adEnv, driver, ingredients, targetWayPointId)
|
||||
-- med eksplicit mål bruges AD's tilstand ikke (dvale-tjekket kalder med flowets parkerede vogn, der ingen .ad har)
|
||||
local wayPointId = targetWayPointId
|
||||
@@ -1298,7 +1309,10 @@ function ADSmartPickup.findSupplyPickup(adEnv, driver, ingredients, targetWayPoi
|
||||
-- 20 mio. l-silo som ét kæmpe behov, og alle andre får smuler (in-game 10/10: 3.110 l af 334.730 l)
|
||||
local tripNeed = math.min(need.freeSpace or math.huge, loadCapacity or math.huge)
|
||||
if tripNeed == math.huge then tripNeed = need.freeSpace or 0 end
|
||||
local totalFree, others = registerDemand(need.fillType, driver, tripNeed)
|
||||
-- en prøve (parkeret vogn: ADWagonSwap/dvalen) registrerer intet behov — ellers deler de andre traktorer
|
||||
-- lageret med en vogn, der ikke kører (review 18/10)
|
||||
local totalFree, others = tripNeed, 0
|
||||
if not probing then totalFree, others = registerDemand(need.fillType, driver, tripNeed) end
|
||||
if choice.isOwn and others > 0 then
|
||||
local share = ADSupplyPlanner.fairShare(choice.level or 0, tripNeed, totalFree)
|
||||
if share < pending then
|
||||
@@ -1447,6 +1461,16 @@ function ADSmartPickup.choosePickup(adEnv, driver)
|
||||
if choice == nil then
|
||||
choice = tryOtherRunTargets(adEnv, driver, ingredients)
|
||||
end
|
||||
-- én traktor, flere vogne: skal en anden af traktorens vogne køre turen? Skiftet udføres i ADWagonSwap.tick
|
||||
if ADWagonSwap ~= nil and ADWagonSwap.consider ~= nil then
|
||||
local okSwap, swapped = pcall(ADWagonSwap.consider, adEnv, driver, activeRunOf(driver), choice)
|
||||
if not okSwap then
|
||||
Logging.warning(ADSmartPickup.LOG_PREFIX .. "vogneskift-tjek fejlede: %s", tostring(swapped))
|
||||
elseif swapped then
|
||||
supplyState[driver] = nil
|
||||
return nil
|
||||
end
|
||||
end
|
||||
if choice == nil then
|
||||
-- Traktor i et forsynings-run uden noget (tilladt) at hente: hold ved Wait og prøv igen, i stedet
|
||||
-- for at falde tilbage til mappe-logikken (den henter hvad som helst, fx ensilage i et halvfuldt trug).
|
||||
@@ -1891,6 +1915,10 @@ function ADSmartPickup:update(dt)
|
||||
local okFlow, errFlow = pcall(ADFlowWagons.tick, getAutoDriveEnv(), gameDt)
|
||||
if not okFlow then Logging.warning(ADSmartPickup.LOG_PREFIX .. "flow-vogne fejlede: %s", tostring(errFlow)) end
|
||||
end
|
||||
if ADWagonSwap ~= nil and getAutoDriveEnv() ~= nil then
|
||||
local okSwap, errSwap = pcall(ADWagonSwap.tick, getAutoDriveEnv(), gameDt)
|
||||
if not okSwap then Logging.warning(ADSmartPickup.LOG_PREFIX .. "vogneskift fejlede: %s", tostring(errSwap)) end
|
||||
end
|
||||
if ADBuildings ~= nil and ADBuildings.tickDump ~= nil then pcall(ADBuildings.tickDump, getAutoDriveEnv(), dt) end
|
||||
if ADMarkerGuard ~= nil and getAutoDriveEnv() ~= nil then
|
||||
local okGuard, errGuard = pcall(ADMarkerGuard.tick, ADMarkerGuard.gameEnv(getAutoDriveEnv()))
|
||||
|
||||
@@ -0,0 +1,171 @@
|
||||
-- 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
|
||||
@@ -471,6 +471,8 @@ function SmartPickupFrame:saveFlowGuide(guide, start)
|
||||
local wagons = ADRuns.copyWagons(savedRun.wagons)
|
||||
for tractorId, wagonId in pairs(result.wagons or {}) do wagons[tractorId] = wagonId end
|
||||
savedRun.wagons = wagons
|
||||
-- ekstra vogne (én traktor, flere vogntyper): guidens valg erstatter de valgte traktorers
|
||||
savedRun.spareWagons = ADRuns.copySpares(result.spareWagons)
|
||||
end
|
||||
ADRunsController.resolveMarkers(adEnv, ADRuns.getRun(ADRunsController.store, runId))
|
||||
self.selectedRunId = runId
|
||||
|
||||
@@ -29,6 +29,8 @@
|
||||
<text name="spu_status_error" text="Fejl: %s"/>
|
||||
<text name="spu_guide_flow_wagon" text=" ↳ Vogn"/>
|
||||
<text name="spu_guide_flow_noFreeWagon" text=" ↳ ingen ledig vogn (frakoblet, med Connect-markør, kan bære varen)"/>
|
||||
<text name="spu_guide_flow_spareWagon" text=" ↳ Ekstra vogn (skifter mellem ture)"/>
|
||||
<text name="spu_guide_flow_noSpare" text="ingen"/>
|
||||
<text name="spu_guide_flow_soloText" text="%s — ingen vogn bagpå: henter en ledig vogn"/>
|
||||
<text name="spu_reason_noTrailer" text="ingen vogn (kobl en på, eller giv vognens parkering flowets navn)"/>
|
||||
<text name="spu_reason_cannotCarry" text="vognen kan ikke bære run'ets varer"/>
|
||||
|
||||
@@ -29,6 +29,8 @@
|
||||
<text name="spu_status_error" text="Error: %s"/>
|
||||
<text name="spu_guide_flow_wagon" text=" ↳ Trailer"/>
|
||||
<text name="spu_guide_flow_noFreeWagon" text=" ↳ no free trailer (detached, with a Connect marker, able to carry the goods)"/>
|
||||
<text name="spu_guide_flow_spareWagon" text=" ↳ Extra trailer (swaps between trips)"/>
|
||||
<text name="spu_guide_flow_noSpare" text="none"/>
|
||||
<text name="spu_guide_flow_soloText" text="%s — no trailer attached: fetches a free trailer"/>
|
||||
<text name="spu_reason_noTrailer" text="no trailer (attach one, or name the trailer's parking after the flow)"/>
|
||||
<text name="spu_reason_cannotCarry" text="trailer cannot carry the run's goods"/>
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
<?xml version="1.0" encoding="utf-8" standalone="no"?>
|
||||
<modDesc descVersion="107">
|
||||
<author>masterdraco</author>
|
||||
<version>1.62.336.0</version>
|
||||
<version>1.62.337.0</version>
|
||||
<title>
|
||||
<en>AD Smart Pickup</en>
|
||||
</title>
|
||||
@@ -68,6 +68,7 @@
|
||||
<sourceFile filename="adHitchApproach.lua"/>
|
||||
<sourceFile filename="adPool.lua"/>
|
||||
<sourceFile filename="adFlowWagons.lua"/>
|
||||
<sourceFile filename="adWagonSwap.lua"/>
|
||||
<sourceFile filename="adFlowSleep.lua"/>
|
||||
<sourceFile filename="adMarkerGuard.lua"/>
|
||||
<sourceFile filename="adParkGuard.lua"/>
|
||||
|
||||
Reference in New Issue
Block a user