974 lines
55 KiB
Lua
974 lines
55 KiB
Lua
-- AD Livestock
|
|
-- Slagtedyr (brugerønske 19/10 16:01: "kan vi få systemet til at hente køer når de er fuldt udvokset og klar til
|
|
-- slagteriet"). Fase 1: konsolkommandoen spuAnimals viser, hvad moden kan se — stalde (dyr, alder, pris, hvornår
|
|
-- prisen topper), dyrehandlere, kreaturvogne og AD-markørerne ved læsseområderne — så spillets dyre-API kan bekræftes
|
|
-- in-game, før transporten bygges. Ren logik øverst (testes med luajit), spil-adapter nederst.
|
|
|
|
-- info-log bag "Detaljeret log" (ADLog i adSettings.lua; uden ADLog — tests — direkte til Logging)
|
|
local function logInfo(...) return (ADLog or Logging).info(...) end
|
|
|
|
ADLivestock = {}
|
|
ADLivestock.LOG_PREFIX = "ADSmartPickup: dyr: "
|
|
ADLivestock.MARKER_M = 40 -- AD-markør så tæt på en dyre-læssetrigger hører til den
|
|
ADLivestock.MAX_AGE_SCAN = 240 -- måneder: så langt frem søges efter salgsprisens top
|
|
ADLivestock.READY_SHARE = 0.99 -- "klar": prisen er mindst så stor en del af toppen
|
|
|
|
-- ---- ren logik ----
|
|
|
|
-- Alderen (måneder), hvor prisen første gang når READY_SHARE af toppen. priceAt(age) -> pris eller nil. -> alder, toppris
|
|
function ADLivestock.readyAge(priceAt, maxAge)
|
|
local best = nil
|
|
for age = 0, maxAge or ADLivestock.MAX_AGE_SCAN do
|
|
local price = priceAt(age)
|
|
if type(price) == "number" and (best == nil or price > best) then best = price end
|
|
end
|
|
if best == nil or best <= 0 then return nil, nil end
|
|
for age = 0, maxAge or ADLivestock.MAX_AGE_SCAN do
|
|
local price = priceAt(age)
|
|
if type(price) == "number" and price >= best * ADLivestock.READY_SHARE then return age, best end
|
|
end
|
|
return nil, best
|
|
end
|
|
|
|
-- ---- spil-adapter ----
|
|
|
|
local function call(object, method, ...)
|
|
if object == nil or object[method] == nil then return nil end
|
|
local ok, result = pcall(object[method], object, ...)
|
|
return ok and result or nil
|
|
end
|
|
|
|
-- brugerens eget bygningsnavn (ADNames, fx "129 Kvægstald") før spillets ("Cowbarn with manure Pit")
|
|
local function placeableName(placeable)
|
|
local own = ADNames ~= nil and ADNames.forPlaceable ~= nil and ADNames.forPlaceable(placeable) or nil
|
|
if own ~= nil and own ~= "" then return tostring(own) end
|
|
return tostring(call(placeable, "getName") or "?")
|
|
end
|
|
|
|
local function nodePos(node)
|
|
if node == nil or getWorldTranslation == nil then return nil end
|
|
local ok, x, _, z = pcall(getWorldTranslation, node)
|
|
if not ok then return nil end
|
|
return x, z
|
|
end
|
|
|
|
-- Nærmeste AD-markør (ikke P/Connect/Wait/service) til et punkt: "navn (12 m)" eller "ingen inden for 40 m"
|
|
local function nearestMarker(adEnv, x, z)
|
|
if adEnv == nil or x == nil then return "ingen position" end
|
|
local best, bestD = nil, ADLivestock.MARKER_M
|
|
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
|
local candidate = ADBuildings == nil or ADBuildings.isCandidateMarker == nil or ADBuildings.isCandidateMarker(marker)
|
|
local wp = candidate and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
|
|
if wp ~= nil then
|
|
local d = math.sqrt((wp.x - x) ^ 2 + (wp.z - z) ^ 2)
|
|
if d < bestD then best, bestD = marker, d end
|
|
end
|
|
end
|
|
if best == nil then return string.format("ingen inden for %d m", ADLivestock.MARKER_M) end
|
|
return string.format("'%s' (%.0f m)", tostring(best.name), bestD)
|
|
end
|
|
|
|
local function subTypeOf(subTypeIndex)
|
|
local system = g_currentMission ~= nil and g_currentMission.animalSystem or nil
|
|
return system ~= nil and call(system, "getSubTypeByIndex", subTypeIndex) or nil
|
|
end
|
|
|
|
local function typeName(typeIndex)
|
|
local system = g_currentMission ~= nil and g_currentMission.animalSystem or nil
|
|
local animalType = system ~= nil and call(system, "getTypeByIndex", typeIndex) or nil
|
|
return tostring(animalType ~= nil and (animalType.name or animalType.title) or typeIndex)
|
|
end
|
|
|
|
-- Pris pr. dyr ved en alder fra undertypens salgskurve (spillets felt hedder sellPrice; andre navne prøves også)
|
|
local function curvePrice(subType, age)
|
|
if subType == nil then return nil end
|
|
for _, key in ipairs({"sellPrice", "sellPriceCurve"}) do
|
|
local curve = subType[key]
|
|
if type(curve) == "table" and curve.get ~= nil then
|
|
local ok, price = pcall(curve.get, curve, age)
|
|
if ok and type(price) == "number" then return price end
|
|
end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
local function clusterLine(cluster)
|
|
local subTypeIndex = call(cluster, "getSubTypeIndex") or cluster.subTypeIndex
|
|
local subType = subTypeOf(subTypeIndex)
|
|
local age = call(cluster, "getAge") or cluster.age
|
|
local health = call(cluster, "getHealth") or cluster.health
|
|
local sellPrice = call(cluster, "getSellPrice")
|
|
local curve = curvePrice(subType, age or 0)
|
|
local readyAge, topPrice = ADLivestock.readyAge(function(a) return curvePrice(subType, a) end)
|
|
return string.format("%s: %s dyr, alder %s mdr, sundhed %s, pris getSellPrice=%s kurve=%s, klar fra %s mdr (top %s)",
|
|
tostring(subType ~= nil and (subType.name or subType.title) or subTypeIndex), tostring(cluster.numAnimals),
|
|
tostring(age), tostring(health), tostring(sellPrice), tostring(curve), tostring(readyAge), tostring(topPrice))
|
|
end
|
|
|
|
function ADLivestock.survey(adEnv)
|
|
local lines = {}
|
|
local farmId = g_currentMission:getFarmId()
|
|
local placeables = g_currentMission.placeableSystem ~= nil and g_currentMission.placeableSystem.placeables or {}
|
|
for _, placeable in ipairs(placeables) do
|
|
local okPlaceable, errPlaceable = pcall(function()
|
|
local animals = placeable.spec_husbandryAnimals
|
|
local owned = call(placeable, "getOwnerFarmId") == farmId
|
|
if animals ~= nil and owned then
|
|
local trigger = animals.animalLoadingTrigger
|
|
local x, z = nodePos(trigger ~= nil and trigger.triggerNode or nil)
|
|
table.insert(lines, string.format("STALD %s: %s, %s/%s dyr, læssetrigger %s, markør %s", placeableName(placeable),
|
|
typeName(animals.animalTypeIndex), tostring(call(placeable, "getNumOfAnimals")), tostring(call(placeable, "getMaxNumOfAnimals")),
|
|
trigger ~= nil and "ja" or "NEJ", nearestMarker(adEnv, x, z)))
|
|
for _, cluster in ipairs(call(placeable, "getClusters") or {}) do
|
|
local ok, line = pcall(clusterLine, cluster)
|
|
table.insert(lines, " " .. (ok and line or ("fejl: " .. tostring(line))))
|
|
end
|
|
end
|
|
local dealerSpec = placeable.spec_animalLoadingTrigger
|
|
local dealer = dealerSpec ~= nil and dealerSpec.animalLoadingTrigger or nil
|
|
if dealer ~= nil and dealer.isDealer then
|
|
local x, z = nodePos(dealer.triggerNode)
|
|
local types = {}
|
|
for _, typeIndex in ipairs(dealer.animalTypes or {}) do table.insert(types, typeName(typeIndex)) end
|
|
table.insert(lines, string.format("HANDLER %s (%s): tager %s, markør %s", placeableName(placeable), tostring(dealer.title),
|
|
#types > 0 and table.concat(types, ", ") or "alle", nearestMarker(adEnv, x, z)))
|
|
end
|
|
end)
|
|
-- én underlig bygning må ikke skjule resten (review)
|
|
if not okPlaceable then table.insert(lines, string.format("fejl ved %s: %s", placeableName(placeable), tostring(errPlaceable))) end
|
|
end
|
|
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
|
|
local spec = vehicle.spec_livestockTrailer
|
|
local okVehicle, errVehicle = pcall(function()
|
|
if spec ~= nil and call(vehicle, "getOwnerFarmId") == farmId then
|
|
local parts = {}
|
|
for typeIndex, place in pairs(spec.animalTypeIndexToPlaces or {}) do
|
|
table.insert(parts, string.format("%s %d pladser", typeName(typeIndex), #(place.slots or {})))
|
|
end
|
|
local parkIndex = vehicle.advd ~= nil and vehicle.advd.parkDestination or nil
|
|
local park = type(parkIndex) == "number" and parkIndex >= 1 and adEnv.ADGraphManager:getMapMarkerById(parkIndex) or nil
|
|
local connect = park ~= nil and ADPool ~= nil and ADPool.connectFor(park.name, adEnv.ADGraphManager:getMapMarkers()) or nil
|
|
table.insert(lines, string.format("VOGN %s: %s; i vognen %s dyr; P %s, Connect %s", tostring(call(vehicle, "getName")),
|
|
table.concat(parts, ", "), tostring(call(vehicle, "getNumOfAnimals")), tostring(park ~= nil and park.name or "-"),
|
|
tostring(connect ~= nil and connect.name or "-")))
|
|
end
|
|
end)
|
|
if not okVehicle then table.insert(lines, string.format("fejl ved vogn %s: %s", tostring(call(vehicle, "getName")), tostring(errVehicle))) end
|
|
end
|
|
return lines
|
|
end
|
|
|
|
function ADLivestock.consoleSurvey()
|
|
local adEnv = FS25_AutoDrive
|
|
if adEnv == nil or adEnv.ADGraphManager == nil or g_currentMission == nil then return "dyr: AutoDrive er ikke indlæst" end
|
|
local ok, lines = pcall(ADLivestock.survey, adEnv)
|
|
if not ok then return "dyr: fejl: " .. tostring(lines) end
|
|
for _, line in ipairs(lines) do logInfo(ADLivestock.LOG_PREFIX .. "%s", line) end
|
|
return string.format("dyr: %d linjer (også i log.txt med Detaljeret log slået til)\n%s", #lines, table.concat(lines, "\n"))
|
|
end
|
|
|
|
-- ==== Fase 2: transport af slagteklare dyr (brugerønske 19/10 16:20: "kun slagtekvæg stalden, men gerne en option pr
|
|
-- stald"). Pr. stald (ADSettings "sellReadyAnimals"): har stalden dyr, hvis salgspris har toppet, låner moden en ledig
|
|
-- traktor og en ledig kreaturvogn (egen P-plads + Connect), kører til staldens dyre-læsseplads, flytter de klare dyr
|
|
-- ind, kører til den dyrehandler der betaler bedst, sælger dem og sætter vognen på plads. Flere vogne = flere ture
|
|
-- på én gang. Intet gemmes: afbrydes en tur, bliver dyrene i vognen, og en vogn med dyr sælges ved næste tjek.
|
|
|
|
ADLivestock.CHECK_MS = 60 * 1000
|
|
ADLivestock.PHASE_TIMEOUT_MS = 25 * 60 * 1000
|
|
ADLivestock.ARRIVE_M = 30
|
|
|
|
-- Ren: hvor mange klare dyr skal med, og skal turen køre? ready = klare dyr i stalden, total = alle dyr, slots =
|
|
-- vognens frie pladser. Kør, når et fuldt læs er klar, eller når alle stallens dyr er klare (sidste rest).
|
|
-- quotaLeft (nil = ingen månedskvote): højst så mange dyr endnu denne måned. Er kvoten det, der begrænser, køres
|
|
-- resten af kvoten, selv om det ikke er et fuldt læs (ellers blev en kvote på 17 aldrig kørt med en vogn til 25).
|
|
function ADLivestock.tripSize(ready, total, slots, quotaLeft)
|
|
if (ready or 0) <= 0 or (slots or 0) <= 0 then return 0 end
|
|
if quotaLeft ~= nil then
|
|
if quotaLeft <= 0 then return 0 end
|
|
if quotaLeft <= ready then return math.min(quotaLeft, slots) end
|
|
end
|
|
if ready >= slots then return slots end
|
|
if ready >= (total or 0) then return ready end
|
|
return 0
|
|
end
|
|
|
|
-- Ren: månedskvote ved "fordel salg over måneder" (brugerønske 19/10: "en lille del hver måned ... indtægt hver
|
|
-- måned"). total = dyr i stalden ved månedens start, months = 0 (fra) | antal måneder. -> antal | nil (ingen kvote)
|
|
function ADLivestock.monthlyQuota(total, months)
|
|
if (months or 0) <= 0 then return nil end
|
|
if (total or 0) <= 0 then return 0 end
|
|
return math.ceil(total / months)
|
|
end
|
|
|
|
-- Ren: kvote-posten for stalden i denne måned (ny post ved månedsskifte). record = {key, quota, sold} | nil
|
|
function ADLivestock.monthRecord(record, key, total, months)
|
|
if record ~= nil and record.key == key and record.months == months then return record end
|
|
return {key = key, months = months, quota = ADLivestock.monthlyQuota(total, months), sold = 0}
|
|
end
|
|
|
|
-- Ren: bedste handler. dealers = {{id, price, distance}} -> den med højest pris (lige pris: nærmest)
|
|
function ADLivestock.bestDealer(dealers)
|
|
local best = nil
|
|
for _, d in ipairs(dealers or {}) do
|
|
if best == nil or (d.price or 0) > (best.price or 0)
|
|
or ((d.price or 0) == (best.price or 0) and (d.distance or math.huge) < (best.distance or math.huge)) then
|
|
best = d
|
|
end
|
|
end
|
|
return best
|
|
end
|
|
|
|
-- Eget slagteri (brugerønske 20/10: FS25_ProcessamentoAnimal "Slaughterhouse and Meat Processing" er et nyt sted at
|
|
-- levere slagtekvæg). Slagteriet er ingen dyrehandler: vognen holder i dets dyre-trigger, og spilleren trykker R og siger
|
|
-- ja -> placeable:rl_requestSlaughter(vogn). Dyr under slagteriets mindstealder (køer 12 mdr.) bliver i vognen.
|
|
ADLivestock.SLAUGHTER_TRIGGER_WAIT_MS = 5000
|
|
ADLivestock.SLAUGHTER_MIN_AGE_FIELDS = {COW = "minAgeCow", PIG = "minAgePig", SHEEP = "minAgeSheep", CHICKEN = "minAgeChicken"}
|
|
|
|
-- Ren: slagteriets mindstealder for dyretypen -> måneder | nil (tager ikke typen). animalTypes = {COW = index, ...}
|
|
function ADLivestock.slaughterMinAge(spec, typeIndex, animalTypes)
|
|
if spec == nil or typeIndex == nil or animalTypes == nil then return nil end
|
|
for name, field in pairs(ADLivestock.SLAUGHTER_MIN_AGE_FIELDS) do
|
|
-- uden aldersgrænse (ukendt/omdøbt felt) tages typen ikke — ellers blev alder 0 = nyfødte kalve (review)
|
|
if animalTypes[name] == typeIndex then return tonumber(spec[field]) end
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Ren: alderen et dyr skal have for at komme med. Handler: prisens top. Slagteri: slagteriets mindstealder — det
|
|
-- regner slagtevægten uden alder (uden Realistic Livestock fast 500 kg pr. dyr), så det er spild at vente på pristoppen
|
|
-- (brugerønske 20/10: "lad den tage dyr fra 12 måneder")
|
|
function ADLivestock.effectiveReadyAge(readyAge, minAge)
|
|
if minAge ~= nil then return minAge end
|
|
return readyAge
|
|
end
|
|
|
|
-- dyre-læssetriggere (også kortets handlere, der ikke er placeables): registreres når spillet opretter dem
|
|
local knownTriggers = setmetatable({}, {__mode = "k"})
|
|
if AnimalLoadingTrigger ~= nil and AnimalLoadingTrigger.new ~= nil and not ADLivestock.triggerHooked then
|
|
ADLivestock.triggerHooked = true
|
|
local originalNew = AnimalLoadingTrigger.new
|
|
AnimalLoadingTrigger.new = function(...)
|
|
local trigger = originalNew(...)
|
|
if trigger ~= nil then knownTriggers[trigger] = true end
|
|
return trigger
|
|
end
|
|
end
|
|
|
|
local jobs = {} -- trailer -> job
|
|
ADLivestock.monthly = {} -- staldens id -> {key (år*100+periode), months, quota, sold}; gemmes i savegamet
|
|
local busyVehicles = setmetatable({}, {__mode = "k"}) -- traktor/vogn -> job
|
|
local checkTimer = 0
|
|
ADLivestock.FAIL_COOLDOWN_MS = 15 * 60 * 1000 -- mislykket tur: samme stald/vogn prøves først igen efter så lang tid
|
|
ADLivestock.START_GRACE_MS = 10 * 1000 -- AD får så lang tid til at komme i gang efter en kørselsordre
|
|
ADLivestock.LOST_MS = 20 * 1000 -- hente-/hjemtur uden ADHitch-job så længe = tilbagekaldet er tabt
|
|
local failedUntil = setmetatable({}, {__mode = "k"}) -- stald/vogn -> ms
|
|
local pendingLoaded = {} -- vogn-id -> antal dyr: "læsset af os" fra savegamet, vognen endnu ikke fundet
|
|
local loadedByUs = setmetatable({}, {__mode = "k"}) -- vogn -> true: dyrene er læsset af en dyretur (review: aldrig spillerens egne dyr)
|
|
local warnedOnce = {}
|
|
|
|
local function now() return ADUtil.now() end
|
|
local function vname(v) return ADRuns ~= nil and tostring(ADRuns.vehicleLabel(v)) or tostring(call(v, "getName") or "?") end
|
|
local function notify(text, critical)
|
|
logInfo(ADLivestock.LOG_PREFIX .. "%s", text)
|
|
if ADFieldJobs ~= nil and ADFieldJobs.notify ~= nil then pcall(ADFieldJobs.notify, text, critical == true) end
|
|
end
|
|
local function warnOnce(key, text)
|
|
if warnedOnce[key] then return end
|
|
warnedOnce[key] = true
|
|
logInfo(ADLivestock.LOG_PREFIX .. "%s", text)
|
|
end
|
|
|
|
-- Fast traktor pr. stald (brugerønske 19/10: "låse den traktor der står på 129 til det job"): staldens id -> køretøjs-id.
|
|
-- En låst traktor bruges kun til staldens dyreture og er optaget for alt andet, mens salget er slået til.
|
|
ADLivestock.locks = {}
|
|
|
|
function ADLivestock.setLock(barnId, vehicleId)
|
|
ADLivestock.locks[barnId] = vehicleId
|
|
end
|
|
|
|
function ADLivestock.getLock(barnId)
|
|
return ADLivestock.locks[barnId]
|
|
end
|
|
|
|
local function isLockedTractor(vehicle)
|
|
local id = ADRunsController ~= nil and ADRunsController.getVehicleId(vehicle) or nil
|
|
if id == nil then return false end
|
|
for barnId, vehicleId in pairs(ADLivestock.locks) do
|
|
if vehicleId == id and ADSettings ~= nil and ADSettings.getOwn("sellReadyAnimals", barnId) == 1 then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- På dyretur lige nu (ikke bare låst)? Spillerens-maskine-reglen må køre en låst traktor hjem, når den ikke er på tur.
|
|
function ADLivestock.isOnTrip(vehicle)
|
|
return vehicle ~= nil and busyVehicles[vehicle] ~= nil
|
|
end
|
|
|
|
-- Optaget af en dyretur eller låst til en stalds dyreture? (pulje, flows, oprydning, spillerens maskine)
|
|
function ADLivestock.isBusy(vehicle)
|
|
if vehicle == nil then return false end
|
|
return busyVehicles[vehicle] ~= nil or isLockedTractor(vehicle)
|
|
end
|
|
|
|
-- AD-markør ved en trigger: helst en med "animal"/"dyr" i navnet inden for MARKER_M, ellers nærmeste
|
|
local function triggerMarker(adEnv, trigger)
|
|
local x, z = nodePos(trigger ~= nil and trigger.triggerNode or nil)
|
|
if x == nil then return nil end
|
|
local best, bestD, named, namedD = nil, ADLivestock.MARKER_M, nil, ADLivestock.MARKER_M
|
|
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers()) do
|
|
local candidate = ADBuildings == nil or ADBuildings.isCandidateMarker(marker)
|
|
local wp = candidate and adEnv.ADGraphManager:getWayPointById(marker.id) or nil
|
|
if wp ~= nil then
|
|
local d = math.sqrt((wp.x - x) ^ 2 + (wp.z - z) ^ 2)
|
|
local lower = string.lower(tostring(marker.name))
|
|
if (lower:find("animal", 1, true) or lower:find("dyr", 1, true) or lower:find("livestock", 1, true)) and d < namedD then
|
|
named, namedD = marker, d
|
|
end
|
|
if d < bestD then best, bestD = marker, d end
|
|
end
|
|
end
|
|
return named or best, x, z
|
|
end
|
|
|
|
local function readyAgeOf(subTypeIndex)
|
|
local subType = subTypeOf(subTypeIndex)
|
|
return (ADLivestock.readyAge(function(a) return curvePrice(subType, a) end))
|
|
end
|
|
|
|
local function isOwnSlaughterhouse(placeable, farmId)
|
|
local spec = placeable.spec_rlSlaughterhouse
|
|
return spec ~= nil and spec.animalTriggerNode ~= nil and placeable.rl_requestSlaughter ~= nil and call(placeable, "getOwnerFarmId") == farmId
|
|
end
|
|
|
|
-- Gårdens slagterier der tager dyretypen, med AD-markør ved dyre-triggeren (som handlerne: {marker, price, distance, title})
|
|
-- vogne hvis dyr skal slagtes (læsset til en stald med "Eget slagteri"): en mislykket slagtning eller afbrudt tur
|
|
-- sender dem ikke til dyrehandleren bagefter (review 20/10). Gemmes ikke: efter en genindlæsning gælder handleren.
|
|
local slaughterBound = setmetatable({}, {__mode = "k"})
|
|
|
|
local function slaughterhousesFor(adEnv, farmId, typeIndex, x, z)
|
|
local list = {}
|
|
for _, placeable in ipairs(g_currentMission.placeableSystem.placeables or {}) do
|
|
local minAge = isOwnSlaughterhouse(placeable, farmId) and ADLivestock.slaughterMinAge(placeable.spec_rlSlaughterhouse, typeIndex, AnimalType) or nil
|
|
if minAge ~= nil then
|
|
local marker, tx, tz = triggerMarker(adEnv, {triggerNode = placeable.spec_rlSlaughterhouse.animalTriggerNode})
|
|
if marker == nil then
|
|
warnOnce("slaughterNoMarker:" .. tostring(placeable), string.format("slagteriet '%s' har ingen AD-markør inden for %d m af dyre-triggeren — bruges ikke", placeableName(placeable), ADLivestock.MARKER_M))
|
|
else
|
|
local d = tx ~= nil and x ~= nil and math.sqrt((tx - x) ^ 2 + (tz - z) ^ 2) or math.huge
|
|
table.insert(list, {slaughterhouse = placeable, minAge = minAge, marker = marker, price = 0, distance = d, title = placeableName(placeable)})
|
|
end
|
|
end
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- Stalde med "sælg slagteklare dyr" og deres klare dyr
|
|
local function readyBarns(adEnv, farmId)
|
|
local list = {}
|
|
for _, placeable in ipairs(g_currentMission.placeableSystem.placeables or {}) do
|
|
local animals = placeable.spec_husbandryAnimals
|
|
local id = ADBuildings ~= nil and ADBuildings.getId(placeable) or nil
|
|
if animals ~= nil and call(placeable, "getOwnerFarmId") == farmId and id ~= nil
|
|
and ADSettings ~= nil and ADSettings.getOwn("sellReadyAnimals", id) == 1 and animals.animalLoadingTrigger ~= nil then
|
|
local ready, total = 0, 0
|
|
-- slagteri: det slagteri turen kører til (nærmeste med markør) bestemmer mindstealderen (review)
|
|
local minAge = nil
|
|
if ADSettings.getOwn("sellReadyTarget", id) == 1 then
|
|
local x, z = nodePos(animals.animalLoadingTrigger.triggerNode)
|
|
local target = ADLivestock.bestDealer(slaughterhousesFor(adEnv, farmId, animals.animalTypeIndex, x, z))
|
|
minAge = target ~= nil and target.minAge or nil
|
|
end
|
|
for _, cluster in ipairs(call(placeable, "getClusters") or {}) do
|
|
local n = call(cluster, "getNumAnimals") or cluster.numAnimals or 0
|
|
total = total + n
|
|
local readyAge = ADLivestock.effectiveReadyAge(readyAgeOf(call(cluster, "getSubTypeIndex")), minAge)
|
|
local age = call(cluster, "getAge") or 0
|
|
if readyAge ~= nil and age >= readyAge then ready = ready + n end
|
|
end
|
|
if ready > 0 then table.insert(list, {placeable = placeable, id = id, ready = ready, total = total, typeIndex = animals.animalTypeIndex}) end
|
|
end
|
|
end
|
|
return list
|
|
end
|
|
|
|
local function freeTrailers(adEnv, farmId, typeIndex)
|
|
local list = {}
|
|
local markers = adEnv.ADGraphManager:getMapMarkers()
|
|
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
|
|
local spec = vehicle.spec_livestockTrailer
|
|
if spec ~= nil and call(vehicle, "getOwnerFarmId") == farmId and jobs[vehicle] == nil
|
|
and (vehicle.getAttacherVehicle == nil or vehicle:getAttacherVehicle() == nil)
|
|
and (typeIndex == nil or call(vehicle, "getSupportsAnimalType", typeIndex))
|
|
and not (ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle))
|
|
and not (ADPool.skipBroken ~= nil and ADPool.skipBroken(vehicle)) then -- ødelagt kreaturvogn (20/10)
|
|
local parkIndex = vehicle.advd ~= nil and vehicle.advd.parkDestination or nil
|
|
local park = type(parkIndex) == "number" and parkIndex >= 1 and adEnv.ADGraphManager:getMapMarkerById(parkIndex) or nil
|
|
local connect = park ~= nil and ADPool.connectFor(park.name, markers) or nil
|
|
local id = ADRunsController.getVehicleId(vehicle)
|
|
if connect ~= nil and id ~= nil and not ADPool.isReserved(id) then
|
|
table.insert(list, {vehicle = vehicle, id = id, connectId = connect.id, animals = call(vehicle, "getNumOfAnimals") or 0})
|
|
elseif connect == nil then
|
|
warnOnce("noConnect:" .. tostring(id), string.format("kreaturvognen '%s' har ingen P-plads med Connect-markør — bruges ikke", vname(vehicle)))
|
|
end
|
|
end
|
|
end
|
|
return list
|
|
end
|
|
|
|
local function freeTractor(adEnv, trailer)
|
|
local ok, _, tractors = pcall(ADPool.collect, adEnv, function(v) return ADFieldWork.isBusyVehicle(v, ADRunsController.getVehicleId(v)) end)
|
|
if not ok then return nil end
|
|
local blocked = ADPool.blocked(now())
|
|
local candidates = {}
|
|
for _, tractor in ipairs(tractors or {}) do
|
|
if not blocked[tractor.id] and not tractor.offNetwork and ADRunsController.getRunForVehicle(tractor.vehicle) == nil
|
|
and busyVehicles[tractor.vehicle] == nil then
|
|
table.insert(candidates, tractor)
|
|
end
|
|
end
|
|
local x, _, z = getWorldTranslation(trailer.rootNode)
|
|
local okHp, neededHp = pcall(ADPool.readNeededHp, trailer)
|
|
return ADPool.bestFit(candidates, {x = x, z = z, neededHp = okHp and neededHp or nil}, "unloader")
|
|
end
|
|
|
|
-- Staldens låste traktor, hvis den er ledig lige nu (holder, ingen spiller, intet flow, ikke reserveret) -> {id, vehicle} | nil
|
|
-- Er traktoren ledig til en dyretur? ignoreClaim: spillerens 10-min-krav tæller ikke (traktoren kører allerede
|
|
-- moddens læssede dyr — brugerønske 19/10 22:21: turen skal fortsætte, når spilleren stiger ud)
|
|
local function tractorFree(vehicle, vehicleId, ignoreClaim)
|
|
if vehicle == nil or busyVehicles[vehicle] ~= nil or ADPool.isReserved(vehicleId) then return false end
|
|
if ADPool.skipBroken ~= nil and ADPool.skipBroken(vehicle) then return false end -- ødelagt (in-game 20/10)
|
|
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
|
if module ~= nil and module:isActive() then return false end
|
|
if vehicle.getIsControlled ~= nil and vehicle:getIsControlled() then return false end
|
|
if ADRunsController.getRunForVehicle(vehicle) ~= nil then return false end
|
|
if not ignoreClaim and ADPlayerClaim ~= nil and ADPlayerClaim.claims(vehicle) then return false end
|
|
if ADHitch.isBusy ~= nil and ADHitch.isBusy(vehicle) then return false end
|
|
-- samme optaget-regler som puljen (review: en markopgave/CP/marksilo-lån fra før låsen må ikke overtages)
|
|
if ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and (ADFieldJobs.state.assignments or {})[vehicleId] ~= nil then return false end
|
|
if ADCpBridge ~= nil and ADCpBridge.isWorking ~= nil and ADCpBridge.isWorking(vehicle) then return false end
|
|
if ADFieldSilos ~= nil and ADFieldSilos.isLoaned ~= nil and ADFieldSilos.isLoaned(vehicle) then return false end
|
|
if ADPool.isReturning ~= nil and ADPool.isReturning(vehicle) then return false end
|
|
if ADFlowWagons ~= nil and ADFlowWagons.isEmptying ~= nil and ADFlowWagons.isEmptying(vehicle) then return false end
|
|
return true
|
|
end
|
|
|
|
local function lockedTractor(adEnv, vehicleId)
|
|
local vehicle = ADRunsController.findVehicleById(adEnv, vehicleId)
|
|
if not tractorFree(vehicle, vehicleId, false) then return nil, vehicle end
|
|
return {id = vehicleId, vehicle = vehicle}, vehicle
|
|
end
|
|
|
|
-- Kreaturvogne med dyr, som en dyretur selv har læsset, der stadig sidder på en (nu ledig) traktor — turen blev
|
|
-- sluppet, fordi spilleren satte sig i traktoren (in-game 19/10 22:05). -> {{trailerInfo, tractor}}
|
|
local function attachedLoaded(farmId)
|
|
local list, seen = {}, {}
|
|
for trailer in pairs(loadedByUs) do
|
|
local attacher = trailer.getAttacherVehicle ~= nil and trailer:getAttacherVehicle() or nil
|
|
-- kun en traktor med AutoDrive (ikke vogn nr. 1 i et tog), og én tur pr. traktor (review)
|
|
if attacher ~= nil and (attacher.spec_motorized == nil or attacher.ad == nil or seen[attacher]) then attacher = nil end
|
|
local tractorId = attacher ~= nil and ADRunsController.getVehicleId(attacher) or nil
|
|
local trailerId = ADRunsController.getVehicleId(trailer)
|
|
if attacher ~= nil and tractorId ~= nil and trailerId ~= nil and jobs[trailer] == nil
|
|
and call(trailer, "getOwnerFarmId") == farmId and (call(trailer, "getNumOfAnimals") or 0) > 0
|
|
and (failedUntil[trailer] or 0) <= now() and not ADPool.isReserved(trailerId) and tractorFree(attacher, tractorId, true) then
|
|
seen[attacher] = true
|
|
table.insert(list, {trailerInfo = {vehicle = trailer, id = trailerId}, tractor = {id = tractorId, vehicle = attacher}})
|
|
end
|
|
end
|
|
return list
|
|
end
|
|
|
|
-- Handlere der tager dyretypen, med AD-markør; pris pr. dyr for et eksempel-cluster
|
|
local function dealersFor(adEnv, typeIndex, x, z)
|
|
local list = {}
|
|
local seen = {}
|
|
local function consider(trigger)
|
|
if trigger == nil or seen[trigger] or not trigger.isDealer or not trigger.isEnabled then return end
|
|
seen[trigger] = true
|
|
local takes = trigger.animalTypes == nil
|
|
for _, t in ipairs(trigger.animalTypes or {}) do if t == typeIndex then takes = true end end
|
|
if not takes then return end
|
|
local marker, tx, tz = triggerMarker(adEnv, trigger)
|
|
if marker == nil then
|
|
warnOnce("dealerNoMarker:" .. tostring(trigger.title), string.format("dyrehandleren '%s' har ingen AD-markør inden for %d m af læssepladsen — bruges ikke", tostring(trigger.title), ADLivestock.MARKER_M))
|
|
return
|
|
end
|
|
local d = tx ~= nil and x ~= nil and math.sqrt((tx - x) ^ 2 + (tz - z) ^ 2) or math.huge
|
|
-- spillets handlere betaler samme pris; nærmeste vinder (prisen kan senere komme fra en mod-handler)
|
|
table.insert(list, {trigger = trigger, marker = marker, price = 0, distance = d, title = tostring(trigger.title)})
|
|
end
|
|
for trigger in pairs(knownTriggers) do consider(trigger) end
|
|
for _, placeable in ipairs(g_currentMission.placeableSystem.placeables or {}) do
|
|
local spec = placeable.spec_animalLoadingTrigger
|
|
consider(spec ~= nil and spec.animalLoadingTrigger or nil)
|
|
end
|
|
return list
|
|
end
|
|
|
|
local function distanceTo(adEnv, vehicle, markerId)
|
|
local wp = adEnv.ADGraphManager:getWayPointById(markerId)
|
|
if wp == nil or vehicle.rootNode == nil then return math.huge end
|
|
local x, _, z = getWorldTranslation(vehicle.rootNode)
|
|
return math.sqrt((wp.x - x) ^ 2 + (wp.z - z) ^ 2)
|
|
end
|
|
|
|
local function finish(job, text, critical)
|
|
if job.done then return end
|
|
job.done = true
|
|
if text ~= nil then notify(text, critical) end
|
|
-- et hængende hente-/hjemtur-job må ikke kalde tilbage på en afsluttet tur (review)
|
|
if ADHitch.isBusy ~= nil and ADHitch.isBusy(job.tractor) then ADHitch.cancel(job.tractor) end
|
|
ADPool.release(job)
|
|
if busyVehicles[job.tractor] == job then busyVehicles[job.tractor] = nil end
|
|
if busyVehicles[job.trailer] == job then busyVehicles[job.trailer] = nil end
|
|
if jobs[job.trailer] == job then jobs[job.trailer] = nil end
|
|
end
|
|
|
|
local function fail(job)
|
|
local untilMs = now() + ADLivestock.FAIL_COOLDOWN_MS
|
|
failedUntil[job.trailer] = untilMs
|
|
if job.barn ~= nil then failedUntil[job.barn] = untilMs end
|
|
end
|
|
|
|
local function goHome(adEnv, job, text, critical)
|
|
if job.done then return end
|
|
job.phase = "home"
|
|
job.since = now()
|
|
if text ~= nil then notify(text, critical) end
|
|
local ok, started = pcall(ADHitch.returnHome, adEnv, job.tractor, function()
|
|
finish(job, nil)
|
|
end)
|
|
if not ok or not started then finish(job, string.format("'%s' kunne ikke køre kreaturvognen hjem — gør det selv", vname(job.tractor)), true) end
|
|
end
|
|
|
|
local function driveTo(adEnv, job, marker, phase)
|
|
job.phase, job.since, job.markerId, job.markerName, job.restarted = phase, now(), marker.id, tostring(marker.name), false
|
|
ADFieldWork.startAd(adEnv, job.tractor, adEnv.AutoDrive.MODE_DRIVETO, marker.id, nil)
|
|
logInfo(ADLivestock.LOG_PREFIX .. "'%s' kører med '%s' til '%s'", vname(job.tractor), vname(job.trailer), job.markerName)
|
|
end
|
|
|
|
-- Antal frie pladser i vognen til dyretypen (spillets egen tælling)
|
|
local function freeSlots(trailer, typeIndex)
|
|
local animalType = g_currentMission.animalSystem:getTypeByIndex(typeIndex)
|
|
if animalType == nil then return 0 end
|
|
return math.max(0, (call(trailer, "getMaxNumOfAnimals", animalType) or 0) - (call(trailer, "getNumOfAnimals") or 0))
|
|
end
|
|
|
|
-- Klare dyr fra stalden ind i vognen. Dyret klones som når spillet tager et dyr ud til ridning (alder, sundhed,
|
|
-- avlsdata følger med); stalden mister dem via changeNumAnimals + updateNow (spillets eget mønster). -> antal flyttet
|
|
local function loadAnimals(job)
|
|
local trailer, placeable = job.trailer, job.barn
|
|
local free = freeSlots(trailer, job.typeIndex)
|
|
if (job.size or 0) > 0 then free = math.min(free, job.size) end -- månedskvoten bestemmer turens størrelse
|
|
local moved = 0
|
|
local clusters = {}
|
|
for _, cluster in ipairs(call(placeable, "getClusters") or {}) do table.insert(clusters, cluster) end
|
|
-- ældste først
|
|
table.sort(clusters, function(a, b) return (call(a, "getAge") or 0) > (call(b, "getAge") or 0) end)
|
|
for _, cluster in ipairs(clusters) do
|
|
if free <= 0 then break end
|
|
local subTypeIndex = call(cluster, "getSubTypeIndex")
|
|
local readyAge = ADLivestock.effectiveReadyAge(readyAgeOf(subTypeIndex), job.dealer ~= nil and job.dealer.minAge or nil)
|
|
local age = call(cluster, "getAge") or 0
|
|
local count = call(cluster, "getNumAnimals") or cluster.numAnimals or 0
|
|
if readyAge ~= nil and age >= readyAge and count > 0 and call(trailer, "getSupportsAnimalSubType", subTypeIndex) then
|
|
local n = math.min(count, free)
|
|
local newCluster = cluster:clone()
|
|
newCluster.numAnimals = n
|
|
cluster:changeNumAnimals(-n)
|
|
trailer:addCluster(newCluster)
|
|
moved = moved + n
|
|
free = free - n
|
|
loadedByUs[trailer] = true
|
|
slaughterBound[trailer] = (job.dealer ~= nil and job.dealer.slaughterhouse ~= nil) or nil -- følger det aktuelle læs
|
|
end
|
|
end
|
|
local clusterSystem = call(placeable, "getClusterSystem")
|
|
if clusterSystem ~= nil and clusterSystem.updateNow ~= nil then clusterSystem:updateNow() end
|
|
local record = job.barnId ~= nil and ADLivestock.monthly[job.barnId] or nil
|
|
-- altid i den aktuelle måneds post (review: en tur planlagt i én måned og læsset i den næste tæller i den næste)
|
|
if record ~= nil then record.sold = record.sold + moved end
|
|
job.loaded = true
|
|
return moved
|
|
end
|
|
|
|
-- Sælg vognens dyr ved handleren (spillets salgspris pr. dyr, sundhedsjusteret). -> antal, kroner
|
|
local function sellAnimals(job)
|
|
local total, count = 0, 0
|
|
local clusters = {}
|
|
for _, cluster in ipairs(call(job.trailer, "getClusters") or {}) do table.insert(clusters, cluster) end
|
|
for _, cluster in ipairs(clusters) do
|
|
local n = call(cluster, "getNumAnimals") or cluster.numAnimals or 0
|
|
local price = call(cluster, "getSellPrice") or curvePrice(subTypeOf(call(cluster, "getSubTypeIndex")), call(cluster, "getAge") or 0) or 0
|
|
if n > 0 then
|
|
total = total + price * n
|
|
count = count + n
|
|
cluster:changeNumAnimals(-n)
|
|
end
|
|
end
|
|
if count == 0 then return 0, 0 end
|
|
local clusterSystem = call(job.trailer, "getClusterSystem")
|
|
if clusterSystem ~= nil then clusterSystem:updateNow() end
|
|
local moneyType = MoneyType ~= nil and (MoneyType.SOLD_ANIMALS or MoneyType.OTHER) or nil
|
|
g_currentMission:addMoney(total, job.farmId, moneyType, true)
|
|
loadedByUs[job.trailer] = nil
|
|
slaughterBound[job.trailer] = nil
|
|
return count, total
|
|
end
|
|
|
|
-- Slagteriet slagter vognens dyr (slagterimoddens egen funktion, som når spilleren trykker R og siger ja)
|
|
local function slaughterAnimals(adEnv, job)
|
|
local placeable = job.dealer.slaughterhouse
|
|
local spec = placeable.spec_rlSlaughterhouse
|
|
-- slagteriet kender kun vognen i sin trigger på klienten (enkeltspiller: altid)
|
|
if spec == nil or (placeable.isClient and spec.currentTrailer ~= job.trailer) then
|
|
-- slagteriets trigger melder vognen lidt efter, at traktoren er fremme (review)
|
|
job.triggerWaitSince = job.triggerWaitSince or now()
|
|
if spec ~= nil and now() - job.triggerWaitSince < ADLivestock.SLAUGHTER_TRIGGER_WAIT_MS then return end
|
|
fail(job)
|
|
goHome(adEnv, job, string.format("kreaturvognen holder ikke i slagteriets dyre-trigger ved '%s' — dyrene bliver i vognen; flyt markøren", tostring(job.markerName)), true)
|
|
return
|
|
end
|
|
local before = call(job.trailer, "getNumOfAnimals") or 0
|
|
local ok, err = pcall(placeable.rl_requestSlaughter, placeable, job.trailer)
|
|
local after = call(job.trailer, "getNumOfAnimals") or 0
|
|
local count = before - after
|
|
if not ok or count <= 0 then
|
|
fail(job)
|
|
goHome(adEnv, job, string.format("'%s' slagtede ingen dyr fra '%s'%s — dyrene bliver i vognen (slagteriets lager fuldt, eller dyrene for unge?)",
|
|
job.dealer.title, vname(job.trailer), ok and "" or (": " .. tostring(err))), true)
|
|
return
|
|
end
|
|
if after == 0 then loadedByUs[job.trailer] = nil slaughterBound[job.trailer] = nil end
|
|
goHome(adEnv, job, string.format("%s: %d dyr slagtet på '%s'%s", job.barnName or "dyr fra vognen", count, job.dealer.title,
|
|
after > 0 and string.format(" (%d bliver i vognen)", after) or ""))
|
|
end
|
|
|
|
-- "sælges hos X" / "slagtes på X"
|
|
local function deliveryText(dealer)
|
|
return string.format(dealer.slaughterhouse ~= nil and "slagtes på '%s'" or "sælges hos '%s'", tostring(dealer.title))
|
|
end
|
|
|
|
-- Leveringssted for stallens slagtedyr: valgt slagteri (nærmeste med markør) eller dyrehandleren der betaler bedst.
|
|
-- barnId nil (vogn med dyr fra en afbrudt tur): slagteriet hvis vognen blev læsset til det, ellers handleren.
|
|
-- -> mål | nil, forklaring
|
|
local function deliveryFor(adEnv, farmId, barnId, typeIndex, x, z, trailer)
|
|
local toSlaughter = (trailer ~= nil and slaughterBound[trailer]) or (barnId ~= nil and ADSettings ~= nil and ADSettings.getOwn("sellReadyTarget", barnId) == 1)
|
|
if toSlaughter then
|
|
local target = ADLivestock.bestDealer(slaughterhousesFor(adEnv, farmId, typeIndex, x, z))
|
|
return target, target == nil and "intet eget slagteri med AD-markør tager dem" or nil
|
|
end
|
|
local dealer = ADLivestock.bestDealer(dealersFor(adEnv, typeIndex, x, z))
|
|
return dealer, dealer == nil and "ingen dyrehandler med AD-markør tager dem" or nil
|
|
end
|
|
|
|
-- attached: vognen sidder allerede på traktoren (fortsat salg) -> ingen hentetur
|
|
local function startJob(adEnv, farmId, barn, trailerInfo, tractor, dealer, size, attached)
|
|
local job = {farmId = farmId, barn = barn and barn.placeable or nil, barnName = barn and placeableName(barn.placeable) or nil,
|
|
trailer = trailerInfo.vehicle, tractor = tractor.vehicle, dealer = dealer, size = size, phase = "fetch", since = now(),
|
|
sellOnly = barn == nil, typeIndex = barn ~= nil and barn.typeIndex or nil, barnId = barn ~= nil and barn.id or nil,
|
|
monthKey = barn ~= nil and barn.monthKey or nil}
|
|
jobs[job.trailer] = job
|
|
busyVehicles[job.tractor], busyVehicles[job.trailer] = job, job
|
|
ADPool.reserve(job, {tractor.id, trailerInfo.id})
|
|
if attached then
|
|
notify(string.format("dyr i vognen: '%s' kører videre med '%s' — %s", vname(job.tractor), vname(job.trailer), deliveryText(dealer)))
|
|
driveTo(adEnv, job, dealer.marker, "toDealer")
|
|
return
|
|
end
|
|
notify(string.format("%s: '%s' henter kreaturvognen '%s'%s — %s", job.barnName or "dyr i vognen", vname(job.tractor),
|
|
vname(job.trailer), size > 0 and string.format(" til %d slagteklare dyr", size) or "", deliveryText(dealer)))
|
|
ADHitch.fetch(adEnv, job.tractor, trailerInfo.connectId, function(_, ok, detail)
|
|
if job.done then return end
|
|
local okStep, err = pcall(function()
|
|
if ok and detail ~= nil and detail ~= job.trailer then
|
|
ok, detail = false, "en anden vogn blev koblet på"
|
|
end
|
|
if not ok then
|
|
finish(job, string.format("'%s' kunne ikke koble kreaturvognen på (%s)", vname(job.tractor), tostring(detail)), true)
|
|
return
|
|
end
|
|
if job.sellOnly then
|
|
driveTo(adEnv, job, dealer.marker, "toDealer")
|
|
else
|
|
local marker = triggerMarker(adEnv, job.barn.spec_husbandryAnimals.animalLoadingTrigger)
|
|
if marker == nil then goHome(adEnv, job, string.format("%s: ingen AD-markør ved staldens dyre-læsseplads (inden for %d m)", job.barnName, ADLivestock.MARKER_M), true) return end
|
|
driveTo(adEnv, job, marker, "toBarn")
|
|
end
|
|
end)
|
|
if not okStep then finish(job, string.format("dyretur med '%s' fejlede: %s", vname(job.tractor), tostring(err)), true) end
|
|
end)
|
|
end
|
|
|
|
-- Ét job ét skridt videre
|
|
local function stepJob(adEnv, job)
|
|
if job.done then return end
|
|
local module = job.tractor.ad ~= nil and job.tractor.ad.stateModule or nil
|
|
local driving = module ~= nil and module:isActive()
|
|
-- spilleren tager over (sætter sig i traktoren) eller "Stop alt og parkér": turen slippes, intet køres videre (review)
|
|
local controlled = job.tractor.getIsControlled ~= nil and job.tractor:getIsControlled() and not driving
|
|
local paused = ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.paused
|
|
if controlled or paused then
|
|
finish(job, string.format("dyretur med '%s' sluppet (%s)%s", vname(job.tractor), paused and "Stop alt" or "du kører den",
|
|
(call(job.trailer, "getNumOfAnimals") or 0) > 0 and " — dyrene er stadig i vognen" or ""))
|
|
return
|
|
end
|
|
if job.phase == "fetch" or job.phase == "home" then
|
|
if now() - job.since > ADLivestock.PHASE_TIMEOUT_MS then finish(job, string.format("dyretur med '%s' gav op (%s tog for lang tid)", vname(job.tractor), job.phase), true) return end
|
|
-- tabt tilbagekald (et andet modul afbrød hente-/hjemturen): turen slippes
|
|
if ADHitch.isBusy ~= nil and not ADHitch.isBusy(job.tractor) and not driving then
|
|
job.lostSince = job.lostSince or now()
|
|
if now() - job.lostSince > ADLivestock.LOST_MS then finish(job, job.phase == "fetch" and string.format("'%s' fik ikke hentet kreaturvognen", vname(job.tractor)) or nil, job.phase == "fetch") end
|
|
else
|
|
job.lostSince = nil
|
|
end
|
|
return
|
|
end
|
|
-- lige sendt af sted: AD kan bruge et øjeblik på at starte (prøv én gang mere)
|
|
if not driving and now() - job.since < ADLivestock.START_GRACE_MS then return end
|
|
if not driving and not job.restarted and distanceTo(adEnv, job.tractor, job.markerId) > ADLivestock.ARRIVE_M then
|
|
job.restarted, job.since = true, now()
|
|
ADFieldWork.startAd(adEnv, job.tractor, adEnv.AutoDrive.MODE_DRIVETO, job.markerId, nil)
|
|
return
|
|
end
|
|
if driving then
|
|
if now() - job.since > ADLivestock.PHASE_TIMEOUT_MS then
|
|
pcall(job.tractor.stopAutoDrive, job.tractor)
|
|
fail(job)
|
|
goHome(adEnv, job, string.format("dyretur med '%s' nåede ikke frem til '%s' — kører hjem", vname(job.tractor), tostring(job.markerName)), true)
|
|
end
|
|
return
|
|
end
|
|
if distanceTo(adEnv, job.tractor, job.markerId) > ADLivestock.ARRIVE_M then
|
|
fail(job)
|
|
goHome(adEnv, job, string.format("'%s' stoppede før '%s' — dyreturen afbrudt, kører hjem", vname(job.tractor), tostring(job.markerName)), true)
|
|
return
|
|
end
|
|
local trigger = call(job.trailer, "getLoadingTrigger")
|
|
if job.phase == "toBarn" then
|
|
if trigger ~= job.barn.spec_husbandryAnimals.animalLoadingTrigger then
|
|
fail(job)
|
|
goHome(adEnv, job, string.format("%s: kreaturvognen holder ikke i staldens dyre-trigger ved '%s' — flyt markøren, så vognen står i læssepladsen", job.barnName, tostring(job.markerName)), true)
|
|
return
|
|
end
|
|
local moved = loadAnimals(job)
|
|
if moved == 0 then fail(job) goHome(adEnv, job, string.format("%s: ingen slagteklare dyr at læsse — kører hjem", job.barnName)) return end
|
|
logInfo(ADLivestock.LOG_PREFIX .. "%s: %d slagteklare dyr læsset i '%s'", job.barnName, moved, vname(job.trailer))
|
|
driveTo(adEnv, job, job.dealer.marker, "toDealer")
|
|
elseif job.phase == "toDealer" then
|
|
if job.dealer.slaughterhouse ~= nil then slaughterAnimals(adEnv, job) return end
|
|
if trigger == nil or not trigger.isDealer then
|
|
fail(job)
|
|
goHome(adEnv, job, string.format("kreaturvognen holder ikke i dyrehandlerens trigger ved '%s' — dyrene bliver i vognen; flyt markøren", tostring(job.markerName)), true)
|
|
return
|
|
end
|
|
local count, total = sellAnimals(job)
|
|
goHome(adEnv, job, string.format("%s: %d dyr solgt hos '%s' for %s kr", job.barnName or "dyr fra vognen", count, job.dealer.title, g_i18n ~= nil and g_i18n:formatNumber(total, 0) or tostring(math.floor(total))))
|
|
end
|
|
end
|
|
|
|
-- Spillets måned: år*100+periode (nil før miljøet findes)
|
|
local function monthKey()
|
|
local environment = g_currentMission ~= nil and g_currentMission.environment or nil
|
|
if environment == nil or environment.currentPeriod == nil then return nil end
|
|
return (environment.currentYear or 0) * 100 + environment.currentPeriod
|
|
end
|
|
|
|
ADLivestock.FILE_NAME = "ADSmartPickup_livestock.xml"
|
|
ADLivestock.ROOT = "ADSmartPickupLivestock"
|
|
|
|
-- Månedskvoterne gemmes, så en genindlæsning midt i måneden ikke giver en ny fuld kvote (kaldt fra ADRunsController.save)
|
|
function ADLivestock.save()
|
|
local path = ADUtil.savePath(ADLivestock.FILE_NAME)
|
|
if path == nil or XMLFile == nil then return false end
|
|
local xmlFile = XMLFile.create("ADSmartPickupLivestock", path, ADLivestock.ROOT)
|
|
if xmlFile == nil then return false end
|
|
local index = 0
|
|
for id, record in pairs(ADLivestock.monthly) do
|
|
local node = string.format("%s.month(%d)", ADLivestock.ROOT, index)
|
|
xmlFile:setString(node .. "#building", id)
|
|
xmlFile:setInt(node .. "#key", record.key)
|
|
xmlFile:setInt(node .. "#months", record.months)
|
|
xmlFile:setInt(node .. "#quota", record.quota or 0)
|
|
xmlFile:setInt(node .. "#sold", record.sold)
|
|
index = index + 1
|
|
end
|
|
-- "læsset af os" overlever en genindlæsning (in-game 19/10 22:29: Noah med 25 læssede kvæg parkeret og gemt —
|
|
-- uden mærket var dyrene spillerens og blev i vognen). Ikke-fundne id'er fra indlæsningen gemmes videre.
|
|
index = 0
|
|
local loadedIds = {}
|
|
for trailer in pairs(loadedByUs) do
|
|
-- slettet vogn (svag nøgle) eller spillerens vogn lige nu: ikke med (review)
|
|
local ok, id, count = pcall(function()
|
|
if trailer.isDeleted or (ADPlayerClaim ~= nil and ADPlayerClaim.claims(trailer)) then return nil end
|
|
return ADRunsController.getVehicleId(trailer), call(trailer, "getNumOfAnimals") or 0
|
|
end)
|
|
if ok and id ~= nil and count > 0 then loadedIds[id] = count end
|
|
end
|
|
for id, count in pairs(pendingLoaded) do loadedIds[id] = loadedIds[id] or count end
|
|
for id, count in pairs(loadedIds) do
|
|
local node = string.format("%s.loaded(%d)", ADLivestock.ROOT, index)
|
|
xmlFile:setString(node .. "#vehicle", id)
|
|
xmlFile:setInt(node .. "#animals", count)
|
|
index = index + 1
|
|
end
|
|
index = 0
|
|
for barnId, vehicleId in pairs(ADLivestock.locks) do
|
|
local node = string.format("%s.lock(%d)", ADLivestock.ROOT, index)
|
|
xmlFile:setString(node .. "#building", barnId)
|
|
xmlFile:setString(node .. "#vehicle", vehicleId)
|
|
index = index + 1
|
|
end
|
|
xmlFile:save()
|
|
xmlFile:delete()
|
|
return true
|
|
end
|
|
|
|
function ADLivestock.load()
|
|
ADLivestock.monthly = {}
|
|
ADLivestock.locks = {}
|
|
pendingLoaded = {}
|
|
local path = ADUtil.savePath(ADLivestock.FILE_NAME)
|
|
if path == nil or fileExists == nil or not fileExists(path) or XMLFile == nil then return false end
|
|
local xmlFile = XMLFile.load("ADSmartPickupLivestock", path)
|
|
if xmlFile == nil then return false end
|
|
xmlFile:iterate(ADLivestock.ROOT .. ".month", function(_, node)
|
|
local id = xmlFile:getString(node .. "#building")
|
|
local key = xmlFile:getInt(node .. "#key")
|
|
if id ~= nil and key ~= nil then
|
|
ADLivestock.monthly[id] = {key = key, months = xmlFile:getInt(node .. "#months") or 0,
|
|
quota = xmlFile:getInt(node .. "#quota") or 0, sold = xmlFile:getInt(node .. "#sold") or 0}
|
|
end
|
|
end)
|
|
xmlFile:iterate(ADLivestock.ROOT .. ".lock", function(_, node)
|
|
local id, vehicleId = xmlFile:getString(node .. "#building"), xmlFile:getString(node .. "#vehicle")
|
|
if id ~= nil and vehicleId ~= nil and vehicleId ~= "" then ADLivestock.locks[id] = vehicleId end
|
|
end)
|
|
xmlFile:iterate(ADLivestock.ROOT .. ".loaded", function(_, node)
|
|
local vehicleId = xmlFile:getString(node .. "#vehicle")
|
|
local count = xmlFile:getInt(node .. "#animals") or 0
|
|
if vehicleId ~= nil and vehicleId ~= "" and count > 0 then pendingLoaded[vehicleId] = count end
|
|
end)
|
|
xmlFile:delete()
|
|
return true
|
|
end
|
|
|
|
local function planJobs(adEnv)
|
|
local farmId = g_currentMission:getFarmId()
|
|
-- 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)
|
|
if next(pendingLoaded) ~= nil then
|
|
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
|
|
local id = vehicle.spec_livestockTrailer ~= nil and ADRunsController.getVehicleId(vehicle) or nil
|
|
local saved = id ~= nil and pendingLoaded[id] or nil
|
|
if saved ~= nil then
|
|
local count = call(vehicle, "getNumOfAnimals") or 0
|
|
if count > 0 and count <= saved then loadedByUs[vehicle] = true end
|
|
end
|
|
end
|
|
end
|
|
-- første planlægning er mindst CHECK_MS efter indlæsningen: en vogn der ikke findes nu, er solgt/slettet
|
|
pendingLoaded = {}
|
|
-- sluppet tur med læssede dyr, vognen sidder stadig på traktoren: fortsæt direkte til handleren
|
|
for _, entry in ipairs(attachedLoaded(farmId)) do
|
|
local trailer = entry.trailerInfo.vehicle
|
|
local x, _, z = getWorldTranslation(trailer.rootNode)
|
|
local typeObj = call(trailer, "getCurrentAnimalType")
|
|
local dealer, why = deliveryFor(adEnv, farmId, nil, typeObj ~= nil and typeObj.typeIndex or nil, x, z, trailer)
|
|
if dealer ~= nil then startJob(adEnv, farmId, nil, entry.trailerInfo, entry.tractor, dealer, 0, true)
|
|
else warnOnce("leftover:" .. tostring(trailer) .. ":" .. tostring(why), string.format("dyrene i '%s' venter: %s", vname(trailer), tostring(why))) end
|
|
end
|
|
-- vogne der allerede har dyr (afbrudt tur, genindlæsning): sælges først
|
|
for _, trailerInfo in ipairs(freeTrailers(adEnv, farmId, nil)) do
|
|
local cooling = (failedUntil[trailerInfo.vehicle] or 0) > now()
|
|
-- tom vogn: et gammelt "læsset af os"-mærke må ikke gælde spillerens senere dyr (review)
|
|
if trailerInfo.animals == 0 then loadedByUs[trailerInfo.vehicle] = nil slaughterBound[trailerInfo.vehicle] = nil end
|
|
if trailerInfo.animals > 0 and not loadedByUs[trailerInfo.vehicle] then
|
|
-- spillerens egne dyr (købt, flyttet, eller læsset før en genindlæsning): rør dem ikke
|
|
warnOnce("foreign:" .. tostring(trailerInfo.id), string.format("kreaturvognen '%s' har dyr, som dyreturen ikke selv har læsset — de bliver i vognen", vname(trailerInfo.vehicle)))
|
|
elseif trailerInfo.animals > 0 and not cooling then
|
|
local x, _, z = getWorldTranslation(trailerInfo.vehicle.rootNode)
|
|
local typeObj = call(trailerInfo.vehicle, "getCurrentAnimalType")
|
|
local dealer, why = deliveryFor(adEnv, farmId, nil, typeObj ~= nil and typeObj.typeIndex or nil, x, z, trailerInfo.vehicle)
|
|
if dealer == nil then warnOnce("leftover:" .. tostring(trailerInfo.id) .. ":" .. tostring(why), string.format("dyrene i '%s' venter: %s", vname(trailerInfo.vehicle), tostring(why))) end
|
|
local tractor = dealer ~= nil and freeTractor(adEnv, trailerInfo.vehicle) or nil
|
|
if tractor ~= nil then startJob(adEnv, farmId, nil, trailerInfo, tractor, dealer, 0) end
|
|
end
|
|
end
|
|
local key = monthKey()
|
|
for _, barn in ipairs(readyBarns(adEnv, farmId)) do
|
|
local planned = 0
|
|
-- kun ture der ikke har læsset endnu (læssede dyr er allerede ude af staldens tal)
|
|
for _, job in pairs(jobs) do if job.barn == barn.placeable and not job.loaded then planned = planned + (job.size or 0) end end
|
|
local ready = barn.ready - planned
|
|
local months = ADSettings.getOwn("sellReadySpreadMonths", barn.id) or 0
|
|
local quotaLeft = nil
|
|
if key ~= nil and months > 0 then
|
|
local record = ADLivestock.monthRecord(ADLivestock.monthly[barn.id], key, barn.total, months)
|
|
ADLivestock.monthly[barn.id] = record
|
|
quotaLeft = record.quota - record.sold - planned
|
|
barn.monthKey = key
|
|
end
|
|
if ready > 0 and (failedUntil[barn.placeable] or 0) <= now() then
|
|
local x, z = nodePos(barn.placeable.spec_husbandryAnimals.animalLoadingTrigger.triggerNode)
|
|
local dealer, why = deliveryFor(adEnv, farmId, barn.id, barn.typeIndex, x, z)
|
|
if dealer == nil then
|
|
warnOnce("noDealer:" .. tostring(barn.id) .. ":" .. tostring(why), string.format("%s: %d slagteklare dyr, men %s", placeableName(barn.placeable), barn.ready, tostring(why)))
|
|
else
|
|
for _, trailerInfo in ipairs(freeTrailers(adEnv, farmId, barn.typeIndex)) do
|
|
if ready <= 0 then break end
|
|
if trailerInfo.animals == 0 and (failedUntil[trailerInfo.vehicle] or 0) <= now() then
|
|
local slots = freeSlots(trailerInfo.vehicle, barn.typeIndex)
|
|
local size = ADLivestock.tripSize(ready, barn.total - planned, slots, quotaLeft)
|
|
if size > 0 then
|
|
local lockId = ADLivestock.locks[barn.id]
|
|
local tractor, lockedVehicle
|
|
if lockId ~= nil then
|
|
-- låst traktor: kun den (er den optaget, ventes til næste tjek)
|
|
tractor, lockedVehicle = lockedTractor(adEnv, lockId)
|
|
if tractor == nil then
|
|
warnOnce("lockBusy:" .. tostring(barn.id), string.format("%s: venter på den faste traktor '%s'", placeableName(barn.placeable),
|
|
lockedVehicle ~= nil and vname(lockedVehicle) or ("findes ikke: " .. tostring(lockId))))
|
|
break
|
|
end
|
|
else
|
|
tractor = freeTractor(adEnv, trailerInfo.vehicle)
|
|
end
|
|
if tractor == nil then
|
|
warnOnce("noTractor:" .. tostring(barn.placeable), string.format("%s: slagteklare dyr, men ingen ledig traktor til kreaturvognen", placeableName(barn.placeable)))
|
|
break
|
|
end
|
|
startJob(adEnv, farmId, barn, trailerInfo, tractor, dealer, size)
|
|
ready = ready - size
|
|
if quotaLeft ~= nil then quotaLeft = quotaLeft - size end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function ADLivestock.tick(adEnv, dt)
|
|
if adEnv == nil or g_currentMission == nil or ADPool == nil or ADHitch == nil or ADFieldWork == nil then return end
|
|
if g_currentMission.getIsServer ~= nil and not g_currentMission:getIsServer() then return end
|
|
for _, job in pairs(jobs) do
|
|
local ok, err = pcall(stepJob, adEnv, job)
|
|
if not ok then
|
|
Logging.warning(ADLivestock.LOG_PREFIX .. "dyretur: %s", tostring(err))
|
|
finish(job, nil)
|
|
end
|
|
end
|
|
checkTimer = checkTimer + (dt or 0)
|
|
if checkTimer < ADLivestock.CHECK_MS then return end
|
|
checkTimer = 0
|
|
if ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and ADFieldJobs.state.paused then return end -- "Stop alt og parkér"
|
|
local ok, err = pcall(planJobs, adEnv)
|
|
if not ok then Logging.warning(ADLivestock.LOG_PREFIX .. "planlægning: %s", tostring(err)) end
|
|
end
|
|
|
|
if addConsoleCommand ~= nil then
|
|
addConsoleCommand("spuAnimals", "Stalde (dyr, alder, pris, klar-alder), dyrehandlere, kreaturvogne og AD-markører ved læsseområderne", "consoleSurvey", ADLivestock)
|
|
end
|