492 lines
21 KiB
Lua
492 lines
21 KiB
Lua
-- AD Field Guide
|
|
-- "Opsæt mark": markguidens trin oven på ADGuide (ren Lua, ingen spil-API). Kladden er en kopi af
|
|
-- markens plan (+ faste maskiner), så intet ændres før [Gem]. Alt spil-afhængigt kommer i `context`:
|
|
-- {info, sowable = {{name, title}}, mowable = {[name] = true}, straw = {[name] = true} | nil,
|
|
-- rigs = {{id, text, role}}, rigIdsByField = {[fieldId] = ids}, fieldSilos = {{id, text}},
|
|
-- stores = {{id, text}} | nil (nil = markens vare kendes ikke), storeHidden, fields = {{id, text}}}
|
|
-- Rækker er data: {type = "choice"|"toggle"|"check"|"text"|"link", id, title/label, ...}; GUI'et tegner dem.
|
|
|
|
ADFieldGuide = {}
|
|
|
|
ADFieldGuide.ORDER = {"field", "crop", "cropChoice", "prep", "care", "machines", "store", "summary"}
|
|
ADFieldGuide.SOIL_VALUES = {"auto", "cultivate", "plow", "none"}
|
|
ADFieldGuide.STRAW_VALUES = {"chop", "collect", "bale"}
|
|
|
|
local function L(key, args) return {key = key, args = args} end
|
|
local function T(text) return {text = text} end
|
|
local YES_NO = {off = L("ui_no"), on = L("ui_yes")}
|
|
|
|
-- ---- afledte egenskaber ----
|
|
|
|
local function target(draft)
|
|
return draft.plan ~= nil and draft.plan.targetFruit or ""
|
|
end
|
|
|
|
local function isMowable(context, name)
|
|
return name ~= nil and name ~= "" and (context.mowable or {})[name] == true
|
|
end
|
|
|
|
-- Ukendt halm-tabel (tom/nil): alle høstafgrøder regnes med halm (som før guiden).
|
|
local function hasStraw(context, name)
|
|
if context.straw == nil or next(context.straw) == nil then return true end
|
|
return name ~= nil and context.straw[name] == true
|
|
end
|
|
|
|
local function info(guide) return guide.context.info or {} end
|
|
|
|
local function mowOptions(guide)
|
|
local t = target(guide.draft)
|
|
return info(guide).kind == "mowable" or isMowable(guide.context, t)
|
|
end
|
|
|
|
local function strawOptions(guide)
|
|
local t, i = target(guide.draft), info(guide)
|
|
if t ~= "" then
|
|
if isMowable(guide.context, t) then return false end
|
|
return hasStraw(guide.context, t)
|
|
end
|
|
return i.kind == "harvest" and hasStraw(guide.context, i.fruitName)
|
|
end
|
|
|
|
-- Der høstes (mejetærsker + aflæsningsvogne) nu eller senere.
|
|
local function harvestInvolved(guide)
|
|
local t = target(guide.draft)
|
|
return info(guide).kind == "harvest" or (t ~= "" and not isMowable(guide.context, t))
|
|
end
|
|
|
|
local function prepVisible(guide)
|
|
local t, i = target(guide.draft), info(guide)
|
|
return i.kind ~= "mowable" or (t ~= "" and t ~= i.fruitName)
|
|
end
|
|
|
|
local function careVisible(guide)
|
|
return info(guide).kind ~= "bare" or target(guide.draft) ~= ""
|
|
end
|
|
|
|
-- Ukrudt giver kun mening på afgrøder der ikke slås (samme regel som før).
|
|
local function weedVisible(guide)
|
|
local t = target(guide.draft)
|
|
if t ~= "" then return not isMowable(guide.context, t) end
|
|
return info(guide).kind ~= "mowable"
|
|
end
|
|
|
|
local VISIBLE = {
|
|
field = function(guide) return guide.draft.pickField == true end,
|
|
crop = function(guide) return guide.draft.fieldId ~= nil end,
|
|
cropChoice = function(guide) return guide.draft.fieldId ~= nil and (mowOptions(guide) or strawOptions(guide)) end,
|
|
prep = function(guide) return guide.draft.fieldId ~= nil and prepVisible(guide) end,
|
|
care = function(guide) return guide.draft.fieldId ~= nil and careVisible(guide) end,
|
|
machines = function(guide) return guide.draft.fieldId ~= nil end,
|
|
store = function(guide) return guide.draft.fieldId ~= nil and guide.context.stores ~= nil and info(guide).kind ~= "bare" end,
|
|
summary = function(guide) return guide.draft.fieldId ~= nil end,
|
|
}
|
|
|
|
function ADFieldGuide.isVisible(step, guide)
|
|
local rule = VISIBLE[step]
|
|
return rule ~= nil and rule(guide) == true
|
|
end
|
|
|
|
ADFieldGuide.DEF = {order = ADFieldGuide.ORDER, isVisible = ADFieldGuide.isVisible}
|
|
|
|
function ADFieldGuide.stepKey(step) return "spu_guide_field_step_" .. tostring(step) end
|
|
function ADFieldGuide.hintKey(step) return "spu_guide_field_hint_" .. tostring(step) end
|
|
|
|
-- ---- kladde ----
|
|
|
|
local function isPrepAuto(plan)
|
|
return (plan.soil or "auto") == "auto" and plan.mulch ~= true and plan.lime ~= false and plan.roll ~= true
|
|
end
|
|
|
|
-- Pleje "Automatisk" = al pleje slået til (gødning, ukrudt, kalk). Kalk tæller kun her når den ikke hører
|
|
-- under klargøring — ellers afgør klargøringens valg den.
|
|
local function isCareAuto(plan)
|
|
return plan.fertilize ~= false and plan.weed ~= false and plan.lime ~= false
|
|
end
|
|
|
|
local function storeModeOf(ids, fieldSilos)
|
|
if #ids == 0 then return "auto" end
|
|
local silo = {}
|
|
for _, entry in ipairs(fieldSilos or {}) do silo[entry.id] = true end
|
|
for _, id in ipairs(ids) do
|
|
if not silo[id] then return "manual" end
|
|
end
|
|
return "fieldSilo"
|
|
end
|
|
|
|
local function draftFrom(field, context)
|
|
local plan = ADGuide.deepCopy(field.plan or {})
|
|
plan.storeBuildingIds = plan.storeBuildingIds or {}
|
|
plan.rigIds = plan.rigIds or {}
|
|
local mode = storeModeOf(plan.storeBuildingIds, context.fieldSilos)
|
|
return {
|
|
fieldId = field.id, plan = plan, originalTarget = plan.targetFruit or "",
|
|
prepAuto = isPrepAuto(plan), careAuto = isCareAuto(plan), useDedicated = #plan.rigIds > 0,
|
|
storeMode = mode, storeIds = mode == "manual" and ADGuide.deepCopy(plan.storeBuildingIds) or {},
|
|
}
|
|
end
|
|
|
|
function ADFieldGuide.open(field, context, options)
|
|
return ADGuide.new(ADFieldGuide.DEF, draftFrom(field, context), context, options)
|
|
end
|
|
|
|
-- Guiden åbnet uden valgt mark: trin 1 "Mark".
|
|
function ADFieldGuide.openPicker(context)
|
|
return ADGuide.new(ADFieldGuide.DEF, {pickField = true}, context, {step = "field"})
|
|
end
|
|
|
|
-- Mark valgt i trin 1: kladden bygges fra markens plan; trin 1 tæller stadig med.
|
|
function ADFieldGuide.pickField(guide, field, context)
|
|
local draft = draftFrom(field, context)
|
|
draft.pickField = true
|
|
local picked = ADGuide.withContext(ADGuide.withDraft(guide, draft), context)
|
|
return (ADGuide.next(picked))
|
|
end
|
|
|
|
-- ---- valg ----
|
|
|
|
local PLAN_VALUES = {
|
|
targetFruit = true, sow = true, rake = true, mulch = true, lime = true, roll = true,
|
|
fertilize = true, weed = true, straw = true, chainFree = true, soil = true, rigs = true, unloaders = true,
|
|
}
|
|
|
|
function ADFieldGuide.choose(guide, id, value)
|
|
local draft = ADGuide.deepCopy(guide.draft)
|
|
if PLAN_VALUES[id] then
|
|
draft.plan[id] = value
|
|
elseif id == "product" then
|
|
draft.plan.product = value and "hay" or "silage"
|
|
elseif id == "prepAuto" or id == "careAuto" or id == "useDedicated" then
|
|
draft[id] = value == true
|
|
elseif id == "rigIds" then
|
|
draft.plan.rigIds = ADGuide.toggleItem(draft.plan.rigIds, value.item, value.on)
|
|
elseif id == "useFieldSilo" then
|
|
draft.storeMode = value and "fieldSilo" or "auto"
|
|
elseif id == "storeAuto" then
|
|
draft.storeMode = value and "auto" or "manual"
|
|
elseif id == "storeBuildingIds" then
|
|
draft.storeIds = ADGuide.toggleItem(draft.storeIds, value.item, value.on)
|
|
else
|
|
return guide
|
|
end
|
|
return ADGuide.withDraft(guide, draft)
|
|
end
|
|
|
|
-- ---- rækker pr. trin ----
|
|
|
|
local function numberOptions(from, to)
|
|
local options = {}
|
|
for value = from, to do table.insert(options, {label = T(tostring(value)), value = value}) end
|
|
return options
|
|
end
|
|
|
|
local function choice(id, title, options, value)
|
|
return {type = "choice", id = id, title = title, options = options, value = value}
|
|
end
|
|
|
|
local function toggle(id, title, value, off, on)
|
|
return {type = "toggle", id = id, title = title, off = off or YES_NO.off, on = on or YES_NO.on, value = value == true}
|
|
end
|
|
|
|
local function rowsField(guide)
|
|
local rows = {}
|
|
for _, entry in ipairs(guide.context.fields or {}) do
|
|
table.insert(rows, {type = "link", id = "field", value = entry.id, label = T(entry.text)})
|
|
end
|
|
if #rows == 0 then table.insert(rows, {type = "text", label = L("spu_field_scanning")}) end
|
|
return rows
|
|
end
|
|
|
|
local function rowsCrop(guide)
|
|
local plan = guide.draft.plan
|
|
local options = {{label = L("spu_guide_crop_keep"), value = ""}}
|
|
for _, fruit in ipairs(guide.context.sowable or {}) do
|
|
table.insert(options, {label = T(fruit.title), value = fruit.name})
|
|
end
|
|
local rows = {choice("targetFruit", L("spu_guide_crop"), options, plan.targetFruit or "")}
|
|
if target(guide.draft) == "" and info(guide).kind ~= "mowable" then
|
|
table.insert(rows, toggle("sow", L("spu_guide_crop_sowAgain"), plan.sow))
|
|
end
|
|
table.insert(rows, toggle("chainFree", L("spu_field_chainFree"), plan.chainFree))
|
|
return rows
|
|
end
|
|
|
|
local function rowsCropChoice(guide)
|
|
local plan, rows = guide.draft.plan, {}
|
|
if mowOptions(guide) then
|
|
table.insert(rows, toggle("product", L("spu_field_plan"), ADFieldModel.product(plan, "mowable") == "hay",
|
|
L("spu_field_plan_silage"), L("spu_field_plan_hay")))
|
|
table.insert(rows, toggle("rake", L("spu_field_rake"), plan.rake))
|
|
end
|
|
if strawOptions(guide) then
|
|
local options = {}
|
|
for _, value in ipairs(ADFieldGuide.STRAW_VALUES) do
|
|
table.insert(options, {label = L("spu_field_straw_" .. value), value = value})
|
|
end
|
|
table.insert(rows, choice("straw", L("spu_field_straw"), options, plan.straw or "chop"))
|
|
end
|
|
return rows
|
|
end
|
|
|
|
local function rowsPrep(guide)
|
|
local draft, plan = guide.draft, guide.draft.plan
|
|
local rows = {choice("prepAuto", L("spu_guide_prep"), {
|
|
{label = L("spu_guide_auto"), value = true}, {label = L("spu_guide_manual"), value = false}}, draft.prepAuto)}
|
|
if draft.prepAuto then
|
|
table.insert(rows, {type = "text", label = L("spu_guide_prep_autoText")})
|
|
return rows
|
|
end
|
|
local soil = {}
|
|
for _, value in ipairs(ADFieldGuide.SOIL_VALUES) do
|
|
table.insert(soil, {label = L("spu_field_soil_" .. value), value = value})
|
|
end
|
|
table.insert(rows, choice("soil", L("spu_field_soil"), soil, plan.soil or "auto"))
|
|
table.insert(rows, toggle("lime", L("spu_field_lime"), plan.lime ~= false))
|
|
table.insert(rows, toggle("mulch", L("spu_field_mulch"), plan.mulch))
|
|
if target(draft) ~= "" or plan.sow then
|
|
table.insert(rows, toggle("roll", L("spu_field_roll"), plan.roll))
|
|
end
|
|
return rows
|
|
end
|
|
|
|
local function rowsCare(guide)
|
|
local draft, plan = guide.draft, guide.draft.plan
|
|
local rows = {choice("careAuto", L("spu_guide_care"), {
|
|
{label = L("spu_guide_auto"), value = true}, {label = L("spu_guide_manual"), value = false}}, draft.careAuto)}
|
|
if draft.careAuto then
|
|
table.insert(rows, {type = "text", label = L("spu_guide_care_autoText")})
|
|
return rows
|
|
end
|
|
table.insert(rows, toggle("fertilize", L("spu_field_fertilize"), plan.fertilize ~= false))
|
|
if weedVisible(guide) then table.insert(rows, toggle("weed", L("spu_field_weed"), plan.weed ~= false)) end
|
|
if not prepVisible(guide) then table.insert(rows, toggle("lime", L("spu_field_lime"), plan.lime ~= false)) end
|
|
return rows
|
|
end
|
|
|
|
-- Faste maskiner: kun ledige og dem der allerede er faste her; faste på andre marker skjules med en linje.
|
|
local function dedicatedRows(guide)
|
|
local draft, rows = guide.draft, {}
|
|
local byField = {}
|
|
for fieldId, ids in pairs(guide.context.rigIdsByField or {}) do byField[fieldId] = ids end
|
|
byField[draft.fieldId] = draft.plan.rigIds
|
|
local own = {}
|
|
for _, id in ipairs(draft.plan.rigIds) do own[id] = true end
|
|
local visible, hidden, fields = ADFieldFleet.visibleForField(guide.context.rigs or {}, draft.fieldId, byField)
|
|
local sorted = {}
|
|
for _, rig in ipairs(visible) do table.insert(sorted, rig) end
|
|
table.sort(sorted, function(a, b)
|
|
if (own[a.id] == true) ~= (own[b.id] == true) then return own[a.id] == true end
|
|
if (a.role or "") ~= (b.role or "") then return (a.role or "") < (b.role or "") end
|
|
return ADFlowView.naturalLess(tostring(a.text), tostring(b.text))
|
|
end)
|
|
for _, rig in ipairs(sorted) do
|
|
table.insert(rows, {type = "check", id = "rigIds", item = rig.id, title = T(rig.text), value = own[rig.id] == true})
|
|
end
|
|
if #sorted == 0 then table.insert(rows, {type = "text", label = L("spu_field_noRigs")}) end
|
|
if hidden > 0 then
|
|
local names = {}
|
|
for _, fieldId in ipairs(fields) do table.insert(names, "F" .. tostring(fieldId)) end
|
|
table.insert(rows, {type = "text", label = L("spu_field_hiddenDedicated", {hidden, table.concat(names, ", ")})})
|
|
end
|
|
return rows
|
|
end
|
|
|
|
local function rowsMachines(guide)
|
|
local draft, plan = guide.draft, guide.draft.plan
|
|
local rows = {choice("rigs", L("spu_guide_rigs"), numberOptions(1, ADFieldModel.MAX_RIGS), plan.rigs or 1)}
|
|
if harvestInvolved(guide) then
|
|
table.insert(rows, choice("unloaders", L("spu_field_unloaders"), numberOptions(1, ADFieldModel.MAX_UNLOADERS), plan.unloaders or 1))
|
|
end
|
|
table.insert(rows, toggle("useDedicated", L("spu_guide_dedicated"), draft.useDedicated))
|
|
if draft.useDedicated then
|
|
for _, row in ipairs(dedicatedRows(guide)) do table.insert(rows, row) end
|
|
end
|
|
return rows
|
|
end
|
|
|
|
local function rowsStore(guide)
|
|
local draft, context, rows = guide.draft, guide.context, {}
|
|
local silos = context.fieldSilos or {}
|
|
if #silos > 0 then
|
|
local names = {}
|
|
for _, silo in ipairs(silos) do table.insert(names, silo.text) end
|
|
table.insert(rows, toggle("useFieldSilo", L("spu_guide_useFieldSilo"), draft.storeMode == "fieldSilo"))
|
|
table.insert(rows, {type = "text", label = T(" " .. table.concat(names, ", "))})
|
|
if draft.storeMode == "fieldSilo" then return rows end
|
|
end
|
|
table.insert(rows, choice("storeAuto", L("spu_guide_store"), {
|
|
{label = L("spu_guide_auto"), value = true}, {label = L("spu_guide_manual"), value = false}}, draft.storeMode ~= "manual"))
|
|
if draft.storeMode ~= "manual" then
|
|
table.insert(rows, {type = "text", label = L("spu_guide_store_autoText")})
|
|
return rows
|
|
end
|
|
local chosen = {}
|
|
for _, id in ipairs(draft.storeIds) do chosen[id] = true end
|
|
for _, store in ipairs(context.stores or {}) do
|
|
table.insert(rows, {type = "check", id = "storeBuildingIds", item = store.id, title = T(store.text), value = chosen[store.id] == true})
|
|
end
|
|
if #(context.stores or {}) == 0 then table.insert(rows, {type = "text", label = L("spu_field_noStore")}) end
|
|
if (context.storeHidden or 0) > 0 then
|
|
table.insert(rows, {type = "text", label = L("spu_field_storeHidden", {context.storeHidden})})
|
|
end
|
|
return rows
|
|
end
|
|
|
|
local function rowsSummary(guide)
|
|
local rows = {}
|
|
for _, line in ipairs(ADFieldGuide.summary(guide)) do
|
|
table.insert(rows, {type = "link", id = "jump", value = line.step, line = line})
|
|
end
|
|
return rows
|
|
end
|
|
|
|
local ROWS = {
|
|
field = rowsField, crop = rowsCrop, cropChoice = rowsCropChoice, prep = rowsPrep, care = rowsCare,
|
|
machines = rowsMachines, store = rowsStore, summary = rowsSummary,
|
|
}
|
|
|
|
function ADFieldGuide.rows(guide)
|
|
local builder = ROWS[guide.step]
|
|
return builder ~= nil and builder(guide) or {}
|
|
end
|
|
|
|
-- ---- resumé ----
|
|
|
|
local function fruitTitle(context, name)
|
|
for _, fruit in ipairs(context.sowable or {}) do
|
|
if fruit.name == name then return fruit.title end
|
|
end
|
|
return tostring(name)
|
|
end
|
|
|
|
local function storeText(guide)
|
|
local draft, context = guide.draft, guide.context
|
|
if draft.storeMode == "fieldSilo" then return {L("spu_guide_sum_fieldSilo")} end
|
|
if draft.storeMode ~= "manual" or #draft.storeIds == 0 then return {L("spu_guide_sum_auto")} end
|
|
local names = {}
|
|
for _, id in ipairs(draft.storeIds) do
|
|
for _, store in ipairs(context.stores or {}) do
|
|
if store.id == id then table.insert(names, store.text) end
|
|
end
|
|
end
|
|
if #names == 0 or #names > 2 or #names ~= #draft.storeIds then
|
|
return {L("spu_guide_sum_stores", {#draft.storeIds})}
|
|
end
|
|
return {T(table.concat(names, " + "))}
|
|
end
|
|
|
|
local SUMMARY = {
|
|
crop = function(guide)
|
|
local plan, t = guide.draft.plan, target(guide.draft)
|
|
if t ~= "" then return {L("spu_guide_sum_target", {fruitTitle(guide.context, t)})} end
|
|
local parts = {L("spu_guide_crop_keep")}
|
|
if plan.sow and info(guide).kind ~= "mowable" then table.insert(parts, L("spu_guide_sum_sowAgain")) end
|
|
return parts
|
|
end,
|
|
cropChoice = function(guide)
|
|
local plan, parts = guide.draft.plan, {}
|
|
if mowOptions(guide) then
|
|
table.insert(parts, L(ADFieldModel.product(plan, "mowable") == "hay" and "spu_field_plan_hay" or "spu_field_plan_silage"))
|
|
table.insert(parts, L(plan.rake and "spu_guide_sum_rake" or "spu_guide_sum_noRake"))
|
|
end
|
|
if strawOptions(guide) then table.insert(parts, L("spu_guide_sum_straw_" .. (plan.straw or "chop"))) end
|
|
return parts
|
|
end,
|
|
prep = function(guide)
|
|
local plan = guide.draft.plan
|
|
if guide.draft.prepAuto then return {L("spu_guide_sum_auto")} end
|
|
local parts = {L("spu_field_soil_" .. (plan.soil or "auto"))}
|
|
if plan.lime ~= false then table.insert(parts, L("spu_guide_sum_lime")) end
|
|
if plan.mulch then table.insert(parts, L("spu_guide_sum_mulch")) end
|
|
if plan.roll and (plan.sow or target(guide.draft) ~= "") then table.insert(parts, L("spu_guide_sum_roll")) end
|
|
return parts
|
|
end,
|
|
care = function(guide)
|
|
if guide.draft.careAuto then return {L("spu_guide_sum_auto")} end
|
|
local plan, parts = guide.draft.plan, {}
|
|
if plan.fertilize ~= false then table.insert(parts, L("spu_guide_sum_fert")) end
|
|
if weedVisible(guide) and plan.weed ~= false then table.insert(parts, L("spu_guide_sum_weed")) end
|
|
if not prepVisible(guide) and plan.lime ~= false then table.insert(parts, L("spu_guide_sum_lime")) end
|
|
if #parts == 0 then parts = {L("spu_guide_sum_noCare")} end
|
|
return parts
|
|
end,
|
|
machines = function(guide)
|
|
local draft, plan = guide.draft, guide.draft.plan
|
|
local parts = {}
|
|
if draft.useDedicated and #plan.rigIds > 0 then
|
|
table.insert(parts, L("spu_guide_sum_dedicated", {#plan.rigIds}))
|
|
else
|
|
table.insert(parts, L("spu_guide_sum_freeRigs"))
|
|
end
|
|
table.insert(parts, L("spu_guide_sum_rigs", {plan.rigs or 1}))
|
|
if harvestInvolved(guide) then table.insert(parts, L("spu_guide_sum_unloaders", {plan.unloaders or 1})) end
|
|
return parts
|
|
end,
|
|
store = storeText,
|
|
}
|
|
|
|
-- Resumé-linjer {step, title, parts} for de synlige trin (ikke "Mark" og "Oversigt").
|
|
function ADFieldGuide.summary(guide)
|
|
local lines = {}
|
|
for _, step in ipairs(ADGuide.visibleSteps(guide)) do
|
|
local build = SUMMARY[step]
|
|
if build ~= nil then
|
|
table.insert(lines, {step = step, title = L(ADFieldGuide.stepKey(step)), parts = build(guide)})
|
|
end
|
|
end
|
|
return lines
|
|
end
|
|
|
|
-- ---- gem ----
|
|
|
|
-- start: true = [Kør automatisk], false = [Gem uden at starte], nil = [Ret] (tilstanden bevares).
|
|
-- Mål-afgrøde kører altid automatisk (ADFieldModel.setTarget).
|
|
function ADFieldGuide.result(guide, start)
|
|
local draft = guide.draft
|
|
local plan = ADGuide.deepCopy(draft.plan)
|
|
-- kilden ejes af setTarget; kladdens gamle værdi må ikke overskrive den
|
|
plan.targetSource = nil
|
|
local t = plan.targetFruit or ""
|
|
if t ~= "" then
|
|
plan.mode = "auto"
|
|
elseif start ~= nil then
|
|
plan.mode = start and "auto" or "manual"
|
|
end
|
|
if draft.prepAuto and ADFieldGuide.isVisible("prep", guide) then
|
|
plan.soil, plan.mulch, plan.lime, plan.roll = "auto", false, true, false
|
|
end
|
|
if draft.careAuto and ADFieldGuide.isVisible("care", guide) then
|
|
plan.fertilize, plan.weed = true, true
|
|
if not prepVisible(guide) then plan.lime = true end
|
|
end
|
|
if ADFieldGuide.isVisible("store", guide) then
|
|
if draft.storeMode == "fieldSilo" then
|
|
local ids = {}
|
|
for _, silo in ipairs(guide.context.fieldSilos or {}) do table.insert(ids, silo.id) end
|
|
plan.storeBuildingIds = ids
|
|
elseif draft.storeMode == "manual" then
|
|
plan.storeBuildingIds = ADGuide.deepCopy(draft.storeIds)
|
|
else
|
|
plan.storeBuildingIds = {}
|
|
end
|
|
end
|
|
local rigIds = draft.useDedicated and ADGuide.deepCopy(plan.rigIds) or {}
|
|
plan.rigIds = nil
|
|
return {fieldId = draft.fieldId, targetFruit = t, targetChanged = t ~= (draft.originalTarget or ""), plan = plan, rigIds = rigIds}
|
|
end
|
|
|
|
-- Faste maskiner for alle marker efter gem: marken får rigIds, og de fjernes fra andre marker.
|
|
function ADFieldGuide.applyRigs(rigIdsByField, fieldId, rigIds)
|
|
local mine = {}
|
|
for _, id in ipairs(rigIds or {}) do mine[id] = true end
|
|
local result = {}
|
|
for otherId, ids in pairs(rigIdsByField or {}) do
|
|
if otherId ~= fieldId then
|
|
local copy = {}
|
|
for _, id in ipairs(ids or {}) do if not mine[id] then table.insert(copy, id) end end
|
|
result[otherId] = copy
|
|
end
|
|
end
|
|
result[fieldId] = ADGuide.deepCopy(rigIds or {})
|
|
return result
|
|
end
|