497 lines
20 KiB
Python
497 lines
20 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""救护车一次性生成器 (v3，支持多车型)：
|
||
对 CARS 里的每个车型：
|
||
1) 依据其源模型（用户原始模型，已按网易规则做过 X 镜像）逐立方体做层级变换，
|
||
得到世界空间 AABB。关键：网易方块实体的渲染映射为 world = (-geo_x/16, geo_y/16, geo_z/16)，
|
||
即 X 轴镜像；因此碰撞检测必须使用镜像后的世界坐标。
|
||
2) 对 4 个车体旋转角 φ(0/90/180/270) 分别求「每格与车体的交集 AABB」，量化到 1/QUANT 格并去重；
|
||
几何体根骨骼 Y 角设为 90 - φ（才能得到世界旋转 φ），并把整车居中到主方块中心、车底贴地。
|
||
3) 生成：每个车型一份预旋转几何体（4 条，按朝向）、4 个主方块 + 若干形状共享占位方块；
|
||
汇总生成 blocks.json、terrain_texture.json，并把布局数据写入 ambulanceServer.py 末尾。
|
||
|
||
车型命名规则（tag）：
|
||
主方块 dn_sa:<tag>_main_<yaw>
|
||
占位方块 dn_sa:<tag>_ph_<NN> （形状共享，仅提供碰撞）
|
||
几何体 geometry.dn_sa_<tag>_<yaw> -> resource_pack/models/entity/<tag>_geo.json
|
||
client_entity entity/<tag>_main_<yaw>_block_entity.json
|
||
"""
|
||
import json
|
||
import math
|
||
import os
|
||
import io
|
||
|
||
ROOT = r"e:\MCStudioDownload\work\3027246179@qq.com\Cpp\AddOn\0aaaa4f2f16c46e8964025a5ab0ecc02"
|
||
BP = os.path.join(ROOT, "behavior_pack_kcH4M5u0")
|
||
RP = os.path.join(ROOT, "resource_pack_t7eJjrxY")
|
||
BEH_BLOCKS_DIR = os.path.join(BP, "netease_blocks")
|
||
ENTITY_DIR = os.path.join(RP, "entity")
|
||
MODELS_DIR = os.path.join(RP, r"models\entity")
|
||
|
||
# ---------------------------------------------------------------- 车型配置
|
||
# tag 决定所有资源的命名；src 是源模型；tex 是该车的整车贴图（client_entity 用）
|
||
CARS = [
|
||
{
|
||
"item": "dn_sa:ambulance_car",
|
||
"tag": "ambulance_car",
|
||
"src": os.path.join(ROOT, "_gen_amb_src.geo.json"),
|
||
"tex": "textures/blocks/ambulance_car",
|
||
},
|
||
{
|
||
"item": "dn_sa:ambulance_car_broken",
|
||
"tag": "ambulance_car_broken",
|
||
"src": os.path.join(ROOT, "_gen_amb_src_broken.geo.json"),
|
||
"tex": "textures/blocks/ambulance_broken",
|
||
},
|
||
{
|
||
"item": "dn_sa:ambulance_car_destroyed",
|
||
"tag": "ambulance_car_destroyed",
|
||
"src": os.path.join(ROOT, "_gen_amb_src_destroyed.geo.json"),
|
||
"tex": "textures/blocks/ambulance_destroyed",
|
||
},
|
||
]
|
||
|
||
# 模型原点(0,0,0) 对应的主方块格上的位置（最小角）。若游戏内整车整体偏移，改这里即可。
|
||
ANCHOR = (0.0, 0.0, 0.0)
|
||
QUANT = 8 # 碰撞盒量化精度：1/8 格（约 2 个贴图像素）
|
||
YAWS = (0, 90, 180, 270) # 车体在世界空间的旋转角 φ（几何体根骨骼 Y 角 = 90 - φ）
|
||
|
||
# 玩家朝向象限(0=南+Z,90=西-X,180=北-Z,270=东+X) -> 车体世界旋转角 φ
|
||
# 依据：φ=0 时车头(capo)朝 -X；把 -X 经 Ry(φ) 转到玩家朝向
|
||
EXTRA_BY_FACING = {0: 90, 90: 0, 180: 270, 270: 180}
|
||
|
||
# 「车体局部格」(φ=0 坐标系，相对主方块的偏移) —— 这些格子不生成占位方块。
|
||
# 1) 挡风玻璃前上方 / 引擎盖正上方那一片：玻璃是斜的(rot -60)，它的整体包围盒把它前上方
|
||
# 那几格也算了进去，但那里几乎全是空气，碰撞盒会悬在车外。
|
||
# 2) 引擎盖最前面(x=-3) 顶层(y=2)：该层只有车头那 0.3 格高的一小条，比它后面一格
|
||
# (x=-2 顶层已被剔除) 高出来一截，看起来像引擎盖前端多出一块，一并剔除。
|
||
# 3) 警灯上方(x=-1) 顶层(y=3)：驾驶室顶只有 2.79 高、警灯顶 3.02，这一层(3.0~3.5)全部
|
||
# 来自斜挡风玻璃包围盒的溢出，正好悬在警灯上方，看起来像警灯位置高出来一块。
|
||
SKIP_LOCAL = {
|
||
(-2, 2, -1), (-2, 2, 0), (-2, 2, 1),
|
||
(-2, 3, -1), (-2, 3, 0), (-2, 3, 1),
|
||
(-3, 2, -1), (-3, 2, 0), (-3, 2, 1),
|
||
(-1, 3, -1), (-1, 3, 0), (-1, 3, 1),
|
||
}
|
||
|
||
BLANK_MODEL = "dn_sa:ambulance_blank_model"
|
||
|
||
# 主方块碰撞盒模式（网易方块实体的模型可见性跟着「方块所在位置」走，主方块碰撞盒太小时，
|
||
# 玩家把屏幕转开、方块位置离开视野，整车的实体模型就会停止渲染而消失）：
|
||
# "model"：给主方块一个涵盖整车的碰撞盒（解决上述消失问题）
|
||
# "cell" ：只用主方块自己那一格的碰撞盒（旧行为，其余碰撞靠占位方块）
|
||
MAIN_BOX_MODE = "model"
|
||
|
||
|
||
def model_box(bones, anchor):
|
||
"""整车在世界空间（相对主方块）的包围盒 (lo, hi)。"""
|
||
boxes = world_boxes(bones, False) # 含零厚度面片，才能真的涵盖整个模型
|
||
lo = [min(bx[0][i] for bx in boxes) + anchor[i] for i in range(3)]
|
||
hi = [max(bx[1][i] for bx in boxes) + anchor[i] for i in range(3)]
|
||
return lo, hi
|
||
|
||
|
||
def skip_cells(phi):
|
||
"""把车体局部格按 yaw 旋转成世界格（与几何体同向）。"""
|
||
out = set()
|
||
for (x, y, z) in SKIP_LOCAL:
|
||
if phi == 0:
|
||
ax, az = x, z
|
||
elif phi == 90:
|
||
ax, az = z, -x
|
||
elif phi == 180:
|
||
ax, az = -x, -z
|
||
else:
|
||
ax, az = -z, x
|
||
out.add((ax, y, az))
|
||
return out
|
||
|
||
|
||
# ---------------------------------------------------------------- math
|
||
def mat_mul(a, b):
|
||
return [[sum(a[i][k] * b[k][j] for k in range(3)) for j in range(3)] for i in range(3)]
|
||
|
||
|
||
def rot_axis(axis, deg):
|
||
t = math.radians(deg)
|
||
c, s = math.cos(t), math.sin(t)
|
||
if axis == 'x':
|
||
return [[1, 0, 0], [0, c, -s], [0, s, c]]
|
||
if axis == 'y':
|
||
return [[c, 0, s], [0, 1, 0], [-s, 0, c]]
|
||
return [[c, -s, 0], [s, c, 0], [0, 0, 1]]
|
||
|
||
|
||
def euler(rx, ry, rz):
|
||
m = rot_axis('y', ry)
|
||
m = mat_mul(m, rot_axis('x', rx))
|
||
m = mat_mul(m, rot_axis('z', rz))
|
||
return m
|
||
|
||
|
||
def apply(m, v, pivot):
|
||
d = [v[i] - pivot[i] for i in range(3)]
|
||
return [sum(m[i][k] * d[k] for k in range(3)) + pivot[i] for i in range(3)]
|
||
|
||
|
||
def cube_corners(cube):
|
||
o = cube['origin']
|
||
s = cube['size']
|
||
pt = cube.get('pivot', [0, 0, 0])
|
||
pts = [[o[0] + s[0] * dx, o[1] + s[1] * dy, o[2] + s[2] * dz]
|
||
for dx in (0, 1) for dy in (0, 1) for dz in (0, 1)]
|
||
rot = cube.get('rotation')
|
||
if rot and any(abs(v) > 1e-9 for v in rot):
|
||
m = euler(rot[0], rot[1], rot[2])
|
||
pts = [apply(m, p, pt) for p in pts]
|
||
return pts
|
||
|
||
|
||
def bone_world(by_name, bone, p):
|
||
b = bone
|
||
while b is not None:
|
||
rot = b.get('rotation')
|
||
if rot and any(abs(v) > 1e-9 for v in rot):
|
||
m = euler(rot[0], rot[1], rot[2])
|
||
p = apply(m, p, b.get('pivot', [0, 0, 0]))
|
||
b = by_name.get(b.get('parent'))
|
||
return p
|
||
|
||
|
||
def world_boxes(bones, skip_degenerate=True):
|
||
by_name = {b['name']: b for b in bones}
|
||
out = []
|
||
for b in bones:
|
||
for cube in b.get('cubes', []):
|
||
pts = [bone_world(by_name, b, p) for p in cube_corners(cube)]
|
||
# 网易方块实体：世界 X = -几何体 X（镜像），Y/Z 不变
|
||
pts = [[-p[0] / 16.0, p[1] / 16.0, p[2] / 16.0] for p in pts]
|
||
lo = [min(p[i] for p in pts) for i in range(3)]
|
||
hi = [max(p[i] for p in pts) for i in range(3)]
|
||
if skip_degenerate and (hi[0] - lo[0] < 1e-9 or hi[1] - lo[1] < 1e-9
|
||
or hi[2] - lo[2] < 1e-9):
|
||
continue # 零厚度面片不产生碰撞
|
||
out.append((lo, hi))
|
||
return out
|
||
|
||
|
||
def cells_for(boxes, anchor):
|
||
cells = {}
|
||
for lo, hi in boxes:
|
||
lo = [lo[i] + anchor[i] for i in range(3)]
|
||
hi = [hi[i] + anchor[i] for i in range(3)]
|
||
for ix in range(int(math.floor(lo[0])), int(math.floor(hi[0] - 1e-9)) + 1):
|
||
for iy in range(int(math.floor(lo[1])), int(math.floor(hi[1] - 1e-9)) + 1):
|
||
for iz in range(int(math.floor(lo[2])), int(math.floor(hi[2] - 1e-9)) + 1):
|
||
key = (ix, iy, iz)
|
||
l = [max(lo[0], ix), max(lo[1], iy), max(lo[2], iz)]
|
||
h = [min(hi[0], ix + 1), min(hi[1], iy + 1), min(hi[2], iz + 1)]
|
||
if key not in cells:
|
||
cells[key] = [l, h]
|
||
else:
|
||
pl, ph = cells[key]
|
||
cells[key] = [[min(pl[i], l[i]) for i in range(3)],
|
||
[max(ph[i], h[i]) for i in range(3)]]
|
||
return cells
|
||
|
||
|
||
def q(v, quant):
|
||
return round(v * quant) / float(quant)
|
||
|
||
|
||
def local_aabb(cell, l, h, quant=QUANT):
|
||
"""返回该格内 0~1 的局部 AABB（量化 1/quant），退化则返回 None。"""
|
||
lo = [min(1.0, max(0.0, q(l[i] - cell[i], quant))) for i in range(3)]
|
||
hi = [min(1.0, max(0.0, q(h[i] - cell[i], quant))) for i in range(3)]
|
||
if any(hi[i] - lo[i] <= 1e-6 for i in range(3)):
|
||
return None
|
||
return tuple(lo + hi)
|
||
|
||
|
||
# ---------------------------------------------------------------- per-car 计算
|
||
def load_model(path):
|
||
with io.open(path, 'r', encoding='utf-8') as f:
|
||
raw = json.load(f)
|
||
geo = raw['minecraft:geometry'][0]
|
||
root = [b['name'] for b in geo['bones'] if 'parent' not in b][0]
|
||
return geo, root
|
||
|
||
|
||
def bones_for_yaw(base_geo, root_name, phi):
|
||
"""车体世界旋转 φ 时对应的几何体骨骼：根骨骼 Y=90-φ，并把整车居中到主方块中心、车底贴地。"""
|
||
bones = json.loads(json.dumps(base_geo['bones']))
|
||
for b in bones:
|
||
if b['name'] == root_name:
|
||
r = list(b.get('rotation', [0, 0, 0]))
|
||
b['rotation'] = [r[0], r[1] - phi, r[2]]
|
||
# 求世界包围盒（已含 X 镜像，含零厚度面片），据此算居中/贴地平移量
|
||
boxes = world_boxes(bones, False)
|
||
lo = [min(bx[0][i] for bx in boxes) for i in range(3)]
|
||
hi = [max(bx[1][i] for bx in boxes) for i in range(3)]
|
||
cx = (lo[0] + hi[0]) / 2.0
|
||
cz = (lo[2] + hi[2]) / 2.0
|
||
tw = (0.5 - cx, -lo[1], 0.5 - cz) # 期望世界平移：X/Z 居中，车底 y=0
|
||
shift = [-16.0 * tw[0], 16.0 * tw[1], 16.0 * tw[2]] # 几何体空间平移 Δ = 16*diag(-1,1,1)*tw
|
||
for b in bones:
|
||
p = b.get('pivot', [0, 0, 0])
|
||
b['pivot'] = [p[i] + shift[i] for i in range(3)]
|
||
for c in b.get('cubes', []):
|
||
o = c['origin']
|
||
c['origin'] = [o[i] + shift[i] for i in range(3)]
|
||
if 'pivot' in c: # 立方体自带旋转轴心也需平移，否则非纯平移
|
||
cp = c['pivot']
|
||
c['pivot'] = [cp[i] + shift[i] for i in range(3)]
|
||
return bones
|
||
|
||
|
||
def wjson(path, obj):
|
||
with io.open(path, 'w', encoding='utf-8') as f:
|
||
f.write(json.dumps(obj, indent=2, ensure_ascii=False))
|
||
f.write(u"\n")
|
||
|
||
|
||
def block_json(identifier, aabb):
|
||
lo, hi = aabb
|
||
return {
|
||
"format_version": "1.10.0",
|
||
"minecraft:block": {
|
||
"description": {
|
||
"identifier": identifier,
|
||
"register_to_creative_menu": False,
|
||
"is_experimental": False,
|
||
"category": "dn_sa",
|
||
},
|
||
"components": {
|
||
"netease:solid": {"value": True},
|
||
"netease:render_layer": {"value": "alpha"},
|
||
"minecraft:destroy_time": {"value": 1.0},
|
||
"minecraft:block_light_absorption": {"value": 0},
|
||
"netease:aabb": {
|
||
"collision": {"min": list(lo), "max": list(hi)},
|
||
"clip": {"min": list(lo), "max": list(hi)},
|
||
},
|
||
},
|
||
},
|
||
}
|
||
|
||
|
||
# 清理可能残留的旧文件（旧命名 / 旧的占位方块 / 旧的渲染锚点方块与客户端实体）
|
||
for f in os.listdir(BEH_BLOCKS_DIR):
|
||
if not f.endswith(".json"):
|
||
continue
|
||
if f == "ambulance_car_main.json" or ("ambulance_car" in f and "_ph_" in f):
|
||
os.remove(os.path.join(BEH_BLOCKS_DIR, f))
|
||
for f in os.listdir(ENTITY_DIR):
|
||
if not f.endswith(".json"):
|
||
continue
|
||
if "ambulance_car" in f and f.endswith("_block_entity.json"):
|
||
os.remove(os.path.join(ENTITY_DIR, f))
|
||
old_ent = os.path.join(ENTITY_DIR, "ambulance_car_main_block_entity.json")
|
||
if os.path.exists(old_ent):
|
||
os.remove(old_ent)
|
||
|
||
results = []
|
||
for car in CARS:
|
||
tag = car["tag"]
|
||
main_prefix = "dn_sa:%s_main" % tag
|
||
ph_prefix = "dn_sa:%s_ph_" % tag
|
||
geo_id = "geometry.dn_sa_%s" % tag
|
||
base_geo, root_name = load_model(car["src"])
|
||
|
||
per_yaw = {} # yaw -> {cell: local_aabb}（逐格碰撞盒）
|
||
yaw_bones = {} # yaw -> 已旋转/居中/贴地的骨骼
|
||
main_box = {} # yaw -> 整车包围盒（主方块「涵盖整个模型」碰撞盒）
|
||
shapes = {} # local_aabb -> None（形状共享）
|
||
for yaw in YAWS:
|
||
bones = bones_for_yaw(base_geo, root_name, yaw)
|
||
yaw_bones[yaw] = bones
|
||
cells = cells_for(world_boxes(bones), ANCHOR)
|
||
skip = skip_cells(yaw)
|
||
table = {}
|
||
removed = []
|
||
for cell, (l, h) in sorted(cells.items()):
|
||
if cell in skip:
|
||
removed.append(cell)
|
||
continue
|
||
la = local_aabb(cell, l, h)
|
||
if la is None:
|
||
continue
|
||
table[cell] = la
|
||
per_yaw[yaw] = table
|
||
main_box[yaw] = model_box(bones, ANCHOR)
|
||
for la in table.values():
|
||
shapes.setdefault(la, None)
|
||
print("[%s] yaw=%3d cells=%3d shapes=%3d removed=%s"
|
||
% (tag, yaw, len(table), len(set(table.values())), removed))
|
||
|
||
# 形状共享占位方块命名（每种「格内碰撞盒」一个变体，被多格复用）
|
||
names = {}
|
||
for i, shape in enumerate(sorted(shapes.keys())):
|
||
names[shape] = "%s%02d" % (ph_prefix, i)
|
||
# 每格最终方块名：主方块所在格用主方块，其余用形状共享占位方块
|
||
cellname = {}
|
||
for yaw in YAWS:
|
||
m = {}
|
||
for cell, la in per_yaw[yaw].items():
|
||
if cell == (0, 0, 0):
|
||
continue
|
||
m[cell] = names[la]
|
||
cellname[yaw] = m
|
||
print("[%s] placeholder shapes=%d" % (tag, len(names)))
|
||
|
||
# 1) 预旋转几何体：每个朝向一条，渲染整车
|
||
geos = []
|
||
for yaw in YAWS:
|
||
desc = dict(base_geo["description"])
|
||
desc["identifier"] = "%s_%d" % (geo_id, yaw)
|
||
geos.append({"description": desc, "bones": yaw_bones[yaw]})
|
||
wjson(os.path.join(MODELS_DIR, "%s_geo.json" % tag),
|
||
{"format_version": "1.21.0", "minecraft:geometry": geos})
|
||
|
||
# 2) client_entity：每个朝向一份，渲染整车
|
||
for yaw in YAWS:
|
||
name = "%s_%d" % (main_prefix, yaw)
|
||
ent = {
|
||
"format_version": "1.10.0",
|
||
"minecraft:client_entity": {
|
||
"description": {
|
||
"identifier": name,
|
||
"geometry": {"default": "%s_%d" % (geo_id, yaw)},
|
||
"textures": {"default": car["tex"]},
|
||
"materials": {"default": "entity_alphatest"},
|
||
"render_controllers": [
|
||
{"controller.render.dn_sa_ambulance_car_main": "variable.variant == 0"}
|
||
],
|
||
"scripts": {"initialize": ["variable.variant = 0;"]},
|
||
}
|
||
},
|
||
}
|
||
wjson(os.path.join(ENTITY_DIR, "%s_main_%d_block_entity.json" % (tag, yaw)), ent)
|
||
|
||
# 3) 方块定义：主方块（带 block_entity） + 形状共享占位方块
|
||
for yaw in YAWS:
|
||
name = "%s_%d" % (main_prefix, yaw)
|
||
if MAIN_BOX_MODE == "model":
|
||
lo, hi = main_box[yaw] # 一个碰撞盒涵盖整车
|
||
else:
|
||
la = per_yaw[yaw].get((0, 0, 0)) or (0.0, 0.0, 0.0, 1.0, 1.0, 1.0)
|
||
lo, hi = la[:3], la[3:]
|
||
obj = block_json(name, (lo, hi))
|
||
obj["minecraft:block"]["components"]["netease:block_entity"] = {"tick": False, "movable": False}
|
||
wjson(os.path.join(BEH_BLOCKS_DIR, "%s_main_%d.json" % (tag, yaw)), obj)
|
||
for shape, name in sorted(names.items(), key=lambda kv: kv[1]):
|
||
short = name.split(":", 1)[1]
|
||
wjson(os.path.join(BEH_BLOCKS_DIR, short + ".json"),
|
||
block_json(name, (shape[:3], shape[3:])))
|
||
|
||
results.append({
|
||
"item": car["item"], "tag": tag, "tex": car["tex"],
|
||
"main_prefix": main_prefix, "ph_prefix": ph_prefix,
|
||
"cellname": cellname, "names": names,
|
||
})
|
||
print("[%s] wrote geo + %d client_entity + %d block defs"
|
||
% (tag, len(YAWS), len(YAWS) + len(names)))
|
||
|
||
|
||
# ---------------------------------------------------------------- blocks.json
|
||
blocks = {"format_version": [1, 1, 0]}
|
||
blocks["dn_sa:generator"] = {
|
||
"sound": "stone",
|
||
"client_entity": {
|
||
"identifier": "dn_sa:generator",
|
||
"hand_model_use_client_entity": True,
|
||
"destroyed_textures": "dn_sa:generator_icon",
|
||
"block_icon": "dn_sa:generator_icon",
|
||
},
|
||
}
|
||
blocks["dn_sa:salvage_bin"] = {
|
||
"sound": "stone",
|
||
"client_entity": {
|
||
"identifier": "dn_sa:salvage_bin",
|
||
"hand_model_use_client_entity": True,
|
||
"destroyed_textures": "dn_sa:salvage_bin_icon",
|
||
"block_icon": "dn_sa:salvage_bin_icon",
|
||
},
|
||
}
|
||
for car in results:
|
||
for yaw in YAWS:
|
||
name = "%s_%d" % (car["main_prefix"], yaw)
|
||
blocks[name] = {
|
||
"sound": "stone",
|
||
"client_entity": {
|
||
"identifier": name,
|
||
"hand_model_use_client_entity": True,
|
||
"destroyed_textures": car["item"],
|
||
"block_icon": car["item"],
|
||
},
|
||
}
|
||
for car in results:
|
||
for shape, name in sorted(car["names"].items(), key=lambda kv: kv[1]):
|
||
blocks[name] = {"sound": "stone", "netease_model": BLANK_MODEL}
|
||
wjson(os.path.join(RP, "blocks.json"), blocks)
|
||
print("wrote blocks.json (%d entries)" % len(blocks))
|
||
|
||
|
||
# ---------------------------------------------------------------- terrain_texture.json
|
||
tt_path = os.path.join(RP, r"textures\terrain_texture.json")
|
||
with io.open(tt_path, 'r', encoding='utf-8') as f:
|
||
tt = json.load(f)
|
||
td = tt["texture_data"]
|
||
for legacy in ("dn_sa_ambulance_car_main", "dn_sa_ambulance_car_placeholder"):
|
||
td.pop(legacy, None)
|
||
for key in [k for k in td if k.startswith("dn_sa:ambulance") and "_ph_a" in k]:
|
||
td.pop(key, None) # 清掉上一次生成的渲染锚点贴图条目
|
||
for car in results:
|
||
td["dn_sa_%s" % car["tag"]] = {"textures": car["tex"]} # 方块破坏/图标贴图
|
||
for yaw in YAWS:
|
||
td["%s_%d" % (car["main_prefix"], yaw)] = {"textures": "textures/blocks/dn_sa_blank"}
|
||
wjson(tt_path, tt)
|
||
print("wrote terrain_texture.json")
|
||
|
||
|
||
# ---------------------------------------------------------------- 注入碰撞数据到 ambulanceServer.py
|
||
MARKER = u"# ==== AUTO-GENERATED LAYOUT DATA (by _gen_amb.py, do not edit) ===="
|
||
lines = []
|
||
lines.append(u"")
|
||
lines.append(MARKER)
|
||
lines.append(u"# 玩家朝向象限(0=南+Z,90=西-X,180=北-Z,270=东+X) -> 车体额外 Y 旋转角")
|
||
lines.append(u"EXTRA_BY_FACING = {")
|
||
for k in sorted(EXTRA_BY_FACING):
|
||
lines.append(u" %d: %d," % (k, EXTRA_BY_FACING[k]))
|
||
lines.append(u"}")
|
||
lines.append(u"# 物品名 -> 车型数据")
|
||
lines.append(u"CARS = {}")
|
||
for car in results:
|
||
lines.append(u"CARS['%s'] = {" % car["item"])
|
||
lines.append(u" 'main_prefix': '%s'," % car["main_prefix"])
|
||
lines.append(u" 'ph_prefix': '%s'," % car["ph_prefix"])
|
||
lines.append(u" 'main': {")
|
||
for yaw in YAWS:
|
||
lines.append(u" %d: '%s_%d'," % (yaw, car["main_prefix"], yaw))
|
||
lines.append(u" },")
|
||
lines.append(u" 'cells': {")
|
||
for yaw in YAWS:
|
||
lines.append(u" %d: {" % yaw)
|
||
for cell in sorted(car["cellname"][yaw].keys()):
|
||
if cell == (0, 0, 0):
|
||
continue
|
||
lines.append(u" (%d, %d, %d): '%s',"
|
||
% (cell[0], cell[1], cell[2], car["cellname"][yaw][cell]))
|
||
lines.append(u" },")
|
||
lines.append(u" },")
|
||
lines.append(u"}")
|
||
data_block = u"\n".join(lines)
|
||
|
||
server_path = os.path.join(BP, r"Script_dn_sa\ambulanceServer.py")
|
||
with io.open(server_path, 'r', encoding='utf-8') as f:
|
||
content = f.read()
|
||
idx = content.find(MARKER)
|
||
if idx < 0:
|
||
raise RuntimeError("marker not found in ambulanceServer.py")
|
||
with io.open(server_path, 'w', encoding='utf-8') as f:
|
||
f.write(content[:idx] + data_block + u"\n")
|
||
print("injected layout data into ambulanceServer.py")
|
||
|
||
old_layout = os.path.join(BP, r"Script_dn_sa\ambulanceLayout.py")
|
||
if os.path.exists(old_layout):
|
||
os.remove(old_layout)
|
||
print("DONE") |