678 lines
32 KiB
Lua
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
|
|
|