2844 lines
168 KiB
Lua
2844 lines
168 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.
|
|
|
|
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
|
|
local function logInfo(...) return (ADLog or Logging).info(...) end
|
|
|
|
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
|
|
ADFieldWork.WIDTH_GUARD_MS = 10000 -- så tit tjekkes at variabel bredde ikke er sprunget tilbage
|
|
-- 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}
|
|
logInfo("ADSmartPickup: '%s' kører en parkeringstur genoptaget ved indlæsning — en mark må overtage den",
|
|
tostring(ADRuns.vehicleLabel(vehicle)))
|
|
else
|
|
-- tur ud til en mark (in-game 11/10: sprøjten med flydende gødning kørte selv til F36 efter indlæsning,
|
|
-- og moden lod den holde der): overtag den, når den er fremme (tickReadopt)
|
|
local vehicleId = ADRunsController.getVehicleId(vehicle)
|
|
if vehicleId ~= nil and ADFieldWork.taken[vehicleId] == nil and ADFieldJobs.state.assignments[vehicleId] == nil then
|
|
local fieldId, marker = fieldTripTarget(adEnv, vehicle, getFieldList)
|
|
local field = fieldId ~= nil and ADFieldJobs.getField(fieldId) or nil
|
|
local role = field ~= nil and ADFieldModel.roleFor(field.stage) or nil
|
|
if role ~= nil then
|
|
-- kun et sæt moden selv kan køre med markens rolle (ellers glemmes det straks og registreres igen)
|
|
if rigsById == nil then
|
|
rigsById = {}
|
|
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do rigsById[rig.id] = rig end
|
|
end
|
|
local rig = rigsById[vehicleId]
|
|
if rig ~= nil and (rig.role == role or (rig.roles ~= nil and rig.roles[role] == true)) then
|
|
ADFieldWork.taken[vehicleId] = {fieldId = fieldId, role = role, stage = field.stage,
|
|
helper = false, at = now(), trip = {markerId = marker.id}}
|
|
log(fieldId, "'%s' kører ud til %s (AutoDrive genoptog turen ved indlæsning) — overtages ved ankomst",
|
|
ADRuns.vehicleLabel(vehicle), tostring(marker.name))
|
|
local okFix, errFix = pcall(ADFieldWork.fixResumedRefill, adEnv, vehicle, fieldId)
|
|
if not okFix then Logging.warning("ADSmartPickup: genoptaget påfyldning: %s", tostring(errFix)) end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Genoptagne ture ud til marken tæller som et sæt på vej, så marken ikke får et ekstra sæt i mellemtiden
|
|
-- (review 1.62.222: ellers arbejdede både erstatningen og den genoptagne maskine på marken)
|
|
function ADFieldWork.tripPlaceholders(fieldId)
|
|
local list = {}
|
|
for vehicleId, entry in pairs(ADFieldWork.taken) do
|
|
if entry.trip ~= nil and entry.fieldId == fieldId then
|
|
table.insert(list, {vehicleId = vehicleId, fieldId = fieldId, role = entry.role, stage = entry.stage, helper = false,
|
|
phase = "driving", leader = true, groupSize = 1, placeholder = true})
|
|
end
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- Hjemtur efter et markjob: maskinen er ledig undervejs — en mark der kan bruge den (samme redskab), tager den direkte
|
|
-- i stedet for at vente, til den har parkeret (brugerønske 19/10 00:55). Samme mekanisme som de genoptagne ture.
|
|
function ADFieldWork.markTakeableParkTrip(adEnv, vehicle, markerId)
|
|
if vehicle == nil or markerId == nil then return end
|
|
loadTripEnv = loadTripEnv or adEnv -- isLoadTrip slår turen op med AD-miljøet
|
|
loadTrips[vehicle] = {markerId = markerId, untilMs = now() + ADFieldWork.LOAD_TRIP_MS}
|
|
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)
|
|
function ADFieldWork.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)
|
|
ADFieldWork.enableFoldImplements(vehicle)
|
|
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
|
|
-- via tabellen, så profilerens indpakning (ADProfiler.wrap) også måler kaldene herfra (ALDRIG ADFieldWork.startAd =
|
|
-- startAd igen: det pegede tabellen på omviseren selv -> uendelig rekursion, in-game 17/10 04:06 "error in error handling")
|
|
local function startAd(...) return ADFieldWork.startAd(...) end
|
|
ADFieldWork.enableParkAtJobFinished = enableParkAtJobFinished
|
|
|
|
-- Markopgaver: AutoDrives "parkér når jobbet er færdigt" slås FRA — moden afslutter selv (finishAssignment): først
|
|
-- puljeredskabet hjem på sin plads, så traktoren. Med AD's parkering bakkede traktoren ind på sin egen plads med
|
|
-- redskabet på og kørte bagefter til redskabets plads (in-game 16/10, brugerønske). Rest-læs køres af moden.
|
|
local function disableParkAtJobFinished(vehicle)
|
|
local setting = vehicle.ad.settings ~= nil and vehicle.ad.settings.enableParkAtJobFinished or nil
|
|
if setting ~= nil then
|
|
setting.current = 1
|
|
setting.new = 1
|
|
end
|
|
end
|
|
ADFieldWork.disableParkAtJobFinished = disableParkAtJobFinished
|
|
|
|
-- AutoDrives "Fold implements" (pr. køretøj): AD folder alle redskaber sammen og venter, før turen starter (brugerønske
|
|
-- 19/10 00:12). Standard for nye køretøjer er Ja hos spilleren, men 36 ældre stod på Nej. Slås til ved hver start fra moden.
|
|
function ADFieldWork.enableFoldImplements(vehicle)
|
|
local setting = vehicle ~= nil and vehicle.ad ~= nil and vehicle.ad.settings ~= nil and vehicle.ad.settings.FoldImplements or nil
|
|
if setting == nil or setting.values == nil then return false end
|
|
local index = nil
|
|
for i, value in ipairs(setting.values) do if value == true then index = i end end
|
|
if index == nil or setting.current == index then return false end
|
|
setting.current = index
|
|
setting.new = index
|
|
return true
|
|
end
|
|
|
|
-- 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
|
|
-- redskabet selv først: et FRAKOBLET redskab kender AutoDrive.getAllUnits ikke (in-game 17/10 18:33 og 19:27: riven
|
|
-- stod med "P Kuhn GA4731", men spilleropslaget så "uden parkering" og bad spilleren koble den på — puljen, der
|
|
-- læser advd direkte, hentede den samtidig selv)
|
|
if index == nil or index < 1 then
|
|
local own = vehicle.advd ~= nil and vehicle.advd.parkDestination or nil
|
|
if type(own) == "number" and own >= 1 then index = own end
|
|
end
|
|
-- parkeringen kan ligge på vognen/redskabet (advd.parkDestination); AD kopierer den først til traktoren når
|
|
-- redskabet kobles på/vælges — efter indlæsning er kopien ofte tom (in-game 27/9: 20 af 25 "uden parkering")
|
|
if index == nil or index < 1 then
|
|
local ok, units = pcall(adEnv.AutoDrive.getAllUnits, vehicle)
|
|
for _, unit in ipairs(ok and units or {}) do
|
|
local own = unit.advd ~= nil and unit.advd.parkDestination or nil
|
|
if type(own) == "number" and own >= 1 then index = own break end
|
|
end
|
|
end
|
|
if index == nil or index < 1 then return nil end
|
|
local marker = adEnv.ADGraphManager:getMapMarkerById(index)
|
|
return marker ~= nil and marker.id or nil
|
|
end
|
|
ADFieldWork.parkMarkerId = parkMarkerId
|
|
|
|
-- Høster på marken skal stoppe ved fuld tank, så CP's tømmevogn kan tømme den (ADCpBridge.ensureStopForUnload).
|
|
-- Også høstere spilleren kører ud (manual): når moden har overtaget dem og sender tømmevogne, gælder samme problem
|
|
-- (in-game 16/10 F26: Mejetærsker 6 — tømmevognen kørte i ring). Indstillingen bliver stående (brugerønske 16/10).
|
|
local function ensureHarvesterStops(assignment)
|
|
if assignment.role ~= "harvester" then return end
|
|
if ADCpBridge.ensureStopForUnload(assignment.vehicle) then
|
|
log(assignment.fieldId, "'%s': Courseplay \"Stop for unloading\" slået til (ellers kører tømmevognen i ring)",
|
|
ADRuns.vehicleLabel(assignment.vehicle))
|
|
end
|
|
end
|
|
|
|
local function restLoad(adEnv, vehicle)
|
|
local ok, level = pcall(function()
|
|
return (adEnv.AutoDrive.getAllFillLevels(adEnv.AutoDrive.getAllUnits(vehicle)))
|
|
end)
|
|
return ok and tonumber(level) or 0
|
|
end
|
|
|
|
function ADFieldWork.vehiclePosition(vehicle)
|
|
local x, _, z = getWorldTranslation(vehicle.rootNode)
|
|
return x, z
|
|
end
|
|
local vehiclePosition = ADFieldWork.vehiclePosition
|
|
|
|
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))
|
|
-- spillerens maskine (kørt af spilleren de sidste 10 min): puljen, kæder og lån rører den ikke
|
|
or (ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle))
|
|
-- på dyretur (slagteklare dyr til handleren)
|
|
or (ADLivestock ~= nil and ADLivestock.isBusy ~= nil and ADLivestock.isBusy(vehicle))
|
|
-- flow med låst sæt (20/10): pulje, kæder, marksilo og lån rører det aldrig
|
|
or (ADFlowWagons ~= nil and ADFlowWagons.isLockedSet ~= nil and ADFlowWagons.isLockedSet(vehicle))
|
|
end
|
|
|
|
ADFieldWork.isBusyVehicle = isBusyVehicle
|
|
|
|
-- Ledigt skærebord til en manuel høster? s = {isCutter, isCombine, onCombine, owned, reserved}. Et skærebord på en
|
|
-- skærebordsvogn tæller med (spilleren monterer det på marken); et der sidder på en anden høster eller er reserveret
|
|
-- af en anden opgave gør ikke (review 19/10).
|
|
function ADFieldWork.headerAvailable(s)
|
|
return s.isCutter == true and not s.isCombine and not s.onCombine and s.owned == true and not s.reserved
|
|
end
|
|
|
|
-- Gårdens ledige skærebord/optagere (spec_cutter, ikke på en høster): {{vehicle, fruits, categories}}
|
|
function ADFieldWork.looseHeaders(farmId)
|
|
local list = {}
|
|
for _, object in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
|
|
local cutter = object.spec_cutter
|
|
local attacher = object.getAttacherVehicle ~= nil and object:getAttacherVehicle() or nil
|
|
local id = ADRunsController.getVehicleId(object)
|
|
local available = ADFieldWork.headerAvailable({isCutter = cutter ~= nil, isCombine = object.spec_combine ~= nil,
|
|
onCombine = attacher ~= nil and attacher.spec_combine ~= nil,
|
|
owned = farmId == nil or (object.getOwnerFarmId ~= nil and object:getOwnerFarmId() == farmId),
|
|
reserved = id ~= nil and ADPool ~= nil and ADPool.isReserved ~= nil and ADPool.isReserved(id) == true})
|
|
if available then
|
|
local fruits = ADCpBridge.harvestFruitSet(cutter)
|
|
if next(fruits) ~= nil then
|
|
table.insert(list, {vehicle = object, fruits = fruits, categories = ADHeaderSwap ~= nil and ADHeaderSwap.storeCategories(object) or {}})
|
|
end
|
|
end
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- Afgrøder høsteren kan tage med et af de frakoblede skærebord, der passer til den. -> {[fruit] = true}
|
|
function ADFieldWork.headerFruitsFor(vehicle, headers)
|
|
local fruits = {}
|
|
local combine = ADHeaderSwap ~= nil and ADHeaderSwap.storeCategories(vehicle) or {}
|
|
for _, header in ipairs(headers or {}) do
|
|
if ADHeaderSwap == nil or ADHeaderSwap.headerFitsCombine(combine, header.categories) then
|
|
for fruit in pairs(header.fruits) do fruits[fruit] = true end
|
|
end
|
|
end
|
|
return fruits
|
|
end
|
|
|
|
function ADFieldWork.getRigs(adEnv)
|
|
local rigs = {}
|
|
local state = ADFieldJobs.state
|
|
local parkedHeaders = nil -- skærebord på transporthjul (ADHeaderSwap), slås op én gang
|
|
local looseHeaders = nil -- frakoblede skærebord (manuelle høstere), læses é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)
|
|
-- (et stoppet/sovende flows samlede sæt med gyllevogn/spreder er også markflåde: ADFlowWagons.isFieldRigTractor)
|
|
if role ~= nil and id ~= nil and (ADPool ~= nil and ADPool.isFreeFromFlows(vehicle) or ADRunsController.getRunForVehicle(vehicle) == nil
|
|
or (ADFlowWagons ~= nil and ADFlowWagons.isFieldRigTractor ~= nil and ADFlowWagons.isFieldRigTractor(vehicle))) 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,
|
|
-- varer sprederen/gyllevognen kan tage (gylle som gødning: egne varer foretrækkes)
|
|
sprayNames = specs.sprayNames,
|
|
}
|
|
if role == "harvester" then
|
|
rig.fruits = ADCpBridge.getHarvestFruits(vehicle) or {}
|
|
rig.tankFillType = ADFieldWork.tankFillType(vehicle) -- nil = tom
|
|
-- manuel høster uden skærebord: afgrøderne gårdens frakoblede skærebord til netop den kan tage
|
|
if rig.manual and next(rig.fruits) == nil then
|
|
looseHeaders = looseHeaders or ADFieldWork.looseHeaders(vehicle:getOwnerFarmId())
|
|
rig.headerFruits = ADFieldWork.headerFruitsFor(vehicle, looseHeaders)
|
|
end
|
|
end
|
|
-- mejetærsker uden skærebord, men et skærebord på transporthjul står parkeret ved en Connect-markør: den kan
|
|
-- hente det selv (brugerønske 10/10) — dens afgrøder er de parkerede skærebords
|
|
if role == "harvester" and not rig.manual and next(rig.fruits) == nil and ADHeaderSwap ~= nil and ADHeaderSwap.canTowHeader(vehicle) then
|
|
if parkedHeaders == nil then
|
|
local okH, list = pcall(ADHeaderSwap.parkedHeaders, adEnv, vehicle:getOwnerFarmId())
|
|
parkedHeaders = okH and list or {}
|
|
end
|
|
-- kun skærebord der passer til maskinen (in-game 14/10: Ropa Tiger 6S blev sendt efter FD250-kornskærebordet)
|
|
local fitting = {}
|
|
local combineCategories = ADHeaderSwap.storeCategories(vehicle)
|
|
for _, option in ipairs(parkedHeaders) do
|
|
if ADHeaderSwap.headerFitsCombine(combineCategories, ADHeaderSwap.storeCategories(option.vehicle)) then
|
|
table.insert(fitting, option)
|
|
end
|
|
end
|
|
if #fitting > 0 then
|
|
rig.headerOptions = fitting
|
|
-- bredden: skærebordets (mejetærskeren alene har 0 m og ville blive valgt fra)
|
|
for _, option in ipairs(fitting) do
|
|
for fruit in pairs(option.fruits or {}) do rig.fruits[fruit] = true end
|
|
if (option.width or 0) > (rig.width or 0) then rig.width = option.width end
|
|
end
|
|
end
|
|
end
|
|
if role == "seeder" then
|
|
rig.seedFruits = ADCpBridge.getSeedFruits(vehicle)
|
|
rig.hasSeeds = ADCpBridge.hasSeeds(vehicle)
|
|
rig.seedsOnPallets = not rig.hasSeeds and ADFieldWork.seedsOnPallets(vehicle)
|
|
rig.seedsRefill = not rig.hasSeeds and not rig.seedsOnPallets and ADFieldWork.seedsRefillable(adEnv, vehicle, x, z)
|
|
end
|
|
if role == "weeder" then rig.mechanical = ADCpBridge.isMechanicalWeeder(vehicle) end
|
|
table.insert(rigs, rig)
|
|
end
|
|
end
|
|
return rigs
|
|
end
|
|
|
|
-- ---- kurser ----
|
|
|
|
local function coursesOf(fieldId)
|
|
ADFieldJobs.courses[fieldId] = ADFieldJobs.courses[fieldId] or {}
|
|
return ADFieldJobs.courses[fieldId]
|
|
end
|
|
|
|
-- Hvor stor en del af kursets punkter ligger på marken (inde i omridset eller inden for marginen)? nil uden punkter.
|
|
-- Ren funktion til test: insidePolygon(x, z, verts) og distanceToPolygon(x, z, verts) gives med.
|
|
ADFieldWork.COURSE_ON_FIELD_MARGIN_M = 15
|
|
ADFieldWork.COURSE_ON_FIELD_MIN = 0.5
|
|
function ADFieldWork.courseOnField(points, verts, insidePolygon, distanceToPolygon, marginM)
|
|
if type(points) ~= "table" or #points == 0 or type(verts) ~= "table" or #verts < 3 then return nil end
|
|
local margin = marginM or ADFieldWork.COURSE_ON_FIELD_MARGIN_M
|
|
local hits = 0
|
|
for _, p in ipairs(points) do
|
|
if insidePolygon(p.x, p.z, verts) or (distanceToPolygon ~= nil and distanceToPolygon(p.x, p.z, verts) <= margin) then
|
|
hits = hits + 1
|
|
end
|
|
end
|
|
return hits / #points
|
|
end
|
|
|
|
-- Op til maxSamples jævnt fordelte vejpunkter (x, z) fra et Courseplay-kursus; tom liste når kurset ikke kan læses.
|
|
ADFieldWork.COURSE_SAMPLES = 40
|
|
local function coursePoints(course, maxSamples)
|
|
local points = {}
|
|
if course == nil or course.getNumberOfWaypoints == nil or course.getWaypoint == nil then return points end
|
|
local okN, n = pcall(course.getNumberOfWaypoints, course)
|
|
if not okN or type(n) ~= "number" or n < 1 then return points end
|
|
local step = math.max(1, math.ceil(n / (maxSamples or ADFieldWork.COURSE_SAMPLES)))
|
|
for i = 1, n, step do
|
|
local okWp, wp = pcall(course.getWaypoint, course, i)
|
|
if okWp and type(wp) == "table" and type(wp.x) == "number" and type(wp.z) == "number" then
|
|
table.insert(points, {x = wp.x, z = wp.z})
|
|
end
|
|
end
|
|
return points
|
|
end
|
|
|
|
-- Kurset et trin skal genbruge ("mower"/"rake"/"harvester"): gemt kopi, ellers maskinens nuværende kursus.
|
|
-- Maskinens nuværende kursus kan høre til en ANDEN mark: de huskede kopier er væk efter genindlæsning, og
|
|
-- slåmaskinen har siden slået et andet sted (in-game 17/10: F42's læssevogn kørte BiG M 450's F100-kursus,
|
|
-- og F36/F39 fik det samme kursus fra én slåmaskine). Derfor tjekkes kurset mod markens omrids (info.verts).
|
|
local courseUncheckedLogged = {} -- fieldId -> {source = true}
|
|
local function sourceCourse(adEnv, field, info, source)
|
|
local course, origin = coursesOf(field.id)[source], "gemt"
|
|
if course == nil then
|
|
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
|
|
course, origin = ADCpBridge.getCourse(vehicle), "maskinens nuværende"
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if course == nil then return nil end
|
|
local verts = info ~= nil and info.verts or nil
|
|
local onField = ADFieldWork.courseOnField(coursePoints(course), verts, ADFieldJobs.insidePolygon, ADFieldJobs.distanceToPolygon)
|
|
if onField == nil then
|
|
-- kan ikke bedømmes (omrids ukendt eller kurset uden læsbare punkter): kurset bruges som før, men sig det én gang pr. mark
|
|
courseUncheckedLogged[field.id] = courseUncheckedLogged[field.id] or {}
|
|
if not courseUncheckedLogged[field.id][source] then
|
|
courseUncheckedLogged[field.id][source] = true
|
|
log(field.id, "%s %s-kursus kunne ikke tjekkes mod markens omrids — bruges som det er", origin, source)
|
|
end
|
|
elseif onField < ADFieldWork.COURSE_ON_FIELD_MIN then
|
|
log(field.id, "%s %s-kursus ligger på en anden mark (%d %% af punkterne på marken) — Courseplay laver et nyt kursus",
|
|
origin, source, math.floor(onField * 100 + 0.5))
|
|
if origin == "gemt" then coursesOf(field.id)[source] = nil end
|
|
return nil
|
|
end
|
|
return course
|
|
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
|
|
|
|
-- Ren: hvor mange af ballerne ligger løst (ikke på en vogn) inden for markens polygon med varen?
|
|
-- bales = {{x, z, fillType, mounted}}
|
|
function ADFieldWork.countBalesIn(bales, verts, fillType)
|
|
local count = 0
|
|
if #(verts or {}) < 3 then return 0 end
|
|
for _, bale in ipairs(bales or {}) do
|
|
if not bale.mounted and bale.fillType == fillType and ADFieldJobs.insidePolygon(bale.x, bale.z, verts) then
|
|
count = count + 1
|
|
end
|
|
end
|
|
return count
|
|
end
|
|
|
|
-- Baller med afgrødens vare på marken (spillets balleliste, som Courseplays ballefinder). nil = kan ikke tælles.
|
|
function ADFieldWork.countFieldBales(info, fruit)
|
|
if info == nil or #(info.verts or {}) < 3 or g_currentMission == nil or g_currentMission.slotSystem == nil
|
|
or SlotSystem == nil or g_fillTypeManager == nil then return nil end
|
|
local fillType = g_fillTypeManager:getFillTypeIndexByName(string.upper(tostring(fruit)))
|
|
local limits = g_currentMission.slotSystem.objectLimits
|
|
local list = limits ~= nil and limits[SlotSystem.LIMITED_OBJECT_BALE] ~= nil and limits[SlotSystem.LIMITED_OBJECT_BALE].objects or nil
|
|
if fillType == nil or list == nil then return nil end
|
|
local bales = {}
|
|
for _, object in pairs(list) do
|
|
-- varen først (billigt), så positionen; på en vogn/stropper/autoload = ikke løs (som Courseplays isLoaded)
|
|
if object.getFillType ~= nil and object:getFillType() == fillType and object.nodeId ~= nil and object.nodeId ~= 0
|
|
and entityExists(object.nodeId) then
|
|
local x, _, z = getWorldTranslation(object.nodeId)
|
|
table.insert(bales, {x = x, z = z, fillType = fillType,
|
|
mounted = object.mountObject ~= nil or object.dynamicMountObject ~= nil or object.tensionMountObject ~= nil
|
|
or object.currentlyLoadedOnAPalletAutoLoaderId ~= nil})
|
|
end
|
|
end
|
|
return ADFieldWork.countBalesIn(bales, info.verts, fillType)
|
|
end
|
|
|
|
-- Ballelasterens fyldtyper for en ballehøst-afgrøde: {SQUAREBALE_COTTON, ROUNDBALE_COTTON} som indeks (de findes).
|
|
function ADFieldWork.baleFillTypes(fruit)
|
|
local result = {}
|
|
if fruit == nil or g_fillTypeManager == nil then return result end
|
|
for _, prefix in ipairs({"SQUAREBALE_", "ROUNDBALE_"}) do
|
|
local index = g_fillTypeManager:getFillTypeIndexByName(prefix .. string.upper(tostring(fruit)))
|
|
if index ~= nil then table.insert(result, index) end
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- Kan sættet (traktor med opsamler, eller løs opsamler) bære en af balletyperne? Uden kendte typer: nej.
|
|
function ADFieldWork.carriesAnyBale(vehicle, baleTypes)
|
|
if vehicle == nil or #(baleTypes or {}) == 0 then return false end
|
|
for _, fillType in ipairs(baleTypes) do
|
|
if ADPool.rigHasCargoFor(vehicle, fillType) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function acceptFor(field, info, role)
|
|
if role == "harvester" then
|
|
local fruit = info.fruitIndex
|
|
return function(candidate) return ADManualTransport.acceptsHarvester(candidate, fruit) end
|
|
elseif role == "seeder" then
|
|
local fruitIndex = ADFieldWork.sowFruitIndex(field)
|
|
-- tom såmaskine er med, når dens frø findes på paller (risplanter + stiklingepaller, in-game 4/10)
|
|
return function(candidate) return ADFieldWork.seederAccepts(candidate, fruitIndex) end
|
|
elseif role == "unloader" then
|
|
-- vognen skal kunne bære høstens vare (påkoblet vogn eller løs vogn, se ADPool.rigCarries)
|
|
local fillType = info.harvestFillType
|
|
return function(candidate)
|
|
return ADFieldWork.unloaderAccepts(candidate.vehicle) and ADPool.rigCarries(candidate.vehicle, fillType)
|
|
end
|
|
elseif role == "baleCollector" and ADFieldModel.isBaleHarvest(field.lastFruit) then
|
|
-- bomuldsmoduler: kun en opsamler der kan bære dem (SQUAREBALE_/ROUNDBALE_COTTON) — in-game 16/10 F39 tog
|
|
-- spillerens Pickup 2017, Courseplay fandt intet at samle, og marken gik videre med modulerne liggende
|
|
local baleTypes = ADFieldWork.baleFillTypes(field.lastFruit)
|
|
return function(candidate) return ADFieldWork.carriesAnyBale(candidate.vehicle, baleTypes) end
|
|
elseif role == "weeder" then
|
|
local large = (info.weed or 0) > ADFieldModel.WEED_MECHANICAL_MAX
|
|
return function(candidate) return not (large and candidate.mechanical) end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
function ADFieldWork.sowFruitIndex(field)
|
|
local name = ADFieldModel.sowFruit(field)
|
|
if name == nil or g_fruitTypeManager == nil then return nil end
|
|
local fruit = g_fruitTypeManager:getFruitTypeByName(name)
|
|
return fruit ~= nil and fruit.index or nil
|
|
end
|
|
|
|
-- Kan trinnet overhovedet begynde? (såning: afgrøde valgt og i såperioden)
|
|
local function preflight(field, role)
|
|
if role == "seeder" then
|
|
local fruitIndex = ADFieldWork.sowFruitIndex(field)
|
|
if fruitIndex == nil then return false, {key = "spu_field_reason_noSowFruit"} end
|
|
if not ADCpBridge.isPlantableNow(fruitIndex) then
|
|
return false, {key = "spu_field_reason_notPlantable", name = ADFieldModel.sowFruit(field)}
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
ADFieldWork.REFILL_ROLES = {seeder = true, fertilizer = true, limer = true, weeder = true}
|
|
|
|
local fillTypeName = ADUtil.fillTypeName
|
|
|
|
-- 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
|
|
|
|
-- Gylle som gødning: spreder/gyllevogn med gårdens egne varer først, når lageret dækker markens behov.
|
|
-- -> candidate -> bool, eller nil når reglen ikke gælder (anden rolle, slået fra, eller reglen fejlede)
|
|
local function fertilizerPrefer(role, farmId, info)
|
|
if role ~= "fertilizer" or ADFieldFertilizer == nil or ADFieldFertilizer.preferCandidate == nil then return nil end
|
|
local areaHa = ADFields ~= nil and ADFields.polygonAreaHa ~= nil and info.verts ~= nil and ADFields.polygonAreaHa(info.verts) or 0
|
|
local okP, result = pcall(ADFieldFertilizer.preferCandidate, farmId, areaHa)
|
|
if not okP and not ADFieldFertilizer.preferFailed then
|
|
ADFieldFertilizer.preferFailed = true
|
|
Logging.warning(ADFieldFertilizer.LOG_PREFIX .. "fortrinsreglen fejlede: %s", tostring(result))
|
|
end
|
|
return okP and result or nil
|
|
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
|
|
-- gylle som gødning gælder også puljens redskaber (in-game 17/10: MEGA valgt, Supercis stod klar i puljen)
|
|
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or nil
|
|
local pair, why, args = ADPool.pairFor(role, info.x, info.z, implements, tractors, ADPool.blocked(now()), accept,
|
|
fertilizerPrefer(role, farmId, info))
|
|
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
|
|
|
|
-- Hvilke maskiner må overvejes til rollen: faste maskiner efter markens plan, lånt kontraktudstyr efter reglerne.
|
|
-- -> kandidater | nil når sagen allerede er givet videre (spilleren bedes koble det lånte redskab på)
|
|
local function dispatchCandidates(adEnv, field, info, role)
|
|
-- 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 nil
|
|
end
|
|
candidates = leasedFirst
|
|
end
|
|
return candidates
|
|
end
|
|
|
|
-- Kan kandidaten tage opgaven herfra? Rollens krav, tankindhold, skærebordets plads og afstand til AutoDrive-vejnettet.
|
|
-- Maskiner for langt fra vejnettet noteres i offNetwork (til forklaringen, når ingen kan).
|
|
local function dispatchAccept(adEnv, field, info, role, decision, roleAccept, offNetwork)
|
|
return function(candidate)
|
|
if roleAccept ~= nil and not roleAccept(candidate) then return false end
|
|
-- høster med noget i tanken: kun en mark med samme afgrøde (ellers blandes den i tanken)
|
|
if role == "harvester" and candidate.tankFillType ~= nil and info.harvestFillType ~= nil
|
|
and candidate.tankFillType ~= info.harvestFillType then return false end
|
|
-- manuel transport: spilleren kører den — afstand til AutoDrive-vejnettet er ligegyldig
|
|
if role == "harvester" and candidate.manual then return true end
|
|
-- kontraktmark uden F-markør: spillets egen hjælper (Courseplay-jobbets kørsel med Giants' vejfinding) kører
|
|
-- sættet derud — ingen AutoDrive, ingen parkering nødvendig (brugerønske 10/10). Mejetærsker kun med eget skærebord foran.
|
|
if info.markerId == nil then
|
|
if not field.contract then return false end
|
|
if role == "harvester" and (candidate.headerOptions ~= nil
|
|
or (ADHeaderSwap ~= nil and candidate.vehicle ~= nil and ADHeaderSwap.headerPosition(candidate.vehicle) == "rear")) then
|
|
return false
|
|
end
|
|
return true
|
|
end
|
|
-- skærebord på transporthjul FORAN (foldet ud): må ikke ud på vejen — kun til den mark, den står på.
|
|
-- Optaget (høster en anden mark): sættes bag på efter høst, så marken venter i kø — ikke "kan ingen"
|
|
-- (in-game 15/10: F95 hvede rød, mens Mejetærsker 1 høstede F63 med FD250 foran)
|
|
if role == "harvester" and not candidate.busy and ADHeaderSwap ~= nil and candidate.vehicle ~= nil and ADHeaderSwap.headerPosition(candidate.vehicle) == "front"
|
|
and not (candidate.x ~= nil and #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(candidate.x, candidate.z, info.verts)) then
|
|
return false
|
|
end
|
|
-- optaget andetsteds (eller spilleren kører den): hvor den står nu (fx midt på en anden mark, langt fra vejnettet)
|
|
-- siger intet om, hvorvidt den kan opgaven — vurderes når den er ledig. Ellers "ingen kan" i stedet for kø
|
|
-- (in-game 16/10: F39 "stone picker missing", mens 8280 TTV med Scorpio plukkede sten på F22)
|
|
if candidate.busy or candidate.controlled then return true 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
|
|
end
|
|
|
|
-- Flådens valg: ét sæt, eller flere til multi-tool. -> {rig...} | nil, why, args
|
|
local function pickRigs(candidates, role, decision, info, required, accept)
|
|
-- gylle som gødning: spreder/gyllevogn med gårdens egne varer først, når lageret dækker markens behov
|
|
local first = candidates[1] ~= nil and candidates[1].vehicle or nil
|
|
local farmId = first ~= nil and first.getOwnerFarmId ~= nil and first:getOwnerFarmId() or nil
|
|
local prefer = fertilizerPrefer(role, farmId, info)
|
|
if (decision.count or 1) > 1 then
|
|
return ADFieldFleet.pickMany(candidates, role, decision.count, info.x, info.z, required, accept, prefer)
|
|
end
|
|
local rig, why, args = ADFieldFleet.pick(candidates, role, info.x, info.z, required, accept, prefer)
|
|
return rig ~= nil and {rig} or nil, why, args
|
|
end
|
|
|
|
-- Ingen færdig kombination: en ledig solo-traktor henter et puljeredskab (kun hovedopgaver, ikke tømmevogne).
|
|
-- Marken med egne faste maskiner til rollen venter på dem (som uden puljen).
|
|
-- -> true når sagen er afgjort (sendt, eller grunden noteret); ellers false og evt. justeret why, args
|
|
local function tryPool(adEnv, field, info, role, decision, candidates, roleAccept, why, args)
|
|
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 not (ADPool ~= nil and info.markerId ~= nil and ADPool.mayUsePool(decision, hasOwnForRole)
|
|
and (why == "noRig" or why == "allBusy" or why == "cannotDo")) then
|
|
return false, why, args
|
|
end
|
|
local pooled, poolWhy, poolArgs = ADFieldWork.dispatchPool(adEnv, field, info, role, roleAccept, decision)
|
|
if pooled then return true 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 true
|
|
end
|
|
if poolWhy == "noPoolTractor" and why ~= "allBusy" then
|
|
return false, poolWhy, poolArgs
|
|
elseif poolWhy == "poolBusy" then
|
|
-- puljeredskabet hentes til en anden mark: kø (gul), ikke "ingen maskine" (rød)
|
|
return false, "allBusy", nil
|
|
end
|
|
return false, why, args
|
|
end
|
|
|
|
-- Også i loggen (én gang pr. ændring): før stod grunden kun i fanen, og loggen var tavs (in-game 27/9).
|
|
-- Hvem har rollen, og hvorfor kan de ikke bruges (in-game 27/9: "allBusy" uden at sige hvem)
|
|
-- Høster med en anden afgrøde i tanken (dispatchAccept afviser den): sig det i stedet for "ledig" (in-game 19/10: Mejetærsker 6
|
|
-- med 149.431 l majs stod som "ledig" ved spinatkontrakten F83). -> tekst eller nil
|
|
function ADFieldWork.tankBlockText(role, tankFillType, harvestFillType)
|
|
if role ~= "harvester" or tankFillType == nil or harvestFillType == nil or tankFillType == harvestFillType then return nil end
|
|
local name = g_fillTypeManager ~= nil and g_fillTypeManager.getFillTypeNameByIndex ~= nil and g_fillTypeManager:getFillTypeNameByIndex(tankFillType) or tostring(tankFillType)
|
|
return string.format("har %s i tanken — tøm den først", tostring(name))
|
|
end
|
|
|
|
-- Den eneste grund til "ingen kan" er en høster med en anden afgrøde i tanken? -> dens navn (kø "tøm den", ikke "mangler
|
|
-- på gården"; review 19/10). Ellers nil.
|
|
function ADFieldWork.tankBlockedHarvester(role, candidates, roleAccept, harvestFillType)
|
|
if role ~= "harvester" then return nil end
|
|
for _, candidate in ipairs(candidates or {}) do
|
|
if (candidate.role == role or (candidate.roles ~= nil and candidate.roles[role])) and candidate.enabled ~= false
|
|
and not candidate.busy and not candidate.controlled and (roleAccept == nil or roleAccept(candidate))
|
|
and ADFieldWork.tankBlockText(role, candidate.tankFillType, harvestFillType) ~= nil then
|
|
return candidate.label
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function logNoRig(field, role, why, candidates, roleAccept, info)
|
|
local noRigKey = tostring(role) .. ":" .. tostring(why)
|
|
if lastNoRig[field.id] == noRigKey then return end
|
|
lastNoRig[field.id] = noRigKey
|
|
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 ADFieldWork.tankBlockText(role, candidate.tankFillType, info ~= nil and info.harvestFillType or nil) 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
|
|
|
|
-- Intet sæt kunne vælges: pulje, spillerkørsel, spring sten over — ellers grunden i fanen og loggen.
|
|
local function dispatchNoRig(adEnv, field, info, role, decision, candidates, required, roleAccept, why, args, offNetwork)
|
|
local handled
|
|
handled, why, args = tryPool(adEnv, field, info, role, decision, candidates, roleAccept, why, args)
|
|
if handled then return 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
|
|
local blockedName = why == "cannotDo" and ADFieldWork.tankBlockedHarvester(role, candidates, roleAccept, info.harvestFillType) or nil
|
|
if blockedName ~= nil then
|
|
why = "tankBlocked"
|
|
note(field.id, {reason = {key = "spu_field_reason_tankBlocked", name = tostring(blockedName), role = role},
|
|
retryAt = ADPool.alignedRetry(now(), ADFieldWork.NO_RIG_RETRY_MS)})
|
|
else
|
|
note(field.id, {reason = {key = "spu_field_reason_" .. tostring(why), role = role, args = args}, retryAt = ADPool.alignedRetry(now(), ADFieldWork.NO_RIG_RETRY_MS)})
|
|
end
|
|
logNoRig(field, role, why, candidates, roleAccept, info)
|
|
end
|
|
|
|
-- Mejetærskeren henter sit skærebord på transporthjul (som puljens "fetching": samme fejl- og karantænevej) og
|
|
-- monterer det på marken. Er en anden ved at montere ved markens indkørsel, venter den hjemme.
|
|
local function launchHeaderFetch(adEnv, field, rig, assignment, header)
|
|
header.taken = true
|
|
if (header.width or 0) > 0 then assignment.width = header.width end
|
|
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
|
|
end
|
|
|
|
-- AutoDrive kører sættet til marken — tomt redskab fyldes på vejen (LOAD), uden påfyldning prøves paller.
|
|
-- -> false når udsendelsen skal stoppe her (paller sat i gang, eller tom uden påfyldning: markens status er sat)
|
|
local function launchDrive(adEnv, field, info, role, rig, assignment)
|
|
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 false
|
|
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 false
|
|
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
|
|
return true
|
|
end
|
|
|
|
-- Sættet sendes af sted: skærebord hentes først, manuel høster = spilleren kører, kontrakt uden markør = spillets
|
|
-- hjælper, ellers AutoDrive. -> false når udsendelsen af marken skal stoppe her
|
|
local function launchRig(adEnv, field, info, role, rig, assignment)
|
|
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
|
|
launchHeaderFetch(adEnv, field, rig, assignment, header)
|
|
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
|
|
return launchDrive(adEnv, field, info, role, rig, assignment)
|
|
end
|
|
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
|
|
local candidates = dispatchCandidates(adEnv, field, info, role)
|
|
if candidates == nil then return 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 = dispatchAccept(adEnv, field, info, role, decision, roleAccept, offNetwork)
|
|
local rigs, why, args = pickRigs(candidates, role, decision, info, required, accept)
|
|
if rigs == nil then
|
|
return dispatchNoRig(adEnv, field, info, role, decision, candidates, required, roleAccept, why, args, offNetwork)
|
|
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,
|
|
}
|
|
if not launchRig(adEnv, field, info, role, rig, assignment) then return end
|
|
end
|
|
note(field.id, {reason = false})
|
|
end
|
|
|
|
-- Læssevogn: AutoDrive overtager ved "fuld" (Hent og aflever F -> lager, hjælper = Courseplay).
|
|
local function prepareCollector(adEnv, field, info, assignment)
|
|
local vehicle = assignment.vehicle
|
|
local store, why = ADFieldWork.chooseStore(adEnv, field, info, vehicle, ADFieldWork.storeFillType(field, info))
|
|
if store == nil then
|
|
ADFieldWork.release(assignment)
|
|
fail(field.id, "intet lager: " .. tostring(why))
|
|
return false
|
|
end
|
|
assignment.storeId = store.id
|
|
local module = stateModule(vehicle)
|
|
module:setMode(adEnv.AutoDrive.MODE_PICKUPANDDELIVER)
|
|
module:setFirstMarkerByWayPointId(info.markerId)
|
|
module:setSecondMarkerByWayPointId(store.id)
|
|
module:setStartHelper(true)
|
|
module.usedHelper = helperCp(adEnv)
|
|
disableParkAtJobFinished(vehicle)
|
|
module:raiseDirtyFlag()
|
|
log(field.id, "læssevogn '%s' aflæsser i %s", ADRuns.vehicleLabel(vehicle), tostring(store.name))
|
|
return true
|
|
end
|
|
|
|
-- Påfyldning undervejs (såmaskine/sprøjte/spreder): AutoDrive LOAD med hjælper = Courseplay. Når CP melder
|
|
-- tom (onCpEmpty), kører AD til påfyldningen (2. markør), fylder op, kører tilbage til F-markøren (1. markør)
|
|
-- og genstarter CP. Findes ingen påfyldning, stopper sættet når det er tomt ("tom for …", se finish).
|
|
local function prepareRefill(adEnv, field, info, assignment)
|
|
local vehicle = assignment.vehicle
|
|
local fillType = ADCpBridge.getRefillFillType(vehicle, assignment.role)
|
|
if fillType == nil then return end
|
|
assignment.refillFillType = fillType
|
|
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
|
|
-- uden F-markør (kontraktmark, spillets hjælper) kan AutoDrive ikke køre tilbage til marken efter påfyldning
|
|
local refillId = info.markerId ~= nil and ADFieldWork.findRefillMarker(adEnv, vehicle, fillType, info.x, info.z) or nil
|
|
if refillId == nil then
|
|
log(field.id, "ingen påfyldning af %s med AutoDrive-markør fundet — '%s' stopper når den er tom", tostring(name), ADRuns.vehicleLabel(vehicle))
|
|
return
|
|
end
|
|
local module = stateModule(vehicle)
|
|
local ok = pcall(function()
|
|
module:setMode(adEnv.AutoDrive.MODE_LOAD)
|
|
module:setFirstMarkerByWayPointId(info.markerId)
|
|
module:setSecondMarkerByWayPointId(refillId)
|
|
module:setFillType(fillType)
|
|
module:setStartHelper(true)
|
|
module.usedHelper = helperCp(adEnv)
|
|
disableParkAtJobFinished(vehicle)
|
|
module:raiseDirtyFlag()
|
|
end)
|
|
if ok then
|
|
assignment.adHandlesEnd = true
|
|
local marker = adEnv.ADGraphManager:getMapMarkerByWayPointId(refillId)
|
|
log(field.id, "'%s' fyldes op med %s ved %s af AutoDrive når den er tom", ADRuns.vehicleLabel(vehicle), tostring(name), tostring(marker ~= nil and marker.name or refillId))
|
|
end
|
|
end
|
|
|
|
-- Aflæsningsvogn under høst: Courseplays combine-unloader med stationen fra silovalget.
|
|
local function beginUnloader(adEnv, field, info, assignment)
|
|
local vehicle = assignment.vehicle
|
|
local fillType = assignment.fillType or info.harvestFillType
|
|
local store, why = ADFieldWork.chooseStore(adEnv, field, info, vehicle, fillType)
|
|
-- høstkontrakt uden AutoDrive-vej (ingen F-markør eller ingen markør ved salgsstedet): spillets hjælper kører
|
|
-- læssene til kontraktens salgssted (Courseplay "Giants unload", brugerønske 10/10)
|
|
local giantsStation = nil
|
|
if field.contract and field.contractStation ~= nil and (store == nil or info.markerId == nil) then
|
|
giantsStation, store = field.contractStation, nil
|
|
end
|
|
if store == nil and giantsStation == nil then
|
|
ADFieldWork.release(assignment)
|
|
ADHitch.returnHome(adEnv, vehicle)
|
|
fail(field.id, "intet lager til høsten: " .. tostring(why))
|
|
return
|
|
end
|
|
assignment.storeId = store ~= nil and store.id or nil
|
|
local station = giantsStation or ADSmartPickup.getUnloadStationAtWayPointId(adEnv, store.id, vehicle:getOwnerFarmId())
|
|
local storeName = store ~= nil and tostring(store.name)
|
|
or tostring(giantsStation.getName ~= nil and giantsStation:getName() or "kontraktens salgssted")
|
|
-- AutoDrive kører de fulde læs til siloen ad vejnettet (Hent og aflever, hjælper = Courseplay), ikke CP selv
|
|
local adReady = store ~= nil and pcall(function()
|
|
local module = stateModule(vehicle)
|
|
module:setMode(adEnv.AutoDrive.MODE_PICKUPANDDELIVER)
|
|
module:setFirstMarkerByWayPointId(info.markerId)
|
|
module:setSecondMarkerByWayPointId(store.id)
|
|
if fillType ~= nil then
|
|
module:setFillType(fillType)
|
|
module.selectedFillTypes = {fillType}
|
|
end
|
|
module:setStartHelper(true)
|
|
module.usedHelper = helperCp(adEnv)
|
|
disableParkAtJobFinished(vehicle)
|
|
module:raiseDirtyFlag()
|
|
end)
|
|
if adReady then assignment.adHandlesEnd = true end
|
|
local markerPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
|
|
-- punktet nærmest traktoren: CP lægger kursets start dér (ikke i den anden ende af marken)
|
|
local vx, vz = vehiclePosition(assignment.vehicle)
|
|
local point = ADFieldJobs.nearestPoint(info.points, vx, vz) or {x = info.x, z = info.z}
|
|
assignment.phase = "starting"
|
|
assignment.since = now()
|
|
-- ventepladsen inde på marken, ikke på F-markøren (ADFieldJobs.waitSpot)
|
|
local waitX, waitZ = markerPoint ~= nil and markerPoint.x or point.x, markerPoint ~= nil and markerPoint.z or point.z
|
|
local wait = ADFieldJobs.waitSpot(info.verts, waitX, waitZ, info.x, info.z, ADFieldWork.UNLOADER_WAIT_INSET_M, ADFieldWork.UNLOADER_WAIT_SIDE_M)
|
|
if wait ~= nil then waitX, waitZ = wait.x, wait.z end
|
|
for _, other in pairs(ADFieldJobs.state.assignments) do
|
|
if other.fieldId == field.id then ensureHarvesterStops(other) end
|
|
end
|
|
local handle, err = ADCpBridge.startUnloader(vehicle, point.x, point.z, waitX, waitZ, station, function(ok, reason)
|
|
if ok then
|
|
assignment.phase = "working"
|
|
assignment.since = now()
|
|
log(field.id, "aflæsningsvogn '%s' følger høsteren -> %s (%s)", ADRuns.vehicleLabel(vehicle), storeName,
|
|
adReady and "AutoDrive kører læssene ad vejnettet" or "spillets hjælper kører læssene (Courseplay/Giants)")
|
|
else
|
|
ADFieldWork.release(assignment)
|
|
ADHitch.returnHome(adEnv, vehicle)
|
|
fail(field.id, "aflæsningsvogn: " .. tostring(reason))
|
|
end
|
|
end, not adReady)
|
|
if handle == nil then
|
|
ADFieldWork.release(assignment)
|
|
ADHitch.returnHome(adEnv, vehicle)
|
|
fail(field.id, "aflæsningsvogn: " .. tostring(err))
|
|
return
|
|
end
|
|
assignment.handle = handle
|
|
end
|
|
|
|
-- Ballesamler: Courseplays ballefinder; fuld vogn tømmes af AutoDrive i nærmeste ballelager (palleskur der
|
|
-- tager halmballer), som læssevognen. Uden lager stopper den når den er fuld.
|
|
local function beginBaleCollector(adEnv, field, info, assignment)
|
|
local vehicle = assignment.vehicle
|
|
local farmId = vehicle:getOwnerFarmId()
|
|
-- halmballer, eller bomuldsmoduler efter bomuldshøst (ADFieldWork.storeFillType)
|
|
local baleFillType = ADFieldWork.storeFillType(field, info)
|
|
local isReachable = function(markerId) return ADUnloadWait.hasRouteTo(adEnv, vehicle, markerId) end
|
|
local store = ADFieldWork.chooseBaleStore(adEnv, field, info, vehicle, baleFillType, isReachable, farmId)
|
|
if store ~= nil then
|
|
pcall(function()
|
|
local module = stateModule(vehicle)
|
|
module:setMode(adEnv.AutoDrive.MODE_PICKUPANDDELIVER)
|
|
module:setFirstMarkerByWayPointId(info.markerId)
|
|
module:setSecondMarkerByWayPointId(store.wayPointId)
|
|
module:setStartHelper(true)
|
|
module.usedHelper = helperCp(adEnv)
|
|
disableParkAtJobFinished(vehicle)
|
|
module:raiseDirtyFlag()
|
|
end)
|
|
assignment.adHandlesEnd = true
|
|
-- AD's parkering ved jobslut er fra: moden kører selv et rest-læs til lageret (review 16/10)
|
|
assignment.storeId = store.wayPointId
|
|
log(field.id, "ballesamler '%s' kører fulde læs til %s", ADRuns.vehicleLabel(vehicle), tostring(store.name))
|
|
else
|
|
log(field.id, "intet ballelager med plads og vej fundet — ballesamleren stopper når den er fuld")
|
|
end
|
|
-- punktet nærmest traktoren: CP lægger kursets start dér (ikke i den anden ende af marken)
|
|
local vx, vz = vehiclePosition(assignment.vehicle)
|
|
local point = ADFieldJobs.nearestPoint(info.points, vx, vz) or {x = info.x, z = info.z}
|
|
assignment.phase = "starting"
|
|
assignment.since = now()
|
|
local handle, err = ADCpBridge.startBaleFinder(vehicle, point.x, point.z, function(ok, reason)
|
|
if ok then
|
|
assignment.phase = "working"
|
|
assignment.since = now()
|
|
log(field.id, "Courseplay startet (ballesamler)")
|
|
else
|
|
ADFieldWork.release(assignment)
|
|
fail(field.id, "ballesamler: " .. tostring(reason))
|
|
end
|
|
end)
|
|
if handle == nil then
|
|
ADFieldWork.release(assignment)
|
|
fail(field.id, "ballesamler: " .. tostring(err))
|
|
return
|
|
end
|
|
assignment.handle = handle
|
|
end
|
|
|
|
-- Multi-tool: følgere venter på lederens kursus for trinnet og kopierer det med deres bane.
|
|
local function courseOptions(adEnv, field, info, assignment)
|
|
local source = ADFieldModel.courseSource(field, assignment.role)
|
|
if source ~= nil then
|
|
local course = sourceCourse(adEnv, field, info, 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
|
|
|
|
-- Høsteren: halmskår efter planen (hakkes = fra; samles op/presses = skår). Vinmark: kurset i gangen (ikke på
|
|
-- vinen), ellers kører maskinen ind i stolperne.
|
|
local function applyCourseTweaks(field, info, assignment, vehicle)
|
|
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
|
|
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
|
|
end
|
|
|
|
-- Redskabet gøres klar til rollen: læssevogn (AutoDrive overtager ved fuld), påfyldning undervejs, frøvalg og
|
|
-- sideforskydning. -> false når sættet er sluppet igen (fejl)
|
|
local function prepareRoleTools(adEnv, field, info, assignment, source)
|
|
local vehicle = assignment.vehicle
|
|
if assignment.role == "collector" then
|
|
if not prepareCollector(adEnv, field, info, assignment) then return false 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 false
|
|
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
|
|
return true
|
|
end
|
|
|
|
-- Punktet nærmest traktoren: CP lægger kursets start dér (ikke i den anden ende af marken). Kontrakt der køres igen:
|
|
-- markpunktet længst væk (spillets markkant fandt kun det stykke, maskinen står på).
|
|
local function courseStartPoint(field, info, vx, vz)
|
|
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}
|
|
if field.contract and (field.contractPasses or 0) > 0 then
|
|
point = ADFieldJobs.farthestPoint(info.points, vx, vz) or point
|
|
end
|
|
return point
|
|
end
|
|
|
|
-- Courseplay kører: kurset huskes til genbrug og følgere, høsteren får "Stop for unloading".
|
|
local function onCourseStarted(field, assignment, vehicle, source, reason, cacheContext)
|
|
assignment.phase = "working"
|
|
assignment.since = now()
|
|
ADCourseCache.afterStart(vehicle, assignment.vehicleId, cacheContext)
|
|
if assignment.role == "mower" then
|
|
-- mål bredden igen nu: lige efter koblingen kan Courseplay endnu ikke have talt bagslåmaskinen med
|
|
-- (in-game 8/10: KDF 341 + KDD 941 målt 3,4 m 0,2 s efter koblingen, 9,4 m et sekund efter)
|
|
local okNow, widthNow = pcall(ADCpBridge.getWorkWidth, vehicle)
|
|
if okNow and type(widthNow) == "number" and widthNow > 0 then assignment.width = widthNow end
|
|
note(field.id, {mowWidth = assignment.width, mowVehicleId = assignment.vehicleId})
|
|
rememberCourse(field, "mower", vehicle)
|
|
elseif assignment.role == "rake" then
|
|
note(field.id, {rakeVehicleId = assignment.vehicleId})
|
|
rememberCourse(field, "rake", vehicle)
|
|
elseif assignment.role == "harvester" then
|
|
note(field.id, {harvestVehicleId = assignment.vehicleId})
|
|
rememberCourse(field, "harvester", vehicle)
|
|
ensureHarvesterStops(assignment)
|
|
end
|
|
if assignment.leader and (assignment.groupSize or 1) > 1 then
|
|
rememberCourse(field, field.stage, vehicle)
|
|
end
|
|
log(field.id, "Courseplay startet (%s%s%s)", assignment.role,
|
|
reason == "copied" and source ~= nil and (", " .. tostring(source) .. "-kursus kopieret") or "",
|
|
assignment.lane ~= nil and string.format(", bane %d", assignment.lane) or "")
|
|
end
|
|
|
|
-- Courseplay fejlede: sættet slippes, kursusfejl venter længere, og maskinen kører hjem.
|
|
local function onCourseFailed(adEnv, field, assignment, vehicle, reason)
|
|
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
|
|
|
|
-- Kurset lægges og Courseplay startes (fase "starting"; svaret kommer asynkront i onCourseStarted/onCourseFailed).
|
|
local function startCourse(adEnv, field, info, assignment, opts, source)
|
|
local vehicle = assignment.vehicle
|
|
local vx, vz = vehiclePosition(vehicle)
|
|
local point = courseStartPoint(field, info, vx, vz)
|
|
-- 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 == "last" then log(field.id, "'%s' fortsætter sit eget kursus fra sidste punkt", ADRuns.vehicleLabel(vehicle)) 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
|
|
onCourseStarted(field, assignment, vehicle, source, reason, cacheContext)
|
|
else
|
|
onCourseFailed(adEnv, field, assignment, vehicle, reason)
|
|
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
|
|
|
|
local function beginWork(adEnv, field, info, assignment)
|
|
local vehicle = assignment.vehicle
|
|
-- aldrig Courseplay med tom tank (den kører kurset uden at sprede/så)
|
|
if ADFieldWork.REFILL_ROLES[assignment.role] then
|
|
local fillType = ADCpBridge.getRefillFillType(vehicle, assignment.role)
|
|
if fillType ~= nil and ADCpBridge.getRefillLevel(vehicle, fillType) <= 0 then
|
|
ADFieldWork.release(assignment)
|
|
fail(field.id, string.format("'%s' er stadig tom for %s ved marken — fyld den op (på vognen: %s)", ADRuns.vehicleLabel(vehicle), fillTypeName(fillType), ADCpBridge.describeFill(vehicle)))
|
|
return
|
|
end
|
|
end
|
|
if assignment.role == "unloader" then return beginUnloader(adEnv, field, info, assignment) end
|
|
if assignment.role == "baleCollector" then return beginBaleCollector(adEnv, field, info, assignment) end
|
|
-- variabel bredde: fold ud og vent, før bredden måles og kurset lægges (in-game 9/10: BiG M 450 målt sammenfoldet)
|
|
if not assignment.unfoldedForWidth and ADCpBridge.unfoldVariableWidth ~= nil then
|
|
local started, blocked = ADCpBridge.unfoldVariableWidth(vehicle)
|
|
if started then
|
|
assignment.phase, assignment.since = "unfolding", now()
|
|
log(field.id, "'%s' foldes ud før bredden måles", ADRuns.vehicleLabel(vehicle))
|
|
return
|
|
end
|
|
if blocked ~= nil and not assignment.unfoldBlockedLogged then
|
|
assignment.unfoldBlockedLogged = true
|
|
log(field.id, "'%s' foldes ikke ud før bredden måles: '%s' kan ikke foldes sammen igen (fyldt tank)", ADRuns.vehicleLabel(vehicle), blocked)
|
|
end
|
|
end
|
|
assignment.unfoldedForWidth = nil
|
|
applyCourseTweaks(field, info, assignment, vehicle)
|
|
local opts, source = courseOptions(adEnv, field, info, 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 not prepareRoleTools(adEnv, field, info, assignment, source) then return end
|
|
startCourse(adEnv, field, info, assignment, opts, source)
|
|
end
|
|
|
|
-- Tom for påfyldningsvaren — kun når redskabet stadig sidder på. AutoDrives parkering efter jobbet kan have sat
|
|
-- puljeredskabet af, og så måler traktoren alene 0 l (in-game 15/10: K105 sat af ved P Bredal, F22 meldt "tom for
|
|
-- LIME" med kalk i sprederen, og F25 hentede den straks fyldt).
|
|
-- Sat af puljeredskab: mål på redskabet selv (det kan være løbet tørt, før AutoDrive parkerede det).
|
|
function ADFieldWork.isRefillEmpty(vehicle, assignment, adEnv)
|
|
if assignment.refillFillType == nil then return false end
|
|
if ADCpBridge.getRefillFillType(vehicle, assignment.role) ~= nil then
|
|
return ADCpBridge.getRefillLevel(vehicle, assignment.refillFillType) <= 0
|
|
end
|
|
if adEnv == nil or assignment.pool == nil then return false end
|
|
for _, item in ipairs(assignment.pool.implements or {{id = assignment.pool.implementId}}) do
|
|
local okFind, implement = pcall(ADRunsController.findVehicleById, adEnv, item.id)
|
|
if okFind and implement ~= nil and ADCpBridge.getRefillFillType(implement, assignment.role) ~= nil then
|
|
return ADCpBridge.getRefillLevel(implement, assignment.refillFillType) <= 0
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- Sættet er færdigt: rest til lager (læsse-/aflæsningsvogn), ellers parkering.
|
|
local followHeaderSwap
|
|
|
|
local function finishAssignment(adEnv, assignment)
|
|
local vehicle = assignment.vehicle
|
|
-- skærebord på transporthjul foran: bag på først, så hjem (followHeaderSwap kalder tilbage hertil)
|
|
if not assignment.headerUnmounted then
|
|
local swapState = ADFieldWork.startHeaderSwap(adEnv, assignment, "rear")
|
|
if swapState == "started" then return end
|
|
if swapState == "failed" then
|
|
-- kunne ikke startes: ikke ud på vejen med skærebordet foran
|
|
assignment.headerUnmounted, assignment.manual = true, true
|
|
ADFieldJobs.notify(string.format("F%s: '%s' kunne ikke sætte skærebordet bag på — gør det selv og kør den hjem",
|
|
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle)), true)
|
|
end
|
|
end
|
|
-- høster med plads tilbage i tanken: bliv på marken — næste mark med samme afgrøde kan bruge den (brugerønske
|
|
-- 16/10); kommer ingen inden HARVESTER_LINGER_MS, køres den hjem og spilleren får besked (tickLingering)
|
|
local linger = assignment.role == "harvester" and not assignment.manual and restLoad(adEnv, vehicle) > 0
|
|
and ADFieldWork.tankFullRatio(vehicle) < ADFieldWork.HARVESTER_FULL_RATIO
|
|
if linger then
|
|
ADFieldWork.lingering[assignment.vehicleId] = {vehicle = vehicle, since = now(), fieldId = assignment.fieldId}
|
|
log(assignment.fieldId, "'%s' har %.0f l i tanken — venter op til %d min på næste mark med samme afgrøde", ADRuns.vehicleLabel(vehicle),
|
|
restLoad(adEnv, vehicle), math.floor(ADFieldWork.HARVESTER_LINGER_MS / 60000))
|
|
elseif assignment.role == "harvester" and restLoad(adEnv, vehicle) > 0 then
|
|
-- høster der stadig har korn efter rest-turen: AutoDrive kunne ikke tømme den — sig det tydeligt
|
|
local text = string.format("'%s' har stadig korn i tanken (%.0f l) — tøm den (AutoDrive kunne ikke aflæsse den)",
|
|
ADRuns.vehicleLabel(vehicle), restLoad(adEnv, vehicle))
|
|
log(assignment.fieldId, "%s", text)
|
|
ADFieldJobs.notify(string.format("F%s: %s", tostring(assignment.fieldId), text), true)
|
|
end
|
|
-- tom såmaskine/sprøjte der ikke blev fyldt op: arbejdet er IKKE færdigt — marken må ikke gå videre
|
|
if ADFieldWork.isRefillEmpty(vehicle, assignment, adEnv) then
|
|
local name = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(assignment.refillFillType) or "?"
|
|
ADFieldWork.release(assignment)
|
|
if ADHitch ~= nil then ADHitch.returnHome(adEnv, vehicle) end
|
|
fail(assignment.fieldId, string.format("'%s' er tom for %s — fyld op, så fortsætter marken", ADRuns.vehicleLabel(vehicle), tostring(name)))
|
|
return
|
|
end
|
|
log(assignment.fieldId, "%s '%s' færdig", assignment.role, ADRuns.vehicleLabel(vehicle))
|
|
-- manuel transport: ALDRIG ud på vejen med AutoDrive (skærebordet sidder på) — spilleren henter den
|
|
-- puljeredskab bag traktoren: sæt det af på sin parkering, traktoren hjem (afhænger kun af hvad der hænger
|
|
-- bag, så det virker også efter genindlæsning); ellers som før
|
|
local pooled = ADPool ~= nil and ADPool.shouldReturnHome(assignment) and ADHitch ~= nil
|
|
and ADHitch.returnHome(adEnv, vehicle, function(_, ok, detail)
|
|
if not ok then log(assignment.fieldId, "'%s' kom ikke hjem fra puljen: %s", ADRuns.vehicleLabel(vehicle), tostring(detail)) end
|
|
end)
|
|
-- AD's parkering ved jobslut er slået fra på markopgaver: moden parkerer altid selv (også når AD kørte læssene)
|
|
local park = not pooled and not linger and not assignment.manual and parkMarkerId(adEnv, vehicle) or nil
|
|
if park ~= nil then
|
|
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil)
|
|
-- ikke en høster med korn tilbage (review: den blev ellers hevet tilbage til marken for at tømme); såmaskiner og
|
|
-- sprøjter med rest-sæd/-gødning må gerne tages — de kan bruge resten på næste mark
|
|
if not (assignment.role == "harvester" and restLoad(adEnv, vehicle) > 0) then
|
|
ADFieldWork.markTakeableParkTrip(adEnv, vehicle, park)
|
|
log(assignment.fieldId, "'%s' kører hjem — kan tages af næste mark undervejs", ADRuns.vehicleLabel(vehicle))
|
|
end
|
|
end
|
|
if pooled then log(assignment.fieldId, "'%s' sætter redskabet af og kører hjem", ADRuns.vehicleLabel(vehicle)) end
|
|
-- uden P-plads blev den stående på marken uden et ord (in-game 16/10: Ropa'en efter F94)
|
|
if park == nil and not pooled and not linger and not assignment.manual and not assignment.playerTransport then
|
|
local text = string.format("'%s' har ingen AutoDrive-parkering — bliver på marken (sæt en P-plads, så kører den selv hjem)",
|
|
ADRuns.vehicleLabel(vehicle))
|
|
log(assignment.fieldId, "%s", text)
|
|
ADFieldJobs.notify(string.format("F%s: %s", tostring(assignment.fieldId), text), true)
|
|
end
|
|
if assignment.playerTransport and ADPlayerTransport ~= nil then
|
|
-- ingen parkering: spilleren henter den (pop-up/statusvindue, indtil den er kørt væk fra marken)
|
|
ADPlayerTransport.finished(assignment)
|
|
elseif assignment.manual then
|
|
ADFieldJobs.notify(string.format("F%s høstet — afmontér skærebordet og kør '%s' hjem", tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle)), true)
|
|
end
|
|
restoreToolOffset(assignment)
|
|
assignment.phase = "finished"
|
|
table.insert(ADFieldJobs.finished, assignment)
|
|
ADFieldJobs.state.assignments[assignment.vehicleId] = nil
|
|
end
|
|
|
|
local MANUAL_REASON_TEXT = {
|
|
notThere = "kør den til marken",
|
|
noHeader = "montér skærebordet",
|
|
wrongHeader = "skærebordet kan ikke høste afgrøden — montér det rigtige",
|
|
playerInside = "stig ud, så overtager Smart Pickup",
|
|
}
|
|
|
|
-- Manuel transport: overtag når høsteren står på marken med passende skærebord og spilleren er steget ud
|
|
-- (eller når spilleren trykker "Start nu"); påmind hvert 5. minut indtil da.
|
|
local function followManual(adEnv, field, info, assignment)
|
|
if field == nil or info == nil then return ADFieldWork.release(assignment) end
|
|
if assignment.playerTransport and ADPlayerTransport ~= nil then return ADPlayerTransport.follow(adEnv, field, info, assignment) end
|
|
local vehicle = assignment.vehicle
|
|
local x, z = vehiclePosition(vehicle)
|
|
local atField = #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(x, z, info.verts)
|
|
if not atField and info.markerId ~= nil then
|
|
local wayPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
|
|
atField = wayPoint ~= nil and math.sqrt((wayPoint.x - x) ^ 2 + (wayPoint.z - z) ^ 2) <= ADFieldWork.ARRIVE_DISTANCE
|
|
end
|
|
local forced = ADFieldJobs.takeoverRequested[field.id] == true
|
|
ADFieldJobs.takeoverRequested[field.id] = nil
|
|
-- skærebord på transporthjul skal sidde FORAN (bag mejetærskeren kan det ikke høste)
|
|
local fruits = ADCpBridge.getHarvestFruits(vehicle) or {}
|
|
if ADHeaderSwap ~= nil and ADHeaderSwap.headerPosition(vehicle) == "rear" then fruits = {} end
|
|
local ok, why = ADManualTransport.readiness({atField = atField, fruits = fruits,
|
|
fruit = info.fruitIndex, controlled = isControlledByPlayer(vehicle), forced = forced})
|
|
if ok then
|
|
log(field.id, "overtager '%s'%s", ADRuns.vehicleLabel(vehicle), forced and " (Start nu)" or "")
|
|
return beginWork(adEnv, field, info, assignment)
|
|
end
|
|
local reason = MANUAL_REASON_TEXT[why] or tostring(why)
|
|
note(field.id, {reason = {text = string.format("venter på dig: '%s' — %s", ADRuns.vehicleLabel(vehicle), reason)}})
|
|
if forced then
|
|
ADFieldJobs.notify(string.format("F%s: kan ikke starte '%s' endnu — %s", tostring(field.id), ADRuns.vehicleLabel(vehicle), reason), true)
|
|
elseif ADManualTransport.shouldRemind(assignment.remindedAt, now()) then
|
|
askPlayer(field, info, assignment, false)
|
|
end
|
|
end
|
|
|
|
-- Opsamleren står stille med Courseplay aktiv og fyldes ikke: tæl tiden (bevægelse eller mere last nulstiller).
|
|
local function collectorStillMs(adEnv, assignment, vehicle)
|
|
local speed = vehicle.getLastSpeed ~= nil and vehicle:getLastSpeed() or 0
|
|
local fill = restLoad(adEnv, vehicle) or 0
|
|
if speed > 0.5 or fill > (assignment.stallFill or -1) + 1 then
|
|
assignment.stallSince, assignment.stallFill = nil, fill
|
|
return 0
|
|
end
|
|
assignment.stallSince = assignment.stallSince or now()
|
|
return now() - assignment.stallSince
|
|
end
|
|
|
|
-- Høsterens tank: fyldningsgrad 0..1 (største fyldenhed der hører til combine-spec'en; 0 hvis ukendt).
|
|
ADFieldWork.HARVESTER_FULL_RATIO = 0.95
|
|
ADFieldWork.HARVESTER_FULL_WAIT_MS = 15 * 60 * 1000 -- så længe venter en fuld høster på en tømmevogn
|
|
-- Høsterens tankindhold (filltype med fyld > 0) eller nil når tom.
|
|
function ADFieldWork.tankFillType(vehicle)
|
|
local spec = vehicle.spec_combine
|
|
local index = spec ~= nil and spec.fillUnitIndex or nil
|
|
if index == nil or vehicle.getFillUnitFillLevel == nil or vehicle.getFillUnitFillType == nil then return nil end
|
|
local okLevel, level = pcall(vehicle.getFillUnitFillLevel, vehicle, index)
|
|
-- en lille rest (fx fra spillerens egen kørsel) blokerer ikke en ny afgrøde (review)
|
|
if not okLevel or type(level) ~= "number" or level < ADFieldWork.TANK_MIN_CONTENT_L then return nil end
|
|
local okType, fillType = pcall(vehicle.getFillUnitFillType, vehicle, index)
|
|
return okType and fillType or nil
|
|
end
|
|
|
|
ADFieldWork.TANK_MIN_CONTENT_L = 100 -- under dette regnes høsterens tank for tom (ved afgrøde-tjekket)
|
|
ADFieldWork.HARVESTER_LINGER_MS = 5 * 60 * 1000 -- høster med plads i tanken venter så længe på næste mark før hjem
|
|
ADFieldWork.lingering = {} -- vehicleId -> {vehicle, since, fieldId}
|
|
|
|
function ADFieldWork.tankFullRatio(vehicle)
|
|
local spec = vehicle.spec_combine
|
|
local index = spec ~= nil and spec.fillUnitIndex or nil
|
|
if index == nil or vehicle.getFillUnitFillLevelPercentage == nil then return 0 end
|
|
local ok, ratio = pcall(vehicle.getFillUnitFillLevelPercentage, vehicle, index)
|
|
return ok and type(ratio) == "number" and ratio or 0
|
|
end
|
|
|
|
-- Courseplay stoppede midt i kurset (fx "off track"): start igen fra sidste punkt (ADFieldJobs.shouldRestartCp).
|
|
-- -> true når den blev startet igen (så er opgaven ikke færdig).
|
|
local function restartUnfinishedCp(adEnv, assignment)
|
|
local vehicle = assignment.vehicle
|
|
local okIx, rememberedIx = pcall(function()
|
|
return vehicle.getCpLastRememberedWaypointIx ~= nil and vehicle:getCpLastRememberedWaypointIx() or nil
|
|
end)
|
|
local refillEmpty = ADFieldWork.isRefillEmpty(vehicle, assignment, adEnv)
|
|
local restart = ADFieldJobs.shouldRestartCp({
|
|
rememberedIx = okIx and rememberedIx or nil,
|
|
hasCourse = vehicle.hasCpCourse ~= nil and vehicle:hasCpCourse() == true,
|
|
restarts = assignment.cpRestarts, intended = assignment.cpStopIntended, controlled = isControlledByPlayer(vehicle),
|
|
helper = assignment.helper == true, refillEmpty = refillEmpty,
|
|
collector = assignment.role == "collector" or assignment.role == "baleCollector",
|
|
loaded = assignment.role ~= "harvester" and (restLoad(adEnv, vehicle) or 0) > 0,
|
|
})
|
|
if not restart then return false end
|
|
local okStart, started = pcall(ADCpResume.startAtLast, vehicle)
|
|
if not okStart or not started then return false end
|
|
assignment.cpRestarts = (assignment.cpRestarts or 0) + 1
|
|
assignment.idleSince, assignment.cpRestarting, assignment.cpRestartedAt = nil, now(), now()
|
|
log(assignment.fieldId, "'%s': Courseplay stoppede midt i kurset (waypoint %d) — startes igen fra sidste punkt (%d/%d)",
|
|
ADRuns.vehicleLabel(vehicle), rememberedIx, assignment.cpRestarts, ADFieldJobs.CP_RESTARTS)
|
|
return true
|
|
end
|
|
|
|
-- Så længe venter en arbejdende opgave, mens spilleren sidder i med CP stoppet (kører den fri), før tomgang tæller
|
|
ADFieldWork.PLAYER_SEATED_WAIT_MS = 3 * 60 * 1000
|
|
|
|
local restStore -- defineret under followWorking (bruger chooseStore + pickRestStore)
|
|
local function followWorking(adEnv, field, assignment)
|
|
local vehicle = assignment.vehicle
|
|
if assignment.role == "rake" and field.windrowOffset == nil and now() - assignment.since >= ADFieldWork.WINDROW_MEASURE_MS
|
|
and ADCpBridge.isWorking(vehicle) then
|
|
local offset = ADCpBridge.getWindrowOffset(vehicle)
|
|
note(assignment.fieldId, {windrowOffset = offset or 0})
|
|
log(assignment.fieldId, offset ~= nil and "river lægger skåret %.1f m fra sin kursuslinje (venstre +)" or "river: nedlægningsområde ikke fundet — regner med midten (%.1f m)", offset or 0)
|
|
end
|
|
if ADCpBridge.isWorking(vehicle) or isAdActive(vehicle) then
|
|
assignment.idleSince = nil
|
|
assignment.waitingUnloader = nil -- arbejder igen (fx genstartet af spilleren): ikke længere ventende
|
|
assignment.seenWorking = true
|
|
assignment.cpRestarting = nil
|
|
if assignment.cpRestartedAt ~= nil and now() - assignment.cpRestartedAt >= ADFieldJobs.CP_RESTART_RESET_MS then
|
|
assignment.cpRestarts, assignment.cpRestartedAt = 0, nil
|
|
end
|
|
if assignment.role == "collector" and ADCpBridge.isWorking(vehicle) then
|
|
local okStill, stillMs = pcall(collectorStillMs, adEnv, assignment, vehicle)
|
|
if okStill and ADFieldJobs.collectorStalled({role = assignment.role, stillMs = stillMs}) then
|
|
-- intet at samle op: stop CP; næste tik afslutter som færdig (rest til lager, marken videre)
|
|
assignment.stallSince = nil
|
|
assignment.cpStopIntended = true
|
|
pcall(ADCpBridge.stop, vehicle)
|
|
local text = string.format("'%s' stod stille i %d min uden at samle noget op — opsamlingen stoppes",
|
|
ADRuns.vehicleLabel(vehicle), math.floor(ADFieldJobs.COLLECTOR_STALL_MS / 60000))
|
|
log(assignment.fieldId, "%s", text)
|
|
ADFieldJobs.notify(string.format("F%s: %s", tostring(assignment.fieldId), text), true)
|
|
end
|
|
end
|
|
return
|
|
end
|
|
-- genoptaget efter indlæsning: CP starter asynkront — vent til den kører, før "står stille" betyder færdig
|
|
if assignment.resumed and not assignment.seenWorking then
|
|
if now() - assignment.since > ADFieldWork.START_TIMEOUT_MS then
|
|
ADFieldWork.release(assignment)
|
|
fail(assignment.fieldId, string.format("'%s': Courseplay fortsatte ikke efter genindlæsning", ADRuns.vehicleLabel(vehicle)))
|
|
end
|
|
return
|
|
end
|
|
-- genstartet (restartUnfinishedCp): giv CP tid til at komme i gang; kom den ikke, afsluttes opgaven som før
|
|
if assignment.cpRestarting ~= nil then
|
|
if now() - assignment.cpRestarting < ADFieldJobs.CP_RESTART_GRACE_MS then return end
|
|
assignment.cpRestarting = nil
|
|
assignment.cpRestarts = ADFieldJobs.CP_RESTARTS
|
|
log(assignment.fieldId, "'%s': Courseplay kom ikke i gang igen — opgaven afsluttes", ADRuns.vehicleLabel(vehicle))
|
|
end
|
|
-- spilleren sidder i og kører den fri (et kort stykke slipper ikke sættet, se ovenfor): CP er stoppet, men
|
|
-- opgaven er ikke færdig (in-game 16/10 F39: modulhøsteren kørt fri af et modul blev meldt "færdig" og sendt hjem)
|
|
-- Højst PLAYER_SEATED_WAIT_MS: bliver spilleren siddende efter et færdigt kursus, afsluttes opgaven som før (review)
|
|
if isControlledByPlayer(vehicle) then
|
|
assignment.playerSeatedSince = assignment.playerSeatedSince or now()
|
|
if now() - assignment.playerSeatedSince < ADFieldWork.PLAYER_SEATED_WAIT_MS then
|
|
if not assignment.playerSeatedLogged then
|
|
assignment.playerSeatedLogged = true
|
|
log(assignment.fieldId, "'%s': spilleren sidder i — venter (ikke færdig)", ADRuns.vehicleLabel(vehicle))
|
|
end
|
|
assignment.idleSince = nil
|
|
return
|
|
end
|
|
else
|
|
assignment.playerSeatedSince, assignment.playerSeatedLogged = nil, nil
|
|
end
|
|
assignment.idleSince = assignment.idleSince or now()
|
|
if now() - assignment.idleSince < ADFieldWork.IDLE_CONFIRM_MS then return end
|
|
-- høster med fuld tank: Courseplay stopper og venter på en tømmevogn — det er IKKE færdig (in-game 16/10: F94-
|
|
-- roeoptageren med 161.570 l blev regnet færdig hvert 13. s, startet igen, og tømmevognen blev afbrudt hver gang)
|
|
if assignment.role == "harvester" and vehicle.spec_combine ~= nil then
|
|
local full = ADFieldWork.tankFullRatio(vehicle) >= ADFieldWork.HARVESTER_FULL_RATIO
|
|
local waitedTooLong = assignment.waitingUnloader and now() - (assignment.waitingSince or now()) >= ADFieldWork.HARVESTER_FULL_WAIT_MS
|
|
if full and waitedTooLong then
|
|
-- ingen tømmevogn i tide: sig det, og afslut som før (så marken ikke er låst for evigt)
|
|
assignment.waitingUnloader = nil
|
|
ADFieldJobs.notify(string.format("F%s: '%s' har ventet %d min med fuld tank uden tømmevogn — tøm den selv",
|
|
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle), math.floor(ADFieldWork.HARVESTER_FULL_WAIT_MS / 60000)), true)
|
|
elseif full then
|
|
if not assignment.waitingUnloader then
|
|
assignment.waitingUnloader, assignment.waitingSince = true, now()
|
|
log(assignment.fieldId, "'%s' har fuld tank — venter på en tømmevogn", ADRuns.vehicleLabel(vehicle))
|
|
end
|
|
assignment.idleSince = nil
|
|
return
|
|
elseif assignment.waitingUnloader then
|
|
-- tømt: videre fra sidste punkt (uden om genstart-tælleren — det var ventetid, ikke CP der gik i stå)
|
|
assignment.waitingUnloader = nil
|
|
local okStart, started = pcall(ADCpResume.startAtLast, vehicle)
|
|
if okStart and started then
|
|
assignment.idleSince, assignment.cpRestarting, assignment.cpRestartedAt = nil, now(), now()
|
|
log(assignment.fieldId, "'%s' er tømt — høster videre fra sidste punkt", ADRuns.vehicleLabel(vehicle))
|
|
return
|
|
end
|
|
end
|
|
end
|
|
if restartUnfinishedCp(adEnv, assignment) then return end
|
|
-- kontraktmark: tømmevognen har intet lager fra start (spillets hjælper kører læssene til salgsstedet), men resten skal
|
|
-- stadig afleveres — ellers satte den vognen af med afgrøden (in-game 19/10 F83: 20 % spinat stod i EDK 650'en)
|
|
-- kun høstkontraktens tømmevogne (review: en sprøjte med restgødning på en gødningskontrakt gav ellers falsk besked)
|
|
local contractRest = field ~= nil and field.contract == true and assignment.role == "unloader" and field.contractSellIds ~= nil
|
|
local rest = (assignment.storeId ~= nil or contractRest) and not assignment.deliveredRest and restLoad(adEnv, vehicle) or 0
|
|
if rest > 0 and assignment.role == "harvester" and vehicle.spec_combine ~= nil then
|
|
-- mejetærsker: ikke selv til siloen med resten — røret skal foldes ud og ramme triggeren (og et skærebord på
|
|
-- transporthjul hænger på); bliv, sig til (brugerønske 10/10). Tømmevognen eller spilleren tømmer den
|
|
assignment.deliveredRest = true
|
|
if not assignment.restNoticeGiven then
|
|
assignment.restNoticeGiven = true
|
|
ADFieldJobs.notify(string.format("F%s: '%s' har %.0f l korn tilbage — send en tømmevogn til den eller tøm den selv",
|
|
tostring(assignment.fieldId), ADRuns.vehicleLabel(vehicle), rest), true)
|
|
log(assignment.fieldId, "'%s' har %.0f l rest — mejetærskere kører ikke selv til lager", ADRuns.vehicleLabel(vehicle), rest)
|
|
end
|
|
rest = 0
|
|
end
|
|
if rest > 0 then
|
|
-- CP færdig/stoppet med læs på: AD's parkering ved jobslut er fra på markopgaver, så moden sender resten til lager.
|
|
-- Lageret fra start kan være fyldt siden (in-game 18/10 00:50: Ballesamler 2 med 869.000 l hø til en silo med 7 l fri,
|
|
-- mens Bunker Silo 3C havde 2,5 mio. l fri): vælg igen med hele læsset, ellers det gamle
|
|
assignment.deliveredRest = true
|
|
assignment.idleSince = nil
|
|
local storeId, storeName = restStore(adEnv, field, assignment, vehicle, rest)
|
|
if storeId == nil then
|
|
-- intet sted med AutoDrive-markør (kontraktens salgssted uden markør): sig det, og kør hjem som før
|
|
-- vognen bliver stående med læsset (sættes ikke af med afgrøden), og spilleren kører det derhen
|
|
local text = string.format("'%s' har %.0f l tilbage, men intet salgssted med AutoDrive-markør — kør resten derhen selv",
|
|
ADRuns.vehicleLabel(vehicle), rest)
|
|
log(assignment.fieldId, "%s", text)
|
|
ADFieldJobs.notify(string.format("F%s: %s", tostring(assignment.fieldId), text), true)
|
|
ADFieldWork.release(assignment)
|
|
return
|
|
end
|
|
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DELIVERTO, storeId, nil)
|
|
log(assignment.fieldId, "'%s' kører rest-læs (%.0f l) til lager%s", ADRuns.vehicleLabel(vehicle), rest,
|
|
storeName ~= nil and (" — valgte nyt lager: " .. storeName) or "")
|
|
return
|
|
end
|
|
finishAssignment(adEnv, assignment)
|
|
end
|
|
|
|
-- Rent: lageret til rest-læsset — det nye valg når det findes og er et andet, ellers det gamle.
|
|
-- -> id, skiftet (true når et andet lager valgtes)
|
|
function ADFieldWork.pickRestStore(currentId, chosen)
|
|
if chosen == nil or chosen.id == nil or chosen.id == currentId then return currentId, false end
|
|
return chosen.id, true
|
|
end
|
|
|
|
-- Lageret til rest-læsset: vælg igen med hele læsset (fyldte siloer falder fra). -> id, navn på det nye lager (kun ved skift)
|
|
-- Varen: opgavens egen (hjælper) eller markens for trinnet; ukendt vare -> det gamle lager (review: trinnet kan være skiftet)
|
|
restStore = function(adEnv, field, assignment, vehicle, liters)
|
|
local info = ADFields ~= nil and ADFields.getInfo ~= nil and ADFields.getInfo(assignment.fieldId) or nil
|
|
if info == nil or field == nil then return assignment.storeId, nil end
|
|
-- kontrakt: markens høstafgrøde (marken står på "færdig", så storeFillType gav skårene — review 19/10)
|
|
local okType, fillType = pcall(function()
|
|
return assignment.fillType or (field.contract and info.harvestFillType) or ADFieldWork.storeFillType(field, info)
|
|
end)
|
|
if not okType or fillType == nil then return assignment.storeId, nil end
|
|
local ok, store = pcall(ADFieldWork.chooseStore, adEnv, field, info, vehicle, fillType, liters, true)
|
|
local id, switched = ADFieldWork.pickRestStore(assignment.storeId, ok and store or nil)
|
|
if switched then assignment.storeId = id end
|
|
return id, switched and tostring(store.name) or nil
|
|
end
|
|
|
|
-- Meld en maskine, der allerede kører Courseplay, ind på marken som genoptaget opgave (følges og afsluttes som ellers).
|
|
local function adoptResumed(adEnv, rig, fieldId, stage, what)
|
|
local vehicle = rig.vehicle
|
|
ADFieldJobs.state.assignments[rig.id] = {vehicleId = rig.id, vehicle = vehicle, fieldId = fieldId, role = rig.role,
|
|
stage = stage, helper = false, phase = "working", since = now(), width = rig.width,
|
|
groupSize = 1, leader = true, resumed = true, manual = rig.manual == true}
|
|
-- lager til læssevognens rest, som ved en normal start
|
|
local assignment = ADFieldJobs.state.assignments[rig.id]
|
|
local field, info = ADFieldJobs.getField(fieldId), ADFields.getInfo(fieldId)
|
|
local fillType = nil
|
|
-- kun læssevognen kører selv hjem med læsset; høsteren tømmes af tømmevognene på marken
|
|
if rig.role == "collector" then fillType = ADFieldWork.storeFillType(field, info) end
|
|
if fillType ~= nil then
|
|
local okStore, store = pcall(ADFieldWork.chooseStore, adEnv, field, info, vehicle, fillType)
|
|
if okStore and store ~= nil then assignment.storeId = store.id end
|
|
end
|
|
log(fieldId, "'%s' %s%s", tostring(rig.label), what,
|
|
assignment.storeId ~= nil and "" or (fillType ~= nil and " — intet lager til resten fundet" or ""))
|
|
end
|
|
|
|
-- Genstartet efter indlæsning uden en mark i gang med rollen: så længe venter den på, at en mark kommer i den fase
|
|
ADFieldWork.ORPHAN_CP_MS = 3 * 60 * 1000
|
|
ADFieldWork.ORPHAN_CP_START_GRACE_MS = 30000 -- CP starter asynkront: først derefter betyder "kører ikke" stoppet
|
|
ADFieldWork.orphanCp = {} -- vehicleId -> {vehicle, role, label, points, at}
|
|
|
|
-- Courseplay-maskine genstartet uden mark: kommer marken (i maskinens fase, maskinen eller kursets sidste punkt på
|
|
-- marken), meldes den ind — ellers sendte marken forgæves en anden ud og fik ingen tømmevogn (in-game 16/10: F94
|
|
-- "allBusy — 'Mejetærsker 2': Courseplay kører" hvert minut).
|
|
function ADFieldWork.tickOrphanCp(adEnv)
|
|
if next(ADFieldWork.orphanCp) == nil then return end
|
|
local rigsById = {}
|
|
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do rigsById[rig.id] = rig end
|
|
local fields, stageById = nil, {}
|
|
for vehicleId, entry in pairs(ADFieldWork.orphanCp) do
|
|
local rig = rigsById[vehicleId]
|
|
local age = now() - entry.at
|
|
local working = rig ~= nil and ADCpBridge.isWorking(rig.vehicle)
|
|
if rig == nil or ADFieldJobs.state.assignments[vehicleId] ~= nil or rig.controlled or age >= ADFieldWork.ORPHAN_CP_MS
|
|
or (not working and age >= ADFieldWork.ORPHAN_CP_START_GRACE_MS) then
|
|
ADFieldWork.orphanCp[vehicleId] = nil
|
|
elseif working then
|
|
if fields == nil then
|
|
fields = {}
|
|
for _, info in ipairs(ADFields.list()) do
|
|
local field = ADFieldJobs.getField(info.id)
|
|
if field ~= nil and ADFieldModel.isWorking(field) then
|
|
table.insert(fields, {id = info.id, stage = field.stage, verts = info.verts})
|
|
stageById[info.id] = field.stage
|
|
end
|
|
end
|
|
end
|
|
local fieldId = ADFieldJobs.resumeField(rig.x, rig.z, entry.role, fields, entry.points)
|
|
if fieldId ~= nil then
|
|
ADFieldWork.orphanCp[vehicleId] = nil
|
|
adoptResumed(adEnv, rig, fieldId, stageById[fieldId], "kører allerede Courseplay her — meldes ind på marken")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Efter genindlæsning: spillet stopper alle arbejdere ved gem, og Courseplay genstarter dem ikke (in-game 27/9).
|
|
-- En maskine med CP-kursus og et husket waypoint (CP nulstiller det når kurset er kørt færdigt) var midt i et job:
|
|
-- start den fra sidste waypoint med CP's eget "fortsæt"-job (med gemt liste fra ADCpResume: netop de maskiner
|
|
-- der kørte CP ved gem, fra nærmeste waypoint) (HUD'ens eget startpunkt røres ikke). Står den på en
|
|
-- mark hvis aktuelle trin er maskinens rolle, meldes den ind på marken igen, så den følges og trinnet afsluttes.
|
|
function ADFieldWork.resumeAfterLoad(adEnv)
|
|
-- gemt liste over maskiner hvor CP kørte (ADCpResume): den afgør alene hvem der startes, fra nærmeste waypoint
|
|
local toStart, cpVehicles = nil, {}
|
|
if ADCpResume ~= nil then toStart, cpVehicles = ADCpResume.takeToStart(adEnv) end
|
|
local startSet, handled = {}, {}
|
|
for _, id in ipairs(toStart or {}) do startSet[id] = true end
|
|
local fields, stageById = {}, {}
|
|
for _, info in ipairs(ADFields.list()) do
|
|
local field = ADFieldJobs.getField(info.id)
|
|
if field ~= nil and ADFieldModel.isWorking(field) then
|
|
table.insert(fields, {id = info.id, stage = field.stage, verts = info.verts})
|
|
stageById[info.id] = field.stage
|
|
end
|
|
end
|
|
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do
|
|
local vehicle = rig.vehicle
|
|
local wasWorking = vehicle.startCpAtLastWp ~= nil and vehicle.hasCpCourse ~= nil and vehicle:hasCpCourse()
|
|
and vehicle.getCpLastRememberedWaypointIx ~= nil and vehicle:getCpLastRememberedWaypointIx() ~= nil
|
|
if toStart ~= nil then wasWorking = startSet[rig.id] == true end
|
|
handled[rig.id] = true
|
|
local fieldId, distance, extra = nil, nil, {}
|
|
if wasWorking then
|
|
local okWp, wp = pcall(function()
|
|
local course = ADCpBridge.getCourse(vehicle)
|
|
return course ~= nil and course:getWaypoint(vehicle:getCpLastRememberedWaypointIx()) or nil
|
|
end)
|
|
if okWp and type(wp) == "table" and wp.x ~= nil then
|
|
table.insert(extra, {x = wp.x, z = wp.z})
|
|
distance = math.sqrt((wp.x - rig.x) ^ 2 + (wp.z - rig.z) ^ 2)
|
|
end
|
|
fieldId = ADFieldJobs.resumeField(rig.x, rig.z, rig.role, fields, extra)
|
|
end
|
|
-- puljesæt (traktor med puljeredskab) uden en mark i gang med dens rolle: kurset er fra et afsluttet job — det
|
|
-- genstartes ikke, sættet sendes hjem (in-game 10/10: 6230 TTV 5 med læssevogn fra F13 blev genstartet ved hver
|
|
-- genindlæsning og kørte det gamle kursus hen over F11, der var ved at blive sået)
|
|
local stalePool = wasWorking and toStart ~= nil and fieldId == nil and not rig.busy and not rig.controlled
|
|
and ADHitch ~= nil and ADPool ~= nil and #ADHitch.poolParkIds(adEnv, vehicle) > 0
|
|
if stalePool then
|
|
logInfo(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
|
|
logInfo(ADFieldJobs.LOG_PREFIX .. "'%s' genstartes ikke: husket waypoint fra et gammelt job (%s væk, ikke på en mark i gang)",
|
|
tostring(rig.label), distance ~= nil and string.format("%.0f m", distance) or "ukendt afstand")
|
|
elseif wasWorking and not rig.busy and not rig.controlled then
|
|
local ok, started
|
|
if toStart ~= nil then ok, started = pcall(ADCpResume.startAtLast, vehicle)
|
|
else ok, started = pcall(vehicle.startCpAtLastWp, vehicle) end
|
|
if not ok then
|
|
Logging.warning(ADFieldJobs.LOG_PREFIX .. "'%s' kunne ikke genstartes: %s", tostring(rig.label), tostring(started))
|
|
elseif started then
|
|
if fieldId ~= nil then
|
|
adoptResumed(adEnv, rig, fieldId, stageById[fieldId], "fortsætter efter genindlæsning (Courseplay fra sidste waypoint)")
|
|
else
|
|
-- ingen mark i gang med rollen lige nu (fx F94 stod på "liming" og gik tilbage til høst et sekund
|
|
-- efter, in-game 16/10): husk den kort, så den meldes ind, når marken kommer (tickOrphanCp)
|
|
ADFieldWork.orphanCp[rig.id] = {vehicle = vehicle, role = rig.role, label = rig.label, points = extra, at = now()}
|
|
logInfo(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
|
|
logInfo(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)
|
|
logInfo(ADFieldJobs.LOG_PREFIX .. "'%s' navngivet '%s' (markflåde, %s)", model, name, tostring(rig.role))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Høsten er færdig, men den høster der høstede marken har korn i tanken og står ved marken: start dens CP-job igen
|
|
-- (sidste/nærmeste punkt), så CP venter ved kursets ende til tømmevognene har tømt den. Én gang pr. mark.
|
|
function ADFieldWork.tryEmptyHarvester(adEnv, field, info)
|
|
local vehicleId = field.harvestVehicleId
|
|
if vehicleId == nil or info == nil then return false end
|
|
local rig = nil
|
|
for _, candidate in ipairs(ADFieldWork.getRigs(adEnv)) do
|
|
if candidate.id == vehicleId then rig = candidate break end
|
|
end
|
|
if rig == nil then return false end
|
|
local fill = restLoad(adEnv, rig.vehicle)
|
|
local near = #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(rig.x, rig.z, info.verts)
|
|
if not near and info.markerId ~= nil then
|
|
local wayPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
|
|
near = wayPoint ~= nil and math.sqrt((wayPoint.x - rig.x) ^ 2 + (wayPoint.z - rig.z) ^ 2) <= 100
|
|
end
|
|
if not ADFieldJobs.shouldEmptyHarvester({fill = fill, near = near, busy = rig.busy, controlled = rig.controlled,
|
|
tried = ADFieldJobs.emptyAttempts[field.id] == true}) then
|
|
return false
|
|
end
|
|
ADFieldJobs.emptyAttempts[field.id] = true
|
|
local assignment = {vehicleId = rig.id, vehicle = rig.vehicle, fieldId = field.id, role = "harvester", stage = field.stage,
|
|
helper = false, phase = "driving", since = now(), width = rig.width, groupSize = 1, leader = true,
|
|
manual = rig.manual == true, emptying = true}
|
|
ADFieldJobs.state.assignments[rig.id] = assignment
|
|
log(field.id, "høsten er færdig, men '%s' har %.0f l i tanken — tømmes på marken, før marken går videre", tostring(rig.label), fill)
|
|
beginWork(adEnv, field, info, assignment)
|
|
return true
|
|
end
|
|
|
|
ADFieldWork.taken = {}
|
|
|
|
-- Genoptag maskiner spilleren tog over, når han står af ved marken (én gang pr. tick for hver).
|
|
-- Høstere der venter på næste mark (finishAssignment): fik de en opgave, glemmes de; ellers efter HARVESTER_LINGER_MS
|
|
-- hjem på parkering og besked om at tømme tanken.
|
|
function ADFieldWork.tickLingering(adEnv)
|
|
for vehicleId, entry in pairs(ADFieldWork.lingering) do
|
|
local vehicle = entry.vehicle
|
|
if ADFieldJobs.state.assignments[vehicleId] ~= nil or vehicle == nil or vehicle.rootNode == nil then
|
|
ADFieldWork.lingering[vehicleId] = nil
|
|
elseif isControlledByPlayer(vehicle) or isAdActive(vehicle) then
|
|
ADFieldWork.lingering[vehicleId] = nil -- spilleren eller AD har taget over
|
|
elseif now() - entry.since >= ADFieldWork.HARVESTER_LINGER_MS then
|
|
ADFieldWork.lingering[vehicleId] = nil
|
|
local rest = restLoad(adEnv, vehicle)
|
|
if rest > 0 then
|
|
ADFieldJobs.notify(string.format("F%s: '%s' har stadig %.0f l i tanken og ingen mark med samme afgrøde — tøm den",
|
|
tostring(entry.fieldId), ADRuns.vehicleLabel(vehicle), rest), true)
|
|
end
|
|
local park = parkMarkerId(adEnv, vehicle)
|
|
if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
|
|
log(entry.fieldId, "'%s' fik ingen ny mark — kører hjem", ADRuns.vehicleLabel(vehicle))
|
|
end
|
|
end
|
|
end
|
|
|
|
function ADFieldWork.tickReadopt(adEnv)
|
|
if next(ADFieldWork.taken) == nil then return end
|
|
local rigsById = {}
|
|
for _, rig in ipairs(ADFieldWork.getRigs(adEnv)) do rigsById[rig.id] = rig end
|
|
for vehicleId, entry in pairs(ADFieldWork.taken) do
|
|
local rig = rigsById[vehicleId]
|
|
local field = ADFieldJobs.getField(entry.fieldId)
|
|
local info = ADFields.getInfo(entry.fieldId)
|
|
if rig == nil or field == nil or info == nil or ADFieldJobs.state.assignments[vehicleId] ~= nil then
|
|
ADFieldWork.taken[vehicleId] = nil
|
|
else
|
|
local near = #(info.verts or {}) >= 3 and ADFieldJobs.insidePolygon(rig.x, rig.z, info.verts)
|
|
if not near and info.markerId ~= nil then
|
|
local wayPoint = adEnv.ADGraphManager:getWayPointById(info.markerId)
|
|
near = wayPoint ~= nil and math.sqrt((wayPoint.x - rig.x) ^ 2 + (wayPoint.z - rig.z) ^ 2) <= 100
|
|
end
|
|
-- genoptaget tur ud til marken: vent mens AD kører derud; hænger AD ved markøren, stoppes den (som i "driving")
|
|
local tripActive = false
|
|
if entry.trip ~= nil and isAdActive(rig.vehicle) then
|
|
local module = stateModule(rig.vehicle)
|
|
local marker = module ~= nil and module.getFirstMarker ~= nil and module:getFirstMarker() or nil
|
|
tripActive = marker ~= nil and marker.id == entry.trip.markerId
|
|
if tripActive then
|
|
local wayPoint = adEnv.ADGraphManager:getWayPointById(entry.trip.markerId)
|
|
local distance = wayPoint ~= nil and math.sqrt((wayPoint.x - rig.x) ^ 2 + (wayPoint.z - rig.z) ^ 2) or math.huge
|
|
local speed = rig.vehicle.getLastSpeed ~= nil and rig.vehicle:getLastSpeed() or 0
|
|
local wpLeft = nil
|
|
local dpm = rig.vehicle.ad ~= nil and rig.vehicle.ad.drivePathModule or nil
|
|
if dpm ~= nil and dpm.getWayPoints ~= nil then
|
|
local okWp, wayPoints, current = pcall(dpm.getWayPoints, dpm)
|
|
if okWp and type(wayPoints) == "table" and type(current) == "number" then wpLeft = #wayPoints - current end
|
|
end
|
|
if speed > ADFieldJobs.STALL_SPEED then entry.stillSince = nil elseif entry.stillSince == nil then entry.stillSince = now() end
|
|
if ADFieldJobs.stalledAtTarget({adActive = true, speed = speed, wpLeft = wpLeft, distance = distance,
|
|
stillMs = entry.stillSince ~= nil and now() - entry.stillSince or 0}) then
|
|
log(entry.fieldId, "'%s' holdt stille ved markøren — AutoDrive stoppes, overtages", tostring(rig.label))
|
|
stopAd(rig.vehicle)
|
|
end
|
|
end
|
|
end
|
|
-- genoptaget tur afbrudt undervejs (AD stoppet langt fra marken): glem den, så marken kan få et andet sæt
|
|
if entry.trip ~= nil and not tripActive and not isAdActive(rig.vehicle) and not near then
|
|
ADFieldWork.taken[vehicleId] = nil
|
|
log(entry.fieldId, "'%s' nåede ikke frem (AutoDrive stoppet undervejs) — marken må få et andet sæt", tostring(rig.label))
|
|
else
|
|
local otherWorking = false
|
|
for _, assignment in pairs(ADFieldJobs.state.assignments) do
|
|
-- høstere undtaget (flere mejetærskere på én mark rører vi ikke ved)
|
|
if assignment.fieldId == entry.fieldId and assignment.role == entry.role and entry.role ~= "harvester"
|
|
and (assignment.helper == true) == (entry.helper == true)
|
|
and assignment.vehicleId ~= rig.id and (assignment.phase == "working" or assignment.phase == "starting") then
|
|
otherWorking = true
|
|
end
|
|
end
|
|
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()), otherWorking = otherWorking})
|
|
if action == "forget" then
|
|
ADFieldWork.taken[vehicleId] = nil
|
|
elseif action == "sendHome" then
|
|
ADFieldWork.taken[vehicleId] = nil
|
|
log(entry.fieldId, "'%s' sendes hjem — en anden %s arbejder allerede marken", tostring(rig.label), tostring(entry.role))
|
|
if not (ADHitch ~= nil and ADHitch.returnHome(adEnv, rig.vehicle)) then
|
|
local park = parkMarkerId(adEnv, rig.vehicle)
|
|
if park ~= nil then startAd(adEnv, rig.vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
|
|
end
|
|
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
|
|
|
|
-- 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).
|
|
-- -> true når follow skal stoppe her (ikke videre til followWorking: dens CP-genstart ville skjule, at hjælperen har opgivet)
|
|
local function followGiants(adEnv, assignment, vehicle)
|
|
if not (assignment.giants and not assignment.arrived and assignment.phase == "working" and not ADCpBridge.isWorking(vehicle)) then
|
|
assignment.giantsIdleSince = nil
|
|
return false
|
|
end
|
|
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))
|
|
end
|
|
return true
|
|
end
|
|
|
|
-- Spillets hjælper kører ud til kontraktmarken: fremme, når maskinen står inde på marken (tømmevogne venter til da).
|
|
local function followGiantsArrival(assignment, vehicle)
|
|
if not (assignment.giants and not assignment.arrived) then return end
|
|
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). -> true når sættet er sluppet
|
|
local function followPlayerTakeover(assignment, vehicle)
|
|
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()}
|
|
ADFieldWork.release(assignment)
|
|
return true
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- 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 function fetchFailed(adEnv, assignment, vehicle, hitch)
|
|
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
|
|
end
|
|
|
|
-- Koblet på: variabel bredde stilles (Unrealistic), sammenfoldet til vejen, bredden måles med redskabet på. Passer
|
|
-- redskabet ikke, sættes det tilbage; tom såmaskine/sprøjte fyldes op på vejen (uden påfyldning køres den hjem igen).
|
|
local function fetchDone(adEnv, field, info, assignment, vehicle)
|
|
local okVar, errVar = pcall(ADCpBridge.setVariableWidth, vehicle)
|
|
if not okVar then Logging.warning("ADSmartPickup: bredde: %s", tostring(errVar)) end
|
|
pcall(ADHitch.foldForTransport, vehicle)
|
|
local width = ADCpBridge.getWorkWidth(vehicle, assignment.role)
|
|
-- skærebord på transporthjul bag mejetærskeren: arbejdsbredden måles først, når det sidder foran
|
|
if assignment.headerSwap ~= nil and (width or 0) < ADFieldModel.MIN_WORK_WIDTH then width = assignment.width end
|
|
local okWidth, widthReason, widthArgs = ADFieldModel.checkWidth(assignment.role, width, ADFieldModel.requiredWidth(field, assignment.role))
|
|
if not okWidth then
|
|
-- redskabet passer ikke til opgaven: karantæne, ellers hentes det igen og igen (in-game 6/10: Servo 25 til F9)
|
|
log(assignment.fieldId, "%s: '%s' med '%s' passer ikke (%s, bredde %.1f m) — redskabet sættes tilbage og prøves ikke foreløbig",
|
|
tostring(assignment.role), ADRuns.vehicleLabel(vehicle), tostring(assignment.pool.implementName), tostring(widthReason), tonumber(width) or -1)
|
|
for _, item in ipairs(assignment.pool.implements or {{id = assignment.pool.implementId}}) do
|
|
ADPool.quarantine(item.id, now())
|
|
end
|
|
ADFieldWork.release(assignment)
|
|
note(assignment.fieldId, {retryAt = now() + ADFieldModel.RETRY_MS, reason = {key = "spu_field_reason_" .. tostring(widthReason), role = assignment.role, args = widthArgs}})
|
|
ADHitch.returnHome(adEnv, vehicle)
|
|
return
|
|
end
|
|
-- som almindelig udsendelse: tom såmaskine/sprøjte fyldes op på vejen, uden påfyldning køres den hjem igen
|
|
local refill = refillPlan(adEnv, assignment.fieldId, vehicle, assignment.role, info.x, info.z)
|
|
local nextDrive = ADPool.nextDrive(refill)
|
|
if nextDrive == "empty" and startPalletRefill(adEnv, assignment, vehicle, refill.fillType, assignment.pool.implementName) then
|
|
assignment.width = width
|
|
return
|
|
end
|
|
if nextDrive == "empty" then
|
|
ADFieldWork.release(assignment)
|
|
ADHitch.returnHome(adEnv, vehicle)
|
|
fail(assignment.fieldId, string.format("'%s' er tom for %s og der er ingen påfyldning med AutoDrive-markør — fyld den op",
|
|
tostring(assignment.pool.implementName), fillTypeName(refill.fillType)))
|
|
return
|
|
end
|
|
assignment.width, assignment.phase, assignment.since = width, "driving", now()
|
|
assignment.startX, assignment.startZ = vehiclePosition(vehicle)
|
|
if nextDrive == "load" then
|
|
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_LOAD, info.markerId, refill.refillId, refill.fillType)
|
|
assignment.drive = {mode = adEnv.AutoDrive.MODE_LOAD, first = info.markerId, second = refill.refillId, fillType = refill.fillType}
|
|
else
|
|
startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, info.markerId, nil)
|
|
assignment.drive = {mode = adEnv.AutoDrive.MODE_DRIVETO, first = info.markerId}
|
|
end
|
|
note(assignment.fieldId, {reason = false})
|
|
log(assignment.fieldId, "%s '%s' har '%s' på — kører til %s (%.1f m)", assignment.role, ADRuns.vehicleLabel(vehicle),
|
|
tostring(assignment.pool.implementName), tostring(info.markerName), width or 0)
|
|
end
|
|
|
|
-- Fase "fetching": traktoren henter et puljeredskab (ADHitch melder i assignment.hitch, når koblingen er afgjort).
|
|
local function followFetching(adEnv, field, info, assignment, vehicle)
|
|
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 return fetchFailed(adEnv, assignment, vehicle, hitch) end
|
|
fetchDone(adEnv, field, info, assignment, vehicle)
|
|
end
|
|
|
|
-- AD hænger ved markmarkøren (aktiv, stille ved et af de sidste vejpunkter): stop den, så marken går i gang.
|
|
local function stopIfStalled(adEnv, assignment, vehicle, info, px, pz, targetDistance)
|
|
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
|
|
end
|
|
|
|
-- AutoDrive er stoppet: fremme ved marken -> skærebord/arbejde; ellers ingen rute, kør videre, eller opgiv og kør hjem.
|
|
local function afterDrive(adEnv, field, info, assignment, vehicle)
|
|
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
|
|
|
|
-- Fase "driving": AutoDrive kører sættet til marken (evt. via påfyldning). Spilleren kan holde pause eller tage over.
|
|
local function followDriving(adEnv, field, info, assignment, vehicle)
|
|
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 adState = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
|
local firstMarker = adState ~= nil and adState.getFirstMarker ~= nil and adState: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
|
|
if isAdActive(vehicle) then return stopIfStalled(adEnv, assignment, vehicle, info, px, pz, targetDistance) end
|
|
assignment.stillSince = nil
|
|
if now() - assignment.since > 2000 then afterDrive(adEnv, field, info, assignment, vehicle) end
|
|
end
|
|
|
|
-- Fase "palletRefill": fyldes fra paller (ADPalletRefill); færdig -> AutoDrive til marken.
|
|
local function followPalletRefill(adEnv, field, info, assignment, vehicle)
|
|
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
|
|
end
|
|
|
|
-- Fase "unfolding": udfoldet (eller 20 s gået): mål og start.
|
|
local function followUnfolding(adEnv, field, info, assignment, vehicle)
|
|
if ADCpBridge.variableWidthUnfolded(vehicle) or now() - assignment.since > ADFieldWork.UNFOLD_WAIT_MS then
|
|
assignment.unfoldedForWidth = true
|
|
beginWork(adEnv, field, info, assignment)
|
|
end
|
|
end
|
|
|
|
-- Fase "waitingCourse": multi-tool-følger venter på lederens kursus.
|
|
local function followWaitingCourse(adEnv, field, info, assignment, vehicle)
|
|
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
|
|
end
|
|
|
|
-- Fase "starting": Courseplay er bedt om at starte (kursus lægges asynkront).
|
|
local function followStarting(adEnv, field, info, assignment, vehicle)
|
|
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
|
|
end
|
|
|
|
-- Fase "working": bredde-vagt (variabel bredde må ikke springe tilbage), og så arbejdets forløb.
|
|
local function followWorkingPhase(adEnv, field, info, assignment, vehicle)
|
|
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)
|
|
end
|
|
|
|
-- Fase "queuedSwap": den anden mejetærsker høster nu: hent skærebordet og kør ud.
|
|
local function followQueuedSwap(adEnv, field, info, assignment, vehicle)
|
|
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
|
|
|
|
-- fase -> opfølgning(adEnv, field, info, assignment, vehicle)
|
|
local PHASE_FOLLOW = {
|
|
fetching = followFetching,
|
|
driving = followDriving,
|
|
palletRefill = followPalletRefill,
|
|
unfolding = followUnfolding,
|
|
waitingCourse = followWaitingCourse,
|
|
starting = followStarting,
|
|
working = followWorkingPhase,
|
|
awaitingPlayer = function(adEnv, field, info, assignment) followManual(adEnv, field, info, assignment) end,
|
|
mountingHeader = function(adEnv, field, info, assignment) followHeaderSwap(adEnv, field, info, assignment) end,
|
|
unmountingHeader = function(adEnv, field, info, assignment) followHeaderSwap(adEnv, field, info, assignment) end,
|
|
queuedSwap = followQueuedSwap,
|
|
}
|
|
|
|
function ADFieldWork.follow(adEnv, assignment)
|
|
local vehicle = assignment.vehicle
|
|
if followGiants(adEnv, assignment, vehicle) then return end
|
|
followGiantsArrival(assignment, vehicle)
|
|
if followPlayerTakeover(assignment, vehicle) then return end
|
|
local field = ADFieldJobs.getField(assignment.fieldId)
|
|
local info = ADFields.getInfo(assignment.fieldId)
|
|
wake(vehicle)
|
|
local followPhase = PHASE_FOLLOW[assignment.phase]
|
|
if followPhase ~= nil then return followPhase(adEnv, field, info, assignment, vehicle) end
|
|
end
|
|
|
|
-- Høsten er færdig: aflæsningsvognene stoppes; har de rest, kører den til lager, ellers parkering.
|
|
function ADFieldWork.windDownHelpers(adEnv, fieldId, stage)
|
|
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(fieldId)) do
|
|
if assignment.helper and assignment.stage == stage and assignment.phase == "fetching" then
|
|
-- høsten sluttede mens puljevognen blev hentet: afbryd, vognen tilbage hvis den nåede at komme på
|
|
local vehicle = assignment.vehicle
|
|
ADFieldWork.release(assignment)
|
|
if not ADHitch.returnHome(adEnv, vehicle) then
|
|
local park = parkMarkerId(adEnv, vehicle)
|
|
if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
|
|
end
|
|
log(fieldId, "tømmevogn '%s' afbrudt under hentning — høsten er færdig", ADRuns.vehicleLabel(vehicle))
|
|
elseif assignment.helper and assignment.stage == stage and not assignment.deliveredRest then
|
|
-- deliveredRest: allerede på vej med rest-læsset (AutoDrive er et AI-job; et nyt stop afbrød turen —
|
|
-- in-game 16/10 F38 blev stoppet to gange, 14:02 og 14:03, med 'Tømmevogn 3' på vej til siloen)
|
|
if assignment.handle ~= nil then assignment.handle.cancelled = true end
|
|
assignment.cpStopIntended = true
|
|
ADCpBridge.stop(assignment.vehicle)
|
|
assignment.phase = "working"
|
|
assignment.idleSince = nil
|
|
log(fieldId, "aflæsningsvogn '%s' stoppes — høsten er færdig", ADRuns.vehicleLabel(assignment.vehicle))
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Stop alle markarbejdets opgaver (Stop alt og parkér). Returnerer {{vehicle, manual}}; markernes trin bevares,
|
|
-- så arbejdet fortsætter efter pausen.
|
|
function ADFieldWork.stopAllAssignments(adEnv)
|
|
local stopped = {}
|
|
local list = {}
|
|
for _, assignment in pairs(ADFieldJobs.state.assignments) do table.insert(list, assignment) end
|
|
for _, assignment in ipairs(list) do
|
|
if assignment.playerTransport and assignment.phase == "awaitingPlayer" then
|
|
-- venter på spilleren: intet kører (og et frakoblet redskab er ingen traktor) — bare slip opgaven
|
|
ADFieldWork.release(assignment)
|
|
else
|
|
pcall(stopAd, assignment.vehicle)
|
|
pcall(ADCpBridge.stop, assignment.vehicle)
|
|
ADHitch.stow(assignment.vehicle, "stop alt")
|
|
ADFieldWork.release(assignment)
|
|
-- puljeredskab: sættes af på sin plads og traktoren kører hjem (i stedet for almindelig parkering)
|
|
local okPool, pooled = pcall(ADHitch.returnHome, adEnv, assignment.vehicle)
|
|
table.insert(stopped, {vehicle = assignment.vehicle, manual = assignment.manual == true, pooled = okPool and pooled == true})
|
|
end
|
|
end
|
|
return stopped
|
|
end
|
|
|
|
function ADFieldWork.stopAll(adEnv, fieldId)
|
|
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(fieldId)) do
|
|
if assignment.playerTransport and assignment.phase == "awaitingPlayer" then
|
|
ADFieldWork.release(assignment)
|
|
else
|
|
ADFieldWork.stopOne(adEnv, assignment)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Stop ét sæt på marken: AutoDrive/Courseplay af, redskabet foldes, puljeredskab sættes af (ellers hjem).
|
|
function ADFieldWork.stopOne(adEnv, assignment)
|
|
pcall(stopAd, assignment.vehicle)
|
|
ADCpBridge.stop(assignment.vehicle)
|
|
ADHitch.stow(assignment.vehicle, "marken stoppet")
|
|
local wasFetching = assignment.phase == "fetching"
|
|
ADFieldWork.release(assignment)
|
|
local okHome, pooled = pcall(ADHitch.returnHome, adEnv, assignment.vehicle)
|
|
if wasFetching and not (okHome and pooled) then
|
|
local park = parkMarkerId(adEnv, assignment.vehicle)
|
|
if park ~= nil then pcall(startAd, adEnv, assignment.vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end
|
|
end
|
|
end
|
|
|
|
-- til ADPlayerTransport (spillerkørsel): samme opstart, besked og påfyldningsplan som de øvrige sæt
|
|
ADFieldWork.beginWork = beginWork
|
|
ADFieldWork.askPlayer = askPlayer
|
|
ADFieldWork.refillPlan = refillPlan
|
|
ADFieldWork.vehiclePosition = vehiclePosition
|
|
ADFieldWork.isControlledByPlayer = isControlledByPlayer
|