Compare commits
13 Commits
v1.62.411.0
...
mp
| Author | SHA1 | Date | |
|---|---|---|---|
| 7bbeb6015c | |||
| 2e3f781b14 | |||
| 389c629878 | |||
| 8efef4ab58 | |||
| 8159f9e2ad | |||
| f9da06cc18 | |||
| 8067d9bcb3 | |||
| 0f87c42f47 | |||
| 81534ab873 | |||
| 1f639af77a | |||
| b4004616eb | |||
| d0db7a25b9 | |||
| ce50abce6c |
@@ -8,6 +8,12 @@ står i [docs/BRUGERMANUAL.md](docs/BRUGERMANUAL.md) (dansk) og [docs/USER_MANUA
|
||||
|
||||
## 1.62 — Kæder slås selv til
|
||||
|
||||
- **1.62.417** — Færre hak. Bygningslisten bruger nu et markørindeks, så hver bygning kun ser på markører i nærheden. Før blev alle markører gennemgået for hver bygning, og det tog 190–230 ms hvert 30. sekund. Syntetisk test: 150 ms → 6 ms, med samme resultat. Kildesøgningen bruger det cachede opslag af markørens station; før gennemgik den alle stationer for hver markør ved hver søgning (20 gange i minuttet, 40–45 ms hver gang). Stationscachen nulstilles, når AD-nettet redigeres. Nyt kursus-bibliotek (`ADSmartPickup_courses.xml` i savegamet): beregnede Courseplay-kurser huskes pr. mark, bredde og form, også når maskinen har fået et andet kursus. Så skal Courseplay ikke beregne kurset igen, og det giver en frysning på 1–4 s mindre hver gang. Biblioteket bruges ikke, når spilleren selv har lavet et nyt kursus på maskinen. `spuForgetCourses` tømmer også biblioteket. Profileren måler kildesøgningens dele og bygningsnavnene hver for sig. In-game 27/10 (savegame8): værste frame 209–297 ms hvert minut, og frysninger på 1,3–4 s ved nye kurser.
|
||||
- **1.62.416** — Har flowets vogn en anden vare på end den, der skal hentes (også et parkeret læs), og kan målene ikke tage hele resten, køres resten på lager, så flowet kan hente det, der mangler. In-game 26/10: flowet 'TMR' havde 383.075 l hø på vognen, begge TMR-fabrikker var fulde af hø og stod stille uden ensilage — høet blev kørt til den fulde fabrik og parkeret med læsset igen. Dyrefoder af samme vare som den, der hentes, leveres som før.
|
||||
- **1.62.415** — Koblingen giver pænt op, hvis vognen (eller frontredskabet) forsvinder midt i en bakning, fx solgt eller nulstillet. In-game 26/10 14:44: '8280 TTV' bakkede hen til 'BOSS ALPIN 251', vognens node forsvandt, og bakke-opgaven læste den slettede node i hvert billede — 7.829 Lua-fejl på 2 min. Nu: én advarsel, og AutoDrive kører videre.
|
||||
- **1.62.414** — Modkørsels-vagten bakker ikke en AD-maskine, der holder for rødt ved en lyskurv fra den nye mod FS25_TrafficLights (`TrafficLights.isHolding`). Uden lyskurve-modden er alt som før.
|
||||
- **1.62.413** — Dyrenes trug tømmer ikke længere en kørende TMR-fabrik for råvarer: ensilage (og andre råvarer) hentes ikke til et trug fra en fabrik, hvis en aktiv produktion laver bedre foder af den til netop det trug, og fabrikken har de andre råvarer til en cyklus. Truget får i stedet fabrikkens TMR. In-game 25/10 01:29-01:44: 'All Cow Food and Straw' tog 1,46 mio. l ensilage fra TMR Production Facility 2 til Kostald 3 og 4 — 1 l ensilage giver 2 l TMR i fabrikken, og begge TMR-fabrikker stod stille. Står produktionen stille eller mangler den en anden råvare, gælder "dyrene først" som før.
|
||||
- **1.62.412** — Køb af dyrefoder går kun til en markør, hvis trigger tager varen: når gården ikke selv havde TMR, købte forsyningen det ved købestationen til den første markør i flowets liste — også en stalds halm-markør. In-game 25/10 01:03-01:09: TMR blev købt til '102 Cow Barn Straw', halmtriggeren afviste det, og læsset endte i Kostald 5, mens Kostald 3 stod uden foder. Nu springes halm-markøren over, og flowet prøver staldens fodermarkør.
|
||||
- **1.62.411** — Saltruten overtager salttraktoren, når AutoDrive kører den videre efter en genindlæsning (saltjobbet gemmes ikke): turen stoppes, og saltruten kører sin egen rute med sprederen. In-game 21/10 01:37: T255 Versu kørte på sne uden at salte efter genstart. Kun hvis traktoren bærer en saltspreder og ikke er i et flow, markarbejde, lån, hjemtur, tømning eller kørt af spilleren.
|
||||
- **1.62.410** — Saltruten salter kun, hvor der ligger sne: sprederen tændes ud fra sneen under traktoren (6 × 6 m, tændt 1,5 s efter sidste sne) og slukker indendørs, under tag og på allerede saltede stræk (in-game 21/10: den saltede foderbordet i kostalden og dobbelt-saltede). Rutepunkter uden sne, inden for 15 m af P-/Connect-/Wait-markører eller med et andet køretøj holdende (det sidste prøves igen én gang til sidst) springes over, så den ikke kører ind i stalde eller sidder fast på parkerings- og ventebaner. Hvert mål står i loggen, og slutbeskeden viser saltede og sprungne steder.
|
||||
- **1.62.409** — Salttraktor: en traktor med saltspreder koblet på (eller en selvkørende spreder) er låst til saltruten — puljen, dyreture, flows og markarbejde låner den ikke, og puljen tager heller ikke en frakoblet saltspreder. Har du en traktor kun til saltning, så lad sprederen sidde på og giv traktoren en AD-parkering: saltruten bruger sættet direkte og kører det hjem til traktorens P.
|
||||
|
||||
@@ -368,7 +368,7 @@ function ADAutoCrop.tick(adEnv, dt)
|
||||
if ADSettings == nil or ADSettings.get("autoAll") ~= 1 then return end
|
||||
if not changed then return ADAutoCrop.tickNeeds(adEnv) end
|
||||
logInfo("ADSmartPickup: Alt automatisk: gårdens marker er ændret — planen laves om")
|
||||
local result = ADAutoCrop.applyAll(g_currentMission:getFarmId(), adEnv, {enableIds = added, replan = true})
|
||||
local result = ADAutoCrop.applyAll(ADUtil.farmId(), adEnv, {enableIds = added, replan = true})
|
||||
-- mislykket (gården kunne ikke læses, scanning): prøv igen ved næste tjek
|
||||
if result == nil or result.failed ~= nil or result.scanning then
|
||||
ADAutoCrop.knownFields = previous
|
||||
@@ -431,5 +431,5 @@ function ADAutoCrop.tickNeeds(adEnv)
|
||||
logInfo("ADSmartPickup: Alt automatisk: gårdens behov er ændret (%s -> %s) — planen laves om",
|
||||
describeSignature(ADAutoCrop.knownNeeds), describeSignature(now))
|
||||
-- lykkes det ikke, står knownNeeds uændret, og der prøves igen ved næste tjek
|
||||
ADAutoCrop.applyAll(g_currentMission:getFarmId(), adEnv, {enableIds = {}, replan = true})
|
||||
ADAutoCrop.applyAll(ADUtil.farmId(), adEnv, {enableIds = {}, replan = true})
|
||||
end
|
||||
|
||||
@@ -252,45 +252,92 @@ function ADBuildings.labelWithPlace(building)
|
||||
return tostring(building ~= nil and building.name or "?") .. ADBuildings.placeSuffix(building)
|
||||
end
|
||||
|
||||
-- Alle navngivne markører (uden P/Connect/Wait) med position -> {{name, x, z}}
|
||||
local function namedMarkers(adEnv)
|
||||
-- Markørindeks: markørerne med position i et gitter, så et opslag kun ser på markører i nærheden af bygningen.
|
||||
-- Bygges én gang pr. opbygning af listen (savegame8 27/10: alle markører x alle noder x alle bygninger tog
|
||||
-- 190-230 ms hvert 30. s og gav et hak). entries = {{marker, x, z, order}}; order = rækkefølgen i AD's markørliste.
|
||||
ADBuildings.GRID_CELL_M = 50
|
||||
local GRID_OFFSET, GRID_STRIDE = 100000, 1000000
|
||||
|
||||
local function cellOf(cellSize, x, z)
|
||||
return math.floor(x / cellSize), math.floor(z / cellSize)
|
||||
end
|
||||
|
||||
function ADBuildings.newMarkerIndex(entries, cellSize)
|
||||
local index = {cell = cellSize or ADBuildings.GRID_CELL_M, cells = {}, all = entries or {}}
|
||||
for _, entry in ipairs(index.all) do
|
||||
local cx, cz = cellOf(index.cell, entry.x, entry.z)
|
||||
local key = (cx + GRID_OFFSET) * GRID_STRIDE + (cz + GRID_OFFSET)
|
||||
local bucket = index.cells[key]
|
||||
if bucket == nil then
|
||||
bucket = {}
|
||||
index.cells[key] = bucket
|
||||
end
|
||||
table.insert(bucket, entry)
|
||||
end
|
||||
return index
|
||||
end
|
||||
|
||||
-- Indeksets markører i gittercellerne der dækker radius om mindst én position (et overmængde: kalderen måler selv
|
||||
-- afstanden), i AD's rækkefølge som en fuld gennemgang ville give dem.
|
||||
function ADBuildings.markersNear(index, positions, radius)
|
||||
local found, seen = {}, {}
|
||||
local span = math.ceil((radius or 0) / index.cell)
|
||||
for _, position in ipairs(positions or {}) do
|
||||
local cx, cz = cellOf(index.cell, position.x, position.z)
|
||||
for ix = cx - span, cx + span do
|
||||
for iz = cz - span, cz + span do
|
||||
local bucket = index.cells[(ix + GRID_OFFSET) * GRID_STRIDE + (iz + GRID_OFFSET)]
|
||||
for _, entry in ipairs(bucket or {}) do
|
||||
if not seen[entry] then
|
||||
seen[entry] = true
|
||||
table.insert(found, entry)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
table.sort(found, function(a, b) return a.order < b.order end)
|
||||
return found
|
||||
end
|
||||
|
||||
-- AD's markører der opfylder accept, med vejpunktets position -> {{marker, x, z, order}}
|
||||
local function scanMarkers(adEnv, accept)
|
||||
local list = {}
|
||||
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
||||
local wayPoint = ADBuildings.isCandidateMarker(marker) and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
|
||||
if wayPoint ~= nil then table.insert(list, {name = tostring(marker.name), x = wayPoint.x, z = wayPoint.z}) end
|
||||
local wayPoint = accept(marker) and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
|
||||
if wayPoint ~= nil then table.insert(list, {marker = marker, x = wayPoint.x, z = wayPoint.z, order = #list + 1}) end
|
||||
end
|
||||
return list
|
||||
end
|
||||
|
||||
-- Nærmeste ikke-Wait-markør til en af noderne, ≤ MAX_MARKER_DISTANCE.
|
||||
local function nearestMarker(adEnv, nodes)
|
||||
local best, bestDistance = nil, ADBuildings.MAX_MARKER_DISTANCE
|
||||
if #nodes == 0 then
|
||||
return nil
|
||||
local function isNonWaitMarker(marker) return not ADSupplyPlanner.isWaitMarker(marker) end
|
||||
|
||||
-- under build(): {candidates = indeks over bygnings-kandidater, nonWait = indeks over alle ikke-Wait-markører}
|
||||
local buildIndex = nil
|
||||
|
||||
-- Kandidatmarkører (ikke Wait/P/Connect/service) der kan stå inden for radius af positionerne.
|
||||
local function candidatesNear(adEnv, positions, radius)
|
||||
if buildIndex ~= nil then return ADBuildings.markersNear(buildIndex.candidates, positions, radius) end
|
||||
return scanMarkers(adEnv, ADBuildings.isCandidateMarker)
|
||||
end
|
||||
|
||||
local function nodePositions(nodes)
|
||||
local positions = {}
|
||||
for _, node in ipairs(nodes) do
|
||||
local x, z = getNodePosition(node)
|
||||
if x ~= nil then table.insert(positions, {x = x, z = z}) end
|
||||
end
|
||||
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
||||
if ADBuildings.isCandidateMarker(marker) then
|
||||
local wayPoint = adEnv.ADGraphManager:getWayPointById(marker.id)
|
||||
if wayPoint ~= nil then
|
||||
for _, position in ipairs(positions) do
|
||||
local dx, dz = wayPoint.x - position.x, wayPoint.z - position.z
|
||||
local distance = math.sqrt(dx * dx + dz * dz)
|
||||
if distance < bestDistance then
|
||||
best, bestDistance = marker, distance
|
||||
return positions
|
||||
end
|
||||
|
||||
-- Navngivne markører (uden P/Connect/Wait) nær et punkt -> {{name, x, z}} til nearestNamedMarker
|
||||
local function namedMarkersNear(adEnv, x, z)
|
||||
local list = {}
|
||||
if x == nil or z == nil then return list end
|
||||
for _, entry in ipairs(candidatesNear(adEnv, {{x = x, z = z}}, ADBuildings.NEAR_MARKER_M)) do
|
||||
table.insert(list, {name = tostring(entry.marker.name), x = entry.x, z = entry.z})
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if best == nil then
|
||||
return nil
|
||||
end
|
||||
return {id = best.id, name = tostring(best.name), distance = math.floor(bestDistance + 0.5)}
|
||||
return list
|
||||
end
|
||||
|
||||
-- Aflæsningsmarkør: nærmeste ikke-Wait-markør ≤ MAX_MARKER_DISTANCE til aflæsningsnoderne — men ikke
|
||||
@@ -298,22 +345,17 @@ end
|
||||
-- aflæsningstriggeren end drop). Kun én fælles markør (AIO Load / Unload) bruges til begge.
|
||||
-- Alle ikke-Wait-markører ≤ MAX_MARKER_DISTANCE til nodes, nærmeste først: {{id, name, distance}}.
|
||||
local function markerCandidates(adEnv, nodes)
|
||||
local positions, found = {}, {}
|
||||
for _, node in ipairs(nodes) do
|
||||
local x, z = getNodePosition(node)
|
||||
if x ~= nil then table.insert(positions, {x = x, z = z}) end
|
||||
end
|
||||
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
||||
local wayPoint = ADBuildings.isCandidateMarker(marker) and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
|
||||
if wayPoint ~= nil then
|
||||
local positions, found = nodePositions(nodes), {}
|
||||
if #positions == 0 then return found end
|
||||
for _, entry in ipairs(candidatesNear(adEnv, positions, ADBuildings.MAX_MARKER_DISTANCE)) do
|
||||
local marker = entry.marker
|
||||
local nearest = nil
|
||||
for _, position in ipairs(positions) do
|
||||
local distance = math.sqrt((wayPoint.x - position.x) ^ 2 + (wayPoint.z - position.z) ^ 2)
|
||||
local distance = math.sqrt((entry.x - position.x) ^ 2 + (entry.z - position.z) ^ 2)
|
||||
if nearest == nil or distance < nearest then nearest = distance end
|
||||
end
|
||||
if nearest ~= nil and nearest < ADBuildings.MAX_MARKER_DISTANCE then
|
||||
table.insert(found, {id = marker.id, name = tostring(marker.name), distance = nearest, x = wayPoint.x, z = wayPoint.z})
|
||||
end
|
||||
table.insert(found, {id = marker.id, name = tostring(marker.name), distance = nearest, x = entry.x, z = entry.z})
|
||||
end
|
||||
end
|
||||
table.sort(found, function(a, b) return a.distance < b.distance end)
|
||||
@@ -415,21 +457,14 @@ end
|
||||
-- (in-game 27/9: Goat Food fik "Sheep Milk"-markørerne som mål og Goat Milk Pickup "Sheep Food" som kilde)
|
||||
local diagnosed = {}
|
||||
local function closestMarkers(adEnv, nodes, count)
|
||||
local positions, found = {}, {}
|
||||
for _, node in ipairs(nodes) do
|
||||
local x, z = getNodePosition(node)
|
||||
if x ~= nil then table.insert(positions, {x = x, z = z}) end
|
||||
end
|
||||
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
||||
local wayPoint = ADBuildings.isCandidateMarker(marker) and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
|
||||
if wayPoint ~= nil then
|
||||
local positions, found = nodePositions(nodes), {}
|
||||
for _, entry in ipairs(#positions > 0 and candidatesNear(adEnv, positions, ADBuildings.MAX_MARKER_DISTANCE) or {}) do
|
||||
local nearest = nil
|
||||
for _, position in ipairs(positions) do
|
||||
local distance = math.sqrt((wayPoint.x - position.x) ^ 2 + (wayPoint.z - position.z) ^ 2)
|
||||
local distance = math.sqrt((entry.x - position.x) ^ 2 + (entry.z - position.z) ^ 2)
|
||||
if nearest == nil or distance < nearest then nearest = distance end
|
||||
end
|
||||
if nearest ~= nil and nearest < ADBuildings.MAX_MARKER_DISTANCE then table.insert(found, {name = tostring(marker.name), distance = nearest}) end
|
||||
end
|
||||
if nearest ~= nil and nearest < ADBuildings.MAX_MARKER_DISTANCE then table.insert(found, {name = tostring(entry.marker.name), distance = nearest}) end
|
||||
end
|
||||
table.sort(found, function(a, b) return a.distance < b.distance end)
|
||||
local parts = {}
|
||||
@@ -537,21 +572,15 @@ local function unloadMarkerFor(adEnv, nodes, loadMarkers, allowSkipLoad, placeab
|
||||
end
|
||||
local isLoad = {}
|
||||
for _, marker in ipairs(loadMarkers or {}) do isLoad[marker.id] = true end
|
||||
local positions = {}
|
||||
for _, node in ipairs(nodes) do
|
||||
local x, z = getNodePosition(node)
|
||||
if x ~= nil then table.insert(positions, {x = x, z = z}) end
|
||||
end
|
||||
local positions = nodePositions(nodes)
|
||||
local best, bestOther, nearbyAll = nil, nil, {}
|
||||
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
||||
if ADBuildings.isCandidateMarker(marker) then
|
||||
local wayPoint = adEnv.ADGraphManager:getWayPointById(marker.id)
|
||||
if wayPoint ~= nil then
|
||||
for _, near in ipairs(#positions > 0 and candidatesNear(adEnv, positions, ADBuildings.MAX_MARKER_DISTANCE) or {}) do
|
||||
local marker = near.marker
|
||||
for _, position in ipairs(positions) do
|
||||
local dx, dz = wayPoint.x - position.x, wayPoint.z - position.z
|
||||
local dx, dz = near.x - position.x, near.z - position.z
|
||||
local distance = math.sqrt(dx * dx + dz * dz)
|
||||
if distance < ADBuildings.MAX_MARKER_DISTANCE then
|
||||
local entry = {marker = marker, distance = distance, x = wayPoint.x, z = wayPoint.z}
|
||||
local entry = {marker = marker, distance = distance, x = near.x, z = near.z}
|
||||
table.insert(nearbyAll, entry)
|
||||
if best == nil or distance < best.distance then best = entry end
|
||||
if not isLoad[marker.id] and (bestOther == nil or distance < bestOther.distance) then
|
||||
@@ -560,8 +589,6 @@ local function unloadMarkerFor(adEnv, nodes, loadMarkers, allowSkipLoad, placeab
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
-- siloer: altid nærmeste (en fælles markør må ikke erstattes af nabosiloens); ellers kun en "anden"
|
||||
-- markør der står tæt på aflæsningen
|
||||
local chosen = best
|
||||
@@ -621,24 +648,37 @@ end
|
||||
|
||||
-- Silo: den markør hvis STRENGE opslag (trigger bag næsen) rammer siloens læssestation.
|
||||
local function siloLoadMarker(adEnv, farmId, placeable, loadStations)
|
||||
local own = {}
|
||||
local own, triggerPositions = {}, {}
|
||||
for _, station in pairs(loadStations) do
|
||||
if station.owningPlaceable == placeable then own[station] = true end
|
||||
if station.owningPlaceable == placeable then
|
||||
own[station] = true
|
||||
for _, trigger in pairs(station.loadTriggers or {}) do
|
||||
local x, z = getNodePosition(trigger.triggerNode)
|
||||
if x ~= nil then table.insert(triggerPositions, {x = x, z = z}) end
|
||||
end
|
||||
end
|
||||
end
|
||||
-- det strenge opslag finder kun en station hvis triggerNode står inden for MAX_MARKER_TO_TRIGGER_DISTANCE af
|
||||
-- markøren: kun markører så tæt på siloens egne triggere spørges (uden kendte triggere: alle, som før)
|
||||
local markers
|
||||
if buildIndex ~= nil and #triggerPositions > 0 then
|
||||
local radius = (ADSmartPickup.MAX_MARKER_TO_TRIGGER_DISTANCE or ADBuildings.MAX_MARKER_DISTANCE) + 1
|
||||
markers = ADBuildings.markersNear(buildIndex.nonWait, triggerPositions, radius)
|
||||
else
|
||||
markers = scanMarkers(adEnv, isNonWaitMarker)
|
||||
end
|
||||
-- rammer flere markører stationen (AD's triggerafstand er stor, 25 m), vinder den der står tættest på
|
||||
-- læssetriggeren — ikke den tilfældigt første (in-game 9/10: marksiloen ved F9 fik markmarkøren 'F9' 19 m væk
|
||||
-- i stedet for 'F9 Silo' 11 m; vognen stod uden for boksen)
|
||||
local best = nil
|
||||
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
||||
if not ADSupplyPlanner.isWaitMarker(marker) then
|
||||
for _, entry in ipairs(markers) do
|
||||
local marker = entry.marker
|
||||
local station = ADSmartPickup.getLoadStationAtWayPointId(adEnv, marker.id, farmId)
|
||||
if station ~= nil and own[station] then
|
||||
local wayPoint = adEnv.ADGraphManager:getWayPointById(marker.id)
|
||||
local distance = wayPoint ~= nil and stationTriggerDistance(station, wayPoint.x, wayPoint.z) or 0
|
||||
local distance = stationTriggerDistance(station, entry.x, entry.z)
|
||||
best = ADBuildings.closerHit(best, {id = marker.id, name = tostring(marker.name), distance = math.floor(distance + 0.5)})
|
||||
end
|
||||
end
|
||||
end
|
||||
return best
|
||||
end
|
||||
|
||||
@@ -693,7 +733,7 @@ end
|
||||
|
||||
local fallbackLogged = {} -- "stald-id:markør-id" -> true
|
||||
|
||||
local function build(adEnv, farmId)
|
||||
local function buildList(adEnv, farmId)
|
||||
local placeables = g_currentMission ~= nil and g_currentMission.placeableSystem ~= nil and g_currentMission.placeableSystem.placeables or {}
|
||||
local storage = g_currentMission ~= nil and g_currentMission.storageSystem or nil
|
||||
local loadStations = storage ~= nil and storage:getLoadingStations() or {}
|
||||
@@ -704,8 +744,6 @@ local function build(adEnv, farmId)
|
||||
-- naboens marker kan være nærmere dem (in-game 17/10 08:05: Hønsehus 2 tog 'Coop 1 Egg Pickup' 7 m fra sin
|
||||
-- palleplads, og Hønsehus 3 stod uden markør)
|
||||
local loadOwner, prepared = {}, {}
|
||||
local okNamed, named = pcall(namedMarkers, adEnv)
|
||||
if not okNamed then named = {} end
|
||||
for _, placeable in pairs(placeables) do
|
||||
if getKind(placeable) == "husbandry" and isOwnedBy(placeable, farmId) then
|
||||
local loadGroups, unloadNodes = collectNodes(placeable, loadStations, unloadStations)
|
||||
@@ -784,7 +822,7 @@ local function build(adEnv, farmId)
|
||||
local nearX, nearZ = getNodePosition(placeable.rootNode)
|
||||
table.insert(result, {
|
||||
id = id, name = getName(placeable, id), kind = kind, placeable = placeable,
|
||||
near = ADBuildings.nearestNamedMarker(named, nearX, nearZ), -- stedet (nærmeste AD-markør) til listerne
|
||||
near = ADBuildings.nearestNamedMarker(namedMarkersNear(adEnv, nearX, nearZ), nearX, nearZ), -- stedet (nærmeste AD-markør) til listerne
|
||||
loadMarker = loadMarkers[1],
|
||||
loadMarkers = loadMarkers,
|
||||
unloadMarker = unloadMarker,
|
||||
@@ -800,6 +838,23 @@ local function build(adEnv, farmId)
|
||||
return result
|
||||
end
|
||||
|
||||
-- Listen bygges med et markørindeks (se newMarkerIndex); et indlejret kald (stationsopslag der selv beder om listen)
|
||||
-- får sit eget indeks, og det ydre gendannes bagefter.
|
||||
-- debug-biblioteket er ikke sikkert til stede i spillets release-runtime (review 27/10)
|
||||
local traceback = (type(debug) == "table" and debug.traceback) or function(err) return err end
|
||||
|
||||
local function build(adEnv, farmId)
|
||||
local previous = buildIndex
|
||||
buildIndex = {
|
||||
candidates = ADBuildings.newMarkerIndex(scanMarkers(adEnv, ADBuildings.isCandidateMarker)),
|
||||
nonWait = ADBuildings.newMarkerIndex(scanMarkers(adEnv, isNonWaitMarker)),
|
||||
}
|
||||
local ok, result = xpcall(buildList, traceback, adEnv, farmId)
|
||||
buildIndex = previous
|
||||
if not ok then error(result, 0) end
|
||||
return result
|
||||
end
|
||||
|
||||
-- Sted-endelsen for en bygning i den cachede liste (til "Vis bygning"-vælgeren): " · Silo Complex" eller ""
|
||||
function ADBuildings.placeSuffixFor(adEnv, farmId, placeable)
|
||||
local id = placeable ~= nil and ADBuildings.getId(placeable) or nil
|
||||
@@ -1014,6 +1069,6 @@ function ADBuildings.tickDump(adEnv, dt)
|
||||
dumpState.done = true
|
||||
local path = getUserProfileAppPath ~= nil and (getUserProfileAppPath() .. "modSettings/FS25_ADSmartPickup/dumpTriggers.txt") or nil
|
||||
if path == nil or fileExists == nil or not fileExists(path) then return end
|
||||
local ok, err = pcall(ADBuildings.dumpTriggers, adEnv, g_currentMission:getFarmId())
|
||||
local ok, err = pcall(ADBuildings.dumpTriggers, adEnv, ADUtil.farmId())
|
||||
if not ok then Logging.warning("ADSmartPickup: TRIGGER-dump fejlede: %s", tostring(err)) end
|
||||
end
|
||||
|
||||
@@ -306,7 +306,7 @@ end
|
||||
-- ---- evaluering ----
|
||||
|
||||
local function farmId()
|
||||
return g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
return ADUtil.farmId()
|
||||
end
|
||||
|
||||
local function plan(data, state)
|
||||
|
||||
@@ -230,7 +230,7 @@ local function start(adEnv, entry, enabled)
|
||||
if harvest and entry.mission ~= nil then
|
||||
-- høst: læssene skal til kontraktens salgssted (ADFieldWork.chooseStore)
|
||||
local placeable, where, station = sellPlaceableOf(entry.mission)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
changes.contractSellIds = placeable ~= nil and sellMarkerIds(adEnv, placeable, farmId) or {}
|
||||
-- uden AutoDrive-vej kører spillets hjælper læssene hertil (ADFieldWork beginUnloader)
|
||||
changes.contractStation = station
|
||||
@@ -289,7 +289,9 @@ function ADContracts.onAnswer(_, yes, entry)
|
||||
end
|
||||
|
||||
local function ask(entry)
|
||||
if YesNoDialog == nil or YesNoDialog.show == nil then
|
||||
-- dedikeret server (ingen skærm): ingen at spørge -> rør den ikke, som uden dialog (multiplayer etape 1;
|
||||
-- spørgsmålet til en spiller kommer i etape 4)
|
||||
if YesNoDialog == nil or YesNoDialog.show == nil or (g_client == nil and g_server ~= nil) then
|
||||
-- kan ikke spørge: rør den ikke (spilleren kan vælge "moden altid" under Indstillinger)
|
||||
start(ADContracts.adEnv, entry, false)
|
||||
return
|
||||
@@ -372,7 +374,7 @@ function ADContracts.tick(adEnv, nowMs)
|
||||
local decision = ADContracts.decision(ADSettings ~= nil and ADSettings.get("contracts") or nil)
|
||||
if lastScanAt ~= nil and nowMs - lastScanAt < ADContracts.SCAN_MS then return end
|
||||
lastScanAt = nowMs
|
||||
local farmId = g_currentMission ~= nil and g_currentMission:getFarmId() or nil
|
||||
local farmId = ADUtil.farmId()
|
||||
if farmId == nil then return end
|
||||
local okCollect, errCollect = pcall(collectFinished, farmId, nowMs)
|
||||
if not okCollect then Logging.warning("ADSmartPickup: indkassering af kontrakter: %s", tostring(errCollect)) end
|
||||
|
||||
@@ -79,6 +79,9 @@ function ADCourseCache.without(records, vehicleId)
|
||||
return result
|
||||
end
|
||||
|
||||
-- Spilleren har lavet et nyt kursus på maskinen (i CP's HUD): så hentes heller intet fra biblioteket
|
||||
ADCourseCache.STALE_REASON = "kurset på maskinen er ændret"
|
||||
|
||||
-- Kursus der kan genbruges: egen maskines først ("own"), ellers en anden maskines ("copy", laveste id først).
|
||||
-- isValid(record) (valgfri) tjekker at kurset stadig sidder på maskinen. Intet: nil + grunden.
|
||||
function ADCourseCache.findReusable(records, request, vehicleId, isValid)
|
||||
@@ -103,7 +106,7 @@ function ADCourseCache.findReusable(records, request, vehicleId, isValid)
|
||||
for _, id in ipairs(ids) do
|
||||
if usable(records[id]) then return records[id], "copy" end
|
||||
end
|
||||
if anyStale then return nil, "kurset på maskinen er ændret" end
|
||||
if anyStale then return nil, ADCourseCache.STALE_REASON end
|
||||
return nil, ADCourseCache.mismatchReason(own, request)
|
||||
end
|
||||
|
||||
@@ -205,9 +208,17 @@ local function prepareUnsafe(adEnv, field, info, assignment, opts)
|
||||
local source = vehicles[record.vehicle]
|
||||
result.course = source.course
|
||||
log(field.id, "kursus kopieret fra '%s' til '%s' — ingen ny beregning", ADRuns.vehicleLabel(source.vehicle), ADRuns.vehicleLabel(vehicle))
|
||||
else
|
||||
-- biblioteket husker kurser som maskinerne har fået skiftet ud (adCourseLibrary.lua)
|
||||
local saved = how ~= ADCourseCache.STALE_REASON and ADCourseLibrary ~= nil and ADCourseLibrary.get(ADCourseCache.key(request)) or nil
|
||||
if saved ~= nil then
|
||||
result.course = saved
|
||||
log(field.id, "kursus hentet fra biblioteket til '%s' — ingen ny beregning", ADRuns.vehicleLabel(vehicle))
|
||||
how = "library"
|
||||
else
|
||||
log(field.id, "nyt kursus beregnes til '%s' (%s)", ADRuns.vehicleLabel(vehicle), tostring(how))
|
||||
end
|
||||
end
|
||||
return result, {request = request, how = how}
|
||||
end
|
||||
|
||||
@@ -232,6 +243,11 @@ function ADCourseCache.afterStart(vehicle, vehicleId, context)
|
||||
local r = context.request
|
||||
local record = ADCourseCache.newRecord({vehicle = vehicleId, field = r.field, width = r.width, sig = r.sig,
|
||||
settings = r.settings, waypoints = waypointCount(course)})
|
||||
-- biblioteket: nyberegnede kurser afløser det gemte; kun kurser med forager (som genbrugsreglen i ADCpBridge)
|
||||
local fresh = context.how ~= "own" and context.how ~= "copy" and context.how ~= "library"
|
||||
if ADCourseLibrary ~= nil and (ADCpBridge.courseHasHeadlands == nil or ADCpBridge.courseHasHeadlands(course)) then
|
||||
ADCourseLibrary.put(ADCourseCache.key(r), course, fresh)
|
||||
end
|
||||
local existing = records[record.vehicle]
|
||||
if existing ~= nil and ADCourseCache.matches(existing, r) and existing.waypoints == record.waypoints then return end
|
||||
setRecords(ADCourseCache.withRecord(records, record))
|
||||
@@ -243,6 +259,7 @@ end
|
||||
function ADCourseCache.checkField(fieldId, sig)
|
||||
local records = getRecords()
|
||||
local kept, removed = ADCourseCache.invalidateField(records, fieldId, sig)
|
||||
if sig ~= nil and ADCourseLibrary ~= nil then removed = removed + ADCourseLibrary.forget(fieldId, sig) end
|
||||
if removed > 0 then
|
||||
setRecords(kept)
|
||||
log(fieldId, "markens form er ændret — %d gemt(e) kursus(er) glemt, næste start beregner nyt", removed)
|
||||
@@ -254,6 +271,7 @@ end
|
||||
function ADCourseCache:consoleForget(arg)
|
||||
local fieldId = tonumber((tostring(arg or ""):gsub("^[Ff]", "")))
|
||||
local kept, removed = ADCourseCache.forget(getRecords(), fieldId)
|
||||
if ADCourseLibrary ~= nil then removed = removed + ADCourseLibrary.forget(fieldId) end
|
||||
setRecords(kept)
|
||||
local text = string.format("ADSmartPickup: %d gemt(e) kursus(er) glemt (%s) — næste start beregner nyt", removed,
|
||||
fieldId ~= nil and ("F" .. tostring(fieldId)) or "alle marker")
|
||||
|
||||
@@ -0,0 +1,252 @@
|
||||
-- AD Course Library
|
||||
-- Bibliotek af beregnede Courseplay-kurser pr. "mark|bredde|form|indstillinger" (ADCourseCache.key). Registret i
|
||||
-- adCourseCache husker kun hver maskines SENESTE kursus: får maskinen en anden mark, er kurset væk, og næste gang
|
||||
-- beregnes det forfra (savegame8 27/10: 6 nye beregninger på 20 min, hver en frysning på 1,3-4 s). Biblioteket
|
||||
-- beholder en kopi af hvert kursus og gemmes i savegamet (ADSmartPickup_courses.xml, Courseplays eget kursusformat).
|
||||
-- Rene regler øverst (tests/test_adCourseLibrary.lua); spil-nær lim nederst (alt pcall'et).
|
||||
|
||||
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
|
||||
local function logInfo(...) return (ADLog or Logging).info(...) end
|
||||
|
||||
ADCourseLibrary = {}
|
||||
|
||||
ADCourseLibrary.FILE_NAME = "ADSmartPickup_courses.xml"
|
||||
ADCourseLibrary.ROOT = "ADSmartPickupCourses"
|
||||
ADCourseLibrary.MAX_ENTRIES = 40
|
||||
ADCourseLibrary.LOG_PREFIX = "ADSmartPickup: "
|
||||
|
||||
-- key -> {course = Course, used = løbenummer}; used stiger ved hver brug (mindst brugte smides ud først)
|
||||
ADCourseLibrary.entries = {}
|
||||
ADCourseLibrary.counter = 0
|
||||
ADCourseLibrary.loaded = false
|
||||
ADCourseLibrary.writable = false -- filen må skrives (læst uden fejl, eller fandtes ikke)
|
||||
ADCourseLibrary.dirty = false -- noget er ændret siden sidste gem
|
||||
|
||||
-- ---- rene regler ----
|
||||
|
||||
-- Marken i en nøgle ("41|50.0|sig|off=..." -> 41); nil når nøglen ikke har formen.
|
||||
function ADCourseLibrary.fieldOfKey(key)
|
||||
if type(key) ~= "string" then return nil end
|
||||
return tonumber(key:match("^([^|]+)|"))
|
||||
end
|
||||
|
||||
-- Nøglerne der skal ud for at holde biblioteket på max poster: de mindst brugte (laveste used), ældste først.
|
||||
function ADCourseLibrary.evictions(entries, max)
|
||||
local keys = {}
|
||||
for key in pairs(entries or {}) do table.insert(keys, key) end
|
||||
if #keys <= (max or 0) then return {} end
|
||||
table.sort(keys, function(a, b)
|
||||
local ua, ub = entries[a].used or 0, entries[b].used or 0
|
||||
if ua ~= ub then return ua < ub end
|
||||
return a < b
|
||||
end)
|
||||
local drop = {}
|
||||
for index = 1, #keys - max do table.insert(drop, keys[index]) end
|
||||
return drop
|
||||
end
|
||||
|
||||
-- Nøglerne for en mark (fieldId) eller alle (nil); keepSig = behold poster med netop den formsignatur.
|
||||
function ADCourseLibrary.keysFor(entries, fieldId, keepSig)
|
||||
local keys = {}
|
||||
for key in pairs(entries or {}) do
|
||||
local sig = key:match("^[^|]+|[^|]+|([^|]+)|")
|
||||
if (fieldId == nil or ADCourseLibrary.fieldOfKey(key) == fieldId) and (keepSig == nil or sig ~= keepSig) then
|
||||
table.insert(keys, key)
|
||||
end
|
||||
end
|
||||
table.sort(keys)
|
||||
return keys
|
||||
end
|
||||
|
||||
-- ---- spil-nær lim ----
|
||||
|
||||
local function touch(entry)
|
||||
ADCourseLibrary.counter = ADCourseLibrary.counter + 1
|
||||
entry.used = ADCourseLibrary.counter
|
||||
end
|
||||
|
||||
local function isSingleVehicle(course)
|
||||
return course ~= nil and (course.nVehicles == nil or course.nVehicles == 1)
|
||||
end
|
||||
|
||||
local materialize -- (entry) -> course|nil; pakker et gemt kursus ud første gang det bruges (spil-lim nedenfor)
|
||||
|
||||
-- Kurset til nøglen (en kopi gives videre af ADCpBridge via cpCopyCourse), eller nil.
|
||||
function ADCourseLibrary.get(key)
|
||||
if key == nil then return nil end
|
||||
ADCourseLibrary.load()
|
||||
local entry = ADCourseLibrary.entries[key]
|
||||
if entry == nil then return nil end
|
||||
local course = materialize(entry)
|
||||
if course == nil then
|
||||
ADCourseLibrary.entries[key] = nil
|
||||
ADCourseLibrary.dirty = true
|
||||
return nil
|
||||
end
|
||||
touch(entry)
|
||||
return course
|
||||
end
|
||||
|
||||
-- Gem en kopi af kurset under nøglen. Findes nøglen, tæller det kun som brug — medmindre replace (et nyberegnet
|
||||
-- kursus afløser det gemte). Kun kurser til én maskine.
|
||||
function ADCourseLibrary.put(key, course, replace)
|
||||
if key == nil or not isSingleVehicle(course) or course.copy == nil then return end
|
||||
ADCourseLibrary.load()
|
||||
local entry = ADCourseLibrary.entries[key]
|
||||
if entry ~= nil and not replace then
|
||||
touch(entry)
|
||||
return
|
||||
end
|
||||
local ok, copy = pcall(course.copy, course)
|
||||
if not ok or copy == nil then
|
||||
Logging.warning(ADCourseLibrary.LOG_PREFIX .. "kursus-bibliotek: kunne ikke kopiere kursus: %s", tostring(copy))
|
||||
return
|
||||
end
|
||||
-- Course:copy tager ikke disse med: compacted = lige rækker gemmes som start+slut (ellers bliver filen stor)
|
||||
copy.compacted, copy.headlandClockwise, copy.islandHeadlandClockwise = course.compacted, course.headlandClockwise, course.islandHeadlandClockwise
|
||||
entry = {course = copy}
|
||||
touch(entry)
|
||||
ADCourseLibrary.entries[key] = entry
|
||||
ADCourseLibrary.dirty = true
|
||||
for _, drop in ipairs(ADCourseLibrary.evictions(ADCourseLibrary.entries, ADCourseLibrary.MAX_ENTRIES)) do
|
||||
ADCourseLibrary.entries[drop] = nil
|
||||
end
|
||||
end
|
||||
|
||||
-- Glem kurser for en mark (nil = alle); keepSig = behold dem med markens nuværende form. Returnerer antal.
|
||||
function ADCourseLibrary.forget(fieldId, keepSig)
|
||||
ADCourseLibrary.load()
|
||||
local keys = ADCourseLibrary.keysFor(ADCourseLibrary.entries, fieldId, keepSig)
|
||||
for _, key in ipairs(keys) do ADCourseLibrary.entries[key] = nil end
|
||||
if #keys > 0 then ADCourseLibrary.dirty = true end
|
||||
return #keys
|
||||
end
|
||||
|
||||
local function getPath()
|
||||
return ADRunsStorage ~= nil and ADRunsStorage.getPath ~= nil and ADRunsStorage.getPath() ~= nil
|
||||
and (ADRunsStorage.getPath():gsub("[^/\\]+$", ADCourseLibrary.FILE_NAME)) or nil
|
||||
end
|
||||
|
||||
-- Courseplays klasser ligger i dens mod-miljø, den globale tabel FS25_Courseplay (zip-navnet) — som FS25_AutoDrive
|
||||
local function cpClass(name)
|
||||
local env = FS25_Courseplay
|
||||
return type(env) == "table" and env[name] or nil
|
||||
end
|
||||
|
||||
local schema = nil
|
||||
local function getSchema()
|
||||
if schema ~= nil then return schema end
|
||||
local courseManager = cpClass("CpCourseManager")
|
||||
if XMLSchema == nil or courseManager == nil or courseManager.registerXmlSchemaValues == nil then return nil end
|
||||
schema = XMLSchema.new("ADSmartPickupCourses")
|
||||
local key = ADCourseLibrary.ROOT .. ".course(?)"
|
||||
courseManager.registerXmlSchemaValues(schema, key)
|
||||
schema:register(XMLValueType.STRING, key .. "#adspKey", "ADSmartPickup: mark|bredde|form|indstillinger")
|
||||
schema:register(XMLValueType.INT, key .. "#adspUsed", "ADSmartPickup: senest brugt (løbenummer)")
|
||||
return schema
|
||||
end
|
||||
|
||||
-- Den gemte fil holdes åben, og et kursus pakkes først ud når det skal bruges: at læse alle kurser på én gang
|
||||
-- (Waypoint() slår terrænhøjden op for hvert punkt) ville selv give den frysning biblioteket skal fjerne (review 27/10).
|
||||
local openXml = nil
|
||||
|
||||
local function closeXml()
|
||||
if openXml ~= nil then
|
||||
openXml:delete()
|
||||
openXml = nil
|
||||
end
|
||||
end
|
||||
|
||||
materialize = function(entry)
|
||||
if entry.course ~= nil then return entry.course end
|
||||
local courseClass = cpClass("Course")
|
||||
if entry.xmlKey == nil or openXml == nil or courseClass == nil or courseClass.createFromXml == nil then return nil end
|
||||
local ok, course = pcall(courseClass.createFromXml, nil, openXml, entry.xmlKey)
|
||||
if not ok or not isSingleVehicle(course) then
|
||||
if not ok then Logging.warning(ADCourseLibrary.LOG_PREFIX .. "kursus-bibliotek: et gemt kursus kunne ikke læses: %s", tostring(course)) end
|
||||
return nil
|
||||
end
|
||||
entry.course, entry.xmlKey = course, nil
|
||||
return course
|
||||
end
|
||||
|
||||
-- Kun nøglerne læses; nil = filen kunne ikke åbnes/læses (så må den heller ikke overskrives).
|
||||
local function loadUnsafe()
|
||||
local path, xmlSchema = getPath(), getSchema()
|
||||
if path == nil or xmlSchema == nil or cpClass("Course") == nil then return nil end
|
||||
if fileExists ~= nil and not fileExists(path) then return 0 end
|
||||
local xmlFile = XMLFile.loadIfExists("adspCourses", path, xmlSchema)
|
||||
if xmlFile == nil then return nil end
|
||||
openXml = xmlFile
|
||||
local count = 0
|
||||
xmlFile:iterate(ADCourseLibrary.ROOT .. ".course", function(_, key)
|
||||
local libraryKey = xmlFile:getValue(key .. "#adspKey")
|
||||
if libraryKey ~= nil then
|
||||
local used = xmlFile:getValue(key .. "#adspUsed") or 0
|
||||
ADCourseLibrary.entries[libraryKey] = {xmlKey = key, used = used}
|
||||
ADCourseLibrary.counter = math.max(ADCourseLibrary.counter, used)
|
||||
count = count + 1
|
||||
end
|
||||
end)
|
||||
return count
|
||||
end
|
||||
|
||||
-- Indlæs biblioteket fra savegamet første gang det bruges. Fejler læsningen, skrives filen aldrig over (writable).
|
||||
function ADCourseLibrary.load()
|
||||
if ADCourseLibrary.loaded then return end
|
||||
ADCourseLibrary.loaded = true
|
||||
local ok, count = pcall(loadUnsafe)
|
||||
ADCourseLibrary.writable = ok and count ~= nil
|
||||
if not ok then
|
||||
Logging.warning(ADCourseLibrary.LOG_PREFIX .. "kursus-bibliotek kunne ikke indlæses: %s", tostring(count))
|
||||
elseif count ~= nil and count > 0 then
|
||||
logInfo(ADCourseLibrary.LOG_PREFIX .. "kursus-bibliotek: %d gemte kurser fundet", count)
|
||||
end
|
||||
end
|
||||
|
||||
local function saveUnsafe()
|
||||
local path, xmlSchema = getPath(), getSchema()
|
||||
if path == nil or xmlSchema == nil then return end
|
||||
-- filen skrives om: kurser der endnu ikke er pakket ud, læses først (kun når noget er ændret)
|
||||
local keys = {}
|
||||
for key, entry in pairs(ADCourseLibrary.entries) do
|
||||
if materialize(entry) ~= nil then table.insert(keys, key) end
|
||||
end
|
||||
table.sort(keys)
|
||||
closeXml()
|
||||
local xmlFile = XMLFile.create("adspCourses", path, ADCourseLibrary.ROOT, xmlSchema)
|
||||
if xmlFile == nil then return end
|
||||
local ok, err = pcall(function()
|
||||
for index, libraryKey in ipairs(keys) do
|
||||
local entry = ADCourseLibrary.entries[libraryKey]
|
||||
local key = string.format("%s.course(%d)", ADCourseLibrary.ROOT, index - 1)
|
||||
entry.course:saveToXml(xmlFile, key)
|
||||
xmlFile:setValue(key .. "#adspKey", libraryKey)
|
||||
xmlFile:setValue(key .. "#adspUsed", entry.used or 0)
|
||||
end
|
||||
xmlFile:save()
|
||||
end)
|
||||
xmlFile:delete()
|
||||
if not ok then error(err, 0) end
|
||||
ADCourseLibrary.dirty = false
|
||||
end
|
||||
|
||||
-- Skriv biblioteket i savegamet (når spillet gemmer) — kun når noget er ændret, og aldrig hvis læsningen fejlede.
|
||||
function ADCourseLibrary.save()
|
||||
if not ADCourseLibrary.loaded or not ADCourseLibrary.writable or not ADCourseLibrary.dirty then return end
|
||||
local ok, err = pcall(saveUnsafe)
|
||||
if not ok then Logging.warning(ADCourseLibrary.LOG_PREFIX .. "kursus-bibliotek kunne ikke gemmes: %s", tostring(err)) end
|
||||
end
|
||||
|
||||
-- Spillet lukker kortet: den åbne fil frigives
|
||||
function ADCourseLibrary.close()
|
||||
pcall(closeXml)
|
||||
end
|
||||
|
||||
function ADCourseLibrary.installSaveHook()
|
||||
if ItemSystem == nil or ItemSystem.save == nil or Utils == nil then return end
|
||||
ItemSystem.save = Utils.prependedFunction(ItemSystem.save, function() ADCourseLibrary.save() end)
|
||||
if FSBaseMission ~= nil and FSBaseMission.delete ~= nil then
|
||||
FSBaseMission.delete = Utils.prependedFunction(FSBaseMission.delete, function() ADCourseLibrary.close() end)
|
||||
end
|
||||
end
|
||||
@@ -140,7 +140,7 @@ end
|
||||
-- gælder. En gyllevogn/spreder foretrækkes, når gården har mindst minSharePercent af markens behov for DENS vare.
|
||||
function ADFieldFertilizer.preferCandidate(farmId, areaHa)
|
||||
if not ADFieldFertilizer.isEnabled() then return nil end
|
||||
farmId = farmId or (g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId()) or 1
|
||||
farmId = farmId or ADUtil.farmId()
|
||||
local minStock = ADFieldWork ~= nil and ADFieldWork.MIN_REFILL_STOCK_L or 500
|
||||
local share = ADFieldFertilizer.minSharePercent()
|
||||
return function(candidate)
|
||||
|
||||
@@ -956,7 +956,7 @@ function ADFieldJobs.tick(adEnv, 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)
|
||||
local okScan, errScan = pcall(ADFields.scanStep, adEnv, ADUtil.farmId(), 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
|
||||
|
||||
@@ -74,7 +74,7 @@ end
|
||||
-- ---- spil-input ----
|
||||
|
||||
local function farmId()
|
||||
return g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
return ADUtil.farmId()
|
||||
end
|
||||
|
||||
local function position(node)
|
||||
|
||||
@@ -858,7 +858,7 @@ function ADFieldWork.dispatchPool(adEnv, field, info, role, roleAccept, decision
|
||||
return (implement.width or 0) <= 0 or ADFieldModel.checkWidth(role, implement.width, required)
|
||||
end
|
||||
-- gylle som gødning gælder også puljens redskaber (in-game 17/10: MEGA valgt, Supercis stod klar i puljen)
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or nil
|
||||
local farmId = ADUtil.farmId()
|
||||
local pair, why, args = ADPool.pairFor(role, info.x, info.z, implements, tractors, ADPool.blocked(now()), accept,
|
||||
fertilizerPrefer(role, farmId, info))
|
||||
if pair == nil then
|
||||
|
||||
@@ -43,7 +43,7 @@ end
|
||||
|
||||
function ADFleetNames.apply(adEnv)
|
||||
local vehicles, byId, parkUse = {}, {}, {}
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, any in pairs(g_currentMission.vehicleSystem.vehicles) do
|
||||
local index = any.advd ~= nil and any.advd.parkDestination or nil
|
||||
if type(index) == "number" and index >= 1 and any.getOwnerFarmId ~= nil and any:getOwnerFarmId() == farmId then
|
||||
|
||||
@@ -451,7 +451,7 @@ local function guessFor(adEnv, run, vehicle, tractorId)
|
||||
local taken = {}
|
||||
for _, id in ipairs(ADRuns.wagonIdsOf(run)) do taken[id] = true end
|
||||
local candidates = {}
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, any in pairs(g_currentMission.vehicleSystem.vehicles) do
|
||||
local index = any.advd ~= nil and any.advd.parkDestination or nil
|
||||
local attached = any.getAttacherVehicle ~= nil and any:getAttacherVehicle() ~= nil
|
||||
|
||||
@@ -298,6 +298,14 @@ local function isDriveTask(adEnv, task)
|
||||
return false
|
||||
end
|
||||
|
||||
-- Holder en lyskurv (modden FS25_TrafficLights) køretøjet for rødt? Så er det ikke låst næse mod næse og
|
||||
-- må ikke bakkes. api = spillets globale TrafficLights-tabel (nil uden lyskurve-modden).
|
||||
function ADHeadOn.isHeldByTrafficLight(vehicle, api)
|
||||
if api == nil or type(api.isHolding) ~= "function" then return false end
|
||||
local ok, held = pcall(api.isHolding, vehicle)
|
||||
return ok and held == true
|
||||
end
|
||||
|
||||
local function isCandidate(adEnv, vehicle)
|
||||
local ad = vehicle.ad
|
||||
if ad == nil or ad.collisionDetectionModule == nil or ad.collisionDetectionModule.detectedObstable ~= true then return false end
|
||||
@@ -311,6 +319,8 @@ local function isCandidate(adEnv, vehicle)
|
||||
-- holdt med vilje af modden (vent ved aflæsning / udkørsel)
|
||||
if ADUnloadWait ~= nil and ADUnloadWait.getWaitFor ~= nil and ADUnloadWait.getWaitFor(vehicle) ~= nil then return false end
|
||||
if ADOutbound ~= nil and ADOutbound.getHoldFor ~= nil and ADOutbound.getHoldFor(vehicle) ~= nil then return false end
|
||||
local globals = type(getfenv) == "function" and getfenv(0) or nil
|
||||
if globals ~= nil and ADHeadOn.isHeldByTrafficLight(vehicle, globals.TrafficLights) then return false end
|
||||
return true
|
||||
end
|
||||
|
||||
|
||||
@@ -167,6 +167,16 @@ function ADHitchCreep.reverseOutStep(s)
|
||||
return "drive"
|
||||
end
|
||||
|
||||
-- Findes alle noderne stadig? (exists = spillets entityExists; nil i tests). En vogn kan forsvinde midt i en
|
||||
-- bakning (solgt/nulstillet) -> in-game 26/10: getWorldTranslation på en slettet node gav 7800 Lua-fejl på 2 min.
|
||||
function ADHitchCreep.nodesExist(exists, ...)
|
||||
for i = 1, select("#", ...) do
|
||||
local node = select(i, ...)
|
||||
if node == nil or (exists ~= nil and not exists(node)) then return false end
|
||||
end
|
||||
return true
|
||||
end
|
||||
|
||||
-- ---- spil ----
|
||||
|
||||
local function worldPos(node)
|
||||
@@ -285,6 +295,8 @@ function CreepTask:finish(action, distance)
|
||||
if sdm ~= nil and sdm.stopVehicle ~= nil then sdm:stopVehicle() end
|
||||
if action == "done" then
|
||||
logInfo(ADHitchCreep.LOG_PREFIX .. "'%s' står ved '%s' — kobler på", vehicleName(self.vehicle), vehicleName(self.target.wagon))
|
||||
elseif action == "gone" then
|
||||
Logging.warning(ADHitchCreep.LOG_PREFIX .. "'%s' opgav at bakke: vognen eller krogen forsvandt undervejs", vehicleName(self.vehicle))
|
||||
else
|
||||
Logging.warning(ADHitchCreep.LOG_PREFIX .. "'%s' opgav at bakke hen til '%s' (%.1f m tilbage efter %d s)", vehicleName(self.vehicle),
|
||||
vehicleName(self.target.wagon), distance, math.floor(self.elapsedMs / 1000))
|
||||
@@ -296,6 +308,9 @@ end
|
||||
function CreepTask:update(dt)
|
||||
self.elapsedMs = self.elapsedMs + dt
|
||||
self.checkMs = self.checkMs + dt
|
||||
if self.target.wagon.isDeleted or not ADHitchCreep.nodesExist(entityExists, self.target.joint, self.target.target) then
|
||||
return self:finish("gone", 0)
|
||||
end
|
||||
if self.target.wagon.getAttacherVehicle ~= nil and self.target.wagon:getAttacherVehicle() ~= nil then
|
||||
return self:finish("giveUp", 0) -- en anden har taget vognen
|
||||
end
|
||||
@@ -331,7 +346,8 @@ function CreepTask:getI18nInfo() return "" end
|
||||
function CreepTask:getExcludedVehiclesForCollisionCheck() return {self.target.wagon} end
|
||||
|
||||
local function isBlocking(vehicle, object)
|
||||
if object.rootNode == nil then return false end
|
||||
-- et redskab, der er forsvundet (solgt/nulstillet), spærrer ikke længere
|
||||
if object.isDeleted or not ADHitchCreep.nodesExist(entityExists, object.rootNode) then return false end
|
||||
local p = worldPos(object.rootNode)
|
||||
local lx, _, lz = worldToLocal(vehicle.rootNode, p.x, p.y, p.z)
|
||||
return ADHitchCreep.isBlockingFront(lx, lz, (vehicle.size ~= nil and vehicle.size.length or 5) / 2)
|
||||
|
||||
@@ -107,7 +107,7 @@ end
|
||||
|
||||
function ADLivestock.survey(adEnv)
|
||||
local lines = {}
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local placeables = g_currentMission.placeableSystem ~= nil and g_currentMission.placeableSystem.placeables or {}
|
||||
for _, placeable in ipairs(placeables) do
|
||||
local okPlaceable, errPlaceable = pcall(function()
|
||||
@@ -921,7 +921,7 @@ function ADLivestock.load()
|
||||
end
|
||||
|
||||
local function planJobs(adEnv)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
-- gemte "læsset af os"-mærker: knyttes til vognene, når de findes efter indlæsningen
|
||||
-- kreaturvogne er ikke i AD's køretøjsliste: søg i spillets (review). Kun hvis vognen ikke har FLERE dyr end
|
||||
-- ved gemningen (spilleren har ikke sat sine egne ind)
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
-- AD Net
|
||||
-- Multiplayer etape 2a (plan docs/superpowers/plans/2026-10-25-adsmartpickup-multiplayer.md): serverens tilstand
|
||||
-- spejles til klienterne. Rene hjælpere uden spil-afhængighed: en Lua-værdi (tabeller af tal, tekst, bool) bliver til
|
||||
-- tekst og tilbage, og teksten deles i bidder, der sendes hver for sig og samles i vilkårlig rækkefølge.
|
||||
-- Format: n | t | f | d<tal>; | s<længde>:<bytes> | T<nøgle><værdi>...e (funktioner/userdata springes over).
|
||||
|
||||
ADNet = {}
|
||||
|
||||
local function encodeValue(value, out, seen)
|
||||
local kind = type(value)
|
||||
if kind == "nil" then
|
||||
out[#out + 1] = "n"
|
||||
elseif kind == "boolean" then
|
||||
out[#out + 1] = value and "t" or "f"
|
||||
elseif kind == "number" then
|
||||
out[#out + 1] = "d" .. string.format("%.17g", value) .. ";"
|
||||
elseif kind == "string" then
|
||||
out[#out + 1] = "s" .. #value .. ":" .. value
|
||||
elseif kind == "table" then
|
||||
if seen[value] then error("ADNet.encode: cyklisk tabel") end
|
||||
-- et objekt (køretøj, placeable, klasse-instans) har en metatabel: det må aldrig sendes ved en fejl
|
||||
if getmetatable(value) ~= nil then error("ADNet.encode: objekt (tabel med metatabel) kan ikke sendes") end
|
||||
seen[value] = true
|
||||
out[#out + 1] = "T"
|
||||
for key, item in pairs(value) do
|
||||
local keyKind, itemKind = type(key), type(item)
|
||||
if (keyKind == "string" or keyKind == "number" or keyKind == "boolean")
|
||||
and itemKind ~= "function" and itemKind ~= "userdata" and itemKind ~= "thread" then
|
||||
encodeValue(key, out, seen)
|
||||
encodeValue(item, out, seen)
|
||||
end
|
||||
end
|
||||
out[#out + 1] = "e"
|
||||
seen[value] = nil
|
||||
end
|
||||
-- funktioner, userdata og tråde springes over (de kan ikke sendes)
|
||||
end
|
||||
|
||||
function ADNet.encode(value)
|
||||
local out = {}
|
||||
encodeValue(value, out, {})
|
||||
return table.concat(out)
|
||||
end
|
||||
|
||||
local function decodeAt(text, pos)
|
||||
local tag = text:sub(pos, pos)
|
||||
if tag == "n" then return nil, pos + 1 end
|
||||
if tag == "t" then return true, pos + 1 end
|
||||
if tag == "f" then return false, pos + 1 end
|
||||
if tag == "d" then
|
||||
local stop = text:find(";", pos + 1, true)
|
||||
if stop == nil then error("ADNet.decode: tal uden slut") end
|
||||
local number = tonumber(text:sub(pos + 1, stop - 1))
|
||||
if number == nil then error("ADNet.decode: ugyldigt tal ved " .. pos) end
|
||||
return number, stop + 1
|
||||
end
|
||||
if tag == "s" then
|
||||
local colon = text:find(":", pos + 1, true)
|
||||
if colon == nil then error("ADNet.decode: tekst uden længde") end
|
||||
local length = tonumber(text:sub(pos + 1, colon - 1))
|
||||
if length == nil or length < 0 or length % 1 ~= 0 or colon + length > #text then
|
||||
error("ADNet.decode: ugyldig tekstlængde ved " .. pos)
|
||||
end
|
||||
return text:sub(colon + 1, colon + length), colon + length + 1
|
||||
end
|
||||
if tag == "T" then
|
||||
local result = {}
|
||||
pos = pos + 1
|
||||
while text:sub(pos, pos) ~= "e" do
|
||||
if pos > #text then error("ADNet.decode: tabel uden slut") end
|
||||
local key, item
|
||||
key, pos = decodeAt(text, pos)
|
||||
item, pos = decodeAt(text, pos)
|
||||
if key ~= nil and key == key then result[key] = item end -- (NaN kan ikke være nøgle)
|
||||
end
|
||||
return result, pos + 1
|
||||
end
|
||||
error("ADNet.decode: ukendt tegn '" .. tag .. "' ved " .. pos)
|
||||
end
|
||||
|
||||
function ADNet.decode(text)
|
||||
local value = decodeAt(text, 1)
|
||||
return value
|
||||
end
|
||||
|
||||
-- Transport: spillets streamWriteString er ikke garanteret byte-sikker (NUL, UTF-8 delt over bidder), så alt uden
|
||||
-- for synlig ASCII sendes som %XX. Escaping ophæves først efter samlingen, så en bid må gerne skære midt i en %XX.
|
||||
function ADNet.toWire(text)
|
||||
return (text:gsub("[^\32-\36\38-\126]", function(char) return string.format("%%%02X", char:byte()) end))
|
||||
end
|
||||
|
||||
function ADNet.fromWire(text)
|
||||
return (text:gsub("%%(%x%x)", function(hex) return string.char(tonumber(hex, 16)) end))
|
||||
end
|
||||
|
||||
-- Teksten i bidder på højst size tegn (mindst én bid, også for tom tekst).
|
||||
function ADNet.split(text, size)
|
||||
local chunks = {}
|
||||
for start = 1, #text, size do chunks[#chunks + 1] = text:sub(start, start + size - 1) end
|
||||
if #chunks == 0 then chunks[1] = "" end
|
||||
return chunks
|
||||
end
|
||||
|
||||
-- Samling pr. sektion: bidder af en ældre version end den, der er i gang eller allerede er samlet, kasseres; en nyere
|
||||
-- starter forfra. Data kommer fra netværket: ugyldigt index/total afvises i stedet for at fejle (review).
|
||||
function ADNet.newAssembly() return {} end
|
||||
|
||||
local function isIndex(value, total)
|
||||
return type(value) == "number" and value % 1 == 0 and value >= 1 and value <= total
|
||||
end
|
||||
|
||||
-- Returnerer den samlede tekst, når sektionens sidste manglende bid er kommet, ellers nil.
|
||||
function ADNet.addChunk(assembly, section, version, index, total, data)
|
||||
if type(version) ~= "number" or type(total) ~= "number" or total < 1 or total % 1 ~= 0 or not isIndex(index, total)
|
||||
or type(data) ~= "string" then
|
||||
return nil
|
||||
end
|
||||
local current = assembly[section]
|
||||
if current ~= nil and (version < current.version or (current.done and version == current.version)) then return nil end
|
||||
if current == nil or version > current.version then
|
||||
current = {version = version, total = total, parts = {}, count = 0}
|
||||
assembly[section] = current
|
||||
end
|
||||
if total ~= current.total then return nil end
|
||||
if current.parts[index] == nil then
|
||||
current.parts[index] = data
|
||||
current.count = current.count + 1
|
||||
end
|
||||
if current.count < current.total then return nil end
|
||||
local text = table.concat(current.parts, "", 1, current.total)
|
||||
assembly[section] = {version = version, done = true}
|
||||
return text
|
||||
end
|
||||
@@ -1131,7 +1131,7 @@ local function describeLoadFailure(adEnv, vehicle, task, state, source)
|
||||
local parts = {}
|
||||
local marker = adEnv.ADGraphManager.getMapMarkerByWayPointId ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(state.current) or nil
|
||||
table.insert(parts, string.format("markør '%s' (%s)", marker ~= nil and tostring(marker.name) or "?", tostring(state.current)))
|
||||
local ok, products = pcall(ADSources.getProducts, adEnv, source, g_currentMission:getFarmId())
|
||||
local ok, products = pcall(ADSources.getProducts, adEnv, source, ADUtil.farmId())
|
||||
local wanted = {}
|
||||
for _, fillType in ipairs(state.trip.fillTypes) do wanted[fillType] = true end
|
||||
for _, item in ipairs(ok and products or {}) do
|
||||
|
||||
@@ -82,7 +82,7 @@ end
|
||||
-- Frakoblede redskaber med rollen. Returnerer det nærmeste uden AutoDrive-parkering (spilleren kobler det på) og
|
||||
-- om der findes et MED parkering — det henter puljen selv (også når det er i brug), så spilleren spørges ikke.
|
||||
local function looseImplement(adEnv, role, x, z, required, roleAccept, only)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local best, bestD, parkedExists = nil, nil, false
|
||||
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
|
||||
local owned = vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId
|
||||
|
||||
@@ -671,7 +671,7 @@ end
|
||||
-- isBusy(vehicle): markarbejdets optaget-regel (opgave, AD/CP kører, lånt af marksilo, på hjemtur).
|
||||
function ADPool.collect(adEnv, isBusy)
|
||||
local markers = adEnv.ADGraphManager:getMapMarkers()
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local implements, tractors = {}, {}
|
||||
local targeted = connectTargets(adEnv)
|
||||
-- spillets egen liste: frakoblede redskaber er ikke nødvendigvis i AutoDrive's køretøjsliste
|
||||
@@ -730,7 +730,7 @@ end
|
||||
-- spilleren kan se hvorfor) og alle traktorer uden egen arbejdsrolle, der ikke hører til et flow.
|
||||
function ADPool.overview(adEnv)
|
||||
local markers = adEnv.ADGraphManager:getMapMarkers()
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local nowMs = ADFieldJobs.now or 0
|
||||
local implements, tractors = {}, {}
|
||||
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
|
||||
|
||||
@@ -122,7 +122,7 @@ end
|
||||
|
||||
-- Spillerens gård ejer placeablen; ukendt ejer = regnes som egen (afleveringer til egne anlæg er ikke salg).
|
||||
function ADPrices.isOwnedByPlayer(placeable)
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
if getOwner(placeable) == nil then
|
||||
return true
|
||||
end
|
||||
|
||||
@@ -139,6 +139,11 @@ function ADProfiler.install()
|
||||
{ADSmartPickup, "shouldWaitForLoading", "vent ved pålæsning"},
|
||||
{ADSmartPickup, "choosePickup", "forsyning kildevalg"},
|
||||
{ADSmartPickup, "findSupplyPickup", "forsyning kildesøgning"},
|
||||
-- 27/10: kildesøgningen tog 40-45 ms pr. kald — delene måles hver for sig
|
||||
{ADSmartPickup, "restrictSupplySources", "forsyning kildefilter"},
|
||||
{ADSmartPickup, "getStableSiloFillTypes", "forsyning staldsilo"},
|
||||
{ADSmartPickup, "factoryMayGet", "forsyning fabriksreserve"},
|
||||
{ADSmartPickup, "buyFeed", "forsyning købefoder"},
|
||||
{ADRunsController, "applyVehicleNames", "traktornavne"},
|
||||
{ADFieldJobs, "tick", "markarbejde tick"},
|
||||
{ADFields, "scanStep", "markscanning"},
|
||||
@@ -151,6 +156,7 @@ function ADProfiler.install()
|
||||
{ADCpBridge, "start", "Courseplay-start"},
|
||||
{ADCourseCache, "prepare", "kursus-cache"},
|
||||
{ADBuildings, "list", "bygningsliste"},
|
||||
{ADNames, "autoName", "bygningsnavne"},
|
||||
{ADSources, "getFarmInventory", "gårdens lagre"},
|
||||
{ADWaitPool, "hasRouteTo", "rutetjek"},
|
||||
{ADWaitPool, "hasRouteBothWays", "rutetjek frem+tilbage"},
|
||||
|
||||
@@ -47,6 +47,14 @@ local function sellAtValue(value)
|
||||
return clampRange(number, ADRuns.DEFAULT_SELL_AT_PERCENT, ADRuns.MIN_SELL_AT_PERCENT, ADRuns.MAX_SELL_AT_PERCENT)
|
||||
end
|
||||
|
||||
-- Vognen har en ANDEN vare på end den, flowet skal hente, og varen hører til flowet: kan målene ikke tage hele resten
|
||||
-- nu (targetsFree = deres samlede fri plads, nil = ukendt), køres den på lager i stedet for at blokere flowet — ellers
|
||||
-- kører vognen frem og tilbage til et fuldt mål og bliver parkeret med læsset igen (in-game 26/10: 'TMR' havde 383.075 l
|
||||
-- hø på, begge fabrikker var fulde af hø og stod stille uden ensilage). -> true = på lager
|
||||
function ADRuns.storeMixedCargo(targetsFree, liters)
|
||||
return (targetsFree or 0) < (liters or 0)
|
||||
end
|
||||
|
||||
-- Flow-vogne: {[traktorId] = vognId} (maskinpulje — flowet henter sin egen vogn).
|
||||
-- Start alle pr. flow: isRunning (traktorer kører AD), stopped (pause fra Stop alt / Stop).
|
||||
-- -> "queue" (start traktorerne), "resume" (kører allerede: kun pausen ophæves), "skip".
|
||||
|
||||
@@ -39,7 +39,7 @@ function ADRunsController.getVehicleId(vehicle)
|
||||
end
|
||||
|
||||
function ADRunsController.getFarmVehicles(adEnv)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local result = {}
|
||||
for _, vehicle in pairs(adEnv.AutoDrive.getAllVehicles()) do
|
||||
-- kun motoriserede (traktorer, høstere); AD-spec'en sidder også på redskaber
|
||||
@@ -197,7 +197,7 @@ function ADRunsController.canStoreAt(adEnv, building, goods)
|
||||
if building.unloadMarker == nil or ADLoadSwap == nil or ADLoadSwap.isStoreTarget == nil then
|
||||
return false
|
||||
end
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
local station = ADSmartPickup.getUnloadStationAtWayPointId(adEnv, building.unloadMarker.id, farmId)
|
||||
if station == nil then
|
||||
return false
|
||||
@@ -215,7 +215,7 @@ end
|
||||
function ADRunsController.getStoreBuildings(adEnv, run)
|
||||
local result = {}
|
||||
if ADBuildings == nil or run == nil then return result end
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, buildingId in ipairs(run.storeBuildingIds or {}) do
|
||||
local building = ADBuildings.find(adEnv, farmId, buildingId)
|
||||
if building ~= nil then table.insert(result, building) end
|
||||
@@ -227,7 +227,7 @@ end
|
||||
function ADRunsController.getFeedBuildings(adEnv, run)
|
||||
local result = {}
|
||||
if ADBuildings == nil or run == nil then return result end
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, buildingId in ipairs(run.feedBuildingIds or {}) do
|
||||
local building = ADBuildings.find(adEnv, farmId, buildingId)
|
||||
if building ~= nil then table.insert(result, building) end
|
||||
@@ -239,7 +239,7 @@ end
|
||||
function ADRunsController.getStoreMarkers(adEnv, run)
|
||||
local result = {}
|
||||
if ADBuildings == nil or run == nil then return result end
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, buildingId in ipairs(run.storeBuildingIds or {}) do
|
||||
local building = ADBuildings.find(adEnv, farmId, buildingId)
|
||||
if building ~= nil and building.unloadMarker ~= nil then
|
||||
@@ -485,7 +485,7 @@ end
|
||||
|
||||
-- Alle varer målet tager (uanset vogn) — afkrydsningslisten i GUI'et. {index, name, title}, sorteret på titel.
|
||||
function ADRunsController.getTargetAcceptedFillTypes(adEnv, run)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local stations = getTargetStations(adEnv, run, farmId)
|
||||
if #stations == 0 then
|
||||
return {}
|
||||
@@ -615,7 +615,7 @@ function ADRunsController.resolveMarkers(adEnv, run)
|
||||
if ADBuildings == nil or run == nil then
|
||||
return {missing = missing}
|
||||
end
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local role = run.kind == "outbound" and "load" or "unload"
|
||||
local buildingIds = run.kind == "outbound" and run.sourceBuildingIds or run.targetBuildingIds
|
||||
local existing = run.kind == "outbound" and run.sourceWayPointIds or ADRunsController.getRunTargets(run)
|
||||
@@ -709,7 +709,7 @@ function ADRunsController.migrateBuildings(adEnv)
|
||||
if ADBuildings == nil then
|
||||
return
|
||||
end
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, run in ipairs(ADRunsController.store.runs) do
|
||||
local role = run.kind == "outbound" and "load" or "unload"
|
||||
local ids = copyList(run.kind == "outbound" and run.sourceBuildingIds or run.targetBuildingIds)
|
||||
@@ -734,7 +734,7 @@ end
|
||||
|
||||
-- Data til én række i flow-tavlen (GUI'et formaterer teksten).
|
||||
function ADRunsController.getFlowRow(adEnv, run)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local row = {productNames = {}, productAuto = false, fromNames = {}, toNames = {}, fromAllSilos = run.kind ~= "outbound", missing = {}, policies = {}, vehicleNames = {}, collectRound = run.collectRound == true, sellAtPercent = run.sellAtPercent, storeAbovePercent = run.storeAbovePercent, loops = run.loops, kind = run.kind}
|
||||
local ids = run.kind == "outbound" and run.sourceBuildingIds or run.targetBuildingIds
|
||||
local names = run.kind == "outbound" and row.fromNames or row.toNames
|
||||
@@ -862,7 +862,7 @@ end
|
||||
-- Alle varer kilderne rummer/producerer med run'ets politik (uanset vogn) — til fanen Udkørsel.
|
||||
-- {fillType, name, title, policy, isPallet, available, level, capacity}, sorteret på titel.
|
||||
function ADRunsController.getRunProducts(adEnv, run, includeEmpty)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local byName, result = {}, {}
|
||||
for _, source in ipairs(getRunSources(adEnv, run, farmId)) do
|
||||
for _, item in ipairs(ADSources.getProducts(adEnv, source, farmId, includeEmpty)) do
|
||||
@@ -1066,7 +1066,9 @@ end
|
||||
-- Vognens last som INGEN af run'ets mål tager -> {marker, fillType, liters} for en silo der gør
|
||||
-- (plads >= resten, vejnet til siloen og fra siloen til målet); nil når lasten passer eller
|
||||
-- ingen silo findes (så kører AD som normalt og Wait-logikken tager over).
|
||||
function ADRunsController.findWrongCargoDump(adEnv, run, vehicle, targetId)
|
||||
-- storeIfTargetsFull: vognen skal hente en ANDEN vare end den har på (pålæsningen) — så køres også en vare, der hører
|
||||
-- til flowet, på lager, når målene ikke kan tage hele resten (ADRuns.storeMixedCargo). Ved Start (uden) som før.
|
||||
function ADRunsController.findWrongCargoDump(adEnv, run, vehicle, targetId, storeIfTargetsFull)
|
||||
if ADUnloadWait == nil or ADUnloadWait.getRestLoad == nil or ADLoadSwap == nil or ADLoadSwap.findDumpMarker == nil then
|
||||
return nil
|
||||
end
|
||||
@@ -1077,27 +1079,37 @@ function ADRunsController.findWrongCargoDump(adEnv, run, vehicle, targetId)
|
||||
local farmId = ADSmartPickup.getFarmId(vehicle)
|
||||
-- Lasten hører til run'et: valgte varer ("Vælg"), eller alt målet tager ("Auto"). Kun så afleveres
|
||||
-- den ved målet — ellers havnede fx gødning i en ensilage-DOB, fordi DOB'en også tager gødning.
|
||||
local belongs = false
|
||||
if run.ingredientMode == "manual" then
|
||||
for _, index in ipairs(ADRunsController.getRunIngredients(adEnv, run, vehicle)) do
|
||||
if index == fillType then return nil end
|
||||
if index == fillType then belongs = true end
|
||||
end
|
||||
else
|
||||
end
|
||||
local targetsFree, measured = 0, false
|
||||
for _, entry in ipairs(getTargetStations(adEnv, run, farmId)) do
|
||||
if ADSmartPickup.getStationLevelAndCapacity(entry.station, fillType, farmId) ~= nil then
|
||||
return nil
|
||||
local level, capacity = ADSmartPickup.getStationLevelAndCapacity(entry.station, fillType, farmId)
|
||||
if level ~= nil then
|
||||
if run.ingredientMode ~= "manual" then belongs = true end
|
||||
measured = true
|
||||
targetsFree = targetsFree + math.max(0, (capacity or 0) - level)
|
||||
end
|
||||
end
|
||||
local why = "målet tager ikke varen"
|
||||
if belongs then
|
||||
-- ingen mål kunne måles (review): leveres som før, ikke på lager på et gæt
|
||||
if not (storeIfTargetsFull and measured and ADRuns.storeMixedCargo(targetsFree, liters)) then return nil end
|
||||
why = string.format("målene har kun %.0f l fri", targetsFree)
|
||||
end
|
||||
local isReachable = function(markerId)
|
||||
return ADUnloadWait.hasRouteTo == nil or ADUnloadWait.hasRouteTo(adEnv, vehicle, markerId)
|
||||
end
|
||||
local marker, why = ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, liters, targetId, isReachable)
|
||||
local marker, noDumpWhy = ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, liters, targetId, isReachable)
|
||||
local fillTypeName = g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeNameByIndex(fillType) or tostring(fillType)
|
||||
if marker == nil then
|
||||
Logging.warning(ADRunsController.LOG_PREFIX .. "run '%s': '%s' har %.0f l %s på vognen, som målet ikke tager — %s; AutoDrive starter som normalt", tostring(run.name), tostring(ADRuns.vehicleLabel(vehicle)), liters, tostring(fillTypeName), tostring(why))
|
||||
Logging.warning(ADRunsController.LOG_PREFIX .. "run '%s': '%s' har %.0f l %s på vognen (%s) — %s; AutoDrive starter som normalt", tostring(run.name), tostring(ADRuns.vehicleLabel(vehicle)), liters, tostring(fillTypeName), why, tostring(noDumpWhy))
|
||||
return nil
|
||||
end
|
||||
logInfo(ADRunsController.LOG_PREFIX .. "run '%s': '%s' læsser først %.0f l %s af i %s (markør %s) — målet tager ikke varen", tostring(run.name), tostring(ADRuns.vehicleLabel(vehicle)), liters, tostring(fillTypeName), tostring(marker.name), tostring(marker.markerIndex or marker.id))
|
||||
logInfo(ADRunsController.LOG_PREFIX .. "run '%s': '%s' læsser først %.0f l %s af i %s (markør %s) — %s", tostring(run.name), tostring(ADRuns.vehicleLabel(vehicle)), liters, tostring(fillTypeName), tostring(marker.name), tostring(marker.markerIndex or marker.id), why)
|
||||
return {marker = marker, fillType = fillType, liters = liters}
|
||||
end
|
||||
|
||||
@@ -1745,7 +1757,7 @@ end
|
||||
-- Niveauer pr. mål for run'ets varer: {{wayPointId, name, levels = {{fillType, level, capacity, free}}}}
|
||||
-- i samme rangering som valget bruger (trug som én trang, fodervægt som prioritet); fulde sidst.
|
||||
function ADRunsController.getTargetsLevels(adEnv, run)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local fillTypes = {}
|
||||
if run.ingredientMode == "manual" then
|
||||
for _, name in ipairs(run.ingredients) do
|
||||
|
||||
@@ -10,6 +10,9 @@ ADRunsStorage.LOG_PREFIX = "ADSmartPickup: "
|
||||
|
||||
-- Samme opslag som AutoDrive.getXMLFile_new: mappen kendes efter første gem, ellers via indeks.
|
||||
function ADRunsStorage.getPath()
|
||||
-- multiplayer-klient: serveren ejer modens data; en klient må aldrig skrive (fallback-stien ville ramme spillerens
|
||||
-- egen lokale savegameN med samme nummer). Alle modens filer går gennem denne sti (ADUtil.savePath).
|
||||
if ADUtil ~= nil and ADUtil.isMpClient() then return nil end
|
||||
local info = g_currentMission ~= nil and g_currentMission.missionInfo or nil
|
||||
if info == nil then
|
||||
return nil
|
||||
|
||||
@@ -575,7 +575,7 @@ end
|
||||
local function plan(adEnv)
|
||||
if ADSettings == nil or ADSettings.get("autoSalt") ~= 1 then return end
|
||||
if not ADSaltRoute.shouldStart(snowHeight(), ADSaltRoute.lastDone, currentDay()) then return end
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local spreaders = findSpreaders(adEnv, farmId)
|
||||
if #spreaders == 0 then
|
||||
warnOnce("noSpreader", "der ligger sne, men ingen ledig saltspreder (købt, med P-plads og Connect-markør) — der saltes ikke")
|
||||
|
||||
@@ -74,7 +74,7 @@ end
|
||||
-- Alle salgssteder med AD-markør -> {{id, names}} (markørens navn først: det spilleren ser i AutoDrive).
|
||||
local function sellStations(adEnv)
|
||||
local list, byId = {}, {}
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
||||
local station = ADSmartPickup.getUnloadStationAtWayPointId(adEnv, marker.id, farmId)
|
||||
local id = station ~= nil and ADPrices.isSellingStation(station) and stationId(station) or nil
|
||||
|
||||
@@ -13,6 +13,10 @@ ADSettings.LOG_PREFIX = "ADSmartPickup: indstilling: "
|
||||
|
||||
-- nøgle -> {default, min, max, text}. Nye indstillinger tilføjes her, så de får standardværdi, grænser og hjælpetekst.
|
||||
ADSettings.KEYS = {
|
||||
-- dedikeret server (multiplayer): gården ADSmartPickup kører for; 0 = automatisk (gården med flest AD-køretøjer).
|
||||
-- Uden valg-liste, så den ikke står i indstillingsfanen; sættes i singleplayer med spuSet serverFarmId 2 (gemmes i
|
||||
-- ADSmartPickup_settings.xml og følger savegamet over på serveren) eller direkte i den fil
|
||||
serverFarmId = {default = 0, min = 0, max = 16, text = "dedikeret server: gården ADSmartPickup kører for (0 = automatisk)"},
|
||||
stableSiloRange = {default = 80, min = 10, max = 500, perBuilding = true, choices = {40, 60, 80, 100, 120, 150, 200, 300}, format = "%s m",
|
||||
text = "m: en silo inden for denne afstand af en stald er staldens egen silo (forsyning henter der først)"},
|
||||
waitHomeMinutes = {default = 0, min = 0, max = 240, perBuilding = true, choices = {0, 5, 10, 15, 20, 30, 45, 60, 90, 120}, format = "%s min",
|
||||
@@ -228,10 +232,10 @@ local function findBuilding(name)
|
||||
local adEnv = ADFieldSilos ~= nil and ADFieldSilos.adEnv or nil
|
||||
if adEnv == nil or ADBuildings == nil or g_currentMission == nil then return nil end
|
||||
local wanted = string.lower(name)
|
||||
for _, building in ipairs(ADBuildings.list(adEnv, g_currentMission:getFarmId()) or {}) do
|
||||
for _, building in ipairs(ADBuildings.list(adEnv, ADUtil.farmId()) or {}) do
|
||||
if string.lower(tostring(building.name)) == wanted then return building end
|
||||
end
|
||||
for _, building in ipairs(ADBuildings.list(adEnv, g_currentMission:getFarmId()) or {}) do
|
||||
for _, building in ipairs(ADBuildings.list(adEnv, ADUtil.farmId()) or {}) do
|
||||
if string.find(string.lower(tostring(building.name)), wanted, 1, true) then return building end
|
||||
end
|
||||
return nil
|
||||
|
||||
@@ -428,8 +428,9 @@ end
|
||||
local function collectMarkerStations(adEnv, candidateMarkers, farmId, excludedPlaceable)
|
||||
local markerStations = {}
|
||||
for _, marker in pairs(candidateMarkers) do
|
||||
local wayPoint = ADSmartPickup.isSourceMarker(marker) and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
|
||||
local station = wayPoint ~= nil and getLoadStationAtMarker(adEnv, wayPoint, farmId) or nil
|
||||
-- cachet opslag (30 s, spredt udløb): kildesøgningen kører for hver vogn og gennemgik alle markører x alle
|
||||
-- stationer x triggere hver gang (savegame8 27/10: 20 søgninger/min á 40-45 ms, op til 214 ms)
|
||||
local station = ADSmartPickup.isSourceMarker(marker) and ADSmartPickup.getLoadStationAtWayPointId(adEnv, marker.id, farmId) or nil
|
||||
local isExcluded = station ~= nil and excludedPlaceable ~= nil and station.owningPlaceable == excludedPlaceable
|
||||
if station ~= nil and not isExcluded then
|
||||
table.insert(markerStations, {marker = marker, station = station})
|
||||
@@ -464,6 +465,14 @@ local function getProductionPoint(station)
|
||||
return nil
|
||||
end
|
||||
|
||||
-- Fabrikkens eget lager af varen (liter); 0 når lageret ikke kan læses.
|
||||
local function productionLevel(productionPoint, fillType)
|
||||
local storage = productionPoint ~= nil and productionPoint.storage or nil
|
||||
if storage == nil or storage.getFillLevel == nil then return 0 end
|
||||
local ok, level = pcall(storage.getFillLevel, storage, fillType)
|
||||
return ok and level or 0
|
||||
end
|
||||
|
||||
-- En fabriks læssestation udleverer også dens INPUTS (fx halm i en TMR-fabrik).
|
||||
-- Dem stjæler vi aldrig — fabrikken ville løbe tør for det, den skal bruge.
|
||||
-- Outputs (og varer der både er input og output i en kæde) må gerne hentes.
|
||||
@@ -512,6 +521,10 @@ local function mayUseSource(station, fillTypes, level, loadCapacity, need)
|
||||
if ADSupplyPlanner.isProductionInput(productionPoint.productions, fillType) then
|
||||
local perMinute = ADSupplyPlanner.inputUsePerMinute(productionPoint.productions, fillType)
|
||||
if not ADSupplyPlanner.mayTakeInput(level, loadCapacity, perMinute, need) then return false end
|
||||
if need ~= nil and need.trough and ADSupplyPlanner.inputMakesBetterFood(productionPoint.activeProductions, fillType,
|
||||
need.priority, need.foodWeights, function(inputType) return productionLevel(productionPoint, inputType) end) then
|
||||
return false
|
||||
end
|
||||
end
|
||||
end
|
||||
return true
|
||||
@@ -920,7 +933,8 @@ local function getTargetNeeds(station, ingredients, farmId, demand)
|
||||
if level ~= nil then
|
||||
local troughScore, priority, troughCapacity = getFoodPriority(station, fillType)
|
||||
if troughScore == nil or ADSupplyPlanner.troughNeedsRefill(troughScore, threshold) then
|
||||
table.insert(needs, {fillType = fillType, level = level, capacity = capacity, litersPerMinute = demand[fillType], scoreOverride = troughScore, priority = priority, troughCapacity = troughCapacity})
|
||||
local foodWeights = troughScore ~= nil and getHusbandryFoodFillTypes(getHusbandry(station)) or nil
|
||||
table.insert(needs, {fillType = fillType, level = level, capacity = capacity, litersPerMinute = demand[fillType], scoreOverride = troughScore, priority = priority, troughCapacity = troughCapacity, foodWeights = foodWeights})
|
||||
end
|
||||
end
|
||||
end
|
||||
@@ -1228,7 +1242,7 @@ local function logSupplyMiss(driver, ranked, bestFood, markerStations, farmId, h
|
||||
end
|
||||
end
|
||||
local fillType = g_fillTypeManager ~= nil and g_fillTypeManager.getFillTypeByIndex ~= nil and g_fillTypeManager:getFillTypeByIndex(need.fillType) or nil
|
||||
table.insert(parts, string.format("%s: fri %.0f l, %s, %d kilder med lager (bedst %.0f l), %d afvist (dyrestaldens eget lager, fabriksreserve, eller triggeren giver varen ikke ud)%s",
|
||||
table.insert(parts, string.format("%s: fri %.0f l, %s, %d kilder med lager (bedst %.0f l), %d afvist (dyrestaldens eget lager, fabriksreserve, fabrikken laver bedre foder af den, eller triggeren giver varen ikke ud)%s",
|
||||
fillType ~= nil and fillType.name or tostring(need.fillType), need.freeSpace or 0,
|
||||
(held or {})[need] and ((held or {})[need] == "stable" and "HOLDT (bedre foder på lager — prioriteringslisten)"
|
||||
or (held or {})[need] == "trigger" and "HOLDT (triggeren ved målmarkøren tager ikke varen)"
|
||||
@@ -1275,8 +1289,10 @@ ADSmartPickup.carriedLiters = carriedLiters
|
||||
-- Køb dyrefoder ved en købestation, når intet eget lager kan levere: første tilladte trug-behov i rækkefølgen.
|
||||
-- Aldrig når vognen allerede har varen (in-game 8/10: EDK 650 på 1 mio. l blev fyldt ved Solid Buy, truget tog
|
||||
-- 150.000 l — med 848.000 l rest ville den købe igen i stedet for at aflevere resten).
|
||||
-- held (valgfri): behov findSupplyPickup holder tilbage; "trigger" = triggeren ved målmarkøren tager ikke varen
|
||||
-- (in-game 25/10: TMR købt til '102 Cow Barn Straw', halmtriggeren afviste den, Kostald 3 sultede).
|
||||
local boughtLoggedAt = setmetatable({}, {__mode = "k"})
|
||||
function ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint, wayPointId)
|
||||
function ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint, wayPointId, held)
|
||||
if ADFieldWork == nil or ADFieldWork.findBuyMarker == nil or targetWayPoint == nil then
|
||||
buyMissReason[driver] = "intet mål"
|
||||
return nil
|
||||
@@ -1289,9 +1305,11 @@ function ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint,
|
||||
return nil
|
||||
end
|
||||
end
|
||||
local reasons = {}
|
||||
local reasons, triggerHeld = {}, 0
|
||||
for _, need in ipairs(ranked or {}) do
|
||||
if need.trough and (ADSupplyPlanner.isFoodAllowed == nil or ADSupplyPlanner.isFoodAllowed(need, bestFood)) then
|
||||
if need.trough and (held or {})[need] == "trigger" then triggerHeld = triggerHeld + 1 end
|
||||
if need.trough and (held or {})[need] ~= "trigger"
|
||||
and (ADSupplyPlanner.isFoodAllowed == nil or ADSupplyPlanner.isFoodAllowed(need, bestFood)) then
|
||||
local markerId, info = ADFieldWork.findBuyMarker(adEnv, driver, need.fillType, targetWayPoint.x, targetWayPoint.z, driver.ad == nil)
|
||||
local marker = markerId ~= nil and adEnv.ADGraphManager:getMapMarkerByWayPointId(markerId) or nil
|
||||
if marker == nil and #reasons < 4 then
|
||||
@@ -1313,7 +1331,9 @@ function ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint,
|
||||
end
|
||||
end
|
||||
end
|
||||
buyMissReason[driver] = #reasons > 0 and table.concat(reasons, "; ") or "intet trug-foder mangler"
|
||||
buyMissReason[driver] = #reasons > 0 and table.concat(reasons, "; ")
|
||||
or triggerHeld > 0 and string.format("%d trug-varer afvist: triggeren ved målmarkøren tager dem ikke", triggerHeld)
|
||||
or "intet trug-foder mangler"
|
||||
return nil
|
||||
end
|
||||
|
||||
@@ -1447,7 +1467,7 @@ function ADSmartPickup.findSupplyPickup(adEnv, driver, ingredients, targetWayPoi
|
||||
end
|
||||
end
|
||||
-- dyrene skal have foder: intet eget lager -> køb ved en købestation (sidste udvej, 8/10)
|
||||
local bought = ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint, wayPointId)
|
||||
local bought = ADSmartPickup.buyFeed(adEnv, driver, ranked, bestFood, targetWayPoint, wayPointId, held)
|
||||
if bought ~= nil then return bought end
|
||||
local okLog, errLog = pcall(logSupplyMiss, driver, ranked, bestFood, markerStations, farmId, held)
|
||||
if not okLog then Logging.warning(ADSmartPickup.LOG_PREFIX .. "forsynings-diagnose: %s", tostring(errLog)) end
|
||||
@@ -1706,7 +1726,7 @@ local function installLoadWaitHook(adEnv)
|
||||
if run ~= nil and ADRunsController.findWrongCargoDump ~= nil and ADUnloadWait.setDumpTarget ~= nil then
|
||||
local stateModule = loadTask.vehicle.ad.stateModule
|
||||
local current = stateModule.getSecondMarker ~= nil and stateModule:getSecondMarker() or nil
|
||||
local ok, dump = pcall(ADRunsController.findWrongCargoDump, adEnv, run, loadTask.vehicle, current ~= nil and current.id or nil)
|
||||
local ok, dump = pcall(ADRunsController.findWrongCargoDump, adEnv, run, loadTask.vehicle, current ~= nil and current.id or nil, true)
|
||||
if ok and dump ~= nil then
|
||||
ADUnloadWait.setDumpTarget(loadTask.vehicle, dump.marker.id)
|
||||
end
|
||||
@@ -1720,6 +1740,11 @@ local function installLoadWaitHook(adEnv)
|
||||
if loadTask.spuParkedChecked or ADFlowWagons == nil or ADFlowWagons.isDeliveringParkedLoad == nil then return false end
|
||||
loadTask.spuParkedChecked = true
|
||||
if not ADFlowWagons.isDeliveringParkedLoad(adEnv, loadTask.vehicle) then return false end
|
||||
-- en ANDEN vare end den, der skal hentes: som blandet last (hasWrongCargo) — kan målene ikke tage den, køres den
|
||||
-- på lager, så flowet kan hente det, der mangler (in-game 26/10: parkeret hø blokerede ensilagen til TMR-fabrikkerne)
|
||||
local pickup = activePickups[loadTask.vehicle]
|
||||
local cargoType = ADUnloadWait ~= nil and ADUnloadWait.getRestLoad ~= nil and ADUnloadWait.getRestLoad(adEnv, loadTask.vehicle) or nil
|
||||
if pickup ~= nil and pickup.fillType ~= nil and cargoType ~= nil and cargoType ~= pickup.fillType then return false end
|
||||
logInfo(ADSmartPickup.LOG_PREFIX .. "'%s' leverer parkeret læs først", tostring(ADRuns.vehicleLabel(loadTask.vehicle)))
|
||||
return true
|
||||
end
|
||||
@@ -1974,11 +1999,21 @@ function ADSmartPickup:loadMap()
|
||||
end
|
||||
end
|
||||
|
||||
-- Multiplayer etape 1: al automatik og indlæsning/gemning kun på serveren (den har AD/CP og køretøjerne). Singleplayer
|
||||
-- og værten er server; en MP-klient viser kun HUD'en (status fra serveren kommer i etape 2).
|
||||
function ADSmartPickup.isServer()
|
||||
return ADUtil.isServer()
|
||||
end
|
||||
|
||||
function ADSmartPickup:update(dt)
|
||||
if ADProfiler ~= nil and ADProfiler.installed then
|
||||
local now = ADProfiler.clock()
|
||||
if now ~= nil then pcall(ADProfiler.frame, now) end
|
||||
end
|
||||
if not ADSmartPickup.isServer() then
|
||||
if ADStatusHud ~= nil then pcall(ADStatusHud.update, dt, getAutoDriveEnv()) end
|
||||
return
|
||||
end
|
||||
if not isHooked then
|
||||
local adEnv = getAutoDriveEnv()
|
||||
if adEnv ~= nil and g_currentMission ~= nil and g_currentMission.storageSystem ~= nil then
|
||||
@@ -1989,6 +2024,7 @@ function ADSmartPickup:update(dt)
|
||||
if ADRunsController ~= nil then
|
||||
pcall(ADRunsController.load, adEnv)
|
||||
pcall(ADRunsController.installSaveHook)
|
||||
if ADCourseLibrary ~= nil then pcall(ADCourseLibrary.installSaveHook) end
|
||||
end
|
||||
end
|
||||
return
|
||||
@@ -2108,6 +2144,8 @@ function ADSmartPickup:update(dt)
|
||||
if ADRunsController ~= nil and ADRunsController.adoptLoadedThrottled ~= nil then
|
||||
pcall(ADRunsController.adoptLoadedThrottled, getAutoDriveEnv(), dt)
|
||||
end
|
||||
-- multiplayer etape 2c: konfigurationen til klienterne (kun i et MP-spil)
|
||||
if ADSync ~= nil and ADSync.serverTick ~= nil then pcall(ADSync.serverTick, dt) end
|
||||
local ok, err = pcall(restoreStoppedVehicles)
|
||||
if not ok then
|
||||
Logging.warning(ADSmartPickup.LOG_PREFIX .. "kunne ikke gendanne varevalg: %s", tostring(err))
|
||||
|
||||
@@ -514,7 +514,7 @@ local function getSiloProducts(source, includeEmpty)
|
||||
-- storageRadius: tanken selv kan være tom mens puljen er fuld. Læssestationens tal er det man kan hente.
|
||||
local station = source.station
|
||||
if station ~= nil and station.getAllFillLevels ~= nil then
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
local ok, pooled, pooledCapacity = pcall(station.getAllFillLevels, station, farmId)
|
||||
if ok and type(pooled) == "table" then
|
||||
for fillType, level in pairs(pooled) do
|
||||
@@ -631,7 +631,7 @@ end
|
||||
|
||||
local function getHusbandryProducts(adEnv, source)
|
||||
local placeable, station = source.placeable, source.station
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
if station == nil then
|
||||
-- kilde via staldens pallespawner (hønsehus: æg): kun pallevarerne
|
||||
return getHusbandryPalletProducts(source, farmId)
|
||||
@@ -656,7 +656,7 @@ local function getHusbandryProducts(adEnv, source)
|
||||
-- en siloExtension inden for storageRadius). getHusbandryFillLevel ser kun staldens egen beholder.
|
||||
local stationLevels = nil
|
||||
if station ~= nil and station.getAllFillLevels ~= nil then
|
||||
local ok, levels = pcall(station.getAllFillLevels, station, g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1)
|
||||
local ok, levels = pcall(station.getAllFillLevels, station, ADUtil.farmId())
|
||||
if ok and type(levels) == "table" then stationLevels = levels end
|
||||
end
|
||||
local products = {}
|
||||
@@ -678,7 +678,7 @@ local function getStationProducts(source)
|
||||
if station == nil or station.getAllFillLevels == nil then
|
||||
return {}
|
||||
end
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or 1
|
||||
local farmId = ADUtil.farmId()
|
||||
local ok, levels, capacity = pcall(station.getAllFillLevels, station, farmId)
|
||||
if not ok or type(levels) ~= "table" then
|
||||
return {}
|
||||
@@ -1530,7 +1530,7 @@ local function getHusbandryStationLevels(placeable)
|
||||
if storage == nil or storage.getLoadingStations == nil then return result end
|
||||
for _, station in pairs(storage:getLoadingStations()) do
|
||||
if station.owningPlaceable == placeable and station.getAllFillLevels ~= nil then
|
||||
local ok, levels = pcall(station.getAllFillLevels, station, g_currentMission:getFarmId())
|
||||
local ok, levels = pcall(station.getAllFillLevels, station, ADUtil.farmId())
|
||||
for fillType, level in pairs(ok and type(levels) == "table" and levels or {}) do
|
||||
result[fillType] = math.max(result[fillType] or 0, level or 0)
|
||||
end
|
||||
|
||||
@@ -285,7 +285,7 @@ end
|
||||
function ADStatusHud.stuckEntries()
|
||||
local entries = {}
|
||||
if ADStuckDiag == nil or ADStuckDiag.stillVehicles == nil then return entries end
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or nil
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, still in ipairs(ADStuckDiag.stillVehicles(ADStatusHud.STUCK_WARN_MS)) do
|
||||
local vehicle = still.vehicle
|
||||
local owned = not isGone(vehicle) and (farmId == nil or (vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId))
|
||||
|
||||
@@ -108,7 +108,7 @@ function ADStrayUnload.tick(adEnv, dt)
|
||||
timerMs = 0
|
||||
if adEnv == nil or ADUnloadWait == nil or ADFlowWagons == nil or ADRunsController == nil or ADSmartPickup == nil then return end
|
||||
local minutes = ADSettings ~= nil and ADSettings.get("strayFullMinutes") or 5
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or nil
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
|
||||
local mine = farmId == nil or (vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId)
|
||||
local ok, stuck, targetName, rest, fillType, targetId = false, false, nil, nil, nil, nil
|
||||
|
||||
@@ -129,6 +129,31 @@ function ADSupplyPlanner.mayTakeInput(level, load, perMinute, need)
|
||||
return (level or 0) - (load or 0) >= reserve
|
||||
end
|
||||
|
||||
-- Bliver varen til BEDRE foder for truget i en kørende produktion? Så må truget ikke tage den (in-game 25/10: Kostald 3
|
||||
-- og 4 tømte TMR Production Facility 2 for 1,46 mio. l ensilage på 15 min — 1 l ensilage giver 2 l TMR, og begge
|
||||
-- TMR-fabrikker stod stille). Kun når produktionen har de andre råvarer til en cyklus; ellers bliver varen aldrig til TMR.
|
||||
-- activeProductions = fabrikkens aktive produktioner ({inputs, outputs} med type/amount; nil = ukendt = må tages),
|
||||
-- needPriority = trugets fodervægt for varen, foodWeights = {[fillType] = vægt} for truget, levelOf(fillType) -> liter.
|
||||
function ADSupplyPlanner.inputMakesBetterFood(activeProductions, fillType, needPriority, foodWeights, levelOf)
|
||||
if activeProductions == nil or foodWeights == nil or needPriority == nil then return false end
|
||||
for _, production in ipairs(activeProductions) do
|
||||
local usesIt, better, complete = false, false, true
|
||||
for _, input in ipairs(production.inputs or {}) do
|
||||
if input.type == fillType then
|
||||
usesIt = true
|
||||
elseif (levelOf(input.type) or 0) < (input.amount or 0) then
|
||||
complete = false
|
||||
end
|
||||
end
|
||||
for _, output in ipairs(production.outputs or {}) do
|
||||
local weight = foodWeights[output.type]
|
||||
if weight ~= nil and weight > needPriority then better = true end
|
||||
end
|
||||
if usesIt and better and complete then return true end
|
||||
end
|
||||
return false
|
||||
end
|
||||
|
||||
-- Fabrikker får kun en vare, dyrene spiser, når gårdens hentbare lager (siloer/objektlagre/fabrikkers output) stadig
|
||||
-- dækker dyrenes forbrug i ANIMAL_RESERVE_MONTHS efter læsset (brugerønske 8/10: "systemet skal sige fra ved ting som
|
||||
-- fermentor indtil gårdens driftslager er i siloerne"). animalPerMonth = dyrenes forbrug (0/nil = dyrene spiser den ikke).
|
||||
@@ -271,6 +296,7 @@ function ADSupplyPlanner.rankNeeds(needs, loadCapacity)
|
||||
score = need.scoreOverride or ADSupplyPlanner.scoreNeed(need.level, need.capacity, freeSpace, minutesToEmpty),
|
||||
priority = need.priority or 0,
|
||||
trough = need.scoreOverride ~= nil,
|
||||
foodWeights = need.foodWeights,
|
||||
})
|
||||
end
|
||||
end
|
||||
|
||||
@@ -0,0 +1,200 @@
|
||||
-- AD Sync
|
||||
-- Multiplayer etape 2c (plan docs/superpowers/plans/2026-10-25-adsmartpickup-multiplayer.md): modulernes
|
||||
-- konfiguration spejles fra serveren til klienterne. Hver sektion har collect (serveren: den tilstand, der sendes) og
|
||||
-- apply (klienten: læg den modtagne tilstand ind). Serveren sammenligner hver SYNC_MS den kodede tekst med den sidst
|
||||
-- sendte og sender kun ændrede sektioner; en spiller, der tilslutter sig, får alle. Kernen er ren (testes uden spillet).
|
||||
|
||||
ADSync = {}
|
||||
|
||||
ADSync.SYNC_MS = 2000
|
||||
ADSync.CHUNK_SIZE = 6000 -- tegn pr. event (konservativt; streamWriteString's grænse er ukendt — review 2a)
|
||||
local LOG_PREFIX = "ADSmartPickup: "
|
||||
|
||||
function ADSync.new(sections, chunkSize)
|
||||
return {sections = sections, chunkSize = chunkSize or ADSync.CHUNK_SIZE, lastSent = {}, versions = {},
|
||||
assembly = ADNet.newAssembly(), byName = {}}
|
||||
end
|
||||
|
||||
local function packetsFor(sync, name, text)
|
||||
local version = (sync.versions[name] or 0) + 1
|
||||
sync.versions[name] = version
|
||||
local chunks = ADNet.split(ADNet.toWire(text), sync.chunkSize)
|
||||
local packets = {}
|
||||
for index, data in ipairs(chunks) do
|
||||
packets[#packets + 1] = {section = name, version = version, index = index, total = #chunks, data = data}
|
||||
end
|
||||
return packets
|
||||
end
|
||||
|
||||
-- Kodet tekst pr. sektion; en sektion, der fejler, springes over (og logges én gang pr. fejltekst).
|
||||
local function collectTexts(sync)
|
||||
local texts = {}
|
||||
for _, section in ipairs(sync.sections) do
|
||||
local ok, text = pcall(function() return ADNet.encode(section.collect()) end)
|
||||
if ok then
|
||||
texts[section.name] = text
|
||||
elseif sync.loggedError ~= tostring(text) and Logging ~= nil then
|
||||
sync.loggedError = tostring(text)
|
||||
Logging.warning(LOG_PREFIX .. "multiplayer-synk af %s fejlede: %s", section.name, tostring(text))
|
||||
end
|
||||
end
|
||||
return texts
|
||||
end
|
||||
|
||||
-- Serveren: pakker for de sektioner, der har ændret sig siden sidst.
|
||||
function ADSync.collectChanged(sync)
|
||||
local packets = {}
|
||||
local texts = collectTexts(sync)
|
||||
for _, section in ipairs(sync.sections) do
|
||||
local text = texts[section.name]
|
||||
if text ~= nil and text ~= sync.lastSent[section.name] then
|
||||
sync.lastSent[section.name] = text
|
||||
for _, packet in ipairs(packetsFor(sync, section.name, text)) do packets[#packets + 1] = packet end
|
||||
end
|
||||
end
|
||||
return packets
|
||||
end
|
||||
|
||||
-- Serveren: alle sektioner (til en spiller, der tilslutter sig). Rører IKKE lastSent: pakkerne går kun til den nye
|
||||
-- spiller, så en ændring, de andre endnu ikke har fået, skal stadig broadcastes ved næste tick (review H1).
|
||||
function ADSync.collectAll(sync)
|
||||
local packets = {}
|
||||
local texts = collectTexts(sync)
|
||||
for _, section in ipairs(sync.sections) do
|
||||
local text = texts[section.name]
|
||||
if text ~= nil then
|
||||
for _, packet in ipairs(packetsFor(sync, section.name, text)) do packets[#packets + 1] = packet end
|
||||
end
|
||||
end
|
||||
return packets
|
||||
end
|
||||
|
||||
-- Klienten: én pakke; når sektionen er samlet, anvendes den. Fejl (ødelagt pakke, ukendt sektion) vælter intet.
|
||||
function ADSync.receive(sync, packet)
|
||||
local text = ADNet.addChunk(sync.assembly, packet.section, packet.version, packet.index, packet.total, packet.data)
|
||||
if text == nil then return false end
|
||||
local section = nil
|
||||
for _, candidate in ipairs(sync.sections) do if candidate.name == packet.section then section = candidate end end
|
||||
if section == nil then return false end
|
||||
local ok, err = pcall(function() section.apply(ADNet.decode(ADNet.fromWire(text))) end)
|
||||
if not ok and Logging ~= nil then Logging.warning(LOG_PREFIX .. "multiplayer-synk: %s kunne ikke anvendes: %s", packet.section, tostring(err)) end
|
||||
return ok
|
||||
end
|
||||
|
||||
---------------------------------------------------------------- spillet
|
||||
|
||||
-- Modulernes konfiguration (etape 2c). Kun rene data (ingen køretøjs-objekter — ADNet afviser dem).
|
||||
local function fieldsCollect()
|
||||
local state = ADFieldJobs.state
|
||||
return {fields = state.fields, fleet = state.fleet, fleetMode = state.fleetMode, excluded = state.excluded,
|
||||
manual = state.manual, playerTrips = state.playerTrips, paused = state.paused, resumed = state.resumed}
|
||||
end
|
||||
|
||||
local function fieldsApply(value)
|
||||
local state = ADFieldJobs.state
|
||||
for _, key in ipairs({"fields", "fleet", "excluded", "manual", "playerTrips", "resumed"}) do state[key] = value[key] or {} end
|
||||
state.fleetMode = value.fleetMode or "all"
|
||||
state.paused = value.paused == true
|
||||
end
|
||||
|
||||
function ADSync.gameSections()
|
||||
return {
|
||||
{name = "RUNS", collect = function() return ADRunsController.store end,
|
||||
apply = function(value) ADRunsController.store = value end},
|
||||
{name = "FIELDS", collect = fieldsCollect, apply = fieldsApply},
|
||||
{name = "NAMES", collect = function() return ADNames.byId end, apply = function(value) ADNames.byId = value end},
|
||||
{name = "SETTINGS", collect = function() return ADSettings.snapshot() end, apply = function(value) ADSettings.restore(value) end},
|
||||
{name = "SELLBLOCK", collect = function() return ADSellBlock.blocked end, apply = function(value) ADSellBlock.blocked = value or {} end},
|
||||
{name = "LOCKS", collect = function() return ADLivestock.locks end, apply = function(value) ADLivestock.locks = value or {} end},
|
||||
{name = "SILOCFG", collect = function() return ADFieldSiloConfig.toRecord(ADFieldSilos.config) end,
|
||||
apply = function(value) ADFieldSilos.config = ADFieldSiloConfig.fromRecord(value) end},
|
||||
{name = "CHAINSTATE", collect = function() return ADChain.state end, apply = function(value) ADChain.state = value end},
|
||||
}
|
||||
end
|
||||
|
||||
-- Kun i et multiplayer-spil (singleplayer er helt uberørt).
|
||||
local function isMultiplayer()
|
||||
local info = g_currentMission ~= nil and g_currentMission.missionDynamicInfo or nil
|
||||
return info ~= nil and info.isMultiplayer == true
|
||||
end
|
||||
|
||||
ADSync.sinceMs = 0
|
||||
local loggedSizes, loggedTickError = false, nil
|
||||
function ADSync.serverTick(dt)
|
||||
if g_server == nil or not isMultiplayer() or ADSyncEvent == nil then return end
|
||||
ADSync.sinceMs = ADSync.sinceMs + (dt or 0)
|
||||
if ADSync.sinceMs < ADSync.SYNC_MS then return end
|
||||
ADSync.sinceMs = 0
|
||||
local ok, err = pcall(function()
|
||||
ADSync.game = ADSync.game or ADSync.new(ADSync.gameSections())
|
||||
local packets = ADSync.collectChanged(ADSync.game)
|
||||
if not loggedSizes and #packets > 0 then
|
||||
-- én gang: hvor store sektionerne er (review M2: mål trafikken in-game)
|
||||
loggedSizes = true
|
||||
local sizes = {}
|
||||
for name, text in pairs(ADSync.game.lastSent) do sizes[#sizes + 1] = string.format("%s %d", name, #text) end
|
||||
table.sort(sizes)
|
||||
Logging.info(LOG_PREFIX .. "multiplayer-synk: sektioner (tegn) %s", table.concat(sizes, ", "))
|
||||
end
|
||||
for _, packet in ipairs(packets) do g_server:broadcastEvent(ADSyncEvent.new(packet)) end
|
||||
end)
|
||||
if not ok and loggedTickError ~= tostring(err) then
|
||||
loggedTickError = tostring(err)
|
||||
Logging.warning(LOG_PREFIX .. "multiplayer-synk fejlede: %s", tostring(err))
|
||||
end
|
||||
end
|
||||
|
||||
if Class ~= nil and Event ~= nil and InitEventClass ~= nil then
|
||||
ADSyncEvent = {}
|
||||
local ADSyncEvent_mt = Class(ADSyncEvent, Event)
|
||||
InitEventClass(ADSyncEvent, "ADSyncEvent")
|
||||
|
||||
function ADSyncEvent.emptyNew() return Event.new(ADSyncEvent_mt) end
|
||||
|
||||
function ADSyncEvent.new(packet)
|
||||
local self = ADSyncEvent.emptyNew()
|
||||
self.packet = packet
|
||||
return self
|
||||
end
|
||||
|
||||
function ADSyncEvent:writeStream(streamId, connection)
|
||||
local p = self.packet
|
||||
streamWriteString(streamId, p.section)
|
||||
streamWriteInt32(streamId, p.version)
|
||||
streamWriteUInt16(streamId, p.index)
|
||||
streamWriteUInt16(streamId, p.total)
|
||||
streamWriteString(streamId, p.data)
|
||||
end
|
||||
|
||||
function ADSyncEvent:readStream(streamId, connection)
|
||||
local section = streamReadString(streamId)
|
||||
local version = streamReadInt32(streamId)
|
||||
local index = streamReadUInt16(streamId)
|
||||
local total = streamReadUInt16(streamId)
|
||||
self.packet = {section = section, version = version, index = index, total = total, data = streamReadString(streamId)}
|
||||
self:run(connection)
|
||||
end
|
||||
|
||||
-- Kun server -> klient: en klient anvender serverens tilstand
|
||||
function ADSyncEvent:run(connection)
|
||||
-- kun en ren klient anvender: værten (og singleplayer) har selv sandheden (review H2)
|
||||
if g_server ~= nil or not connection:getIsServer() then return end
|
||||
ADSync.client = ADSync.client or ADSync.new(ADSync.gameSections())
|
||||
ADSync.receive(ADSync.client, self.packet)
|
||||
end
|
||||
|
||||
-- En spiller, der tilslutter sig, får alle sektioner (samme krog som Courseplays CpJoinEvent).
|
||||
if FSBaseMission ~= nil and FSBaseMission.onConnectionFinishedLoading ~= nil then
|
||||
FSBaseMission.onConnectionFinishedLoading = Utils.appendedFunction(FSBaseMission.onConnectionFinishedLoading,
|
||||
function(_, connection)
|
||||
-- kun i multiplayer (singleplayer har også en lokal forbindelse — review H2)
|
||||
if connection == nil or g_server == nil or not isMultiplayer() then return end
|
||||
if connection.getIsLocal ~= nil and connection:getIsLocal() then return end
|
||||
local ok, err = pcall(function()
|
||||
ADSync.game = ADSync.game or ADSync.new(ADSync.gameSections())
|
||||
for _, packet in ipairs(ADSync.collectAll(ADSync.game)) do connection:sendEvent(ADSyncEvent.new(packet)) end
|
||||
end)
|
||||
if not ok then Logging.warning(LOG_PREFIX .. "multiplayer-synk ved tilslutning fejlede: %s", tostring(err)) end
|
||||
end)
|
||||
end
|
||||
end
|
||||
@@ -452,7 +452,7 @@ local function updateWaiting(adEnv, task, wait, dt)
|
||||
wait.isRejected = isRejected
|
||||
-- ventetid ved Wait (ADSettings "waitHomeMinutes", pr. stald): udløbet -> resten køres hjem i gårdens lager
|
||||
wait.waitedMs = (wait.waitedMs or 0) + (dt or 0)
|
||||
local homeBuilding = ADBuildings ~= nil and ADBuildings.byMarker ~= nil and ADBuildings.byMarker(adEnv, g_currentMission:getFarmId(), home, "unload") or nil
|
||||
local homeBuilding = ADBuildings ~= nil and ADBuildings.byMarker ~= nil and ADBuildings.byMarker(adEnv, ADUtil.farmId(), home, "unload") or nil
|
||||
local waitMinutes = ADSettings ~= nil and ADSettings.get("waitHomeMinutes", homeBuilding ~= nil and homeBuilding.id or nil) or 0
|
||||
if ADUnloadWait.waitHomeDue(wait.waitedMs, waitMinutes) and ADLoadSwap ~= nil and ADLoadSwap.findDumpMarker ~= nil then
|
||||
local marker = ADLoadSwap.findDumpMarker(adEnv, vehicle, fillType, rest, home, function(markerId) return hasRouteTo(adEnv, vehicle, markerId) end)
|
||||
|
||||
@@ -7,6 +7,58 @@ local function logInfo(...) return (ADLog or Logging).info(...) end
|
||||
|
||||
ADUtil = {}
|
||||
|
||||
-- Gården ADSmartPickup kører for (multiplayer etape 1; én fælles gård, brugerens valg 25/10). Med lokal spiller
|
||||
-- (singleplayer/vært) spillerens gård. På en dedikeret server er der ingen spiller (tilskuer-gården): så den
|
||||
-- indstillede gård (serverFarmId), ellers gården med flest AutoDrive-køretøjer, ellers 1.
|
||||
-- Server/klient (multiplayer): singleplayer og værten er server; en MP-klient er klient uden server.
|
||||
function ADUtil.isServer() return g_server ~= nil end
|
||||
function ADUtil.isMpClient() return g_client ~= nil and g_server == nil end
|
||||
|
||||
ADUtil.FARM_CACHE_MS = 60000
|
||||
local farmCache = {id = nil, atMs = -math.huge}
|
||||
|
||||
function ADUtil.resetFarmCache() farmCache = {id = nil, atMs = -math.huge} end
|
||||
|
||||
function ADUtil.configuredFarmId()
|
||||
local value = ADSettings ~= nil and ADSettings.get ~= nil and tonumber(ADSettings.get("serverFarmId")) or 0
|
||||
return math.floor(value)
|
||||
end
|
||||
|
||||
local function spectatorFarmId()
|
||||
return FarmManager ~= nil and FarmManager.SPECTATOR_FARM_ID or 0
|
||||
end
|
||||
|
||||
local function dominantFarmId()
|
||||
local counts, best, bestCount = {}, nil, 0
|
||||
local system = g_currentMission ~= nil and g_currentMission.vehicleSystem or nil
|
||||
for _, vehicle in ipairs(system ~= nil and system.vehicles or {}) do
|
||||
if vehicle.ad ~= nil and vehicle.getOwnerFarmId ~= nil then
|
||||
local farm = vehicle:getOwnerFarmId()
|
||||
if farm ~= nil and farm ~= spectatorFarmId() then
|
||||
counts[farm] = (counts[farm] or 0) + 1
|
||||
if counts[farm] > bestCount or (counts[farm] == bestCount and farm < best) then best, bestCount = farm, counts[farm] end
|
||||
end
|
||||
end
|
||||
end
|
||||
return best
|
||||
end
|
||||
|
||||
function ADUtil.farmId()
|
||||
local mission = g_currentMission
|
||||
if mission ~= nil and mission.getFarmId ~= nil then
|
||||
local own = mission:getFarmId()
|
||||
if own ~= nil and own ~= spectatorFarmId() then return own end
|
||||
end
|
||||
local configured = ADUtil.configuredFarmId()
|
||||
if configured ~= nil and configured > 0 then return configured end
|
||||
if mission == nil then return 1 end
|
||||
local nowMs = ADUtil.now()
|
||||
if farmCache.id == nil or nowMs - farmCache.atMs > ADUtil.FARM_CACHE_MS or nowMs < farmCache.atMs then
|
||||
farmCache = {id = dominantFarmId() or 1, atMs = nowMs}
|
||||
end
|
||||
return farmCache.id
|
||||
end
|
||||
|
||||
-- Spiltid i ms (g_currentMission.time); uden spil (tests) processorens tid.
|
||||
function ADUtil.now()
|
||||
if g_currentMission ~= nil and type(g_currentMission.time) == "number" then return g_currentMission.time end
|
||||
|
||||
@@ -374,6 +374,11 @@ function ADWaitPool.install(adEnv)
|
||||
local original = graph.markChanges
|
||||
graph.markChanges = function(self, ...)
|
||||
ADWaitPool.resetRouteCache()
|
||||
-- markør -> station-svarene er nøglet på vejpunkt-id, og AD omnummererer ved sletning (review 27/10)
|
||||
if ADCache ~= nil and ADCache.clear ~= nil then
|
||||
ADCache.clear("loadStation")
|
||||
ADCache.clear("unloadStation")
|
||||
end
|
||||
return original(self, ...)
|
||||
end
|
||||
return true
|
||||
|
||||
@@ -64,7 +64,7 @@ end
|
||||
-- Siloer der tager markens vare: marksilo først, gæringssiloer, så de nærmeste (samme regel som før).
|
||||
function SmartPickupFrame:fieldStoreContext(adEnv, info, plan, chosenIds)
|
||||
local fillType = fieldFillType(info, plan)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local fieldSilos, silosById = {}, {}
|
||||
for _, building in ipairs(ADFields.fieldSilos(adEnv, farmId, info)) do
|
||||
local markers = ADBuildings.getMarkers ~= nil and ADBuildings.getMarkers(building, "unload") or {}
|
||||
|
||||
@@ -83,7 +83,7 @@ function SmartPickupFrame:fillFieldSiloRows(adEnv)
|
||||
end
|
||||
|
||||
self:addTextRow(i18n:getText("spu_fs_storesTitle"))
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
for _, building in ipairs(ADBuildings.list(adEnv, farmId)) do
|
||||
if building.kind == "silo" then
|
||||
local option = self:addToggleRow("fsStore", ADBuildings.labelWithPlace(building), onOff, ADFieldSiloConfig.hasStore(cfg, building.id))
|
||||
|
||||
@@ -398,7 +398,7 @@ end
|
||||
function SmartPickupFrame:onAutoAllResult(yes)
|
||||
self:safe(function(frame)
|
||||
if not yes then return end
|
||||
local result = ADAutoCrop.applyAll(g_currentMission:getFarmId(), frame.getAdEnv(), {resetUser = frame.autoAllResetUser == true})
|
||||
local result = ADAutoCrop.applyAll(ADUtil.farmId(), frame.getAdEnv(), {resetUser = frame.autoAllResetUser == true})
|
||||
if result.scanning then
|
||||
frame.statusOverride = frame.i18n:getText("spu_field_autoAllScanning")
|
||||
frame.statusOverrideTicks = SmartPickupFrame.STATUS_OVERRIDE_TICKS
|
||||
|
||||
@@ -174,7 +174,7 @@ end
|
||||
-- og kan bære flowets varer. Bedste først (navnematch, så "Disponibel"). In-game 29/9: flowet kunne ikke oprettes
|
||||
-- uden at omdøbe en vogns parkering til flowets navn.
|
||||
function SmartPickupFrame:flowWagonContext(adEnv, preview)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local markers = adEnv.ADGraphManager:getMapMarkers()
|
||||
local wanted = flowFillTypes(adEnv, preview)
|
||||
local candidates = {}
|
||||
@@ -242,7 +242,7 @@ end
|
||||
|
||||
-- draft: kladden (eller selve run'et — samme feltnavne).
|
||||
function SmartPickupFrame:flowGuideContext(adEnv, draft)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local preview = ADFlowGuide.previewRun(draft, function(buildingId, role)
|
||||
local building = ADBuildings.find(adEnv, farmId, buildingId)
|
||||
local ids = {}
|
||||
|
||||
@@ -14,7 +14,7 @@ SmartPickupFrame.SELL_MARKERS_CACHE_MS = 30000
|
||||
function SmartPickupFrame:getSellMarkersCached(adEnv)
|
||||
local time = g_time or (os.clock ~= nil and os.clock() * 1000) or 0
|
||||
if self.sellMarkersCache == nil or (time - (self.sellMarkersCacheTime or 0)) > SmartPickupFrame.SELL_MARKERS_CACHE_MS then
|
||||
self.sellMarkersCache = ADSources.getSellMarkers(adEnv, g_currentMission:getFarmId())
|
||||
self.sellMarkersCache = ADSources.getSellMarkers(adEnv, ADUtil.farmId())
|
||||
self.sellMarkersCacheTime = time
|
||||
end
|
||||
return self.sellMarkersCache
|
||||
|
||||
@@ -36,7 +36,7 @@ end
|
||||
-- silo). Fast rækkefølge også for ens navne (sted, så id — review)
|
||||
local function collectBarns(adEnv)
|
||||
local barns, animalBarns = {}, {}
|
||||
for _, building in ipairs(ADBuildings.list(adEnv, g_currentMission:getFarmId()) or {}) do
|
||||
for _, building in ipairs(ADBuildings.list(adEnv, ADUtil.farmId()) or {}) do
|
||||
if building.kind == "husbandry" then table.insert(barns, building) end
|
||||
if building.kind == "husbandry" or (building.placeable ~= nil and building.placeable.spec_husbandryAnimals ~= nil) then
|
||||
table.insert(animalBarns, building)
|
||||
|
||||
@@ -50,7 +50,7 @@ function SmartPickupFrame:getInventory(adEnv)
|
||||
if ADSources == nil or ADSources.getFarmInventory == nil then
|
||||
return {}
|
||||
end
|
||||
return ADSources.getFarmInventory(adEnv, g_currentMission:getFarmId())
|
||||
return ADSources.getFarmInventory(adEnv, ADUtil.farmId())
|
||||
end
|
||||
|
||||
-- ---- detaljer for den valgte bygning ----
|
||||
@@ -71,7 +71,7 @@ end
|
||||
|
||||
-- Beregner stats for alle varer i bygningen (gårdens totaler og rater regnes én gang pr. opdatering).
|
||||
function SmartPickupFrame:computeBuildingStats(adEnv, entry, inventory)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local totals = ADStorageStats.farmTotals(inventory)
|
||||
local rates = ADSources.getFarmRates ~= nil and ADSources.getFarmRates(adEnv, farmId) or {}
|
||||
local stats = {}
|
||||
@@ -120,7 +120,7 @@ end
|
||||
function SmartPickupFrame:storageLabels(inventory, adEnv)
|
||||
local counts, seen, labels = {}, {}, {}
|
||||
for _, entry in ipairs(inventory) do counts[entry.name] = (counts[entry.name] or 0) + 1 end
|
||||
local farmId = g_currentMission ~= nil and g_currentMission.getFarmId ~= nil and g_currentMission:getFarmId() or nil
|
||||
local farmId = ADUtil.farmId()
|
||||
for index, entry in ipairs(inventory) do
|
||||
seen[entry.name] = (seen[entry.name] or 0) + 1
|
||||
local base = counts[entry.name] > 1 and string.format("%s #%d", entry.name, seen[entry.name]) or entry.name
|
||||
|
||||
@@ -77,7 +77,7 @@ end
|
||||
-- Fanens varer med statistik; gårdens totaler/kapacitet/rater regnes over HELE gården.
|
||||
function SmartPickupFrame:computeItemStats(adEnv, inventory, fullInventory)
|
||||
self.lastFullInventory = fullInventory -- til "kræver handling" -> flow (hvem bruger varen)
|
||||
local farmId = g_currentMission:getFarmId()
|
||||
local farmId = ADUtil.farmId()
|
||||
local totals = ADStorageStats.farmTotals(fullInventory)
|
||||
local capacities = ADStorageStats.farmCapacities(fullInventory)
|
||||
local rates = ADSources.getFarmRates ~= nil and ADSources.getFarmRates(adEnv, farmId) or {}
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
<?xml version="1.0" encoding="utf-8" standalone="no"?>
|
||||
<modDesc descVersion="107">
|
||||
<author>masterdraco</author>
|
||||
<version>1.62.411.0</version>
|
||||
<version>1.62.417.1</version>
|
||||
<title>
|
||||
<en>AD Smart Pickup</en>
|
||||
<de>AD Smart Pickup</de>
|
||||
@@ -42,6 +42,8 @@ Menu: ESC-menuen, siden "Smart Pickup". Statusvindue: numpad *. Kræver AutoDriv
|
||||
<l10n filenamePrefix="l10n/l10n"/>
|
||||
<extraSourceFiles>
|
||||
<sourceFile filename="adUtil.lua"/>
|
||||
<sourceFile filename="adNet.lua"/>
|
||||
<sourceFile filename="adSync.lua"/>
|
||||
<sourceFile filename="adCache.lua"/>
|
||||
<sourceFile filename="adNaming.lua"/>
|
||||
<sourceFile filename="adNames.lua"/>
|
||||
@@ -83,6 +85,7 @@ Menu: ESC-menuen, siden "Smart Pickup". Statusvindue: numpad *. Kræver AutoDriv
|
||||
<sourceFile filename="adFields.lua"/>
|
||||
<sourceFile filename="adCpBridge.lua"/>
|
||||
<sourceFile filename="adCourseCache.lua"/>
|
||||
<sourceFile filename="adCourseLibrary.lua"/>
|
||||
<sourceFile filename="adFieldStorage.lua"/>
|
||||
<sourceFile filename="adManualTransport.lua"/>
|
||||
<sourceFile filename="adPalletRefill.lua"/>
|
||||
|
||||
Reference in New Issue
Block a user