193 lines
10 KiB
Lua
193 lines
10 KiB
Lua
-- AD Player Claim
|
|
-- Spillerens maskine (brugerønske 19/10: "jeg låner en tilfældig traktor ... og en tom opsamlervogn der tilhørte Cow
|
|
-- Food"). En traktor spilleren selv KØRER (sidder i, AutoDrive/Courseplay slukket, i bevægelse) og dens påkoblede
|
|
-- redskaber er spillerens i CLAIM_MS efter sidste kørsel: ingen flow-opvågning, lånt traktor, maskinpulje eller
|
|
-- oprydning rører dem. At sidde i en traktor AD kører (kigge med) tæller ikke. Sættes vognen tilbage på sin P-plads og
|
|
-- kobles af, er den fri med det samme. Når tiden er gået, og traktoren holder ubrugt væk fra sin plads, kører den selv
|
|
-- hjem: vognen tømmes (lager, ellers salg; en udbringers last sælges aldrig) og sættes på sin P-plads.
|
|
-- 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
|
|
|
|
ADPlayerClaim = {}
|
|
ADPlayerClaim.LOG_PREFIX = "ADSmartPickup: spillerens maskine: "
|
|
ADPlayerClaim.CLAIM_MS = 10 * 60 * 1000
|
|
ADPlayerClaim.TICK_MS = 1000
|
|
ADPlayerClaim.DRIVE_SPEED = 0.0003 -- m/ms (ca. 1 km/t): spilleren kører den
|
|
ADPlayerClaim.OWN_PARK_M = 30 -- så tæt på sin egen P-plads = sat på plads
|
|
|
|
-- ---- ren logik ----
|
|
|
|
-- s = {controlled, autoDriving, sinceMs (siden sidste spillerkørsel, nil = aldrig), attached, atOwnPark} -> bool
|
|
function ADPlayerClaim.isClaimed(s)
|
|
-- sidder i en holdende maskine uden AD/CP: spillerens (en opvågning må ikke starte den under ham)
|
|
if s.controlled and not s.autoDriving then return true end
|
|
if s.sinceMs == nil or s.sinceMs >= ADPlayerClaim.CLAIM_MS then return false end
|
|
-- sat tilbage på sin plads og koblet af: fri med det samme
|
|
if s.atOwnPark and not s.attached then return false end
|
|
return true
|
|
end
|
|
|
|
-- Kør selv hjem nu? s = {wasClaimed, claimed, motorized, busy, atOwnPark, hasPark, isCar}
|
|
-- En bil (butikskategori CARS) er spillerens transport: den bliver, hvor han satte den (in-game 19/10 18:39: "hvad skal
|
|
-- moddet bruge min bil til ??" — Pickup 2017 kørte selv til sin AD-parkering)
|
|
function ADPlayerClaim.returnAction(s)
|
|
if not s.wasClaimed or s.claimed or not s.motorized or s.busy or s.atOwnPark or s.isCar then return nil end
|
|
return s.hasPark and "home" or "noPark"
|
|
end
|
|
|
|
-- ---- spil-adapter ----
|
|
|
|
local lastDriven = setmetatable({}, {__mode = "k"}) -- køretøj -> ms for sidste spillerkørsel
|
|
local claimedBefore = setmetatable({}, {__mode = "k"}) -- køretøj -> true: var spillerens ved sidste tick
|
|
local loggedNoPark = setmetatable({}, {__mode = "k"})
|
|
local timerMs, clock = 0, 0
|
|
local env = nil
|
|
|
|
local function controlled(vehicle)
|
|
return vehicle.getIsControlled ~= nil and vehicle:getIsControlled() == true
|
|
end
|
|
|
|
local function autoDriving(vehicle)
|
|
local module = vehicle.ad ~= nil and vehicle.ad.stateModule or nil
|
|
return (module ~= nil and module:isActive()) or (ADCpBridge ~= nil and ADCpBridge.isWorking ~= nil and ADCpBridge.isWorking(vehicle) == true)
|
|
end
|
|
|
|
-- Traktoren og alle redskaber i kæden bag/foran den.
|
|
local function rigOf(vehicle)
|
|
local list = {vehicle}
|
|
if vehicle.getChildVehicles ~= nil then
|
|
local ok, children = pcall(vehicle.getChildVehicles, vehicle)
|
|
for _, child in ipairs(ok and children or {}) do if child ~= vehicle then table.insert(list, child) end end
|
|
elseif ADHitch ~= nil then
|
|
for _, implement in ipairs(ADHitch.directImplementsOf(vehicle)) do table.insert(list, implement.object) end
|
|
end
|
|
return list
|
|
end
|
|
|
|
local function isAttached(vehicle)
|
|
if vehicle.getAttacherVehicle ~= nil and vehicle:getAttacherVehicle() ~= nil then return true end
|
|
return ADHitch ~= nil and #ADHitch.directImplementsOf(vehicle) > 0
|
|
end
|
|
|
|
local function atOwnPark(vehicle)
|
|
if env == nil or ADFieldWork == nil or ADFieldWork.parkMarkerId == nil or vehicle.rootNode == nil then return false end
|
|
local ok, parkId = pcall(ADFieldWork.parkMarkerId, env, vehicle)
|
|
local wp = ok and parkId ~= nil and env.ADGraphManager:getWayPointById(parkId) or nil
|
|
if wp == nil then return false end
|
|
local x, _, z = getWorldTranslation(vehicle.rootNode)
|
|
return (x - wp.x) ^ 2 + (z - wp.z) ^ 2 <= ADPlayerClaim.OWN_PARK_M ^ 2
|
|
end
|
|
|
|
local function hasFieldJob(vehicle)
|
|
if ADFieldJobs == nil or ADFieldJobs.state == nil or ADRunsController == nil then return false end
|
|
local assignments = ADFieldJobs.state.assignments or {}
|
|
local id = ADRunsController.getVehicleId(vehicle)
|
|
if id ~= nil and assignments[id] ~= nil then return true end
|
|
local attacher = vehicle.getAttacherVehicle ~= nil and vehicle:getAttacherVehicle() or nil
|
|
local attacherId = attacher ~= nil and ADRunsController.getVehicleId(attacher) or nil
|
|
return attacherId ~= nil and assignments[attacherId] ~= nil
|
|
end
|
|
|
|
-- Er køretøjet spillerens lige nu? (til flows, lån, maskinpulje og oprydning). En markopgave spilleren kører ud for
|
|
-- moden (ADPlayerTransport: "kør sættet til marken og stig ud") er moddens, ikke spillerens.
|
|
function ADPlayerClaim.claims(vehicle)
|
|
if vehicle == nil or hasFieldJob(vehicle) then return false end
|
|
local since = lastDriven[vehicle] ~= nil and (clock - lastDriven[vehicle]) or nil
|
|
local isControlled = controlled(vehicle)
|
|
if since == nil and not isControlled then return false end
|
|
return ADPlayerClaim.isClaimed({controlled = isControlled, autoDriving = isControlled and autoDriving(vehicle),
|
|
sinceMs = since, attached = since ~= nil and isAttached(vehicle), atOwnPark = since ~= nil and atOwnPark(vehicle)})
|
|
end
|
|
|
|
-- Til loggen/statusvinduet: minutter tilbage, eller nil
|
|
function ADPlayerClaim.minutesLeft(vehicle)
|
|
if lastDriven[vehicle] == nil then return nil end
|
|
local left = ADPlayerClaim.CLAIM_MS - (clock - lastDriven[vehicle])
|
|
return left > 0 and math.ceil(left / 60000) or nil
|
|
end
|
|
|
|
local function label(vehicle)
|
|
return ADRuns ~= nil and tostring(ADRuns.vehicleLabel(vehicle)) or tostring(vehicle.getName ~= nil and vehicle:getName() or "?")
|
|
end
|
|
|
|
local function isBusy(vehicle)
|
|
if autoDriving(vehicle) then return true end
|
|
local id = ADRunsController ~= nil and ADRunsController.getVehicleId(vehicle) or nil
|
|
if id ~= nil and ADFieldJobs ~= nil and ADFieldJobs.state ~= nil and (ADFieldJobs.state.assignments or {})[id] ~= nil then return true end
|
|
if ADRunsController ~= nil and ADRunsController.getActiveRunForVehicle(vehicle) ~= nil then return true end
|
|
if ADLivestock ~= nil and ADLivestock.isOnTrip ~= nil and ADLivestock.isOnTrip(vehicle) then return true end
|
|
-- låst flow-sæt (20/10): kører ikke selv hjem til gården efter spillerkørsel
|
|
if ADFlowWagons ~= nil and ADFlowWagons.isLockedSet ~= nil and ADFlowWagons.isLockedSet(vehicle) then return true end
|
|
if ADPlayerTransport ~= nil and ADPlayerTransport.isPickup ~= nil and ADPlayerTransport.isPickup(vehicle) then return true end
|
|
return ADFlowWagons ~= nil and ADFlowWagons.statusOf ~= nil and ADFlowWagons.statusOf(vehicle) ~= nil
|
|
end
|
|
|
|
local function isCar(vehicle)
|
|
if g_storeManager == nil or vehicle.configFileName == nil then return false end
|
|
local item = g_storeManager:getItemByXMLFilename(vehicle.configFileName)
|
|
if item == nil then return false end
|
|
for _, category in ipairs(type(item.categoryNames) == "table" and item.categoryNames or {item.categoryName}) do
|
|
if string.lower(tostring(category)) == "cars" then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
local function sendHome(vehicle)
|
|
local hasRear = ADHitch ~= nil and #ADHitch.rearImplementsOf(vehicle) > 0
|
|
if hasRear and ADFlowWagons ~= nil and ADFlowWagons.homeVehicle ~= nil then
|
|
-- brugerønske 19/10: en vogn spilleren har efterladt med læs tømmes, så den er klar til sit eget flow (lager,
|
|
-- ellers salg — en udbringers gødning/kalk/frø sælges aldrig, den parkeres med lasten)
|
|
ADFlowWagons.homeVehicle(env, vehicle, nil, "playerClaim")
|
|
else
|
|
local parkId = ADFieldWork.parkMarkerId(env, vehicle)
|
|
ADFieldWork.startAd(env, vehicle, env.AutoDrive.MODE_DRIVETO, parkId, nil)
|
|
end
|
|
logInfo(ADPlayerClaim.LOG_PREFIX .. "'%s' har stået ubrugt i %d min efter spillerkørsel — kører selv på plads%s",
|
|
label(vehicle), math.floor(ADPlayerClaim.CLAIM_MS / 60000), hasRear and " (vognen tømmes først og sættes på sin P-plads)" or "")
|
|
end
|
|
|
|
local function checkReturn(vehicle)
|
|
local claimed = ADPlayerClaim.claims(vehicle)
|
|
local wasClaimed = claimedBefore[vehicle] == true
|
|
claimedBefore[vehicle] = claimed or nil
|
|
if not wasClaimed or claimed then return end
|
|
lastDriven[vehicle] = nil
|
|
local motorized = vehicle.spec_motorized ~= nil
|
|
local okPark, parkId = pcall(ADFieldWork.parkMarkerId, env, vehicle)
|
|
local action = ADPlayerClaim.returnAction({wasClaimed = true, claimed = false, motorized = motorized,
|
|
busy = motorized and isBusy(vehicle), atOwnPark = motorized and atOwnPark(vehicle), hasPark = okPark and parkId ~= nil,
|
|
isCar = motorized and isCar(vehicle)})
|
|
if action == "home" then
|
|
sendHome(vehicle)
|
|
elseif action == "noPark" and not loggedNoPark[vehicle] then
|
|
loggedNoPark[vehicle] = true
|
|
logInfo(ADPlayerClaim.LOG_PREFIX .. "'%s' er fri igen, men har ingen AutoDrive-parkering — bliver stående", label(vehicle))
|
|
end
|
|
end
|
|
|
|
function ADPlayerClaim.tick(adEnv, dt)
|
|
timerMs = timerMs + (dt or 0)
|
|
clock = clock + (dt or 0)
|
|
if timerMs < ADPlayerClaim.TICK_MS then return end
|
|
timerMs = 0
|
|
if adEnv == nil or g_currentMission == nil or g_currentMission.vehicleSystem == nil then return end
|
|
env = adEnv
|
|
for _, vehicle in pairs(g_currentMission.vehicleSystem.vehicles or {}) do
|
|
-- spilleren kører selv (ikke AD/CP, i bevægelse): traktoren og hele dens sæt er spillerens fra nu. Sidder han
|
|
-- stille i en maskine han har kørt, tæller tiden fra han stiger ud (review: ellers kørte den hjem straks efter
|
|
-- en lang pause i førersædet). Moddens markopgaver (spilleren kører sættet ud) stemples ikke.
|
|
if controlled(vehicle) and not autoDriving(vehicle) and not hasFieldJob(vehicle)
|
|
and ((vehicle.lastSpeedReal or 0) >= ADPlayerClaim.DRIVE_SPEED or lastDriven[vehicle] ~= nil) then
|
|
for _, member in ipairs(rigOf(vehicle)) do
|
|
if not hasFieldJob(member) then lastDriven[member] = clock end
|
|
end
|
|
end
|
|
end
|
|
for vehicle in pairs(lastDriven) do
|
|
local ok, err = pcall(checkReturn, vehicle)
|
|
if not ok then Logging.warning(ADPlayerClaim.LOG_PREFIX .. "%s", tostring(err)) end
|
|
end
|
|
end
|