From 0b406d2623b3813a93ad96ea0f911ca62094bd45 Mon Sep 17 00:00:00 2001 From: masterdraco Date: Mon, 19 Oct 2026 00:51:18 +0200 Subject: [PATCH] =?UTF-8?q?feat:=20markmaskiner=20hedder=20efter=20deres?= =?UTF-8?q?=20aktuelle=20job=20(Fertilizer=20F23=20-=202)=20og=20f=C3=A5r?= =?UTF-8?q?=20eget=20navn=20igen=20bagefter=20(1.62.352)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 1 + FS25_ADSmartPickup/adJobNames.lua | 134 ++++++++++++++++++++++++ FS25_ADSmartPickup/adNaming.lua | 12 +++ FS25_ADSmartPickup/adRunsController.lua | 9 +- FS25_ADSmartPickup/l10n/l10n_da.xml | 17 +++ FS25_ADSmartPickup/l10n/l10n_en.xml | 17 +++ FS25_ADSmartPickup/modDesc.xml | 3 +- docs/BRUGERMANUAL.md | 2 + docs/USER_MANUAL.md | 2 + 9 files changed, 192 insertions(+), 5 deletions(-) create mode 100644 FS25_ADSmartPickup/adJobNames.lua diff --git a/CHANGELOG.md b/CHANGELOG.md index bce04d0..790b67f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ står i [docs/BRUGERMANUAL.md](docs/BRUGERMANUAL.md) (dansk) og [docs/USER_MANUA ## 1.62 — Kæder slås selv til +- **1.62.352** Markmaskiner hedder efter deres aktuelle job: "Fertilizer F23", flere på samme job og mark "Fertilizer F23 - 1/- 2" (stabil nummerering efter hvem der kom først); når jobbet slutter, får maskinen navnet fra før jobbet igen, eller navnet fra sin P-plads (brugerønske 19/10 00:46: mange hed "Tømmevogn …" mens de kørte sprøjte). Flow-traktorer beholder flow-navnet. Den gamle engangs-rollenavngivning er slået fra; gamle rollenavne ("Tømmevogn 6") afløses af P-pladsens navn efter første job. Navnene følger spillets sprog (spu_jobname_*). - **1.62.351** Markgrænsevagt: en Courseplay-tømmevogn, der står i "Field detection" i over 2 min, får målt markens grænse igen fra et punkt inde på marken (Courseplays egen cpDetectFieldBoundary); hjælper det ikke inden 2 min mere, kommer der en besked (in-game 19/10 00:14–00:26: 'Ballesamler 2' på F6 ventede, mens Mejetærsker 2 meldte "Needs to be unloaded"). Nyt modul adCpFieldGuard.lua. - **1.62.350** Mejetærsker med en anden afgrøde i tanken: i stedet for "ingen kan" / "mangler på gården" står der nu "venter på at 'Mejetærsker 6' bliver tømt (en anden afgrøde i tanken)" (gul kø, kort: "tøm høsteren"), og loggen siger "har MAIZE i tanken — tøm den først" i stedet for "ledig" (in-game 19/10: spinatkontrakten F83 — Mejetærsker 6 med Ropa-optager kunne godt, men havde 149.431 l majs i tanken). - **1.62.349** Færdige kontrakter indkasseres selv: når spillet melder en kontrakt færdig med succes (99,5 %), og den har stået sådan i 1 min, afslutter modden den med spillets egen afslutning — pengene udbetales, kontrakten forsvinder, og der kommer en besked (brugerønske 19/10: F15-gødning hang "færdig" siden 18/10). Venter, mens et lånt køretøj er i brug (spiller, AutoDrive eller hjælper). AutoDrives "Fold implements" slås til på hvert køretøj, modden starter (markarbejde og flows): redskaberne foldes sammen, før turen starter (36 ældre køretøjer stod på Nej); indstillingen gemmes på køretøjet. Påfyldning: foldede AutoDrive en såmaskine sammen under fyldningen, foldes den ud igen. diff --git a/FS25_ADSmartPickup/adJobNames.lua b/FS25_ADSmartPickup/adJobNames.lua new file mode 100644 index 0000000..28f7b56 --- /dev/null +++ b/FS25_ADSmartPickup/adJobNames.lua @@ -0,0 +1,134 @@ +-- AD Job Names +-- Markmaskiner hedder efter det job, de har lige nu (brugerønske 19/10 00:46: "mange af dem hedder tømmevogn eller noget +-- andet i stedet for det job de har ... hvis mega er på vej til f23 så kunne den 'Fertilizer F23 - x'"). Under et markjob: +-- " F", flere på samme job og mark: " - 1", " - 2" …; når jobbet slutter: maskinens faste navn fra dens P-plads +-- (som flowene, ADRuns.ownNameFromPark). Flow-traktorer beholder flow-navnet. Ren logik øverst, spil-adapter nederst. + +ADJobNames = {} + +ADJobNames.ROLE_KEYS = { + mower = "spu_jobname_mower", tedder = "spu_jobname_tedder", rake = "spu_jobname_rake", collector = "spu_jobname_collector", + harvester = "spu_jobname_harvester", unloader = "spu_jobname_unloader", mulcher = "spu_jobname_mulcher", + limer = "spu_jobname_limer", plow = "spu_jobname_plow", cultivator = "spu_jobname_cultivator", seeder = "spu_jobname_seeder", + roller = "spu_jobname_roller", weeder = "spu_jobname_weeder", fertilizer = "spu_jobname_fertilizer", baler = "spu_jobname_baler", + baleCollector = "spu_jobname_baleCollector", stonePicker = "spu_jobname_stonePicker", +} + +-- ---- ren logik ---- + +-- jobs = {{key, role, fieldId, order}}; labelOf(role) -> tekst. -> {[key] = navn}. Flere med samme rolle og mark nummereres +-- efter order (stabil rækkefølge), ellers intet nummer. +function ADJobNames.desired(jobs, labelOf) + local groups, order = {}, {} + for _, job in ipairs(jobs or {}) do + local label = labelOf(job.role) + if label ~= nil and job.fieldId ~= nil then + local groupKey = label .. "|" .. tostring(job.fieldId) + if groups[groupKey] == nil then + groups[groupKey] = {} + table.insert(order, groupKey) + end + table.insert(groups[groupKey], {key = job.key, label = label, fieldId = job.fieldId, order = job.order or 0}) + end + end + local result = {} + for _, groupKey in ipairs(order) do + local list = groups[groupKey] + table.sort(list, function(a, b) if a.order ~= b.order then return a.order < b.order end return tostring(a.key) < tostring(b.key) end) + for i, item in ipairs(list) do + local name = string.format("%s F%s", item.label, tostring(item.fieldId)) + if #list > 1 then name = string.format("%s - %d", name, i) end + result[item.key] = name + end + end + return result +end + +-- Er navnet et jobnavn (sat af os)? labels = {[tekst] = true} +function ADJobNames.isJobName(name, labels) + if type(name) ~= "string" then return false end + local prefix = name:match("^(.+) F%d+ %- %d+$") or name:match("^(.+) F%d+$") + return prefix ~= nil and labels[prefix] == true +end + +-- ---- spil-adapter ---- + +-- uniqueId -> navnet før jobbet (sættes tilbage bagefter; review: et eget navn som "Bertha" gik ellers tabt) +local beforeJob = {} +-- "uniqueId|rolle|mark" -> løbenummer for hvornår maskinen kom på jobbet (stabil nummerering; assignment.since flytter +-- sig ved hver fase, og så byttede "- 1" og "- 2" plads) +local firstSeen, seenCounter = {}, 0 + +local function labelOf(role) + local key = ADJobNames.ROLE_KEYS[role] + if key == nil or g_i18n == nil then return nil end + local ok, text = pcall(g_i18n.getText, g_i18n, key) + return ok and type(text) == "string" and text ~= "" and text or nil +end + +local function allLabels() + local labels = {} + for role in pairs(ADJobNames.ROLE_KEYS) do + local label = labelOf(role) + if label ~= nil then labels[label] = true end + end + return labels +end + +local function setName(stateModule, name) + stateModule:setName(name) + if stateModule.raiseDirtyFlag ~= nil then stateModule:raiseDirtyFlag() end +end + +function ADJobNames.apply(adEnv) + if ADFieldJobs == nil or ADFieldJobs.state == nil or ADRunsController == nil then return end + local store = ADRunsController.store + local runNames = ADRuns.vehicleNames(store) + local jobs, assigned, seenNow = {}, {}, {} + for _, assignment in pairs(ADFieldJobs.state.assignments or {}) do + local vehicle = assignment.vehicle + local key = vehicle ~= nil and ADRunsController.getVehicleId(vehicle) or nil + -- flow-traktorer (også udlånte) beholder flow-navnet; spilleren i førersædet: rør det ikke + local controlled = vehicle ~= nil and vehicle.getIsControlled ~= nil and vehicle:getIsControlled() + if key ~= nil then assigned[key] = true end + if key ~= nil and runNames[key] == nil and not controlled then + local seenKey = string.format("%s|%s|%s", key, tostring(assignment.role), tostring(assignment.fieldId)) + if firstSeen[seenKey] == nil then + seenCounter = seenCounter + 1 + firstSeen[seenKey] = seenCounter + end + seenNow[seenKey] = true + table.insert(jobs, {key = key, role = assignment.role, fieldId = assignment.fieldId, order = firstSeen[seenKey]}) + end + end + for seenKey in pairs(firstSeen) do if not seenNow[seenKey] then firstSeen[seenKey] = nil end end + local wanted = ADJobNames.desired(jobs, labelOf) + local labels = allLabels() + for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do + local stateModule = vehicle.ad ~= nil and vehicle.ad.stateModule or nil + local key = ADRunsController.getVehicleId(vehicle) + if stateModule ~= nil and stateModule.setName ~= nil and key ~= nil then + local current = stateModule.getName ~= nil and stateModule:getName() or stateModule.driverName + local name = wanted[key] + if runNames[key] ~= nil then beforeJob[key] = nil end -- gået over i et flow: det huskede navn er forældet + if name ~= nil then + if current ~= name then + -- gamle rollenavne ("Tømmevogn 6") huskes ikke — de afløses af P-pladsens navn bagefter + local oldRole = ADNaming ~= nil and ADNaming.isOldRoleName ~= nil and ADNaming.isOldRoleName(current) + if beforeJob[key] == nil and current ~= nil and not oldRole and not ADJobNames.isJobName(current, labels) then beforeJob[key] = current end + setName(stateModule, name) + end + elseif runNames[key] == nil and not assigned[key] and ADJobNames.isJobName(current, labels) then + -- jobbet er slut: navnet fra før jobbet, ellers det faste navn fra P-pladsen (ellers modelnavnet) + local own = beforeJob[key] + if own == nil then + local parkIndex = vehicle.advd ~= nil and vehicle.advd.parkDestination or nil + local marker = type(parkIndex) == "number" and parkIndex >= 1 and adEnv.ADGraphManager:getMapMarkerById(parkIndex) or nil + own = ADRuns.ownNameFromPark(marker ~= nil and marker.name or nil, tostring(vehicle:getName()), store) + end + setName(stateModule, own) + beforeJob[key] = nil + end + end + end +end diff --git a/FS25_ADSmartPickup/adNaming.lua b/FS25_ADSmartPickup/adNaming.lua index fc0782a..5149b8a 100644 --- a/FS25_ADSmartPickup/adNaming.lua +++ b/FS25_ADSmartPickup/adNaming.lua @@ -77,6 +77,18 @@ ADNaming.ROLE_PREFIX = {collector = "Læssevogn", mower = "Skårlægger", tedder mulcher = "Stubhakker", cultivator = "Kultivator", plow = "Plov", unloader = "Tømmevogn"} ADNaming.HARVESTER_PREFIX = {beet = "Roeoptager", forage = "Finsnitter"} +-- Gammelt engangs-rollenavn for en traktor ("Tømmevogn 6", "Skårlægger 4")? Traktorer skifter redskab, så navnet bliver +-- forkert (19/10) — det sættes ikke tilbage efter et job. Høstere ("Mejetærsker 6") er altid høstere og beholdes. +function ADNaming.isOldRoleName(name) + if type(name) ~= "string" then return false end + local prefix = name:match("^(.-) %d+$") + if prefix == nil then return false end + for _, value in pairs(ADNaming.ROLE_PREFIX) do + if value == prefix then return true end + end + return false +end + function ADNaming.fleetName(role, subtype, names) local prefix if role == "harvester" then diff --git a/FS25_ADSmartPickup/adRunsController.lua b/FS25_ADSmartPickup/adRunsController.lua index 831e265..006854b 100644 --- a/FS25_ADSmartPickup/adRunsController.lua +++ b/FS25_ADSmartPickup/adRunsController.lua @@ -272,10 +272,11 @@ function ADRunsController.applyVehicleNamesThrottled(adEnv, dt) if nameTimerMs < ADRunsController.NAME_INTERVAL_MS then return end nameTimerMs = 0 ADRunsController.applyVehicleNames(adEnv) - -- markmaskiner uden eget navn (stadig modelnavnet) får et rollenavn - if ADFieldWork ~= nil and ADFieldWork.autoNameFleet ~= nil and ADFieldJobs ~= nil and ADFieldJobs.loaded then - local ok, err = pcall(ADFieldWork.autoNameFleet, adEnv) - if not ok then Logging.warning(ADRunsController.LOG_PREFIX .. "navne til markflåden fejlede: %s", tostring(err)) end + -- markmaskiner hedder efter deres aktuelle job ("Fertilizer F23 - 2"), og får deres faste navn igen bagefter (ADJobNames). + -- Den gamle engangs-rollenavngivning (ADFieldWork.autoNameFleet: "Tømmevogn 6" der kørte sprøjte) er slået fra (19/10). + if ADJobNames ~= nil and ADFieldJobs ~= nil and ADFieldJobs.loaded then + local ok, err = pcall(ADJobNames.apply, adEnv) + if not ok then Logging.warning(ADRunsController.LOG_PREFIX .. "jobnavne fejlede: %s", tostring(err)) end end end diff --git a/FS25_ADSmartPickup/l10n/l10n_da.xml b/FS25_ADSmartPickup/l10n/l10n_da.xml index 1d48f6b..2ce2f60 100644 --- a/FS25_ADSmartPickup/l10n/l10n_da.xml +++ b/FS25_ADSmartPickup/l10n/l10n_da.xml @@ -120,6 +120,23 @@ + + + + + + + + + + + + + + + + + diff --git a/FS25_ADSmartPickup/l10n/l10n_en.xml b/FS25_ADSmartPickup/l10n/l10n_en.xml index 1539175..da13cef 100644 --- a/FS25_ADSmartPickup/l10n/l10n_en.xml +++ b/FS25_ADSmartPickup/l10n/l10n_en.xml @@ -120,6 +120,23 @@ + + + + + + + + + + + + + + + + + diff --git a/FS25_ADSmartPickup/modDesc.xml b/FS25_ADSmartPickup/modDesc.xml index c861963..f950ee5 100644 --- a/FS25_ADSmartPickup/modDesc.xml +++ b/FS25_ADSmartPickup/modDesc.xml @@ -1,7 +1,7 @@ masterdraco - 1.62.351.0 + 1.62.352.0 <en>AD Smart Pickup</en> @@ -20,6 +20,7 @@ + diff --git a/docs/BRUGERMANUAL.md b/docs/BRUGERMANUAL.md index 60e26bd..6bf3efb 100644 --- a/docs/BRUGERMANUAL.md +++ b/docs/BRUGERMANUAL.md @@ -1581,6 +1581,8 @@ Har du flere skærebord, tager modden det nærmeste, der kan høste afgrøden. Såsæd, gødning og mineralfoder i bigbags/sække kan den godt. Har et flow allerede en Autoload-vogn, sendes den ikke ud efter korn (loggen: *"vognen kan ikke bære flowets varer — skift vogn, eller slå Autoload fra"*). +- **Maskinerne hedder efter deres job:** under et markjob hedder en maskine fx *"Gødning F23"* (*"Fertilizer F23"* på + engelsk), flere på samme job *"… - 1"*, *"… - 2"*. Bagefter får den sit eget navn igen (fra før jobbet eller P-pladsen). - **Tømmevogn fast i "Field detection":** står en Courseplay-tømmevogn og venter på markens grænse i over 2 minutter, måles grænsen igen fra et punkt inde på marken. Hjælper det ikke, får du besked. - **Høster med anden afgrøde i tanken:** en mejetærsker sendes aldrig til en mark med en anden afgrøde, end den har i diff --git a/docs/USER_MANUAL.md b/docs/USER_MANUAL.md index d630833..fc991e2 100644 --- a/docs/USER_MANUAL.md +++ b/docs/USER_MANUAL.md @@ -1629,6 +1629,8 @@ If you have several headers, the mod takes the nearest one that can harvest the should haul grain. Seeds, fertilizer and mineral feed in big bags/sacks are fine. A flow that already has an Autoload trailer is not sent out for grain (log: *"vognen kan ikke bære flowets varer — skift vogn, eller slå Autoload fra"*). +- **Machines are named after their job:** during field work a machine is called e.g. *"Fertilizer F23"*, several on + the same job *"… - 1"*, *"… - 2"*. Afterwards it gets its own name back (from before the job or its P bay). - **Unloader stuck in "Field detection":** if a Courseplay unloader waits for the field boundary for more than 2 minutes, the boundary is detected again from a point inside the field. If that doesn't help, you get a notice. - **Harvester with another crop in the tank:** a combine is never sent to a field with a different crop than its tank