Files
fs25-adsmartpickup/FS25_ADSmartPickup/adFieldJobs.lua
T

682 lines
35 KiB
Lua
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
-- AD Field Jobs
-- Markarbejdets job-løkke (hvert sekund): opdater markerne, start kæder og pleje, beslut hvilke sæt der
-- skal ud, og gå videre til næste trin. decide() er ren og testet; udsendelse og opfølgning af sættene
-- (AutoDrive/Courseplay) ligger i adFieldWork. Alt spil-nært er pcall'et pr. mark og pr. sæt.
ADFieldJobs = {}
ADFieldJobs.LOG_PREFIX = "ADSmartPickup: "
ADFieldJobs.TICK_MS = 1000
-- én mark scannes hvert andet sekund; passive marker (manuelle, uden mål) vurderes i ti portioner
ADFieldJobs.PASSIVE_SLICES = 10
-- tidsmåling: tager et tick mere end dette, skrives det i loggen (højst én gang pr. minut)
ADFieldJobs.SLOW_TICK_MS = 3
ADFieldJobs.tickCount = 0
-- Courseplay kan efterlade hjørner på skæve marker: efter så mange færdige ture pr. sæt går marken videre.
ADFieldJobs.MAX_PASSES = 2
-- fleetMode: "all" = alle ledige maskiner (standard, "vælg og glem"), "ticked" = kun med flueben
-- courseRecords: vehicleId -> post i kursus-registret (ADCourseCache)
-- manual: {[vehicleId] = true} = høstere spilleren selv kører til marken (for brede til vejene)
ADFieldJobs.state = {fields = {}, fleet = {}, excluded = {}, assignments = {}, fleetMode = "all", courseRecords = {}, manual = {}}
-- mark-id -> {mower = kursus, rake = kursus, <trin> = fælles multi-tool-kursus}: kopier (kun i hukommelsen;
-- efter genindlæsning hentes slå-/rivekurset fra maskinen, som CP selv gemmer kurset på)
ADFieldJobs.courses = {}
ADFieldJobs.finished = {}
-- starter halvt forskudt, så markarbejdet og menuens opdatering (begge hvert sekund) ikke rammer samme frame
ADFieldJobs.timer = 500
ADFieldJobs.now = 0
ADFieldJobs.loaded = false
-- awaitingPlayer: høster med manuel transport, spilleren kører den til marken (tæller som i gang)
ADFieldJobs.ACTIVE_PHASES = {fetching = true, driving = true, starting = true, waitingCourse = true, unfolding = true, working = true, awaitingPlayer = true,
mountingHeader = true, unmountingHeader = true, queuedSwap = true}
-- Hovedsæt, hvor tømmevognene venter hjemme: spilleren kører høsteren ud, eller mejetærskeren henter/monterer sit
-- skærebord på transporthjul (in-game 10/10: tømmevognen holdt ved F14's markør, så mejetærskeren ikke kunne komme
-- ind og montere skærebordet).
function ADFieldJobs.holdsHelpers(assignment)
local phase = assignment.phase
if phase == "awaitingPlayer" or phase == "mountingHeader" or phase == "queuedSwap" or phase == "unmountingHeader" then return true end
return assignment.headerSwap ~= nil and (phase == "fetching" or phase == "driving")
end
-- Andel græs i mellemhøjde (høstbart, men halv ydelse) der får en afbrudt slåning til at vente.
ADFieldJobs.REGROW_RATIO = 0.1
-- Trin efter høsten der ødelægger/ignorerer en stående afgrøde.
-- Klargøring der kan måles på jorden: trin -> info-felt (andel af marken). Kultivering er gjort når jorden er
-- klargjort (kultiveret/pløjet/såbed/stubbearbejdet); pløjning først når den er pløjet.
ADFieldJobs.GROUND_PREP_STAGES = {cultivating = "prepared", plowing = "plowed"}
ADFieldJobs.PREPARED_DONE_RATIO = 0.95
ADFieldJobs.POST_MOW_STAGES = {tedding = true, raking = true, collecting = true}
ADFieldJobs.PREP_STAGES = {strawCollecting = true, baling = true, baleCollecting = true, mulching = true, liming = true,
plowing = true, cultivating = true, sowing = true, rolling = true}
-- ---- ren beslutning ----
-- Er afgrøden taget (trin med afgrøde)? Slåning: under 50 % står. Høst: marken er bar, eller under 5 % af HELE
-- marken står (rester i hjørnerne). readyRatio regner kun med den afgrøde der er tilbage, så en halvt høstet mark
-- lignede "væk" (in-game 27/9 F111 gik til kultivering med halvdelen stående).
ADFieldJobs.HARVEST_DONE_RATIO = 0.05
local function cropGone(stage, info, finished)
if info == nil then return false end
-- slåning: lav klar-andel er også ung/voksende græs. Uden en klipper der har kørt, skal marken stå som slået
-- (in-game 8/10 savegame6: F5-F8+F13 startede slåning og gik videre til vending/opsamling ét sekund efter,
-- uden at blive slået — læssevogne sendt ud på uslåede marker)
if stage == "mowing" and (finished or 0) == 0 and (info.phase == "growing" or info.phase == "ready") then return false end
if stage == "harvesting" and info.kind == "bare" then return true end
if stage == "harvesting" and type(info.standingRatio) == "number" then
return info.standingRatio < ADFieldJobs.HARVEST_DONE_RATIO
end
return (info.readyRatio or 0) < ADFieldModel.CUT_RATIO
end
-- Ligger (x, z) inden for omridset? (lige-ulige-reglen; kanten tæller som inde)
-- Kursets startpunkt inde på marken: står maskinen uden for marken (fx ved F-markøren ude ved vejen), lægger Courseplay
-- ellers kursets start uden for marken og kører ad vejen (in-game 10/10 F14). -> punktet på markkanten nærmest (x, z),
-- flyttet inset meter ind mod (cx, cz). Står maskinen allerede på marken: (x, z).
function ADFieldJobs.startInsideField(verts, x, z, cx, cz, inset)
if verts == nil or #verts < 3 or ADFieldJobs.insidePolygon(x, z, verts) then return x, z end
local bestX, bestZ, bestD = nil, nil, math.huge
for index = 1, #verts do
local a, b = verts[index], verts[index % #verts + 1]
local dx, dz = b.x - a.x, b.z - a.z
local len2 = dx * dx + dz * dz
local t = len2 > 0 and math.max(0, math.min(1, ((x - a.x) * dx + (z - a.z) * dz) / len2)) or 0
local px, pz = a.x + t * dx, a.z + t * dz
local d = (px - x) ^ 2 + (pz - z) ^ 2
if d < bestD then bestX, bestZ, bestD = px, pz, d end
end
if bestX == nil then return x, z end
local vx, vz = (cx or bestX) - bestX, (cz or bestZ) - bestZ
local len = math.sqrt(vx * vx + vz * vz)
if len < 1e-6 then return bestX, bestZ end
local step = math.min(inset or 15, len)
return bestX + vx / len * step, bestZ + vz / len * step
end
function ADFieldJobs.insidePolygon(x, z, verts)
local inside, j = false, #verts
for i = 1, #verts do
local a, b = verts[i], verts[j]
if (a.z > z) ~= (b.z > z) and x <= (b.x - a.x) * (z - a.z) / (b.z - a.z) + a.x then inside = not inside end
j = i
end
return inside
end
-- Efter genindlæsning: marken en CP-maskine står på, hvis markens aktuelle trin er maskinens rolle (ellers nil).
-- fields = {{id, stage, verts = {{x, z}}}}
-- Afstand fra (x, z) til omridsets kant.
function ADFieldJobs.distanceToPolygon(x, z, verts)
local best, j = math.huge, #verts
for i = 1, #verts do
local a, b = verts[j], verts[i]
local dx, dz = b.x - a.x, b.z - a.z
local len2 = dx * dx + dz * dz
local t = len2 > 0 and math.max(0, math.min(1, ((x - a.x) * dx + (z - a.z) * dz) / len2)) or 0
best = math.min(best, math.sqrt((a.x + t * dx - x) ^ 2 + (a.z + t * dz - z) ^ 2))
j = i
end
return best
end
-- Det skannede omrids er grovt (4-6 hjørner), og en læssevogn på forageren står ofte lige uden for det
-- (in-game 6/10: 6230 TTV 3+4 på F7 blev ikke genkendt efter genindlæsning, og F7 fik en 3. læssevogn).
-- Derfor: maskinen ELLER dens huskede CP-waypoint (extra) inde på marken, ellers nærmeste mark inden for margen.
ADFieldJobs.RESUME_FIELD_MARGIN_M = 40
function ADFieldJobs.resumeField(x, z, role, fields, extra)
local points = {{x = x, z = z}}
for _, p in ipairs(extra or {}) do table.insert(points, p) end
local candidates = {}
for _, field in ipairs(fields or {}) do
if #(field.verts or {}) >= 3 and ADFieldModel.roleFor(field.stage) == role then table.insert(candidates, field) end
end
for _, p in ipairs(points) do
for _, field in ipairs(candidates) do
if ADFieldJobs.insidePolygon(p.x, p.z, field.verts) then return field.id end
end
end
local best, bestDistance = nil, ADFieldJobs.RESUME_FIELD_MARGIN_M
for _, field in ipairs(candidates) do
local d = ADFieldJobs.distanceToPolygon(x, z, field.verts)
if d <= bestDistance then best, bestDistance = field.id, d end
end
return best
end
-- Hvor Courseplay skal starte i kurset: "last" (eget kursus + husket waypoint = fortsæt præcis), "nearest"
-- (marken er allerede delvist høstet/slået), ellers "first". CP's eget standardvalg er "first" — også på en
-- halvt høstet mark (in-game 27/9: mejetærskeren startede F111 forfra).
-- s = {reuse, remembered, stage, standingRatio}
ADFieldJobs.PARTLY_DONE_RATIO = 0.95
function ADFieldJobs.startAtFor(s)
if s.reuse and s.remembered then return "last" end
local cropStage = s.stage == "harvesting" or s.stage == "mowing"
if cropStage and type(s.standingRatio) == "number" and s.standingRatio < ADFieldJobs.PARTLY_DONE_RATIO then return "nearest" end
return "first"
end
-- Skal en maskine med husket CP-waypoint genstartes efter indlæsning? Kun hvis den stadig er midt i jobbet: den
-- står på en mark der er i gang med dens trin (fieldId), eller den står lige ved sit huskede waypoint. Et husket
-- waypoint fra et gammelt job sendte ellers maskinen ud ad vejene (in-game 27/9: to ROPA'er). s = {fieldId, distance}
ADFieldJobs.RESUME_NEAR_M = 30
function ADFieldJobs.shouldResume(s)
if s.fieldId ~= nil then return true end
return type(s.distance) == "number" and s.distance <= ADFieldJobs.RESUME_NEAR_M
end
-- Højst én maskine sendt ud pr. DISPATCH_GAP_MS på tværs af alle marker (in-game 27/9: 6 maskiner kørte fra
-- parkeringen i samme sekund efter Start alle).
-- Justerbart pr. savegame (brugerønske 6/10): få maskiner kan nøjes med 1–5 s, mange har brug for 30 s eller mere.
ADFieldJobs.DISPATCH_GAP_CHOICES = {1, 5, 10, 15, 20, 30, 45, 60} -- sekunder
ADFieldJobs.DISPATCH_GAP_DEFAULT_S = 15
ADFieldJobs.DISPATCH_GAP_MS = ADFieldJobs.DISPATCH_GAP_DEFAULT_S * 1000
-- Gyldigt valg (sekunder) eller standarden.
function ADFieldJobs.normalizeDispatchGap(seconds)
for _, s in ipairs(ADFieldJobs.DISPATCH_GAP_CHOICES) do
if s == seconds then return s end
end
return ADFieldJobs.DISPATCH_GAP_DEFAULT_S
end
function ADFieldJobs.dispatchGapMs()
return ADFieldJobs.normalizeDispatchGap(ADFieldJobs.state ~= nil and ADFieldJobs.state.dispatchGapS or nil) * 1000
end
function ADFieldJobs.mayDispatch(now, lastAt, gapMs)
return lastAt == nil or now - lastAt >= (gapMs or ADFieldJobs.dispatchGapMs())
end
function ADFieldJobs.setDispatchGap(seconds)
ADFieldJobs.state.dispatchGapS = ADFieldJobs.normalizeDispatchGap(seconds)
ADFieldJobs.save()
end
function ADFieldJobs.assignmentCount()
local count = 0
for _ in pairs(ADFieldJobs.state.assignments) do count = count + 1 end
return count
end
-- Har Courseplay-starten taget for lang tid? Mens CP beregner kursus (store marker), må det tage op til
-- COURSE_GENERATE_MS; ellers START_MS (in-game 27/9 F90: 140 ha tog over 60 s, og moden opgav midt i beregningen).
ADFieldJobs.START_MS = 60000
ADFieldJobs.COURSE_GENERATE_MS = 300000
function ADFieldJobs.startTimedOut(elapsed, generating)
return elapsed > (generating and ADFieldJobs.COURSE_GENERATE_MS or ADFieldJobs.START_MS)
end
-- Høsten er færdig, men høsteren har korn i tanken: tøm den på marken før marken går videre (én gang pr. mark).
-- s = {fill, near, busy, controlled, tried}
ADFieldJobs.emptyAttempts = {}
-- Genoptag efter spilleren: en maskine moden frigav fordi spilleren kørte den. s = {controlled, busy, near,
-- sameStage, hasRole, ageMs} -> "readopt" | "wait" | "forget" (in-game 4/10: Vario 2 kørt uden om en forhindring
-- og parkeret ved F14 — moden sendte i stedet en anden tømmevogn)
ADFieldJobs.READOPT_MAX_MS = 1800000
function ADFieldJobs.readoptAction(s)
if s.busy or not s.sameStage or not s.hasRole or (s.ageMs or 0) > ADFieldJobs.READOPT_MAX_MS then return "forget" end
if s.controlled or not s.near then return "wait" end
return "readopt"
end
-- Den erstatning (samme mark/rolle) der skal hjem igen, når den genoptagne maskine overtager: kun én der endnu
-- ikke arbejder. assignments = liste {phase, helper}; -> indeks eller nil
function ADFieldJobs.replacementToCancel(assignments, helper)
for index, assignment in ipairs(assignments or {}) do
if assignment.helper == helper and assignment.phase ~= "working" and assignment.phase ~= "starting" then return index end
end
return nil
end
function ADFieldJobs.shouldEmptyHarvester(s)
return (s.fill or 0) > 0 and s.near == true and not s.busy and not s.controlled and not s.tried
end
-- Markens punkt nærmest (x, z) — CP bruger det som kursets startsted. Uden position: første punkt.
function ADFieldJobs.nearestPoint(points, x, z)
if points == nil or points[1] == nil then return nil end
if x == nil or z == nil then return points[1] end
local best, bestD = nil, nil
for _, point in ipairs(points) do
local d = (point.x - x) ^ 2 + (point.z - z) ^ 2
if bestD == nil or d < bestD then best, bestD = point, d end
end
return best
end
-- Beslutning for én mark. assignments = sæt på marken ({phase, stage, helper}); kun sæt på det aktuelle
-- trin tæller (en aflæsningsvogn på vej hjem fra høsten forstyrrer ikke kultiveringen).
-- env = {raining = bool}: vejrfølsomme trin (høst/slå/vend/riv/hø) sendes ikke ud i regn.
-- Svar: {action = "start"|"care"|"advance"|"dispatch"|"wait"|"none", role, count, helper, stage, care, reason}.
function ADFieldJobs.decide(field, info, assignments, now, env)
local hasMarker = info ~= nil and info.markerId ~= nil
local raining = env ~= nil and env.raining == true
local period = env ~= nil and env.period or nil
local kind = field.kind or (info ~= nil and info.kind) or "mowable"
if field.stage == "ready" then
if not ADFieldModel.shouldStart(field) then return {action = "none"} end
if not hasMarker then return {action = "wait"} end
local first = ADFieldModel.workStages(field.plan, info.kind, info.needs)[1]
if ADFieldModel.isOutOfSeason(first, period) then return {action = "wait", reason = "winter"} end
if raining and first ~= nil and ADFieldModel.isWeatherSensitive(first, field.plan, info.kind) then
return {action = "wait", reason = "rain"}
end
return {action = "start"}
end
-- mål-afgrøde på en bar mark: klargør straks; såningen venter selv på såtiden
if info ~= nil and info.kind == "bare" and field.plan.targetFruit ~= nil and field.plan.targetFruit ~= "" then
if ADFieldModel.shouldStartBare(field, "bare") then
if not hasMarker then return {action = "wait"} end
return {action = "start"}
end
end
-- klargøring på en mark hvor afgrøden står uhøstet: tilbage til klar (in-game 27/9 F16: kartofler
-- blev regnet som høstet, og marken stod til kultivering med afgrøden i jorden)
local standing = info ~= nil and type(info.standingRatio) == "number" and info.standingRatio >= ADFieldJobs.HARVEST_DONE_RATIO
if ADFieldJobs.PREP_STAGES[field.stage] and info ~= nil and info.kind == "harvest" and info.phase == "ready"
and (standing or (info.readyRatio or 0) >= ADFieldModel.READY_RATIO) then
return {action = "rewind"}
end
-- samme for slåmarker: klargøring/såning på en mark med moden græs (in-game 8/10 demo F52/F53: gemt som bar
-- mark på såning, men græsset stod klar til slåning). Ikke ved slå-og-så-om, hvor græsset gror igen undervejs.
if ADFieldJobs.PREP_STAGES[field.stage] and info ~= nil and info.kind == "mowable" and not field.plan.prepAfterMow
and (info.readyRatio or 0) >= ADFieldModel.READY_RATIO then
return {action = "rewind"}
end
-- vend/riv/saml op på en mark med uslået, modent græs: slå først (in-game 8/10 savegame6 F13: gemt på opsamling,
-- græsset vokset op igen -> læssevogn sendt ud på uslået mark). Lige efter slåning er klar-andelen under 50 %.
if ADFieldJobs.POST_MOW_STAGES[field.stage] and info ~= nil and info.kind == "mowable"
and (info.readyRatio or 0) >= ADFieldModel.READY_RATIO then
return {action = "rewind"}
end
if not ADFieldModel.isWorking(field) then
local care = ADFieldModel.careNeed(field, info)
if care == nil then return {action = "none"} end
if field.plan.mode ~= "auto" and not field.startRequested then return {action = "none", care = care} end
if not hasMarker then return {action = "wait", care = care} end
return {action = "care", stage = care}
end
local active, finished, helpers, awaiting = 0, 0, 0, 0
for _, assignment in ipairs(assignments) do
if assignment.stage == nil or assignment.stage == field.stage then
local isActive = ADFieldJobs.ACTIVE_PHASES[assignment.phase]
if assignment.helper then
if isActive then helpers = helpers + 1 end
else
if isActive then active = active + 1 end
if ADFieldJobs.holdsHelpers(assignment) then awaiting = awaiting + 1 end
if assignment.phase == "finished" then finished = finished + 1 end
end
end
end
local isCropStage = ADFieldModel.CROP_STAGES[field.stage] == true
if active == 0 then
-- afgrøden er væk (sluppet undervejs, genindlæst, eller færdig): videre
if isCropStage and cropGone(field.stage, info, finished) then return {action = "advance"} end
-- klargøringen er allerede gjort (målt på jorden): videre — også efter genindlæsning, hvor
-- opgaven ikke er husket (in-game 28/9: F17 blev kultiveret 3 gange)
local groundKey = ADFieldJobs.GROUND_PREP_STAGES[field.stage]
if groundKey ~= nil and info ~= nil and type(info[groundKey]) == "number" and info[groundKey] >= ADFieldJobs.PREPARED_DONE_RATIO then
return {action = "advance"}
end
if finished > 0 then
local maxPasses = ADFieldJobs.MAX_PASSES * ADFieldModel.maxRigs(field.stage, field.plan)
if not isCropStage or finished >= maxPasses then return {action = "advance"} end
end
-- slåning uden maskine på en halvt slået mark: vent til genvæksten er fuldt udvokset igen
-- (et hjørne Courseplay efterlod i samme omgang, finished > 0, slås straks)
if field.stage == "mowing" and finished == 0 and info ~= nil and (info.immatureRatio or 0) > ADFieldJobs.REGROW_RATIO then
return {action = "wait", reason = "regrowing"}
end
if not hasMarker then return {action = "wait"} end
if (field.retryAt or 0) > now then return {action = "none"} end
if ADFieldModel.isOutOfSeason(field.stage, period) then return {action = "wait", reason = "winter"} end
if raining and ADFieldModel.isWeatherSensitive(field.stage, field.plan, kind) then
return {action = "wait", reason = "rain"}
end
return {action = "dispatch", role = ADFieldModel.roleFor(field.stage), count = ADFieldModel.maxRigs(field.stage, field.plan), helper = false}
end
-- hovedsættene arbejder: fyld op med hjælpere (aflæsningsvogne) en ad gangen
local helperRole = ADFieldModel.helperFor(field.stage)
-- tømmevogne først når en høster faktisk er i gang (ikke mens spilleren kører den derud)
if helperRole ~= nil and active > awaiting and helpers < ADFieldModel.maxHelpers(field.stage, field.plan) and hasMarker and (field.retryAt or 0) <= now then
return {action = "dispatch", role = helperRole, count = 1, helper = true}
end
return {action = "none"}
end
-- ---- tilstand ----
function ADFieldJobs.log(fieldId, fmt, ...)
Logging.info(ADFieldJobs.LOG_PREFIX .. "F%s " .. fmt, tostring(fieldId), ...)
end
function ADFieldJobs.getField(id)
return ADFieldJobs.state.fields[id] or ADFieldModel.newField(id)
end
function ADFieldJobs.setField(field)
ADFieldJobs.state.fields[field.id] = field
end
-- Ændr felter på marken (kopi via modellen).
function ADFieldJobs.note(fieldId, changes)
ADFieldJobs.setField(ADFieldModel.with(ADFieldJobs.getField(fieldId), changes))
end
function ADFieldJobs.assignmentsFor(fieldId)
local list = {}
for _, assignment in pairs(ADFieldJobs.state.assignments) do
if assignment.fieldId == fieldId then table.insert(list, assignment) end
end
return list
end
function ADFieldJobs.save()
local ok, err = pcall(ADFieldStorage.save, ADFieldJobs.state)
if not ok then Logging.warning(ADFieldJobs.LOG_PREFIX .. "marker kunne ikke gemmes: %s", tostring(err)) end
end
function ADFieldJobs.load()
local ok, loaded = pcall(ADFieldStorage.load)
if ok then
ADFieldJobs.state.fields, ADFieldJobs.state.fleet = loaded.fields, loaded.fleet
ADFieldJobs.state.fleetMode = loaded.fleetMode or "all"
ADFieldJobs.state.excluded = loaded.excluded or {}
ADFieldJobs.state.courseRecords = loaded.courseRecords or {}
ADFieldJobs.state.manual = loaded.manual or {}
ADFieldJobs.state.paused = loaded.paused == true
ADFieldJobs.state.resumed = loaded.resumed or {}
ADFieldJobs.state.dispatchGapS = ADFieldJobs.normalizeDispatchGap(loaded.dispatchGapS)
else
Logging.warning(ADFieldJobs.LOG_PREFIX .. "marker kunne ikke indlæses: %s", tostring(loaded))
end
ADFieldJobs.loaded = true
end
function ADFieldJobs.setPlan(id, changes)
ADFieldJobs.note(id, {plan = changes})
ADFieldJobs.save()
end
-- "Start nu" på en mark hvor moden venter på spilleren (manuel transport): overtag uden at vente
ADFieldJobs.takeoverRequested = {}
function ADFieldJobs.requestTakeover(id)
ADFieldJobs.takeoverRequested[id] = true
end
-- Venter moden på at spilleren kører en høster til marken? (assignment eller nil)
function ADFieldJobs.awaitingPlayer(fieldId)
for _, assignment in pairs(ADFieldJobs.state.assignments) do
if assignment.fieldId == fieldId and assignment.phase == "awaitingPlayer" then return assignment end
end
return nil
end
-- Under global pause: kun denne mark genoptages (de andre venter på Start alle). nil = pause igen.
function ADFieldJobs.setFieldResumed(id, isOn)
ADFieldJobs.state.resumed = ADFieldJobs.state.resumed or {}
ADFieldJobs.state.resumed[id] = isOn ~= false or nil
end
function ADFieldJobs.isFieldResumed(id)
return (ADFieldJobs.state.resumed or {})[id] == true
end
function ADFieldJobs.requestStart(id)
ADFieldJobs.note(id, {startRequested = true})
end
function ADFieldJobs.forceReady(id)
ADFieldJobs.setField(ADFieldModel.forceReady(ADFieldJobs.getField(id)))
end
function ADFieldJobs.setTarget(id, fruitName, source, product)
ADFieldJobs.setField(ADFieldModel.setTarget(ADFieldJobs.getField(id), fruitName, source, product))
ADFieldJobs.log(id, "mål-afgrøde: %s%s", fruitName ~= "" and fruitName or "ingen", product ~= nil and (" (" .. tostring(product) .. ")") or "")
ADFieldJobs.save()
end
function ADFieldJobs.setFleetMode(mode)
ADFieldJobs.state.fleetMode = mode
ADFieldJobs.save()
end
-- Pause (Stop alt og parkér): intet nyt sendes ud, ingen genstart efter indlæsning. Gemmes.
function ADFieldJobs.setPaused(value)
ADFieldJobs.state.paused = value == true
ADFieldJobs.state.resumed = {}
ADFieldJobs.save()
Logging.info(ADFieldJobs.LOG_PREFIX .. "markarbejde %s", value and "på pause" or "genoptaget")
end
function ADFieldJobs.toggleManual(vehicleId)
ADFieldJobs.state.manual = ADFieldFleet.toggle(ADFieldJobs.state.manual or {}, vehicleId)
ADFieldJobs.save()
end
-- Fluebenet i markflåden: i "kun med flueben" slås maskinen til/fra; i "brug alle" udelukkes den/tages med igen.
function ADFieldJobs.toggleFleet(vehicleId)
local state = ADFieldJobs.state
if state.fleetMode == "ticked" then
state.fleet = ADFieldFleet.toggle(state.fleet, vehicleId)
else
state.excluded = ADFieldFleet.toggle(state.excluded, vehicleId)
end
ADFieldJobs.save()
end
-- GUI'et henter flåde og gæringssiloer herfra (ligger i adFieldWork).
function ADFieldJobs.getRigs(adEnv) return ADFieldWork.getRigs(adEnv) end
function ADFieldJobs.getFermenters(...) return ADFieldWork.getFermenters(...) end
function ADFieldJobs.forgetFinished(fieldId)
local remaining = {}
for _, done in ipairs(ADFieldJobs.finished) do
if done.fieldId ~= fieldId then table.insert(remaining, done) end
end
ADFieldJobs.finished = remaining
end
local function finishedFor(fieldId)
local list = {}
for _, assignment in ipairs(ADFieldJobs.finished) do
if assignment.fieldId == fieldId then table.insert(list, assignment) end
end
return list
end
function ADFieldJobs.stopField(adEnv, id)
ADFieldWork.stopAll(adEnv, id)
ADFieldJobs.forgetFinished(id)
ADFieldJobs.setField(ADFieldModel.stop(ADFieldJobs.getField(id)))
ADFieldJobs.save()
ADFieldJobs.log(id, "stoppet fra menuen")
end
-- Besked i spillet (højre side). critical = rød. Samme tekst vises kun én gang i træk.
function ADFieldJobs.notify(text, critical)
if ADFieldJobs.lastNotice == text then return end
ADFieldJobs.lastNotice = text
pcall(function()
local kind = critical and FSBaseMission.INGAME_NOTIFICATION_CRITICAL or FSBaseMission.INGAME_NOTIFICATION_OK
g_currentMission:addIngameNotification(kind, "Smart Pickup: " .. text)
end)
end
-- Opsamler der står stille med Courseplay aktiv uden at blive fyldt så længe, har intet at samle op (in-game 7/10:
-- F13's læssevogne stod stille i januar efter genindlæsning, og marken stod som "kører").
ADFieldJobs.COLLECTOR_STALL_MS = 3 * 60 * 1000
function ADFieldJobs.collectorStalled(s)
return s.role == "collector" and type(s.stillMs) == "number" and s.stillMs >= ADFieldJobs.COLLECTOR_STALL_MS
end
-- Vejret lige nu (regn) og årets periode, læst en gang pr. tick.
function ADFieldJobs.environment()
local ok, raining = pcall(function()
local weather = g_currentMission.environment.weather
return weather ~= nil and weather.getIsRaining ~= nil and weather:getIsRaining() or false
end)
local okPeriod, period = pcall(function() return g_currentMission.environment.currentPeriod end)
return {
raining = ok and raining == true,
period = okPeriod and type(period) == "number" and period or nil,
-- kan afgrøden (navn) sås i den aktuelle periode?
plantable = function(name)
local fruit = g_fruitTypeManager ~= nil and g_fruitTypeManager:getFruitTypeByName(name) or nil
return fruit ~= nil and ADCpBridge.isPlantableNow(fruit.index)
end,
}
end
-- Seneste beslutning pr. mark (GUI viser pleje-behov og grunde).
ADFieldJobs.lastDecision = {}
-- Hvornår en mark begyndte at vente på en maskine (kø: længst ventende får næste ledige traktor).
ADFieldJobs.waitingSince = {}
local function stepField(adEnv, info, env)
local current = ADFieldJobs.getField(info.id)
local field = ADFieldModel.onReadiness(current, info.readyRatio or 0)
if field ~= current then ADFieldJobs.setField(field) end
local assignments = ADFieldJobs.assignmentsFor(info.id)
for _, done in ipairs(finishedFor(info.id)) do table.insert(assignments, done) end
local decision = ADFieldJobs.decide(field, info, assignments, ADFieldJobs.now, env)
ADFieldJobs.lastDecision[info.id] = decision
if decision.action == "start" then
local started = ADFieldModel.start(field, info.kind, info.needs, info.fruitName)
started.lastFruit = info.kind == "harvest" and info.fruitName or field.lastFruit
ADFieldJobs.setField(started)
ADFieldJobs.log(info.id, "starter (%s: %s)", tostring(info.kind), started.stage)
ADFieldJobs.save()
elseif decision.action == "rewind" then
ADFieldJobs.setField(ADFieldModel.with(field, {stage = "ready", retryAt = 0, reason = false}))
ADFieldJobs.waitingSince[info.id] = nil
ADFieldWork.windDownHelpers(adEnv, info.id, field.stage)
-- maskinerne på det gamle trin (fx læssevognen på uslået græs) stoppes og køres hjem
if #ADFieldJobs.assignmentsFor(info.id) > 0 and ADFieldWork.stopAll ~= nil then pcall(ADFieldWork.stopAll, adEnv, info.id) end
ADFieldJobs.log(info.id, "%s -> ready: afgrøden står stadig uhøstet (%.0f %% klar)", field.stage, (info.readyRatio or 0) * 100)
ADFieldJobs.save()
elseif decision.action == "care" then
ADFieldJobs.setField(ADFieldModel.startCare(field, decision.stage))
ADFieldJobs.log(info.id, "pleje: %s", decision.stage)
ADFieldJobs.save()
elseif decision.action == "advance" then
-- høsteren har stadig korn i tanken: CP genstartes og venter ved kursets ende, tømmevognene kommer
-- (marken bliver på høst til tanken er tom) — in-game 27/9 F15
if field.stage == "harvesting" and ADFieldWork.tryEmptyHarvester ~= nil then
local okEmpty, emptying = pcall(ADFieldWork.tryEmptyHarvester, adEnv, field, info)
if okEmpty and emptying then return end
end
local nextField = ADFieldModel.advance(field, info.needs)
ADFieldJobs.setField(nextField)
ADFieldJobs.waitingSince[info.id] = nil
ADFieldJobs.forgetFinished(info.id)
ADFieldWork.windDownHelpers(adEnv, info.id, field.stage)
ADFieldJobs.log(info.id, "%s -> %s (klar %.0f %%, fase %s)", field.stage, nextField.stage, (info.readyRatio or 0) * 100, tostring(info.phase))
if nextField.stage == "done" or (ADFieldModel.isCare(field.stage) and nextField.stage == "idle") then
ADFieldJobs.notify(string.format("F%d %s", info.id, g_i18n ~= nil and g_i18n:getText("spu_field_notice_done") or "done"), false)
end
ADFieldJobs.save()
elseif decision.action == "wait" and decision.reason ~= nil then
local key = "spu_field_reason_" .. decision.reason
if field.reason == nil or field.reason.key ~= key then
ADFieldJobs.note(info.id, {reason = {key = key}})
end
elseif decision.action == "dispatch" then
-- én udsendelse ad gangen på tværs af markerne: marken prøver igen ved næste tick
if not ADFieldJobs.mayDispatch(ADFieldJobs.now, ADFieldJobs.lastDispatchAt) then return end
local before = ADFieldJobs.assignmentCount()
ADFieldWork.dispatch(adEnv, field, info, decision)
if ADFieldJobs.assignmentCount() > before then
ADFieldJobs.lastDispatchAt = ADFieldJobs.now
ADFieldJobs.waitingSince[info.id] = nil
elseif ADFieldJobs.waitingSince[info.id] == nil then
ADFieldJobs.waitingSince[info.id] = ADFieldJobs.now
end
end
end
-- Realtid i ms: netGetTime (bruges overalt i FS), ellers getTimeSec.
local function clockMs()
local ok, ms = pcall(function() return netGetTime() end)
if ok and type(ms) == "number" then return ms end
local okSec, seconds = pcall(function() return getTimeSec() end)
return okSec and type(seconds) == "number" and seconds * 1000 or nil
end
-- Et langsomt tick (> SLOW_TICK_MS) skrives i loggen med fordeling, højst én gang pr. minut.
local function reportSlow(total, scan, follow, steps, stepped)
if total == nil or total <= ADFieldJobs.SLOW_TICK_MS then return end
if ADFieldJobs.lastSlowReport ~= nil and ADFieldJobs.now - ADFieldJobs.lastSlowReport < 60000 then return end
ADFieldJobs.lastSlowReport = ADFieldJobs.now
Logging.info(ADFieldJobs.LOG_PREFIX .. "markarbejde-tick %.1f ms (scan %.1f, sæt %.1f, marker %.1f for %d marker)",
total, scan or 0, follow or 0, steps or 0, stepped)
end
ADFieldJobs.STARTUP_GRACE_MS = 120000
function ADFieldJobs.tick(adEnv, dt)
ADFieldJobs.now = ADFieldJobs.now + dt
ADFieldJobs.timer = ADFieldJobs.timer + dt
if ADFieldJobs.loaded then
-- markscanningen kører et lille stykke HVERT frame (arbejdskø), aldrig en hel mark i ét frame
local okScan, errScan = pcall(ADFields.scanStep, adEnv, g_currentMission:getFarmId(), ADFieldJobs.now)
if not okScan then Logging.warning(ADFieldJobs.LOG_PREFIX .. "markscanning: %s", tostring(errScan)) end
end
if ADFieldJobs.timer < ADFieldJobs.TICK_MS then return end
ADFieldJobs.timer = 0
ADFieldJobs.tickCount = ADFieldJobs.tickCount + 1
if not ADFieldJobs.loaded then ADFieldJobs.load() end
local t0 = clockMs()
local t1 = t0
for _, assignment in pairs(ADFieldJobs.state.assignments) do
local ok, err = pcall(ADFieldWork.follow, adEnv, assignment)
if not ok then
Logging.warning(ADFieldJobs.LOG_PREFIX .. "F%s opfølgning fejlede: %s", tostring(assignment.fieldId), tostring(err))
ADFieldWork.release(assignment)
end
end
if ADFieldJobs.now < ADFieldWork.LOAD_TRIP_SNAPSHOT_MS then
local okTrip, errTrip = pcall(ADFieldWork.snapshotLoadTrips, adEnv)
if not okTrip then Logging.warning(ADFieldJobs.LOG_PREFIX .. "parkeringsture efter indlæsning: %s", tostring(errTrip)) end
end
local okRe, errRe = pcall(ADFieldWork.tickReadopt, adEnv)
if not okRe then Logging.warning(ADFieldJobs.LOG_PREFIX .. "genoptag: %s", tostring(errRe)) end
local t2 = clockMs()
-- de første minutter efter indlæsning sendes intet ud: Courseplay/AutoDrive genoptager deres egne jobs
-- lidt efter start, og indtil da ligner de maskiner ledige (in-game 26/9: kultivatoren blev taget midt
-- i spillerens eget CP-job 45 s efter indlæsning)
if ADFieldJobs.now < ADFieldJobs.STARTUP_GRACE_MS then return end
-- Stop alt og parkér: intet sendes ud og intet genstartes, før spilleren trykker Start alle — undtagen
-- marker spilleren har genoptaget enkeltvis ([Start] i Fields-listen, ADFieldJobs.setFieldResumed)
local paused, resumed = ADFieldJobs.state.paused, ADFieldJobs.state.resumed or {}
if paused and next(resumed) == nil then return end
-- under pause: kun hvis spilleren har startet marker enkeltvis (de maskiner, der kørte ved gem, fortsætter)
if not ADFieldJobs.resumedAfterLoad and (not paused or next(resumed) ~= nil) then
-- én gang, før noget nyt sendes ud: CP-maskiner der var midt i et job, fortsætter (og tæller som aktive)
ADFieldJobs.resumedAfterLoad = true
local okResume, errResume = pcall(ADFieldWork.resumeAfterLoad, adEnv)
if not okResume then Logging.warning(ADFieldJobs.LOG_PREFIX .. "genstart efter indlæsning fejlede: %s", tostring(errResume)) end
end
local env = ADFieldJobs.environment()
local slice = ADFieldJobs.tickCount % ADFieldJobs.PASSIVE_SLICES
local stepped = 0
local infos = ADFields.list()
if ADPool ~= nil then infos = ADPool.queueOrder(infos, ADFieldJobs.waitingSince) end
for index, info in ipairs(infos) do
-- passive marker (der sker intet uden brugeren) vurderes kun i deres tiendedel af sekunderne
if (not paused or resumed[info.id]) and (not ADFieldModel.isPassive(ADFieldJobs.getField(info.id)) or index % ADFieldJobs.PASSIVE_SLICES == slice) then
stepped = stepped + 1
local ok, err = pcall(stepField, adEnv, info, env)
if not ok then Logging.warning(ADFieldJobs.LOG_PREFIX .. "F%s fejl: %s", tostring(info.id), tostring(err)) end
end
end
local t3 = clockMs()
if t0 ~= nil and t3 ~= nil then reportSlow(t3 - t0, t1 - t0, t2 - t1, t3 - t2, stepped) end
end