Files

1289 lines
66 KiB
Lua
Raw Permalink 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 Courseplay Bridge
-- Den eneste kode der rører Courseplay: start markarbejde på en mark (grænse -> kursus -> start, alt
-- async), og læs om et sæt arbejder. Opskriften er bevist i spillet i AI-Bonden (AIHelperGlue.startCP):
-- CP kalder grænse-callbacken to gange (først false ved fejl) — kun første kald tæller.
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
local function logInfo(...) return (ADLog or Logging).info(...) end
ADCpBridge = {}
-- spec_trailer/spec_dischargeable: ADPool.roleOf genkender en frakoblet tippevogn som tømmevogn på dem
-- (Courseplays combine-unloader-tjek siger nej uden traktor — in-game 4/10: ingen tømmevogn i puljen)
ADCpBridge.SPECS = {"spec_mower", "spec_tedder", "spec_windrower", "spec_forageWagon", "spec_combine", "spec_baler",
"spec_sowingMachine", "spec_cultivator", "spec_plow", "spec_roller", "spec_weeder", "spec_mulcher",
"spec_trailer", "spec_dischargeable", "spec_stonePicker"}
-- Sprøjtens/sprederens fyld -> rolle (tom sprøjte har ingen rolle; den kan ikke sendes ud).
ADCpBridge.SPRAY_ROLES = {
FERTILIZER = "fertilizer", LIQUIDFERTILIZER = "fertilizer", MANURE = "fertilizer",
LIQUIDMANURE = "fertilizer", DIGESTATE = "fertilizer", LIME = "limer", HERBICIDE = "weeder",
}
function ADCpBridge.sprayRoleForFillType(name)
return ADCpBridge.SPRAY_ROLES[name]
end
-- Afgrøder et skærebord/optager kan høste (spec_cutter). Finsnittere (fruitTypeConverters) tager ingen:
-- de laver hakkelse, ikke korn/roer.
function ADCpBridge.harvestFruitSet(cutterSpec)
local fruits = {}
if cutterSpec == nil then return fruits end
if type(cutterSpec.fruitTypeConverters) == "table" and next(cutterSpec.fruitTypeConverters) ~= nil then
return fruits
end
-- (ikke ipairs over {a, b}: den stopper ved første nil)
for _, key in ipairs({"fruitTypes", "fruitTypeIndices"}) do
local source = cutterSpec[key]
if type(source) == "table" then
for key, value in pairs(source) do
if type(value) == "number" then fruits[value] = true
elseif value == true and type(key) == "number" then fruits[key] = true end
end
end
end
return fruits
end
-- Må afgrøden sås i perioden? (growthDataSeasonal.periods[p].plantingAllowed, bevist i AI-Bonden).
-- Ukendte data = tilladt (kort uden sæsondata).
function ADCpBridge.isPlantableIn(fruit, period)
local periods = fruit ~= nil and fruit.growthDataSeasonal ~= nil and fruit.growthDataSeasonal.periods or nil
local data = periods ~= nil and periods[period] or nil
if type(data) ~= "table" then return true end
return data.plantingAllowed == true
end
function ADCpBridge.isAvailable()
return AIJobType ~= nil and AIJobType.FIELDWORK_CP ~= nil
end
local function collect(vehicle, list)
list = list or {}
table.insert(list, vehicle)
if vehicle.getAttachedImplements ~= nil then
for _, implement in ipairs(vehicle:getAttachedImplements()) do
if implement.object ~= nil then collect(implement.object, list) end
end
end
return list
end
-- Hvilke varer der hører til en rolle (påfyldning af en tom spreder/sprøjte), i foretrukken rækkefølge.
ADCpBridge.ROLE_FILLTYPES = {
fertilizer = {"FERTILIZER", "LIQUIDFERTILIZER", "MANURE", "LIQUIDMANURE", "DIGESTATE"},
limer = {"LIME"},
weeder = {"HERBICIDE"},
}
ADCpBridge.ROLE_ORDER = {"fertilizer", "limer", "weeder"}
-- Sprøjtens/sprederens roller: alle roller dens fyldenhed kan tage (Bredal-spreder: gødning OG kalk).
-- Primær rolle = fyldets rolle (har den kalk på, er den kalkspreder), ellers den første den kan tage.
-- Returnerer primær, sæt {[rolle] = true}, fyldets rolle (nil = tom); nil hvis ingen roller.
function ADCpBridge.sprayRolesFor(filledName, supportedNames)
local roles, first = {}, nil
for _, role in ipairs(ADCpBridge.ROLE_ORDER) do
for _, name in ipairs(ADCpBridge.ROLE_FILLTYPES[role]) do
if supportedNames[name] then
roles[role] = true
first = first or role
break
end
end
end
local filledRole = filledName ~= nil and ADCpBridge.sprayRoleForFillType(filledName) or nil
if filledRole ~= nil then roles[filledRole] = true end
local primary = filledRole or first
return primary, primary ~= nil and roles or nil, filledRole
end
local function sprayerNames(object)
local unitIndex = object:getSprayerFillUnitIndex()
local filledName = nil
local level = object:getFillUnitFillLevel(unitIndex) or 0
local capacity = object.getFillUnitCapacity ~= nil and (object:getFillUnitCapacity(unitIndex) or 0) or 0
if level > 0 then
filledName = g_fillTypeManager:getFillTypeNameByIndex(object:getFillUnitFillType(unitIndex))
end
local supported = {}
local unit = object.spec_fillUnit ~= nil and object.spec_fillUnit.fillUnits ~= nil and object.spec_fillUnit.fillUnits[unitIndex] or nil
for fillType, isSupported in pairs(unit ~= nil and unit.supportedFillTypes or {}) do
if isSupported then
local name = g_fillTypeManager:getFillTypeNameByIndex(fillType)
if name ~= nil then supported[name] = true end
end
end
return filledName, supported, level, capacity
end
local function sprayRole(object)
if object.spec_sprayer == nil or object.getSprayerFillUnitIndex == nil then return nil end
local ok, role, roles, filledRole, wrongFillDumpable, supported = pcall(function()
local filledName, supported, level, capacity = sprayerNames(object)
local r, rs, fr = ADCpBridge.sprayRolesFor(filledName, supported)
return r, rs, fr, ADCpBridge.isDumpable(level, capacity), supported
end)
if not ok then return nil end
return role, roles, filledRole, wrongFillDumpable, supported
end
-- Må en forkert vare hældes ud? Kun en lille rest: højst 10 % af tanken og aldrig over 2.000 l
-- (in-game 26/9: 100.000 l flydende gødning og 4.000 l sprøjtemiddel blev hældt ud for at skifte opgave).
ADCpBridge.MAX_DUMP_LITERS = 2000
ADCpBridge.MAX_DUMP_SHARE = 0.10
function ADCpBridge.isDumpable(level, capacity)
level = level or 0
if level <= 0 then return true end
if level > ADCpBridge.MAX_DUMP_LITERS then return false end
return capacity == nil or capacity <= 0 or level <= capacity * ADCpBridge.MAX_DUMP_SHARE
end
-- Tøm sprøjten/sprederen for en vare der ikke hører til opgaven (kalk på, skal gøde). FS25 kan ikke
-- tippe gødning/kalk af, så resten kasseres. Returnerer liter og varenavn (0 hvis intet blev tømt).
function ADCpBridge.emptySprayerIfWrong(vehicle, role)
local liters, name = 0, nil
for _, object in ipairs(collect(vehicle)) do
if object.spec_sprayer ~= nil and object.getSprayerFillUnitIndex ~= nil then
pcall(function()
local filledName, _, level, capacity = sprayerNames(object)
if filledName == nil or ADCpBridge.sprayRoleForFillType(filledName) == role then return end
if not ADCpBridge.isDumpable(level, capacity) then return end
local unit = object:getSprayerFillUnitIndex()
object:addFillUnitFillLevel(object:getOwnerFarmId(), unit, -level, object:getFillUnitFillType(unit), ToolType.UNDEFINED, nil)
liters, name = liters + level, filledName
end)
end
end
return liters, name
end
-- Ligger kursets første punkt mere end FAR_FIRST_POINT_M fra maskinen, logges det (en lang tur hen over marken var
-- grunden til "nærmeste" 10/10 — nu starter feltarbejdet altid ved første punkt).
ADCpBridge.FAR_FIRST_POINT_M = 150
function ADCpBridge.logFarFirstPoint(vehicle)
local course = ADCpBridge.getCourse(vehicle)
if course == nil or course.getWaypointPosition == nil or vehicle.rootNode == nil then return end
local x, _, z = course:getWaypointPosition(1)
local vx, _, vz = getWorldTranslation(vehicle.rootNode)
if x == nil or vx == nil then return end
local distance = math.sqrt((x - vx) ^ 2 + (z - vz) ^ 2)
if distance > ADCpBridge.FAR_FIRST_POINT_M then
logInfo("ADSmartPickup: '%s' starter ved kursets første punkt, %.0f m væk — kører derhen først",
tostring(vehicle.getName ~= nil and vehicle:getName() or "?"), distance)
end
end
-- Når jobbet er startet (fx fra første waypoint): maskinens eget CP-startpunkt sættes til "sidste", så enhver
-- senere genstart — spillerens, efter tømning eller efter indlæsning — fortsætter hvor den slap (in-game 4/10:
-- mejetærskeren sprang stykker over, fordi startpunktet stod på "nærmeste").
function ADCpBridge.resumeFromLast(vehicle)
if CpFieldWorkJobParameters == nil or vehicle == nil or vehicle.getCpStartingPointSetting == nil then return false end
local ok, setting = pcall(vehicle.getCpStartingPointSetting, vehicle)
if not ok or setting == nil or setting.setValue == nil then return false end
return (pcall(setting.setValue, setting, CpFieldWorkJobParameters.START_AT_LAST_POINT))
end
function ADCpBridge.getSpecs(vehicle)
local specs = {}
for _, object in ipairs(collect(vehicle)) do
for _, name in ipairs(ADCpBridge.SPECS) do
if object[name] ~= nil then specs[name] = true end
end
if specs.sprayRole == nil then specs.sprayRole, specs.sprayRoles, specs.filledRole, specs.dumpable, specs.sprayNames = sprayRole(object) end
end
if vehicle.getCanStartCpCombineUnloader ~= nil then
local ok, can = pcall(vehicle.getCanStartCpCombineUnloader, vehicle)
specs.canUnload = ok and can == true or nil
end
if vehicle.getCanStartCpBaleFinder ~= nil then
local ok, can = pcall(vehicle.getCanStartCpBaleFinder, vehicle)
specs.canBaleCollect = ok and can == true or nil
end
return specs
end
-- Vinhøster (fx Grégoire GL86): afgrøden vælges i konfigurationen og står i spec_vineCutter, ikke i spec_cutter
-- (in-game 29/9: F22 hvide druer "none can do it" — moddet så aldrig vinhøstere som høstere).
function ADCpBridge.vineFruitSet(spec)
local fruits = {}
if spec == nil then return fruits end
for _, key in ipairs({"inputFruitTypeIndex", "fruitTypeIndex", "fruitType"}) do
if type(spec[key]) == "number" then fruits[spec[key]] = true end
end
if type(spec.fruitTypes) == "table" then
for key, value in pairs(spec.fruitTypes) do
if type(value) == "number" then fruits[value] = true
elseif value == true and type(key) == "number" then fruits[key] = true end
end
end
return fruits
end
local vineLogged = setmetatable({}, {__mode = "k"})
-- Afgrøder høsteren kan tage (alle skærebord/optagere/vinhøstere i kæden). nil = ikke en høster.
function ADCpBridge.getHarvestFruits(vehicle)
if vehicle.spec_combine == nil then return nil end
local fruits = {}
for _, object in ipairs(collect(vehicle)) do
for fruit in pairs(ADCpBridge.harvestFruitSet(object.spec_cutter)) do fruits[fruit] = true end
if object.spec_vineCutter ~= nil then
local vine = ADCpBridge.vineFruitSet(object.spec_vineCutter)
for fruit in pairs(vine) do fruits[fruit] = true end
if next(vine) == nil and not vineLogged[object] then
-- ukendt feltnavn i denne spilversion: vis nøglerne, så reglen kan rettes
vineLogged[object] = true
local keys = {}
for key, value in pairs(object.spec_vineCutter) do table.insert(keys, tostring(key) .. "=" .. type(value)) end
table.sort(keys)
logInfo("ADSmartPickup: vinhøster uden afgrøde fundet — spec_vineCutter: %s", table.concat(keys, ", "))
end
end
end
return fruits
end
-- Mekanisk strigle (kun småt ukrudt) frem for ukrudtssprøjte.
function ADCpBridge.isMechanicalWeeder(vehicle)
for _, object in ipairs(collect(vehicle)) do
if object.spec_weeder ~= nil then return true end
end
return false
end
local function seederOf(vehicle)
for _, object in ipairs(collect(vehicle)) do
if object.spec_sowingMachine ~= nil then return object end
end
return nil
end
-- Såmaskinens frø-vare: SEEDS når enheden tager det, ellers enhedens egen (risplanter: RICESAPLINGS — in-game 4/10).
function ADCpBridge.seedFillTypeOf(seeder)
if seeder == nil or g_fillTypeManager == nil then return nil end
local seedsIndex = g_fillTypeManager:getFillTypeIndexByName("SEEDS")
local spec = seeder.spec_sowingMachine
local unitIndex = spec ~= nil and spec.fillUnitIndex or nil
local units = seeder.spec_fillUnit ~= nil and seeder.spec_fillUnit.fillUnits or {}
local unit = unitIndex ~= nil and units[unitIndex] or nil
if unit == nil or unit.supportedFillTypes == nil then return seedsIndex end
if unit.supportedFillTypes[seedsIndex] then return seedsIndex end
for fillType, supported in pairs(unit.supportedFillTypes) do
if supported then return fillType end
end
return seedsIndex
end
-- Har såmaskinen frø på? (frø-enheden, uanset om det er SEEDS eller fx ris-stiklinger)
function ADCpBridge.hasSeeds(vehicle)
local seeder = seederOf(vehicle)
if seeder == nil then return false end
local ok, has = pcall(function()
local seedType = ADCpBridge.seedFillTypeOf(seeder)
for index, unit in ipairs(seeder.spec_fillUnit ~= nil and seeder.spec_fillUnit.fillUnits or {}) do
if unit.fillType == seedType and (unit.fillLevel or 0) > 0 then return true end
if unit.supportedFillTypes ~= nil and unit.supportedFillTypes[seedType] and seeder:getFillUnitFillLevel(index) > 0 then return true end
end
return false
end)
return ok and has == true
end
-- Afgrøder såmaskinen kan så (spec_sowingMachine.seeds).
function ADCpBridge.getSeedFruits(vehicle)
local seeder = seederOf(vehicle)
local fruits = {}
local seeds = seeder ~= nil and seeder.spec_sowingMachine.seeds or nil
for _, fruit in pairs(seeds or {}) do fruits[fruit] = true end
return fruits
end
-- Sæt såmaskinens afgrøde (setSeedIndex(slot), bevist i AI-Bonden).
function ADCpBridge.setSeedFruit(vehicle, fruitIndex)
local seeder = seederOf(vehicle)
if seeder == nil then return false, "ingen såmaskine" end
for slot, fruit in pairs(seeder.spec_sowingMachine.seeds or {}) do
if fruit == fruitIndex then
if seeder.setSeedIndex ~= nil then
local ok, err = pcall(seeder.setSeedIndex, seeder, slot)
return ok, not ok and tostring(err) or nil
end
end
end
return false, "såmaskinen kan ikke så afgrøden"
end
function ADCpBridge.isPlantableNow(fruitIndex)
local fruit = g_fruitTypeManager:getFruitTypeByIndex(fruitIndex)
local environment = g_currentMission ~= nil and g_currentMission.environment or nil
return ADCpBridge.isPlantableIn(fruit, environment ~= nil and environment.currentPeriod or 0)
end
-- Hvilken vare sættet bruger og kan få fyldt på af AutoDrive: frø (såmaskine) eller sprøjtens/sprederens
-- fyld; en TOM spreder får rollens vare (gødning ved gødskning, kalk ved kalkning), hvis dens fyldenhed
-- kan tage den. nil = intet at fylde på (strigle, plov ...).
function ADCpBridge.getRefillFillType(vehicle, role)
for _, object in ipairs(collect(vehicle)) do
if object.spec_sowingMachine ~= nil and g_fillTypeManager ~= nil then
return ADCpBridge.seedFillTypeOf(object)
end
end
for _, object in ipairs(collect(vehicle)) do
if object.spec_sprayer ~= nil and object.getSprayerFillUnitIndex ~= nil then
local ok, fillType = pcall(function()
local filledName, supported = sprayerNames(object)
if filledName ~= nil and (role == nil or ADCpBridge.sprayRoleForFillType(filledName) == role) then
return g_fillTypeManager:getFillTypeIndexByName(filledName)
end
for _, name in ipairs(ADCpBridge.ROLE_FILLTYPES[role] or {}) do
if supported[name] then return g_fillTypeManager:getFillTypeIndexByName(name) end
end
return nil
end)
if ok and fillType ~= nil and fillType ~= 0 then return fillType end
end
end
return nil
end
-- Hvad sættet faktisk har på (til "er tom"-loggen): "K105: FERTILIZER 10000 l" ...
function ADCpBridge.describeFill(vehicle)
local parts = {}
for _, object in ipairs(collect(vehicle)) do
pcall(function()
for index in ipairs(object.spec_fillUnit ~= nil and object.spec_fillUnit.fillUnits or {}) do
local level = object:getFillUnitFillLevel(index) or 0
if level > 0 then
local ft = object.getFillUnitFillType ~= nil and object:getFillUnitFillType(index) or nil
local name = ft ~= nil and g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(ft) or tostring(ft)
table.insert(parts, string.format("%s: %s %.0f l", tostring(object.getName ~= nil and object:getName() or "?"), tostring(name), level))
end
end
end)
end
return #parts > 0 and table.concat(parts, ", ") or "intet"
end
-- Hvor meget af påfyldningsvaren sættet har tilbage (liter, alle fyldenheder med varen).
function ADCpBridge.getRefillLevel(vehicle, fillType)
local total = 0
for _, object in ipairs(collect(vehicle)) do
pcall(function()
for index, unit in ipairs(object.spec_fillUnit ~= nil and object.spec_fillUnit.fillUnits or {}) do
-- spillets egen funktion: feltet unit.fillType er ikke altid opdateret (in-game 9/10: K105 Unrealistic
-- med 10 t gødning blev meldt "tom", sendt på læs-tur og kørte fuld direkte til marken)
local current = object.getFillUnitFillType ~= nil and object:getFillUnitFillType(index) or unit.fillType
if current == fillType then total = total + (object:getFillUnitFillLevel(index) or 0) end
end
end)
end
return total
end
-- Halmskår bag mejetærskeren (Courseplays køretøjsindstilling strawSwath: 1 = fra/hakkes, 2 = til).
function ADCpBridge.setStrawSwath(vehicle, on)
return (pcall(function() vehicle:getCpSettings().strawSwath:setValue(on and 2 or 1) end))
end
-- Ballesamler: Courseplays BALE_FINDER_CP (ballevogn eller Universal Autoload) samler markens baller.
function ADCpBridge.startBaleFinder(vehicle, fieldX, fieldZ, onDone)
if AIJobType == nil or AIJobType.BALE_FINDER_CP == nil then
return nil, "Courseplay (BALE_FINDER_CP) findes ikke"
end
local farmId = vehicle:getOwnerFarmId()
local job = g_currentMission.aiJobTypeManager:createJob(AIJobType.BALE_FINDER_CP)
if job == nil then return nil, "kunne ikke oprette ballesamler-job" end
pcall(function() job:applyCurrentState(vehicle, g_currentMission, farmId, false, false) end)
local params = job.cpJobParameters
if params ~= nil and params.fieldPosition ~= nil then pcall(function() params.fieldPosition:setPosition(fieldX, fieldZ) end) end
if params ~= nil and params.startPosition ~= nil then
local vx, _, vz = getWorldTranslation(vehicle.rootNode)
pcall(function() params.startPosition:setPosition(vx, vz) end)
end
pcall(function() job:setValues() end)
local handle = {cancelled = false, fired = false, finished = false}
local function finish(success, reason)
if handle.finished then return end
handle.finished = true
if not handle.cancelled then onDone(success, reason) end
end
local function startJob()
if handle.cancelled then return end
local valid, err = job:validate(farmId)
if not valid then return finish(false, "Courseplay: " .. tostring(err)) end
g_currentMission.aiSystem:startJob(job, farmId)
finish(true)
end
handle.onBoundary = function(_, success, message)
if handle.fired then return end
handle.fired = true
if not success then return finish(false, "Courseplay fandt ikke markgrænsen: " .. tostring(message)) end
startJob()
end
if job.registerFieldBoundaryDetectionCallback ~= nil then
job:registerFieldBoundaryDetectionCallback(handle, handle.onBoundary)
end
local isValid, isRunning, message = job:detectFieldBoundary()
if isValid and not isRunning then
startJob()
elseif not isRunning then
return nil, "Courseplay: " .. tostring(message)
end
return handle
end
-- Stop køretøjets AI-job (Courseplay/hjælper).
function ADCpBridge.stop(vehicle)
pcall(function()
if vehicle.getIsAIActive ~= nil and vehicle:getIsAIActive() and vehicle.stopCurrentAIJob ~= nil then
vehicle:stopCurrentAIJob(AIMessageSuccessStoppedByUser.new())
end
end)
end
-- Variabel bredde (Unrealistic Pack m.fl.) først, som Courseplays WorkWidthUtil: AI-markørerne står på
-- grundbredden (læssevogn 2,4 m selv om den er sat til 40,8 m).
local function variableWidth(object)
if object.getVariableWorkWidth == nil then return nil end
-- uden sektioner (fx vores _MD-udgave af Unrealistic med fast bredde) er AI-markørerne den rigtige bredde
local spec = object.spec_variableWorkWidth
if spec ~= nil and (type(spec.sections) ~= "table" or #spec.sections == 0) then return nil end
local okLeft, left, _, leftValid = pcall(object.getVariableWorkWidth, object, true)
local okRight, right, _, rightValid = pcall(object.getVariableWorkWidth, object)
if okLeft and okRight and leftValid and rightValid and type(left) == "number" and type(right) == "number" then
return math.abs(left) + math.abs(right)
end
return nil
end
-- Courseplays egen bredde-indstilling (den i HUD'en) er den marken faktisk køres med.
local function courseplayWidth(vehicle)
if vehicle.getCourseGeneratorSettings == nil then return nil end
local ok, width = pcall(function() return vehicle:getCourseGeneratorSettings().workWidth:getValue() end)
if ok and type(width) == "number" and width > 0 then return width end
return nil
end
-- Unrealistic-redskaber med variabel bredde (sektioner, fx Pöttinger Servo 25: 1,2–120 m) stilles til
-- VARIABLE_TARGET_WIDTH ved påkobling (brugerønske 6/10: Courseplays maksimum). Står de på minimum, afvises de
-- som "bredde ukendt" (< 1,5 m), og helt åbne er de bredere end Courseplay kan lave kursus til.
ADCpBridge.VARIABLE_TARGET_WIDTH = 50
-- under denne bredde er en måling ubrugelig (= ADFieldModel.MIN_WORK_WIDTH)
ADCpBridge.MIN_USABLE_WIDTH = 1.5
-- widths[k] = bredde med k sektioner pr. side slået til (k = 0..n) -> det k der giver størst bredde <= target
function ADCpBridge.pickSectionCount(widths, target)
local best, bestWidth = 0, -1 -- 0 = ingen kandidat <= target (kalderen vælger så 1)
for k, w in pairs(widths) do
if type(w) == "number" and w <= target + 0.01 and w > bestWidth then best, bestWidth = k, w end
end
return best
end
-- Under arbejdet: mindst kursets bredde (overlap er bedre end uslåede striber — in-game 9/10: BiG M 450 sænket gav
-- 4 sektioner = 45 m på et 50 m-kursus). Ingen der rækker: den bredeste.
function ADCpBridge.pickSectionCountAtLeast(widths, target)
local best, bestWidth, widest, widestWidth = nil, math.huge, 0, -1
for k, w in pairs(widths) do
if type(w) == "number" then
if w >= target - 0.01 and w < bestWidth then best, bestWidth = k, w end
if w > widestWidth then widest, widestWidth = k, w end
end
end
return best or widest
end
local function currentVariableWidth(object)
local okL, left = pcall(object.getVariableWorkWidth, object, true)
local okR, right = pcall(object.getVariableWorkWidth, object)
if not okL or not okR or type(left) ~= "number" or type(right) ~= "number" then return nil end
return math.abs(left) + math.abs(right)
end
-- Arbejdsfelternes faktiske bredde i spillet (start- til breddenode), fx "forageWagon 50.0 m" — til loggen: viser om
-- opsamleren/klipperen reelt arbejder i den bredde sektionerne siger (in-game 9/10: læssevogn tog kun skåret lige under sig).
function ADCpBridge.describeWorkAreas(object)
local parts = {}
pcall(function()
local spec = object.spec_workArea
for _, area in ipairs(spec ~= nil and spec.workAreas or {}) do
if area.start ~= nil and area.width ~= nil then
local typeName = g_workAreaTypeManager ~= nil and g_workAreaTypeManager:getWorkAreaTypeNameByIndex(area.type) or tostring(area.type)
table.insert(parts, string.format("%s %.1f m", tostring(typeName), calcDistanceFrom(area.start, area.width)))
end
end
end)
return #parts > 0 and table.concat(parts, ", ") or "ukendt"
end
local warnedNoApi = {}
-- -> liste af {name, before, after} for de redskaber der blev stillet
function ADCpBridge.setVariableWidth(vehicle, target, atLeast, quiet)
target = target or ADCpBridge.VARIABLE_TARGET_WIDTH
local changed = {}
for _, object in ipairs(collect(vehicle)) do
local spec = object.spec_variableWorkWidth
if spec ~= nil and type(spec.sections) == "table" and #spec.sections > 0 and object.getVariableWorkWidth ~= nil then
local name = object.getName ~= nil and object:getName() or "?"
if object.setSectionsActive == nil then
if not warnedNoApi[name] then
warnedNoApi[name] = true
local keys = {}
for k in pairs(spec) do table.insert(keys, tostring(k)) end
Logging.warning("ADSmartPickup: bredde: '%s' har variabel bredde, men ingen setSectionsActive — felter: %s", name, table.concat(keys, ","))
end
else
local before = currentVariableWidth(object)
local center, left, right = {}, {}, {}
for i, section in ipairs(spec.sections) do
local ref = section.maxWidthNode or section.node
local dist = 0
if ref ~= nil and object.rootNode ~= nil then
local okD, x = pcall(function() local lx = localToLocal(ref, object.rootNode, 0, 0, 0) return lx end)
dist = okD and math.abs(x or 0) or 0
end
if section.isCenter then table.insert(center, i)
elseif section.isLeft then table.insert(left, {i = i, d = dist})
else table.insert(right, {i = i, d = dist}) end
end
table.sort(left, function(a, b) return a.d < b.d end)
table.sort(right, function(a, b) return a.d < b.d end)
local n = math.min(#left, #right)
local function ids(k)
local list = {}
for _, i in ipairs(center) do table.insert(list, i) end
for j = 1, k do table.insert(list, left[j].i); table.insert(list, right[j].i) end
return list
end
-- bredden udregnes af sektionernes yderkant (måling lige efter setSectionsActive er forældet —
-- in-game 6/10: K105 målte 120 m for alle valg, fik 0 sektioner og endte på 0,5 m)
local widths = {}
for k = 1, n do widths[k] = left[k].d + right[k].d end
if n == 0 or (widths[n] or 0) <= 0 then
Logging.warning("ADSmartPickup: bredde: '%s' — sektionernes placering kendes ikke; bredden røres ikke", name)
else
local k = atLeast and ADCpBridge.pickSectionCountAtLeast(widths, target) or ADCpBridge.pickSectionCount(widths, target)
if k == 0 then k = math.min(1, n) end -- aldrig kun midten: det er minimumsbredden
pcall(object.setSectionsActive, object, ids(k))
local planned = widths[k]
table.insert(changed, {name = name, before = before, after = planned})
if not quiet then
logInfo("ADSmartPickup: bredde: '%s' stillet fra %.1f m til ca. %.1f m (%d af %d sektioner pr. side, mål %d m); arbejdsfelter: %s",
name, before or -1, planned or -1, k, n, target, ADCpBridge.describeWorkAreas(object))
end
end
end
end
end
return changed
end
-- Vagt under arbejdet: maskinen må ikke springe tilbage til fuld bredde (in-game 6/10: Case 635-høsteren blev stillet
-- til 50 m ved start, men arbejdede bagefter i 120 m på et 50 m-kursus). -> skal bredden stilles igen?
ADCpBridge.WIDTH_GUARD_TOLERANCE = 5
function ADCpBridge.needsWidthReset(current, target)
return type(current) == "number" and current > (target or ADCpBridge.VARIABLE_TARGET_WIDTH) + ADCpBridge.WIDTH_GUARD_TOLERANCE
end
-- sections = {{isCenter, isLeft, d (afstand fra midten), isActive}} -> de aktive sektioners bredde (yderkant venstre +
-- højre); nil når sektionerne ikke oplyser isActive (så må spillets måling bruges).
function ADCpBridge.activeSectionWidth(sections)
local left, right, known = 0, 0, false
for _, section in ipairs(sections or {}) do
if type(section.isActive) == "boolean" then known = true end
if section.isActive and not section.isCenter then
if section.isLeft then left = math.max(left, section.d or 0) else right = math.max(right, section.d or 0) end
end
end
return known and left + right or nil
end
-- Skal vagten nulstille? -> reset, ny "sidst nulstillede måling". En måling der står præcis stille efter en
-- nulstilling er ubrugelig (Unrealistic-redskaber svarer altid 120 m; in-game 7/10 nulstillet hvert 10. s).
ADCpBridge.GUARD_COOLDOWN_MS = 5 * 60 * 1000 -- højst én nulstilling pr. redskab så tit
ADCpBridge.GUARD_SECTION_COOLDOWN_MS = 5000
function ADCpBridge.guardCooldownOver(lastAt, nowMs, cooldownMs)
return lastAt == nil or nowMs - lastAt >= (cooldownMs or ADCpBridge.GUARD_COOLDOWN_MS)
end
ADCpBridge.GUARD_SAME_READING_M = 1 -- målinger så tæt på hinanden er "den samme" (kommatal varierer)
function ADCpBridge.guardDecision(current, target, lastReset)
if not ADCpBridge.needsWidthReset(current, target) then return false, nil end
if lastReset ~= nil and math.abs(current - lastReset) < ADCpBridge.GUARD_SAME_READING_M then return false, lastReset end
return true, current
end
local function sectionDistance(object, section)
local ref = section.maxWidthNode or section.node
if ref == nil or object.rootNode == nil then return 0 end
local okD, x = pcall(function() local lx = localToLocal(ref, object.rootNode, 0, 0, 0) return lx end)
return okD and math.abs(x or 0) or 0
end
-- Aktiv bredde ud fra sektionerne (som setVariableWidth regner), ellers spillets måling. -> bredde, kilde
local function guardedWidth(object, spec)
local list = {}
for _, section in ipairs(spec.sections) do
table.insert(list, {isCenter = section.isCenter, isLeft = section.isLeft, isActive = section.isActive, d = sectionDistance(object, section)})
end
local fromSections = ADCpBridge.activeSectionWidth(list)
if fromSections ~= nil then return fromSections, "sektioner" end
return currentVariableWidth(object), "spillets måling"
end
local lastGuardReset = setmetatable({}, {__mode = "k"}) -- redskab -> måling ved sidste nulstilling
local lastGuardResetAt = setmetatable({}, {__mode = "k"}) -- redskab -> tid (ms) for sidste nulstilling
local lastGuardLogAt = setmetatable({}, {__mode = "k"}) -- redskab -> tid (ms) for sidste advarsel i loggen
local function guardNow()
if g_currentMission ~= nil and type(g_currentMission.time) == "number" then return g_currentMission.time end
return os.clock() * 1000
end
function ADCpBridge.guardVariableWidth(vehicle)
for _, object in ipairs(collect(vehicle)) do
local spec = object.spec_variableWorkWidth
if spec ~= nil and type(spec.sections) == "table" and #spec.sections > 0 and object.setSectionsActive ~= nil
and object.getVariableWorkWidth ~= nil then
-- fast bredde (vores Unrealistic _MD: én sektion pr. side) — intet at stille, kun støj i loggen (9/10)
local sides = {left = 0, right = 0}
for _, section in ipairs(spec.sections) do
if not section.isCenter then
local side = section.isLeft and "left" or "right"
sides[side] = sides[side] + 1
end
end
local fixedWidth = sides.left <= 1 and sides.right <= 1
local current, source = nil, nil
if not fixedWidth then current, source = guardedWidth(object, spec) end
-- holdes på den bredde kurset er lavet til (Courseplays indstilling), ikke 50 m: ellers slog BiG M 450
-- 40,8 m på et kursus med 20,8 m mellem banerne (in-game 9/10)
local target = courseplayWidth(vehicle) or ADCpBridge.VARIABLE_TARGET_WIDTH
local reset = false
if not fixedWidth then
reset, lastGuardReset[object] = ADCpBridge.guardDecision(current, target, lastGuardReset[object])
end
local now = guardNow()
-- sektionernes egen tilstand er pålidelig: straks igen (Courseplay slår alle sektioner til ved sænkning —
-- in-game 9/10: 112,8 m få sekunder efter nulstillingen); kun spillets måling (altid 120 m) får pausen
local cooldownOver = source == "sektioner" and ADCpBridge.guardCooldownOver(lastGuardResetAt[object], now, ADCpBridge.GUARD_SECTION_COOLDOWN_MS)
or ADCpBridge.guardCooldownOver(lastGuardResetAt[object], now)
if reset and cooldownOver then
lastGuardResetAt[object] = now
-- loggen højst hvert 5. min pr. redskab (vagten nulstiller nu hvert 5. s, når sektionerne springer)
local loud = ADCpBridge.guardCooldownOver(lastGuardLogAt[object], now)
if loud then
lastGuardLogAt[object] = now
Logging.warning("ADSmartPickup: bredde: '%s' er sprunget tilbage til %.1f m under arbejdet (%s) — stilles igen",
tostring(object.getName ~= nil and object:getName() or "?"), current, source)
end
ADCpBridge.setVariableWidth(vehicle, target, true, not loud)
return true
end
end
end
return false
end
-- Vinhøster uden AI-markører: bredden er vinrækken (3 m = Courseplays vin-gitter for druer).
ADCpBridge.VINE_ROW_WIDTH = 3
function ADCpBridge.widthOrVine(width, hasVineCutter)
-- under markarbejdets minimum (1,5 m) — også en lille bredde fra Courseplay (in-game 29/9: stadig widthUnknown)
if hasVineCutter and (width or 0) < 1.5 then return ADCpBridge.VINE_ROW_WIDTH end
return width
end
local function hasSettableVariableWidth(vehicle)
for _, object in ipairs(collect(vehicle)) do
local spec = object.spec_variableWorkWidth
if spec ~= nil and type(spec.sections) == "table" and #spec.sections > 0 and object.setSectionsActive ~= nil then return true end
end
return false
end
ADCpBridge.hasSettableVariableWidth = hasSettableVariableWidth
-- Redskaber med variabel bredde måles på sektionernes yderkant — sammenfoldet giver det for lidt (in-game 9/10:
-- BiG M 450 målt til 20,8 m sammenfoldet, slog 40,8 m udfoldet). Fold dem ud før måling og kursus.
-- Kun hvis det kan foldes sammen igen: spillet nægter at folde en fyldt høster (Combine/FillUnit:getIsFoldAllowed),
-- og så kan spillets AI-fører ikke køre ("not in transport mode"; in-game 16/10: roeoptageren med 161.570 l på F94
-- gik i ring hvert 30. s).
-- -> true hvis et redskab med variabel bredde er sammenfoldet (og udfoldning er sat i gang); 2. værdi = navn på et
-- redskab der blev ladt sammenfoldet, fordi det ikke kan foldes sammen igen
function ADCpBridge.unfoldVariableWidth(vehicle)
local started, blocked = false, nil
for _, object in ipairs(collect(vehicle)) do
local spec = object.spec_variableWorkWidth
if spec ~= nil and type(spec.sections) == "table" and #spec.sections > 0 and object.spec_foldable ~= nil
and object.getIsUnfolded ~= nil and not object:getIsUnfolded() and object.setFoldDirection ~= nil then
local turnOn = object.spec_foldable.turnOnFoldDirection or 1
if ADCpBridge.canFoldBack(object, turnOn) then
pcall(object.setFoldDirection, object, turnOn)
started = true
else
blocked = object.getName ~= nil and object:getName() or "?"
end
end
end
return started, blocked
end
-- Må redskabet foldes sammen (transportretning) lige nu? Ukendt (ingen API/fejl) = ja.
function ADCpBridge.canFoldBack(object, turnOnFoldDirection)
if object.getIsFoldAllowed == nil then return true end
local ok, allowed = pcall(object.getIsFoldAllowed, object, -(turnOnFoldDirection or 1), false)
return not ok or allowed ~= false
end
-- Er alle redskaber med variabel bredde foldet ud?
function ADCpBridge.variableWidthUnfolded(vehicle)
for _, object in ipairs(collect(vehicle)) do
local spec = object.spec_variableWorkWidth
if spec ~= nil and type(spec.sections) == "table" and #spec.sections > 0 and object.getIsUnfolded ~= nil and not object:getIsUnfolded()
and ADCpBridge.canFoldBack(object, object.spec_foldable ~= nil and object.spec_foldable.turnOnFoldDirection or 1) then
-- et redskab der ikke foldes ud (kan ikke foldes sammen igen) tæller ikke med
return false
end
end
return true
end
-- role (valgfri): spreder/sprøjte under minimum -> spray-typens bredde for rollens vare.
function ADCpBridge.getWorkWidth(vehicle, role)
local width = ADCpBridge.getMeasuredWorkWidth(vehicle)
if (width or 0) >= ADCpBridge.MIN_USABLE_WIDTH then return width end
-- variabel bredde på minimum (Servo 25: 1,2 m): stilles til målbredden når arbejdet starter
if hasSettableVariableWidth(vehicle) then return ADCpBridge.VARIABLE_TARGET_WIDTH end
-- spreder/sprøjte: målingen afhænger af fyldet og er upålidelig lige efter påkobling (in-game 16/10: Bredal
-- K105 målt 0,5 m og sat tilbage) — xml'ens faste bredde pr. spray-type
return ADCpBridge.getSprayerWidth(vehicle, role) or width
end
-- Ren: sprederens spray-typer ({fillTypes = {"LIME", ...}, width}) -> bredden for rollens første vare, ellers nil.
-- Bredal K105 (in-game 16/10): målingen lige efter påkobling gav 0,5 m / 12 m / ingenting for samme spreder; xml'ens
-- usageScales#workingWidth pr. spray-type (kalk 12/18 m, gødning 24/30 m) er fast.
function ADCpBridge.sprayTypeWidth(sprayTypes, wantedNames)
for _, wanted in ipairs(wantedNames or {}) do
for _, sprayType in ipairs(sprayTypes or {}) do
for _, name in ipairs(sprayType.fillTypes or {}) do
if string.upper(tostring(name)) == wanted and (sprayType.width or 0) > 0 then return sprayType.width end
end
end
end
return nil
end
-- Sprederens/sprøjtens bredde til rollen ud fra spray-typerne (kun dem spillet har indlæst for konfigurationen), eller nil.
-- Uden rolle: den største spray-type (så en parkeret spreder ikke afvises før den er koblet på).
function ADCpBridge.getSprayerWidth(vehicle, role)
local wanted = role ~= nil and ADCpBridge.ROLE_FILLTYPES[role] or nil
if role ~= nil and wanted == nil then return nil end
for _, object in ipairs(collect(vehicle)) do
local spec = object.spec_sprayer
if spec ~= nil and type(spec.sprayTypes) == "table" then
local list = {}
for _, sprayType in ipairs(spec.sprayTypes) do
local usage = sprayType.usageScale or {}
local width = usage.workingWidth
-- arbejdsområdets bredde er beregnet ud fra noderne og lige så upålidelig som målingen: kun hvis den er brugbar
if usage.workAreaIndex ~= nil and object.getWorkAreaWidth ~= nil then
local ok, areaWidth = pcall(object.getWorkAreaWidth, object, usage.workAreaIndex)
if ok and type(areaWidth) == "number" and areaWidth >= ADCpBridge.MIN_USABLE_WIDTH then width = areaWidth end
end
table.insert(list, {fillTypes = sprayType.fillTypes, width = tonumber(width)})
end
local width
if wanted ~= nil then
width = ADCpBridge.sprayTypeWidth(list, wanted)
else
for _, entry in ipairs(list) do
if (entry.width or 0) > (width or 0) then width = entry.width end
end
end
if width ~= nil and width >= ADCpBridge.MIN_USABLE_WIDTH then return width end
end
end
return nil
end
function ADCpBridge.getMeasuredWorkWidth(vehicle)
local hasVine = false
for _, object in ipairs(collect(vehicle)) do
if object.spec_vineCutter ~= nil then hasVine = true end
end
local cpWidth = courseplayWidth(vehicle)
-- Courseplays indstilling opdateres ikke altid lige ved påkobling: under minimum er den forældet (in-game 16/10:
-- Omega-såmaskinen 0,5 m lige efter påkobling, 6 m en anden gang) — mål selv på redskabets AI-markører
if cpWidth ~= nil and cpWidth >= ADCpBridge.MIN_USABLE_WIDTH then return ADCpBridge.widthOrVine(cpWidth, hasVine) end
local best = 0
for _, object in ipairs(collect(vehicle)) do
local variable = variableWidth(object)
if variable ~= nil then
best = math.max(best, variable)
elseif object.getAIMarkers ~= nil then
pcall(function() if object.updateAIMarkerWidth ~= nil then object:updateAIMarkerWidth() end end)
local ok, _, _, _, _, width = pcall(object.getAIMarkers, object)
if ok and type(width) == "number" and width > best then best = width end
end
end
-- heller ingen brugbar markør-bredde: Courseplays (evt. lille) værdi som før
if best < ADCpBridge.MIN_USABLE_WIDTH and cpWidth ~= nil then best = math.max(best, cpWidth) end
return ADCpBridge.widthOrVine(best, hasVine)
end
-- AutoDrive kører også som AI-job i FS25: aktiv AD er ikke Courseplay (in-game 29/9: Milk Store ved Cow Wait
-- med AD aktiv blev meldt 'Courseplay kører' og ventede på sig selv).
function ADCpBridge.isWorking(vehicle)
if vehicle.getIsCpFieldWorkActive ~= nil and vehicle:getIsCpFieldWorkActive() then return true end
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if module ~= nil and module.isActive ~= nil and module:isActive() then return false end
return vehicle.getIsAIActive ~= nil and vehicle:getIsAIActive() or false
end
-- Courseplays værktøjsforskydning (venstre positiv) på køretøjet; den der flytter kursuslinjen.
function ADCpBridge.getToolOffset(vehicle)
if vehicle == nil or vehicle.getCpSettings == nil then return 0 end
local ok, value = pcall(function() return vehicle:getCpSettings().toolOffsetX:getValue() end)
return ok and type(value) == "number" and value or 0
end
function ADCpBridge.setToolOffset(vehicle, value)
if vehicle == nil or vehicle.getCpSettings == nil then return false end
return (pcall(function() vehicle:getCpSettings().toolOffsetX:setFloatValue(value) end))
end
-- Riverens XML: workArea-nr (1-baseret) -> dropWindrowWorkAreaIndex. Bruges når spillet ikke har feltet
-- på workArea-tabellen. Cachet pr. fil.
ADCpBridge.dropIndexCache = {}
function ADCpBridge.readDropIndicesFromXml(fileName)
if ADCpBridge.dropIndexCache[fileName] ~= nil then return ADCpBridge.dropIndexCache[fileName] end
local indices = {}
local ok = pcall(function()
local xmlFile = XMLFile.load("adspuRake", fileName)
if xmlFile == nil then return end
local position = 0
xmlFile:iterate("vehicle.workAreas.workArea", function(_, key)
position = position + 1
local dropIndex = xmlFile:getInt(key .. ".windrower#dropWindrowWorkAreaIndex")
if dropIndex ~= nil then indices[position] = dropIndex end
end)
xmlFile:delete()
end)
if not ok then indices = {} end
ADCpBridge.dropIndexCache[fileName] = indices
return indices
end
-- Hvor langt til venstre (positiv) for rivens kursuslinje skåret lægges: midten af nedlægningsområdet i
-- traktorens ramme minus rivens egen CP-forskydning. Midterrive ≈ 0, siderive fx 3 m. nil = ingen river.
function ADCpBridge.getWindrowOffset(vehicle)
local root = vehicle.rootNode
local sum, count = 0, 0
for _, object in ipairs(collect(vehicle)) do
local areas = object.spec_windrower ~= nil and object.spec_workArea ~= nil and object.spec_workArea.workAreas or nil
if areas ~= nil then
local fromXml = nil
for position, workArea in ipairs(areas) do
local dropIndex = workArea.dropWindrowWorkAreaIndex
if dropIndex == nil and object.configFileName ~= nil then
fromXml = fromXml or ADCpBridge.readDropIndicesFromXml(object.configFileName)
dropIndex = fromXml[position]
end
local drop = dropIndex ~= nil and areas[dropIndex] or nil
if drop ~= nil and drop.width ~= nil and drop.height ~= nil then
local widthX = localToLocal(drop.width, root, 0, 0, 0)
local heightX = localToLocal(drop.height, root, 0, 0, 0)
sum, count = sum + (widthX + heightX) / 2, count + 1
end
end
end
end
if count == 0 then return nil end
return sum / count - ADCpBridge.getToolOffset(vehicle)
end
-- Køretøjets nuværende Courseplay-kursus (slåmaskinens kursus genbruges af de næste trin).
function ADCpBridge.getCourse(vehicle)
if vehicle == nil or vehicle.getFieldWorkCourse == nil then return nil end
local ok, course = pcall(vehicle.getFieldWorkCourse, vehicle)
return ok and course or nil
end
-- Forager: nye kurser får altid HEADLANDS runder og starter på forageren, så der ikke køres ind i træer, hegn
-- o.l. i hjørnerne (brugerkrav 29/9). Kan kurset ikke laves med forager (smal mark), prøves én gang uden.
ADCpBridge.HEADLANDS = 2
function ADCpBridge.setHeadlands(vehicle, n)
if vehicle.getCourseGeneratorSettings == nil then return false end
return (pcall(function()
local settings = vehicle:getCourseGeneratorSettings()
settings.numberOfHeadlands:setValue(n)
if settings.startOnHeadland ~= nil then settings.startOnHeadland:setValue(n > 0) end
end))
end
-- Har kurset forager? (ukendt API = antag ja, så intet genberegnes unødigt)
function ADCpBridge.courseHasHeadlands(course)
if course == nil then return false end
if course.getNumberOfHeadlands == nil then return true end
local ok, n = pcall(course.getNumberOfHeadlands, course)
return not ok or type(n) ~= "number" or n > 0
end
-- Kursusbredde til Courseplay: højst 50 m (CP's grænse; Unrealistic-redskaber kan sættes bredere). nil = urørt.
ADCpBridge.CP_MAX_WIDTH = 50
function ADCpBridge.cpCourseWidth(width)
if type(width) == "number" and width > ADCpBridge.CP_MAX_WIDTH then return ADCpBridge.CP_MAX_WIDTH end
return nil
end
local function clampCourseWidth(vehicle)
pcall(function()
local setting = vehicle:getCourseGeneratorSettings().workWidth
local capped = ADCpBridge.cpCourseWidth(setting:getValue())
if capped ~= nil then
setting:setValue(capped)
logInfo("ADSmartPickup: kursusbredde for '%s' begrænset til %d m (Courseplays maksimum)", tostring(vehicle.getName ~= nil and vehicle:getName() or "?"), capped)
end
end)
end
-- Multi-tool: sæt antal sæt på kursus-generatoren før kurset laves (1 = normalt kursus).
local function setMultiTools(vehicle, n)
pcall(function() vehicle:getCourseGeneratorSettings().multiTools:setValue(n or 1) end)
end
-- Sæt køretøjets bane på et multi-tool-kursus (samme som HUD'ens "Baneforskydning").
local function setLane(vehicle, params, lane)
if lane == nil then return end
pcall(function()
local course = vehicle:getFieldWorkCourse()
if course ~= nil and course.getMultiTools ~= nil and course:getMultiTools() > 1 then course:setPosition(lane) end
end)
if params ~= nil and params.laneOffset ~= nil then pcall(function() params.laneOffset:setValue(lane) end) end
end
-- Start Courseplay-markarbejde. opts (valgfri):
-- course = færdigt kursus der kopieres (slåmaskinens/rivens, eller trinnets fælles multi-tool-kursus)
-- multiTools = antal sæt når kurset laves her (multi-tool-leder)
-- lane = køretøjets bane på et multi-tool-kursus (laneOffset -2..2)
-- reuse = start på køretøjets eget nuværende kursus uden ny beregning (ADCourseCache fandt det passende)
-- onDone(ok, reason) kaldes én gang; reason "copied"/"reused" ved succes med kopieret/genbrugt kursus.
-- Vinmarker (druer/oliven): Courseplays kursus ligger som standard PÅ vinen — en sprøjte/spreder/harve kører
-- så ind i stolperne ("Blocked by an object", in-game 26/9 F22). Alt der arbejder i gangene køres til
-- venstre for vinen; høsteren kører hen over rækken. nil = ikke en vinmark (rør intet).
ADCpBridge.VINE_FRUITS = {GRAPE = true, GRAPEB = true, OLIVE = true, OLIVEB = true, HOPS = true}
function ADCpBridge.vineOffsetFor(fruitName, role)
if fruitName == nil or not ADCpBridge.VINE_FRUITS[string.upper(tostring(fruitName))] then return nil end
if role == "harvester" then return 0 end
return -1
end
-- Vinrækker der springes over: sprøjter/spredere arbejder på begge sider af gangen på én gang, så de kører kun
-- i hver anden gang (1). Andre redskaber (harve, mulcher) arbejder mod én side (0). nil = ikke en vinmark.
ADCpBridge.VINE_BOTH_SIDES = {fertilizer = true, weeder = true, limer = true}
function ADCpBridge.vineSkipFor(fruitName, role)
if ADCpBridge.vineOffsetFor(fruitName, role) == nil then return nil end
return ADCpBridge.VINE_BOTH_SIDES[role] and 1 or 0
end
function ADCpBridge.setVineSkip(vehicle, value)
if vehicle == nil or vehicle.getCpVineSettings == nil or value == nil then return false end
return (pcall(function() vehicle:getCpVineSettings().vineRowsToSkip:setValue(value) end))
end
function ADCpBridge.setVineOffset(vehicle, value)
if vehicle == nil or vehicle.getCpVineSettings == nil or value == nil then return false end
return (pcall(function() vehicle:getCpVineSettings().vineCenterOffset:setValue(value) end))
end
-- changed = setVariableWidth-resultatet -> den største planlagte bredde (>= 1,5 m), ellers nil
function ADCpBridge.plannedWidth(changed)
local best = nil
for _, entry in ipairs(changed or {}) do
if type(entry.after) == "number" and entry.after >= 1.5 and (best == nil or entry.after > best) then best = entry.after end
end
return best
end
function ADCpBridge.start(vehicle, fieldX, fieldZ, onDone, opts)
local okVar, changed = pcall(ADCpBridge.setVariableWidth, vehicle)
if not okVar then Logging.warning("ADSmartPickup: bredde: %s", tostring(changed)) end
-- Courseplays kursusbredde følger sektionerne først et tick senere og stod på 0,5 m (in-game 6/10: K105 på F5
-- afvist hver gang, 724 Vario 2 pendlede mellem F5 og F14) — sæt den planlagte bredde direkte
local planned = okVar and ADCpBridge.plannedWidth(changed) or nil
-- fast bredde: Courseplay beregner bredden kun ved indlæsning/påkobling — en gemt værdi fra et andet redskab blev
-- stående (in-game 10/10: lånt Bredal K105 kørte med 30 m, F40 blev 67 %). Genberegn lige før start.
if planned == nil and CpCourseGeneratorSettings ~= nil and CpCourseGeneratorSettings.setAutomaticWorkWidthAndOffset ~= nil then
local before = courseplayWidth(vehicle)
-- genberegningen sætter også sideforskydningen: markarbejdet har lige sat den (læssevognen i rivens skår)
local okOffset, offset = pcall(ADCpBridge.getToolOffset, vehicle)
pcall(CpCourseGeneratorSettings.setAutomaticWorkWidthAndOffset, vehicle)
if okOffset and type(offset) == "number" then pcall(ADCpBridge.setToolOffset, vehicle, offset) end
local after = courseplayWidth(vehicle)
if before ~= nil and after ~= nil and math.abs(before - after) > 0.05 then
logInfo("ADSmartPickup: bredde: Courseplays bredde for '%s' rettet fra %.1f m til %.1f m (genberegnet fra redskabet)",
tostring(vehicle.getName ~= nil and vehicle:getName() or "?"), before, after)
end
end
if planned ~= nil then
-- setValue kræver en værdi der står præcis i listen (0,1 m-trin) og afviste 49,87 m stille; setFloatValue
-- vælger trinnet inden for ±0,05 m
local rounded = math.floor(planned * 10 + 0.5) / 10
local okSet, failed = pcall(function() return vehicle:getCourseGeneratorSettings().workWidth:setFloatValue(rounded) end)
if not okSet or failed then
Logging.warning("ADSmartPickup: bredde: Courseplays kursusbredde kunne ikke sættes til %.1f m (%s)", rounded, tostring(failed))
end
end
-- lykkedes det ikke at stille en variabel bredde, startes Courseplay ikke med en halv meter (fryser spillet, 26/9)
if hasSettableVariableWidth(vehicle) then
local measured = ADCpBridge.getMeasuredWorkWidth(vehicle)
if (measured or 0) < 1.5 then
return nil, string.format("arbejdsbredden kunne ikke stilles (%.1f m)", measured or 0)
end
end
opts = opts or {}
if not ADCpBridge.isAvailable() then
return nil, "Courseplay (FIELDWORK_CP) findes ikke"
end
local farmId = vehicle:getOwnerFarmId()
local job = g_currentMission.aiJobTypeManager:createJob(AIJobType.FIELDWORK_CP)
if job == nil then return nil, "kunne ikke oprette Courseplay-job" end
job:applyCurrentState(vehicle, g_currentMission, farmId, false, false)
local vx, _, vz = getWorldTranslation(vehicle.rootNode)
local params = job.cpJobParameters
if params ~= nil and params.fieldPosition ~= nil then params.fieldPosition:setPosition(fieldX, fieldZ) end
-- startpunkt: inde på marken (opts.startX/Z fra markarbejdet), ellers maskinens plads
if params ~= nil and params.startPosition ~= nil then params.startPosition:setPosition(opts.startX or vx, opts.startZ or vz) end
-- startpunkt i kurset: CP's standard er "first" (forfra) — "nearest"/"last" på en påbegyndt mark
local startAtValues = CpFieldWorkJobParameters ~= nil and {first = CpFieldWorkJobParameters.START_AT_FIRST_POINT,
nearest = CpFieldWorkJobParameters.START_AT_NEAREST_POINT, last = CpFieldWorkJobParameters.START_AT_LAST_POINT} or {}
if opts.startAt ~= nil and startAtValues[opts.startAt] ~= nil and params ~= nil and params.startAt ~= nil then
pcall(function() params.startAt:setValue(startAtValues[opts.startAt]) end)
end
job:setValues()
local handle = {cancelled = false, fired = false, finished = false}
local function finish(ok, reason)
if handle.finished then return end
handle.finished = true
if not handle.cancelled then onDone(ok, reason) end
end
local function startWithCourse()
setLane(vehicle, params, opts.lane)
job:setValues()
local ok, err = job:validate(farmId)
if not ok then return finish(false, "Courseplay: " .. tostring(err)) end
g_currentMission.aiSystem:startJob(job, farmId)
-- første punkt langt væk: maskinen kører derhen først (brugerkrav 18/10: første punkt, aldrig nærmeste) — vis det
if opts.startAt == nil or opts.startAt == "first" then pcall(ADCpBridge.logFarFirstPoint, vehicle) end
ADCpBridge.resumeFromLast(vehicle)
finish(true, handle.copiedCourse and "copied" or (handle.reusedCourse and "reused" or nil))
end
local function generateAndStart()
if handle.cancelled then return end
-- genbrug: maskinens eget kursus (CP's validate kræver kun hasCpCourse) — ingen ny beregning
-- eget kursus genbruges kun med forager (ellers nyt kursus med 2 runder)
if opts.reuse and ADCpBridge.getCourse(vehicle) ~= nil and ADCpBridge.courseHasHeadlands(ADCpBridge.getCourse(vehicle)) then
handle.reusedCourse = true
return startWithCourse()
end
if opts.course ~= nil and vehicle.cpCopyCourse ~= nil then
local copied, copyError = pcall(vehicle.cpCopyCourse, vehicle, opts.course)
if copied then
handle.copiedCourse = true
return startWithCourse()
end
Logging.warning("ADSmartPickup: kunne ikke kopiere kursus: %s — laver nyt", tostring(copyError))
end
setMultiTools(vehicle, opts.multiTools or 1)
clampCourseWidth(vehicle)
-- kursusberegningen kører over mange frames på store marker: moden venter længere imens
local function generate(headlands)
ADCpBridge.setHeadlands(vehicle, headlands)
handle.generating = true
job:onClickGenerateFieldWorkCourse(function(generated)
handle.generating = false
if handle.cancelled then return end
if not generated and headlands > 0 then
logInfo("ADSmartPickup: kursus med %d forager-runder kunne ikke laves — prøver uden forager", headlands)
return generate(0)
end
if not generated then return finish(false, "Courseplay kunne ikke lave kursus") end
-- kurset uden forager starter også ved første punkt (brugerkrav 18/10 19:05: "first point og ikke nearest"
-- — ellers springes stykket før det nærmeste punkt over). Tidligere: nærmeste (10/10 F14 "skovtur").
local course = ADCpBridge.getCourse(vehicle)
if course ~= nil and not ADCpBridge.courseHasHeadlands(course) then
logInfo("ADSmartPickup: kursus uden forager — starter ved første punkt")
end
startWithCourse()
end)
end
generate(ADCpBridge.HEADLANDS)
end
handle.onBoundary = function(_, success, message)
if handle.fired then return end
handle.fired = true
if handle.cancelled then return end
if not success then return finish(false, "Courseplay fandt ikke markgrænsen: " .. tostring(message)) end
generateAndStart()
end
job:registerFieldBoundaryDetectionCallback(handle, handle.onBoundary)
local isValid, isRunning, message = job:detectFieldBoundary()
if isValid and not isRunning then
generateAndStart()
elseif not isRunning then
return nil, "Courseplay: " .. tostring(message)
end
return handle
end
-- Sideafstand til høsteren (Courseplays "Offset left/right", combineOffsetX) pr. vogntype. Negativ = længere ud fra
-- røret i venstre side. EDK 650 (Unrealistic) er bred og kørte ind i mejetærskeren (brugerønske 15/10: -1,5 m).
ADCpBridge.UNLOADER_OFFSETS = {{pattern = "edk650", offsetX = -1.5}}
-- Offset for sættet ud fra påhængenes xml-filnavne (små bogstaver), eller nil. files = {"…/edk650.xml", …}
function ADCpBridge.unloaderOffsetFor(files)
for _, file in ipairs(files or {}) do
local name = string.lower(tostring(file))
for _, rule in ipairs(ADCpBridge.UNLOADER_OFFSETS) do
if string.find(name, rule.pattern, 1, true) then return rule.offsetX end
end
end
return nil
end
-- Sæt vogntypens offset, men kun når spilleren ikke selv har valgt et (står den på 0).
local function applyUnloaderOffset(vehicle)
local files = {}
for _, object in ipairs(collect(vehicle)) do
if object ~= vehicle and object.configFileName ~= nil then table.insert(files, object.configFileName) end
end
local offsetX = ADCpBridge.unloaderOffsetFor(files)
if offsetX == nil or vehicle.getCpSettings == nil then return end
pcall(function()
local setting = vehicle:getCpSettings().combineOffsetX
if setting ~= nil and math.abs(setting:getValue() or 0) < 0.05 then
setting:setFloatValue(offsetX)
logInfo("ADSmartPickup: '%s' får sideafstand %.1f m til høsteren (vogntype)", tostring(vehicle:getName()), offsetX)
end
end)
end
-- Har høsteren brug for en tømmevogn? Nej kun når sættet beviseligt er en høster (spec_combine) uden rør (spec_pipe):
-- bomuldshøsteren Module Express laver selv moduler på marken (in-game 16/10 F39: tømmevogn sendt ud uden at kunne
-- bruges). Ukendt = ja (som før).
function ADCpBridge.needsUnloader(vehicle)
if vehicle == nil then return true end
local ok, combine, pipe = pcall(function()
local hasCombine, hasPipe = false, false
for _, object in ipairs(collect(vehicle)) do
if object.spec_combine ~= nil then hasCombine = true end
if object.spec_pipe ~= nil then hasPipe = true end
end
return hasCombine, hasPipe
end)
if not ok then return true end
return not combine or pipe
end
-- Høsteren skal stoppe ved fuld tank, ellers kan CP's tømmevogn ikke tømme den: med "Stop for unloading" fra
-- regner tømmevognen en fuld, holdende høster for kørende (willWaitForUnloadToFinish) og kører i ring
-- (in-game 16/10 F38: CR11 "Needs to be unloaded", EDK 650 cirklede med "not in a good position to unload").
-- Returnerer true når indstillingen blev slået til nu.
function ADCpBridge.ensureStopForUnload(harvester)
if harvester == nil or harvester.getCpSettings == nil then return false end
local ok, changed = pcall(function()
local setting = harvester:getCpSettings().stopForUnload
if setting == nil or setting:getValue() == true then return false end
return setting:setValue(true) ~= true -- setValue returnerer "failed"
end)
return ok and changed == true
end
-- Aflæsningsvogn under høst: Courseplays combine-unloader (bevist i AI-Bonden). Vognen venter ved
-- (waitX, waitZ) — markens F-markør — følger høsteren på marken og kører fuld til station. station =
-- den station Smart Pickups silovalg fandt; findes den ikke i Courseplays liste, bruges nærmeste.
-- useGiants = false: Courseplay stopper ved fuld vogn, og AutoDrive (Hent og aflever, hjælper CP) kører læsset til
-- siloen ad vejnettet og genstarter CP (in-game 4/10: CP's egen kørsel til siloen fulgte ikke AD-nettet ind i graven)
function ADCpBridge.startUnloader(vehicle, fieldX, fieldZ, waitX, waitZ, station, onDone, useGiants)
if AIJobType == nil or AIJobType.COMBINE_UNLOADER_CP == nil then
return nil, "Courseplay (COMBINE_UNLOADER_CP) findes ikke"
end
applyUnloaderOffset(vehicle)
local farmId = vehicle:getOwnerFarmId()
local job = g_currentMission.aiJobTypeManager:createJob(AIJobType.COMBINE_UNLOADER_CP)
if job == nil then return nil, "kunne ikke oprette aflæsningsjob" end
pcall(function() job:applyCurrentState(vehicle, g_currentMission, farmId, false, false) end)
local params = job.cpJobParameters
if params ~= nil then
if params.fieldPosition ~= nil then pcall(function() params.fieldPosition:setPosition(fieldX, fieldZ) end) end
if params.startPosition ~= nil then pcall(function() params.startPosition:setPosition(waitX, waitZ) end) end
-- positioner med retning: CP's applyCurrentState sætter retningen, men fejler den (pcall ovenfor) bliver den
-- aldrig sat, og spillet afviser jobbet med "Angle missing" (in-game 27/9 F15, hvert 5. min i en time)
pcall(function()
local dirX, _, dirZ = localDirectionToWorld(vehicle.rootNode, 0, 0, 1)
local angle = MathUtil.getYRotationFromDirection(dirX, dirZ)
for _, position in ipairs({params.startPosition, params.fieldUnloadPosition}) do
if position ~= nil and position.getAngle ~= nil and position:getAngle() == nil then
if position.getPosition ~= nil and select(1, position:getPosition()) == nil then
local vx, _, vz = getWorldTranslation(vehicle.rootNode)
position:setPosition(vx, vz)
end
position:setAngle(angle)
end
end
end)
if params.useGiantsUnload ~= nil then pcall(function() params.useGiantsUnload:setValue(useGiants ~= false) end) end
end
pcall(function() job:setValues() end)
local chosen = nil
local ok, stations = pcall(function() return job:getUnloadingStations() end)
if ok and type(stations) == "table" then
local best, bestDistance = nil, math.huge
for _, candidate in ipairs(stations) do
if station ~= nil and (candidate == station or candidate.owningPlaceable == station.owningPlaceable) then
best, bestDistance = candidate, -1
elseif bestDistance >= 0 then
local okPos, sx, sz = pcall(function()
local x, _, z = getWorldTranslation(candidate.owningPlaceable.rootNode)
return x, z
end)
local distance = okPos and ((sx - fieldX) ^ 2 + (sz - fieldZ) ^ 2) or math.huge
if distance < bestDistance then best, bestDistance = candidate, distance end
end
end
chosen = best
end
if chosen == nil or params == nil or params.unloadingStation == nil then
return nil, "ingen aflæsningsstation Courseplay kan bruge"
end
pcall(function() params.unloadingStation:setValue(NetworkUtil.getObjectId(chosen)) end)
pcall(function() job:setValues() end)
local handle = {cancelled = false, fired = false, finished = false, stationName = chosen.getName ~= nil and chosen:getName() or nil}
local function finish(success, reason)
if handle.finished then return end
handle.finished = true
if not handle.cancelled then onDone(success, reason) end
end
local function startJob()
if handle.cancelled then return end
local valid, err = job:validate(farmId)
if not valid then return finish(false, "Courseplay: " .. tostring(err)) end
g_currentMission.aiSystem:startJob(job, farmId)
finish(true)
end
handle.onBoundary = function(_, success, message)
if handle.fired then return end
handle.fired = true
if not success then return finish(false, "Courseplay fandt ikke markgrænsen: " .. tostring(message)) end
startJob()
end
if job.registerFieldBoundaryDetectionCallback ~= nil then
job:registerFieldBoundaryDetectionCallback(handle, handle.onBoundary)
end
local isValid, isRunning, message = job:detectFieldBoundary()
if isValid and not isRunning then
startJob()
elseif not isRunning then
return nil, "Courseplay: " .. tostring(message)
end
return handle
end