From 95e69aa66289494e4789904826d6dafffc2b24f8 Mon Sep 17 00:00:00 2001 From: masterdraco Date: Mon, 19 Oct 2026 11:19:54 +0200 Subject: [PATCH] =?UTF-8?q?feat:=20spillerens=20maskine=20(10=20min)=20+?= =?UTF-8?q?=20udbringeres=20last=20s=C3=A6lges=20aldrig=20ved=20oprydning?= =?UTF-8?q?=20(1.62.368)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CHANGELOG.md | 1 + FS25_ADSmartPickup/adFieldWork.lua | 2 + FS25_ADSmartPickup/adFlowSleep.lua | 25 ++++ FS25_ADSmartPickup/adFlowWagons.lua | 32 ++++- FS25_ADSmartPickup/adPlayerClaim.lua | 173 +++++++++++++++++++++++++++ FS25_ADSmartPickup/adSmartPickup.lua | 4 + FS25_ADSmartPickup/modDesc.xml | 3 +- docs/BRUGERMANUAL.md | 18 +++ docs/USER_MANUAL.md | 19 +++ 9 files changed, 274 insertions(+), 3 deletions(-) create mode 100644 FS25_ADSmartPickup/adPlayerClaim.lua diff --git a/CHANGELOG.md b/CHANGELOG.md index 7535214..d68ccf7 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.368** Spillerens maskine (brugerønske 19/10): en traktor spilleren selv kører, og dens påkoblede redskaber, er spillerens i 10 min efter sidste kørsel (tiden tæller fra han stiger ud) — ingen flow-opvågning, lån, maskinpulje, kæde eller oprydning rører dem; et flow, hvis traktor/vogn spilleren bruger, sover videre ("spilleren bruger '…'") i stedet for at bytte traktoren ud. Vogn sat på sin P-plads og koblet af er fri med det samme. Efter de 10 min kører en ubrugt traktor væk fra sin plads selv hjem: vognen tømmes (lager, ellers salg) og sættes på sin P-plads. Desuden: en udbringers last (gødning, kalk, frø i sprøjte/spreder/såmaskine) sælges aldrig ved oprydning — den parkeres med lasten (in-game 19/10 11:10: oprydning efter genindlæsning solgte 100.000 l flydende gødning fra flere sprøjter). - **1.62.367** Fremrulning ved aflæsning ser også staldenes fodertrug (spillets husbandry-trug ligger ikke blandt siloernes triggere): en lang læssevogn, der holder ved markøren med tippestedet nogle meter før truget, ruller nu frem, til AutoDrive tipper (in-game 19/10: 'Sheep Food' med BOSS ALPIN 251 stod 8 m før fåre-/gedestaldens trug med 5 mio. l hø, selv om truget tog hø og havde plads). Kun gårdens egne stalde (samme ejerregel som siloer) og trug med plads til varen. - **1.62.366** Vogn parkeret med læs vågner også ved små mål: kravet til fri plads er højst flowets "kør hjem under"-andel af målets kapacitet (standard 50 %, samme som Wait-reglen) — før ventede 'Chicken Food' med 259.388 l hvede på 64.847 l fri ved hønsehuse med 12.938 l kapacitet og vågnede aldrig (in-game 19/10). Statusteksten viser det rigtige krav. - **1.62.365** Lån en ledig traktor, lettere at slå til: den vogn flowets egen traktor har på (med egen P-plads og "Connect P …"-markør) tilbydes og vælges som lånevogn — før skulle flowet stoppes, så vognen stod frakoblet (in-game 19/10: honning-vognen "P U Pallevogn" sad på 1050'en, og guiden sagde "no free trailer"). Ved gem kører den gamle traktor vognen på dens P-plads (med læs: parkeret med læsset, ikke tømt) og selv hjem. Mangler en vogn, siger guiden præcis hvad (egen AD-parkering "P " + markør "Connect P ", frakoblet, kan bære varen). Manualerne har fået et samlet afsnit om lånt traktor (krav, opsætning, hvad der sker, statustekster). diff --git a/FS25_ADSmartPickup/adFieldWork.lua b/FS25_ADSmartPickup/adFieldWork.lua index b507ed3..96e45ba 100644 --- a/FS25_ADSmartPickup/adFieldWork.lua +++ b/FS25_ADSmartPickup/adFieldWork.lua @@ -311,6 +311,8 @@ local function isBusyVehicle(vehicle, id) return ADFieldJobs.state.assignments[id] ~= nil or (isAdActive(vehicle) and not isLoadTrip(vehicle)) or ADCpBridge.isWorking(vehicle) or (ADFieldSilos ~= nil and ADFieldSilos.isLoaned(vehicle)) or (ADPool ~= nil and ADPool.isReturning(vehicle)) or (ADFlowWagons ~= nil and ADFlowWagons.isEmptying(vehicle)) + -- spillerens maskine (kørt af spilleren de sidste 10 min): puljen, kæder og lån rører den ikke + or (ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle)) end ADFieldWork.isBusyVehicle = isBusyVehicle diff --git a/FS25_ADSmartPickup/adFlowSleep.lua b/FS25_ADSmartPickup/adFlowSleep.lua index 9b82f8a..78268a4 100644 --- a/FS25_ADSmartPickup/adFlowSleep.lua +++ b/FS25_ADSmartPickup/adFlowSleep.lua @@ -556,6 +556,10 @@ local function staffBorrowed(adEnv, run, now) return false end local wagonName = tostring(ADRuns.vehicleLabel(wagon)) + if ADPlayerClaim ~= nil and ADPlayerClaim.claims(wagon) then + noteNoWork(run, string.format("spilleren bruger vognen '%s'", wagonName), now) + return false + end local attacher = wagon.getAttacherVehicle ~= nil and wagon:getAttacherVehicle() or nil local attacherInfo = nil if attacher ~= nil then @@ -590,7 +594,28 @@ end local borrowRetryAt = {} -- runId -> ms: lånt traktor kunne ikke starte — ikke låne igen før (review 19/10: ellers blev en -- ny puljetraktor hentet og sendt hjem ved hvert vågn-tjek) +-- Bruger spilleren en af flowets traktorer eller vogne (ADPlayerClaim)? Så sover flowet videre — ikke byt traktoren ud +-- (review 19/10: at sætte sig ind i flowets traktor fik ellers opvågningen til at give flowet en anden traktor for altid). +-- -> navnet eller nil +local function playerUses(run, byId) + if ADPlayerClaim == nil then return nil end + for _, tractorId in ipairs(run.vehicleIds or {}) do + local own = byId[tractorId] + if own ~= nil and ADPlayerClaim.claims(own) then return tostring(ADRuns.vehicleLabel(own)) end + end + for _, wagonId in ipairs(ADRuns.wagonIdsOf(run)) do + local wagon = findVehicle(wagonId) + if wagon ~= nil and ADPlayerClaim.claims(wagon) then return tostring(ADRuns.vehicleLabel(wagon)) end + end + return nil +end + local function wake(adEnv, run, byId, why) + local used = playerUses(run, byId) + if used ~= nil then + noteNoWork(run, string.format("spilleren bruger '%s'", used), nowMs()) + return + end if run.borrowWagonId ~= nil and #(run.vehicleIds or {}) == 0 then local now = nowMs() if borrowRetryAt[run.id] ~= nil and now < borrowRetryAt[run.id] then diff --git a/FS25_ADSmartPickup/adFlowWagons.lua b/FS25_ADSmartPickup/adFlowWagons.lua index a6a0fc6..796687d 100644 --- a/FS25_ADSmartPickup/adFlowWagons.lua +++ b/FS25_ADSmartPickup/adFlowWagons.lua @@ -43,6 +43,16 @@ function ADFlowWagons.isWorkTool(object) return object ~= nil and (object.spec_stonePicker ~= nil or object.spec_sowingMachine ~= nil) end +-- Udbringer (sprøjte, spreder, gyllevogn, såmaskine): dens last er markens forbrug (gødning, kalk, frø …). Den +-- sælges aldrig ved oprydning — vognen parkeres med lasten (in-game 19/10 11:10: tre sprøjter fundet uden opgave efter +-- genindlæsning solgte hver 100.000 l flydende gødning ved Liquid Buy Silo). objects = de påkoblede redskaber. +function ADFlowWagons.isApplicatorSet(objects) + for _, object in ipairs(objects or {}) do + if object ~= nil and (object.spec_sprayer ~= nil or object.spec_sowingMachine ~= nil) then return true end + end + return false +end + -- Glem traktorens vogn: ny tabel uden den. function ADFlowWagons.forget(wagons, tractorId) if (wagons or {})[tractorId] == nil then return wagons end @@ -448,6 +458,7 @@ end -- Hvilken af isPoolBusy's grunde (til loggen). function ADFlowWagons.busyWhy(vehicle, tractorId) + if ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle) then return "spilleren bruger den" end if ADFieldJobs ~= nil and ADFieldJobs.state.assignments[tractorId] ~= nil then return "markopgave" end if ADFieldSilos ~= nil and ADFieldSilos.isLoaned(vehicle) then return "lånt af marksilo" end if ADPool ~= nil and ADPool.isReturning(vehicle) then return "sætter redskab af" end @@ -463,6 +474,7 @@ function ADFlowWagons.isPoolBusy(vehicle, tractorId) or (ADPool ~= nil and ADPool.isReturning(vehicle)) or (ADCpBridge ~= nil and ADCpBridge.isWorking(vehicle)) or (ADFlowWagons.isEmptying ~= nil and ADFlowWagons.isEmptying(vehicle)) + or (ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle)) end -- Flowet kunne ikke starte lige efter vognen blev hentet: vognen står stadig på sin plads (traktoren er ved Connect), @@ -535,7 +547,8 @@ function ADFlowWagons.beforeStart(adEnv, run, vehicle) hasRear = #ADHitch.rearImplementsOf(vehicle) > 0, wagonId = wagonId, wagonExists = wagon ~= nil, hasConnect = connectId ~= nil, wagonAttached = wagon ~= nil and wagon.getAttacherVehicle ~= nil and wagon:getAttacherVehicle() ~= nil, - wagonBusy = wagonId ~= nil and ADPool.isReserved(wagonId), + -- spilleren bruger vognen (fx kørt ud på marken og koblet af dér): vent + wagonBusy = wagonId ~= nil and (ADPool.isReserved(wagonId) or (ADPlayerClaim ~= nil and ADPlayerClaim.claims(wagon))), } local action = ADFlowWagons.startAction(startState) if action == "start" then lastWaitText[vehicle] = nil return false end @@ -680,7 +693,15 @@ local function startDump(adEnv, vehicle, state) okSet and fieldSilos or nil, state.triedMarkers, true) -- intet lager tager varen overhovedet (ikke bare fuldt): sælg resten ved bedste salgssted (in-game 16/10: 20.644 l -- sorte bønner parkeret med last — gården har intet lager til bønner) - if (not ok or marker == nil) and ADFieldWork.findSaleMarker ~= nil then + -- alle enheder lasten ligger i (hele vognkæden, som cargoOf) + de direkte redskaber (review 19/10) + local implements = {} + local okUnits, units = pcall(adEnv.AutoDrive.getAllDischargeableUnits, vehicle) + for _, unit in ipairs(okUnits and units or {}) do table.insert(implements, unit.object) end + for _, implement in ipairs(ADHitch.directImplementsOf(vehicle)) do table.insert(implements, implement.object) end + local applicator = ADFlowWagons.isApplicatorSet(implements) + if (not ok or marker == nil) and applicator then + why = "udbringerens last sælges ikke" + elseif (not ok or marker == nil) and ADFieldWork.findSaleMarker ~= nil then local okAny, anyStore = pcall(ADLoadSwap.anyStoreAccepts, adEnv, vehicle, fillType, nil) if okAny and not anyStore then local okSale, sale = pcall(ADFieldWork.findSaleMarker, adEnv, vehicle, fillType, nil) @@ -694,6 +715,12 @@ local function startDump(adEnv, vehicle, state) if not ok or marker == nil then Logging.warning(ADFlowWagons.LOG_PREFIX .. "'%s' har stadig %d l %s — intet sted at aflæsse (%s); parkeres med last", tostring(ADRuns.vehicleLabel(vehicle)), math.floor(cargo), fillName(fillType), tostring(ok and why or marker)) + -- vognbytte venter på tømningen: fortsæt byttet (som giveUp) i stedet for at køre hjem med vognen (review 19/10) + if state.onEmptied ~= nil then + emptying[vehicle] = nil + state.onEmptied() + return + end goHome(adEnv, vehicle) return end @@ -1006,6 +1033,7 @@ local function tickOrphans(adEnv, elapsed) local owned = (module ~= nil and module:isActive()) or (vehicle.getIsControlled ~= nil and vehicle:getIsControlled()) or (run ~= nil and not run.stopped) or (ADFieldJobs ~= nil and id ~= nil and ADFieldJobs.state.assignments[id] ~= nil) or (ADCpBridge ~= nil and ADCpBridge.isWorking(vehicle)) or #ADHitch.rearImplementsOf(vehicle) == 0 + or (ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle)) local atOwnPark = false local parkId = ADFieldWork ~= nil and ADFieldWork.parkMarkerId ~= nil and ADFieldWork.parkMarkerId(adEnv, vehicle) or nil local parkWp = parkId ~= nil and adEnv.ADGraphManager:getWayPointById(parkId) or nil diff --git a/FS25_ADSmartPickup/adPlayerClaim.lua b/FS25_ADSmartPickup/adPlayerClaim.lua new file mode 100644 index 0000000..a577a45 --- /dev/null +++ b/FS25_ADSmartPickup/adPlayerClaim.lua @@ -0,0 +1,173 @@ +-- AD Player Claim +-- Spillerens maskine (brugerønske 19/10: "jeg låner en tilfældig traktor ... og en tom opsamlervogn der tilhørte Cow +-- Food"). En traktor spilleren selv KØRER (sidder i, AutoDrive/Courseplay slukket, i bevægelse) og dens påkoblede +-- redskaber er spillerens i CLAIM_MS efter sidste kørsel: ingen flow-opvågning, lånt traktor, maskinpulje eller +-- oprydning rører dem. At sidde i en traktor AD kører (kigge med) tæller ikke. Sættes vognen tilbage på sin P-plads og +-- kobles af, er den fri med det samme. Når tiden er gået, og traktoren holder ubrugt væk fra sin plads, kører den selv +-- hjem: vognen tømmes (lager, ellers salg; en udbringers last sælges aldrig) og sættes på sin P-plads. +-- Ren logik øverst (testes med luajit), spil-adapter nederst. + +ADPlayerClaim = {} +ADPlayerClaim.LOG_PREFIX = "ADSmartPickup: spillerens maskine: " +ADPlayerClaim.CLAIM_MS = 10 * 60 * 1000 +ADPlayerClaim.TICK_MS = 1000 +ADPlayerClaim.DRIVE_SPEED = 0.0003 -- m/ms (ca. 1 km/t): spilleren kører den +ADPlayerClaim.OWN_PARK_M = 30 -- så tæt på sin egen P-plads = sat på plads + +-- ---- ren logik ---- + +-- s = {controlled, autoDriving, sinceMs (siden sidste spillerkørsel, nil = aldrig), attached, atOwnPark} -> bool +function ADPlayerClaim.isClaimed(s) + -- sidder i en holdende maskine uden AD/CP: spillerens (en opvågning må ikke starte den under ham) + if s.controlled and not s.autoDriving then return true end + if s.sinceMs == nil or s.sinceMs >= ADPlayerClaim.CLAIM_MS then return false end + -- sat tilbage på sin plads og koblet af: fri med det samme + if s.atOwnPark and not s.attached then return false end + return true +end + +-- Kør selv hjem nu? s = {wasClaimed, claimed, motorized, busy, atOwnPark, hasPark} +function ADPlayerClaim.returnAction(s) + if not s.wasClaimed or s.claimed or not s.motorized or s.busy or s.atOwnPark then return nil end + return s.hasPark and "home" or "noPark" +end + +-- ---- spil-adapter ---- + +local lastDriven = setmetatable({}, {__mode = "k"}) -- køretøj -> ms for sidste spillerkørsel +local claimedBefore = setmetatable({}, {__mode = "k"}) -- køretøj -> true: var spillerens ved sidste tick +local loggedNoPark = setmetatable({}, {__mode = "k"}) +local timerMs, clock = 0, 0 +local env = nil + +local function controlled(vehicle) + return vehicle.getIsControlled ~= nil and vehicle:getIsControlled() == true +end + +local function autoDriving(vehicle) + local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil + return (module ~= nil and module:isActive()) or (ADCpBridge ~= nil and ADCpBridge.isWorking ~= nil and ADCpBridge.isWorking(vehicle) == true) +end + +-- Traktoren og alle redskaber i kæden bag/foran den. +local function rigOf(vehicle) + local list = {vehicle} + if vehicle.getChildVehicles ~= nil then + local ok, children = pcall(vehicle.getChildVehicles, vehicle) + for _, child in ipairs(ok and children or {}) do if child ~= vehicle then table.insert(list, child) end end + elseif ADHitch ~= nil then + for _, implement in ipairs(ADHitch.directImplementsOf(vehicle)) do table.insert(list, implement.object) end + end + return list +end + +local function isAttached(vehicle) + if vehicle.getAttacherVehicle ~= nil and vehicle:getAttacherVehicle() ~= nil then return true end + return ADHitch ~= nil and #ADHitch.directImplementsOf(vehicle) > 0 +end + +local function atOwnPark(vehicle) + if env == nil or ADFieldWork == nil or ADFieldWork.parkMarkerId == nil or vehicle.rootNode == nil then return false end + local ok, parkId = pcall(ADFieldWork.parkMarkerId, env, vehicle) + local wp = ok and parkId ~= nil and env.ADGraphManager:getWayPointById(parkId) or nil + if wp == nil then return false end + local x, _, z = getWorldTranslation(vehicle.rootNode) + return (x - wp.x) ^ 2 + (z - wp.z) ^ 2 <= ADPlayerClaim.OWN_PARK_M ^ 2 +end + +local function hasFieldJob(vehicle) + if ADFieldJobs == nil or ADFieldJobs.state == nil or ADRunsController == nil then return false end + local assignments = ADFieldJobs.state.assignments or {} + local id = ADRunsController.getVehicleId(vehicle) + if id ~= nil and assignments[id] ~= nil then return true end + local attacher = vehicle.getAttacherVehicle ~= nil and vehicle:getAttacherVehicle() or nil + local attacherId = attacher ~= nil and ADRunsController.getVehicleId(attacher) or nil + return attacherId ~= nil and assignments[attacherId] ~= nil +end + +-- Er køretøjet spillerens lige nu? (til flows, lån, maskinpulje og oprydning). En markopgave spilleren kører ud for +-- moden (ADPlayerTransport: "kør sættet til marken og stig ud") er moddens, ikke spillerens. +function ADPlayerClaim.claims(vehicle) + if vehicle == nil or hasFieldJob(vehicle) then return false end + local since = lastDriven[vehicle] ~= nil and (clock - lastDriven[vehicle]) or nil + local isControlled = controlled(vehicle) + if since == nil and not isControlled then return false end + return ADPlayerClaim.isClaimed({controlled = isControlled, autoDriving = isControlled and autoDriving(vehicle), + sinceMs = since, attached = since ~= nil and isAttached(vehicle), atOwnPark = since ~= nil and atOwnPark(vehicle)}) +end + +-- Til loggen/statusvinduet: minutter tilbage, eller nil +function ADPlayerClaim.minutesLeft(vehicle) + if lastDriven[vehicle] == nil then return nil end + local left = ADPlayerClaim.CLAIM_MS - (clock - lastDriven[vehicle]) + return left > 0 and math.ceil(left / 60000) or nil +end + +local function label(vehicle) + return ADRuns ~= nil and tostring(ADRuns.vehicleLabel(vehicle)) or tostring(vehicle.getName ~= nil and vehicle:getName() or "?") +end + +local function isBusy(vehicle) + if autoDriving(vehicle) then return true end + local id = ADRunsController ~= nil and ADRunsController.getVehicleId(vehicle) or nil + if id ~= nil and ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and (ADFieldJobs.state.assignments or {})[id] ~= nil then return true end + if ADRunsController ~= nil and ADRunsController.getActiveRunForVehicle(vehicle) ~= nil then return true end + if ADPlayerTransport ~= nil and ADPlayerTransport.isPickup ~= nil and ADPlayerTransport.isPickup(vehicle) then return true end + return ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) ~= nil +end + +local function sendHome(vehicle) + local hasRear = ADHitch ~= nil and #ADHitch.rearImplementsOf(vehicle) > 0 + if hasRear and ADFlowWagons ~= nil and ADFlowWagons.homeVehicle ~= nil then + -- brugerønske 19/10: en vogn spilleren har efterladt med læs tømmes, så den er klar til sit eget flow (lager, + -- ellers salg — en udbringers gødning/kalk/frø sælges aldrig, den parkeres med lasten) + ADFlowWagons.homeVehicle(env, vehicle, nil, "playerClaim") + else + local parkId = ADFieldWork.parkMarkerId(env, vehicle) + ADFieldWork.startAd(env, vehicle, env.AutoDrive.MODE_DRIVETO, parkId, nil) + end + Logging.info(ADPlayerClaim.LOG_PREFIX .. "'%s' har stået ubrugt i %d min efter spillerkørsel — kører selv på plads%s", + label(vehicle), math.floor(ADPlayerClaim.CLAIM_MS / 60000), hasRear and " (vognen tømmes først og sættes på sin P-plads)" or "") +end + +local function checkReturn(vehicle) + local claimed = ADPlayerClaim.claims(vehicle) + local wasClaimed = claimedBefore[vehicle] == true + claimedBefore[vehicle] = claimed or nil + if not wasClaimed or claimed then return end + lastDriven[vehicle] = nil + local motorized = vehicle.spec_motorized ~= nil + local okPark, parkId = pcall(ADFieldWork.parkMarkerId, env, vehicle) + local action = ADPlayerClaim.returnAction({wasClaimed = true, claimed = false, motorized = motorized, + busy = motorized and isBusy(vehicle), atOwnPark = motorized and atOwnPark(vehicle), hasPark = okPark and parkId ~= nil}) + if action == "home" then + sendHome(vehicle) + elseif action == "noPark" and not loggedNoPark[vehicle] then + loggedNoPark[vehicle] = true + Logging.info(ADPlayerClaim.LOG_PREFIX .. "'%s' er fri igen, men har ingen AutoDrive-parkering — bliver stående", label(vehicle)) + end +end + +function ADPlayerClaim.tick(adEnv, dt) + timerMs = timerMs + (dt or 0) + clock = clock + (dt or 0) + if timerMs < ADPlayerClaim.TICK_MS then return end + timerMs = 0 + if adEnv == nil or g_currentMission == nil or g_currentMission.vehicleSystem == nil then return end + env = adEnv + for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do + -- spilleren kører selv (ikke AD/CP, i bevægelse): traktoren og hele dens sæt er spillerens fra nu. Sidder han + -- stille i en maskine han har kørt, tæller tiden fra han stiger ud (review: ellers kørte den hjem straks efter + -- en lang pause i førersædet). Moddens markopgaver (spilleren kører sættet ud) stemples ikke. + if controlled(vehicle) and not autoDriving(vehicle) and not hasFieldJob(vehicle) + and ((vehicle.lastSpeedReal or 0) >= ADPlayerClaim.DRIVE_SPEED or lastDriven[vehicle] ~= nil) then + for _, member in ipairs(rigOf(vehicle)) do + if not hasFieldJob(member) then lastDriven[member] = clock end + end + end + end + for vehicle in pairs(lastDriven) do + local ok, err = pcall(checkReturn, vehicle) + if not ok then Logging.warning(ADPlayerClaim.LOG_PREFIX .. "%s", tostring(err)) end + end +end diff --git a/FS25_ADSmartPickup/adSmartPickup.lua b/FS25_ADSmartPickup/adSmartPickup.lua index 002131d..6f099ba 100644 --- a/FS25_ADSmartPickup/adSmartPickup.lua +++ b/FS25_ADSmartPickup/adSmartPickup.lua @@ -1991,6 +1991,10 @@ function ADSmartPickup:update(dt) local okPark, errPark = pcall(ADParkGuard.tick, getAutoDriveEnv()) if not okPark then Logging.warning(ADSmartPickup.LOG_PREFIX .. "parkeringsvagt fejlede: %s", tostring(errPark)) end end + if ADPlayerClaim ~= nil then + local okClaim, errClaim = pcall(ADPlayerClaim.tick, getAutoDriveEnv(), dt) + if not okClaim then Logging.warning(ADSmartPickup.LOG_PREFIX .. "spillerens maskine fejlede: %s", tostring(errClaim)) end + end if ADFlowSleep ~= nil then local okSleep, errSleep = pcall(ADFlowSleep.tick, getAutoDriveEnv(), dt) if not okSleep then Logging.warning(ADSmartPickup.LOG_PREFIX .. "dvale fejlede: %s", tostring(errSleep)) end diff --git a/FS25_ADSmartPickup/modDesc.xml b/FS25_ADSmartPickup/modDesc.xml index e657576..0985711 100644 --- a/FS25_ADSmartPickup/modDesc.xml +++ b/FS25_ADSmartPickup/modDesc.xml @@ -1,7 +1,7 @@ masterdraco - 1.62.367.0 + 1.62.368.0 <en>AD Smart Pickup</en> @@ -74,6 +74,7 @@ + diff --git a/docs/BRUGERMANUAL.md b/docs/BRUGERMANUAL.md index b632002..81bdf26 100644 --- a/docs/BRUGERMANUAL.md +++ b/docs/BRUGERMANUAL.md @@ -879,6 +879,24 @@ kun en **vogn**, og en ledig traktor lånes til hver tur. Så sparer du traktore - Traktorer i **andre flows** lånes aldrig — heller ikke fra et sovende flow. Et kædeflow, du skifter til lån, hører ikke længere til kæden. +### Spillerens maskine (når du selv kører) + +Vil du selv hjælpe til — fx samle græs med en traktor og en opsamlervogn, der hører til et flow — tager moden ikke +maskinerne fra dig: + +- En traktor, du **selv kører** (AutoDrive og Courseplay slukket), og alt, der er koblet på den, er **din i 10 minutter** + efter, du sidst kørte den. I den tid bliver de ikke vækket af et flow, lånt af et flow med lånt traktor, taget af + maskinpuljen eller en kæde og ikke ryddet op. At sidde i en traktor, som AutoDrive kører (bare kigge med), tæller ikke. +- Sidder du i en holdende traktor, er den også din, så længe du sidder der. +- Sætter du vognen tilbage på dens P-plads og kobler den af, er den flowets igen med det samme. +- Et flow, der vil bruge vognen imens, venter (*spilleren bruger vognen '…'*). +- **Hop bare ud:** står traktoren ubrugt i 10 minutter væk fra sin plads, kører den selv hjem. Vognen **tømmes først** + (på et lager, ellers sælges varen), så den er klar til sit flow, og sættes så på sin P-plads. Gødning, kalk og frø i + en sprøjte, spreder eller såmaskine sælges aldrig — de parkeres med lasten. Loggen: *"spillerens maskine: '…' har stået ubrugt i 10 + min efter spillerkørsel — kører selv på plads"*. Uden AutoDrive-parkering bliver den stående. +- Markopgaver, hvor moden beder dig køre et sæt ud ("kør sættet til marken og stig ud"), er moddens og følger ikke + denne regel. + ### Maskinpuljen Maskinpuljen bruges af markarbejdet og marksiloerne, når der ikke står et færdigt sæt klar. diff --git a/docs/USER_MANUAL.md b/docs/USER_MANUAL.md index ac39a61..3e109c6 100644 --- a/docs/USER_MANUAL.md +++ b/docs/USER_MANUAL.md @@ -905,6 +905,25 @@ owns only a **trailer**; a free tractor is borrowed for each trip. That saves tr - Tractors in **other flows** are never borrowed — not even from a sleeping flow. A chain flow you switch to borrowing no longer belongs to the chain. +### The player's machine (when you drive yourself) + +If you want to help out yourself — e.g. collect grass with a tractor and a pick-up wagon that belong to a flow — the +mod does not take the machines from you: + +- A tractor you **drive yourself** (AutoDrive and Courseplay off) and everything attached to it are **yours for 10 + minutes** after you last drove it. During that time they are not woken by a flow, borrowed by a borrow flow, taken by + the machine pool or a chain, and not cleaned up. Sitting in a tractor AutoDrive is driving (just watching) does not + count. +- A stationary tractor you are sitting in is also yours while you sit there. +- Put the trailer back at its P bay and detach it, and it belongs to the flow again at once. +- A flow that wants the trailer meanwhile waits (*spilleren bruger vognen '…'*). +- **Just hop out:** if the tractor stands unused for 10 minutes away from its spot, it drives home by itself. The trailer + is **emptied first** (at a storage, otherwise the goods are sold) so it is ready for its flow, then parked at its P + bay. Fertilizer, lime and seed in a sprayer, spreader or seeder are never sold — they are parked with the load. Log: *"spillerens maskine: '…' har stået + ubrugt i 10 min efter spillerkørsel — kører selv på plads"*. Without an AutoDrive parking it stays where it is. +- Field jobs where the mod asks you to drive a set out ("drive the set to the field and get out") belong to the mod and + do not follow this rule. + ### The machine pool The machine pool is used by field work and field silos when no ready-made set is free.