diff --git a/CHANGELOG.md b/CHANGELOG.md index 4ffa67f..3533761 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.16** Nyt: påfyldning fra paller. Er en såmaskine, spreder eller sprøjte tom, og har intet lager/købested varen, finder moden paller med varen — løse paller eller paller i et palleskur — kører til AutoDrive-markøren ved dem, tager en palle ud af skuret og overfører varen (200 l/s, inden for 20 m). Risplanteren genkendes nu (frø-varen er ris-stiklinger, ikke SEEDS), og en tom såmaskine sendes ud, når dens frø findes på paller. - **1.62.15** Rettet: (1) en traktor med en fyldt vogn uden opgave efter genindlæsning parkerede vognen fuld — nu aflæsses den i en silo først. (2) En selvkørende sprøjte blev regnet som ledig puljetraktor og sendt efter en tømmevogn. - **1.62.14** Rettet: høstere sprang stykker over ved genstart, fordi Courseplays startpunkt stod på "nærmeste". Nu starter et nyt job som før (første waypoint på en ny mark), og straks efter skiftes maskinens CP-startpunkt til "sidste" — enhver genstart fortsætter, hvor den slap. Genstart efter indlæsning bruger også "sidste" for markmaskiner. - **1.62.13** Rettet: traktoren der skal hente et puljeredskab kunne blive holdende ved vognen uden at koble på — AutoDrive styrer efter traktorens midte, så krogen ramte trækøjet før målet, og AD blev aldrig færdig. Holder AD stille ved sidste waypoint inden for 5 m af Connect-markøren i 4 s, stoppes AD, og moden kobler på. diff --git a/FS25_ADSmartPickup/adCpBridge.lua b/FS25_ADSmartPickup/adCpBridge.lua index 4c7fcaf..906dbd7 100644 --- a/FS25_ADSmartPickup/adCpBridge.lua +++ b/FS25_ADSmartPickup/adCpBridge.lua @@ -238,15 +238,31 @@ local function seederOf(vehicle) return nil end --- Har såmaskinen frø på? (fyldenheder med SEEDS) +-- Såmaskinens frø-vare: SEEDS når enheden tager det, ellers enhedens egen (risplanter: RICESAPLINGS — in-game 4/10). +function ADCpBridge.seedFillTypeOf(seeder) + if seeder == nil or g_fillTypeManager == nil then return nil end + local seedsIndex = g_fillTypeManager:getFillTypeIndexByName("SEEDS") + local spec = seeder.spec_sowingMachine + local unitIndex = spec ~= nil and spec.fillUnitIndex or nil + local units = seeder.spec_fillUnit ~= nil and seeder.spec_fillUnit.fillUnits or {} + local unit = unitIndex ~= nil and units[unitIndex] or nil + if unit == nil or unit.supportedFillTypes == nil then return seedsIndex end + if unit.supportedFillTypes[seedsIndex] then return seedsIndex end + for fillType, supported in pairs(unit.supportedFillTypes) do + if supported then return fillType end + end + return seedsIndex +end + +-- Har såmaskinen frø på? (frø-enheden, uanset om det er SEEDS eller fx ris-stiklinger) function ADCpBridge.hasSeeds(vehicle) local seeder = seederOf(vehicle) if seeder == nil then return false end local ok, has = pcall(function() - local seedsIndex = g_fillTypeManager:getFillTypeIndexByName("SEEDS") + local seedType = ADCpBridge.seedFillTypeOf(seeder) for index, unit in ipairs(seeder.spec_fillUnit ~= nil and seeder.spec_fillUnit.fillUnits or {}) do - if unit.fillType == seedsIndex and (unit.fillLevel or 0) > 0 then return true end - if unit.supportedFillTypes ~= nil and unit.supportedFillTypes[seedsIndex] and seeder:getFillUnitFillLevel(index) > 0 then return true end + if unit.fillType == seedType and (unit.fillLevel or 0) > 0 then return true end + if unit.supportedFillTypes ~= nil and unit.supportedFillTypes[seedType] and seeder:getFillUnitFillLevel(index) > 0 then return true end end return false end) @@ -289,7 +305,7 @@ end function ADCpBridge.getRefillFillType(vehicle, role) for _, object in ipairs(collect(vehicle)) do if object.spec_sowingMachine ~= nil and g_fillTypeManager ~= nil then - return g_fillTypeManager:getFillTypeIndexByName("SEEDS") + return ADCpBridge.seedFillTypeOf(object) end end for _, object in ipairs(collect(vehicle)) do diff --git a/FS25_ADSmartPickup/adFieldWork.lua b/FS25_ADSmartPickup/adFieldWork.lua index d5a8ed2..9ee4e27 100644 --- a/FS25_ADSmartPickup/adFieldWork.lua +++ b/FS25_ADSmartPickup/adFieldWork.lua @@ -172,6 +172,7 @@ function ADFieldWork.getRigs(adEnv) if role == "seeder" then rig.seedFruits = ADCpBridge.getSeedFruits(vehicle) rig.hasSeeds = ADCpBridge.hasSeeds(vehicle) + rig.seedsOnPallets = not rig.hasSeeds and ADFieldWork.seedsOnPallets(vehicle) end if role == "weeder" then rig.mechanical = ADCpBridge.isMechanicalWeeder(vehicle) end table.insert(rigs, rig) @@ -298,6 +299,30 @@ function ADFieldWork.release(assignment, phase) ADFieldJobs.state.assignments[assignment.vehicleId] = nil end +-- Findes såmaskinens frø (SEEDS eller fx ris-stiklinger) på paller hos gården? +function ADFieldWork.seedsOnPallets(vehicle) + if ADPalletRefill == nil or vehicle == nil or vehicle.getOwnerFarmId == nil then return false end + local ok, result = pcall(function() + local fillType = ADCpBridge.getRefillFillType(vehicle, "seeder") + return fillType ~= nil and ADPalletRefill.hasAny(vehicle:getOwnerFarmId(), fillType) + end) + return ok and result == true +end + +-- Tom og ingen station med varen: paller (løse eller i palleskur). -> true når påfyldningen er startet +local function startPalletRefill(adEnv, assignment, vehicle, fillType, label) + if ADPalletRefill == nil then return false end + local ok, source = pcall(ADPalletRefill.findSource, adEnv, vehicle, fillType) + if not ok or source == nil then return false end + assignment.pallet = ADPalletRefill.newJob(source, fillType) + assignment.phase, assignment.since = "palletRefill", now() + assignment.startX, assignment.startZ = vehiclePosition(vehicle) + startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, source.markerId, nil) + log(assignment.fieldId, "'%s' er tom — henter %s fra %s ved %s", tostring(label), ADPalletRefill.fillName(fillType), + tostring(source.kind), tostring(source.markerName)) + return true +end + local function fail(fieldId, text) note(fieldId, {retryAt = now() + ADFieldModel.RETRY_MS, reason = {text = tostring(text)}}) log(fieldId, "%s", tostring(text)) @@ -334,7 +359,10 @@ local function acceptFor(field, info, role) return function(candidate) return ADManualTransport.acceptsHarvester(candidate, fruit) end elseif role == "seeder" then local fruitIndex = ADFieldWork.sowFruitIndex(field) - return function(candidate) return candidate.hasSeeds and fruitIndex ~= nil and candidate.seedFruits[fruitIndex] == true end + -- tom såmaskine er med, når dens frø findes på paller (risplanter + stiklingepaller, in-game 4/10) + return function(candidate) + return (candidate.hasSeeds or candidate.seedsOnPallets) and fruitIndex ~= nil and candidate.seedFruits[fruitIndex] == true + end elseif role == "weeder" then local large = (info.weed or 0) > ADFieldModel.WEED_MECHANICAL_MAX return function(candidate) return not (large and candidate.mechanical) end @@ -434,6 +462,7 @@ function ADFieldWork.dispatchPool(adEnv, field, info, role, roleAccept, decision if role == "seeder" then candidate.seedFruits = ADCpBridge.getSeedFruits(implement.vehicle) candidate.hasSeeds = ADCpBridge.hasSeeds(implement.vehicle) + candidate.seedsOnPallets = not candidate.hasSeeds and ADFieldWork.seedsOnPallets(implement.vehicle) end if role == "weeder" then candidate.mechanical = ADCpBridge.isMechanicalWeeder(implement.vehicle) end if roleAccept ~= nil and not roleAccept(candidate) then return false end @@ -564,8 +593,14 @@ function ADFieldWork.dispatch(adEnv, field, info, decision) else local refill = refillPlan(adEnv, field.id, rig.vehicle, role, info.x, info.z) if refill ~= nil and refill.empty and refill.refillId == nil then - -- tom og intet sted at fylde op: ud på marken ville den bare køre kurset uden at sprede - fail(field.id, string.format("'%s' er tom for %s og der er ingen påfyldning med AutoDrive-markør — fyld den op", rig.label, fillTypeName(refill.fillType))) + -- tom og ingen station: paller (palleskur/løse); ellers ville den bare køre kurset uden at sprede + ADFieldJobs.state.assignments[rig.id] = assignment + if startPalletRefill(adEnv, assignment, rig.vehicle, refill.fillType, rig.label) then + note(field.id, {reason = false}) + return + end + ADFieldJobs.state.assignments[rig.id] = nil + fail(field.id, string.format("'%s' er tom for %s og der er ingen påfyldning eller palle med AutoDrive-markør — fyld den op", rig.label, fillTypeName(refill.fillType))) return end assignment.startX, assignment.startZ = rig.x, rig.z @@ -1301,6 +1336,10 @@ function ADFieldWork.follow(adEnv, assignment) -- som almindelig udsendelse: tom såmaskine/sprøjte fyldes op på vejen, uden påfyldning køres den hjem igen local refill = refillPlan(adEnv, assignment.fieldId, vehicle, assignment.role, info.x, info.z) local nextDrive = ADPool.nextDrive(refill) + if nextDrive == "empty" and startPalletRefill(adEnv, assignment, vehicle, refill.fillType, assignment.pool.implementName) then + assignment.width = width + return + end if nextDrive == "empty" then ADFieldWork.release(assignment) ADHitch.returnHome(adEnv, vehicle) @@ -1350,6 +1389,27 @@ function ADFieldWork.follow(adEnv, assignment) end end end + elseif assignment.phase == "palletRefill" then + local okTick, result, why = pcall(ADPalletRefill.tick, adEnv, assignment, ADFieldJobs.TICK_MS or 1000) + if not okTick then + result, why = "failed", tostring(result) + end + if result == "done" then + log(assignment.fieldId, "'%s' fyldt op med %.0f %s fra paller — kører til %s", ADRuns.vehicleLabel(vehicle), assignment.pallet.filled or 0, + ADPalletRefill.fillName(assignment.pallet.fillType), tostring(info ~= nil and info.markerName or "?")) + assignment.pallet = nil + assignment.phase, assignment.since = "driving", now() + assignment.startX, assignment.startZ = vehiclePosition(vehicle) + startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, info.markerId, nil) + assignment.drive = {mode = adEnv.AutoDrive.MODE_DRIVETO, first = info.markerId} + elseif result == "failed" then + ADFieldWork.release(assignment) + fail(assignment.fieldId, string.format("påfyldning fra paller mislykkedes for '%s' (%s)", ADRuns.vehicleLabel(vehicle), tostring(why))) + if not (ADHitch ~= nil and ADHitch.returnHome(adEnv, vehicle)) then + local park = parkMarkerId(adEnv, vehicle) + if park ~= nil then startAd(adEnv, vehicle, adEnv.AutoDrive.MODE_DRIVETO, park, nil) end + end + end elseif assignment.phase == "waitingCourse" then if now() - assignment.since > ADFieldWork.COURSE_WAIT_MS then ADFieldWork.release(assignment) diff --git a/FS25_ADSmartPickup/adPalletRefill.lua b/FS25_ADSmartPickup/adPalletRefill.lua new file mode 100644 index 0000000..066e9a5 --- /dev/null +++ b/FS25_ADSmartPickup/adPalletRefill.lua @@ -0,0 +1,257 @@ +-- AD Pallet Refill +-- Påfyldning fra paller: er et sæt tomt, og har intet lager/købested varen, finder moden paller med varen — løse +-- paller ude eller paller i et palleskur (objektlager). Sættet kører til AutoDrive-markøren ved pallen/skuret, +-- tager en palle ud af lageret (som knappen i spillet) og flytter varen over inden for rækkevidde (som pallens +-- egen påfyldningstrigger, men uden at redskabets åbning skal stå præcist). Tomme paller fjerner spillet selv. +-- (in-game 4/10: kalk og gødning i palleskuret, ris-stiklinger ved risplanteren) +-- Ren logik øverst (testes med luajit), spil-adapter nederst. + +ADPalletRefill = {} +ADPalletRefill.LOG_PREFIX = "ADSmartPickup: palle: " +ADPalletRefill.REACH_M = 20 -- pallen må højst stå så langt fra redskabet +ADPalletRefill.MARKER_RANGE_M = 40 -- AD-markøren skal stå så tæt på pallen/skuret +ADPalletRefill.ARRIVE_M = 8 -- fremme ved markøren +ADPalletRefill.RATE_LPS = 200 -- som en big bags egen påfyldning (200 l/s) +ADPalletRefill.SPAWN_WAIT_MS = 15000 -- så længe ventes på en udtaget palle +ADPalletRefill.START_GRACE_MS = 3000 + +-- ---- ren logik ---- + +function ADPalletRefill.nearest(list, x, z) + local best, bestDistance = nil, math.huge + for _, item in ipairs(list or {}) do + local d = (item.x - x) ^ 2 + (item.z - z) ^ 2 + if d < bestDistance then best, bestDistance = item, d end + end + return best +end + +function ADPalletRefill.transferAmount(rateLps, dtMs, palletLevel, free) + return math.max(0, math.min(rateLps * dtMs / 1000, palletLevel or 0, free or 0)) +end + +function ADPalletRefill.newJob(source, fillType) + return {source = source, fillType = fillType, state = "driving", elapsed = 0, seenActive = false, + spawnPending = false, spawnedAt = 0, filled = 0} +end + +-- Et skridt. s = {adActive, distance, free, palletLevel, stored} -> job, handling ("wait"|"transfer"|"spawn"|nil) +-- Tilstande: driving -> filling -> done | failed (reason: notArrived / noPallet / spawnTimeout) +function ADPalletRefill.step(job, s, dt) + job.elapsed = job.elapsed + (dt or 0) + if job.state == "driving" then + if s.adActive then + job.seenActive = true + return job, "wait" + end + if (s.distance or math.huge) <= ADPalletRefill.ARRIVE_M then + job.state, job.elapsed = "filling", 0 + return job, "wait" + end + if job.seenActive or job.elapsed >= ADPalletRefill.START_GRACE_MS then + job.state, job.reason = "failed", "notArrived" + end + return job, nil + end + if job.state ~= "filling" then return job, nil end + if (s.free or 0) < 1 then + job.state = "done" + return job, nil + end + if (s.palletLevel or 0) > 0 then + job.spawnPending = false + return job, "transfer" + end + if job.spawnPending then + if job.elapsed - job.spawnedAt < ADPalletRefill.SPAWN_WAIT_MS then return job, "wait" end + job.state, job.reason = "failed", "spawnTimeout" + return job, nil + end + if (s.stored or 0) > 0 then + job.spawnPending, job.spawnedAt = true, job.elapsed + return job, "spawn" + end + -- ingen paller tilbage: kør videre med det der kom på, ellers fejl + if (job.filled or 0) > 0 then + job.state = "done" + else + job.state, job.reason = "failed", "noPallet" + end + return job, nil +end + +-- ---- spil ---- + +local function positionOf(object) + if object == nil or object.rootNode == nil then return nil end + local x, _, z = getWorldTranslation(object.rootNode) + return x, z +end + +local function isPallet(vehicle) + return vehicle.spec_pallet ~= nil or vehicle.typeName == "pallet" +end + +-- Fyldenheden på et objekt med varen: index, niveau (nil hvis ingen) +local function unitWith(object, fillType) + for index in ipairs(object.getFillUnits ~= nil and object:getFillUnits() or {}) do + if object:getFillUnitFillType(index) == fillType then + local level = object:getFillUnitFillLevel(index) or 0 + if level > 0 then return index, level end + end + end + return nil +end + +-- Løse paller med varen (ejet af gården, ikke læsset på noget) +function ADPalletRefill.loosePallets(farmId, fillType) + local result = {} + for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do + if isPallet(vehicle) and vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId then + local unit, level = unitWith(vehicle, fillType) + local x, z = positionOf(vehicle) + if unit ~= nil and x ~= nil then + table.insert(result, {vehicle = vehicle, unit = unit, level = level, x = x, z = z}) + end + end + end + return result +end + +-- Palleskure med varen +function ADPalletRefill.storages(farmId, fillType) + local result = {} + for _, placeable in pairs(g_currentMission.placeableSystem.placeables) do + if placeable.spec_objectStorage ~= nil and placeable.getOwnerFarmId ~= nil and placeable:getOwnerFarmId() == farmId then + local count = ADSources.countStored({placeable = placeable}, fillType) + local x, z = positionOf(placeable) + if count > 0 and x ~= nil then + table.insert(result, {placeable = placeable, count = count, x = x, z = z}) + end + end + end + return result +end + +-- Nærmeste AD-markør (ikke Wait) ved (x, z) med rute fra køretøjet +local function markerNear(adEnv, vehicle, x, z) + local best, bestDistance = nil, ADPalletRefill.MARKER_RANGE_M ^ 2 + for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do + local wp = adEnv.ADGraphManager:getWayPointById(marker.id) + if wp ~= nil and not (ADSupplyPlanner ~= nil and ADSupplyPlanner.isWaitMarker(marker)) then + local d = (wp.x - x) ^ 2 + (wp.z - z) ^ 2 + if d < bestDistance and (ADUnloadWait == nil or ADUnloadWait.hasRouteTo(adEnv, vehicle, marker.id)) then + best, bestDistance = marker, d + end + end + end + return best +end + +-- Hvor sættet kan få varen fra paller: {markerId, markerName, placeable?, x, z} eller nil, grund +function ADPalletRefill.findSource(adEnv, vehicle, fillType) + local farmId = vehicle:getOwnerFarmId() + local vx, vz = positionOf(vehicle) + if vx == nil then return nil, "ingen position" end + local candidates = {} + for _, pallet in ipairs(ADPalletRefill.loosePallets(farmId, fillType)) do + local marker = markerNear(adEnv, vehicle, pallet.x, pallet.z) + if marker ~= nil then table.insert(candidates, {markerId = marker.id, markerName = marker.name, x = pallet.x, z = pallet.z, kind = "palle"}) end + end + for _, storage in ipairs(ADPalletRefill.storages(farmId, fillType)) do + local marker = markerNear(adEnv, vehicle, storage.x, storage.z) + if marker ~= nil then + table.insert(candidates, {markerId = marker.id, markerName = marker.name, x = storage.x, z = storage.z, + placeable = storage.placeable, kind = "palleskur"}) + end + end + local best = ADPalletRefill.nearest(candidates, vx, vz) + if best == nil then return nil, "ingen paller med varen ved en AutoDrive-markør" end + return best +end + +-- Er der overhovedet paller med varen (ude eller i et skur)? Gemmes 10 s. +function ADPalletRefill.hasAny(farmId, fillType) + local function count() + return #ADPalletRefill.loosePallets(farmId, fillType) + #ADPalletRefill.storages(farmId, fillType) > 0 + end + if ADCache ~= nil and ADCache.get ~= nil then + return ADCache.get("palletAny", tostring(farmId) .. ":" .. tostring(fillType), 10000, count) + end + return count() +end + +local function collect(vehicle, list) + list = list or {} + table.insert(list, vehicle) + for _, implement in ipairs(vehicle.getAttachedImplements ~= nil and vehicle:getAttachedImplements() or {}) do + if implement.object ~= nil then collect(implement.object, list) end + end + return list +end + +-- Den del af sættet der skal have varen: objekt, enhed, ledig plads +function ADPalletRefill.receiverOf(vehicle, fillType) + for _, object in ipairs(collect(vehicle)) do + for index in ipairs(object.getFillUnits ~= nil and object:getFillUnits() or {}) do + if object:getFillUnitSupportsFillType(index, fillType) then + local free = (object:getFillUnitCapacity(index) or 0) - (object:getFillUnitFillLevel(index) or 0) + return object, index, math.max(0, free) + end + end + end + return nil +end + +-- Én opgave pr. tick for sættet i assignment.pallet. -> "done" | "failed", grund | nil (i gang) +function ADPalletRefill.tick(adEnv, assignment, dt) + local job = assignment.pallet + local vehicle = assignment.vehicle + local fillType = job.fillType + local farmId = vehicle:getOwnerFarmId() + local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil + local wp = adEnv.ADGraphManager:getWayPointById(job.source.markerId) + local vx, vz = positionOf(vehicle) + local receiver, unit, free = ADPalletRefill.receiverOf(vehicle, fillType) + if receiver == nil then return "failed", "sættet kan ikke tage varen" end + local rx, rz = positionOf(receiver) + local pallet = nil + if job.state == "filling" then + for _, candidate in ipairs(ADPalletRefill.loosePallets(farmId, fillType)) do + local d = math.sqrt((candidate.x - rx) ^ 2 + (candidate.z - rz) ^ 2) + if d <= ADPalletRefill.REACH_M and (pallet == nil or d < pallet.distance) then + pallet = candidate + pallet.distance = d + end + end + end + local stored = job.source.placeable ~= nil and ADSources.countStored({placeable = job.source.placeable}, fillType) or 0 + local s = { + adActive = module ~= nil and module:isActive(), + distance = (wp ~= nil and vx ~= nil) and math.sqrt((wp.x - vx) ^ 2 + (wp.z - vz) ^ 2) or math.huge, + free = free, palletLevel = pallet ~= nil and pallet.level or 0, stored = stored, + } + local _, action = ADPalletRefill.step(job, s, dt) + if action == "transfer" then + local amount = ADPalletRefill.transferAmount(ADPalletRefill.RATE_LPS, dt, pallet.level, free) + local toolType = ToolType ~= nil and ToolType.UNDEFINED or 0 + local added = receiver:addFillUnitFillLevel(farmId, unit, amount, fillType, toolType, nil) or 0 + if added > 0 then + pallet.vehicle:addFillUnitFillLevel(farmId, pallet.unit, -added, fillType, toolType, nil) + job.filled = (job.filled or 0) + added + end + elseif action == "spawn" then + local index = ADSources.getObjectInfoIndex({placeable = job.source.placeable}, fillType) + local ok = index ~= nil and ADSources.spawnOne({placeable = job.source.placeable}, index) + Logging.info(ADPalletRefill.LOG_PREFIX .. "palle med %s taget ud af '%s'%s", tostring(ADPalletRefill.fillName(fillType)), + tostring(job.source.markerName), ok and "" or " — mislykkedes") + end + if job.state == "done" then return "done" end + if job.state == "failed" then return "failed", job.reason end + return nil +end + +function ADPalletRefill.fillName(fillType) + local desc = fillType ~= nil and g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeByIndex(fillType) or nil + return desc ~= nil and (desc.title or desc.name) or tostring(fillType) +end diff --git a/FS25_ADSmartPickup/modDesc.xml b/FS25_ADSmartPickup/modDesc.xml index fa1580b..47190b0 100644 --- a/FS25_ADSmartPickup/modDesc.xml +++ b/FS25_ADSmartPickup/modDesc.xml @@ -1,7 +1,7 @@ masterdraco - 1.62.15.0 + 1.62.16.0 <en>AD Smart Pickup</en> @@ -44,6 +44,7 @@ + diff --git a/docs/BRUGERMANUAL.md b/docs/BRUGERMANUAL.md index 324d425..b478471 100644 --- a/docs/BRUGERMANUAL.md +++ b/docs/BRUGERMANUAL.md @@ -167,6 +167,18 @@ kobler de redskaber af, der sidder **bag** traktoren, når den kører dertil med frontlæssere bliver siddende. En plov o.l. foldes ud først, hvis spillet kræver det. Kører du en traktor med "Kør til" til et puljeredskabs egen parkering, sættes redskabet også af dér. +### Påfyldning fra paller + +Er en såmaskine, gødnings-/kalkspreder eller sprøjte tom, og har intet lager eller købested varen, bruger moden +**paller**: løse paller med varen eller paller i et **palleskur** (objektlager). Sættet kører til AutoDrive-markøren +ved pallen/skuret, moden tager en palle ud af skuret (som knappen i spillet) og overfører varen, til redskabet er +fuldt eller pallerne er brugt. Tomme paller forsvinder af sig selv. + +- Sæt en AutoDrive-markør højst **40 m** fra palleskuret (eller de løse paller), der hvor redskabet holder. +- Pallen skal dukke op højst **20 m** fra redskabet. +- Gælder frø, ris-stiklinger, kalk og fast/flydende gødning. Påfyldning *undervejs* (når redskabet løber tomt midt + på marken) bruger stadig kun lagre/købesteder — paller bruges, når sættet sendes ud. + ### Marker: "F" Hver mark, der skal køres af moden, skal have en markør ved markkanten med navnet `F` + marknummeret,