Files
fs25-adsmartpickup/FS25_ADSmartPickup/adContracts.lua
T

239 lines
12 KiB
Lua

-- AD Contracts
-- Kontrakter kører selv (brugerønske 9/10, "byg det hele" 10/10): accepterer spilleren en markkontrakt, sætter moden
-- kontraktens mark til det tilsvarende trin (pløj, kultivér, så, ukrudt, gødning, slåning, sten), og markarbejdet
-- sender et sæt — eller beder spilleren køre et, uden parkering/markør (ADPlayerTransport). Kun det ene trin; når
-- kontrakten er færdig eller annulleret, stoppes sættene og marken glemmes. Høst: tømmevognene kører læssene til
-- kontraktens salgssted (dets AutoDrive-markører); uden F-markør kører spilleren mejetærskeren derud og tømmer selv.
-- Hvem kører kontrakten (brugerønske 10/10): indstillingen contracts — 2 = spørg ved hver kontrakt (standard),
-- 1 = moden altid, 0 = spilleren altid. Kontraktmarken står altid i marklisten: [Til] = moden kører den, [Fra] =
-- spilleren (svarer man nej, eller "jeg selv altid", står den på Fra og kan slås til senere). Ren logik øverst, spil-adapter nederst.
ADContracts = {}
ADContracts.SCAN_MS = 5000
-- kontrakttype (uden "Mission", små bogstaver) -> markens trin
ADContracts.STAGES = {
plow = "plowing", cultivate = "cultivating", sow = "sowing", weed = "weeding", hoe = "weeding",
herbicide = "weeding", fertilize = "fertilizing", mow = "mowing", stonepick = "stonePicking", roll = "rolling",
harvest = "harvesting",
}
function ADContracts.stageFor(typeName)
if typeName == nil then return nil end
local key = string.lower(tostring(typeName)):gsub("mission$", "")
return ADContracts.STAGES[key]
end
-- indstillingen contracts -> "ask" | "start" | "skip"
function ADContracts.decision(mode)
if mode == 1 then return "start" end
if mode == 0 then return "skip" end
return "ask"
end
-- entries = {{id, placeable}} (AutoDrive-markører og bygningen deres aflæsning hører til) -> id'er ved placeable
function ADContracts.markersAt(entries, placeable)
local ids = {}
if placeable == nil then return ids end
for _, entry in ipairs(entries or {}) do
if entry.placeable == placeable then table.insert(ids, entry.id) end
end
return ids
end
-- tracked/running = {[nøgle] = {fieldId, ...}} -> startede, afsluttede (lister {key, ...})
function ADContracts.diff(tracked, running)
local started, ended = {}, {}
for key, entry in pairs(running or {}) do
if (tracked or {})[key] == nil then
table.insert(started, {key = key, fieldId = entry.fieldId, stage = entry.stage, fruit = entry.fruit, mission = entry.mission})
end
end
for key, entry in pairs(tracked or {}) do
if (running or {})[key] == nil then table.insert(ended, {key = key, fieldId = entry.fieldId}) end
end
table.sort(started, function(a, b) return tostring(a.key) < tostring(b.key) end)
table.sort(ended, function(a, b) return tostring(a.key) < tostring(b.key) end)
return started, ended
end
-- ---- spil-adapter ----
ADContracts.tracked = {} -- nøgle -> {fieldId}
ADContracts.fieldIds = {} -- markId -> true (kontraktmarker, som ADFields scanner med)
local lastScanAt = nil
function ADContracts.isContractField(fieldId)
return ADContracts.fieldIds[fieldId] == true
end
local function missionKey(mission)
return tostring(mission.uniqueId or mission.activeMissionId or mission)
end
local function fieldIdOf(mission)
local field = mission.field or (mission.getField ~= nil and mission:getField()) or nil
if field == nil then return nil end
return field.getId ~= nil and field:getId() or field.fieldId
end
-- Høstkontraktens salgssted (placeable). Feltnavnet er ikke dokumenteret (HarvestMission.lua mangler i spilkilden):
-- sellingStation, ellers første felt med en aflæsningsstation, ellers savegame-id'et. Returnerer placeable, hvor fundet.
local function sellPlaceableOf(mission)
local station = mission.sellingStation
local where = "sellingStation"
if station == nil then
for key, value in pairs(mission) do
if type(value) == "table" and value.owningPlaceable ~= nil and value.unloadTriggers ~= nil then
station, where = value, tostring(key)
break
end
end
end
local placeable = station ~= nil and station.owningPlaceable or nil
local uniqueId = mission.sellingStationPlaceableUniqueId
if placeable == nil and uniqueId ~= nil and g_currentMission.placeableSystem.getPlaceableByUniqueId ~= nil then
placeable, where = g_currentMission.placeableSystem:getPlaceableByUniqueId(uniqueId), "sellingStationPlaceableUniqueId"
end
-- aflæsningsstationen selv (til spillets hjælper / Courseplay "Giants unload")
if station == nil and placeable ~= nil and placeable.spec_sellingStation ~= nil then
station = placeable.spec_sellingStation.sellingStation
end
return placeable, where, station
end
-- AutoDrive-markører hvis aflæsning hører til salgsstedet.
local function sellMarkerIds(adEnv, placeable, farmId)
local entries = {}
for _, marker in pairs(adEnv.ADGraphManager:getMapMarkers() or {}) do
local okStation, station = pcall(ADSmartPickup.getUnloadStationAtWayPointId, adEnv, marker.id, farmId)
table.insert(entries, {id = marker.id, placeable = okStation and station ~= nil and station.owningPlaceable or nil})
end
return ADContracts.markersAt(entries, placeable)
end
local function fruitNameOf(mission)
local index = mission.fruitTypeIndex or mission.fruitType
if type(index) ~= "number" or g_fruitTypeManager == nil then return nil end
local fruit = g_fruitTypeManager:getFruitTypeByIndex(index)
return fruit ~= nil and fruit.name or nil
end
-- Kørende markkontrakter for gården, som moden kan udføre: {[nøgle] = {fieldId, stage, fruit}}
local function runningContracts(farmId)
local running = {}
if g_missionManager == nil or MissionStatus == nil then return running end
for _, mission in ipairs(g_missionManager:getMissions() or {}) do
if mission.farmId == farmId and mission.status == MissionStatus.RUNNING then
local stage = ADContracts.stageFor(mission.type ~= nil and mission.type.name or nil)
local fieldId = stage ~= nil and fieldIdOf(mission) or nil
if fieldId ~= nil then
running[missionKey(mission)] = {fieldId = fieldId, stage = stage, fruit = fruitNameOf(mission), mission = mission}
end
end
end
return running
end
-- enabled = false: spilleren kører selv — marken står i listen som [Fra], så moden kan slås til senere
local function start(adEnv, entry, enabled)
enabled = enabled ~= false
ADContracts.tracked[entry.key] = {fieldId = entry.fieldId}
ADContracts.fieldIds[entry.fieldId] = true
-- kun kontraktens trin: slået til, intet efterfølgende trin (ADFieldJobs: contract -> done efter trinnet)
local harvest = entry.stage == "harvesting"
local changes = {stage = entry.stage, kind = harvest and "harvest" or "bare", contract = true,
plan = {mode = enabled and "auto" or "manual", sow = entry.stage == "sowing", sowFruit = entry.fruit or "", straw = "chop"}}
if harvest and entry.mission ~= nil then
-- høst: læssene skal til kontraktens salgssted (ADFieldWork.chooseStore)
local placeable, where, station = sellPlaceableOf(entry.mission)
local farmId = g_currentMission:getFarmId()
changes.contractSellIds = placeable ~= nil and sellMarkerIds(adEnv, placeable, farmId) or {}
-- uden AutoDrive-vej kører spillets hjælper læssene hertil (ADFieldWork beginUnloader)
changes.contractStation = station
ADFieldJobs.log(entry.fieldId, "høstkontrakt: salgssted %s (fundet via %s), %d AutoDrive-markør(er) ved det",
placeable ~= nil and tostring(placeable.getName ~= nil and placeable:getName() or "?") or "ikke fundet",
tostring(where), #changes.contractSellIds)
end
local field = ADFieldModel.with(ADFieldModel.newField(entry.fieldId), changes)
ADFieldJobs.setField(field)
ADFields.ownedAt = nil -- scan kontraktmarken med det samme
local text = string.format("Kontrakt på F%s: moden %s marken", tostring(entry.fieldId),
({plowing = "pløjer", cultivating = "kultiverer", sowing = "sår", weeding = "renser", fertilizing = "gøder",
mowing = "slår", stonePicking = "plukker sten på", rolling = "tromler", harvesting = "høster"})[entry.stage] or "bearbejder")
if not enabled then
text = string.format("Kontrakt på F%s: du kører den selv — klik [Til] på marken i Marker, hvis moden skal overtage",
tostring(entry.fieldId))
end
ADFieldJobs.log(entry.fieldId, "%s (%s)", text, tostring(entry.key))
ADFieldJobs.notify(text, false)
end
local function finish(adEnv, entry)
local tracked = ADContracts.tracked[entry.key]
ADContracts.tracked[entry.key] = nil
-- spilleren kører den selv (eller spørgsmålet er ikke besvaret): moden har intet på marken
if tracked ~= nil and (tracked.declined or tracked.pending) then
if ADContracts.asking == entry.key then ADContracts.asking = nil end
return
end
ADContracts.fieldIds[entry.fieldId] = nil
pcall(ADFieldWork.stopAll, adEnv, entry.fieldId)
ADFieldJobs.state.fields[entry.fieldId] = nil
ADFieldJobs.forgetFinished(entry.fieldId)
ADFields.ownedAt = nil
ADFieldJobs.log(entry.fieldId, "kontrakten er slut — sættene er stoppet, og marken er glemt")
end
-- Svar på "skal moden køre kontrakten?" (YesNoDialog: callback(target, yes, args)).
function ADContracts.onAnswer(_, yes, entry)
ADContracts.asking = nil
local tracked = entry ~= nil and ADContracts.tracked[entry.key] or nil
if tracked == nil or not tracked.pending then return end -- kontrakten er slut i mellemtiden
ADContracts.tracked[entry.key] = nil
-- nej: marken kommer i listen som [Fra], så moden kan overtage senere ([Til])
start(ADContracts.adEnv, entry, yes == true)
end
local function ask(entry)
if YesNoDialog == nil or YesNoDialog.show == nil then
-- kan ikke spørge: rør den ikke (spilleren kan vælge "moden altid" under Indstillinger)
start(ADContracts.adEnv, entry, false)
return
end
ADContracts.tracked[entry.key] = {fieldId = entry.fieldId, pending = true}
ADContracts.asking = entry.key
local text = string.format("Ny kontrakt: F%s skal %s. Skal Smart Pickup køre den?", tostring(entry.fieldId),
ADManualTransport.stageVerb(entry.stage))
local ok = pcall(YesNoDialog.show, ADContracts.onAnswer, nil, text, "Smart Pickup", "Ja, kør den", "Nej, jeg kører selv",
nil, nil, nil, entry)
if not ok then ADContracts.onAnswer(nil, false, entry) end
end
-- Kaldes fra markarbejdets tick.
function ADContracts.tick(adEnv, nowMs)
ADContracts.adEnv = adEnv
local decision = ADContracts.decision(ADSettings ~= nil and ADSettings.get("contracts") or nil)
if lastScanAt ~= nil and nowMs - lastScanAt < ADContracts.SCAN_MS then return end
lastScanAt = nowMs
local farmId = g_currentMission ~= nil and g_currentMission:getFarmId() or nil
if farmId == nil then return end
local started, ended = ADContracts.diff(ADContracts.tracked, runningContracts(farmId))
for _, entry in ipairs(ended) do finish(adEnv, entry) end
-- "Stop alt"-pause: nye kontrakter startes først, når markarbejdet kører igen
if ADFieldJobs.state.paused then started = {} end
for _, entry in ipairs(started) do
-- egen mark (kontrakt på egen jord findes ikke i FS25, men for en sikkerheds skyld): rør ikke spillerens plan
local own = ADFieldJobs.state.fields[entry.fieldId]
if own == nil or own.contract then
if decision ~= "ask" then
-- "Moden altid" -> [Til]; "Jeg selv altid" -> [Fra] (kan slås til senere)
start(adEnv, entry, decision == "start")
elseif ADContracts.asking == nil then
ask(entry) -- én dialog ad gangen; de næste spørges ved de følgende aflæsninger
end
end
end
end