Files

773 lines
43 KiB
Lua

-- AD Chain Run (kædens handlinger i spillet)
-- Udfører ADChain's plan: skifter frie marker (kun "auto", højst MAX_FIELD_SWITCHES pr. tick), tænder/slukker
-- mellemled, opretter manglende forsyningsflows (højst MAX_NEW_FLOWS pr. tick) og stopper flows for rødder der
-- er slået fra. Hver del kører i pcall, så en fejl ikke stopper resten. Spilkald kun inde i funktioner.
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
local function logInfo(...) return (ADLog or Logging).info(...) end
ADChainRun = {}
local function log(fmt, ...) logInfo(ADChain.LOG_PREFIX .. fmt, ...) end
local function warn(fmt, ...) Logging.warning(ADChain.LOG_PREFIX .. fmt, ...) end
local UNLOADER = "unloader"
-- Samme rolletjek som ADPool.pairAll("unloader", …) (hasRole er lokal i adPool).
local function isUnloader(implement)
return implement.role == UNLOADER or (implement.roles ~= nil and implement.roles[UNLOADER] == true)
end
-- Traktor i et flow (også et STOPPET): ADPool.collect regner den ledig til korte lån, men ADRuns.assignVehicle
-- ville flytte den permanent ud af spillerens flow — kæden tager den aldrig.
local function belongsToFlow(tractor)
return tractor.vehicle ~= nil and ADRunsController.getRunForVehicle(tractor.vehicle) ~= nil
end
-- Første puljetømmevogn der kan bære varen + den bedst egnede ledige traktor (maskinpuljens regler: hk og
-- kategori via ADPool.bestFit). used = {[id] = true}: brugt i dette tick; blocked = ADPool.blocked(nu).
-- pallet = true: palle-vare -> en vogn med Universal Autoload (in-game 18/10 18:30: "vi har dem jo" — tre EDK 650
-- Autoload i puljen, men kæden krævede, at vognens fyldenhed bar varen, og paller ligger ikke i en fyldenhed).
function ADChainRun.choosePair(implements, tractors, fillTypeIndex, used, blocked, pallet)
if fillTypeIndex == nil then return nil end
used, blocked = used or {}, blocked or {}
local free = {}
for _, tractor in ipairs(tractors or {}) do
if not used[tractor.id] and not blocked[tractor.id] and not tractor.offNetwork and not belongsToFlow(tractor) then
table.insert(free, tractor)
end
end
-- palle-vare: rene pallevogne først; en Autoload-tipvogn (tømmevogn i markarbejdet) kun hvis ingen anden er ledig
-- (review: en parkeret tipvogn er måske høstens eneste tømmevogn)
local passes = pallet and {function(i) return i.autoload == true and not isUnloader(i) end, function(i) return i.autoload == true end}
or {function(i) return isUnloader(i) and ADPool.canCarry(i, fillTypeIndex) end}
for _, fits in ipairs(passes) do
for _, implement in ipairs(implements or {}) do
if not used[implement.id] and not blocked[implement.id] and fits(implement) then
local tractor = ADPool.bestFit(free, implement, "unloader")
if tractor ~= nil then return {implement = implement, tractor = tractor} end
end
end
end
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)
for _, field in ipairs(fields or {}) do
if field.id == id then return field end
end
return nil
end
function ADChainRun.switchFields(data, actions)
local switched = 0
for _, action in ipairs(actions or {}) do
if switched >= ADChain.MAX_FIELD_SWITCHES then break end
local field = fieldById(data.fields, action.fieldId)
-- brugerens egen målafgrøde røres aldrig (dobbelttjek oven i ADCropPlan); en mark slået fra heller ikke
if action.mode == "auto" and field ~= nil and field.targetSource ~= "user" and field.enabled ~= false then
local ok, err = pcall(ADFieldJobs.setTarget, action.fieldId, action.to, "chain", action.product)
if ok then
switched = switched + 1
ADChain.switchCount = ADChain.switchCount + 1
local text = string.format("F%s: %s -> %s%s (%.1f ha) til %s", tostring(action.fieldId), tostring(action.from),
tostring(action.to), action.product ~= nil and (" (" .. tostring(action.product) .. ")") or "", action.hectares or 0,
tostring(action.reason))
log("%s", text)
pcall(ADFieldJobs.notify, text, false)
else
warn("F%s kunne ikke skiftes: %s", tostring(action.fieldId), tostring(err))
end
end
end
end
-- ---- mellemled ----
local function setProduction(data, key, isOn)
local entry = data.points[key]
if entry == nil or entry.point == nil or entry.point.setProductionState == nil then
warn("produktion %s findes ikke (længere)", tostring(key))
return false
end
local ok, err = pcall(entry.point.setProductionState, entry.point, entry.productionId, isOn)
if not ok then warn("produktion %s kunne ikke %s: %s", tostring(key), isOn and "tændes" or "slukkes", tostring(err)) end
return ok
end
-- Spillerens slukninger er allerede lagt i state.userOff (ADChain.reconcile før planen): de tændes ikke igen.
-- Delvise data: intet slukkes (en rod der ikke kunne læses, ligner en rod der er slået fra).
function ADChainRun.toggleProductions(data, prod)
local state = ADChain.state
local byChain = state.byChain
for _, key in ipairs(prod.enable or {}) do
if not state.userOff[key] and setProduction(data, key, true) then
byChain[key] = true
log("tænder %s (mellemled i kæden)", key)
end
end
if data.partial then return end
for _, key in ipairs(prod.disable or {}) do
if setProduction(data, key, false) then
byChain[key] = nil
log("slukker %s (kæden bruger den ikke længere)", key)
end
end
end
-- ---- flows ----
local function collectPool(adEnv)
local ok, implements, tractors = pcall(ADPool.collect, adEnv, function(v)
return ADFieldWork.isBusyVehicle(v, ADRunsController.getVehicleId(v))
end)
if not ok then
warn("maskinpuljen kunne ikke læses: %s", tostring(implements))
return {}, {}
end
return implements or {}, tractors or {}
end
-- kind = "noVehicle"|"pallet": vises som status på kanten i fanen Kæder
local function createStopped(run, kind, reason, ...)
run.stopped = true
run.chainIdle = true -- gemmes: kæden bemander flowet senere (ADChainRun.staffIdleFlows)
ADChain.noVehicle[run.id] = kind
log("flow '%s' oprettet stoppet: " .. reason, tostring(run.name), ...)
end
-- Ét flow pr. modtagerbygning med alle dens manglende bulkvarer (manuelle varer); palle-varer får hver sit
-- stoppede flow. group = {consumer, consumerName, rootKey, fillTypes}.
local function flowTitle(data, fillTypes)
local first = data.fillTitles[fillTypes[1]] or fillTypes[1]
if #fillTypes == 1 then return first end
return string.format("%s +%d", tostring(first), #fillTypes - 1)
end
local function startWithPair(adEnv, run, runId, pair, used, verb)
used[pair.tractor.id], used[pair.implement.id] = true, true
ADRunsController.assignVehicle(runId, pair.tractor.vehicle)
run = ADRuns.getRun(ADRunsController.store, runId)
local wagons = ADRuns.copyWagons(run.wagons)
wagons[pair.tractor.id] = pair.implement.id
run.wagons = wagons
ADRunsController.resolveMarkers(adEnv, run)
local results = ADRunsController.startRun(adEnv, runId)
local started = 0
for _, result in ipairs(results or {}) do if result.ok then started = started + 1 end end
log("flow '%s' %s '%s' + vogn '%s' (%d startet)", tostring(run.name), verb or "oprettet med", tostring(pair.tractor.name),
tostring(pair.implement.name), started)
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 fillIndex = data.fillIndex[fillTypes[1]]
local pallet = fillIndex ~= nil and ADSources.isPalletOnlyFillType(fillIndex)
local waitPool = ADChain.waitPoolFor(ADRunsController.store.runs, group.consumer)
-- palle-varer med kendte producenter: udkørselsflow (forsyningen kan ikke hente paller — 20/10 Canola Oil)
local sources = pallet and ADChainActions.sourcesFor(group.producers, fillTypes) or {}
local created = ADRunsController.createRun(ADChain.flowName(title, group.consumerName or group.consumer), #sources > 0 and "outbound" or "supply")
local runId = created.id
if #sources > 0 then
ADRunsController.updateRun(runId, ADChainActions.palletFlowChanges(group.consumer, fillTypes, sources, group.rootKey, waitPool))
else
ADRunsController.updateRun(runId, {targetBuildingIds = {group.consumer}, ingredientMode = "manual", ingredients = fillTypes,
waitPoolGroup = waitPool, chain = group.rootKey})
end
-- updateRun erstatter store'en: slå altid run'et op igen
local run = ADRuns.getRun(ADRunsController.store, runId)
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, fillIndex, used, pool.blocked, pallet)
if pair == nil and pallet then
createStopped(run, "pallet", "palle-vare: ingen ledig traktor + vogn med Universal Autoload (%s)", tostring(title))
return
elseif pair == nil then
createStopped(run, "noVehicle", "ingen ledig traktor/vogn til %s", tostring(title))
return
end
startWithPair(adEnv, run, runId, pair, used)
end
-- Nye varer til en bygning, der allerede har et kædeflow: lægges i det flow. Et palle-flow (udkørsel) får varerne på
-- Lager og producenterne (sources) som kilder.
local function extendFlow(runId, fillTypes, sources)
local run = ADRuns.getRun(ADRunsController.store, runId)
if run == nil then return false end
if run.kind == "outbound" then
local products, added = {}, {}
local have = {}
for _, product in ipairs(run.products or {}) do table.insert(products, {fillType = product.fillType, policy = product.policy}); have[product.fillType] = true end
for _, name in ipairs(fillTypes) do
if not have[name] then have[name] = true; table.insert(products, {fillType = name, policy = "store"}); table.insert(added, name) end
end
local sourceIds, newSource = {}, false
for _, id in ipairs(run.sourceBuildingIds or {}) do table.insert(sourceIds, id) end
for _, id in ipairs(sources or {}) do
local present = false
for _, have2 in ipairs(sourceIds) do if have2 == id then present = true end end
if not present then table.insert(sourceIds, id); newSource = true end
end
if #added == 0 and not newSource then return false end
ADRunsController.updateRun(runId, {products = products, sourceBuildingIds = sourceIds})
log("flow '%s' får også %s", tostring(run.name), #added > 0 and table.concat(added, ", ") or "flere kilder")
return true
end
local ingredients = {}
for _, name in ipairs(run.ingredients or {}) do table.insert(ingredients, name) end
local added = {}
for _, name in ipairs(fillTypes) do
local present = false
for _, have in ipairs(ingredients) do if have == name then present = true end end
if not present then table.insert(ingredients, name); table.insert(added, name) end
end
if #added == 0 then return false end
ADRunsController.updateRun(runId, {ingredients = ingredients})
log("flow '%s' får også %s", tostring(run.name), table.concat(added, ", "))
return true
end
-- Tidligere kædeflows (ét pr. vare) til samme bygning uden traktorer lægges sammen i ét.
-- Flowets slags ("bulk"/"pallet"/"mixed") ud fra varerne i data.fillIndex. -> funktion(run)
local function kindOfFor(data)
local isPalletName = function(name)
local index = (data ~= nil and data.fillIndex or {})[name]
return index ~= nil and ADSources.isPalletOnlyFillType(index)
end
return function(run) return ADChainActions.flowKind(ADChainActions.goodsOf(run) or run.ingredients, isPalletName) end, isPalletName
end
-- Et kædeflow med traktor gøres klar til at blive delt/lavet om: stoppes (vognen hjem) og traktoren slippes.
-- false = lad flowet være (låst sæt, eller stop fejlede — en traktor må ikke køre videre uden flow; review 20/10)
local function releaseForRework(adEnv, run)
if #(run.vehicleIds or {}) == 0 then return true end
-- låst sæt: slå det rigtige flow op (kædens oversigt over flows har ikke alle felter)
local full = ADRuns.getRun(ADRunsController.store, run.id)
if full == nil or full.lockSet == true then return false end
if adEnv ~= nil and adEnv.ADGraphManager ~= nil then
local ok, err = pcall(ADRunsController.stopRun, adEnv, run.id)
if not ok then
warn("flow '%s' kunne ikke stoppes til omlægning: %s", tostring(run.name), tostring(err))
return false
end
end
for _, vehicleId in ipairs(run.vehicleIds) do
ADRunsController.store = ADRuns.unassignVehicle(ADRunsController.store, vehicleId)
end
local fresh = ADRuns.getRun(ADRunsController.store, run.id)
if fresh ~= nil then fresh.wagons, fresh.spareWagons, fresh.parkedLoaded = {}, {}, nil end
return true
end
ADChainRun.releaseForRework = releaseForRework
-- Kædeflows uden traktor med både løsvarer og paller deles i to (brugerønske 18/10 18:34: "så skal den jo tildele 2
-- traktorer og vogne"): løsvarerne bliver, palle-varerne får et nyt flow, så hver del får sin egen traktor + vogn.
-- edges (valgfri): kanternes producenter. Et flow MED traktor deles kun, når palle-varernes producenter kendes (så
-- palle-delen kan blive et udkørselsflow) — ellers er det kombinerede flow (tipvogn + pallevogn) det bedste (review 20/10)
-- -> kilderne for varerne, og om HVER vare har mindst én kendt producent (flere kanter til samme vare flettes)
local function palletSourcesFor(edges, consumer, names)
local producers = {}
for _, edge in ipairs(edges or {}) do
if edge.consumer == consumer then
local list = producers[edge.fillType] or {}
for _, building in ipairs(edge.producerBuildings or {}) do
local present = false
for _, have in ipairs(list) do if have == building then present = true end end
if not present then table.insert(list, building) end
end
producers[edge.fillType] = list
end
end
local all = #(names or {}) > 0
for _, name in ipairs(names or {}) do
if #(producers[name] or {}) == 0 then all = false end
end
return ADChainActions.sourcesFor(producers, names), all
end
function ADChainRun.splitMixedFlows(adEnv, data, active, edges)
local kindOf, isPalletName = kindOfFor(data)
local split = 0
for _, run in ipairs(ADChain.runsView(ADRunsController.store.runs)) do
local bulk, pallets = {}, {}
local hadVehicles = #(run.vehicleIds or {}) > 0
local palletNames = {}
for _, name in ipairs(run.ingredients or {}) do if isPalletName(name) then table.insert(palletNames, name) end end
-- også med traktor (et kombineret flow fra før 20/10: én traktor, tipvogn + pallevogn): stoppes og slippes først —
-- men kun når palle-delen kan blive et udkørselsflow
local mixed = run.chain ~= nil and run.chain ~= "" and (active or {})[run.chain] and kindOf(run) == "mixed"
and (not hadVehicles or select(2, palletSourcesFor(edges, (run.targetBuildingIds or {})[1], palletNames)))
and releaseForRework(adEnv, run)
if mixed then
-- altid delt: palle-delen bliver et udkørselsflow (convertPalletFlows) — et forsyningsflow kan ikke hente
-- paller, heller ikke med en pallevogn som ekstra vogn (20/10)
for _, name in ipairs(run.ingredients or {}) do table.insert(isPalletName(name) and pallets or bulk, name) end
end
if mixed then
ADRunsController.updateRun(run.id, {ingredients = bulk})
-- traktoren blev sluppet: løsvare-delen bemandes igen (staffIdleFlows)
local kept = ADRuns.getRun(ADRunsController.store, run.id)
if kept ~= nil and hadVehicles then kept.stopped, kept.chainIdle = true, true end
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")
ADRunsController.updateRun(created.id, {targetBuildingIds = run.targetBuildingIds, ingredientMode = "manual",
ingredients = pallets, waitPoolGroup = run.waitPoolGroup, chain = run.chain})
local fresh = ADRuns.getRun(ADRunsController.store, created.id)
if fresh ~= nil then fresh.stopped, fresh.chainIdle = true, true end
log("flow '%s' delt: løsvarer (%s) og paller (%s) i hvert sit flow", tostring(run.name), table.concat(bulk, ", "), table.concat(pallets, ", "))
split = split + 1
end
end
return split
end
-- Kædens palle-flows af den gamle slags (forsyning, kunne aldrig hente paller) laves om til udkørselsflows med
-- producenterne fra kanterne som kilder. Har flowet en traktor, stoppes det og traktoren slippes først (flowet er
-- kædens eget — chain er sat; review 20/10: ellers stod "Kæde: Canola Oil" ødelagt og "ok" i fanen). Det bemandes
-- igen med en pallevogn (staffIdleFlows). -> antal lavet om
-- active (valgfri): kun flows i aktive kæder (et pauset/slået-fra flow stoppes ikke — review 20/10)
function ADChainRun.convertPalletFlows(adEnv, data, edges, active)
local kindOf = kindOfFor(data)
local converted = 0
for _, run in ipairs(ADChain.runsView(ADRunsController.store.runs)) do
local consumer = (run.targetBuildingIds or {})[1]
if run.kind == "supply" and run.chain ~= nil and run.chain ~= "" and run.ingredientMode == "manual" and consumer ~= nil
and (active == nil or active[run.chain]) and kindOf(run) == "pallet" then
local sources, allKnown = palletSourcesFor(edges, consumer, run.ingredients)
if allKnown and releaseForRework(adEnv, run) then
ADRunsController.updateRun(run.id, ADChainActions.palletFlowChanges(consumer, run.ingredients, sources, run.chain, run.waitPoolGroup))
local fresh = ADRuns.getRun(ADRunsController.store, run.id)
if fresh ~= nil then fresh.stopped, fresh.chainIdle, fresh.wagons, fresh.spareWagons = true, true, {}, {} end
log("flow '%s' er nu et udkørselsflow fra %d producent(er): palle-varer hentes ved pallepladserne (bemandes igen med en pallevogn)", tostring(run.name), #sources)
converted = converted + 1
end
end
end
return converted
end
function ADChainRun.mergeIdleFlows(adEnv, data)
local merged = 0
for _, merge in ipairs(ADChainActions.mergeIdle(ADChain.runsView(ADRunsController.store.runs), (kindOfFor(data)))) do
if #merge.add > 0 or #(merge.addSources or {}) > 0 then extendFlow(merge.keepId, merge.add, merge.addSources) end
for _, id in ipairs(merge.deleteIds) do
local ok, err = pcall(ADRunsController.deleteRun, id, adEnv)
if ok then
ADChain.noVehicle[id] = nil
merged = merged + 1
else
warn("kædeflow %s kunne ikke lægges sammen: %s", tostring(id), tostring(err))
end
end
end
if merged > 0 then log("%d tomme kædeflows lagt sammen (ét flow pr. bygning)", merged) end
return merged
end
-- Ren: kædeflows uden traktor, der kan bemandes: kædens (chain sat) i en AKTIV kæde (review: en slået-fra kædes tomme
-- flow slettes af stopFlows — bemandet ville det i stedet blive sluppet med traktor), oprettet uden traktor af kæden
-- (run.chainIdle, gemt: spilleren kan selv have tømt et flow), ikke pauset, og mindst én kendt vare. opts = {active,
-- paused} (sæt pr. rodnøgle). -> {{id, fillIndex, pallet}}: første løsvare bærer vognvalget; kun
-- palle-varer -> pallet = true (vogn med Universal Autoload)
function ADChainRun.staffableFlows(runs, fillIndex, isPalletOnly, opts)
opts = opts or {}
local active, paused = opts.active or {}, opts.paused or {}
local list = {}
for _, run in ipairs(runs or {}) do
if run.chain ~= nil and run.chain ~= "" and #(run.vehicleIds or {}) == 0 and active[run.chain]
and not paused[run.chain] and run.chainIdle == true then
local bulk, pallet = nil, nil
for _, name in ipairs(ADChainActions.goodsOf(run) or run.ingredients or {}) do
local index = (fillIndex or {})[name]
if index ~= nil and isPalletOnly(index) then pallet = pallet or index
elseif index ~= nil then bulk = bulk or index end
end
if bulk ~= nil then table.insert(list, {id = run.id, fillIndex = bulk})
elseif pallet ~= nil then table.insert(list, {id = run.id, fillIndex = pallet, pallet = true}) end
end
end
return list
end
-- Kædeflows uden traktor får en ledig traktor + vogn, når der bliver en (in-game 18/10 18:25: "Canola → Oil Mill" og
-- "Barley → Grain Mill" stod "needs a tractor/trailer" for evigt — kæden prøvede kun, da flowet blev oprettet).
-- Højst MAX_NEW_FLOWS pr. tick, hvert flow højst hvert STAFF_RETRY_MS (maskinpuljen er dyr at læse); "venter" logges
-- én gang, så længe flowet venter. -> antal bemandede
-- Beskeden når et kædeflow ikke kan få traktor + vogn: hvad der mangler (pallevogn med Universal Autoload eller en
-- vogn der kan bære varen). textOf(nøgle) -> oversat tekst med %s for flowets navn.
function ADChainRun.textOf(key) return g_i18n ~= nil and g_i18n:getText(key) or key end
function ADChainRun.noVehicleText(runName, pallet, textOf)
local key = pallet and "spu_chain_needPalletWagon" or "spu_chain_needWagon"
local ok, text = pcall(string.format, (textOf or ADChainRun.textOf)(key), tostring(runName))
return ok and text or (tostring(runName) .. ": " .. key)
end
ADChainRun.STAFF_RETRY_MS = 5 * 60 * 1000
local waitLogged, nextTry = {}, {}
function ADChainRun.resetStaffing()
waitLogged, nextTry = {}, {}
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).
undoStaffing = function(adEnv, runId, pair)
pcall(ADRunsController.unassignVehicle, pair.tractor.vehicle)
local run = ADRuns.getRun(ADRunsController.store, runId)
if run ~= nil then
run.stopped, run.chainIdle = true, true
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))
end
function ADChainRun.staffIdleFlows(adEnv, data, active)
local runs = ADRunsController.store.runs
for _, run in ipairs(runs) do
-- spilleren har selv sat en traktor på: ikke længere kædens tomme flow
if run.chainIdle and #(run.vehicleIds or {}) > 0 then run.chainIdle = nil end
end
local now = ADFieldJobs ~= nil and ADFieldJobs.now or 0
local candidates = ADChainRun.staffableFlows(runs, data.fillIndex, ADSources.isPalletOnlyFillType,
{active = active, paused = ADChain.state ~= nil and ADChain.state.paused or nil})
local isCandidate, due = {}, {}
for _, item in ipairs(candidates) do
isCandidate[item.id] = true
if (nextTry[item.id] or 0) <= now then table.insert(due, item) end
end
for id in pairs(waitLogged) do if not isCandidate[id] then waitLogged[id] = nil end end
for id in pairs(nextTry) do if not isCandidate[id] then nextTry[id] = nil end end
if #due == 0 then return 0 end
local pool, used, staffed = {}, {}, 0
pool.implements, pool.tractors = collectPool(adEnv)
pool.blocked = ADPool.blocked(now)
for _, item in ipairs(due) do
if staffed >= ADChain.MAX_NEW_FLOWS then break end
local run = ADRuns.getRun(ADRunsController.store, item.id)
local pair = run ~= nil and ADChainRun.choosePair(pool.implements, pool.tractors, item.fillIndex, used, pool.blocked, item.pallet) or nil
if pair ~= nil then
local started = startWithPair(adEnv, run, item.id, pair, used, "får traktor")
if started > 0 then
waitLogged[item.id], nextTry[item.id] = nil, nil
ADChain.noVehicle[item.id] = nil
local fresh = ADRuns.getRun(ADRunsController.store, item.id)
if fresh ~= nil then fresh.chainIdle = nil end
staffed = staffed + 1
else
undoStaffing(adEnv, item.id, pair)
nextTry[item.id] = now + ADChainRun.STAFF_RETRY_MS
if not waitLogged[item.id] then
waitLogged[item.id] = true
local text = ADChainRun.noVehicleText(run.name, item.pallet, ADChainRun.textOf)
if ADFieldJobs ~= nil and ADFieldJobs.notify ~= nil then ADFieldJobs.notify(text, true) end
end
end
elseif run ~= nil then
nextTry[item.id] = now + ADChainRun.STAFF_RETRY_MS
if not waitLogged[item.id] then
waitLogged[item.id] = true
local text = ADChainRun.noVehicleText(run.name, item.pallet, ADChainRun.textOf)
log("flow venter: %s", text)
-- spilleren skal vide, hvad der mangler (brugerønske 18/10 18:31: "kom op og brok dig")
if ADFieldJobs ~= nil and ADFieldJobs.notify ~= nil then ADFieldJobs.notify(text, true) end
end
end
end
return staffed
end
function ADChainRun.createFlows(adEnv, data, edges)
local runs = ADChain.runsView(ADRunsController.store.runs)
local missing = ADChainActions.missingFlows(edges, runs)
local pool, used, count = {}, {}, 0
for _, group in ipairs(ADChainActions.groupMissing(missing)) do
if count >= ADChain.MAX_NEW_FLOWS then break end
local bulk, pallets = {}, {}
for _, name in ipairs(group.fillTypes) do
local index = data.fillIndex[name]
table.insert((index ~= nil and ADSources.isPalletOnlyFillType(index)) and pallets or bulk, name)
end
local kindOf = kindOfFor(data)
local ok, err = pcall(function()
-- begge slags og intet kædeflow til bygningen endnu: helst ét flow med én traktor (tipvogn + pallevogn) —
-- kun når paller ikke kan få et udkørselsflow (ukendte producenter)
local palletSources = ADChainActions.sourcesFor(group.producers, pallets)
if #bulk > 0 and #pallets > 0 and #palletSources == 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)
if existing ~= nil then
local sources = part.kind == "pallet" and ADChainActions.sourcesFor(group.producers, part.goods) or nil
if extendFlow(existing, part.goods, sources) then count = count + 1 end
else
createGroupFlow(adEnv, data, group, part.goods, pool, used)
count = count + 1
end
end
end
end)
if not ok then warn("flow til %s kunne ikke oprettes: %s", tostring(group.consumerName), tostring(err)) end
end
return count
end
-- Slutprodukter: sælg straks (fabrikkens udgang -> "Sælg direkte"), medmindre kæden står på "Behold". Varer kæden
-- selv satte til salg, sættes tilbage til "Behold", når spilleren vælger det.
-- Har spilleren skiftet en udgang væk fra "Sælg direkte", som kæden selv satte? -> true = respektér det
function ADChainRun.userOverrodeSale(setByChain, notSellingNow)
return setByChain == true and notSellingNow == true
end
local function outputMode(point, fillIndex)
if point.getOutputDistributionMode == nil then return nil end
local ok, mode = pcall(point.getOutputDistributionMode, point, fillIndex)
return ok and mode or nil
end
function ADChainRun.applyFinalSales(data, chain, edges)
if ProductionPoint == nil or ProductionPoint.OUTPUT_MODE == nil then return 0 end
local state, changed = ADChain.state, 0
local wanted = {}
local uses = ADChainActions.farmUses(data, ADChain.runsView(ADRunsController.store.runs))
for _, sale in ipairs(ADChainActions.finalSales(chain, data.recipes, edges, state.finalKeep, uses)) do
local id = sale.key .. "|" .. sale.fillType
wanted[id] = true
local entry, fillIndex = (data.points or {})[sale.key], data.fillIndex[sale.fillType]
local current = entry ~= nil and entry.point ~= nil and fillIndex ~= nil and outputMode(entry.point, fillIndex) or nil
if ADChainRun.userOverrodeSale(state.soldByChain[id] == true, current ~= nil and current ~= ProductionPoint.OUTPUT_MODE.DIRECT_SELL) then
-- kæden satte den til salg, og spilleren har skiftet den væk igen: spillerens valg gælder (in-game 6/10:
-- TMR-fabrikken blev sat tilbage til Sælg to gange, men TMR'en skal til køerne)
state.finalKeep[sale.key] = true
state.soldByChain[id] = nil
wanted[id] = nil
log("slutprodukt %s i %s: spilleren valgte ikke at sælge — beholdes fremover", tostring(sale.fillType), tostring(entry.buildingName or sale.key))
elseif entry ~= nil and entry.point ~= nil and fillIndex ~= nil and entry.point.setOutputDistributionMode ~= nil
and current ~= ProductionPoint.OUTPUT_MODE.DIRECT_SELL then
entry.point:setOutputDistributionMode(fillIndex, ProductionPoint.OUTPUT_MODE.DIRECT_SELL)
state.soldByChain[id] = true
changed = changed + 1
log("slutprodukt %s i %s sælges straks", tostring(sale.fillType), tostring(entry.buildingName or sale.key))
end
end
for id in pairs(state.soldByChain) do
local key, fillType = id:match("^(.*)|([^|]+)$")
-- sat til salg af kæden, men ikke længere ønsket (Behold, gården bruger varen, kæden væk): tilbage til Behold
if key ~= nil and not wanted[id] then
local entry, fillIndex = (data.points or {})[key], data.fillIndex[fillType]
if entry ~= nil and entry.point ~= nil and fillIndex ~= nil
and outputMode(entry.point, fillIndex) == ProductionPoint.OUTPUT_MODE.DIRECT_SELL then
entry.point:setOutputDistributionMode(fillIndex, ProductionPoint.OUTPUT_MODE.KEEP)
changed = changed + 1
log("slutprodukt %s beholdes igen", tostring(fillType))
end
state.soldByChain[id] = nil
end
end
return changed
end
-- Mellemvarer der står på Sælg: næste led i kæden fik intet. Sættes til Behold (spawn/lager), så kædens flow henter
-- dem ved fabrikken; tages ud af soldByChain, så slutprodukt-logikken ikke sætter dem til salg igen.
function ADChainRun.keepIntermediates(data, edges)
if ProductionPoint == nil or ProductionPoint.OUTPUT_MODE == nil then return 0 end
local changed = 0
for _, item in ipairs(ADChainActions.soldIntermediates(edges)) do
local entry, fillIndex = (data.points or {})[item.key], data.fillIndex[item.fillType]
if entry ~= nil and entry.point ~= nil and fillIndex ~= nil and entry.point.setOutputDistributionMode ~= nil
and outputMode(entry.point, fillIndex) == ProductionPoint.OUTPUT_MODE.DIRECT_SELL then
entry.point:setOutputDistributionMode(fillIndex, ProductionPoint.OUTPUT_MODE.KEEP)
ADChain.state.soldByChain[item.key .. "|" .. item.fillType] = nil
changed = changed + 1
log("mellemvare %s i %s sælges ikke længere (næste led i kæden bruger den) -> Behold", tostring(item.fillType),
tostring(entry.buildingName or item.key))
end
end
return changed
end
-- Flows for rødder der er slået fra: flyt til en anden rod der stadig bruger kanten, ellers stop og slip (chain
-- ryddes, så spilleren kan starte flowet igen uden at kæden stopper det næste minut; det slettes ikke).
function ADChainRun.stopFlows(adEnv, chain, edges)
local changed = 0
local active = ADChain.activeRoots(chain, ADChain.state.paused)
for _, run in ipairs(ADChainActions.flowsToStop(ADChain.runsView(ADRunsController.store.runs), active)) do
local rootKey = ADChain.stillNeeded(run, edges)
if rootKey ~= nil then
ADRunsController.updateRun(run.id, {chain = rootKey})
log("flow '%s' hører nu til kæden %s", tostring(run.name), tostring(rootKey))
changed = changed + 1
elseif ADChainActions.releaseAction(run) == "delete" then
local ok, err = pcall(ADRunsController.deleteRun, run.id, adEnv)
if ok then
ADChain.noVehicle[run.id] = nil
log("tomt kædeflow '%s' slettet: kæden %s er slået fra", tostring(run.name), tostring(run.chain))
changed = changed + 1
else
warn("flow '%s' kunne ikke slettes: %s", tostring(run.name), tostring(err))
end
else
local ok, err = pcall(ADRunsController.stopRun, adEnv, run.id)
if ok then
ADRunsController.updateRun(run.id, {chain = ""})
log("flow '%s' stoppet og sluppet af kæden: kæden %s er slået fra", tostring(run.name), tostring(run.chain))
changed = changed + 1
else
warn("flow '%s' kunne ikke stoppes: %s", tostring(run.name), tostring(err))
end
end
end
return changed
end
-- Kædens egne mål-afgrøder der ikke må bruges (data.unswitchable: fx eng, kan ikke sås) ryddes, så marken ikke
-- står "ingen kan" for evigt (in-game 5/10: F5/F9 -> MEADOW). Brugerens egne mål røres aldrig. -> antal ryddet
function ADChainRun.repairTargets(data)
local repaired = 0
for _, field in ipairs(data ~= nil and data.fields or {}) do
local target = field.targetFruit
if field.targetSource == "chain" and target ~= nil and target ~= "" and (data.unswitchable or {})[target] then
local ok, err = pcall(ADFieldJobs.setTarget, field.id, "", "chain")
if ok then
repaired = repaired + 1
log("F%s: kædens mål %s kan ikke bruges (kan ikke sås) — ryddet", tostring(field.id), tostring(target))
else
warn("F%s: mål kunne ikke ryddes: %s", tostring(field.id), tostring(err))
end
end
end
return repaired
end
-- Hele planen; hver del for sig i pcall.
function ADChainRun.apply(adEnv, data, result)
local okRepair, errRepair = pcall(ADChainRun.repairTargets, data)
if not okRepair then warn("oprydning af mål fejlede: %s", tostring(errRepair)) end
local okFields, errFields = pcall(ADChainRun.switchFields, data, result.actions)
if not okFields then warn("markskift fejlede: %s", tostring(errFields)) end
local okProd, errProd = pcall(ADChainRun.toggleProductions, data, result.prod)
if not okProd then warn("mellemled fejlede: %s", tostring(errProd)) end
-- blandede flows deles kun i aktive kæder og aldrig på delvise data (som bemandingen)
local okSplit, splitCount = true, 0
if not data.partial then
okSplit, splitCount = pcall(ADChainRun.splitMixedFlows, adEnv, data, ADChain.activeRoots(result.chain, ADChain.state.paused), result.edges)
if not okSplit then warn("deling af blandede kædeflows fejlede: %s", tostring(splitCount)) end
end
local okMerge, mergedCount = pcall(ADChainRun.mergeIdleFlows, adEnv, data)
if not okMerge then warn("sammenlægning af kædeflows fejlede: %s", tostring(mergedCount)) end
-- gamle palle-flows (forsyning) -> udkørsel; aldrig på delvise data
local okConvert, convertCount = true, 0
if not data.partial then
okConvert, convertCount = pcall(ADChainRun.convertPalletFlows, adEnv, data, result.edges, ADChain.activeRoots(result.chain, ADChain.state.paused))
if not okConvert then warn("palle-flows kunne ikke laves om: %s", tostring(convertCount)) end
end
local okNew, created = pcall(ADChainRun.createFlows, adEnv, data, result.edges)
-- tomme kædeflows bemandes kun i aktive kæder og aldrig på delvise data (en ulæselig rod ligner en slået-fra)
local okStaff, staffed = true, 0
if not data.partial then
okStaff, staffed = pcall(ADChainRun.staffIdleFlows, adEnv, data, ADChain.activeRoots(result.chain, ADChain.state.paused))
if not okStaff then warn("bemanding af tomme kædeflows fejlede: %s", tostring(staffed)) end
end
local okSell, sellErr = pcall(ADChainRun.applyFinalSales, data, result.chain, result.edges)
if not okSell then warn("slutprodukter fejlede: %s", tostring(sellErr)) end
local okKeep, keepErr = pcall(ADChainRun.keepIntermediates, data, result.edges)
if not okKeep then warn("mellemvarer fejlede: %s", tostring(keepErr)) end
if not okNew then warn("nye flows fejlede: %s", tostring(created)) end
-- ændringer tælles for sig (review: fejlede createFlows, blev deling/sammenlægning ikke gemt)
local changed = (okNew and created or 0) + (okMerge and mergedCount or 0) + (okSplit and splitCount or 0) + (okConvert and convertCount or 0)
-- delvise data: en rod der ikke kunne læses, må ikke få sine flows stoppet
local okStop, stopped = true, 0
if not data.partial then
okStop, stopped = pcall(ADChainRun.stopFlows, adEnv, result.chain, result.edges)
if not okStop then warn("stop af flows fejlede: %s", tostring(stopped)) end
end
if changed > 0 or (okStop and stopped > 0) or (okStaff and staffed > 0) then
local okSave, errSave = pcall(ADRunsController.save)
if not okSave then warn("flows kunne ikke gemmes: %s", tostring(errSave)) end
end
end