Search Results for

    Show / Hide Table of Contents

    从零制作你的第一辆坦克

    中文 | English

    在仓库根目录运行以下命令,用本机 Unity MCP 回放本页示例。 命令也会重拍两种语言的配图。

    python Docs/Manual/manual/tools/tutorials.py run vehicle-basics --capture
    
    点击展开 MCP 操作点击收起 MCP 操作

    准备教学样例。${变量} 由配方提供。

    {
      "variables": {
        "source": "Packages/com.shanghaiwindy.coreresources/BuiltInVehicles/PatriotRadar/BuiltIn-Patriot-Radar",
        "vehicleData": "${fixture}/Tutorial_NativeVehicleData.asset",
        "vehicleText": "${fixture}/Tutorial_NativeText.asset",
        "vehicleInfo": "${fixture}/Tutorial_NativeVehicleInfo.asset",
        "packModel": "${fixture}/Tutorial_NativePackModel.prefab",
        "vehicleName": "Docs-Vehicle-Basics-${runId}",
        "vehicleGuid": "2a1fb39dea694fdab732${runId}",
        "cooked": "${fixture}/2a1fb39dea694fdab732${runId}_pre.prefab",
        "package": "${fixture}/Docs_${runId}_Package.asset",
        "pipeline": "${fixture}/Docs_${runId}_Pipeline.asset",
        "packageGuid": "f2f8a67f-7edd-5f4d-9bc4-a53463120f09",
        "wheel": "${fixture}/Tutorial_WheelCollider.prefab",
        "track": "${fixture}/Tutorial_Track.asset",
        "link": "${fixture}/Tutorial_TrackLink.prefab",
        "armor": "${fixture}/Tutorial_TankHitBox.asset",
        "armorDraft": "${fixture}/Tutorial_TankHitBox_Setup.asset",
        "armorSource": "${fixture}/Tutorial_ArmorSource.prefab",
        "armorPrefab": "${fixture}/Tutorial_Armor.prefab",
        "bullet": "${fixture}/Tutorial-76mm-AP.asset",
        "gunSound": "Packages/com.shanghaiwindy.coreresources/FMod/Tank/Gun/76mm_zis5.asset",
        "engine": "Packages/com.shanghaiwindy.coreresources/FMod/Tank/Engine/kv220.asset",
        "bulletVfx": "Packages/com.shanghaiwindy.coreresources/BulletVFX/宝马鸽特效/AP-BulletVFX-M.asset",
        "moduleSource": "${fixture}/Tutorial_InternalSource.prefab"
      },
      "calls": [
        {
          "tool": "invoke",
          "arguments": {
            "path": "static:UnityEditor.AssetDatabase/CreateFolder",
            "args": [
              "${fixtureParent}",
              "${folder}"
            ]
          },
          "expect": {
            "contains": "(String)"
          }
        },
        {
          "tool": "invoke",
          "arguments": {
            "path": "static:UnityEditor.AssetDatabase/CreateAsset",
            "args": [
              "@static:UnityEngine.ScriptableObject/CreateInstance(ShanghaiWindy.Core.ModPackageData)",
              "${package}"
            ]
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        },
        {
          "tool": "invoke",
          "arguments": {
            "path": "static:UnityEditor.AssetDatabase/CreateAsset",
            "args": [
              "@static:UnityEngine.ScriptableObject/CreateInstance(ShanghaiWindy.Core.ModPackageBuildPiplineData)",
              "${pipeline}"
            ]
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        },
        {
          "tool": "inspect_set",
          "arguments": {
            "path": "asset:${package}/localizedModName/defaultName",
            "value": "Tutorial Package"
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        },
        {
          "tool": "inspect_set",
          "arguments": {
            "path": "asset:${package}/localizedDescription/defaultName",
            "value": "Documentation teaching package"
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        },
        {
          "tool": "inspect_set",
          "arguments": {
            "path": "asset:${package}/author",
            "value": "Documentation"
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        },
        {
          "tool": "inspect_set",
          "arguments": {
            "path": "asset:${package}/supportURL",
            "value": "https://doc.game.windyverse.net/"
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        },
        {
          "tool": "inspect_set",
          "arguments": {
            "path": "asset:${package}/guid",
            "value": "${packageGuid}"
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        },
        {
          "tool": "inspect_set",
          "arguments": {
            "path": "asset:${pipeline}/linkedModPackage",
            "value": "@asset:${package}"
          },
          "expect": {
            "contains": "OK:"
          },
          "phase": "build"
        }
      ]
    }
    

    本教程从 Blender 模型开始,制作、打包并试开一辆单炮塔履带车 Tutorial-Tank。参数表给出了首轮可照填的教学值。KV-2 的实图展示同一套节点与资产关系,最后可用它做试车对照。

    1. 准备工程、模型和声音

    1. 按 项目初始化 安装并打开 SDK 工程。使用 SDK 要求的 Unity 版本,等待 Console 中的编译错误解决后再打开模组工具。找不到工具菜单时先检查这一项。
    2. 在 Blender 中准备显示模型和独立的伤害模型。贴图可用 Substance 3D Painter、Photoshop 等工具制作。准备基本色和法线等贴图,以及引擎启动、怠速、运行与开火近声、远声。首次测试可以引用 SDK 中兼容的 FMOD 配置。
    3. 为这辆车在 Project 窗口建一个文件夹,再为模型、材质和碰撞预制体建立子目录。保留源文件,后续更新原有 FBX 时沿用原路径和 .meta,以保留 Unity 引用。

    2. 整理 Blender 模型并导出

    在 Blender 的 Outliner 中为载具保留一个根对象。选择子对象,再按住 Shift 选择它的父对象,通过 Ctrl+P → Object (Keep Transform) 建立父子关系。分离部件时可在 Edit Mode 选中该部件的面,再按 P → Selection。将部件原点放在实际转轴处,避免旋转时围绕车体原点公转。

    根对象下的节点 放入的对象与检查项
    MainBody 车体网格。
    Turret → Gun → Dym 炮塔、主炮俯仰节点、炮管后坐节点。炮塔原点在座圈中心,主炮原点在俯仰轴,炮管向车头伸出。三个节点逐层嵌套。
    LeftWheel、RightWheel 空的分组对象。负重轮分别命名 l_1、l_2…和 r_1、r_2…,原点在轮轴中心。
    LeftUpperWheel、RightUpperWheel 空的托带轮分组。将两侧托带轮放到各自分组,可分别用 lu_1、ru_1 编号。当前打包器会按前后位置重新排序轮子。
    LeftTrack、RightTrack 静态履带网格或对应的占位节点。后面还会为动态履带设置履带节和路径。
    1. 在 Blender 按实际尺寸建模,以米为单位。选中前述对象,点 File → Export → FBX。旧教程图中使用 Scale 1.00、Apply Scalings → FBX Units Scale、Forward → −Z Forward 和 Up → Y Up。导入 Unity 后确认 +Z 朝前、+Y 朝上,再用已知长度测量车体。轴向问题参见 Blender 轴向修正。
    2. 另存一份低面数的伤害模型。按装甲厚度、材质类型和活动部位拆开板件。在引擎中每块独立设置厚度,随炮塔、主炮或炮管转动的板件后续要挂在相应父节点。内部模块也要独立拆分。按伤害模型命名规范命名后导出。
    3. 小型入门载具可沿用旧指南的预算作为起点,显示模型约 2 万面以内、约 4 个材质、贴图 2048 × 2048 或更低,伤害模型约 5000 面以内。先合并重复材质、简化看不见的面和碰撞轮廓,保留可辨识的车体、炮塔与轮组。

    把 FBX 拖入 Unity 场景,展开模型根节点。下面是载具工程的 KV-2。先在 Hierarchy 找到 MainBody 与 Turret,再逐级展开 Turret → Gun → Dym,对照 Scene View 的部件位置。

    KV-2 在 Unity 中的车体、炮塔、俯仰轴和后坐节点定位

    KV-2
    ├── MainBody
    ├── Turret
    │   └── Gun
    │       └── Dym
    ├── LeftWheel / LeftUpperWheel / LeftTrack
    └── RightWheel / RightUpperWheel / RightTrack
    

    3. 在 Unity 中绑定材质和物理碰撞

    1. 将显示 FBX、伤害 FBX 和贴图拖进 Project。选中显示 FBX,在 Inspector 的 Model 页从 Scale Factor = 1 开始。沿用 FBX 文件单位,关闭 Generate Colliders,保留子节点层级。伤害 FBX 在 Model 页启用 Read/Write,便于生成伤害网格。点 Apply 后检查实例根缩放为 1, 1, 1,车头沿 +Z、炮口朝前。用长 1 米的参考立方体核对比例。
    2. 在 Project 右键 Create → Material,选工程支持的载具材质。把基本色图放进 Base Map,把法线贴图在导入设置中设为 Normal map 后填入法线槽。展开模型的 Mesh Renderer → Materials 按槽绑定车体、轮组和履带材质。载具表面应显示正常贴图。若为粉色,先查当前渲染管线与材质 Shader。
    3. 在 Hierarchy 展开模型。分别给车体和炮塔的实体网格添加 Box Collider,关闭 Is Trigger,点 Edit Collider 调整 Center 和 Size。从正面及侧面检查盒体:覆盖硬质车体,底边高于负重轮接地点,炮口与轮子留给各自的节点控制。
    4. 把模型根对象拖回 Project 的 Collision 文件夹,保存为预制体。后续 MainModel 引用这个预制体。用于击穿判定的板件由独立的伤害模型提供。
    点击展开 MCP 操作点击收起 MCP 操作

    用简单几何体重做完整的履带车层级。在保存碰撞预制体前检查车体碰撞、炮塔父子关系、前方和上方。

    [
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Core.AssetBundleManager/LuaEnv/DoString",
          "args": [
            "local U = CS.UnityEngine\nlocal E = CS.UnityEditor\nlocal function empty(name, parent, x, y, z)\n    local obj = U.GameObject(name)\n    if parent then obj.transform:SetParent(parent.transform, false) end\n    obj.transform.localPosition = U.Vector3(x, y, z)\n    return obj\nend\nlocal function cube(name, parent, x, y, z, sx, sy, sz)\n    local obj = U.GameObject.CreatePrimitive(U.PrimitiveType.Cube)\n    obj.name = name\n    obj.transform:SetParent(parent.transform, false)\n    obj.transform.localPosition = U.Vector3(x, y, z)\n    obj.transform.localScale = U.Vector3(sx, sy, sz)\n    return obj\nend\n\nlocal root = empty('TutorialTank', nil, 0, 0, 0)\ncube('MainBody', root, 0, 0.9, 0, 2.6, 0.75, 5)\nlocal turret = empty('Turret', root, 0, 1.55, 0)\ncube('TurretMesh', turret, 0, 0, 0, 1.8, 0.65, 1.6)\nlocal gun = empty('Gun', turret, 0, 0, 0.75)\ncube('GunMesh', gun, 0, 0, 0, 0.6, 0.34, 0.35)\nempty('GunSight', gun, 0.24, 0.2, 0.15)\nlocal barrel = empty('Dym', gun, 0, 0, 0)\ncube('BarrelMesh', barrel, 0, 0, 1.2, 0.17, 0.17, 2.4)\nfor _, side in ipairs({{'Left', 'l', -1.42}, {'Right', 'r', 1.42}}) do\n    local sideName, prefix, x = side[1], side[2], side[3]\n    local wheel = empty(sideName .. 'Wheel', root, 0, 0, 0)\n    local upperWheel = empty(sideName .. 'UpperWheel', root, 0, 0, 0)\n    for index, z in ipairs({1.8, 0.6, -0.6, -1.8}) do\n        local axis = empty(prefix .. '_' .. index, wheel, x, 0.43, z)\n        local mesh = U.GameObject.CreatePrimitive(U.PrimitiveType.Cylinder)\n        mesh.name = 'WheelMesh'\n        mesh.transform:SetParent(axis.transform, false)\n        mesh.transform.localRotation = U.Quaternion.Euler(0, 0, 90)\n        mesh.transform.localScale = U.Vector3(0.86, 0.17, 0.86)\n        U.Object.DestroyImmediate(mesh:GetComponent(typeof(U.Collider)))\n    end\n    empty(prefix .. 'u_1', upperWheel, x, 0.91, 0)\n    local track = cube(sideName .. 'Track', root, x, 0.45, 0, 0.34, 0.14, 4.6)\n    U.Object.DestroyImmediate(track:GetComponent(typeof(U.Collider)))\nend\nfor _, path in ipairs({'Turret/Gun/GunMesh', 'Turret/Gun/Dym/BarrelMesh'}) do\n    U.Object.DestroyImmediate(root.transform:Find(path):GetComponent(typeof(U.Collider)))\nend\nassert(root.transform:Find('MainBody'):GetComponent(typeof(U.BoxCollider)) ~= nil)\nassert(root.transform:Find('Turret/Gun/Dym') ~= nil)\nlocal target = E.PrefabUtility.SaveAsPrefabAsset(root, '${packModel}')\nU.Object.DestroyImmediate(root)\nassert(target ~= nil)\nreturn 'Ground-model hierarchy and physical hull created'\n",
            "tank-geometry",
            "null"
          ]
        },
        "expect": {
          "contains": "Ground-model"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${packModel}/transform/forward"
        },
        "expect": {
          "contains": "(Vector3) (0.00, 0.00, 1.00)"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${packModel}/transform/up"
        },
        "expect": {
          "contains": "(Vector3) (0.00, 1.00, 0.00)"
        }
      }
    ]
    

    4. 创建并核对载具数据

    1. 在 Unity 顶部打开 Framework - 框架 → 0. Home Page,点击载具制作引导。在引导的创建步骤点击打开,进入 GM 编辑器的载具 → 载具创建。也可直接在 GM 编辑器选择这个分类。
    2. 类型选择 Ground,输入唯一内部名,例如 Tutorial-Tank。当前创建工具接受英文大小写、数字和短横线。前缀可选,显示名稍后单独设置。点击创建载具,确认创建。
    3. 在 Project 打开 Assets/Res/Vehicles/Ground/Data/Vehicle/Tutorial-Tank/。对照下表核对生成的资产。把内部名填回制作向导可跳转到相应文件。
    生成的资产 在哪里使用
    Tutorial-Tank.asset(VehicleInfo) 设置显示名称、等级、国家、缩略图。最后把它拖入模组构建管线。
    Tutorial-Tank_VehicleHitBox.asset 绑定外部装甲、内部模块和生成的伤害预制体。
    Tutorial-Tank_VehicleTextData.asset 配置基础、移动、开火和炮塔参数。
    Tutorial-Tank_VehicleData.asset 汇总模型与数据,编辑关键节点,并生成载具预制体。
    Tutorial-Tank_WheelCollider.prefab 与 Tutorial-Tank_VehicleTrack.asset 给 移动参数提供轮碰撞与动态履带配置。
    点击展开 MCP 操作点击收起 MCP 操作
    [
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.AssetDatabase/CopyAsset",
          "args": [
            "${source}_VehicleData.asset",
            "${vehicleData}"
          ]
        },
        "expect": {
          "contains": "(Boolean) True"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.AssetDatabase/CopyAsset",
          "args": [
            "${source}_VehicleTextData.asset",
            "${vehicleText}"
          ]
        },
        "expect": {
          "contains": "(Boolean) True"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.AssetDatabase/CopyAsset",
          "args": [
            "${source}.asset",
            "${vehicleInfo}"
          ]
        },
        "expect": {
          "contains": "(Boolean) True"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleText}/AssetName",
          "value": "${vehicleName}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleInfo}/vehicleName",
          "value": "${vehicleName}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleInfo}/assetGuid",
          "value": "${vehicleGuid}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleInfo}/cookedDirectory",
          "value": "${fixture}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleData}/vehicleTextData",
          "value": "@asset:${vehicleText}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleData}/modelData/MainModel",
          "value": "@asset:${packModel}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleData}/cookedLocation",
          "value": "NextToData"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${vehicleData}/modelData/MainModel/name"
        },
        "expect": {
          "contains": "Tutorial_NativePackModel"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${vehicleData}/vehicleTextData/AssetName"
        },
        "expect": {
          "contains": "${vehicleName}"
        }
      }
    ]
    

    5. 生成并编辑伤害模型

    5.1 绑定源模型并生成预制体

    1. 在 Project 选中 VehicleHitBox。把外部装甲 FBX 拖入 外部装甲模型。若已有独立的内构 FBX,拖入 内部模块模型。导入前,用显示模型核对两个源模型的原点、朝向和比例。下图的两个源资产是教程 MCP 使用的样例预制体。

    VehicleHitBox 中的外部装甲模型、内部模块模型与生成预制按钮

    1. 点击 生成预制 - Create Prefab,再点 编辑模式 - Open Edit Mode。确认 Unity 已进入这辆车的 Prefab Mode。到独立的 伤害模型编辑器 窗口下半区,点击 外部装甲模型 - Generate External Armor。已绑定内构 FBX 时,再点 内部模块模型 - Generate Internal Armor。两个按钮会在当前预制体中新增对象。需要重新导入时,先备份预制体,再清理准备替换的旧节点。

    伤害模型编辑器中的外部装甲生成、内部模块生成、批量更新缓存和自动分配血量按钮

    5.2 检查装甲板和内构层级

    1. 在 Hierarchy 展开 HitBox/Main,选中教学车的 HullFront_65。在 HitBox 组件中确认装甲类型与厚度 65 mm。依次检查 HitBox/Main、HitBox/Turret、HitBox/Gun、HitBox/Dym 分别对应车体、炮塔、俯仰和后坐。源模型中的 HitBox_Main、HitBox_Turret 等组能自动匹配。如果网格仍留在新导入的根节点内,把它拖进对应组,保持相对整车的位置。详见伤害模型命名与导入。

    HullFront_65 的 HitBox 组件,装甲厚度为 65 mm

    如果外部板件需要记录命中后已消耗的区域,按反应装甲配置设置对应的 HitBox。

    1. 在伤害模型编辑器选择模块类型和预设,放置后移动到实际位置。在 InternalModule 下按同样的四组归位。内构源模型用 Module_Main、Module_Turret 等组自动匹配。通过 InternalModule 组件设置单个模块的 HP。批量调整时,在 VehicleHitBox 填写总体 HP 和所需的按类型覆盖,再回到窗口点击 自动设置模块血量。批量分配后复查需要保留的单个数值。
    2. 对乘员勾选其岗位。准备支持模块模式的履带载具时,检查车长、驾驶员、炮手、通讯员,以及装填手或自动装填模块。首轮验证基础车时可先关闭模块模式,完成下方内构配置后再启用。
    3. 在 Prefab Mode 按 Ctrl+S 保存。退出后,回到 VehicleHitBox 的 Inspector,确认 伤害模型预制体(自动生成) 已指向刚编辑的预制体。

    内构模块怎么填

    1. 打开生成的伤害预制体。选中 InternalModule 下的网格,在它的 InternalModule 组件里确认 模块类型、模块装甲(mm)和伤害点数(模块 HP)。用 FBX 导入时可直接采用第一列的名字,手动放预设时需要自己填写数值与岗位。
    教学节点 放在 InternalModule 下的组 HP / 装甲 位置或岗位
    Engine_40_10 Main 40 / 10 mm 发动机舱内
    Crew_10_0_Driver_Radioer Main 10 / 0 mm 车体前部,驾驶员与通讯员
    Crew_10_0_Commander_Gunner Turret 10 / 0 mm 炮塔内,车长与炮手
    Crew_10_0_Reloader Turret 10 / 0 mm 炮塔内,装填手
    Breech_12_5 Gun 12 / 5 mm 主炮后部,随炮俯仰
    AmmoShell_25_5 Main 25 / 5 mm 车体一侧的弹药架
    1. 选中 InternalModule/Main/AmmoShell_25_5,把最大可携带炮弹数量填为 30,关闭是否待发弹。导入器可能已经建立一个边界,先检查 当前编辑 ID = 1 和 Scene 视图中边框的位置。没有边界时点增加新边界,用 Scene 手柄围住弹药网格。改边界后点创建弹药架模型缓存。图中的教学弹药架应显示 缓存模型数 1。制作分段弹药架时,每段单独圈出再重建。要处理多个弹药架,回到伤害模型编辑器点批量更新弹药架模型缓存,再逐个核对结果。
    2. 若要让内构损坏联动指定的火炮或炮塔,可在组件底部查看可相连载具模块,再从 VehicleTextData → 模块标识复制对应主炮或炮塔的 GUID,填入 Connected Vehicle Module Guids 列表。节点路径决定模块跟谁移动,GUID 决定损坏后关联哪个系统。
    3. 按 Ctrl+S 保存伤害预制体。回到 VehicleInfo 打开 Is Module Ready,重打包,在测试场选 Module Based。检查发动车体、瞄准和开火;再切换内构视图,确认驾驶员在车体、炮手随炮塔走。用对方车辆射击一个已知模块,检查对应模块的 HP 或损坏状态。

    教学弹药架的耐久、装甲和容量

    点击展开 MCP 操作点击收起 MCP 操作
    [
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.AssetDatabase/CreateAsset",
          "args": [
            "@static:UnityEngine.ScriptableObject/CreateInstance(ShanghaiWindy.Core.VehicleHitBox)",
            "${armor}"
          ]
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Core.AssetBundleManager/LuaEnv/DoString",
          "args": [
            "local run = assert(loadfile(\"../../Tools/ManualMcp/TankTutorial/armor.lua\"))()\nreturn run({armorSource = \"${armorSource}\", moduleSource = \"${moduleSource}\", armorPrefab = \"${armorPrefab}\", armorDraft = \"${armorDraft}\"})\n",
            "tank-armor",
            "null"
          ]
        },
        "expect": {
          "contains": "six internal modules saved"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${armor}/ExternalArmorModel",
          "value": "@asset:${armorSource}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${armor}/InternalModuleModel",
          "value": "@asset:${moduleSource}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${armor}/HitBoxPrefab",
          "value": "@asset:${armorPrefab}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${armorPrefab}/HitBox/Main/HullFront_65/HitBox/Armor"
        },
        "expect": {
          "contains": "65"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleData}/modelData/HitBox",
          "value": "@asset:${armor}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleInfo}/isModuleReady",
          "value": "true"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${armorPrefab}/InternalModule/Main/AmmoShell_25_5/InternalModule/maxAmmoCapacity"
        },
        "expect": {
          "contains": "30"
        }
      }
    ]
    

    6. 设置载具信息、炮弹、音效和参数

    1. 打开 VehicleInfo,显示名称填 Tutorial Tank、等级填 3。找到 出生方式 - Spawn Policy,设为 玩家选择(Player Pick)。如果从雷达或召唤物复制,尤其要检查这个字段。将国家与 VehicleTextData → 基础保持一致,打包会同步国家。用 载具缩略图 设置列表图片。
    2. 项目中已有适用音效时,先用现成的 VehicleEngineFmodSoundData 和 BulletFmodSound。自制音效时,将录音导入匹配的 FMOD 工程,给引擎的启动和运行事件安排怠速与加速声音,并配置开火的近、远听感以及相应事件。构建并刷新 Bank 后,用事件选择器绑定资源。旧教程中的 Fire Near、Fire Far 是旧音频资产的字段。FMOD 工程配置
    3. 打开 VehicleTextData,从 Inspector 底部点打开炮弹编辑器,新建穿甲弹 Tutorial-76mm-AP。首轮填 Caliber = 76 mm、Velocity = 650 m/s、Penetration = 90 mm、Damage = 100,弹头选 AP。在 模块中填入弹体质量 6.5 kg。这发实心弹的引信延迟和 TNT 当量均为 0。选择匹配的 AP Bullet VFX,再把资产拖入 开火 → 炮弹列表。第一轮只留这一项。
    4. 按表配置 VehicleTextData。修改后保存并重新选中,确认字段和引用都保留。教学车使用本地炮和炮塔设置。若栏位被共享资产隐藏,先清空 Shared Gun Data 或 Shared Turret Data,再编辑本地值。
    标签页 要完成的操作
    基础 · PSParameter Health 600、View Range 360 m。先关闭自定义瞄准点,待前向和开火点通过试车后再配置。
    移动 · PTCParameter 保持履带控制器。质量 30,000 kg,前进/倒车限速 35/10 km/h,正向/倒车扭矩 3500/2600、制动扭矩 5000。扭矩曲线的示例点是 (0, 1)、(35, 0.35)。绑定有效的引擎音效,在第 8 节检查 TankWheelCollider 与 Track Data。需要调整扭矩曲线、换挡阈值或音效的转速输入时,见引擎、挡位和 RPM。
    开火 · TFParameter 标准(Standard),装填 6 秒,主炮总弹数 30,关闭 Has Slot。射击间隔 0,后坐比例 1,保留一项 AP 弹和有效开火音效。基础 dispersion 用 0.003。展开 Spread,按 76 mm 的默认值填下段参数。口径从炮弹资产读取。
    炮塔 · MTParameter 对称回转半角 180°,炮塔 18°/s,炮管俯仰 12°/s,最大仰角 20°、最大俯角 6°。俯角这里填正数。先留空各方向的覆盖范围。需要限制左右回转、避让车体或设置稳定器时,见炮塔、俯仰和稳定器。

    Spread 中的缩圈数据和基础 dispersion 是两组设置。76 mm 的默认缩圈数据为散布 0.35、瞄准时间 1.92 秒、移动/炮塔转向系数各 0.14、炮管移动系数 0.11,开火后系数 3、损毁系数 2。保存后检查 Inspector 已消除散布和炮弹后效提示。

    需要配置弹夹、弹鼓或能量武器时,见火炮、开火与装填。如果装填时炮管必须回到特定角度,见定角装填配置。

    下面四张 Inspector 图来自同一辆教学车,依次对应移动、开火、炮塔和炮弹资产。

    教学车的质量、轮碰撞器和履带引用

    教学车的 6 秒装填和 30 发总弹量

    炮塔回转速度与炮管的俯仰范围

    教学穿甲弹的口径、初速与伤害

    点击展开 MCP 操作点击收起 MCP 操作

    以可运行的数据结构作为起点,覆盖出生角色、移动、主炮、炮塔和开火节点,验证教学车参数与正文一致。

    [
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleData}/isGenLOD",
          "value": "false"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Core.AssetBundleManager/LuaEnv/DoString",
          "args": [
            "local setup = assert(loadfile(\"../../Tools/ManualMcp/TankTutorial/configure.lua\"))()\nreturn setup({\n    text = \"${vehicleText}\", data = \"${vehicleData}\", info = \"${vehicleInfo}\",\n    bullet = \"${bullet}\", bulletVfx = \"${bulletVfx}\", gunSound = \"${gunSound}\", engine = \"${engine}\"\n})\n",
            "tank-first-drive-parameters",
            "null"
          ]
        },
        "expect": {
          "contains": "Player-selectable tank parameters and 76 mm AP ready"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${vehicleInfo}/spawnPolicy"
        },
        "expect": {
          "contains": "PlayerPick"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${vehicleText}/PTCParameter/Mass"
        },
        "expect": {
          "contains": "(Int32) 30000"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${vehicleText}/TFParameter/AmmoCount"
        },
        "expect": {
          "contains": "(Int32) 30"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${vehicleText}/MTParameter/UpMaxDegree"
        },
        "expect": {
          "contains": "20"
        }
      }
    ]
    

    配置炮口、弹道和命中特效

    1. 在 VehicleTextData → 开火 → 开火效果将 Muzzle Fire 选为中 (Muzzle Middle)。它在第 7 节的 EffectStart 生成炮口火焰。先留空 Override Muzzle Fires。转动炮塔后火焰仍应出现在炮口前方。
    2. 选中 Tutorial-76mm-AP,在 Bullet VFX 选中 SDK 的 AP-BulletVFX-M,点击引用定位到该资产。下面是教学弹读回的特效键。命中覆盖列表按顺序选择第一个已注册的键,找不到覆盖时使用同一行的基础键。这个预设未指定跳弹键,需要专门的跳弹效果时再填写 击中装甲跳弹。
    BulletVFX 字段 基础键 教学覆盖键
    弹道 WeaponProjectile 留空
    击中地面 FireExplosionHitOnGround AP-HitOnGround-M
    击中装甲 FirePenetrateHitOnArmor AP-HitOnArmor-M
    1. 要改成自己的特效时,复制一份 BulletVFX,将粒子 prefab 注册到 Pool Resource 的独立特效名,再从复制品的字段下拉框选择相同名字。把 Pool Resource 加入构建管线。如果特效单独打包,给载具包添加该特效包的 GUID 依赖。保留是否用物品重载弹道为关闭,使用当前对象池路径。特效资源与依赖配置
    2. 在试车场分别对空地和靶车射击。只有炮口位置错时先查 EffectStart。有炮口火焰但没有弹道时查 弹道键。弹道可见但命中无效果时,核对命中分支、覆盖键与包的加载状态。

    开火页签里的中型炮口火焰

    教学穿甲弹的弹道和命中特效键

    点击展开 MCP 操作点击收起 MCP 操作
    [
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Core.AssetBundleManager/LuaEnv/DoString",
          "args": [
            "local verify = assert(loadfile(\"../../Tools/ManualMcp/TankTutorial/check_details.lua\"))()\nreturn verify.effects(\"${vehicleText}\", \"${bulletVfx}\")\n",
            "tank-effects",
            "null"
          ]
        },
        "expect": {
          "contains": "Muzzle preset and AP effect keys verified"
        }
      }
    ]
    

    换弹种时,按炮弹与特效核对穿深、弹道、单弹种携带上限和地面/装甲命中特效。需要在开火时播放弹壳抛出动作,可接着做坦克抛壳动画。

    KV-2 的资产可用来对照重车参数。其源配置质量为 52,850 kg,限速 37/7 km/h,共享炮塔回转速度 14°/s,最大仰角 12°、俯角 5°,履带节距 0.275 m。它的主炮弹由共享火炮资产提供。试车场读取到的第一发为 OF-530,口径 152 mm、初速 530 m/s。

    可选的 Tanks.gg 入口仍在 VehicleTextData。填写 tanksGGName 后可尝试导入三扩数据。另一个按钮会覆盖多项现有参数,先把资产保存在 Git 或备份里。外部响应依赖第三方,导入后仍须补齐并检查其余字段。详细参数字段与图示

    7. 绑定主模型并定位开火节点

    1. 选中 VehicleData。将第 3 节的碰撞预制体拖进 Model Data → MainModel。确认 VehicleTextData 和 HitBox 分别指向这辆车的详细数据和伤害资产。
    2. 点击 编辑进入变换编辑。Scene 视图中会出现橙色节点。每改好一组,在 Scene 视图按 K 保存。用前视核对横向,侧视核对高度,再从斜前方检查节点朝向。

    | 节点 | 应放的位置 | | --- | --- | | FFPoint、EffectStart | 炮口正中、朝 +Z,略出炮口避免与炮管相交。教学车以 Gun 为父节点,局部坐标 (0, 0, 2.45)。 | | CenterOfGravity | 车体内、左右轮之间。教学车局部坐标 (0, 0.78, 0)。悬挂下沉与起步点头异常时回查。 | | MainCameraFollowTarget、MainCameraGunner | 前者给第三人称相机追随,放在车体上方。后者给炮手视角,放在炮口方向的瞄准装置。 | | EngineSound、EngineSmoke | 分别放在发动机舱和排烟口。每次调整后回到编辑模式检查位置已保存。 | 3. 点击 解锁视图(Unlock Inspector)。回到 Project 核对选中的仍是这辆车,重开编辑模式时节点应保留刚保存的位置。

    载具数据中的主模型与详细参数资产

    需要为炮手视角增加瞄准倍率时,见载具缩放倍率配置。

    可选的车载部件

    • 需要近光、远光或刹车灯时,在 MainBody 下放置独立灯具节点,再按坦克灯光设置绑定灯型、发光节点和光束朝向。圆形近光的完整示例见车灯组件。
    • 在车体上布置主动防御装置时,保留挂载节点和发射点,按主动防御系统核对朝向、覆盖范围和冷却。
    • 需要在游戏内搜索并锁定目标时,打开 VehicleTextData → 杂项 → 防空雷达。按地面载具雷达配置扫描,并核对可选的天线模型。

    8. 调整负重轮与履带

    1. 在 VehicleTextData → 移动 → TankWheelCollider 点击引用找到预制体。双击它进入 Prefab Mode,选中带 Wheel Collider 的根节点。在场景副本里可同时对照显示模型的轮轴。若改的是场景实例,通过 Overrides → Apply 把值写回同一份预制体。
    2. 按下表录入。展开 Suspension Spring、Forward Friction 和 Sideways Friction 查看子字段。切回载具,确认仍引用刚保存的模板。
    WheelCollider 字段 教学车值 检查方法
    Radius / Mass 0.43 m / 320 kg 半径对齐实际负重轮。Mass 是单个轮模板质量,整车质量在第 6 节。
    Center (0, 0, 0) 轮轴原点居中。履带组还要核对 TrackData 的悬挂 Y 偏移。
    Suspension Distance / Force App Point Distance 0.2 m / 0.4 m 分别是悬挂行程与静止轮底上方的受力点距离。
    Suspension Spring Spring 205000、Damper 14500、Target Position 0.5 控制回弹力、缓和振荡和静止目标在行程中的位置。
    Forward Friction Extremum Slip / Value 1 / 1,Asymptote Slip / Value 1 / 1,Stiffness 1.7 平地起步、直线刹车,看轮子是否持续打滑。
    Sideways Friction Extremum Slip / Value 1.2 / 1.2,Asymptote Slip / Value 1 / 1,Stiffness 4 同样速度转向,比较横向滑移与侧倾。

    模板里的 Wheel Damping Rate 与 Layer Overrides 可先保留默认,履带控制器会设置运行时阻尼和碰撞层。试车时先对齐轮轴、半径和履带节点,再分别改弹簧、阻尼或摩擦。每次改变一个字段,重打包后走同一段平地和小坡对比。Unity WheelCollider 字段说明 · 轮式载具设置

    负重轮模板的 Unity WheelCollider 属性

    1. 选中 VehicleTrackData,为**履带模型(TrackMesh)**绑定单节履带预制体。左右形状不同时还可设置左履带模型。**履带长度(手动设置)**对应字段 TrackDistance,可先从默认 0.12 开始,按实际履带节长度调整。保留编辑器生成的悬挂数据。
    2. 在 VehicleData 点击**编辑悬挂(Edit Track)**打开编辑器。若直接从履带资产进入编辑模式,把已有的载具编辑对象填给 Target Edit Object 后点击 读取悬挂信息。编辑对象还未生成时,回到 VehicleData 进入编辑模式,生成后再来编辑履带。
    3. 从侧面观察轮组,按绕履带一圈的顺序点击 创建节点并放置节点。把路径放到负重轮下方、托带轮上方和前后转折处,检查每一侧形成闭环。可以临时隐藏伤害模型或静态履带,便于观察。
    4. 点击 预览悬挂(Preview Track),检查履带节的方向、转角与间距。调整后使用 更新预览,完成后点击 保存数据与解锁视图。检查履带数据仍绑定在这辆车。履带 IK 与悬挂图示

    下面用载具工程的 KV-2 数据展示履带环路。橙点是路径节点,青线依次把它们连成闭环,整条示意线向外移开一点以便观察。自己的车也应沿负重轮底部绕过两端轮,再从上方闭合。

    KV-2 履带节点和青色闭环的 Unity Scene View 侧视图

    履带节资源与间距

    点击展开 MCP 操作点击收起 MCP 操作
    [
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Editor.WheelUtil/CreateWheelPrefab",
          "args": [
            "${wheel}"
          ]
        },
        "expect": {
          "contains": "GameObject"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${wheel}/WheelCollider/radius",
          "value": "0.43"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${wheel}/WheelCollider/mass",
          "value": "320"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.EditorUtility/SetDirty",
          "args": [
            "@asset:${wheel}/WheelCollider"
          ]
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.AssetDatabase/SaveAssets",
          "args": []
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.AssetDatabase/CreateAsset",
          "args": [
            "@static:UnityEngine.ScriptableObject/CreateInstance(ShanghaiWindy.Core.VehicleTrackData)",
            "${track}"
          ]
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleText}/isStationary",
          "value": "false"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleText}/PTCParameter/TankWheelCollider",
          "value": "@asset:${wheel}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${vehicleText}/PTCParameter/TrackData",
          "value": "@asset:${track}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Core.AssetBundleManager/LuaEnv/DoString",
          "args": [
            "local U, E = CS.UnityEngine, CS.UnityEditor\nlocal link = U.GameObject.CreatePrimitive(U.PrimitiveType.Cube)\nlink.name = 'Tutorial Track Link'\nlink.transform.localScale = U.Vector3(0.36, 0.07, 0.12)\nU.Object.DestroyImmediate(link:GetComponent(typeof(U.Collider)))\nassert(E.PrefabUtility.SaveAsPrefabAsset(link, '${link}'))\nU.Object.DestroyImmediate(link)\nlocal data = E.AssetDatabase.LoadMainAssetAtPath('${track}')\ndata.trackNodes:Clear()\nfor _, point in ipairs({{0.02, 1.85}, {0.02, -1.85}, {0.48, -2.29}, {0.95, -1.85},\n    {0.95, 1.85}, {0.48, 2.29}}) do\n    local node = CS.ShanghaiWindy.Core.TrackNode()\n    node.leftNode = U.Vector3(-1.42, point[1], point[2])\n    node.rightNode = U.Vector3(1.42, point[1], point[2])\n    data.trackNodes:Add(node)\nend\nE.EditorUtility.SetDirty(data)\nE.AssetDatabase.SaveAssets()\nreturn 'Six track nodes per side'\n",
            "tank-track-nodes",
            "null"
          ]
        },
        "expect": {
          "contains": "Six track nodes per side"
        }
      },
      {
        "tool": "inspect_set",
        "arguments": {
          "path": "asset:${track}/TrackMesh",
          "value": "@asset:${link}"
        },
        "expect": {
          "contains": "OK:"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${track}/trackNodes"
        },
        "expect": {
          "contains": "Count=6"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${track}/TrackDistance"
        },
        "expect": {
          "contains": "0.12"
        }
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${vehicleText}/GetGroundType()"
        },
        "expect": {
          "contains": "TrackController"
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Core.AssetBundleManager/LuaEnv/DoString",
          "args": [
            "local verify = assert(loadfile(\"../../Tools/ManualMcp/TankTutorial/check_details.lua\"))()\nreturn verify.wheel(\"${wheel}\", \"${vehicleText}\")\n",
            "tank-wheel",
            "null"
          ]
        },
        "expect": {
          "contains": "Wheel template and suspension values verified"
        }
      }
    ]
    

    9. 生成载具预制体

    选中 VehicleData,点击 打包(Pack),确认生成载具预制体。烘焙输出位置决定使用共享 Cooked 目录,还是保存到 VehicleData 同目录。检查 VehicleInfo 能定位到生成物。修改显示模型、物理碰撞、伤害模型、轮组或关键节点后,再打包一次。成功生成预制体后再继续构建模组。

    10. 构建、安装和验收你的模组

    1. 在 GM 编辑器打开模组打包 → 创建模组包,用清楚的包名,例如 Vehicle-Tutorial-Tank。打开创建的 ModPackageBuildPiplineData,将这辆车的 VehicleInfo 拖入 Linked Objects。检查 Linked Mod Package 已引用相应的 ModPackageData。
    2. 在 File → Build Settings 或 Ctrl+Shift+B 选定目标平台,并完成平台切换。检查当前活动平台,再在构建管线里构建链接的资源。在 ModPackageData 填写名称、简介、作者和版本,执行 Package Now。每次更换平台都重新构建资源并打包。
    3. 在工程的 Build/Mod-Package/<平台>/ 下找到生成的 .modpack,核对平台后按安装模组导入。Windows 产物用于 Windows 试车。以实际输出路径和文件扩展名为准。
    4. 在 SDK 中也可先选 VehicleData → 试驾(重打包),使用载具测试场验证当前工程。初次只验证外装甲时选 Health Based,确认能选中 Tutorial Tank 并生成在地面。完成内部模块后,再以 Module Based 测试。
    5. 用默认移动键测试前进、倒车和左右转向,松开后车辆应减速。观察负重轮接地、履带节是否反向或离开车轮。瞄准与车头不同方向的目标,检查炮塔回转和炮管俯仰。在靶场用第一个弹种开火,确认弹从炮口出现、弹数减一且约 6 秒后重新装填。最后测试命中反馈。
    6. 若包已成功安装而列表找不到车,先查 Player Pick、测试场伤害模式及地图可用的载具类型。若能上车却不动,先查移动扭矩与 TankWheelCollider。若转向后炮口错位,回到第 7 节检查 Gun → Dym 层级与开火点,再重打包试驾。
    点击展开 MCP 操作点击收起 MCP 操作
    [
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:ShanghaiWindy.Core.PackUtil/Pack",
          "args": [
            "@asset:${vehicleData}"
          ]
        },
        "expect": {
          "contains": "OK:"
        },
        "phase": "build"
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${cooked}/name"
        },
        "expect": {
          "contains": "(String)"
        },
        "phase": "build"
      },
      {
        "tool": "inspect",
        "arguments": {
          "path": "asset:${cooked}/VehicleComponentsReferenceManager/LeftWheels"
        },
        "expect": {
          "contains": "Count=4"
        },
        "phase": "build"
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "asset:${pipeline}/linkedObjects/Add",
          "args": [
            "@asset:${vehicleInfo}"
          ]
        },
        "expect": {
          "contains": "OK:"
        },
        "phase": "build"
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.EditorUtility/SetDirty",
          "args": [
            "@asset:${pipeline}"
          ]
        },
        "expect": {
          "contains": "OK:"
        },
        "phase": "build"
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:UnityEditor.AssetDatabase/SaveAssets",
          "args": []
        },
        "expect": {
          "contains": "OK:"
        },
        "phase": "build"
      },
      {
        "tool": "modpack_plan",
        "arguments": {
          "pipeline": "${pipeline}"
        },
        "expect": {
          "equals": {
            "ok": true,
            "built": false
          }
        },
        "phase": "build"
      },
      {
        "tool": "modpack_build",
        "arguments": {
          "pipeline": "${pipeline}"
        },
        "expect": {
          "equals": {
            "ok": true,
            "archiveExists": true,
            "published": false,
            "installed": false
          }
        },
        "phase": "build",
        "capture": {
          "archivePath": {
            "path": "archivePath"
          }
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:Frontend.Editor.ModPackageWorkshopMeta/WriteSidecar",
          "args": [
            "${archivePath}"
          ]
        },
        "expect": {
          "contains": ".modpack.json"
        },
        "phase": "build",
        "capture": {
          "sidecarPath": {
            "regex": "\\(String\\) (.+)"
          }
        }
      },
      {
        "tool": "invoke",
        "arguments": {
          "path": "static:System.IO.File/ReadAllText",
          "args": [
            "${sidecarPath}"
          ]
        },
        "expect": {
          "contains": "${packageGuid}"
        },
        "phase": "build"
      }
    ]
    
    点击展开 MCP 试车回放

    在能启动游戏环境、已加载地图资源的本地 DE 编辑器中,先用上方配方构建 Windows 包。将生成的 run.json 路径作为第一个参数传给试车脚本。

    python Tools/ManualMcp/TankTutorial/test_drive.py "<构建回执 run.json>" Temp/ManualMcp/TankFirstDrive
    

    脚本通过 MCP 安装构建产物并在 PlayField 生成载具,验证前进、倒车、转向和教学穿甲弹的弹道命中。它会切到模块模式回读已加载的内构和运行时对象池中的特效键。回放会退出 Play,测试读数保存在输出目录。玩家输入触发的扣弹、装填节奏和特效外观,按本节手动试车步骤核对。

    11. 完成基础车后尝试变体

    变体 如何在基础车上继续
    轮式载具 对沿用履带控制器的轮式车,保留 LeftTrack 和 RightTrack 占位节点,按原流程调整轮碰撞,并配置轮式和履带控制差异。
    机炮(旧教程的 M3 Stuart 示例) 在主炮开火数据选标准模式,勾选 Has Slot,设 Slot Count 与 Slot Duration。旧图示例为 5 与 3.35,试车时检查连发和随后装填的节奏。
    弹鼓炮(Progetto 65 示例) 将 Fire State 设为 Drum,填写 Fire Duration 与 Reload Times。旧图示例为 2 秒与 [12.4, 10.3, 8.6, 6.8],逐档核对装填。
    弹夹炮(Bat 25t 风格示例) 选 Advance,在 Advance Fire Class 填短装填、长装填与每夹弹数。旧图演示短装填 2 秒、长装填 33 秒、每夹 4 发。
    多炮塔(BMD-1、T-35) BMD-1 示例将副武器配置为导弹。T-35 示例在模型根节点下增加 SubTurret01 → SubGun01 → SubDym01,其余三个副炮塔用 02、03、04 编号。设置从模型根到炮塔、从炮塔到炮根、从炮根到炮管的路径,核对发射点与特效偏移。
    双管(ST-II) 旧示例把 SubTurret → SubGun → SubDym 放在 Turret/Gun 下。把第二根炮管的支点设在其炮尾回转位置。旧配置中的炮塔路径为 Turret/Gun/SubTurret,枪和炮管路径分别为 SubGun、SubDym。按旧版多炮塔复现核对它与主炮的瞄准方向。

    以上旧图读数用于理解界面,可按你的模组重新调校。新载具的多炮塔优先看 VehicleTextData 的多炮塔配置。需要车体辅助转向、固定炮架或液压悬挂时,参考自行火炮、坦克歼击车与 Strv 悬挂。遇到模型不显示、开火方向错误或打包后找不到载具时,先查看载具开发排查。

    In this article
    Back to top Panzer War Document