Files
fs25-adsmartpickup/FS25_ADSmartPickup/adSmartPickup.lua
T

2158 lines
113 KiB
Lua
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
-- AD Smart Pickup
-- Gør AutoDrives mappe-rotation for pålæsning vare-bevidst: i stedet for
-- "næste markør i mappen" vælges den markør, hvis silo har den valgte vare —
-- og blandt dem den med MINDST i (så rester tømmes først og siloer frigives).
-- Findes ingen silo med varen, bruges AutoDrives originale rotation uændret.
--
-- Behovsstyret forsyning: er der valgt FLERE varer i AutoDrive, ses de som
-- ingredienser til aflæsningsmålet (fx en TMR-blander). Pr. tur hentes den
-- ingrediens målet mangler mest, fra en silo hvor som helst på kortet.
-- Flowet der styrer traktoren nu (et stoppet flow styrer intet — ADRunsController.getActiveRunForVehicle)
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
local function logInfo(...) return (ADLog or Logging).info(...) end
local function activeRunOf(vehicle)
local controller = ADRunsController
if controller == nil or controller.getRunForVehicle == nil then return nil end
local run = controller.getRunForVehicle(vehicle)
if run ~= nil and run.stopped then return nil end
return run
end
ADSmartPickup = {}
-- ADCache-opslag der også virker uden adCache (tests)
local function cacheGet(bucket, key, ttlMs, fn)
if ADCacheGet == nil then return fn() end
return ADCacheGet(bucket, key, ttlMs, fn)
end
ADSmartPickup.dir = g_currentModDirectory
if ADSmartPickup.dir ~= nil and source ~= nil then
source(ADSmartPickup.dir .. "gui/SmartPickupFrame.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupSupplyTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupOutboundTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupStorageTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupStorageView.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupFlowTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupFieldTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupMonthTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupFieldSiloTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupSettingsTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupChainTab.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupGuide.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupFieldGuide.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupFlowGuide.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupEditPanel.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupAttentionFlow.lua")
source(ADSmartPickup.dir .. "gui/SmartPickupHelp.lua") -- sidst: lægger sig om rebuild m.fl.
end
-- Markøren er dér hvor trækkerens næse stopper; læssetriggeren ligger et
-- vogntog bagved. Siloer tættere end dette regnes som "markørens silo".
ADSmartPickup.MAX_MARKER_TO_TRIGGER_DISTANCE = 40
-- I tætte silo-rækker ligger nabosiloens trigger FORAN næsen og er ofte nærmere
-- end markørens egen. Vognen holder altid BAG næsen, så en trigger foran næsen
-- hører til naboen (en ensom silo med markøren ved røret fanges af nødløsningen).
ADSmartPickup.MAX_TRIGGER_AHEAD_OF_MARKER = 0
-- Vognen følger trækkerens spor: en trigger længere til siden end dette er en
-- anden bane (fx aflæsningssiden af samme tank), ikke markørens læsseplads.
ADSmartPickup.MAX_TRIGGER_LATERAL_OFFSET = 6
-- Kendes køreretningen, men ligger ingen trigger i sporet bag næsen (kurve ind til
-- markøren), accepteres kun en trigger helt tæt på.
ADSmartPickup.MAX_FALLBACK_TRIGGER_DISTANCE = 12
-- Under dette niveau regnes siloen som tom (undgår ture efter støv-rester).
ADSmartPickup.MIN_USEFUL_LITERS = 1
-- Sikkerhedsventil: står køretøjet ved markøren så længe uden at vognen fyldes
-- (forkert markør↔silo-kobling, røret når ikke vognen), slippes grebet.
ADSmartPickup.MAX_WAIT_WITHOUT_LOADING_MS = 30000
ADSmartPickup.LOG_PREFIX = "ADSmartPickup: "
local LOAD_TRIGGER_NODE_FIELDS = {"triggerNode"}
local UNLOAD_TRIGGER_NODE_FIELDS = {"exactFillRootNode", "triggerNode", "aiNode"}
local isHooked = false
-- køretøj -> {ingredients, narrowedTo}. AutoDrive roterer selv vare ved triggeren
-- når flere er valgt, så valget indsnævres til én pr. tur; listen huskes her.
local supplyState = setmetatable({}, {__mode = "k"})
-- køretøj -> {station, fillTypes}: siloen moden sendte køretøjet til på denne tur.
local activePickups = setmetatable({}, {__mode = "k"})
-- køretøj -> senest loggede valg (AutoDrive spørger flere gange pr. start).
-- køretøj -> {wayPointId, fillType, liters}: læs traktoren er på vej med (fordeler flere traktorer til
-- samme mål; ryddes ved aflæsning, stop eller ny tur)
local enRoute = setmetatable({}, {__mode = "k"})
local lastLogged = setmetatable({}, {__mode = "k"})
-- Cross-mod adgang: FS25-mods er sandboxede; AutoDrives globals ligger
-- i den globale tabel FS25_AutoDrive (zip-navnet).
local function getAutoDriveEnv()
if FS25_AutoDrive ~= nil and FS25_AutoDrive.ADMultipleTargetsManager ~= nil then
return FS25_AutoDrive
end
return nil
end
-- Adgang til en station: spillets adgangstjek, eller stationens bygning er gårdens efter den fælles
-- ejerregel (jord-bundne kortanlæg som Dakotas BGA står med ejer 15 selv på gårdens jord).
function ADSmartPickup.canUseStation(farmId, station)
local access = g_currentMission ~= nil and g_currentMission.accessHandler or nil
if access == nil or access:canFarmAccess(farmId, station) then
return true
end
return station.owningPlaceable ~= nil and ADPrices ~= nil and ADPrices.isOwnedBy ~= nil and ADPrices.isOwnedBy(station.owningPlaceable, farmId)
end
function ADSmartPickup.getFarmId(vehicle)
if vehicle.getOwnerFarmId ~= nil then
local farmId = vehicle:getOwnerFarmId()
if farmId ~= nil and farmId > 0 then
return farmId
end
end
if vehicle.spec_aiVehicle ~= nil and vehicle.spec_aiVehicle.startedFarmId ~= nil and vehicle.spec_aiVehicle.startedFarmId > 0 then
return vehicle.spec_aiVehicle.startedFarmId
end
return nil
end
local getFarmId = ADSmartPickup.getFarmId
local function getWantedFillTypes(driver)
local wanted = {}
local selected = driver.ad.stateModule:getSelectedFillTypes()
if type(selected) == "table" then
for _, fillType in pairs(selected) do
table.insert(wanted, fillType)
end
end
if #wanted == 0 then
local fillType = driver.ad.stateModule:getFillType()
if fillType ~= nil then
table.insert(wanted, fillType)
end
end
return wanted
end
-- Ankomstretning ved markøren (enhedsvektor) ud fra forrige waypoint, ellers nil.
local function getArrivalDirection(adEnv, wayPoint)
local previousId = wayPoint.incoming ~= nil and wayPoint.incoming[1] or nil
local previous = previousId ~= nil and adEnv.ADGraphManager:getWayPointById(previousId) or nil
if previous == nil then
return nil
end
local dx, dz = wayPoint.x - previous.x, wayPoint.z - previous.z
local length = math.sqrt(dx * dx + dz * dz)
if length < 0.01 then
return nil
end
return {x = dx / length, z = dz / length}
end
-- Nærmeste trigger-afstand for en station, samlet og blandt triggere BAG næsen.
local function getDistancesToTriggers(triggers, nodeFields, wayPoint, direction)
local closest, closestBehind = math.huge, math.huge
for _, trigger in pairs(triggers or {}) do
for _, field in ipairs(nodeFields) do
local node = trigger[field]
if node ~= nil and entityExists(node) then
local tx, _, tz = getWorldTranslation(node)
local distance = MathUtil.vector2Length(wayPoint.x - tx, wayPoint.z - tz)
closest = math.min(closest, distance)
if direction ~= nil then
-- behind > 0: bag næsen set i køreretningen; lateral: afstand fra sporet
local behind = (wayPoint.x - tx) * direction.x + (wayPoint.z - tz) * direction.z
local lateral = math.abs((wayPoint.x - tx) * direction.z - (wayPoint.z - tz) * direction.x)
if behind >= -ADSmartPickup.MAX_TRIGGER_AHEAD_OF_MARKER and lateral <= ADSmartPickup.MAX_TRIGGER_LATERAL_OFFSET then
closestBehind = math.min(closestBehind, distance)
end
end
end
end
end
return closest, closestBehind
end
-- Markørens station: nærmeste trigger i sporet bag næsen. Findes ingen, bruges
-- nærmeste trigger overhovedet — helt tæt på hvis retningen kendes, ellers som før.
local function getClosestStation(adEnv, candidateStations, triggersField, nodeFields, wayPoint, farmId)
local direction = getArrivalDirection(adEnv, wayPoint)
local maxFallbackDistance = direction ~= nil and ADSmartPickup.MAX_FALLBACK_TRIGGER_DISTANCE or ADSmartPickup.MAX_MARKER_TO_TRIGGER_DISTANCE
local best = {any = {distance = maxFallbackDistance}, behind = {distance = ADSmartPickup.MAX_MARKER_TO_TRIGGER_DISTANCE}}
for _, station in pairs(candidateStations) do
if ADSmartPickup.canUseStation(farmId, station) then
local closest, closestBehind = getDistancesToTriggers(station[triggersField], nodeFields, wayPoint, direction)
if closest < best.any.distance then
best.any = {distance = closest, station = station}
end
if closestBehind < best.behind.distance then
best.behind = {distance = closestBehind, station = station}
end
end
end
return best.behind.station or best.any.station
end
local function getLoadStationAtMarker(adEnv, wayPoint, farmId)
return getClosestStation(adEnv, g_currentMission.storageSystem:getLoadingStations(), "loadTriggers", LOAD_TRIGGER_NODE_FIELDS, wayPoint, farmId)
end
-- En stalds foder-trigger står ikke altid i aflæsningsstationens unloadTriggers (hønsehuset har kun
-- foder-triggeren under spec_husbandryFood; feltstien varierer). Står stationen uden trigger-noder, søges
-- foderdataene, og opslaget får en proxy med de fundne noder, der peger på staldens station (eller en
-- minimal station). Caches i UNLOAD_CACHE_MS.
ADSmartPickup.UNLOAD_CACHE_MS = 1000
local unloadCache = {list = nil, time = -math.huge}
function ADSmartPickup.invalidateUnloadCandidates()
unloadCache.list, unloadCache.time = nil, -math.huge
end
local function getUnloadCandidates()
local now = g_currentMission ~= nil and type(g_currentMission.time) == "number" and g_currentMission.time or nil
if unloadCache.list ~= nil and now ~= nil and (now - unloadCache.time) < ADSmartPickup.UNLOAD_CACHE_MS then
return unloadCache.list
end
local list, byPlaceable = {}, {}
for _, station in pairs(g_currentMission.storageSystem:getUnloadingStations()) do
table.insert(list, station)
if station.owningPlaceable ~= nil and byPlaceable[station.owningPlaceable] == nil then
byPlaceable[station.owningPlaceable] = station
end
end
local placeables = g_currentMission.placeableSystem ~= nil and g_currentMission.placeableSystem.placeables or {}
for _, placeable in pairs(placeables) do
local ownStation = byPlaceable[placeable]
-- foder-triggeren med, også når stalden har sin egen station med andre triggere (in-game 12/10: CM-freestallens
-- station har kun halm/gylle/mælk — fodertruget ligger for sig under spec_husbandryFood, og flowet fandt
-- "0 stationer"). Kun noder stationen ikke allerede har, så intet tælles to gange.
local ownNodes = {}
if ownStation ~= nil and ownStation.unloadTriggers ~= nil then
for _, node in ipairs(ADSupplyPlanner.findTriggerNodes(ownStation.unloadTriggers, 1)) do ownNodes[node] = true end
end
local foodNodes = {}
if placeable.getHusbandryFillLevel ~= nil then
for _, node in ipairs(ADSupplyPlanner.findTriggerNodes(placeable.spec_husbandryFood)) do
if not ownNodes[node] then table.insert(foodNodes, node) end
end
end
if #foodNodes > 0 then
local triggers = {}
-- isFoodProxy: tager kun staldens foder (markerTriggerAccepts), ikke alt
for _, foodNode in ipairs(foodNodes) do table.insert(triggers, {exactFillRootNode = foodNode, isFoodProxy = true}) end
local station = ownStation or {
owningPlaceable = placeable,
-- spillets adgangstjek kalder getOwnerFarmId på stationen
getOwnerFarmId = function() return placeable.getOwnerFarmId ~= nil and placeable:getOwnerFarmId() or placeable.ownerFarmId end,
}
table.insert(list, setmetatable({unloadTriggers = triggers}, {__index = station}))
end
end
unloadCache.list, unloadCache.time = list, now or -math.huge
return list
end
-- Stationens aflæsningstriggere i verden -> {{x, z}}
function ADSmartPickup.unloadTriggerPoints(station)
local points = {}
for _, trigger in pairs(station ~= nil and station.unloadTriggers or {}) do
for _, field in ipairs(UNLOAD_TRIGGER_NODE_FIELDS) do
local node = trigger[field]
if node ~= nil and entityExists(node) then
local x, _, z = getWorldTranslation(node)
table.insert(points, {x = x, z = z})
break
end
end
end
return points
end
local function getUnloadStationAtMarker(adEnv, wayPoint, farmId)
return getClosestStation(adEnv, getUnloadCandidates(), "unloadTriggers", UNLOAD_TRIGGER_NODE_FIELDS, wayPoint, farmId)
end
-- Station ved et AutoDrive-waypoint (bruges af runs-controlleren og læs-byttet); nil uden station.
-- Markør -> station er stabil (stationer og markører flytter sig sjældent): caches 10 s (ADCache).
ADSmartPickup.STATION_CACHE_MS = 30000
function ADSmartPickup.getLoadStationAtWayPointId(adEnv, wayPointId, farmId)
return cacheGet("loadStation", tostring(wayPointId) .. ":" .. tostring(farmId), ADSmartPickup.STATION_CACHE_MS, function()
local wayPoint = adEnv.ADGraphManager:getWayPointById(wayPointId)
return wayPoint ~= nil and getLoadStationAtMarker(adEnv, wayPoint, farmId) or nil
end)
end
function ADSmartPickup.getUnloadStationAtWayPointId(adEnv, wayPointId, farmId)
return cacheGet("unloadStation", tostring(wayPointId) .. ":" .. tostring(farmId), ADSmartPickup.STATION_CACHE_MS, function()
local wayPoint = adEnv.ADGraphManager:getWayPointById(wayPointId)
return wayPoint ~= nil and getUnloadStationAtMarker(adEnv, wayPoint, farmId) or nil
end)
end
-- Løst opslag: nærmeste læssestation inden for maxDistance, uanset køreretning og "bag næsen".
-- Til stalde og fabrikker (mælketank ved siden af markøren); siloer skal bruge det strenge
-- opslag, ellers rammes nabosiloen i tætte rækker.
function ADSmartPickup.getLoadStationNearWayPointId(adEnv, wayPointId, farmId, maxDistance)
local wayPoint = adEnv.ADGraphManager:getWayPointById(wayPointId)
if wayPoint == nil then
return nil
end
local best, bestDistance = nil, maxDistance or ADSmartPickup.MAX_MARKER_TO_TRIGGER_DISTANCE
for _, station in pairs(g_currentMission.storageSystem:getLoadingStations()) do
if ADSmartPickup.canUseStation(farmId, station) then
local closest = getDistancesToTriggers(station.loadTriggers, LOAD_TRIGGER_NODE_FIELDS, wayPoint, nil)
if closest < bestDistance then
best, bestDistance = station, closest
end
end
end
return best, best ~= nil and bestDistance or nil
end
-- Siloens EGET indhold. Udvidelses-siloer (isExtension) deler lager med naboer
-- inden for storageRadius, så stationens niveau er en nabo-sum — eget lager er
-- det tal spilleren ser på siloen og giver en præcis "mindst først"-rangering.
function ADSmartPickup.getOwnStorageLevel(station, fillTypes)
local placeable = station.owningPlaceable
local storages = placeable ~= nil and placeable.spec_silo ~= nil and placeable.spec_silo.storages or nil
if storages == nil then
return 0
end
local total = 0
for _, storage in pairs(storages) do
for _, fillType in ipairs(fillTypes) do
total = total + (storage:getFillLevel(fillType) or 0)
end
end
return total
end
local getOwnStorageLevel = ADSmartPickup.getOwnStorageLevel
-- Returnerer niveau + om det er siloens eget lager (true) eller kun nabo-lagre (false).
local function getStationFillLevel(station, fillTypes, farmId)
local ownLevel = getOwnStorageLevel(station, fillTypes)
if ownLevel >= ADSmartPickup.MIN_USEFUL_LITERS then
return ownLevel, true
end
-- intet i eget lager: stationen kan stadig læsse fra nabo-lagre
local total = 0
for _, fillType in ipairs(fillTypes) do
total = total + (station:getFillLevel(fillType, farmId) or 0)
end
return total, false
end
-- Parrer markører med deres læssestation (markører uden station udelades).
-- excludedPlaceable: aflæsningsmålets egen placeable må ikke være kilde.
-- Flere markører ved samme læssestation: "unload"-markører droppes, når stationen også har en anden markør — der
-- læsses på, ikke af (in-game 8/10: 'Cow Barn 1' skulle hente ensilage i TMR-fabrikken og valgte "TMR Unload",
-- 13,7 m fra læssetriggeren, frem for "TMR Load"). roleOf(navn) -> "load" | "unload" | nil.
function ADSmartPickup.dropUnloadDuplicates(entries, roleOf)
local hasOther = {}
for _, entry in ipairs(entries) do
if roleOf(entry.marker.name) ~= "unload" then hasOther[entry.station] = true end
end
local kept = {}
for _, entry in ipairs(entries) do
if roleOf(entry.marker.name) ~= "unload" or not hasOther[entry.station] then table.insert(kept, entry) end
end
return kept
end
-- Ren: en stald hentes kun fra ved de læssemarkører, staldanalysen valgte (ADBuildings: loadMarkers), eller ved en
-- markør med læsse-navn (Collection/Pickup/Load …). En foder-markør ved samme læssestation fjernes (in-game 18/10
-- 17:03: begge mælkebiler sendt til "Cattle Barn 1 Feed" — ruten gik gennem kostalden, de sad fast i 35 min).
-- Valgte markører kendes på id ELLER navn (review: AD omnummererer vejpunkter, bygningslisten caches 30 s).
-- loadIds = {[placeable] = {ids = {[id] = true}, names = {[navn] = true}}}; placeables uden opslag eller uden
-- valgte markører (ukendt) bevares urørt. roleOf(navn) -> "load" | "unload" | nil.
function ADSmartPickup.keepOwnLoadMarkers(entries, loadIds, roleOf)
if loadIds == nil then return entries end
local kept = {}
for _, entry in ipairs(entries) do
local placeable = entry.station ~= nil and entry.station.owningPlaceable or nil
local chosen = placeable ~= nil and loadIds[placeable] or nil
local marker = entry.marker
local keep = chosen == nil or next(chosen.ids or {}) == nil
or (chosen.ids or {})[marker.id] or (chosen.names or {})[marker.name]
or (roleOf ~= nil and roleOf(marker.name) == "load")
if keep then table.insert(kept, entry) end
end
return kept
end
-- Staldenes valgte læssemarkører pr. placeable (kun stalde; andre bygningstyper filtreres ikke).
local loadIdsWarned = false
local function husbandryLoadIds(adEnv, farmId)
if ADBuildings == nil or ADBuildings.list == nil then return nil end
local ok, buildings = pcall(ADBuildings.list, adEnv, farmId)
if not ok then
if not loadIdsWarned then
loadIdsWarned = true
Logging.warning(ADSmartPickup.LOG_PREFIX .. "staldenes læssemarkører kunne ikke læses: %s", tostring(buildings))
end
return nil
end
local loadIds = {}
for _, building in ipairs(buildings or {}) do
if building.kind == "husbandry" and building.placeable ~= nil then
local ids, names = {}, {}
for _, marker in ipairs(building.loadMarkers or {}) do
if marker.id ~= nil then ids[marker.id] = true end
if marker.name ~= nil then names[marker.name] = true end
end
loadIds[building.placeable] = {ids = ids, names = names}
end
end
return loadIds
end
ADSmartPickup.husbandryLoadIds = husbandryLoadIds -- til test
-- Må markøren være en kilde? Parkering (P …), kobling (Connect …) og ventepladser aldrig (in-game 18/10 18:57:
-- bunkerbåsen "P Stor Ledig 2" stod ved et lagers læssestation — tre flows sendte traktorer på P-pladsen efter hø).
-- Samme regel som salgsstederne (ADFieldWork.isServiceMarker: "P …", "Connect …", wait i navn eller mappe).
local serviceWarned = false
function ADSmartPickup.isSourceMarker(marker)
if ADFieldWork == nil or ADFieldWork.isServiceMarker == nil then
if not serviceWarned then
serviceWarned = true
Logging.warning(ADSmartPickup.LOG_PREFIX .. "servicemarkør-reglen mangler — P-/Connect-/Wait-markører kan blive kilder")
end
return true
end
return not ADFieldWork.isServiceMarker(marker)
end
local function collectMarkerStations(adEnv, candidateMarkers, farmId, excludedPlaceable)
local markerStations = {}
for _, marker in pairs(candidateMarkers) do
local wayPoint = ADSmartPickup.isSourceMarker(marker) and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
local station = wayPoint ~= nil and getLoadStationAtMarker(adEnv, wayPoint, farmId) or nil
local isExcluded = station ~= nil and excludedPlaceable ~= nil and station.owningPlaceable == excludedPlaceable
if station ~= nil and not isExcluded then
table.insert(markerStations, {marker = marker, station = station})
end
end
if ADBuildings ~= nil and ADBuildings.nameRole ~= nil then
markerStations = ADSmartPickup.dropUnloadDuplicates(markerStations, ADBuildings.nameRole)
end
if #markerStations > 0 then
markerStations = ADSmartPickup.keepOwnLoadMarkers(markerStations, husbandryLoadIds(adEnv, farmId),
ADBuildings ~= nil and ADBuildings.nameRole or nil)
end
return markerStations
end
local function getFillTypeNames(fillTypes)
local names = {}
for _, fillType in ipairs(fillTypes) do
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or nil
if name ~= nil then
table.insert(names, name)
end
end
return names
end
local function getProductionPoint(station)
local placeable = station.owningPlaceable
if placeable ~= nil and placeable.spec_productionPoint ~= nil then
return placeable.spec_productionPoint.productionPoint
end
return nil
end
-- Fabrikkens eget lager af varen (liter); 0 når lageret ikke kan læses.
local function productionLevel(productionPoint, fillType)
local storage = productionPoint ~= nil and productionPoint.storage or nil
if storage == nil or storage.getFillLevel == nil then return 0 end
local ok, level = pcall(storage.getFillLevel, storage, fillType)
return ok and level or 0
end
-- En fabriks læssestation udleverer også dens INPUTS (fx halm i en TMR-fabrik).
-- Dem stjæler vi aldrig — fabrikken ville løbe tør for det, den skal bruge.
-- Outputs (og varer der både er input og output i en kæde) må gerne hentes.
-- En STALDS læssestation udleverer kun staldens produktion. Den kan dog "have" halm/foder/vand
-- (strøelse, trug, udvidelseslagre inden for storageRadius) — dem henter vi aldrig dér.
local HUSBANDRY_OUTPUTS = {MILK = true, GOATMILK = true, BUFFALOMILK = true, SHEEPMILK = true, LIQUIDMANURE = true, MANURE = true, DIGESTATE = true, EGG = true, WOOL = true}
local function isProtectedHusbandryInput(station, fillTypes)
local placeable = station.owningPlaceable
if placeable == nil or placeable.getHusbandryFillLevel == nil or g_fillTypeManager == nil then
return false
end
for _, fillType in ipairs(fillTypes) do
if not HUSBANDRY_OUTPUTS[tostring(g_fillTypeManager:getFillTypeNameByIndex(fillType))] then
return true
end
end
return false
end
-- Bedste kilde der har varen: mindst fyldte først for lagervarer, fyldeste først for
-- varer hvis tanke løber fulde (ADSupplyPlanner). Siloer med varen i EGET lager går
-- altid forud for dem der kun kan låne fra naboer. Returnerer et valg eller nil.
local getLoadCapacity -- defineret længere nede (læs-kapacitet til kildevalget)
-- Udleverer stationens læssetriggere varen? Et lager kan rumme en vare, som triggeren ikke giver ud (in-game 8/10:
-- fermentorens 6,6 mio. l hø er input — læssetriggeren giver kun ensilage ud). Trigger uden liste = alt.
function ADSmartPickup.triggerDispenses(station, fillType)
local any = false
for _, trigger in pairs(station.loadTriggers or {}) do
any = true
if type(trigger.fillTypes) ~= "table" or trigger.fillTypes[fillType] then return true end
end
return not any
end
-- Må kilden bruges? Dyrestaldens egne lagre aldrig; fabriksinput efter ADSupplyPlanner.mayTakeInput.
local function mayUseSource(station, fillTypes, level, loadCapacity, need)
if isProtectedHusbandryInput(station, fillTypes) then return false end
for _, fillType in ipairs(fillTypes) do
if not ADSmartPickup.triggerDispenses(station, fillType) then return false end
end
local productionPoint = getProductionPoint(station)
if productionPoint == nil or productionPoint.productions == nil then return true end
for _, fillType in ipairs(fillTypes) do
if ADSupplyPlanner.isProductionInput(productionPoint.productions, fillType) then
local perMinute = ADSupplyPlanner.inputUsePerMinute(productionPoint.productions, fillType)
if not ADSupplyPlanner.mayTakeInput(level, loadCapacity, perMinute, need) then return false end
if need ~= nil and need.trough and ADSupplyPlanner.inputMakesBetterFood(productionPoint.activeProductions, fillType,
need.priority, need.foodWeights, function(inputType) return productionLevel(productionPoint, inputType) end) then
return false
end
end
end
return true
end
-- Behov pr. vare lige nu (til retfærdig fordeling): køretøj -> {free, at}
local demandRegistry = {}
ADSmartPickup.DEMAND_FRESH_MS = 10 * 60 * 1000
local probing = false -- ADSmartPickup.probeSupplyPickup: kun spørge, intet registreres
local function registerDemand(fillType, driver, freeSpace)
local now = g_currentMission ~= nil and g_currentMission.time or 0
demandRegistry[fillType] = demandRegistry[fillType] or {}
demandRegistry[fillType][driver] = {free = freeSpace or 0, at = now}
local total, others = 0, 0
for vehicle, entry in pairs(demandRegistry[fillType]) do
if now - entry.at > ADSmartPickup.DEMAND_FRESH_MS then
demandRegistry[fillType][vehicle] = nil
else
total = total + entry.free
if vehicle ~= driver then others = others + 1 end
end
end
return total, others
end
-- Kun gårdens lagre eller en silo ved stalden (ADSupplyPlanner.filterSupplySources); marksiloer udelades.
function ADSmartPickup.restrictSupplySources(adEnv, markerStations, targetPlaceable)
local fieldSiloIds = {}
for _, silo in ipairs(ADFieldSilos ~= nil and ADFieldSilos.lastSilos or {}) do fieldSiloIds[silo.id] = true end
local tx, tz = nil, nil
if targetPlaceable ~= nil and targetPlaceable.rootNode ~= nil then
local ok, x, _, z = pcall(getWorldTranslation, targetPlaceable.rootNode)
if ok then tx, tz = x, z end
end
local entries = {}
for _, entry in ipairs(markerStations) do
local placeable = entry.station ~= nil and entry.station.owningPlaceable or nil
local id = placeable ~= nil and ADBuildings ~= nil and ADBuildings.getId ~= nil and ADBuildings.getId(placeable) or nil
local distance = nil
if tx ~= nil and placeable ~= nil and placeable.rootNode ~= nil then
local ok, x, _, z = pcall(getWorldTranslation, placeable.rootNode)
if ok then distance = math.sqrt((x - tx) ^ 2 + (z - tz) ^ 2) end
end
table.insert(entries, {marker = entry.marker, station = entry.station, isFieldSilo = id ~= nil and fieldSiloIds[id] == true,
isSilo = placeable ~= nil and placeable.spec_silo ~= nil, distance = distance})
end
local targetId = targetPlaceable ~= nil and ADBuildings ~= nil and ADBuildings.getId ~= nil and ADBuildings.getId(targetPlaceable) or nil
local range = ADSettings ~= nil and ADSettings.get("stableSiloRange", targetId) or nil
local near, farm = ADSupplyPlanner.filterSupplySources(entries, range)
local all = {}
for _, entry in ipairs(near) do table.insert(all, entry) end
for _, entry in ipairs(farm) do table.insert(all, entry) end
return {near, farm}, all
end
local function findBestSource(markerStations, fillTypes, farmId, loadCapacity, need)
local prefersFullest = ADSupplyPlanner.prefersFullestSource(getFillTypeNames(fillTypes))
local ample = ADSupplyPlanner.ampleLevel(loadCapacity)
-- silo/fabrik som mål: kun kilder med et rigeligt læs (dyrenes trug tager alt)
local minLevel = ADSupplyPlanner.minSourceLevel ~= nil and ADSupplyPlanner.minSourceLevel(loadCapacity, need) or nil
local best = {[true] = {}, [false] = {}}
for _, entry in ipairs(markerStations) do
local level, isOwn = getStationFillLevel(entry.station, fillTypes, farmId)
if level >= math.max(ADSmartPickup.MIN_USEFUL_LITERS, minLevel or 0) and mayUseSource(entry.station, fillTypes, level, loadCapacity, need)
and ADSupplyPlanner.isBetterSource(level, best[isOwn].level, prefersFullest, ample) then
best[isOwn] = {level = level, marker = entry.marker, station = entry.station, isOwn = isOwn}
end
end
-- eget lager går forud — men ikke en næsten tom egen tank frem for et rigeligt nabolager
local own, other = best[true], best[false]
local choice = own
if own.marker == nil or (not prefersFullest and other.marker ~= nil and own.level < ample and other.level >= ample) then
choice = other
end
if choice.marker == nil then
return nil
end
return {
markerIndex = choice.marker.markerIndex,
markerId = choice.marker.id,
markerName = choice.marker.name,
group = choice.marker.group,
level = choice.level,
station = choice.station,
isOwn = choice.isOwn,
fillTypes = fillTypes,
prefersFullest = prefersFullest,
}
end
-- Stald-silo først (tier 1), ellers gårdens lagre (tier 2): en tom stald-silo må ikke spærre for gården.
local function findBestSourceTiered(tiers, fillTypes, farmId, loadCapacity, need)
for _, tier in ipairs(tiers or {}) do
local choice = #tier > 0 and findBestSource(tier, fillTypes, farmId, loadCapacity, need) or nil
if choice ~= nil then return choice end
end
return nil
end
-- Mappe-logik: mappens mindst fyldte silo der har den/de valgte varer, ellers nil.
function ADSmartPickup.findLeastFilledPickup(adEnv, driver)
local firstMarker = driver.ad.stateModule:getFirstMarker()
if firstMarker == nil or firstMarker.group == nil or firstMarker.group == "All" then
return nil
end
local farmId = getFarmId(driver)
local fillTypes = getWantedFillTypes(driver)
if farmId == nil or #fillTypes == 0 then
return nil
end
local groupMarkers = adEnv.ADGraphManager:getMapMarkersInGroup(firstMarker.group)
return findBestSource(collectMarkerStations(adEnv, groupMarkers, farmId, nil), fillTypes, farmId, getLoadCapacity(adEnv, driver))
end
-- Lagrene bag aflæsningsstationen; produktionspunkter uden targetStorages læses direkte.
local function getTargetStorages(station)
if station.targetStorages ~= nil and next(station.targetStorages) ~= nil then
return station.targetStorages
end
local productionPoint = getProductionPoint(station)
if productionPoint ~= nil and productionPoint.storage ~= nil then
return {productionPoint.storage}
end
return {}
end
local function isProductionEnabled(productionPoint, production)
if productionPoint.getIsProductionEnabled ~= nil then
return productionPoint:getIsProductionEnabled(production.id) == true
end
for _, active in ipairs(productionPoint.activeProductions or {}) do
if active == production then
return true
end
end
return false
end
-- Fabriksstyret: {[fillType] = liter/min} som målets ønskede produktioner bruger,
-- begrænset til det vognen kan bære. Tom tabel = intet produktionspunkt/intet ønsket.
local function getProductionDemand(adEnv, station, driver)
local productionPoint = getProductionPoint(station)
if productionPoint == nil or productionPoint.productions == nil then
return {}
end
local canCarry = {}
for _, fillType in ipairs(ADRunsController.getCarriableFillTypes(adEnv, driver)) do
canCarry[fillType] = true
end
local missingInputs = ProductionPoint ~= nil and ProductionPoint.PROD_STATUS ~= nil and ProductionPoint.PROD_STATUS.MISSING_INPUTS or nil
local function isWanted(production)
return ADSupplyPlanner.isProductionWanted(isProductionEnabled(productionPoint, production), production.status, missingInputs)
end
return ADSupplyPlanner.collectProductionDemand(productionPoint.productions, isWanted, canCarry)
end
-- Fabrikkens inputs som sorteret liste (stabil rækkefølge -> stabil log/rangering).
local function getDemandFillTypes(demand)
local fillTypes = {}
for fillType in pairs(demand) do
table.insert(fillTypes, fillType)
end
table.sort(fillTypes)
return fillTypes
end
-- Fabrik som mål uden ønskede produktioner: sig det én gang, så en stille
-- tilbagefald til brugerens valg ikke ligner en fejl i moden.
local factoryFallbackLogged = setmetatable({}, {__mode = "k"})
local function logFactoryFallbackOnce(driver, station, outcome)
local placeable = station.owningPlaceable
local name = (ADNames ~= nil and ADNames.forPlaceable(placeable)) or (placeable ~= nil and placeable.getName ~= nil and placeable:getName()) or "fabrik"
local message = string.format("'%s': %s har ingen ønskede produktioner (tændte eller auto-slukkede pga. mangel) med varer vognen kan bære; %s", tostring(ADRuns.vehicleLabel(driver)), tostring(name), tostring(outcome))
if factoryFallbackLogged[driver] ~= message then
factoryFallbackLogged[driver] = message
logInfo(ADSmartPickup.LOG_PREFIX .. "%s", message)
end
end
-- Brugerens varevalg, begrænset til det vognen kan bære. Fabrikken uden ønskede produktioner falder tilbage til flowets
-- varevalg — det må ikke sende en vogn efter varer, den ikke kan læsse (in-game 18/10 21:32: "Kæde: Barley → Grain Mill"
-- beholdt sin EDK 650 Autoload fra før 340 og blev vækket til byg ved TMR Silo Farma). Tom liste = ukendte varer: uændret —
-- undtagen når emptyMeansNone (parkeret Autoload-vogn: tom liste = den kan intet af det, review 18/10). -> ny liste
function ADSmartPickup.carriableIngredients(ingredients, carriable, emptyMeansNone)
if carriable == nil or (carriable[1] == nil and not emptyMeansNone) then return ingredients end
local allowed = {}
for _, fillType in ipairs(carriable) do allowed[fillType] = true end
local kept = {}
for _, fillType in ipairs(ingredients or {}) do
if allowed[fillType] then table.insert(kept, fillType) end
end
return kept
end
-- Stalde (kostald m.fl.) holder foder/halm/vand i egne lagre bag én aflæsningsstation,
-- der ikke nødvendigvis siger ja til alle varer. Stalden selv svarer for alle.
local function getHusbandry(station)
local placeable = station.owningPlaceable
if placeable ~= nil and placeable.getHusbandryFillLevel ~= nil and placeable.getHusbandryCapacity ~= nil then
return placeable
end
return nil
end
-- FS25-staldes foder ligger i spec_husbandryFood: ét fælles trug (capacity) med niveau pr.
-- vare (fillLevels). Hvilke varer der er foder, ved animalFoodSystem (grupper + blandinger).
-- Returnerer {[fillType] = true} eller nil når stalden ikke har foder-spec.
local function getHusbandryFoodFillTypes(husbandry)
local foodSpec = husbandry.spec_husbandryFood
local foodSystem = g_currentMission ~= nil and g_currentMission.animalFoodSystem or nil
if foodSpec == nil or foodSystem == nil or foodSpec.animalTypeIndex == nil then
return nil
end
-- værdien er foderets vægt (spillets productionWeight/eatWeight: TMR 1,0, hø/ensilage
-- 0,8, græs 0,4) — bruges som prioritet inden for truget; ukendt = 1
local fillTypes = {}
local animalFood = foodSystem.getAnimalFood ~= nil and foodSystem:getAnimalFood(foodSpec.animalTypeIndex) or nil
for _, group in pairs(animalFood ~= nil and animalFood.groups or {}) do
local weight = tonumber(group.productionWeight) or tonumber(group.eatWeight) or 1
for _, fillType in pairs(group.fillTypes or {}) do
fillTypes[fillType] = math.max(fillTypes[fillType] or 0, weight)
end
end
local mixtures = foodSystem.getMixturesByAnimalTypeIndex ~= nil and foodSystem:getMixturesByAnimalTypeIndex(foodSpec.animalTypeIndex) or nil
for _, mixture in pairs(mixtures or {}) do
local fillType = type(mixture) == "table" and (mixture.fillType or mixture.fillTypeIndex) or mixture
if type(fillType) == "number" then
fillTypes[fillType] = math.max(fillTypes[fillType] or 0, 1)
end
end
return fillTypes
end
-- Parallelt foder (animalFood consumptionType PARALLEL, fx høns: korn + roesnitter): dyrene spiser fra alle
-- grupper samtidig. Returnerer grupperne {fillTypes, eatWeight} eller nil (serielt = bedste foder først).
local function getParallelFoodGroups(husbandry)
local foodSpec = husbandry.spec_husbandryFood
local foodSystem = g_currentMission ~= nil and g_currentMission.animalFoodSystem or nil
if foodSpec == nil or foodSystem == nil or foodSpec.animalTypeIndex == nil or foodSystem.getAnimalFood == nil then
return nil
end
local animalFood = foodSystem:getAnimalFood(foodSpec.animalTypeIndex)
if animalFood == nil then return nil end
local consumption = animalFood.consumptionType
local parallelConstant = AnimalFoodSystem ~= nil and AnimalFoodSystem.FOOD_CONSUME_TYPE_PARALLEL or nil
local isParallel = (parallelConstant ~= nil and consumption == parallelConstant) or string.upper(tostring(consumption)) == "PARALLEL"
if not isParallel then return nil end
local groups = {}
for _, group in pairs(animalFood.groups or {}) do
table.insert(groups, {fillTypes = group.fillTypes or {}, eatWeight = tonumber(group.eatWeight) or tonumber(group.productionWeight) or 1})
end
return groups
end
-- Trugets fælles trang (fri/kapacitet) og foderets vægt for en vare; nil når varen ikke er foder.
local function getFoodPriority(station, fillType)
local husbandry = getHusbandry(station)
local foodFillTypes = husbandry ~= nil and getHusbandryFoodFillTypes(husbandry) or nil
if foodFillTypes == nil or foodFillTypes[fillType] == nil then
return nil
end
-- parallelt foder: grupperne supplerer hinanden, så "bedste foder først" gælder ikke
if getParallelFoodGroups(husbandry) ~= nil then
return nil
end
local foodSpec = husbandry.spec_husbandryFood
local total = 0
for _, level in pairs(foodSpec.fillLevels or {}) do
total = total + (level or 0)
end
local capacity = foodSpec.capacity or 0
local troughScore = capacity > 0 and math.max(0, capacity - total) / capacity or 0
return troughScore, foodFillTypes[fillType], capacity
end
-- Trugets fri andel (0-1) for foder-varen ved stationen, som turplanlægningen bruger mod "troughRefillPercent".
-- nil = ikke foder (halm, vand, ikke-stald) eller parallelt foder: ingen tærskel.
function ADSmartPickup.troughScore(station, fillType)
local ok, score = pcall(getFoodPriority, station, fillType)
return ok and score or nil
end
-- En stald kan MODTAGE foder, halm og vand — ikke sine egne outputs (mælk, gødning, gylle),
-- selv om placeable'n "understøtter" dem som lager. Uden foder-spec (ældre/mod-stalde)
-- spørges staldens egen understøttelse.
local function isFillTypeAccepted(station, husbandry, fillType)
if husbandry ~= nil then
local foodFillTypes = getHusbandryFoodFillTypes(husbandry)
if foodFillTypes ~= nil then
if foodFillTypes[fillType] then
return true
end
local strawSpec, waterSpec = husbandry.spec_husbandryStraw, husbandry.spec_husbandryWater
local isStraw = strawSpec ~= nil and (strawSpec.fillType == nil or strawSpec.fillType == fillType)
and g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) == "STRAW"
local isWater = waterSpec ~= nil and waterSpec.automaticWaterSupply ~= true
and (waterSpec.fillType == fillType or g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) == "WATER")
return isStraw or isWater
end
if husbandry.getHusbandryIsFillTypeSupported ~= nil then
return husbandry:getHusbandryIsFillTypeSupported(fillType)
end
end
return station.getIsFillTypeSupported == nil or station:getIsFillTypeSupported(fillType)
end
-- Foder deler ét trug: varens eget niveau + trugets fri plads = den kapacitet varen kan nå.
local function getHusbandryFoodLevelAndCapacity(husbandry, fillType)
local foodSpec = husbandry.spec_husbandryFood
local groups = getParallelFoodGroups(husbandry)
if groups ~= nil then
local level, capacity = ADSupplyPlanner.parallelFoodShare(groups, foodSpec.fillLevels, foodSpec.capacity, fillType)
if level ~= nil then
-- andelen kan ikke overstige den plads truget faktisk har fri (fuldt af korn = ingen plads til snitter)
local total = 0
for _, value in pairs(foodSpec.fillLevels or {}) do total = total + (value or 0) end
local actualFree = math.max(0, (foodSpec.capacity or 0) - total)
return level, math.max(level, math.min(capacity, level + actualFree))
end
end
local total = 0
for _, level in pairs(foodSpec.fillLevels or {}) do
total = total + (level or 0)
end
local level = (foodSpec.fillLevels or {})[fillType] or 0
local freeSpace = math.max(0, (foodSpec.capacity or 0) - total)
return level, level + freeSpace
end
-- Niveau + kapacitet for én vare i aflæsningsmålet; nil hvis målet ikke tager varen.
function ADSmartPickup.getStationLevelAndCapacity(station, fillType, farmId)
local husbandry = getHusbandry(station)
if not isFillTypeAccepted(station, husbandry, fillType) then
return nil
end
if husbandry ~= nil then
local foodFillTypes = getHusbandryFoodFillTypes(husbandry)
if foodFillTypes ~= nil and foodFillTypes[fillType] then
return getHusbandryFoodLevelAndCapacity(husbandry, fillType)
end
local level = husbandry:getHusbandryFillLevel(fillType) or 0
return level, husbandry:getHusbandryCapacity(fillType) or level
end
local level, freeSpace = 0, 0
for _, storage in pairs(getTargetStorages(station)) do
level = level + (storage:getFillLevel(fillType) or 0)
freeSpace = freeSpace + (storage:getFreeCapacity(fillType) or 0)
end
if level + freeSpace <= 0 and station.getFreeCapacity ~= nil then
-- ukendt lagertype: brug stationens egen opgørelse af fri plads
level, freeSpace = 0, station:getFreeCapacity(fillType, farmId) or 0
end
return level, level + freeSpace
end
local getTargetLevelAndCapacity = ADSmartPickup.getStationLevelAndCapacity
-- Niveau + kapacitet pr. ingrediens i aflæsningsmålets lager; demand giver forbrug/min.
-- Stald-silo som mål: de varer staldene inden for stableSiloRange af siloen bruger (foder + halm). nil når målet ikke
-- er en ren silo, eller ingen stald står ved den (så fyldes siloen med alt, den tager — et almindeligt lager).
-- 2. værdi: {[fillType] = fodervægt} for stalde med serielt foder (køer) — valget følger prioriteringslisten.
function ADSmartPickup.getStableSiloFillTypes(adEnv, stations, farmId)
local placeables = {}
for _, entry in ipairs(stations or {}) do
local placeable = entry.station ~= nil and entry.station.owningPlaceable or nil
if placeable == nil or placeable.spec_silo == nil or getHusbandry(entry.station) ~= nil or getProductionPoint(entry.station) ~= nil then return nil end
table.insert(placeables, placeable)
end
if #placeables == 0 or ADBuildings == nil then return nil end
local result, any, foodWeights = {}, false, {}
local strawIndex = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeIndexByName("STRAW") or nil
for _, silo in ipairs(placeables) do
local siloId = ADBuildings.getId ~= nil and ADBuildings.getId(silo) or nil
local range = ADSettings ~= nil and ADSettings.get("stableSiloRange", siloId) or ADSupplyPlanner.STABLE_SILO_M
local okS, sx, _, sz = pcall(getWorldTranslation, silo.rootNode)
if okS then
for _, building in ipairs(ADBuildings.list(adEnv, farmId) or {}) do
local husbandry = building.kind == "husbandry" and building.placeable or nil
if husbandry ~= nil and husbandry.rootNode ~= nil then
local okH, hx, _, hz = pcall(getWorldTranslation, husbandry.rootNode)
if okH and math.sqrt((hx - sx) ^ 2 + (hz - sz) ^ 2) <= range then
-- serielt foder (køer) følger prioriteringslisten ved valget (foodWeights); parallelt (høns) æder alle
local foods = getHusbandryFoodFillTypes(husbandry) or {}
for fillType, weight in pairs(foods) do
result[fillType], any = true, true
if getParallelFoodGroups(husbandry) == nil then foodWeights[fillType] = math.max(foodWeights[fillType] or 0, weight) end
end
if strawIndex ~= nil and husbandry.spec_husbandryStraw ~= nil then result[strawIndex], any = true, true end
end
end
end
end
end
if not any then return nil end
return result, foodWeights
end
local function getTargetNeeds(station, ingredients, farmId, demand)
local needs = {}
-- trug-tærskel pr. stald (ADSettings "troughRefillPercent"): kør først når truget er under tærsklen
local placeable = station ~= nil and station.owningPlaceable or nil
local buildingId = placeable ~= nil and ADBuildings ~= nil and ADBuildings.getId ~= nil and ADBuildings.getId(placeable) or nil
local threshold = ADSettings ~= nil and ADSettings.get("troughRefillPercent", buildingId) or 100
for _, fillType in ipairs(ingredients) do
local level, capacity = getTargetLevelAndCapacity(station, fillType, farmId)
if level ~= nil then
local troughScore, priority, troughCapacity = getFoodPriority(station, fillType)
if troughScore == nil or ADSupplyPlanner.troughNeedsRefill(troughScore, threshold) then
local foodWeights = troughScore ~= nil and getHusbandryFoodFillTypes(getHusbandry(station)) or nil
table.insert(needs, {fillType = fillType, level = level, capacity = capacity, litersPerMinute = demand[fillType], scoreOverride = troughScore, priority = priority, troughCapacity = troughCapacity, foodWeights = foodWeights})
end
end
end
return needs
end
-- Til fanen: samme rangering som valget bruger (uden vogn-størrelse). Fulde varer sidst.
-- ---- læs på vej ----
function ADSmartPickup.setEnRoute(vehicle, wayPointId, fillType, liters)
if wayPointId == nil or fillType == nil or liters == nil or liters <= 0 then
enRoute[vehicle] = nil
return
end
enRoute[vehicle] = {wayPointId = wayPointId, fillType = fillType, liters = liters}
end
function ADSmartPickup.getEnRoute(vehicle)
return enRoute[vehicle]
end
-- Fyldt run-traktor -> "på vej" til mål targetId, så mål-valget for de næste fordeler dem.
function ADSmartPickup.registerCargo(adEnv, vehicle, targetId, ingredients)
if targetId == nil or ADUnloadWait == nil or ADUnloadWait.getRestLoad == nil then return false end
local restFillType, restLiters = ADUnloadWait.getRestLoad(adEnv, vehicle)
local fillType, liters = ADSupplyPlanner.cargoFor(restFillType, restLiters, ingredients)
if fillType == nil then return false end
ADSmartPickup.setEnRoute(vehicle, targetId, fillType, liters)
return true
end
function ADSmartPickup.clearEnRoute(vehicle)
enRoute[vehicle] = nil
end
function ADSmartPickup.resetEnRoute()
enRoute = setmetatable({}, {__mode = "k"})
end
-- {[fillType] = liter} som ANDRE (aktive) traktorer er på vej med til målet.
function ADSmartPickup.getPending(wayPointId, excludeVehicle)
local pending = {}
for vehicle, entry in pairs(enRoute) do
if vehicle ~= excludeVehicle and entry.wayPointId == wayPointId then
pending[entry.fillType] = (pending[entry.fillType] or 0) + entry.liters
end
end
return pending
end
-- Antal ANDRE traktorer på vej til målet (målvalget fordeler vognene på flere drops).
function ADSmartPickup.countEnRoute(wayPointId, excludeVehicle)
local count = 0
for vehicle, entry in pairs(enRoute) do
if vehicle ~= excludeVehicle and entry.wayPointId == wayPointId then count = count + 1 end
end
return count
end
-- pending (valgfri): læs på vej til målet, lægges oven i (fanen og mål-valget mellem stalde).
function ADSmartPickup.getTargetNeedsRanked(station, fillTypes, farmId, pending)
local needs = getTargetNeeds(station, fillTypes, farmId, {})
if pending ~= nil and next(pending) ~= nil then
needs = ADSupplyPlanner.applyPending(needs, pending)
end
local ranked = ADSupplyPlanner.rankNeeds(needs)
local seen = {}
for _, need in ipairs(ranked) do seen[need.fillType] = true end
for _, need in ipairs(needs) do
if not seen[need.fillType] then
table.insert(ranked, {fillType = need.fillType, level = need.level, capacity = need.capacity, freeSpace = need.capacity - need.level, fits = false, score = 0, priority = need.priority or 0})
end
end
return ranked
end
-- Vognens samlede kapacitet (liter); nil hvis AutoDrive ikke kan opgøre den.
getLoadCapacity = function(adEnv, driver)
if adEnv.AutoDrive.getAllUnits == nil or adEnv.AutoDrive.getAllFillLevels == nil then
return nil
end
local trailers = adEnv.AutoDrive.getAllUnits(driver)
local _, capacity = adEnv.AutoDrive.getAllFillLevels(trailers)
return capacity ~= nil and capacity > 0 and capacity or nil
end
-- Fri plads + kapacitet for varen i køretøjets aflæsningsmål (Wait-punkt-logikken);
-- nil hvis målet ikke kendes eller ikke tager varen.
-- askAccepted=true: returnerer i stedet true/false for "tager målet varen?" (nil = mål ukendt).
-- targetWayPointId (valgfri): brug dette mål i stedet for AD's 2. markør (mens en traktor venter
-- ved et Wait-punkt, peger AD's markør på Wait-punktet, så AD ikke tipper).
-- (en frakoblet vogn parkeret med læs har intet .ad: AD's markør læses kun, når målet ikke er givet)
function ADSmartPickup.getTargetFreeCapacity(adEnv, driver, fillType, askAccepted, targetWayPointId)
local wayPointId = targetWayPointId
if wayPointId == nil then
local secondMarker = driver.ad.stateModule:getSecondMarker()
wayPointId = secondMarker ~= nil and secondMarker.id or nil
end
local farmId = getFarmId(driver)
if wayPointId == nil or farmId == nil then
return nil
end
local targetWayPoint = adEnv.ADGraphManager:getWayPointById(wayPointId)
local target = targetWayPoint ~= nil and getUnloadStationAtMarker(adEnv, targetWayPoint, farmId) or nil
if target == nil then
return nil
end
local level, capacity = getTargetLevelAndCapacity(target, fillType, farmId)
if askAccepted then
return level ~= nil
end
if level == nil then
return nil
end
return capacity - level, capacity
end
-- Tager en aflæsningstrigger VED markøren varen? Stationen kan godt tage varen et andet sted (stalden tager
-- foder i truget), mens triggeren ved markøren kun tager halm (in-game 14/10: 975.917 l TMR sendt til 'Cow Barn
-- Straw', fordi staldens station havde plads til foderet). Triggere uden fyldtype-data (foder-proxyer) tæller som ja.
local function triggerAcceptsFillType(trigger, fillType)
if trigger.getIsFillTypeAllowed ~= nil then
local ok, allowed = pcall(trigger.getIsFillTypeAllowed, trigger, fillType)
if ok and allowed ~= nil then return allowed ~= false end
end
return trigger.fillTypes == nil or trigger.fillTypes[fillType] == true
end
-- Triggere inden for så mange meter af den nærmeste regnes som "ved markøren" (vognen står over dem).
ADSmartPickup.NEAREST_TRIGGER_TOLERANCE = 10
-- Ren logik: entries = {{distance, accepts}} for triggere inden for MAX_MARKER_TO_TRIGGER_DISTANCE.
-- Tager en af de NÆRMESTE varen? Tom liste (ingen trigger med kendt position) = ja, stol på stationen.
function ADSmartPickup.nearestTriggerAccepts(entries, tolerance)
if #entries == 0 then return true end
local nearest = math.huge
for _, entry in ipairs(entries) do nearest = math.min(nearest, entry.distance) end
for _, entry in ipairs(entries) do
if entry.accepts and entry.distance <= nearest + (tolerance or ADSmartPickup.NEAREST_TRIGGER_TOLERANCE) then return true end
end
return false
end
-- Tager triggeren ved markøren varen? Alle bygningens triggere tæller — også fodertruget, der i CM-freestallen ligger
-- som en egen kandidat ved siden af stationen med halm/gylle/mælk (in-game 16/10: rest-TMR blev ikke sendt til den
-- tomme Kostald 2, fordi kun stationens triggere blev set). De nærmeste afgør (1.62.229: TMR ikke til halm-markøren).
-- diag (valgfri tabel): bygning og hver trigger (afstand, tager varen, trug) til loggen (in-game 16/10: Kostald 2)
function ADSmartPickup.markerTriggerAccepts(adEnv, wayPointId, fillType, farmId, diag)
local wayPoint = wayPointId ~= nil and adEnv.ADGraphManager:getWayPointById(wayPointId) or nil
local station = wayPoint ~= nil and getUnloadStationAtMarker(adEnv, wayPoint, farmId) or nil
if station == nil then
if diag ~= nil then table.insert(diag, "ingen station ved markøren") end
return false
end
local owner = station.owningPlaceable
if diag ~= nil then
local ownerName = owner ~= nil and owner.getName ~= nil and owner:getName() or "?"
table.insert(diag, string.format("bygning '%s'%s", tostring(ownerName), station.unloadTriggers ~= nil and station.unloadTriggers[1] ~= nil
and station.unloadTriggers[1].isFoodProxy and " (første trigger = trug)" or ""))
end
local entries = {}
for _, candidate in ipairs(getUnloadCandidates()) do
if candidate == station or (owner ~= nil and candidate.owningPlaceable == owner) then
for _, trigger in pairs(candidate.unloadTriggers or {}) do
local distance = getDistancesToTriggers({trigger}, UNLOAD_TRIGGER_NODE_FIELDS, wayPoint, nil)
if distance <= ADSmartPickup.MAX_MARKER_TO_TRIGGER_DISTANCE then
local accepts
if trigger.isFoodProxy then
-- fodertruget: kun staldens foder (ukendt foderliste = som før, tag det)
local foodTypes = candidate.owningPlaceable ~= nil and getHusbandryFoodFillTypes(candidate.owningPlaceable) or nil
accepts = foodTypes == nil or next(foodTypes) == nil or foodTypes[fillType] ~= nil
else
accepts = triggerAcceptsFillType(trigger, fillType)
end
table.insert(entries, {distance = distance, accepts = accepts, trigger = trigger})
if diag ~= nil then
table.insert(diag, string.format("%.1f m %s%s", distance, accepts and "tager" or "nej", trigger.isFoodProxy and " (trug)" or ""))
end
end
end
end
end
if ADSmartPickup.nearestTriggerAccepts(entries) then return true end
-- gennemkørsel: AD-vejen ind til markøren kører forbi en trigger der tager varen (in-game 16/10 Kostald 4: markøren
-- står i porten for enden af foderbordet, truget 24 m inde — vognen kører langs truget og stopper selv ved det)
for _, entry in ipairs(entries) do
-- kun inden for AD's trigger-rækkevidde fra markøren (AD tømmer først, når markøren er så tæt på — review)
if entry.accepts and entry.trigger ~= nil and entry.distance <= ADSmartPickup.AD_TRIGGER_RANGE_M then
local passing = ADSmartPickup.approachDistanceToTrigger(adEnv, wayPointId, entry.trigger)
if passing ~= nil and passing <= ADSmartPickup.DRIVE_THROUGH_TRIGGER_M then
if diag ~= nil then table.insert(diag, string.format("vejen ind kører %.1f m fra en trigger der tager varen", passing)) end
return true
end
end
end
return false
end
-- Trigger der kun tager varen som genstande (paller/baller/træ), ikke tippet bulk. Spillet selv (UnloadingStation.
-- validateUnloadTriggers) skelner på klassen: PalletUnloadTrigger / BaleUnloadTrigger / WoodUnloadTrigger er objekt-
-- triggere, en almindelig UnloadTrigger (med exactFillRootNode) tager bulk. Uden klasserne (tests) kendes de på deres
-- felter (palletsInRange / balesInTrigger). In-game 20/10: Farmers Markets palletTrigger tager CARROT — men kun paller.
-- (spillets globale klasser slås op ved kaldet — modmiljøet har ikke _G som spillets tabel; som adFieldStore.lua)
function ADSmartPickup.isObjectTrigger(trigger)
if trigger == nil then return false end
if ClassUtil ~= nil and ClassUtil.getClassObjectByObject ~= nil then
local ok, class = pcall(ClassUtil.getClassObjectByObject, trigger)
if ok and class ~= nil then
if (PalletUnloadTrigger ~= nil and class == PalletUnloadTrigger) or (BaleUnloadTrigger ~= nil and class == BaleUnloadTrigger)
or (WoodUnloadTrigger ~= nil and class == WoodUnloadTrigger) then
return true
end
end
end
return trigger.palletsInRange ~= nil or trigger.balesInTrigger ~= nil
end
-- Triggere der tager varen og ligger så tæt på den nærmeste af dem, regnes som lige nære (bulk-tjekket).
ADSmartPickup.BULK_TRIGGER_TOLERANCE = 3
-- Ren logik: entries = {{distance, accepts, isObject}} for stationens triggere. Kan bulk tippes ved markøren? Den
-- nærmeste trigger der tager varen afgør: er den en palle-/balletrigger (og ingen bulk-trigger lige så nær), nej.
-- Ingen trigger med kendt position der tager varen = ja, stol på stationen (som før).
function ADSmartPickup.nearestAcceptingTakesBulk(entries, tolerance)
local nearest = math.huge
for _, entry in ipairs(entries or {}) do
if entry.accepts then nearest = math.min(nearest, entry.distance) end
end
if nearest == math.huge then return true end
for _, entry in ipairs(entries) do
if entry.accepts and not entry.isObject and entry.distance <= nearest + (tolerance or ADSmartPickup.BULK_TRIGGER_TOLERANCE) then
return true
end
end
return false
end
-- Kan BULK af varen tippes ved salgsmarkøren for stationen? Stationen kan godt tage varen (Farmers Market: CARROT i
-- unloadTrigger OG palletTrigger), men markøren ved palletriggeren ("Pallet Delivery") kan kun tage paller — en
-- tipvogn holdt dér for evigt med 1.000.000 l gulerødder (in-game 20/10). Kun til bulk-last; paller bruger ikke tjekket.
function ADSmartPickup.markerTakesBulk(adEnv, wayPointId, station, fillType)
local wayPoint = wayPointId ~= nil and adEnv.ADGraphManager:getWayPointById(wayPointId) or nil
if wayPoint == nil or station == nil then return true end
local entries = {}
for _, trigger in pairs(station.unloadTriggers or {}) do
local distance = getDistancesToTriggers({trigger}, UNLOAD_TRIGGER_NODE_FIELDS, wayPoint, nil)
if distance < math.huge then
table.insert(entries, {distance = distance, accepts = triggerAcceptsFillType(trigger, fillType),
isObject = ADSmartPickup.isObjectTrigger(trigger)})
end
end
return ADSmartPickup.nearestAcceptingTakesBulk(entries)
end
-- Hvor tæt kommer AD-vejen ind til markøren (ADFieldWork.approachPoints, 40 m bagud) en triggers knudepunkter?
-- Gemmes pr. markør+trigger (vej og bygning flytter sig ikke i et spil). nil = kan ikke måles.
ADSmartPickup.DRIVE_THROUGH_TRIGGER_M = 4
ADSmartPickup.AD_TRIGGER_RANGE_M = 25 -- AutoDrives standard for "maxTriggerDistance" (Settings: 25 m)
local approachCache = {}
function ADSmartPickup.approachDistanceToTrigger(adEnv, wayPointId, trigger)
if ADFieldWork == nil or ADFieldWork.approachPoints == nil or wayPointId == nil then return nil end
local byTrigger = approachCache[wayPointId]
if byTrigger == nil then
byTrigger = setmetatable({}, {__mode = "k"})
approachCache[wayPointId] = byTrigger
end
if byTrigger[trigger] ~= nil then return byTrigger[trigger] end
local ok, points = pcall(ADFieldWork.approachPoints, adEnv, wayPointId)
if not ok or points == nil then return nil end
local best = math.huge
for _, point in ipairs(points) do
best = math.min(best, (getDistancesToTriggers({trigger}, UNLOAD_TRIGGER_NODE_FIELDS, point, nil)))
end
if best == math.huge then return nil end -- ikke målt (fx vejnettet ikke indlæst endnu): prøv igen senere
byTrigger[trigger] = best
return best
end
-- Behovsstyret: den ingrediens aflæsningsmålet mangler mest, som også findes i en silo.
-- Hvorfor fandt forsyningen intet? Én linje pr. behov (højst hvert 5. min pr. traktor) — in-game 8/10: 'Sheep Food'
-- holdt ved Wait med tomt trug, mens gården havde 6,6 mio. l hø.
local supplyMissLoggedAt = setmetatable({}, {__mode = "k"})
ADSmartPickup.SUPPLY_MISS_LOG_MS = 5 * 60 * 1000
local buyMissReason = setmetatable({}, {__mode = "k"}) -- køretøj -> hvorfor buyFeed ikke købte (til loggen)
local function logSupplyMiss(driver, ranked, bestFood, markerStations, farmId, held)
local t = g_currentMission ~= nil and g_currentMission.time or 0
if supplyMissLoggedAt[driver] ~= nil and t - supplyMissLoggedAt[driver] < ADSmartPickup.SUPPLY_MISS_LOG_MS then return end
supplyMissLoggedAt[driver] = t
local parts = {}
for _, need in ipairs(ranked or {}) do
local allowed = ADSupplyPlanner.isFoodAllowed == nil or ADSupplyPlanner.isFoodAllowed(need, bestFood)
local withStock, protected, bestLevel, tooLittle = 0, 0, 0, 0
local minLevel = ADSupplyPlanner.minSourceLevel ~= nil and ADSupplyPlanner.minSourceLevel(loadCapacity, need) or nil
for _, entry in ipairs(markerStations or {}) do
local level = getStationFillLevel(entry.station, {need.fillType}, farmId)
if level >= ADSmartPickup.MIN_USEFUL_LITERS then
if not mayUseSource(entry.station, {need.fillType}, level, nil, need) then
protected = protected + 1
elseif minLevel ~= nil and level < minLevel then
tooLittle = tooLittle + 1
else
withStock = withStock + 1
bestLevel = math.max(bestLevel, level)
end
end
end
local fillType = g_fillTypeManager ~= nil and g_fillTypeManager.getFillTypeByIndex ~= nil and g_fillTypeManager:getFillTypeByIndex(need.fillType) or nil
table.insert(parts, string.format("%s: fri %.0f l, %s, %d kilder med lager (bedst %.0f l), %d afvist (dyrestaldens eget lager, fabriksreserve, fabrikken laver bedre foder af den, eller triggeren giver varen ikke ud)%s",
fillType ~= nil and fillType.name or tostring(need.fillType), need.freeSpace or 0,
(held or {})[need] and ((held or {})[need] == "stable" and "HOLDT (bedre foder på lager — prioriteringslisten)"
or (held or {})[need] == "trigger" and "HOLDT (triggeren ved målmarkøren tager ikke varen)"
or "HOLDT (dyrene først: siloerne dækker ikke dyrene)") or (allowed and "tilladt" or "IKKE tilladt (bedre foder findes)"),
withStock, bestLevel, protected,
tooLittle > 0 and string.format(", %d med for lidt til et rigeligt læs (< %.0f l — silo/fabrik venter)", tooLittle, minLevel or 0) or ""))
end
if #parts == 0 then table.insert(parts, "målet mangler intet (eller varerne kendes ikke)") end
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s' forsyning fandt intet: %s (%d markør-stationer) — køb: %s", tostring(ADRuns.vehicleLabel(driver)),
table.concat(parts, " | "), #(markerStations or {}), tostring(buyMissReason[driver] or "ikke forsøgt"))
end
-- Dyrenes forbrug af varen pr. måned (kædens data, 0 når dyrene ikke spiser den) og gårdens hentbare lager.
local function animalPerMonth(fillType)
local data = ADChain ~= nil and ADChain.last ~= nil and ADChain.last.data or nil
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or nil
return data ~= nil and name ~= nil and (data.animalDemand or {})[name] or 0
end
function ADSmartPickup.factoryMayGet(adEnv, farmId, fillType, loadCapacity)
local perMonth = animalPerMonth(fillType)
if perMonth <= 0 or ADStorageStats == nil or ADStorageStats.availableTotals == nil then return true end
local ok, totals = pcall(function() return ADStorageStats.availableTotals(ADSources.getFarmInventory(adEnv, farmId)) end)
if not ok or totals == nil then return true end
return ADSupplyPlanner.mayFeedFactory(totals[fillType] or 0, perMonth, loadCapacity)
end
-- Liter af varen på traktorens vogne (rest fra sidste læs).
local function carriedLiters(adEnv, driver, fillType)
local total = 0
pcall(function()
for _, unit in ipairs(adEnv.AutoDrive.getAllUnits(driver) or {}) do
if unit.getFillUnits ~= nil then
for index in ipairs(unit:getFillUnits() or {}) do
if unit:getFillUnitFillType(index) == fillType then total = total + (unit:getFillUnitFillLevel(index) or 0) end
end
end
end
end)
return total
end
ADSmartPickup.carriedLiters = carriedLiters
-- Køb dyrefoder ved en købestation, når intet eget lager kan levere: første tilladte trug-behov i rækkefølgen.
-- Aldrig når vognen allerede har varen (in-game 8/10: EDK 650 på 1 mio. l blev fyldt ved Solid Buy, truget tog
-- 150.000 l — med 848.000 l rest ville den købe igen i stedet for at aflevere resten).
-- held (valgfri): behov findSupplyPickup holder tilbage; "trigger" = triggeren ved målmarkøren tager ikke varen
-- (in-game 25/10: TMR købt til '102 Cow Barn Straw', halmtriggeren afviste den, Kostald 3 sultede).
local boughtLoggedAt = setmetatable({}, {__mode = "k"})
function ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint, wayPointId, held)
if ADFieldWork == nil or ADFieldWork.findBuyMarker == nil or targetWayPoint == nil then
buyMissReason[driver] = "intet mål"
return nil
end
local function fillName(fillType) return tostring(g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or fillType) end
for _, need in ipairs(ranked or {}) do
local carried = need.trough and carriedLiters(adEnv, driver, need.fillType) or 0
if carried > 0 then
buyMissReason[driver] = string.format("vognen har stadig %.0f l %s", carried, fillName(need.fillType))
return nil
end
end
local reasons, triggerHeld = {}, 0
for _, need in ipairs(ranked or {}) do
if need.trough and (held or {})[need] == "trigger" then triggerHeld = triggerHeld + 1 end
if need.trough and (held or {})[need] ~= "trigger"
and (ADSupplyPlanner.isFoodAllowed == nil or ADSupplyPlanner.isFoodAllowed(need, bestFood)) then
local markerId, info = ADFieldWork.findBuyMarker(adEnv, driver, need.fillType, targetWayPoint.x, targetWayPoint.z, driver.ad == nil)
local marker = markerId ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(markerId) or nil
if marker == nil and #reasons < 4 then
info = info or {}
table.insert(reasons, string.format("%s: %d stationer sælger, %d med markør, %d med rute%s", fillName(need.fillType),
info.stations or 0, info.withMarker or 0, info.withRoute or 0, info.error ~= nil and (" (fejl " .. info.error .. ")") or ""))
end
if marker ~= nil then
buyMissReason[driver] = nil
local t = g_currentMission ~= nil and g_currentMission.time or 0
if boughtLoggedAt[driver] == nil or t - boughtLoggedAt[driver] > 5 * 60 * 1000 then
boughtLoggedAt[driver] = t
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s' intet eget lager med %s — KØBER ved '%s' (dyrene skal have foder)",
tostring(ADRuns.vehicleLabel(driver)), tostring(g_fillTypeManager:getFillTypeNameByIndex(need.fillType)), tostring(marker.name))
end
return {markerIndex = marker.markerIndex, markerId = marker.id, targetWayPointId = wayPointId, markerName = marker.name,
group = marker.group, level = math.huge, isOwn = false, fillTypes = {need.fillType}, fillType = need.fillType, need = need,
pendingLiters = need.freeSpace, bought = true}
end
end
end
buyMissReason[driver] = #reasons > 0 and table.concat(reasons, "; ")
or triggerHeld > 0 and string.format("%d trug-varer afvist: triggeren ved målmarkøren tager dem ikke", triggerHeld)
or "intet trug-foder mangler"
return nil
end
-- Hvad kunne vognen hente? Som findSupplyPickup, men uden at registrere et behov (til parkerede vogne:
-- ADWagonSwap og dvale-tjekket). -> valg eller nil
function ADSmartPickup.probeSupplyPickup(adEnv, cargo, ingredients, targetWayPointId)
probing = true
local ok, choice = pcall(ADSmartPickup.findSupplyPickup, adEnv, cargo, ingredients, targetWayPointId)
probing = false
if not ok then error(choice, 0) end
return choice
end
function ADSmartPickup.findSupplyPickup(adEnv, driver, ingredients, targetWayPointId)
-- med eksplicit mål bruges AD's tilstand ikke (dvale-tjekket kalder med flowets parkerede vogn, der ingen .ad har)
local wayPointId = targetWayPointId
if wayPointId == nil then
local secondMarker = driver.ad.stateModule:getSecondMarker()
wayPointId = secondMarker ~= nil and secondMarker.id or nil
end
local farmId = getFarmId(driver)
if wayPointId == nil or farmId == nil then
return nil
end
local targetWayPoint = adEnv.ADGraphManager:getWayPointById(wayPointId)
local target = targetWayPoint ~= nil and getUnloadStationAtMarker(adEnv, targetWayPoint, farmId) or nil
if target == nil then
return nil
end
-- Er målet en fabrik med ønskede produktioner, følger listen fabrikken —
-- brugerens multi-valg er kun tændknappen (og gendannes ved stop).
local demand = getProductionDemand(adEnv, target, driver)
if next(demand) ~= nil then
ingredients = getDemandFillTypes(demand)
factoryFallbackLogged[driver] = nil
elseif getProductionPoint(target) ~= nil then
local parkedAutoload = driver.ad == nil and ADPool ~= nil and ADPool.hasAutoload ~= nil and ADPool.hasAutoload(driver)
ingredients = ADSmartPickup.carriableIngredients(ingredients, ADRunsController.getCarriableFillTypes(adEnv, driver), parkedAutoload)
if ingredients[1] == nil then
logFactoryFallbackOnce(driver, target, "vognen kan ikke bære flowets varer — skift vogn, eller slå Autoload fra")
return nil
end
logFactoryFallbackOnce(driver, target, "bruger dit varevalg")
end
local allMarkers = adEnv.ADGraphManager:getMapMarkers()
local markerStations = collectMarkerStations(adEnv, allMarkers, farmId, target.owningPlaceable)
local sourceTiers
sourceTiers, markerStations = ADSmartPickup.restrictSupplySources(adEnv, markerStations, target.owningPlaceable)
local loadCapacity = getLoadCapacity(adEnv, driver)
local needs = ADSupplyPlanner.applyPending(getTargetNeeds(target, ingredients, farmId, demand), ADSmartPickup.getPending(wayPointId, driver))
local ranked = ADSupplyPlanner.rankNeeds(needs, loadCapacity)
-- bedste foder først: lavere foder kun når truget er nødlidende (ADSupplyPlanner.isFoodAllowed)
local bestFood = ADSupplyPlanner.bestFoodPriority ~= nil and ADSupplyPlanner.bestFoodPriority(ranked) or nil
-- fabrik som mål: varer dyrene spiser kun når siloerne dækker dyrene først (8/10)
local feedsFactory = getProductionPoint(target) ~= nil
local held = {}
-- stald-silo som mål: TMR så længe gården har et læs TMR, ellers næste foder på prioriteringslisten (10/10)
local _, stableWeights = ADSmartPickup.getStableSiloFillTypes(adEnv, {{station = target}}, farmId)
if stableWeights ~= nil and next(stableWeights) ~= nil then
local allowed = ADSupplyPlanner.stableFoodAllowed(stableWeights, function(fillType)
return findBestSourceTiered(sourceTiers, {fillType}, farmId, loadCapacity, {freeSpace = math.huge}) ~= nil
end)
for _, need in ipairs(ranked) do
if stableWeights[need.fillType] ~= nil and not allowed[need.fillType] then held[need] = "stable" end
end
end
for _, need in ipairs(ranked) do
if feedsFactory and not ADSmartPickup.factoryMayGet(adEnv, farmId, need.fillType, loadCapacity) then held[need] = true end
end
-- kun varer triggeren ved MÅLMARKØREN tager: stationens behov gælder hele bygningen (in-game 16/10: 'Cow Food 2'
-- hentede FORAGE til "Cow Barn Straw", fordi Kostald 3's fodertrug manglede foder — halmtriggeren tager ikke foder)
-- kun stalde (fodertrug ved siden af halm/gylle/mælk): fabrikker med spredte ingredienstriggere røres ikke (review)
if not feedsFactory and getHusbandry(target) ~= nil then
local takesByType = {}
for _, need in ipairs(ranked) do
if not held[need] then
if takesByType[need.fillType] == nil then
local okTakes, takes = pcall(ADSmartPickup.markerTriggerAccepts, adEnv, wayPointId, need.fillType, farmId)
takesByType[need.fillType] = not (okTakes and takes == false)
end
if not takesByType[need.fillType] then held[need] = "trigger" end
end
end
-- bedste foder blandt dem der kan leveres her (et holdt foder må ikke spærre for de lavere)
if ADSupplyPlanner.bestFoodPriority ~= nil then
local open = {}
for _, need in ipairs(ranked) do if held[need] ~= "trigger" then table.insert(open, need) end end
bestFood = ADSupplyPlanner.bestFoodPriority(open)
end
end
for _, need in ipairs(ranked) do
local choice = not held[need] and (ADSupplyPlanner.isFoodAllowed == nil or ADSupplyPlanner.isFoodAllowed(need, bestFood))
and findBestSourceTiered(sourceTiers, {need.fillType}, farmId, loadCapacity, need) or nil
if choice ~= nil then
-- retfærdig fordeling af gårdens lager mellem alle, der mangler varen lige nu (brugerønske 10/10)
local pending = math.min(loadCapacity or math.huge, choice.level or math.huge, need.freeSpace or math.huge)
-- behovet er det, denne tur kan tage (vognens størrelse), ikke målets samlede frie plads: ellers tæller en
-- 20 mio. l-silo som ét kæmpe behov, og alle andre får smuler (in-game 10/10: 3.110 l af 334.730 l)
local tripNeed = math.min(need.freeSpace or math.huge, loadCapacity or math.huge)
if tripNeed == math.huge then tripNeed = need.freeSpace or 0 end
-- en prøve (parkeret vogn: ADWagonSwap/dvalen) registrerer intet behov — ellers deler de andre traktorer
-- lageret med en vogn, der ikke kører (review 18/10)
local totalFree, others = tripNeed, 0
if not probing then totalFree, others = registerDemand(need.fillType, driver, tripNeed) end
if choice.isOwn and others > 0 then
local share = ADSupplyPlanner.fairShare(choice.level or 0, tripNeed, totalFree)
if share < pending then
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s': %s deles med %d andre behov — tager %.0f l af %.0f l i %s",
tostring(ADRuns.vehicleLabel(driver)), tostring(g_fillTypeManager:getFillTypeNameByIndex(need.fillType)), others, share, choice.level or 0, tostring(choice.markerName))
pending = math.max(share, ADSmartPickup.MIN_USEFUL_LITERS or 0)
end
end
return {
markerIndex = choice.markerIndex,
markerId = choice.markerId,
targetWayPointId = wayPointId,
-- det der reelt kommer af: vognen, kildens beholdning og målets fri plads sætter grænsen
pendingLiters = pending,
markerName = choice.markerName,
group = choice.group,
level = choice.level,
station = choice.station,
isOwn = choice.isOwn,
fillTypes = choice.fillTypes,
prefersFullest = choice.prefersFullest,
fillType = need.fillType,
need = need,
}
end
end
-- dyrene skal have foder: intet eget lager -> køb ved en købestation (sidste udvej, 8/10)
local bought = ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint, wayPointId, held)
if bought ~= nil then return bought end
local okLog, errLog = pcall(logSupplyMiss, driver, ranked, bestFood, markerStations, farmId, held)
if not okLog then Logging.warning(ADSmartPickup.LOG_PREFIX .. "forsynings-diagnose: %s", tostring(errLog)) end
return nil
end
local function applySupplyChoice(driver, ingredients, choice)
local stateModule = driver.ad.stateModule
ADSmartPickup.setEnRoute(driver, choice.targetWayPointId, choice.fillType, choice.pendingLiters)
stateModule:setFillType(choice.fillType)
stateModule.selectedFillTypes = {choice.fillType}
stateModule:raiseDirtyFlag()
supplyState[driver] = {ingredients = ingredients, narrowedTo = choice.fillType}
end
-- Ingredienslisten for køretøjet: run'ets liste når det er i et run (ingen tændknap
-- nødvendig), ellers AD's multi-valg (>1 vare). nil = ingen behovsstyring.
-- Den silo og vare moden sidst sendte køretøjet efter (til overblikket); nil = ingen.
function ADSmartPickup.getActivePickup(vehicle)
local pickup = activePickups[vehicle]
if pickup == nil then
return nil
end
return {markerName = pickup.markerName, fillType = pickup.fillType}
end
-- Udkørslens opsamlingsrunde skifter kilde midt i en tur: grebet ("stå og læs ved markøren")
-- følger med til den nye kilde. choice = {station, fillTypes, markerName, fillType} eller nil.
function ADSmartPickup.setActivePickup(vehicle, choice)
if choice == nil or choice.station == nil then
activePickups[vehicle] = nil
return
end
activePickups[vehicle] = {station = choice.station, fillTypes = choice.fillTypes or {}, markerName = choice.markerName, fillType = choice.fillType or (choice.fillTypes or {})[1]}
end
function ADSmartPickup.getIngredientsFor(adEnv, driver)
local run = ADRunsController ~= nil and activeRunOf(driver) or nil
if run ~= nil then
local ingredients = ADRunsController.getRunIngredients(adEnv, run, driver)
if #ingredients > 0 then
return ingredients
end
return nil
end
return ADSupplyPlanner.resolveIngredients(supplyState[driver], driver.ad.stateModule:getSelectedFillTypes())
end
-- Ved turens start sættes AD's aflæsningsmål til run'ets mål — ved flere mål den stald der
-- mangler mest; ved ét mål gendannes det (fx efter at forkert last er læsset af i en silo).
-- AD læser først målet når vognen er læsset, så skiftet her gælder for hele turen.
local function chooseRunTarget(adEnv, driver)
local run = ADRunsController ~= nil and activeRunOf(driver) or nil
if run ~= nil and ADRunsController.resolveMarkers ~= nil then
pcall(ADRunsController.resolveMarkers, adEnv, run)
end
if run == nil or ADRunsController.chooseTarget == nil or #ADRunsController.getRunTargets(run) < 1 then
return
end
-- Er AD's mål midlertidigt en silo (forkert last læsses af), må det ikke røres nu.
if ADUnloadWait ~= nil and ADUnloadWait.getPendingTargetRestore ~= nil and ADUnloadWait.getPendingTargetRestore(driver) ~= nil then
return
end
local stateModule = driver.ad.stateModule
local targetId = ADRunsController.chooseTarget(adEnv, run, driver)
local current = stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
if targetId == nil or stateModule.setSecondMarkerByWayPointId == nil or (current ~= nil and current.id == targetId) then
return
end
stateModule:setSecondMarkerByWayPointId(targetId)
local marker = adEnv.ADGraphManager.getMapMarkerByWayPointId ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(targetId) or nil
local why = #ADRunsController.getRunTargets(run) > 1 and "mangler mest af run'ets mål" or "run'ets mål"
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s' kører til %s (%s)", tostring(ADRuns.vehicleLabel(driver)), marker ~= nil and tostring(marker.name) or tostring(targetId), why)
end
local tryOtherRunTargets
-- Det valgte mål har intet der kan hentes (kilden er tom, eller andre traktorer har allerede læs på vej
-- til det): prøv run'ets ANDRE mål, og skift AD's aflæsningsmål til det første der kan forsynes.
-- Ellers holdt traktoren ved Wait mens fx fire andre DOB'er ved samme biogasanlæg stod tomme.
tryOtherRunTargets = function(adEnv, driver, ingredients)
local run = ADRunsController ~= nil and activeRunOf(driver) or nil
if run == nil or (run.kind or "supply") ~= "supply" then
return nil
end
-- AD's mål er midlertidigt en silo (forkert last læsses af): rør det ikke
if ADUnloadWait ~= nil and ADUnloadWait.getPendingTargetRestore ~= nil and ADUnloadWait.getPendingTargetRestore(driver) ~= nil then
return nil
end
local stateModule = driver.ad.stateModule
local current = stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
local currentId = current ~= nil and current.id or nil
for _, targetId in ipairs(ADRunsController.getRunTargets(run)) do
if targetId ~= currentId then
local choice = ADSmartPickup.findSupplyPickup(adEnv, driver, ingredients, targetId)
if choice ~= nil and stateModule.setSecondMarkerByWayPointId ~= nil then
stateModule:setSecondMarkerByWayPointId(targetId)
local marker = adEnv.ADGraphManager.getMapMarkerByWayPointId ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(targetId) or nil
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s' kører til %s (intet at hente til %s)", tostring(ADRuns.vehicleLabel(driver)),
marker ~= nil and tostring(marker.name) or tostring(targetId), current ~= nil and tostring(current.name) or "?")
return choice
end
end
end
return nil
end
-- Samlet valg: behovsstyret med ingrediensliste, ellers mappe-logik. nil = AutoDrives original.
function ADSmartPickup.choosePickup(adEnv, driver)
enRoute[driver] = nil -- ny tur: forrige læs er leveret (eller opgivet)
chooseRunTarget(adEnv, driver)
local ingredients = ADSmartPickup.getIngredientsFor(adEnv, driver)
if ingredients == nil then
supplyState[driver] = nil
return ADSmartPickup.findLeastFilledPickup(adEnv, driver)
end
local choice = ADSmartPickup.findSupplyPickup(adEnv, driver, ingredients)
if choice == nil then
choice = tryOtherRunTargets(adEnv, driver, ingredients)
end
-- én traktor, flere vogne: skal en anden af traktorens vogne køre turen? Skiftet udføres i ADWagonSwap.tick
if ADWagonSwap ~= nil and ADWagonSwap.consider ~= nil then
local okSwap, swapped = pcall(ADWagonSwap.consider, adEnv, driver, activeRunOf(driver), choice)
if not okSwap then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "vogneskift-tjek fejlede: %s", tostring(swapped))
elseif swapped then
supplyState[driver] = nil
return nil
end
end
if choice == nil then
-- Traktor i et forsynings-run uden noget (tilladt) at hente: hold ved Wait og prøv igen, i stedet
-- for at falde tilbage til mappe-logikken (den henter hvad som helst, fx ensilage i et halvfuldt trug).
local run = ADRunsController ~= nil and activeRunOf(driver) or nil
if run ~= nil and (run.kind or "supply") == "supply" and ADOutbound ~= nil and ADOutbound.holdSupplyVehicle ~= nil then
local replan = function()
local list = ADSmartPickup.getIngredientsFor(adEnv, driver)
local next = list ~= nil and ADSmartPickup.findSupplyPickup(adEnv, driver, list) or nil
if next == nil then
return nil
end
applySupplyChoice(driver, list, next)
activePickups[driver] = {station = next.station, fillTypes = next.fillTypes, markerName = next.markerName, fillType = next.fillType}
return next.markerId
end
local held = ADOutbound.holdSupplyVehicle(adEnv, driver, run, {"intet at hente til nogen af run'ets mål (tom kilde, læs på vej, eller bedste foder mangler)"}, replan)
if held ~= nil then
return held
end
end
return ADSmartPickup.findLeastFilledPickup(adEnv, driver)
end
applySupplyChoice(driver, ingredients, choice)
return choice
end
local function describeChoice(choice)
local source = choice.isOwn and "eget lager" or "nabo-lager"
source = source .. (choice.prefersFullest and ", fyldeste først" or ", mindst fyldte først")
if choice.fillType == nil then
return string.format("%.0f l, %s", choice.level, source)
end
local fillTypeName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(choice.fillType) or tostring(choice.fillType)
local urgency = ""
if choice.need.minutesToEmpty ~= nil then
urgency = string.format(", fabrikken bruger %.0f l/min = %.0f min til tom", choice.need.litersPerMinute, choice.need.minutesToEmpty)
end
if choice.need.fits == false then
urgency = urgency .. ", et fuldt læs passer IKKE (rest ventes ved Wait-punkt)"
end
return string.format("%s: kilde %.0f l, %s, målet har %.0f/%.0f l%s", tostring(fillTypeName), choice.level, source, choice.need.level, choice.need.capacity, urgency)
end
local function logChoiceOnce(driver, choice)
local message = string.format("'%s' -> %s (%s)", tostring(ADRuns.vehicleLabel(driver)), tostring(choice.markerName), describeChoice(choice))
if lastLogged[driver] ~= message then
lastLogged[driver] = message
logInfo(ADSmartPickup.LOG_PREFIX .. "%s", message)
end
end
-- Sendte moden køretøjet til en silo der stadig har varen? Så skal AutoDrive
-- stå og læsse dér; løber kilden tør, slippes grebet og turen fortsætter.
function ADSmartPickup.shouldWaitForLoading(vehicle)
local pickup = activePickups[vehicle]
if pickup == nil then
return false
end
-- kun FREMME ved markøren: undervejs ruller vognen gennem nabosiloers triggere,
-- og dér skal AutoDrives rotation gælde (kør videre ved tom trigger).
local drivePathModule = vehicle.ad ~= nil and vehicle.ad.drivePathModule or nil
if drivePathModule == nil or not drivePathModule:isTargetReached() then
return false
end
local level = getStationFillLevel(pickup.station, pickup.fillTypes, getFarmId(vehicle))
return level >= ADSmartPickup.MIN_USEFUL_LITERS
end
-- Med "Rotér mål" + mapper afslutter AutoDrive pålæsningen i det øjeblik markøren
-- nås (LoadAtDestinationTask: rotation = "prøv næste silo", aldrig vente). Moden
-- har valgt en silo der HAR varen, så under opgavens update ser AutoDrive
-- rotationen som slået fra for netop det køretøj -> den står og læsser som normalt.
local function installLoadWaitHook(adEnv)
local task, autoDrive = adEnv.LoadAtDestinationTask, adEnv.AutoDrive
if task == nil or task.update == nil or autoDrive == nil or autoDrive.getSetting == nil then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "kunne ikke koble på pålæsningsopgaven; traktoren venter ikke ved siloen")
return
end
local originalGetSetting, originalUpdate = autoDrive.getSetting, task.update
local waitingVehicle = nil
-- "fortsæt ved tom silo" afslutter også pålæsningen straks ved en egnet trigger (in-game 10/10: Milk Run og slurry
-- stod i boksen med varen i kilden og alle AD's porte grønne — fortsætTom=true; de læssede ingen steder)
autoDrive.getSetting = function(settingName, vehicle)
if waitingVehicle ~= nil and vehicle == waitingVehicle then
if settingName == "rotateTargets" then return autoDrive.RT_NONE end
if settingName == "continueOnEmptySilo" then return false end
end
return originalGetSetting(settingName, vehicle)
end
-- true når vognen ikke er blevet fyldt i MAX_WAIT_WITHOUT_LOADING_MS ved markøren
local function hasLoadingStalled(loadTask, dt)
local pickup = activePickups[loadTask.vehicle]
local fillLevel = autoDrive.getAllFillLevels ~= nil and autoDrive.getAllFillLevels(loadTask.trailers) or 0
if pickup.lastFillLevel == nil or fillLevel > pickup.lastFillLevel then
pickup.lastFillLevel, pickup.stalledMs = fillLevel, 0
return false
end
pickup.stalledMs = pickup.stalledMs + dt
return pickup.stalledMs > ADSmartPickup.MAX_WAIT_WITHOUT_LOADING_MS
end
-- Vognen kan kun læsse oven i SAMME vare. Er der en anden vare på vognen (rest fra et
-- tidligere run), afsluttes pålæsningen med det samme, så AD kører til aflæsning med
-- det den har — dér tager Wait-/bytte-logikken over, hvis målet ikke tager varen.
local function hasWrongCargo(loadTask)
if loadTask.spuCargoChecked or ADUnloadWait == nil or ADUnloadWait.getRestLoad == nil then
return false
end
loadTask.spuCargoChecked = true
local pickup = activePickups[loadTask.vehicle]
if pickup == nil or pickup.fillType == nil then
return false
end
local fillType, liters = ADUnloadWait.getRestLoad(adEnv, loadTask.vehicle)
if fillType == nil or liters < 100 or fillType == pickup.fillType then
return false
end
local cargoName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
local wantedName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(pickup.fillType) or tostring(pickup.fillType)
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s' har %.0f l %s på vognen og skulle hente %s — leverer først det den har", tostring(ADRuns.vehicleLabel(loadTask.vehicle)), liters, tostring(cargoName), tostring(wantedName))
-- hører lasten ikke til run'et (fx gødning i et ensilage-run), køres den til en silo der tager den
local run = ADRunsController ~= nil and activeRunOf(loadTask.vehicle) or nil
if run ~= nil and ADRunsController.findWrongCargoDump ~= nil and ADUnloadWait.setDumpTarget ~= nil then
local stateModule = loadTask.vehicle.ad.stateModule
local current = stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
local ok, dump = pcall(ADRunsController.findWrongCargoDump, adEnv, run, loadTask.vehicle, current ~= nil and current.id or nil, true)
if ok and dump ~= nil then
ADUnloadWait.setDumpTarget(loadTask.vehicle, dump.marker.id)
end
end
return true
end
-- Vognen er parkeret med læs og hentet igen (ADFlowWagons, 19/10): læsset leveres FØR der hentes mere — pålæsningen
-- afsluttes straks, så AD kører til aflæsning (ét tjek pr. opgave)
local function isParkedLoadFirst(loadTask)
if loadTask.spuParkedChecked or ADFlowWagons == nil or ADFlowWagons.isDeliveringParkedLoad == nil then return false end
loadTask.spuParkedChecked = true
if not ADFlowWagons.isDeliveringParkedLoad(adEnv, loadTask.vehicle) then return false end
-- en ANDEN vare end den, der skal hentes: som blandet last (hasWrongCargo) — kan målene ikke tage den, køres den
-- på lager, så flowet kan hente det, der mangler (in-game 26/10: parkeret hø blokerede ensilagen til TMR-fabrikkerne)
local pickup = activePickups[loadTask.vehicle]
local cargoType = ADUnloadWait ~= nil and ADUnloadWait.getRestLoad ~= nil and ADUnloadWait.getRestLoad(adEnv, loadTask.vehicle) or nil
if pickup ~= nil and pickup.fillType ~= nil and cargoType ~= nil and cargoType ~= pickup.fillType then return false end
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s' leverer parkeret læs først", tostring(ADRuns.vehicleLabel(loadTask.vehicle)))
return true
end
task.update = function(self, dt)
local parkedOk, isParked = pcall(isParkedLoadFirst, self)
if parkedOk and isParked and self.finished ~= nil then
activePickups[self.vehicle] = nil
self:finished()
return
end
local wrongOk, isWrong = pcall(hasWrongCargo, self)
if wrongOk and isWrong then
activePickups[self.vehicle] = nil
if self.finished ~= nil then
self:finished()
return
end
end
local ok, shouldWait = pcall(ADSmartPickup.shouldWaitForLoading, self.vehicle)
shouldWait = ok and shouldWait
if shouldWait then
local stalledOk, isStalled = pcall(hasLoadingStalled, self, dt)
if not stalledOk or isStalled then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "'%s' læsser ikke ved markøren; slipper grebet så AutoDrive kører videre", tostring(ADRuns.vehicleLabel(self.vehicle)))
activePickups[self.vehicle] = nil
shouldWait = false
end
end
waitingVehicle = shouldWait and self.vehicle or nil
local updateOk, err = pcall(originalUpdate, self, dt)
waitingVehicle = nil
if not updateOk then
error(err, 0)
end
end
end
-- Forsyningskørsel uden noget at hente: AD's nuværende 1. markør (markørindeks), så AD ikke roterer videre i mappen.
-- nil for traktorer uden for en forsyningskørsel (så gælder AD's egen rotation som før).
local stayLogged = setmetatable({}, {__mode = "k"})
function ADSmartPickup.stayAtCurrentPickup(driver)
local run = ADRunsController ~= nil and ADRunsController.getRunForVehicle ~= nil and activeRunOf(driver) or nil
if run == nil or (run.kind or "supply") ~= "supply" then return nil end
local stateModule = driver.ad ~= nil and driver.ad.stateModule or nil
local first = stateModule ~= nil and stateModule.getFirstMarker ~= nil and stateModule:getFirstMarker() or nil
if first == nil or first.markerIndex == nil then return nil end
if stayLogged[driver] ~= first.markerIndex then
stayLogged[driver] = first.markerIndex
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s': intet at hente lige nu — bliver ved '%s' (ikke AutoDrives mappe-rotation)", tostring(ADRuns.vehicleLabel(driver)), tostring(first.name))
end
return first.markerIndex
end
local function installHook(adEnv)
local manager = adEnv.ADMultipleTargetsManager
local originalGetNextPickup = manager.getNextPickup
manager.getNextPickup = function(self, driver, forcedSkip)
-- Udkørsel: turvalg (kilde + mål + varer) eller Wait-punkt fra ADOutbound.
if ADOutbound ~= nil and ADOutbound.isOutboundVehicle(driver) then
local okOut, outChoice = pcall(ADOutbound.choosePickup, adEnv, driver)
if not okOut then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "fejl i udkørsel, bruger AutoDrives rotation: %s", tostring(outChoice))
activePickups[driver] = nil
return originalGetNextPickup(self, driver, forcedSkip)
end
if outChoice == nil then
activePickups[driver] = nil
return originalGetNextPickup(self, driver, forcedSkip)
end
ADSmartPickup.setActivePickup(driver, outChoice)
self.pickups[outChoice.group] = self.pickups[outChoice.group] or {}
self.pickups[outChoice.group].lastTarget = outChoice.markerIndex
self.pickups[outChoice.group].lastVehicle = driver
return outChoice.markerIndex
end
local ok, choice = pcall(ADSmartPickup.choosePickup, adEnv, driver)
if not ok then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "fejl i silo-opslag, bruger AutoDrives rotation: %s", tostring(choice))
activePickups[driver] = nil
return originalGetNextPickup(self, driver, forcedSkip)
end
if choice == nil then
activePickups[driver] = nil
-- forsyningskørsel uden noget at hente: bliv ved den nuværende pålæsning i stedet for AD's mappe-rotation,
-- der tager næste markør i mappen (in-game 10/10: Fill Cow Silos kørte til Cow 4 Milk/Slurry)
local stay = ADSmartPickup.stayAtCurrentPickup(driver)
if stay ~= nil then return stay end
return originalGetNextPickup(self, driver, forcedSkip)
end
activePickups[driver] = choice.station ~= nil and {station = choice.station, fillTypes = choice.fillTypes, markerName = choice.markerName, fillType = choice.fillType or choice.fillTypes[1]} or nil
-- hold AutoDrives egen rotations-tilstand konsistent med vores valg
self.pickups[choice.group] = self.pickups[choice.group] or {}
self.pickups[choice.group].lastTarget = choice.markerIndex
self.pickups[choice.group].lastVehicle = driver
if choice.level ~= nil then
logChoiceOnce(driver, choice) -- et hold ved Wait logges af ADOutbound
end
return choice.markerIndex
end
installLoadWaitHook(adEnv)
if ADWaitPool ~= nil and ADWaitPool.install ~= nil then
ADWaitPool.install(adEnv) -- rutesvar glemmes ved indlæsning og når AD-vejnettet redigeres
end
if ADUnloadWait ~= nil then
ADUnloadWait.install(adEnv)
end
-- efter Wait-logikken: rulningen ligger yderst og springer den over, mens toget ruller frem
if ADTriggerLock ~= nil and ADTriggerLock.install ~= nil then
local okLock, errLock = pcall(ADTriggerLock.install, adEnv)
if not okLock then Logging.warning(ADSmartPickup.LOG_PREFIX .. "trigger-lås kunne ikke installeres: %s", tostring(errLock)) end
end
if ADUnloadRoll ~= nil and ADUnloadRoll.install ~= nil then
ADUnloadRoll.install(adEnv)
end
if ADOutbound ~= nil and ADOutbound.install ~= nil then
ADOutbound.install(adEnv)
end
if ADMarkerGuard ~= nil then
local okGuard, errGuard = pcall(ADMarkerGuard.install, ADMarkerGuard.gameEnv(adEnv))
if not okGuard then Logging.warning(ADSmartPickup.LOG_PREFIX .. "markørvagt kunne ikke installeres: %s", tostring(errGuard)) end
end
if ADParkGuard ~= nil then
local okPark, errPark = pcall(ADParkGuard.install, adEnv)
if not okPark then Logging.warning(ADSmartPickup.LOG_PREFIX .. "parkeringsvagt kunne ikke installeres: %s", tostring(errPark)) end
end
if ADHitchCreep ~= nil and ADHitchCreep.install ~= nil then
ADHitchCreep.install(adEnv)
end
if ADHitchApproach ~= nil and ADHitchApproach.install ~= nil then
ADHitchApproach.install(adEnv)
end
if ADLoadDiag ~= nil and ADLoadDiag.install ~= nil then
ADLoadDiag.install(adEnv)
end
-- yderst: mens toget ruller frem til læssetriggeren, springes udkørslens "intet at læsse"-tælling og diagnosen over
if ADLoadRoll ~= nil and ADLoadRoll.install ~= nil then
ADLoadRoll.install(adEnv)
end
logInfo(ADSmartPickup.LOG_PREFIX .. "aktiv (mindst fyldte silo med varen; flere valgte varer = behovsstyret forsyning; Wait-punkter for rest-læs; udkørsel til silo/salg)")
end
-- Når AutoDrive stopper, får køretøjet hele ingredienslisten tilbage i varevalget
-- (AutoDrive gemmer valget i savegame, så listen overlever også en genindlæsning).
local function restoreStoppedVehicles()
-- en standset traktor må ikke tage "stå og læs"-grebet med over i næste opgave
for vehicle in pairs(activePickups) do
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if stateModule == nil or stateModule.isActive == nil or not stateModule:isActive() then
activePickups[vehicle] = nil
end
end
for vehicle in pairs(enRoute) do
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if stateModule == nil or stateModule.isActive == nil or not stateModule:isActive() then
enRoute[vehicle] = nil
end
end
for vehicle, state in pairs(supplyState) do
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if stateModule == nil or not stateModule:isActive() then
supplyState[vehicle] = nil
local selected = stateModule ~= nil and stateModule:getSelectedFillTypes() or nil
if type(selected) == "table" and #selected == 1 and selected[1] == state.narrowedTo then
stateModule.selectedFillTypes = ADSupplyPlanner.copyList(state.ingredients)
stateModule:raiseDirtyFlag()
end
end
end
end
-- Tilføjer fanen SIDST i ESC-menuen (mønster fra FS25_FarmManager/Courseplay). Siden skal
-- først være barn af PagingElement, ellers mangler den i idPageHash og rebuildTabList
-- fejler. Omrokering af siderne forskyder fane↔side-koblingen (sidebjælkens markering
-- hoppede), så positionen er den samme overalt: efter de eksisterende sider.
local function insertInGameMenuPage(frame, pageName, iconFile, iconUVs, predicate)
local inGameMenu = g_gui ~= nil and g_gui.screenControllers ~= nil and g_gui.screenControllers[InGameMenu] or nil
if inGameMenu == nil or inGameMenu.pagingElement == nil or inGameMenu.pageFrames == nil then
return false
end
local position = #inGameMenu.pageFrames + 1
if inGameMenu.controlIDs ~= nil then
inGameMenu.controlIDs[pageName] = nil
end
if inGameMenu.exposeControlsAsFields ~= nil then
inGameMenu:exposeControlsAsFields({pageName})
end
inGameMenu[pageName] = frame
inGameMenu.pagingElement:addElement(frame)
-- Lige over spillets Indstillinger (brugerønske 29/9). Siden flyttes på ALLE tre lister med samme indeks
-- (sider, pagerens sider, pageFrames) som FS25_FarmOperationsDashboard — at flytte kun nogle af dem gav
-- tidligere forskudt fane↔side. Uden Indstillinger-side: sidst som før.
local target = 0
for i, child in ipairs(inGameMenu.pagingElement.elements) do
if inGameMenu.pageSettings ~= nil and child == inGameMenu.pageSettings then
target = i
break
end
end
local function moveTo(list, matches)
if target == 0 or list == nil then return end
for i, child in ipairs(list) do
if matches(child) then
table.remove(list, i)
table.insert(list, target, child)
return
end
end
end
moveTo(inGameMenu.pagingElement.elements, function(child) return child == frame end)
moveTo(inGameMenu.pagingElement.pages, function(child) return child.element == frame end)
inGameMenu.pagingElement:updateAbsolutePosition()
inGameMenu.pagingElement:updatePageMapping()
inGameMenu:registerPage(frame, position, predicate)
inGameMenu:addPageTab(frame, iconFile, iconUVs)
moveTo(inGameMenu.pageFrames, function(child) return child == frame end)
if frame.updateAbsolutePosition ~= nil then
frame:updateAbsolutePosition()
end
inGameMenu:rebuildTabList()
return true
end
local function loadGui()
if g_gui == nil or SmartPickupFrame == nil or ADSmartPickup.dir == nil then
return
end
g_gui:loadProfiles(ADSmartPickup.dir .. "gui/guiProfiles.xml")
local frame = SmartPickupFrame.new(g_i18n, getAutoDriveEnv)
g_gui:loadGui(ADSmartPickup.dir .. "gui/SmartPickupFrame.xml", "smartPickupFrame", frame, true)
-- Eget faneikon i spillets stil (hvid streg på gennemsigtig baggrund, 1024×1024, DXT5).
local iconFile = Utils.getFilename("gui/menuIcon.dds", ADSmartPickup.dir)
local iconUVs = GuiUtils.getUVs({0, 0, 1024, 1024}, {1024, 1024})
if not insertInGameMenuPage(frame, "smartPickupFrame", iconFile, iconUVs, function() return g_currentMission ~= nil end) then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "kunne ikke indsætte fanen i ESC-menuen")
return
end
frame:initialize()
ADSmartPickup.guiFrame = frame
logInfo(ADSmartPickup.LOG_PREFIX .. "ESC-fane 'Smart Pickup' registreret")
end
function ADSmartPickup:loadMap()
local ok, err = pcall(loadGui)
if not ok then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "GUI kunne ikke indlæses (resten af moden virker): %s", tostring(err))
end
end
function ADSmartPickup:update(dt)
if ADProfiler ~= nil and ADProfiler.installed then
local now = ADProfiler.clock()
if now ~= nil then pcall(ADProfiler.frame, now) end
end
if not isHooked then
local adEnv = getAutoDriveEnv()
if adEnv ~= nil and g_currentMission ~= nil and g_currentMission.storageSystem ~= nil then
installHook(adEnv)
isHooked = true
if ADProfiler ~= nil then pcall(ADProfiler.install) end
if ADCache ~= nil then ADCache.enabled = true end
if ADRunsController ~= nil then
pcall(ADRunsController.load, adEnv)
pcall(ADRunsController.installSaveHook)
end
end
return
end
if ADUnloadWait ~= nil then
pcall(ADUnloadWait.releaseInactive)
if ADUnloadWait.adoptOrphansThrottled ~= nil then
ADUnloadWait.adoptOrphansThrottled(getAutoDriveEnv(), dt)
end
end
if ADOutbound ~= nil and ADOutbound.releaseInactive ~= nil then
pcall(ADOutbound.releaseInactive)
end
if ADLaunchGate ~= nil then ADLaunchGate.tick(dt) end
if ADRunsController ~= nil and ADRunsController.processStartQueue ~= nil then
pcall(ADRunsController.processStartQueue, getAutoDriveEnv(), dt)
end
if ADRunsController ~= nil and ADRunsController.stopBrokenThrottled ~= nil then
pcall(ADRunsController.stopBrokenThrottled, getAutoDriveEnv(), dt)
end
if ADRunsController ~= nil and ADRunsController.applyVehicleNamesThrottled ~= nil then
pcall(ADRunsController.applyVehicleNamesThrottled, getAutoDriveEnv(), dt)
end
-- marksiloer før markarbejdet: venter de på udsendelsesporten, får de den først (markarbejdet tjekker hvert sekund)
if ADFieldSilos ~= nil then
local okSilos, errSilos = pcall(ADFieldSilos.tick, getAutoDriveEnv(), dt)
if not okSilos then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "marksilo-flow fejlede: %s", tostring(errSilos))
end
end
if ADFillFold ~= nil then pcall(ADFillFold.tick, getAutoDriveEnv(), dt) end
if ADFieldJobs ~= nil then
local okFields, errFields = pcall(ADFieldJobs.tick, getAutoDriveEnv(), dt)
if not okFields then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "markarbejde fejlede: %s", tostring(errFields))
end
end
if ADAutoCrop ~= nil then
local okAuto, errAuto = pcall(ADAutoCrop.tick, getAutoDriveEnv(), dt)
if not okAuto then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "Alt automatisk-genplan fejlede: %s", tostring(errAuto))
end
end
if ADChain ~= nil then
local okChain, errChain = pcall(ADChain.tick, getAutoDriveEnv(), dt)
if not okChain then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "kæde fejlede: %s", tostring(errChain))
end
end
-- pausebevidst skridt (0 mens spillet er pauset, 1.62.328): koblingsture og flow-vogne må ikke tælle tid i menuen
local gameDt = (ADFieldJobs ~= nil and ADFieldJobs.frameDt) or dt
if ADFlowWagons ~= nil then
local okFlow, errFlow = pcall(ADFlowWagons.tick, getAutoDriveEnv(), gameDt)
if not okFlow then Logging.warning(ADSmartPickup.LOG_PREFIX .. "flow-vogne fejlede: %s", tostring(errFlow)) end
end
if ADWagonSwap ~= nil and getAutoDriveEnv() ~= nil then
local okSwap, errSwap = pcall(ADWagonSwap.tick, getAutoDriveEnv(), gameDt)
if not okSwap then Logging.warning(ADSmartPickup.LOG_PREFIX .. "vogneskift fejlede: %s", tostring(errSwap)) end
end
if ADBuildings ~= nil and ADBuildings.tickDump ~= nil then pcall(ADBuildings.tickDump, getAutoDriveEnv(), dt) end
if ADMarkerGuard ~= nil and getAutoDriveEnv() ~= nil then
local okGuard, errGuard = pcall(ADMarkerGuard.tick, ADMarkerGuard.gameEnv(getAutoDriveEnv()))
if not okGuard then Logging.warning(ADSmartPickup.LOG_PREFIX .. "markørvagt fejlede: %s", tostring(errGuard)) end
end
if ADParkGuard ~= nil and getAutoDriveEnv() ~= nil then
local okPark, errPark = pcall(ADParkGuard.tick, getAutoDriveEnv())
if not okPark then Logging.warning(ADSmartPickup.LOG_PREFIX .. "parkeringsvagt fejlede: %s", tostring(errPark)) end
end
if ADPlayerClaim ~= nil then
local okClaim, errClaim = pcall(ADPlayerClaim.tick, getAutoDriveEnv(), dt)
if not okClaim then Logging.warning(ADSmartPickup.LOG_PREFIX .. "spillerens maskine fejlede: %s", tostring(errClaim)) end
end
if ADFlowSleep ~= nil then
local okSleep, errSleep = pcall(ADFlowSleep.tick, getAutoDriveEnv(), dt)
if not okSleep then Logging.warning(ADSmartPickup.LOG_PREFIX .. "dvale fejlede: %s", tostring(errSleep)) end
end
if ADHitch ~= nil then
local okHitch, errHitch = pcall(ADHitch.tick, getAutoDriveEnv(), gameDt)
if not okHitch then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "kobling fejlede: %s", tostring(errHitch))
end
end
if ADStuckDiag ~= nil then pcall(ADStuckDiag.tick, dt) end
if ADCpFieldGuard ~= nil then
local okField, errField = pcall(ADCpFieldGuard.tick, dt)
if not okField then Logging.warning(ADSmartPickup.LOG_PREFIX .. "markgrænsevagt fejlede: %s", tostring(errField)) end
end
if ADTargetGuard ~= nil and getAutoDriveEnv() ~= nil then
local okTarget, errTarget = pcall(ADTargetGuard.tick, getAutoDriveEnv(), dt)
if not okTarget then Logging.warning(ADSmartPickup.LOG_PREFIX .. "aflæssestedsvagt fejlede: %s", tostring(errTarget)) end
end
if ADHeadOn ~= nil and getAutoDriveEnv() ~= nil then
local okHead, errHead = pcall(ADHeadOn.tick, getAutoDriveEnv(), dt)
if not okHead then Logging.warning(ADSmartPickup.LOG_PREFIX .. "modkørsel fejlede: %s", tostring(errHead)) end
end
if ADTriggerLock ~= nil then
local okLock, errLock = pcall(ADTriggerLock.tick, getAutoDriveEnv(), dt)
if not okLock then Logging.warning(ADSmartPickup.LOG_PREFIX .. "trigger-lås fejlede: %s", tostring(errLock)) end
end
if ADLivestock ~= nil and ADLivestock.tick ~= nil then
local okLive, errLive = pcall(ADLivestock.tick, getAutoDriveEnv(), dt)
if not okLive then Logging.warning(ADSmartPickup.LOG_PREFIX .. "dyretransport fejlede: %s", tostring(errLive)) end
end
if ADSaltRoute ~= nil and ADSaltRoute.tick ~= nil then
local okSalt, errSalt = pcall(ADSaltRoute.tick, getAutoDriveEnv(), dt)
if not okSalt then Logging.warning(ADSmartPickup.LOG_PREFIX .. "saltrute fejlede: %s", tostring(errSalt)) end
end
if ADStrayUnload ~= nil then
local okStray, errStray = pcall(ADStrayUnload.tick, getAutoDriveEnv(), dt)
if not okStray then Logging.warning(ADSmartPickup.LOG_PREFIX .. "fuldt mål fejlede: %s", tostring(errStray)) end
end
if ADUnloadKick ~= nil then
local okKick, errKick = pcall(ADUnloadKick.tick, getAutoDriveEnv(), dt)
if not okKick then Logging.warning(ADSmartPickup.LOG_PREFIX .. "aflæsnings-skub fejlede: %s", tostring(errKick)) end
end
if ADRunsController ~= nil and ADRunsController.adoptLoadedThrottled ~= nil then
pcall(ADRunsController.adoptLoadedThrottled, getAutoDriveEnv(), dt)
end
local ok, err = pcall(restoreStoppedVehicles)
if not ok then
Logging.warning(ADSmartPickup.LOG_PREFIX .. "kunne ikke gendanne varevalg: %s", tostring(err))
supplyState = setmetatable({}, {__mode = "k"})
end
if ADStatusHud ~= nil then pcall(ADStatusHud.update, dt, getAutoDriveEnv()) end
end
-- Statusvinduet på skærmen (adStatusHud.lua): tegner kun den cachede tekst.
function ADSmartPickup:draw()
if ADStatusHud ~= nil then pcall(ADStatusHud.draw) end
end
-- Statusvinduet flyttes med musen (adStatusHud.lua).
function ADSmartPickup:mouseEvent(posX, posY, isDown, isUp, button)
if ADStatusHud ~= nil then pcall(ADStatusHud.mouseEvent, posX, posY, isDown, isUp, button) end
end
function ADSmartPickup:deleteMap()
if ADStatusHud ~= nil then pcall(ADStatusHud.delete) end
end
addModEventListener(ADSmartPickup)