Files
fs25-adsmartpickup/FS25_ADSmartPickup/adFieldWork.lua
T

3032 lines
179 KiB
Lua

-- AD Field Work
-- Udsendelse og opfølgning af markflådens sæt: AutoDrive kører sættet til markens F-markør, derfra starter
-- Courseplay arbejdet (eget kursus, kopieret kursus eller multi-tool-bane), og når det er færdigt kører
-- sættet hjem. Læssevogne tømmes af AutoDrive (Hent og aflever), aflæsningsvogne under høst er Courseplays
-- combine-unloader. Beslutningen om HVAD der sendes ud ligger i ADFieldJobs.decide.
ADFieldWork = {}
ADFieldWork.ARRIVE_DISTANCE = 30
ADFieldWork.IDLE_CONFIRM_MS = 5000
ADFieldWork.UNLOADER_WAIT_INSET_M = 20 -- tømmevognenes venteplads: så langt ind på marken fra kanten ved markøren
ADFieldWork.UNLOADER_WAIT_SIDE_M = 40 -- og så langt til siden langs kanten (væk fra mejetærskernes vej ind)
ADFieldWork.START_TIMEOUT_MS = 60000
ADFieldWork.COURSE_WAIT_MS = 180000
ADFieldWork.PLAYER_DRIVING_KMH = 3
ADFieldWork.PLAYER_DRIVING_MS = 3000 -- så længe skal spilleren køre selv, før sættet slippes
-- riven skal være udfoldet og i gang, før nedlægningsområdet måles
ADFieldWork.WINDROW_MEASURE_MS = 10000
-- mangler der sæt, prøves igen efter så lang tid (ikke hvert sekund over hele flåden)
ADFieldWork.NO_RIG_RETRY_MS = 30000
-- spillets hjælper: står Courseplay stille så længe uden for marken, er der ingen vej -> spillerkørsel
ADFieldWork.GIANTS_GIVE_UP_MS = 15000
ADFieldWork.COURSE_FAIL_RETRY_MS = 1800000
ADFieldWork.SWAP_INSET_M = 60 -- skærebordet skiftes så langt inde på marken, væk fra indkørslen (in-game 10/10 F5) -- Courseplay kunne ikke lave kursus/finde markgrænsen: prøv igen om 30 min
-- AutoDrive der stopper før markøren startes igen så mange gange, før turen opgives
ADFieldWork.DRIVE_RETRIES = 2
-- længere fra AD-vejnettet end dette kan AutoDrive ikke finde en rute ("Could not calculate path", in-game 26/9:
-- kultivatoren stod 666 m fra nærmeste waypoint); sådan en maskine sendes ikke ud
ADFieldWork.MAX_OFF_NETWORK = 60
-- flyttede køretøjet sig mindre end dette før AD stoppede, fandt AD ingen rute — ingen genforsøg
ADFieldWork.NO_MOVE_DISTANCE = 5
ADFieldWork.REFILL_ROLES = {seeder = true, fertilizer = true, limer = true, weeder = true}
local function log(...) ADFieldJobs.log(...) end
local function note(...) ADFieldJobs.note(...) end
local function now() return ADFieldJobs.now end
local lastNoRig = {}
-- ---- AutoDrive ----
local function stateModule(vehicle)
return vehicle.ad ~= nil and vehicle.ad.stateModule or nil
end
local function isAdActive(vehicle)
local module = stateModule(vehicle)
return module ~= nil and module:isActive()
end
-- Parkeringsture som AutoDrive genoptog ved indlæsning: spillet stopper alle hjælpere, og AD's "parkér når jobbet
-- er slut" kører så markmaskiner hjem med redskabet på (in-game 6/10: 724 + rive -> P River 1 mens F13 manglede
-- riven). Ture der var i gang de første LOAD_TRIP_SNAPSHOT_MS efter indlæsning tæller ikke som "optaget" i
-- LOAD_TRIP_MS — en mark må overtage sættet. Spillerens egne parkeringsordrer senere røres ikke.
ADFieldWork.LOAD_TRIP_SNAPSHOT_MS = 60000
ADFieldWork.LOAD_TRIP_MS = 15 * 60 * 1000
local loadTrips = setmetatable({}, {__mode = "k"})
local loadTripEnv = nil
local function parkTripMarkerId(adEnv, vehicle)
local module = stateModule(vehicle)
if module == nil or not module:isActive() or module.getMode == nil or module:getMode() ~= adEnv.AutoDrive.MODE_DRIVETO then return nil end
local marker = module.getFirstMarker ~= nil and module:getFirstMarker() or nil
if marker == nil or type(marker.name) ~= "string" or marker.name:sub(1, 2) ~= "P " then return nil end
return marker.id
end
-- AutoDrive kører en tur ud til en mark, der blev genoptaget ved indlæsning (moden gemmer ikke sine opgaver):
-- -> markens id + markør, hvis turen går til F-markøren for en mark der er slået til og har et trin med en rolle.
-- Bevidst afvejning: en tur spilleren selv startede mod en mark der er [Til], med en maskine der kan markens trin,
-- overtages også — moden kan ikke se forskel efter indlæsning.
local function fieldTripTarget(adEnv, vehicle, getFieldList)
local module = stateModule(vehicle)
if module == nil or not module:isActive() or module.getMode == nil then return nil end
local mode = module:getMode()
if mode ~= adEnv.AutoDrive.MODE_DRIVETO and mode ~= adEnv.AutoDrive.MODE_LOAD then return nil end
local marker = module.getFirstMarker ~= nil and module:getFirstMarker() or nil
if marker == nil or marker.id == nil then return nil end
return ADFieldJobs.fieldForMarker(marker.id, getFieldList()), marker
end
-- includeParkTrips: parkeringsture kun de første LOAD_TRIP_SNAPSHOT_MS; markture hele opstartsperioden
-- (marker scannes løbende, og AD genoptager sine ture lidt efter start)
function ADFieldWork.snapshotLoadTrips(adEnv, includeParkTrips)
loadTripEnv = adEnv
local fieldList, rigsById = nil, nil
local function getFieldList()
if fieldList == nil then
fieldList = {}
for fieldId, field in pairs(ADFieldJobs.state.fields) do
local info = ADFields.getInfo(fieldId)
table.insert(fieldList, {id = fieldId, markerId = info ~= nil and info.markerId or nil,
enabled = ADFieldModel.isEnabled(field) and not field.held, role = ADFieldModel.roleFor(field.stage)})
end
end
return fieldList
end
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
if loadTrips[vehicle] == nil and (ADPool == nil or ADPool.isFreeFromFlows(vehicle)) then
local id = includeParkTrips and parkTripMarkerId(adEnv, vehicle) or nil
if id ~= nil then
loadTrips[vehicle] = {markerId = id, untilMs = now() + ADFieldWork.LOAD_TRIP_MS}
Logging.info("ADSmartPickup: '%s' kører en parkeringstur genoptaget ved indlæsning — en mark må overtage den",
tostring(ADRuns.vehicleLabel(vehicle)))
else
-- tur ud til en mark (in-game 11/10: sprøjten med flydende gødning kørte selv til F36 efter indlæsning,
-- og moden lod den holde der): overtag den, når den er fremme (tickReadopt)
local vehicleId = ADRunsController.getVehicleId(vehicle)
if vehicleId ~= nil and ADFieldWork.taken[vehicleId] == nil and ADFieldJobs.state.assignments[vehicleId] == nil then
local fieldId, marker = fieldTripTarget(adEnv, vehicle, getFieldList)
local field = fieldId ~= nil and ADFieldJobs.getField(fieldId) or nil
local role = field ~= nil and ADFieldModel.roleFor(field.stage) or nil
if role ~= nil then
-- kun et sæt moden selv kan køre med markens rolle (ellers glemmes det straks og registreres igen)
if rigsById == nil then
rigsById = {}
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do rigsById[rig.id] = rig end
end
local rig = rigsById[vehicleId]
if rig ~= nil and (rig.role == role or (rig.roles ~= nil and rig.roles[role] == true)) then
ADFieldWork.taken[vehicleId] = {fieldId = fieldId, role = role, stage = field.stage,
helper = false, at = now(), trip = {markerId = marker.id}}
log(fieldId, "'%s' kører ud til %s (AutoDrive genoptog turen ved indlæsning) — overtages ved ankomst",
ADRuns.vehicleLabel(vehicle), tostring(marker.name))
local okFix, errFix = pcall(ADFieldWork.fixResumedRefill, adEnv, vehicle, fieldId)
if not okFix then Logging.warning("ADSmartPickup: genoptaget påfyldning: %s", tostring(errFix)) end
end
end
end
end
end
end
end
-- Genoptagne ture ud til marken tæller som et sæt på vej, så marken ikke får et ekstra sæt i mellemtiden
-- (review 1.62.222: ellers arbejdede både erstatningen og den genoptagne maskine på marken)
function ADFieldWork.tripPlaceholders(fieldId)
local list = {}
for vehicleId, entry in pairs(ADFieldWork.taken) do
if entry.trip ~= nil and entry.fieldId == fieldId then
table.insert(list, {vehicleId = vehicleId, fieldId = fieldId, role = entry.role, stage = entry.stage, helper = false,
phase = "driving", leader = true, groupSize = 1, placeholder = true})
end
end
return list
end
local function isLoadTrip(vehicle)
local trip = loadTrips[vehicle]
if trip == nil then return false end
if loadTripEnv == nil or now() > trip.untilMs or parkTripMarkerId(loadTripEnv, vehicle) ~= trip.markerId then
loadTrips[vehicle] = nil
return false
end
return true
end
ADFieldWork.isLoadTrip = isLoadTrip
local function stopAd(vehicle)
if isAdActive(vehicle) then vehicle:stopAutoDrive() end
end
-- Parkerede køretøjer SOVER i FS25 (motoren kalder ikke onUpdate), så AutoDrives køreopgave står stille,
-- til nogen vækker dem (in-game 25/9). Samme greb som flows (applyAndStart) + raiseActive fra AI-Bonden.
local function wake(vehicle, kick)
if vehicle.raiseActive ~= nil then vehicle:raiseActive() end
if kick and vehicle.isServer and SpecializationUtil ~= nil and SpecializationUtil.raiseEvent ~= nil then
SpecializationUtil.raiseEvent(vehicle, "onUpdate", 16, false, false, false)
end
end
local function enableParkAtJobFinished(vehicle)
local setting = vehicle.ad.settings ~= nil and vehicle.ad.settings.enableParkAtJobFinished or nil
if setting ~= nil then
setting.current = 2
setting.new = 2
end
end
local function helperCp(adEnv)
return adEnv.ADStateModule ~= nil and adEnv.ADStateModule.HELPER_CP or 1
end
-- fillType (valgfri, LOAD): varen AutoDrive skal læsse — uden den kører AD til påfyldningen og hjem tom
-- (in-game 26/9: sprøjten kom tom tilbage fra Buying Station Multifruit)
local function startAd(adEnv, vehicle, mode, firstId, secondId, fillType)
local module = stateModule(vehicle)
stopAd(vehicle)
module:setMode(mode)
module:setFirstMarkerByWayPointId(firstId)
if secondId ~= nil then module:setSecondMarkerByWayPointId(secondId) end
if fillType ~= nil then
module:setFillType(fillType)
module.selectedFillTypes = {fillType}
end
module:setStartHelper(false)
if module.setActualFarmId ~= nil then module:setActualFarmId(vehicle:getOwnerFarmId()) end
module:raiseDirtyFlag()
local current = module:getCurrentMode()
if current ~= nil and current.start ~= nil then
current:start(adEnv.AutoDrive.USER_PLAYER or 1)
else
vehicle:startAutoDrive()
end
-- "Kør til" med et løst frontredskab lige foran (fx lige sat af ved "P Front Mower"): bak fri først (8/10).
-- FØR wake: vækningen kører AD's onUpdate, og så er køreopgaven allerede taget i brug (in-game 8/10 v1.62.77)
if mode == adEnv.AutoDrive.MODE_DRIVETO and ADHitchCreep ~= nil and ADHitchCreep.backOffIfBlocked ~= nil then
local ok, err = pcall(ADHitchCreep.backOffIfBlocked, adEnv, vehicle)
if not ok then Logging.warning("ADSmartPickup: bak fri af frontredskab: %s", tostring(err)) end
end
wake(vehicle, true)
end
ADFieldWork.startAd = startAd
ADFieldWork.enableParkAtJobFinished = enableParkAtJobFinished
-- Markopgaver: AutoDrives "parkér når jobbet er færdigt" slås FRA — moden afslutter selv (finishAssignment): først
-- puljeredskabet hjem på sin plads, så traktoren. Med AD's parkering bakkede traktoren ind på sin egen plads med
-- redskabet på og kørte bagefter til redskabets plads (in-game 16/10, brugerønske). Rest-læs køres af moden.
local function disableParkAtJobFinished(vehicle)
local setting = vehicle.ad.settings ~= nil and vehicle.ad.settings.enableParkAtJobFinished or nil
if setting ~= nil then
setting.current = 1
setting.new = 1
end
end
ADFieldWork.disableParkAtJobFinished = disableParkAtJobFinished
-- AD-parkering: sidder på redskabet og kopieres af AD til traktorens stateModule (markør-INDEKS).
local function parkMarkerId(adEnv, vehicle)
local module = stateModule(vehicle)
local index = module ~= nil and module.getParkDestinationAtJobFinished ~= nil and module:getParkDestinationAtJobFinished() or nil
-- parkeringen kan ligge på vognen/redskabet (advd.parkDestination); AD kopierer den først til traktoren når
-- redskabet kobles på/vælges — efter indlæsning er kopien ofte tom (in-game 27/9: 20 af 25 "uden parkering")
if index == nil or index < 1 then
local ok, units = pcall(adEnv.AutoDrive.getAllUnits, vehicle)
for _, unit in ipairs(ok and units or {}) do
local own = unit.advd ~= nil and unit.advd.parkDestination or nil
if type(own) == "number" and own >= 1 then index = own break end
end
end
if index == nil or index < 1 then return nil end
local marker = adEnv.ADGraphManager:getMapMarkerById(index)
return marker ~= nil and marker.id or nil
end
ADFieldWork.parkMarkerId = parkMarkerId
-- Høster på marken skal stoppe ved fuld tank, så CP's tømmevogn kan tømme den (ADCpBridge.ensureStopForUnload).
-- Spillerens egne (manuelle) høstere røres ikke. Indstillingen bliver stående (brugerønske 16/10).
local function ensureHarvesterStops(assignment)
if assignment.role ~= "harvester" or assignment.manual then return end
if ADCpBridge.ensureStopForUnload(assignment.vehicle) then
log(assignment.fieldId, "'%s': Courseplay \"Stop for unloading\" slået til (ellers kører tømmevognen i ring)",
ADRuns.vehicleLabel(assignment.vehicle))
end
end
local function restLoad(adEnv, vehicle)
local ok, level = pcall(function()
return (adEnv.AutoDrive.getAllFillLevels(adEnv.AutoDrive.getAllUnits(vehicle)))
end)
return ok and tonumber(level) or 0
end
local function vehiclePosition(vehicle)
local x, _, z = getWorldTranslation(vehicle.rootNode)
return x, z
end
local function isControlledByPlayer(vehicle)
return (vehicle.getIsControlled ~= nil and vehicle:getIsControlled()) or false
end
-- ---- flåde ----
-- Optaget for markarbejdet: vores egen opgave, AutoDrive/Courseplay kører den, lånt af marksilo-flowet,
-- eller på hjemtur fra puljen (sætter redskab af).
local function isBusyVehicle(vehicle, id)
return ADFieldJobs.state.assignments[id] ~= nil or (isAdActive(vehicle) and not isLoadTrip(vehicle)) or ADCpBridge.isWorking(vehicle)
or (ADFieldSilos ~= nil and ADFieldSilos.isLoaned(vehicle)) or (ADPool ~= nil and ADPool.isReturning(vehicle))
or (ADFlowWagons ~= nil and ADFlowWagons.isEmptying(vehicle))
end
ADFieldWork.isBusyVehicle = isBusyVehicle
function ADFieldWork.getRigs(adEnv)
local rigs = {}
local state = ADFieldJobs.state
local parkedHeaders = nil -- skærebord på transporthjul (ADHeaderSwap), slås op én gang
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
local specs = ADCpBridge.getSpecs(vehicle)
local role = ADFieldFleet.roleFromSpecs(specs)
local id = ADRunsController.getVehicleId(vehicle)
-- traktorer i et almindeligt flow (æg, gylle, foder ...) hører til den drift og er ikke markflåde
-- (et stoppet flows traktorer er ledige — maskinpulje/flow-vogne)
if role ~= nil and id ~= nil and (ADPool ~= nil and ADPool.isFreeFromFlows(vehicle) or ADRunsController.getRunForVehicle(vehicle) == nil) then
local x, z = vehiclePosition(vehicle)
local rig = {
id = id, vehicle = vehicle, role = role, label = ADRuns.vehicleLabel(vehicle),
enabled = ADFieldFleet.isEnabled(state.fleetMode, state.fleet, id, state.excluded),
-- optaget: vores egen opgave, eller AutoDrive/Courseplay kører den allerede (fx spillerens
-- egen parkeringstur) — den må ikke kapres midt i en anden kørsel
busy = isBusyVehicle(vehicle, id),
-- hvorfor optaget (til loggen, når ingen maskine kan sendes ud)
busyWhy = (state.assignments[id] ~= nil and ("opgave F" .. tostring(state.assignments[id].fieldId)))
or (isAdActive(vehicle) and not isLoadTrip(vehicle) and "AutoDrive kører") or (ADCpBridge.isWorking(vehicle) and "Courseplay kører")
or (ADFieldSilos ~= nil and ADFieldSilos.isLoaned(vehicle) and "lånt af marksilo-flow")
or (ADPool ~= nil and ADPool.isReturning(vehicle) and "sætter redskab af") or nil,
controlled = isControlledByPlayer(vehicle),
-- manuel transport: spilleren kører den til marken (for bred til vejene med skærebord)
manual = (state.manual or {})[id] == true,
-- AutoDrive-parkering: uden den kører sættet ikke selv — spilleren kører det (ADPlayerTransport)
hasPark = parkMarkerId(adEnv, vehicle) ~= nil,
width = ADCpBridge.getWorkWidth(vehicle), x = x, z = z,
-- tom spreder kan flere ting (gødning og kalk): alle dens roller
roles = ADPool.rolesOf(role, specs.sprayRoles), filledRole = specs.filledRole, dumpable = specs.dumpable,
}
if role == "harvester" then
rig.fruits = ADCpBridge.getHarvestFruits(vehicle) or {}
rig.tankFillType = ADFieldWork.tankFillType(vehicle) -- nil = tom
end
-- mejetærsker uden skærebord, men et skærebord på transporthjul står parkeret ved en Connect-markør: den kan
-- hente det selv (brugerønske 10/10) — dens afgrøder er de parkerede skærebords
if role == "harvester" and not rig.manual and next(rig.fruits) == nil and ADHeaderSwap ~= nil and ADHeaderSwap.canTowHeader(vehicle) then
if parkedHeaders == nil then
local okH, list = pcall(ADHeaderSwap.parkedHeaders, adEnv, vehicle:getOwnerFarmId())
parkedHeaders = okH and list or {}
end
-- kun skærebord der passer til maskinen (in-game 14/10: Ropa Tiger 6S blev sendt efter FD250-kornskærebordet)
local fitting = {}
local combineCategories = ADHeaderSwap.storeCategories(vehicle)
for _, option in ipairs(parkedHeaders) do
if ADHeaderSwap.headerFitsCombine(combineCategories, ADHeaderSwap.storeCategories(option.vehicle)) then
table.insert(fitting, option)
end
end
if #fitting > 0 then
rig.headerOptions = fitting
-- bredden: skærebordets (mejetærskeren alene har 0 m og ville blive valgt fra)
for _, option in ipairs(fitting) do
for fruit in pairs(option.fruits or {}) do rig.fruits[fruit] = true end
if (option.width or 0) > (rig.width or 0) then rig.width = option.width end
end
end
end
if role == "seeder" then
rig.seedFruits = ADCpBridge.getSeedFruits(vehicle)
rig.hasSeeds = ADCpBridge.hasSeeds(vehicle)
rig.seedsOnPallets = not rig.hasSeeds and ADFieldWork.seedsOnPallets(vehicle)
rig.seedsRefill = not rig.hasSeeds and not rig.seedsOnPallets and ADFieldWork.seedsRefillable(adEnv, vehicle, x, z)
end
if role == "weeder" then rig.mechanical = ADCpBridge.isMechanicalWeeder(vehicle) end
table.insert(rigs, rig)
end
end
return rigs
end
-- ---- lager ----
-- Gårdens gæringssiloer for markens skår, nærmest marken først (produktioner skår -> SILAGE).
function ADFieldWork.getFermenters(adEnv, farmId, windrowFillType, x, z)
local silage = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeIndexByName("SILAGE") or nil
local result = {}
for _, building in ipairs(ADBuildings.list(adEnv, farmId)) do
local spec = building.kind == "factory" and building.placeable ~= nil and building.placeable.spec_productionPoint or nil
local point = spec ~= nil and spec.productionPoint or nil
if point ~= nil and ADFieldModel.isFermenter(point.productions, windrowFillType, silage) then
local bx, _, bz = getWorldTranslation(building.placeable.rootNode)
table.insert(result, {building = building, distance = (bx - (x or bx)) ^ 2 + (bz - (z or bz)) ^ 2})
end
end
table.sort(result, function(a, b) return a.distance < b.distance end)
local buildings = {}
for _, entry in ipairs(result) do table.insert(buildings, entry.building) end
return buildings
end
local function unloadMarkerIds(buildings)
local markerIds = {}
for _, building in ipairs(buildings) do
for _, marker in ipairs(ADBuildings.getMarkers(building, "unload") or {}) do
table.insert(markerIds, marker.id)
end
end
return markerIds
end
-- Hvilken vare markens trin fører til lager: skår (ensilage), tørskår (hø) eller høstet afgrøde.
function ADFieldWork.storeFillType(field, info)
if field.stage == "harvesting" then return info.harvestFillType end
if field.stage == "baleCollecting" and ADFieldModel.isBaleHarvest(field.lastFruit) then
return g_fillTypeManager:getFillTypeIndexByName(string.upper(field.lastFruit))
end
if field.stage == "strawCollecting" or field.stage == "baling" or field.stage == "baleCollecting" then
return g_fillTypeManager:getFillTypeIndexByName("STRAW")
end
local product = ADFieldModel.product(field.plan, field.kind or info.kind)
return product == "hay" and info.hay or info.windrow
end
-- Tvunget lager -> de valgte; ensilage -> gæringssiloer før almindelige siloer (in-game 25/9: græs endte
-- i en Farma-silo); hø og høst -> kun siloer (gæringssiloer laver også hø om til ensilage).
local saleLogged = {} -- fieldId -> salgsmarkør der sidst blev logget (log kun ved skift)
function ADFieldWork.chooseStore(adEnv, field, info, vehicle, fillType)
local isReachable = function(markerId) return ADUnloadWait.hasRouteTo(adEnv, vehicle, markerId) end
local farmId = vehicle:getOwnerFarmId()
-- høstkontrakt: læssene skal til kontraktens salgssted (ADContracts), aldrig gårdens lager
if field.contract and field.contractSellIds ~= nil then
if #field.contractSellIds == 0 then return nil, "kontraktens salgssted har ingen AutoDrive-markør" end
return ADLoadSwap.findForcedDumpMarker(adEnv, vehicle, fillType, 1, field.contractSellIds, isReachable)
end
if #field.plan.storeBuildingIds > 0 then
local buildings = {}
for _, buildingId in ipairs(field.plan.storeBuildingIds) do
local building = ADBuildings.find(adEnv, farmId, buildingId)
if building ~= nil then table.insert(buildings, building) end
end
return ADLoadSwap.findForcedDumpMarker(adEnv, vehicle, fillType, 1, unloadMarkerIds(buildings), isReachable)
end
local product = ADFieldModel.product(field.plan, field.kind or info.kind)
if field.stage == "collecting" and product == "silage" then
local fermenters = ADFieldWork.getFermenters(adEnv, farmId, fillType, info.x, info.z)
if #fermenters > 0 then
local store, why = ADLoadSwap.findForcedDumpMarker(adEnv, vehicle, fillType, 1, unloadMarkerIds(fermenters), isReachable)
if store ~= nil then return store end
log(field.id, "ingen gæringssilo kan tage græsset (%s) — bruger almindelig silo", tostring(why))
end
end
local store, why = ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, 1, info.markerId, isReachable, nil, nil, false)
if store ~= nil then return store end
-- intet lager tager afgrøden: sælg den ved det bedst betalende salgssted med AD-markør og vej (in-game 16/10:
-- sukkerroer fra F36 — gården har intet roelager, og tømmevognene blev sluppet igen og igen)
-- kun når INTET lager tager varen — en fuld eller utilgængelig silo betyder vent, ikke sælg (review 16/10)
local okAny, anyStore = pcall(ADLoadSwap.anyStoreAccepts, adEnv, vehicle, fillType, info.markerId)
if okAny and anyStore then return nil, why end
local sale, price = ADFieldWork.findSaleMarker(adEnv, vehicle, fillType, info.markerId)
if sale ~= nil then
if saleLogged[field.id] ~= sale.id then
saleLogged[field.id] = sale.id
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
log(field.id, "intet lager tager %s — høsten sælges ved %s (%.0f kr/1000 l)", tostring(name), tostring(sale.name), (price or 0) * 1000)
end
return sale
end
return nil, why
end
-- Ren: salgstilbud {price, wayPointId, name, routed} -> det bedst betalende der kan nås (nil hvis intet).
function ADFieldWork.pickSaleQuote(quotes)
local best = nil
for _, quote in ipairs(quotes or {}) do
if quote.routed and (best == nil or quote.price > best.price or (quote.price == best.price and quote.wayPointId < best.wayPointId)) then
best = quote
end
end
return best
end
-- Salgssted for høst uden lager: alle salgsmarkører (som udkørselsflowene: ikke spærrede, ikke P/Connect/Wait) hvis
-- station tager varen; højeste pris med vej fra marken og tilbage. -> AD-markør, pris pr. liter | nil
-- stationOk(station) (valgfri): ekstra krav til stationen (baller: ballestation, ADFieldWork.stationTakesBales)
function ADFieldWork.findSaleMarker(adEnv, vehicle, fillType, fieldMarkerId, stationOk)
if fillType == nil or ADSources == nil or ADSources.getSellMarkers == nil or ADPrices == nil then return nil end
local farmId = vehicle:getOwnerFarmId()
local quotes = {}
for _, entry in ipairs(ADSources.getSellMarkers(adEnv, farmId) or {}) do
if ADSources.stationAccepts(entry.station, fillType) and (stationOk == nil or stationOk(entry.station)) then
local quote = ADPrices.getQuote(entry.station, fillType)
if quote ~= nil and quote.price > 0 then
table.insert(quotes, {price = quote.price, wayPointId = entry.marker.id, name = entry.marker.name, routed = false})
end
end
end
-- rutetjek kun for de bedste (dyrt): højeste pris først, stop ved første der kan nås
table.sort(quotes, function(a, b)
if a.price ~= b.price then return a.price > b.price end
return a.wayPointId < b.wayPointId
end)
for _, quote in ipairs(quotes) do
local ok, routed = pcall(function()
if fieldMarkerId ~= nil then return ADWaitPool.hasRouteBothWays(adEnv, vehicle, quote.wayPointId, fieldMarkerId) end
return ADUnloadWait.hasRouteTo(adEnv, vehicle, quote.wayPointId)
end)
quote.routed = ok and routed == true
if quote.routed then break end
end
local best = ADFieldWork.pickSaleQuote(quotes)
if best == nil then return nil end
return adEnv.ADGraphManager:getMapMarkerByWayPointId(best.wayPointId), best.price
end
-- ---- kurser ----
local function coursesOf(fieldId)
ADFieldJobs.courses[fieldId] = ADFieldJobs.courses[fieldId] or {}
return ADFieldJobs.courses[fieldId]
end
-- Kurset et trin skal genbruge ("mower"/"rake"/"harvester"): gemt kopi, ellers maskinens nuværende kursus.
local function sourceCourse(adEnv, field, source)
local saved = coursesOf(field.id)[source]
if saved ~= nil then return saved end
local vehicleIds = {mower = field.mowVehicleId, rake = field.rakeVehicleId, harvester = field.harvestVehicleId}
local vehicleId = vehicleIds[source]
if vehicleId == nil then return nil end
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
if ADRunsController.getVehicleId(vehicle) == vehicleId then return ADCpBridge.getCourse(vehicle) end
end
return nil
end
local function copyCourse(course)
if course ~= nil and course.copy ~= nil then
local ok, copy = pcall(course.copy, course)
if ok and copy ~= nil then return copy end
end
return course
end
local function rememberCourse(field, key, vehicle)
-- et kursus beregnet med skærebordet på transporthjul BAG mejetærskeren er forkert (redskabet bagved) og må ikke
-- genbruges (in-game 10/10: kopieret til Mejetærsker 2 på F14, som kørte "på vildtur")
if ADHeaderSwap ~= nil and ADHeaderSwap.headerPosition(vehicle) == "rear" then return end
coursesOf(field.id)[key] = copyCourse(ADCpBridge.getCourse(vehicle))
end
-- ---- udsendelse ----
local function restoreToolOffset(assignment)
if assignment.restoreToolOffset ~= nil then
ADCpBridge.setToolOffset(assignment.vehicle, assignment.restoreToolOffset)
assignment.restoreToolOffset = nil
end
end
function ADFieldWork.release(assignment, phase)
restoreToolOffset(assignment)
if assignment.handle ~= nil then assignment.handle.cancelled = true end
-- henter stadig puljeredskabet: afbryd koblingen, så det ikke kobles på uden en opgave
if assignment.phase == "fetching" and assignment.hitch ~= nil and not assignment.hitch.done and ADHitch ~= nil then
ADHitch.cancel(assignment.vehicle)
end
-- skærebords-skift i gang: stop det, så det ikke kører videre uden en opgave
if (assignment.phase == "mountingHeader" or assignment.phase == "unmountingHeader") and ADHeaderSwap ~= nil then
pcall(ADHeaderSwap.cancel, assignment.vehicle)
end
assignment.phase = phase or "released"
if ADPool ~= nil and assignment.pool ~= nil then ADPool.release(assignment) end
ADFieldJobs.state.assignments[assignment.vehicleId] = nil
end
-- Findes såmaskinens frø (SEEDS eller fx ris-stiklinger) på paller hos gården?
function ADFieldWork.seedsOnPallets(vehicle)
if ADPalletRefill == nil or vehicle == nil or vehicle.getOwnerFarmId == nil then return false end
local ok, result = pcall(function()
local fillType = ADCpBridge.getRefillFillType(vehicle, "seeder")
return fillType ~= nil and ADPalletRefill.hasAny(vehicle:getOwnerFarmId(), fillType)
end)
return ok and result == true
end
-- Tom og ingen station med varen: paller (løse eller i palleskur). -> true når påfyldningen er startet
local function startPalletRefill(adEnv, assignment, vehicle, fillType, label)
if ADPalletRefill == nil then return false end
local ok, source = pcall(ADPalletRefill.findSource, adEnv, vehicle, fillType)
if not ok or source == nil then return false end
assignment.pallet = ADPalletRefill.newJob(source, fillType)
assignment.phase, assignment.since = "palletRefill", now()
assignment.startX, assignment.startZ = vehiclePosition(vehicle)
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, source.markerId, nil)
log(assignment.fieldId, "'%s' er tom — henter %s fra %s ved %s", tostring(label), ADPalletRefill.fillName(fillType),
tostring(source.kind), tostring(source.markerName))
return true
end
local function fail(fieldId, text)
note(fieldId, {retryAt = now() + ADFieldModel.RETRY_MS, reason = {text = tostring(text)}})
log(fieldId, "%s", tostring(text))
ADFieldJobs.notify(string.format("F%s: %s", tostring(fieldId), tostring(text)), true)
end
-- Hvad et sæt skal kunne ud over rollen (afgrøde, frø, ukrudtets størrelse).
-- Afstand fra (x, z) til nærmeste AD-waypoint (nil hvis vejnettet ikke kan læses).
function ADFieldWork.distanceToNetwork(adEnv, x, z)
-- gemmes 30 s pr. 10 m-celle (15.000 waypoints pr. opslag)
if ADCacheGet ~= nil then
local key = string.format("%d:%d", math.floor(x / 10), math.floor(z / 10))
return ADCacheGet("networkDistance", key, 30000, function() return ADFieldWork.distanceToNetworkUncached(adEnv, x, z) end)
end
return ADFieldWork.distanceToNetworkUncached(adEnv, x, z)
end
function ADFieldWork.distanceToNetworkUncached(adEnv, x, z)
local ok, best = pcall(function()
local wayPoints = adEnv.ADGraphManager:getWayPoints()
local bestD = math.huge
for _, wp in pairs(wayPoints or {}) do
local d = (wp.x - x) ^ 2 + (wp.z - z) ^ 2
if d < bestD then bestD = d end
end
return math.sqrt(bestD)
end)
return ok and best ~= math.huge and best or nil
end
-- Tømmevogn under høst: traktor med vogn eller puljevogn — ikke en lastbil med eget lad (Courseplays mejetærsker
-- registrerer den ikke som tømmevogn; in-game 4/10: Lizard-tiplastbilen holdt ved F5 uden at blive tømt i)
function ADFieldWork.unloaderAccepts(vehicle)
if vehicle == nil then return false end
return not (vehicle.spec_motorized ~= nil and vehicle.spec_trailer ~= nil)
end
-- Såmaskinen kan afgrøden og har frø på, på paller eller ved en påfyldning (lager/købestation med AD-markør);
-- en tom maskine fyldes op på vejen (refillPlan). In-game 5/10: nykøbt, tom NS 3030 blev afvist ("none can do it").
function ADFieldWork.seederAccepts(candidate, fruitIndex)
local seeds = candidate.hasSeeds or candidate.seedsOnPallets or candidate.seedsRefill
return seeds == true and fruitIndex ~= nil and type(candidate.seedFruits) == "table" and candidate.seedFruits[fruitIndex] == true
end
-- Findes en påfyldning med såmaskinens frø (AD-markør ved lager/købestation)? Uden rutetjek: vehicle kan være et
-- frakoblet puljeredskab (in-game 5/10: AD's getPathTo fejlede på vehicle.ad.frontNode, så NS 3030 blev afvist).
function ADFieldWork.seedsRefillable(adEnv, vehicle, x, z)
if adEnv == nil or vehicle == nil then return false end
local ok, result = pcall(function()
local fillType = ADCpBridge.getRefillFillType(vehicle, "seeder")
return fillType ~= nil and ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, x, z, true) ~= nil
end)
return ok and result == true
end
-- Ballelasterens fyldtyper for en ballehøst-afgrøde: {SQUAREBALE_COTTON, ROUNDBALE_COTTON} som indeks (de findes).
function ADFieldWork.baleFillTypes(fruit)
local result = {}
if fruit == nil or g_fillTypeManager == nil then return result end
for _, prefix in ipairs({"SQUAREBALE_", "ROUNDBALE_"}) do
local index = g_fillTypeManager:getFillTypeIndexByName(prefix .. string.upper(tostring(fruit)))
if index ~= nil then table.insert(result, index) end
end
return result
end
-- Kan sættet (traktor med opsamler, eller løs opsamler) bære en af balletyperne? Uden kendte typer: nej.
function ADFieldWork.carriesAnyBale(vehicle, baleTypes)
if vehicle == nil or #(baleTypes or {}) == 0 then return false end
for _, fillType in ipairs(baleTypes) do
if ADPool.rigHasCargoFor(vehicle, fillType) then return true end
end
return false
end
local function acceptFor(field, info, role)
if role == "harvester" then
local fruit = info.fruitIndex
return function(candidate) return ADManualTransport.acceptsHarvester(candidate, fruit) end
elseif role == "seeder" then
local fruitIndex = ADFieldWork.sowFruitIndex(field)
-- tom såmaskine er med, når dens frø findes på paller (risplanter + stiklingepaller, in-game 4/10)
return function(candidate) return ADFieldWork.seederAccepts(candidate, fruitIndex) end
elseif role == "unloader" then
-- vognen skal kunne bære høstens vare (påkoblet vogn eller løs vogn, se ADPool.rigCarries)
local fillType = info.harvestFillType
return function(candidate)
return ADFieldWork.unloaderAccepts(candidate.vehicle) and ADPool.rigCarries(candidate.vehicle, fillType)
end
elseif role == "baleCollector" and ADFieldModel.isBaleHarvest(field.lastFruit) then
-- bomuldsmoduler: kun en opsamler der kan bære dem (SQUAREBALE_/ROUNDBALE_COTTON) — in-game 16/10 F39 tog
-- spillerens Pickup 2017, Courseplay fandt intet at samle, og marken gik videre med modulerne liggende
local baleTypes = ADFieldWork.baleFillTypes(field.lastFruit)
return function(candidate) return ADFieldWork.carriesAnyBale(candidate.vehicle, baleTypes) end
elseif role == "weeder" then
local large = (info.weed or 0) > ADFieldModel.WEED_MECHANICAL_MAX
return function(candidate) return not (large and candidate.mechanical) end
end
return nil
end
function ADFieldWork.sowFruitIndex(field)
local name = ADFieldModel.sowFruit(field)
if name == nil or g_fruitTypeManager == nil then return nil end
local fruit = g_fruitTypeManager:getFruitTypeByName(name)
return fruit ~= nil and fruit.index or nil
end
-- Kan trinnet overhovedet begynde? (såning: afgrøde valgt og i såperioden)
local function preflight(field, role)
if role == "seeder" then
local fruitIndex = ADFieldWork.sowFruitIndex(field)
if fruitIndex == nil then return false, {key = "spu_field_reason_noSowFruit"} end
if not ADCpBridge.isPlantableNow(fruitIndex) then
return false, {key = "spu_field_reason_notPlantable", name = ADFieldModel.sowFruit(field)}
end
end
return true
end
ADFieldWork.REFILL_ROLES = {seeder = true, fertilizer = true, limer = true, weeder = true}
local function fillTypeName(fillType)
return g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
end
-- Før udsendelse: forkert vare af (kalk på, skal gøde), og er sættet tomt, findes påfyldningen.
-- Returnerer {fillType, empty, refillId} eller nil (sættet bruger intet fyld: strigle, plov ...).
local function refillPlan(adEnv, fieldId, vehicle, role, x, z)
if not ADFieldWork.REFILL_ROLES[role] then return nil end
local dumped, dumpedName = ADCpBridge.emptySprayerIfWrong(vehicle, role)
if dumped > 0 then
log(fieldId, "'%s' tømt for %.0f l %s (skal bruges til %s)", ADRuns.vehicleLabel(vehicle), dumped, tostring(dumpedName), tostring(role))
end
local fillType = ADCpBridge.getRefillFillType(vehicle, role)
if fillType == nil then return nil end
local empty = ADCpBridge.getRefillLevel(vehicle, fillType) <= 0
local refillId = empty and ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, x, z) or nil
if refillId ~= nil then
local marker = adEnv.ADGraphManager:getMapMarkerByWayPointId(refillId)
log(fieldId, "'%s' er tom: fyldes med %s ved %s (på vognen: %s)", ADRuns.vehicleLabel(vehicle), fillTypeName(fillType), tostring(marker ~= nil and marker.name or refillId), ADCpBridge.describeFill(vehicle))
end
return {fillType = fillType, empty = empty, refillId = refillId}
end
-- Manuel transport: bed spilleren køre høsteren til marken (dialog første gang, ellers besked i hjørnet).
local function askPlayer(field, info, assignment, withDialog)
local text = string.format("F%s skal høstes: kør '%s' til %s, montér skærebordet og stig ud — så overtager Smart Pickup",
tostring(field.id), ADRuns.vehicleLabel(assignment.vehicle), tostring(info.markerName or ("F" .. tostring(field.id))))
if assignment.manualMount then
text = string.format("F%s: '%s' kunne ikke selv montere skærebordet — montér det foran og stig ud, så overtager Smart Pickup",
tostring(field.id), ADRuns.vehicleLabel(assignment.vehicle))
end
assignment.remindedAt = now()
log(field.id, "venter på spilleren: %s", text)
ADFieldWork.tellPlayer(text, withDialog)
end
-- Besked til spilleren om at køre en maskine: pop-up (første gang) eller kun statusvinduet, efter indstillingen
-- playerPopup. Påmindelser (withDialog = false) kommer i hjørnet — med "kun statusvindue" slet ikke.
function ADFieldWork.tellPlayer(text, withDialog)
local popup = ADSettings == nil or ADSettings.get("playerPopup") ~= 0
if not popup then return end
if withDialog and InfoDialog ~= nil and InfoDialog.show ~= nil then
pcall(InfoDialog.show, "Smart Pickup: " .. text)
else
ADFieldJobs.notify(text, true)
end
end
-- Puljekombination: nærmeste puljeredskab til marken + nærmeste ledige traktor med nok hk. Traktoren kører til
-- "Connect X", kobler på og fortsætter så som en almindelig udsendelse (fase fetching -> driving).
-- Puljen fandt intet sæt: skriv hvorfor og hvad den så (én gang pr. ændring pr. mark). In-game 4/10: F5 stod
-- på "noRig" uden tømmevogn, selvom en frakoblet GX 520 med parkering og Connect stod klar.
local lastPoolMiss = {}
function ADFieldWork.logPoolMiss(fieldId, role, why, implements, tractors, accept)
local seen = {}
for _, implement in ipairs(implements or {}) do
local hasRole = implement.role == role or (implement.roles ~= nil and implement.roles[role] == true)
local state = not hasRole and ("rolle " .. tostring(implement.role))
or (accept ~= nil and not accept(implement) and "afvist (vare/bredde)") or "ok"
table.insert(seen, string.format("'%s': %s", tostring(implement.name), state))
end
local pullers = {}
for _, tractor in ipairs(tractors or {}) do
table.insert(pullers, string.format("'%s'%s", tostring(tractor.name), tractor.offNetwork and " (uden for vejnettet)" or ""))
end
local text = string.format("pulje fandt intet til %s (%s) — puljeredskaber: %s; frie traktorer: %s", tostring(role), tostring(why),
#seen > 0 and table.concat(seen, ", ") or "ingen", #pullers > 0 and table.concat(pullers, ", ") or "ingen")
if lastPoolMiss[fieldId] ~= text then
lastPoolMiss[fieldId] = text
log(fieldId, "%s", text)
end
end
function ADFieldWork.dispatchPool(adEnv, field, info, role, roleAccept, decision)
local implements, tractors = ADPool.collect(adEnv, function(vehicle)
return isBusyVehicle(vehicle, ADRunsController.getVehicleId(vehicle))
end)
local accept = function(implement)
-- samme felter som getRigs giver sæt, så markens krav (frø, afgrøde, ukrudt) tjekkes på redskabet selv
local candidate = {role = implement.role, roles = implement.roles, vehicle = implement.vehicle}
if role == "seeder" then
candidate.seedFruits = ADCpBridge.getSeedFruits(implement.vehicle)
candidate.hasSeeds = ADCpBridge.hasSeeds(implement.vehicle)
candidate.seedsOnPallets = not candidate.hasSeeds and ADFieldWork.seedsOnPallets(implement.vehicle)
candidate.seedsRefill = not candidate.hasSeeds and not candidate.seedsOnPallets
and ADFieldWork.seedsRefillable(adEnv, implement.vehicle, info.x, info.z)
end
if role == "weeder" then candidate.mechanical = ADCpBridge.isMechanicalWeeder(implement.vehicle) end
if roleAccept ~= nil and not roleAccept(candidate) then return false end
-- tømmevogn: skal kunne bære høstens vare
if role == "unloader" and not ADPool.canCarry(implement, info.harvestFillType) then return false end
local required = ADFieldModel.requiredWidth(field, role)
return (implement.width or 0) <= 0 or ADFieldModel.checkWidth(role, implement.width, required)
end
local pair, why, args = ADPool.pairFor(role, info.x, info.z, implements, tractors, ADPool.blocked(now()), accept)
if pair == nil then
ADFieldWork.logPoolMiss(field.id, role, why, implements, tractors, accept)
return false, why, args
end
local tractor, implement = pair.tractor, pair.implement
-- kombi (front + bag slåmaskine, in-game 8/10): begge hentes, front først — ét sæt, der altid følges ad
local fetchList, names, ids, connectIds = {}, {}, {}, {}
for _, item in ipairs(pair.implements or {implement}) do
table.insert(fetchList, {id = item.id, name = item.name, connectId = item.connectId})
table.insert(names, tostring(item.name))
table.insert(ids, item.id)
table.insert(connectIds, item.connectId)
end
table.insert(ids, tractor.id)
local implementName = table.concat(names, " + ")
local assignment = {
vehicleId = tractor.id, vehicle = tractor.vehicle, fieldId = field.id, role = role, stage = field.stage,
helper = decision ~= nil and decision.helper == true, phase = "fetching", since = now(), width = implement.width,
groupSize = 1, leader = true, fillType = decision ~= nil and decision.helper and info.harvestFillType or nil,
startX = tractor.x, startZ = tractor.z,
pool = {implementId = implement.id, implementName = implementName, connectId = implement.connectId, implements = fetchList},
hitch = {done = false},
}
ADFieldJobs.state.assignments[tractor.id] = assignment
ADPool.reserve(assignment, ids)
local function onFetched(_, ok, detail, failedIndex)
assignment.hitch = {done = true, ok = ok, detail = detail, failedIndex = failedIndex}
end
if #connectIds > 1 then
ADHitch.route(adEnv, tractor.vehicle, connectIds, onFetched)
else
ADHitch.fetch(adEnv, tractor.vehicle, implement.connectId, onFetched)
end
note(field.id, {reason = {key = "spu_field_reason_fetching", name = implementName}})
log(field.id, "%s: '%s' henter '%s' (%s)", role, tractor.name, implementName, "pulje")
return true
end
function ADFieldWork.dispatch(adEnv, field, info, decision)
local role = decision.role
-- marken har afgrøde, men ingen markjord i kortet: Courseplay finder ikke markgrænsen ("Field detection failed",
-- in-game 10/10 Flat Acres 4X F2) — spilleren må høste/bearbejde den selv
if info ~= nil and info.cropOnly then
fail(field.id, "kortet har ingen markjord her — Courseplay kan ikke finde markgrænsen; høst/bearbejd marken selv")
return
end
local ok, reason = preflight(field, role)
if not ok then
note(field.id, {retryAt = now() + ADFieldModel.RETRY_MS, reason = reason})
return
end
-- faste maskiner: andre markers faste bruges ikke; har marken selv faste med rollen, kun dem
local rigIdsByField = {}
for fieldId, other in pairs(ADFieldJobs.state.fields) do rigIdsByField[fieldId] = other.plan ~= nil and other.plan.rigIds or nil end
local candidates = ADFieldFleet.filterDedicated(ADFieldWork.getRigs(adEnv), field.id, role, rigIdsByField)
-- lånt kontraktudstyr kun til kontrakter (aldrig gårdens egne marker) — men gerne en anden kontrakt end den, det er
-- lånt til: så spares lejen (brugerønske 10/10)
if ADContracts ~= nil and not field.contract then
local usable = {}
for _, candidate in ipairs(candidates) do
if not ADContracts.isMissionVehicle(candidate.vehicle) then table.insert(usable, candidate) end
end
candidates = usable
end
-- kontraktmark: kontraktens eget lånte udstyr først, så andet lånt udstyr, og gårdens egne maskiner til sidst
if field.contract and ADContracts ~= nil then
local isLeased = function(vehicle) return ADContracts.isLeasedFor(field, vehicle) end
local leasedFirst = ADContracts.preferLeased(candidates, isLeased)
if leasedFirst == candidates then leasedFirst = ADContracts.preferLeased(candidates, ADContracts.isMissionVehicle) end
-- intet lånt sæt samlet, men det lånte redskab står løst: bed spilleren koble det på (frem for gårdens eget)
if leasedFirst == candidates and ADPlayerTransport ~= nil
and ADPlayerTransport.dispatchLeasedImplement(adEnv, field, info, role, ADFieldModel.requiredWidth(field, role), acceptFor(field, info, role)) then
return
end
candidates = leasedFirst
end
local required = ADFieldModel.requiredWidth(field, role)
local roleAccept = acceptFor(field, info, role)
-- kun maskiner AutoDrive kan køre fra: tæt på vejnettet
local offNetwork = {}
local accept = function(candidate)
if roleAccept ~= nil and not roleAccept(candidate) then return false end
-- høster med noget i tanken: kun en mark med samme afgrøde (ellers blandes den i tanken)
if role == "harvester" and candidate.tankFillType ~= nil and info.harvestFillType ~= nil
and candidate.tankFillType ~= info.harvestFillType then return false end
-- manuel transport: spilleren kører den — afstand til AutoDrive-vejnettet er ligegyldig
if role == "harvester" and candidate.manual then return true end
-- kontraktmark uden F-markør: spillets egen hjælper (Courseplay-jobbets kørsel med Giants' vejfinding) kører
-- sættet derud — ingen AutoDrive, ingen parkering nødvendig (brugerønske 10/10). Mejetærsker kun med eget skærebord foran.
if info.markerId == nil then
if not field.contract then return false end
if role == "harvester" and (candidate.headerOptions ~= nil
or (ADHeaderSwap ~= nil and candidate.vehicle ~= nil and ADHeaderSwap.headerPosition(candidate.vehicle) == "rear")) then
return false
end
return true
end
-- skærebord på transporthjul FORAN (foldet ud): må ikke ud på vejen — kun til den mark, den står på.
-- Optaget (høster en anden mark): sættes bag på efter høst, så marken venter i kø — ikke "kan ingen"
-- (in-game 15/10: F95 hvede rød, mens Mejetærsker 1 høstede F63 med FD250 foran)
if role == "harvester" and not candidate.busy and ADHeaderSwap ~= nil and candidate.vehicle ~= nil and ADHeaderSwap.headerPosition(candidate.vehicle) == "front"
and not (candidate.x ~= nil and #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(candidate.x, candidate.z, info.verts)) then
return false
end
-- uden parkering (eller langt fra vejnettet): spilleren kører den (ADPlayerTransport), ikke AutoDrive
if ADPlayerTransport ~= nil and ADPlayerTransport.needsPlayer(adEnv, candidate, role, decision) then return false end
local d = candidate.x ~= nil and ADFieldWork.distanceToNetwork(adEnv, candidate.x, candidate.z) or nil
if d ~= nil and d > ADFieldWork.MAX_OFF_NETWORK then
table.insert(offNetwork, string.format("'%s' %.0f m", tostring(candidate.label), d))
return false
end
return true
end
local rigs, why, args
if (decision.count or 1) > 1 then
rigs, why, args = ADFieldFleet.pickMany(candidates, role, decision.count, info.x, info.z, required, accept)
else
local rig
rig, why, args = ADFieldFleet.pick(candidates, role, info.x, info.z, required, accept)
rigs = rig ~= nil and {rig} or nil
end
if rigs == nil then
-- ingen færdig kombination: en ledig solo-traktor henter et puljeredskab (kun hovedopgaver, ikke tømmevogne)
-- marken har egne faste maskiner til rollen: den venter på dem (som uden puljen)
local ownIds, hasOwnForRole = {}, false
for _, id in ipairs(field.plan ~= nil and field.plan.rigIds or {}) do ownIds[id] = true end
for _, candidate in ipairs(candidates) do
if ownIds[candidate.id] and (candidate.role == role or (candidate.roles ~= nil and candidate.roles[role])) then hasOwnForRole = true end
end
if ADPool ~= nil and info.markerId ~= nil and ADPool.mayUsePool(decision, hasOwnForRole)
and (why == "noRig" or why == "allBusy" or why == "cannotDo") then
local pooled, poolWhy, poolArgs = ADFieldWork.dispatchPool(adEnv, field, info, role, roleAccept, decision)
if pooled then return end
if poolWhy == "tooWeak" then
note(field.id, {reason = {text = string.format("ingen ledig traktor med ≥%.0f hk til '%s'",
(poolArgs or {})[1] or 0, tostring((poolArgs or {})[2] or role))}, retryAt = ADPool.alignedRetry(now(), ADFieldWork.NO_RIG_RETRY_MS)})
return
end
if poolWhy == "noPoolTractor" and why ~= "allBusy" then
why, args = poolWhy, poolArgs
elseif poolWhy == "poolBusy" then
-- puljeredskabet hentes til en anden mark: kø (gul), ikke "ingen maskine" (rød)
why, args = "allBusy", nil
end
end
-- intet kan køre selv: bed spilleren køre et sæt (eller et frakoblet redskab) til marken
if ADPlayerTransport ~= nil and ADPlayerTransport.dispatch(adEnv, field, info, role, decision, candidates, required, roleAccept) then
lastNoRig[field.id] = nil
return
end
-- ingen stenplukker på gården overhovedet: stenene springes over, så såningen ikke går i stå
if role == "stonePicker" and why == "noRig" then
ADFieldJobs.setField(ADFieldModel.advance(field, info.needs))
log(field.id, "ingen stenplukker på gården — stenplukning springes over")
return
end
if #offNetwork > 0 and (why == "cannotDo" or why == "noRig") then
-- de eneste med rollen står uden for AD-vejnettet
note(field.id, {reason = {text = string.format("ingen %s kan køre til %s — står for langt fra AutoDrive-vejnettet (%s)",
tostring(role), tostring(info.markerName), table.concat(offNetwork, ", "))}, retryAt = ADPool.alignedRetry(now(), ADFieldWork.NO_RIG_RETRY_MS)})
return
end
note(field.id, {reason = {key = "spu_field_reason_" .. tostring(why), role = role, args = args}, retryAt = ADPool.alignedRetry(now(), ADFieldWork.NO_RIG_RETRY_MS)})
-- også i loggen (én gang pr. ændring): før stod grunden kun i fanen, og loggen var tavs (in-game 27/9)
local noRigKey = tostring(role) .. ":" .. tostring(why)
if lastNoRig[field.id] ~= noRigKey then
lastNoRig[field.id] = noRigKey
-- hvem har rollen, og hvorfor kan de ikke bruges (in-game 27/9: "allBusy" uden at sige hvem)
local who = {}
for _, candidate in ipairs(candidates) do
if candidate.role == role or (candidate.roles ~= nil and candidate.roles[role]) then
local state = candidate.controlled and "spiller i førersædet" or candidate.busyWhy
or (not candidate.enabled and "ikke i flåden") or (roleAccept ~= nil and not roleAccept(candidate) and "kan ikke (afgrøde/frø)") or "ledig"
table.insert(who, string.format("'%s': %s", tostring(candidate.label), state))
end
end
log(field.id, "ingen maskine sendt til %s: %s%s", tostring(role), tostring(why), #who > 0 and (" — " .. table.concat(who, "; ")) or "")
end
return
end
lastNoRig[field.id] = nil
local count = #rigs
local lanes = ADFieldModel.lanePositions(count)
for index, rig in ipairs(rigs) do
local assignment = {
vehicleId = rig.id, vehicle = rig.vehicle, fieldId = field.id, role = role, stage = field.stage,
helper = decision.helper == true, phase = "driving", since = now(), width = rig.width,
groupSize = decision.helper and 1 or count, lane = count > 1 and lanes[index] or nil, leader = index == 1,
fillType = decision.helper and info.harvestFillType or nil,
}
local header = role == "harvester" and not rig.manual and not assignment.helper and rig.headerOptions ~= nil
and ADHeaderSwap.pickHeader(rig.headerOptions, info.fruitIndex, info.x, info.z) or nil
if header == nil and rig.headerOptions ~= nil then
-- mejetærsker uden skærebord og intet ledigt skærebord til afgrøden: sendes ikke ud
log(field.id, "harvester: '%s' har intet skærebord, og intet ledigt skærebord kan høste afgrøden", rig.label)
elseif header ~= nil then
header.taken = true
if (header.width or 0) > 0 then assignment.width = header.width end
-- henter sit skærebord på transporthjul (som puljens "fetching": samme fejl- og karantænevej), monterer det på marken
assignment.phase, assignment.startX, assignment.startZ = "fetching", rig.x, rig.z
assignment.pool = {implementId = header.id, implementName = header.name, connectId = header.connectId,
implements = {{id = header.id, name = header.name, connectId = header.connectId}}}
assignment.hitch, assignment.headerSwap = {done = false}, {}
ADFieldJobs.state.assignments[rig.id] = assignment
ADPool.reserve(assignment, {header.id, rig.id})
if ADFieldWork.swapInProgress(field.id, assignment) then
-- en anden mejetærsker er ved at montere sit skærebord ved markens indkørsel: vent hjemme, til den
-- høster — ellers støder de sammen ved markøren (brugerønske 10/10, F14 med 2 maskiner)
assignment.phase = "queuedSwap"
log(field.id, "harvester: '%s' venter med at hente '%s', til den anden mejetærsker har monteret sit skærebord",
rig.label, header.name)
else
ADFieldWork.startHeaderFetch(adEnv, assignment)
log(field.id, "harvester: '%s' henter skærebordet '%s' (%s)", rig.label, header.name, tostring(header.parkName))
end
elseif role == "harvester" and rig.manual and not assignment.helper then
-- for bred til vejene: spilleren kører den selv til marken og monterer skærebordet
assignment.phase, assignment.manual = "awaitingPlayer", true
assignment.startX, assignment.startZ = rig.x, rig.z
ADFieldJobs.state.assignments[rig.id] = assignment
askPlayer(field, info, assignment, true)
elseif info.markerId == nil then
-- kontraktmark uden AutoDrive-markør: Courseplay startes her, og spillets hjælper kører sættet ud til marken
assignment.startX, assignment.startZ, assignment.giants = rig.x, rig.z, true
ADFieldJobs.state.assignments[rig.id] = assignment
log(field.id, "%s '%s' sendes til F%s med spillets hjælper (ingen AutoDrive-markør)", role, rig.label, tostring(field.id))
ADFieldWork.beginWork(adEnv, field, info, assignment)
else
local refill = refillPlan(adEnv, field.id, rig.vehicle, role, info.x, info.z)
if refill ~= nil and refill.empty and refill.refillId == nil then
-- tom og ingen station: paller (palleskur/løse); ellers ville den bare køre kurset uden at sprede
ADFieldJobs.state.assignments[rig.id] = assignment
if startPalletRefill(adEnv, assignment, rig.vehicle, refill.fillType, rig.label) then
note(field.id, {reason = false})
return
end
ADFieldJobs.state.assignments[rig.id] = nil
fail(field.id, string.format("'%s' er tom for %s og der er ingen påfyldning eller palle med AutoDrive-markør — fyld den op", rig.label, fillTypeName(refill.fillType)))
return
end
assignment.startX, assignment.startZ = rig.x, rig.z
-- skærebord på transporthjul allerede bag på: monteres på marken — tømmevogne og andre mejetærskere venter
-- (in-game 10/10 SG7: tømmevognen kom, før mejetærskeren havde skiftet)
if role == "harvester" and ADHeaderSwap ~= nil and ADHeaderSwap.headerPosition(rig.vehicle) == "rear" then
assignment.headerSwap = {}
end
ADFieldJobs.state.assignments[rig.id] = assignment
if refill ~= nil and refill.empty then
-- AutoDrive LOAD: påfyldningen (2. markør), fyld op, videre til F-markøren (1.) — så Courseplay
startAd(adEnv, rig.vehicle, adEnv.AutoDrive.MODE_LOAD, info.markerId, refill.refillId, refill.fillType)
assignment.drive = {mode = adEnv.AutoDrive.MODE_LOAD, first = info.markerId, second = refill.refillId, fillType = refill.fillType}
local marker = adEnv.ADGraphManager:getMapMarkerByWayPointId(refill.refillId)
log(field.id, "%s '%s' er tom — fyldes med %s ved %s og kører så til %s", role, rig.label, fillTypeName(refill.fillType),
tostring(marker ~= nil and marker.name or refill.refillId), tostring(info.markerName))
else
startAd(adEnv, rig.vehicle, adEnv.AutoDrive.MODE_DRIVETO, info.markerId, nil)
assignment.drive = {mode = adEnv.AutoDrive.MODE_DRIVETO, first = info.markerId}
log(field.id, "%s '%s' sendt til %s (%.1f m%s)", role, rig.label, tostring(info.markerName), rig.width or 0,
assignment.lane ~= nil and string.format(", bane %d", assignment.lane) or "")
end
end
end
note(field.id, {reason = false})
end
-- Læssevogn: AutoDrive overtager ved "fuld" (Hent og aflever F -> lager, hjælper = Courseplay).
local function prepareCollector(adEnv, field, info, assignment)
local vehicle = assignment.vehicle
local store, why = ADFieldWork.chooseStore(adEnv, field, info, vehicle, ADFieldWork.storeFillType(field, info))
if store == nil then
ADFieldWork.release(assignment)
fail(field.id, "intet lager: " .. tostring(why))
return false
end
assignment.storeId = store.id
local module = stateModule(vehicle)
module:setMode(adEnv.AutoDrive.MODE_PICKUPANDDELIVER)
module:setFirstMarkerByWayPointId(info.markerId)
module:setSecondMarkerByWayPointId(store.id)
module:setStartHelper(true)
module.usedHelper = helperCp(adEnv)
disableParkAtJobFinished(vehicle)
module:raiseDirtyFlag()
log(field.id, "læssevogn '%s' aflæsser i %s", ADRuns.vehicleLabel(vehicle), tostring(store.name))
return true
end
-- Nærmeste påfyldning af varen: en læssestation gården har adgang til, med varen på lager, en AutoDrive-
-- markør ved triggeren og vej fra traktoren. (AutoDrives eget "automatiske påfyldningsmål" er slået fra i
-- AutoDrive — AutoDrive.automaticPickupTarget = false — så vi finder stedet selv, som silovalget.)
-- Sælger købestationen varen? (placeable.spec_buyingStation.buyingStation; FS25-felter varierer, så flere
-- opslag: udbudte varer, triggernes varer, AI-varer.)
function ADFieldWork.buyingSupports(station, fillType)
if station == nil or fillType == nil then return false end
local ok, result = pcall(function()
for _, key in ipairs({"providedFillTypes", "supportedFillTypes", "fillTypes"}) do
local set = station[key]
if type(set) == "table" and set[fillType] then return true end
end
for _, trigger in pairs(station.loadTriggers or {}) do
if type(trigger.fillTypes) == "table" and trigger.fillTypes[fillType] then return true end
end
if station.getAISupportedFillTypes ~= nil then
local set = station:getAISupportedFillTypes()
if type(set) == "table" and set[fillType] then return true end
end
return false
end)
return ok and result == true
end
-- Parkering, kobling og ventepladser er aldrig en læssemarkør.
local function isServiceMarker(marker)
local name = string.lower(tostring(marker.name or ""))
local group = string.lower(tostring(marker.group or ""))
return string.find(name, "^p ") ~= nil or string.find(name, "^connect ") ~= nil
or string.find(name, "%f[%a]wait%f[%A]") ~= nil or string.find(group, "%f[%a]wait%f[%A]") ~= nil
end
ADFieldWork.THROUGH_TRIGGER_M = 3 -- AD-vejen før markøren kører gennem triggeren, hvis et punkt er så tæt på
-- Kører AD-vejen ind til markøren gennem en af triggerne? marker.approach = {{x, z}} (punkter bagud fra markøren).
function ADFieldWork.drivesThrough(marker, points)
local limit = ADFieldWork.THROUGH_TRIGGER_M ^ 2
for _, p in ipairs(marker.approach or {}) do
for _, point in ipairs(points) do
if (p.x - point.x) ^ 2 + (p.z - point.z) ^ 2 <= limit then return true end
end
end
return false
end
-- markers = {{id, name, group, x, z, approach?}}, points = triggerpositioner {{x, z}} -> id på læssemarkøren inden
-- for maxDistance m af en af triggerne, ellers nil. En markør hvis AD-vej kører GENNEM triggeren foretrækkes for den
-- blot nærmeste (in-game 6/10: sprøjten til den blå væsketank holdt ved "Palleskur 2 load" på nabosporet, 0,5 m
-- tættere end "Buy All" lige efter tankene).
function ADFieldWork.nearestStationMarker(markers, points, maxDistance)
points = points or {}
local best, bestDistance, bestThrough = nil, maxDistance * maxDistance, false
for _, marker in ipairs(markers or {}) do
if not isServiceMarker(marker) then
local nearest = math.huge
for _, point in ipairs(points) do
nearest = math.min(nearest, (marker.x - point.x) ^ 2 + (marker.z - point.z) ^ 2)
end
if nearest <= maxDistance * maxDistance then
local through = ADFieldWork.drivesThrough(marker, points)
if (through and not bestThrough) or (through == bestThrough and nearest < bestDistance) then
best, bestDistance, bestThrough = marker.id, nearest, through
end
end
end
end
return best, bestThrough
end
ADFieldWork.STATION_MARKER_M = 30
ADFieldWork.STATION_MATCH_M = 80 -- markører så tæt på bygningen tjekkes med markør->station-opslaget
ADFieldWork.WIDTH_GUARD_MS = 10000 -- så tit tjekkes at variabel bredde ikke er sprunget tilbage
-- Stationens læssetriggere i verden (buying-/loading-station) -> {{x, z}}.
local function loadTriggerPoints(station)
local points = {}
for _, trigger in pairs(station.loadTriggers or {}) do
local node = trigger.triggerNode or trigger.aiNode
if node ~= nil then
local ok, x, _, z = pcall(getWorldTranslation, node)
if ok and x ~= nil then table.insert(points, {x = x, z = z}) end
end
end
return points
end
ADFieldWork.APPROACH_M = 40 -- så langt bagud ad AD-vejen ledes der efter triggeren
-- Punkterne AD kører igennem ind til markøren (bagud ad incoming, op til APPROACH_M).
function ADFieldWork.approachPoints(adEnv, startId)
local points, seen, queue = {}, {[startId] = true}, {{id = startId, d = 0}}
local head = 1
while head <= #queue and #points < 600 do
local item = queue[head]
head = head + 1
local wayPoint = adEnv.ADGraphManager:getWayPointById(item.id)
if wayPoint ~= nil then
table.insert(points, {x = wayPoint.x, z = wayPoint.z})
for _, prevId in ipairs(wayPoint.incoming or {}) do
local prev = not seen[prevId] and adEnv.ADGraphManager:getWayPointById(prevId) or nil
if prev ~= nil then
seen[prevId] = true
local step = math.sqrt((prev.x - wayPoint.x) ^ 2 + (prev.z - wayPoint.z) ^ 2)
-- et punkt pr. meter mellem knuderne (AD-knuder ligger flere meter fra hinanden)
for t = 1, math.floor(step) do
local f = t / step
table.insert(points, {x = wayPoint.x + (prev.x - wayPoint.x) * f, z = wayPoint.z + (prev.z - wayPoint.z) * f})
end
if item.d + step <= ADFieldWork.APPROACH_M then table.insert(queue, {id = prevId, d = item.d + step}) end
end
end
end
end
return points
end
-- points: kun markører inden for nearM af et af punkterne får deres AD-vej med (approach)
local function markerList(adEnv, points, nearM)
local list = {}
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
local wayPoint = adEnv.ADGraphManager:getWayPointById(marker.id)
if wayPoint ~= nil then
local entry = {id = marker.id, name = marker.name, group = marker.group, x = wayPoint.x, z = wayPoint.z}
for _, point in ipairs(points or {}) do
if (wayPoint.x - point.x) ^ 2 + (wayPoint.z - point.z) ^ 2 <= (nearM or 0) ^ 2 then
entry.approach = ADFieldWork.approachPoints(adEnv, marker.id)
break
end
end
table.insert(list, entry)
end
end
return list
end
-- Stationens markør: den der kører GENNEM en af triggerne (points), ellers den nærmeste inden for maxDistance.
-- accept(marker) filtrerer (fx væk med andre bygningers markører). -> id, through (eller nil). Til salgsstederne:
-- markør->station giver hver markør kun én station ("Buy All" gennem væske- og bulkmarkedet blev kun bulkmarkedets,
-- in-game 7/10), og uden gennemkørsel vandt nabosporets palleskur- eller koblingsmarkør.
function ADFieldWork.stationMarkerAt(adEnv, points, maxDistance, accept)
local list = {}
for _, marker in ipairs(markerList(adEnv, points, maxDistance)) do
if accept == nil or accept(marker) then table.insert(list, marker) end
end
return ADFieldWork.nearestStationMarker(list, points, maxDistance)
end
ADFieldWork.isServiceMarker = isServiceMarker
-- AD-markøren ved stationen: den nærmeste markør ved stationens EGNE læssetriggere, ellers nærmeste ikke-Wait markør
-- inden for 40 m af bygningen ("Liquid Buy Station" står ved tanken, ikke ved triggeren). AutoDrives
-- ADTriggerManager:getMarkerAtStation bruges IKKE: den vil have markøren togets længde + 3..13 m forbi triggeren (et
-- langt sæt fik en anden stations markør: Puma + Kinze 4900 ventede på frø ved "Market Price Liquid Fill Station"), og
-- finder den ingen, OPRETTER den en ny markør med stationens navn (2 ekstra "Buying Station Multifruit", in-game 30/9).
-- Alle læsse-/købsstationer med deres påfyldningstriggeres positioner (lager + købestationer).
local function allLoadStations()
local list = {}
local seen = {}
pcall(function()
for _, station in pairs(g_currentMission.storageSystem:getLoadingStations()) do
if not seen[station] then seen[station] = true; table.insert(list, station) end
end
end)
pcall(function()
for _, placeable in pairs(g_currentMission.placeableSystem.placeables) do
local spec = placeable.spec_buyingStation
local station = spec ~= nil and spec.buyingStation or nil
if station ~= nil and not seen[station] then seen[station] = true; table.insert(list, station) end
end
end)
return list
end
-- Hører markøren til DENNE station? Den station hvis påfyldningstrigger ligger nærmest markøren (over alle stationer).
-- Retningsløst: markør->station-opslaget (bagud fra næsen) koblede hverken "Solid Buy Silo" eller "Liquid Buy Silo" til
-- bulkstationen, så den gamle regel valgte Liquid Buy til frø (in-game 16/10, efter 1.62.250).
-- stationer + triggerpunkter genbruges kort (markerBelongsTo kaldes pr. kandidatmarkør — review: ellers S²·M)
local stationPointsCache = {at = -math.huge, list = nil}
local STATION_POINTS_TTL_MS = 2000
local function stationPoints()
local t = now()
if stationPointsCache.list == nil or t - stationPointsCache.at > STATION_POINTS_TTL_MS then
local list = {}
for _, candidate in ipairs(allLoadStations()) do table.insert(list, {station = candidate, points = loadTriggerPoints(candidate)}) end
stationPointsCache.list, stationPointsCache.at = list, t
end
return stationPointsCache.list
end
-- Stationen hvis påfyldningstrigger ligger nærmest markøren (inden for STATION_MATCH_M), eller nil.
local function markerOwner(adEnv, markerId)
local wayPoint = adEnv.ADGraphManager:getWayPointById(markerId)
if wayPoint == nil then return nil end
local best, bestDistance = nil, math.huge
for _, entry in ipairs(stationPoints()) do
for _, point in ipairs(entry.points) do
local d = (point.x - wayPoint.x) ^ 2 + (point.z - wayPoint.z) ^ 2
if d < bestDistance then best, bestDistance = entry.station, d end
end
end
if best == nil or bestDistance > ADFieldWork.STATION_MATCH_M * ADFieldWork.STATION_MATCH_M then return nil end
return best
end
local function sameStation(a, station, placeable)
return a ~= nil and (a == station or (placeable ~= nil and a.owningPlaceable == placeable))
end
local function markerBelongsTo(adEnv, farmId, markerId, station, placeable)
return sameStation(markerOwner(adEnv, markerId), station, placeable)
end
-- Hører markøren til en ANDEN station? (trin 3/4 må ikke låne nabostationens markør — in-game 16/10: gårdens lager
-- "Farma 500 + Obi 1000" fik "Liquid Buy Silo", og sprederne holdt dér uden at blive fyldt)
local function markerOfOther(adEnv, markerId, station, placeable)
local owner = markerOwner(adEnv, markerId)
return owner ~= nil and not sameStation(owner, station, placeable)
end
local function markerAtStationRaw(adEnv, vehicle, station, placeable)
local farmId = vehicle ~= nil and ADSmartPickup ~= nil and ADSmartPickup.getFarmId ~= nil and ADSmartPickup.getFarmId(vehicle) or nil
-- 1) markør ved stationens egne triggere, der hører til stationen. Uden filteret vandt en markør, hvis vej kører
-- GENNEM triggeren videre til nabostationen (in-game 16/10: frø fra "Bulk Fill Station" ved "Liquid Buy Silo")
local points = nil
local okOwn, ownId = pcall(function()
points = loadTriggerPoints(station)
local list = {}
for _, entry in ipairs(markerList(adEnv, points, ADFieldWork.STATION_MARKER_M)) do
if not isServiceMarker(entry) and markerBelongsTo(adEnv, farmId, entry.id, station, placeable) then table.insert(list, entry) end
end
return ADFieldWork.nearestStationMarker(list, points, ADFieldWork.STATION_MARKER_M)
end)
if okOwn and ownId ~= nil then return ownId, 1 end
local node = placeable ~= nil and placeable.rootNode or nil
local px, pz
if node ~= nil then
local x, _, z = getWorldTranslation(node); px, pz = x, z
end
-- 2) samme filter i større radius (STATION_MATCH_M) om triggerne, rangeret som trin 1 (gennemkørsel, afstand til
-- triggeren); uden kendte triggere: afstand til bygningen
local okMatch, matchId = pcall(function()
local around = (points ~= nil and #points > 0) and points or (px ~= nil and {{x = px, z = pz}} or nil)
if around == nil then return nil end
local list = {}
for _, entry in ipairs(markerList(adEnv, around, ADFieldWork.STATION_MATCH_M)) do
local near = false
for _, point in ipairs(around) do
if (entry.x - point.x) ^ 2 + (entry.z - point.z) ^ 2 <= ADFieldWork.STATION_MATCH_M ^ 2 then near = true break end
end
if near and not isServiceMarker(entry) and markerBelongsTo(adEnv, farmId, entry.id, station, placeable) then table.insert(list, entry) end
end
return ADFieldWork.nearestStationMarker(list, around, ADFieldWork.STATION_MATCH_M)
end)
if okMatch and matchId ~= nil then return matchId, 2 end
-- 3) som før: markør ved triggerne (også gennemkørsel), ellers nærmeste ikke-Wait markør inden for 40 m af bygningen
local okAny, anyId = pcall(function()
local pts = points or loadTriggerPoints(station)
local list = {}
for _, entry in ipairs(markerList(adEnv, pts, ADFieldWork.STATION_MARKER_M)) do
if not markerOfOther(adEnv, entry.id, station, placeable) then table.insert(list, entry) end
end
return ADFieldWork.nearestStationMarker(list, pts, ADFieldWork.STATION_MARKER_M)
end)
if okAny and anyId ~= nil then return anyId, 3 end
if px == nil then return nil end
local best, bestDistance = nil, 40 * 40
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
local isWait = ADSupplyPlanner ~= nil and ADSupplyPlanner.isWaitMarker ~= nil and ADSupplyPlanner.isWaitMarker(marker)
local wayPoint = not isWait and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
if wayPoint ~= nil then
local d = (wayPoint.x - px) ^ 2 + (wayPoint.z - pz) ^ 2
if d < bestDistance and not markerOfOther(adEnv, marker.id, station, placeable) then best, bestDistance = marker.id, d end
end
end
return best, 4
end
-- Til loggen: valgt markør pr. station (kun når valget ændrer sig) — trin 1 = ved triggeren og hører til stationen,
-- 2 = hører til stationen (80 m), 3 = gammel regel ved triggeren, 4 = nærmest bygningen.
local loggedStationMarker = {}
local function markerAtStation(adEnv, vehicle, station, placeable)
local id, step = markerAtStationRaw(adEnv, vehicle, station, placeable)
pcall(function()
local key = placeable or station
if key ~= nil and loggedStationMarker[key] ~= tostring(id) then
loggedStationMarker[key] = tostring(id)
local marker = id ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(id) or nil
local name = placeable ~= nil and placeable.getName ~= nil and placeable:getName() or "?"
Logging.info("ADSmartPickup: påfyldning: station '%s' -> markør '%s' (trin %s)", tostring(name),
tostring(marker ~= nil and marker.name or id), tostring(step))
end
end)
return id
end
-- Nærmeste påfyldning af varen med AD-markør og vej: lagre/siloer med varen, og købestationer (købes
-- efter behov — ingen lagerbeholdning, så de fandtes ikke før; in-game 26/9 "Liquid Buy Station").
-- skipRoute: rutetjekket springes over (frakoblet puljeredskab har ingen .ad, så AD's getPathTo fejler; traktoren
-- tjekkes igen i refillPlan efter påkobling).
-- exclude (valgfri): {[wayPointId] = true} der springes over (fx et lager der er løbet tørt, mens vognen ventede)
ADFieldWork.MIN_REFILL_STOCK_L = 500 -- eget lager skal have mindst så meget af varen for at være påfyldningssted
function ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, x, z, skipRoute, exclude)
local farmId = vehicle:getOwnerFarmId()
local best, bestDistance = nil, math.huge
local function consider(wayPointId)
if exclude ~= nil and wayPointId ~= nil and exclude[wayPointId] then return end
local wayPoint = wayPointId ~= nil and wayPointId > 0 and adEnv.ADGraphManager:getWayPointById(wayPointId) or nil
if wayPoint == nil then return end
local distance = (wayPoint.x - x) ^ 2 + (wayPoint.z - z) ^ 2
if distance < bestDistance and (skipRoute or ADUnloadWait.hasRouteTo(adEnv, vehicle, wayPointId)) then
best, bestDistance = wayPointId, distance
end
end
-- gårdens egne lagre først (stalde/tanke med gylle, lager med gødning): købes kun når intet eget findes
-- (in-game 26/9: 7 mio. l gylle ved BGA'en, men påfyldningen ville købe ved købestationen)
pcall(function()
for _, station in pairs(g_currentMission.storageSystem:getLoadingStations()) do
local supported = station.getAISupportedFillTypes ~= nil and station:getAISupportedFillTypes() or {}
local isShop = station.owningPlaceable ~= nil and station.owningPlaceable.spec_buyingStation ~= nil
if not isShop and g_currentMission.accessHandler:canFarmAccess(farmId, station) and supported[fillType]
and (station:getFillLevel(fillType, farmId) or 0) >= ADFieldWork.MIN_REFILL_STOCK_L then
consider(markerAtStation(adEnv, vehicle, station, station.owningPlaceable))
end
end
end)
if best ~= nil then return best end
pcall(function()
for _, placeable in pairs(g_currentMission.placeableSystem.placeables) do
local spec = placeable.spec_buyingStation
local station = spec ~= nil and spec.buyingStation or nil
if station ~= nil and ADFieldWork.buyingSupports(station, fillType) then
consider(markerAtStation(adEnv, vehicle, station, placeable))
end
end
end)
return best
end
-- Påfyldningsstedet er løbet tørt, mens vognen venter der (in-game 16/10: kalk-sprederen holdt ved "TMR Silo Farma",
-- der var tom): find næste sted uden det nuværende, og kør derhen. -> true når turen er flyttet.
function ADFieldWork.retargetEmptyRefill(adEnv, vehicle)
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if module == nil or not module:isActive() or module:getMode() ~= adEnv.AutoDrive.MODE_LOAD then return false end
local first, second = module:getFirstMarker(), module:getSecondMarker()
local fillType = module.getFillType ~= nil and module:getFillType() or nil
if first == nil or second == nil or fillType == nil then return false end
-- kun når stedet BEVISELIGT ikke kan levere (review): eget lager under minimum, eller købestation der ikke sælger
-- varen. Kø ved stationen, langsom pumpe eller fuld tank flytter den ikke.
local station = markerOwner(adEnv, second.id)
if station ~= nil then
local shop = station.owningPlaceable ~= nil and station.owningPlaceable.spec_buyingStation ~= nil
if shop then
if ADFieldWork.buyingSupports(station, fillType) then return false end
else
local farmId = vehicle:getOwnerFarmId()
local okLevel, stock = pcall(station.getFillLevel, station, fillType, farmId)
if okLevel and (stock or 0) >= ADFieldWork.MIN_REFILL_STOCK_L then return false end
end
end
local x, z = vehiclePosition(vehicle)
local right = ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, x, z, true, {[second.id] = true})
if right == nil then return false end
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_LOAD, first.id, right, fillType)
local marker = adEnv.ADGraphManager:getMapMarkerByWayPointId(right)
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
Logging.info("ADSmartPickup: påfyldning: '%s' fik intet %s ved %s — kører til %s", tostring(ADRuns.vehicleLabel(vehicle)),
tostring(name), tostring(second.name), tostring(marker ~= nil and marker.name or right))
return true
end
-- Genoptaget AD-tur i påfyldnings-tilstand (LOAD): påfyldningsstedet blev valgt før gem — måske af en ældre version
-- (in-game 16/10: kalk og gødning ved "Liquid Buy Silo", som ikke sælger dem; sprederne holdt der). Find det rigtige
-- sted for varen nu, og genstart turen dertil, hvis det er et andet.
function ADFieldWork.fixResumedRefill(adEnv, vehicle, fieldId)
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if module == nil or not module:isActive() or module:getMode() ~= adEnv.AutoDrive.MODE_LOAD then return false end
local first, second = module:getFirstMarker(), module:getSecondMarker()
local fillType = module.getFillType ~= nil and module:getFillType() or nil
if first == nil or second == nil or fillType == nil then return false end
-- allerede fyldt: turen ud til marken er i gang — rør den ikke
if ADCpBridge ~= nil and ADCpBridge.getRefillLevel ~= nil and (ADCpBridge.getRefillLevel(vehicle, fillType) or 0) > 0 then return false end
-- det gemte sted har varen (sælger den / lager med varen): spillerens eller et gyldigt valg — behold det (review)
local farmId = ADSmartPickup.getFarmId(vehicle)
local saved = ADSmartPickup.getLoadStationAtWayPointId(adEnv, second.id, farmId)
if saved ~= nil then
local shop = saved.owningPlaceable ~= nil and saved.owningPlaceable.spec_buyingStation ~= nil
and saved.owningPlaceable.spec_buyingStation.buyingStation or nil
if shop ~= nil and ADFieldWork.buyingSupports(shop, fillType) then return false end
if shop == nil and saved.getFillLevel ~= nil and (saved:getFillLevel(fillType, farmId) or 0) > 0 then return false end
end
local x, z = vehiclePosition(vehicle)
-- uden rutetjek: det kører ved indlæsning (AD finder selv vejen; undgå hak)
local right = ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, x, z, true)
if right == nil or right == second.id then return false end
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_LOAD, first.id, right, fillType)
local marker = adEnv.ADGraphManager:getMapMarkerByWayPointId(right)
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
log(fieldId, "'%s': påfyldning af %s flyttet fra %s til %s (genoptaget tur)", ADRuns.vehicleLabel(vehicle), tostring(name),
tostring(second.name), tostring(marker ~= nil and marker.name or right))
return true
end
-- Kun købestationer der sælger varen (dyrefoder som sidste udvej, 8/10). -> waypoint-id | nil
-- -> waypoint-id | nil, diagnose {stations, withMarker, withRoute} (hvorfor intet købes — til loggen)
function ADFieldWork.findBuyMarker(adEnv, vehicle, fillType, x, z, skipRoute)
local best, bestDistance = nil, math.huge
local info = {stations = 0, withMarker = 0, withRoute = 0}
local ok, err = pcall(function()
for _, placeable in pairs(g_currentMission.placeableSystem.placeables) do
local spec = placeable.spec_buyingStation
local station = spec ~= nil and spec.buyingStation or nil
if station ~= nil and ADFieldWork.buyingSupports(station, fillType) then
info.stations = info.stations + 1
local wayPointId = markerAtStation(adEnv, vehicle, station, placeable)
local wayPoint = wayPointId ~= nil and wayPointId > 0 and adEnv.ADGraphManager:getWayPointById(wayPointId) or nil
if wayPoint ~= nil then
info.withMarker = info.withMarker + 1
local distance = (wayPoint.x - x) ^ 2 + (wayPoint.z - z) ^ 2
local routed = skipRoute or ADUnloadWait.hasRouteTo(adEnv, vehicle, wayPointId)
if routed then info.withRoute = info.withRoute + 1 end
if distance < bestDistance and routed then
best, bestDistance = wayPointId, distance
end
end
end
end
end)
if not ok then info.error = tostring(err) end
return best, info
end
-- Påfyldning undervejs (såmaskine/sprøjte/spreder): AutoDrive LOAD med hjælper = Courseplay. Når CP melder
-- tom (onCpEmpty), kører AD til påfyldningen (2. markør), fylder op, kører tilbage til F-markøren (1. markør)
-- og genstarter CP. Findes ingen påfyldning, stopper sættet når det er tomt ("tom for …", se finish).
local function prepareRefill(adEnv, field, info, assignment)
local vehicle = assignment.vehicle
local fillType = ADCpBridge.getRefillFillType(vehicle, assignment.role)
if fillType == nil then return end
assignment.refillFillType = fillType
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
-- uden F-markør (kontraktmark, spillets hjælper) kan AutoDrive ikke køre tilbage til marken efter påfyldning
local refillId = info.markerId ~= nil and ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, info.x, info.z) or nil
if refillId == nil then
log(field.id, "ingen påfyldning af %s med AutoDrive-markør fundet — '%s' stopper når den er tom", tostring(name), ADRuns.vehicleLabel(vehicle))
return
end
local module = stateModule(vehicle)
local ok = pcall(function()
module:setMode(adEnv.AutoDrive.MODE_LOAD)
module:setFirstMarkerByWayPointId(info.markerId)
module:setSecondMarkerByWayPointId(refillId)
module:setFillType(fillType)
module:setStartHelper(true)
module.usedHelper = helperCp(adEnv)
disableParkAtJobFinished(vehicle)
module:raiseDirtyFlag()
end)
if ok then
assignment.adHandlesEnd = true
local marker = adEnv.ADGraphManager:getMapMarkerByWayPointId(refillId)
log(field.id, "'%s' fyldes op med %s ved %s af AutoDrive når den er tom", ADRuns.vehicleLabel(vehicle), tostring(name), tostring(marker ~= nil and marker.name or refillId))
end
end
-- Aflæsningsvogn under høst: Courseplays combine-unloader med stationen fra silovalget.
local function beginUnloader(adEnv, field, info, assignment)
local vehicle = assignment.vehicle
local fillType = assignment.fillType or info.harvestFillType
local store, why = ADFieldWork.chooseStore(adEnv, field, info, vehicle, fillType)
-- høstkontrakt uden AutoDrive-vej (ingen F-markør eller ingen markør ved salgsstedet): spillets hjælper kører
-- læssene til kontraktens salgssted (Courseplay "Giants unload", brugerønske 10/10)
local giantsStation = nil
if field.contract and field.contractStation ~= nil and (store == nil or info.markerId == nil) then
giantsStation, store = field.contractStation, nil
end
if store == nil and giantsStation == nil then
ADFieldWork.release(assignment)
ADHitch.returnHome(adEnv, vehicle)
fail(field.id, "intet lager til høsten: " .. tostring(why))
return
end
assignment.storeId = store ~= nil and store.id or nil
local station = giantsStation or ADSmartPickup.getUnloadStationAtWayPointId(adEnv, store.id, vehicle:getOwnerFarmId())
local storeName = store ~= nil and tostring(store.name)
or tostring(giantsStation.getName ~= nil and giantsStation:getName() or "kontraktens salgssted")
-- AutoDrive kører de fulde læs til siloen ad vejnettet (Hent og aflever, hjælper = Courseplay), ikke CP selv
local adReady = store ~= nil and pcall(function()
local module = stateModule(vehicle)
module:setMode(adEnv.AutoDrive.MODE_PICKUPANDDELIVER)
module:setFirstMarkerByWayPointId(info.markerId)
module:setSecondMarkerByWayPointId(store.id)
if fillType ~= nil then
module:setFillType(fillType)
module.selectedFillTypes = {fillType}
end
module:setStartHelper(true)
module.usedHelper = helperCp(adEnv)
disableParkAtJobFinished(vehicle)
module:raiseDirtyFlag()
end)
if adReady then assignment.adHandlesEnd = true end
local markerPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
-- punktet nærmest traktoren: CP lægger kursets start dér (ikke i den anden ende af marken)
local vx, vz = vehiclePosition(assignment.vehicle)
local point = ADFieldJobs.nearestPoint(info.points, vx, vz) or {x = info.x, z = info.z}
assignment.phase = "starting"
assignment.since = now()
-- ventepladsen inde på marken, ikke på F-markøren (ADFieldJobs.waitSpot)
local waitX, waitZ = markerPoint ~= nil and markerPoint.x or point.x, markerPoint ~= nil and markerPoint.z or point.z
local wait = ADFieldJobs.waitSpot(info.verts, waitX, waitZ, info.x, info.z, ADFieldWork.UNLOADER_WAIT_INSET_M, ADFieldWork.UNLOADER_WAIT_SIDE_M)
if wait ~= nil then waitX, waitZ = wait.x, wait.z end
for _, other in pairs(ADFieldJobs.state.assignments) do
if other.fieldId == field.id then ensureHarvesterStops(other) end
end
local handle, err = ADCpBridge.startUnloader(vehicle, point.x, point.z, waitX, waitZ, station, function(ok, reason)
if ok then
assignment.phase = "working"
assignment.since = now()
log(field.id, "aflæsningsvogn '%s' følger høsteren -> %s (%s)", ADRuns.vehicleLabel(vehicle), storeName,
adReady and "AutoDrive kører læssene ad vejnettet" or "spillets hjælper kører læssene (Courseplay/Giants)")
else
ADFieldWork.release(assignment)
ADHitch.returnHome(adEnv, vehicle)
fail(field.id, "aflæsningsvogn: " .. tostring(reason))
end
end, not adReady)
if handle == nil then
ADFieldWork.release(assignment)
ADHitch.returnHome(adEnv, vehicle)
fail(field.id, "aflæsningsvogn: " .. tostring(err))
return
end
assignment.handle = handle
end
-- Ballesamler: Courseplays ballefinder; fuld vogn tømmes af AutoDrive i nærmeste ballelager (palleskur der
-- tager halmballer), som læssevognen. Uden lager stopper den når den er fuld.
-- Plads der skal være i fabrikken til et ballelæs (et bomuldsmodul er flere tusinde liter; 1 l sendte vognen til en
-- fuld fabrik — review 16/10)
ADFieldWork.BALE_MIN_FREE_L = 20000
-- Tager stationen baller af varen? Spillets egen regel (UnloadingStation: "does not have a BaleUnloadTrigger"): en
-- BaleUnloadTrigger for varen, eller en almindelig UnloadTrigger uden exactFillRootNode. In-game 16/10: bomulds-
-- modulerne blev sendt til TMR Silo Farma (silo der tager COTTON løst, men ingen ballestation).
function ADFieldWork.stationTakesBales(station, fillType)
if station == nil or fillType == nil then return false end
for _, trigger in pairs(station.unloadTriggers or {}) do
if trigger.fillTypes ~= nil and trigger.fillTypes[fillType] ~= nil then
local class = ClassUtil ~= nil and ClassUtil.getClassObjectByObject(trigger) or nil
if BaleUnloadTrigger ~= nil and class == BaleUnloadTrigger then return true end
if UnloadTrigger ~= nil and class == UnloadTrigger and trigger.exactFillRootNode == nil then return true end
end
end
return false
end
-- Som ADLoadSwap.findDumpMarker (silo eller egen fabrik der bruger varen), men kun stationer med ballestation til
-- varen: stationer uden springes over, og der søges igen (højst MAX_BALE_TRIES gange).
ADFieldWork.MAX_BALE_TRIES = 20
function ADFieldWork.findBaleDumpMarker(adEnv, vehicle, fillType, rest, homeMarkerId, isReachable, farmId)
local excluded = {}
for _ = 1, ADFieldWork.MAX_BALE_TRIES do
local marker = ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, rest, homeMarkerId, isReachable, excluded, nil, true)
if marker == nil then return nil end
-- samme gård som findDumpMarker selv slår op med (review: getUnloadStationAtWayPointId caches pr. gård)
local station = ADSmartPickup.getUnloadStationAtWayPointId(adEnv, marker.id, ADSmartPickup.getFarmId(vehicle))
if station == nil then return nil end
if ADFieldWork.stationTakesBales(station, fillType) then return marker end
-- findDumpMarker udelukker på owningPlaceable; uden en kan stationen ikke springes over
if station.owningPlaceable == nil then return nil end
excluded[station.owningPlaceable] = true
end
return nil
end
-- Mål for ballesamlerens læs -> {wayPointId, name} | nil. Halm: balle-/palleskur (som før). Bomuldsmoduler
-- (brugerønske 16/10): egen fabrik der bruger dem (spinderiet), ellers skur, ellers salgssted der køber dem.
function ADFieldWork.chooseBaleStore(adEnv, field, info, vehicle, fillType, isReachable, farmId)
if not ADFieldModel.isBaleHarvest(field.lastFruit) then
return ADSources.findPalletStore(adEnv, vehicle, fillType, nil, isReachable, farmId)
end
local takesBales = function(station) return ADFieldWork.stationTakesBales(station, fillType) end
local okFactory, factory = pcall(ADFieldWork.findBaleDumpMarker, adEnv, vehicle, fillType, ADFieldWork.BALE_MIN_FREE_L,
info.markerId, isReachable, farmId)
if not okFactory then log(field.id, "ballemål: fabriksopslag fejlede: %s", tostring(factory)) end
if okFactory and factory ~= nil then return {wayPointId = factory.id, name = factory.name} end
local shed = ADSources.findPalletStore(adEnv, vehicle, fillType, nil, isReachable, farmId)
if shed ~= nil then return shed end
-- en fabrik der bruger varen, men er fuld lige nu: vent, sælg ikke (som chooseStore, review 16/10)
local okAny, anyFactory = pcall(ADFieldWork.findBaleDumpMarker, adEnv, vehicle, fillType, 0, info.markerId, isReachable, farmId)
if okAny and anyFactory ~= nil then
log(field.id, "ballemål: %s har ikke plads lige nu — modulerne venter", tostring(anyFactory.name))
return nil
end
local okSale, sale = pcall(ADFieldWork.findSaleMarker, adEnv, vehicle, fillType, info.markerId, takesBales)
if not okSale then log(field.id, "ballemål: salgsopslag fejlede: %s", tostring(sale)) end
if okSale and sale ~= nil then return {wayPointId = sale.id, name = sale.name} end
return nil
end
local function beginBaleCollector(adEnv, field, info, assignment)
local vehicle = assignment.vehicle
local farmId = vehicle:getOwnerFarmId()
-- halmballer, eller bomuldsmoduler efter bomuldshøst (ADFieldWork.storeFillType)
local baleFillType = ADFieldWork.storeFillType(field, info)
local isReachable = function(markerId) return ADUnloadWait.hasRouteTo(adEnv, vehicle, markerId) end
local store = ADFieldWork.chooseBaleStore(adEnv, field, info, vehicle, baleFillType, isReachable, farmId)
if store ~= nil then
pcall(function()
local module = stateModule(vehicle)
module:setMode(adEnv.AutoDrive.MODE_PICKUPANDDELIVER)
module:setFirstMarkerByWayPointId(info.markerId)
module:setSecondMarkerByWayPointId(store.wayPointId)
module:setStartHelper(true)
module.usedHelper = helperCp(adEnv)
disableParkAtJobFinished(vehicle)
module:raiseDirtyFlag()
end)
assignment.adHandlesEnd = true
-- AD's parkering ved jobslut er fra: moden kører selv et rest-læs til lageret (review 16/10)
assignment.storeId = store.wayPointId
log(field.id, "ballesamler '%s' kører fulde læs til %s", ADRuns.vehicleLabel(vehicle), tostring(store.name))
else
log(field.id, "intet ballelager med plads og vej fundet — ballesamleren stopper når den er fuld")
end
-- punktet nærmest traktoren: CP lægger kursets start dér (ikke i den anden ende af marken)
local vx, vz = vehiclePosition(assignment.vehicle)
local point = ADFieldJobs.nearestPoint(info.points, vx, vz) or {x = info.x, z = info.z}
assignment.phase = "starting"
assignment.since = now()
local handle, err = ADCpBridge.startBaleFinder(vehicle, point.x, point.z, function(ok, reason)
if ok then
assignment.phase = "working"
assignment.since = now()
log(field.id, "Courseplay startet (ballesamler)")
else
ADFieldWork.release(assignment)
fail(field.id, "ballesamler: " .. tostring(reason))
end
end)
if handle == nil then
ADFieldWork.release(assignment)
fail(field.id, "ballesamler: " .. tostring(err))
return
end
assignment.handle = handle
end
-- Multi-tool: følgere venter på lederens kursus for trinnet og kopierer det med deres bane.
local function courseOptions(adEnv, field, assignment)
local source = ADFieldModel.courseSource(field, assignment.role)
if source ~= nil then
local course = sourceCourse(adEnv, field, source)
if course == nil then
log(field.id, "intet %s-kursus kendt — Courseplay laver et nyt kursus til %s", source, assignment.role)
end
return {course = course, lane = assignment.lane}, source
end
if (assignment.groupSize or 1) > 1 then
if assignment.leader then
return {multiTools = assignment.groupSize, lane = assignment.lane}, nil
end
local shared = coursesOf(field.id)[field.stage]
if shared == nil then return nil, nil end
return {course = shared, lane = assignment.lane}, "multi"
end
return {}, nil
end
ADFieldWork.UNFOLD_WAIT_MS = 20000
local function beginWork(adEnv, field, info, assignment)
local vehicle = assignment.vehicle
-- aldrig Courseplay med tom tank (den kører kurset uden at sprede/så)
if ADFieldWork.REFILL_ROLES[assignment.role] then
local fillType = ADCpBridge.getRefillFillType(vehicle, assignment.role)
if fillType ~= nil and ADCpBridge.getRefillLevel(vehicle, fillType) <= 0 then
ADFieldWork.release(assignment)
fail(field.id, string.format("'%s' er stadig tom for %s ved marken — fyld den op (på vognen: %s)", ADRuns.vehicleLabel(vehicle), fillTypeName(fillType), ADCpBridge.describeFill(vehicle)))
return
end
end
if assignment.role == "unloader" then return beginUnloader(adEnv, field, info, assignment) end
if assignment.role == "baleCollector" then return beginBaleCollector(adEnv, field, info, assignment) end
-- variabel bredde: fold ud og vent, før bredden måles og kurset lægges (in-game 9/10: BiG M 450 målt sammenfoldet)
if not assignment.unfoldedForWidth and ADCpBridge.unfoldVariableWidth ~= nil then
local started, blocked = ADCpBridge.unfoldVariableWidth(vehicle)
if started then
assignment.phase, assignment.since = "unfolding", now()
log(field.id, "'%s' foldes ud før bredden måles", ADRuns.vehicleLabel(vehicle))
return
end
if blocked ~= nil and not assignment.unfoldBlockedLogged then
assignment.unfoldBlockedLogged = true
log(field.id, "'%s' foldes ikke ud før bredden måles: '%s' kan ikke foldes sammen igen (fyldt tank)", ADRuns.vehicleLabel(vehicle), blocked)
end
end
assignment.unfoldedForWidth = nil
-- høsteren: halmskår efter planen (hakkes = fra; samles op/presses = skår)
if assignment.role == "harvester" then
local keepStraw = field.plan.straw == "collect" or field.plan.straw == "bale"
ADCpBridge.setStrawSwath(vehicle, keepStraw)
-- høsteren sendes IKKE selv til lager med resten (in-game 27/9: den er for stor til at komme til lageret).
-- Courseplay venter selv ved kursets ende til tømmevognene har tømt tanken (WAITING_FOR_UNLOAD_AFTER_
-- FIELDWORK_ENDED), og tømmevognene bliver på marken, så længe høsterens CP-job kører.
end
-- vinmark: kurset i gangen (ikke på vinen), ellers kører maskinen ind i stolperne
local vineOffset = ADCpBridge.vineOffsetFor(info.fruitName, assignment.role)
if vineOffset ~= nil and ADCpBridge.setVineOffset(vehicle, vineOffset) then
local skip = ADCpBridge.vineSkipFor(info.fruitName, assignment.role) or 0
ADCpBridge.setVineSkip(vehicle, skip)
log(field.id, "vinmark: Courseplay-kurset lægges %s, springer %d række(r) over", vineOffset == 0 and "på vinen (høster)" or "til venstre for vinen (i gangen)", skip)
end
local opts, source = courseOptions(adEnv, field, assignment)
if opts == nil then
-- følger uden lederens kursus endnu
if assignment.phase ~= "waitingCourse" then
assignment.phase = "waitingCourse"
assignment.since = now()
end
return
end
if assignment.role == "collector" then
if not prepareCollector(adEnv, field, info, assignment) then return end
assignment.adHandlesEnd = true
elseif assignment.role == "seeder" or assignment.role == "fertilizer" or assignment.role == "limer" or assignment.role == "weeder" then
prepareRefill(adEnv, field, info, assignment)
end
if assignment.role == "seeder" then
local okSeed, seedError = ADCpBridge.setSeedFruit(vehicle, ADFieldWork.sowFruitIndex(field))
if not okSeed then
ADFieldWork.release(assignment)
fail(field.id, "såmaskine: " .. tostring(seedError))
return
end
end
-- slåmaskine: ingen sideforskydning (en gammel 2,1 m fra et tidligere rive-kursus sad fast på BiG M 450, 9/10)
if assignment.role == "mower" then
local own = ADCpBridge.getToolOffset(vehicle)
if type(own) == "number" and math.abs(own) > 0.05 and ADCpBridge.setToolOffset(vehicle, 0) then
log(field.id, "'%s' sideforskydning %.1f m -> 0 (slåmaskine)", ADRuns.vehicleLabel(vehicle), own)
end
end
-- kun læssevognen følger skårene; en slåmaskine på et genbrugt rive-kursus må ikke forskydes (in-game 9/10:
-- BiG M 450 på F6 kørte med 2,1 m forskydning)
if assignment.role == "collector" and source == "rake" and field.windrowOffset ~= nil and math.abs(field.windrowOffset) > 0.05 then
local own = ADCpBridge.getToolOffset(vehicle)
local target = ADFieldModel.collectorOffset(own, field.windrowOffset)
if ADCpBridge.setToolOffset(vehicle, target) then
assignment.restoreToolOffset = own
log(field.id, "skår ligger %.1f m %s for rivens linje -> læssevognens forskydning %.1f m (var %.1f m)",
math.abs(field.windrowOffset), field.windrowOffset > 0 and "til venstre" or "til højre", target, own)
end
end
-- punktet nærmest traktoren: CP lægger kursets start dér (ikke i den anden ende af marken)
local vx, vz = vehiclePosition(assignment.vehicle)
local cropStage = field.stage == "harvesting" or field.stage == "mowing"
local point = ADFieldJobs.coursePoint(info.points, vx, vz, cropStage and info.fruitIndex or nil) or {x = info.x, z = info.z}
-- kontrakt der køres igen: markpunktet længst væk (spillets markkant fandt kun det stykke, maskinen står på)
if field.contract and (field.contractPasses or 0) > 0 then
point = ADFieldJobs.farthestPoint(info.points, vx, vz) or point
end
-- genbrug af Courseplay-kurser: maskinens eget / en andens matchende kursus frem for ny beregning
local cacheContext
opts, cacheContext = ADCourseCache.prepare(adEnv, field, info, assignment, opts)
-- påbegyndt mark: fortsæt/start nærmest i stedet for forfra (CP's standard)
opts = opts or {}
local remembered = vehicle.getCpLastRememberedWaypointIx ~= nil and vehicle:getCpLastRememberedWaypointIx() ~= nil
opts.startAt = ADFieldJobs.startAtFor({reuse = opts.reuse == true, remembered = remembered, stage = field.stage,
standingRatio = info.standingRatio})
if opts.startAt ~= "first" then log(field.id, "'%s' starter kurset ved %s punkt (marken er påbegyndt)", ADRuns.vehicleLabel(vehicle), opts.startAt == "last" and "sidste" or "nærmeste") end
-- kursets start inde på marken, ikke ved maskinen ude ved vejen
opts.startX, opts.startZ = ADFieldJobs.startInsideField(info.verts, vx, vz, point.x, point.z, 15)
assignment.phase = "starting"
assignment.since = now()
-- Courseplay lægger kursets start ved markpunktet (ikke ved maskinen): brug punktet på marken lige ved maskinen, så
-- den begynder, hvor den holder (in-game 10/10: markpunktet lå 350 m inde på F14 -> "udflugt", også med 15 m)
local fieldX, fieldZ = opts.startX or point.x, opts.startZ or point.z
if not (#(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(fieldX, fieldZ, info.verts)) then fieldX, fieldZ = point.x, point.z end
local handle, err = ADCpBridge.start(vehicle, fieldX, fieldZ, function(ok, reason)
if ok then
assignment.phase = "working"
assignment.since = now()
ADCourseCache.afterStart(vehicle, assignment.vehicleId, cacheContext)
if assignment.role == "mower" then
-- mål bredden igen nu: lige efter koblingen kan Courseplay endnu ikke have talt bagslåmaskinen med
-- (in-game 8/10: KDF 341 + KDD 941 målt 3,4 m 0,2 s efter koblingen, 9,4 m et sekund efter)
local okNow, widthNow = pcall(ADCpBridge.getWorkWidth, vehicle)
if okNow and type(widthNow) == "number" and widthNow > 0 then assignment.width = widthNow end
note(field.id, {mowWidth = assignment.width, mowVehicleId = assignment.vehicleId})
rememberCourse(field, "mower", vehicle)
elseif assignment.role == "rake" then
note(field.id, {rakeVehicleId = assignment.vehicleId})
rememberCourse(field, "rake", vehicle)
elseif assignment.role == "harvester" then
note(field.id, {harvestVehicleId = assignment.vehicleId})
rememberCourse(field, "harvester", vehicle)
ensureHarvesterStops(assignment)
end
if assignment.leader and (assignment.groupSize or 1) > 1 then
rememberCourse(field, field.stage, vehicle)
end
log(field.id, "Courseplay startet (%s%s%s)", assignment.role,
reason == "copied" and source ~= nil and (", " .. tostring(source) .. "-kursus kopieret") or "",
assignment.lane ~= nil and string.format(", bane %d", assignment.lane) or "")
else
ADFieldWork.release(assignment)
fail(field.id, "Courseplay fejlede: " .. tostring(reason))
-- kan Courseplay slet ikke lave et kursus (markgrænsen), hjælper et nyt forsøg om 5 min ikke: vent 30 min
-- (in-game 10/10: F2 sendte den næste mejetærsker ud efter 52 s)
if tostring(reason):find("kursus") or tostring(reason):find("markgrænsen") then
note(field.id, {retryAt = now() + ADFieldWork.COURSE_FAIL_RETRY_MS})
end
-- ikke efterladt på marken med redskabet foldet ud: hjem (skærebord på transporthjul sættes bag på først);
-- in-game 10/10: Mejetærsker 2 blev stående med skærebordet foran og valgt til en anden mark
if not (ADHitch ~= nil and ADHitch.returnHome(adEnv, vehicle)) then
local park = parkMarkerId(adEnv, vehicle)
if park ~= nil and not (ADHeaderSwap ~= nil and ADHeaderSwap.headerPosition(vehicle) == "front") then
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil)
end
end
end
end, opts)
if handle == nil then
ADFieldWork.release(assignment)
fail(field.id, "Courseplay kunne ikke startes: " .. tostring(err))
return
end
assignment.handle = handle
end
-- Tom for påfyldningsvaren — kun når redskabet stadig sidder på. AutoDrives parkering efter jobbet kan have sat
-- puljeredskabet af, og så måler traktoren alene 0 l (in-game 15/10: K105 sat af ved P Bredal, F22 meldt "tom for
-- LIME" med kalk i sprederen, og F25 hentede den straks fyldt).
-- Sat af puljeredskab: mål på redskabet selv (det kan være løbet tørt, før AutoDrive parkerede det).
function ADFieldWork.isRefillEmpty(vehicle, assignment, adEnv)
if assignment.refillFillType == nil then return false end
if ADCpBridge.getRefillFillType(vehicle, assignment.role) ~= nil then
return ADCpBridge.getRefillLevel(vehicle, assignment.refillFillType) <= 0
end
if adEnv == nil or assignment.pool == nil then return false end
for _, item in ipairs(assignment.pool.implements or {{id = assignment.pool.implementId}}) do
local okFind, implement = pcall(ADRunsController.findVehicleById, adEnv, item.id)
if okFind and implement ~= nil and ADCpBridge.getRefillFillType(implement, assignment.role) ~= nil then
return ADCpBridge.getRefillLevel(implement, assignment.refillFillType) <= 0
end
end
return false
end
-- Sættet er færdigt: rest til lager (læsse-/aflæsningsvogn), ellers parkering.
local followHeaderSwap
local function finishAssignment(adEnv, assignment)
local vehicle = assignment.vehicle
-- skærebord på transporthjul foran: bag på først, så hjem (followHeaderSwap kalder tilbage hertil)
if not assignment.headerUnmounted then
local swapState = ADFieldWork.startHeaderSwap(adEnv, assignment, "rear")
if swapState == "started" then return end
if swapState == "failed" then
-- kunne ikke startes: ikke ud på vejen med skærebordet foran
assignment.headerUnmounted, assignment.manual = true, true
ADFieldJobs.notify(string.format("F%s: '%s' kunne ikke sætte skærebordet bag på — gør det selv og kør den hjem",
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle)), true)
end
end
-- høster med plads tilbage i tanken: bliv på marken — næste mark med samme afgrøde kan bruge den (brugerønske
-- 16/10); kommer ingen inden HARVESTER_LINGER_MS, køres den hjem og spilleren får besked (tickLingering)
local linger = assignment.role == "harvester" and not assignment.manual and restLoad(adEnv, vehicle) > 0
and ADFieldWork.tankFullRatio(vehicle) < ADFieldWork.HARVESTER_FULL_RATIO
if linger then
ADFieldWork.lingering[assignment.vehicleId] = {vehicle = vehicle, since = now(), fieldId = assignment.fieldId}
log(assignment.fieldId, "'%s' har %.0f l i tanken — venter op til %d min på næste mark med samme afgrøde", ADRuns.vehicleLabel(vehicle),
restLoad(adEnv, vehicle), math.floor(ADFieldWork.HARVESTER_LINGER_MS / 60000))
elseif assignment.role == "harvester" and restLoad(adEnv, vehicle) > 0 then
-- høster der stadig har korn efter rest-turen: AutoDrive kunne ikke tømme den — sig det tydeligt
local text = string.format("'%s' har stadig korn i tanken (%.0f l) — tøm den (AutoDrive kunne ikke aflæsse den)",
ADRuns.vehicleLabel(vehicle), restLoad(adEnv, vehicle))
log(assignment.fieldId, "%s", text)
ADFieldJobs.notify(string.format("F%s: %s", tostring(assignment.fieldId), text), true)
end
-- tom såmaskine/sprøjte der ikke blev fyldt op: arbejdet er IKKE færdigt — marken må ikke gå videre
if ADFieldWork.isRefillEmpty(vehicle, assignment, adEnv) then
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(assignment.refillFillType) or "?"
ADFieldWork.release(assignment)
if ADHitch ~= nil then ADHitch.returnHome(adEnv, vehicle) end
fail(assignment.fieldId, string.format("'%s' er tom for %s — fyld op, så fortsætter marken", ADRuns.vehicleLabel(vehicle), tostring(name)))
return
end
log(assignment.fieldId, "%s '%s' færdig", assignment.role, ADRuns.vehicleLabel(vehicle))
-- manuel transport: ALDRIG ud på vejen med AutoDrive (skærebordet sidder på) — spilleren henter den
-- puljeredskab bag traktoren: sæt det af på sin parkering, traktoren hjem (afhænger kun af hvad der hænger
-- bag, så det virker også efter genindlæsning); ellers som før
local pooled = ADPool ~= nil and ADPool.shouldReturnHome(assignment) and ADHitch ~= nil
and ADHitch.returnHome(adEnv, vehicle, function(_, ok, detail)
if not ok then log(assignment.fieldId, "'%s' kom ikke hjem fra puljen: %s", ADRuns.vehicleLabel(vehicle), tostring(detail)) end
end)
-- AD's parkering ved jobslut er slået fra på markopgaver: moden parkerer altid selv (også når AD kørte læssene)
local park = not pooled and not linger and not assignment.manual and parkMarkerId(adEnv, vehicle) or nil
if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
if pooled then log(assignment.fieldId, "'%s' sætter redskabet af og kører hjem", ADRuns.vehicleLabel(vehicle)) end
-- uden P-plads blev den stående på marken uden et ord (in-game 16/10: Ropa'en efter F94)
if park == nil and not pooled and not linger and not assignment.manual and not assignment.playerTransport then
local text = string.format("'%s' har ingen AutoDrive-parkering — bliver på marken (sæt en P-plads, så kører den selv hjem)",
ADRuns.vehicleLabel(vehicle))
log(assignment.fieldId, "%s", text)
ADFieldJobs.notify(string.format("F%s: %s", tostring(assignment.fieldId), text), true)
end
if assignment.playerTransport and ADPlayerTransport ~= nil then
-- ingen parkering: spilleren henter den (pop-up/statusvindue, indtil den er kørt væk fra marken)
ADPlayerTransport.finished(assignment)
elseif assignment.manual then
ADFieldJobs.notify(string.format("F%s høstet — afmontér skærebordet og kør '%s' hjem", tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle)), true)
end
restoreToolOffset(assignment)
assignment.phase = "finished"
table.insert(ADFieldJobs.finished, assignment)
ADFieldJobs.state.assignments[assignment.vehicleId] = nil
end
local MANUAL_REASON_TEXT = {
notThere = "kør den til marken",
noHeader = "montér skærebordet",
wrongHeader = "skærebordet kan ikke høste afgrøden — montér det rigtige",
playerInside = "stig ud, så overtager Smart Pickup",
}
-- Manuel transport: overtag når høsteren står på marken med passende skærebord og spilleren er steget ud
-- (eller når spilleren trykker "Start nu"); påmind hvert 5. minut indtil da.
local function followManual(adEnv, field, info, assignment)
if field == nil or info == nil then return ADFieldWork.release(assignment) end
if assignment.playerTransport and ADPlayerTransport ~= nil then return ADPlayerTransport.follow(adEnv, field, info, assignment) end
local vehicle = assignment.vehicle
local x, z = vehiclePosition(vehicle)
local atField = #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(x, z, info.verts)
if not atField and info.markerId ~= nil then
local wayPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
atField = wayPoint ~= nil and math.sqrt((wayPoint.x - x) ^ 2 + (wayPoint.z - z) ^ 2) <= ADFieldWork.ARRIVE_DISTANCE
end
local forced = ADFieldJobs.takeoverRequested[field.id] == true
ADFieldJobs.takeoverRequested[field.id] = nil
-- skærebord på transporthjul skal sidde FORAN (bag mejetærskeren kan det ikke høste)
local fruits = ADCpBridge.getHarvestFruits(vehicle) or {}
if ADHeaderSwap ~= nil and ADHeaderSwap.headerPosition(vehicle) == "rear" then fruits = {} end
local ok, why = ADManualTransport.readiness({atField = atField, fruits = fruits,
fruit = info.fruitIndex, controlled = isControlledByPlayer(vehicle), forced = forced})
if ok then
log(field.id, "overtager '%s'%s", ADRuns.vehicleLabel(vehicle), forced and " (Start nu)" or "")
return beginWork(adEnv, field, info, assignment)
end
local reason = MANUAL_REASON_TEXT[why] or tostring(why)
note(field.id, {reason = {text = string.format("venter på dig: '%s' — %s", ADRuns.vehicleLabel(vehicle), reason)}})
if forced then
ADFieldJobs.notify(string.format("F%s: kan ikke starte '%s' endnu — %s", tostring(field.id), ADRuns.vehicleLabel(vehicle), reason), true)
elseif ADManualTransport.shouldRemind(assignment.remindedAt, now()) then
askPlayer(field, info, assignment, false)
end
end
-- Opsamleren står stille med Courseplay aktiv og fyldes ikke: tæl tiden (bevægelse eller mere last nulstiller).
local function collectorStillMs(adEnv, assignment, vehicle)
local speed = vehicle.getLastSpeed ~= nil and vehicle:getLastSpeed() or 0
local fill = restLoad(adEnv, vehicle) or 0
if speed > 0.5 or fill > (assignment.stallFill or -1) + 1 then
assignment.stallSince, assignment.stallFill = nil, fill
return 0
end
assignment.stallSince = assignment.stallSince or now()
return now() - assignment.stallSince
end
-- Høsterens tank: fyldningsgrad 0..1 (største fyldenhed der hører til combine-spec'en; 0 hvis ukendt).
ADFieldWork.HARVESTER_FULL_RATIO = 0.95
ADFieldWork.HARVESTER_FULL_WAIT_MS = 15 * 60 * 1000 -- så længe venter en fuld høster på en tømmevogn
-- Høsterens tankindhold (filltype med fyld > 0) eller nil når tom.
function ADFieldWork.tankFillType(vehicle)
local spec = vehicle.spec_combine
local index = spec ~= nil and spec.fillUnitIndex or nil
if index == nil or vehicle.getFillUnitFillLevel == nil or vehicle.getFillUnitFillType == nil then return nil end
local okLevel, level = pcall(vehicle.getFillUnitFillLevel, vehicle, index)
-- en lille rest (fx fra spillerens egen kørsel) blokerer ikke en ny afgrøde (review)
if not okLevel or type(level) ~= "number" or level < ADFieldWork.TANK_MIN_CONTENT_L then return nil end
local okType, fillType = pcall(vehicle.getFillUnitFillType, vehicle, index)
return okType and fillType or nil
end
ADFieldWork.TANK_MIN_CONTENT_L = 100 -- under dette regnes høsterens tank for tom (ved afgrøde-tjekket)
ADFieldWork.HARVESTER_LINGER_MS = 5 * 60 * 1000 -- høster med plads i tanken venter så længe på næste mark før hjem
ADFieldWork.lingering = {} -- vehicleId -> {vehicle, since, fieldId}
function ADFieldWork.tankFullRatio(vehicle)
local spec = vehicle.spec_combine
local index = spec ~= nil and spec.fillUnitIndex or nil
if index == nil or vehicle.getFillUnitFillLevelPercentage == nil then return 0 end
local ok, ratio = pcall(vehicle.getFillUnitFillLevelPercentage, vehicle, index)
return ok and type(ratio) == "number" and ratio or 0
end
-- Courseplay stoppede midt i kurset (fx "off track"): start igen fra sidste punkt (ADFieldJobs.shouldRestartCp).
-- -> true når den blev startet igen (så er opgaven ikke færdig).
local function restartUnfinishedCp(adEnv, assignment)
local vehicle = assignment.vehicle
local okIx, rememberedIx = pcall(function()
return vehicle.getCpLastRememberedWaypointIx ~= nil and vehicle:getCpLastRememberedWaypointIx() or nil
end)
local refillEmpty = ADFieldWork.isRefillEmpty(vehicle, assignment, adEnv)
local restart = ADFieldJobs.shouldRestartCp({
rememberedIx = okIx and rememberedIx or nil,
hasCourse = vehicle.hasCpCourse ~= nil and vehicle:hasCpCourse() == true,
restarts = assignment.cpRestarts, intended = assignment.cpStopIntended, controlled = isControlledByPlayer(vehicle),
helper = assignment.helper == true, refillEmpty = refillEmpty,
collector = assignment.role == "collector" or assignment.role == "baleCollector",
loaded = assignment.role ~= "harvester" and (restLoad(adEnv, vehicle) or 0) > 0,
})
if not restart then return false end
local okStart, started = pcall(ADCpResume.startAtLast, vehicle)
if not okStart or not started then return false end
assignment.cpRestarts = (assignment.cpRestarts or 0) + 1
assignment.idleSince, assignment.cpRestarting, assignment.cpRestartedAt = nil, now(), now()
log(assignment.fieldId, "'%s': Courseplay stoppede midt i kurset (waypoint %d) — startes igen fra sidste punkt (%d/%d)",
ADRuns.vehicleLabel(vehicle), rememberedIx, assignment.cpRestarts, ADFieldJobs.CP_RESTARTS)
return true
end
-- Så længe venter en arbejdende opgave, mens spilleren sidder i med CP stoppet (kører den fri), før tomgang tæller
ADFieldWork.PLAYER_SEATED_WAIT_MS = 3 * 60 * 1000
local function followWorking(adEnv, field, assignment)
local vehicle = assignment.vehicle
if assignment.role == "rake" and field.windrowOffset == nil and now() - assignment.since >= ADFieldWork.WINDROW_MEASURE_MS
and ADCpBridge.isWorking(vehicle) then
local offset = ADCpBridge.getWindrowOffset(vehicle)
note(assignment.fieldId, {windrowOffset = offset or 0})
log(assignment.fieldId, offset ~= nil and "river lægger skåret %.1f m fra sin kursuslinje (venstre +)" or "river: nedlægningsområde ikke fundet — regner med midten (%.1f m)", offset or 0)
end
if ADCpBridge.isWorking(vehicle) or isAdActive(vehicle) then
assignment.idleSince = nil
assignment.waitingUnloader = nil -- arbejder igen (fx genstartet af spilleren): ikke længere ventende
assignment.seenWorking = true
assignment.cpRestarting = nil
if assignment.cpRestartedAt ~= nil and now() - assignment.cpRestartedAt >= ADFieldJobs.CP_RESTART_RESET_MS then
assignment.cpRestarts, assignment.cpRestartedAt = 0, nil
end
if assignment.role == "collector" and ADCpBridge.isWorking(vehicle) then
local okStill, stillMs = pcall(collectorStillMs, adEnv, assignment, vehicle)
if okStill and ADFieldJobs.collectorStalled({role = assignment.role, stillMs = stillMs}) then
-- intet at samle op: stop CP; næste tik afslutter som færdig (rest til lager, marken videre)
assignment.stallSince = nil
assignment.cpStopIntended = true
pcall(ADCpBridge.stop, vehicle)
local text = string.format("'%s' stod stille i %d min uden at samle noget op — opsamlingen stoppes",
ADRuns.vehicleLabel(vehicle), math.floor(ADFieldJobs.COLLECTOR_STALL_MS / 60000))
log(assignment.fieldId, "%s", text)
ADFieldJobs.notify(string.format("F%s: %s", tostring(assignment.fieldId), text), true)
end
end
return
end
-- genoptaget efter indlæsning: CP starter asynkront — vent til den kører, før "står stille" betyder færdig
if assignment.resumed and not assignment.seenWorking then
if now() - assignment.since > ADFieldWork.START_TIMEOUT_MS then
ADFieldWork.release(assignment)
fail(assignment.fieldId, string.format("'%s': Courseplay fortsatte ikke efter genindlæsning", ADRuns.vehicleLabel(vehicle)))
end
return
end
-- genstartet (restartUnfinishedCp): giv CP tid til at komme i gang; kom den ikke, afsluttes opgaven som før
if assignment.cpRestarting ~= nil then
if now() - assignment.cpRestarting < ADFieldJobs.CP_RESTART_GRACE_MS then return end
assignment.cpRestarting = nil
assignment.cpRestarts = ADFieldJobs.CP_RESTARTS
log(assignment.fieldId, "'%s': Courseplay kom ikke i gang igen — opgaven afsluttes", ADRuns.vehicleLabel(vehicle))
end
-- spilleren sidder i og kører den fri (et kort stykke slipper ikke sættet, se ovenfor): CP er stoppet, men
-- opgaven er ikke færdig (in-game 16/10 F39: modulhøsteren kørt fri af et modul blev meldt "færdig" og sendt hjem)
-- Højst PLAYER_SEATED_WAIT_MS: bliver spilleren siddende efter et færdigt kursus, afsluttes opgaven som før (review)
if isControlledByPlayer(vehicle) then
assignment.playerSeatedSince = assignment.playerSeatedSince or now()
if now() - assignment.playerSeatedSince < ADFieldWork.PLAYER_SEATED_WAIT_MS then
if not assignment.playerSeatedLogged then
assignment.playerSeatedLogged = true
log(assignment.fieldId, "'%s': spilleren sidder i — venter (ikke færdig)", ADRuns.vehicleLabel(vehicle))
end
assignment.idleSince = nil
return
end
else
assignment.playerSeatedSince, assignment.playerSeatedLogged = nil, nil
end
assignment.idleSince = assignment.idleSince or now()
if now() - assignment.idleSince < ADFieldWork.IDLE_CONFIRM_MS then return end
-- høster med fuld tank: Courseplay stopper og venter på en tømmevogn — det er IKKE færdig (in-game 16/10: F94-
-- roeoptageren med 161.570 l blev regnet færdig hvert 13. s, startet igen, og tømmevognen blev afbrudt hver gang)
if assignment.role == "harvester" and vehicle.spec_combine ~= nil then
local full = ADFieldWork.tankFullRatio(vehicle) >= ADFieldWork.HARVESTER_FULL_RATIO
local waitedTooLong = assignment.waitingUnloader and now() - (assignment.waitingSince or now()) >= ADFieldWork.HARVESTER_FULL_WAIT_MS
if full and waitedTooLong then
-- ingen tømmevogn i tide: sig det, og afslut som før (så marken ikke er låst for evigt)
assignment.waitingUnloader = nil
ADFieldJobs.notify(string.format("F%s: '%s' har ventet %d min med fuld tank uden tømmevogn — tøm den selv",
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle), math.floor(ADFieldWork.HARVESTER_FULL_WAIT_MS / 60000)), true)
elseif full then
if not assignment.waitingUnloader then
assignment.waitingUnloader, assignment.waitingSince = true, now()
log(assignment.fieldId, "'%s' har fuld tank — venter på en tømmevogn", ADRuns.vehicleLabel(vehicle))
end
assignment.idleSince = nil
return
elseif assignment.waitingUnloader then
-- tømt: videre fra sidste punkt (uden om genstart-tælleren — det var ventetid, ikke CP der gik i stå)
assignment.waitingUnloader = nil
local okStart, started = pcall(ADCpResume.startAtLast, vehicle)
if okStart and started then
assignment.idleSince, assignment.cpRestarting, assignment.cpRestartedAt = nil, now(), now()
log(assignment.fieldId, "'%s' er tømt — høster videre fra sidste punkt", ADRuns.vehicleLabel(vehicle))
return
end
end
end
if restartUnfinishedCp(adEnv, assignment) then return end
local rest = assignment.storeId ~= nil and not assignment.deliveredRest and restLoad(adEnv, vehicle) or 0
if rest > 0 and assignment.role == "harvester" and vehicle.spec_combine ~= nil then
-- mejetærsker: ikke selv til siloen med resten — røret skal foldes ud og ramme triggeren (og et skærebord på
-- transporthjul hænger på); bliv, sig til (brugerønske 10/10). Tømmevognen eller spilleren tømmer den
assignment.deliveredRest = true
if not assignment.restNoticeGiven then
assignment.restNoticeGiven = true
ADFieldJobs.notify(string.format("F%s: '%s' har %.0f l korn tilbage — send en tømmevogn til den eller tøm den selv",
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle), rest), true)
log(assignment.fieldId, "'%s' har %.0f l rest — mejetærskere kører ikke selv til lager", ADRuns.vehicleLabel(vehicle), rest)
end
rest = 0
end
if rest > 0 then
-- CP færdig/stoppet med læs på: AD's parkering ved jobslut er fra på markopgaver, så moden sender resten til lager
assignment.deliveredRest = true
assignment.idleSince = nil
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DELIVERTO, assignment.storeId, nil)
log(assignment.fieldId, "'%s' kører rest-læs (%.0f l) til lager", ADRuns.vehicleLabel(vehicle), rest)
return
end
finishAssignment(adEnv, assignment)
end
-- Meld en maskine, der allerede kører Courseplay, ind på marken som genoptaget opgave (følges og afsluttes som ellers).
local function adoptResumed(adEnv, rig, fieldId, stage, what)
local vehicle = rig.vehicle
ADFieldJobs.state.assignments[rig.id] = {vehicleId = rig.id, vehicle = vehicle, fieldId = fieldId, role = rig.role,
stage = stage, helper = false, phase = "working", since = now(), width = rig.width,
groupSize = 1, leader = true, resumed = true, manual = rig.manual == true}
-- lager til læssevognens rest, som ved en normal start
local assignment = ADFieldJobs.state.assignments[rig.id]
local field, info = ADFieldJobs.getField(fieldId), ADFields.getInfo(fieldId)
local fillType = nil
-- kun læssevognen kører selv hjem med læsset; høsteren tømmes af tømmevognene på marken
if rig.role == "collector" then fillType = ADFieldWork.storeFillType(field, info) end
if fillType ~= nil then
local okStore, store = pcall(ADFieldWork.chooseStore, adEnv, field, info, vehicle, fillType)
if okStore and store ~= nil then assignment.storeId = store.id end
end
log(fieldId, "'%s' %s%s", tostring(rig.label), what,
assignment.storeId ~= nil and "" or (fillType ~= nil and " — intet lager til resten fundet" or ""))
end
-- Genstartet efter indlæsning uden en mark i gang med rollen: så længe venter den på, at en mark kommer i den fase
ADFieldWork.ORPHAN_CP_MS = 3 * 60 * 1000
ADFieldWork.ORPHAN_CP_START_GRACE_MS = 30000 -- CP starter asynkront: først derefter betyder "kører ikke" stoppet
ADFieldWork.orphanCp = {} -- vehicleId -> {vehicle, role, label, points, at}
-- Courseplay-maskine genstartet uden mark: kommer marken (i maskinens fase, maskinen eller kursets sidste punkt på
-- marken), meldes den ind — ellers sendte marken forgæves en anden ud og fik ingen tømmevogn (in-game 16/10: F94
-- "allBusy — 'Mejetærsker 2': Courseplay kører" hvert minut).
function ADFieldWork.tickOrphanCp(adEnv)
if next(ADFieldWork.orphanCp) == nil then return end
local rigsById = {}
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do rigsById[rig.id] = rig end
local fields, stageById = nil, {}
for vehicleId, entry in pairs(ADFieldWork.orphanCp) do
local rig = rigsById[vehicleId]
local age = now() - entry.at
local working = rig ~= nil and ADCpBridge.isWorking(rig.vehicle)
if rig == nil or ADFieldJobs.state.assignments[vehicleId] ~= nil or rig.controlled or age >= ADFieldWork.ORPHAN_CP_MS
or (not working and age >= ADFieldWork.ORPHAN_CP_START_GRACE_MS) then
ADFieldWork.orphanCp[vehicleId] = nil
elseif working then
if fields == nil then
fields = {}
for _, info in ipairs(ADFields.list()) do
local field = ADFieldJobs.getField(info.id)
if field ~= nil and ADFieldModel.isWorking(field) then
table.insert(fields, {id = info.id, stage = field.stage, verts = info.verts})
stageById[info.id] = field.stage
end
end
end
local fieldId = ADFieldJobs.resumeField(rig.x, rig.z, entry.role, fields, entry.points)
if fieldId ~= nil then
ADFieldWork.orphanCp[vehicleId] = nil
adoptResumed(adEnv, rig, fieldId, stageById[fieldId], "kører allerede Courseplay her — meldes ind på marken")
end
end
end
end
-- Efter genindlæsning: spillet stopper alle arbejdere ved gem, og Courseplay genstarter dem ikke (in-game 27/9).
-- En maskine med CP-kursus og et husket waypoint (CP nulstiller det når kurset er kørt færdigt) var midt i et job:
-- start den fra sidste waypoint med CP's eget "fortsæt"-job (med gemt liste fra ADCpResume: netop de maskiner
-- der kørte CP ved gem, fra nærmeste waypoint) (HUD'ens eget startpunkt røres ikke). Står den på en
-- mark hvis aktuelle trin er maskinens rolle, meldes den ind på marken igen, så den følges og trinnet afsluttes.
function ADFieldWork.resumeAfterLoad(adEnv)
-- gemt liste over maskiner hvor CP kørte (ADCpResume): den afgør alene hvem der startes, fra nærmeste waypoint
local toStart, cpVehicles = nil, {}
if ADCpResume ~= nil then toStart, cpVehicles = ADCpResume.takeToStart(adEnv) end
local startSet, handled = {}, {}
for _, id in ipairs(toStart or {}) do startSet[id] = true end
local fields, stageById = {}, {}
for _, info in ipairs(ADFields.list()) do
local field = ADFieldJobs.getField(info.id)
if field ~= nil and ADFieldModel.isWorking(field) then
table.insert(fields, {id = info.id, stage = field.stage, verts = info.verts})
stageById[info.id] = field.stage
end
end
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do
local vehicle = rig.vehicle
local wasWorking = vehicle.startCpAtLastWp ~= nil and vehicle.hasCpCourse ~= nil and vehicle:hasCpCourse()
and vehicle.getCpLastRememberedWaypointIx ~= nil and vehicle:getCpLastRememberedWaypointIx() ~= nil
if toStart ~= nil then wasWorking = startSet[rig.id] == true end
handled[rig.id] = true
local fieldId, distance, extra = nil, nil, {}
if wasWorking then
local okWp, wp = pcall(function()
local course = ADCpBridge.getCourse(vehicle)
return course ~= nil and course:getWaypoint(vehicle:getCpLastRememberedWaypointIx()) or nil
end)
if okWp and type(wp) == "table" and wp.x ~= nil then
table.insert(extra, {x = wp.x, z = wp.z})
distance = math.sqrt((wp.x - rig.x) ^ 2 + (wp.z - rig.z) ^ 2)
end
fieldId = ADFieldJobs.resumeField(rig.x, rig.z, rig.role, fields, extra)
end
-- puljesæt (traktor med puljeredskab) uden en mark i gang med dens rolle: kurset er fra et afsluttet job — det
-- genstartes ikke, sættet sendes hjem (in-game 10/10: 6230 TTV 5 med læssevogn fra F13 blev genstartet ved hver
-- genindlæsning og kørte det gamle kursus hen over F11, der var ved at blive sået)
local stalePool = wasWorking and toStart ~= nil and fieldId == nil and not rig.busy and not rig.controlled
and ADHitch ~= nil and ADPool ~= nil and #ADHitch.poolParkIds(adEnv, vehicle) > 0
if stalePool then
Logging.info(ADFieldJobs.LOG_PREFIX .. "'%s' genstartes ikke: puljesæt (%s) uden en mark i gang med rollen — sendes hjem",
tostring(rig.label), tostring(rig.role))
local okHome, pooled = pcall(ADHitch.returnHome, adEnv, vehicle)
if not (okHome and pooled) then
local park = ADFieldWork.parkMarkerId(adEnv, vehicle)
if park ~= nil then pcall(ADFieldWork.startAd, adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
end
elseif wasWorking and toStart == nil and not rig.busy and not rig.controlled and not ADFieldJobs.shouldResume({fieldId = fieldId, distance = distance}) then
Logging.info(ADFieldJobs.LOG_PREFIX .. "'%s' genstartes ikke: husket waypoint fra et gammelt job (%s væk, ikke på en mark i gang)",
tostring(rig.label), distance ~= nil and string.format("%.0f m", distance) or "ukendt afstand")
elseif wasWorking and not rig.busy and not rig.controlled then
local ok, started
if toStart ~= nil then ok, started = pcall(ADCpResume.startAtLast, vehicle)
else ok, started = pcall(vehicle.startCpAtLastWp, vehicle) end
if not ok then
Logging.warning(ADFieldJobs.LOG_PREFIX .. "'%s' kunne ikke genstartes: %s", tostring(rig.label), tostring(started))
elseif started then
if fieldId ~= nil then
adoptResumed(adEnv, rig, fieldId, stageById[fieldId], "fortsætter efter genindlæsning (Courseplay fra sidste waypoint)")
else
-- ingen mark i gang med rollen lige nu (fx F94 stod på "liming" og gik tilbage til høst et sekund
-- efter, in-game 16/10): husk den kort, så den meldes ind, når marken kommer (tickOrphanCp)
ADFieldWork.orphanCp[rig.id] = {vehicle = vehicle, role = rig.role, label = rig.label, points = extra, at = now()}
Logging.info(ADFieldJobs.LOG_PREFIX .. "'%s' genstartet fra sidste waypoint efter genindlæsning", tostring(rig.label))
end
end
end
end
-- CP-maskiner uden markrolle (fx balleopsamler, tømmevogn i CP-job): start dem også
for _, id in ipairs(toStart or {}) do
local vehicle = cpVehicles[id]
if not handled[id] and vehicle ~= nil then
local ok, started = pcall(ADCpResume.startNearest, vehicle)
if ok and started then
Logging.info(ADFieldJobs.LOG_PREFIX .. "'%s' genstartet fra nærmeste waypoint efter genindlæsning", tostring(ADRuns.vehicleLabel(vehicle)))
elseif not ok then
Logging.warning(ADFieldJobs.LOG_PREFIX .. "'%s' kunne ikke genstartes: %s", tostring(ADRuns.vehicleLabel(vehicle)), tostring(started))
end
end
end
end
-- Markmaskiner der stadig hedder modelnavnet ("Unrealistic Engine 3") får et navn efter rollen ("Roeoptager 2").
-- Navne spilleren/moden har givet røres aldrig; flow-traktorer navngives af deres flow (ikke i markflåden).
local BEET_FRUITS = {SUGARBEET = true, POTATO = true, CARROT = true, PARSNIP = true, BEETROOT = true}
local function harvesterSubtype(rig)
for fruit in pairs(rig.fruits or {}) do
local desc = g_fruitTypeManager ~= nil and g_fruitTypeManager:getFruitTypeByIndex(fruit) or nil
if desc ~= nil and BEET_FRUITS[desc.name] then return "beet" end
end
local chaff = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeIndexByName("CHAFF") or nil
local ok, isForage = pcall(function()
local vehicle = rig.vehicle
for index in ipairs(vehicle.getFillUnits ~= nil and vehicle:getFillUnits() or {}) do
if chaff ~= nil and vehicle:getFillUnitSupportsFillType(index, chaff) then return true end
end
return false
end)
return ok and isForage and "forage" or nil
end
function ADFieldWork.autoNameFleet(adEnv)
local names = {}
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do table.insert(names, ADRuns.vehicleLabel(vehicle)) end
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do
local vehicle = rig.vehicle
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
local model = vehicle.getName ~= nil and tostring(vehicle:getName()) or nil
-- puljetraktor med et lånt redskab: ikke opkaldt efter redskabet (in-game 28/9: Challenger blev "Kultivator 1")
local pooled = ADHitch ~= nil and ADPool ~= nil and #ADHitch.poolParkIds(adEnv, vehicle) > 0
if stateModule ~= nil and stateModule.setName ~= nil and model ~= nil and ADRuns.vehicleLabel(vehicle) == model and not rig.controlled and not pooled then
local name = ADNaming.fleetName(rig.role, rig.role == "harvester" and harvesterSubtype(rig) or nil, names)
if name ~= nil then
stateModule:setName(name)
if stateModule.raiseDirtyFlag ~= nil then stateModule:raiseDirtyFlag() end
table.insert(names, name)
Logging.info(ADFieldJobs.LOG_PREFIX .. "'%s' navngivet '%s' (markflåde, %s)", model, name, tostring(rig.role))
end
end
end
end
-- Høsten er færdig, men den høster der høstede marken har korn i tanken og står ved marken: start dens CP-job igen
-- (sidste/nærmeste punkt), så CP venter ved kursets ende til tømmevognene har tømt den. Én gang pr. mark.
function ADFieldWork.tryEmptyHarvester(adEnv, field, info)
local vehicleId = field.harvestVehicleId
if vehicleId == nil or info == nil then return false end
local rig = nil
for _, candidate in ipairs(ADFieldWork.getRigs(adEnv)) do
if candidate.id == vehicleId then rig = candidate break end
end
if rig == nil then return false end
local fill = restLoad(adEnv, rig.vehicle)
local near = #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(rig.x, rig.z, info.verts)
if not near and info.markerId ~= nil then
local wayPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
near = wayPoint ~= nil and math.sqrt((wayPoint.x - rig.x) ^ 2 + (wayPoint.z - rig.z) ^ 2) <= 100
end
if not ADFieldJobs.shouldEmptyHarvester({fill = fill, near = near, busy = rig.busy, controlled = rig.controlled,
tried = ADFieldJobs.emptyAttempts[field.id] == true}) then
return false
end
ADFieldJobs.emptyAttempts[field.id] = true
local assignment = {vehicleId = rig.id, vehicle = rig.vehicle, fieldId = field.id, role = "harvester", stage = field.stage,
helper = false, phase = "driving", since = now(), width = rig.width, groupSize = 1, leader = true,
manual = rig.manual == true, emptying = true}
ADFieldJobs.state.assignments[rig.id] = assignment
log(field.id, "høsten er færdig, men '%s' har %.0f l i tanken — tømmes på marken, før marken går videre", tostring(rig.label), fill)
beginWork(adEnv, field, info, assignment)
return true
end
ADFieldWork.taken = {}
-- Genoptag maskiner spilleren tog over, når han står af ved marken (én gang pr. tick for hver).
-- Høstere der venter på næste mark (finishAssignment): fik de en opgave, glemmes de; ellers efter HARVESTER_LINGER_MS
-- hjem på parkering og besked om at tømme tanken.
function ADFieldWork.tickLingering(adEnv)
for vehicleId, entry in pairs(ADFieldWork.lingering) do
local vehicle = entry.vehicle
if ADFieldJobs.state.assignments[vehicleId] ~= nil or vehicle == nil or vehicle.rootNode == nil then
ADFieldWork.lingering[vehicleId] = nil
elseif isControlledByPlayer(vehicle) or isAdActive(vehicle) then
ADFieldWork.lingering[vehicleId] = nil -- spilleren eller AD har taget over
elseif now() - entry.since >= ADFieldWork.HARVESTER_LINGER_MS then
ADFieldWork.lingering[vehicleId] = nil
local rest = restLoad(adEnv, vehicle)
if rest > 0 then
ADFieldJobs.notify(string.format("F%s: '%s' har stadig %.0f l i tanken og ingen mark med samme afgrøde — tøm den",
tostring(entry.fieldId), ADRuns.vehicleLabel(vehicle), rest), true)
end
local park = parkMarkerId(adEnv, vehicle)
if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
log(entry.fieldId, "'%s' fik ingen ny mark — kører hjem", ADRuns.vehicleLabel(vehicle))
end
end
end
function ADFieldWork.tickReadopt(adEnv)
if next(ADFieldWork.taken) == nil then return end
local rigsById = {}
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do rigsById[rig.id] = rig end
for vehicleId, entry in pairs(ADFieldWork.taken) do
local rig = rigsById[vehicleId]
local field = ADFieldJobs.getField(entry.fieldId)
local info = ADFields.getInfo(entry.fieldId)
if rig == nil or field == nil or info == nil or ADFieldJobs.state.assignments[vehicleId] ~= nil then
ADFieldWork.taken[vehicleId] = nil
else
local near = #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(rig.x, rig.z, info.verts)
if not near and info.markerId ~= nil then
local wayPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
near = wayPoint ~= nil and math.sqrt((wayPoint.x - rig.x) ^ 2 + (wayPoint.z - rig.z) ^ 2) <= 100
end
-- genoptaget tur ud til marken: vent mens AD kører derud; hænger AD ved markøren, stoppes den (som i "driving")
local tripActive = false
if entry.trip ~= nil and isAdActive(rig.vehicle) then
local module = stateModule(rig.vehicle)
local marker = module ~= nil and module.getFirstMarker ~= nil and module:getFirstMarker() or nil
tripActive = marker ~= nil and marker.id == entry.trip.markerId
if tripActive then
local wayPoint = adEnv.ADGraphManager:getWayPointById(entry.trip.markerId)
local distance = wayPoint ~= nil and math.sqrt((wayPoint.x - rig.x) ^ 2 + (wayPoint.z - rig.z) ^ 2) or math.huge
local speed = rig.vehicle.getLastSpeed ~= nil and rig.vehicle:getLastSpeed() or 0
local wpLeft = nil
local dpm = rig.vehicle.ad ~= nil and rig.vehicle.ad.drivePathModule or nil
if dpm ~= nil and dpm.getWayPoints ~= nil then
local okWp, wayPoints, current = pcall(dpm.getWayPoints, dpm)
if okWp and type(wayPoints) == "table" and type(current) == "number" then wpLeft = #wayPoints - current end
end
if speed > ADFieldJobs.STALL_SPEED then entry.stillSince = nil elseif entry.stillSince == nil then entry.stillSince = now() end
if ADFieldJobs.stalledAtTarget({adActive = true, speed = speed, wpLeft = wpLeft, distance = distance,
stillMs = entry.stillSince ~= nil and now() - entry.stillSince or 0}) then
log(entry.fieldId, "'%s' holdt stille ved markøren — AutoDrive stoppes, overtages", tostring(rig.label))
stopAd(rig.vehicle)
end
end
end
-- genoptaget tur afbrudt undervejs (AD stoppet langt fra marken): glem den, så marken kan få et andet sæt
if entry.trip ~= nil and not tripActive and not isAdActive(rig.vehicle) and not near then
ADFieldWork.taken[vehicleId] = nil
log(entry.fieldId, "'%s' nåede ikke frem (AutoDrive stoppet undervejs) — marken må få et andet sæt", tostring(rig.label))
else
local action = ADFieldJobs.readoptAction({controlled = rig.controlled, busy = rig.busy, near = near, tripActive = tripActive,
sameStage = field.stage == entry.stage,
hasRole = rig.role == entry.role or (rig.roles ~= nil and rig.roles[entry.role] == true),
ageMs = now() - (entry.at or now())})
if action == "forget" then
ADFieldWork.taken[vehicleId] = nil
elseif action == "readopt" then
ADFieldWork.taken[vehicleId] = nil
-- erstatningen der stadig er på vej, sendes hjem
local others = {}
for _, assignment in pairs(ADFieldJobs.state.assignments) do
if assignment.fieldId == entry.fieldId and assignment.role == entry.role then table.insert(others, assignment) end
end
local cancel = ADFieldJobs.replacementToCancel(others, entry.helper)
if cancel ~= nil then
local other = others[cancel]
ADFieldWork.release(other)
log(entry.fieldId, "'%s' sendes hjem — '%s' er tilbage og overtager", ADRuns.vehicleLabel(other.vehicle), tostring(rig.label))
if not (ADHitch ~= nil and ADHitch.returnHome(adEnv, other.vehicle)) then
local park = parkMarkerId(adEnv, other.vehicle)
if park ~= nil then startAd(adEnv, other.vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
end
end
local assignment = {vehicleId = rig.id, vehicle = rig.vehicle, fieldId = entry.fieldId, role = entry.role, stage = entry.stage,
helper = entry.helper, phase = "driving", since = now(), width = rig.width, groupSize = 1, leader = true,
manual = rig.manual == true, fillType = entry.fillType}
ADFieldJobs.state.assignments[rig.id] = assignment
log(entry.fieldId, "'%s' overtaget igen efter spilleren (%s)", tostring(rig.label), tostring(entry.role))
-- skærebord på transporthjul bag mejetærskeren: montér det foran først (in-game 10/10: Courseplay startede med
-- skærebordet bag på, da Mejetærsker 1 blev overtaget igen)
local swapState = ADFieldWork.startHeaderSwap(adEnv, assignment, "front")
if swapState == "none" then
beginWork(adEnv, field, info, assignment)
elseif swapState == "failed" then
ADFieldWork.headerMountFailed(adEnv, assignment, assignment.headerSwap ~= nil and assignment.headerSwap.text or "?")
end
end
end
end
end
end
-- Er en anden mejetærsker på marken ved at hente/montere sit skærebord på transporthjul (ikke høstet endnu)?
function ADFieldWork.swapInProgress(fieldId, except)
for _, other in ipairs(ADFieldJobs.assignmentsFor(fieldId)) do
if other ~= except and not other.helper and other.role == "harvester" and other.headerSwap ~= nil
and (other.phase == "fetching" or other.phase == "driving" or other.phase == "mountingHeader") then
return true
end
end
return false
end
-- Hent skærebordet (fasen "fetching", som puljens hentning).
function ADFieldWork.startHeaderFetch(adEnv, assignment)
assignment.phase, assignment.since = "fetching", now()
ADHitch.fetch(adEnv, assignment.vehicle, assignment.pool.connectId, function(_, ok, detail, failedIndex)
assignment.hitch = {done = true, ok = ok, detail = detail, failedIndex = failedIndex}
end)
end
-- Skærebord på transporthjul (ADHeaderSwap): "front" = montér før høst (sidder bag), "rear" = sæt bag på efter høst
-- (sidder foran). -> "started" (fasen venter på skiftet) | "none" (intet at skifte) | "failed" (kunne ikke startes).
function ADFieldWork.startHeaderSwap(adEnv, assignment, toward)
if ADHeaderSwap == nil or assignment.role ~= "harvester" or assignment.manual then return "none" end
local position = ADHeaderSwap.headerPosition(assignment.vehicle)
if (toward == "front" and position ~= "rear") or (toward == "rear" and position ~= "front") then return "none" end
local swap = {done = false}
local mount = toward == "front" and ADHeaderSwap.mountFront or ADHeaderSwap.mountRear
-- montering foran: først ADFieldWork.SWAP_INSET_M ind på marken, mod afgrøden/midten
local mountOpts = nil
if toward == "front" then
local info = ADFields.getInfo(assignment.fieldId)
if info ~= nil then
local vx, vz = vehiclePosition(assignment.vehicle)
local target = ADFieldJobs.coursePoint(info.points, vx, vz, info.fruitIndex) or {x = info.x, z = info.z}
mountOpts = {spot = ADFieldJobs.swapSpot(info.verts, vx, vz, target.x, target.z, ADFieldWork.SWAP_INSET_M)}
-- huskes: efter høst sættes skærebordet bag på samme frie sted
assignment.swapSpot = mountOpts.spot
end
elseif assignment.swapSpot ~= nil then
mountOpts = {spot = assignment.swapSpot}
end
local ok, started, why = pcall(mount, adEnv, assignment.vehicle, function(_, okSwap, text)
swap.done, swap.ok, swap.text = true, okSwap, text
end, mountOpts)
if not ok or not started then
log(assignment.fieldId, "'%s': skærebordet kunne ikke %s (%s)", ADRuns.vehicleLabel(assignment.vehicle),
toward == "front" and "monteres foran" or "sættes bag på", tostring(ok and why or started))
assignment.headerSwap = {done = true, ok = false, text = tostring(ok and why or started)}
return "failed"
end
assignment.headerSwap = swap
assignment.phase, assignment.since = toward == "front" and "mountingHeader" or "unmountingHeader", now()
-- efter høst: tømmevognene hjem nu, ikke først når marken er afsluttet — ellers holder de i vejen, mens
-- mejetærskeren kører rundt for at sætte skærebordet bag på (in-game 10/10 F2). Kun når ingen anden høster arbejder.
if toward == "rear" then
local othersWorking = false
for _, other in ipairs(ADFieldJobs.assignmentsFor(assignment.fieldId)) do
if other ~= assignment and not other.helper and other.role == "harvester" and other.phase == "working" then othersWorking = true end
end
if not othersWorking then pcall(ADFieldWork.windDownHelpers, adEnv, assignment.fieldId, assignment.stage) end
end
log(assignment.fieldId, "'%s' %s", ADRuns.vehicleLabel(assignment.vehicle), toward == "front" and "monterer skærebordet foran" or "sætter skærebordet bag på")
return "started"
end
-- Skærebordet kunne ikke monteres foran (fx ingen plads ved markens indkørsel, træer): spilleren bedes montere det og
-- stige ud — så overtager modden som ved manuel transport, og efter høst sætter den selv skærebordet bag på og kører hjem
-- (brugerønske 10/10). Fasen "awaitingPlayer" + followManual (skærebordet skal sidde FORAN).
function ADFieldWork.headerMountFailed(adEnv, assignment, text)
local vehicle = assignment.vehicle
assignment.phase, assignment.since, assignment.manualMount = "awaitingPlayer", now(), true
assignment.remindedAt = nil
log(assignment.fieldId, "'%s' kunne ikke selv montere skærebordet (%s) — venter på spilleren", ADRuns.vehicleLabel(vehicle), tostring(text))
local field, info = ADFieldJobs.getField(assignment.fieldId), ADFields.getInfo(assignment.fieldId)
if field ~= nil and info ~= nil then askPlayer(field, info, assignment, true) end
end
local headerMountFailed = ADFieldWork.headerMountFailed
followHeaderSwap = function(adEnv, field, info, assignment)
local swap = assignment.headerSwap
if swap == nil or not swap.done then return end
local vehicle = assignment.vehicle
if assignment.phase == "mountingHeader" then
if swap.ok and field ~= nil and info ~= nil then
beginWork(adEnv, field, info, assignment)
elseif swap.ok then
-- marken findes ikke længere: skærebordet bag på igen og hjem
assignment.phase = "working"
finishAssignment(adEnv, assignment)
else
headerMountFailed(adEnv, assignment, swap.text)
end
return
end
-- efter høst: bag på og hjem; lykkedes det ikke, må mejetærskeren ikke ud på vejen med skærebordet foran
assignment.headerUnmounted = true
if not swap.ok then
assignment.manual = true
ADFieldJobs.notify(string.format("F%s: '%s' kunne ikke sætte skærebordet bag på (%s) — gør det selv og kør den hjem",
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle), tostring(swap.text)), true)
end
finishAssignment(adEnv, assignment)
end
function ADFieldWork.follow(adEnv, assignment)
local vehicle = assignment.vehicle
-- spillets hjælper fandt ingen vej (kortet mangler AI-veje dertil, in-game 10/10 North Frisian F2): Courseplay står
-- stille uden for marken -> stop, og bed spilleren køre sættet derud (spillerkørsel, uden hjælper for denne opgave)
if assignment.giants and not assignment.arrived and assignment.phase == "working" and not ADCpBridge.isWorking(vehicle) then
assignment.giantsIdleSince = assignment.giantsIdleSince or now()
if now() - assignment.giantsIdleSince >= ADFieldWork.GIANTS_GIVE_UP_MS then
pcall(ADCpBridge.stop, vehicle)
assignment.phase, assignment.since = "awaitingPlayer", now()
assignment.manual, assignment.playerTransport, assignment.giants = true, true, nil
assignment.giantsFailed, assignment.remindedAt, assignment.readySince = true, nil, nil
log(assignment.fieldId, "spillets hjælper fandt ingen vej til F%s med '%s' — spilleren bedes køre den derud",
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle))
return
end
-- (ikke videre til followWorking: dens CP-genstart ville skjule, at hjælperen har opgivet)
return
else
assignment.giantsIdleSince = nil
end
-- spillets hjælper kører ud til kontraktmarken: fremme, når maskinen står inde på marken (tømmevogne venter til da)
if assignment.giants and not assignment.arrived then
local giantsInfo = ADFields.getInfo(assignment.fieldId)
local gx, gz = vehiclePosition(vehicle)
if giantsInfo ~= nil and #(giantsInfo.verts or {}) >= 3 and ADFieldJobs.insidePolygon(gx, gz, giantsInfo.verts) then
assignment.arrived = true
log(assignment.fieldId, "'%s' er fremme på marken (spillets hjælper)", ADRuns.vehicleLabel(vehicle))
end
end
-- Kun når spilleren selv KØRER (bevæger sig uden Courseplay/AutoDrive) slippes sættet — at sidde i
-- førersædet og kigge må ikke slippe det (in-game 25/9).
local steeredByAi = ADCpBridge.isWorking(vehicle) or isAdActive(vehicle) or assignment.phase == "starting"
local speed = vehicle.getLastSpeed ~= nil and vehicle:getLastSpeed() or 0
-- skal holde i PLAYER_DRIVING_MS: AutoDrive slipper et øjeblik ved rute-skift/genstart, mens maskinen ruller
-- (in-game 10/10: Mejetærsker 1 blev sluppet på vej til F14 med spilleren siddende i førerhuset)
local playerDriving = assignment.phase ~= "awaitingPlayer" and isControlledByPlayer(vehicle) and not steeredByAi and speed > ADFieldWork.PLAYER_DRIVING_KMH
if not playerDriving then
assignment.playerDrivingSince = nil
elseif assignment.playerDrivingSince == nil then
assignment.playerDrivingSince = now()
end
-- hvor spilleren tog over (AD/CP fra, han i sædet): kort kørsel på vej ud er at køre den fri, ikke at overtage
if isControlledByPlayer(vehicle) and not steeredByAi then
if assignment.playerFromX == nil then assignment.playerFromX, assignment.playerFromZ = vehiclePosition(vehicle) end
else
assignment.playerFromX, assignment.playerFromZ = nil, nil
end
local movedM = nil
if assignment.playerFromX ~= nil then
local px, pz = vehiclePosition(vehicle)
movedM = math.sqrt((px - assignment.playerFromX) ^ 2 + (pz - assignment.playerFromZ) ^ 2)
end
if playerDriving and now() - assignment.playerDrivingSince >= ADFieldWork.PLAYER_DRIVING_MS
and ADFieldJobs.playerTakesOver({phase = assignment.phase, movedM = movedM}) then
log(assignment.fieldId, "'%s' frigivet — spilleren kører det", ADRuns.vehicleLabel(vehicle))
-- husk den: står spilleren af ved marken, overtager moden igen (ADFieldWork.tickReadopt)
ADFieldWork.taken[assignment.vehicleId] = {fieldId = assignment.fieldId, role = assignment.role, stage = assignment.stage,
helper = assignment.helper, fillType = assignment.fillType, at = now()}
return ADFieldWork.release(assignment)
end
local field = ADFieldJobs.getField(assignment.fieldId)
local info = ADFields.getInfo(assignment.fieldId)
wake(vehicle)
if assignment.phase == "fetching" then
local hitch = assignment.hitch
if not hitch.done then return end
ADPool.release(assignment)
if info == nil or field == nil then
-- marken findes ikke længere (fx solgt): redskabet tilbage, traktoren hjem
ADFieldWork.release(assignment)
if hitch.ok then ADHitch.returnHome(adEnv, vehicle) end
return
end
if not hitch.ok then
-- koblingen fejlede: den skyldige i karantæne (kom traktoren ikke frem, er det traktoren), hjem, prøv igen.
-- Kombi: det trin der fejlede afgør redskabet (8/10)
local pool = assignment.pool
local blamed, failed = ADPool.blame(hitch.detail, assignment.vehicleId,
pool.implements or {{id = pool.implementId, name = pool.implementName}}, hitch.failedIndex)
ADPool.quarantine(blamed, now())
ADFieldWork.release(assignment)
note(assignment.fieldId, {retryAt = ADPool.alignedRetry(now(), ADFieldWork.NO_RIG_RETRY_MS),
reason = {text = string.format("kunne ikke koble '%s' på (%s) — prøver et andet om lidt",
tostring(failed.name), tostring(hitch.detail))}})
-- er bagslåmaskinen allerede på (fronten fejlede), sættes den af på sin P før traktoren kører hjem
local dropped = (hitch.failedIndex or 1) > 1 and ADHitch.returnHome(adEnv, vehicle)
local park = parkMarkerId(adEnv, vehicle)
if not dropped and park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
return
end
-- koblet på: variabel bredde stilles (Unrealistic), sammenfoldet til vejen, bredden med redskabet på
local okVar, errVar = pcall(ADCpBridge.setVariableWidth, vehicle)
if not okVar then Logging.warning("ADSmartPickup: bredde: %s", tostring(errVar)) end
pcall(ADHitch.foldForTransport, vehicle)
local width = ADCpBridge.getWorkWidth(vehicle, assignment.role)
-- skærebord på transporthjul bag mejetærskeren: arbejdsbredden måles først, når det sidder foran
if assignment.headerSwap ~= nil and (width or 0) < ADFieldModel.MIN_WORK_WIDTH then width = assignment.width end
local okWidth, widthReason, widthArgs = ADFieldModel.checkWidth(assignment.role, width, ADFieldModel.requiredWidth(field, assignment.role))
if not okWidth then
-- redskabet passer ikke til opgaven: karantæne, ellers hentes det igen og igen (in-game 6/10: Servo 25 til F9)
log(assignment.fieldId, "%s: '%s' med '%s' passer ikke (%s, bredde %.1f m) — redskabet sættes tilbage og prøves ikke foreløbig",
tostring(assignment.role), ADRuns.vehicleLabel(vehicle), tostring(assignment.pool.implementName), tostring(widthReason), tonumber(width) or -1)
for _, item in ipairs(assignment.pool.implements or {{id = assignment.pool.implementId}}) do
ADPool.quarantine(item.id, now())
end
ADFieldWork.release(assignment)
note(assignment.fieldId, {retryAt = now() + ADFieldModel.RETRY_MS, reason = {key = "spu_field_reason_" .. tostring(widthReason), role = assignment.role, args = widthArgs}})
ADHitch.returnHome(adEnv, vehicle)
return
end
-- som almindelig udsendelse: tom såmaskine/sprøjte fyldes op på vejen, uden påfyldning køres den hjem igen
local refill = refillPlan(adEnv, assignment.fieldId, vehicle, assignment.role, info.x, info.z)
local nextDrive = ADPool.nextDrive(refill)
if nextDrive == "empty" and startPalletRefill(adEnv, assignment, vehicle, refill.fillType, assignment.pool.implementName) then
assignment.width = width
return
end
if nextDrive == "empty" then
ADFieldWork.release(assignment)
ADHitch.returnHome(adEnv, vehicle)
fail(assignment.fieldId, string.format("'%s' er tom for %s og der er ingen påfyldning med AutoDrive-markør — fyld den op",
tostring(assignment.pool.implementName), fillTypeName(refill.fillType)))
return
end
assignment.width, assignment.phase, assignment.since = width, "driving", now()
assignment.startX, assignment.startZ = vehiclePosition(vehicle)
if nextDrive == "load" then
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_LOAD, info.markerId, refill.refillId, refill.fillType)
assignment.drive = {mode = adEnv.AutoDrive.MODE_LOAD, first = info.markerId, second = refill.refillId, fillType = refill.fillType}
else
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, info.markerId, nil)
assignment.drive = {mode = adEnv.AutoDrive.MODE_DRIVETO, first = info.markerId}
end
note(assignment.fieldId, {reason = false})
log(assignment.fieldId, "%s '%s' har '%s' på — kører til %s (%.1f m)", assignment.role, ADRuns.vehicleLabel(vehicle),
tostring(assignment.pool.implementName), tostring(info.markerName), width or 0)
elseif assignment.phase == "driving" then
local px, pz = vehiclePosition(vehicle)
local target = info ~= nil and adEnv.ADGraphManager:getWayPointById(info.markerId) or nil
local targetDistance = target ~= nil and math.sqrt((target.x - px) ^ 2 + (target.z - pz) ^ 2) or math.huge
local arrived = targetDistance <= ADFieldWork.ARRIVE_DISTANCE
local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
local firstMarker = stateModule ~= nil and stateModule.getFirstMarker ~= nil and stateModule:getFirstMarker() or nil
local otherTarget = assignment.drive ~= nil and firstMarker ~= nil and firstMarker.id ~= nil and firstMarker.id ~= assignment.drive.first
local pause = ADFieldJobs.drivePause({adActive = isAdActive(vehicle), controlled = isControlledByPlayer(vehicle),
paused = assignment.playerPaused, arrived = arrived, otherTarget = otherTarget})
if pause == "release" then
log(assignment.fieldId, "'%s' frigivet — spilleren gav AutoDrive et andet mål (%s)", ADRuns.vehicleLabel(vehicle), tostring(firstMarker.name))
ADFieldWork.taken[assignment.vehicleId] = {fieldId = assignment.fieldId, role = assignment.role, stage = assignment.stage,
helper = assignment.helper, fillType = assignment.fillType, at = now()}
return ADFieldWork.release(assignment)
elseif pause == "wait" then
-- spilleren har slået AD fra og kører den fri af en anden: vent på ham (in-game 11/10)
assignment.playerPaused, assignment.since, assignment.stillSince = true, now(), nil
return
elseif pause == "clear" then
assignment.playerPaused = nil
elseif pause == "resume" and assignment.drive == nil then
assignment.playerPaused = nil
elseif pause == "resume" then
assignment.playerPaused, assignment.since, assignment.stillSince = nil, now(), nil
assignment.startX, assignment.startZ = vehiclePosition(vehicle)
local d = assignment.drive
startAd(adEnv, vehicle, d.mode, d.first, d.second, d.fillType)
log(assignment.fieldId, "'%s': spilleren steg af — kører videre til %s", ADRuns.vehicleLabel(vehicle), tostring(info ~= nil and info.markerName or "?"))
return
end
-- AD hænger ved markmarkøren (aktiv, stille ved et af de sidste vejpunkter): stop den, så marken går i gang
if isAdActive(vehicle) then
local speed = vehicle.getLastSpeed ~= nil and vehicle:getLastSpeed() or 0
local wpLeft = nil
local dpm = vehicle.ad ~= nil and vehicle.ad.drivePathModule or nil
if dpm ~= nil and dpm.getWayPoints ~= nil then
local okWp, wayPoints, current = pcall(dpm.getWayPoints, dpm)
if okWp and type(wayPoints) == "table" and type(current) == "number" then wpLeft = #wayPoints - current end
end
if speed > ADFieldJobs.STALL_SPEED then
assignment.stillSince = nil
elseif assignment.stillSince == nil then
assignment.stillSince = now()
end
local stillMs = assignment.stillSince ~= nil and now() - assignment.stillSince or 0
-- påfyldning tæt på marken (LOAD): står den ved påfyldningsstedet, læsser den — det er ikke at hænge
local refillPoint = assignment.drive ~= nil and assignment.drive.second ~= nil and adEnv.ADGraphManager:getWayPointById(assignment.drive.second) or nil
if refillPoint ~= nil and math.sqrt((refillPoint.x - px) ^ 2 + (refillPoint.z - pz) ^ 2) <= ADFieldJobs.STALL_ARRIVE_M then
stillMs = 0
end
if ADFieldJobs.stalledAtTarget({adActive = true, speed = speed, wpLeft = wpLeft, distance = targetDistance, stillMs = stillMs}) then
log(assignment.fieldId, "'%s' holdt stille %.0f s ved %s (%.0f m, %s vejpunkt(er) tilbage) — AutoDrive stoppes, arbejdet starter",
ADRuns.vehicleLabel(vehicle), stillMs / 1000, tostring(info ~= nil and info.markerName or "?"), targetDistance, tostring(wpLeft))
assignment.stillSince = nil
stopAd(vehicle)
assignment.since = now() - 2001
end
return
end
assignment.stillSince = nil
if not isAdActive(vehicle) and now() - assignment.since > 2000 then
local x, z = vehiclePosition(vehicle)
local wayPoint = info ~= nil and adEnv.ADGraphManager:getWayPointById(info.markerId) or nil
local distance = wayPoint ~= nil and math.sqrt((wayPoint.x - x) ^ 2 + (wayPoint.z - z) ^ 2) or math.huge
if distance <= ADFieldWork.ARRIVE_DISTANCE then
local swapState = ADFieldWork.startHeaderSwap(adEnv, assignment, "front")
if swapState == "none" then
beginWork(adEnv, field, info, assignment)
elseif swapState == "failed" then
headerMountFailed(adEnv, assignment, assignment.headerSwap ~= nil and assignment.headerSwap.text or "?")
end
elseif assignment.startX ~= nil and math.sqrt((x - assignment.startX) ^ 2 + (z - assignment.startZ) ^ 2) < ADFieldWork.NO_MOVE_DISTANCE
and (assignment.driveRetries or 0) >= 1 then
-- AD startede og stoppede uden at flytte sig (to gange): ingen rute — genforsøg hjælper ikke
ADFieldWork.release(assignment)
fail(assignment.fieldId, string.format("AutoDrive fandt ingen rute fra '%s' til %s — står den uden for vejnettet?", ADRuns.vehicleLabel(vehicle), tostring(info ~= nil and info.markerName or "?")))
elseif assignment.drive ~= nil and (assignment.driveRetries or 0) < ADFieldWork.DRIVE_RETRIES then
-- AutoDrive stoppede undervejs (spilleren byggede, trafik, ...): kør videre i stedet for at opgive
assignment.driveRetries = (assignment.driveRetries or 0) + 1
assignment.since = now()
local d = assignment.drive
startAd(adEnv, vehicle, d.mode, d.first, d.second, d.fillType)
log(assignment.fieldId, "'%s' stoppede %.0f m fra %s — AutoDrive startes igen (%d/%d)", ADRuns.vehicleLabel(vehicle), distance,
tostring(info ~= nil and info.markerName or "?"), assignment.driveRetries, ADFieldWork.DRIVE_RETRIES)
else
ADFieldWork.release(assignment)
fail(assignment.fieldId, string.format("%s nåede ikke %s (%.0f m væk)", ADRuns.vehicleLabel(vehicle), tostring(info ~= nil and info.markerName or "?"), distance))
-- ikke efterladt midt på vejen/ved en mark: hjem til parkeringen (puljeredskab sættes af først)
if not (ADHitch ~= nil and ADHitch.returnHome(adEnv, vehicle)) then
local park = parkMarkerId(adEnv, vehicle)
if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
end
end
end
elseif assignment.phase == "palletRefill" then
local okTick, result, why = pcall(ADPalletRefill.tick, adEnv, assignment, ADFieldJobs.TICK_MS or 1000)
if not okTick then
result, why = "failed", tostring(result)
end
if result == "done" then
log(assignment.fieldId, "'%s' fyldt op med %.0f %s fra paller — kører til %s", ADRuns.vehicleLabel(vehicle), assignment.pallet.filled or 0,
ADPalletRefill.fillName(assignment.pallet.fillType), tostring(info ~= nil and info.markerName or "?"))
assignment.pallet = nil
assignment.phase, assignment.since = "driving", now()
assignment.startX, assignment.startZ = vehiclePosition(vehicle)
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, info.markerId, nil)
assignment.drive = {mode = adEnv.AutoDrive.MODE_DRIVETO, first = info.markerId}
elseif result == "failed" then
ADFieldWork.release(assignment)
fail(assignment.fieldId, string.format("påfyldning fra paller mislykkedes for '%s' (%s)", ADRuns.vehicleLabel(vehicle), tostring(why)))
if not (ADHitch ~= nil and ADHitch.returnHome(adEnv, vehicle)) then
local park = parkMarkerId(adEnv, vehicle)
if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
end
end
elseif assignment.phase == "unfolding" then
-- udfoldet (eller 20 s gået): mål og start
if ADCpBridge.variableWidthUnfolded(vehicle) or now() - assignment.since > ADFieldWork.UNFOLD_WAIT_MS then
assignment.unfoldedForWidth = true
beginWork(adEnv, field, info, assignment)
end
elseif assignment.phase == "waitingCourse" then
if now() - assignment.since > ADFieldWork.COURSE_WAIT_MS then
ADFieldWork.release(assignment)
ADHitch.returnHome(adEnv, vehicle)
fail(assignment.fieldId, "multi-tool: lederens kursus kom ikke (3 min)")
elseif coursesOf(field.id)[field.stage] ~= nil then
beginWork(adEnv, field, info, assignment)
end
elseif assignment.phase == "starting" then
local generating = assignment.handle ~= nil and assignment.handle.generating == true
if ADFieldJobs.startTimedOut(now() - assignment.since, generating) then
ADFieldWork.release(assignment)
ADHitch.returnHome(adEnv, vehicle)
fail(assignment.fieldId, generating and "Courseplay blev ikke færdig med kurset (5 min)" or "Courseplay svarede ikke (60 s)")
end
elseif assignment.phase == "working" then
local t = now()
if t - (assignment.widthCheckAt or 0) >= ADFieldWork.WIDTH_GUARD_MS then
assignment.widthCheckAt = t
local okGuard, errGuard = pcall(ADCpBridge.guardVariableWidth, vehicle)
if not okGuard then Logging.warning("ADSmartPickup: bredde-vagt: %s", tostring(errGuard)) end
end
followWorking(adEnv, field, assignment)
elseif assignment.phase == "awaitingPlayer" then
followManual(adEnv, field, info, assignment)
elseif assignment.phase == "mountingHeader" or assignment.phase == "unmountingHeader" then
followHeaderSwap(adEnv, field, info, assignment)
elseif assignment.phase == "queuedSwap" then
-- den anden mejetærsker høster nu: hent skærebordet og kør ud
if field == nil or info == nil then return ADFieldWork.release(assignment) end
if not ADFieldWork.swapInProgress(assignment.fieldId, assignment) then
ADFieldWork.startHeaderFetch(adEnv, assignment)
log(assignment.fieldId, "harvester: '%s' henter nu skærebordet '%s'", ADRuns.vehicleLabel(vehicle), tostring(assignment.pool.implementName))
end
end
end
-- Høsten er færdig: aflæsningsvognene stoppes; har de rest, kører den til lager, ellers parkering.
function ADFieldWork.windDownHelpers(adEnv, fieldId, stage)
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(fieldId)) do
if assignment.helper and assignment.stage == stage and assignment.phase == "fetching" then
-- høsten sluttede mens puljevognen blev hentet: afbryd, vognen tilbage hvis den nåede at komme på
local vehicle = assignment.vehicle
ADFieldWork.release(assignment)
if not ADHitch.returnHome(adEnv, vehicle) then
local park = parkMarkerId(adEnv, vehicle)
if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
end
log(fieldId, "tømmevogn '%s' afbrudt under hentning — høsten er færdig", ADRuns.vehicleLabel(vehicle))
elseif assignment.helper and assignment.stage == stage and not assignment.deliveredRest then
-- deliveredRest: allerede på vej med rest-læsset (AutoDrive er et AI-job; et nyt stop afbrød turen —
-- in-game 16/10 F38 blev stoppet to gange, 14:02 og 14:03, med 'Tømmevogn 3' på vej til siloen)
if assignment.handle ~= nil then assignment.handle.cancelled = true end
assignment.cpStopIntended = true
ADCpBridge.stop(assignment.vehicle)
assignment.phase = "working"
assignment.idleSince = nil
log(fieldId, "aflæsningsvogn '%s' stoppes — høsten er færdig", ADRuns.vehicleLabel(assignment.vehicle))
end
end
end
-- Stop alle markarbejdets opgaver (Stop alt og parkér). Returnerer {{vehicle, manual}}; markernes trin bevares,
-- så arbejdet fortsætter efter pausen.
function ADFieldWork.stopAllAssignments(adEnv)
local stopped = {}
local list = {}
for _, assignment in pairs(ADFieldJobs.state.assignments) do table.insert(list, assignment) end
for _, assignment in ipairs(list) do
if assignment.playerTransport and assignment.phase == "awaitingPlayer" then
-- venter på spilleren: intet kører (og et frakoblet redskab er ingen traktor) — bare slip opgaven
ADFieldWork.release(assignment)
else
pcall(stopAd, assignment.vehicle)
pcall(ADCpBridge.stop, assignment.vehicle)
ADHitch.stow(assignment.vehicle, "stop alt")
ADFieldWork.release(assignment)
-- puljeredskab: sættes af på sin plads og traktoren kører hjem (i stedet for almindelig parkering)
local okPool, pooled = pcall(ADHitch.returnHome, adEnv, assignment.vehicle)
table.insert(stopped, {vehicle = assignment.vehicle, manual = assignment.manual == true, pooled = okPool and pooled == true})
end
end
return stopped
end
function ADFieldWork.stopAll(adEnv, fieldId)
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(fieldId)) do
if assignment.playerTransport and assignment.phase == "awaitingPlayer" then
ADFieldWork.release(assignment)
else
ADFieldWork.stopOne(adEnv, assignment)
end
end
end
-- Stop ét sæt på marken: AutoDrive/Courseplay af, redskabet foldes, puljeredskab sættes af (ellers hjem).
function ADFieldWork.stopOne(adEnv, assignment)
pcall(stopAd, assignment.vehicle)
ADCpBridge.stop(assignment.vehicle)
ADHitch.stow(assignment.vehicle, "marken stoppet")
local wasFetching = assignment.phase == "fetching"
ADFieldWork.release(assignment)
local okHome, pooled = pcall(ADHitch.returnHome, adEnv, assignment.vehicle)
if wasFetching and not (okHome and pooled) then
local park = parkMarkerId(adEnv, assignment.vehicle)
if park ~= nil then pcall(startAd, adEnv, assignment.vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
end
end
-- til ADPlayerTransport (spillerkørsel): samme opstart, besked og påfyldningsplan som de øvrige sæt
ADFieldWork.beginWork = beginWork
ADFieldWork.askPlayer = askPlayer
ADFieldWork.refillPlan = refillPlan
ADFieldWork.vehiclePosition = vehiclePosition
ADFieldWork.isControlledByPlayer = isControlledByPlayer