145 lines
7.6 KiB
Lua
145 lines
7.6 KiB
Lua
-- AD Crop Plan (ren logik)
|
||
-- Mangel pr. afgrøde over 12 måneder (lager + forventet høst mod kædens behov) og valg af marker der skal skifte
|
||
-- målafgrøde: "fri til kæden" -> auto, ellers forslag. Brugerens egen målafgrøde ændres aldrig automatisk.
|
||
|
||
ADCropPlan = {}
|
||
ADCropPlan.HORIZON_MONTHS = 12
|
||
ADCropPlan.MIN_SHARE = 0.10
|
||
ADCropPlan.MIN_HA = 0.5
|
||
-- højst så mange forslag (ikke auto-skift) pr. afgrøde, så listen ikke vokser til snesevis af rækker
|
||
ADCropPlan.MAX_SUGGEST_PER_FRUIT = 3
|
||
|
||
function ADCropPlan.plannedFruit(field)
|
||
if field.targetFruit ~= nil and field.targetFruit ~= "" then return field.targetFruit end
|
||
return field.fruit
|
||
end
|
||
|
||
-- Markens produkt for slåafgrøder: "auto" (standard) er ensilage.
|
||
function ADCropPlan.fieldProduct(field)
|
||
local product = field.product
|
||
if product == nil or product == "" or product == "auto" then return "silage" end
|
||
return product
|
||
end
|
||
|
||
-- Afgrøder der gror igen efter slæt (græs, kløver, lucerne) høstes flere gange om året; yields er ét slæt
|
||
-- (in-game 17/10: hø-behov 207 ha -> 20 marker til græs). Forsigtigt skøn — hellere lidt for meget græs.
|
||
ADCropPlan.REGROW_CUTS_PER_YEAR = 3
|
||
|
||
-- Høst pr. år for afgrøden (navn): 1, eller REGROW_CUTS_PER_YEAR når den gror igen. Ukendt = 1.
|
||
function ADCropPlan.cutsPerYear(fruitName)
|
||
-- vin, oliven, poppel gror også igen, men høstes én gang om året
|
||
if ADChainData ~= nil and ADChainData.isPermanent ~= nil and ADChainData.isPermanent(fruitName) then return 1 end
|
||
local fruit = g_fruitTypeManager ~= nil and fruitName ~= nil and g_fruitTypeManager:getFruitTypeByName(fruitName) or nil
|
||
return fruit ~= nil and fruit.regrows == true and ADCropPlan.REGROW_CUTS_PER_YEAR or 1
|
||
end
|
||
|
||
-- demand/stock/yields er pr. afgrøde, eller pr. markvare når products[nøgle] = {fruit, product} (hø = græs med
|
||
-- produkt hø): så tæller kun marker med samme afgrøde OG produkt som udbud, og manglen bærer afgrøde + produkt.
|
||
-- cutsOf(afgrøde) -> høst pr. år (nil = ADCropPlan.cutsPerYear): udbyttet pr. ha og år = yields × høst.
|
||
function ADCropPlan.shortages(demand, stock, fields, yields, products, cutsOf)
|
||
local list = {}
|
||
local cutsFor = cutsOf or ADCropPlan.cutsPerYear
|
||
for key, perMonth in pairs(demand or {}) do
|
||
local spec = (products or {})[key]
|
||
local fruit, product = spec ~= nil and spec.fruit or key, spec ~= nil and spec.product or nil
|
||
local perHa = ((yields or {})[key] or 0) * math.max(1, cutsFor(fruit) or 1)
|
||
if perHa > 0 and (perMonth or 0) > 0 then
|
||
local need = perMonth * ADCropPlan.HORIZON_MONTHS
|
||
local supply = (stock or {})[key] or 0
|
||
for _, field in ipairs(fields or {}) do
|
||
local planned = ADCropPlan.plannedFruit(field)
|
||
-- andre afgrøder med samme vindue (eng) tæller også som udbud
|
||
local sameCrop = planned == fruit or (spec ~= nil and spec.fruits ~= nil and planned ~= nil and spec.fruits[planned] == true)
|
||
if sameCrop and (product == nil or ADCropPlan.fieldProduct(field) == product) then
|
||
supply = supply + (field.areaHa or 0) * perHa
|
||
end
|
||
end
|
||
local missing = need - supply
|
||
local missingHa = missing / perHa
|
||
if missing > need * ADCropPlan.MIN_SHARE and missingHa > ADCropPlan.MIN_HA then
|
||
table.insert(list, {fruit = fruit, product = product, key = key, needLiters = need, supplyLiters = supply,
|
||
missingLiters = missing, missingHa = missingHa})
|
||
end
|
||
end
|
||
end
|
||
table.sort(list, function(a, b)
|
||
if a.missingHa ~= b.missingHa then return a.missingHa > b.missingHa end
|
||
return a.key < b.key
|
||
end)
|
||
return list
|
||
end
|
||
|
||
local function isCandidate(field, used, dismissedFruit, fruit)
|
||
if field.permanent or field.excluded then return false end
|
||
local planned = ADCropPlan.plannedFruit(field)
|
||
if planned ~= nil and planned ~= "" and used[planned] then return false end
|
||
return dismissedFruit ~= fruit
|
||
end
|
||
|
||
-- prices: {[afgrøde] = pris} eller en funktion afgrøde -> pris (slås kun op for kandidaternes afgrøder).
|
||
-- harvesting = {[afgrøde] = true}: afgrøder der høstes lige nu — ingen forslag/skift for dem (læssene er på vej).
|
||
function ADCropPlan.choose(shortages, fields, usedFruits, yields, prices, dismissed, harvesting)
|
||
local actions, taken = {}, {}
|
||
local used = usedFruits or {}
|
||
local priceOf = type(prices) == "function" and prices or function(fruit) return (prices or {})[fruit] or 0 end
|
||
local priceCache = {}
|
||
local function valueOf(fruit)
|
||
if fruit == "" then return 0 end
|
||
if priceCache[fruit] == nil then priceCache[fruit] = ((yields or {})[fruit] or 0) * (priceOf(fruit) or 0) end
|
||
return priceCache[fruit]
|
||
end
|
||
for _, shortage in ipairs(shortages or {}) do
|
||
local remaining = (harvesting or {})[shortage.fruit] and 0 or shortage.missingHa
|
||
local candidates = {}
|
||
for _, field in ipairs(fields or {}) do
|
||
-- afvisninger gemmes pr. nøgle (afgrøden, eller varen for hø/ensilage), så hø og ensilage ikke blandes
|
||
if not taken[field.id] and isCandidate(field, used, (dismissed or {})[field.id], shortage.key or shortage.fruit) then
|
||
local planned = ADCropPlan.plannedFruit(field) or ""
|
||
local value = valueOf(planned)
|
||
table.insert(candidates, {field = field, value = value})
|
||
end
|
||
end
|
||
table.sort(candidates, function(a, b)
|
||
if a.value ~= b.value then return a.value < b.value end
|
||
local da, db = math.abs((a.field.areaHa or 0) - remaining), math.abs((b.field.areaHa or 0) - remaining)
|
||
if da ~= db then return da < db end
|
||
return a.field.id < b.field.id
|
||
end)
|
||
local suggested = 0
|
||
for _, candidate in ipairs(candidates) do
|
||
if remaining <= 0 then break end
|
||
local field = candidate.field
|
||
-- en mark slået fra i marklisten skiftes aldrig selv — den foreslås i stedet (godkend = slå til)
|
||
local auto = field.chainFree == true and field.targetSource ~= "user" and field.enabled ~= false
|
||
if auto or suggested < ADCropPlan.MAX_SUGGEST_PER_FRUIT then
|
||
table.insert(actions, {fieldId = field.id, from = ADCropPlan.plannedFruit(field) or "", to = shortage.fruit,
|
||
product = shortage.product, hectares = field.areaHa or 0, reason = shortage.key or shortage.fruit,
|
||
mode = auto and "auto" or "suggest"})
|
||
taken[field.id] = true
|
||
remaining = remaining - (field.areaHa or 0)
|
||
if not auto then suggested = suggested + 1 end
|
||
end
|
||
end
|
||
end
|
||
return actions
|
||
end
|
||
|
||
-- Mangler, som markerne ikke kan dække: manglende ha minus det, de valgte marker (auto + forslag) giver. Over MIN_HA
|
||
-- tilbage = advarsel "ikke marker nok" (brugerønske 8/10). -> {{key, fruit, product, missingHa, coveredHa}}
|
||
function ADCropPlan.uncovered(shortages, actions)
|
||
local covered = {}
|
||
for _, action in ipairs(actions or {}) do
|
||
local key = action.reason or action.to
|
||
covered[key] = (covered[key] or 0) + (action.hectares or 0)
|
||
end
|
||
local list = {}
|
||
for _, shortage in ipairs(shortages or {}) do
|
||
local key = shortage.key or shortage.fruit
|
||
local left = (shortage.missingHa or 0) - (covered[key] or 0)
|
||
if left > ADCropPlan.MIN_HA then
|
||
table.insert(list, {key = key, fruit = shortage.fruit, product = shortage.product, missingHa = left, coveredHa = covered[key] or 0})
|
||
end
|
||
end
|
||
return list
|
||
end
|