From cb6217d0cdeb3711d8cc025833adc4d0bf59be38 Mon Sep 17 00:00:00 2001
From: wjsjwr <wjsjwr@gmail.com>
Date: Sun, 18 Jan 2026 12:38:03 +0800
Subject: [PATCH] NDBS update

---
 GEMINI.md                        |   67 ++
 docs/配置定义系统文档.md         |  188 +++++
 tools/ndbs/server/web/app.js     | 1256 +++++++++++++++++++++++++++++-
 tools/ndbs/server/web/index.html |   41 +-
 tools/ndbs/server/web/styles.css |  146 ++++
 5 files changed, 1689 insertions(+), 9 deletions(-)
 create mode 100644 GEMINI.md
 create mode 100644 docs/配置定义系统文档.md

diff --git a/GEMINI.md b/GEMINI.md
new file mode 100644
index 0000000..5eba249
--- /dev/null
+++ b/GEMINI.md
@@ -0,0 +1,67 @@
+# GEMINI.md - Context & Instructions for "Super Mentor" (最强导师)
+
+## 1. Project Overview
+
+**Project Name:** Super Mentor (最强导师 / Supervisor Simulator)
+**Type:** Simulation / Strategy / Roguelite Game
+**Engine:** Godot 4.x (C# / .NET)
+**Platform:** Windows (Win32), likely cross-platform capable.
+
+**Core Concept:**
+A "survival horror" simulation of academic life. Players manage a lab, recruit students, publish papers, secure funding, and navigate academic politics ("publish or perish").
+
+## 2. Architecture & Directory Structure
+
+### 2.1 Game Engine (Godot/C#)
+*   **Root:** Contains `project.godot`, `.sln`, `.csproj`.
+*   **`scripts/`**: The core C# source code.
+    *   `Core/`: Game systems (TurnSystem, TaskSystem, EconomySystem, SynergySystem) and Interfaces.
+    *   `Models/`: Data models (StudentModel, TaskModel, etc.) and Definitions.
+    *   `[Node classes]`: `Player.cs`, `Student.cs` (Godot Node behaviors).
+*   **`resources/definitions/`**: Data-driven design files.
+    *   `.json`: Archetypes, Roles, Traits.
+    *   `.tres`: Discipline specific resources (Godot Text Resource).
+*   **`scenes/`**: Godot `.tscn` scene files.
+*   **`docs/`**: Detailed game design documents (GDD).
+
+### 2.2 Tooling: Numerical Design & Balancing System (NDBS)
+Located in `tools/ndbs/`, this is a web-based tool for designers to edit game data and write scripts.
+*   **Backend:** Python 3.14 (FastAPI), managed by `uv`.
+*   **Frontend:** Vue.js (Vite, Naive UI/Element Plus).
+*   **Spec:** `specs/numerical_design_system.md`.
+
+## 3. Building & Development
+
+### 3.1 Game (Godot)
+*   **Prerequisites:** Godot Engine (Mono version), .NET SDK.
+*   **Build:** Standard Godot build process or via IDE (Visual Studio / JetBrains Rider / VS Code).
+*   **Run:** Open `project.godot` in Godot Editor or run via CLI.
+
+### 3.2 NDBS Tool (`tools/ndbs`)
+*   **Backend (`tools/ndbs/server`):**
+    *   Manager: `uv`
+    *   Run: `uv run main.py` (or `uvicorn main:app --reload`)
+*   **Frontend (`tools/ndbs/client`):**
+    *   Manager: `npm` / `yarn`
+    *   Build: `npm run build` (Output consumed by Python server).
+
+## 4. Key Conventions
+
+### 4.1 C# / Godot
+*   **Systems Pattern:** Core logic is decoupled from Godot Nodes where possible, residing in `scripts/Core` implementing `IGameSystem`.
+*   **Rule System:** Game logic "rules" (Buffs/Debuffs) are referenced by string IDs (`RuleIds`) and executed via a `RuleManager` (using Reflection).
+*   **Data Driven:** Heavy reliance on JSON/TRES definitions for content.
+
+### 4.2 Code Style
+*   **C#:** Standard .NET conventions (PascalCase for public, camelCase for private/locals).
+*   **Python:** Type hints required (Python 3.14+). Pydantic for data validation.
+*   **Frontend:** Vue Composition API (`<script setup lang="ts">`).
+
+## 5. Current Task Context (As of Jan 2026)
+The project is actively implementing the **NDBS Tool** defined in `specs/numerical_design_system.md`.
+**Goal:** Create a unified service where a Python backend serves a Vue frontend to allow editing of `resources/definitions` and generation of `scripts/Rules/Generated/*.cs` files.
+
+**Immediate Next Steps:**
+1.  Initialize the Python backend using `uv`.
+2.  Set up the Vue frontend.
+3.  Implement the File System API for JSON/TRES handling.
diff --git a/docs/配置定义系统文档.md b/docs/配置定义系统文档.md
new file mode 100644
index 0000000..c0ce7a7
--- /dev/null
+++ b/docs/配置定义系统文档.md
@@ -0,0 +1,188 @@
+# 配置定义系统文档 (Definition System)
+
+本文档详细说明了《最强导师》游戏中的数据定义系统。该系统采用数据驱动（Data-Driven）的设计理念，将核心游戏内容（如学科、角色、特质等）与代码逻辑分离，存储为 JSON 格式的配置文件。这不仅便于开发过程中的数值调整，也为未来的 Mod 支持打下了基础。
+
+## 1. 系统概述
+
+游戏的核心数据存储在 `resources/definitions/` 目录下。游戏启动时，`ContentRegistry`（位于 `scripts/Core/ContentRegistry.cs`）负责加载这些文件，并将它们反序列化为 C# 对象，最终汇聚在 `GameContentDatabase` 中供游戏逻辑查询。
+
+**主要特点：**
+*   **格式统一**：主要使用 JSON 格式。
+*   **支持热加载/Mod**：设计上支持从多个源（`res://` 或 `user://`）加载并合并数据。
+*   **国际化支持**：所有名称和描述都包含 `Key` (本地化键) 和 `Fallback` (默认文本)。
+
+## 2. 核心数据结构
+
+几乎所有的定义文件都复用了以下核心数据结构。
+
+### 2.1 DefinitionHeader (通用头部)
+所有定义对象都包含一个 `Header` 字段，用于标识身份。
+
+| 字段名 | 类型 | 说明 |
+| :--- | :--- | :--- |
+| `Id` | `string` | 唯一标识符，建议格式 `namespace:type_name` (如 `core:archetype_grinder`)。 |
+| `Name` | `LocalizedText` | 显示名称。 |
+| `Description` | `LocalizedText` | 详细描述。 |
+| `IconPath` | `string` | 图标资源路径 (可选)。 |
+| `Tags` | `List<string>` | 标签列表，用于分类或过滤。 |
+
+### 2.2 LocalizedText (本地化文本)
+用于支持多语言。
+
+| 字段名 | 类型 | 说明 |
+| :--- | :--- | :--- |
+| `Key` | `string` | 翻译文件中的 Key (如 `archetype.grinder.name`)。 |
+| `Fallback` | `string` | 当找不到翻译时的默认显示文本。 |
+
+### 2.3 ModifierBundle (数值修正包)
+用于描述 Buff、Debuff 或被动效果。它不直接修改数值，而是提供加成或规则 ID。
+
+*   **AttributeModifiers**: 属性修正 (如 `Academic`, `Engineering`)。
+    *   `Type`: 属性枚举。
+    *   `Add`: 固定加值。
+    *   `Multiplier`: 乘法倍率 (默认为 1.0)。
+*   **StatusModifiers**: 状态修正 (如 `Mood`, `Stress`)。
+*   **ResourceModifiers**: 资源修正 (如 `Money`)。
+*   **RuleIds**: `List<string>`，特殊规则的 ID (如 `rule:no_sleep`)，由代码逻辑解析具体效果。
+
+---
+
+## 3. 定义类型详解
+
+以下是各类定义文件的详细说明。
+
+### 3.1 学科 (Disciplines)
+**文件**: `resources/definitions/disciplines.json`
+**对应类**: `DisciplineDefinition`
+
+定义了游戏中的学术流派（如“经济学”、“计算机科学”）。学科决定了核心的资源循环机制和允许使用的角色。
+
+*   **Buff**: 学科全局 Buff，通常提供特定资源产出或属性加成。
+*   **RolePoolIds**: 该学科允许使用的角色 ID 列表。
+*   **ItemPoolIds**: 该学科关联的特殊物品池。
+*   **TaskKeywordIds**: 任务生成的关键词偏好。
+
+**示例片段**:
+```json
+{
+  "Header": { "Id": "core:discipline_computer", ... },
+  "Buff": {
+    "Name": { "Fallback": "Overclock" },
+    "Modifiers": {
+      "AttributeModifiers": [{ "Type": "Engineering", "Add": 5, "Multiplier": 1.05 }]
+    }
+  },
+  "RolePoolIds": [ "core:role_geek", "core:role_coder" ]
+}
+```
+
+### 3.2 角色身份 (Roles)
+**文件**: `resources/definitions/roles.json`
+**对应类**: `RoleDefinition` (推测)
+
+定义了学生在实验室中的具体分工（如“码农”、“实验员”）。
+
+*   **Tiers**: 角色等级列表。通常随人数或投入增加解锁更高级别的修正。
+    *   `RequiredCount`: 激活该层级所需数量。
+    *   `Modifiers`: 该层级提供的修正包。
+*   **AllowedDisciplineIds**: (可选) 限制该角色只能在特定学科中使用。
+
+**示例片段**:
+```json
+{
+  "Header": { "Id": "core:role_coder", ... },
+  "Tiers": [
+    {
+      "RequiredCount": 2,
+      "Modifiers": { "AttributeModifiers": [{ "Type": "Engineering", "Multiplier": 1.20 }] }
+    }
+  ]
+}
+```
+
+### 3.3 原型 (Archetypes)
+**文件**: `resources/definitions/archetypes.json`
+**对应类**: `ArchetypeDefinition` (推测)
+
+定义了学生的性格原型（如“卷王”、“摸鱼怪”）。类似于种族天赋，随同类学生数量增加而增强。
+
+*   **Tiers**: 羁绊等级列表。
+    *   `RequiredCount`: 激活羁绊所需人数。
+    *   `Modifiers`: 羁绊效果。
+
+**示例片段**:
+```json
+{
+  "Header": { "Id": "core:archetype_grinder", ... },
+  "Tiers": [
+    {
+      "RequiredCount": 2,
+      "Modifiers": { "AttributeModifiers": [{ "Type": "Activation", "Multiplier": 1.15 }] }
+    }
+  ]
+}
+```
+
+### 3.4 特质 (Traits)
+**文件**: `resources/definitions/traits.json`
+**对应类**: `TraitDefinition` (推测)
+
+定义了学生个体的具体特征（如“咖啡依赖”、“夜猫子”）。
+
+*   **Modifiers**: 特质带来的修正效果，通常直接包含 `RuleIds` 来触发特殊逻辑。
+
+**示例片段**:
+```json
+{
+  "Header": { "Id": "core:trait_night_owl", ... },
+  "Modifiers": { "RuleIds": [ "rule:trait_night_owl" ] }
+}
+```
+
+### 3.5 校园行为与模拟参数 (Campus Behavior)
+**文件**: `resources/definitions/campus_behavior.json`
+**对应结构**: 模拟配置对象 (非标准 Definition)
+
+定义了模拟系统的全局常数和行为交互规则。
+
+*   **Thresholds**: 各种状态的阈值（如 `CriticalStressThreshold`: 90）。
+*   **Decay/Growth Rates**: 状态随时间变化的速率（如 `HungerDecayPerSecond`）。
+*   **ActionConfigs**: 定义学生可执行的具体动作。
+    *   `ActionId`: 动作 ID (如 `Eating`)。
+    *   `LocationId`: 执行地点 (如 `Canteen`)。
+    *   `DurationSeconds`: 持续时间。
+    *   `*Delta`: 执行该动作对各项数值的影响 (如 `HungerDelta`, `StressDelta`)。
+
+**示例片段**:
+```json
+{
+  "CriticalStressThreshold": 90,
+  "ActionConfigs": [
+    {
+      "ActionId": "Eating",
+      "LocationId": "Canteen",
+      "HungerDelta": 3.00,
+      "StressDelta": -0.50
+    }
+  ]
+}
+```
+
+## 4. 如何添加新内容
+
+1.  **找到对应文件**: 在 `resources/definitions/` 下找到对应类型的 JSON 文件。
+2.  **复制模板**: 复制现有的一个对象块。
+3.  **修改 ID**: 确保 `Header.Id` 是全局唯一的。
+4.  **配置参数**: 修改名称、描述和修正数值。
+5.  **重启游戏**: 数据将在游戏启动时重新加载。
+
+## 5. 关联代码文件
+
+*   **加载逻辑**: `scripts/Core/ContentRegistry.cs`
+*   **数据仓库**: `scripts/Models/GameContentDatabase.cs`
+*   **学科定义**: `scripts/Models/DisciplineDefinitions.cs`
+*   **修正结构**: `scripts/Models/Modifiers.cs`
+*   **通用结构**: `scripts/Models/DefinitionSupport.cs`
+
+---
+*文档生成日期: 2026-01-17*
diff --git a/tools/ndbs/server/web/app.js b/tools/ndbs/server/web/app.js
index 5fb749f..745d622 100644
--- a/tools/ndbs/server/web/app.js
+++ b/tools/ndbs/server/web/app.js
@@ -1,8 +1,12 @@
+
 const state = {
   definitions: [],
   rules: [],
   activeType: null,
   activeFile: null,
+  viewMode: "raw",
+  currentContent: null,
+  activeEntryIndex: 0,
 };
 
 const elements = {
@@ -15,6 +19,12 @@ const elements = {
   editorTitle: document.getElementById("editor-title"),
   editorSubtitle: document.getElementById("editor-subtitle"),
   editorTextarea: document.getElementById("editor-textarea"),
+  rawEditor: document.getElementById("raw-editor"),
+  structuredEditor: document.getElementById("structured-editor"),
+  structuredForm: document.getElementById("structured-form"),
+  entrySelect: document.getElementById("entry-select"),
+  addEntryButton: document.getElementById("add-entry"),
+  deleteEntryButton: document.getElementById("delete-entry"),
   schemaSummary: document.getElementById("schema-summary"),
   formatButton: document.getElementById("format-button"),
   saveButton: document.getElementById("save-button"),
@@ -23,6 +33,15 @@ const elements = {
   createRuleButton: document.getElementById("create-rule"),
   buildButton: document.getElementById("build-button"),
   buildOutput: document.getElementById("build-output"),
+  guideTitle: document.getElementById("guide-title"),
+  guideDesc: document.getElementById("guide-desc"),
+  guideFields: document.getElementById("guide-fields"),
+  insertTemplateButton: document.getElementById("insert-template"),
+  validateFileButton: document.getElementById("validate-file"),
+  validateAllButton: document.getElementById("validate-all"),
+  validationOutput: document.getElementById("validation-output"),
+  viewRawButton: document.getElementById("view-raw"),
+  viewStructuredButton: document.getElementById("view-structured"),
 };
 
 const fetchJson = async (url, options = {}) => {
@@ -68,6 +87,232 @@ const renderSchema = (schema) => {
   elements.schemaSummary.classList.toggle("hidden", fields.length === 0);
 };
 
+const localizedTemplate = () => ({ Key: "", Fallback: "" });
+const modifiersTemplate = () => ({
+  AttributeModifiers: [],
+  StatusModifiers: [],
+  ResourceModifiers: [],
+  RuleIds: [],
+});
+
+const definitionGuides = {
+  "disciplines.json": {
+    title: "Disciplines",
+    description: "Academic disciplines with buffs, role pools, and item pools.",
+    fields: ["Header", "Buff", "RolePoolIds", "ItemPoolIds", "TaskKeywordIds"],
+    templateType: "array",
+    template: () => ({
+      Header: {
+        Id: "core:discipline_new",
+        Name: localizedTemplate(),
+        Description: localizedTemplate(),
+        IconPath: "",
+        Tags: ["discipline"],
+      },
+      Buff: {
+        Name: localizedTemplate(),
+        Description: localizedTemplate(),
+        Modifiers: modifiersTemplate(),
+      },
+      RolePoolIds: [],
+      ItemPoolIds: [],
+      TaskKeywordIds: [],
+    }),
+  },
+  "roles.json": {
+    title: "Roles",
+    description: "Role definitions with tiered modifiers and discipline limits.",
+    fields: ["Header", "Tiers", "AllowedDisciplineIds"],
+    templateType: "array",
+    template: () => ({
+      Header: {
+        Id: "core:role_new",
+        Name: localizedTemplate(),
+        Description: localizedTemplate(),
+        IconPath: "",
+        Tags: ["role"],
+      },
+      Tiers: [
+        {
+          RequiredCount: 1,
+          Modifiers: modifiersTemplate(),
+        },
+      ],
+      AllowedDisciplineIds: [],
+    }),
+  },
+  "archetypes.json": {
+    title: "Archetypes",
+    description: "Synergy archetypes with stacked tiers.",
+    fields: ["Header", "Tiers"],
+    templateType: "array",
+    template: () => ({
+      Header: {
+        Id: "core:archetype_new",
+        Name: localizedTemplate(),
+        Description: localizedTemplate(),
+        IconPath: "",
+        Tags: ["archetype"],
+      },
+      Tiers: [
+        {
+          RequiredCount: 1,
+          Modifiers: modifiersTemplate(),
+        },
+      ],
+    }),
+  },
+  "traits.json": {
+    title: "Traits",
+    description: "Individual traits with modifier bundles and rules.",
+    fields: ["Header", "Modifiers"],
+    templateType: "array",
+    template: () => ({
+      Header: {
+        Id: "core:trait_new",
+        Name: localizedTemplate(),
+        Description: localizedTemplate(),
+        IconPath: "",
+        Tags: ["trait"],
+      },
+      Modifiers: modifiersTemplate(),
+    }),
+  },
+  "campus_behavior.json": {
+    title: "Campus behavior",
+    description: "Global thresholds and action configs for campus AI.",
+    fields: [
+      "CriticalSanityThreshold",
+      "CriticalStaminaThreshold",
+      "CriticalStressThreshold",
+      "HungerThreshold",
+      "EnergyThreshold",
+      "SocialThreshold",
+      "LowMoodThreshold",
+      "HungerDecayPerSecond",
+      "EnergyDecayPerSecond",
+      "StaminaDecayPerSecond",
+      "StressGrowthPerSecond",
+      "SocialDecayPerSecond",
+      "DecisionIntervalSeconds",
+      "ActionDurationVariance",
+      "MinPlannedActionSeconds",
+      "ActionConfigs",
+    ],
+    templateType: "object",
+    template: () => ({
+      CriticalSanityThreshold: 0,
+      CriticalStaminaThreshold: 0,
+      CriticalStressThreshold: 0,
+      HungerThreshold: 0,
+      EnergyThreshold: 0,
+      SocialThreshold: 0,
+      LowMoodThreshold: 0,
+      HungerDecayPerSecond: 0.0,
+      EnergyDecayPerSecond: 0.0,
+      StaminaDecayPerSecond: 0.0,
+      StressGrowthPerSecond: 0.0,
+      SocialDecayPerSecond: 0.0,
+      DecisionIntervalSeconds: 0.0,
+      ActionDurationVariance: 0.0,
+      MinPlannedActionSeconds: 0.0,
+      ActionConfigs: [],
+    }),
+  },
+};
+
+const tresGuide = {
+  title: "Discipline resource",
+  description: "Godot resource-based discipline definition.",
+  fields: [
+    "Id",
+    "NameKey",
+    "NameFallback",
+    "DescriptionKey",
+    "DescriptionFallback",
+    "IconPath",
+    "Tags",
+    "BuffNameKey",
+    "BuffNameFallback",
+    "BuffDescriptionKey",
+    "BuffDescriptionFallback",
+    "BuffRuleIds",
+    "RolePoolIds",
+    "ItemPoolIds",
+    "TaskKeywordIds",
+  ],
+  templateType: "object",
+  template: () => ({
+    Id: "core:discipline_new_tres",
+    NameKey: "",
+    NameFallback: "",
+    DescriptionKey: "",
+    DescriptionFallback: "",
+    IconPath: "",
+    Tags: ["discipline"],
+    BuffNameKey: "",
+    BuffNameFallback: "",
+    BuffDescriptionKey: "",
+    BuffDescriptionFallback: "",
+    BuffRuleIds: [],
+    RolePoolIds: [],
+    ItemPoolIds: [],
+    TaskKeywordIds: [],
+  }),
+};
+
+const idPattern = /^[a-z0-9_]+:[a-z0-9_]+$/;
+
+const getGuideForFile = (filename) => {
+  if (filename.endsWith(".tres")) {
+    return tresGuide;
+  }
+  return definitionGuides[filename] || null;
+};
+
+const renderGuide = (guide, filename, content) => {
+  if (!guide) {
+    elements.guideTitle.textContent = "No definition selected";
+    elements.guideDesc.textContent = "Select a definition file to see expected fields.";
+    elements.guideFields.innerHTML = "";
+    return;
+  }
+  const entryLabel = Array.isArray(content)
+    ? `${content.length} entries`
+    : "single object";
+  elements.guideTitle.textContent = `${guide.title} (${filename})`;
+  elements.guideDesc.textContent = `${guide.description} (${entryLabel}).`;
+  elements.guideFields.innerHTML = "";
+  guide.fields.forEach((field) => {
+    const chip = document.createElement("span");
+    chip.className = "guide-field";
+    chip.textContent = field;
+    elements.guideFields.appendChild(chip);
+  });
+};
+
+const setGuideButtons = ({ enabled, hasTemplate }) => {
+  elements.insertTemplateButton.disabled = !enabled || !hasTemplate;
+  elements.validateFileButton.disabled = !enabled;
+  elements.validateAllButton.disabled = !state.definitions.length;
+};
+
+const clearValidation = () => {
+  elements.validationOutput.textContent = "";
+  elements.validationOutput.classList.add("hidden");
+};
+
+const renderValidation = (issues) => {
+  elements.validationOutput.classList.remove("hidden");
+  if (!issues.length) {
+    elements.validationOutput.textContent = "No issues found.";
+    return;
+  }
+  elements.validationOutput.textContent = issues
+    .map((issue) => `[${issue.level.toUpperCase()}] ${issue.file}: ${issue.message}`)
+    .join("\n");
+};
+
 const createNavItem = (file, isActive, onClick) => {
   const button = document.createElement("button");
   button.className = "nav-item";
@@ -94,26 +339,650 @@ const renderLists = () => {
   elements.rulesList.innerHTML = "";
   defFiles.forEach((file) => {
     elements.definitionsList.appendChild(
-      createNavItem(file, state.activeType === "definition" && state.activeFile === file, openDefinition),
+      createNavItem(
+        file,
+        state.activeType === "definition" && state.activeFile === file,
+        openDefinition,
+      ),
     );
   });
   ruleFiles.forEach((file) => {
     elements.rulesList.appendChild(
-      createNavItem(file, state.activeType === "rule" && state.activeFile === file, openRule),
+      createNavItem(
+        file,
+        state.activeType === "rule" && state.activeFile === file,
+        openRule,
+      ),
     );
   });
 
   elements.definitionsCount.textContent = String(defFiles.length);
   elements.rulesCount.textContent = String(ruleFiles.length);
+  setGuideButtons({
+    enabled: state.activeType === "definition" && !!state.activeFile,
+    hasTemplate: !!getGuideForFile(state.activeFile || "")?.template,
+  });
 };
 
 const setEditorState = ({ title, subtitle, content, mode }) => {
   elements.editorTitle.textContent = title;
   elements.editorSubtitle.textContent = subtitle;
   elements.editorTextarea.value = content;
-  elements.formatButton.classList.toggle("hidden", mode !== "definition");
+  elements.formatButton.classList.toggle(
+    "hidden",
+    mode !== "definition" || state.viewMode !== "raw",
+  );
 };
 
+const setGuideState = ({ mode, filename, content }) => {
+  clearValidation();
+  if (mode !== "definition" || !filename) {
+    renderGuide(null, "", null);
+    setGuideButtons({ enabled: false, hasTemplate: false });
+    return;
+  }
+  const guide = getGuideForFile(filename);
+  renderGuide(guide, filename, content);
+  setGuideButtons({ enabled: true, hasTemplate: !!guide?.template });
+};
+
+const setViewMode = (mode, { skipRender } = { skipRender: false }) => {
+  state.viewMode = mode;
+  elements.rawEditor.classList.toggle("hidden", mode === "structured");
+  elements.structuredEditor.classList.toggle("hidden", mode !== "structured");
+  elements.viewRawButton.classList.toggle("active", mode === "raw");
+  elements.viewStructuredButton.classList.toggle("active", mode === "structured");
+  elements.formatButton.classList.toggle(
+    "hidden",
+    state.activeType !== "definition" || mode !== "raw",
+  );
+
+  if (mode === "structured" && !skipRender) {
+    const ok = syncContentFromRaw();
+    if (!ok) {
+      setStatus("Invalid JSON. Fix errors before opening structured editor.", true);
+      setViewMode("raw", { skipRender: true });
+      return;
+    }
+    renderStructuredEditor();
+  }
+};
+
+const updateViewButtons = () => {
+  const allowStructured = state.activeType === "definition";
+  elements.viewStructuredButton.disabled = !allowStructured;
+  if (!allowStructured) {
+    setViewMode("raw", { skipRender: true });
+  }
+};
+
+const syncContentFromRaw = () => {
+  if (state.activeType !== "definition") {
+    return false;
+  }
+  try {
+    state.currentContent = JSON.parse(elements.editorTextarea.value);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+
+const syncRawFromContent = () => {
+  if (state.activeType !== "definition") {
+    return;
+  }
+  elements.editorTextarea.value = JSON.stringify(state.currentContent ?? {}, null, 2);
+};
+
+const createSection = (title) => {
+  const section = document.createElement("div");
+  section.className = "form-section";
+  const heading = document.createElement("h3");
+  heading.textContent = title;
+  section.appendChild(heading);
+  return section;
+};
+
+const createRow = (label, input) => {
+  const row = document.createElement("div");
+  row.className = "form-row";
+  const labelEl = document.createElement("div");
+  labelEl.className = "form-label";
+  labelEl.textContent = label;
+  row.appendChild(labelEl);
+  row.appendChild(input);
+  return row;
+};
+
+const createTextInput = (value, onChange) => {
+  const input = document.createElement("input");
+  input.className = "form-input";
+  input.type = "text";
+  input.value = value ?? "";
+  input.addEventListener("input", () => onChange(input.value));
+  return input;
+};
+
+const createNumberInput = (value, onChange) => {
+  const input = document.createElement("input");
+  input.className = "form-input";
+  input.type = "number";
+  input.step = "any";
+  input.value = value ?? 0;
+  input.addEventListener("input", () => {
+    const parsed = Number(input.value);
+    onChange(Number.isNaN(parsed) ? 0 : parsed);
+  });
+  return input;
+};
+
+const createCheckboxInput = (value, onChange) => {
+  const input = document.createElement("input");
+  input.className = "form-input";
+  input.type = "checkbox";
+  input.checked = Boolean(value);
+  input.addEventListener("change", () => onChange(input.checked));
+  return input;
+};
+
+const createArrayInput = (value, onChange) => {
+  const input = document.createElement("input");
+  input.className = "form-input";
+  input.type = "text";
+  input.value = Array.isArray(value) ? value.join(", ") : "";
+  input.addEventListener("input", () => {
+    const parts = input.value
+      .split(",")
+      .map((item) => item.trim())
+      .filter((item) => item.length > 0);
+    onChange(parts);
+  });
+  return input;
+};
+
+const ensureObject = (target, key, fallback) => {
+  if (!target[key] || typeof target[key] !== "object" || Array.isArray(target[key])) {
+    target[key] = fallback;
+  }
+  return target[key];
+};
+
+const ensureLocalized = (target, key) => {
+  return ensureObject(target, key, localizedTemplate());
+};
+
+const ensureModifiers = (target, key) => {
+  return ensureObject(target, key, modifiersTemplate());
+};
+
+const renderArrayEditor = (options) => {
+  const { title, items, fields, onChange } = options;
+  const section = createSection(title);
+  const listContainer = document.createElement("div");
+
+  const rebuild = () => {
+    listContainer.innerHTML = "";
+    items.forEach((item, index) => {
+      const row = document.createElement("div");
+      row.className = "array-row";
+      fields.forEach((field) => {
+        const input = field.type === "number"
+          ? createNumberInput(item[field.key], (value) => {
+              item[field.key] = value;
+              onChange();
+            })
+          : createTextInput(item[field.key], (value) => {
+              item[field.key] = value;
+              onChange();
+            });
+        input.placeholder = field.label;
+        row.appendChild(input);
+      });
+      const remove = document.createElement("button");
+      remove.className = "ghost";
+      remove.textContent = "Remove";
+      remove.addEventListener("click", () => {
+        items.splice(index, 1);
+        onChange(true);
+      });
+      row.appendChild(remove);
+      listContainer.appendChild(row);
+    });
+  };
+
+  const addButton = document.createElement("button");
+  addButton.className = "ghost";
+  addButton.textContent = `Add ${title}`;
+  addButton.addEventListener("click", () => {
+    const newItem = {};
+    fields.forEach((field) => {
+      newItem[field.key] = field.defaultValue ?? (field.type === "number" ? 0 : "");
+    });
+    items.push(newItem);
+    onChange(true);
+  });
+
+  rebuild();
+  section.appendChild(listContainer);
+  section.appendChild(addButton);
+  return section;
+};
+
+const renderModifiersSection = (modifiers, onChange) => {
+  const section = createSection("Modifiers");
+  const attributeSection = renderArrayEditor({
+    title: "AttributeModifiers",
+    items: modifiers.AttributeModifiers || [],
+    fields: [
+      { key: "Type", label: "Type" },
+      { key: "Add", label: "Add", type: "number", defaultValue: 0 },
+      { key: "Multiplier", label: "Multiplier", type: "number", defaultValue: 1.0 },
+    ],
+    onChange,
+  });
+  const statusSection = renderArrayEditor({
+    title: "StatusModifiers",
+    items: modifiers.StatusModifiers || [],
+    fields: [
+      { key: "Type", label: "Type" },
+      { key: "Add", label: "Add", type: "number", defaultValue: 0 },
+      { key: "Multiplier", label: "Multiplier", type: "number", defaultValue: 1.0 },
+    ],
+    onChange,
+  });
+  const resourceSection = renderArrayEditor({
+    title: "ResourceModifiers",
+    items: modifiers.ResourceModifiers || [],
+    fields: [
+      { key: "Type", label: "Type" },
+      { key: "Add", label: "Add", type: "number", defaultValue: 0 },
+      { key: "Multiplier", label: "Multiplier", type: "number", defaultValue: 1.0 },
+    ],
+    onChange,
+  });
+  const ruleIdsRow = createRow(
+    "RuleIds",
+    createArrayInput(modifiers.RuleIds || [], (value) => {
+      modifiers.RuleIds = value;
+      onChange();
+    }),
+  );
+
+  section.appendChild(attributeSection);
+  section.appendChild(statusSection);
+  section.appendChild(resourceSection);
+  section.appendChild(ruleIdsRow);
+  return section;
+};
+
+const renderHeaderSection = (entry, onChange) => {
+  const header = ensureObject(entry, "Header", {});
+  const name = ensureLocalized(header, "Name");
+  const description = ensureLocalized(header, "Description");
+
+  const section = createSection("Header");
+  section.appendChild(
+    createRow(
+      "Id",
+      createTextInput(header.Id, (value) => {
+        header.Id = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Name.Key",
+      createTextInput(name.Key, (value) => {
+        name.Key = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Name.Fallback",
+      createTextInput(name.Fallback, (value) => {
+        name.Fallback = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Description.Key",
+      createTextInput(description.Key, (value) => {
+        description.Key = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Description.Fallback",
+      createTextInput(description.Fallback, (value) => {
+        description.Fallback = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "IconPath",
+      createTextInput(header.IconPath, (value) => {
+        header.IconPath = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Tags",
+      createArrayInput(header.Tags || [], (value) => {
+        header.Tags = value;
+        onChange();
+      }),
+    ),
+  );
+  return section;
+};
+
+const renderBuffSection = (entry, onChange) => {
+  const buff = ensureObject(entry, "Buff", {});
+  const name = ensureLocalized(buff, "Name");
+  const description = ensureLocalized(buff, "Description");
+  const modifiers = ensureModifiers(buff, "Modifiers");
+
+  const section = createSection("Buff");
+  section.appendChild(
+    createRow(
+      "Name.Key",
+      createTextInput(name.Key, (value) => {
+        name.Key = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Name.Fallback",
+      createTextInput(name.Fallback, (value) => {
+        name.Fallback = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Description.Key",
+      createTextInput(description.Key, (value) => {
+        description.Key = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(
+    createRow(
+      "Description.Fallback",
+      createTextInput(description.Fallback, (value) => {
+        description.Fallback = value;
+        onChange();
+      }),
+    ),
+  );
+  section.appendChild(renderModifiersSection(modifiers, onChange));
+  return section;
+};
+
+const renderTierSection = (tiers, onChange) => {
+  const section = createSection("Tiers");
+  const tierList = document.createElement("div");
+
+  const rebuild = () => {
+    tierList.innerHTML = "";
+    tiers.forEach((tier, index) => {
+      const tierSection = document.createElement("div");
+      tierSection.className = "form-section";
+      const heading = document.createElement("h3");
+      heading.textContent = `Tier ${index + 1}`;
+      tierSection.appendChild(heading);
+      tierSection.appendChild(
+        createRow(
+          "RequiredCount",
+          createNumberInput(tier.RequiredCount, (value) => {
+            tier.RequiredCount = value;
+            onChange();
+          }),
+        ),
+      );
+      const modifiers = ensureModifiers(tier, "Modifiers");
+      tierSection.appendChild(renderModifiersSection(modifiers, onChange));
+      const remove = document.createElement("button");
+      remove.className = "ghost";
+      remove.textContent = "Remove tier";
+      remove.addEventListener("click", () => {
+        tiers.splice(index, 1);
+        onChange(true);
+      });
+      tierSection.appendChild(remove);
+      tierList.appendChild(tierSection);
+    });
+  };
+
+  const addButton = document.createElement("button");
+  addButton.className = "ghost";
+  addButton.textContent = "Add tier";
+  addButton.addEventListener("click", () => {
+    tiers.push({ RequiredCount: 1, Modifiers: modifiersTemplate() });
+    onChange(true);
+  });
+
+  rebuild();
+  section.appendChild(tierList);
+  section.appendChild(addButton);
+  return section;
+};
+
+const renderDefinitionEntryForm = (filename, entry) => {
+  elements.structuredForm.innerHTML = "";
+  const onChange = (rerender) => {
+    syncRawFromContent();
+    if (rerender) {
+      renderStructuredEditor();
+    }
+  };
+
+  elements.structuredForm.appendChild(renderHeaderSection(entry, onChange));
+
+  if (filename === "disciplines.json") {
+    elements.structuredForm.appendChild(renderBuffSection(entry, onChange));
+    elements.structuredForm.appendChild(
+      createRow(
+        "RolePoolIds",
+        createArrayInput(entry.RolePoolIds || [], (value) => {
+          entry.RolePoolIds = value;
+          onChange();
+        }),
+      ),
+    );
+    elements.structuredForm.appendChild(
+      createRow(
+        "ItemPoolIds",
+        createArrayInput(entry.ItemPoolIds || [], (value) => {
+          entry.ItemPoolIds = value;
+          onChange();
+        }),
+      ),
+    );
+    elements.structuredForm.appendChild(
+      createRow(
+        "TaskKeywordIds",
+        createArrayInput(entry.TaskKeywordIds || [], (value) => {
+          entry.TaskKeywordIds = value;
+          onChange();
+        }),
+      ),
+    );
+  }
+
+  if (filename === "roles.json" || filename === "archetypes.json") {
+    entry.Tiers = Array.isArray(entry.Tiers) ? entry.Tiers : [];
+    elements.structuredForm.appendChild(renderTierSection(entry.Tiers, onChange));
+  }
+
+  if (filename === "roles.json") {
+    elements.structuredForm.appendChild(
+      createRow(
+        "AllowedDisciplineIds",
+        createArrayInput(entry.AllowedDisciplineIds || [], (value) => {
+          entry.AllowedDisciplineIds = value;
+          onChange();
+        }),
+      ),
+    );
+  }
+
+  if (filename === "traits.json") {
+    const modifiers = ensureModifiers(entry, "Modifiers");
+    elements.structuredForm.appendChild(renderModifiersSection(modifiers, onChange));
+  }
+};
+
+const renderCampusBehaviorForm = (content) => {
+  elements.structuredForm.innerHTML = "";
+  const onChange = (rerender) => {
+    syncRawFromContent();
+    if (rerender) {
+      renderStructuredEditor();
+    }
+  };
+  const fields = definitionGuides["campus_behavior.json"].fields.filter(
+    (field) => field !== "ActionConfigs",
+  );
+  const section = createSection("Global settings");
+  fields.forEach((field) => {
+    section.appendChild(
+      createRow(
+        field,
+        createNumberInput(content[field], (value) => {
+          content[field] = value;
+          onChange();
+        }),
+      ),
+    );
+  });
+  elements.structuredForm.appendChild(section);
+
+  content.ActionConfigs = Array.isArray(content.ActionConfigs) ? content.ActionConfigs : [];
+  const actionSection = renderArrayEditor({
+    title: "ActionConfigs",
+    items: content.ActionConfigs,
+    fields: [
+      { key: "ActionId", label: "ActionId" },
+      { key: "LocationId", label: "LocationId" },
+      { key: "DurationSeconds", label: "DurationSeconds", type: "number", defaultValue: 0 },
+      { key: "HungerDelta", label: "HungerDelta", type: "number", defaultValue: 0 },
+      { key: "EnergyDelta", label: "EnergyDelta", type: "number", defaultValue: 0 },
+      { key: "StaminaDelta", label: "StaminaDelta", type: "number", defaultValue: 0 },
+      { key: "StressDelta", label: "StressDelta", type: "number", defaultValue: 0 },
+      { key: "MoodDelta", label: "MoodDelta", type: "number", defaultValue: 0 },
+      { key: "SocialDelta", label: "SocialDelta", type: "number", defaultValue: 0 },
+      { key: "SanityDelta", label: "SanityDelta", type: "number", defaultValue: 0 },
+      { key: "HealthDelta", label: "HealthDelta", type: "number", defaultValue: 0 },
+    ],
+    onChange,
+  });
+  elements.structuredForm.appendChild(actionSection);
+};
+
+const renderTresForm = (content) => {
+  elements.structuredForm.innerHTML = "";
+  const onChange = () => {
+    syncRawFromContent();
+  };
+  const section = createSection("Resource fields");
+  tresGuide.fields.forEach((field) => {
+    let input;
+    const value = content[field];
+    if (Array.isArray(value)) {
+      input = createArrayInput(value, (list) => {
+        content[field] = list;
+        onChange();
+      });
+    } else if (typeof value === "number") {
+      input = createNumberInput(value, (next) => {
+        content[field] = next;
+        onChange();
+      });
+    } else if (typeof value === "boolean") {
+      input = createCheckboxInput(value, (next) => {
+        content[field] = next;
+        onChange();
+      });
+    } else {
+      input = createTextInput(value ?? "", (next) => {
+        content[field] = next;
+        onChange();
+      });
+    }
+    section.appendChild(createRow(field, input));
+  });
+  elements.structuredForm.appendChild(section);
+};
+
+const renderStructuredEditor = () => {
+  if (state.activeType !== "definition" || !state.activeFile) {
+    return;
+  }
+  const filename = state.activeFile;
+  const content = state.currentContent;
+  if (!content) {
+    return;
+  }
+
+  if (filename === "campus_behavior.json") {
+    elements.entrySelect.classList.add("hidden");
+    elements.addEntryButton.classList.add("hidden");
+    elements.deleteEntryButton.classList.add("hidden");
+    renderCampusBehaviorForm(content);
+    return;
+  }
+
+  if (filename.endsWith(".tres")) {
+    elements.entrySelect.classList.add("hidden");
+    elements.addEntryButton.classList.add("hidden");
+    elements.deleteEntryButton.classList.add("hidden");
+    renderTresForm(content);
+    return;
+  }
+
+  if (!Array.isArray(content)) {
+    elements.structuredForm.innerHTML = "";
+    return;
+  }
+
+  elements.entrySelect.classList.remove("hidden");
+  elements.addEntryButton.classList.remove("hidden");
+  elements.deleteEntryButton.classList.remove("hidden");
+
+  elements.entrySelect.innerHTML = "";
+  content.forEach((entry, index) => {
+    const option = document.createElement("option");
+    const entryId = entry?.Header?.Id || `Entry ${index + 1}`;
+    option.value = String(index);
+    option.textContent = entryId;
+    elements.entrySelect.appendChild(option);
+  });
+  if (state.activeEntryIndex >= content.length) {
+    state.activeEntryIndex = 0;
+  }
+  elements.entrySelect.value = String(state.activeEntryIndex);
+  const entry = content[state.activeEntryIndex];
+  if (entry) {
+    renderDefinitionEntryForm(filename, entry);
+  }
+};
 const openDefinition = async (filename) => {
   try {
     setStatus("Loading definition...");
@@ -123,6 +992,8 @@ const openDefinition = async (filename) => {
     ]);
     state.activeType = "definition";
     state.activeFile = filename;
+    state.currentContent = contentResponse.content || {};
+    state.activeEntryIndex = 0;
     renderLists();
     const rawContent = JSON.stringify(contentResponse.content || {}, null, 2);
     setEditorState({
@@ -132,6 +1003,15 @@ const openDefinition = async (filename) => {
       mode: "definition",
     });
     renderSchema(schemaResponse.schema);
+    setGuideState({
+      mode: "definition",
+      filename,
+      content: contentResponse.content,
+    });
+    updateViewButtons();
+    if (state.viewMode === "structured") {
+      renderStructuredEditor();
+    }
     setStatus("Definition loaded.");
   } catch (err) {
     setStatus(err.message || "Failed to load definition.", true);
@@ -146,6 +1026,7 @@ const openRule = async (filename) => {
     );
     state.activeType = "rule";
     state.activeFile = filename;
+    state.currentContent = null;
     renderLists();
     setEditorState({
       title: filename,
@@ -154,6 +1035,9 @@ const openRule = async (filename) => {
       mode: "rule",
     });
     clearSchema();
+    setGuideState({ mode: "rule", filename: null, content: null });
+    updateViewButtons();
+    setViewMode("raw", { skipRender: true });
     setStatus("Rule loaded.");
   } catch (err) {
     setStatus(err.message || "Failed to load rule.", true);
@@ -231,6 +1115,331 @@ const formatJson = () => {
   }
 };
 
+const mergeMissing = (target, template) => {
+  const output = Array.isArray(target) ? [...target] : { ...target };
+  Object.keys(template).forEach((key) => {
+    const value = template[key];
+    if (!(key in output)) {
+      output[key] = value;
+      return;
+    }
+    const current = output[key];
+    if (
+      value &&
+      typeof value === "object" &&
+      !Array.isArray(value) &&
+      current &&
+      typeof current === "object" &&
+      !Array.isArray(current)
+    ) {
+      output[key] = mergeMissing(current, value);
+    }
+  });
+  return output;
+};
+
+const insertTemplate = () => {
+  if (state.activeType !== "definition" || !state.activeFile) {
+    setStatus("Select a definition file first.", true);
+    return;
+  }
+  const guide = getGuideForFile(state.activeFile);
+  if (!guide || !guide.template) {
+    setStatus("No template available for this file.", true);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(elements.editorTextarea.value);
+  } catch (err) {
+    setStatus("Invalid JSON. Fix errors before inserting template.", true);
+    return;
+  }
+  const templateValue = guide.template();
+  if (guide.templateType === "array") {
+    if (!Array.isArray(parsed)) {
+      setStatus("Expected a JSON array for this definition file.", true);
+      return;
+    }
+    parsed.push(templateValue);
+  } else {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      setStatus("Expected a JSON object for this definition file.", true);
+      return;
+    }
+    parsed = mergeMissing(parsed, templateValue);
+  }
+  elements.editorTextarea.value = JSON.stringify(parsed, null, 2);
+  state.currentContent = parsed;
+  if (state.viewMode === "structured") {
+    renderStructuredEditor();
+  }
+  setStatus("Template inserted.");
+};
+
+const validateLocalizedText = (value, path, issues) => {
+  if (!value || typeof value !== "object") {
+    issues.push({ level: "error", file: path, message: "LocalizedText missing." });
+    return;
+  }
+  if (!value.Fallback) {
+    issues.push({ level: "warn", file: path, message: "Fallback is empty." });
+  }
+  if (!value.Key) {
+    issues.push({ level: "warn", file: path, message: "Key is empty." });
+  }
+};
+
+const validateModifiers = (modifiers, path, issues) => {
+  if (!modifiers || typeof modifiers !== "object") {
+    issues.push({ level: "warn", file: path, message: "Modifiers missing." });
+    return;
+  }
+  ["AttributeModifiers", "StatusModifiers", "ResourceModifiers", "RuleIds"].forEach(
+    (key) => {
+      if (key in modifiers && !Array.isArray(modifiers[key])) {
+        issues.push({
+          level: "error",
+          file: path,
+          message: `${key} should be an array.`,
+        });
+      }
+    },
+  );
+};
+
+const validateDefinitionArray = (filename, content) => {
+  const issues = [];
+  if (!Array.isArray(content)) {
+    issues.push({ level: "error", file: filename, message: "Expected an array." });
+    return issues;
+  }
+  const requiredFields = definitionGuides[filename]?.fields || [];
+  const ids = new Set();
+  content.forEach((entry, index) => {
+    const entryPath = `${filename}[${index}]`;
+    if (!entry || typeof entry !== "object") {
+      issues.push({ level: "error", file: entryPath, message: "Entry is not an object." });
+      return;
+    }
+    requiredFields.forEach((field) => {
+      if (!(field in entry)) {
+        issues.push({ level: "error", file: entryPath, message: `${field} missing.` });
+      }
+    });
+    const header = entry.Header;
+    if (!header || typeof header !== "object") {
+      issues.push({ level: "error", file: entryPath, message: "Header missing." });
+    } else {
+      const id = header.Id;
+      if (!id) {
+        issues.push({ level: "error", file: entryPath, message: "Header.Id missing." });
+      } else {
+        if (!idPattern.test(id)) {
+          issues.push({
+            level: "warn",
+            file: entryPath,
+            message: `Header.Id format is unusual (${id}).`,
+          });
+        }
+        if (ids.has(id)) {
+          issues.push({
+            level: "error",
+            file: entryPath,
+            message: `Duplicate Header.Id ${id}.`,
+          });
+        }
+        ids.add(id);
+      }
+      validateLocalizedText(header.Name, `${entryPath}.Header.Name`, issues);
+      validateLocalizedText(header.Description, `${entryPath}.Header.Description`, issues);
+      if (header.Tags && !Array.isArray(header.Tags)) {
+        issues.push({
+          level: "error",
+          file: entryPath,
+          message: "Header.Tags should be an array.",
+        });
+      }
+    }
+
+    if (entry.Tiers) {
+      if (!Array.isArray(entry.Tiers)) {
+        issues.push({ level: "error", file: entryPath, message: "Tiers should be an array." });
+      } else {
+        entry.Tiers.forEach((tier, tierIndex) => {
+          const tierPath = `${entryPath}.Tiers[${tierIndex}]`;
+          if (tier.RequiredCount == null) {
+            issues.push({ level: "warn", file: tierPath, message: "RequiredCount missing." });
+          }
+          validateModifiers(tier.Modifiers, `${tierPath}.Modifiers`, issues);
+        });
+      }
+    }
+
+    if (entry.Modifiers) {
+      validateModifiers(entry.Modifiers, `${entryPath}.Modifiers`, issues);
+    }
+
+    if (entry.Buff) {
+      validateLocalizedText(entry.Buff.Name, `${entryPath}.Buff.Name`, issues);
+      validateLocalizedText(entry.Buff.Description, `${entryPath}.Buff.Description`, issues);
+      validateModifiers(entry.Buff.Modifiers, `${entryPath}.Buff.Modifiers`, issues);
+    }
+
+    ["RolePoolIds", "ItemPoolIds", "TaskKeywordIds", "AllowedDisciplineIds"].forEach(
+      (field) => {
+        if (field in entry && !Array.isArray(entry[field])) {
+          issues.push({
+            level: "error",
+            file: entryPath,
+            message: `${field} should be an array.`,
+          });
+        }
+      },
+    );
+  });
+  return issues;
+};
+
+const validateCampusBehavior = (filename, content) => {
+  const issues = [];
+  if (!content || typeof content !== "object" || Array.isArray(content)) {
+    issues.push({ level: "error", file: filename, message: "Expected an object." });
+    return issues;
+  }
+  const requiredFields = definitionGuides[filename]?.fields || [];
+  requiredFields.forEach((field) => {
+    if (!(field in content)) {
+      issues.push({ level: "error", file: filename, message: `${field} missing.` });
+    }
+  });
+  if (content.ActionConfigs && !Array.isArray(content.ActionConfigs)) {
+    issues.push({ level: "error", file: filename, message: "ActionConfigs should be an array." });
+  }
+  (content.ActionConfigs || []).forEach((action, index) => {
+    const actionPath = `${filename}.ActionConfigs[${index}]`;
+    ["ActionId", "LocationId", "DurationSeconds"].forEach((field) => {
+      if (!(field in action)) {
+        issues.push({ level: "error", file: actionPath, message: `${field} missing.` });
+      }
+    });
+    [
+      "HungerDelta",
+      "EnergyDelta",
+      "StaminaDelta",
+      "StressDelta",
+      "MoodDelta",
+      "SocialDelta",
+      "SanityDelta",
+      "HealthDelta",
+    ].forEach((field) => {
+      if (!(field in action)) {
+        issues.push({ level: "warn", file: actionPath, message: `${field} missing.` });
+      }
+    });
+  });
+  return issues;
+};
+
+const validateTres = (filename, content) => {
+  const issues = [];
+  if (!content || typeof content !== "object" || Array.isArray(content)) {
+    issues.push({ level: "error", file: filename, message: "Expected an object." });
+    return issues;
+  }
+  tresGuide.fields.forEach((field) => {
+    if (!(field in content)) {
+      issues.push({ level: "warn", file: filename, message: `${field} missing.` });
+    }
+  });
+  if (content.Id && !idPattern.test(content.Id)) {
+    issues.push({
+      level: "warn",
+      file: filename,
+      message: `Id format is unusual (${content.Id}).`,
+    });
+  }
+  if (content.Tags && !Array.isArray(content.Tags)) {
+    issues.push({ level: "error", file: filename, message: "Tags should be an array." });
+  }
+  return issues;
+};
+
+const validateDefinitionContent = (filename, content) => {
+  if (filename === "campus_behavior.json") {
+    return validateCampusBehavior(filename, content);
+  }
+  if (filename.endsWith(".tres")) {
+    return validateTres(filename, content);
+  }
+  return validateDefinitionArray(filename, content);
+};
+
+const extractDefinitionIds = (filename, content) => {
+  if (filename.endsWith(".tres") && content && typeof content === "object") {
+    return content.Id ? [content.Id] : [];
+  }
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content
+    .map((entry) => entry?.Header?.Id)
+    .filter((value) => typeof value === "string" && value.length > 0);
+};
+
+const validateFile = () => {
+  if (state.activeType !== "definition" || !state.activeFile) {
+    setStatus("Select a definition file to validate.", true);
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(elements.editorTextarea.value);
+  } catch (err) {
+    setStatus("Invalid JSON. Fix errors before validating.", true);
+    return;
+  }
+  const issues = validateDefinitionContent(state.activeFile, parsed);
+  renderValidation(issues);
+  setStatus(issues.length ? "Validation complete with issues." : "Validation passed.");
+};
+
+const validateAll = async () => {
+  if (!state.definitions.length) {
+    await refreshAll();
+  }
+  const issues = [];
+  const idIndex = new Map();
+  for (const file of state.definitions) {
+    try {
+      const response = await fetchJson(
+        `/api/files/content?filename=${encodeURIComponent(file)}`,
+      );
+      const content = response.content;
+      validateDefinitionContent(file, content).forEach((issue) => issues.push(issue));
+      extractDefinitionIds(file, content).forEach((id) => {
+        if (!idIndex.has(id)) {
+          idIndex.set(id, []);
+        }
+        idIndex.get(id).push(file);
+      });
+    } catch (err) {
+      issues.push({ level: "error", file, message: err.message || "Failed to load file." });
+    }
+  }
+  idIndex.forEach((files, id) => {
+    if (files.length > 1) {
+      issues.push({
+        level: "error",
+        file: files.join(", "),
+        message: `Duplicate Id across files: ${id}`,
+      });
+    }
+  });
+  renderValidation(issues);
+  setStatus(issues.length ? "Validation complete with issues." : "Validation passed.");
+};
+
 const createRule = async () => {
   const ruleId = elements.newRuleInput.value.trim();
   if (!ruleId) {
@@ -266,6 +1475,37 @@ const buildGame = async () => {
   }
 };
 
+const changeEntrySelection = () => {
+  const index = Number(elements.entrySelect.value);
+  if (Number.isNaN(index)) {
+    return;
+  }
+  state.activeEntryIndex = index;
+  renderStructuredEditor();
+};
+
+const addEntry = () => {
+  if (!Array.isArray(state.currentContent)) {
+    return;
+  }
+  const guide = getGuideForFile(state.activeFile || "");
+  const template = guide?.template ? guide.template() : { Header: { Id: "" } };
+  state.currentContent.push(template);
+  state.activeEntryIndex = state.currentContent.length - 1;
+  syncRawFromContent();
+  renderStructuredEditor();
+};
+
+const deleteEntry = () => {
+  if (!Array.isArray(state.currentContent)) {
+    return;
+  }
+  state.currentContent.splice(state.activeEntryIndex, 1);
+  state.activeEntryIndex = Math.max(0, state.activeEntryIndex - 1);
+  syncRawFromContent();
+  renderStructuredEditor();
+};
+
 const init = () => {
   elements.refreshButton.addEventListener("click", refreshAll);
   elements.filterInput.addEventListener("input", renderLists);
@@ -273,7 +1513,17 @@ const init = () => {
   elements.formatButton.addEventListener("click", formatJson);
   elements.createRuleButton.addEventListener("click", createRule);
   elements.buildButton.addEventListener("click", buildGame);
+  elements.insertTemplateButton.addEventListener("click", insertTemplate);
+  elements.validateFileButton.addEventListener("click", validateFile);
+  elements.validateAllButton.addEventListener("click", validateAll);
+  elements.viewRawButton.addEventListener("click", () => setViewMode("raw"));
+  elements.viewStructuredButton.addEventListener("click", () => setViewMode("structured"));
+  elements.entrySelect.addEventListener("change", changeEntrySelection);
+  elements.addEntryButton.addEventListener("click", addEntry);
+  elements.deleteEntryButton.addEventListener("click", deleteEntry);
   refreshAll();
+  setGuideState({ mode: null, filename: null, content: null });
+  setViewMode("raw", { skipRender: true });
   setStatus("Ready.");
 };
 
diff --git a/tools/ndbs/server/web/index.html b/tools/ndbs/server/web/index.html
index 8a075a7..756d1c1 100644
--- a/tools/ndbs/server/web/index.html
+++ b/tools/ndbs/server/web/index.html
@@ -53,6 +53,21 @@
           <div id="build-output" class="build-output"></div>
         </section>
 
+        <section class="panel guide">
+          <div class="panel-title">Definition guide</div>
+          <div id="guide-title" class="guide-title">No definition selected</div>
+          <div id="guide-desc" class="guide-desc">
+            Select a definition file to see expected fields and templates.
+          </div>
+          <div id="guide-fields" class="guide-fields"></div>
+          <div class="guide-actions">
+            <button id="insert-template" class="ghost">Insert template</button>
+            <button id="validate-file">Validate file</button>
+            <button id="validate-all" class="ghost">Validate all</button>
+          </div>
+          <div id="validation-output" class="build-output hidden"></div>
+        </section>
+
         <section class="panel editor-panel">
           <div class="editor-header">
             <div>
@@ -62,17 +77,31 @@
               </div>
             </div>
             <div class="editor-actions">
+              <div class="view-toggle">
+                <button id="view-raw" class="ghost">Raw</button>
+                <button id="view-structured">Structured</button>
+              </div>
               <button id="format-button" class="ghost">Format</button>
               <button id="save-button">Save</button>
             </div>
           </div>
           <div id="schema-summary" class="schema-summary hidden"></div>
-          <textarea
-            id="editor-textarea"
-            class="code-area"
-            spellcheck="false"
-            placeholder="Open a file to start editing."
-          ></textarea>
+          <div id="structured-editor" class="structured hidden">
+            <div class="structured-toolbar">
+              <select id="entry-select" class="text-input"></select>
+              <button id="add-entry" class="ghost">Add entry</button>
+              <button id="delete-entry" class="ghost">Delete entry</button>
+            </div>
+            <div id="structured-form" class="structured-form"></div>
+          </div>
+          <div id="raw-editor" class="raw-editor">
+            <textarea
+              id="editor-textarea"
+              class="code-area"
+              spellcheck="false"
+              placeholder="Open a file to start editing."
+            ></textarea>
+          </div>
           <div id="status-message" class="status-message"></div>
         </section>
       </main>
diff --git a/tools/ndbs/server/web/styles.css b/tools/ndbs/server/web/styles.css
index a9f1c52..3a38486 100644
--- a/tools/ndbs/server/web/styles.css
+++ b/tools/ndbs/server/web/styles.css
@@ -72,6 +72,13 @@ button:hover {
   box-shadow: 0 6px 16px rgba(0, 0, 0, 0.12);
 }
 
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+  transform: none;
+  box-shadow: none;
+}
+
 button.ghost {
   background: transparent;
 }
@@ -86,6 +93,15 @@ input.filter-input {
   font-size: 13px;
 }
 
+select.text-input {
+  width: 100%;
+  border: 1px solid rgba(18, 33, 38, 0.16);
+  border-radius: 12px;
+  padding: 8px 10px;
+  background: rgba(255, 255, 255, 0.8);
+  font-size: 13px;
+}
+
 .app-shell {
   position: relative;
   display: grid;
@@ -271,6 +287,41 @@ input.filter-input {
   gap: 12px;
 }
 
+.guide {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.guide-title {
+  font-family: "KenneyFuture", "AlibabaPuHuiTi", serif;
+  font-size: 16px;
+}
+
+.guide-desc {
+  color: var(--ink-2);
+  font-size: 13px;
+}
+
+.guide-fields {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.guide-field {
+  padding: 3px 8px;
+  border-radius: 999px;
+  background: rgba(245, 158, 11, 0.16);
+  font-size: 12px;
+}
+
+.guide-actions {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+}
+
 .control-row {
   display: flex;
   gap: 12px;
@@ -297,6 +348,24 @@ input.filter-input {
   gap: 10px;
 }
 
+.view-toggle {
+  display: flex;
+  gap: 6px;
+  padding: 4px;
+  border-radius: 12px;
+  background: rgba(24, 33, 38, 0.08);
+}
+
+.view-toggle button {
+  padding: 6px 10px;
+  border-radius: 8px;
+  font-size: 12px;
+}
+
+.view-toggle button.active {
+  background: rgba(245, 158, 11, 0.86);
+}
+
 .code-area {
   width: 100%;
   min-height: 420px;
@@ -312,6 +381,83 @@ input.filter-input {
   outline: none;
 }
 
+.structured {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.structured-toolbar {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+  align-items: center;
+}
+
+.structured-form {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+
+.form-section {
+  border: 1px solid rgba(18, 33, 38, 0.12);
+  border-radius: 14px;
+  padding: 12px;
+  background: rgba(255, 255, 255, 0.7);
+}
+
+.form-section h3 {
+  margin: 0 0 8px;
+  font-size: 14px;
+  font-family: "KenneyFuture", "AlibabaPuHuiTi", serif;
+}
+
+.form-row {
+  display: grid;
+  grid-template-columns: 160px 1fr;
+  gap: 10px;
+  align-items: center;
+  margin-bottom: 8px;
+}
+
+.form-row:last-child {
+  margin-bottom: 0;
+}
+
+.form-label {
+  font-size: 12px;
+  color: var(--ink-2);
+}
+
+.form-input {
+  border: 1px solid rgba(18, 33, 38, 0.16);
+  border-radius: 10px;
+  padding: 6px 8px;
+  background: rgba(255, 255, 255, 0.9);
+  font-size: 12px;
+}
+
+.form-input[type="checkbox"] {
+  width: auto;
+}
+
+.array-row {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+  margin-bottom: 6px;
+}
+
+.array-row input {
+  flex: 1;
+}
+
+.array-row button {
+  padding: 4px 8px;
+  font-size: 11px;
+}
+
 .schema-summary {
   display: flex;
   gap: 10px;