232 lines
11 KiB
Python
232 lines
11 KiB
Python
"""savegame8 15/10: de 60 nye bak-ind-båse ved Farm 102 (mm363-422) navngives og tildeles.
|
|
|
|
Vestkolonnen (399-422, P mod vest) = køretøjer med motor; østkolonnen (363-398) = redskaber/vogne m. Connect.
|
|
Mejetærskere + skærebord/optager, lastbil, gyllevogn, paller og R975i (har allerede plads ved 102) røres ikke.
|
|
Har køretøjet en P ved Farm 130, flytter navnet med; den gamle markør bliver 'P Ledig N' (+ 'Connect P Ledig N').
|
|
Frakoblede redskaber stilles ind i båsen (bagende 0,5 m fra P, trækstang mod mundingen); påkoblede sættes af
|
|
af AutoDrive, når traktoren parkerer. Connect = nyt punkt delt ind på bakkesporet ved trækøjet.
|
|
Skriver .new-filer. Brug: farm102park.py <savegame-mappe>
|
|
"""
|
|
import math, os, re, sys, zipfile
|
|
import xml.etree.ElementTree as ET
|
|
sys.path.insert(0, "/var/home/masterdraco/fs25-adsmartpickup/tools/ad-smooth")
|
|
from adsmooth import read, write, apply_splits, dist
|
|
|
|
SG = sys.argv[1].rstrip("/") + "/"
|
|
GAME = os.path.expanduser("~/.local/share/Steam/steamapps/common/Farming Simulator 25/")
|
|
MODS = os.path.expanduser("~/FS25-data/mods/")
|
|
GROUP = ".Farm Plot 102 Park"
|
|
REAR_GAP = 0.5
|
|
MOUNTED_GAP = 0.1
|
|
SKIP_FILES = {"cr11GoldEdition.xml", "tiger6S.xml", "fd250GoldEdition.xml", "rrXL9.xml", "FH16tanker.xml",
|
|
"ctr30_app.xml", "r975i.xml", "bigBagPallet_fertilizer.xml", "silageAdditivePallet.xml"}
|
|
MOTOR_FILES = {"vario1000.xml", "series8.xml", "pickup2017.xml", "Special_Edition_Krone_BiggM.xml", "bigM450.xml"}
|
|
MOUNTED_FILES = {"SP10MU.xml", "ns3030.xml", "ecoCultivator300.xml"}
|
|
SIZE_OVERRIDE = {"SP10MU.xml": (6.0, 0.0), "flieglCargos9500.xml": (10.8, 0.9)} # plov: sammenklappet skøn
|
|
NEW_NAME = {"pickup2017.xml": "Pickup 2017", "series8.xml": "Series 8 TTV", "edk650.xml": "EDK 650",
|
|
"scorpio550.xml": "Elho Scorpio 550"}
|
|
MOTOR_ORDER = ["vario1000.xml", "series8.xml", "Special_Edition_Krone_BiggM.xml", "bigM450.xml", "pickup2017.xml"]
|
|
|
|
|
|
def xmltext(fn):
|
|
if fn.startswith("data/"):
|
|
return open(GAME + fn, encoding="utf-8", errors="ignore").read()
|
|
mod, rest = fn.replace("$moddir$", "").split("/", 1)
|
|
z = zipfile.ZipFile(MODS + mod + ".zip")
|
|
t = z.read(rest).decode("utf-8", "ignore")
|
|
p = re.search(r'parentFile xmlFilename="([^"]+)"', t)
|
|
if p and not re.search(r"<size [^>]*length=", t):
|
|
t = z.read(p.group(1)).decode("utf-8", "ignore")
|
|
return t
|
|
|
|
|
|
def size_of(v):
|
|
f = v.get("filename").split("/")[-1]
|
|
if f in SIZE_OVERRIDE:
|
|
return SIZE_OVERRIDE[f]
|
|
m = re.search(r"<size [^>]*>", xmltext(v.get("filename"))).group(0)
|
|
L = float(re.search(r'length="([\d.]+)"', m).group(1))
|
|
lo = re.search(r'lengthOffset="(-?[\d.]+)"', m)
|
|
return L, float(lo.group(1)) if lo else 0.0
|
|
|
|
|
|
def heading(el):
|
|
r = [float(t) for t in el.find("component").get("rotation").split()]
|
|
return math.radians(r[1] + (180 if abs(r[0]) > 90 else 0))
|
|
|
|
|
|
def angn(a):
|
|
return (a + math.pi) % (2 * math.pi) - math.pi
|
|
|
|
|
|
doc = read(SG + "AutoDrive_config.xml"); N = doc["N"]
|
|
MK_RE = r"<mm(\d+)>\s*<id>([\d.]+)</id>\s*<name>([^<]*)</name>\s*<group>([^<]*)</group>"
|
|
mk = {int(m.group(1)): dict(wp=int(float(m.group(2))), name=m.group(3), group=m.group(4)) for m in re.finditer(MK_RE, doc["s"])}
|
|
byname = {m["name"].lower(): i for i, m in mk.items()}
|
|
|
|
VT = ET.parse(SG + "vehicles.xml"); VR = VT.getroot()
|
|
vehicles = [v for v in VR.iter("vehicle") if v.get("farmId") == "1"]
|
|
parent = {a.get("attachedVehicleUniqueId"): v.get("uniqueId") for v in VR.iter("vehicle") for a in v.iter("attachedImplement")}
|
|
fname = lambda v: v.get("filename").split("/")[-1]
|
|
|
|
|
|
def adname(v):
|
|
ad = v.find("AutoDrive"); return (ad.get("driverName") if ad is not None else None) or ""
|
|
|
|
|
|
def park_of(v):
|
|
ad = v.find("AutoDrive"); p = ad.get("parkDestination") if ad is not None else None
|
|
return int(p) if p and p.lstrip("-").isdigit() and int(p) in mk else None
|
|
|
|
|
|
def set_park(v, idx):
|
|
ad = v.find("AutoDrive")
|
|
if ad is None:
|
|
last = list(v)[-1]; ad = ET.SubElement(v, "AutoDrive"); ad.tail = last.tail; last.tail = "\n "
|
|
ad.set("parkDestination", str(idx))
|
|
|
|
|
|
def bay_axis(p_wp):
|
|
P = N[p_wp]; cur, prev = p_wp, None
|
|
for _ in range(6):
|
|
nb = [x for x in set(N[cur]["out"]) | set(N[cur]["inc"]) if x != prev]
|
|
if not nb: break
|
|
nxt = max(nb, key=lambda x: dist(N[x], P)); prev, cur = cur, nxt
|
|
return math.atan2(N[cur]["x"] - P["x"], N[cur]["z"] - P["z"])
|
|
|
|
|
|
def along_lat(p_wp, e, x, z):
|
|
dx, dz = x - N[p_wp]["x"], z - N[p_wp]["z"]
|
|
return dx * math.sin(e) + dz * math.cos(e), dx * math.cos(e) - dz * math.sin(e)
|
|
|
|
|
|
def split_point_on_track(p_wp, e, d):
|
|
track = []
|
|
for i, n in N.items():
|
|
a, l = along_lat(p_wp, e, n["x"], n["z"])
|
|
if abs(l) < 0.35 and -0.1 < a < 26:
|
|
track.append((a, i))
|
|
track.sort()
|
|
for (a1, i1), (a2, i2) in zip(track, track[1:]):
|
|
linked = i2 in N[i1]["out"] or i1 in N[i2]["out"]
|
|
if linked and a1 <= d <= a2:
|
|
u, w = min(i1, i2), max(i1, i2)
|
|
return u, w, round(abs(d - (a1 if u == i1 else a2)), 3)
|
|
raise SystemExit(f"fandt ikke sporet {d:.1f} m fra P (wp {p_wp})")
|
|
|
|
|
|
def ground_offset(v):
|
|
c = v.find("component"); x, y, z = [float(t) for t in c.get("position").split()]
|
|
return 0.0 if y < -50 else y - min(N.values(), key=lambda n: (n["x"] - x) ** 2 + (n["z"] - z) ** 2)["y"]
|
|
|
|
|
|
def place(v, p_wp, e, root_along):
|
|
tx = N[p_wp]["x"] + root_along * math.sin(e); tz = N[p_wp]["z"] + root_along * math.cos(e)
|
|
ground = min(N.values(), key=lambda n: (n["x"] - tx) ** 2 + (n["z"] - tz) ** 2)["y"] # banens højde ved roden
|
|
ty = ground + max(0.0, min(ground_offset(v), 2.5)) + 0.05
|
|
cs = v.findall("component"); p0 = [float(t) for t in cs[0].get("position").split()]
|
|
d = angn(e - heading(v))
|
|
for c in cs:
|
|
q = [float(t) for t in c.get("position").split()]; r = [float(t) for t in c.get("rotation").split()]
|
|
rx, rz = q[0] - p0[0], q[2] - p0[2]
|
|
nx = tx + rx * math.cos(d) + rz * math.sin(d); nz = tz - rx * math.sin(d) + rz * math.cos(d)
|
|
c.set("position", "%.3f %.3f %.3f" % (nx, q[1] - p0[1] + ty, nz))
|
|
r[1] = (r[1] + math.degrees(d) + 180) % 360 - 180
|
|
c.set("rotation", "%.2f %.2f %.2f" % tuple(r))
|
|
|
|
|
|
# båse: tættest på vejen (størst z) først
|
|
west = sorted(range(399, 423), key=lambda i: -N[mk[i]["wp"]]["z"])
|
|
east = sorted(range(363, 399), key=lambda i: -N[mk[i]["wp"]]["z"])
|
|
for i in west + east:
|
|
assert re.fullmatch(r"\d+_mapMarker", mk[i]["name"]), (i, mk[i]["name"])
|
|
|
|
movers = [v for v in vehicles if fname(v) not in SKIP_FILES]
|
|
motors = sorted([v for v in movers if fname(v) in MOTOR_FILES], key=lambda v: (MOTOR_ORDER.index(fname(v)), mk[park_of(v)]["name"] if park_of(v) else "~", adname(v)))
|
|
tools = sorted([v for v in movers if fname(v) not in MOTOR_FILES], key=lambda v: (fname(v), mk[park_of(v)]["name"] if park_of(v) else "~"))
|
|
assert len(motors) <= len(west) and len(tools) <= len(east), (len(motors), len(tools))
|
|
|
|
renames, freed, pending, req, log = {}, [], [], {}, []
|
|
|
|
|
|
def keeps_old_name(v):
|
|
old = park_of(v)
|
|
return old is not None and mk[old]["group"] != GROUP and not re.fullmatch(r"P Ledig \d+", mk[old]["name"])
|
|
|
|
|
|
NEW_TOTAL = {}
|
|
for x in movers:
|
|
if not keeps_old_name(x):
|
|
NEW_TOTAL[NEW_NAME[fname(x)]] = NEW_TOTAL.get(NEW_NAME[fname(x)], 0) + 1
|
|
counters = {}
|
|
ledig = max([int(m.group(1)) for m in (re.fullmatch(r"(?:Connect )?P Ledig (\d+)", x["name"]) for x in mk.values()) if m] or [0])
|
|
|
|
|
|
def new_name(v):
|
|
old = park_of(v)
|
|
if old is not None and mk[old]["group"] != GROUP and not re.fullmatch(r"P Ledig \d+", mk[old]["name"]):
|
|
return mk[old]["name"][2:], old
|
|
base = NEW_NAME[fname(v)]
|
|
counters[base] = counters.get(base, 0) + 1
|
|
total = NEW_TOTAL[base]
|
|
return (f"{base} {counters[base]}" if total > 1 else base), None
|
|
|
|
|
|
for slot, v in list(zip(west, motors)) + list(zip(east, tools)):
|
|
name, old = new_name(v)
|
|
renames[slot] = "P " + name
|
|
if old is not None:
|
|
freed.append(old)
|
|
set_park(v, slot)
|
|
line = f"{adname(v) or fname(v):26s} -> mm{slot} 'P {name}'"
|
|
if v in tools:
|
|
pw = mk[slot]["wp"]; e = bay_axis(pw)
|
|
L, lo = size_of(v)
|
|
d = REAR_GAP + L + (MOUNTED_GAP if fname(v) in MOUNTED_FILES else 0.0)
|
|
u, w, du = split_point_on_track(pw, e, d)
|
|
req.setdefault((u, w), set()).add(du)
|
|
pending.append((slot, name, (u, w, du)))
|
|
if v.get("uniqueId") in parent:
|
|
line += f" Connect {d:.1f} m (sidder på '{adname(VR.find(f'.//vehicle[@uniqueId=\"{parent[v.get('uniqueId')]}\"]'))}' — sættes af ved parkering)"
|
|
else:
|
|
place(v, pw, e, REAR_GAP - lo + L / 2)
|
|
line += f" Connect {d:.1f} m, stillet ind i båsen"
|
|
log.append(line)
|
|
|
|
# frigjorte Farm 130-pladser -> 'P Ledig N' (+ deres Connect)
|
|
for old in freed:
|
|
ledig += 1
|
|
oldname = mk[old]["name"]
|
|
renames[old] = f"P Ledig {ledig}"
|
|
c = byname.get(("connect " + oldname).lower())
|
|
if c is not None:
|
|
renames[c] = f"Connect P Ledig {ledig}"
|
|
log.append(f"frigjort: '{oldname}' -> 'P Ledig {ledig}'" + (" (+ Connect)" if c is not None else ""))
|
|
|
|
# ubrugte nye båse: 'P Ledig N' i parkeringsmappen (vest først, så øst — tættest på vejen først)
|
|
for slot in west + east:
|
|
if slot not in renames:
|
|
ledig += 1
|
|
renames[slot] = f"P Ledig {ledig}"
|
|
log.append(f"ledig: mm{slot} -> 'P Ledig {ledig}'")
|
|
|
|
made = apply_splits(N, req)
|
|
write(doc, SG + "AutoDrive_config.xml.new")
|
|
raw = open(SG + "AutoDrive_config.xml.new", "rb").read()
|
|
bom = raw.startswith(b"\xef\xbb\xbf"); s = raw.decode("utf-8-sig")
|
|
for slot, new in renames.items():
|
|
grp = GROUP if slot in west or slot in east else None
|
|
pat = r"(<mm%d>\s*<id>[\d.]+</id>\s*<name>)[^<]*(</name>\s*<group>)([^<]*)(</group>)" % slot
|
|
s, n = re.subn(pat, (lambda m, new=new, grp=grp: m.group(1) + new + m.group(2) + (grp or m.group(3)) + m.group(4)), s)
|
|
assert n == 1, slot
|
|
nxt = max(mk) + 1; add = ""
|
|
for slot, name, key in pending:
|
|
add += (" <mm%d>\r\n <id>%d.000000</id>\r\n <name>Connect P %s</name>\r\n"
|
|
" <group>%s</group>\r\n </mm%d>\r\n") % (nxt, made[key], name, GROUP, nxt)
|
|
nxt += 1
|
|
i = s.rfind(" </mapmarker>"); s = s[:i] + add + s[i:]
|
|
open(SG + "AutoDrive_config.xml.new", "wb").write((b"\xef\xbb\xbf" if bom else b"") + s.encode("utf-8"))
|
|
body = ET.tostring(VR, encoding="unicode").replace("\r\n", "\n").replace("\n", "\r\n")
|
|
open(SG + "vehicles.xml.new", "wb").write(b"\xef\xbb\xbf" + ('<?xml version="1.0" encoding="utf-8" standalone="no"?>\r\n' + body + "\r\n").encode("utf-8"))
|
|
print("\n".join(log)); print(f"{len(motors)} med motor, {len(tools)} redskaber, {len(pending)} Connect, {len(freed)} frigjort; skrevet .new")
|