Files
fs25-adsmartpickup/FS25_ADSmartPickup/adFieldWork.lua
T
masterdraco ade868568c fix: sæt på vej ud til en mark ved gem overtages efter indlæsning (1.62.222)
In-game F36: sprøjten var på vej ud, da der blev gemt; AutoDrive kørte turen færdig efter
indlæsning, men moden kendte den ikke og lod den holde på marken, mens et andet sæt blev sendt.
Opstartsperioden genkender AD-ture til en marks F-markør (maskiner med markens rolle, marker
[Til]) og overtager ved ankomst (tickReadopt); turen tæller som sæt på vej (tripPlaceholders).
Review: ingen dobbelt-sæt, ingen genregistrering af maskiner uden rolle, vindue 2 min,
afbrudt tur glemmes.
2026-10-11 23:34:26 +02:00

2451 lines
144 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))
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
-- 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
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 {} 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
if #parkedHeaders > 0 then
rig.headerOptions = parkedHeaders
-- bredden: skærebordets (mejetærskeren alene har 0 m og ville blive valgt fra)
for _, option in ipairs(parkedHeaders) 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 == "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).
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
return ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, 1, info.markerId, isReachable, nil, nil, false)
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
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
return function(candidate) return ADFieldWork.unloaderAccepts(candidate.vehicle) 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
-- 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å
if role == "harvester" 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)
enableParkAtJobFinished(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.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).
local function markerAtStation(adEnv, vehicle, station, placeable)
local okOwn, ownId = pcall(function()
local points = loadTriggerPoints(station)
return ADFieldWork.nearestStationMarker(markerList(adEnv, points, ADFieldWork.STATION_MARKER_M), points, ADFieldWork.STATION_MARKER_M)
end)
if okOwn and ownId ~= nil then return ownId end
local node = placeable ~= nil and placeable.rootNode or nil
if node == nil then return nil end
local px, _, pz = getWorldTranslation(node)
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 then best, bestDistance = marker.id, d end
end
end
return best
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).
function ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, x, z, skipRoute)
local farmId = vehicle:getOwnerFarmId()
local best, bestDistance = nil, math.huge
local function consider(wayPointId)
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) > 0 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
-- 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)
enableParkAtJobFinished(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)
enableParkAtJobFinished(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
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.
local function beginBaleCollector(adEnv, field, info, assignment)
local vehicle = assignment.vehicle
local farmId = vehicle:getOwnerFarmId()
local straw = g_fillTypeManager:getFillTypeIndexByName("STRAW")
local isReachable = function(markerId) return ADUnloadWait.hasRouteTo(adEnv, vehicle, markerId) end
local store = ADSources.findPalletStore(adEnv, vehicle, straw, nil, 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)
enableParkAtJobFinished(vehicle)
module:raiseDirtyFlag()
end)
assignment.adHandlesEnd = true
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 and ADCpBridge.unfoldVariableWidth(vehicle) then
assignment.phase, assignment.since = "unfolding", now()
log(field.id, "'%s' foldes ud før bredden måles", ADRuns.vehicleLabel(vehicle))
return
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)
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
-- 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 der stadig har korn efter rest-turen: AutoDrive kunne ikke tømme den — sig det tydeligt
if assignment.role == "harvester" and restLoad(adEnv, vehicle) > 0 then
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 assignment.refillFillType ~= nil and ADCpBridge.getRefillLevel(vehicle, assignment.refillFillType) <= 0 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))
-- læssevogn/påfyldte sæt parkeres af AutoDrive selv (onCpFinished med parkering sat)
-- 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)
local park = not pooled and not assignment.adHandlesEnd 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
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
-- 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 = assignment.refillFillType ~= nil and ADCpBridge.getRefillLevel(vehicle, assignment.refillFillType) <= 0
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
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.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
assignment.idleSince = assignment.idleSince or now()
if now() - assignment.idleSince < ADFieldWork.IDLE_CONFIRM_MS then return 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 tømmer kun selv med parkering sat, så vi 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
-- 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 = nil, nil
if wasWorking then
local extra = {}
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
ADFieldJobs.state.assignments[rig.id] = {vehicleId = rig.id, vehicle = vehicle, fieldId = fieldId, role = rig.role,
stage = stageById[fieldId], 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' fortsætter efter genindlæsning (Courseplay fra sidste waypoint)%s", tostring(rig.label),
assignment.storeId ~= nil and "" or (fillType ~= nil and " — intet lager til resten fundet" or ""))
else
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).
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)
-- 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 then
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