Files
fs25-adsmartpickup/FS25_ADSmartPickup/adPool.lua
T

678 lines
32 KiB
Lua

-- AD Pool
-- Maskinpulje: plove, kultivatorer, såmaskiner … holder frakoblet på deres AD-parkering "X", og en ledig
-- solo-traktor henter dem via markøren "Connect X", når markarbejdet mangler en færdig kombination.
-- Ren logik øverst (testes med luajit), spil-adapter nederst.
ADPool = {}
ADPool.LOG_PREFIX = "ADSmartPickup: pulje: "
ADPool.QUARANTINE_MS = 600000 -- redskab der ikke kunne kobles på, springes over så længe
-- ---- ren logik ----
-- Rolle for et frakoblet redskab ud fra dets egne specs (samme prioritet som markflåden); en ren vogn med
-- tip/snegl er tømmevogn.
function ADPool.roleOf(specs)
local role = ADFieldFleet.roleFromSpecs(specs)
if role ~= nil and role ~= "unloader" then return role end
if specs.spec_trailer and specs.spec_dischargeable then return "unloader" end
return role
end
-- Ekstra roller for et redskab: sprøjtens roller (gødning/kalk/ukrudt) — men ikke for en såmaskine med
-- gødningstank (Kinze 4905), den er kun såmaskine (in-game 30/9: hentet til ren gødning).
function ADPool.rolesOf(role, sprayRoles)
if role ~= "seeder" and sprayRoles ~= nil then return sprayRoles end
return ADFieldFleet.rolesFor(role)
end
-- Butiksdata er enten et tal eller en tabel pr. konfiguration: største tal, ellers nil.
function ADPool.numberOf(value)
if type(value) == "number" then return value end
if type(value) ~= "table" then return nil end
local best = nil
for _, entry in pairs(value) do
if type(entry) == "number" and (best == nil or entry > best) then best = entry end
end
return best
end
-- Mangler et af tallene, tillades det (intet må gå i stå på manglende data).
function ADPool.powerOk(tractorHp, neededHp)
if tractorHp == nil or neededHp == nil or tractorHp <= 0 or neededHp <= 0 then return true end
return tractorHp >= neededHp
end
-- Butikskategori: markredskaber kun bag traktorer (tractorsS/M/L …) — ikke lastbil/Unimog, læssere o.l.
-- Tømmevogne må alle trække. Ukendt kategori tillades (intet må gå i stå på manglende data).
ADPool.ANY_PULLER_ROLES = {unloader = true}
function ADPool.categoryOk(category, role)
if category == nil or ADPool.ANY_PULLER_ROLES[role] then return true end
return tostring(category):lower():find("^tractors") ~= nil
end
local function suits(tractor, implement, role)
return ADPool.powerOk(tractor.hp, implement.neededHp) and ADPool.categoryOk(tractor.category, role)
end
-- Markøren "Connect <parkering>" for en parkering (navneregel).
function ADPool.connectFor(parkName, markers)
if type(parkName) ~= "string" then return nil end
local wanted = parkName:lower()
for _, marker in pairs(markers or {}) do
local action, target = ADHitch.parseMarker(marker.name)
if action == "attach" and target ~= nil and target:lower() == wanted then return marker end
end
return nil
end
-- Kan redskabet tage opgaven? En spreder fuld af en ANDEN vare (fx 100.000 l kalk til en gødningsopgave) kan ikke:
-- kun en lille rest må hældes ud (dumpable). In-game 9/10: K105 med kalk hentet til gødning -> "stadig tom" ved marken.
function ADPool.hasRole(item, role)
if not (item.role == role or (item.roles ~= nil and item.roles[role] == true)) then return false end
local wrongFill = item.filledRole ~= nil and item.filledRole ~= role
return not (wrongFill and item.dumpable == false)
end
local hasRole = ADPool.hasRole
local function distanceSq(ax, az, bx, bz)
return (ax - bx) ^ 2 + (az - bz) ^ 2
end
local function nearest(items, x, z, keep)
local best, bestDistance = nil, math.huge
for _, item in ipairs(items) do
if keep == nil or keep(item) then
local distance = distanceSq(item.x, item.z, x, z)
if distance < bestDistance then best, bestDistance = item, distance end
end
end
return best
end
-- Når opgaven slutter, sættes puljeredskabet af — også når AutoDrive ellers selv ville parkere (påfyldte
-- sæt): AD parkerer ved redskabets plads med redskabet på. Aldrig ved manuel transport.
-- Bedste pasform: den mindste traktor med hk nok; afstand afgør kun mellem traktorer inden for FIT_BAND af den
-- mindste. Over OVERSIZE_FACTOR x behovet kun når intet andet passer; ukendt traktor-hk efter de kendte.
-- Redskab uden hk-data: nærmeste (intet at matche på). tractors = allerede filtrerede kandidater.
ADPool.FIT_BAND = 1.15
ADPool.OVERSIZE_FACTOR = 2.5
function ADPool.bestFit(tractors, implement, role)
local fitting = {}
for _, tractor in ipairs(tractors or {}) do
if suits(tractor, implement, role) then table.insert(fitting, tractor) end
end
local needed = implement.neededHp
if needed == nil or needed <= 0 then return nearest(fitting, implement.x, implement.z) end
local sized, oversized, unknown = {}, {}, {}
for _, tractor in ipairs(fitting) do
if tractor.hp == nil or tractor.hp <= 0 then table.insert(unknown, tractor)
elseif tractor.hp > needed * ADPool.OVERSIZE_FACTOR then table.insert(oversized, tractor)
else table.insert(sized, tractor) end
end
local pool = #sized > 0 and sized or (#unknown > 0 and unknown or oversized)
if pool ~= unknown then
local smallest = math.huge
for _, tractor in ipairs(pool) do smallest = math.min(smallest, tractor.hp) end
local band = {}
for _, tractor in ipairs(pool) do
if tractor.hp <= smallest * ADPool.FIT_BAND then table.insert(band, tractor) end
end
pool = band
end
return nearest(pool, implement.x, implement.z)
end
function ADPool.shouldReturnHome(assignment)
return not assignment.manual
end
-- Kun maskiner uden egen arbejdsrolle (almindelige traktorer) henter puljeredskaber — ikke mejetærskere,
-- selvkørende sprøjter o.l., selv om de har koblingspunkter.
-- Kan køretøjet hente puljevogne? Ikke lastbiler (butikskategori) eller køretøjer med eget lad/tank
-- (in-game 4/10: pallebil og mælkebil sendt efter en GX 520). s = {category, ownBody}
ADPool.NON_PULLER_CATEGORIES = {trucks = true, cars = true}
function ADPool.isPuller(s)
if s.ownBody then return false end
-- FS25's butikskategorier står med store bogstaver ("CARS") — sammenlign uden (in-game 14/10: pickup som trækker)
return not ADPool.NON_PULLER_CATEGORIES[string.lower(tostring(s.category or ""))]
end
function ADPool.canPull(role)
return role == nil
end
-- Hvem fik koblingen til at fejle? Kom traktoren ikke frem, er det traktoren (ingen AD-rute), ellers redskabet.
function ADPool.failureBlames(reason)
if tostring(reason):find("^stoppedAway") ~= nil then return "tractor" end
return "implement"
end
-- Efter koblingen: refill = markarbejdets påfyldningsplan (nil = intet at fylde).
function ADPool.nextDrive(refill)
if refill == nil or not refill.empty then return "drive" end
if refill.refillId ~= nil then return "load" end
return "empty"
end
-- Puljen bruges til opgaver med ét sæt (også tømmevogne ved høst), ikke når marken har egne faste maskiner
-- til rollen.
function ADPool.mayUsePool(decision, hasOwnForRole)
return (decision.count or 1) == 1 and not hasOwnForRole
end
-- Kan puljevognen bære varen? (implement.carries = {[fillType] = true}; nil vare = intet krav)
function ADPool.canCarry(implement, fillType)
if fillType == nil then return true end
return implement.carries ~= nil and implement.carries[fillType] == true
end
-- Status til flådefanen. s = {parkName, hasConnect, attachedTo, quarantineMin, reserved} -> nøgle, argument
function ADPool.implementStatus(s)
if s.parkName == nil then return "noPark" end
if not s.hasConnect then return "noConnect", s.parkName end
if s.attachedTo ~= nil then return "attached", s.attachedTo end
if s.flowName ~= nil then return "flow", s.flowName end
if (s.quarantineMin or 0) > 0 then return "quarantine", s.quarantineMin end
if s.reserved then return "reserved" end
return "parked", s.parkName
end
-- s = {hasPark, enabled, controlled, returning, fieldId, busy, offNetwork, hitched} -> nøgle, argument
function ADPool.tractorStatus(s)
if not s.hasPark then return "noPark" end
if s.controlled then return "player" end
if s.returning then return "returning" end
if s.fieldId ~= nil then return "job", s.fieldId end
if s.busy then return "busy" end
if not s.enabled then return "notInFleet" end
if s.offNetwork then return "offNetwork" end
if s.hitched then return "hitched" end
return "free"
end
-- Frontmonteret løst redskab: dets AD-parkering hedder noget med "front" ("P Front Mower"). Spillet har intet
-- pålideligt front-signal for et frakoblet redskab (CP/AD ser kun påkoblede), så navnet afgør (in-game 8/10).
function ADPool.isFrontImplement(parkName)
return ADHitch.isFrontName(parkName)
end
-- Er traktoren ledig til puljen? attached = {{front, role}} for de redskaber der sidder direkte på den. Alt bagpå
-- blokerer (som før); foran kun et redskab med markrolle — en frontvægt er almindelig (in-game 8/10: traktor med
-- frontslåmaskine blev regnet som ledig solo-traktor).
function ADPool.isFreeTractor(attached)
for _, item in ipairs(attached or {}) do
if not item.front or item.role ~= nil then return false end
end
return true
end
-- Roller hvor front + bag hentes sammen som ét sæt (front fylder hullet mellem butterfly-slåmaskinerne).
ADPool.COMBO_ROLES = {mower = true}
local function frontTractors(tractors)
local list = {}
for _, tractor in ipairs(tractors) do
if tractor.freeFront then table.insert(list, tractor) end
end
return list
end
-- Kombiens hk-behov: spillet lægger redskabernes reelle PTO-forbrug sammen på motoren (powerConsumer, kW), så det
-- summeres. Butikkens "anbefalet hk" er for hvert redskab alene og alt for højt for sættet (KDD 941 220 + KDF 341 110
-- = 330 > T7.300, mens PTO er 70 + 35 kW ≈ 143 hk — in-game 8/10). Mangler PTO-tal, bruges summen af anbefalingerne.
function ADPool.comboNeededHp(list)
local pto, ptoKnown, store, storeKnown = 0, true, 0, false
for _, implement in ipairs(list) do
if implement.ptoHp ~= nil and implement.ptoHp > 0 then pto = pto + implement.ptoHp else ptoKnown = false end
if implement.neededHp ~= nil and implement.neededHp > 0 then store, storeKnown = store + implement.neededHp, true end
end
if ptoKnown and #list > 0 then return pto end
return storeKnown and store or nil
end
-- Kombi: nærmeste bag- og frontredskab med én traktor med ledig frontkrog og hk nok til begges samlede PTO-forbrug. -> par | nil
local function pairCombo(role, candidates, free)
local rear, front = nil, nil
for _, implement in ipairs(candidates) do
if implement.front then front = front or implement else rear = rear or implement end
end
if rear == nil or front == nil then return nil end
-- hentes front først: udturen er hjemturen spejlvendt (in-game 8/10 savegame4: Connect P Rear Mower nås kun gennem
-- frontbåsen — med fronten stadig parkeret kørte traktoren ind i den). Hjem: bag først (ADHitch.parkOrder).
local both = {front, rear}
local tractor = ADPool.bestFit(frontTractors(free), {x = rear.x, z = rear.z, neededHp = ADPool.comboNeededHp(both)}, role)
if tractor == nil then return nil end
return {implement = rear, implements = both, tractor = tractor}
end
-- Redskab med rollen nærmest marken, derefter nærmeste ledige traktor med nok hk til redskabet.
-- blocked = {[id] = true} (reserverede og redskaber i karantæne). accept (valgfri): implement -> bool.
-- -> {implement, implements, tractor}; implements = alle der hentes i rækkefølge (kombi: front først), implement = hovedredskabet (bag).
-- Frontredskaber kræver en traktor med ledig frontkrog (tractor.freeFront).
function ADPool.pairFor(role, fieldX, fieldZ, implements, tractors, blocked, accept)
blocked = blocked or {}
local free = {}
for _, tractor in ipairs(tractors or {}) do
if not blocked[tractor.id] and not tractor.offNetwork then table.insert(free, tractor) end
end
local candidates, sawBlocked = {}, false
for _, implement in ipairs(implements or {}) do
if hasRole(implement, role) and (accept == nil or accept(implement)) then
if blocked[implement.id] then sawBlocked = true else table.insert(candidates, implement) end
end
end
-- poolBusy: redskabet findes, men er reserveret/i karantæne — marken står i kø, intet mangler på gården
if #candidates == 0 then return nil, sawBlocked and "poolBusy" or "noPoolImplement" end
if #free == 0 then return nil, "noPoolTractor" end
table.sort(candidates, function(a, b)
return distanceSq(a.x, a.z, fieldX, fieldZ) < distanceSq(b.x, b.z, fieldX, fieldZ)
end)
if ADPool.COMBO_ROLES[role] then
local combo = pairCombo(role, candidates, free)
if combo ~= nil then return combo end
end
local weakest, frontOnly = nil, nil
for _, implement in ipairs(candidates) do
local pullers = implement.front and frontTractors(free) or free
if #pullers == 0 then
frontOnly = true
else
local tractor = ADPool.bestFit(pullers, implement, role)
if tractor ~= nil then return {implement = implement, implements = {implement}, tractor = tractor} end
if weakest == nil or (implement.neededHp or 0) < (weakest.neededHp or 0) then weakest = implement end
end
end
-- kun frontredskaber og ingen ledig traktor med frontkrog
if weakest == nil and frontOnly then return nil, "noPoolTractor" end
return nil, "tooWeak", {weakest ~= nil and weakest.neededHp or 0, weakest ~= nil and weakest.name or "?"}
end
-- Hentningen fejlede ved trin failedIndex (kombi: 1 = front, 2 = bag): hvem i karantæne, og hvilket redskab.
-- implements = {{id, name}} i hente-rækkefølge. -> skyldig id, redskabets post
function ADPool.blame(reason, tractorId, implements, failedIndex)
local entry = implements[failedIndex or 1] or implements[1]
if ADPool.failureBlames(reason) == "tractor" then return tractorId, entry end
return entry.id, entry
end
-- Alle frie puljeredskaber med rollen, hver parret med den nærmeste endnu ubrugte traktor med nok hk
-- (marksilo-flowet planlægger over mange vogne på én gang).
function ADPool.pairAll(role, implements, tractors, blocked)
blocked = blocked or {}
local used, result = {}, {}
for _, implement in ipairs(implements or {}) do
if hasRole(implement, role) and not blocked[implement.id] then
local open = {}
for _, t in ipairs(tractors or {}) do
if not used[t.id] and not blocked[t.id] and not t.offNetwork then table.insert(open, t) end
end
local tractor = ADPool.bestFit(open, implement, role)
if tractor ~= nil then
used[tractor.id] = true
table.insert(result, {implement = implement, tractor = tractor})
end
end
end
return result
end
-- Ventende marker prøver igen på fælles taktslag (ikke hver sin 30 s fra eget forsøg): så udløber de i samme
-- tick, og køens rækkefølge (længst ventende først) afgør hvem der får den næste ledige traktor.
function ADPool.alignedRetry(nowMs, periodMs)
return (math.floor(nowMs / periodMs) + 1) * periodMs
end
-- Ventende marker først (længst ventende først, lige -> lavest id); resten bagefter i oprindelig rækkefølge.
function ADPool.queueOrder(infos, waitingSince)
local waiting, rest = {}, {}
for _, info in ipairs(infos or {}) do
if waitingSince ~= nil and waitingSince[info.id] ~= nil then table.insert(waiting, info) else table.insert(rest, info) end
end
table.sort(waiting, function(a, b)
local wa, wb = waitingSince[a.id], waitingSince[b.id]
if wa ~= wb then return wa < wb end
return a.id < b.id
end)
for _, info in ipairs(rest) do table.insert(waiting, info) end
return waiting
end
-- Reservationer (i hukommelsen): owner -> {id, ...}. Karantæne: id -> udløbstid.
local reservations, quarantined = {}, {}
function ADPool.reserve(owner, ids)
reservations[owner] = ids
end
function ADPool.release(owner)
reservations[owner] = nil
end
function ADPool.quarantine(id, nowMs)
quarantined[id] = nowMs + ADPool.QUARANTINE_MS
end
function ADPool.quarantineMinutes(id, nowMs)
local untilMs = quarantined[id]
if untilMs == nil or nowMs >= untilMs then return 0 end
return math.ceil((untilMs - nowMs) / 60000)
end
function ADPool.isReserved(id)
for _, ids in pairs(reservations) do
for _, reserved in ipairs(ids) do if reserved == id then return true end end
end
return false
end
function ADPool.blocked(nowMs)
local result = {}
for _, ids in pairs(reservations) do
for _, id in ipairs(ids) do result[id] = true end
end
for id, untilMs in pairs(quarantined) do
if nowMs < untilMs then result[id] = true end
end
return result
end
-- Traktorer på hjemtur (sætter redskab af, kører hjem): optaget for markarbejdet til de er hjemme.
local returning = setmetatable({}, {__mode = "k"})
function ADPool.setReturning(vehicle, isOn)
returning[vehicle] = isOn and true or nil
end
function ADPool.isReturning(vehicle)
return returning[vehicle] == true
end
-- ---- spil ----
local function parkMarker(adEnv, vehicle)
local index = vehicle.advd ~= nil and vehicle.advd.parkDestination or nil
if type(index) ~= "number" or index < 1 then return nil end
return adEnv.ADGraphManager:getMapMarkerById(index)
end
local positionOf = ADUtil.positionOf
-- Butiksdata: redskabets krævede effekt (hk). specs indlæses først, når butikken har vist varen.
local neededHpCache = {} -- configFileName -> hk eller false (butiksdata ændrer sig ikke i et spil)
local function neededHpOf(vehicle)
if g_storeManager == nil or vehicle.configFileName == nil then return nil end
local cached = neededHpCache[vehicle.configFileName]
if cached ~= nil then return cached or nil end
local value = ADPool.readNeededHp(vehicle)
neededHpCache[vehicle.configFileName] = value or false
return value
end
-- Redskabets reelle PTO-forbrug i hk (powerConsumer neededMaxPtoPower er kW), nil uden PTO.
function ADPool.readPtoHp(vehicle)
local spec = vehicle.spec_powerConsumer
local kw = spec ~= nil and tonumber(spec.neededMaxPtoPower) or nil
if kw == nil or kw <= 0 then return nil end
return kw * 1.35962
end
function ADPool.readNeededHp(vehicle)
local item = g_storeManager:getItemByXMLFilename(vehicle.configFileName)
if item == nil then return nil end
if item.specs == nil and StoreItemUtil ~= nil and StoreItemUtil.loadSpecsFromXML ~= nil then
pcall(StoreItemUtil.loadSpecsFromXML, item)
end
return item.specs ~= nil and ADPool.numberOf(item.specs.neededPower) or nil
end
local tractorHpCache = setmetatable({}, {__mode = "k"}) -- vehicle -> hk eller false
-- Traktorens effekt i hk: motorens topeffekt (kW) omregnet; ellers butiksdata. Gemmes pr. traktor.
local function tractorHpOf(vehicle)
local cached = tractorHpCache[vehicle]
if cached ~= nil then return cached or nil end
local value = ADPool.readTractorHp(vehicle)
tractorHpCache[vehicle] = value or false
return value
end
function ADPool.readTractorHp(vehicle)
local motor = vehicle.spec_motorized ~= nil and vehicle.spec_motorized.motor or nil
local kw = motor ~= nil and motor.peakMotorPower or nil
if type(kw) == "number" and kw > 0 then return kw * 1.35962 end
if g_storeManager == nil or vehicle.configFileName == nil then return nil end
local item = g_storeManager:getItemByXMLFilename(vehicle.configFileName)
return item ~= nil and item.specs ~= nil and ADPool.numberOf(item.specs.power) or nil
end
-- Butikskategori (fx "TRACTORSM", "TRUCKS") eller nil.
local function categoryOf(vehicle)
if g_storeManager == nil or vehicle.configFileName == nil then return nil end
local item = g_storeManager:getItemByXMLFilename(vehicle.configFileName)
return item ~= nil and item.categoryName or nil
end
-- Varer og samlet kapacitet i redskabets fyldenheder (tømmevogne).
function ADPool.cargoOf(vehicle)
local carries, capacity = {}, 0
local units = vehicle.spec_fillUnit ~= nil and vehicle.spec_fillUnit.fillUnits or {}
for index in ipairs(units) do
capacity = capacity + (vehicle:getFillUnitCapacity(index) or 0)
for fillType in pairs(vehicle:getFillUnitSupportedFillTypes(index) or {}) do carries[fillType] = true end
end
return carries, capacity
end
-- Kan et sæt (traktor med vogn koblet på, eller en løs vogn) bære varen? Kun påhængte redskaber med fyldenheder tæller; uden nogen = ukendt
-- = ja. In-game 16/10 F38: 'Series 8 TTV 1' med EDK 650 blev sendt til blackbean, som vognen ikke tager — CR11'eren
-- åbnede aldrig røret, og CP-tømmevognen kørte i ring.
function ADPool.rigCarries(vehicle, fillType)
if fillType == nil or vehicle == nil or vehicle.getAttachedImplements == nil then return true end
local found, carries = false, false
local function check(object)
if object.spec_fillUnit ~= nil and #(object.spec_fillUnit.fillUnits or {}) > 0 then
found = true
if ADPool.canCarry({carries = (ADPool.cargoOf(object))}, fillType) then carries = true end
end
end
local function visit(object)
for _, implement in ipairs(object:getAttachedImplements() or {}) do
local child = implement.object
if child ~= nil then
check(child)
if child.getAttachedImplements ~= nil then visit(child) end
end
end
end
local ok = pcall(function()
-- løs vogn (spillertransport/leje): vognen selv; en traktors egne fyldenheder (diesel) tæller ikke
if vehicle.spec_motorized == nil then check(vehicle) end
visit(vehicle)
end)
return not ok or not found or carries
end
-- Har sættet (eller den løse vogn) en fyldenhed der bærer varen? Som rigCarries, men ukendt/ingen fyldenheder = nej
-- (rigCarries siger ja ved "ukendt" — til tømmevogne; ballelasteren skal beviseligt kunne).
function ADPool.rigHasCargoFor(vehicle, fillType)
if vehicle == nil or fillType == nil then return false end
local found = false
local function check(object)
if object.spec_fillUnit ~= nil and ADPool.canCarry({carries = (ADPool.cargoOf(object))}, fillType) then found = true end
end
local function visit(object)
if object.getAttachedImplements == nil then return end
for _, implement in ipairs(object:getAttachedImplements() or {}) do
if implement.object ~= nil then check(implement.object); visit(implement.object) end
end
end
local ok = pcall(function()
if vehicle.spec_motorized == nil then check(vehicle) end
visit(vehicle)
end)
return ok and found
end
-- Ikke bundet af et kørende flow (traktorer i stoppede flows er ledige).
function ADPool.isFreeFromFlows(vehicle)
if ADFlowWagons ~= nil then return ADFlowWagons.isFreeTractor(vehicle) end
return ADRunsController.getRunForVehicle(vehicle) == nil
end
-- Connect-markører som en aktiv AD-traktor kører hen mod ("Kør til"): redskabet der er på vej til at blive hentet.
-- In-game 9/10: gemt midt i en hentetur — AD fortsatte turen efter indlæsning, men puljen havde glemt reservationen
-- og sendte en anden traktor efter samme Supercis ("noAttachable").
local function connectTargets(adEnv)
local targets = {}
pcall(function()
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
if module ~= nil and module:isActive() and module:getMode() == adEnv.AutoDrive.MODE_DRIVETO then
local marker = module:getFirstMarker()
if marker ~= nil and marker.id ~= nil then targets[marker.id] = true end
end
end
end)
return targets
end
local function isAttached(vehicle)
return vehicle.getAttacherVehicle ~= nil and vehicle:getAttacherVehicle() ~= nil
end
-- Traktorens egen rolle uden de redskaber der hænger på (mejetærsker/selvkørende har en, en traktor ikke).
function ADPool.ownRole(vehicle)
local specs = {}
for _, name in ipairs(ADCpBridge.SPECS) do
if vehicle[name] ~= nil then specs[name] = true end
end
local role = ADFieldFleet.roleFromSpecs(specs)
-- selvkørende sprøjte/spreder har ingen markrolle når den er tom, men er ingen traktor (in-game 4/10: Condor
-- blev sendt efter en tømmevogn -> stoppedAway)
if role == nil and vehicle.spec_sprayer ~= nil then return "sprayer" end
return role
end
-- Redskaberne direkte på traktoren til ADPool.isFreeTractor: {front, role}. Rolle kun for frontredskaber (alt bagpå
-- blokerer alligevel); frontvægt har ingen rolle og blokerer ikke.
local function attachedRoles(vehicle)
local list = {}
for _, implement in ipairs(ADHitch.directImplementsOf(vehicle)) do
local front = implement.z > 0
local role = front and ADPool.roleOf(ADCpBridge.getSpecs(implement.object)) or nil
table.insert(list, {front = front, role = role})
end
return list
end
-- Puljeredskaber (frakoblet, parkering "X", markør "Connect X") og puljetraktorer.
-- 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 implements, tractors = {}, {}
local targeted = connectTargets(adEnv)
-- spillets egen liste: frakoblede redskaber er ikke nødvendigvis i AutoDrive's køretøjsliste
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
local owned = vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId
if owned and vehicle.spec_motorized == nil and vehicle.spec_attachable ~= nil and not isAttached(vehicle) then
local park = parkMarker(adEnv, vehicle)
local connect = park ~= nil and ADPool.connectFor(park.name, markers) or nil
local specs = connect ~= nil and ADCpBridge.getSpecs(vehicle) or nil
local role = specs ~= nil and ADPool.roleOf(specs) or nil
-- flowvogne: kun et sovende flows vogn må lånes (ADFlowWagons.isLendable)
local held = role ~= nil and ADFlowWagons ~= nil and ADFlowWagons.isLendableWagon ~= nil
and not ADFlowWagons.isLendableWagon(ADRunsController.getVehicleId(vehicle), vehicle.spec_sprayer ~= nil)
if role ~= nil and not held and not targeted[connect.id] then
local x, z = positionOf(vehicle)
local carries, capacity = ADPool.cargoOf(vehicle)
table.insert(implements, {carries = carries, capacity = capacity,
id = ADRunsController.getVehicleId(vehicle), vehicle = vehicle, name = ADRuns.vehicleLabel(vehicle),
role = role, roles = ADPool.rolesOf(role, specs.sprayRoles), filledRole = specs.filledRole, dumpable = specs.dumpable,
x = x, z = z, width = ADCpBridge.getWorkWidth(vehicle),
neededHp = neededHpOf(vehicle), ptoHp = ADPool.readPtoHp(vehicle), connectId = connect.id, parkId = park.id,
front = ADPool.isFrontImplement(park.name),
})
end
end
end
local state = ADFieldJobs.state
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
local id = ADRunsController.getVehicleId(vehicle)
local park = parkMarker(adEnv, vehicle)
local controlled = vehicle.getIsControlled ~= nil and vehicle:getIsControlled()
if id ~= nil and park ~= nil and vehicle.spec_attacherJoints ~= nil and ADPool.isFreeTractor(attachedRoles(vehicle))
and ADPool.isFreeFromFlows(vehicle) and not controlled and not isBusy(vehicle)
and not ADPool.isReturning(vehicle) and ADFieldFleet.isEnabled(state.fleetMode, state.fleet, id, state.excluded)
and ADPool.canPull(ADPool.ownRole(vehicle))
and ADPool.isPuller({category = categoryOf(vehicle), ownBody = vehicle.spec_trailer ~= nil or vehicle.spec_dischargeable ~= nil}) then
local x, z = positionOf(vehicle)
-- uden for AD-vejnettet: den kan ikke køre ud efter redskabet (ville sende redskaber i karantæne)
local networkDistance = ADFieldWork.distanceToNetwork(adEnv, x, z)
table.insert(tractors, {id = id, vehicle = vehicle, name = ADRuns.vehicleLabel(vehicle), x = x, z = z,
hp = tractorHpOf(vehicle), category = categoryOf(vehicle), parkId = park.id,
freeFront = ADHitch.hasFreeFrontJoint(vehicle), -- kan tage en frontslåmaskine (8/10)
offNetwork = networkDistance ~= nil and networkDistance > ADFieldWork.MAX_OFF_NETWORK})
end
end
return implements, tractors
end
-- Oversigt til flådefanen: alle redskaber med en markrolle (også dem der mangler parkering/Connect, så
-- 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 nowMs = ADFieldJobs.now or 0
local implements, tractors = {}, {}
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
local owned = vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId
if owned and vehicle.spec_motorized == nil and vehicle.spec_attachable ~= nil then
local role = ADPool.roleOf(ADCpBridge.getSpecs(vehicle))
if role ~= nil then
local id = ADRunsController.getVehicleId(vehicle)
local park = parkMarker(adEnv, vehicle)
local attacher = isAttached(vehicle) and vehicle:getAttacherVehicle() or nil
local key, arg = ADPool.implementStatus({
parkName = park ~= nil and park.name or nil,
hasConnect = park ~= nil and ADPool.connectFor(park.name, markers) ~= nil,
attachedTo = attacher ~= nil and ADRuns.vehicleLabel(attacher) or nil,
quarantineMin = id ~= nil and ADPool.quarantineMinutes(id, nowMs) or 0,
reserved = id ~= nil and ADPool.isReserved(id),
flowName = id ~= nil and ADFlowWagons ~= nil and ADFlowWagons.isLendableWagon ~= nil and not ADFlowWagons.isLendableWagon(id, vehicle.spec_sprayer ~= nil)
and tostring(ADFlowWagons.ownerOf(ADRunsController.store.runs, id).name) or nil,
})
table.insert(implements, {id = id, label = ADRuns.vehicleLabel(vehicle), role = role, status = key, arg = arg})
end
end
end
local state = ADFieldJobs.state
for _, vehicle in ipairs(ADRunsController.getFarmVehicles(adEnv)) do
local id = ADRunsController.getVehicleId(vehicle)
-- en traktor med et redskab der giver den en markrolle, står allerede i flåden som kombination
if id ~= nil and vehicle.spec_attacherJoints ~= nil and ADPool.isFreeFromFlows(vehicle)
and ADPool.canPull(ADPool.ownRole(vehicle)) and ADFieldFleet.roleFromSpecs(ADCpBridge.getSpecs(vehicle)) == nil then
local x, z = positionOf(vehicle)
local distance = ADFieldWork.distanceToNetwork(adEnv, x, z)
local assignment = state.assignments[id]
local key, arg = ADPool.tractorStatus({
hasPark = parkMarker(adEnv, vehicle) ~= nil,
enabled = ADFieldFleet.isEnabled(state.fleetMode, state.fleet, id, state.excluded),
controlled = vehicle.getIsControlled ~= nil and vehicle:getIsControlled(),
returning = ADPool.isReturning(vehicle),
fieldId = assignment ~= nil and assignment.fieldId or nil,
busy = ADFieldWork.isBusyVehicle(vehicle, id),
offNetwork = distance ~= nil and distance > ADFieldWork.MAX_OFF_NETWORK,
hitched = not ADPool.isFreeTractor(attachedRoles(vehicle)), -- samme regel som collect (frontvægt er ok)
})
table.insert(tractors, {id = id, label = ADRuns.vehicleLabel(vehicle), hp = tractorHpOf(vehicle), status = key, arg = arg,
enabled = ADFieldFleet.isEnabled(state.fleetMode, state.fleet, id, state.excluded)})
end
end
return implements, tractors
end