935 lines
51 KiB
Lua
935 lines
51 KiB
Lua
-- 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
|
|
-- balleopsamling med baller tilbage: så mange færdige ballesamler-ture før marken går videre alligevel
|
|
ADFieldJobs.MAX_BALE_PASSES = 5
|
|
-- 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
|
|
-- kontrakt med spillets hjælper: Courseplay melder "i gang", mens hjælperen stadig kører ud — vent til den er på marken
|
|
if assignment.giants and not assignment.arrived 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, stonePicking = 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
|
|
-- Klar-andel til mark-tilstanden: på en høstmark hvor under HARVEST_DONE_RATIO af HELE marken står (rester i
|
|
-- hjørnerne), er der intet at høste — ellers vækker "100 % klar" (af resten) en færdig mark til høst igen.
|
|
function ADFieldJobs.effectiveReadiness(info)
|
|
if info == nil then return 0 end
|
|
if info.kind == "harvest" and type(info.standingRatio) == "number" and info.standingRatio < ADFieldJobs.HARVEST_DONE_RATIO then
|
|
return 0
|
|
end
|
|
return info.readyRatio or 0
|
|
end
|
|
|
|
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)
|
|
-- Courseplays markpunkt: nærmeste scanningspunkt — ved høst/slåning kun punkter, hvor afgrøden står. Kortets mark kan
|
|
-- dække flere adskilte stykker jord (Flat Acres 4X F14: hvede på den ene side af vejen, pløjet jord på den anden), og
|
|
-- Courseplay finder marken ud fra jorden ved punktet (in-game 10/10: kurset blev lagt på den pløjede del).
|
|
function ADFieldJobs.coursePoint(points, x, z, fruit)
|
|
if fruit ~= nil then
|
|
local withCrop = {}
|
|
for _, point in ipairs(points or {}) do
|
|
if point.fruit == fruit then table.insert(withCrop, point) end
|
|
end
|
|
if #withCrop > 0 then return ADFieldJobs.nearestPoint(withCrop, x, z) end
|
|
end
|
|
return ADFieldJobs.nearestPoint(points, x, z)
|
|
end
|
|
|
|
-- Sted at skifte skærebord: inset meter ind på marken fra markkanten nærmest (x, z), mod (cx, cz) — væk fra indkørslen,
|
|
-- vejen og træerne (in-game 10/10 F5). -> {x, z, dirX, dirZ} (retning ind mod marken) eller nil uden omrids.
|
|
function ADFieldJobs.swapSpot(verts, x, z, cx, cz, inset)
|
|
if verts == nil or #verts < 3 or cx == nil then return nil 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
|
|
local vx, vz = cx - bestX, cz - bestZ
|
|
local len = math.sqrt(vx * vx + vz * vz)
|
|
if len < 1e-6 then return nil end
|
|
local step = math.min(inset or 45, len)
|
|
return {x = bestX + vx / len * step, z = bestZ + vz / len * step, dirX = vx / len, dirZ = vz / len}
|
|
end
|
|
|
|
-- Tømmevognenes ventepladser: inset meter ind på marken fra kanten nærmest markøren, flyttet side meter langs kanten.
|
|
-- Courseplay-tømmevognen venter på sin startPosition; lå den på F-markøren, holdt tomme vogne i indkørslen og spærrede
|
|
-- for den næste mejetærsker (in-game 10/10 F14 med 3 maskiner). Sidelæns, så de heller ikke står på mejetærskernes
|
|
-- vej ind til skærebords-skiftet (swapSpot ligger på linjen lige ind fra kanten). -> {x, z} eller nil uden omrids.
|
|
function ADFieldJobs.waitSpot(verts, x, z, cx, cz, inset, side)
|
|
if verts == nil or #verts < 3 or cx == nil then return nil end
|
|
local best, bestD = 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 d = (a.x + t * dx - x) ^ 2 + (a.z + t * dz - z) ^ 2
|
|
if d < bestD then best, bestD = {a = a, dx = dx, dz = dz, len2 = len2, t = t}, d end
|
|
end
|
|
if best == nil or best.len2 <= 0 then return nil end
|
|
local len = math.sqrt(best.len2)
|
|
-- langs kanten, men ikke ud over dens hjørner
|
|
local t = math.max(0, math.min(1, best.t + (side or 0) / len))
|
|
local ex, ez = best.a.x + t * best.dx, best.a.z + t * best.dz
|
|
local vx, vz = cx - ex, cz - ez
|
|
local vlen = math.sqrt(vx * vx + vz * vz)
|
|
if vlen < 1e-6 then return {x = ex, z = ez} end
|
|
local step = math.min(inset or 20, vlen)
|
|
local spot = {x = ex + vx / vlen * step, z = ez + vz / vlen * step}
|
|
-- skæv/L-formet mark: forskydningen kan ende uden for marken -> uden sideforskydning
|
|
if ADFieldJobs.insidePolygon ~= nil and not ADFieldJobs.insidePolygon(spot.x, spot.z, verts) and (side or 0) ~= 0 then
|
|
return ADFieldJobs.waitSpot(verts, x, z, cx, cz, inset, 0)
|
|
end
|
|
return spot
|
|
end
|
|
|
|
-- Courseplay stoppede, men kurset er ikke kørt færdigt (CP sletter sit huskede waypoint, når kurset er kørt helt
|
|
-- igennem): start det igen fra sidste punkt i stedet for at melde maskinen færdig (in-game 10/10 F14: "vehicle off
|
|
-- track, shutting off Courseplay now" -> mejetærskeren pakkede sammen og kørte hjem midt i marken).
|
|
-- Kun markarbejde der ikke selv stopper, når det er fuldt: opsamlere (fulde -> "is full") og tømmevogne ikke.
|
|
-- s = {rememberedIx, hasCourse, restarts, intended, controlled, helper, refillEmpty, collector, loaded}
|
|
ADFieldJobs.CP_RESTARTS = 3
|
|
ADFieldJobs.CP_RESTART_GRACE_MS = 20000 -- så længe må CP være om at komme i gang efter genstart
|
|
ADFieldJobs.CP_RESTART_RESET_MS = 300000 -- har den kørt så længe efter en genstart, tælles forfra
|
|
function ADFieldJobs.shouldRestartCp(s)
|
|
if s.intended or s.controlled or s.helper or s.refillEmpty or s.collector or s.loaded then return false end
|
|
if not s.hasCourse or type(s.rememberedIx) ~= "number" or s.rememberedIx <= 1 then return false end
|
|
return (s.restarts or 0) < ADFieldJobs.CP_RESTARTS
|
|
end
|
|
|
|
-- 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
|
|
|
|
-- Spilleren kører en maskine selv (AD/CP slået fra). På vej hen at hente redskabet eller ud til marken er det oftest
|
|
-- for at køre den fri af en anden (in-game 11/10) — sættet slippes først, når han har kørt et rigtigt stykke.
|
|
-- s = {phase, movedM}
|
|
ADFieldJobs.PLAYER_TAKEOVER_M = 75
|
|
ADFieldJobs.TRANSPORT_PHASES = {fetching = true, driving = true}
|
|
function ADFieldJobs.playerTakesOver(s)
|
|
if not ADFieldJobs.TRANSPORT_PHASES[s.phase] then return true end
|
|
return type(s.movedM) == "number" and s.movedM >= ADFieldJobs.PLAYER_TAKEOVER_M
|
|
end
|
|
|
|
-- Køreturen ud med AD slået fra. s = {adActive, controlled, paused, arrived, otherTarget}
|
|
-- -> "wait" | "resume" | "clear" | "release" | nil
|
|
-- (wait: spilleren sidder i den; resume: han stod af — start AD igen; clear: han slog AD til selv mod samme mål;
|
|
-- release: han gav AD et andet mål — så kører han den; nil: almindelig håndtering, også fremme ved markøren)
|
|
function ADFieldJobs.drivePause(s)
|
|
if s.adActive then
|
|
if not s.paused then return nil end
|
|
return s.otherTarget and "release" or "clear"
|
|
end
|
|
if s.arrived then return nil end
|
|
if s.controlled then return "wait" end
|
|
if s.paused then return "resume" end
|
|
return nil
|
|
end
|
|
|
|
-- AutoDrive hænger ved markmarkøren: stadig aktiv, men stille ved et af de sidste vejpunkter tæt på målet
|
|
-- (in-game 11/10 F36: wp 461/462 i minutter — moden ventede på at AD stoppede, og marken blev aldrig startet).
|
|
-- s = {adActive, speed (km/t), wpLeft, distance (m), stillMs}
|
|
ADFieldJobs.STALL_ARRIVE_MS = 15000
|
|
ADFieldJobs.STALL_ARRIVE_M = 30
|
|
ADFieldJobs.STALL_WP_LEFT = 2
|
|
ADFieldJobs.STALL_SPEED = 1
|
|
function ADFieldJobs.stalledAtTarget(s)
|
|
if not s.adActive or (s.speed or 0) > ADFieldJobs.STALL_SPEED then return false end
|
|
if type(s.wpLeft) ~= "number" or s.wpLeft > ADFieldJobs.STALL_WP_LEFT then return false end
|
|
if type(s.distance) ~= "number" or s.distance > ADFieldJobs.STALL_ARRIVE_M then return false end
|
|
return (s.stillMs or 0) >= ADFieldJobs.STALL_ARRIVE_MS
|
|
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)
|
|
-- tripActive: AutoDrive kører stadig turen ud til marken (genoptaget ved indlæsning) — vent på ankomsten
|
|
if s.busy and s.tripActive and s.sameStage and s.hasRole and (s.ageMs or 0) <= ADFieldJobs.READOPT_MAX_MS then return "wait" end
|
|
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
|
|
|
|
-- Hvilken mark kører AutoDrive ud til? Kun marker der er slået til og har et trin med en rolle.
|
|
-- fields = liste {id, markerId, enabled, role} -> id | nil
|
|
function ADFieldJobs.fieldForMarker(markerId, fields)
|
|
if markerId == nil then return nil end
|
|
for _, f in ipairs(fields or {}) do
|
|
if f.markerId == markerId and f.enabled and f.role ~= nil then return f.id end
|
|
end
|
|
return nil
|
|
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 længst fra (x, z) (kontrakt der køres igen fra den anden ende).
|
|
function ADFieldJobs.farthestPoint(points, x, z)
|
|
local best, bestD = nil, nil
|
|
for _, point in ipairs(points or {}) 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
|
|
|
|
-- 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)
|
|
-- kontraktmark slået [Fra]: spilleren kører den selv — moden sender intet
|
|
if field.contract and field.plan.mode ~= "auto" then return {action = "none"} end
|
|
-- kontraktmark uden F-markør: spilleren kører sættet derud (ADPlayerTransport)
|
|
local hasMarker = info ~= nil and (info.markerId ~= nil or field.contract == true)
|
|
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
|
|
-- hø: regner det, før græsset kan nå at tørre, venter slåningen (vejrudsigten, ADWeather)
|
|
if first == "mowing" and ADWeather ~= nil and ADFieldModel.product(field.plan, info.kind) == "hay"
|
|
and ADWeather.blocksHay(env ~= nil and env.rainInHours or nil) then
|
|
return {action = "wait", reason = "rainSoon"}
|
|
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)
|
|
-- Kendes andelen der står af HELE marken, afgør den alene: readyRatio regner kun med den rest der er tilbage, så
|
|
-- løg i hjørnerne (< 5 %) er "100 % klar" — og høst -> kalkning -> klar -> høst løb i ring hvert sekund (in-game 14/10 F25)
|
|
local hasStanding = info ~= nil and type(info.standingRatio) == "number"
|
|
local standing = hasStanding and info.standingRatio >= ADFieldJobs.HARVEST_DONE_RATIO
|
|
-- kontrakt: kun kontraktens trin — aldrig spol tilbage til høst/slåning på en andens mark
|
|
if not field.contract and ADFieldJobs.PREP_STAGES[field.stage] and info ~= nil and info.kind == "harvest" and info.phase == "ready"
|
|
and (standing or (not hasStanding and (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 not field.contract and 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 not field.contract and 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
|
|
-- høster uden rør (bomuldsmoduler): ingen tømmevogn — tælles som én, der ikke venter på hjælpere
|
|
if ADFieldJobs.holdsHelpers(assignment) or (isActive and not ADFieldJobs.needsHelper(assignment, field)) 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
|
|
-- balleopsamling med optalte baller (bomuldsmoduler): videre først når marken er tom — eller efter
|
|
-- MAX_BALE_PASSES forsøg, så marken ikke låses af moduler ingen opsamler kan tage (brugerønske 16/10)
|
|
local balesLeft = info ~= nil and info.balesLeft or nil
|
|
if field.stage == "baleCollecting" and balesLeft ~= nil then
|
|
if balesLeft == 0 then return {action = "advance"} end
|
|
if finished >= ADFieldJobs.MAX_BALE_PASSES then return {action = "advance", balesLeft = balesLeft} end
|
|
elseif 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)
|
|
-- (tømmevognene kører med AutoDrive mellem F-markøren og lageret: uden markør — kontraktmark — ingen)
|
|
if helperRole ~= nil and active > awaiting and helpers < ADFieldModel.maxHelpers(field.stage, field.plan)
|
|
and info ~= nil and (info.markerId ~= nil or field.contract == true) and (field.retryAt or 0) <= now then
|
|
return {action = "dispatch", role = helperRole, count = 1, helper = true}
|
|
end
|
|
return {action = "none"}
|
|
end
|
|
|
|
-- Skal hovedsættet have hjælpere (tømmevogn)? Kun en høster uden rør på en ballehøst-mark (bomuld) siger nej
|
|
-- (ADCpBridge.needsUnloader) — ikke kartoffel-/roeoptagere, der kan tømme uden spec_pipe (review 16/10).
|
|
function ADFieldJobs.needsHelper(assignment, field)
|
|
if assignment.role ~= "harvester" or ADCpBridge == nil or ADCpBridge.needsUnloader == nil then return true end
|
|
if field == nil or not ADFieldModel.isBaleHarvest(field.lastFruit) then return true end
|
|
return ADCpBridge.needsUnloader(assignment.vehicle)
|
|
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.playerTrips = loaded.playerTrips or {}
|
|
ADFieldJobs.state.paused = loaded.paused == true
|
|
ADFieldJobs.state.resumed = loaded.resumed or {}
|
|
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
|
|
|
|
-- Til/Fra fra marklisten: om moden selv kører marken (ADFieldModel.setEnabled).
|
|
function ADFieldJobs.setFieldEnabled(id, isOn, adEnv)
|
|
local field = ADFieldJobs.getField(id)
|
|
-- kontraktmark slået fra: spilleren overtager — modens sæt stoppes (slås den til igen, fortsætter trinnet)
|
|
if field.contract and not isOn and adEnv ~= nil and ADFieldWork ~= nil then pcall(ADFieldWork.stopAll, adEnv, id) end
|
|
ADFieldJobs.setField(ADFieldModel.setEnabled(field, isOn))
|
|
ADFieldJobs.save()
|
|
ADFieldJobs.log(id, isOn and "slået til — moden kører marken" or "slået fra — moden starter intet selv")
|
|
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)
|
|
local okRain, rainInHours = pcall(function() return ADWeather ~= nil and ADWeather.rainInHours() or nil end)
|
|
return {
|
|
raining = ok and raining == true,
|
|
-- timer til næste regn ifølge vejrudsigten (nil = ingen i udsigt)
|
|
rainInHours = okRain and rainInHours or nil,
|
|
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, ADFieldJobs.effectiveReadiness(info))
|
|
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
|
|
if ADFieldWork ~= nil and ADFieldWork.tripPlaceholders ~= nil then
|
|
for _, pending in ipairs(ADFieldWork.tripPlaceholders(info.id)) do table.insert(assignments, pending) end
|
|
end
|
|
-- balleopsamling efter ballehøst: tæl de baller der stadig ligger på marken (kopi af info — cachen røres ikke)
|
|
if field.stage == "baleCollecting" and ADFieldModel.isBaleHarvest(field.lastFruit) and ADFieldWork ~= nil
|
|
and ADFieldWork.countFieldBales ~= nil then
|
|
local okCount, count = pcall(ADFieldWork.countFieldBales, info, field.lastFruit)
|
|
if okCount and type(count) == "number" then
|
|
local copy = {}
|
|
for key, value in pairs(info) do copy[key] = value end
|
|
copy.balesLeft = count
|
|
info = copy
|
|
end
|
|
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%s)", field.stage, (info.readyRatio or 0) * 100,
|
|
type(info.standingRatio) == "number" and string.format(", %.0f %% af marken står", info.standingRatio * 100) or "")
|
|
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
|
|
if (decision.balesLeft or 0) > 0 then
|
|
local text = string.format("F%s: %d baller ligger stadig på marken efter %d opsamlinger — saml dem selv",
|
|
tostring(info.id), decision.balesLeft, ADFieldJobs.MAX_BALE_PASSES)
|
|
ADFieldJobs.log(info.id, "%s", text)
|
|
ADFieldJobs.notify(text, true)
|
|
end
|
|
-- 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)
|
|
-- kontrakt: kun kontraktens ene trin, og marken starter ikke selv igen (ADContracts glemmer den, når kontrakten slutter).
|
|
-- Er kontrakten ikke færdig, køres trinnet igen fra den anden ende af marken (højst 3 gange)
|
|
if field.contract and ADContracts ~= nil then
|
|
local completion = ADContracts.completionOf(field)
|
|
if ADContracts.needsAnotherPass(completion, field.contractPasses) then
|
|
local passes = (field.contractPasses or 0) + 1
|
|
ADFieldJobs.setField(ADFieldModel.with(field, {contractPasses = passes}))
|
|
ADFieldJobs.forgetFinished(info.id)
|
|
ADFieldJobs.log(info.id, "kontrakten er kun %d %% færdig — %s køres igen fra den anden ende af marken (%d/%d)",
|
|
math.floor(completion * 100 + 0.5), tostring(field.stage), passes, ADContracts.MAX_PASSES)
|
|
return
|
|
end
|
|
if completion ~= nil and completion < 0.999 then
|
|
ADFieldJobs.notify(string.format("Kontrakt F%d er kun %d %% færdig — kør resten selv", info.id, math.floor(completion * 100 + 0.5)), true)
|
|
end
|
|
nextField = ADFieldModel.with(field, {stage = "done", plan = {mode = "manual"}})
|
|
end
|
|
ADFieldJobs.setField(nextField)
|
|
if nextField.stage == "stonePicking" and ADFields.stoneHistogram ~= nil then
|
|
local okStone, histogram = pcall(ADFields.stoneHistogram, info.field)
|
|
ADFieldJobs.log(info.id, "sten på marken (værdi:pixels): %s", okStone and tostring(histogram) or ("fejl: " .. tostring(histogram)))
|
|
end
|
|
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
|
|
-- en maskine der allerede kører Courseplay her efter indlæsning, meldes ind først — ellers sendes en ekstra
|
|
-- høster ud i samme tick, som marken skifter fase (review 1.62.260)
|
|
if not decision.helper and ADFieldWork.tickOrphanCp ~= nil and next(ADFieldWork.orphanCp or {}) ~= nil then
|
|
pcall(ADFieldWork.tickOrphanCp, adEnv)
|
|
for _, assignment in ipairs(ADFieldJobs.assignmentsFor(info.id)) do
|
|
if not assignment.helper and assignment.resumed then return end
|
|
end
|
|
end
|
|
-- én udsendelse ad gangen på tværs af markerne: marken prøver igen ved næste tick
|
|
-- fælles port: også "Start alle", marksiloer og flows tæller med (in-game 16/10)
|
|
if ADLaunchGate ~= nil and not ADLaunchGate.isOpen("fieldWork") then return end
|
|
local before = ADFieldJobs.assignmentCount()
|
|
ADFieldWork.dispatch(adEnv, field, info, decision)
|
|
local launched = ADFieldJobs.assignmentCount() > before
|
|
if ADLaunchGate ~= nil then
|
|
if launched then ADLaunchGate.markLaunched("fieldWork") else ADLaunchGate.done("fieldWork") end
|
|
end
|
|
if launched then
|
|
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 < ADFieldJobs.STARTUP_GRACE_MS then
|
|
local okTrip, errTrip = pcall(ADFieldWork.snapshotLoadTrips, adEnv, ADFieldJobs.now < ADFieldWork.LOAD_TRIP_SNAPSHOT_MS)
|
|
if not okTrip then Logging.warning(ADFieldJobs.LOG_PREFIX .. "parkeringsture efter indlæsning: %s", tostring(errTrip)) end
|
|
end
|
|
local okLinger, errLinger = pcall(ADFieldWork.tickLingering, adEnv)
|
|
if not okLinger then Logging.warning(ADFieldJobs.LOG_PREFIX .. "ventende høstere: %s", tostring(errLinger)) end
|
|
local okOrphan, errOrphan = pcall(ADFieldWork.tickOrphanCp, adEnv)
|
|
if not okOrphan then Logging.warning(ADFieldJobs.LOG_PREFIX .. "genstartet uden mark: %s", tostring(errOrphan)) end
|
|
local okRe, errRe = pcall(ADFieldWork.tickReadopt, adEnv)
|
|
if not okRe then Logging.warning(ADFieldJobs.LOG_PREFIX .. "genoptag: %s", tostring(errRe)) end
|
|
if ADPlayerTransport ~= nil then
|
|
-- spillerkørsel: redskaber spilleren har koblet på (flyttes til traktoren efter løkken) og maskiner der er hentet
|
|
local okTake, errTake = pcall(ADPlayerTransport.applyTakeovers, adEnv)
|
|
if not okTake then Logging.warning(ADFieldJobs.LOG_PREFIX .. "overtagelse efter spillerkørsel: %s", tostring(errTake)) end
|
|
local okPick, errPick = pcall(ADPlayerTransport.tickPickups, adEnv)
|
|
if not okPick then Logging.warning(ADFieldJobs.LOG_PREFIX .. "maskiner der skal hentes: %s", tostring(errPick)) end
|
|
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
|
|
if ADContracts ~= nil then
|
|
local okContract, errContract = pcall(ADContracts.tick, adEnv, ADFieldJobs.now)
|
|
if not okContract then Logging.warning(ADFieldJobs.LOG_PREFIX .. "kontrakter: %s", tostring(errContract)) end
|
|
end
|
|
if ADBriefing ~= nil then
|
|
local okBrief, errBrief = pcall(ADBriefing.tick)
|
|
if not okBrief then Logging.warning(ADFieldJobs.LOG_PREFIX .. "morgenbriefing: %s", tostring(errBrief)) end
|
|
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
|
|
-- regn på vej: vejrfølsomme marker (høst, slåning, vending, rivning, presning) får maskinerne først
|
|
if ADWeather ~= nil and ADWeather.rainSoon(env.rainInHours) then
|
|
infos = ADWeather.prioritize(infos, function(info)
|
|
local field = ADFieldJobs.getField(info.id)
|
|
local stage = field.stage == "ready" and ADFieldModel.workStages(field.plan, info.kind, info.needs)[1] or field.stage
|
|
return stage ~= nil and ADFieldModel.isWeatherSensitive(stage, field.plan, info.kind)
|
|
end)
|
|
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
|