261 lines
14 KiB
Python
261 lines
14 KiB
Python
# Demobane i savegame4 (Golden Lands): AutoDrive-vejnet, markører, parkeringer, køretøjer, flows.
|
|
# Kør: python3 build_demo.py <savegame-mappe>
|
|
import sys, re, math, uuid
|
|
|
|
SG = sys.argv[1]
|
|
Y = 106.0
|
|
|
|
# ---------------- vejnet ----------------
|
|
xs, zs, flags, outs, ins = [], [], [], [], []
|
|
markers = [] # (navn, waypoint-id)
|
|
named = {} # (x,z) -> id for kryds
|
|
|
|
def node(x, z, flag=0):
|
|
key = (round(x, 2), round(z, 2))
|
|
if key in named:
|
|
return named[key]
|
|
xs.append(x); zs.append(z); flags.append(flag); outs.append([]); ins.append([])
|
|
named[key] = len(xs)
|
|
return len(xs)
|
|
|
|
def link(a, b):
|
|
if b not in outs[a-1]: outs[a-1].append(b)
|
|
if a not in ins[b-1]: ins[b-1].append(a)
|
|
|
|
def reverse_link(a, b):
|
|
# AutoDrive bak-kant: i a's out, IKKE i b's incoming (køres baglæns)
|
|
if b not in outs[a-1]: outs[a-1].append(b)
|
|
|
|
def road(points, flag=0, spacing=3.0, chamfer=5.0):
|
|
"""Polylinje gennem points (envejs i rækkefølge). Hjørner fases af (chamfer m) undtagen kryds-punkter."""
|
|
pts = [tuple(p) for p in points]
|
|
# afføjning af hjørner: indsæt punkter chamfer m før og efter hvert indre hjørne der ikke er et kryds
|
|
smooth = [pts[0]]
|
|
for i in range(1, len(pts) - 1):
|
|
(ax, az), (bx, bz), (cx, cz) = pts[i-1], pts[i], pts[i+1]
|
|
d1 = (bx-ax, bz-az); d2 = (cx-bx, cz-bz)
|
|
l1 = math.hypot(*d1); l2 = math.hypot(*d2)
|
|
cross = abs(d1[0]*d2[1] - d1[1]*d2[0]) / (l1*l2)
|
|
if cross > 0.3 and (round(bx, 2), round(bz, 2)) not in named and l1 > 2*chamfer and l2 > 2*chamfer:
|
|
smooth.append((bx - d1[0]/l1*chamfer, bz - d1[1]/l1*chamfer))
|
|
smooth.append((bx + d2[0]/l2*chamfer, bz + d2[1]/l2*chamfer))
|
|
else:
|
|
smooth.append((bx, bz))
|
|
smooth.append(pts[-1])
|
|
ids = []
|
|
for i in range(len(smooth) - 1):
|
|
(ax, az), (bx, bz) = smooth[i], smooth[i+1]
|
|
L = math.hypot(bx-ax, bz-az); n = max(1, int(round(L / spacing)))
|
|
for k in range(n):
|
|
f = k / n
|
|
ids.append(node(ax + (bx-ax)*f, az + (bz-az)*f, flag))
|
|
ids.append(node(*smooth[-1], flag))
|
|
for a, b in zip(ids, ids[1:]):
|
|
if a != b: link(a, b)
|
|
return ids
|
|
|
|
def at(x, z):
|
|
return named[(round(x, 2), round(z, 2))]
|
|
|
|
def marker(name, x, z):
|
|
# markøren ligger på et eksisterende vejpunkt nær (x,z)
|
|
best = min(range(len(xs)), key=lambda i: (xs[i]-x)**2 + (zs[i]-z)**2)
|
|
markers.append((name, best + 1))
|
|
return best + 1
|
|
|
|
# kryds-punkter registreres først (så hjørne-afføjning ikke flytter dem)
|
|
N_Z, S_Z, W_X, E_X = -865.0, -690.0, 95.0, 505.0
|
|
for x in (95, 116, 144, 190, 282, 317.64, 335, 355, 505): node(x, N_Z)
|
|
for x in (505, 441.98, 340, 317.64, 282, 270, 262, 250, 144, 116, 104, 95): node(x, S_Z)
|
|
for z in (-600, -620, -645, -668, -690, -728.1, -865): node(W_X, z)
|
|
node(E_X, -843.6)
|
|
|
|
# ringvej (med uret): nord mod øst, øst mod syd, syd mod vest, vest mod nord
|
|
road([(95, N_Z), (116, N_Z), (144, N_Z), (190, N_Z), (282, N_Z), (317.64, N_Z), (335, N_Z), (355, N_Z), (505, N_Z)])
|
|
road([(505, N_Z), (505, -843.6), (505, S_Z)])
|
|
road([(505, S_Z), (441.98, S_Z), (340, S_Z), (317.64, S_Z), (282, S_Z), (270, S_Z), (262, S_Z), (250, S_Z), (144, S_Z), (116, S_Z), (104, S_Z), (95, S_Z)])
|
|
road([(95, -600), (95, -620), (95, -645), (95, -668), (95, S_Z), (95, -728.1), (95, N_Z)])
|
|
|
|
# hønsehus: æg (vestsiden, mod syd) og foder + silo (østsiden, mod syd; silo-gren mod vest under siloen)
|
|
road([(116, N_Z), (116, S_Z)])
|
|
node(144, -728.1)
|
|
road([(144, N_Z), (144, -728.1), (144, S_Z)])
|
|
road([(144, -728.1), (95, -728.1)])
|
|
# fårestald: uld (sydsiden, mod øst)
|
|
road([(190, N_Z), (190, -799), (250, -799), (250, S_Z)])
|
|
# kostald: mælk (vest, mod syd) og gylle (øst, mod syd)
|
|
road([(282, N_Z), (282, S_Z)])
|
|
road([(317.64, N_Z), (317.64, S_Z)])
|
|
# palleskur: unload- og load-spor mod vest, ud ad x=270 mod syd
|
|
node(335, -795.8); node(270, -795.8); node(270, -788.1)
|
|
road([(335, N_Z), (335, -795.8), (335, -788.1)])
|
|
road([(335, -795.8), (270, -795.8)])
|
|
road([(335, -788.1), (270, -788.1)])
|
|
road([(270, -795.8), (270, -788.1), (270, S_Z)])
|
|
# biogasanlæg: gennem anlægget mod øst (gyllepunkt + punker), ud på østvejen
|
|
road([(355, N_Z), (375, -843.6), (505, -843.6)])
|
|
# mejeri: kør frem ind i båsen mod nord, bak ud igen (bak-kanter)
|
|
bay = road([(441.98, S_Z), (441.98, -708)], flag=1)
|
|
for a, b in zip(reversed(bay), list(reversed(bay))[1:]):
|
|
reverse_link(a, b)
|
|
# marker: sløjfe syd for gården (ud ad x=262, hjem ad x=104)
|
|
road([(262, S_Z), (262, -580), (104, -580), (104, S_Z)])
|
|
# parkeringer + Wait: indkørsel ad x=340 mod syd, sporene mod vest ud på vestvejen
|
|
road([(340, S_Z), (340, -668), (340, -645), (340, -620)], flag=1)
|
|
road([(340, -668), (95, -668)], flag=1)
|
|
road([(340, -645), (95, -645)], flag=1)
|
|
road([(340, -620), (95, -620)], flag=1)
|
|
|
|
# ---------------- markører ----------------
|
|
marker("Silo", 124, -728.1)
|
|
marker("Chicken Feed", 144, -806.5)
|
|
marker("Chicken Eggs", 116, -807)
|
|
marker("Sheep Wool", 234, -799)
|
|
marker("Cow Milk", 282, -735)
|
|
marker("Cow Slurry", 317.64, -727.6)
|
|
marker("Storage Unload", 291, -795.8)
|
|
marker("Storage Load", 286, -788.1)
|
|
marker("Dairy", 441.98, -708)
|
|
marker("Biogas", 443, -843.6)
|
|
marker("F52", 146, -580)
|
|
marker("F53", 239.5, -580)
|
|
for i, x in enumerate((310, 280, 225, 195, 165), 1):
|
|
marker("Wait %d" % i, x, -668)
|
|
|
|
SLOTS = [320, 298, 276, 240, 218, 196, 174, 152, 130]
|
|
# (filnavn-del, nummer blandt ens, markørnavn, spor-z, plads, kobling?)
|
|
PARK = [
|
|
("z18051", 1, "Tipper 1", -645, 0, True), ("z18051", 2, "Tipper 2", -645, 1, True),
|
|
("mks32", 1, "Milk Tank", -645, 2, True), ("supercis800", 1, "Slurry Tank", -645, 3, True),
|
|
("cenio4000", 1, "Cultivator", -645, 4, True), ("pov5xl", 1, "Plow", -645, 5, True),
|
|
("seeder1500", 1, "Seeder", -645, 6, True), ("maxima3TIL", 1, "Planter", -645, 7, True),
|
|
("k105", 1, "Spreader", -645, 8, True),
|
|
("crystal", 1, "Crystal", -620, 0, False), ("vario700", 1, "Vario 700", -620, 1, False),
|
|
("puma", 1, "Puma", -620, 2, False), ("multiPurposeTruck", 1, "Pallet Truck", -620, 3, False),
|
|
("mt655", 1, "MT655", -620, 4, False), ("series6RLarge", 1, "6R", -620, 5, False),
|
|
("t7", 1, "T7", -620, 6, False), ("series6C", 1, "6C", -620, 7, False),
|
|
]
|
|
park_marker = {}
|
|
for key, num, name, lz, slot, connect in PARK:
|
|
x = SLOTS[slot]
|
|
marker("P " + name, x, lz)
|
|
if connect: marker("Connect P " + name, x, lz)
|
|
park_marker[(key, num)] = len(markers) # 1-baseret indeks på P-markøren
|
|
if connect: park_marker[(key, num)] = len(markers) - 1
|
|
# øvrige (ingen AD): stilles i en række øst for parkeringen
|
|
YARD = {"evion450": (380, -625), "vario620": (395, -610), "diamant8": (410, -610), "weight650": (425, -610),
|
|
"rwgP13": (440, -610), "pickUp1150": (455, -625)}
|
|
|
|
# ---------------- forbindelseskontrol ----------------
|
|
def reach(s):
|
|
seen = {s}; q = [s]
|
|
while q:
|
|
i = q.pop()
|
|
for n in outs[i-1]:
|
|
if n not in seen: seen.add(n); q.append(n)
|
|
return seen
|
|
ids = [m[1] for m in markers]
|
|
bad = []
|
|
for name, i in markers:
|
|
r = reach(i)
|
|
miss = [n for n, j in markers if j not in r]
|
|
if miss: bad.append((name, miss[:4]))
|
|
print("vejpunkter", len(xs), "markører", len(markers), "uden fuld forbindelse:", bad[:6])
|
|
|
|
# ---------------- AutoDrive_config.xml ----------------
|
|
path = SG + "/AutoDrive_config.xml"
|
|
raw = open(path, encoding="utf-8-sig", newline="").read()
|
|
bom = open(path, "rb").read(3) == b"\xef\xbb\xbf"
|
|
nl = "\r\n" if "\r\n" in raw else "\n"
|
|
def lst(v): return ",".join(v)
|
|
wp = (nl + " <id>" + lst(str(i+1) for i in range(len(xs))) + "</id>"
|
|
+ nl + " <x>" + lst("%.3f" % v for v in xs) + "</x>"
|
|
+ nl + " <y>" + lst("%.3f" % Y for _ in xs) + "</y>"
|
|
+ nl + " <z>" + lst("%.3f" % v for v in zs) + "</z>"
|
|
+ nl + " <out>" + ";".join(",".join(map(str, o)) if o else "-1" for o in outs) + "</out>"
|
|
+ nl + " <incoming>" + ";".join(",".join(map(str, o)) if o else "-1" for o in ins) + "</incoming>"
|
|
+ nl + " <flags>" + lst(str(f) for f in flags) + "</flags>" + nl + " ")
|
|
raw = re.sub(r"(<waypoints>).*?(</waypoints>)", lambda m: m.group(1) + wp + m.group(2), raw, count=1, flags=re.S)
|
|
mm = nl + "".join(" <mm%d>%s <id>%d.000000</id>%s <name>%s</name>%s <group>All</group>%s </mm%d>%s"
|
|
% (k, nl, wid, nl, name, nl, nl, k, nl) for k, (name, wid) in enumerate(markers, 1)) + " "
|
|
raw = re.sub(r"(<mapmarker>).*?(</mapmarker>)", lambda m: m.group(1) + mm + m.group(2), raw, count=1, flags=re.S)
|
|
open(path, "w", encoding="utf-8-sig" if bom else "utf-8", newline="").write(raw)
|
|
|
|
# ---------------- køretøjer: flyt til pladser, vend mod vest, sæt parkering ----------------
|
|
vpath = SG + "/vehicles.xml"
|
|
vraw = open(vpath, encoding="utf-8-sig", newline="").read()
|
|
vbom = open(vpath, "rb").read(3) == b"\xef\xbb\xbf"
|
|
counts = {}
|
|
NEW_YAW = -90.0
|
|
def yaw_of(rot):
|
|
rx, ry, rz = [float(v) for v in rot.split()]
|
|
return 180.0 - ry if abs(rx) > 90 else ry
|
|
def place(block, cx, cz):
|
|
comps = re.findall(r'<component index="(\d+)" position="([^"]*)" rotation="([^"]*)"/>', block)
|
|
x0, y0, z0 = [float(v) for v in comps[0][1].split()]
|
|
t0 = math.radians(yaw_of(comps[0][2])); tn = math.radians(NEW_YAW)
|
|
def mv(m):
|
|
px, py, pz = [float(v) for v in m.group(2).split()]
|
|
dx, dz = px - x0, pz - z0
|
|
lx = dx*math.cos(t0) - dz*math.sin(t0); lz = dx*math.sin(t0) + dz*math.cos(t0)
|
|
nx = lx*math.cos(tn) + lz*math.sin(tn); nz = -lx*math.sin(tn) + lz*math.cos(tn)
|
|
return '<component index="%s" position="%.3f %.3f %.3f" rotation="0.00 %.2f 0.00"/>' % (m.group(1), cx+nx, py, cz+nz, NEW_YAW)
|
|
return re.sub(r'<component index="(\d+)" position="([^"]*)" rotation="([^"]*)"/>', mv, block)
|
|
uids = {}
|
|
def fix(m):
|
|
block = m.group(0)
|
|
fn = re.search(r'filename="([^"]*)"', block).group(1)
|
|
key = fn.split("/")[-1].replace(".xml", "")
|
|
counts[key] = counts.get(key, 0) + 1
|
|
num = counts[key]
|
|
uids[(key, num)] = re.search(r'uniqueId="([^"]*)"', block).group(1)
|
|
block = re.sub(r'\s*<AutoDrive [^>]*/>', '', block)
|
|
for pk, pnum, name, lz, slot, connect in PARK:
|
|
if pk == key and pnum == num:
|
|
x = SLOTS[slot]
|
|
cx = x + (9.0 if connect else 1.0) # redskab/vogn bag traktoren (øst), traktor på pladsen
|
|
block = place(block, cx, lz)
|
|
block = block.replace("</vehicle>", ' <AutoDrive parkDestination="%d"/>\n </vehicle>' % park_marker[(key, num)])
|
|
return block
|
|
if key in YARD:
|
|
return place(block, *YARD[key])
|
|
return block
|
|
vraw = re.sub(r'<vehicle\s.*?</vehicle>', fix, vraw, flags=re.S)
|
|
open(vpath, "w", encoding="utf-8-sig" if vbom else "utf-8", newline="").write(vraw)
|
|
|
|
# ---------------- bygningsnavne (engelsk), flows ----------------
|
|
pl = open(SG + "/placeables.xml", encoding="utf-8-sig").read()
|
|
puid = {fn.split("/")[-1].replace(".xml", ""): u for fn, u in re.findall(r'filename="([^"]*)" uniqueId="([^"]*)"', pl)}
|
|
names = {"farmSilo": "Demo Silo", "pigBarnSmall": "Demo Pig Barn", "cowBarnMedium": "Demo Cow Barn",
|
|
"chickenBarnBig": "Demo Chicken Coop", "sheepBarnBig": "Demo Sheep Barn", "objectStorage": "Demo Pallet Storage",
|
|
"dairyPlaceable": "Dairy", "bga500kw": "Biogas Plant"}
|
|
open(SG + "/ADSmartPickup_names.xml", "w", encoding="utf-8-sig", newline="\n").write(
|
|
'<?xml version="1.0" encoding="utf-8" standalone="no"?>\n<ADSmartPickupNames>\n'
|
|
+ "".join(' <building id="%s" name="%s"/>\n' % (puid[k], v) for k, v in names.items())
|
|
+ "</ADSmartPickupNames>\n")
|
|
mid = dict(markers)
|
|
def run(i, name, kind, sources, targets, stores, products, vehicle, wagon, target_marker="", extra=""):
|
|
w = ' wagons="%s=%s"' % (uids[vehicle], uids[wagon]) if wagon else ' wagons=""'
|
|
tgt = str(mid[target_marker]) if target_marker else ""
|
|
return (' <run id="%d" name="%s" target="%s" targets="%s" ingredientMode="auto" ingredients="" waitPool="" loops="0"'
|
|
' returnBelow="50" kind="%s" sources="" sourceBuildings="%s" targetBuildings="%s" storeBuildings="%s"'
|
|
' products="%s" sellAt="%s" storeAbove="80" sellAbove="0" minSource="%s" collectRound="%s" stopped="1" sleeping="0"%s>\n'
|
|
' <vehicle id="%s"/>\n </run>\n') % (i, name, tgt, tgt, kind, sources, targets, stores, products,
|
|
extra.get("sellAt", "90") if isinstance(extra, dict) else "90",
|
|
extra.get("minSource", "0") if isinstance(extra, dict) else "0",
|
|
extra.get("collectRound", "0") if isinstance(extra, dict) else "0", w, uids[vehicle])
|
|
runs = '<?xml version="1.0" encoding="utf-8" standalone="no"?>\n<ADSmartPickupRuns version="3">\n'
|
|
runs += run(1, "Chicken Feed", "supply", puid["farmSilo"], puid["chickenBarnBig"], "", "", ("crystal", 1), ("z18051", 1), "Chicken Feed")
|
|
runs += run(2, "Milk Sale", "outbound", puid["cowBarnMedium"], "", "", "MILK:sell", ("vario700", 1), ("mks32", 1), "", {"sellAt": "80", "minSource": "30"})
|
|
runs += run(3, "Slurry Sale", "outbound", puid["cowBarnMedium"], "", "", "LIQUIDMANURE:sell", ("puma", 1), ("supercis800", 1), "", {"sellAt": "80", "minSource": "30"})
|
|
runs += run(4, "Eggs and Wool", "outbound", puid["chickenBarnBig"] + " " + puid["sheepBarnBig"], "", puid["objectStorage"],
|
|
"EGG:store WOOL:store", ("multiPurposeTruck", 1), None, "", {"collectRound": "1"})
|
|
runs += "</ADSmartPickupRuns>\n"
|
|
open(SG + "/ADSmartPickup_runs.xml", "w", encoding="utf-8-sig", newline="\n").write(runs)
|
|
|
|
# hønsehuset får lidt foder (så foderflowet har arbejde fra start); gamle missioner væk (pegede på slettet salgssted)
|
|
pl2 = re.sub(r'(chickenBarnBig.xml".*?<fillLevel fillType="WHEAT" fillLevel=")[^"]*"', lambda m: m.group(1) + '3000.000000"', pl, count=1, flags=re.S)
|
|
open(SG + "/placeables.xml", "w", encoding="utf-8-sig", newline="\n").write(pl2)
|
|
open(SG + "/missions.xml", "w", encoding="utf-8-sig", newline="\n").write('<?xml version="1.0" encoding="utf-8" standalone="no"?>\n<missions version="0">\n</missions>\n')
|
|
print("færdig:", len(markers), "markører,", len(PARK), "parkeringer, 4 flows")
|