Files
fs25-adsmartpickup/FS25_ADSmartPickup/adCpBridge.lua
T

1164 lines
59 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 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.
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 = 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)
end)
if not ok then return nil end
return role, roles, filledRole, wrongFillDumpable
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
-- 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 = 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)
Logging.info("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
-- 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
Logging.info("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.
-- -> true hvis et redskab med variabel bredde er sammenfoldet (og udfoldning er sat i gang)
function ADCpBridge.unfoldVariableWidth(vehicle)
local started = false
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
pcall(object.setFoldDirection, object, object.spec_foldable.turnOnFoldDirection or 1)
started = true
end
end
return started
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() then
return false
end
end
return true
end
function ADCpBridge.getWorkWidth(vehicle)
local width = ADCpBridge.getMeasuredWorkWidth(vehicle)
-- variabel bredde på minimum (Servo 25: 1,2 m): stilles til målbredden når arbejdet starter
if (width or 0) < 1.5 and hasSettableVariableWidth(vehicle) then return ADCpBridge.VARIABLE_TARGET_WIDTH end
return width
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)
if cpWidth ~= nil 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
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)
Logging.info("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
Logging.info("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)
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
Logging.info("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 blev uden forager (CP opgav dem internt, fx 50 m bredde på en L-formet mark): start ved nærmeste
-- punkt, ikke kursets første, der kan ligge i den anden ende af marken (in-game 10/10 F14: "skovtur")
local course = ADCpBridge.getCourse(vehicle)
if course ~= nil and not ADCpBridge.courseHasHeadlands(course) and params ~= nil and params.startAt ~= nil
and CpFieldWorkJobParameters ~= nil and CpFieldWorkJobParameters.START_AT_NEAREST_POINT ~= nil then
pcall(function() params.startAt:setValue(CpFieldWorkJobParameters.START_AT_NEAREST_POINT) end)
Logging.info("ADSmartPickup: kursus uden forager — starter ved nærmeste 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: -2 m).
ADCpBridge.UNLOADER_OFFSETS = {{pattern = "edk650", offsetX = -2.0}}
-- 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)
Logging.info("ADSmartPickup: '%s' får sideafstand %.1f m til høsteren (vogntype)", tostring(vehicle:getName()), offsetX)
end
end)
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