-- AD Flow Guide -- "Opsæt flow": flowguidens trin oven på ADGuide (ren Lua, ingen spil-API) — samme trin-skærm og knapper -- som markguiden. Kladden er en kopi af flowets felter, så intet ændres før [Gem]/[Start flow]. Det -- spil-afhængige kommer i `context` (GUI'et henter det ud fra kladden, se previewRun): -- {buildings = {{id, name, label, hasMarker, text}} -- kandidater til Fra (udkørsel) / Til (forsyning) -- fillTypes = {{name, title}} -- varer målet tager (forsyning, Vælg selv) -- products = {{name, title}} -- varer kilderne har (udkørsel) -- storeBuildings = {{id, name, text}} -- lagre der kan tage flowets lagervarer -- waitPools = {{group, count}} -- vehicles = {{id, label, text, otherRunId, otherRunName, blocked, solo}} -- label = kort navn (resumé) -- wagons = {{id, label}}} -- ledige vogne til solo-traktorer (bedste først) -- Solo-traktor (ingen vogn bagpå) får en ledig vogn fra context.wagons (draft.wagons = {[traktorId] = vognId}), -- som den henter ved "Connect " — uden at vognens parkering skal omdøbes. -- Gem: ADRunsController.createRun/updateRun + assignVehicle/unassignVehicle (GUI'et). ADFlowGuide = {} ADFlowGuide.ORDER = {"name", "direction", "buildings", "goods", "store", "rules", "wait", "tractors", "summary"} ADFlowGuide.POLICIES = {"off", "store", "sell", "sellElseStore"} ADFlowGuide.MAX_NAMED_TRACTORS = 3 ADFlowGuide.MAX_NAMED_GOODS = 3 local function L(key, args) return {key = key, args = args} end local function T(text) return {text = text} end local function isOut(guide) return guide.draft.kind == "outbound" end local function hasStorePolicy(draft) for _, product in ipairs(draft.products or {}) do if product.policy == "store" or product.policy == "sellElseStore" then return true end end return false end local VISIBLE = { name = function(guide) return guide.draft.isNew == true end, store = function(guide) return isOut(guide) and hasStorePolicy(guide.draft) end, } function ADFlowGuide.isVisible(step, guide) local rule = VISIBLE[step] if rule ~= nil then return rule(guide) == true end for _, id in ipairs(ADFlowGuide.ORDER) do if id == step then return true end end return false end ADFlowGuide.DEF = {order = ADFlowGuide.ORDER, isVisible = ADFlowGuide.isVisible} -- Overskrift pr. trin; "Fra"/"Til" følger retningen. function ADFlowGuide.stepKey(step, guide) if step == "buildings" then return (guide ~= nil and isOut(guide)) and "spu_guide_flow_step_from" or "spu_guide_flow_step_to" end return "spu_guide_flow_step_" .. tostring(step) end local KIND_HINTS = {buildings = true, goods = true, rules = true} function ADFlowGuide.hintKey(step, guide) if KIND_HINTS[step] then return "spu_guide_flow_hint_" .. step .. ((guide ~= nil and isOut(guide)) and "_out" or "_in") end return "spu_guide_flow_hint_" .. tostring(step) end -- ---- kladde ---- local RUN_FIELDS = { "id", "name", "kind", "sourceBuildingIds", "targetBuildingIds", "storeBuildingIds", "products", "ingredientMode", "ingredients", "sellAtPercent", "storeAbovePercent", "sellAbovePercent", "minSourcePercent", "collectRound", "loops", "returnBelowPercent", "waitPoolGroup", "vehicleIds", "wagons", "chain", "spareWagons", "borrowWagonId", } local function draftFrom(run, isNew) local draft = {} for _, key in ipairs(RUN_FIELDS) do draft[key] = ADGuide.deepCopy(run[key]) end for _, key in ipairs({"sourceBuildingIds", "targetBuildingIds", "storeBuildingIds", "products", "ingredients", "vehicleIds"}) do draft[key] = draft[key] or {} end draft.kind = draft.kind == "outbound" and "outbound" or "supply" draft.ingredientMode = draft.ingredientMode == "manual" and "manual" or "auto" draft.sellAtPercent = draft.sellAtPercent or ADRuns.DEFAULT_SELL_AT_PERCENT draft.storeAbovePercent = draft.storeAbovePercent or ADRuns.DEFAULT_STORE_ABOVE_PERCENT draft.sellAbovePercent = draft.sellAbovePercent or ADRuns.DEFAULT_SELL_ABOVE_PERCENT draft.minSourcePercent = draft.minSourcePercent or ADRuns.DEFAULT_MIN_SOURCE_PERCENT draft.returnBelowPercent = draft.returnBelowPercent or ADRuns.DEFAULT_RETURN_BELOW_PERCENT 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 draft.storeAuto = #draft.storeBuildingIds == 0 draft.borrowTractor = draft.borrowWagonId ~= nil return draft end function ADFlowGuide.open(run, context, options) return ADGuide.new(ADFlowGuide.DEF, draftFrom(run, false), context, options) end -- Nyt flow: intet oprettes før [Gem]; kladden har standardværdierne fra ADRuns.createRun. function ADFlowGuide.openNew(name, context) local _, run = ADRuns.createRun(ADRuns.newStore(), name, "supply") local draft = draftFrom(run, true) draft.id = nil return ADGuide.new(ADFlowGuide.DEF, draft, context) end -- Run-formet tabel til controllerens opslag (varer, vogne) før noget er gemt: markører fra de valgte -- bygninger. markerIds(buildingId, role) -> {wayPointId, ...}. function ADFlowGuide.previewRun(draft, markerIds) local run = ADGuide.deepCopy(draft) local function resolve(ids, role) local result, seen = {}, {} for _, buildingId in ipairs(ids or {}) do for _, wayPointId in ipairs(markerIds(buildingId, role) or {}) do if not seen[wayPointId] then seen[wayPointId] = true table.insert(result, wayPointId) end end end return result end run.sourceWayPointIds = resolve(draft.sourceBuildingIds, "load") run.targetWayPointIds = resolve(draft.targetBuildingIds, "unload") run.targetWayPointId = run.targetWayPointIds[1] return run end -- ---- vogne til solo-traktorer ---- local function soloIds(context) local set = {} for _, vehicle in ipairs((context or {}).vehicles or {}) do if vehicle.solo then set[vehicle.id] = true end end return set end -- Ny vogn-tabel: fravalgte traktorer slipper deres vogn; valgte solo-traktorer uden (gyldig) vogn får den første -- ledige i context.wagons, som ingen anden traktor i flowet har. Vogne til ikke-solo-traktorer bevares (husket). function ADFlowGuide.assignWagons(draft, context) local chosen, solo, offered = {}, soloIds(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 wagons[tractorId] = wagonId used[wagonId] = true end end for _, tractorId in ipairs(draft.vehicleIds or {}) do if solo[tractorId] and wagons[tractorId] == nil then for _, wagon in ipairs((context or {}).wagons or {}) do if not used[wagon.id] then wagons[tractorId] = wagon.id used[wagon.id] = true break end end end end return wagons end -- ---- valg ---- local SET_VALUES = { kind = true, ingredientMode = true, sellAtPercent = true, storeAbovePercent = true, sellAbovePercent = true, minSourcePercent = true, loops = true, returnBelowPercent = true, waitPoolGroup = true, borrowWagonId = true, } local BOOL_VALUES = {showAllBuildings = true, storeAuto = true, collectRound = true, borrowTractor = true} local LIST_VALUES = {ingredients = true, storeBuildingIds = true, vehicleIds = true} local function setPolicy(products, name, policy) local result = {} for _, product in ipairs(products or {}) do if product.fillType ~= name then table.insert(result, {fillType = product.fillType, policy = product.policy}) end end if policy ~= "off" then table.insert(result, {fillType = name, policy = policy}) end return result end function ADFlowGuide.choose(guide, id, value) if id == "showBlocked" then -- visning, ikke en del af flowet: fold listen over traktorer der ikke kan bruges ud/ind local copy = {} for key, field in pairs(guide) do copy[key] = field end copy.showBlocked = not guide.showBlocked return copy end local draft = ADGuide.deepCopy(guide.draft) if SET_VALUES[id] then draft[id] = value elseif BOOL_VALUES[id] then draft[id] = value == true elseif LIST_VALUES[id] then draft[id] = ADGuide.toggleItem(draft[id], value.item, value.on) if id == "vehicleIds" then draft.wagons = ADFlowGuide.assignWagons(draft, guide.context) end 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) elseif id == "policy" then draft.products = setPolicy(draft.products, value.item, value.value) elseif id == "name" then if type(value) ~= "string" or not value:match("%S") then return guide end draft.name = value else return guide end return ADGuide.withDraft(guide, draft) end -- ---- rækker ---- -- Hjælpetekst pr. række (in-game 19/10: alle valgrækker viste varepolitikkens tekst, fordi de er kloner af varerækken) ADFlowGuide.TOOLTIPS = { policy = "spu_policy_tooltip", ingredientMode = "spu_ingredientMode_tooltip", sellAtPercent = "spu_sellAt_tooltip", storeAbovePercent = "spu_storeAbove_tooltip", sellAbovePercent = "spu_sellAbove_tooltip", minSourcePercent = "spu_minSource_tooltip", collectRound = "spu_collectRound_tooltip", loops = "spu_loops_tooltip", returnBelowPercent = "spu_returnBelow_tooltip", waitPoolGroup = "spu_waitPool_tooltip", borrowTractor = "spu_guide_flow_borrow_tooltip", borrowWagonId = "spu_guide_flow_borrowWagon_tooltip", } local function choice(id, title, options, value, item) return {type = "choice", id = id, title = title, options = options, value = value, item = item, tooltip = ADFlowGuide.TOOLTIPS[id]} end local function toggle(id, title, value) return {type = "toggle", id = id, title = title, off = L("ui_no"), on = L("ui_yes"), value = value == true, tooltip = ADFlowGuide.TOOLTIPS[id]} end local function check(id, item, text, value) return {type = "check", id = id, item = item, title = T(text), value = value == true} end local function text(key, args) return {type = "text", label = L(key, args)} end local function percentOptions(from, to, step) local options = {} for percent = from, to, step do table.insert(options, {label = T(string.format("%d %%", percent)), value = percent}) end return options end -- "Sælg altid over": Fra, 50-100 % local function sellAboveOptions() local options = {{label = L("spu_sellAbove_off"), value = 0}} for _, option in ipairs(percentOptions(50, ADRuns.MAX_SELL_ABOVE_PERCENT, 5)) do table.insert(options, option) end return options end local function minSourceOptions() local options = {{label = L("spu_minSource_off"), value = 0}} for _, option in ipairs(percentOptions(10, 90, 10)) do table.insert(options, option) end return options end local function chosenSet(list) local set = {} for _, value in ipairs(list or {}) do set[value] = true end return set end local function buildingIds(draft) return draft.kind == "outbound" and draft.sourceBuildingIds or draft.targetBuildingIds end local function rowsName(guide) return { {type = "text", label = T(guide.draft.name or "")}, {type = "link", id = "rename", value = true, label = L("spu_guide_flow_rename")}, } end local function rowsDirection(guide) return {choice("kind", L("spu_direction"), { {label = L("spu_direction_in"), value = "supply"}, {label = L("spu_direction_out"), value = "outbound"}}, guide.draft.kind)} end -- Bygninger i fast rækkefølge (navn, markør); uden markør kun med "Vis alle" (eller når valgt). local function rowsBuildings(guide) local draft, rows = guide.draft, {} local chosen = chosenSet(buildingIds(draft)) local candidates = guide.context.buildings or {} local shown = ADFlowView.buildingRows(candidates, chosen, draft.showAllBuildings) local hidden = ADFlowView.hiddenCount(candidates, shown) if hidden > 0 or draft.showAllBuildings then table.insert(rows, toggle("showAllBuildings", L("spu_showAllBuildings", {hidden}), draft.showAllBuildings)) end for _, building in ipairs(shown) do table.insert(rows, check("buildings", building.id, building.text or building.name, chosen[building.id])) end if #shown == 0 then table.insert(rows, text("spu_noBuildings")) end return rows end local function rowsGoods(guide) local draft, context, rows = guide.draft, guide.context, {} if isOut(guide) then local products = context.products or {} if #products == 0 then -- kilde valgt, men den kan intet levere — ikke "vælg først en kilde" (in-game 11/10) local chosenSources = buildingIds(draft) or {} return {text(#chosenSources > 0 and "spu_guide_flow_noProductsAtSource" or "spu_guide_flow_noProducts")} end local options = {} for _, policy in ipairs(ADFlowGuide.POLICIES) do table.insert(options, {label = L("spu_policy_" .. policy), value = policy}) end for _, product in ipairs(products) do table.insert(rows, choice("policy", T(product.text or product.title), options, ADRuns.getProductPolicy(draft, product.name), product.name)) end return rows end table.insert(rows, choice("ingredientMode", L("spu_guide_flow_goods"), { {label = L("spu_guide_flow_goodsAutoChoice"), value = "auto"}, {label = L("spu_guide_manual"), value = "manual"}}, draft.ingredientMode)) if draft.ingredientMode ~= "manual" then table.insert(rows, text("spu_guide_flow_goodsAutoText")) return rows end local chosen = chosenSet(draft.ingredients) for _, fillType in ipairs(context.fillTypes or {}) do table.insert(rows, check("ingredients", fillType.name, " " .. tostring(fillType.title), chosen[fillType.name])) end if #(context.fillTypes or {}) == 0 then table.insert(rows, text("spu_guide_flow_noGoodsTo")) end return rows end local function rowsStore(guide) local draft, rows = guide.draft, {} table.insert(rows, choice("storeAuto", L("spu_guide_store"), { {label = L("spu_guide_flow_storeAutoChoice"), value = true}, {label = L("spu_guide_manual"), value = false}}, draft.storeAuto)) if draft.storeAuto then table.insert(rows, text("spu_guide_flow_storeAutoText")) return rows end local chosen = chosenSet(draft.storeBuildingIds) for _, building in ipairs(guide.context.storeBuildings or {}) do table.insert(rows, check("storeBuildingIds", building.id, building.text, chosen[building.id])) end if #(guide.context.storeBuildings or {}) == 0 then table.insert(rows, text("spu_noBuildings")) end return rows end local function productPolicies(draft) local policies = {} for _, product in ipairs(draft.products or {}) do table.insert(policies, product.policy) end return policies end -- Kun regler varernes politik bruger: rent lager-flow viser ikke salgsgrænser og omvendt (in-game 29/9). local function rowsRules(guide) local draft = guide.draft if isOut(guide) then local sells, stores = ADFlowView.policyUse(productPolicies(draft)) local rows = {} if sells then -- "Altid" (0) øverst: sælg uanset pris (in-game 30/9) local options = {{label = L("spu_sellAt_always"), value = 0}} for _, option in ipairs(percentOptions(ADRuns.MIN_SELL_AT_PERCENT, ADRuns.MAX_SELL_AT_PERCENT, 5)) do table.insert(options, option) end table.insert(rows, choice("sellAtPercent", L("spu_sellAt"), options, draft.sellAtPercent)) end if stores then table.insert(rows, choice("storeAbovePercent", L("spu_storeAbove"), percentOptions(ADRuns.MIN_STORE_ABOVE_PERCENT, ADRuns.MAX_STORE_ABOVE_PERCENT, 5), draft.storeAbovePercent)) end if sells then table.insert(rows, choice("sellAbovePercent", L("spu_sellAbove"), sellAboveOptions(), draft.sellAbovePercent)) end if sells then table.insert(rows, choice("minSourcePercent", L("spu_minSource"), minSourceOptions(), draft.minSourcePercent or 0)) end table.insert(rows, toggle("collectRound", L("spu_collectRound"), draft.collectRound)) return rows end local loops = {{label = L("spu_loops_infinite"), value = 0}} for count = 1, ADRuns.MAX_LOOPS do table.insert(loops, {label = T(tostring(count)), value = count}) end return { choice("loops", L("spu_loops"), loops, draft.loops), choice("returnBelowPercent", L("spu_returnBelow"), percentOptions(ADRuns.MIN_RETURN_BELOW_PERCENT, ADRuns.MAX_RETURN_BELOW_PERCENT, 10), draft.returnBelowPercent), } end local function rowsWait(guide) local options = {{label = L("spu_waitPool_all"), value = ""}} for _, pool in ipairs(guide.context.waitPools or {}) do table.insert(options, {label = T(string.format("%s (%d)", tostring(pool.group), pool.count or 0)), value = pool.group}) end return {choice("waitPoolGroup", L("spu_waitPool"), options, guide.draft.waitPoolGroup or "")} end -- Vognvalg under en valgt solo-traktor: dens egen vogn + ledige vogne ingen anden traktor i flowet har. local function rowWagon(guide, tractorId, ownWagon) local wagons = guide.draft.wagons or {} local usedByOthers = {} 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 for _, wagon in ipairs(guide.context.wagons or {}) do if not usedByOthers[wagon.id] and (ownWagon == nil or wagon.id ~= ownWagon.id) then table.insert(options, {label = T(tostring(wagon.label)), value = wagon.id}) end end local current = wagons[tractorId] or (ownWagon ~= nil and ownWagon.id or nil) if #options == 0 or current == nil then return text("spu_guide_flow_noFreeWagon") end 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 -- Lånevognen: den valgte (flowets egen — også mens en lånt traktor kører med den og den derfor ikke står som ledig), -- ellers den første ledige vogn der passer til varerne. function ADFlowGuide.borrowWagon(draft, context) if draft.borrowWagonId ~= nil and draft.borrowWagonId ~= "" then return draft.borrowWagonId end local first = ((context or {}).wagons or {})[1] return first ~= nil and first.id or nil end -- Lånt traktor (brugerønske 19/10): kun en vogn vælges; ingen traktor er bundet til flowet. local function rowsBorrow(guide) local rows = {toggle("borrowTractor", L("spu_guide_flow_borrow"), true)} local options, listed = {}, false local current = ADFlowGuide.borrowWagon(guide.draft, guide.context) for _, wagon in ipairs(guide.context.wagons or {}) do table.insert(options, {label = T(tostring(wagon.label)), value = wagon.id}) if wagon.id == current then listed = true end end -- flowets vogn er ude at køre (sidder på den lånte traktor): den står ikke som ledig, men er stadig valget if current ~= nil and not listed then table.insert(options, 1, {label = L("spu_guide_flow_borrowWagonInUse"), value = current}) end if current == nil then table.insert(rows, text("spu_guide_flow_noFreeWagon")) else table.insert(rows, choice("borrowWagonId", L("spu_guide_flow_borrowWagon"), options, current)) end table.insert(rows, text("spu_guide_flow_borrowText")) return rows 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) local draft, rows = guide.draft, {} if draft.borrowTractor then return rowsBorrow(guide) end table.insert(rows, toggle("borrowTractor", L("spu_guide_flow_borrow"), false)) local inRun = chosenSet(draft.vehicleIds) local entries = {} local other, blocked = 0, 0 local blockedTexts = {} for _, vehicle in ipairs(guide.context.vehicles or {}) do local state = "free" if inRun[vehicle.id] then state = "in" elseif vehicle.otherRunId ~= nil and vehicle.otherRunId ~= draft.id then state = "other" other = other + 1 elseif vehicle.blocked then state = "blocked" blocked = blocked + 1 table.insert(blockedTexts, tostring(vehicle.text)) end table.insert(entries, {id = vehicle.id, label = tostring(vehicle.text), state = state, ownWagon = vehicle.ownWagon}) end local solo = soloIds(guide.context) for _, entry in ipairs(ADFlowView.vehicleRows(entries, false)) do table.insert(rows, check("vehicleIds", entry.id, entry.label, entry.state == "in")) local own = nil for _, e in ipairs(entries) do if e.id == entry.id then own = e.ownWagon end end 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 == 1 then table.insert(rows, text("spu_guide_flow_noTractors")) end if other > 0 then table.insert(rows, text("spu_guide_flow_otherFlows", {other})) end if blocked > 0 then -- foldet sammen som standard; linjen med antallet folder navn + grund ud/ind local key = guide.showBlocked and "spu_guide_flow_blockedHide" or "spu_guide_flow_blockedShow" table.insert(rows, {type = "link", id = "showBlocked", value = true, label = L(key, {blocked})}) if guide.showBlocked then table.sort(blockedTexts) for _, line in ipairs(blockedTexts) do table.insert(rows, {type = "text", label = T(" " .. line)}) end end end return rows end local function rowsSummary(guide) local rows = {} for _, line in ipairs(ADFlowGuide.summary(guide)) do table.insert(rows, {type = "link", id = "jump", value = line.step, line = line}) end return rows end local ROWS = { name = rowsName, direction = rowsDirection, buildings = rowsBuildings, goods = rowsGoods, store = rowsStore, rules = rowsRules, wait = rowsWait, tractors = rowsTractors, summary = rowsSummary, } function ADFlowGuide.rows(guide) local builder = ROWS[guide.step] return builder ~= nil and builder(guide) or {} end -- ---- resumé ---- -- Korte navne til resuméet (field, ellers navn, ellers rækkens tekst). local function namesFor(ids, entries, field) local byId = {} for _, entry in ipairs(entries or {}) do byId[entry.id or entry.name] = entry[field] or entry.name or entry.text end local names = {} for _, id in ipairs(ids or {}) do table.insert(names, tostring(byId[id] or id)) end return names end local SUMMARY = { name = function(guide) return {T(guide.draft.name or "")} end, direction = function(guide) return {L(isOut(guide) and "spu_direction_out" or "spu_direction_in")} end, buildings = function(guide) local names = namesFor(buildingIds(guide.draft), guide.context.buildings, "name") if #names == 0 then return {L("spu_guide_flow_none")} end return {T(ADFlowView.joinCounted(names, " + ", ""))} end, goods = function(guide) local draft = guide.draft if isOut(guide) then local parts = {} local titles = {} for _, product in ipairs(guide.context.products or {}) do titles[product.name] = product.title end for _, product in ipairs(draft.products or {}) do table.insert(parts, {key = "spu_policy_" .. product.policy, prefix = tostring(titles[product.fillType] or product.fillType) .. ": "}) end if #parts == 0 then return {L("spu_guide_flow_none")} end return parts end if draft.ingredientMode ~= "manual" then return {L("spu_guide_flow_goodsAuto")} end if #draft.ingredients == 0 then return {L("spu_guide_flow_none")} end if #draft.ingredients > ADFlowGuide.MAX_NAMED_GOODS then return {L("spu_guide_flow_sumGoods", {#draft.ingredients})} end local byName = {} for _, fillType in ipairs(guide.context.fillTypes or {}) do byName[fillType.name] = fillType.title end local names = {} for _, name in ipairs(draft.ingredients) do table.insert(names, tostring(byName[name] or name)) end return {T(table.concat(names, " + "))} end, store = function(guide) local draft = guide.draft if draft.storeAuto or #draft.storeBuildingIds == 0 then return {L("spu_guide_sum_auto")} end if #draft.storeBuildingIds > 2 then return {L("spu_guide_sum_stores", {#draft.storeBuildingIds})} end return {T(table.concat(namesFor(draft.storeBuildingIds, guide.context.storeBuildings, "name"), " + "))} end, rules = function(guide) local draft = guide.draft if isOut(guide) then local sells, stores = ADFlowView.policyUse(productPolicies(draft)) local parts = {} if sells then table.insert(parts, draft.sellAtPercent == 0 and L("spu_guide_flow_sumSellAlways") or L("spu_guide_flow_sumSellAt", {draft.sellAtPercent})) end if stores then table.insert(parts, L("spu_guide_flow_sumStoreAbove", {draft.storeAbovePercent})) end if sells and (draft.sellAbovePercent or 0) > 0 then table.insert(parts, L("spu_guide_flow_sumSellAbove", {draft.sellAbovePercent})) end if sells and (draft.minSourcePercent or 0) > 0 then table.insert(parts, L("spu_guide_flow_sumMinSource", {draft.minSourcePercent})) end if draft.collectRound then table.insert(parts, L("spu_guide_flow_sumRound")) end return parts end local loops = (draft.loops or 0) > 0 and L("spu_guide_flow_sumLoops", {draft.loops}) or L("spu_guide_flow_sumLoopsInf") return {loops, L("spu_guide_flow_sumReturn", {draft.returnBelowPercent})} end, wait = function(guide) local group = guide.draft.waitPoolGroup or "" return {group == "" and L("spu_waitPool_all") or T(group)} end, tractors = function(guide) if guide.draft.borrowTractor then local wagonId = ADFlowGuide.borrowWagon(guide.draft, guide.context) if wagonId == nil then return {L("spu_guide_flow_sumNoTractors")} end local known = false for _, wagon in ipairs(guide.context.wagons or {}) do if wagon.id == wagonId then known = true end end if not known then return {L("spu_guide_flow_sumBorrowInUse")} end return {L("spu_guide_flow_sumBorrow", {namesFor({wagonId}, guide.context.wagons, "label")[1]})} end local ids = guide.draft.vehicleIds if #ids == 0 then return {L("spu_guide_flow_sumNoTractors")} end if #ids > ADFlowGuide.MAX_NAMED_TRACTORS then return {L("spu_guide_flow_sumTractors", {#ids})} end -- traktorer der ikke findes (solgt, eller ikke indlæst endnu) vises ikke som rå id local known = {} for _, vehicle in ipairs(guide.context.vehicles or {}) do known[vehicle.id] = true end local present = {} for _, id in ipairs(ids) do if known[id] then table.insert(present, id) end end if #present == 0 then return {L("spu_guide_flow_sumNoTractors")} end return {T(table.concat(namesFor(present, guide.context.vehicles, "label"), ", "))} end, } -- Resumé-linjer {step, title, parts}: Navn (altid) + de synlige trin. function ADFlowGuide.summary(guide) local lines = {} for _, step in ipairs(ADFlowGuide.ORDER) do local build = SUMMARY[step] if build ~= nil and (step == "name" or ADFlowGuide.isVisible(step, guide)) then table.insert(lines, {step = step, title = L(ADFlowGuide.stepKey(step, guide)), parts = build(guide)}) end end return lines end -- ---- gem ---- function ADFlowGuide.result(guide) local draft = guide.draft local storeIds = ADGuide.deepCopy(draft.storeBuildingIds) if ADFlowGuide.isVisible("store", guide) and draft.storeAuto then storeIds = {} end local changes = { kind = draft.kind, sourceBuildingIds = ADGuide.deepCopy(draft.sourceBuildingIds), targetBuildingIds = ADGuide.deepCopy(draft.targetBuildingIds), storeBuildingIds = storeIds, products = ADGuide.deepCopy(draft.products), ingredientMode = draft.ingredientMode, ingredients = ADGuide.deepCopy(draft.ingredients), sellAtPercent = draft.sellAtPercent, storeAbovePercent = draft.storeAbovePercent, sellAbovePercent = draft.sellAbovePercent or 0, minSourcePercent = draft.minSourcePercent or 0, collectRound = draft.collectRound, loops = draft.loops, returnBelowPercent = draft.returnBelowPercent, waitPoolGroup = draft.waitPoolGroup or "", } if draft.name ~= nil and draft.name:match("%S") then changes.name = draft.name end -- lånt traktor: ingen faste traktorer (de slippes ved gem), kun vognen huskes; uden ledig vogn = faste traktorer local borrowWagonId = draft.borrowTractor and ADFlowGuide.borrowWagon(draft, guide.context) or nil changes.borrowWagonId = borrowWagonId or false if borrowWagonId ~= nil then -- spillerens eget flow nu: kæden må ikke regne det som sit tomme flow (slette/lægge sammen/bemande — review 19/10) changes.chain = "" return {isNew = draft.isNew == true, runId = draft.id, name = draft.name, kind = draft.kind, changes = changes, vehicleIds = {}, wagons = {}, spareWagons = {}, borrow = true} 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), spareWagons = ADFlowGuide.resultSpares(draft)} end -- Vogne for de valgte traktorer (til run.wagons ved gem). function ADFlowGuide.resultWagons(draft) local chosen, wagons = chosenSet(draft.vehicleIds), {} for tractorId, wagonId in pairs(draft.wagons or {}) do if chosen[tractorId] then wagons[tractorId] = wagonId end end 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) local added, removed = {}, {} for _, id in ipairs(newIds or {}) do if not old[id] then table.insert(added, id) end end for _, id in ipairs(oldIds or {}) do if not new[id] then table.insert(removed, id) end end return added, removed end