258 lines
11 KiB
Lua
258 lines
11 KiB
Lua
-- AD Pallet Refill
|
|
-- Påfyldning fra paller: er et sæt tomt, og har intet lager/købested varen, finder moden paller med varen — løse
|
|
-- paller ude eller paller i et palleskur (objektlager). Sættet kører til AutoDrive-markøren ved pallen/skuret,
|
|
-- tager en palle ud af lageret (som knappen i spillet) og flytter varen over inden for rækkevidde (som pallens
|
|
-- egen påfyldningstrigger, men uden at redskabets åbning skal stå præcist). Tomme paller fjerner spillet selv.
|
|
-- (in-game 4/10: kalk og gødning i palleskuret, ris-stiklinger ved risplanteren)
|
|
-- Ren logik øverst (testes med luajit), spil-adapter nederst.
|
|
|
|
ADPalletRefill = {}
|
|
ADPalletRefill.LOG_PREFIX = "ADSmartPickup: palle: "
|
|
ADPalletRefill.REACH_M = 20 -- pallen må højst stå så langt fra redskabet
|
|
ADPalletRefill.MARKER_RANGE_M = 40 -- AD-markøren skal stå så tæt på pallen/skuret
|
|
ADPalletRefill.ARRIVE_M = 8 -- fremme ved markøren
|
|
ADPalletRefill.RATE_LPS = 200 -- som en big bags egen påfyldning (200 l/s)
|
|
ADPalletRefill.SPAWN_WAIT_MS = 15000 -- så længe ventes på en udtaget palle
|
|
ADPalletRefill.START_GRACE_MS = 3000
|
|
|
|
-- ---- ren logik ----
|
|
|
|
function ADPalletRefill.nearest(list, x, z)
|
|
local best, bestDistance = nil, math.huge
|
|
for _, item in ipairs(list or {}) do
|
|
local d = (item.x - x) ^ 2 + (item.z - z) ^ 2
|
|
if d < bestDistance then best, bestDistance = item, d end
|
|
end
|
|
return best
|
|
end
|
|
|
|
function ADPalletRefill.transferAmount(rateLps, dtMs, palletLevel, free)
|
|
return math.max(0, math.min(rateLps * dtMs / 1000, palletLevel or 0, free or 0))
|
|
end
|
|
|
|
function ADPalletRefill.newJob(source, fillType)
|
|
return {source = source, fillType = fillType, state = "driving", elapsed = 0, seenActive = false,
|
|
spawnPending = false, spawnedAt = 0, filled = 0}
|
|
end
|
|
|
|
-- Et skridt. s = {adActive, distance, free, palletLevel, stored} -> job, handling ("wait"|"transfer"|"spawn"|nil)
|
|
-- Tilstande: driving -> filling -> done | failed (reason: notArrived / noPallet / spawnTimeout)
|
|
function ADPalletRefill.step(job, s, dt)
|
|
job.elapsed = job.elapsed + (dt or 0)
|
|
if job.state == "driving" then
|
|
if s.adActive then
|
|
job.seenActive = true
|
|
return job, "wait"
|
|
end
|
|
if (s.distance or math.huge) <= ADPalletRefill.ARRIVE_M then
|
|
job.state, job.elapsed = "filling", 0
|
|
return job, "wait"
|
|
end
|
|
if job.seenActive or job.elapsed >= ADPalletRefill.START_GRACE_MS then
|
|
job.state, job.reason = "failed", "notArrived"
|
|
end
|
|
return job, nil
|
|
end
|
|
if job.state ~= "filling" then return job, nil end
|
|
if (s.free or 0) < 1 then
|
|
job.state = "done"
|
|
return job, nil
|
|
end
|
|
if (s.palletLevel or 0) > 0 then
|
|
job.spawnPending = false
|
|
return job, "transfer"
|
|
end
|
|
if job.spawnPending then
|
|
if job.elapsed - job.spawnedAt < ADPalletRefill.SPAWN_WAIT_MS then return job, "wait" end
|
|
job.state, job.reason = "failed", "spawnTimeout"
|
|
return job, nil
|
|
end
|
|
if (s.stored or 0) > 0 then
|
|
job.spawnPending, job.spawnedAt = true, job.elapsed
|
|
return job, "spawn"
|
|
end
|
|
-- ingen paller tilbage: kør videre med det der kom på, ellers fejl
|
|
if (job.filled or 0) > 0 then
|
|
job.state = "done"
|
|
else
|
|
job.state, job.reason = "failed", "noPallet"
|
|
end
|
|
return job, nil
|
|
end
|
|
|
|
-- ---- spil ----
|
|
|
|
local function positionOf(object)
|
|
if object == nil or object.rootNode == nil then return nil end
|
|
local x, _, z = getWorldTranslation(object.rootNode)
|
|
return x, z
|
|
end
|
|
|
|
local function isPallet(vehicle)
|
|
return vehicle.spec_pallet ~= nil or vehicle.typeName == "pallet"
|
|
end
|
|
|
|
-- Fyldenheden på et objekt med varen: index, niveau (nil hvis ingen)
|
|
local function unitWith(object, fillType)
|
|
for index in ipairs(object.getFillUnits ~= nil and object:getFillUnits() or {}) do
|
|
if object:getFillUnitFillType(index) == fillType then
|
|
local level = object:getFillUnitFillLevel(index) or 0
|
|
if level > 0 then return index, level end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Løse paller med varen (ejet af gården, ikke læsset på noget)
|
|
function ADPalletRefill.loosePallets(farmId, fillType)
|
|
local result = {}
|
|
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles) do
|
|
if isPallet(vehicle) and vehicle.getOwnerFarmId ~= nil and vehicle:getOwnerFarmId() == farmId then
|
|
local unit, level = unitWith(vehicle, fillType)
|
|
local x, z = positionOf(vehicle)
|
|
if unit ~= nil and x ~= nil then
|
|
table.insert(result, {vehicle = vehicle, unit = unit, level = level, x = x, z = z})
|
|
end
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- Palleskure med varen
|
|
function ADPalletRefill.storages(farmId, fillType)
|
|
local result = {}
|
|
for _, placeable in pairs(g_currentMission.placeableSystem.placeables) do
|
|
if placeable.spec_objectStorage ~= nil and placeable.getOwnerFarmId ~= nil and placeable:getOwnerFarmId() == farmId then
|
|
local count = ADSources.countStored({placeable = placeable}, fillType)
|
|
local x, z = positionOf(placeable)
|
|
if count > 0 and x ~= nil then
|
|
table.insert(result, {placeable = placeable, count = count, x = x, z = z})
|
|
end
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
-- Nærmeste AD-markør (ikke Wait) ved (x, z) med rute fra køretøjet
|
|
local function markerNear(adEnv, vehicle, x, z)
|
|
local best, bestDistance = nil, ADPalletRefill.MARKER_RANGE_M ^ 2
|
|
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
|
local wp = adEnv.ADGraphManager:getWayPointById(marker.id)
|
|
if wp ~= nil and not (ADSupplyPlanner ~= nil and ADSupplyPlanner.isWaitMarker(marker)) then
|
|
local d = (wp.x - x) ^ 2 + (wp.z - z) ^ 2
|
|
if d < bestDistance and (ADUnloadWait == nil or ADUnloadWait.hasRouteTo(adEnv, vehicle, marker.id)) then
|
|
best, bestDistance = marker, d
|
|
end
|
|
end
|
|
end
|
|
return best
|
|
end
|
|
|
|
-- Hvor sættet kan få varen fra paller: {markerId, markerName, placeable?, x, z} eller nil, grund
|
|
function ADPalletRefill.findSource(adEnv, vehicle, fillType)
|
|
local farmId = vehicle:getOwnerFarmId()
|
|
local vx, vz = positionOf(vehicle)
|
|
if vx == nil then return nil, "ingen position" end
|
|
local candidates = {}
|
|
for _, pallet in ipairs(ADPalletRefill.loosePallets(farmId, fillType)) do
|
|
local marker = markerNear(adEnv, vehicle, pallet.x, pallet.z)
|
|
if marker ~= nil then table.insert(candidates, {markerId = marker.id, markerName = marker.name, x = pallet.x, z = pallet.z, kind = "palle"}) end
|
|
end
|
|
for _, storage in ipairs(ADPalletRefill.storages(farmId, fillType)) do
|
|
local marker = markerNear(adEnv, vehicle, storage.x, storage.z)
|
|
if marker ~= nil then
|
|
table.insert(candidates, {markerId = marker.id, markerName = marker.name, x = storage.x, z = storage.z,
|
|
placeable = storage.placeable, kind = "palleskur"})
|
|
end
|
|
end
|
|
local best = ADPalletRefill.nearest(candidates, vx, vz)
|
|
if best == nil then return nil, "ingen paller med varen ved en AutoDrive-markør" end
|
|
return best
|
|
end
|
|
|
|
-- Er der overhovedet paller med varen (ude eller i et skur)? Gemmes 10 s.
|
|
function ADPalletRefill.hasAny(farmId, fillType)
|
|
local function count()
|
|
return #ADPalletRefill.loosePallets(farmId, fillType) + #ADPalletRefill.storages(farmId, fillType) > 0
|
|
end
|
|
if ADCache ~= nil and ADCache.get ~= nil then
|
|
return ADCache.get("palletAny", tostring(farmId) .. ":" .. tostring(fillType), 10000, count)
|
|
end
|
|
return count()
|
|
end
|
|
|
|
local function collect(vehicle, list)
|
|
list = list or {}
|
|
table.insert(list, vehicle)
|
|
for _, implement in ipairs(vehicle.getAttachedImplements ~= nil and vehicle:getAttachedImplements() or {}) do
|
|
if implement.object ~= nil then collect(implement.object, list) end
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- Den del af sættet der skal have varen: objekt, enhed, ledig plads
|
|
function ADPalletRefill.receiverOf(vehicle, fillType)
|
|
for _, object in ipairs(collect(vehicle)) do
|
|
for index in ipairs(object.getFillUnits ~= nil and object:getFillUnits() or {}) do
|
|
if object:getFillUnitSupportsFillType(index, fillType) then
|
|
local free = (object:getFillUnitCapacity(index) or 0) - (object:getFillUnitFillLevel(index) or 0)
|
|
return object, index, math.max(0, free)
|
|
end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Én opgave pr. tick for sættet i assignment.pallet. -> "done" | "failed", grund | nil (i gang)
|
|
function ADPalletRefill.tick(adEnv, assignment, dt)
|
|
local job = assignment.pallet
|
|
local vehicle = assignment.vehicle
|
|
local fillType = job.fillType
|
|
local farmId = vehicle:getOwnerFarmId()
|
|
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
|
local wp = adEnv.ADGraphManager:getWayPointById(job.source.markerId)
|
|
local vx, vz = positionOf(vehicle)
|
|
local receiver, unit, free = ADPalletRefill.receiverOf(vehicle, fillType)
|
|
if receiver == nil then return "failed", "sættet kan ikke tage varen" end
|
|
local rx, rz = positionOf(receiver)
|
|
local pallet = nil
|
|
if job.state == "filling" then
|
|
for _, candidate in ipairs(ADPalletRefill.loosePallets(farmId, fillType)) do
|
|
local d = math.sqrt((candidate.x - rx) ^ 2 + (candidate.z - rz) ^ 2)
|
|
if d <= ADPalletRefill.REACH_M and (pallet == nil or d < pallet.distance) then
|
|
pallet = candidate
|
|
pallet.distance = d
|
|
end
|
|
end
|
|
end
|
|
local stored = job.source.placeable ~= nil and ADSources.countStored({placeable = job.source.placeable}, fillType) or 0
|
|
local s = {
|
|
adActive = module ~= nil and module:isActive(),
|
|
distance = (wp ~= nil and vx ~= nil) and math.sqrt((wp.x - vx) ^ 2 + (wp.z - vz) ^ 2) or math.huge,
|
|
free = free, palletLevel = pallet ~= nil and pallet.level or 0, stored = stored,
|
|
}
|
|
local _, action = ADPalletRefill.step(job, s, dt)
|
|
if action == "transfer" then
|
|
local amount = ADPalletRefill.transferAmount(ADPalletRefill.RATE_LPS, dt, pallet.level, free)
|
|
local toolType = ToolType ~= nil and ToolType.UNDEFINED or 0
|
|
local added = receiver:addFillUnitFillLevel(farmId, unit, amount, fillType, toolType, nil) or 0
|
|
if added > 0 then
|
|
pallet.vehicle:addFillUnitFillLevel(farmId, pallet.unit, -added, fillType, toolType, nil)
|
|
job.filled = (job.filled or 0) + added
|
|
end
|
|
elseif action == "spawn" then
|
|
local index = ADSources.getObjectInfoIndex({placeable = job.source.placeable}, fillType)
|
|
local ok = index ~= nil and ADSources.spawnOne({placeable = job.source.placeable}, index)
|
|
Logging.info(ADPalletRefill.LOG_PREFIX .. "palle med %s taget ud af '%s'%s", tostring(ADPalletRefill.fillName(fillType)),
|
|
tostring(job.source.markerName), ok and "" or " — mislykkedes")
|
|
end
|
|
if job.state == "done" then return "done" end
|
|
if job.state == "failed" then return "failed", job.reason end
|
|
return nil
|
|
end
|
|
|
|
function ADPalletRefill.fillName(fillType)
|
|
local desc = fillType ~= nil and g_fillTypeManager ~= nil and g_fillTypeManager:getFillTypeByIndex(fillType) or nil
|
|
return desc ~= nil and (desc.title or desc.name) or tostring(fillType)
|
|
end
|