269 lines
14 KiB
Lua
269 lines
14 KiB
Lua
-- AD Windrow Check
|
|
-- Ligger der overhovedet skår på marken, før en vender, rive eller opsamler sendes ud? Spilleren samler nogle gange
|
|
-- selv høet (brugerønske 17/10 19:38: 4 mio. l hø lagt i Farma-siloen i hånden) — ellers kørte opsamlerne ud,
|
|
-- fandt intet og stoppede først efter 3 min stilstand. Skårene læses i spillets højdekort
|
|
-- (DensityMapHeightUtil.getFillLevelAtArea) i et net af felter over markens omrids. Ren logik øverst, spil-adapter nederst.
|
|
|
|
ADWindrowCheck = {}
|
|
ADWindrowCheck.LOG_PREFIX = "ADSmartPickup: "
|
|
ADWindrowCheck.CELL_M = 25 -- feltstørrelse i nettet (25 x 25 m)
|
|
ADWindrowCheck.MIN_LITERS = 200 -- under dette regnes marken for tom for skår
|
|
ADWindrowCheck.CACHE_MS = 120000 -- svaret gemmes pr. mark (marken prøver igen hvert 30. s, mens den venter)
|
|
ADWindrowCheck.MAX_CELLS = 2500 -- større marker tjekkes ikke (0 = alt tjekkes); 2500 felter = 156 ha ved 25 m
|
|
|
|
-- Faser hvor skårene er forudsætningen
|
|
ADWindrowCheck.STAGES = {tedding = true, raking = true, collecting = true, strawCollecting = true}
|
|
|
|
-- Jordbearbejdning der ødelægger skår, som stadig ligger på marken (in-game 17/10 00:06: F36 gik til harvning efter
|
|
-- en læssevogn på et kursus fra en anden mark — "der ligger græs over det hele"). Mindst SOIL_GUARD_LITERS græs-/
|
|
-- høskår på marken sender den tilbage til opsamling, højst SOIL_GUARD_PASSES gange; derefter sættes marken på Fra.
|
|
-- også slåning: nyt græs oven på gammelt hø (in-game 18/10 23:53: F39 1,5 mio. l og F40 1,1 mio. l hø lå tilbage, og
|
|
-- skårlæggerne blev sendt ud igen — spuWindrows viste det)
|
|
ADWindrowCheck.SOIL_STAGES = {cultivating = true, plowing = true, sowing = true, mulching = true, mowing = true}
|
|
ADWindrowCheck.SOIL_GUARD_LITERS = 5000
|
|
ADWindrowCheck.SOIL_GUARD_PASSES = 2
|
|
|
|
-- Omridsets kasse -> felter (parallelogrammer som spillet vil have dem) med midtpunkt inde i omridset.
|
|
-- verts = {{x, z}} -> {{sx, sz, wx, wz, hx, hz}}
|
|
function ADWindrowCheck.cells(verts, cellM, insidePolygon)
|
|
local list = {}
|
|
if verts == nil or #verts < 3 then return list end
|
|
local step = cellM or ADWindrowCheck.CELL_M
|
|
local minX, maxX, minZ, maxZ = math.huge, -math.huge, math.huge, -math.huge
|
|
for _, v in ipairs(verts) do
|
|
minX, maxX = math.min(minX, v.x), math.max(maxX, v.x)
|
|
minZ, maxZ = math.min(minZ, v.z), math.max(maxZ, v.z)
|
|
end
|
|
local inside = insidePolygon or (ADFieldJobs ~= nil and ADFieldJobs.insidePolygon) or function() return true end
|
|
local x = minX
|
|
while x < maxX do
|
|
local z = minZ
|
|
while z < maxZ do
|
|
if inside(x + step / 2, z + step / 2, verts) then
|
|
table.insert(list, {sx = x, sz = z, wx = x + step, wz = z, hx = x, hz = z + step})
|
|
end
|
|
z = z + step
|
|
end
|
|
x = x + step
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- Varerne der kan ligge som skår for marken: græs-/høskår (info.windrow, info.hay), halm ved halmopsamling.
|
|
-- -> liste af fillType-indeks (uden dubletter)
|
|
function ADWindrowCheck.fillTypesFor(field, info, strawFillType)
|
|
local set, list = {}, {}
|
|
local function add(fillType)
|
|
if fillType ~= nil and not set[fillType] then set[fillType] = true; table.insert(list, fillType) end
|
|
end
|
|
if field ~= nil and field.stage == "strawCollecting" then
|
|
add(strawFillType)
|
|
else
|
|
add(info ~= nil and info.windrow or nil)
|
|
add(info ~= nil and info.hay or nil)
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- Afgørelsen: s = {stage, contract, liters, fillTypes = antal, cells = antal, reads = antal vellykkede opslag}
|
|
-- Springes trinnet over? Kun i skår-faserne, aldrig på kontraktmarker (kontraktens egen færdiggrad styrer), kun når
|
|
-- der var noget at måle (varer og felter), spillet faktisk svarede (reads > 0 — review: fejlede opslag må ikke ligne
|
|
-- en tom mark), og marken er tom.
|
|
function ADWindrowCheck.shouldSkip(s)
|
|
if s == nil or not ADWindrowCheck.STAGES[s.stage] then return false end
|
|
if s.contract then return false end
|
|
if (s.fillTypes or 0) == 0 or (s.cells or 0) == 0 or (s.reads or 0) == 0 then return false end
|
|
return (s.liters or 0) < ADWindrowCheck.MIN_LITERS
|
|
end
|
|
|
|
-- Jordbearbejdning med skår på marken? s = {stage, contract, liters, fillTypes, cells, reads, passes}
|
|
-- -> "collect" (tilbage til opsamling), "off" (for mange forsøg: marken sættes på Fra) eller nil (kør videre).
|
|
-- Aldrig på kontraktmarker, og kun når spillet faktisk svarede (reads > 0) og der lå mindst SOIL_GUARD_LITERS.
|
|
function ADWindrowCheck.soilGuard(s)
|
|
if s == nil or not ADWindrowCheck.SOIL_STAGES[s.stage] then return nil end
|
|
if s.contract then return nil end
|
|
if (s.fillTypes or 0) == 0 or (s.cells or 0) == 0 or (s.reads or 0) == 0 then return nil end
|
|
if (s.liters or 0) < ADWindrowCheck.SOIL_GUARD_LITERS then return nil end
|
|
if (s.passes or 0) >= ADWindrowCheck.SOIL_GUARD_PASSES then return "off" end
|
|
return "collect"
|
|
end
|
|
|
|
-- ---- spil-adapter ----
|
|
|
|
local cache = {} -- fieldId -> {at, stage, skip}
|
|
local soilCache = {} -- fieldId -> {at, stage, liters, reads, fillTypes, cells}
|
|
|
|
local function now()
|
|
if ADUtil ~= nil and ADUtil.now ~= nil then return ADUtil.now() end
|
|
return 0
|
|
end
|
|
|
|
-- Liter skår af varerne i felterne og antal vellykkede opslag; stopper så snart grænsen er nået (marken er så ikke tom).
|
|
-- Et fejlet opslag logges én gang (ellers ville en tavs API-fejl ligne en tom mark).
|
|
local readFailureLogged = false
|
|
local function litersOnField(cells, fillTypes, limit)
|
|
local total, reads = 0, 0
|
|
for _, fillType in ipairs(fillTypes) do
|
|
for _, c in ipairs(cells) do
|
|
local ok, liters = pcall(DensityMapHeightUtil.getFillLevelAtArea, fillType, c.sx, c.sz, c.wx, c.wz, c.hx, c.hz)
|
|
if ok and type(liters) == "number" then
|
|
total, reads = total + liters, reads + 1
|
|
elseif not readFailureLogged then
|
|
readFailureLogged = true
|
|
Logging.warning(ADWindrowCheck.LOG_PREFIX .. "skår-tjek: opslag i højdekortet fejlede (%s) — marker springes ikke over", tostring(liters))
|
|
end
|
|
if total >= limit then return total, reads end
|
|
end
|
|
end
|
|
return total, reads
|
|
end
|
|
|
|
local function fillTypeNames(fillTypes)
|
|
local names = {}
|
|
for _, fillType in ipairs(fillTypes) do
|
|
table.insert(names, g_fillTypeManager ~= nil and g_fillTypeManager.getFillTypeNameByIndex ~= nil
|
|
and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType))
|
|
end
|
|
return table.concat(names, "/")
|
|
end
|
|
|
|
-- Skal markens trin springes over, fordi der ingen skår ligger? Svaret gemmes CACHE_MS pr. mark og trin.
|
|
function ADWindrowCheck.skipsStage(adEnv, field, info)
|
|
if field == nil or info == nil or not ADWindrowCheck.STAGES[field.stage] or field.contract then return false end
|
|
if DensityMapHeightUtil == nil or DensityMapHeightUtil.getFillLevelAtArea == nil then return false end
|
|
local entry = cache[field.id]
|
|
local t = now()
|
|
if entry ~= nil and entry.stage == field.stage and t - entry.at < ADWindrowCheck.CACHE_MS then
|
|
return entry.skip
|
|
end
|
|
local straw = g_fillTypeManager ~= nil and g_fillTypeManager.getFillTypeIndexByName ~= nil
|
|
and g_fillTypeManager:getFillTypeIndexByName("STRAW") or nil
|
|
local fillTypes = ADWindrowCheck.fillTypesFor(field, info, straw)
|
|
local cells = ADWindrowCheck.cells(info.verts, ADWindrowCheck.CELL_M)
|
|
if ADWindrowCheck.MAX_CELLS > 0 and #cells > ADWindrowCheck.MAX_CELLS then
|
|
cache[field.id] = {at = t, stage = field.stage, skip = false}
|
|
return false
|
|
end
|
|
local liters, reads = 0, 0
|
|
if #fillTypes > 0 and #cells > 0 then liters, reads = litersOnField(cells, fillTypes, ADWindrowCheck.MIN_LITERS) end
|
|
local skip = ADWindrowCheck.shouldSkip({stage = field.stage, contract = field.contract, liters = liters,
|
|
fillTypes = #fillTypes, cells = #cells, reads = reads})
|
|
cache[field.id] = {at = t, stage = field.stage, skip = skip}
|
|
if skip then
|
|
Logging.info(ADWindrowCheck.LOG_PREFIX .. "F%s: ingen skår på marken (%s, %d felter) — %s springes over",
|
|
tostring(field.id), fillTypeNames(fillTypes), #cells, tostring(field.stage))
|
|
end
|
|
return skip
|
|
end
|
|
|
|
-- Skår på marken før jordbearbejdning: -> afgørelse ("collect"/"off"/nil), liter. Målt igen pr. CACHE_MS; antal
|
|
-- gange marken er sendt tilbage huskes pr. mark (nulstilles ved genindlæsning — højst to ekstra ture pr. session).
|
|
local soilPasses = {}
|
|
function ADWindrowCheck.soilGuardFor(adEnv, field, info, mowedThisCycle)
|
|
if field == nil or info == nil or not ADWindrowCheck.SOIL_STAGES[field.stage] or field.contract then return nil, 0 end
|
|
-- slåning: kun før omgangens første slåmaskine — bagefter er skårene fra denne slåning (review: en ekstra udsendelse
|
|
-- til hjørner/rester ville ellers sende marken til rivning midt i slåningen)
|
|
if field.stage == "mowing" and (field.mowVehicleId ~= nil or mowedThisCycle) then return nil, 0 end
|
|
if DensityMapHeightUtil == nil or DensityMapHeightUtil.getFillLevelAtArea == nil then return nil, 0 end
|
|
local t = now()
|
|
local entry = soilCache[field.id]
|
|
if entry == nil or entry.stage ~= field.stage or t - entry.at >= ADWindrowCheck.CACHE_MS then
|
|
local fillTypes = ADWindrowCheck.fillTypesFor(field, info, nil)
|
|
local cells = ADWindrowCheck.cells(info.verts, ADWindrowCheck.CELL_M)
|
|
local liters, reads = 0, 0
|
|
if #fillTypes > 0 and #cells > 0 and (ADWindrowCheck.MAX_CELLS <= 0 or #cells <= ADWindrowCheck.MAX_CELLS) then
|
|
liters, reads = litersOnField(cells, fillTypes, ADWindrowCheck.SOIL_GUARD_LITERS)
|
|
end
|
|
entry = {at = t, stage = field.stage, liters = liters, reads = reads, fillTypes = #fillTypes, cells = #cells}
|
|
soilCache[field.id] = entry
|
|
end
|
|
local decision = ADWindrowCheck.soilGuard({stage = field.stage, contract = field.contract, liters = entry.liters,
|
|
fillTypes = entry.fillTypes, cells = entry.cells, reads = entry.reads, passes = soilPasses[field.id]})
|
|
return decision, entry.liters
|
|
end
|
|
|
|
-- Marken ER sendt tilbage til opsamling (review: en fejl i anvendelsen må ikke bruge et forsøg): tæl forsøget og mål igen næste gang.
|
|
function ADWindrowCheck.soilGuardApplied(fieldId)
|
|
soilPasses[fieldId] = (soilPasses[fieldId] or 0) + 1
|
|
soilCache[fieldId] = nil
|
|
end
|
|
|
|
-- Glem alt om marken (ny omgang, stoppet, tilbage til ready): målinger og forsøgstæller.
|
|
function ADWindrowCheck.forget(fieldId)
|
|
cache[fieldId] = nil
|
|
soilCache[fieldId] = nil
|
|
soilPasses[fieldId] = nil
|
|
end
|
|
|
|
-- ---- oversigt: skår på alle marker (konsol: spuWindrows) ----
|
|
-- Brugerønske 18/10 23:40: "hvilke marker ligger der græs eller hø på som ikke er hentet hjem?" Markscanningen måler
|
|
-- ikke skår; her måles alle gårdens marker én gang (fuld sum, ingen grænse) og skrives i loggen/konsollen.
|
|
ADWindrowCheck.SURVEY_FILL_TYPES = {"GRASS_WINDROW", "DRYGRASS_WINDROW", "ALFALFA_WINDROW", "DRYALFALFA_WINDROW",
|
|
"CLOVER_WINDROW", "DRYCLOVER_WINDROW", "STRAW"}
|
|
|
|
-- Ren: {{id, parts = {{name, liters}}}} -> tekstlinjer, marker med mest først; kun varer ≥ MIN_LITERS
|
|
function ADWindrowCheck.surveyLines(results)
|
|
local rows = {}
|
|
for _, r in ipairs(results or {}) do
|
|
local total, kept = 0, {}
|
|
for _, part in ipairs(r.parts or {}) do
|
|
if part.liters >= ADWindrowCheck.MIN_LITERS then
|
|
total = total + part.liters
|
|
table.insert(kept, string.format("%s %.0f l", part.name, part.liters))
|
|
end
|
|
end
|
|
if #kept > 0 then table.insert(rows, {id = r.id, total = total, text = table.concat(kept, ", ")}) end
|
|
end
|
|
table.sort(rows, function(a, b) if a.total ~= b.total then return a.total > b.total end return a.id < b.id end)
|
|
local lines = {}
|
|
for _, row in ipairs(rows) do table.insert(lines, string.format("F%s: %s", tostring(row.id), row.text)) end
|
|
return lines
|
|
end
|
|
|
|
-- loft over opslag i ét billede (review: ~31 marker x 1600 felter x 7 varer kan fryse spillet i sekunder)
|
|
ADWindrowCheck.SURVEY_MAX_READS = 150000
|
|
|
|
function ADWindrowCheck.consoleSurvey()
|
|
if DensityMapHeightUtil == nil or DensityMapHeightUtil.getFillLevelAtArea == nil or ADFields == nil or g_fillTypeManager == nil then
|
|
return "skår-oversigt: spillets højdekort er ikke tilgængeligt"
|
|
end
|
|
local fillTypes = {}
|
|
for _, fillName in ipairs(ADWindrowCheck.SURVEY_FILL_TYPES) do
|
|
local index = g_fillTypeManager:getFillTypeIndexByName(fillName)
|
|
if index ~= nil then table.insert(fillTypes, {index = index, name = fillName}) end
|
|
end
|
|
if #fillTypes == 0 then return "skår-oversigt: ingen af skår-varerne findes i spillet" end
|
|
local results, fields, tooBig, reads, stoppedAt = {}, 0, {}, 0, nil
|
|
for _, info in ipairs(ADFields.list() or {}) do
|
|
local cells = ADWindrowCheck.cells(info.verts, ADWindrowCheck.CELL_M)
|
|
if reads + #cells * #fillTypes > ADWindrowCheck.SURVEY_MAX_READS then
|
|
stoppedAt = stoppedAt or info.id
|
|
elseif ADWindrowCheck.MAX_CELLS > 0 and #cells > ADWindrowCheck.MAX_CELLS then
|
|
table.insert(tooBig, "F" .. tostring(info.id))
|
|
elseif #cells > 0 then
|
|
fields = fields + 1
|
|
local parts = {}
|
|
for _, ft in ipairs(fillTypes) do
|
|
local liters, n = litersOnField(cells, {ft.index}, math.huge)
|
|
reads = reads + n
|
|
table.insert(parts, {name = ft.name, liters = liters})
|
|
end
|
|
table.insert(results, {id = info.id, parts = parts})
|
|
end
|
|
end
|
|
local lines = ADWindrowCheck.surveyLines(results)
|
|
local notes = {}
|
|
if #tooBig > 0 then table.insert(notes, "for store: " .. table.concat(tooBig, " ")) end
|
|
if stoppedAt ~= nil then table.insert(notes, string.format("afbrudt ved F%s (loft %d opslag)", tostring(stoppedAt), ADWindrowCheck.SURVEY_MAX_READS)) end
|
|
if fields > 0 and reads == 0 then table.insert(notes, "opslag fejlede — resultatet siger intet") end
|
|
local head = string.format("skår-oversigt: %d marker målt — %d med skår (mindst %d l)%s", fields, #lines, ADWindrowCheck.MIN_LITERS,
|
|
#notes > 0 and (" [" .. table.concat(notes, "; ") .. "]") or "")
|
|
Logging.info(ADWindrowCheck.LOG_PREFIX .. "%s", head)
|
|
for _, line in ipairs(lines) do Logging.info(ADWindrowCheck.LOG_PREFIX .. "skår-oversigt %s", line) end
|
|
return head .. (#lines > 0 and ("\n" .. table.concat(lines, "\n")) or "")
|
|
end
|
|
|
|
if addConsoleCommand ~= nil then
|
|
addConsoleCommand("spuWindrows", "Skår (græs/hø/lucerne/kløver/halm) der ligger på gårdens marker, i liter (kan hakke et øjeblik)", "consoleSurvey", ADWindrowCheck)
|
|
end
|