249 lines
10 KiB
Lua
249 lines
10 KiB
Lua
-- AD Supply Planner
|
|
-- Rene funktioner (ingen spil-API) til behovsstyret forsyning: hvilken ingrediens
|
|
-- har aflæsningsmålet mest brug for, og hvilken ingrediensliste gælder for køretøjet.
|
|
|
|
ADSupplyPlanner = {}
|
|
|
|
-- Mindre fri plads end dette i målet regnes som "fuldt" (undgår ture med læs der ikke kan komme af).
|
|
ADSupplyPlanner.MIN_FREE_LITERS = 1000
|
|
|
|
-- Varer hvis kilder LØBER FULDE (dyr/produktion fylder tanken løbende og går i stå
|
|
-- når den er fuld): her hentes den fyldeste kilde først. Alt andet er lagervarer,
|
|
-- hvor den mindst fyldte silo tømmes først så rester ryddes og siloer frigives.
|
|
ADSupplyPlanner.FULLEST_FIRST_FILL_TYPES = {
|
|
MILK = true, GOATMILK = true, BUFFALOMILK = true, SHEEPMILK = true,
|
|
LIQUIDMANURE = true, DIGESTATE = true,
|
|
}
|
|
|
|
-- fillTypeNames: navnene på de varer der hentes på turen. Kun når ALLE er
|
|
-- "løber fuld"-varer vendes strategien; blandet eller ukendt valg = mindst først.
|
|
function ADSupplyPlanner.prefersFullestSource(fillTypeNames)
|
|
if #fillTypeNames == 0 then
|
|
return false
|
|
end
|
|
for _, name in ipairs(fillTypeNames) do
|
|
if not ADSupplyPlanner.FULLEST_FIRST_FILL_TYPES[name] then
|
|
return false
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Er en kilde med dette niveau bedre end den hidtil bedste (nil = ingen endnu)?
|
|
function ADSupplyPlanner.isBetterSource(level, bestLevel, prefersFullest)
|
|
if bestLevel == nil then
|
|
return true
|
|
end
|
|
if prefersFullest then
|
|
return level > bestLevel
|
|
end
|
|
return level < bestLevel
|
|
end
|
|
|
|
function ADSupplyPlanner.copyList(list)
|
|
local copy = {}
|
|
for index, value in ipairs(list) do
|
|
copy[index] = value
|
|
end
|
|
return copy
|
|
end
|
|
|
|
-- Ønsker en produktion input? Tændt, eller slukket af kortet fordi den MANGLEDE
|
|
-- input (Dakotas ExtendedProductionPoint slår den fra automatisk, men lader
|
|
-- status stå på MISSING_INPUTS). Manuelt slukket = status INACTIVE -> nej.
|
|
function ADSupplyPlanner.isProductionWanted(isEnabled, status, missingInputsStatus)
|
|
if isEnabled then
|
|
return true
|
|
end
|
|
return status ~= nil and status == missingInputsStatus
|
|
end
|
|
|
|
-- productions: produktionspunktets liste ({id, cyclesPerMinute, inputs = {{type, amount}}}).
|
|
-- isWanted(production) afgør om den tæller; canCarry[fillType] = det vognen kan bære.
|
|
-- Returnerer {[fillType] = liter pr. minut} summeret over ønskede produktioner.
|
|
function ADSupplyPlanner.collectProductionDemand(productions, isWanted, canCarry)
|
|
local demand = {}
|
|
for _, production in ipairs(productions) do
|
|
if isWanted(production) then
|
|
local cyclesPerMinute = production.cyclesPerMinute or 0
|
|
for _, input in ipairs(production.inputs or {}) do
|
|
if canCarry[input.type] then
|
|
demand[input.type] = (demand[input.type] or 0) + (input.amount or 0) * cyclesPerMinute
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return demand
|
|
end
|
|
|
|
-- Er varen et INPUT til fabrikken (og ikke også et output)? Så må den aldrig
|
|
-- hentes derfra — det ville tømme fabrikken for det, den skal bruge.
|
|
function ADSupplyPlanner.isProductionInput(productions, fillType)
|
|
local isInput, isOutput = false, false
|
|
for _, production in ipairs(productions) do
|
|
for _, input in ipairs(production.inputs or {}) do
|
|
if input.type == fillType then isInput = true end
|
|
end
|
|
for _, output in ipairs(production.outputs or {}) do
|
|
if output.type == fillType then isOutput = true end
|
|
end
|
|
end
|
|
return isInput and not isOutput
|
|
end
|
|
|
|
-- Minutter før målets lager af varen er tomt ved nuværende forbrug; nil uden forbrug.
|
|
function ADSupplyPlanner.minutesToEmpty(level, litersPerMinute)
|
|
if litersPerMinute == nil or litersPerMinute <= 0 then
|
|
return nil
|
|
end
|
|
return level / litersPerMinute
|
|
end
|
|
|
|
-- Hvor meget trænger målet til denne ingrediens? Højere = hentes først.
|
|
-- Alle tal er liter i aflæsningsmålets lager. Standard: relativ tomhed (0..1),
|
|
-- så en lille næsten-tom tank vinder over en stor halvfuld. Kendes forbruget
|
|
-- (fabriksstyret), tæller i stedet tid til tom: score i ]1, 2], så varer med
|
|
-- forbrug altid går forud for varer uden, og kortest tid vinder.
|
|
function ADSupplyPlanner.scoreNeed(level, capacity, freeSpace, minutesToEmpty)
|
|
if minutesToEmpty ~= nil then
|
|
return 1 + 1 / (1 + minutesToEmpty)
|
|
end
|
|
if capacity <= 0 then
|
|
return 0
|
|
end
|
|
return freeSpace / capacity
|
|
end
|
|
|
|
-- nil når læs-størrelsen er ukendt, ellers om et fuldt læs kan komme af i målet.
|
|
function ADSupplyPlanner.fullLoadFits(freeSpace, loadCapacity)
|
|
if loadCapacity == nil or loadCapacity <= 0 then
|
|
return nil
|
|
end
|
|
return freeSpace >= loadCapacity
|
|
end
|
|
|
|
-- Wait-punkter: alle markører i en MAPPE med ordet "Wait" i navnet (uanset store/små),
|
|
-- fx mappen "Cow Wait". Her venter en traktor med rest-læs, til der igen er plads i
|
|
-- målet. Markørens eget navn tæller ikke — spillerens mark-ventepladser ("F91 Wait")
|
|
-- ligger i mark-mapperne og hører ikke til puljen.
|
|
function ADSupplyPlanner.isWaitMarker(marker)
|
|
local group = string.lower(tostring(marker.group or ""))
|
|
return string.find(group, "%f[%a]wait%f[%A]") ~= nil
|
|
end
|
|
|
|
-- candidates: {{marker, x, z}}; claims: {[marker.id] = køretøj}. Nærmeste punkt der er
|
|
-- ledigt (eller allerede reserveret af dette køretøj) og som isReachable(candidate)
|
|
-- godkender (valgfri; AutoDrive slukker sig selv, hvis den sendes mod et punkt uden rute).
|
|
-- nil hvis intet punkt duer. Nåelighed tjekkes kun for de punkter der er i spil, nærmeste først.
|
|
function ADSupplyPlanner.pickNearestFreeWaitPoint(candidates, claims, x, z, vehicle, isReachable)
|
|
local free = {}
|
|
for _, candidate in ipairs(candidates) do
|
|
local owner = claims[candidate.marker.id]
|
|
if owner == nil or owner == vehicle then
|
|
local dx, dz = candidate.x - x, candidate.z - z
|
|
table.insert(free, {candidate = candidate, distance = dx * dx + dz * dz})
|
|
end
|
|
end
|
|
table.sort(free, function(a, b) return a.distance < b.distance end)
|
|
for _, entry in ipairs(free) do
|
|
if isReachable == nil or isReachable(entry.candidate) then
|
|
return entry.candidate
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Så stor en andel af målets kapacitet skal være fri, før en rest der er større end
|
|
-- det, kan afleveres (en 700.000 l-vogn kan aldrig tømme HELE resten i en 300.000 l-stald).
|
|
ADSupplyPlanner.WAIT_RETURN_FREE_FRACTION = 0.5
|
|
|
|
-- Kan den ventende køre hjem? Ja når hele resten passer, eller når målet er mindst
|
|
-- freeFraction tomt (standard WAIT_RETURN_FREE_FRACTION; run'ets "kør hjem under X %" =
|
|
-- freeFraction 1 - X/100). capacity nil = kun hele resten tæller.
|
|
function ADSupplyPlanner.canUnloadRest(freeSpace, rest, capacity, freeFraction)
|
|
local needed = rest
|
|
if capacity ~= nil and capacity > 0 then
|
|
needed = math.min(rest, capacity * (freeFraction or ADSupplyPlanner.WAIT_RETURN_FREE_FRACTION))
|
|
end
|
|
return freeSpace >= needed
|
|
end
|
|
|
|
-- needs: {{fillType, level, capacity[, litersPerMinute][, scoreOverride][, priority]}, ...}.
|
|
-- Returnerer NY liste, mest trængende først; ingredienser uden plads i målet er sorteret fra.
|
|
-- loadCapacity (valgfri): vognens kapacitet — varer hvor et FULDT læs kan komme af
|
|
-- går forud (så vognen ikke ender med rest-læs); passer intet, gælder ren trang.
|
|
-- scoreOverride: varer der deler ét lager (staldens fodertrug) får trugets fælles score,
|
|
-- så truget konkurrerer som ÉN trang; priority (fx spillets fodervægt: TMR 1,0 > hø 0,8 >
|
|
-- græs 0,4) afgør så rækkefølgen inden for lageret.
|
|
function ADSupplyPlanner.rankNeeds(needs, loadCapacity)
|
|
local ranked = {}
|
|
for _, need in ipairs(needs) do
|
|
local freeSpace = need.capacity - need.level
|
|
if freeSpace >= ADSupplyPlanner.MIN_FREE_LITERS then
|
|
local minutesToEmpty = ADSupplyPlanner.minutesToEmpty(need.level, need.litersPerMinute)
|
|
table.insert(ranked, {
|
|
fillType = need.fillType,
|
|
level = need.level,
|
|
capacity = need.capacity,
|
|
freeSpace = freeSpace,
|
|
litersPerMinute = need.litersPerMinute,
|
|
minutesToEmpty = minutesToEmpty,
|
|
fits = ADSupplyPlanner.fullLoadFits(freeSpace, loadCapacity),
|
|
score = need.scoreOverride or ADSupplyPlanner.scoreNeed(need.level, need.capacity, freeSpace, minutesToEmpty),
|
|
priority = need.priority or 0,
|
|
trough = need.scoreOverride ~= nil,
|
|
})
|
|
end
|
|
end
|
|
table.sort(ranked, function(a, b)
|
|
if a.fits ~= b.fits then
|
|
return a.fits == true
|
|
end
|
|
if a.score ~= b.score then
|
|
return a.score > b.score
|
|
end
|
|
if a.priority ~= b.priority then
|
|
return a.priority > b.priority
|
|
end
|
|
return a.fillType < b.fillType
|
|
end)
|
|
return ranked
|
|
end
|
|
|
|
-- ---- bedste foder først ----
|
|
-- Foder i et stald-trug deler plads. Lavere foder (ensilage/hø, vægt 0,8) må kun hentes når der er
|
|
-- bedre foder (TMR, 1,0) på listen, hvis truget er nødlidende: mindst så stor en andel fri.
|
|
ADSupplyPlanner.EMERGENCY_TROUGH_FREE = 0.75
|
|
|
|
-- need.trough = true for foder i et fælles trug; need.score = trugets fri andel; need.priority = fodervægt.
|
|
function ADSupplyPlanner.bestFoodPriority(needs)
|
|
local best = nil
|
|
for _, need in ipairs(needs or {}) do
|
|
if need.trough and (best == nil or (need.priority or 0) > best) then best = need.priority or 0 end
|
|
end
|
|
return best
|
|
end
|
|
|
|
function ADSupplyPlanner.isFoodAllowed(need, bestPriority)
|
|
if not need.trough or bestPriority == nil or (need.priority or 0) >= bestPriority then
|
|
return true
|
|
end
|
|
return (need.score or 0) >= ADSupplyPlanner.EMERGENCY_TROUGH_FREE
|
|
end
|
|
|
|
-- state: nil eller {ingredients, narrowedTo} fra forrige tur. selected: AD's aktuelle varevalg.
|
|
-- >1 valgt = (ny) ingrediensliste. Præcis den vare vi selv indsnævrede til = gemt liste.
|
|
-- Alt andet = brugeren har valgt noget andet -> nil (behovsstyring fra).
|
|
function ADSupplyPlanner.resolveIngredients(state, selected)
|
|
if type(selected) ~= "table" then
|
|
return nil
|
|
end
|
|
if #selected > 1 then
|
|
return ADSupplyPlanner.copyList(selected)
|
|
end
|
|
if state ~= nil and #selected == 1 and selected[1] == state.narrowedTo then
|
|
return ADSupplyPlanner.copyList(state.ingredients)
|
|
end
|
|
return nil
|
|
end
|