diff --git a/README.md b/README.md
index 4807f17f8..5a871121f 100644
--- a/README.md
+++ b/README.md
@@ -1,36 +1,36 @@
-# NeoForged Documentation
+# NeoForge 文档
-This repository is used to store documentation on NeoForge, the Minecraft modding API. It also contains documentation on NeoGradle, a Gradle plugin for developing NeoForge and mods using NeoForge.
+此存储库用于存储有关NeoForge的文档，NeoForge是Minecraft模组开发的API。它还包含有关NeoGradle的文档，NeoGradle是一个用于开发NeoForge和使用NeoForge的模组的Gradle插件。
-The documentation is built using [Docusaurus 3](https://docusaurus.io)
+该文档使用[Docusaurus 3](https://docusaurus.io)构建
-## Contributing
+## 贡献
-You can read the [contribution guidelines on the docs](https://docs.neoforged.net/contributing/).
+您可以在[文档贡献指南](https://docs.neoforged.net/contributing/)中阅读贡献指南
-If you wish to contribute to the documentation, fork and clone this repository.
+如果您希望为文档做出贡献，请 fork 并 clone 此存储库。
-The documentation uses Node.js 18. This can either be installed manually or using a version manager that supports `.node-version` or `.nvmrc`. For most version managers, the `install` and/or `use` command can be used to setup the correct Node.js version.
+本文档使用 Node.js 18。可以手动安装，也可以使用支持 `.node-version` 或 `.nvmrc` 的版本管理器安装。对于大多数版本管理器，可以使用 `install` 和/或 `use` 命令来设置正确的 Node.js 版本。
-For example:
+例如:
```bash
nvm install # or 'nvs use'
```
-You can run the following commands if you wish to preview the documentation website locally through the live development server. Most changes are reflected live without having to restart the server.
+如果您想通过实时开发服务器在本地预览文档网站，可以运行以下命令。大多数更改都会实时反馈，无需重新启动服务器。
```bash
npm install
npm run start
```
-### Building
+### 构建
-If you wish to build a static version of the documentation which can be deployed, you can run the following command:
+如果您希望构建可部署的静态版本的文档，您可以运行以下命令：
```bash
npm run build
```
-This command generates static content into the `build` directory and can be served using any static contents hosting service.
+此命令会生成静态内容到`build`目录，并可以使用任何静态内容托管服务来提供服务。
diff --git a/docusaurus.config.js b/docusaurus.config.js
index 071dd3c6e..4a2a614c9 100644
--- a/docusaurus.config.js
+++ b/docusaurus.config.js
@@ -28,8 +28,8 @@ const config = {
// metadata like html lang. For example, if your site is Chinese, you may want
// to replace "en" with "zh-Hans".
i18n: {
- defaultLocale: "en",
- locales: ["en"],
+ defaultLocale: 'en',
+ locales: ['en','zh-Hans'],
},
presets: [
diff --git a/i18n/zh-Hans/code.json b/i18n/zh-Hans/code.json
new file mode 100644
index 000000000..e36f821a9
--- /dev/null
+++ b/i18n/zh-Hans/code.json
@@ -0,0 +1,424 @@
+{
+ "theme.docs.versions.unmaintainedVersionLabel": {
+ "message": "此为 {siteTitle} {versionLabel} 版的文档，现已不再积极维护。",
+ "description": "The label used to tell the user that he's browsing an unmaintained doc version"
+ },
+ "theme.docs.versions.LTSVersionLabel": {
+ "message": "This is documentation for {siteTitle} {versionLabel}, which is currently the LTS version.",
+ "description": "The label used to tell the user that they're browsing a LTS doc version"
+ },
+ "theme.docs.versions.latestVersionSuggestionLabel": {
+ "message": "最新的文档请参阅 {latestVersionLink} ({versionLabel})。",
+ "description": "The label used to tell the user to check the latest version"
+ },
+ "theme.docs.versions.latestVersionLinkLabel": {
+ "message": "最新版本",
+ "description": "The label used for the latest version suggestion link label"
+ },
+ "theme.ErrorPageContent.title": {
+ "message": "页面已崩溃。",
+ "description": "The title of the fallback page when the page crashed"
+ },
+ "theme.BackToTopButton.buttonAriaLabel": {
+ "message": "回到顶部",
+ "description": "The ARIA label for the back to top button"
+ },
+ "theme.blog.archive.title": {
+ "message": "历史博文",
+ "description": "The page & hero title of the blog archive page"
+ },
+ "theme.blog.archive.description": {
+ "message": "历史博文",
+ "description": "The page & hero description of the blog archive page"
+ },
+ "theme.blog.paginator.navAriaLabel": {
+ "message": "博文列表分页导航",
+ "description": "The ARIA label for the blog pagination"
+ },
+ "theme.blog.paginator.newerEntries": {
+ "message": "较新的博文",
+ "description": "The label used to navigate to the newer blog posts page (previous page)"
+ },
+ "theme.blog.paginator.olderEntries": {
+ "message": "较旧的博文",
+ "description": "The label used to navigate to the older blog posts page (next page)"
+ },
+ "theme.blog.post.paginator.navAriaLabel": {
+ "message": "博文分页导航",
+ "description": "The ARIA label for the blog posts pagination"
+ },
+ "theme.blog.post.paginator.newerPost": {
+ "message": "较新一篇",
+ "description": "The blog post button label to navigate to the newer/previous post"
+ },
+ "theme.blog.post.paginator.olderPost": {
+ "message": "较旧一篇",
+ "description": "The blog post button label to navigate to the older/next post"
+ },
+ "theme.blog.post.plurals": {
+ "message": "{count} 篇博文",
+ "description": "Pluralized label for \"{count} posts\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+ },
+ "theme.blog.tagTitle": {
+ "message": "{nPosts} 含有标签「{tagName}」",
+ "description": "The title of the page for a blog tag"
+ },
+ "theme.tags.tagsPageLink": {
+ "message": "查看所有标签",
+ "description": "The label of the link targeting the tag list page"
+ },
+ "theme.colorToggle.ariaLabel": {
+ "message": "切换浅色/暗黑模式（当前为{mode}）",
+ "description": "The ARIA label for the navbar color mode toggle"
+ },
+ "theme.colorToggle.ariaLabel.mode.dark": {
+ "message": "暗黑模式",
+ "description": "The name for the dark color mode"
+ },
+ "theme.colorToggle.ariaLabel.mode.light": {
+ "message": "浅色模式",
+ "description": "The name for the light color mode"
+ },
+ "theme.docs.breadcrumbs.navAriaLabel": {
+ "message": "页面路径",
+ "description": "The ARIA label for the breadcrumbs"
+ },
+ "theme.docs.DocCard.categoryDescription": {
+ "message": "{count} 个项目",
+ "description": "The default description for a category card in the generated index about how many items this category includes"
+ },
+ "theme.docs.paginator.navAriaLabel": {
+ "message": "文件选项卡",
+ "description": "The ARIA label for the docs pagination"
+ },
+ "theme.docs.paginator.previous": {
+ "message": "上一页",
+ "description": "The label used to navigate to the previous doc"
+ },
+ "theme.docs.paginator.next": {
+ "message": "下一页",
+ "description": "The label used to navigate to the next doc"
+ },
+ "theme.docs.tagDocListPageTitle.nDocsTagged": {
+ "message": "{count} 篇文档带有标签",
+ "description": "Pluralized label for \"{count} docs tagged\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+ },
+ "theme.docs.tagDocListPageTitle": {
+ "message": "{nDocsTagged}「{tagName}」",
+ "description": "The title of the page for a docs tag"
+ },
+ "theme.docs.versionBadge.label": {
+ "message": "版本：{versionLabel}"
+ },
+ "theme.docs.versions.unreleasedVersionLabel": {
+ "message": "此为 {siteTitle} {versionLabel} 版尚未发行的文档。",
+ "description": "The label used to tell the user that he's browsing an unreleased doc version"
+ },
+ "theme.common.editThisPage": {
+ "message": "编辑此页",
+ "description": "The link label to edit the current page"
+ },
+ "theme.common.headingLinkTitle": {
+ "message": "{heading}的直接链接",
+ "description": "Title for link to heading"
+ },
+ "theme.lastUpdated.atDate": {
+ "message": "于 {date} ",
+ "description": "The words used to describe on which date a page has been last updated"
+ },
+ "theme.lastUpdated.byUser": {
+ "message": "由 {user} ",
+ "description": "The words used to describe by who the page has been last updated"
+ },
+ "theme.lastUpdated.lastUpdatedAtBy": {
+ "message": "最后{byUser}{atDate}更新",
+ "description": "The sentence used to display when a page has been last updated, and by who"
+ },
+ "theme.navbar.mobileVersionsDropdown.label": {
+ "message": "选择版本",
+ "description": "The label for the navbar versions dropdown on mobile view"
+ },
+ "theme.NotFound.title": {
+ "message": "找不到页面",
+ "description": "The title of the 404 page"
+ },
+ "theme.tags.tagsListLabel": {
+ "message": "标签：",
+ "description": "The label alongside a tag list"
+ },
+ "theme.admonition.caution": {
+ "message": "警告",
+ "description": "The default label used for the Caution admonition (:::caution)"
+ },
+ "theme.admonition.danger": {
+ "message": "危险",
+ "description": "The default label used for the Danger admonition (:::danger)"
+ },
+ "theme.admonition.info": {
+ "message": "信息",
+ "description": "The default label used for the Info admonition (:::info)"
+ },
+ "theme.admonition.note": {
+ "message": "备注",
+ "description": "The default label used for the Note admonition (:::note)"
+ },
+ "theme.admonition.tip": {
+ "message": "提示",
+ "description": "The default label used for the Tip admonition (:::tip)"
+ },
+ "theme.admonition.warning": {
+ "message": "注意",
+ "description": "The default label used for the Warning admonition (:::warning)"
+ },
+ "theme.AnnouncementBar.closeButtonAriaLabel": {
+ "message": "关闭",
+ "description": "The ARIA label for close button of announcement bar"
+ },
+ "theme.blog.sidebar.navAriaLabel": {
+ "message": "最近博文导航",
+ "description": "The ARIA label for recent posts in the blog sidebar"
+ },
+ "theme.CodeBlock.copied": {
+ "message": "复制成功",
+ "description": "The copied button label on code blocks"
+ },
+ "theme.CodeBlock.copyButtonAriaLabel": {
+ "message": "复制代码到剪贴板",
+ "description": "The ARIA label for copy code blocks button"
+ },
+ "theme.CodeBlock.copy": {
+ "message": "复制",
+ "description": "The copy button label on code blocks"
+ },
+ "theme.CodeBlock.wordWrapToggle": {
+ "message": "切换自动换行",
+ "description": "The title attribute for toggle word wrapping button of code block lines"
+ },
+ "theme.DocSidebarItem.expandCategoryAriaLabel": {
+ "message": "展开侧边栏分类 '{label}'",
+ "description": "The ARIA label to expand the sidebar category"
+ },
+ "theme.DocSidebarItem.collapseCategoryAriaLabel": {
+ "message": "折叠侧边栏分类 '{label}'",
+ "description": "The ARIA label to collapse the sidebar category"
+ },
+ "theme.NavBar.navAriaLabel": {
+ "message": "主导航",
+ "description": "The ARIA label for the main navigation"
+ },
+ "theme.navbar.mobileLanguageDropdown.label": {
+ "message": "选择语言",
+ "description": "The label for the mobile language switcher dropdown"
+ },
+ "theme.NotFound.p1": {
+ "message": "我们找不到您要找的页面。",
+ "description": "The first paragraph of the 404 page"
+ },
+ "theme.NotFound.p2": {
+ "message": "请联系原始链接来源网站的所有者，并告知他们链接已损坏。",
+ "description": "The 2nd paragraph of the 404 page"
+ },
+ "theme.TOCCollapsible.toggleButtonLabel": {
+ "message": "本页总览",
+ "description": "The label used by the button on the collapsible TOC component"
+ },
+ "theme.blog.post.readMore": {
+ "message": "阅读更多",
+ "description": "The label used in blog post item excerpts to link to full blog posts"
+ },
+ "theme.blog.post.readMoreLabel": {
+ "message": "阅读 {title} 的全文",
+ "description": "The ARIA label for the link to full blog posts from excerpts"
+ },
+ "theme.blog.post.readingTime.plurals": {
+ "message": "阅读需 {readingTime} 分钟",
+ "description": "Pluralized label for \"{readingTime} min read\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+ },
+ "theme.docs.breadcrumbs.home": {
+ "message": "主页面",
+ "description": "The ARIA label for the home page in the breadcrumbs"
+ },
+ "theme.docs.sidebar.collapseButtonTitle": {
+ "message": "收起侧边栏",
+ "description": "The title attribute for collapse button of doc sidebar"
+ },
+ "theme.docs.sidebar.collapseButtonAriaLabel": {
+ "message": "收起侧边栏",
+ "description": "The title attribute for collapse button of doc sidebar"
+ },
+ "theme.docs.sidebar.navAriaLabel": {
+ "message": "文档侧边栏",
+ "description": "The ARIA label for the sidebar navigation"
+ },
+ "theme.docs.sidebar.closeSidebarButtonAriaLabel": {
+ "message": "关闭导航栏",
+ "description": "The ARIA label for close button of mobile sidebar"
+ },
+ "theme.docs.sidebar.toggleSidebarButtonAriaLabel": {
+ "message": "切换导航栏",
+ "description": "The ARIA label for hamburger menu button of mobile navigation"
+ },
+ "theme.docs.sidebar.expandButtonTitle": {
+ "message": "展开侧边栏",
+ "description": "The ARIA label and title attribute for expand button of doc sidebar"
+ },
+ "theme.docs.sidebar.expandButtonAriaLabel": {
+ "message": "展开侧边栏",
+ "description": "The ARIA label and title attribute for expand button of doc sidebar"
+ },
+ "theme.navbar.mobileSidebarSecondaryMenu.backButtonLabel": {
+ "message": "← 回到主菜单",
+ "description": "The label of the back button to return to main menu, inside the mobile navbar sidebar secondary menu (notably used to display the docs sidebar)"
+ },
+ "theme.SearchBar.seeAll": {
+ "message": "查看全部 {count} 个结果"
+ },
+ "theme.SearchBar.label": {
+ "message": "搜索",
+ "description": "The ARIA label and placeholder for search button"
+ },
+ "theme.SearchModal.searchBox.resetButtonTitle": {
+ "message": "清除查询",
+ "description": "The label and ARIA label for search box reset button"
+ },
+ "theme.SearchModal.searchBox.cancelButtonText": {
+ "message": "取消",
+ "description": "The label and ARIA label for search box cancel button"
+ },
+ "theme.SearchModal.startScreen.recentSearchesTitle": {
+ "message": "最近搜索",
+ "description": "The title for recent searches"
+ },
+ "theme.SearchModal.startScreen.noRecentSearchesText": {
+ "message": "没有最近搜索",
+ "description": "The text when no recent searches"
+ },
+ "theme.SearchModal.startScreen.saveRecentSearchButtonTitle": {
+ "message": "保存这个搜索",
+ "description": "The label for save recent search button"
+ },
+ "theme.SearchModal.startScreen.removeRecentSearchButtonTitle": {
+ "message": "从历史记录中删除这个搜索",
+ "description": "The label for remove recent search button"
+ },
+ "theme.SearchModal.startScreen.favoriteSearchesTitle": {
+ "message": "收藏",
+ "description": "The title for favorite searches"
+ },
+ "theme.SearchModal.startScreen.removeFavoriteSearchButtonTitle": {
+ "message": "从收藏列表中删除这个搜索",
+ "description": "The label for remove favorite search button"
+ },
+ "theme.SearchModal.errorScreen.titleText": {
+ "message": "无法获取结果",
+ "description": "The title for error screen of search modal"
+ },
+ "theme.SearchModal.errorScreen.helpText": {
+ "message": "你可能需要检查网络连接。",
+ "description": "The help text for error screen of search modal"
+ },
+ "theme.SearchModal.footer.selectText": {
+ "message": "选中",
+ "description": "The explanatory text of the action for the enter key"
+ },
+ "theme.SearchModal.footer.selectKeyAriaLabel": {
+ "message": "Enter 键",
+ "description": "The ARIA label for the Enter key button that makes the selection"
+ },
+ "theme.SearchModal.footer.navigateText": {
+ "message": "导航",
+ "description": "The explanatory text of the action for the Arrow up and Arrow down key"
+ },
+ "theme.SearchModal.footer.navigateUpKeyAriaLabel": {
+ "message": "向上键",
+ "description": "The ARIA label for the Arrow up key button that makes the navigation"
+ },
+ "theme.SearchModal.footer.navigateDownKeyAriaLabel": {
+ "message": "向下键",
+ "description": "The ARIA label for the Arrow down key button that makes the navigation"
+ },
+ "theme.SearchModal.footer.closeText": {
+ "message": "关闭",
+ "description": "The explanatory text of the action for Escape key"
+ },
+ "theme.SearchModal.footer.closeKeyAriaLabel": {
+ "message": "Esc 键",
+ "description": "The ARIA label for the Escape key button that close the modal"
+ },
+ "theme.SearchModal.footer.searchByText": {
+ "message": "搜索提供",
+ "description": "The text explain that the search is making by Algolia"
+ },
+ "theme.SearchModal.noResultsScreen.noResultsText": {
+ "message": "没有结果：",
+ "description": "The text explains that there are no results for the following search"
+ },
+ "theme.SearchModal.noResultsScreen.suggestedQueryText": {
+ "message": "试试搜索",
+ "description": "The text for the suggested query when no results are found for the following search"
+ },
+ "theme.SearchModal.noResultsScreen.reportMissingResultsText": {
+ "message": "认为这个查询应该有结果？",
+ "description": "The text for the question where the user thinks there are missing results"
+ },
+ "theme.SearchModal.noResultsScreen.reportMissingResultsLinkText": {
+ "message": "请告知我们。",
+ "description": "The text for the link to report missing results"
+ },
+ "theme.SearchModal.placeholder": {
+ "message": "搜索文档",
+ "description": "The placeholder of the input of the DocSearch pop-up modal"
+ },
+ "theme.SearchPage.documentsFound.plurals": {
+ "message": "找到 {count} 份文件",
+ "description": "Pluralized label for \"{count} documents found\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+ },
+ "theme.SearchPage.existingResultsTitle": {
+ "message": "「{query}」的搜索结果",
+ "description": "The search page title for non-empty query"
+ },
+ "theme.SearchPage.emptyResultsTitle": {
+ "message": "在文档中搜索",
+ "description": "The search page title for empty query"
+ },
+ "theme.SearchPage.inputPlaceholder": {
+ "message": "在此输入搜索字词",
+ "description": "The placeholder for search page input"
+ },
+ "theme.SearchPage.inputLabel": {
+ "message": "搜索",
+ "description": "The ARIA label for search page input"
+ },
+ "theme.SearchPage.algoliaLabel": {
+ "message": "通过 Algolia 搜索",
+ "description": "The ARIA label for Algolia mention"
+ },
+ "theme.SearchPage.noResultsText": {
+ "message": "未找到任何结果",
+ "description": "The paragraph for empty search result"
+ },
+ "theme.SearchPage.fetchingNewResults": {
+ "message": "正在获取新的搜索结果...",
+ "description": "The paragraph for fetching new search results"
+ },
+ "theme.ErrorPageContent.tryAgain": {
+ "message": "重试",
+ "description": "The label of the button to try again rendering when the React error boundary captures an error"
+ },
+ "theme.common.skipToMainContent": {
+ "message": "跳到主要内容",
+ "description": "The skip to content label used for accessibility, allowing to rapidly navigate to main content with keyboard tab/enter navigation"
+ },
+ "theme.tags.tagsPageTitle": {
+ "message": "标签",
+ "description": "The title of the tag list page"
+ },
+ "theme.unlistedContent.title": {
+ "message": "未列出页",
+ "description": "The unlisted content banner title"
+ },
+ "theme.unlistedContent.message": {
+ "message": "此页面未列出。搜索引擎不会对其索引，只有拥有直接链接的用户才能访问。",
+ "description": "The unlisted content banner message"
+ }
+}
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-blog/options.json b/i18n/zh-Hans/docusaurus-plugin-content-blog/options.json
new file mode 100644
index 000000000..9239ff706
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-blog/options.json
@@ -0,0 +1,14 @@
+{
+ "title": {
+ "message": "Blog",
+ "description": "The title for the blog used in SEO"
+ },
+ "description": {
+ "message": "Blog",
+ "description": "The description for the blog used in SEO"
+ },
+ "sidebar.title": {
+ "message": "Recent posts",
+ "description": "The label for the left sidebar"
+ }
+}
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs-neogradle/current.json b/i18n/zh-Hans/docusaurus-plugin-content-docs-neogradle/current.json
new file mode 100644
index 000000000..bede4b8bf
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs-neogradle/current.json
@@ -0,0 +1,14 @@
+{
+ "version.label": {
+ "message": "FG6",
+ "description": "The label for version current"
+ },
+ "sidebar.ngSidebar.category.ForgeGradle Configurations": {
+ "message": "ForgeGradle Configurations",
+ "description": "The label for category ForgeGradle Configurations in sidebar ngSidebar"
+ },
+ "sidebar.ngSidebar.category.Dependencies": {
+ "message": "Dependencies",
+ "description": "The label for category Dependencies in sidebar ngSidebar"
+ }
+}
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs-neogradle/version-5.x.json b/i18n/zh-Hans/docusaurus-plugin-content-docs-neogradle/version-5.x.json
new file mode 100644
index 000000000..8a8d0d233
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs-neogradle/version-5.x.json
@@ -0,0 +1,18 @@
+{
+ "version.label": {
+ "message": "FG5",
+ "description": "The label for version 5.x"
+ },
+ "sidebar.ngSidebar.category.ForgeGradle Documentation": {
+ "message": "ForgeGradle Documentation",
+ "description": "The label for category ForgeGradle Documentation in sidebar ngSidebar"
+ },
+ "sidebar.ngSidebar.category.ForgeGradle Configurations": {
+ "message": "ForgeGradle Configurations",
+ "description": "The label for category ForgeGradle Configurations in sidebar ngSidebar"
+ },
+ "sidebar.ngSidebar.category.Dependencies": {
+ "message": "Dependencies",
+ "description": "The label for category Dependencies in sidebar ngSidebar"
+ }
+}
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current.json
new file mode 100644
index 000000000..b1aac2141
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current.json
@@ -0,0 +1,78 @@
+{
+ "version.label": {
+ "message": "1.20.x",
+ "description": "当前版本的标签"
+ },
+ "sidebar.mainSidebar.category.Getting Started with Neo": {
+ "message": "开始使用Neo",
+ "description": "侧边栏mainSidebar中“开始使用Neo”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Advanced Topics": {
+ "message": "高级主题",
+ "description": "侧边栏mainSidebar中“高级主题”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Block Entities": {
+ "message": "方块实体",
+ "description": "侧边栏mainSidebar中“方块实体”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Blocks": {
+ "message": "方块",
+ "description": "侧边栏mainSidebar中“方块”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Concepts": {
+ "message": "概念",
+ "description": "侧边栏mainSidebar中“概念”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Datagen": {
+ "message": "数据生成",
+ "description": "侧边栏mainSidebar中“数据生成”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Data Maps": {
+ "message": "数据映射",
+ "description": "侧边栏mainSidebar中“数据映射”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Data Storage": {
+ "message": "数据存储",
+ "description": "侧边栏mainSidebar中“数据存储”类别的标签"
+ },
+ "sidebar.mainSidebar.category.GUIs": {
+ "message": "图形用户界面",
+ "description": "侧边栏mainSidebar中“图形用户界面”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Items": {
+ "message": "物品",
+ "description": "侧边栏mainSidebar中“物品”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Legacy": {
+ "message": "遗留",
+ "description": "侧边栏mainSidebar中“遗留”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Miscellaneous": {
+ "message": "杂项",
+ "description": "侧边栏mainSidebar中“杂项”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Networking": {
+ "message": "网络",
+ "description": "侧边栏mainSidebar中“网络”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Resources": {
+ "message": "资源",
+ "description": "侧边栏mainSidebar中“资源”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Client": {
+ "message": "客户端",
+ "description": "侧边栏mainSidebar中“客户端”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Models": {
+ "message": "模型",
+ "description": "侧边栏mainSidebar中“模型”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Datapacks": {
+ "message": "数据包",
+ "description": "侧边栏mainSidebar中“数据包”类别的标签"
+ },
+ "sidebar.mainSidebar.category.Recipes": {
+ "message": "配方",
+ "description": "侧边栏mainSidebar中“配方”类别的标签"
+ }
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/advanced/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/advanced/_category_.json
new file mode 100644
index 000000000..c392eef49
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/advanced/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Advanced Topics"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/advanced/accesstransformers.mdx b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/advanced/accesstransformers.mdx
new file mode 100644
index 000000000..829efaf09
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/advanced/accesstransformers.mdx
@@ -0,0 +1,167 @@
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+# Access Transformers
+
+Access Transformers (简称 ATs) 允许开发者扩大类、方法和字段的可见性，以及修改其 `final` 属性。这些工具使得模组开发者能够访问和修改通常无法访问的类成员。
+
+[规范文档][specs]可以在 NeoForged 的 GitHub 上查看。
+
+## 添加 ATs
+
+将 Access Transformer 添加到您的 mod 项目与在 `build.gradle` 中添加一行代码一样简单：
+
+
+
+Access Transformers 需要在 `build.gradle` 和 `mods.toml` 中声明：
+
+```groovy
+// 在 build.gradle 中：
+// 此部分也是指定映射版本的地方
+minecraft {
+ accessTransformers {
+ file('src/main/resources/META-INF/accesstransformer.cfg')
+ }
+}
+```
+
+```toml
+# 在 mods.toml 中:
+[[accessTransformers]]
+file="META-INF/accesstransformer.cfg"
+```
+
+AT 文件可以位于上面几行指定的任何位置，但如果没有指定其他文件，NeoForge 将默认搜索 `META-INF/accesstransformer.cfg`。
+
+此外，可以指定多个 AT 文件并按顺序应用。 这对于具有多个软件包的大型模组非常有用。
+
+```groovy
+// In build.gradle:
+minecraft {
+ accessTransformers {
+ file('src/main/resources/accesstransformer_main.cfg')
+ file('src/additions/resources/accesstransformer_additions.cfg')
+ }
+}
+```
+
+```toml
+# In mods.toml
+[[accessTransformers]]
+file="accesstransformer_main.cfg"
+
+[[accessTransformers]]
+file="accesstransformer_additions.cfg"
+```
+
+添加或修改任何访问转换器后，必须刷新 Gradle 项目，以便使更改生效。
+
+
+
+在你的模组项目中添加一个 AT 也很简单，只需在 `build.gradle` 中添加一行代码：
+
+```groovy
+// 这一部分也是你指定映射版本的地方
+minecraft {
+ accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
+}
+```
+
+在开发环境中，AT 文件可以放在上述指定的任何位置。然而，在非开发环境中加载时，NeoForge 只会搜索你的 JAR 文件中 `META-INF/accesstransformer.cfg` 的确切路径。
+
+添加或修改访问转换器后，必须刷新 Gradle 项目，以便使更改生效。
+
+
+
+## 注释
+
+`#` 之后直到行尾的所有文本都将被视为注释并且不会被解析。
+
+## 访问控制修饰符
+
+访问控制修饰符指明目标将被转换到的新的成员的可见性。按可见性递减的顺序排列如下:
+
+* `public` - 对包内外的所有类可见
+* `protected` - 只对包内的类和子类可见
+* `default` - 只对包内的类可见
+* `private` - 只对类的内部可见
+
+特殊修饰符 `+f` 和 `-f` 可以分别添加到上述的修饰符之后，用以添加或移除 `final` 修饰符，当应用时可防止子类化、方法覆盖或字段修改。
+
+:::danger
+指令只修改直接引用的方法；任何覆盖的方法都不会被转换。建议确保转换的方法没有未转换覆盖的方法，否则这会限制其可见性，并可能导致 JVM 报错。
+
+可以安全转换的方法示例包括 `private` 方法、`final` 方法（或 `final` 类中的方法）以及 `static` 方法。
+:::
+
+## 目标和指令
+
+### 类
+
+定位类的格式如下:
+
+```
+
+```
+
+内部类通过组合外部类的完全限定名和内部类名，使用 `$` 作为分隔符来表示。
+
+### 字段
+
+定位字段的格式如下：
+
+```
+
+```
+
+### 方法
+
+定位方法需要特殊的语法来表示方法参数和返回类型：
+
+```
+ ()
+```
+
+#### 指定类型
+
+也称为"描述符"：有关更多技术细节，请参见 [Java 虚拟机规范，SE 8，第 4.3.2 节和 4.3.3 节][jvmdescriptors]。
+
+* `B` - `byte`，有符号字节
+* `C` - `char`，Unicode 字符代码点，使用 UTF-16 编码
+* `D` - `double`，双精度浮点值
+* `F` - `float`，单精度浮点值
+* `I` - `integer`，32 位整数
+* `J` - `long`，64 位整数
+* `S` - `short`，有符号短整数
+* `Z` - `boolean`，`true` 或 `false` 值
+* `[` - 表示数组的一个维度
+ * 示例: `[[S` 表示 `short[][]`
+* `L;` - 表示引用类型
+ * 示例: `Ljava/lang/String;` 表示 `java.lang.String` 引
+
+用类型 _(注意使用斜线而非点)_
+* `(` - 表示方法描述符，参数应在此处提供，如果没有参数则不提供
+ * 示例: `(I)Z` 表示一个需要整型参数并返回布尔值的方法
+* `V` - 表示方法不返回值，只能在方法描述符的末尾使用
+ * 示例: `()V` 表示一个没有参数并且不返回任何结果的方法
+
+## 示例
+
+```
+# 将 Crypt 中的 ByteArrayToKeyFunction 接口公开
+public net.minecraft.util.Crypt$ByteArrayToKeyFunction
+
+# 将 MinecraftServer 中的 'random' 字段设为 protected 并移除 final 修饰
+protected-f net.minecraft.server.MinecraftServer random
+
+# 将 Util 中的 'makeExecutor' 方法公开，
+# 接受一个 String 并返回一个 ExecutorService
+public net.minecraft.Util makeExecutor(Ljava/lang/String;)Ljava/util/concurrent/ExecutorService;
+
+# 将 UUIDUtil 中的 'leastMostToIntArray' 方法公开，
+# 接受两个 long 并返回一个 int 数组
+public net.minecraft.core.UUIDUtil leastMostToIntArray(JJ)[I
+```
+
+[specs]: https://github.com/NeoForged/AccessTransformers/blob/main/FMLAT.md
+[jvmdescriptors]: https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blockentities/ber.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blockentities/ber.md
new file mode 100644
index 000000000..a83d801aa
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blockentities/ber.md
@@ -0,0 +1,28 @@
+BlockEntityRenderer
+==================
+
+`BlockEntityRenderer` 或 `BER` 用于以无法用静态烘焙模型（JSON，OBJ，B3D，其他）表示的方式渲染块。块实体渲染器要求块有一个 `BlockEntity`。
+
+创建 BER
+--------------
+
+要创建 BER，创建一个继承自 `BlockEntityRenderer` 的类。它需要一个泛型参数，指定块的 `BlockEntity` 类。泛型参数在 BER 的 `render` 方法中使用。
+
+对于给定的 `BlockEntityType`，只存在一个 BER。因此，应将特定于等级中的单个实例的值存储在传递给渲染器的块实体中，而不是在 BER 本身中。例如，每帧递增的整数，如果存储在 BER 中，将会在该类型的等级中的每一个块实体中每帧递增。
+
+### `render`
+
+每一帧都会调用这个方法来渲染块实体。
+
+#### 参数
+* `blockEntity`：这是正在渲染的块实体的实例。
+* `partialTick`：自上一完整 tick以来已经过去的以 tick 的分数表示的时间。
+* `poseStack`：这是一个堆栈，可以持有四维矩阵条目，这些条目可以偏移到块实体的当前位置。
+* `bufferSource`：一个渲染缓冲区，能够访问顶点消费者。
+* `combinedLight`：块实体上当前光值的整数。
+* `combinedOverlay`：一个设置为块实体当前覆盖层的整数，通常是 `OverlayTexture#NO_OVERLAY` 或 655,360。
+
+注册 BER
+-----------------
+
+要注册 BER，你必须订阅模组事件总线上的 `EntityRenderersEvent$RegisterRenderers` 事件，并调用 `#registerBlockEntityRenderer`。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blockentities/index.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blockentities/index.md
new file mode 100644
index 000000000..84a2627e0
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blockentities/index.md
@@ -0,0 +1,125 @@
+## 注册方块实体
+
+方块实体的创建和移除是动态的，因此它们本身不是注册对象。要创建一个`BlockEntity`，你需要扩展`BlockEntity`类。相应地，另一个对象被注册以方便创建和引用动态对象的*类型*。对于`BlockEntity`，这些类型被称为`BlockEntityType`。
+
+`BlockEntityType`可以像其他注册对象一样被[注册][registration]。使用`BlockEntityType.Builder#of`来构建`BlockEntityType`，它接受两个参数：一个`BlockEntityType.BlockEntitySupplier`，它接受一个`BlockPos`和`BlockState`来创建新的`BlockEntity`实例，以及一个可变数量的`Block`，这些方块可以附加到此`BlockEntity`。
+
+```java
+// 对于某个DeferredRegister> REGISTER
+public static final RegistryObject> MY_BE = REGISTER.register("mybe", () -> BlockEntityType.Builder.of(MyBE::new, validBlocks).build(null));
+
+// 在MyBE中，一个BlockEntity子类
+public MyBE(BlockPos pos, BlockState state) {
+ super(MY_BE.get(), pos, state);
+}
+```
+
+## 创建方块实体
+
+要创建一个`BlockEntity`并将其附加到一个`Block`，你的`Block`子类必须实现`EntityBlock`接口。必须实现方法`EntityBlock#newBlockEntity(BlockPos, BlockState)`并返回你的`BlockEntity`的新实例。
+
+## 存储你的方块实体内的数据
+
+为了保存数据，覆盖以下两个方法：
+```java
+BlockEntity#saveAdditional(CompoundTag tag)
+
+BlockEntity#load(CompoundTag tag)
+```
+这些方法在包含`BlockEntity`的`LevelChunk`从标签加载/保存时调用。使用这些方法读写你的方块实体类中的字段。
+
+:::note
+每当你的数据发生变化时，你需要调用`BlockEntity#setChanged`；否则，在级别保存时可能会跳过包含你的`BlockEntity`的`LevelChunk`。
+:::
+
+:::danger
+调用`super`方法非常重要！
+
+标签名`id`、`x`、`y`、`z`、`ForgeData`和`ForgeCaps`由`super`方法保留。
+:::
+
+## `BlockEntities` 的定时器
+
+如果你需要一个定时的方块实体，例如跟踪熔炼过程中的进度，那么必须在`EntityBlock`内实现并覆盖另一个方法：`EntityBlock#getTicker(Level, BlockState, BlockEntityType)`。这可以实现不同的定时器，取决于用户所在的逻辑侧，或者只实现一个通用定时器。无论哪种情况，都必须返回一个`BlockEntityTicker`。由于这是一个功能接口，它可以仅采用表示定时器的方法：
+
+```java
+// 在某个Block子类内
+@Nullable
+@Override
+public BlockEntityTicker getTicker(Level level, BlockState state, BlockEntityType type) {
+ return type == MyBlockEntityTypes.MYBE.get() ? MyBlockEntity::tick : null;
+}
+
+// 在MyBlockEntity内
+public static void tick(Level level, BlockPos pos, BlockState state, MyBlockEntity blockEntity) {
+ // 执行任务
+}
+```
+
+:::note
+这个方法每个tick都会被调用；因此，你应该避免在这里进行复杂的计算。如果可能，你应该每X个ticks进行更复杂的计算。（一秒钟内的ticks数量可能低于20，但不会更高）
+:::
+
+## 将数据同步到客户端
+
+有三种方法可以将数据同步到客户端：在LevelChunk加载时同步，在方块更新时同步，以及使用自定义网络消息同步。
+
+### 在LevelChunk加载时同步
+
+为此，你需要覆盖
+```java
+BlockEntity#getUpdateTag()
+
+IForgeBlockEntity#handleUpdateTag(CompoundTag tag)
+```
+第一个方法收集应该发送到客户端的数据，而第二个方法处理这些数据。如果你的`BlockEntity`不包含太多数据，你可能可以使用[存储你的方块实体内的数据][storing-data]部分中的方法。
+
+:::caution
+同步过多/无用的方块实体数据可能导致网络拥塞。你应该优化你的网络使用，只在客户端需要时发送客户端需要的信息。例如，通常没有必要在更新标签中发送方块实体的库存，因为这可以通过其[`AbstractContainerMenu`][menu]同步。
+:::
+
+### 在方块更新时同步
+
+这种方法有点复杂，但你只需覆盖两个或三个方法。这里是它的一个小示例实现：
+```java
+@Override
+public CompoundTag getUpdateTag() {
+ CompoundTag tag = new CompoundTag();
+ // 将你的数据写入标签
+ return tag;
+}
+
+@Override
+public Packet getUpdatePacket() {
+ // 从#getUpdateTag获取标签
+ return ClientboundBlockEntityDataPacket.create(this);
+}
+
+// 可以覆盖IForgeBlockEntity#onDataPacket。默认情况下，这将推迟到#load。
+```
+静态构造函数`ClientboundBlockEntityDataPacket#create`接受：
+
+* `BlockEntity`。
+* 一个可选的函数，从`BlockEntity`获取`CompoundTag`。默认情况下，这使用`BlockEntity#getUpdateTag`。
+
+现在，要发送数据包，服务器上必须给出更新通知。
+```java
+Level#sendBlockUpdated(BlockPos pos, BlockState oldState, BlockState newState, int flags)
+```
+`pos`应该是你的`BlockEntity`的位置。
+对于`oldState`和`newState`，你可以传递该位置当前的`BlockState`。
+`flags`是一个位掩码，应包含`2`，这将同步更改到客户端。有关更多信息以及其他标志，请参阅`Block`。标志`2`等同于`Block#UPDATE_CLIENTS`。
+
+### 使用自定义网络消息同步
+
+这种同步方式可能是最复杂的，但通常是最优化的，因为你可以确保只有你需要同步的数据实际上被同步。你应该首先查看[`Networking`][networking]部分，特别是[`SimpleImpl`][simple_impl]，然后再尝试这种方式。一旦你创建了自定义网络消息，你可以使用`SimpleChannel#send(PacketDistributor$PacketTarget, MSG)`将其发送给加载了`BlockEntity`的所有用户。
+
+:::caution
+进行安全检查非常重要，当消息到达玩家时，`BlockEntity`可能已经被销毁/替换！你还应该检查块是否已加载（`Level#hasChunkAt(BlockPos)`）。
+:::
+
+[registration]: ../concepts/registries.md#methods-for-registering
+[storing-data]: #storing-data-within-your-blockentity
+[menu]: ../gui/menus.md
+[networking]: ../networking/index.md
+[simple_impl]: ../networking/simpleimpl.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blocks/index.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blocks/index.md
new file mode 100644
index 000000000..95f1376da
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blocks/index.md
@@ -0,0 +1,235 @@
+## 统一方块的规则
+
+在开始之前，你需要明白在游戏中每个方块都只有一个。一个世界由成千上万个在不同位置引用该方块的实例组成。换句话说，同一个方块多次被显示。
+
+因此，一个方块只应该在[注册]期间实例化一次。一旦注册了方块，你可以根据需要使用已注册的引用。
+
+与大多数其他注册表不同，方块可以使用`DeferredRegister`的特殊版本，称为`DeferredRegister.Blocks`。 `DeferredRegister.Blocks`基本上就像`DeferredRegister`，但有一些细微的差别：
+
+- 它们是通过`DeferredRegister.createBlocks（"yourmodid"）`创建的，而不是通常的`DeferredRegister.create（...）`方法。
+- `＃register`返回一个`DeferredBlock`，它扩展了`DeferredHolder`。 `T`是我们正在注册的方块类的类型。
+- 有一些帮助注册方块的方法。 更多详情请参见[下方]。
+
+现在，让我们注册我们的方块：
+
+```java
+//BLOCKS is a DeferredRegister.Blocks
+public static final DeferredBlock MY_BLOCK = BLOCKS.register("my_block", () -> new Block(...));
+```
+
+注册了方块后，所有对新的`my_block`的引用应使用此常量。例如，如果你想检查给定位置的方块是否是`my_block`，那么相应的代码看起来像这样：
+
+```java
+level.getBlockState(position) //返回在给定位置放置的方块状态
+ //highlight-next-line
+ .is(MyBlockRegistrationClass.MY_BLOCK.get());
+```
+
+这种方法也有一个方便的效果，即`block1 == block2`有效，并且可以代替Java的`equals`方法使用（当然，使用`equals`仍然有效，但是因为它还是通过引用进行比较，所以没有意义）。
+
+:::danger
+不要在注册外部调用`new Block()`！一旦你那样做了，会出现问题：
+
+- 方块必须在注册表解锁时创建。NeoForge为您解锁注册表，并稍后再冻结它们，所以注册是您创建方块的时机窗口。
+- 如果你在注册表再次冻结时尝试创建和/或注册方块，游戏将崩溃并报告一个“null”方块，这可能会非常混乱。
+- 如果你仍然设法拥有一个悬空的方块实例，游戏在同步和保存时将不能识别它，并将其替换为空气。
+:::
+
+## 创建方块
+
+如上所述，我们首先创建我们的`DeferredRegister.Blocks`：
+
+```java
+public static final DeferredRegister.Blocks BLOCKS = DeferredRegister.createBlocks("yourmodid");
+```
+
+### 基础方块
+
+对于不需要特殊功能的简单方块（如圆石，木板等），可以直接使用`Block`类。要做到这一点，在注册期间，用`BlockBehaviour.Properties`参数实例化`Block`。可以使用`BlockBehaviour.Properties＃of`创建此`BlockBehaviour.Properties`参数，并可以通过调用其方法进行定制。这其中最重要的方法是：
+
+- `destroyTime`-决定破坏方块所需的时间。
+ - 石头的破坏时间为1.5，泥土为0.5，黑曜石为50，基岩为-1（不可破坏）。
+- `explosionResistance`-决定方块的抗爆性。
+ - 石头的抗爆性为6.0，泥土为0.5，黑曜石为1,200，基岩为3,600,000。
+- `sound`-设置方块在被击中，打破或放置时的声音。
+ - 默认值是`SoundType.STONE`。更多详细信息请参见[声音页面][sounds]。
+- `lightLevel`-设置方块的光线发射。接收一个带有`BlockState`参数的函数，返回0到15之间的值。
+ 例如，萤石使用`state -> 15`，火炬使用`state -> 14`。
+- `摩擦` - 设置方块的摩擦（滑滑的程度）。
+ - 默认值是0.6。冰使用0.98。
+
+例如，一个简单的实现可能看起来像这样：
+
+```java
+// BLOCKS is a DeferredRegister.Blocks
+public static final DeferredBlock MY_BETTER_BLOCK = BLOCKS.register(
+ "my_better_block",
+ () -> new Block(BlockBehaviour.Properties.of()
+ //highlight-start
+ .destroyTime(2.0f)
+ .explosionResistance(10.0f)
+ .sound(SoundType.GRAVEL)
+ .lightLevel(state -> 7)
+ //highlight-end
+ ));
+```
+
+有关更多文档，请参阅`BlockBehaviour.Properties`的源代码。有关更多示例，或查看Minecraft使用的值，请查看`Blocks`类。
+
+:::note
+重要的是要理解，世界中的一个方块并不同于库存中的东西。库存中看起来像方块的其实是`BlockItem`，它是一种特殊类型的[物品]，在使用时会放置一个方块。这也就意味着，创造标签页或最大堆叠大小等内容都由相应的`BlockItem`处理。
+
+`BlockItem`必须与方块单独注册。这是因为方块不一定需要一个物品，例如，如果它不能被收集 (例如火）。
+### 更多功能
+
+直接使用`Block`只能创造非常基本的方块。如果你想添加功能，像是玩家交互或不同的碰撞箱，就需要一个扩展了`Block`的自定义类。`Block`类有许多可以被重写以实现不同功能的方法；更多信息请参见`Block`、`BlockBehaviour`和`IBlockExtension`类。另外，请查看下方的[使用方块][usingblocks]部分，了解一些方块最常见的用例。
+
+如果你想制作一个有不同变体的方块（想想一个有底部、顶部和双层变体的台阶），你应该使用[blockstates]。最后，如果你想要一个可以存储额外数据的方块（比如一个可以存储其库存的箱子），那么应该使用[block entity][blockentities]。这里的经验法则是，如果你有有限而且相当小的状态量（=最多几百个状态），使用blockstates；如果你有无限或近乎无限的状态量，使用方块实体。
+
+### `DeferredRegister.Blocks` 辅助器
+
+我们已经讨论了如何创建`DeferredRegister.Blocks`[上面]，以及它返回`DeferredBlock`的内容。现在，让我们看看这个专门的`DeferredRegister`还有哪些辅助工具。我们先从`#registerBlock`开始：
+
+```java
+public static final DeferredRegister.Blocks BLOCKS = DeferredRegister.createBlocks("yourmodid");
+
+public static final DeferredBlock EXAMPLE_BLOCK = BLOCKS.registerBlock(
+ "example_block",
+ Block::new, // 将使用的属性传递到哪个工厂。
+ BlockBehaviour.Properties.of() // 要使用的属性。
+);
+```
+
+在内部，这将简单地通过应用属性参数到所提供的方块工厂（通常是构造函数）来调用`BLOCKS.register("example_block", () -> new Block(BlockBehaviour.Properties.of()))`。
+
+如果你想使用`Block::new`，可以完全不使用工厂：
+
+```java
+public static final DeferredBlock EXAMPLE_BLOCK = BLOCKS.registerSimpleBlock(
+ "example_block",
+ BlockBehaviour.Properties.of() // 要使用的属性。
+);
+```
+
+这和之前的例子做的完全一样，只是稍微简洁了一些。当然，如果你想使用`Block`的子类而不是`Block`本身，你将不得不使用前面的方法。
+
+### 资源
+
+当你注册你的方块并将其放置在世界中时，你会发现它缺少如纹理等内容。这是因为[纹理]等内容是由Minecraft的资源系统处理的。要将纹理应用到方块上，你必须提供一个[模型]和一个与纹理和形状关联的[方块状态文件][bsfile]。阅读链接文章以获取更多信息。
+
+## 使用方块
+
+方块很少直接用来做事。实际上，可能在整个Minecraft中最常见的两个操作 - 获取位置上的方块，和设置位置上的方块 - 使用的是方块状态，而不是方块。一般的设计方法是让方块定义行为，但实际上通过方块状态来运行行为。因此，`BlockState`经常作为参数传递给`Block`的方法。有关如何使用方块状态的更多信息，以及如何从方块获取方块状态，请参见[使用方块状态][usingblockstates]。
+
+在几种情况下，`Block`的多个方法在不同的时间被使用。以下小节列出了最常见的与方块相关的流程。除非另有说明，否则所有方法都在逻辑两侧调用，并应在两侧返回相同的结果。
+
+### 放置方块
+
+方块放置逻辑是从`BlockItem#useOn`（或其某些子类的实现，例如用于睡莲的`PlaceOnWaterBlockItem`）调用的。有关游戏如何到达这一点的更多信息，请参见[交互流程][interactionpipeline]。实际上，这意味着一旦`BlockItem`被右键点击（例如圆石物品），这个行为就被调用。
+
+- 检查几个先决条件，例如你不是在旁观者模式下，所有要求的方块功能标志都已启用，或目标位置不在世界边界之外。如果至少有一个检查失败，流程结束。
+- 对当前位于被尝试放置方块的位置的方块调用`Block#canBeReplaced`。如果它返回`false`，流程结束。在这里返回`true`的显著案例是高草或雪层。
+- 调用`Block#getStateForPlacement`。这是根据上下文（包括位置，旋转和放置方块的侧面等信息）返回不同方块状态的地方。这对于例如可以以不同方向放置的方块很有用。
+- 用前一步获得的方块状态调用`Block#canSurvive`。如果返回`false`，流程结束。
+- 通过`Level#setBlock`调用将方块状态设置到游戏世界中。
+ - 在那个`Level#setBlock`调用中，调用`Block#onPlace`。
+- 调用`Block#setPlacedBy`。
+
+### 破坏方块
+
+破坏方块稍微复杂一些，因为它需要时间。这个过程可以大致分为三个阶段：“启动”，“挖掘”和“实际破坏”。
+
+- 当左键被点击时，进入“启动”阶段。
+- 现在，需要持续按住左键，进入“挖掘”阶段。**这个阶段的方法每个刻都会被调用。**
+- 如果“继续”阶段没有被中断（通过释放左键）并且方块被打破，那么进入“实际破坏”阶段。
+
+或者对于那些更喜欢伪代码的人：
+
+```java
+leftClick();
+initiatingStage();
+while (leftClickIsBeingHeld()) {
+ miningStage();
+ if (blockIsBroken()) {
+ actuallyBreakingStage();
+ break;
+ }
+}
+```
+
+以下小节进一步将这些阶段分解为实际的方法调用。
+
+#### “启动”阶段
+
+- 仅客户端：当左键和主手被触发时，会触发`InputEvent.InteractionKeyMappingTriggered`事件。如果事件被取消，流程结束。
+- 检查几个先决条件，例如你不是在旁观者模式下，主手中的`ItemStack`的所有必需功能标志都已启用，或被询问的方块不在世界边界之外。如果至少有一个检查失败，流程结束。
+- 触发`PlayerInteractEvent.LeftClickBlock`事件。如果事件被取消，流程结束。
+ - 注意当事件在客户端被取消时，不会向服务器发送数据包，因此服务器上不会运行任何逻辑。
+ - 然而，在服务器上取消此事件仍然会导致客户端代码运行，这可能会导致不同步！
+- 调用`Block#attack`。
+
+#### “挖掘”阶段
+
+- 触发`PlayerInteractEvent.LeftClickBlock`事件。如果事件被取消，流程移动到“结束”阶段。
+ - 注意当事件在客户端被取消时，不会向服务器发送数据包，因此服务器上不会运行任何逻辑。
+ - 然而，在服务器上取消此事件仍然会导致客户端代码运行，这可能会导致不同步！
+- 调用`Block#getDestroyProgress`并将其加到内部的破坏进度计数器上。
+ - `Block#getDestroyProgress`返回一个介于0和1之间的浮点值，表示破坏进度计数器每个刻应该增加多少。
+- 相应地更新进度覆盖（破裂纹理）。
+- 如果破坏进度大于1.0（即完成，即方块应该被破坏），则退出“挖掘”阶段并进入“实际破坏”阶段。
+
+#### “实际破坏”阶段
+
+- 调用`Item#onBlockStartBreak`。如果它返回`true`（决定方块不应被破坏），流程移动到“结束”阶段。
+- 仅服务器：调用`IBlockExtension#canHarvestBlock`。这决定了方块是否可以被收获，即是否可以带着掉落物被破坏。
+- 调用`Block#onDestroyedByPlayer`。如果它返回`false`，流程移动到“结束”阶段。在`Block#onDestroyedByPlayer`调用中：
+ - 调用`Block#playerWillDestroy`。
+ - 通过用`Blocks.AIR.defaultBlockState()`作为方块状态参数的`Level#setBlock`调用，从游戏世界中移除方块状态。
+ - 在那个`Level#setBlock`调用中，调用`Block#onRemove`。
+- 调用`Block#destroy`。
+- 仅服务器：如果之前对`IBlockExtension#canHarvestBlock`的调用返回了`true`，则调用`Block#playerDestroy`。
+- 仅服务器：调用`IBlockExtension#getExpDrop`。
+- 仅服务器：如果之前`IBlockExtension#getExpDrop`调用的结果大于0，就调用`Block#popExperience`。
+
+### 游戏刻
+
+游戏刻是一种机制，它在每1/20秒或50毫秒（“一个游戏刻”）更新（游戏刻）游戏的某些部分。方块提供了不同的游戏刻方法，这些方法以不同的方式被调用。
+
+#### 服务器游戏刻和游戏刻调度
+
+`Block#tick`在两种情况下被调用：通过默认的[随机刻][randomtick]（见下文），或通过调度的游戏刻。可以通过`Level#scheduleTick(BlockPos, Block, int)`创建调度的游戏刻，其中`int`表示延迟。这在vanilla的多个地方被使用，例如，大型滴叶的倾斜机制就严重依赖于这个系统。其他显著的使用者包括各种红石组件。
+
+#### 客户端游戏刻
+
+`Block#animateTick`仅在客户端，每帧被调用。这是发生客户端仅行为的地方，例如火炬粒子的生成。
+
+#### 天气游戏刻
+
+天气游戏刻由`Block#handlePrecipitation`处理，并独立于常规游戏刻运行。它仅在服务器上被调用，仅当以某种形式下雨时，有1/16的机会被调用。这被用于例如收集雨水或雪水的炼药锅。
+
+#### 随机刻
+
+随机刻系统独立于常规游戏刻运行。随机刻必须通过调用`BlockBehaviour.Properties`的`BlockBehaviour.Properties#randomTicks()`方法来启用。这使得方块可以是随机刻机制的一部分。
+
+每个刻为一个区块中设定数量的方块执行随机刻。这个设定数量是通过`randomTickSpeed`游戏规则定义的。其默认值为3，每个刻，从区块中随机选择3个方块。如果这些方块启用了随机刻，则分别调用它们的`Block#randomTick`方法。
+
+`Block#randomTick`默认调用`Block#tick`，这是通常应该被覆盖的。仅当你特别希望随机刻和常规（调度）游戏刻有不同行为时，才应覆盖`Block#randomTick`。
+
+随机刻被Minecraft中的许多机制使用，例如植物生长、冰雪融化或铜氧化。
+
+[above]: #one-block-to-rule-them-all
+[below]: #deferredregisterblocks-helpers
+[blockentities]: ../blockentities/index.md
+[blockstates]: states.md
+[bsfile]: ../resources/client/models/index.md#blockstate-files
+[events]: ../concepts/events.md
+[interactionpipeline]: ../items/interactionpipeline.md
+[item]: ../items/index.md
+[model]: ../resources/client/models/index.md
+[randomtick]: #random-ticking
+[registration]: ../concepts/registries.md#methods-for-registering
+[resources]: ../resources/index.md#assets
+[sounds]: ../resources/client/sounds.md
+[textures]: ../resources/client/textures.md
+[usingblocks]: #using-blocks
+[usingblockstates]: states.md#using-blockstates
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blocks/states.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blocks/states.md
new file mode 100644
index 000000000..9551668f3
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/blocks/states.md
@@ -0,0 +1,151 @@
+Blockstates
+===========
+
+经常会遇到想要拥有不同状态的方块的情况。例如，小麦作物有八个生长阶段，为每个阶段制作一个单独的方块感觉并不合适。或者你有一个台阶或类台阶方块 - 一个底部状态、一个顶部状态，以及一个状态同时具有两者。
+
+这就是Blockstates发挥作用的地方。Blockstates是一种表示方块可以具有的不同状态的简便方法，如生长阶段或台阶放置类型。
+
+Blockstate 属性
+---------------------
+
+Blockstates使用一套属性系统。一个方块可以具有多种类型的多个属性。例如，一个末地传送门框架有两个属性：它是否有一个眼睛（`eye`，2个选项）和放置的方向（`facing`，4个选项）。所以总的来说，末地传送门框架有8（2 * 4）个不同的Blockstates：
+
+```
+minecraft:end_portal_frame[facing=north,eye=false]
+minecraft:end_portal_frame[facing=east,eye=false]
+minecraft:end_portal_frame[facing=south,eye=false]
+minecraft:end_portal_frame[facing=west,eye=false]
+minecraft:end_portal_frame[facing=north,eye=true]
+minecraft:end_portal_frame[facing=east,eye=true]
+minecraft:end_portal_frame[facing=south,eye=true]
+minecraft:end_portal_frame[facing=west,eye=true]
+```
+
+表示法 `blockid[property1=value1,property2=value,...]` 是表示文本形式Blockstate的标准方式，并且在游戏的某些地方使用，例如在命令中。
+
+如果您的方块没有定义任何Blockstate属性，它仍然有一个Blockstate - 那就是没有任何属性的那个，因为没有属性需要指定。这可以表示为 `minecraft:oak_planks[]` 或者简单的 `minecraft:oak_planks`。
+
+与方块一样，每个 `BlockState` 在内存中仅存在一个。这意味着可以并且应该使用 `==` 来比较 `BlockState`。`BlockState` 也是一个终极类，意味着它不能被扩展。**任何功能都在相应的[Block][block]类中！**
+
+何时使用Blockstates
+-----------------------
+
+### Blockstates vs. 独立方块
+
+一个好的经验法则是：**如果它有一个不同的名称，它应该是一个独立的方块**。一个例子是制作椅子方块：椅子的方向应该是一个属性，而不同类型的木头应该分成不同的方块。所以你会有一个椅子方块适用于每种木头类型，每个椅子方块有四个Blockstates（每个方向一个）。
+
+### Blockstates vs. [方块实体][blockentity]
+
+这里的经验法则是：**如果你有一个有限的状态量，使用blockstate，如果你有一个无限或几乎无限的状态量，使用方块实体。** 方块实体可以存储任意量的数据，但比blockstates慢。
+
+Blockstates和方块实体可以联合使用。例如，箱子使用Blockstate属性来表示诸如方向、是否被水淹没或成为双箱子等事物，同时通过方块实体存储库存、是否当前打开或与漏斗的互动等。
+
+没有一个明确的答案来回答“对于Blockstate来说，多少状态太多了？”的问题，但我们建议，如果您需要超过8-9比特的数据（即超过几百种状态），您应该使用方块实体代替。
+
+实现Blockstates
+------------------------
+
+要实现Blockstate属性，在您的方块类中创建或引用一个 `public static final Property` 常量。虽然您可以自由制作自己的 `Property` 实现，但游戏代码提供了几种便利实现，应该涵盖大多数用例：
+
+* `IntegerProperty`
+ * 实现 `Property`。定义一个持有整数值的属性。注意不支持负值。
+ * 通过调用 `IntegerProperty#create(String propertyName, int minimum, int maximum)` 创建。
+* `BooleanProperty`
+ * 实现 `Property`。定义一个持有 `true` 或 `false` 值的属性。
+ * 通过调用 `BooleanProperty#create(String propertyName)` 创建。
+* `EnumProperty>`
+ * 实现 `Property`。定义一个可以取枚举类值的属性。
+ * 通过调用 `EnumProperty#create(String propertyName, Class enumClass)` 创建。
+ * 还可以使用枚举值的子集（例如，16个`DyeColor`s中的4个），见 `EnumProperty#create` 的重载方法。
+* `DirectionProperty`
+ * `DirectionProperty`
+ * 扩展自 `EnumProperty`。定义了一个可以承载 `Direction`（方向）的属性。
+ * 通过调用 `DirectionProperty#create(String propertyName)` 来创建。
+ * 提供了几个便利的谓词方法。例如，要获取代表基本方向的属性，调用 `DirectionProperty.create("", Direction.Plane.HORIZONTAL)`；要获取X轴方向，调用 `DirectionProperty.create("", Direction.Axis.X)`。
+
+类 `BlockStateProperties` 包含了共享的原版属性，这些属性应尽可能使用或引用，而不是创建自己的属性。
+
+一旦你有了你的属性常量，在你的方块类中重写 `Block#createBlockStateDefinition(StateDefinition$Builder)`。在该方法中，调用 `StateDefinition.Builder#add(YOUR_PROPERTY);`。`StateDefinition.Builder#add` 有一个变长参数，所以如果你有多个属性，你可以一次性添加它们所有。
+
+每个方块还有一个默认状态。如果没有指定其他内容，缺省状态使用每个属性的默认值。你可以通过从构造函数中调用 `Block#registerDefaultState(BlockState)` 方法来更改默认状态。
+
+如果你希望改变放置方块时使用的 `BlockState`，请重写 `Block#getStateForPlacement(BlockPlaceContext)`。这可以用来设置方块的方向，比如基于玩家放置时的站立位置或方向。
+
+为进一步说明，这是 `EndPortalFrameBlock` 类相关部分的样子：
+
+```java
+public class EndPortalFrameBlock extends Block {
+ // 注意：直接使用 BlockStateProperties 中的值而不是在这里再次引用它们是可能的。
+ // 然而，为了简单和可读性考虑，推荐像这样添加常量。
+ public static final DirectionProperty FACING = BlockStateProperties.FACING;
+ public static final BooleanProperty EYE = BlockStateProperties.EYE;
+
+ public EndPortalFrameBlock(BlockBehaviour.Properties pProperties) {
+ super(pProperties);
+ // stateDefinition.any() 返回一个内部集合中的随机 BlockState，
+ // 我们不在意，因为我们 anyway 要自己设置所有值
+ registerDefaultState(stateDefinition.any()
+ .setValue(FACING, Direction.NORTH)
+ .setValue(EYE, false)
+ );
+ }
+
+ @Override
+ protected void createBlockStateDefinition(StateDefinition.Builder pBuilder) {
+ // 这里是属性实际被添加到状态的地方
+ pBuilder.add(FACING, EYE);
+ }
+
+ @Override
+ @Nullable
+ public BlockState getStateForPlacement(BlockPlaceContext pContext) {
+ // 根据 BlockPlaceContext 确定放置此方块时将使用的状态的
+ // 代码
+ }
+}
+```
+
+使用 Blockstates
+----------------
+
+要从 `Block` 转换到 `BlockState`，调用 `Block#defaultBlockState()`。可以通过 `Block#registerDefaultState` 更改默认 blockstate，如上所述。
+
+你可以通过调用 `BlockState#getValue(Property)` 来获取一个属性的值，传递你想获取值的属性。复用我们末地传送门框架的例子，这看起来像这样：
+
+```java
+// EndPortalFrameBlock.FACING 是一个 DirectionProperty，因此可以用来从 BlockState 中获取一个 Direction
+Direction direction = endPortalFrameBlockState.getValue(EndPortalFrameBlock.FACING);
+```
+
+如果你想获得一个具有不同值集的 `BlockState`，只需在现有的 block state 上调用 `BlockState#setValue(Property, T)` 并传入属性及其值。对于我们的杠杆来说，像这样：
+
+```java
+endPortalFrameBlockState = endPortalFrameBlockState.setValue(EndPortalFrameBlock.FACING, Direction.SOUTH);
+```
+
+:::note
+`BlockState` 是不可变的。这意味着当你调用 `#setValue(Property, T)` 时，你实际上不是在修改 blockstate。相反，内部进行了查找，你得到了你请求的 blockstate 对象，那是唯一存在的、具有这些确切属性值的对象。这也意味着，仅仅调用 `state#setValue` 而没有将其保存到一个变量中（例如回到 `state` 中）是无效的。
+:::
+
+要从场景中获取一个 `BlockState`，使用 `Level#getBlockState(BlockPos)`。
+
+### `Level#setBlock`
+
+要在场景中设置一个 `BlockState`，使用 `Level#setBlock(BlockPos, BlockState, int)`。
+
+`int` 参数需要额外的解释，因为它的含义不立即明显。它表示更新标志。
+
+为了正确设置更新标志，`Block` 中有一些以 `UPDATE_` 开头的 `int` 常量。这些常量可以被按位或在一起（例如 `Block.UPDATE_NEIGHBORS | Block.UPDATE_CLIENTS`）如果你希望组合它们。
+
+- `Block.UPDATE_NEIGHBORS` 向相邻方块发送更新。更具体地说，它调用了 `Block#neighborChanged`，它调用了许多方法，其中大部分以某种方式与红石相关。
+- `Block.UPDATE_CLIENTS` 将方块更新同步到客户端。
+- `Block.UPDATE_INVISIBLE` 显式不在客户端更新。这也覆盖了 `Block.UPDATE_CLIENTS`，导致更新不被同步。方块始终在服务器上更新。
+- `Block.UPDATE_IMMEDIATE` 强制在客户端的主线程上重新渲染。
+- `Block.UPDATE_KNOWN_SHAPE` 停止邻居更新递归。
+- `Block.UPDATE_SUPPRESS_DROPS` 禁止旧方块在该位置的掉落物。
+- `Block.UPDATE_MOVE_BY_PISTON` 仅被活塞代码用于表示方块被活塞移动。这主要是为了延迟光照引擎的更新。
+- `Block.UPDATE_ALL` 是 `Block.UPDATE_NEIGHBORS | Block.UPDATE_CLIENTS` 的别名。
+- `Block.UPDATE_ALL_IMMEDIATE` 是 `Block.UPDATE_NEIGHBORS | Block.UPDATE_CLIENTS | Block.UPDATE_IMMEDIATE` 的别名。
+- `Block.NONE` 是 `Block.UPDATE_INVISIBLE` 的别名。
+
+还有一个便利方法 `Level#setBlockAndUpdate(BlockPos pos, BlockState state)`，它在内部调用 `setBlock(pos, state, Block.UPDATE_ALL)`。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/_category_.json
new file mode 100644
index 000000000..5e1f44f64
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Concepts"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/events.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/events.md
new file mode 100644
index 000000000..83debfc15
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/events.md
@@ -0,0 +1,137 @@
+# 事件系统
+
+NeoForge 的核心特性之一是其事件系统。在游戏中，各种事件根据游戏内的不同动作而触发。比如玩家右键点击、玩家或其他实体跳跃、方块渲染、游戏加载时等，都会触发相应的事件。模组开发者可以为这些事件编写处理函数，并在函数中实现他们期望的行为。
+
+这些事件会在相应的事件总线上触发。其中最重要的是 `NeoForge.EVENT_BUS`。此外，在游戏启动期间，系统会为每个加载的模组生成一个独立的模组总线，并传递给模组的构造函数。许多模组总线事件是并行触发的，这与总在同一个线程上运行的主总线事件不同，这种设计显著提高了启动速度。更多细节，请参考[下文][modbus]。
+
+## 注册事件处理函数
+
+注册事件处理函数有多种方式。所有这些方式的共同点是，每个事件处理函数都是一个只接收单一事件参数并且不返回结果（即返回类型为 `void`）的方法。
+
+### `IEventBus#addListener`
+
+最简单的注册方法是直接引用方法，如下所示：
+
+```java
+@Mod("yourmodid")
+public class YourMod {
+ public YourMod(IEventBus modBus) {
+ NeoForge.EVENT_BUS.addListener(YourMod::onLivingJump);
+ }
+
+ // 每次实体跳跃时为其恢复半颗心的生命值。
+ private static void onLivingJump(LivingJumpEvent event) {
+ Entity entity = event.getEntity();
+ // 仅在服务器端进行治疗
+ if (!entity.level().isClientSide()) {
+ entity.heal(1);
+ }
+ }
+}
+```
+
+### `@SubscribeEvent`
+
+另一种方式是使用注解来驱动事件处理，为处理函数添加 `@SubscribeEvent` 注解。然后将包含该处理函数的类的实例传递给事件总线，从而注册该实例中所有带有 `@SubscribeEvent` 注解的事件处理函数：
+
+```java
+public class EventHandler {
+ @SubscribeEvent
+ public void onLivingJump(LivingJumpEvent event) {
+ Entity entity = event.getEntity();
+ if (!entity.level().isClientSide()) {
+ entity.heal(1);
+ }
+ }
+}
+
+@Mod("yourmodid")
+public class YourMod {
+ public YourMod(IEventBus modBus) {
+ NeoForge.EVENT_BUS.addListener(new EventHandler());
+ }
+}
+```
+
+你还可以通过将所有事件处理函数设置为静态，并直接传递类本身，而不是类的实例来实现：
+
+```java
+public class EventHandler {
+ @SubscribeEvent
+ public static void onLivingJump(LivingJumpEvent event) {
+ Entity entity = event.getEntity();
+ if (!entity.level().isClientSide()) {
+ entity.heal(1);
+ }
+ }
+}
+
+@Mod("yourmodid")
+public class YourMod {
+ public YourMod(IEventBus modBus) {
+ NeoForge.EVENT_BUS.addListener(EventHandler.class);
+ }
+}
+```
+
+### `@Mod.EventBusSubscriber`
+
+我们可以进一步优化，将事件处理类标注为 `@Mod.EventBusSubscriber`。这个注解会被 NeoForge 自动识别，允许你从模组构造函数中移除所有与事件相关的代码。实际上，这等同于在模组构造结束时调用 `NeoForge.EVENT_BUS.register(EventHandler.class)`。这也意味着所有的处理函数必须设置为静态。
+
+虽然不是必须的，但强烈建议在注解中指定 `modid` 参数，以便在处理模组冲突时能够更容易进行调试。
+
+```java
+@Mod.EventBusSubscriber(modid = "yourmodid")
+public class EventHandler {
+ @SubscribeEvent
+ public static void onLivingJump(LivingJumpEvent event) {
+ Entity entity = event.getEntity();
+ if (!entity.level().isClientSide()) {
+ entity.heal(1);
+ }
+ }
+}
+```
+
+### 生命周期事件
+
+大多数模组总
+
+线事件被称为生命周期事件。生命周期事件在每个模组的生命周期中仅在启动时运行一次。很多这类事件是并行触发的，如果你想要在主线程上运行这些事件的代码，可以使用 `#enqueueWork(Runnable runnable)` 方法将它们加入队列。
+
+生命周期事件通常按以下顺序进行：
+
+- 调用模组构造函数。在这里或下一步注册你的事件处理函数。
+- 所有的 `@Mod.EventBusSubscriber` 被调用。
+- 触发 `FMLConstructModEvent` 事件。
+- 触发注册事件，包括 [`NewRegistryEvent`][newregistry]、[`DataPackRegistryEvent.NewRegistry`][newdatapackregistry] 以及每个注册表的 [`RegisterEvent`][registerevent]。
+- 触发 `FMLCommonSetupEvent` 事件。这是进行各种杂项设置的阶段。
+- 根据服务器类型触发侧边设置事件：如果在客户端，则为 `FMLClientSetupEvent`；如果在服务器，则为 `FMLDedicatedServerSetupEvent`。
+- 处理 `InterModComms`（详情见下文）。
+- 触发 `FMLLoadCompleteEvent` 事件。
+
+#### `InterModComms`
+
+`InterModComms` 是一个系统，允许模组开发者向其他模组发送消息以实现功能兼容。这个系统保存了模组的消息，所有方法都是线程安全的。主要通过两个事件推动：`InterModEnqueueEvent` 和 `InterModProcessEvent`。
+
+在 `InterModEnqueueEvent` 期间，你可以使用 `InterModComms#sendTo` 向其他模组发送消息。这些方法接受要发送消息到的模组的 ID、与消息数据相关的键（以区分不同的消息），以及持有消息数据的 `Supplier`。发送者可以选择性指定。
+
+接着，在 `InterModProcessEvent` 期间，你可以使用 `InterModComms#getMessages` 获取作为 `IMCMessage` 对象的所有接收到的消息的流。这些消息包含了数据的发送者、预期的接收者、数据键和实际数据的供应商。
+
+### 其他模组总线事件
+
+除了生命周期事件外，还有一些其他在模组总线上触发的杂项事件，主要是出于历史原因。这些事件通常不是并行运行的，与生命周期事件相反。例如：
+
+- `RegisterColorHandlersEvent`
+- `ModelEvent.BakingCompleted`
+- `TextureStitchEvent`
+
+:::warning
+计划在未来版本中将大多数这些事件转移到主事件总线上。
+:::
+
+[modbus]: #event-buses
+[newdatapackregistry]: registries.md#custom-datapack-registries
+[newregistry]: registries.md#custom-registries
+[registerevent]: registries.md#registerevent
+[side]: sides.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/registries.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/registries.md
new file mode 100644
index 000000000..c959c41e3
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/registries.md
@@ -0,0 +1,320 @@
+# 注册
+
+注册是将模组中的对象（如[物品][item]、[方块][block]、实体等）加入游戏并使其被游戏识别的过程。注册这些对象非常重要，因为如果不注册，游戏将无法识别这些对象，这将导致无法解释的行为和崩溃。
+
+简而言之，注册表是围绕映射注册名称（下面将说明）到注册对象的映射的封装，这些注册对象通常称为注册表项。注册名在同一注册表中必须唯一，但同一注册名可以出现在多个注册表中。最常见的例子是方块（在`BLOCKS`注册表中）具有与其同名的物品形式（在`ITEMS`注册表中）。
+
+每个注册对象都有一个唯一的名称，称为其注册名称。名称表示为[`ResourceLocation`][resloc]。例如，泥土方块的注册名称为`minecraft:dirt`，僵尸的注册名称为`minecraft:zombie`。当然，模组化对象不会使用`minecraft`命名空间；而是使用它们的模组ID。
+
+## 原版与模组化
+
+为了理解NeoForge的注册系统中所做的一些设计决策，我们首先看看Minecraft是如何处理这一问题的。我们将使用方块注册表作为例子，因为大多数其他注册表的工作方式相同。
+
+注册表通常注册[单例][singleton]。这意味着所有注册表项实际上只存在一次。例如，你在游戏中看到的所有石块实际上都是同一个石块，被多次显示。如果你需要石块，可以通过引用已注册的方块实例来获取它。
+
+Minecraft在`Blocks`类中注册所有方块。通过`register`方法，调用`Registry#register()`，其中第一个参数是方块注册表`BuiltInRegistries.BLOCK`。所有方块注册完成后，Minecraft会根据方块列表进行各种检查，例如验证所有方块是否已加载模型的自检。
+
+这一切之所以能够工作，是因为`Blocks`类在Minecraft中足够早地被类加载。模组并不会被Minecraft自动类加载，因此需要一些变通方法。
+
+## 注册方法
+
+NeoForge提供了两种注册对象的方式：`DeferredRegister`类和`RegisterEvent`。请注意，前者是后者的封装，并且为了防止错误，推荐使用。
+
+### `DeferredRegister`
+
+我们首先创建我们的`DeferredRegister`：
+
+```java
+public static final DeferredRegister BLOCKS = DeferredRegister.create(
+ // 我们想要使用的注册表。
+ // Minecraft的注册表可以在BuiltInRegistries中找到，NeoForge的注册表可以在NeoForgeRegistries中找到。
+ // 模组也可以添加它们自己的注册表，具体请参考各个模组的文档或源代码。
+ BuiltInRegistries.BLOCKS,
+ // 我们的模组ID。
+ ExampleMod.MOD_ID
+);
+```
+
+然后，我们可以将我们的注册表项添加为静态最终字段（有关在`new Block()`中添加什么参数，请参阅[关于方块的文章][block]）：
+
+```java
+public static final DeferredHolder EXAMPLE_BLOCK = BLOCKS.register(
+ "example_block" // 我们的注册名称。
+ () -> new Block(...) // 我们想要注册的对象的供应商。
+);
+```
+
+`DeferredHolder`类持有我们的对象。类型参数`R`是我们正在注册到的注册表的类型（在这个例子中是`Block`）。类型参数`T`是我们供应商的类型。由于我们在这个例子中直接注册了一个`Block`，我们提供了`Block`作为第二个参数。如果我们
+
+要注册一个`Block`的子类的对象，例如`SlabBlock`，我们将在此提供`SlabBlock`。
+
+`DeferredHolder`是`Supplier`的子类。当我们需要时可以调用`DeferredHolder#get()`来获取我们注册的对象。`DeferredHolder`扩展`Supplier`的事实也允许我们使用`Supplier`作为我们字段的类型。这样，上面的代码块变为以下内容：
+
+```java
+public static final Supplier EXAMPLE_BLOCK = BLOCKS.register(
+ "example_block" // 我们的注册名称。
+ () -> new Block(...) // 我们想要注册的对象的供应商。
+);
+```
+
+请注意，有些地方明确要求使用`Holder`或`DeferredHolder`，而不仅仅接受任何`Supplier`。如果你需要其中的两者之一，最好将你的`Supplier`的类型更改回`Holder`或`DeferredHolder`。
+
+最后，由于整个系统是围绕注册事件的封装，我们需要告诉`DeferredRegister`根据需要将自己附加到注册事件上：
+
+```java
+// 这是我们的模组构造函数
+public ExampleMod(IModEventBus bus) {
+ // 高亮下一行
+ ExampleBlocksClass.BLOCKS.register(bus);
+ // 这里还有其他内容
+}
+```
+
+:::info
+有针对方块和物品的`DeferredRegister`的特化变体，它们提供辅助方法，分别称为[`DeferredRegister.Blocks`][defregblocks]和[`DeferredRegister.Items`][defregitems]。
+:::
+
+### `RegisterEvent`
+
+`RegisterEvent`是注册对象的第二种方式。这个[事件][event]在模组构造函数之后（因为这是`DeferredRegister`注册它们内部事件处理器的地方）和加载配置之前为每个注册表触发。`RegisterEvent`在模组事件总线上触发。
+
+```java
+@SubscribeEvent
+public void register(RegisterEvent event) {
+ event.register(
+ // 这是注册表的注册键。
+ // 从BuiltInRegistries获取vanilla注册表的，
+ // 或从NeoForgeRegistries.Keys获取NeoForge注册表的。
+ BuiltInRegistries.BLOCKS,
+ // 在这里注册你的对象。
+ registry -> {
+ registry.register(new ResourceLocation(MODID, "example_block_1"), new Block(...));
+ registry.register(new ResourceLocation(MODID, "example_block_2"), new Block(...));
+ registry.register(new ResourceLocation(MODID, "example_block_3"), new Block(...));
+ }
+ );
+}
+```
+
+## 查询注册表
+
+有时候，你可能会发现自己处于想要通过给定ID获取注册对象的情况，或者你想要获取某个注册对象的ID。由于注册表本质上是ID（`ResourceLocation`）到独立对象的映射，即可逆映射，这两种操作都是可行的：
+
+```java
+BuiltInRegistries.BLOCKS.get(new ResourceLocation("minecraft", "dirt")); // 返回泥土方块
+BuiltInRegistries.BLOCKS.getKey(Blocks.DIRT); // 返回资源位置"minecraft:dirt"
+
+// 假设ExampleBlocksClass.EXAMPLE_BLOCK.get()是具有ID"yourmodid:example_block"的Supplier
+BuiltInRegistries.BLOCKS.get(new ResourceLocation("yourmodid", "example_block")); // 返回示例方块
+BuiltInRegistries.BLOCKS.getKey(ExampleBlocksClass.EXAMPLE_BLOCK.get()); // 返回资源位置"yourmodid:example_block"
+```
+
+如果你只是想检查是否存在某个对象，这也是可能的，尽管只能用键：
+
+```java
+BuiltInRegistries.BLOCKS.containsKey(new ResourceLocation("minecraft", "dirt")); // true
+BuiltInRegistries.BLOCKS.containsKey(new ResourceLocation("create", "brass_ingot")); // 如果安装了Create则为true
+```
+
+正如最后一个示例所示，这适用于任何模组ID，因此是检查另一个模组中是否存在某个物品的完美方式。
+
+最后，我们还可以迭代注册表中的所有条目，无论是键还
+
+是条目（条目使用Java的`Map.Entry`类型）：
+
+```java
+for (ResourceLocation id : BuiltInRegistries.BLOCKS.keySet()) {
+ // ...
+}
+for (Map.Entry entry : BuiltInRegistries.BLOCKS.entrySet()) {
+ // ...
+}
+```
+
+:::note
+查询操作始终使用vanilla `Registry`，而不是`DeferredRegister`。这是因为`DeferredRegister`只是注册工具。
+:::
+
+:::danger
+查询操作只有在注册完成后才安全使用。**不要在注册仍在进行时查询注册表！**
+:::
+
+## 自定义注册表
+
+自定义注册表允许你指定其他模组可能想要接入的附加系统。例如，如果你的模组要添加效果，你可以使效果成为一个注册表，从而允许其他模组添加效果到你的模组中，而无需你做任何其他事情。它还允许你自动执行一些操作，如同步条目。
+
+让我们从创建[注册表键][resourcekey]和注册表本身开始：
+
+```java
+// 我们在这里使用效果作为注册表的例子，不涉及效果实际是什么（因为这不重要）。
+// 当然，所有提到的效果都可以并且应该替换为你的注册表实际是什么。
+public static final ResourceKey> SPELL_REGISTRY_KEY = ResourceKey.createRegistryKey(new ResourceLocation("yourmodid", "spells"));
+public static final Registry SPELL_REGISTRY = new RegistryBuilder<>(SPELL_REGISTRY_KEY)
+ // If you want to enable integer id syncing, for networking.
+ // These should only be used in networking contexts, for example in packets or purely networking-related NBT data.
+ .sync(true)
+ // The default key. Similar to minecraft:air for blocks. This is optional.
+ .defaultKey(new ResourceLocation("yourmodid", "empty"))
+ // Effectively limits the max count. Generally discouraged, but may make sense in settings such as networking.
+ .maxId(256)
+ // Build the registry.
+ .create();
+```
+
+然后，通过将注册表注册到 `NewRegistryEvent` 中的根注册表来告诉游戏注册表存在：
+
+```java
+@SubscribeEvent
+static void registerRegistries(NewRegistryEvent event) {
+ event.register(SPELL_REGISTRY);
+}
+```
+
+现在，您可以像使用任何其他注册表一样，通过`DeferredRegister`和`RegisterEvent`注册新的注册表内容：
+```java
+public static final DeferredRegister SPELLS = DeferredRegister.create("yourmodid", SPELL_REGISTRY);
+public static final Supplier EXAMPLE_SPELL = SPELLS.register("example_spell", () -> new Spell(...));
+
+// Alternatively:
+@SubscribeEvent
+public static void register(RegisterEvent event) {
+ event.register(SPELL_REGISTRY, registry -> {
+ registry.register(new ResourceLocation("yourmodid", "example_spell"), () -> new Spell(...));
+ });
+}
+```
+
+# 数据包注册表
+
+数据包注册表（也称为动态注册表或世界生成注册表）是一种特殊的注册表，它在世界加载时从数据包 JSON 文件中加载数据，而不是在游戏启动时加载。默认的数据包注册表主要包括大多数世界生成注册表和其他一些注册表。
+
+数据包注册表允许通过 JSON 文件指定其内容。这意味着除了数据生成工具外，不需要任何代码（如果你不想自己编写 JSON 文件的话）。每个数据包注册表都有一个与之关联的编解码器（`Codec`），用于序列化，每个注册表的 ID 决定了其数据包路径：
+
+- Minecraft 的数据包注册表使用格式 `data/yourmodid/registrypath`（例如 `data/yourmodid/worldgen/biomes`，其中 `worldgen/biomes` 是注册表路径）。
+- 所有其他数据包注册表（NeoForge 或模组化的）使用格式 `data/yourmodid/registrynamespace/registrypath`（例如 `data/yourmodid/neoforge/loot_modifiers`，其中 `neoforge` 是注册表命名空间，`loot_modifiers` 是注册表路径）。
+
+可以从 `RegistryAccess` 获取数据包注册表。如果在服务器上，可以通过调用 `ServerLevel#registryAccess()` 来检索此 `RegistryAccess`；如果在客户端，可以通过调用 `Minecraft.getInstance().connection#registryAccess()` 来检索（后者仅在实际连接到世界时有效，否则连接将为 null）。然后可以像使用任何其他注册表一样使用这些调用的结果来获取特定元素或遍历内容。
+
+### 自定义数据包注册表
+
+自定义数据包注册表不需要构建 `Registry`。相反，它们只需要一个注册表键和至少一个编解码器（`Codec`）来序列化和反序列化其内容。根据之前的法术示例，将我们的法术注册表注册为数据包注册表的过程如下所示：
+
+```java
+public static final ResourceKey> SPELL_REGISTRY_KEY = ResourceKey.createRegistryKey(new ResourceLocation("yourmodid", "spells"));
+
+@SubscribeEvent
+public static void registerDatapackRegistries(DataPackRegistryEvent.NewRegistry event) {
+ event.dataPackRegistry(
+ // 注册表键。
+ SPELL_REGISTRY_KEY,
+ // 注册表内容的编解码器。
+ Spell.CODEC,
+ // 网络编解码器。通常与普通编解码器相同。
+ // 可能是普通编解码器的简化版本，省略了客户端不需要的数据。
+ // 可能为 null。如果为 null，则注册表条目根本不会同步到客户端。
+ // 可以省略，这在功能上与传递 null 相同（调用了一个带有两个参数的方法重载，该重载向普通的三参数方法传递 null）。
+ Spell.CODEC
+ );
+}
+```
+
+### 数据包注册表的数据生成
+
+由于手工编写所有 JSON 文件既繁琐又容易出错，NeoForge 提供了一个数据提供器来为你生成 JSON 文件。这适用于内置的和你自己的数据包注册表。
+
+首先，我们创建一个 `RegistrySetBuilder` 并向其添加条目（一个 `RegistrySetBuilder` 可以包含多个注册表的条目）：
+
+```java
+new RegistrySetBuilder()
+ .add(Registries.CONFIGURED_FEATURE, bootstrap -> {
+ // 通过引导上下文注册配置特性。
+ })
+ .add(Registries.PLACED_FEATURE, bootstrap -> {
+ // 通过引导上下文注册放置特性。
+ });
+```
+
+`bootstrap` lambda 参数是我们实际用来注册对象的。要注册一个对象，我们这样调用 `#register`：
+
+```java
+// 我们对象的资源键。
+public static final ResourceKey> EXAMPLE_CONFIGURED_FEATURE = ResourceKey.create(
+ Registries.CONFIGURED_FEATURE,
+ new ResourceLocation(MOD_ID, "example_configured_feature
+
+")
+);
+
+new RegistrySetBuilder()
+ .add(Registries.CONFIGURED_FEATURE, bootstrap -> {
+ bootstrap.register(
+ // 我们配置特性的资源键。
+ EXAMPLE_CONFIGURED_FEATURE,
+ // 实际的配置特性。
+ new ConfiguredFeature<>(Feature.ORE, new OreConfiguration(...))
+ );
+ })
+ .add(Registries.PLACED_FEATURE, bootstrap -> {
+ // ...
+ });
+```
+
+如果需要，`BootstrapContext`（在 1.20.4 及以下版本中名称误写为 `BootstapContext`）还可以用来从另一个注册表查找条目：
+
+```java
+public static final ResourceKey> EXAMPLE_CONFIGURED_FEATURE = ResourceKey.create(
+ Registries.CONFIGURED_FEATURE,
+ new ResourceLocation(MOD_ID, "example_configured_feature")
+);
+public static final ResourceKey EXAMPLE_PLACED_FEATURE = ResourceKey.create(
+ Registries.PLACED_FEATURE,
+ new ResourceLocation(MOD_ID, "example_placed_feature")
+);
+
+new RegistrySetBuilder()
+ .add(Registries.CONFIGURED_FEATURE, bootstrap -> {
+ bootstrap.register(EXAMPLE_CONFIGURED_FEATURE, ...);
+ })
+ .add(Registries.PLACED_FEATURE, bootstrap -> {
+ HolderGetter> otherRegistry = bootstrap.lookup(Registries.CONFIGURED_FEATURE);
+ bootstrap.register(EXAMPLE_PLACED_FEATURE, new PlacedFeature(
+ otherRegistry.getOrThrow(EXAMPLE_CONFIGURED_FEATURE), // 获取配置特性
+ List.of() // 放置发生时无操作 - 替换为你的放置参数
+ ));
+ });
+```
+
+最后，我们在实际的数据提供器中使用我们的 `RegistrySetBuilder` 并将该数据提供器注册到事件中：
+
+```java
+@SubscribeEvent
+static void onGatherData(GatherDataEvent event) {
+ event.getGenerator().addProvider(
+ // 仅在生成服务器数据时运行数据包生成
+ event.includeServer(),
+ // 创建提供器
+ output -> new DatapackBuiltinEntriesProvider(
+ output,
+ event.getLookupProvider(),
+ // 我们的注册表集生成器来生成数据。
+ new RegistrySetBuilder().add(...),
+ // 我们正在生成的模组 ID 集合。通常只有你自己的模组 ID。
+ Set.of("yourmodid")
+ )
+ );
+}
+```
+
+[block]: ../blocks/index.md
+[blockentity]: ../blockentities/index.md
+[codec]: ../datastorage/codecs.md
+[datagen]: #data-generation-for-datapack-registries
+[datagenindex]: ../resources/index.md#data-generation
+[datapack]: ../resources/server/index.md
+[defregblocks]: ../blocks/index.md#deferredregisterblocks-helpers
+[defregitems]: ../items/index.md#deferredregisteritems
+[event]: ./events.md
+[item]: ../items/index.md
+[resloc]: ../misc/resourcelocation.md
+[resourcekey]: ../misc/resourcelocation.md#resourcekeys
+[singleton]: https://en.wikipedia.org/wiki/Singleton_pattern
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/sides.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/sides.md
new file mode 100644
index 000000000..e2154f25c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/concepts/sides.md
@@ -0,0 +1,77 @@
+# 游戏两侧的区分
+
+和许多其他程序一样，Minecraft 遵循客户端-服务器的概念，其中客户端负责显示数据，而服务器负责更新数据。当我们使用这些术语时，我们对其含义有一个相当直观的理解...对吗？
+
+事实证明，并非如此。很多混淆源于 Minecraft 有两种不同的“侧”的概念，这取决于上下文：物理侧和逻辑侧。
+
+## 逻辑侧与物理侧
+
+### 物理侧
+
+当你打开 Minecraft 启动器，选择一个 Minecraft 安装并按下播放时，你启动了一个**物理客户端**。这里使用“物理”一词是在“这是一个客户端程序”的意义上。这尤其意味着客户端功能，如所有渲染相关的功能，都可以在这里使用。相比之下，**物理服务器**，也称为专用服务器，是在你启动一个 Minecraft 服务器 JAR 时打开的。虽然 Minecraft 服务器带有一个基本的 GUI，但它缺少所有仅限客户端的功能。最值得注意的是，各种客户端类在服务器 JAR 中缺失。在物理服务器上调用这些类将导致缺少类错误，即崩溃，因此我们需要对此进行防护。
+
+### 逻辑侧
+
+逻辑侧主要关注 Minecraft 的内部程序结构。**逻辑服务器**是游戏逻辑运行的地方。如时间和天气变化、实体更新、实体生成等都在服务器上运行。所有种类的数据，如库存内容，也都是服务器的责任。另一方面，**逻辑客户端**负责显示所有需要显示的内容。Minecraft 在一个名为 `net.minecraft.client` 的独立包中保留了所有客户端代码，并在一个名为渲染线程的独立线程中运行它，而其他所有内容都被视为公共代码（即客户端和服务器代码）。
+
+### 两者有何区别？
+
+物理侧和逻辑侧之间的区别最好通过两种情况来说明：
+
+- 玩家加入一个**多人游戏**世界。这相当直接：玩家的物理（和逻辑）客户端连接到别处的一个物理（和逻辑）服务器——玩家不关心在哪里；只要他们能连接，这就是所有客户端知道的，也是所有客户端需要知道的。
+- 玩家加入一个**单人游戏**世界。这里的情况变得有趣。玩家的物理客户端启动了一个逻辑服务器，然后现在作为逻辑客户端，连接到同一台机器上的那个逻辑服务器。如果你熟悉网络，你可以把它想象为连接到`localhost`（只是概念上的；没有实际的套接字或类似的东西涉及）。
+
+这两种情况也显示了主要问题：如果一个逻辑服务器可以使用你的代码，这并不保证物理服务器也能同样使用。这就是为什么你应该始终使用专用服务器进行测试，以检查意外行为。由于客户端和服务器分离不当导致的`NoClassDefFoundError`和`ClassNotFoundException`是模组制作中最常见的错误之一。另一个常见的错误是使用静态字段，并从两个逻辑侧访问它们；这特别棘手，因为通常没有迹象表明有什么问题。
+
+:::tip
+如果你需要将数据从一侧传输到另一侧，你必须[发送一个数据包
+
+][networking]。
+:::
+
+在 NeoForge 代码库中，物理侧由一个名为 `Dist` 的枚举表示，而逻辑侧由一个名为 `LogicalSide` 的枚举表示。
+
+:::info
+从历史上看，服务器 JAR 拥有客户端没有的类。在现代版本中，这种情况已不复存在；如果愿意，可以认为物理服务器是物理客户端的一个子集。
+:::
+
+## 执行侧特定操作
+
+### `Level#isClientSide()`
+
+这个布尔检查将是你最常用的检查侧的方式。在 `Level` 对象上查询此字段可以确定级别所属的**逻辑**侧：如果此字段为 `true`，则级别在逻辑客户端上运行。如果字段为 `false`，则级别在逻辑服务器上运行。据此，物理服务器将始终在此字段中包含 `false`，但我们不能假设 `false` 暗示物理服务器，因为此字段也可能在物理客户端内的逻辑服务器（即单人游戏世界）中为 `false`。
+
+只有在需要确定是否运行游戏逻辑和其他机制时才使用此检查。例如，如果你想在玩家每次点击你的方块时对玩家造成伤害，或者让你的机器将泥土处理成钻石，你应该确保 `#isClientSide` 为 `false` 后再进行。在逻辑客户端应用游戏逻辑可能导致最好的情况下出现数据不同步（幽灵实体、不同步的统计数据等），在最坏的情况下导致崩溃。
+
+:::tip
+这个检查应该作为你的默认选择。每当你有一个 `Level` 可用时，就使用这个检查。
+:::
+
+### `FMLEnvironment.dist`
+
+`FMLEnvironment.dist` 是 `Level#isClientSide()` 检查的**物理**对应项。如果此字段为 `Dist.CLIENT`，你就在物理客户端上。如果字段为 `Dist.SERVER`，你就在物理服务器上。
+
+检查物理环境在处理仅限客户端的类时非常重要。所有对客户端代码的调用都应始终包含在对 `Dist.CLIENT` 的检查中，并然后调用一个单独的类以防止意外的类加载：
+
+```java
+public class SomeCommonClass {
+ public void someCommonMethod() {
+ // 仅当你在物理客户端上时，SomeClientClass 才会被加载
+ if (FMLEnvironment.dist == Dist.CLIENT) {
+ SomeClientClass.someClientMethod();
+ }
+ }
+}
+
+public class SomeClientClass {
+ public static void someClientMethod() {
+ Minecraft.getInstance().whatever();
+ }
+}
+```
+
+:::tip
+通常期望模组在任一侧都能工作。这特别意味着，如果你正在开发一个仅限客户端的模组，你应该验证该模组实际上在物理客户端上运行，并且在不运行的情况下无操作。
+:::
+
+[networking]: ../networking/index.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/_category_.json
new file mode 100644
index 000000000..e3a3b9265
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Datagen"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/advancements.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/advancements.md
new file mode 100644
index 000000000..bca701e5c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/advancements.md
@@ -0,0 +1,68 @@
+# 成就生成
+======================
+
+[成就] 可以通过构建一个新的 `AdvancementProvider` 并提供 `AdvancementSubProvider` 来为模组生成。成就可以手动创建和提供，或者为了方便，使用 `Advancement$Builder` 创建。提供者必须[添加][datagen]到 `DataGenerator` 中。
+
+:::note
+Forge 提供了一个扩展的 `AdvancementProvider`，名为 `ForgeAdvancementProvider`，它更适合生成成就。因此，本文档将使用 `ForgeAdvancementProvider` 以及子提供者接口 `ForgeAdvancementProvider$AdvancementGenerator`。
+:::
+
+```java
+// 在 MOD 事件总线上
+@SubscribeEvent
+public void gatherData(GatherDataEvent event) {
+ event.getGenerator().addProvider(
+ // 仅在生成服务器数据时运行生成器
+ event.includeServer(),
+ output -> new ForgeAdvancementProvider(
+ output,
+ event.getLookupProvider(),
+ event.getExistingFileHelper(),
+ // 生成成就的子提供者
+ List.of(subProvider1, subProvider2, /*...*/)
+ )
+ );
+}
+```
+
+`ForgeAdvancementProvider$AdvancementGenerator`
+-----------------------------------------------
+
+`ForgeAdvancementProvider$AdvancementGenerator` 负责生成成就，包含一个方法，该方法接收注册表查找、写入者 (`Consumer`) 和现有文件助手。
+
+```java
+// 在 ForgeAdvancementProvider$AdvancementGenerator 的某个子类中或作为 lambda 引用
+
+@Override
+public void generate(HolderLookup.Provider registries, Consumer writer, ExistingFileHelper existingFileHelper) {
+ // 在这里构建成就
+}
+```
+
+`Advancement$Builder`
+---------------------
+
+`Advancement$Builder` 是一个便利的实现，用于创建用于生成的 `Advancement`。它允许定义父成就、显示信息、完成成就时的奖励以及解锁成就的要求。只需指定要求即可创建一个 `Advancement`。
+
+虽然不是必需的，但有几个方法是重要的：
+
+方法 | 描述
+:---: | :---
+`parent` | 设置此成就直接链接到的成就。可以指定成就的名称或如果由模组制作者生成，则指定成就本身。
+`display` | 设置显示在聊天、弹窗和成就屏幕上的信息。
+`rewards` | 设置完成此成就时获得的奖励。
+`addCriterion` | 为成就添加条件。
+`requirements` | 指定条件是否必须全部为真，或者至少有一个为真。可以使用额外的重载来混合这些操作。
+
+一旦 `Advancement$Builder` 准备好建造，应调用 `#save` 方法，该方法需要写入者、成就的注册名和用于检查提供的父项是否存在的文件助手。
+
+```java
+// 在某个 ForgeAdvancementProvider$AdvancementGenerator#generate(registries, writer, existingFileHelper) 中
+Advancement example = Advancement.Builder.advancement()
+ .addCriterion("example_criterion", triggerInstance) // 如何解锁成就
+ .save(writer, name, existingFileHelper); // 将数据添加到构建器
+```
+
+[成就]: ../../resources/server/advancements.md
+[datagen]: ../index.md#data-providers
+[conditional]: ../../resources/server/conditional.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/glm.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/glm.md
new file mode 100644
index 000000000..e7aafcebe
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/glm.md
@@ -0,0 +1,30 @@
+# 全局战利品修改器生成
+===============================
+
+通过继承 `GlobalLootModifierProvider` 并实现 `#start` 方法，可以为模组生成[全局战利品修改器 (GLMs)][glm]。通过调用 `#add` 并指定修改器的名称和将被序列化的[修改器实例][instance]，可以添加生成每个 GLM。实现后，必须将提供者[添加][datagen]到 `DataGenerator`。
+
+```java
+// 在 MOD 事件总线上
+@SubscribeEvent
+public void gatherData(GatherDataEvent event) {
+ event.getGenerator().addProvider(
+ // 通知生成器仅在生成服务器数据时运行
+ event.includeServer(),
+ output -> new MyGlobalLootModifierProvider(output, MOD_ID)
+ );
+}
+
+// 在某个 GlobalLootModifierProvider#start 中
+this.add("example_modifier", new ExampleModifier(
+ new LootItemCondition[] {
+ WeatherCheck.weather().setRaining(true).build() // 在下雨时执行
+ },
+ "val1",
+ 10,
+ Items.DIRT
+));
+```
+
+[glm]: ../../resources/server/glm.md
+[instance]: ../../resources/server/glm.md#igloballootmodifier
+[datagen]: ../index.md#data-providers
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/loottables.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/loottables.md
new file mode 100644
index 000000000..da652a3ed
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/loottables.md
@@ -0,0 +1,148 @@
+# 战利品表生成
+=====================
+
+通过构建一个新的 `LootTableProvider` 并提供 `LootTableProvider$SubProviderEntry`，可以为模组生成[战利品表][loottable]。提供者必须被[添加][datagen]到 `DataGenerator`。
+
+```java
+// 在 MOD 事件总线上
+@SubscribeEvent
+public void gatherData(GatherDataEvent event) {
+ event.getGenerator().addProvider(
+ // 告诉生成器仅在生成服务器数据时运行
+ event.includeServer(),
+ output -> new MyLootTableProvider(
+ output,
+ // 指定需要生成的表的注册名称，或者可以留空
+ Collections.emptySet(),
+ // 生成战利品的子提供者
+ List.of(subProvider1, subProvider2, /*...*/)
+ )
+ );
+}
+```
+
+`LootTableSubProvider`
+----------------------
+
+每个 `LootTableProvider$SubProviderEntry` 都接收一个 `LootTableSubProvider`，它为给定的 `LootContextParamSet` 生成战利品表。`LootTableSubProvider` 包含一个方法，该方法接收写入者（`BiConsumer`）来生成表。
+
+```java
+public class ExampleSubProvider implements LootTableSubProvider {
+
+ // 用于创建封装 Supplier 的工厂方法
+ public ExampleSubProvider() {}
+
+ // 用于生成战利品表的方法
+ @Override
+ public void generate(BiConsumer writer) {
+ // 在这里通过调用 writer#accept 生成战利品表
+ }
+}
+```
+
+然后可以将表添加到 `LootTableProvider#getTables` 中，适用于任何可用的 `LootContextParamSet`：
+
+```java
+// 传递到 LootTableProvider 构造函数的列表中
+new LootTableProvider.SubProviderEntry(
+ ExampleSubProvider::new,
+ // 为 'empty' 参数集生成战利品表
+ LootContextParamSets.EMPTY
+)
+```
+
+### `BlockLootSubProvider` 和 `EntityLootSubProvider` 子类
+
+对于 `LootContextParamSets#BLOCK` 和 `#ENTITY`，有特殊类型（分别是 `BlockLootSubProvider` 和 `EntityLootSubProvider`），它们提供额外的辅助方法来创建和验证是否存在战利品表。
+
+`BlockLootSubProvider` 的构造函数接受一个物品列表，用于确定如果一个方块被爆炸时是否可以生成战利品表，以及一个 `FeatureFlagSet`，用于确定是否启用了方块以便为其生成战利品表。
+
+```java
+// 在某个 BlockLootSubProvider 子类中
+public MyBlockLootSubProvider() {
+ super(Collections.emptySet(), FeatureFlags.REGISTRY.allFlags());
+}
+```
+
+`EntityLootSubProvider` 的构造函数接受一个 `FeatureFlagSet`，用于确定是否启用了实体类型以便为其生成战利品表。
+
+```java
+// 在某个 EntityLootSubProvider 子类中
+public MyEntityLootSubProvider() {
+ super(FeatureFlags.REGISTRY.allFlags());
+}
+```
+
+要使用它们，所有已注册的对象必须分别提供给 `BlockLootSubProvider#getKnownBlocks` 和 `EntityLootSubProvider#getKnownEntityTypes`。这些方法确保迭代中的所有对象都有一个战利品表。
+
+:::tip
+如果使用 `DeferredRegister` 来注册模组的对象，则 `#getKnown*` 方法可以通过 `DeferredRegister#getEntries` 提供条目：
+
+```java
+// 在某个 BlockLootSubProvider 子类中，用于某个 DeferredRegister BLOCK_REGISTRAR
+@Override
+protected Iterable getKnownBlocks() {
+ return BLOCK_REGISTRAR.getEntries() // 获取所有注册的条目
+ .stream() // 流式处理封装的对象
+ .flatMap(RegistryObject::stream) // 如果可用，则获取对象
+ ::iterator; // 创建迭代器
+}
+```
+:::
+
+通过实现 `#generate` 方法可以添加战利品表。
+
+```java
+// 在某个 BlockLootSubProvider 子类中
+@Override
+public void
+
+ generate() {
+ // 在这里添加战利品表
+}
+```
+
+战利品表生成器
+-------------------
+
+战利品表通过 `LootTableSubProvider` 接收为 `LootTable$Builder`。之后，指定的 `LootContextParamSet` 在 `LootTableProvider$SubProviderEntry` 中设置，然后通过 `#build` 构建。在构建之前，构建器可以指定条目、条件和修饰符，这些因素影响战利品表的功能。
+
+:::note
+战利品表的功能非常广泛，本文档无法全部涵盖。相反，每个组件将简要描述。每个组件的具体子类型可以使用 IDE 查找。它们的实现将留给读者作为练习。
+:::
+
+### LootTable
+
+战利品表是基本对象，可以使用 `LootTable#lootTable` 转换为所需的 `LootTable$Builder`。战利品表可以通过指定的方式构建，包括一系列池（通过 `#withPool` 应用）以及函数（通过 `#apply`），用于修改这些池的结果物品。
+
+### LootPool
+
+战利品池代表一个执行操作的组，并可以使用 `LootPool#lootPool` 生成一个 `LootPool$Builder`。每个战利品池可以指定条目（通过 `#add`），这些条目定义池中的操作，条件（通过 `#when`）定义是否应执行池中的操作，以及函数（通过 `#apply`）修改条目的结果物品。每个池可以执行尽可能多的次数（通过 `#setRolls`）。此外，还可以指定额外的执行次数（通过 `#setBonusRolls`），这受到执行者幸运值的影响。
+
+### LootPoolEntryContainer
+
+战利品条目定义了选中时要执行的操作，通常生成物品。每个条目都有一个相关的、[已注册][registered]的 `LootPoolEntryType`。它们还有自己的相关构建器，这些构建器是 `LootPoolEntryContainer$Builder` 的子类型。多个条目可以同时执行（通过 `#append`）或顺序执行，直到一个失败（通过 `#then`）。此外，条目可以在失败时默认为另一个条目（通过 `#otherwise`）。
+
+### LootItemCondition
+
+战利品条件定义了执行某些操作所需满足的要求。每个条件都有一个相关的、[已注册][registered]的 `LootItemConditionType`。它们还有自己的相关构建器，这些构建器是 `LootItemCondition$Builder` 的子类型。默认情况下，指定的所有战利品条件必须为真，才能执行操作。也可以指定战利品条件，使得只需一个条件为真即可（通过 `#or`）。此外，条件的结果输出可以被反转（通过 `#invert`）。
+
+### LootItemFunction
+
+战利品函数在将执行结果传递给输出之前修改结果。每个函数都有一个相关的、[已注册][registered]的 `LootItemFunctionType`。它们还有自己的相关构建器，这些构建器是 `LootItemFunction$Builder` 的子类型。
+
+#### NbtProvider
+
+NBT 提供者是由 `CopyNbtFunction` 定义的特殊类型函数。它们定义了从哪里拉取标签信息。每个提供者都有一个相关的、[已注册][registered]的 `LootNbtProviderType`。
+
+### NumberProvider
+
+数字提供者决定战利品池执行的次数。每个提供者都有一个相关的、[已注册][registered]的 `LootNumberProviderType`。
+
+#### ScoreboardNameProvider
+
+记分板提供者是由 `ScoreboardValue` 定义的一种特殊类型的数字提供者。它们定义了从哪个记分板拉取执行次数的名字。每个提供者都有一个关联的[已注册][registered]`LootScoreProviderType`。
+
+[loottable]: ../../resources/server/loottables.md
+[datagen]: ../index.md#data-providers
+[registered]: ../../concepts/registries.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/recipes.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/recipes.md
new file mode 100644
index 000000000..0abd31642
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/recipes.md
@@ -0,0 +1,197 @@
+配方生成
+=================
+
+可以通过继承 `RecipeProvider` 并实现 `#buildRecipes` 来为模组生成配方。一旦消费者接受了 `FinishedRecipe` 视图，就会为数据生成提供配方。 `FinishedRecipe` 可以手动创建和提供，或者为方便起见，使用 `RecipeBuilder` 创建。
+
+实现后，必须将提供者[添加][datagen]到 `DataGenerator`。
+
+```java
+// 在MOD事件总线上
+@SubscribeEvent
+public void gatherData(GatherDataEvent event) {
+ event.getGenerator().addProvider(
+ // 告诉生成器只在服务器数据生成时运行
+ event.includeServer(),
+ MyRecipeProvider::new
+ );
+}
+```
+
+`RecipeBuilder`
+---------------
+
+`RecipeBuilder` 是创建 `FinishedRecipe` 以便于生成的便利实现。它提供了解锁、分组、保存和获取配方结果的基本定义。分别通过 `#unlockedBy`、 `#group`、 `#save` 和 `#getResult` 实现。
+
+:::important
+在原生配方构建器中不支持配方的 [`ItemStack` 输出][stack]。必须以不同的方式构建 `FinishedRecipe`，以便现有的原生配方序列化器可以生成这些数据。
+:::
+
+:::warning
+正在生成的物品结果必须有一个有效的 `RecipeCategory` 指定，否则会抛出 `NullPointerException`。
+:::
+
+除了 [`SpecialRecipeBuilder`]，所有的配方构建器都需要指定一个进步条件。所有的配方都会生成一个条件，如果玩家之前使用过这个配方，就会解锁这个配方。然而，必须指定一个额外的条件，允许玩家在没有任何先验知识的情况下获取到配方。如果指定的任何一个条件为真，那么玩家就会在配方书中获取到配方。
+
+:::tip
+配方条件通常使用 `InventoryChangeTrigger` 来在用户的库存中存在某些物品时解锁配方。
+:::
+
+### ShapedRecipeBuilder
+
+`ShapedRecipeBuilder` 用于生成有形状的配方。构建器可以通过 `#shaped` 初始化。可以在保存之前指定配方组、输入符号模式、成分的符号定义和配方解锁条件。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+ShapedRecipeBuilder builder = ShapedRecipeBuilder.shaped(RecipeCategory.MISC, result)
+ .pattern("a a") // 创建配方模式
+ .define('a', item) // 定义符号代表的物品
+ .unlockedBy("criteria", criteria) // 配方的解锁方式
+ .save(writer); // 将数据添加到构建器中
+```
+
+#### 额外的验证检查
+
+在构建之前，有形状的配方会进行一些额外的验证检查：
+
+* 必须定义一个模式，并且需要输入超过一个物品。
+* 所有模式行的宽度必须相同。
+* 一个符号不能被定义多次。
+* 空格字符 (`' '`) 是为了表示插槽中没有物品而保留的，因此不能被定义。
+* 模式必须使用用户定义的所有符号。
+
+### ShapelessRecipeBuilder
+
+`ShapelessRecipeBuilder` 用于生成无形状的配方。可以通过 `#shapeless` 初始化构建器。在保存之前，可以指定配方组、输入成分和配方解锁条件。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+ShapelessRecipeBuilder builder = ShapelessRecipeBuilder.shapeless(RecipeCategory.MISC, result)
+ .requires(item) // 将物品添加到配方中
+ .unlockedBy("criteria", criteria) // 配方的解锁方式
+ .save(writer); // 将数据添加到构建器中
+```
+
+### SimpleCookingRecipeBuilder
+
+`SimpleCookingRecipeBuilder` 用于生成熔炼、爆炸、烟熏和营火烹饪配方。此外，使用 `SimpleCookingSerializer` 的自定义烹饪配方也可以使用这个构建器进行数据生成。可以分别通过 `#smelting`、 `#blasting`、 `#smoking`、 `#campfireCooking` 或 `#cooking` 初始化构建器。在保存之前，可以指定配方组和配方解锁条件。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+SimpleCookingRecipeBuilder builder = SimpleCookingRecipeBuilder.smelting(input, RecipeCategory.MISC, result, experience, cookingTime)
+ .unlockedBy("criteria", criteria) // 配方的解锁方式
+ .save(writer); // 将数据添加到构建器中
+```
+
+### SingleItemRecipeBuilder
+
+`SingleItemRecipeBuilder` 用于生成石切配方。此外，使用类似 `SingleItemRecipe$Serializer` 的序列化器的自定义单物品配方也可以使用这个构建器进行数据生成。可以通过 `#stonecutting` 或者构造函数分别初始化构建器。在保存之前，可以指定配方组和配方解锁条件。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+SingleItemRecipeBuilder builder = SingleItemRecipeBuilder.stonecutting(input, RecipeCategory.MISC, result)
+ .unlockedBy("criteria", criteria) // 配方的解锁方式
+ .save(writer); // 将数据添加到构建器中
+```
+
+非 `RecipeBuilder` 构建器
+----------------------------
+
+一些配方构建器由于缺少所有先前提到的配方使用的功能而不实现 `RecipeBuilder`。
+
+### SmithingTransformRecipeBuilder
+
+`SmithingTransformRecipeBuilder` 用于生成将物品转化的铁匠配方。此外，使用类似 `SmithingTransformRecipe$Serializer` 的序列化器的自定义配方也可以使用这个构建器进行数据生成。可以通过 `#smithing` 或者构造函数分别初始化构建器。在保存之前，可以指定配方解锁条件。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+SmithingTransformRecipeBuilder builder = SmithingTransformRecipeBuilder.smithing(template, base, addition, RecipeCategory.MISC, result)
+ .unlocks("criteria", criteria) // 配方的解锁方式
+ .save(writer, name); // 将数据添加到构建器中
+```
+
+### SmithingTrimRecipeBuilder
+
+`SmithingTrimRecipeBuilder` 用于生成用于装甲修剪的铁匠配方。此外，使用类似 `SmithingTrimRecipe$Serializer` 的序列化器的自定义升级配方也可以使用这个构建器进行数据生成。可以通过 `#smithingTrim` 或者构造函数分别初始化构建器。在保存之前，可以指定配方解锁条件。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+SmithingTrimRecipe builder = SmithingTrimRecipe.smithingTrim(template, base, addition, RecipeCategory.MISC)
+ .unlocks("criteria", criteria) // 配方的解锁方式
+ .save(writer, name); // 将数据添加到构建器中
+```
+
+### SpecialRecipeBuilder
+
+`SpecialRecipeBuilder` 用于为不能轻易约束到配方 JSON 格式（如染色护甲、焰火等）的动态配方生成空的 JSON。可以通过 `#special` 初始化构建器。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+SpecialRecipeBuilder.special(dynamicRecipeSerializer)
+ .save(writer, name); // 将数据添加到构建器中
+```
+条件性配方
+-------------------
+
+[条件性配方][conditional] 也可以通过 `ConditionalRecipe$Builder` 进行数据生成。可以使用 `#builder` 获取构建器。
+
+可以先调用 `#addCondition` 来指定每个配方的条件，然后在所有条件都指定后调用 `#addRecipe`。这个过程可以重复多次，由程序员自行决定。
+
+在所有配方都指定之后，可以在最后使用 `#generateAdvancement` 为每个配方添加进步（advancements）。或者，可以使用 `#setAdvancement` 设置条件性进步。
+
+```java
+// 在 RecipeProvider#buildRecipes(writer) 中
+ConditionalRecipe.builder()
+ // 添加配方的条件
+ .addCondition(...)
+ // 当条件为真时返回配方
+ .addRecipe(...)
+
+ // 添加下一个配方的条件
+ .addCondition(...)
+ // 当下一个条件为真时返回下一个配方
+ .addRecipe(...)
+
+ // 创建使用上述配方中的条件和解锁进步的条件性进步
+ .generateAdvancement()
+ .build(writer, name);
+```
+
+### IConditionBuilder
+
+为了简化向条件性配方添加条件，而不必手动构造每个条件实例，扩展的 `RecipeProvider` 可以实现 `IConditionBuilder`。接口添加了轻松构造条件实例的方法。
+
+```java
+// 在 ConditionalRecipe$Builder#addCondition 中
+(
+ // 如果 'examplemod:example_item'
+ // 或者 'examplemod:example_item2' 存在
+ // 并且
+ // 非FALSE
+
+ // 方法由 IConditionBuilder 定义
+ and(
+ or(
+ itemExists("examplemod", "example_item"),
+ itemExists("examplemod", "example_item2")
+ ),
+ not(
+ FALSE()
+ )
+ )
+)
+```
+
+自定义配方序列化器
+-------------------------
+
+通过创建一个可以构造 `FinishedRecipe` 的构建器，可以数据生成自定义配方序列化器。完成的配方将配方数据编码为JSON，并在存在时将其解锁进步也编码为JSON。此外，还需要指定配方的名称和序列化器，以知道写入位置以及加载时能解码对象的内容。一旦构造了 `FinishedRecipe`，只需将其传递给 `RecipeProvider#buildRecipes` 提供的 `Consumer`。
+
+:::tip
+`FinishedRecipe` 足够灵活，可以数据生成任何对象转换，不仅仅是物品。
+:::
+
+[datagen]: ../index.md#data-providers
+[ingredients]: ../../resources/server/recipes/ingredients.md#forge-types
+[stack]: ../../resources/server/recipes/index.md#recipe-itemstack-result
+[conditional]: ../../resources/server/conditional.md
+[special]: #specialrecipebuilder
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/tags.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/tags.md
new file mode 100644
index 000000000..d72c35a66
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datagen/tags.md
@@ -0,0 +1,123 @@
+标签生成
+======
+
+通过继承`TagsProvider`并实现`#addTags`方法，可以为一个mod生成[标签]。实现后，必须将提供器[添加][datagen]到`DataGenerator`中。
+
+```java
+// 在MOD事件总线上
+@SubscribeEvent
+public void gatherData(GatherDataEvent event) {
+ event.getGenerator().addProvider(
+ // 通知生成器仅在生成服务器数据时运行
+ event.includeServer(),
+ // 继承自net.neoforged.neoforge.common.data.BlockTagsProvider
+ output -> new MyBlockTagsProvider(
+ output,
+ event.getLookupProvider(),
+ MOD_ID,
+ event.getExistingFileHelper()
+ )
+ );
+}
+```
+
+`TagsProvider`
+--------------
+
+标签提供器有两种用于生成标签的方法：通过`#tag`使用对象和其他标签创建一个标签，或者通过`#getOrCreateRawBuilder`使用其他对象类型的标签来生成标签数据。
+
+:::note
+通常，除非一个注册表包含来自不同注册表的对象的表示（例如，方块有项目表示以在库存中获得方块），否则提供器不会直接调用`#getOrCreateRawBuilder`。
+:::
+
+调用`#tag`时，会创建一个`TagAppender`，它作为链式消费者，用于向标签添加元素：
+
+方法 | 描述
+:---: | :---
+`add` | 通过其资源键将一个对象添加到标签中。
+`addOptional` | 通过其名称将一个对象添加到标签中。如果对象不存在，则加载时将跳过该对象。
+`addTag` | 通过其标签键将一个标签添加到标签中。内标签中的所有元素现在都是外标签的一部分。
+`addOptionalTag` | 通过其名称将一个标签添加到标签中。如果标签不存在，则加载时将跳过该标签。
+`replace` | 当为`true`时，此标签从其他数据包添加的所有先前加载的条目将被丢弃。如果在此之后加载了一个数据包，那么它仍然会将条目追加到标签中。
+`remove` | 通过其名称或键从标签中移除一个对象或标签。
+
+```java
+// 在某个TagProvider#addTags中
+this.tag(EXAMPLE_TAG)
+ .add(EXAMPLE_OBJECT) // 将一个对象添加到标签中
+ .addOptional(new ResourceLocation("othermod", "other_object")) // 向标签添加来自其他mod的对象
+
+this.tag(EXAMPLE_TAG_2)
+ .addTag(EXAMPLE_TAG) // 将一个标签添加到另一个标签
+ .remove(EXAMPLE_OBJECT) // 从此标签中移除一个对象
+```
+
+:::important
+如果你的mod的标签对其他mod的标签有软依赖（也就是说，其他mod可能在运行时不存在），那么你应该使用可选的方法来引用其他mod的标签。
+:::
+
+### 现有的供应商
+
+Minecraft中包含了一些可以被子类化的特定注册表的标签供应商。另外，一些供应商包含了额外的辅助方法，可以更容易地创建标签。
+
+注册对象类型 | 标签供应商
+:---: | :---
+`方块` | `BlockTagsProvider`\*
+`物品` | `ItemTagsProvider`
+`实体类型` | `EntityTypeTagsProvider`
+`流体` | `FluidTagsProvider`
+`游戏事件` | `GameEventTagsProvider`
+`生物群系` | `BiomeTagsProvider`
+`平面世界生成预设` | `FlatLevelGeneratorPresetTagsProvider`
+`世界预设` | `WorldPresetTagsProvider`
+`结构` | `StructureTagsProvider`
+`兴趣点类型` | `PoiTypeTagsProvider`
+`旗帜图案` | `BannerPatternTagsProvider`
+`猫的品种` | `CatVariantTagsProvider`
+`画的种类` | `PaintingVariantTagsProvider`
+`乐器` | `InstrumentTagsProvider`
+`伤害类型` | `DamageTypeTagsProvider`
+
+\* `BlockTagsProvider` 是Forge所添加的 `TagsProvider`。
+
+#### `ItemTagsProvider#copy`
+
+方块在物品栏中有物品形式的表示。因此，许多的方块标签也可以是物品标签。为了方便地生成与方块标签具有相同条目的物品标签，可以使用 `#copy` 方法，此方法接收要复制的方块标签和要复制到的物品标签。
+
+```java
+// 在 ItemTagsProvider#addTags 中
+this.copy(EXAMPLE_BLOCK_TAG, EXAMPLE_ITEM_TAG);
+```
+
+自定义标签提供者
+--------------------
+
+通过 `TagsProvider` 的子类，可以创建自定义的标签提供者，这需要传入注册键以生成标签。
+
+```java
+public RecipeTypeTagsProvider(PackOutput output, CompletableFuture registries, ExistingFileHelper fileHelper) {
+ super(output, Registries.RECIPE_TYPE, registries, MOD_ID, fileHelper);
+}
+```
+
+### 内在持有者标签提供者
+
+其中一种特殊的 `TagProvider` 是 `IntrinsicHolderTagsProvider`。当通过这个提供者使用 `#tag` 创建标签时，对象本身可以通过 `#add` 将自己添加到标签中。为此，在构造函数中提供了一个将对象转换为其 `ResourceKey` 的函数。
+
+```java
+// `IntrinsicHolderTagsProvider` 的子类型
+public AttributeTagsProvider(PackOutput output, CompletableFuture registries, ExistingFileHelper fileHelper) {
+ super(
+ output,
+ ForgeRegistries.Keys.ATTRIBUTES,
+ registries,
+ attribute -> ForgeRegistries.ATTRIBUTES.getResourceKey(attribute).get(),
+ MOD_ID,
+ fileHelper
+ );
+}
+```
+
+[tags]: ../../resources/server/tags.md
+[datagen]: ../index.md#data-providers
+[custom]: ../../concepts/registries.md#custom-registries
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/_category_.json
new file mode 100644
index 000000000..43a13824e
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Data Maps"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/index.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/index.md
new file mode 100644
index 000000000..d368ceb3f
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/index.md
@@ -0,0 +1,192 @@
+# 数据映射
+
+注册表数据映射包含可附加到注册表对象的数据驱动、可重载的对象。
+这个系统允许更容易地数据驱动游戏行为，因为它们提供了如同步或冲突解决等功能，从而带来更好、更可配置的用户体验。
+
+你可以将标签看作注册表对象 ➜ 布尔映射，而数据映射则是更灵活的注册表对象 ➜ 对象映射。
+
+数据映射可以附加到静态的内置注册表和动态的数据驱动的数据包注册表上。
+
+数据映射支持通过使用 `/reload` 命令或任何其他重新加载服务器资源的方法来重新加载。
+
+## 注册
+数据映射类型应该静态创建，然后注册到 `RegisterDataMapTypesEvent`（在 [mod事件总线](../concepts/events)上触发）。`DataMapType` 可以使用 `DataMapType$Builder` 通过 `DataMapType#builder` 创建。
+
+构建器提供了一个 `synced` 方法，可以用来标记数据映射为同步并将其发送给客户端。
+
+一个简单的 `DataMapType` 有两个泛型参数：`R`（数据映射所针对的注册表的类型）和 `T`（被附加的值）。因此，可以将附加到 `Item` 的 `SomeObject` 的数据映射表示为 `DataMapType`。
+
+数据映射使用 [编解码器](../datastorage/codecs.md) 进行序列化和反序列化。
+
+以以下表示数据映射值的记录为例：
+```java
+public record DropHealing(
+ float amount, float chance
+) {
+ public static final Codec CODEC = RecordCodecBuilder.create(in -> in.group(
+ Codec.FLOAT.fieldOf("amount").forGetter(DropHealing::amount),
+ Codec.floatRange(0, 1).fieldOf("chance").forGetter(DropHealing::chance)
+ ).apply(in, DropHealing::new));
+}
+```
+
+:::warning
+值 (`T`) 应为 *不可变* 对象，否则如果对象附加到标签内的所有条目，则可能导致奇怪的行为（因为不会创建副本）。
+:::
+
+为了本例的目的，我们将使用此数据映射在玩家丢弃物品时治疗玩家。
+`DataMapType` 可以这样创建：
+```java
+public static final DataMapType DROP_HEALING = DataMapType.builder(
+ new ResourceLocation("mymod:drop_healing"), Registries.ITEM, DropHealing.CODEC
+).build();
+```
+然后使用 `RegisterDataMapTypesEvent#register` 注册到 `RegisterDataMapTypesEvent`。
+
+## 同步
+同步的数据映射将会将其值同步到客户端。可以使用 `DataMapType$Builder#synced(Codec networkCodec, boolean mandatory)` 标记数据映射为同步。
+然后将使用 `networkCodec` 同步数据映射的值。
+如果 `mandatory` 标志设置为 `true`，则不支持数据映射的客户端（包括 Vanilla 客户端）将无法连接到服务器，反之亦然。另一方面，非强制性的数据映射是可选的，因此它不会阻止任何客户端加入。
+
+:::tip
+单独的网络编解码器允许包大小更小，因为你可以选择发送哪些数据以及以什么格式发送。否则可以使用默认编解码器。
+:::
+
+## JSON结构和位置
+数据映射从位于 `mapNamespace/data_maps/registryNamespace/registryPath/mapPath.json` 的JSON文件加载，其中：
+- `mapNamespace` 是数据映射ID的命名空间
+- `mapPath` 是数据映射ID的路径
+- `registryNamespace` 是注册表ID的命名空间；如果命名空间是 `minecraft`，则此值将被省略
+- `registryPath` 是注册表ID的路径
+
+更多信息，请[查看专用页面](./structure.md)。
+
+## 使用
+由于数据映射可以用于任何注册表，因此可以通过 `Holder` 查询它们，而不是通过实际的注册表对象。
+你可以使用 `Holder#getData(DataMapType)` 查询数据映射值。如果该对象没有附加值，方法将返回 `null`。
+
+:::note
+只有引用持有者会在该方法中返回值。`直接` 持有者 **不会**。通常，你只会遇到引用持有者（它们由 `Registry#wrapAsHolder`、`Registry#getHolder` 或不同的 `builtInRegistryHolder` 方法返回）。
+:::
+
+为了继续上面的示例，我们可以如下实现我们预期的行为：
+```java
+public static void onItemDrop(final ItemTossEvent event) {
+ final ItemStack stack = event.getEntity().getItem();
+ // ItemStack 有一个 getItemHolder 方法，它将返回一个指向堆叠物的物品的 Holder-
+ //高亮下一行
+ final DropHealing value = stack.getItemHolder().getData(DROP_HEALING);
+ // 由于 getData 如果物品没有附加 drop healing 值将返回 null，我们保护它不为 null
+ if (value != null) {
+ // 这里我们简单地使用值
+ if (event.getPlayer().level().getRandom().nextFloat() > value.chance()) {
+ event.getPlayer().heal(value.amount());
+ }
+ }
+}
+```
+
+## 高级数据映射
+高级数据映射是具有额外功能的数据映射。即，通过移除器合并值和选择性地移除它们的能力。对于值类似于集合（如 `Map` 或 `List`）的数据映射，强烈推荐实现某种形式的合并和移除器。
+
+`AdvancedDataMapType` 除了 `T` 和 `R` 之外还有一个泛型：`VR extends DataMapValueRemover`。这个额外的泛型允许你通过提高类型安全性来生成移除对象。
+
+### 创建
+你可以使用 `AdvancedDataMapType#builder` 创建 `AdvancedDataMapType`。与普通构建器不同，该方法返回的构建器将有两个额外的方法（`merger` 和 `remover`），并且它将返回一个 `AdvancedDataMapType`。注册方法保持不变。
+
+### 合并器
+高级数据映射可以通过 `AdvancedDataMapType#merger` 提供一个 `DataMapValueMerger`。这个合并器将用于处理尝试将值附加到同一对象的数据包之间的冲突。
+合并器将给出两个冲突的值及其来源（作为 `Either, ResourceKey>`，因为值可以附加到标签内的所有条目，而不仅仅是个别条目），并期望返回实际附加的值。
+通常，合并器应简单地合并值，并且除非必要（即如果合并不可能），否则不应执行“硬”覆盖。如果一个包想要绕过合并器，它可以通过指定对象级别的 `replace` 字段来实现。
+
+假设我们有一个将整数附加到物品的数据映射的情况：
+```java
+public class IntMerger implements DataMapValueMerger {
+ @Override
+ public Integer merge(Registry
- registry, Either, ResourceKey
- > first, Integer firstValue, Either, ResourceKey
- > second, Integer secondValue) {
+ //高亮下一行
+ return firstValue + secondValue;
+ }
+}
+```
+如果两个数据包附加到同一对象，则上述合并器将合并值。所以如果第一个包将值 `12` 附加到 `minecraft:carrot`，第二个包将值 `15` 附加到 `minecraft:carrot`，最终的值将是 `27`。然而，如果第二个包指定对象级别的 `replace` 字段，最终值将是 `15`，因为不会调用合并器。
+
+NeoForge 为合并列表、集合和映射提供了一些默认的合并器，位于 `DataMapValueMerger` 中。
+
+默认合并器（`DataMapValueMerger#defaultMerger`）具有你期望的普通数据包的典型行为，其中最新的值（来自最高的数据包）将覆盖之前的值。
+
+### 移除器
+高级数据映射可以通过 `AdvancedDataMapType#remover` 提供一个 `DataMapValueRemover`。移除器将允许选择性地移除数据映射值，有效地进行分解。
+虽然默认情况下一个数据包只能移除附加到注册表条目的整个对象，但有了移除器，它可以只从附加对象中移除特定的值（即，在映射的情况下，只移除具有给定键的项，或在列表的情况下，只移除具有特定属性的项）。
+
+传递给构建器的编解码器将解码移除器实例。然后这些移除器将给出当前附加的值及其来源，并期望创建一个新对象来替换旧值。
+或者，一个空的 `Optional` 将导致值被完全移除。
+
+一个从基于 `Map` 的数据映射中移除具有特定键的值的移除器示例：
+```java
+public record MapRemover(String key) implements DataMapValueRemover> {
+ public static final Codec CODEC = Codec.STRING.xmap(MapRemover::new, MapRemover::key);
+
+ @Override
+ public Optional> remove(Map value, Registry
- registry, Either, ResourceKey
- > source, Item object) {
+ final Map newMap = new HashMap<>(value);
+ newMap.remove(key);
+ return Optional.of(newMap);
+ }
+}
+```
+
+考虑到上述移除器，我们将字符串映射到物品的字符串。考虑以下数据映射 JSON 文件：
+```js
+{
+ "values": {
+ //高亮开始
+ "minecraft:carrot": {
+ "somekey1": "value1",
+ "somekey2": "value2"
+ }
+ //高亮结束
+ }
+}
+```
+该文件将映射 `[somekey1=value1, somekey2=value2]` 附加到 `minecraft:carrot` 物品。现在，另一个数据包可以在其上面移除具有 `somekey1` 键的值，如下所示：
+```js
+{
+ "remove": {
+ // 由于移除器被解码为字符串，我们可以在这里使用字符串作为值。如果它被解码为对象，我们将需要使用一个对象。
+ //高亮下一行
+ "minecraft:carrot": "somekey1"
+ }
+}
+```
+在读取和应用第二个数据包后，附加到 `minecraft:carrot` 物品的新值将是 `[somekey2=value2]`。
+
+## 数据生成
+数据映射可以通过 `DataMapProvider` [生成](../datagen)。
+你应该扩展这个类，然后覆盖 `generate` 方法来创建你的条目，类似于标签生成。
+
+考虑到起始的摔落治疗示例，我们可以如下生成一些值：
+```java
+public class DropHealingGen extends DataMapProvider {
+
+ public DropHealingGen(PackOutput packOutput, CompletableFuture lookupProvider) {
+ super(packOutput, lookupProvider);
+ }
+
+ @Override
+ protected void gather() {
+ // 在下面的示例中，我们不需要强制替换任何值，因为默认行为是没有提供合并器，所以第三个参数可以是 false。
+
+ // 如果你为你的数据映射提供了合并器，那么第三个参数将导致旧值被覆盖（如果设置为 true），而不调用合并器
+ builder(DROP_HEALING)
+ // 始终给掉落任何 minecraft:fox_food 标签项的实体 12 心
+ .add(ItemTags.FOX_FOOD, new DropHealing(12, 1f), false)
+ // 有 10% 的几率治疗掉落金合欢船的实体一点
+ .add(Items.ACACIA_BOAT.builtInRegistryHolder(), new DropHealing(1, 0.1f), false);
+ }
+}
+```
+
+:::tip
+如果你想将值附加到可选依赖项添加的对象，有 `add` 重载接受原始 `ResourceLocation`。在这种情况下，你还应该通过 var-args 参数提供[一个加载条件](../resources/server/conditional)，以避免崩溃。
+:::
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/neo_maps.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/neo_maps.md
new file mode 100644
index 000000000..988278dab
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/neo_maps.md
@@ -0,0 +1,128 @@
+# 内置数据映射
+
+NeoForge 提供了一些数据映射，这些映射主要取代硬编码的代码内普通映射。
+这些数据映射可以在 `NeoForgeDataMaps` 中找到，并且始终是*可选的*以确保与普通客户端的兼容性。
+
+## `neoforge:compostables`
+
+NeoForge 提供了一个允许配置 Composter 值的数据映射，作为`ComposterBlock#COMPOSTABLES`（现在已被忽略）的替代品。
+该数据映射位于`neoforge/data_maps/item/compostables.json`，其对象具有以下结构：
+
+```js
+{
+ // A 0 to 1 (inclusive) float representing the chance that the item will update the level of the composter
+ "chance": 1
+}
+```
+
+Example:
+
+```js
+{
+ "values": {
+ // Give acacia logs a 50% chance that they will fill a composter
+ "minecraft:acacia_log": {
+ "chance": 0.5
+ }
+ }
+}
+```
+
+## `neoforge:furnace_fuels`
+
+NeoForge 提供了一个数据映射，允许配置物品的燃烧时间。
+该数据图位于`neoforge/data_maps/item/furnace_fuels.json`，其对象具有以下结构：
+
+```js
+{
+ // A positive integer representing the item's burn time, in ticks
+ "burn_time": 1000
+}
+```
+
+Example:
+
+```js
+{
+ "values": {
+ // Give anvils a 2 seconds burn time
+ "minecraft:anvil": {
+ "burn_time": 40
+ }
+ }
+}
+```
+
+:::note
+其他像 `IItemExtension#getBurnTime` 这样的内部代码方法将优先于数据映射，所以建议您在您的mod中使用数据映射来设置简单、静态的燃烧时间，这样用户可以按照他们的需求进行配置。
+:::
+
+:::warning
+
+原版游戏为 `minecraft:logs` 和 `minecraft:planks` 标签中的原木和木板添加了燃烧时间。但是，这些标签也包含了下界木材，因此添加了对 `#minecraft:non_flammable_wood` 中元素的移除。 然而，这种移除不会影响其他数据包或模组添加的任何值，所以如果您想改变木材标签的值，您需要自己添加对不可燃木材标签的移除。
+
+:::
+
+## `neoforge:parrot_imitations`
+
+NeoForge 提供了一个数据映射，允许配置鹦鹉在模仿怪物时产生的声音，这可以替代 `Parrot#MOB_SOUND_MAP`（现在已被忽视）。这个数据映射位于 `neoforge/data_maps/entity_type/parrot_imitations.json`，其对象具有以下结构：
+
+```js
+{
+ // The ID of the sound that parrots will produce when imitating the mob
+ "sound": "minecraft:entity.parrot.imitate.creeper"
+}
+```
+
+Example:
+
+```js
+{
+ "values": {
+ // Make parrots produce the ambient cave sound when imitating allays
+ "minecraft:allay": {
+ "sound": "minecraft:ambient.cave"
+ }
+ }
+}
+```
+
+## `neoforge:raid_hero_gifts`
+
+NeoForge 提供了一个数据映射，允许配置如果你阻止了突袭，具有某个 `VillagerProfession` 的村民可能会赠送给你的礼物，这将替代 `GiveGiftToHero#GIFTS`（现在已经被忽略了）。这个数据映射位于 `neoforge/data_maps/villager_profession/raid_hero_gifts.json`，其对象具有以下结构：
+
+```js
+{
+ "values": {
+ "minecraft:armorer": {
+ // Make armorers give the raid hero the armorer gift loot table
+ "loot_table": "minecraft:gameplay/hero_of_the_village/armorer_gift"
+ },
+ }
+}
+```
+
+## `neoforge:vibration_frequencies`
+
+NeoForge 提供了一个数据映射，允许配置游戏事件发出的潜影贝探头频率，这将替代 `VibrationSystem#VIBRATION_FREQUENCY_FOR_EVENT`（现在已经被忽视了）。这个数据映射位于 `neoforge/data_maps/game_event/vibration_frequencies.json`，其对象具有以下结构：
+
+```js
+{
+ // An integer between 1 and 15 (inclusive) that indicates the vibration frequency of the event
+ "frequency": 2
+}
+```
+
+Example:
+
+```js
+{
+ "values": {
+ // Make the splash in water game event vibrate on the second frequency
+ "minecraft:splash": {
+ "frequency": 2
+ }
+ }
+}
+```
+
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/structure.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/structure.md
new file mode 100644
index 000000000..36bb29e69
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datamaps/structure.md
@@ -0,0 +1,103 @@
+# JSON结构
+对于此页面，我们将使用一个数据映射作为例子，其对象具有两个浮点键：`amount` 和 `chance`。该对象的编码可以在[这里](./index.md#registration)找到。
+
+## 地址
+数据映射加载自位于 `mapNamespace/data_maps/registryNamespace/registryPath/mapPath.json` 的JSON文件，其中：
+- `mapNamespace` 是数据映射ID的命名空间
+- `mapPath` 是数据映射ID的路径
+- `registryNamespace` 是注册表ID的命名空间
+- `registryPath` 是注册表ID的路径
+
+:::note
+如果是 `minecraft`，则省略注册表命名空间。
+:::
+
+示例：
+- 对于名为 `mymod:drop_healing` 的数据映射，用于 `minecraft:item` 注册表（如示例中），路径将是 `mymod/data_maps/item/drop_healing.json`。
+- 对于名为 `somemod:somemap` 的数据映射，用于 `minecraft:block` 注册表，路径将是 `somemod/data_maps/block/somemap.json`。
+- 对于名为 `example:stuff` 的数据映射，用于 `somemod:custom` 注册表，路径将是 `example/data_maps/somemod/custom/stuff.json`。
+
+## 全局 `replace` 字段
+JSON文件具有一个可选的全局 `replace` 字段，类似于标签，当其为 `true` 时，将移除该数据映射的所有先前附加值。这对于想要完全改变整个数据映射的数据包非常有用。
+
+## 加载条件
+数据映射文件支持在根级别和条目级别通过 `neoforge:conditions` 数组支持[加载条件](../resources/server/conditional)。
+
+## 添加值
+可以使用 `values` 映射将值附加到对象。每个键将代表要附加值的单个注册表条目的ID，或者一个以 `#` 开头的标签键。如果是一个标签，那么相同的值将附加到该标签的所有条目上。
+键将是要附加的对象。
+
+```js
+{
+ "values": {
+ // 为胡萝卜项附加一个值
+ "minecraft:carrot": {
+ "amount": 12,
+ "chance": 1
+ },
+ // 将一个值附加到 logs 标签的所有项上
+ "#minecraft:logs": {
+ "amount": 1,
+ "chance": 0.1
+ }
+ }
+}
+```
+
+:::info
+上述结构将在[高级数据映射](./index.md#advanced-data-maps)的情况下调用合并器。如果你不想为特定的对象调用合并器，那么你将不得不使用类似于这样的结构：
+```js
+{
+ "values": {
+ // 覆盖胡萝卜项的值
+ "minecraft:carrot": {
+ // 高亮下一行
+ "replace": true,
+ // 新的值将在 value 子对象下
+ "value": {
+ "amount": 12,
+ "chance": 1
+ }
+ }
+ }
+}
+```
+:::
+
+## 移除值
+
+JSON文件也可以通过使用 `remove` 数组，从对象中移除先前附加的值：
+```js
+{
+ // 移除附加到苹果和土豆的值
+ "remove": ["minecraft:apple", "minecraft:potato"]
+}
+```
+数组包含一系列要从其中移除值的注册表条目ID或标签。
+
+:::warning
+移除操作在当前JSON文件的值被附加后进行，所以你可以使用移除功能来移除通过标签附加到对象的值：
+```js
+{
+ "values": {
+ "#minecraft:logs": 12
+ },
+ // 从金合欢原木移除值，这样所有原木除了金合欢都将附加值 12
+ "remove": ["minecraft:acacia_log"]
+}
+```
+:::
+
+:::info
+在提供自定义移除器的[高级数据映射](./index.md#advanced-data-maps)的情况下，可以通过将 `remove` 数组转换为映射来提供移除器的参数。
+假设移除器对象被串行化为字符串，并且为基于 `Map` 的数据映射移除具有给定键的值：
+```js
+{
+ "remove": {
+ // 移除器将从值（这种情况下为 `somekey1`）反串行化
+ // 并应用于附加到胡萝卜项的值
+ "minecraft:carrot": "somekey1"
+ }
+}
+```
+:::
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/_category_.json
new file mode 100644
index 000000000..7b4467f7c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Data Storage"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/attachments.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/attachments.md
new file mode 100644
index 000000000..408710921
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/attachments.md
@@ -0,0 +1,109 @@
+# 数据附件
+
+数据附件系统允许模组在方块实体、区块、实体和物品堆叠上附加和存储额外数据。
+
+_要存储额外的关卡数据，您可以使用 [SavedData](saveddata)。_
+
+## 创建附件类型
+
+要使用系统，您需要注册一个 `AttachmentType`。
+附件类型包含以下配置：
+- 当数据第一次被访问时创建实例的默认值供应器。也用于比较有数据的堆叠和没有数据的堆叠。
+- 如果附件需要持久化，则需要一个可选的序列化器。
+- （如果配置了序列化器）`copyOnDeath` 标志，用于在死亡时自动复制实体数据（见下文）。
+- （高级）（如果配置了序列化器）自定义 `comparator`，用于检查两个物品堆叠的数据是否相同。
+
+:::tip
+如果您不希望您的附件持久化，不要提供序列化器。
+:::
+
+有几种方法提供附件序列化器：直接实现 `IAttachmentSerializer`，实现 `INBTSerializable` 并使用静态的 `AttachmentSerializer.serializable()` 方法创建构建器，或向构建器提供编解码器。
+
+:::warning
+避免使用编解码器序列化物品堆叠附件，因为它相对较慢。
+:::
+
+无论哪种方式，附件 **必须被注册** 到 `NeoForgeRegistries.ATTACHMENT_TYPES` 注册表中。以下是一个示例：
+```java
+// 为附件类型创建 DeferredRegister
+private static final DeferredRegister> ATTACHMENT_TYPES = DeferredRegister.create(NeoForgeRegistries.ATTACHMENT_TYPES, MOD_ID);
+
+// 通过 INBTSerializable 序列化
+private static final Supplier> HANDLER = ATTACHMENT_TYPES.register(
+ "handler", () -> AttachmentType.serializable(() -> new ItemStackHandler(1)).build());
+// 通过编解码器序列化
+private static final Supplier> MANA = ATTACHMENT_TYPES.register(
+ "mana", () -> AttachmentType.builder(() -> 0).serialize(Codec.INT).build());
+// 无序列化
+private static final Supplier> SOME_CACHE = ATTACHMENT_TYPES.register(
+ "some_cache", () -> AttachmentType.builder(() -> new SomeCache()).build()
+);
+
+// 在您的 mod 构造函数中，不要忘记将 DeferredRegister 注册到您的 mod 总线：
+ATTACHMENT_TYPES.register(modBus);
+```
+
+## 使用附件类型
+
+一旦附件类型注册后，它可以在任何持有对象上使用。
+如果没有数据，调用 `getData` 将附加一个新的默认实例。
+
+```java
+// 如果已存在 ItemStackHandler，则获取它，否则附加一个新的：
+ItemStackHandler stackHandler = stack.getData(HANDLER);
+// 获取当前玩家的法力值（如果有），否则附加 0：
+int playerMana = player.getData(MANA);
+// 等等...
+```
+
+如果不希望附加一个默认实例，可以添加一个 `hasData` 检查：
+```java
+// 检查堆叠是否有 HANDLER 附件，然后再进行任何操作。
+if (stack.hasData(HANDLER)) {
+ ItemStackHandler stackHandler = stack.getData(HANDLER);
+ // 对 stack.getData(HANDLER) 做些什么。
+}
+```
+
+数据也可以用 `setData` 更新：
+```java
+// 将法力值增加 10。
+player.setData(MANA, player.getData(MANA) + 10);
+```
+
+:::important
+通常，当修改方块实体和区块时需要将其标记为脏数据（使用 `setChanged` 和 `setUnsaved(true)`）。这对于 `setData` 的调用是自动完成的：
+```java
+chunk.setData(MANA, chunk.getData(MANA) + 10); // 将自动调用 setUnsaved
+```
+但如果您修改了从 `getData` 获取的数据（包括新创建的默认实例），则必须显式地将方块实体和区块标记为脏数据：
+```java
+var mana = chunk.getData(MUTABLE_MANA);
+mana.set(10);
+chunk.setUnsaved(true); // 必须手动完成，因为我们没有使用 setData
+```
+:::
+
+## 与客户端共享数据
+目前，只有可序列化的物品堆叠附件在客户端和服务器之间同步。
+这是自动完成的。
+
+要将方块实体、区块或实体附件同步到客户端，你需要自己[向客户端发送数据包][network]。
+对于区块，您可以使用 `ChunkWatchEvent.Sent` 来知道何时向玩家发送区块数据。
+
+## 在玩家死亡时复制数据
+默认情况下，实体数据附件在玩家死亡时不会被复制。
+要在玩家死亡时自动复制附件，请在附件构建器中设置 `.copyOnDeath()`。
+
+更复杂的处理可以通过 `PlayerEvent.Clone` 实现，通过从原始实体中读取数据并将其分配给新实体。在此事件中，可以使用 `#isWasDeath` 方法区分死亡后重生和从末地返回。这很重要，因为从末地返回时数据已经存在，因此要注意在这种情况下不要重复值。
+
+例如：
+```java
+NeoForge.EVENT_BUS.register(PlayerEvent.Clone.class, event -> {
+ if (event.isWasDeath() && event.getOriginal().hasData(MY_DATA)) {
+ event.getEntity().getData(MY_DATA).fieldToCopy = event.getOriginal().getData(MY_DATA).fieldToCopy;
+ }
+});
+```
+
+[network]: ../networking/index.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/capabilities.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/capabilities.md
new file mode 100644
index 000000000..ecbd044a7
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/capabilities.md
@@ -0,0 +1,300 @@
+# 功能
+
+功能（Capabilities）允许以动态和灵活的方式公开特性，无需直接实现许多接口。
+
+通常来说，每个功能都以接口的形式提供一个特性。
+
+NeoForge 为方块、实体和物品堆叠添加了功能支持。
+这将在以下部分中更详细地解释。
+
+## 为什么使用功能
+
+功能旨在将**能做什么**与**如何做**分离开来，适用于方块、实体或物品堆叠。
+如果您正在考虑功能是否适合某项工作，请问自己以下问题：
+1. 我只关心方块、实体或物品堆叠能做什么，而不关心它如何做吗？
+2. 这个 **能做什么**，也就是行为，是否只对某些方块、实体或物品堆叠有效，而不是所有？
+3. 这个 **如何做**，即行为的实现，是否依赖于具体的方块、实体或物品堆叠？
+
+以下是一些良好的功能使用示例：
+- *“我希望我的流体容器能与其他模组的流体容器兼容，但我不知道每个流体容器的具体情况。”* - 是的，使用 `IFluidHandler` 功能。
+- *“我想计算某个实体中有多少物品，但我不知道实体可能如何存储它们。”* - 是的，使用 `IItemHandler` 功能。
+- *“我想给某个物品堆叠充能，但我不知道物品堆叠可能如何存储能量。”* - 是的，使用 `IEnergyStorage` 功能。
+- *“我想对玩家当前瞄准的任何方块应用颜色，但我不知道方块将如何变化。”* - 是的。NeoForge 没有提供给方块上色的功能，但你可以自己实现。
+
+以下是不推荐使用功能的示例：
+- *“我想检查某个实体是否在我的机器范围内。”* - 不，使用帮助方法代替。
+
+## NeoForge 提供的功能
+
+NeoForge 为以下三个接口提供了功能：`IItemHandler`，`IFluidHandler` 和 `IEnergyStorage`。
+
+`IItemHandler` 公开了处理库存槽的接口。`IItemHandler` 类型的功能有：
+- `Capabilities.ItemHandler.BLOCK`：方块的自动化可访问库存（用于箱子、机器等）。
+- `Capabilities.ItemHandler.ENTITY`：实体的库存内容（额外的玩家槽位、怪物/生物的库存/包）。
+- `Capabilities.ItemHandler.ENTITY_AUTOMATION`：实体的自动化可访问库存（船、矿车等）。
+- `Capabilities.ItemHandler.ITEM`：物品堆叠的内容（便携背包等）。
+
+`IFluidHandler` 公开了处理流体库存的接口。`IFluidHandler` 类型的功能有：
+- `Capabilities.FluidHandler.BLOCK`：方块的自动化可访问流体库存。
+- `Capabilities.FluidHandler.ENTITY`：实体的流体库存。
+- `Capabilities.FluidHandler.ITEM`：物品堆叠的流体库存。
+这个功能是特殊的 `IFluidHandlerItem` 类型，因为桶装液体的方式有所不同。
+
+`IEnergyStorage` 公开了处理能量容器的接口。它基于 TeamCoFH 的 RedstoneFlux API。`IEnergyStorage` 类型的功能有：
+- `Capabilities.EnergyStorage.BLOCK`：方块内部的能量。
+- `Capabilities.EnergyStorage.ENTITY`：实体内部的能量。
+- `Capabilities.EnergyStorage.ITEM`：物品堆叠内部的能量。
+
+## 创建功能
+
+NeoForge为方块、实体和物品堆叠支持功能性。功能性允许在一定逻辑下查找某些API的实现。在NeoForge中实现了以下几种功能性：
+- `BlockCapability`：适用于方块和方块实体的功能性；行为依赖于特定的`Block`。
+- `EntityCapability`：适用于实体的功能性；行为依赖于特定的`EntityType`。
+- `ItemCapability`：适用于物品堆叠的功能性；行为依赖于特定的`Item`。
+
+:::tip
+为了与其他模组兼容，如果可能的话，我们建议使用NeoForge在`Capabilities`类中提供的功能性。否则，您可以按照本节所述创建自己的功能性。
+:::
+
+创建功能性是单个函数调用，结果对象应该存储在一个`static final`字段中。必须提供以下参数：
+- 功能性的名称。多次创建相同名称的功能性将始终返回相同的对象。不同名称的功能性是**完全独立的**，可以用于不同的目的。
+- 正在查询的行为类型。这是`T`类型参数。
+- 查询中的附加上下文类型。这是`C`类型参数。
+
+例如，以下是如何声明侧向感知方块`IItemHandler`的功能性：
+
+```java
+public static final BlockCapability ITEM_HANDLER_BLOCK =
+ BlockCapability.create(
+ // 提供一个名称以唯一标识功能性。
+ new ResourceLocation("mymod", "item_handler"),
+ // 提供查询的类型。在这里，我们希望查找`IItemHandler`实例。
+ IItemHandler.class,
+ // 提供上下文类型。我们将允许查询接收额外的`Direction side`参数。
+ Direction.class);
+```
+
+对于方块来说，`@Nullable Direction`是如此常见，以至于有一个专门的助手函数：
+
+```java
+public static final BlockCapability ITEM_HANDLER_BLOCK =
+ BlockCapability.createSided(
+ // 提供一个名称以唯一标识功能性。
+ new ResourceLocation("mymod", "item_handler"),
+ // 提供查询的类型。在这里，我们希望查找`IItemHandler`实例。
+ IItemHandler.class);
+```
+
+如果不需要上下文，则应使用`Void`。对于无上下文的功能性也有专门的助手函数：
+
+```java
+public static final BlockCapability ITEM_HANDLER_NO_CONTEXT =
+ BlockCapability.createVoid(
+ // 提供一个名称以唯一标识功能性。
+ new ResourceLocation("mymod", "item_handler_no_context"),
+ // 提供查询的类型。在这里，我们希望查找`IItemHandler`实例。
+ IItemHandler.class);
+```
+
+对于实体和物品堆叠，`EntityCapability`和`ItemCapability`分别存在类似的方法。
+
+## 查询功能性
+一旦我们在一个静态字段中拥有了`BlockCapability`、`EntityCapability`或`ItemCapability`对象，我们就可以查询一个功能性。
+
+对于实体和物品堆叠，我们可以尝试使用`getCapability`找到功能性的实现。如果结果是`null`，则没有可用的实现。
+
+例如：
+
+```java
+var object = entity.getCapability(CAP, context);
+if (object != null) {
+ // 使用object
+}
+```
+```java
+var object = stack.getCapability(CAP, context);
+if (object != null) {
+ // 使用object
+}
+```
+
+方块功能性的使用略有不同，因为没有方块实体的方块也可以拥有功能性。现在，查询是在一个`level`上进行的，有一个我们正在寻找的`pos`位置作为附加参数：
+
+```java
+var object = level.getCapability(CAP, pos, context);
+if (object != null) {
+ // 使用object
+}
+```
+
+如果已知方块实体和/或方块状态，可以传递它们以节省查询时间：
+
+```java
+var object = level.getCapability(CAP, pos, blockState, blockEntity, context);
+if (object != null) {
+ // 使用object
+}
+```
+
+为了给出一个更具体的示例，以下是如何从`Direction.NORTH`侧查询方块的`IItemHandler`功能性：
+
+```java
+IItemHandler handler = level.getCapability(Capabilities.ItemHandler.BLOCK, pos, Direction.NORTH);
+if (handler != null) {
+ // 使用handler进行某些物品相关操作。
+}
+```
+
+当查询某个功能性时，系统会在后台执行以下步骤：
+1. 如果它们没有被提供的话，获取方块实体和方块状态。
+2. 获取注册的功能性提供者。（下文会有更多相关信息）
+3. 遍历提供者并询问他们是否能提供该功能性。
+4. 提供者中的一个将返回功能性实例，可能会分配一个新对象。
+
+尽管实现相当高效，但对于频繁进行的查询，例如每个游戏刻，这些步骤可能会占用大量服务器时间。`BlockCapabilityCache` 系统为在特定位置频繁查询的能力提供了巨大的速度提升。
+
+:::tip
+通常，`BlockCapabilityCache` 会被创建一次，然后存储在执行频繁功能性查询的对象的字段中。何时何地存储缓存取决于您。
+:::
+
+要创建缓存，请使用要查询的功能性，级别，位置和查询上下文调用 `BlockCapabilityCache.create`。
+
+```java
+// 声明字段：
+private BlockCapabilityCache capCache;
+
+// 稍后，例如在方块实体的 `onLoad` 中：
+this.capCache = BlockCapabilityCache.create(
+ Capabilities.ItemHandler.BLOCK, // 要缓存的功能性
+ level, // 世界级别
+ pos, // 目标位置
+ Direction.NORTH // 上下文
+);
+```
+
+然后通过 `getCapability()` 查询缓存：
+```java
+IItemHandler handler = this.capCache.getCapability();
+if (handler != null) {
+ // 对某些与物品相关的操作使用 handler。
+}
+```
+
+**缓存会被垃圾收集器自动清除，无需注销。**
+
+也可以接收到功能性对象变更的通知！这包括功能性变化（`oldHandler != newHandler`）、变得不可用（`null`）或再次变得可用（不再是 `null`）。
+
+创建缓存时需要两个额外的参数：
+- 一个有效性检查，用于确定缓存是否仍然有效。
+在作为方块实体字段的最简单用法中，`() -> !this.isRemoved()` 就可以了。
+- 一个失效监听器，当功能性改变时被调用。
+这是您可以对功能性变更、移除或出现做出反应的地方。
+
+```java
+// 带有可选的失效监听器：
+this.capCache = BlockCapabilityCache.create(
+ Capabilities.ItemHandler.BLOCK, // 要缓存的功能性
+ level, // 世界级别
+ pos, // 目标位置
+ Direction.NORTH, // 上下文
+ () -> !this.isRemoved(), // 有效性检查（因为缓存可能会比它所属的对象更久存在）
+ () -> onCapInvalidate() // 失效监听器
+);
+```
+
+## 方块功能性失效
+:::info
+失效功能是专门针对方块功能性的。实体和物品堆叠的功能性不能被缓存，因此不需要失效处理。
+:::
+
+为了确保缓存可以正确更新它们存储的功能性，**模组开发者必须在功能性改变、出现或消失时调用 `level.invalidateCapabilities(pos)`**。
+```java
+// 每当一个功能性改变、出现或消失时：
+level.invalidateCapabilities(pos);
+```
+
+NeoForge已经处理了常见情况，例如区块的加载/卸载和方块实体的创建/移除，但其他情况需要模组开发者明确处理。例如，模组开发者必须在以下情况中使功能性失效：
+- 如果先前返回的功能性不再有效。
+- 如果放置或状态变化的功能性提供方块（没有方块实体），通过覆写 `onPlace`。
+- 如果移除的功能性提供方块（没有方块实体），通过覆写 `onRemove`。
+
+对于一个简单的方块示例，参考 `ComposterBlock.java` 文件。
+
+更多信息，请参考 [`IBlockCapabilityProvider`][block-cap-provider] 的 javadoc。
+
+## 注册功能性
+功能性*提供者*是最终提供功能性的东西。功能性提供者是一个函数，可以返回一个功能性实例，或者如果不能提供功能性，就返回 `null`。提供者特定于：
+- 它们为之提供服务的给定功能性，以及
+- 它们为之提供服务的方块实例、方块实体类型、实体类型或物品实例。
+
+它们需要在 `RegisterCapabilitiesEvent` 中注册。
+
+方块提供者使用 `registerBlock` 进行注册。例如：
+```java
+private static void registerCapabilities(RegisterCapabilitiesEvent event) {
+ event.registerBlock(
+ Capabilities.ItemHandler.BLOCK, // 注册的功能性
+ (level, pos, state, be, side) -> <返回 IItemHandler>,
+ // 注册的方块
+ MY_ITEM_HANDLER_BLOCK,
+ MY_OTHER_ITEM_HANDLER_BLOCK);
+}
+```
+
+通常，注册将特定于一些方块实体类型，因此提供了 `registerBlockEntity` 辅助方法：
+```java
+ event.registerBlockEntity(
+ Capabilities.ItemHandler.BLOCK, // 注册的功能性
+ MY_BLOCK_ENTITY_TYPE, // 注册的方块实体类型
+ (myBlockEntity, side) -> <为 myBlockEntity 和 side 返回 IItemHandler>);
+```
+
+如果之前由方块或方块实体提供者返回的功能性不再有效，**您必须通过调用 `level.invalidateCapabilities(pos)` 来使缓存失效**。有关更多信息，请参考上文的[失效部分][invalidation]。
+
+实体的注册类似，使用 `registerEntity`：
+```java
+event.registerEntity(
+ Capabilities.ItemHandler.ENTITY, // 要注册的功能性
+ MY_ENTITY_TYPE, // 要注册的实体类型
+ (myEntity, context) -> <返回 myEntity 的 IItemHandler>);
+```
+
+物品的注册也类似。注意，提供者接收堆叠：
+```java
+event.registerItem(
+ Capabilities.ItemHandler.ITEM, // 要注册的功能性
+ (itemStack, context) -> <返回 itemStack 的 IItemHandler>,
+ // 要注册的物品
+ MY_ITEM,
+ MY_OTHER_ITEM);
+```
+
+## 为所有对象注册功能性
+
+如果由于某种原因您需要为所有方块、实体或物品注册一个提供者，您将需要遍历相应的注册表并为每个对象注册提供者。
+
+例如，NeoForge使用这个系统为所有的 `BucketItem`（不包括子类）注册一个流体处理器功能性：
+```java
+// 作为参考，您可以在 `CapabilityHooks` 类中找到这段代码。
+for (Item item : BuiltInRegistries.ITEM) {
+ if (item.getClass() == BucketItem.class) {
+ event.registerItem(Capabilities.FluidHandler.ITEM, (stack, ctx) -> new FluidBucketWrapper(stack), item);
+ }
+}
+```
+
+按照注册的顺序请求提供者提供功能性。如果您想在NeoForge已经为您的某个对象注册的提供者之前运行，请使用更高优先级注册您的 `RegisterCapabilitiesEvent` 处理器。例如：
+```java
+modBus.addListener(RegisterCapabilitiesEvent.class, event -> {
+ event.registerItem(
+ Capabilities.FluidHandler.ITEM,
+ (stack, ctx) -> new MyCustomFluidBucketWrapper(stack),
+ // 要注册的方块
+ MY_CUSTOM_BUCKET);
+}, EventPriority.HIGH); // 使用 HIGH 优先级在 NeoForge 之前注册！
+```
+查看 [`CapabilityHooks`][capability-hooks] 以获取 NeoForge 本身注册的提供者列表。
+
+[block-cap-provider]: https://github.com/neoforged/NeoForge/blob/1.20.x/src/main/java/net/neoforged/neoforge/capabilities/IBlockCapabilityProvider.java
+[capability-hooks]: https://github.com/neoforged/NeoForge/blob/1.20.x/src/main/java/net/neoforged/neoforge/capabilities/CapabilityHooks.java
+[invalidation]: #block-capability-invalidation
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/codecs.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/codecs.md
new file mode 100644
index 000000000..4009381bb
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/codecs.md
@@ -0,0 +1,446 @@
+# 编解码器
+
+编解码器是 Mojang 的 [DataFixerUpper] 库中的一种序列化工具，用于描述对象在不同格式之间的转换方式，如将对象从 `JsonElement` 的 JSON 格式转换为 NBT 的 `Tag` 格式。
+
+## 使用编解码器
+
+编解码器主要用于将 Java 对象编码（或序列化）成某种数据格式，并将格式化的数据对象解码（或反序列化）回其关联的 Java 类型。这通常通过 `Codec#encodeStart` 和 `Codec#parse` 来实现。
+
+### 动态操作
+
+为了确定将数据编码和解码至哪种中间文件格式，`#encodeStart` 和 `#parse` 都需要一个 `DynamicOps` 实例来定义该格式中的数据。
+
+[DataFixerUpper] 库包含了 `JsonOps`，用于对存储在 [`Gson`][gson] 的 `JsonElement` 实例中的 JSON 数据进行编解码。`JsonOps` 支持两种 `JsonElement` 序列化版本：`JsonOps#INSTANCE` 定义了标准的 JSON 文件，而 `JsonOps#COMPRESSED` 允许将数据压缩成单一字符串。
+
+```java
+// 假设 exampleCodec 代表一个 Codec
+// 假设 exampleObject 为一个 ExampleJavaObject
+// 假设 exampleJson 为一个 JsonElement
+
+// 将 Java 对象编码为常规 JsonElement
+exampleCodec.encodeStart(JsonOps.INSTANCE, exampleObject);
+
+// 将 Java 对象编码为压缩的 JsonElement
+exampleCodec.encodeStart(JsonOps.COMPRESSED, exampleObject);
+
+// 将 JsonElement 解码为 Java 对象
+// 假设 JsonElement 是正常解析的
+exampleCodec.parse(JsonOps.INSTANCE, exampleJson);
+```
+
+Minecraft 还提供了 `NbtOps` 用于对存储在 `Tag` 实例中的 NBT 数据进行编解码。可以通过 `NbtOps#INSTANCE` 来引用。
+
+```java
+// 假设 exampleCodec 代表一个 Codec
+// 假设 exampleObject 为一个 ExampleJavaObject
+// 假设 exampleNbt 为一个 Tag
+
+// 将 Java 对象编码为 Tag
+exampleCodec.encodeStart(JsonOps.INSTANCE, exampleObject);
+
+// 将 Tag 解码为 Java 对象
+exampleCodec.parse(JsonOps.INSTANCE, exampleNbt);
+```
+
+#### 格式转换
+
+`DynamicOps` 还可以单独用来在两种不同的编码格式之间转换。这可以通过使用 `#convertTo` 并提供 `DynamicOps` 格式和要转换的编码对象来完成。
+
+```java
+// 将 Tag 转换为 JsonElement
+// 假设 exampleTag 为一个 Tag
+JsonElement convertedJson = NbtOps.INSTANCE.convertTo(JsonOps.INSTANCE, exampleTag);
+```
+
+### 数据结果
+
+使用编解码器编码或解码数据时返回的 `DataResult` 将根据转换是否成功，持有转换后的实例或一些错误数据。当转换成功时，由 `#result` 提供的 `Optional` 将包含成功转换的对象。如果转换失败，由 `#error` 提供的 `Optional` 将包含 `PartialResult`，后者持有错误消息和根据编解码器部分转换的对象。
+
+此外，`DataResult` 上有许多方法可以用来将结果或错误转换为所需格式。例如，`#resultOrPartial` 将返回一个 `Optional`，在成功时包含结果，在失败时包含部分转换的对象。此方法接受一个字符串消费者以确定如何报告错误消息（如果存在）。
+
+```java
+// 假设 exampleCodec 代表一个 Codec
+// 假设 exampleJson 为一个 JsonElement
+
+// 将 JsonElement 解码为 Java 对象
+DataResult result = exampleCodec.parse(JsonOps.INSTANCE, exampleJson);
+
+result
+ // 获取结果或部分错误时的错误消息
+ .resultOrPartial(errorMessage -> /* 处理错误消息 */)
+ // 如果结果或部分存在，则进行某些操作
+ .ifPresent(decodedObject
+
+ -> /* 处理解码对象 */);
+```
+
+## 现有编解码器
+
+### 原始类型
+
+`Codec` 类包含了一些定义的原始类型的静态编解码器实例。
+
+| 编解码器 | Java 类型 |
+|------------|--------|
+| `BOOL` | `Boolean` |
+| `BYTE` | `Byte` |
+| `SHORT` | `Short` |
+| `INT` | `Integer` |
+| `LONG` | `Long` |
+| `FLOAT` | `Float` |
+| `DOUBLE` | `Double` |
+| `STRING` | `String` |
+| `BYTE_BUFFER` | `ByteBuffer` |
+| `INT_STREAM` | `IntStream` |
+| `LONG_STREAM` | `LongStream` |
+| `PASSTHROUGH` | `Dynamic` |
+| `EMPTY` | `Unit` |
+
+* `Dynamic` 是一个在支持的 `DynamicOps` 格式中编码值的对象。这些通常用于将编码对象格式转换为其他编码对象格式。
+* `Unit` 是用于表示 `null` 对象的对象。
+
+### 原版和 Forge
+
+Minecraft 和 Forge 定义了许多常见对象的编解码器。一些示例包括用于 `ResourceLocation` 的 `ResourceLocation#CODEC`，用于 `DateTimeFormatter#ISO_INSTANT` 格式的 `Instant` 的 `ExtraCodecs#INSTANT_ISO8601`，以及用于 `CompoundTag` 的 `CompoundTag#CODEC`。
+
+:::警告
+使用 `JsonOps` 的 `CompoundTag` 不能从 JSON 解码数字列表。`JsonOps` 在转换时会将数字设置为其最窄类型。`ListTag` 强制其数据使用特定类型，因此不同类型的数字（例如 `64` 会是 `byte`，`384` 会是 `short`）在转换时会引发错误。
+:::
+
+原版和 Forge 注册也有针对注册表所包含对象类型的编解码器（例如 `Registry#BLOCK` 或 `ForgeRegistries#BLOCKS` 有一个 `Codec`）。`Registry#byNameCodec` 和 `IForgeRegistry#getCodec` 会将注册表对象编码为其注册名，或者如果压缩，则为整数标识符。原版注册表还有一个 `Registry#holderByNameCodec`，它将编码为注册名并解码为被 `Holder` 包装的注册表对象。
+
+## 创建编解码器
+
+可以为任何对象创建编解码器。为了便于理解，将显示等效的编码 JSON。
+
+### 记录
+
+编解码器可以通过使用记录来定义对象。每个记录编解码器定义了具有明确命名字段的任何对象。创建记录编解码器的方法有很多，但最简单的是通过 `RecordCodecBuilder#create`。
+
+`RecordCodecBuilder#create` 接受一个函数，该函数定义了一个 `Instance` 并返回一个应用（`App`）到构建对象的对象。这可以与创建类*实例*和用于*应用*类的构造函数联系起来。
+
+```java
+// 一个需要创建编解码器的对象
+public class SomeObject {
+
+ public SomeObject(String s, int i, boolean b) { /* ... */ }
+
+ public String s() { /* ... */ }
+
+ public int i() { /* ... */ }
+
+ public boolean b() { /* ... */ }
+}
+```
+
+#### 字段
+
+`Instance` 可以使用 `#group` 定义多达 16 个字段。每个字段必须是一个定义了对象被制造的实例及对象类型的应用。满足此要求的最简单方式是使用 `Codec`，设置字段的解码名称，并设置用于编码字段的 getter。
+
+字段可以使用 `#fieldOf` 从 `Codec` 创建，如果字段是必需的，或使用 `#optionalFieldOf` 创建，如果字段被包装在 `Optional` 中或默认存在。任一方法都需要包含编码对象中字段名称的字符串。然后可以使用 `#forGetter` 设置用于编码字段的 getter，它接受一个函数，该函数给定对象，返回字段数据。
+
+从那里
+
+，生成的产品可以通过 `#apply` 应用，以定义如何为应用构建对象。为了方便起见，分组字段应按照它们在构造函数中出现的顺序列出，以便函数可以简单地是一个构造函数方法引用。
+
+```java
+public static final Codec RECORD_CODEC = RecordCodecBuilder.create(instance -> // 给定一个实例
+ instance.group( // 在实例中定义字段
+ Codec.STRING.fieldOf("s").forGetter(SomeObject::s), // 字符串
+ Codec.INT.optionalFieldOf("i", 0).forGetter(SomeObject::i), // 整数，默认为 0（如果字段不存在）
+ Codec.BOOL.fieldOf("b").forGetter(SomeObject::b) // 布尔
+ ).apply(instance, SomeObject::new) // 定义如何创建对象
+);
+```
+
+```js
+// 编码后的 SomeObject
+{
+ "s": "value",
+ "i": 5,
+ "b": false
+}
+
+// 另一个编码后的 SomeObject
+{
+ "s": "value2",
+ // i 被省略，默认为 0
+ "b": true
+}
+```
+
+### 转换器
+
+编解码器可以通过映射方法转换成等效或部分等效的表现形式。每个映射方法接收两个函数：一个用于将当前类型转换为新类型，另一个用于将新类型转换回当前类型。这是通过 `#xmap` 函数完成的。
+
+```java
+// 一个类
+public class ClassA {
+
+ public ClassB toB() { /* ... */ }
+}
+
+// 另一个等效的类
+public class ClassB {
+
+ public ClassA toA() { /* ... */ }
+}
+
+// 假设存在某个编解码器 A_CODEC
+public static final Codec B_CODEC = A_CODEC.xmap(ClassA::toB, ClassB::toA);
+```
+
+如果类型部分等效，即转换过程中存在某些限制，则存在返回 `DataResult` 的映射函数，可用于在遇到异常或无效状态时返回错误状态。
+
+是否 A 完全等同于 B | 是否 B 完全等同于 A | 转换方法
+:---: | :---: | :---
+是 | 是 | `#xmap`
+是 | 否 | `#flatComapMap`
+否 | 是 | `#comapFlatMap`
+否 | 否 | `#flatXMap`
+
+```java
+// 给定一个字符串编解码器转换为整数
+// 并非所有字符串都可以变成整数（A 与 B 非完全等效）
+// 所有整数都可以变成字符串（B 与 A 完全等效）
+public static final Codec INT_CODEC = Codec.STRING.comapFlatMap(
+ s -> { // 返回失败时包含错误的数据结果
+ try {
+ return DataResult.success(Integer.valueOf(s));
+ } catch (NumberFormatException e) {
+ return DataResult.error(s + " 不是一个整数。");
+ }
+ },
+ Integer::toString // 常规函数
+);
+```
+
+```js
+// 将返回 5
+"5"
+
+// 将错误，不是整数
+"value"
+```
+
+#### 范围编解码器
+
+范围编解码器是 `#flatXMap` 的实现，如果值不在设定的最小值和最大值之间，则返回错误的 `DataResult`。如果值超出范围，仍会提供部分结果。分别有整数、浮点和双精度通过 `#intRange`、`#floatRange` 和 `#doubleRange` 实现。
+
+```java
+public static final Codec RANGE_CODEC = Codec.intRange(0, 4);
+```
+
+```js
+// 将有效，在 [0, 4] 内
+4
+
+// 将错误，在 [0, 4] 外
+5
+```
+
+### 默认值
+
+如果编码或解码的结果失败，可以通过 `Codec#orElse` 或 `Codec#orElseGet` 提供默认值。
+
+```java
+public static final Codec DEFAULT_CODEC = Codec.INT.orElse(0); // 也可以通过 #orElseGet 提供值
+```
+
+```js
+// 不是整数，默认为 0
+"value"
+```
+
+### 单位
+
+一个编解码器，提供代码中的值并不编码任何东西，可以使用 `Codec#unit` 表示。如果编解码器在数据对象中使用了一个不可编码的条目，这非常有用。
+
+```java
+public static final Codec> UNIT_CODEC = Codec.unit(
+ () -> ForgeRegistries.BLOCKS // 也可以是原始值
+);
+```
+
+```js
+// 这里没有任何内容，将返回方块注册表编解码器
+```
+
+### 列表
+
+可以从对象编解码器生成一个对象列表的编解码器，通过 `Codec#listOf` 实现。
+
+```java
+// BlockPos#CODEC 是一个 Codec
+public static final Codec> LIST_CODEC = BlockPos.CODEC.listOf();
+```
+
+```js
+// 编码的 List
+[
+ [1, 2, 3], // BlockPos(1, 2, 3)
+ [4, 5, 6], // BlockPos(4, 5, 6)
+ [7, 8, 9] // BlockPos(7, 8, 9)
+]
+``
+
+`
+
+使用列表编解码器解码的列表对象存储在一个**不可变**列表中。如果需要可变列表，则应该对列表编解码器应用[变换器]。
+
+### 映射
+
+可以通过两个编解码器生成键和值对象映射的编解码器，通过 `Codec#unboundedMap` 实现。无界映射可以指定任何基于字符串的或转换为字符串的值作为键。
+
+```java
+// BlockPos#CODEC 是一个 Codec
+public static final Codec> MAP_CODEC = Codec.unboundedMap(Codec.STRING, BlockPos.CODEC);
+```
+
+```js
+// 编码的 Map
+{
+ "key1": [1, 2, 3], // key1 -> BlockPos(1, 2, 3)
+ "key2": [4, 5, 6], // key2 -> BlockPos(4, 5, 6)
+ "key3": [7, 8, 9] // key3 -> BlockPos(7, 8, 9)
+}
+```
+
+使用无界映射编解码器解码的映射对象存储在一个**不可变**映射中。如果需要可变映射，则应对映射编解码器应用[变换器]。
+
+:::警告
+无界映射只支持可以编码/解码为字符串的键。可以使用键值[对]列表编解码器来绕过此限制。
+:::
+
+### 对
+
+可以通过两个编解码器生成对象对的编解码器，通过 `Codec#pair` 实现。
+
+对编解码器通过首先解码对中的左对象，然后取剩下的编码对象部分并从中解码右对象来解码对象。因此，编解码器必须在解码后表达关于编码对象的某些信息（如[记录]），或者必须被增强为 `MapCodec` 并通过 `#codec` 转换为常规编解码器。这通常可以通过将编解码器作为某个对象的[字段]来实现。
+
+```java
+public static final Codec> PAIR_CODEC = Codec.pair(
+ Codec.INT.fieldOf("left").codec(),
+ Codec.STRING.fieldOf("right").codec()
+);
+```
+
+```js
+// 编码的 Pair
+{
+ "left": 5, // fieldOf 查找左对象的 'left' 键
+ "right": "value" // fieldOf 查找右对象的 'right' 键
+}
+```
+
+:::tips
+可以使用非字符串键的映射编解码器通过应用带有[变换器]的键值对列表来编码/解码。
+:::
+
+### Either 编解码器
+
+可以通过两个编解码器生成一个针对某个对象数据的两种不同编解码方法的编解码器，使用 `Codec#either` 实现。
+
+Either 编解码器首先尝试使用第一个编解码器解码对象。如果失败，它将尝试使用第二个编解码器。如果第二次也失败，那么 `DataResult` 将只包含第二次编解码器失败的错误。
+
+```java
+public static final Codec> EITHER_CODEC = Codec.either(
+ Codec.INT,
+ Codec.STRING
+);
+```
+
+```js
+// 编码 Either$Left
+5
+
+// 编码 Either$Right
+"value"
+```
+
+:::tips
+这可以与[变换器]结合使用，从两种不同的编码方法中获取特定对象。
+:::
+
+### 分派编解码器
+
+编解码器可以拥有可以根据某些指定类型解码特定对象的子编解码器，通过 `Codec#dispatch` 实现。这通常用于包含编解码器的注册表，如规则测试或方块放置器。
+
+分派编解码器首先尝试从某个字符串键（通常是 `type`）获取编码类型。从那里开始，解码类型，调用用于解码实际对象的特定编解码器的获取器。如果用于解码对象的 `DynamicOps` 压缩其映射，或者对象编解码器本身没有增强成 `MapCodec`（如记录或字段化原语），则对象需要存储在 `value` 键中。否则，对象将在与其余数据相同的级别上解码。
+
+```java
+// 定义我们的对象
+public abstract class ExampleObject {
+
+ // 定义用于指定编码对象类型的方法
+ public abstract Codec type();
+}
+
+// 创建存储字符串的简单对象
+public class StringObject extends ExampleObject {
+
+ public StringObject(String s) { /* ... */ }
+
+ public String s() { /* ... */ }
+
+ public Codec type() {
+ // 一个注册的注册表对象
+ // "string":
+ // Codec.STRING.xmap(StringObject::new, StringObject::s)
+ return STRING_OBJECT_CODEC.get();
+ }
+}
+
+// 创建存储字符串和整数的复杂对象
+public class ComplexObject extends ExampleObject {
+
+ public ComplexObject(String s, int i) { /* ... */ }
+
+ public String s() { /* ... */ }
+
+ public int i() { /* ... */ }
+
+ public Codec type() {
+ // 一个注册的注册表对象
+ // "complex":
+ // RecordCodecBuilder.create(instance ->
+ // instance.group(
+ // Codec.STRING.fieldOf("s").forGetter(ComplexObject::s),
+ // Codec.INT.fieldOf("i").forGetter(ComplexObject::i)
+ // ).apply(instance, ComplexObject::new)
+ // )
+ return COMPLEX_OBJECT_CODEC.get();
+ }
+}
+
+// 假设存在一个 IForgeRegistry> DISPATCH
+public static final Codec = DISPATCH.getCodec() // 获取 Codec>
+ .dispatch(
+ ExampleObject::type, // 从特定对象获取编解码器
+ Function.identity() // 从注册表获取编解码器
+ );
+```
+
+```js
+// 简单对象
+{
+ "type": "string", // 对于 StringObject
+ "value": "value" // 编解码器类型未从 MapCodec 增强，需要字段
+}
+
+// 复杂对象
+{
+ "type": "complex", // 对于 ComplexObject
+
+ // 编解码器类型从 MapCodec 增强，可以内联
+ "s": "value",
+ "i": 0
+}
+```
+
+[DataFixerUpper]: https://github.com/Mojang/DataFixerUpper
+[gson]: https://github.com/google/gson
+[transformer]: #transformer-codecs
+[pair]: #pair
+[records]: #records
+[field]: #fields
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/nbt.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/nbt.md
new file mode 100644
index 000000000..f46adb011
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/nbt.md
@@ -0,0 +1,100 @@
+# Named Binary Tag (NBT)
+
+NBT 是 Minecraft 最初时期由 Notch 本人引入的一种格式，它在整个 Minecraft 代码库中广泛用于数据存储。
+
+## 规范
+
+NBT 规范与 JSON 规范类似，但有一些区别：
+
+- 存在字节、短整型、长整型和浮点型的明确类型，分别以 `b`、`s`、`l` 和 `f` 为后缀，类似于在 Java 代码中的表示方式。
+ - 双精度浮点型也可以用 `d` 后缀，但这不是必需的，类似于 Java 代码中的可选 `i` 后缀不被允许。
+ - 后缀不区分大小写。例如，`64b` 与 `64B` 相同，`0.5F` 与 `0.5f` 相同。
+- 布尔类型不存在，而是用字节表示。`true` 变为 `1b`，`false` 变为 `0b`。
+ - 当前实现将所有非零值视为 `true`，因此 `2b` 也会被视为 `true`。
+- NBT 中不存在 `null` 的等效物。
+- 键周围的引号是可选的。所以 JSON 属性 `"duration": 20` 在 NBT 中可以表示为 `duration: 20` 或 `"duration": 20`。
+- 在 JSON 中被称为子对象的东西，在 NBT 中被称为**复合标签**（或简称复合）。
+- NBT 列表不能混合匹配类型，不同于 JSON。列表类型由第一个元素确定，或在代码中定义。
+ - 然而，列表的列表可以混合匹配不同的列表类型。因此，一个列表包含两个列表，其中第一个是字符串列表，第二个是字节列表，是允许的。
+- 存在特殊的**数组**类型，它们不同于列表，但遵循包含元素在方括号中的模式。有三种数组类型：
+ - 字节数组，以 `B;` 开头。例如：`[B;0b,30b]`
+ - 整数数组，以 `I;` 开头。例如：`[I;0,-300]`
+ - 长整型数组，以 `L;` 开头。例如：`[L;0l,240l]`
+- 列表、数组和复合标签中允许有尾随逗号。
+
+## NBT 文件
+
+Minecraft 广泛使用 `.nbt` 文件，例如 [datapacks][datapack] 中的结构文件。包含区域内容（即一系列区块）的区域文件（`.mca`），以及游戏中不同位置使用的各种 `.dat` 文件，也是 NBT 文件。
+
+NBT 文件通常使用 GZip 压缩。因此，它们是二进制文件，不能直接编辑。
+
+## NBT 在代码中的使用
+
+与 JSON 类似，所有 NBT 对象都是封闭对象的子对象。让我们创建一个：
+
+```java
+CompoundTag tag = new CompoundTag();
+```
+
+现在我们可以将数据放入该标签：
+
+```java
+tag.putInt("Color", 0xffffff);
+tag.putString("Level", "minecraft:overworld");
+tag.putDouble("IAmRunningOutOfIdeasForNamesHere", 1d);
+```
+
+这里存在几个辅助方法，例如，`putIntArray` 也有一个便利方法，除了标准变体接受 `int[]` 外，还接受 `List`。
+
+当然，我们也可以从该标签中获取值：
+
+```java
+int color = tag.getInt("Color");
+String level = tag.getString("Level");
+double d = tag.getDouble("IAmRunningOutOfIdeasForNamesHere");
+```
+
+如果不存在，数字类型将返回 0。字符串将返回 `""` 如果不存在。更复杂的类型（列表、数组、复合标签）如果不存在会抛出异常。
+
+因此，我们
+
+希望通过检查标签元素是否存在来进行防护：
+
+```java
+boolean hasColor = tag.contains("Color");
+boolean hasColorMoreExplicitly = tag.contains("Color", Tag.TAG_INT);
+```
+
+`TAG_INT` 常量在 `Tag` 中定义，这是所有标签类型的超接口。大多数标签类型除了 `CompoundTag` 外大多是内部的，例如 `ByteTag` 或 `StringTag`，尽管如果你偶然遇到一些，直接的 `CompoundTag#get` 和 `#put` 方法可以与它们一起工作。
+
+不过，有一个明显的例外：`ListTag`。处理这些是特别的，因为当通过 `CompoundTag#getList` 获取列表标签时，你还必须指定列表类型。例如，获取字符串列表会像这样工作：
+
+```java
+ListTag list = tag.getList("SomeListHere", Tag.TAG_STRING);
+```
+
+类似地，创建 `ListTag` 时，也必须在创建过程中指定列表类型：
+
+```java
+ListTag list = new ListTag(List.of("Value1", "Value2"), Tag.TAG_STRING);
+```
+
+最后，直接在其他 `CompoundTag` 中操作 `CompoundTag` 利用 `CompoundTag#get` 和 `#put`：
+
+```java
+tag.put("Tag", new CompoundTag());
+tag.get("Tag");
+```
+
+## NBT 的用途
+
+NBT 在 Minecraft 中有很多用途。一些最常见的例子包括 [`ItemStack`][itemstack]、[`BlockEntity`][blockentity] 和 `Entity`。
+
+## 另见
+
+- [Minecraft Wiki 上的 NBT 格式][nbtwiki]
+
+[blockentity]: ../blockentities/index.md
+[datapack]: ../resources/server/index.md
+[itemstack]: ../items/index.md#itemstacks
+[nbtwiki]: https://minecraft.wiki/w/NBT_format
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/saveddata.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/saveddata.md
new file mode 100644
index 000000000..1e2247519
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/datastorage/saveddata.md
@@ -0,0 +1,40 @@
+# 保存的数据系统
+
+保存的数据（SD）系统可用于在各级别上保存额外数据。
+
+_如果数据特定于某些方块实体、区块或实体，请考虑使用[数据附件](attachments)。_
+
+## 声明
+
+每个 SD 实现必须是 `SavedData` 类的子类型。有两个重要方法需要注意：
+
+* `save`：允许实现将 NBT 数据写入级别。
+* `setDirty`：在更改数据后必须调用的方法，以通知游戏需要写入的更改。如果不调用，`#save` 将不会被调用，原始数据将保持不变。
+
+## 附加到级别
+
+任何 `SavedData` 都是动态加载和/或附加到级别的。因此，如果一个级别上从未创建过，那么它将不存在。
+
+`SavedData` 是从 `DimensionDataStorage` 创建和加载的，可以通过调用 `ServerChunkCache#getDataStorage` 或 `ServerLevel#getDataStorage` 访问。从那里，您可以通过调用 `DimensionDataStorage#computeIfAbsent` 来获取或创建您的 SD 实例。这将尝试获取当前存在的 SD 实例，或创建一个新实例并加载所有可用数据。
+
+`DimensionDataStorage#computeIfAbsent` 接受两个参数。第一个是 `SavedData.Factory` 的实例，它包括一个供应商来构建一个新的 SD 实例和一个函数，以将 NBT 数据加载到 SD 并返回它。第二个参数是实施级别的 `data` 文件夹中存储的 `.dat` 文件的名称。名称必须是有效的文件名，不能包含 `/` 或 `\`。
+
+例如，如果一个 SD 在下界被命名为 "example"，则会在 `.//DIM-1/data/example.dat` 创建一个文件，并且会像这样实现：
+
+```java
+// 在某个类中
+public ExampleSavedData create() {
+ return new ExampleSavedData();
+}
+
+public ExampleSavedData load(CompoundTag tag) {
+ ExampleSavedData data = this.create();
+ // 加载保存的数据
+ return data;
+}
+
+// 在类中的某个方法内
+netherDataStorage.computeIfAbsent(new Factory<>(this::create, this::load), "example");
+```
+
+如果一个 SD 不特定于一个级别，那么 SD 应该附加到主世界，可以从 `MinecraftServer#overworld` 获取。主世界是唯一从不完全卸载的维度，因此非常适合在其上存储多级别数据。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/_category_.json
new file mode 100644
index 000000000..da8a48332
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/_category_.json
@@ -0,0 +1,4 @@
+{
+ "label": "Getting Started with Neo",
+ "position": 1
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/index.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/index.md
new file mode 100644
index 000000000..f9995afec
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/index.md
@@ -0,0 +1,62 @@
+# 开始使用 NeoForge
+
+本节包含有关如何设置 NeoForge 工作区以及如何运行和测试您的模组的信息。
+
+## 先决条件
+
+- 熟悉 Java 编程语言，特别是其面向对象、多态、泛型和功能性特征。
+- 安装 Java 17 开发工具包（JDK）和 64 位 Java 虚拟机（JVM）。NeoForge 推荐并官方支持 [Microsoft 的 OpenJDK 构建][jdk]，但其他 JDK 也应该可以工作。
+
+:::warning
+确保您正在使用 64 位 JVM。检查的一种方式是在终端运行 `java -version`。使用 32 位 JVM 可能会出现问题，因为很多东西已经不再支持 32 位 JVM 了。
+:::
+
+- 熟悉您选择的集成开发环境（IDE）。
+ - NeoForge 官方支持 [IntelliJ IDEA][intellij] 和 [Eclipse][eclipse]，这两者都集成了 Gradle 支持。但是，可以使用任何 IDE，从 Netbeans 或 Visual Studio Code 到 Vim 或 Emacs 都可以。
+- 熟悉 [Git][git] 和 [GitHub][github]。技术上这不是必需的，但它会让您的生活变得更加轻松。
+
+## 设置工作区
+
+- 打开 [Mod Developer Kit (MDK)][mdk] GitHub 仓库，点击“使用此模板”并将新创建的仓库克隆到您的本地机器。
+ - 如果您不想使用 GitHub，或者想获取旧提交或非默认分支的模板（例如，对于旧版本），您也可以下载仓库的 ZIP 文件（在代码 -> 下载 ZIP 下）并解压。
+- 打开您的 IDE 并导入 Gradle 项目。Eclipse 和 IntelliJ IDEA 会为您自动完成此操作。如果您使用的 IDE 不支持此操作，您也可以通过 `gradlew` 终端命令来完成。
+ - 首次进行此操作时，Gradle 将下载 NeoForge 的所有依赖项，包括 Minecraft 本身，并对其进行反编译。这可能需要相当长的时间（取决于您的硬件和网络强度，最多可达一个小时）。
+ - 每当您对 Gradle 文件进行更改时，需要重新加载 Gradle 更改，可以通过您的 IDE 中的“重新加载 Gradle”按钮或再次通过 `gradlew` 终端命令来完成。
+
+## 自定义您的模组信息
+
+您的模组的许多基本属性都可以在 `gradle.properties` 文件中更改。这包括模组名称或模组版本等基本事项。有关更多信息，请参阅 `gradle.properties` 文件中的注释，或查看 [关于 `gradle.properties` 文件的文档][properties]。
+
+如果您想进一步修改构建过程，可以编辑 `build.gradle` 文件。NeoGradle，NeoForge 的 Gradle 插件，提供了几个配置选项，其中一些选项通过 `build.gradle` 文件中的注释进行了解释。有关完整文档，请参阅 [NeoGradle 文档][neogradle]。
+
+:::warning
+只有在您知道自己在做什么时才编辑 `build.gradle` 和 `settings.gradle` 文件。所有基本属性都可以通过 `gradle.properties` 设置。
+:::
+
+## 构建和测试您的模组
+
+要构建您的模组，请运行 `gradlew build`。这将在 `build/libs` 中输出一个名为 `-.jar` 的文件。`` 和 `` 是通过 `build.gradle` 设置的属性，默认为 `gradle.properties` 文件中的 `mod_id` 和 `mod_version` 值；如果需要，这可以在 `build.gradle` 中更改。然后可以将生成的 JAR 文件放置在启用 NeoForge 的 Minecraft 设置的 `mods` 文件夹中，或
+
+上传到模组分发平台。
+
+要在测试环境中运行您的模组，您可以使用生成的运行配置或使用相关任务（例如 `gradlew runClient`）。这将从相应的运行目录（例如 `runs/client` 或 `runs/server`）启动 Minecraft，以及任何指定的源集。默认 MDK 包括 `main` 源集，因此在 `src/main/java` 中编写的任何代码都将被应用。
+
+### 服务器测试
+
+如果您正在运行一个专用服务器，无论是通过运行配置还是 `gradlew runServer`，服务器将立即关闭。您需要通过编辑运行目录中的 `eula.txt` 文件来接受 Minecraft EULA。
+
+一旦接受，服务器将加载并在 `localhost`（或默认的 `127.0.0.1`）下可用。然而，您仍然无法加入，因为服务器默认会进入在线模式，这需要认证（开发玩家没有）。要解决此问题，请再次停止您的服务器并将 `server.properties` 文件中的 `online-mode` 属性设置为 `false`。现在，启动您的服务器，您应该能够连接。
+
+:::tips
+您应该始终在专用服务器环境中测试您的模组。这包括[仅客户端模组][client]，因为这些在服务器上加载时不应做任何事情。
+:::
+
+[client]: ../concepts/sides.md
+[eclipse]: https://www.eclipse.org/downloads/
+[git]: https://www.git-scm.com/
+[github]: https://github.com/
+[intellij]: https://www.jetbrains.com/idea/
+[jdk]: https://learn.microsoft.com/en-us/java/openjdk/download#openjdk-17
+[mdk]: https://github.com/neoforged/MDK
+[neogradle]: https://docs.neoforged.net/neogradle/docs/
+[properties]: modfiles.md#gradleproperties
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/modfiles.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/modfiles.md
new file mode 100644
index 000000000..733cda92c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/modfiles.md
@@ -0,0 +1,79 @@
+# Mod Files
+
+Mod文件负责确定哪些模组被打包到您的JAR文件中，显示在“Mods”菜单中的信息，以及您的模组在游戏中应如何加载。
+
+## gradle.properties
+
+`gradle.properties`文件保存了您的模组的各种常见属性，例如模组ID或模组版本。在构建过程中，Gradle会读取这些文件中的值，并将它们内联到各种位置，如[mods.toml][modstoml]文件中。这样，您只需要在一个地方更改值，然后它们就会为您在所有地方应用。
+
+大多数值也在[MDK的`gradle.properties`文件]中以注释形式解释。
+
+## mods.toml
+
+位于`src/main/resources/META-INF/mods.toml`的`mods.toml`文件是一个[TOML][toml]格式的文件，定义了您的模组的元数据。它还包含了有关如何将您的模组加载到游戏中的附加信息，以及显示在“Mods”菜单中的显示信息。[MDK提供的`mods.toml`文件][mdkmodstoml]包含解释每个条目的注释，这里将更详细地解释。
+
+`mods.toml`可以分为三部分：非模组特定属性，这些属性与模组文件相关联；模组属性，每个模组有一个部分；依赖配置，每个模组的依赖项有一个部分。与`mods.toml`文件关联的某些属性是强制性的；强制性属性需要指定一个值，否则会抛出异常。
+
+### 非模组特定属性
+
+非模组特定属性与JAR本身相关联，指示如何加载模组以及任何额外的全局元数据。
+
+### 模组特定属性
+
+模组特定属性通过`[[mods]]`头部与指定的模组关联。这是一个[表的数组][array]；所有键/值属性都将附加到该模组，直到下一个头部。
+
+### 依赖配置
+
+模组可以指定它们的依赖关系，NeoForge在加载模组之前会检查这些配置。这些配置是使用`[[dependencies.]]`创建的，其中`modid`是消耗依赖项的模组的标识符。
+
+## Mod 入口点
+
+现在`mods.toml`已经填写完毕，我们需要为模组提供一个入口点。入口点本质上是执行模组的起点。入口点本身由`mods.toml`中使用的语言加载器确定。
+
+### `javafml` 和 `@Mod`
+
+`javafml`是NeoForge为Java编程语言提供的语言加载器。入口点是使用带有`@Mod`注解的公共类定义的。`@Mod`的值必须包含`mods.toml`中指定的模组ID之一。从那里开始，所有初始化逻辑（例如[注册事件][events]或[添加`DeferredRegister`][registration]）可以在类的构造函数中指定。
+
+```java
+@Mod("examplemod") // 必须与mods.toml中的模组ID匹配
+public class Example {
+ public Example(IEventBus modBus) { // 参数是模组特定的事件总线，例如用于注册和事件
+ // 在这里初始化逻辑
+ }
+}
+```
+
+:::tips
+`mods.toml`文件中的模组和`@Mod`入口点必须有1对1的匹配。这意味着对于每个定义的模组，必须有一个带有该模组ID的`@Mod`注解。
+:::
+
+### `lowcodefml`
+
+`lowcodefml`是一种语言加载器，用作以模组形式分发数据包和资源包，而无需代码内入口点。它被指定为`lowcodefml`而不是`nocodefml`，因为未来可能需要最小的代码添加。
+
+[array]: https://toml.io/en/v1.0.0#array-of-tables
+[atlasviewer]: https://github.com/XFactHD/AtlasViewer/blob/1.20.2/neoforge/src/main/resources/META-INF/services/xfacthd.atlasviewer.platform.services.IPlatformHelper
+[events]: ../concepts/events.md
+[features]: #features
+[group]: #the-group-id
+[i18n]: ../resources/client/i18n.md#translating-mod-metadata
+[javafml]: #javafml-and-mod
+[jei]: https://www.curseforge.com/minecraft/mc-mods/jei
+[lowcodefml]: #lowcodefml
+[mcversioning]: versioning.md#minecraft
+[mdkgradleproperties]: https://github.com/neoforged/MDK/blob/main/gradle.properties
+[mdkmodstoml]: https://github.com/neoforged/MDK/blob/main/src/main/resources/META-INF/mods.toml
+[modstoml]: #modstoml
+[mojmaps]: https://github.com/neoforged/NeoForm/blob/main/Mojang.md
+[multiline]: https://toml.io/en/v1.0.0#string
+[mvr]: https://maven.apache.org/enforcer/enforcer-rules/versionRanges.html
+[neoversioning]: versioning.md#neoforge
+[packaging]: ./structuring.md#packaging
+[registration]: ../concepts/registries.md#deferredregister
+[serviceload]: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/ServiceLoader.html#load(java.lang.Class)
+[sides]: ../concepts/sides.md
+[spdx]: https://spdx.org/licenses/
+[toml]: https://toml.io/
+[update]: ../misc/updatechecker.md
+[uses]: https://docs.oracle.com/javase/specs/jls/se17/html/jls-7.html#jls-7.7.3
+[versioning]: ./versioning.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/structuring.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/structuring.md
new file mode 100644
index 000000000..113e5ee52
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/structuring.md
@@ -0,0 +1,82 @@
+# 结构化您的模组
+
+结构化模组有利于维护、贡献并提供对底层代码库的更清晰理解。以下是一些建议，源自 Java、Minecraft 和 NeoForge。
+
+:::note
+您不必遵循下面的建议；您可以按照自己认为合适的方式结构化您的模组。然而，还是强烈建议这样做。
+:::
+
+## 包结构
+
+在构建您的模组时，选择一个独特的顶级包结构。许多程序员会为不同的类、接口等使用相同的名称。Java允许在不同的包中有相同名称的类。因此，如果两个类有相同的包和相同的名称，只有一个类会被加载，很可能会导致游戏崩溃。
+
+```
+a.jar
+ - com.example.ExampleClass
+b.jar
+ - com.example.ExampleClass // 这个类通常不会被加载
+```
+
+当涉及到加载模块时，这一点尤其相关。如果两个包在不同的模块下有同名的类文件，这将导致模组加载器在启动时崩溃，因为模组模块被导出到游戏和其他模组。
+
+```
+模块 A
+ - 包 X
+ - 类 I
+ - 类 J
+模块 B
+ - 包 X // 这个包将导致模组加载器崩溃，因为已经有一个模块导出了包 X
+ - 类 R
+ - 类 S
+ - 类 T
+```
+
+因此，您的顶级包应该是您拥有的东西：域名、电子邮件地址、网站（或子域）等。它甚至可以是您的名字或用户名，只要您能保证它在预期目标中具有唯一可识别性。此外，顶级包还应与您的[group id][group]匹配。
+
+| 类型 | 值 | 顶级包 |
+|:---------:|:--------------:|:----------------------|
+| 域名 | example.com | `com.example` |
+| 子域名 | example.github.io | `io.github.example` |
+| 电邮 | example@gmail.com | `com.gmail.example` |
+
+下一级包应该是您的模组的ID（例如，`com.example.examplemod`，其中`examplemod`是模组ID）。这将保证，除非您有两个模组ID相同的模组（这种情况永远不应该发生），否则您的包不应该有任何加载问题。
+
+您可以在[Oracle的教程页面][naming]上找到一些额外的命名约定。
+
+### 子包组织
+
+除了顶级包，强烈建议将模组的类分配到子包中。有两种主要的方法来做到这一点：
+
+* **按功能分组**：为具有共同目的的类制作子包。例如，可以将方块放在`block`下，物品放在`item`下，实体放在`entity`下等。Minecraft本身使用类似的结构（有一些例外）。
+* **按逻辑分组**：为具有共同逻辑的类制作子包。例如，如果您正在创建一个新类型的工作台，您可以将其方块、菜单、物品等放在`feature.crafting_table`下。
+
+#### 客户端、服务器和数据包
+
+通常，只针对给定侧或运行时的代码应该与其他类隔离在一个单独的子包中。例如，与[数据生成][datagen]相关的代码应该放在`data`包中，只在专用服务器上的代码应该放在`server`包中。
+
+强烈建议将[仅客户端代码][sides]
+
+隔离在`client`子包中。这是因为专用服务器无法访问Minecraft中的任何客户端专用包，并且如果您的模组试图访问它们，将会崩溃。因此，拥有一个专用包提供了一个很好的检查方法，以验证您没有在模组内跨侧访问。
+
+## 类命名方案
+
+常见的类命名方案使得更容易理解类的用途或轻松找到特定类。
+
+类通常以其类型为后缀，例如：
+
+* 一个名为 `PowerRing` 的 `Item` -> `PowerRingItem`。
+* 一个名为 `NotDirt` 的 `Block` -> `NotDirtBlock`。
+* 一个 `Oven` 的菜单 -> `OvenMenu`。
+
+:::tip
+Mojang 通常遵循类似的结构来命名所有类，除了实体。这些实体只用它们的名字表示（例如，`Pig`，`Zombie`等）。
+:::
+
+## 从多种方法中选择一种
+
+执行特定任务有许多方法：注册对象、监听事件等。通常建议使用单一方法来完成给定任务。这可以提高可读性，并避免可能发生的奇怪交互或冗余（例如，您的事件监听器运行两次）。
+
+[group]: index.md#the-group-id
+[naming]: https://docs.oracle.com/javase/tutorial/java/package/namingpkgs.html
+[datagen]: ../resources/index.md#data-generation
+[sides]: ../concepts/sides.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/versioning.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/versioning.md
new file mode 100644
index 000000000..c17930719
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gettingstarted/versioning.md
@@ -0,0 +1,100 @@
+# 版本管理
+
+本文将详细解释 Minecraft 和 NeoForge 的版本管理方式，并为模组版本提供一些建议。
+
+## Minecraft
+
+Minecraft 使用[语义化版本控制][semver]（semantic versioning，简称 "semver"），格式为 `major.minor.patch`。例如，Minecraft 1.20.2 的主版本号（major）为 1，次版本号（minor）为 20，修订号（patch）为 2。
+
+自从 2011 年 Minecraft 1.0 发布以来，Minecraft 的主版本号一直使用 `1`。在此之前，版本号方案经常变化，有诸如 `a1.1`（Alpha 1.1）、`b1.7.3`（Beta 1.7.3）甚至 `infdev` 版本，这些版本根本没有遵循明确的版本控制方案。由于 `1` 作为主版本号已经持续了十多年，并且鉴于 Minecraft 2 的内部笑话，通常认为这一情况不太可能改变。
+
+### 快照版
+
+快照版偏离了标准的 semver 方案。它们被标记为 `YYwWWa`，其中 `YY` 代表年份的最后两位数字（例如 `23`），`WW` 代表那年的周数（例如 `01`）。例如，快照 `23w01a` 是 2023 年第一周发布的快照。
+
+`a` 后缀用于同一周发布两个快照的情况（第二个快照则被命名为 `23w01b`）。Mojang 过去偶尔使用过这种方式。此外，还有像 `20w14infinite` 这样的快照，它是[2020 年无限维度愚人节玩笑][infinite]。
+
+### 预发布和候选发布版本
+
+当快照周期接近完成时，Mojang 开始发布所谓的预发布版本。预发布版本被视为功能完整的版本，专注于修复bug。它们使用 semver 格式并附加 `-preX` 后缀。例如，1.20.2 的第一个预发布版本被命名为 `1.20.2-pre1`。通常会有多个预发布版本，相应地使用 `-pre2`、`-pre3` 等后缀。
+
+类似地，当预发布周期完成时，Mojang 发布第一个候选发布版本（后缀为 `-rc1`，例如 `1.20.2-rc1`）。Mojang 的目标是发布一个候选版本，如果没有进一步的 bug 出现，则可以发布该版本。然而，如果出现意外的 bug，则可能会有 `-rc2`、`-rc3` 等版本，类似于预发布版本。
+
+## NeoForge
+
+NeoForge 使用一种调整过的 semver 系统：主版本号是 Minecraft 的次版本号，次版本号是 Minecraft 的修订号，而修订号则是“实际”的 NeoForge 版本。例如，NeoForge 20.2.59 是 Minecraft 1.20.2 的第 60 版（从 0 开始计数）。由于 `1` 作为开头的数字不太可能改变，请参见[上文][minecraft]了解原因。
+
+NeoForge 的一些位置还使用了[Maven 版本范围][mvr]，例如 [`mods.toml`][modstoml] 文件中的 Minecraft 和 NeoForge 版本范围。这些主要与 semver 兼容，但有些例外（例如，它不考虑 `pre` 标签）。
+
+## 模组
+
+没有最佳的版本控制系统。不同的开发风格、项目范围等都会影响选择哪种版本控制系统的决定。有时，也可以组合使用多种版本控制系统。本节试图概述一些
+
+常用的版本控制系统，并提供现实生活中的示例。
+
+通常，模组的文件名看起来像 `modid-.jar`。所以如果我们的模组ID是 `examplemod`，版本是 `1.2.3`，我们的模组文件将被命名为 `examplemod-1.2.3.jar`。
+
+:::note
+版本控制系统是建议，而不是严格执行的规则。特别是关于何时更改（"bump"）版本，以及以何种方式更改。如果您想使用不同的版本控制系统，没有人会阻止您。
+:::
+
+### 语义化版本控制
+
+语义化版本控制（"semver"）包括三个部分：`major.minor.patch`。当对代码库进行重大更改时，主版本号会提升，这通常与重大新功能和错误修复相关。次版本号在引入次要功能时提升，修订号只包括错误修复时提升。
+
+通常认为任何 `0.x.x` 版本都是开发版本，而第一个（完整）发布版本应该提升到 `1.0.0`。
+
+"次要功能提升次版本号，错误修复提升修订号" 的规则在实践中经常被忽视。一个流行的例子是 Minecraft 本身，它通过次版本号进行重大功能更新，通过修订号进行次要功能更新，并在快照中修复错误（见上文）。
+
+根据模组更新的频率，版本号可能会有所增减。例如，[Supplementaries][supplementaries]目前的版本为`2.6.31`（撰写本文时）。在`patch`版本中，出现三位或四位数字的情况完全有可能。
+
+### “简化”与“扩展”语义化版本控制
+
+有时候，我们可以看到只有两个数字的语义化版本控制，这种是一种“简化”语义化版本控制，或称为“2部分”语义化版本控制。这种版本号只包含`major.minor`模式。它通常用于只添加几个简单物体的小型模组，这类模组很少需要更新（除了Minecraft版本更新），常常永远停留在`1.0`版本。
+
+而“扩展”语义化版本控制，或称为“4部分”语义化版本控制，包括四个数字（比如`1.0.0.0`）。根据模组的不同，其格式可能是`major.api.minor.patch`，或`major.minor.patch.hotfix`，或是完全不同的格式——没有统一的标准方式。
+
+对于`major.api.minor.patch`，`major`版本与`api`版本是分离的。这意味着`major`（功能）位和`api`位可以独立提升。这种方式通常用于那些提供API供其他模组开发者使用的模组。例如，[Mekanism][mekanism]当前的版本是10.4.5.19（撰写本文时）。
+
+对于`major.minor.patch.hotfix`，则是将修订级别分为两部分。这是[Create][create]模组使用的方法，目前版本为0.5.1f（撰写本文时）。注意，Create模组将hotfix表示为一个字母，而不是第四个数字，以保持与常规语义化版本控制的兼容。
+
+:::info
+简化语义化版本控制、扩展语义化版本控制、2部分语义化版本控制和4部分语义化版本控制并非官方术语或标准化格式。
+:::
+
+### Alpha、Beta、Release阶段
+
+像Minecraft本身一样，模组开发通常也会经历软件工程中熟知的`alpha`/`beta`/`release`阶段，其中`alpha`代表不稳定/实验版本（有时也称为`experimental`或`snapshot`），`beta`代表半稳定版本，而`release`则代表稳定版本（有时用`stable`代替`release`）。
+
+一些模组利用它们的主要版本号来表示Minecraft版本的更新。例如，[JEI][jei]使用`13.x.x.x`表示Minecraft 1.19.2，`14.x.x.x`表示1.19.4，以及`15.x.x.x`表示1.20.1（不存在1.19.3和1.20.0的版本）。其他一些模组则在模组名称后附加标签，例如[Minecolonies][minecolonies]模组，当前版本为`1.1.328-BETA`（撰写本文时）。
+
+### 包含Minecraft版本
+
+在模组文件名中包含其适用的Minecraft版本是常见做法。这使得最终用户更容易确定模组适用于哪个版本的Minecraft。这通常发生在模组版本之前或之后，前者比后者更常见。例如，JEI的最新版本`16.0.0.28`（撰写本文时）
+
+适用于1.20.2，可能表示为`jei-1.20.2-16.0.0.28`或`jei-16.0.0.28-1.20.2`。
+
+### 包含模组加载器
+
+正如您可能知道的那样，NeoForge并非唯一的模组加载器，许多模组开发者在多个平台上开发。因此，需要一种方法来区分同一个模组、相同版本但适用于不同模组加载器的两个文件。
+
+通常，这是通过在名称中包含模组加载器来实现的。例如，`jei-neoforge-1.20.2-16.0.0.28`、`jei-1.20.2-neoforge-16.0.0.28`或`jei-1.20.2-16.0.0.28-neoforge`都是有效的命名方式。对于其他模组加载器，`neoforge`部分会被替换为`forge`、`fabric`、`quilt`或您可能正在使用的其他模组加载器。
+
+### Maven备注
+
+Maven——用于依赖托管的系统，其版本控制系统在一些细节上与语义化版本控制不同（尽管基本的`major.minor.patch`模式仍然相同）。NeoForge的某些部分使用了相关的[Maven版本范围（MVR）][mvr]系统。在选择您的版本控制方案时，您应确保它与MVR兼容，否则模组将无法依赖您模组的特定版本！
+
+[create]: https://www.curseforge.com/minecraft/mc-mods/create
+[infinite]: https://minecraft.wiki/w/Java_Edition_20w14∞
+[jei]: https://www.curseforge.com/minecraft/mc-mods/jei
+[mekanism]: https://www.curseforge.com/minecraft/mc-mods/mekanism
+[minecolonies]: https://www.curseforge.com/minecraft/mc-mods/minecolonies
+[minecraft]: #minecraft
+[modstoml]: modfiles.md#modstoml
+[mvr]: https://maven.apache.org/enforcer/enforcer-rules/versionRanges.html
+[mvr]: https://maven.apache.org/ref/3.5.2/maven-artifact/apidocs/org/apache/maven/artifact/versioning/ComparableVersion.html
+[neoforge]: #neoforge
+[pre]: #pre-releases
+[rc]: #release-candidates
+[semver]: https://semver.org/
+[supplementaries]: https://www.curseforge.com/minecraft/mc-mods/supplementaries
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/_category_.json
new file mode 100644
index 000000000..59cfbca67
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "GUIs"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/menus.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/menus.md
new file mode 100644
index 000000000..3d3c0513b
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/menus.md
@@ -0,0 +1,351 @@
+根据您的要求，这里是对上述Markdown文档进行的中文翻译，尽量使语言流畅且专业：
+
+---
+
+# 菜单
+
+菜单是图形用户界面（GUI）后端的一种类型，它们处理与某些数据持有者交互的逻辑。菜单本身并不持有数据。它们是视图，允许用户间接修改内部数据持有者的状态。因此，数据持有者不应直接与任何菜单耦合，而是传递数据引用以调用和修改。
+
+## `MenuType`
+
+菜单是动态创建和删除的，因此它们不是注册对象。因此，另一个工厂对象被注册以便轻松创建和引用菜单的*类型*。对于一个菜单，这些就是`MenuType`。
+
+`MenuType`必须[注册]。
+
+### `MenuSupplier`
+
+通过将`MenuSupplier`和`FeatureFlagSet`传递给其构造函数来创建`MenuType`。`MenuSupplier`代表一个函数，它接受容器的id和查看菜单的玩家的库存，返回一个新创建的[`AbstractContainerMenu`][acm]。
+
+```java
+// 对于某个DeferredRegister> REGISTER
+public static final RegistryObject> MY_MENU = REGISTER.register("my_menu", () -> new MenuType(MyMenu::new, FeatureFlags.DEFAULT_FLAGS));
+
+// 在MyMenu中，一个AbstractContainerMenu子类
+public MyMenu(int containerId, Inventory playerInv) {
+ super(MY_MENU.get(), containerId);
+ // ...
+}
+```
+
+:::note
+容器标识符对每个玩家是唯一的。这意味着在两个不同的玩家上相同的容器id将代表两个不同的菜单，即使他们正在查看同一个数据持有者。
+:::
+
+`MenuSupplier`通常负责在客户端创建菜单，使用虚拟数据引用来存储和交互服务器数据持有者同步的信息。
+
+### `IContainerFactory`
+
+如果客户端需要额外的信息（例如，数据持有者在世界中的位置），则可以使用子类`IContainerFactory`。除了容器id和玩家库存外，这还提供了一个`FriendlyByteBuf`，可以存储从服务器发送的额外信息。可以通过`IForgeMenuType#create`使用`IContainerFactory`创建`MenuType`。
+
+```java
+// 对于某个DeferredRegister> REGISTER
+public static final RegistryObject> MY_MENU_EXTRA = REGISTER.register("my_menu_extra", () -> IForgeMenuType.create(MyMenu::new));
+
+// 在MyMenuExtra中，一个AbstractContainerMenu子类
+public MyMenuExtra(int containerId, Inventory playerInv, FriendlyByteBuf extraData) {
+ super(MY_MENU_EXTRA.get(), containerId);
+ // 存储缓冲区的额外数据
+ // ...
+}
+```
+
+## `AbstractContainerMenu`
+
+所有菜单都继承自`AbstractContainerMenu`。一个菜单需要两个参数，[`MenuType`][mt]，代表菜单本身的类型，以及容器id，代表当前访问者的菜单的唯一标识符。
+
+:::caution
+玩家一次最多只能打开100个唯一的菜单。
+:::
+
+每个菜单应包含两个构造函数：一个用于在服务器上初始化菜单，另一个用于在客户端初始化菜单。用于初始化客户端菜单的构造函数是提供给`MenuType`的。
+
+```java
+// 客户端菜单构造函数
+public MyMenu(int containerId, Inventory playerInventory) {
+ this(containerId, playerInventory);
+}
+
+// 服务器菜单构造函数
+public MyMenu(int containerId, Inventory playerInventory) {
+ // ...
+}
+```
+
+每个菜单实现必须实现两个方法：`#stillValid`和[`#quickMoveStack`][qms]。
+
+### `#stillValid`和`ContainerLevelAccess`
+
+`#stillValid`
+
+确定是否应该为给定玩家保持菜单打开。这通常指向静态的`#stillValid`，它需要一个`ContainerLevelAccess`、玩家和菜单所附属的`Block`。客户端菜单必须始终为此方法返回`true`，这是静态`#stillValid`的默认设置。此实现检查玩家是否在数据存储对象所在位置的八个方块范围内。
+
+`ContainerLevelAccess`提供了当前级别和块所在位置的封闭范围。在服务器上构造菜单时，可以通过调用`ContainerLevelAccess#create`创建新的访问权限。客户端菜单构造函数可以传递`ContainerLevelAccess#NULL`，这将不做任何事。
+
+```java
+// 客户端菜单构造函数
+public MyMenuAccess(int containerId, Inventory playerInventory) {
+ this(containerId, playerInventory, ContainerLevelAccess.NULL);
+}
+
+// 服务器菜单构造函数
+public MyMenuAccess(int containerId, Inventory playerInventory, ContainerLevelAccess access) {
+ // ...
+}
+
+// 假设此菜单附属于RegistryObject MY_BLOCK
+@Override
+public boolean stillValid(Player player) {
+ return AbstractContainerMenu.stillValid(this.access, player, MY_BLOCK.get());
+}
+```
+
+### 数据同步
+
+需要在服务器和客户端上存在某些数据才能显示给玩家。为此，菜单实现了基本的数据同步层，以便每当当前数据与上次同步到客户端的数据不匹配时进行检查。对于玩家来说，这每个游戏刻都会检查。
+
+Minecraft默认支持两种数据同步形式：通过`Slot`的`ItemStack`和通过`DataSlot`的整数。`Slot`和`DataSlot`是持有可以在屏幕上被玩家修改的数据存储引用的视图，前提是动作有效。这些可以通过在构造函数中的`#addSlot`和`#addDataSlot`添加到菜单中。
+
+:::note
+由于NeoForge不推荐使用`Container`，转而使用[`IItemHandler`能力][cap]，下文将围绕使用这种能力的变体：`SlotItemHandler`进行解释。
+:::
+
+`SlotItemHandler`包含四个参数：代表堆栈所在库存的`IItemHandler`，此槽特别代表的堆栈的索引，以及槽在屏幕上相对于`AbstractContainerScreen#leftPos`和`#topPos`的左上位置的x和y位置。客户端菜单构造函数应始终提供一个相同大小的空库存实例。
+
+在大多数情况下，首先添加菜单包含的任何槽，然后是玩家的库存，最后是玩家的快捷栏。要从菜单访问任何单独的`Slot`，必须根据添加槽的顺序计算索引。
+
+`DataSlot`是一个抽象类，应实现getter和setter以引用数据存储对象中存储的数据。客户端菜单构造函数应始终通过`DataSlot#standalone`提供一个新实例。
+
+这些，连同槽一起，应在每次初始化新菜单时重新创建。
+
+:::caution
+尽管`DataSlot`存储一个整数，但由于其通过网络发送值的方式，它实际上限制为一个**短整型**（-32768至32767）。整数的16个高阶位被忽略。
+:::
+
+```java
+// 假设我们有一个大小为5的数据对象库存
+// 假设每次服务器菜单初始化时都构建了一个DataSlot
+
+// 客户端菜单构造函数
+public MyMenuAccess(int containerId, Inventory playerInventory) {
+ this(containerId, playerInventory, new ItemStackHandler(5), DataSlot.standalone());
+}
+
+// 服务器菜单构造函数
+public MyMenuAccess(int containerId, Inventory playerInventory, IItemHandler dataInventory, DataSlot dataSingle) {
+ // 检查数据库存大小是否为某个固定值
+ // 然后，为数据库存添加槽位
+ this.addSlot(new SlotItemHandler(dataInventory, /*...*/));
+
+ // 为玩家库存添加槽位
+ this.addSlot(new Slot(playerInventory, /*...*/));
+
+ // 为处理的整数添加数据槽位
+ this.addDataSlot(dataSingle);
+
+ // ...
+}
+```
+
+#### `ContainerData`
+
+如果需要将多个整数同步到客户端，可以使用`ContainerData`来引用这些整数。这个接口功能类似于索引查找，其中每个索引代表一个不同的整数。如果将`ContainerData`通过`#addDataSlots`方法添加到菜单中，则可以直接在数据对象本身中构建`ContainerData`。该方法为接口指定的数据量创建新的`DataSlot`。客户端菜单构造函数应始终通过`SimpleContainerData`提供新实例。
+
+```java
+// 假设我们有一个大小为3的ContainerData
+
+// 客户端菜单构造函数
+public MyMenuAccess(int containerId, Inventory playerInventory) {
+ this(containerId, playerInventory, new SimpleContainerData(3));
+}
+
+// 服务器菜单构造函数
+public MyMenuAccess(int containerId, Inventory playerInventory, ContainerData dataMultiple) {
+ // 检查ContainerData大小是否为某个固定值
+ checkContainerDataCount(dataMultiple, 3);
+
+ // 为处理的整数添加数据槽位
+ this.addDataSlots(dataMultiple);
+
+ // ...
+}
+```
+
+:::caution
+由于`ContainerData`委托给`DataSlot`，这些也被限制为一个**短整型**（-32768至32767）。
+:::
+
+#### `#quickMoveStack`
+
+`#quickMoveStack`是任何菜单必须实现的第二个方法。每当一个堆栈被快速移动或通过Shift点击从其当前槽中移出时，就会调用此方法，直到堆栈完全移出其前一个槽或没有其他地方可以放置堆栈为止。该方法返回被快速移动的槽中的堆栈副本。
+
+通常使用 `#moveItemStackTo` 在插槽之间移动堆叠物品，该方法将堆叠物品移动到第一个可用的插槽。它接受要移动的堆叠物品、要尝试将堆叠物品移动到的第一个插槽索引（包括）、最后一个插槽索引（不包括），以及是否从第一个到最后一个插槽进行检查（当为 `false` 时）或从最后一个到第一个插槽进行检查（当为 `true` 时）。
+
+在 Minecraft 的各种实现中，该方法在逻辑上相当一致：
+
+```java
+// 假设我们有一个大小为 5 的数据存储库
+// 存储库有 4 个输入插槽（索引 1 - 4），输出到一个结果插槽（索引 0）
+// 我们还有 27 个玩家存储库插槽和 9 个快捷栏插槽
+// 因此，实际插槽的索引如下：
+// - 数据存储库：结果（0）、输入（1 - 4）
+// - 玩家存储库（5 - 31）
+// - 玩家快捷栏（32 - 40）
+@Override
+public ItemStack quickMoveStack(Player player, int quickMovedSlotIndex) {
+ // 快速移动的插槽堆叠物品
+ ItemStack quickMovedStack = ItemStack.EMPTY;
+ // 快速移动的插槽
+ Slot quickMovedSlot = this.slots.get(quickMovedSlotIndex)
+
+ // 如果插槽在有效范围内且插槽不为空
+ if (quickMovedSlot != null && quickMovedSlot.hasItem()) {
+ // 获取要移动的原始堆叠物品
+ ItemStack rawStack = quickMovedSlot.getItem();
+ // 将插槽堆叠设置为原始堆叠的副本
+ quickMovedStack = rawStack.copy();
+
+ /*
+ 以下快速移动逻辑可以简化为在数据存储库中，尝试移动到玩家存储库/快捷栏，反之亦然，对于无法转换数据的容器（例如箱子）。
+ */
+
+ // 如果快速移动在数据存储库结果插槽上执行
+ if (quickMovedSlotIndex == 0) {
+ // 尝试将结果插槽移动到玩家存储库/快捷栏
+ if (!this.moveItemStackTo(rawStack, 5, 41, true)) {
+ // 如果无法移动，不再快速移动
+ return ItemStack.EMPTY;
+ }
+
+ // 对结果插槽快速移动执行逻辑
+ slot.onQuickCraft(rawStack, quickMovedStack);
+ }
+ // 否则如果快速移动在玩家存储库或快捷栏插槽上执行
+ else if (quickMovedSlotIndex >= 5 && quickMovedSlotIndex < 41) {
+ // 尝试将玩家存储库/快捷栏插槽移动到数据存储库输入插槽
+ if (!this.moveItemStackTo(rawStack, 1, 5, false)) {
+ // 如果无法移动且在玩家存储库插槽中，尝试移动到快捷栏
+ if (quickMovedSlotIndex < 32) {
+ if (!this.moveItemStackTo(rawStack, 32, 41, false)) {
+ // 如果无法移动，不再快速移动
+ return ItemStack.EMPTY;
+ }
+ }
+ // 否则尝试将快捷栏移动到玩家存储库插槽
+ else if (!this.moveItemStackTo(rawStack, 5, 32, false)) {
+ // 如果无法移动，不再快速移动
+ return ItemStack.EMPTY;
+ }
+ }
+ }
+ // 否则如果快速移动在数据存储库输入插槽上，则尝试移动到玩家存储库/快捷栏
+ else if (!this.moveItemStackTo(rawStack, 5, 41, false)) {
+ // 如果无法移动，不再快速移动
+ return ItemStack.EMPTY;
+ }
+
+ if (rawStack.isEmpty()) {
+ // 如果原始堆叠完全移出插槽，则将插槽设置为空堆叠
+ quickMovedSlot.set(ItemStack.EMPTY);
+ } else {
+ // 否则，通知插槽堆叠数量已更改
+ quickMovedSlot.setChanged();
+ }
+
+ /*
+ 如果菜单不表示可以转换堆叠的容器（例如箱子），则可以删除以下 if 语句和 Slot#onTake 调用。
+ */
+ if (rawStack.getCount() == quickMovedStack.getCount()) {
+ // 如果原始堆叠无法移动到另一个插槽，则不再快速移动
+ return ItemStack.EMPTY;
+ }
+ // 执行堆叠剩余部分后移动的逻辑
+ quickMovedSlot.onTake(player, rawStack);
+ }
+
+ return quickMovedStack; // 返回插槽堆叠
+}
+```
+
+## 打开菜单
+
+一旦菜单类型已注册，菜单本身已完成，并且 [screen] 已附加，玩家就可以打开菜单。可以通过在逻辑服务器上调用 `NetworkHooks#openScreen` 来打开菜单。该方法接受打开菜单的玩家、服务器端菜单的 `MenuProvider`，以及可选的 `FriendlyByteBuf`，如果需要向客户端同步额外数据。
+
+:::note
+只有在使用 [`IContainerFactory`][icf] 创建菜单类型时，才应使用带有 `FriendlyByteBuf` 参数的 `NetworkHooks
+
+#openScreen`。
+:::
+
+#### `MenuProvider`
+
+`MenuProvider` 是一个包含两个方法的接口：`#createMenu`，用于创建菜单的服务器实例，以及 `#getDisplayName`，返回包含菜单标题的组件以传递给 [screen]。`#createMenu` 方法包含三个参数：菜单的容器 ID、打开菜单的玩家的库存，以及打开菜单的玩家。
+
+可以使用 `SimpleMenuProvider` 轻松创建 `MenuProvider`，它接受一个方法引用来创建服务器菜单和菜单的标题。
+
+```java
+// 在某些实现中
+NetworkHooks.openScreen(serverPlayer, new SimpleMenuProvider(
+ (containerId, playerInventory, player) -> new MyMenu(containerId, playerInventory),
+ Component.translatable("menu.title.examplemod.mymenu")
+));
+```
+
+### 常见实现
+
+通常通过某种玩家交互方式（例如右键单击方块或实体）打开菜单。
+
+#### 方块实现
+
+方块通常通过覆盖 `BlockBehaviour#use` 来实现菜单。如果在逻辑客户端上，交互返回 `InteractionResult#SUCCESS`。否则，打开菜单并返回 `InteractionResult#CONSUME`。
+
+`MenuProvider` 应该通过覆盖 `BlockBehaviour#getMenuProvider` 来实现。原版方法使用此方法在旁观模式下查看菜单。
+
+```java
+// 在某个 Block 子类中
+@Override
+public MenuProvider getMenuProvider(BlockState state, Level level, BlockPos pos) {
+ return new SimpleMenuProvider(/* ... */);
+}
+
+@Override
+public InteractionResult use(BlockState state, Level level, BlockPos pos, Player player, InteractionHand hand, BlockHitResult result) {
+ if (!level.isClientSide && player instanceof ServerPlayer serverPlayer) {
+ NetworkHooks.openScreen(serverPlayer, state.getMenuProvider(level, pos));
+ }
+ return InteractionResult.sidedSuccess(level.isClientSide);
+}
+```
+
+:::note
+这是实现逻辑的最简单方法，不是唯一的方法。如果希望方块仅在满足某些条件时打开菜单，则需要事先将一些数据同步到客户端，以返回 `InteractionResult#PASS` 或 `#FAIL`，如果条件不满足。
+:::
+
+#### 生物实现
+
+生物通常通过覆盖 `Mob#mobInteract` 来实现菜单。这与方块实现类似，唯一的区别是生物本身应该实现 `MenuProvider` 以支持旁观模式查看。
+
+```java
+public class MyMob extends Mob implements MenuProvider {
+ // ...
+
+ @Override
+ public InteractionResult mobInteract(Player player, InteractionHand hand) {
+ if (!this.level.isClientSide && player instanceof ServerPlayer serverPlayer) {
+ NetworkHooks.openScreen(serverPlayer, this);
+ }
+ return InteractionResult.sidedSuccess(this.level.isClientSide);
+ }
+}
+```
+
+:::note
+再次强调，这是实现逻辑的最简单方法，不是唯一的方法。
+:::
+
+[registered]: ../concepts/registries.md#methods-for-registering
+[acm]: #abstractcontainermenu
+[mt]: #menutype
+[qms]: #quickmovestack
+[cap]: ../datastorage/capabilities.md#neoforge-provided-capabilities
+[screen]: ./screens.md
+[icf]: #icontainerfactory
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/screens.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/screens.md
new file mode 100644
index 000000000..8824e99b5
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/gui/screens.md
@@ -0,0 +1,346 @@
+## 屏幕
+
+在 Minecraft 中，屏幕通常是所有图形用户界面（GUI）的基础，用于接收用户输入、在服务器上验证输入，并将结果同步回客户端。它们可以与[菜单](menus)结合使用，创建用于类似库存的视图的通信网络，或者它们可以是独立的，由模组开发者通过自己的[网络](../networking/index.md)实现来处理。
+
+屏幕由许多部分组成，这使得理解“屏幕”在 Minecraft 中实际上是什么变得困难。因此，本文档将介绍屏幕的每个组件以及它是如何应用的，然后讨论屏幕本身。
+
+## 相对坐标
+
+无论何时渲染任何东西，都需要一些标识符来指定其出现的位置。使用许多抽象化，Minecraft 的大多数渲染调用在一个坐标平面上接收 x、y 和 z 值。X 值从左到右增加，y 值从上到下增加，z 值从远到近增加。但是，这些坐标不是固定的范围。它们可以根据屏幕的大小和在选项中指定的比例而变化。因此，必须特别注意确保在渲染时的坐标值相对于可变的屏幕大小适当缩放。
+
+有关如何使您的坐标相对的信息将在[屏幕](#屏幕)部分中提供。
+
+:::caution
+如果选择使用固定坐标或不正确地缩放屏幕，则渲染的对象可能会看起来奇怪或错位。检查坐标是否正确相对化的简单方法是单击您的视频设置中的“GUI 比例”按钮。此值用作除数以确定 GUI 应以哪个比例渲染。
+:::
+
+## GUI 图形
+
+Minecraft 中渲染的任何 GUI 通常都是使用 `GuiGraphics` 进行的。`GuiGraphics` 是几乎所有渲染方法的第一个参数；它包含用于渲染常用对象的基本方法。这些方法分为五类：彩色矩形、字符串和纹理、物品和工具提示。还有一个用于渲染组件的额外方法（`#enableScissor` / `#disableScissor`）。`GuiGraphics` 还公开了 `PoseStack`，它应用了必要的转换，以便将组件正确渲染到屏幕上。此外，颜色采用[ARGB](https://en.wikipedia.org/wiki/RGBA_color_model#ARGB32)格式。
+
+### 彩色矩形
+
+通过位置颜色着色器绘制彩色矩形。可以绘制三种类型的彩色矩形。
+
+首先是水平和垂直的一像素宽线，分别是 `#hLine` 和 `#vLine`。`#hLine` 接受两个 x 坐标，定义了左侧和右侧（包括在内），顶部 y 坐标和颜色。`#vLine` 接受左侧 x 坐标、两个 y 坐标，定义了顶部和底部（包括在内），以及颜色。
+
+其次是 `#fill` 方法，它绘制一个矩形到屏幕上。线方法内部调用此方法。它接受左侧 x 坐标、顶部 y 坐标、右侧 x 坐标、底部 y 坐标和颜色。
+
+最后是 `#fillGradient` 方法，它绘制一个具有垂直渐变的矩形。它接受右侧 x 坐标、底部 y 坐标、左侧 x 坐标、顶部 y 坐标、z 坐标、底部和顶部颜色。
+
+### 字符串
+
+字符串通过其 `Font` 绘制，通常包含正常、透明和偏移模式的自己的着色器。可以渲染两种对齐的字符串，每种字符串都带有背景阴影：左对齐字符串 (`#drawString`) 和居中对齐字符串 (`#drawCenteredString`)。这两种方法都接受要绘制字符串的字体、字符串本身、x 坐标（分别是字符串的左侧或中心）、顶部 y 坐标和颜色。
+
+:::note
+字符串通常应该作为 [`Component`](../resources/client/i18n.md#components) 传递，因为它们处理各种用例，包括该方法的其他两个重载。
+:::
+
+### 纹理
+
+纹理通过贴图绘制，因此方法名为 `#blit`，在这种情况下，它复制图像的
+
+位并直接将其绘制到屏幕上。这些是通过位置纹理着色器绘制的。虽然有许多不同的 `#blit` 重载，但我们只讨论两种静态 `#blit`。
+
+第一个静态 `#blit` 接受六个整数，假定正在渲染的纹理位于一个 256 x 256 的 PNG 文件中。它接受左侧 x 和顶部 y 屏幕坐标，PNG 内部的左侧 x 和顶部 y 坐标，以及要渲染的图像的宽度和高度。
+
+:::tip
+必须指定 PNG 文件的大小，以便将坐标归一化为获取关联的 UV 值。
+:::
+
+第一个调用的静态 `#blit` 将此扩展为九个整数，仅假定图像位于 PNG 文件中。它接受左侧 x 和顶部 y 屏幕坐标，z 坐标（称为 blit 偏移量），PNG 内部的左侧 x 和顶部 y 坐标，要渲染的图像的宽度和高度，以及 PNG 文件的宽度和高度。
+
+#### Blit 偏移量
+
+在渲染纹理时，z 坐标通常设置为 blit 偏移量。偏移量负责在查看屏幕时正确分层渲染。具有较小 z 坐标的渲染在背景中渲染，反之，具有较大 z 坐标的渲染在前景中渲染。可以通过 `#translate` 方法直接在 `PoseStack` 本身上设置 z 偏移量。一些 `GuiGraphics` 方法内部应用了一些基本的偏移逻辑（例如物品渲染）。
+
+:::caution
+设置 blit 偏移量时，必须在渲染对象完成后重置它。否则，屏幕中的其他对象可能会以不正确的层次渲染，导致图形问题。建议在平移前推送当前姿势，然后在所有以偏移量渲染的对象完成后弹出。
+:::
+
+## 可渲染对象
+
+`Renderable` 实际上是指可以被渲染的对象。这些包括屏幕、按钮、聊天框、列表等。`Renderable` 只有一个方法：`#render`。此方法接受用于将事物渲染到屏幕上的 `GuiGraphics`、鼠标的 x 和 y 位置（按相对屏幕大小缩放）、以及帧之间的时间差（自上一帧以来经过了多少个 tick）。
+
+一些常见的可渲染对象是屏幕和“小部件”：通常渲染在屏幕上的可交互元素，如 `Button`、它的子类型 `ImageButton`，以及 `EditBox`，用于在屏幕上输入文本。
+
+## GUI 事件侦听器
+
+Minecraft 中呈现的任何屏幕都实现了 `GuiEventListener`。`GuiEventListener` 负责处理用户与屏幕的交互。这些包括鼠标（移动、点击、释放、拖动、滚动、悬停）和键盘（按下、释放、键入）的输入。每个方法返回关联动作是否成功地影响了屏幕。按钮、聊天框、列表等小部件也实现了此接口。
+
+### 容器事件处理程序
+
+与 `GuiEventListener` 几乎同义的是它们的子类型：`ContainerEventHandler`。这些负责处理在包含小部件的屏幕上的用户交互，管理当前聚焦的是哪个小部件以及如何应用相关交互。`ContainerEventHandler` 添加了三个额外功能：可交互的子元素、拖动和聚焦。
+
+事件处理程序保存了子元素，用于确定元素的交互顺序。在鼠标事件处理程序中（不包括拖动），鼠标悬停在上面的第一个子元素将执行其逻辑。
+
+通过鼠标拖动元素，通过 `#mouseClicked` 和 `#mouseReleased` 实现更精确的逻辑。
+
+聚焦允许首先检查特定的子元素，并在事件执行期间处理它，例如在键盘事件或拖动鼠标期间。焦点通常通过 `#setFocused` 设置。此外，可以使用 `#nextFocusPath` 循环可交互的子元素，选择基于传递的 `FocusNavigationEvent` 的子元素。
+
+:::note
+屏幕通过 `AbstractContainerEventHandler` 实现了 `ContainerEventHandler`，它添加了拖动和聚焦子元素的设置和获取逻辑。
+:::
+
+## NarratableEntry
+
+`NarratableEntry` 是可以通过 Minecraft 的辅助功能叙述功能讲述的元素。每个元素可以根据悬停或选择的内容提供不同的叙述，通常由焦点、悬停，然后是所有其他情况优先。
+
+`NarratableEntry` 有三个方法：确定元素的优先级的一个方法 (`#narrationPriority`)，确定是否说出叙述的一个方法 (`#isActive`)，最后是向其关联输出提供叙述的一个方法 (`#updateNarration`)。
+
+:::note
+Minecraft 中的所有小部件都是 `NarratableEntry`，因此通常不需要手动实现它，如果使用可用的子类型。
+:::
+
+## 屏幕子类型
+
+有了上述所有知识，就可以构建一个基本的屏幕了。为了更方便理解，屏幕的组件将按照它们通常出现的顺序而被提及。
+
+首先，所有的屏幕都需要一个组件 `Component` 来表示屏幕的标题。这个组件通常由其子类型绘制到屏幕上。它仅在基本屏幕中用于叙述消息。
+
+```java
+// 在某个屏幕的子类中
+public MyScreen(Component title) {
+ super(title);
+}
+```
+
+### 初始化
+
+屏幕初始化后，将调用 `#init` 方法。`#init` 方法设置屏幕的初始设置，从 `ItemRenderer` 和 `Minecraft` 实例到由游戏缩放的相对宽度和高度。在这个方法中进行任何设置，比如添加小部件或预计算相对坐标。如果游戏窗口大小改变，将通过调用 `#init` 方法来重新初始化屏幕。
+
+有三种方法可以向屏幕添加小部件，每种方法都有不同的作用：
+
+方法 | 描述
+:---: | :---
+`#addWidget` | 添加一个可交互且叙述的小部件，但不渲染。
+`#addRenderableOnly` | 添加一个仅渲染的小部件；不可交互也不叙述。
+`#addRenderableWidget` | 添加一个既可交互、叙述又可渲染的小部件。
+
+通常情况下，最常用的是 `#addRenderableWidget`。
+
+```java
+// 在某个屏幕的子类中
+@Override
+protected void init() {
+ super.init();
+
+ // 添加小部件和预计算的值
+ this.addRenderableWidget(new EditBox(/* ... */));
+}
+```
+
+### 屏幕更新
+
+屏幕也会使用 `#tick` 方法进行更新，以执行一些用于渲染目的的客户端逻辑。最常见的示例是用于闪烁光标的 `EditBox`。
+
+```java
+// 在某个屏幕的子类中
+@Override
+public void tick() {
+ super.tick();
+
+ // 添加 EditBox 中的更新逻辑
+ this.editBox.tick();
+}
+```
+
+### 输入处理
+
+由于屏幕是 `GuiEventListener` 的子类型，输入处理程序也可以被覆盖，例如处理特定的[按键][keymapping]逻辑。
+
+### 屏幕渲染
+
+最后，屏幕通过作为 `Renderable` 子类型而提供的 `#render` 方法进行渲染。正如前面提到的，`#render` 方法在每一帧绘制屏幕上的所有内容，比如背景、小部件、工具提示等。默认情况下，`#render` 方法只会将小部件渲染到屏幕上。
+
+屏幕中通常不由子类型处理的两个最常见的渲染内容是背景和工具提示。
+
+背景可以使用 `#renderBackground` 进行渲染，其中一个方法接受一个 v 偏移量，用于在渲染屏幕时绘制选项背景，当背后的级别无法显示时使用。
+
+工具提示通过 `GuiGraphics#renderTooltip` 或 `GuiGraphics#renderComponentTooltip` 进行渲染，它们可以接受正在渲染的文本组件、可选的自定义工具提示组件以及工具提示应该在屏幕上渲染的 x / y 相对坐标。
+
+```java
+// 在某个屏幕的子类中
+
+// mouseX 和 mouseY 表示光标在屏幕上的缩放坐标
+@Override
+public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+ // 通常首先渲染背景
+ this.renderBackground(graphics);
+
+ // 在小部件之前渲染东西（背景纹理）
+
+ // 如果这是屏幕的直接子类，则渲染小部件
+ super.render(graphics, mouseX, mouseY, partialTick);
+
+ // 在小部件之后渲染东西（工具提示）
+}
+```
+
+### 关闭屏幕
+
+当屏幕关闭时，两个方法处理清理工作：`#onClose` 和 `#removed`。
+
+`#onClose` 在用户输入关闭当前屏幕时调用。通常用作销毁和保存屏幕内部流程的回调。这包括向服务器发送数据包。
+
+`#removed` 在屏幕改变之前调用，并释放给垃圾收集器。这处理任何在屏幕打开之前未重置回初始状态的内容。
+
+```java
+// 在某个屏幕的子类中
+
+@Override
+public void onClose() {
+ // 在这里停止任何处理程序
+
+ // 最后调用，以防干扰覆盖
+ super.onClose();
+}
+
+@Override
+public void removed() {
+ // 在这里重置初始状态
+
+ // 最后调用，以防干扰覆盖
+ super.removed()
+;}
+```
+
+## `AbstractContainerScreen`
+
+如果一个屏幕直接附加到一个[菜单][menus]上，则应该使用 `AbstractContainerScreen` 的子类。`AbstractContainerScreen` 作为菜单的渲染器和输入处理程序，并包含与插槽同步和交互的逻辑。因此，通常只需要覆盖或实现两个方法，就可以有一个可工作的容器屏幕。再次强调，为了更易于理解，容器屏幕的组件将按照它们通常出现的顺序进行说明。
+
+通常，`AbstractContainerScreen` 需要三个参数：被打开的容器菜单（由泛型 `T` 表示）、玩家库存（仅用于显示名称
+
+）和屏幕本身的标题。在这里，可以设置一些定位字段：
+
+字段 | 描述
+:---: | :---
+`imageWidth` | 背景使用的纹理的宽度。这通常位于一个 256 x 256 的 PNG 内，默认为 176。
+`imageHeight` | 背景使用的纹理的高度。这通常位于一个 256 x 256 的 PNG 内，默认为 166。
+`titleLabelX` | 屏幕标题将被渲染的相对 x 坐标。
+`titleLabelY` | 屏幕标题将被渲染的相对 y 坐标。
+`inventoryLabelX` | 玩家库存名称将被渲染的相对 x 坐标。
+`inventoryLabelY` | 玩家库存名称将被渲染的相对 y 坐标。
+
+:::caution
+在前面的部分中，提到应该在 `#init` 方法中设置预计算的相对坐标。这仍然适用，因为这里提到的值不是预计算的坐标，而是静态值和相对化的坐标。
+
+图像值是静态且不变的，因为它们代表背景纹理的大小。为了在渲染时更方便，`#init` 方法中预计算了两个附加值 (`leftPos` 和 `topPos`)，标记了背景将被渲染的左上角位置。标签坐标是相对于这些值的。
+
+`leftPos` 和 `topPos` 也被用作渲染背景的便捷方式，因为它们已经表示传递到 `#blit` 方法的位置。
+:::caution
+
+```java
+// 在某个 AbstractContainerScreen 子类中
+public MyContainerScreen(MyMenu menu, Inventory playerInventory, Component title) {
+ super(menu, playerInventory, title);
+
+ this.titleLabelX = 10;
+ this.inventoryLabelX = 10;
+
+ /*
+ * 如果 'imageHeight' 被改变，'inventoryLabelY' 也必须被
+ * 改变，因为该值取决于 'imageHeight' 的值。
+ */
+}
+```
+
+### 菜单访问
+
+由于菜单被传递到屏幕中，现在可以通过 `menu` 字段访问任何在菜单中并通过插槽、数据插槽或自定义系统同步的值。
+
+### 容器更新
+
+当玩家活着并且正在查看屏幕时，容器屏幕在 `#tick` 方法中进行更新，通过 `#containerTick` 进行。这基本上取代了容器屏幕内部的 `#tick` 方法，最常见的用法是进行食谱书的更新。
+
+```java
+// 在某个 AbstractContainerScreen 子类中
+@Override
+protected void containerTick() {
+ super.containerTick();
+
+ // 在这里更新内容
+}
+```
+
+### 渲染容器屏幕
+
+容器屏幕的渲染涉及三种方法：`#renderBg`，用于渲染背景纹理，`#renderLabels`，用于在背景上方渲染任何文本，以及 `#render`，它包含前两种方法，并提供了一个灰色背景和工具提示。
+
+从 `#render` 开始，最常见的覆盖（通常是唯一的情况）添加了背景，调用 super 来渲染容器屏幕，并最后在其上渲染工具提示。
+
+```java
+// 在某个 AbstractContainerScreen 子类中
+@Override
+public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+ this.renderBackground(graphics);
+ super.render(graphics, mouseX, mouseY, partialTick);
+
+ /*
+ * 这个方法由容器屏幕添加，用于渲染鼠标悬停插槽的工具提示。
+ */
+ this.renderTooltip(graphics, mouseX, mouseY);
+}
+```
+
+在 super 中，调用了 `#renderBg` 来渲染屏幕的背景。最标准的表示使用了三个方法调用：两个用于设置，一个用于绘制背景纹理。
+
+```java
+// 在某个 AbstractContainerScreen 子类中
+
+// 背景纹理的位置（assets//）
+private static final ResourceLocation BACKGROUND_LOCATION = new ResourceLocation(MOD_ID, "textures/gui/container/my_container_screen.png");
+
+@Override
+protected void renderBg(GuiGraphics graphics, float partialTick, int mouseX, int mouseY) {
+ /*
+ * 设置着色器使用的纹理位置。虽然最多可以设置12个纹理，但 'blit' 中使用的着色器
+ * 只查看第一个纹理索引。
+ */
+ RenderSystem.setShaderTexture(0, BACKGROUND_LOCATION);
+
+ /*
+ * 将背景纹理渲染到屏幕上。'leftPos' 和 'topPos' 应该已经表示纹理应该渲染的
+ * 左上角位置，因为它们是从 'imageWidth' 和 'imageHeight' 预计算出来的。两个
+ * 零表示在 256 x 256 PNG 文件内的整数 u/v 坐标。
+ */
+ graphics.blit(BACKGROUND_LOCATION, this.leftPos, this.topPos, 0, 0, this.imageWidth, this.imageHeight);
+}
+```
+
+最后，调用 `#renderLabels` 来在背景上方但工具提示下方渲染任何文本。这简单地使用字体来绘制关联的组件。
+
+```java
+// 在某个 AbstractContainerScreen 子类中
+@Override
+protected void renderLabels(GuiGraphics graphics, int mouseX, int mouseY) {
+ super.renderLabels(graphics, mouseX, mouseY);
+
+ // 假设我们有一些 Component 'label'
+ // 'label' 将被绘制在 'labelX' 和 'labelY' 处
+ graphics.drawString(this.font, this.label, this.labelX, this.labelY, 0x404040);
+}
+```
+
+:::note
+在渲染标签时，**不需要**指定 `leftPos` 和 `topPos` 偏移量。这些已经在 `PoseStack` 中被转换，因此该方法内的所有内容都相对于这些坐标进行绘制。
+:::
+
+## 注册 AbstractContainerScreen
+
+要将 `AbstractContainerScreen` 与菜单一起使用，需要对其进行注册。可以在 [**mod 事件总线**][modbus] 的 `RegisterMenuScreensEvent` 中调用 `register` 方法来完成。
+
+```java
+// 事件在 mod 事件总线上监听
+private void registerScreens(RegisterMenuScreensEvent event) {
+ event.register(MY_MENU.get(), MyContainerScreen::new);
+}
+```
+
+[menus]: ./menus.md
+[network]: ../networking/index.md
+[screen]: #the-screen-subtype
+[argb]: https://en.wikipedia.org/wiki/RGBA_color_model#ARGB32
+[component]: ../resources/client/i18n.md#components
+[keymapping]: ../misc/keymappings.md#inside-a-gui
+[modbus]: ../concepts/events.md#event-buses
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/bewlr.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/bewlr.md
new file mode 100644
index 000000000..44f3d6d32
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/bewlr.md
@@ -0,0 +1,36 @@
+### BlockEntityWithoutLevelRenderer
+
+`BlockEntityWithoutLevelRenderer` 是一种处理物品的动态渲染方法。这个系统比旧的 `ItemStack` 系统简单得多，因为旧系统需要一个 `BlockEntity`，并且无法访问 `ItemStack`。
+
+使用 BlockEntityWithoutLevelRenderer
+--------------------------
+
+BlockEntityWithoutLevelRenderer 允许你使用 `public void renderByItem(ItemStack itemStack, ItemDisplayContext ctx, PoseStack poseStack, MultiBufferSource bufferSource, int combinedLight, int combinedOverlay)` 来渲染你的物品。
+
+为了使用 BEWLR，`Item` 必须首先满足一个条件：它的模型对于 `BakedModel#isCustomRenderer` 返回 true。如果没有自定义渲染器，它将使用默认的 `ItemRenderer#getBlockEntityRenderer`。一旦返回 true，物品的 BEWLR 将被访问以进行渲染。
+
+:::note
+如果 `Block#getRenderShape` 设置为 `RenderShape#ENTITYBLOCK_ANIMATED`，`Block` 也会使用 BEWLR 进行渲染。
+:::
+
+要为物品设置 BEWLR，必须在 `Item#initializeClient` 中消费 `IClientItemExtensions` 的匿名实例。在匿名实例中，应该重写 `IClientItemExtensions#getCustomRenderer` 以返回你的 BEWLR 的实例：
+
+```java
+// 在你的物品类中
+@Override
+public void initializeClient(Consumer consumer) {
+ consumer.accept(new IClientItemExtensions() {
+
+ @Override
+ public BlockEntityWithoutLevelRenderer getCustomRenderer() {
+ return myBEWLRInstance;
+ }
+ });
+}
+```
+
+:::caution
+每个模组应该只有一个自定义 BEWLR 实例。
+:::
+
+就是这样，使用 BEWLR 不需要额外的设置。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/index.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/index.md
new file mode 100644
index 000000000..5765e113e
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/index.md
@@ -0,0 +1,206 @@
+# 物品
+
+除了方块外，物品是 Minecraft 的关键组成部分。方块构成了你周围的世界，而物品存在于物品栏中。
+
+## 物品到底是什么？
+
+在我们进一步创建物品之前，了解物品究竟是什么，以及它与方块的区别是什么，是非常重要的。让我们通过一个例子来说明这一点：
+
+- 在游戏世界中，你遇到了一个泥土方块并想要挖掘它。这是一个 **方块**，因为它被放置在世界中。（实际上，它不是一个方块，而是一个方块状态。请参阅 [方块状态文章][blockstates] 以获取更详细的信息。）
+ - 并非所有方块在破坏时都会掉落自己（例如树叶），有关更多信息，请参阅 [战利品表][loottables] 文章。
+- 一旦你 [挖掘了方块][breaking]，它就会被移除（即被替换为空气方块），并且泥土掉落。掉落的泥土是一个 **物品实体**。这意味着像其他实体（猪、僵尸、箭等）一样，它可以被水推动，或者被火和岩浆燃烧。
+- 一旦你捡起泥土物品实体，它就会成为你物品栏中的一个 **物品堆叠**。物品堆叠简单地说就是一个物品的实例，带有一些额外的信息，比如堆叠大小。
+- 物品堆叠由它们对应的 **物品**（我们正在创建的东西）支持，物品持有所有物品之间相同的信息（例如，每把铁剑的最大耐久度为 250），而物品堆叠持有在两个类似物品之间可能不同的信息（例如，一把铁剑剩余 100 次使用，而另一把铁剑剩余 200 次使用）。有关通过物品和物品堆叠执行的操作和通过物品堆叠执行的操作的更多信息，请继续阅读。
+ - 物品与物品堆叠之间的关系大致与 [方块][block] 和 [方块状态][blockstates] 之间的关系相同，即方块状态始终由方块支持。这不是一个非常准确的比较（物品堆叠不是单例，例如），但它可以给出一个关于这里概念的好基本理解。
+
+## 创建一个物品
+
+现在我们了解了物品是什么，让我们创建一个吧！
+
+与基本方块一样，对于不需要特殊功能的基本物品（如棍子、糖等），可以直接使用 `Item` 类。为此，在注册期间，使用 `Item.Properties` 参数实例化 `Item`。可以使用 `Item.Properties#of` 创建此 `Item.Properties` 参数，并通过调用其方法来自定义它：
+
+- `stacksTo` - 设置此物品的最大堆叠大小。默认为 64。例如末影珍珠或其他只能堆叠到 16 的物品使用了这个值。
+- `durability` - 设置此物品的耐久度。默认为 0，表示“无耐久度”。例如，铁制工具在此处使用了 250。请注意，设置耐久度会自动将堆叠大小锁定为 1。
+- `craftRemainder` - 设置此物品的制作剩余物品。Vanilla 在制作后留下空桶时使用了这个值。
+- `fireResistant` - 使使用此物品的物品实体对火和岩浆免疫。许多下界物品都使用了这个。
+- `setNoRepair` - 禁用此物品的铁砧和合成网格修复。Vanilla 中未使用。
+- `rarity` - 设置此物品的稀有度。当前，这只是改变物品的颜色。`Rarity` 是一个由四个值 `COMMON`（白色，默认）、`UNCOMMON`（黄色）、`RARE`（青色）和 `EPIC`（浅紫色） 组成的枚举。请注意，模组可能会添加更多的稀有度类型。
+- `requiredFeatures` - 设置此物品所需的功能标志。这主要用于小版本中 Vanilla 的功能锁定系统。除非你要集成 Vanilla 中由功能标志锁定的系统，否则不建议使用这个。
+- `food` - 设置此物品的 [`FoodProperties`][food]。
+
+有关示例，或查看 Minecraft 中使用的各种值，请查看 `Items` 类。
+
+### 食物
+
+`Item` 类提供了食物物品的默认功能，这意味着你不需要单独的类来处理。要使你的物品可食用，你只需要通过 `Item.Properties` 的 `food` 方法设置其上的 `FoodProperties`。
+
+使用 `FoodProperties.Builder` 创建 `FoodProperties`。然后，你可以在其上设置各种属性：
+
+- `nutrition` - 可能是最明显的部分。设置恢复多少饥饿点。以半个饥饿点为单位计数，所以例如，Minecraft 的牛排恢复了 8 个饥饿点。
+- `saturationMod` - 用于计算 [进食][hunger] 时恢复的饱和度值的饱和度修
+
+饰符。计算公式为 `min(2 * nutrition * saturationMod, playerNutrition)`，这意味着使用 `0.5` 将使有效的饱和度值与营养值相同。
+- `meat` - 是否应将此物品视为肉类。用于确定是否可以使用此食物治愈狗。
+- `alwaysEat` - 此物品是否始终可以食用，即使饥饿条已满。默认为 `false`，例如金苹果等提供了除填充饥饿条之外的奖励的物品为 `true`。
+- `fast` - 是否为此食物启用快速进食。默认为 `false`，例如 Vanilla 中的干海带为 `true`。
+- `effect` - 在吃这个物品时添加一个 [`MobEffectInstance`][mobeffectinstance]。第二个参数表示应用效果的概率；例如，腐肉在被吃时有 80% 的几率（= 0.8）应用饥饿效果。这个方法有两个变体；你应该使用一个带有提供者的（另一个直接使用了一个 mob 效果实例，并因为类加载问题而被 NeoForge 废弃）。
+- `build` - 一旦你设置了你想设置的所有内容，调用 `build` 获取一个用于进一步使用的 `FoodProperties` 对象。
+
+有关示例，或查看 Minecraft 中使用的各种值，请查看 `Foods` 类。
+
+要获取物品的 `FoodProperties`，请调用 `Item#getFoodProperties(ItemStack, LivingEntity)`。这可能返回 null，因为并非每个物品都是可食用的。要确定物品是否可食用，请调用 `Item#isEdible()` 或对 `getFoodProperties` 调用的结果进行空检查。
+
+### 更多功能
+
+直接使用 `Item` 仅允许非常基本的物品。如果你想添加功能，例如右键交互，需要一个扩展 `Item` 的自定义类。`Item` 类有许多可以重写以执行不同操作的方法；有关更多信息，请参阅类 `Item` 和 `IItemExtension`。
+
+物品的两种最常见用途是左键单击和右键单击。对于左键单击，请参阅 [破坏方块][breaking] 和 攻击实体（工作中）。对于右键单击，请参阅 [交互管道][interactionpipeline]。
+
+### `DeferredRegister.Items`
+
+所有注册表都使用 `DeferredRegister` 来注册它们的内容，物品也不例外。然而，由于添加新物品是大量模组中一个至关重要的功能，NeoForge 提供了 `DeferredRegister.Items` 帮助类，它扩展了 `DeferredRegister
- ` 并提供了一些特定于物品的辅助程序：
+
+```java
+public static final DeferredRegister.Items ITEMS = DeferredRegister.createItems(ExampleMod.MOD_ID);
+
+public static final Supplier
- EXAMPLE_ITEM = ITEMS.registerItem(
+ "example_item",
+ Item::new, // 将属性传递给工厂。
+ new Item.Properties() // 要使用的属性。
+);
+```
+
+在内部，这只是通过将属性参数应用于提供的物品工厂（通常是构造函数）来调用 `ITEMS.register("example_item", () -> new Item(new Item.Properties()))`。
+
+如果你想使用 `Item::new`，可以完全省略工厂，并使用 `simple` 方法变体：
+
+```java
+public static final Supplier
- EXAMPLE_ITEM = ITEMS.registerSimpleItem(
+ "example_item",
+ new Item.Properties() // 要使用的属性。
+);
+```
+
+这和上一个示例的效果完全相同，但稍微更短一些。当然，如果你想使用 `Item` 的子类而不是 `Item` 本身，则必须使用前一种方法。
+
+这两种方法也有省略 `new Item.Properties()` 参数的重载：
+
+```java
+public static final Supplier
- EXAMPLE_ITEM = ITEMS.registerItem("example_item", Item::new);
+// Variant that also omits the Item::new parameter
+public static final Supplier
- EXAMPLE_ITEM = ITEMS.registerSimpleItem("example_item");
+```
+
+最后，还有块项目的快捷方式：
+
+```java
+public static final Supplier EXAMPLE_BLOCK_ITEM = ITEMS.registerSimpleBlockItem("example_block", ExampleBlocksClass.EXAMPLE_BLOCK, new Item.Properties());
+// Variant that omits the properties parameter:
+public static final Supplier EXAMPLE_BLOCK_ITEM = ITEMS.registerSimpleBlockItem("example_block", ExampleBlocksClass.EXAMPLE_BLOCK);
+// Variant that omits the name parameter, instead using the block's registry name:
+public static final Supplier EXAMPLE_BLOCK_ITEM = ITEMS.registerSimpleBlockItem(ExampleBlocksClass.EXAMPLE_BLOCK, new Item.Properties());
+// Variant that omits both the name and the properties:
+public static final Supplier EXAMPLE_BLOCK_ITEM = ITEMS.registerSimpleBlockItem(ExampleBlocksClass.EXAMPLE_BLOCK);
+```
+
+:::note
+如果您将注册的方块保存在单独的类中，则应该在项目类之前对方块类进行类加载。
+:::
+
+### 资源
+
+如果你注册了你的物品并获得了你的物品（通过 `/give` 命令或通过 [创造模式标签][creativetabs]），你会发现它缺少正确的模型和纹理。这是因为纹理和模型是由 Minecraft 的资源系统处理的。
+
+要为物品应用一个简单的纹理，你必须添加一个物品模型 JSON 文件和一个纹理 PNG 文件。有关更多信息，请参阅 [资源][resources] 部分。
+
+## `ItemStack`（物品堆叠）
+
+与方块和方块状态一样，大多数情况下你期望使用一个 `Item` 实际上都是使用 `ItemStack`。`ItemStack` 表示容器中一个或多个物品的堆叠，例如一个物品栏。与方块和方块状态一样，方法应该被 `Item` 重写，并在 `ItemStack` 上调用，`Item` 中的许多方法都会传入一个 `ItemStack` 实例。
+
+`ItemStack` 由三个主要部分组成：
+
+- 它所表示的 `Item`，可通过 `itemstack.getItem()` 获取。
+- 堆叠大小，通常在 1 和 64 之间，通过 `itemstack.getCount()` 获取，通过 `itemstack.setCount(int)` 或 `itemstack.shrink(int)` 可更改。
+- 额外的 [NBT][nbt] 数据，其中存储了堆叠特定的数据。可通过 `itemstack.getTag()` 获取，或者通过 `itemstack.getOrCreateTag()` 获取，它考虑了尚不存在标签的情况。还存在许多其他与 NBT 相关的方法，最重要的是 `hasTag()` 和 `setTag()`。
+ - 值得注意的是，带有空 NBT 的 `ItemStack` 与根本没有 NBT 的 `ItemStack` 不同。这意味着它们不会堆叠，尽管它们在功能上是等效的。
+
+要创建一个新的 `ItemStack`，请调用 `new ItemStack(Item)`，传入支持的物品。默认情况下，这使用数量为 1 和没有 NBT 数据；如果需要，有接受数量和 NBT 数据的构造函数重载。
+
+`ItemStack` 是可变对象（见下文），但有时需要将它们视为不可变的。如果你需要修改一个被视为不可变的 `ItemStack`，可以使用 `itemstack.copy()` 克隆堆栈。
+
+如果要表示堆叠没有物品，可以使用 `ItemStack.EMPTY`。要检查一个 `ItemStack` 是否为空，请调用 `itemstack.isEmpty()`。
+
+### `ItemStack` 的可变性
+
+`ItemStack` 是可变对象。这意味着如果你调用例如 `setCount`、`setTag` 或 `getOrCreateTag`，`ItemStack` 本身将被修改。Vanilla 广泛使用了 `ItemStack` 的可变性，许多方法依赖于它。例如，`itemstack.split(int)` 从调用者堆栈中分离给定数量的堆栈，同时修改调用者并在过程中返回一个新的 `ItemStack`。
+
+然而，当处理多个 `ItemStack` 时，有时可能会出现问题。最常见的情况是处理库存槽时，因为你必须考虑到当前由光标选择的 `ItemStack`，以及你正在尝试插入/提取的 `ItemStack`。
+
+:::tip
+如果不确定，最好安全起见并对堆栈进行 `#copy()`。
+:::
+
+## 创造模式标签
+
+默认情况下，你的物品只能通过 `/give` 命令获得，并不会出现在创造模式的物品栏中。让我们来改变这一点吧！
+
+将你的物品添加到创造模式菜单中的方式取决于你想要添加到哪个标签。
+
+### 现有的创造模式标签
+
+:::note
+这种方法用于将你的物品添加到 Minecraft 的标签，或其他模组的标签中。要将物品添加到你自己的标签中，请参见下文。
+:::
+
+可以通过 `BuildCreativeModeTabContentsEvent` 将物品添加到现有的 `CreativeModeTab` 中，该事件在 [模组事件总线][modbus] 上触发，仅在 [逻辑客户端][sides] 上触发。通过调用 `event#accept` 来添加物品。
+
+```java
+//MyItemsClass.MY_ITEM 是 Supplier，MyBlocksClass.MY_BLOCK 是 Supplier
+@SubscribeEvent
+public static void buildContents(BuildCreativeModeTabContentsEvent event) {
+ // 这是我们要添加到的标签吗？
+ if (event.getTabKey() == CreativeModeTabs.INGREDIENTS) {
+ event.accept(MyItemsClass.MY_ITEM);
+ // 接受一个 ItemLike。这假设 MY_BLOCK 有一个相应的物品。
+ event.accept(MyBlocksClass.MY_BLOCK);
+ }
+}
+```
+
+事件还提供了一些额外信息，例如 `getFlags()` 来获取已启用的功能标志列表，或 `hasPermissions()` 来检查玩家是否有权限查看操作员物品标签。
+
+### 自定义创造模式标签
+
+`CreativeModeTab` 是一个注册表，意味着自定义的 `CreativeModeTab` 必须被 [注册][registering]。创建创造模式标签使用一个构建器系统
+
+，该构建器通过 `CreativeModeTab#builder` 获得。构建器提供了设置标题、图标、默认物品以及许多其他属性的选项。此外，NeoForge 还提供了额外的方法来自定义标签的图像、标签和槽颜色，标签应该排序在哪里等等。
+
+```java
+//CREATIVE_MODE_TABS 是 DeferredRegister
+public static final Supplier EXAMPLE_TAB = CREATIVE_MODE_TABS.register("example", () -> CreativeModeTab.builder()
+ // 设置标签的标题。不要忘记添加一个翻译！
+ .title(Component.translatable("itemGroup." + MOD_ID + ".example"))
+ // 设置标签的图标。
+ .icon(() -> new ItemStack(MyItemsClass.EXAMPLE_ITEM.get()))
+ // 将你的物品添加到标签中。
+ .displayItems((params, output) -> {
+ output.accept(MyItemsClass.MY_ITEM);
+ // 接受一个 ItemLike。这假设 MY_BLOCK 有一个相应的物品。
+ output.accept(MyBlocksClass.MY_BLOCK);
+ })
+ .build()
+);
+```
+
+[block]: ../blocks/index.md
+[blockstates]: ../blocks/states.md
+[breaking]: ../blocks/index.md#breaking-a-block
+[creativetabs]: #creative-tabs
+[food]: #food
+[hunger]: https://minecraft.wiki/w/Hunger#Mechanics
+[interactionpipeline]: interactionpipeline.md
+[loottables]: ../resources/server/loottables.md
+[mobeffectinstance]: mobeffects.md#mobeffectinstances
+[modbus]: ../concepts/events.md#event-buses
+[nbt]: ../datastorage/nbt.md
+[registering]: ../concepts/registries.md#methods-for-registering
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/interactionpipeline.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/interactionpipeline.md
new file mode 100644
index 000000000..7643241f5
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/interactionpipeline.md
@@ -0,0 +1,71 @@
+The Interaction Pipeline
+========================
+
+本页面旨在使玩家右键单击的相当复杂和令人困惑的过程更容易理解，并澄清应在何处以及为什么使用哪种结果。
+
+右键单击时发生了什么？
+--------------------------------
+
+当你在世界中的任何地方右键单击时，会发生一系列的事情，这取决于你当前正在查看的内容以及你手中的 `ItemStack`。会调用返回两种结果类型之一的一些方法。如果显式地返回了成功或失败，大多数情况下这些方法将取消管线。为了易读起见，这里将“显式成功或显式失败”称为“明确结果”。
+
+- 用右鼠标按钮和主手触发 `InputEvent.InteractionKeyMappingTriggered`。如果事件被取消，管线结束。
+- 检查了几种情况，例如你不处于旁观模式，或者你主手中的 `ItemStack` 的所有必需特性标志都已启用。如果这些检查中至少有一个失败，管线结束。
+- 根据你的视线朝向的内容不同，会发生不同的事情：
+ - 如果你的视线朝向一个在你可触及范围内且不在世界边界之外的实体：
+ - 触发 `PlayerInteractEvent.EntityInteractSpecific`。如果事件被取消，管线结束。
+ - 将在你所看的实体上调用 `Entity#interactAt`。如果它返回了明确结果，管线结束。
+ - 如果你想为你自己的实体添加行为，请重写此方法。如果你想为一个原版实体添加行为，请使用事件。
+ - 如果实体打开了一个界面（例如村民交易 GUI 或箱子矿车 GUI），管线结束。
+ - 触发 `PlayerInteractEvent.EntityInteract`。如果事件被取消，管线结束。
+ - 将在你所看的实体上调用 `Entity#interact`。如果它返回了明确结果，管线结束。
+ - 如果你想为你自己的实体添加行为，请重写此方法。如果你想为一个原版实体添加行为，请使用事件。
+ - 对于 `Mob`，`Entity#interact` 的重写处理了像使用生成蛋时拴绳和产生孩子这样的事情，然后将特定于 mob 的处理推迟到 `Mob#mobInteract`。`Entity#interact` 的结果规则也适用于这里。
+ - 如果你所看的实体是一个 `LivingEntity`，将在你主手中的 `ItemStack` 上调用 `Item#interactLivingEntity`。如果它返回了明确结果，管线结束。
+ - 如果你的视线朝向一个在你可触及范围内且不在世界边界之外的方块：
+ - 触发 `PlayerInteractEvent.RightClickBlock`。如果事件被取消，管线结束。你也可以在这个事件中具体地否定只有方块或物品的使用。
+ - 调用 `IItemExtension#onItemUseFirst`。如果它返回了明确结果，管线结束。
+ - 如果玩家没有潜行并且事件没有否定方块的使用，将调用 `Block#use`。如果它返回了明确结果，管线结束。
+ - 如果事件没有否定物品的使用，将调用 `Item#useOn`。如果它返回了明确结果，管线结束。
+- 调用 `Item#use`。如果它返回了明确结果，管线结束。
+- 上述过程再次运行，这次是用副手而不是主手。
+
+结果类型
+------------
+
+有两种不同的结果类型：`InteractionResult` 和 `InteractionResultHolder`。`InteractionResult` 大多数情况下使用，只有 `Item#use` 使用 `InteractionResultHolder`。
+
+`InteractionResult` 是一个枚举，包含五个值：`SUCCESS`、`CONSUME`、`CONSUME_PARTIAL`、`PASS` 和 `FAIL`。此外，方法 `InteractionResult#sidedSuccess` 可用，它在服务器端返回 `SUCCESS`，在客户端返回 `CONSUME`。
+
+`InteractionResultHolder` 是 `InteractionResult` 的包装器，它为 `T` 添加了额外的上下文。`T` 可以是任何东西，但在 99.99% 的情况下，它是一个 `ItemStack`。`InteractionResultHolder` 为枚举值提供了包装方法（`#success`、`#consume`、`#pass` 和 `#fail`），以及 `#sidedSuccess` 方法，它在服务器上调用 `#success`，在客户端上调用 `#consume`。
+
+一般来说，不同的值意味着以下内容：
+
+- `InteractionResult#sidedSuccess`（或需要时 `InteractionResultHolder#sidedSuccess`）应该在操作应该被认为成功，并且你想要挥动手臂时使用。管线将结束。
+- `InteractionResult.SUCCESS`（或需要时 `InteractionResultHolder#success`）应该在操作应该被认为成功，并且你想要挥动手臂时使用，但只在一侧使用。只有在出于某种原因希望在另一逻辑侧返回不同值时才使用此选项。管线将结束。
+- `InteractionResult.CONSUME`（或需要时 `InteractionResultHolder#consume`）应该在操作应该被认为成功，但你不想要挥动手臂时使用。管线将结束。
+- `InteractionResult.CONSUME_PARTIAL` 在大多数情况下与 `InteractionResult.CONSUME` 相同，唯一的区别在于它在 [`Item#useOn`][itemuseon] 中的使用方式。
+- `InteractionResult.FAIL`（或需要时 `InteractionResult
+
+Holder#fail`）应该在物品功能被认为失败并且不应再进行进一步交互时使用。管线将结束。这可以用在任何地方，但在 `Item#useOn` 和 `Item#use` 之外使用时需要小心。在许多情况下，使用 `InteractionResult.PASS` 更有意义。
+- `InteractionResult.PASS`（或需要时 `InteractionResultHolder#pass`）应该在操作既不应被认为成功也不应被认为失败时使用。管线将继续。这是默认行为（除非另有规定）。
+
+一些方法具有特殊的行为或要求，这些将在下面的章节中解释。
+
+`IItemExtension#onItemUseFirst`
+---------------------------
+
+`InteractionResult#sidedSuccess` 和 `InteractionResult.CONSUME` 在这里没有效果。在这里只应该使用 `InteractionResult.SUCCESS`、`InteractionResult.FAIL` 或 `InteractionResult.PASS`。
+
+`Item#useOn`
+------------
+
+如果你希望操作被视为成功，但你不希望手臂摆动或奖励一个 `ITEM_USED` 统计点，请使用 `InteractionResult.CONSUME_PARTIAL`。
+
+`Item#use`
+----------
+
+这是唯一一个返回类型为 `InteractionResultHolder` 的实例。`InteractionResultHolder` 中的结果 `ItemStack` 将替换发起使用的 `ItemStack`，如果它已更改。
+
+当物品可食用并且玩家可以吃掉物品时（因为他们饥饿了，或者因为物品总是可食用时），`Item#use` 的默认实现返回 `InteractionResultHolder#consume`；当物品可食用但玩家无法吃掉物品时，返回 `InteractionResultHolder#fail`；如果物品不可食用，则返回 `InteractionResultHolder#pass`。
+
+在考虑主手时返回 `InteractionResultHolder#fail` 将阻止运行副手行为。如果你希望运行副手行为（通常是这样），请改为返回 `InteractionResultHolder#pass`。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/mobeffects.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/mobeffects.md
new file mode 100644
index 000000000..17ef1d09c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/mobeffects.md
@@ -0,0 +1,200 @@
+# Mob Effects & Potions
+
+状态效果，有时称为药水效果，并在代码中称为 `MobEffect`，是每个游戏刻对实体产生影响的效果。本文解释了如何使用它们，效果与药水之间的区别，以及如何添加自定义效果。
+
+## 术语
+
+- `MobEffect` 每个游戏刻对实体产生影响。与[方块][block]或[物品][item]一样，`MobEffect` 是注册对象，这意味着它们必须[注册][registration]并且是单例的。
+ - **即时效果** 是一种特殊类型的效果，设计用于应用一次游戏刻。原版有两种即时效果，即即时治疗和即时伤害。
+- `MobEffectInstance` 是 `MobEffect` 的实例，具有持续时间、增幅和一些其他设置（见下文）。`MobEffectInstance` 对于 `MobEffect` 就像 [`ItemStack`][itemstack] 对于 `Item` 一样。
+- `Potion` 是一组 `MobEffectInstance`。原版主要用于四种药水物品（后文），但可以随意应用于任何物品。物品如何使用所设置的药水取决于物品本身。
+- **药水物品** 是指应设置药水的物品。这是一个非正式的术语，原版中有四种药水物品：药水、溅射药水、挥发药水和毒箭；但是模组可能会添加更多。
+
+## `MobEffect`s
+
+要创建自己的 `MobEffect`，请扩展 `MobEffect` 类：
+
+```java
+public class MyMobEffect extends MobEffect {
+ public MyMobEffect(MobEffectCategory category, int color) {
+ super(category, color);
+ }
+
+ @Override
+ public void applyEffectTick(LivingEntity entity, int amplifier) {
+ // 在这里应用你的效果逻辑。
+ }
+
+ // 决定是否在此游戏刻应用效果。例如，恢复效果每 x 个游戏刻应用一次，具体取决于游戏刻和增幅。
+ @Override
+ public boolean shouldApplyEffectTickThisTick(int tickCount, int amplifier) {
+ return tickCount % 2 == 0; // 用你想要的检查替换此处
+ }
+
+ // 当效果首次添加到实体时调用的实用方法。
+ @Override
+ public void onEffectStarted(LivingEntity entity, int amplifier) {
+ }
+}
+```
+
+像所有注册对象一样，`MobEffect` 必须像下面这样注册：
+
+```java
+// MOB_EFFECTS 是一个 DeferredRegister
+public static final Supplier MY_MOB_EFFECT = MOB_EFFECTS.register("my_mob_effect", () -> new MyMobEffect(
+ // 可以是 BENEFICIAL、NEUTRAL 或 HARMFUL。用于确定此效果的药水工具提示颜色。
+ MobEffectCategory.BENEFICIAL,
+ // 效果粒子的颜色。
+ 0xffffff
+));
+```
+
+如果你的效果仅用作标记，你也可以直接使用 `MobEffect` 类，就像你可以使用 `Block` 或 `Item` 类一样。
+
+`MobEffect` 类还为受影响实体添加属性修改器提供了默认功能。例如，速度效果会为移动速度添加属性修改器。效果属性修改器添加如下：
+
+```java
+public static final String MY_MOB_EFFECT_UUID = "01234567-89ab-cdef-0123-456789abcdef";
+public static final Supplier MY_MOB_EFFECT = MOB_EFFECTS.register("my_mob_effect", () -> new MyMobEffect(...)
+ .addAttributeModifier(Attribute.ATTACK_DAMAGE, MY_MOB_EFFECT_UUID, 2.0, AttributeModifier.Operation.ADD)
+);
+```
+
+:::note
+使用的 UUID 必须是有效且唯一的 UUIDv4，因为出于某种原因，Mojang 决定在此处使用 UUID 而不是一些基于文本的标识符。最好
+
+通过在线生成器获得 UUID，例如 [uuidgenerator.net][uuidgen]。
+:::
+
+### `InstantenousMobEffect`
+
+如果要创建即时效果，可以使用助手类 `InstantenousMobEffect` 而不是常规的 `MobEffect` 类，如下所示：
+
+```java
+public class MyMobEffect extends InstantenousMobEffect {
+ public MyMobEffect(MobEffectCategory category, int color) {
+ super(category, color);
+ }
+
+ @Override
+ public void applyEffectTick(LivingEntity entity, int amplifier) {
+ // 在这里应用你的效果逻辑。
+ }
+}
+```
+
+然后，像平常一样注册你的效果。
+
+### 事件
+
+许多效果在其他地方应用它们的逻辑。例如，飘浮效果在生物移动处理程序中应用。对于模组 `MobEffect`，通常最好在[事件处理程序][events]中应用它们。NeoForge 还提供了一些与效果相关的事件：
+
+- `MobEffectEvent.Applicable` 在游戏检查是否可以将 `MobEffectInstance` 应用于实体时触发。此事件可用于拒绝或强制向目标添加效果实例。
+- `MobEffectEvent.Added` 当 `MobEffectInstance` 添加到目标时触发。此事件包含有关可能存在于目标上的先前 `MobEffectInstance` 的信息。
+- `MobEffectEvent.Expired` 当 `MobEffectInstance` 到期时触发，即计时器归零时。
+- `MobEffectEvent.Remove` 当通过除到期之外的方式从实体中移除效果时触发，例如通过喝牛奶或通过命令。
+
+## `MobEffectInstance`s
+
+简单来说，`MobEffectInstance` 是应用于实体的效果。通过调用构造函数创建 `MobEffectInstance`：
+
+```java
+MobEffectInstance instance = new MobEffectInstance(
+ // 要使用的 mob 效果。
+ MobEffects.REGENERATION,
+ // 使用的持续时间，以游戏刻为单位。如果未指定，默认为 0。
+ 500,
+ // 要使用的增幅。这是效果的 “强度”，例如，Strength I、Strength II 等；从 0 开始。如果未指定，默认为 0。
+ 0,
+ // 是否为 “环境” 效果，表示它由环境源应用，Minecraft 目前有信标和导管。如果未指定，默认为 false。
+ false,
+ // 效果是否在库存中可见。如果未指定，默认为 true。
+ true,
+ // 是否在右上角可见效果图标。如果未指定，默认为 true。
+ true
+);
+```
+
+有几种构造函数重载，分别省略最后 1-5 个参数。
+
+:::info
+`MobEffectInstance` 是可变的。如果需要副本，请调用 `new MobEffectInstance(oldInstance)`。
+:::
+
+### 使用 `MobEffectInstance`
+
+可以将 `MobEffectInstance` 添加到实体，如下所示：
+
+```java
+MobEffectInstance instance = new MobEffectInstance(...);
+entity.addEffect(instance);
+```
+
+类似地，也可以从实体中移除 `MobEffectInstance`。由于 `MobEffectInstance` 覆盖了实体上的相同 `MobEffect` 的预先存在的 `MobEffectInstance`，因此每个 `MobEffect` 和实体只能有一个 `MobEffectInstance`。因此，在移除时只需指定 `MobEffect` 即可：
+
+```java
+entity.removeEffect(MobEffects.REGENERATION);
+```
+
+:::info
+`MobEffect` 只能应用于 `LivingEntity` 或其子类，例如玩家和生物。例如物品或投掷雪球无法受到 `MobEffect` 的影响。
+:::
+
+## `Potion`s
+
+`Potion`s 是通过调用 `Potion` 的构造函数并传递你想要的 `MobEffectInstance`s 来创建的。例如：
+
+```java
+// POTIONS 是一个 DeferredRegister
+public static final Supplier MY_POTION = POTIONS.register("my_potion", () -> new Potion(new MobEffectInstance(MY_MOB_EFFECT.get(), 3600)));
+```
+
+请注意，`new Potion` 的参数是可变参数。这意味着你可以向药水添加任意数量的效果。这也意味着可以创建空药水，即不含任何效果的药水。只需调用 `new Potion()` 即可！（顺便说一句，这就是原版如何添加 `awkward` 药水的方式。）
+
+药水的名称可以作为第一个构造函数参数传递。它用于翻译；例如，原版中的长效和强效药水变种使用此参数，使其与基本变种具有相同的名称。名称不是必需的；如果省略了名称，将从注册表中查询名称。
+
+`PotionUtils` 类提供了与药水相关的各种辅助方法，例如 `getPotion` 和 `setPotion` 用于物品堆栈（这可以是任何类型的物品，不仅限于药水物品），或者 `getColor` 用于获取药水的显示颜色。
+
+### 酿造
+
+现在，你的药水已经添加，药水物品可以使用你的药水了。但是，在生存模式下没有办法获得你的药水，所以让我们改变一下！
+
+传统上，药水是在酿造台上制作的。不幸的是，Mojang 没有为酿造配方提供 [数据包][datapack] 支持，因此我们必须有点老派，通过代码添加我们的配方。操作如下：
+
+```java
+// 酿造成分。这是在酿造台顶部的物品。
+Ingredient brewingIngredient = Ingredient.of(Items.FEATHER);
+BrewingRecipeRegistry.addRecipe(
+ // 输入药水成分，通常是一种混合药水。这是在酿造台底部的物品。
+ // 不一定要是药水，但通常是。
+ PotionUtils.setPotion(new ItemStack(Items.POTION), Potions.AWKWARD),
+ // 我们的酿造成分。
+ brewingIngredient,
+ // 结果物品堆栈。不一定要是药水，但通常是。
+ PotionUtils.setPotion(new ItemStack(Items.POTION), MY_POTION)
+);
+// 对于溅射药水和挥发药水，我们还需要单独处理。
+// 原版的毒箭配方由 Minecraft 的毒箭特殊配方处理。
+BrewingRecipeRegistry.addRecipe(
+ PotionUtils.setPotion(new ItemStack(Items.SPLASH_POTION), Potions.AWKWARD),
+ brewingIngredient,
+ PotionUtils.setPotion(new ItemStack(Items.SPLASH_POTION), MY_POTION)
+);
+BrewingRecipeRegistry.addRecipe(
+ PotionUtils.setPotion(new ItemStack(Items.LINGERING_POTION), Potions.AWKWARD),
+ brewingIngredient,
+ PotionUtils.setPotion(new ItemStack(Items.LINGERING_POTION), MY_POTION)
+);
+```
+
+这应该在设置期间的某个时间调用，例如在 [`FMLCommonSetupEvent`][commonsetup] 中。确保将此代码包装到 `event.enqueueWork()` 调用中，因为酿造配方注册表不是线程安全的。
+
+[block]: ../blocks/index.md
+[commonsetup]: ../concepts/events.md#event-buses
+[datapack]: ../resources/server/index.md
+[events]: ../concepts/events.md
+[item]: index.md
+[itemstack]: index.md#itemstacks
+[registration]: ../concepts/registries.md
+[uuidgen]: https://www.uuidgenerator.net/version4
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/tools.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/tools.md
new file mode 100644
index 000000000..dc840ab85
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/items/tools.md
@@ -0,0 +1,331 @@
+## 工具与护甲
+
+工具是其主要用途是破坏[方块][block]的[物品][item]。许多模组添加了新的工具套装（例如铜工具）或新的工具类型（例如锤子）。
+
+## 自定义工具套装
+
+工具套装通常包含五种物品：镐、斧、铲、锄和剑。（剑在传统意义上不是工具，但为了保持一致性也包括在内。）所有这些物品都有对应的类：`PickaxeItem`、`AxeItem`、`ShovelItem`、`HoeItem` 和 `SwordItem`。工具的类层次结构如下所示：
+
+```text
+Item
+- TieredItem
+ - DiggerItem
+ - AxeItem
+ - HoeItem
+ - PickaxeItem
+ - ShovelItem
+ - SwordItem
+```
+
+`TieredItem` 是一个包含了特定 `Tier`（详见下文）的辅助类。`DiggerItem` 包含了设计用于破坏方块的物品的辅助功能。请注意，其他通常被认为是工具的物品，例如剪刀，不包含在此层次结构中。它们直接扩展了 `Item`，并自行处理破坏逻辑。
+
+要创建标准工具套装，首先必须定义一个 `Tier`。有关参考值，请参阅 Minecraft 的 `Tiers` 枚举。以下示例使用铜工具，你可以在此处使用你自己的材料并根据需要调整值。
+
+```java
+// 我们将铜放在石头和铁之间。
+public static final Tier COPPER_TIER = new SimpleTier(
+ // 确定此工具的等级。由于这是一个整数，没有很好的方法将我们的工具放在石头和铁之间。
+ // 石头是 1，铁是 2。
+ 1,
+ // 确定等级的耐久性。
+ // 石头是 131，铁是 250。
+ 200,
+ // 确定等级的挖掘速度。剑不使用此值。
+ // 石头使用 4，铁使用 6。
+ 5f,
+ // 确定攻击伤害加成。不同的工具使用不同的方式。例如，剑会造成 (getAttackDamageBonus() + 4) 的伤害。
+ // 石头使用 1，铁使用 2，对应于剑的 5 和 6 攻击伤害；现在我们的剑造成 5.5 伤害。
+ 1.5f,
+ // 确定等级的附魔能力。这代表了此工具上附魔的好坏程度。
+ // 金使用 22，我们将铜稍微低于这个值。
+ 20,
+ // 确定此工具可以破坏的方块的标签。详见下文。
+ MyBlockTags.NEEDS_COPPER_TOOL,
+ // 确定等级的修复原料。使用 Supplier 进行延迟初始化。
+ () -> Ingredient.of(Tags.Items.INGOTS_COPPER)
+);
+```
+
+现在我们有了我们的 `Tier`，我们可以用它来注册工具。所有工具的构造函数都有相同的四个参数。
+
+```java
+// ITEMS 是一个 DeferredRegister
-
+public static final Supplier COPPER_SWORD = ITEMS.register("copper_sword", () -> new SwordItem(
+ // 要使用的等级。
+ COPPER_TIER,
+ // 类型特定的攻击伤害加成。剑为 3，铲为 1.5，镐为 1，斧和锄有所不同。
+ 3,
+ // 类型特定的攻击速度修正。玩家的默认攻击速度为 4，所以我们使用 -2.4f 来达到期望的值 1.6f。
+ // 剑为 -2.4f，铲为 -3f，镐为 -2.8f，斧和锄有所不同。
+ -2.4f,
+ // 物品属性。我们不需要在这里设置耐久性，因为 TieredItem 会为我们处理。
+ new Item.Properties()
+));
+public static final Supplier COPPER_AXE = ITEMS.register("copper_axe", () -> new AxeItem(...));
+public static final Supplier COPPER_PICKAXE = ITEMS.register("copper_pickaxe", () -> new PickaxeItem(...));
+public static final
+
+ Supplier COPPER_SHOVEL = ITEMS.register("copper_shovel", () -> new ShovelItem(...));
+public static final Supplier COPPER_HOE = ITEMS.register("copper_hoe", () -> new HoeItem(...));
+```
+
+### 标签
+
+创建 `Tier` 时，它被分配了一个包含需要此工具（或更好的工具）才能破坏的方块[标签][tags]。例如，`minecraft:needs_iron_tool` 标签包含了钻石矿石（以及其他方块），而 `minecraft:needs_diamond_tool` 标签包含了方块如黑曜石和远古残骸。
+
+如果你满意的话，你可以重用这些标签中的一个来制作你的工具。例如，如果我们想要我们的铜工具只是更耐用的石头工具，我们可以传入 `BlockTags.NEEDS_STONE_TOOL`。
+
+或者，我们可以创建自己的标签，操作如下：
+
+```java
+public static final TagKey NEEDS_COPPER_TOOL = TagKey.create(BuiltInRegistries.BLOCK.key(), new ResourceLocation(MOD_ID, "needs_copper_tool"));
+```
+
+然后，我们填充我们的标签。例如，让铜能够开采金矿石、金块和红石矿石，但不能开采钻石或绿宝石。 （红石块已经可以被石头工具开采了。）标签文件位于 `src/main/resources/data/mod_id/tags/blocks/needs_copper_tool.json`（其中 `mod_id` 是你的模组 ID）：
+
+```json
+{
+ "values": [
+ "minecraft:gold_block",
+ "minecraft:raw_gold_block",
+ "minecraft:gold_ore",
+ "minecraft:deepslate_gold_ore",
+ "minecraft:redstone_ore",
+ "minecraft:deepslate_redstone_ore"
+ ]
+}
+```
+
+最后，我们可以像上面看到的那样将我们的标签传递给我们的等级创建。
+
+### `TierSortingRegistry`
+
+为了使游戏真正选择你的等级位于另外两个等级之间，你必须将其注册到 `TierSortingRegistry`。这必须在物品注册之前发生，将 `static` 初始化器放在与你的等级定义相同的类中是一个不错的选择。如果你不将你的等级添加到注册表中，它将退回到原版所做的操作。
+
+```java
+public static final Tier COPPER_TIER = new SimpleTier(...);
+
+static {
+ TierSortingRegistry.registerTier(
+ COPPER_TIER,
+ // 用于内部解析的名称。如果适用，可以使用 Minecraft 命名空间。
+ new ResourceLocation("minecraft", "copper"),
+ // 被认为低于正在添加的类型的一系列等级。例如，石头低于铜。
+ // 我们不需要在这里添加木头和金，因为这些已经低于石头了。
+ List.of(Tiers.STONE),
+ // 被认为高于正在添加的类型的一系列等级。例如，铁高于铜。
+ // 我们不需要在这里添加钻石和下界合金，因为这些已经高于铁了。
+ List.of(Tiers.IRON)
+ );
+}
+```
+
+可以将其他等级的 ID 传递到这些列表中，作为 `Tier` 的替代或补充。例如，假设我们想要使我们的材料被认为比铁和 [Mekanism 工具][mektools] 的钨更弱，我们可以这样做：
+
+```java
+public static final Tier COPPER_TIER = new SimpleTier(...);
+
+static {
+ TierSortingRegistry.registerTier(
+ COPPER_TIER,
+ new ResourceLocation("minecraft", "copper"),
+ List.of(Tiers.STONE),
+ // 我们可以在这里混合和匹配 Tiers 和 ResourceLocations。
+ List.of(Tiers.IRON, new ResourceLocation("mekanism", "osmium"))
+ );
+}
+```
+
+## 工具与护甲
+
+工具是主要用于破坏[方块][block]的[物品][item]。许多模组添加了新的工具套装（例如铜工具）或新的工具类型（例如锤子）。
+
+### 自定义工具套装
+
+工具套装通常由五种物品组成：镐、斧、铲、锄和剑。（剑在传统意义上不是工具，但为了保持一致性，也包括在内。）所有这些物品都有各自对应的类：`PickaxeItem`、`AxeItem`、`ShovelItem`、`HoeItem` 和 `SwordItem`。工具的类层次结构如下所示：
+
+```
+Item
+- TieredItem
+ - DiggerItem
+ - AxeItem
+ - HoeItem
+ - PickaxeItem
+ - ShovelItem
+ - SwordItem
+```
+
+`TieredItem` 是一个包含某个 `Tier` 的辅助类（详见下文）。`DiggerItem` 包含了用于破坏方块的物品的辅助方法。请注意，其他通常被视为工具的物品（如剪刀）不包括在这个层次结构中。相反，它们直接扩展 `Item` 并自行处理破坏逻辑。
+
+要创建标准的工具套装，首先必须定义一个 `Tier`。参考 Minecraft 的 `Tiers` 枚举获取参考值。以下示例使用铜工具，你可以在此处使用你自己的材料并根据需要调整值。
+
+```java
+// 我们将铜放在石头和铁之间。
+public static final Tier COPPER_TIER = new SimpleTier(
+ // 确定此工具的等级。由于这是一个整数，因此没有好的方法将我们的工具放置在石头和铁之间。
+ // NeoForge 引入了 TierSortingRegistry 来解决这个问题，有关更多信息，请参见下文。在此处尽力估计。
+ // 石头为 1，铁为 2。
+ 1,
+ // 确定等级的耐久度。
+ // 石头为 131，铁为 250。
+ 200,
+ // 确定等级的挖掘速度。斧头不使用此项。
+ // 石头使用 4，铁使用 6。
+ 5f,
+ // 确定攻击伤害奖励。不同的工具使用方式不同。例如，剑会造成 (getAttackDamageBonus() + 4) 的伤害。
+ // 石头使用 1，铁使用 2，对应于剑的伤害分别为 5 和 6；我们的剑现在造成 5.5 的伤害。
+ 1.5f,
+ // 确定等级的附魔性。这代表了这个工具上附魔的好坏程度。
+ // 金使用 22，我们稍微低于这个值。
+ 20,
+ // 决定这个工具可以破坏哪些方块的标签。更多信息请参见下文。
+ MyBlockTags.NEEDS_COPPER_TOOL,
+ // 确定等级的修复材料。使用供应商进行延迟初始化。
+ () -> Ingredient.of(Tags.Items.INGOTS_COPPER)
+);
+```
+
+现在我们有了我们的 `Tier`，我们可以在注册工具时使用它。所有工具构造函数都具有相同的四个参数。
+
+```java
+// ITEMS 是一个 DeferredRegister
-
+public static final Supplier COPPER_SWORD = ITEMS.register("copper_sword", () -> new SwordItem(
+ // 要使用的等级。
+ COPPER_TIER,
+ // 类型特定的攻击伤害奖励。剑为 3，铲子为 1.5，镐子为 1，斧头和锄头的值各不相同。
+ 3,
+ // 类型特定的攻击速度修饰符。玩家的默认攻击速度为 4，所以要达到期望的值 1.6f，我们使用 -2.4f。对于剑，值为 -2.4f，铲子为 -3f，镐子为 -2.8f，斧头和锄头的值各不相同。
+ -2.4f,
+ // 物品属性。我们不需要在此设置耐久度，因为 TieredItem 会为我们处理。
+ new Item.Properties()
+));
+public static final Supplier COPPER_AXE = ITEMS.register("copper_axe", () -> new AxeItem(...));
+public static final Supplier COPPER_PICKAXE = ITEMS.register("copper_pickaxe", () -> new PickaxeItem(...));
+public static final Supplier COPPER
+
+_SHOVEL = ITEMS.register("copper_shovel", () -> new ShovelItem(...));
+```
+
+### 工具动作
+
+工具动作是工具能够执行和不能执行的操作的抽象。这包括左键和右键行为。NeoForge 在 `ToolActions` 类中提供了默认的 `ToolAction`：
+
+- 挖掘动作。这些适用于上文提到的所有四种 `DiggerItem` 类型，以及剑和剪刀挖掘。
+- 斧头右键动作用于去皮（原木）、刮（氧化铜）和去蜡（蜡质铜）。
+- 剪刀动作用于收获（蜜蜂巢）、雕刻（南瓜）和解除武装（绊线）。
+- 铲子平整（土径）、剑扫射、锄头耕作、盾牌阻挡和钓鱼竿抛出的动作。
+
+要创建自己的 `ToolAction`，请使用 `ToolAction#get` - 它会在需要时创建一个新的 `ToolAction`。然后，在自定义工具类型中根据需要覆盖 `IItemExtension#canPerformAction`。
+
+要查询一个 `ItemStack` 是否可以执行某个 `ToolAction`，请调用 `IItemStackExtension#canPerformAction`。请注意，这适用于任何 `Item`，而不仅仅是工具。
+
+### 护甲
+
+与工具类似，护甲也使用一个等级系统（尽管不同）。工具中称为 `Tier` 的东西在护甲中称为 `ArmorMaterial`。就像上面一样，这个例子展示了如何添加铜护甲；这可以根据需要进行调整。有关原始数值，请参见 `ArmorMaterials` 枚举。
+
+```java
+// 我们将铜放在锁链甲和铁之间。
+public static final ArmorMaterial COPPER_ARMOR_MATERIAL = new ArmorMaterial() {
+ // 护甲材料的名称。主要用于确定护甲纹理的位置。应包含一个前导的模组标识符以确保唯一性，否则当两个模组尝试添加相同的护甲材料时可能会出现问题。（如果省略模组标识符，则将使用 "minecraft" 命名空间。）
+ @Override
+ public String getName() {
+ return "modid:copper";
+ }
+
+ // StringRepresentable 的重写。通常应与 getName() 返回相同的值。
+ @Override
+ public String getSerializedName() {
+ return getName();
+ }
+
+ // 确定此护甲材料的耐久度，具体取决于护甲部件是什么。
+ // ArmorItem.Type 是四个值的枚举：HELMET、CHESTPLATE、LEGGINGS 和 BOOTS。
+ // Vanilla 护甲材料通过使用一个基础值并将其与类型特定的常量相乘来确定这一点。
+ // 这些常量是 13（BOOTS）、15（LEGGINGS）、16（CHESTPLATE）和 11（HELMET）。
+ // 锁链甲和铁都使用 15 作为基础值，所以我们也使用它。
+ @Override
+ public int getDurabilityForType(ArmorItem.Type type) {
+ return switch (type) {
+ case HELMET -> 11 * 15;
+ case CHESTPLATE -> 16 * 15;
+ case LEGGINGS -> 15 * 15;
+ case BOOTS -> 13 * 15;
+ };
+ }
+
+ // 确定此护甲材料的防御值，具体取决于护甲部件是什么。
+ @Override
+ public int getDurabilityForType(ArmorItem.Type type) {
+ return switch (type) {
+ case HELMET -> 2;
+ case CHESTPLATE -> 4;
+ case LEGGINGS -> 6;
+ case BOOTS -> 2;
+ };
+ }
+
+ // 返回护甲的坚韧度值。坚韧度值是包含在伤害计算中的额外值，有关更多信息，请参见 Minecraft Wiki 上的护甲机制文章：https://minecraft.wiki/w/Armor#Armor_toughness
+ // 只有钻石和下界合金在这里的值大于 0，所以我们只返回 0。
+ @Override
+ public float getToughness() {
+ return 0;
+ }
+
+ // 返回护甲的抗击退值。穿戴这种护甲时，玩家对击退具有一定程度的免疫。如果玩家从所有护甲部件中获得的总击退抗性值大于或等于 1，则它们将根本不受到任何击退。
+ // 只有下界合金在这里的值大于 0，所以我们只返回 0。
+ @Override
+ public float getKnockbackResistance() {
+ return 0;
+ }
+
+ // 确定等级的附魔性。这代表了这个护甲上的附魔有多好。
+ // 金使用 25，我们将铜放在稍低的位置。
+ @Override
+ public int getEnchantmentValue(ArmorItem.Type type) {
+ return 20;
+ }
+
+ // 确定装备这件护甲时播放的声音。
+ @Override
+ public SoundEvent getEquipSound() {
+ return SoundEvents.ARMOR_EQUIP_GENERIC;
+ }
+
+ // 确定这件护甲的修复物品。
+ @Override
+ public Ingredient getRepairIngredient() {
+ return Ingredient.of(Tags.Items.INGOTS_COPPER);
+ }
+
+ // 可选地，您还可以在这里重写 #getArmorTexture。此方法返回一个 ResourceLocation，用于确定存储护甲位置的位置，以防您希望将其存储在非默认位置。
+
+有关示例，请参见 Tier 中的默认实现。
+}
+```
+
+然后，在物品注册中使用该护甲材料。
+
+```java
+// ITEMS 是一个 DeferredRegister
-
+public static final Supplier COPPER_HELMET = ITEMS.register("copper_helmet", () -> new ArmorItem(
+ // 要使用的护甲材料。
+ COPPER_ARMOR_MATERIAL,
+ // 要使用的护甲类型。
+ ArmorItem.Type.HELMET,
+ // 物品属性。我们不需要在此设置耐久度，因为 ArmorItem 会为我们处理。
+ new Item.Properties()
+));
+public static final Supplier COPPER_CHESTPLATE = ITEMS.register("copper_chestplate", () -> new ArmorItem(...));
+public static final Supplier COPPER_LEGGINGS = ITEMS.register("copper_leggings", () -> new ArmorItem(...));
+public static final Supplier COPPER_BOOTS = ITEMS.register("copper_boots", () -> new ArmorItem(...));
+```
+
+除了通常的资源外，护甲还需要一个穿戴时的护甲纹理，它将在装备护甲时渲染在玩家模型上。该纹理必须位于 `src/main/resources/assets//textures/models/armor/_layer_1.png`（头盔、胸甲和靴子的纹理），以及相同目录中的 `_layer_2.png`（护腿的纹理）。
+
+创建护甲纹理时，最好在基于标准护甲纹理的基础上进行工作，以确定每个部分的位置。
+
+[block]: ../blocks/index.md
+[farmersdelight]: https://www.curseforge.com/minecraft/mc-mods/farmers-delight
+[item]: index.md
+[mektools]: https://www.curseforge.com/minecraft/mc-mods/mekanism-tools
+[tags]: ../resources/server/tags.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/legacy/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/legacy/_category_.json
new file mode 100644
index 000000000..da5b88dbc
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/legacy/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Legacy"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/legacy/porting.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/legacy/porting.md
new file mode 100644
index 000000000..9e50a0119
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/legacy/porting.md
@@ -0,0 +1,22 @@
+移植到 Minecraft 1.20
+=========================
+
+在这里，您可以找到有关如何从旧版本移植到当前版本的入门指南。某些版本被合并在一起，因为该特定版本从未被广泛使用。
+
+| 从 -> 到 | 入门指南 |
+|:-----------------:|:----------------------------------------|
+| 1.12 -> 1.13/1.14 | [williewillus 的入门指南][112to114] |
+| 1.14 -> 1.15 | [williewillus 的入门指南][114to115] |
+| 1.15 -> 1.16 | [50ap5ud5 的入门指南][115to116] |
+| 1.16 -> 1.17 | [50ap5ud5 的入门指南][116to117] |
+| 1.19.2 -> 1.19.3 | [ChampionAsh5357 的入门指南][1192to1193] |
+| 1.19.3 -> 1.19.4 | [ChampionAsh5357 的入门指南][1193to1194] |
+| 1.19.4 -> 1.20.0 | [ChampionAsh5357 的入门指南][1194to120] |
+
+[112to114]: https://gist.github.com/williewillus/353c872bcf1a6ace9921189f6100d09a
+[114to115]: https://gist.github.com/williewillus/30d7e3f775fe93c503bddf054ef3f93e
+[115to116]: https://gist.github.com/50ap5ud5/f4e70f0e8faeddcfde6b4b1df70f83b8
+[116to117]: https://gist.github.com/50ap5ud5/beebcf056cbdd3c922cc8993689428f4
+[1192to1193]: https://gist.github.com/ChampionAsh5357/c21724bafbc630da2ed8899fe0c1d226
+[1193to1194]: https://gist.github.com/ChampionAsh5357/163a75e87599d19ee6b4b879821953e8
+[1194to120]: https://gist.github.com/ChampionAsh5357/cf818acc53ffea6f4387fe28c2977d56
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/_category_.json
new file mode 100644
index 000000000..26fda970d
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Miscellaneous"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/config.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/config.md
new file mode 100644
index 000000000..e6f94f3eb
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/config.md
@@ -0,0 +1,139 @@
+配置
+=============
+
+配置定义了可应用于模组实例的设置和用户偏好。NeoForge 使用 [TOML][toml] 文件并使用 [NightConfig][nightconfig] 进行读取的配置系统。
+
+创建配置
+------------------------
+
+可以使用 `IConfigSpec` 的子类型来创建配置。NeoForge 通过 `ModConfigSpec` 实现了该类型，并通过 `ModConfigSpec.Builder` 启用其构建。该构建器可以通过 `Builder#push` 将配置值分成部分以创建一个部分，通过 `Builder#pop` 离开一个部分。然后，可以使用以下两种方法之一构建配置：
+
+ 方法 | 描述
+ :--- | :---
+`build` | 创建 `ModConfigSpec`。
+`configure` | 创建持有配置值的类和 `ModConfigSpec` 的一对。
+
+:::note
+`ModConfigSpec.Builder#configure` 通常与 `static` 块和一个类一起使用，该类作为其构造函数的一部分接受 `ModConfigSpec.Builder` 来附加和保存值：
+
+```java
+// 在某个配置类中
+ExampleConfig(ModConfigSpec.Builder builder) {
+ // 在此定义值的最终字段
+}
+
+// 某处可以访问构造函数
+static {
+ Pair pair = new ModConfigSpec.Builder()
+ .configure(ExampleConfig::new);
+ // 将配对值存储在某个常量字段中
+}
+```
+:::
+
+每个配置值可以提供额外的上下文以提供附加行为。必须在完全构建配置值之前定义上下文：
+
+| 方法 | 描述 |
+|:---------------|:------------------------------------------------------------------------------------------------------------|
+| `comment` | 提供配置值功能的描述。可以为多行注释提供多个字符串。 |
+| `translation` | 为配置值的名称提供翻译键。 |
+| `worldRestart` | 必须在更改配置值之前重新启动世界。 |
+
+### ConfigValue
+
+可以使用提供的上下文（如果已定义）使用任何 `#define` 方法构建配置值。
+
+所有配置值方法至少接受两个组件：
+
+* 表示变量名称的路径：一个 `.` 分隔的字符串，表示配置值所在的部分
+* 当没有有效配置时的默认值
+
+`ConfigValue` 特定的方法接受两个额外的组件：
+
+* 验证器，以确保反序列化的对象有效
+* 表示配置值的数据类型的类
+
+```java
+// 对于某个 ModConfigSpec.Builder builder
+ConfigValue value = builder.comment("Comment")
+ .define("config_value_name", defaultValue);
+```
+
+还可以使用 `ConfigValue#get` 获取值。值还被缓存以防止从文件中进行多次读取。
+
+#### 额外的配置值类型
+
+* **范围值**
+ * 描述：值必须在定义的边界之间
+ * 类型：`Comparable`
+ * 方法名：`#defineInRange`
+ * 额外组件：
+ * 配置值可能的最小值和最大值
+ * 表示配置值的数据类型的类
+
+:::note
+`DoubleValue`、`IntValue` 和 `LongValue` 是范围值，它们将类指定为 `Double`、`Integer` 和 `Long`，分别。
+:::
+
+* **白名单值**
+ * 描述：值必须在提供的集合中
+ * 类型：`T`
+ * 方法名：`#defineInList`
+ * 额外组件：
+ * 配置可以是哪些值的集合
+
+* **列表值**
+ * 描述：值是一系列条目
+ * 类型：`List`
+ * 方法名：`#defineList`，如果列表可以为空，则为 `#defineListAllowEmpty`
+ * 额外组件：
+ * 验证器，以确保从列表中反序列化的元素有效
+
+* **枚举值**
+ * 描述：在提供的集合中的枚举值
+ * 类型：`Enum`
+ * 方法名：`#defineEnum`
+ * 额外组件：
+ * 一个 getter，将字符串或整数转换为枚举
+ * 配置可以是哪些值的集合
+
+* **布尔值**
+ * 描述：一个 `boolean` 值
+ * 类型：`Boolean`
+ * 方法名：`#define`
+
+注册配置
+---------------------------
+
+一旦构建了 `ModConfigSpec`，就必须注册它以允许 NeoForge 加载、跟踪和根据需要同步配置设置。配置应该在模组构造函数中通过 `ModLoadingContext#registerConfig` 注册。可以使用给定的类型（表示配置所属的一侧）、`ModConfigSpec` 和可选的特定文件名为配置注册。
+
+```java
+// 在具有 ModConfigSpec CONFIG 的模组构造函数中
+ModLoadingContext.get().registerConfig(Type.COMMON, CONFIG);
+```
+
+以下是可用的配置类型列表：
+
+| 类型 | 加载 | 同步到客户端 | 客户端位置 | 服务器位置 | 默认文件后缀 |
+|:------:|:----------------:|:----------------:|:--------------------------------------------:|:------------------------------------:|:--------------------|
+| CLIENT | 仅客户端 | 否 | `.minecraft/config` | N/A | `-client` |
+| COMMON | 两边都有 | 否 | `.minecraft/config` | `/config` | `-common` |
+| SERVER | 仅服务器 | 是 | `.minecraft/saves//serverconfig` | `/world/serverconfig` | `-server` |
+
+:::tip
+NeoForge 在其代码库中记录了[配置类型][type]。
+:::
+
+配置事件
+--------------------
+
+可以使用 `ModConfigEvent$Loading` 和 `ModConfigEvent$Reloading` 事件在加载或重新加载配置时执行的操作。必须将这些事件[注册][events]到模组事件总线上。
+
+:::caution
+这些事件适用于模组的所有配置；应使用提供的 `ModConfig` 对象来指示正在加载或重新加载的配置。
+:::
+
+[toml]: https://toml.io/
+[nightconfig]: https://github.com/TheElectronWill/night-config
+[type]: https://github.com/neoforged/FancyModLoader/blob/19d6326b810233e683f1beb3d28e41372e1e89d1/core/src/main/java/net/neoforged/fml/config/ModConfig.java#L83-L111
+[events]: ../concepts/events.md#registering-an-event-handler
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/debugprofiler.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/debugprofiler.md
new file mode 100644
index 000000000..15e821aed
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/debugprofiler.md
@@ -0,0 +1,45 @@
+# 调试性能分析器
+
+Minecraft 提供了一个调试性能分析器，它提供系统数据、当前游戏设置、JVM 数据、级别数据和边界刻信息，以找到耗时的代码。考虑到诸如 `TickEvent` 和刻动 `BlockEntities` 等因素，这对于想要找到卡顿来源的模组开发者和服务器所有者非常有用。
+
+## 使用调试性能分析器
+
+调试性能分析器非常简单易用。它需要使用调试按键组合 `F3 + L` 来启动分析器。10 秒后，它将自动停止；但是，您也可以通过再次按下该组合键来提前停止。
+
+:::note
+自然而然，您只能分析实际被执行的代码路径。您想要分析的 `实体` 和 `BlockEntities` 必须存在于级别中才会出现在结果中。
+:::
+
+在停止调试器后，它将在运行目录的 `debug/profiling` 子目录中创建一个新的 zip 文件。文件名将以日期和时间格式化为 `yyyy-mm-dd_hh_mi_ss-WorldName-VersionNumber.zip`
+
+## 阅读性能分析结果
+
+在每个边界文件夹 (`client` 和 `server`) 中，您会找到一个包含结果数据的 `profiling.txt` 文件。在顶部，它首先告诉您在运行的毫秒数以及在此期间运行了多少个刻。
+
+在此之下，您会发现类似于以下片段的信息：
+```
+[00] levels - 96.70%/96.70%
+[01] | Level Name - 99.76%/96.47%
+[02] | | tick - 99.31%/95.81%
+[03] | | | entities - 47.72%/45.72%
+[04] | | | | regular - 98.32%/44.95%
+[04] | | | | blockEntities - 0.90%/0.41%
+[05] | | | | | unspecified - 64.26%/0.26%
+[05] | | | | | minecraft:furnace - 33.35%/0.14%
+[05] | | | | | minecraft:chest - 2.39%/0.01%
+```
+这里是每个部分的简要解释
+
+| [02] | tick | 99.31% | 95.81% |
+| :----------------------- | :---------------------- | :----------- | :----------- |
+| 该部分的深度 | 该部分的名称 | 它花费的时间与其父部分的百分比。对于层级 0，它是一次刻所花费时间的百分比。对于层级 1，它是其父部分所花费时间的百分比。 | 第二个百分比告诉您它从整个刻中花费了多少时间。
+
+## 对自己的代码进行性能分析
+
+调试性能分析器对 `Entity` 和 `BlockEntity` 有基本支持。如果您想分析其他内容，您可能需要手动创建您的部分，如下所示：
+```java
+ProfilerFiller#push(yourSectionName : String);
+//您想要分析的代码
+ProfilerFiller#pop();
+```
+您可以从 `Level`、`MinecraftServer` 或 `Minecraft` 实例获取 `ProfilerFiller` 实例。现在，您只需要在结果文件中搜索您的部分名称即可。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/gametest.mdx b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/gametest.mdx
new file mode 100644
index 000000000..981b1c40c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/gametest.mdx
@@ -0,0 +1,290 @@
+# 游戏测试
+
+游戏测试是一种运行游戏内单元测试的方法。该系统被设计为可扩展并且并行运行，以有效地运行大量不同的测试。测试对象的交互和行为只是该框架的众多应用之一。
+
+创建游戏测试
+------------
+
+标准的游戏测试遵循三个基本步骤：
+
+1. 加载一个结构或模板，其中包含要测试的交互或行为所在的场景。
+2. 一个方法执行逻辑来执行场景上的操作。
+3. 方法逻辑执行。如果达到了成功的状态，则测试成功。否则，测试失败，并将结果存储在场景旁边的讲台上。
+
+因此，要创建一个游戏测试，必须有一个存在的模板，其中包含场景的初始起始状态，以及一个提供执行逻辑的方法。
+
+### 测试方法
+
+游戏测试方法是一个 `Consumer` 引用，意味着它接受一个 `GameTestHelper` 并且不返回任何内容。为了使游戏测试方法被识别，它必须有一个 `@GameTest` 注解：
+
+```java
+public class ExampleGameTests {
+ @GameTest
+ public static void exampleTest(GameTestHelper helper) {
+ // Do stuff
+ }
+}
+```
+
+`@GameTest` 注解还包含配置游戏测试运行方式的成员。
+
+```java
+// 在某个类中
+@GameTest(
+ setupTicks = 20L, // 测试花费 20 刻来设置执行环境
+ required = false // 失败会被记录，但不会影响批次的执行
+)
+public static void exampleConfiguredTest(GameTestHelper helper) {
+ // Do stuff
+}
+```
+
+#### 相对定位
+
+所有 `GameTestHelper` 方法都将结构模板场景中的相对坐标转换为其绝对坐标，使用结构方块的当前位置。为了方便相对和绝对定位之间的转换，可以分别使用 `GameTestHelper#absolutePos` 和 `GameTestHelper#relativePos`。
+
+通过在游戏中加载结构并使用 [测试命令][test] 将玩家放置在所需位置，最后运行 `/test pos` 命令，可以获取结构模板的相对位置。该命令将以可复制的文本组件的形式在聊天中导出相对于玩家所在位置的最近结构的坐标。这个导出的文本可以作为最终的局部变量使用。
+
+:::tip
+`/test pos` 生成的本地变量可以通过将其附加到命令的末尾来指定其引用名称：
+
+```bash
+/test pos # 导出 'final BlockPos = new BlockPos(...);'
+```
+:::
+
+#### 成功完成
+
+游戏测试方法负责一件事情：在有效完成时标记测试为成功。如果在达到超时之前（由 `GameTest#timeoutTicks` 定义）没有达到成功状态，则测试会自动失败。
+
+在 `GameTestHelper` 中有许多抽象方法可以用来定义成功状态；然而，有四个是非常重要的需要注意的。
+
+方法 | 描述
+:---: | :---
+`#succeed` | 将测试标记为成功。
+`#succeedIf` | 立即测试提供的 `Runnable`，如果没有抛出 `GameTestAssertException`，则成功。如果在当前刻没有成功，则标记为失败。
+`#succeedWhen` | 每刻测试提供的 `Runnable`，直到超时，如果在其中一刻检查不会抛出 `GameTestAssertException` 则成功。
+`#succeedOnTickWhen` | 在指定的刻上测试提供的 `Runnable`，如果没有抛出 `GameTestAssertException`，则成功。如果在任何其他刻上成功，则标记为失败。
+
+:::caution
+游戏测试会每刻执行一次，直到测试被标记为成功为止。因此，为了成功标记某一特定刻上的成功，必须在之前的任何刻上都失败。
+:::
+
+#### 安排操作
+
+并不是所有的操作在测试开始时都会发生。可以安排在特定时间或间隔发生的操作：
+
+方法 | 描述
+:---: | :---
+`#runAtTickTime` | 在指定的刻上运行操作。
+`#runAfterDelay` | 在当前刻之后的 `x` 刻运行操作。
+`#onEachTick` | 每一刻都运行操作。
+
+#### 断言
+
+在游戏测试的任何时候，都可以进行断言来检查给定条件是否为真。在 `GameTestHelper` 中有许多断言方法；然而，简化为在适当状态未满足时抛出 `GameTestAssertException`。
+
+### 生成的测试方法
+
+如果游戏测试方法需要动态生成，可以创建一个测试方法生成器。这些方法不接受任何参数，并返回一个 `TestFunction` 集合。为了使测试方法生成器被识别，它必须有一个 `@GameTestGenerator` 注解：
+
+```java
+public class ExampleGameTests {
+ @GameTestGenerator
+ public static Collection exampleTests() {
+ // 返回一个 TestFunction 集合
+ }
+}
+```
+
+#### TestFunction
+
+`TestFunction` 是由 `@GameTest` 注解和运行测试的方法所包装的信息。
+
+:::tip
+使用 `@GameTest` 注解的任何方法都会使用 `GameTestRegistry#turnMethodIntoTestFunction` 将其转换为 `TestFunction`。该方法可用作创建 `TestFunction` 的参考，而不需要使用注解。
+:::
+
+### 批次处理
+
+游戏测试可以以批次方式而不是按照注册顺序执行。可以通过具有相同的提供的 `GameTest#batch` 字符串将测试添加到
+
+批次中。
+
+仅有批处理本身并不提供任何有用的功能。然而，批处理可以用于在测试运行的当前级别上执行设置和拆卸状态。通过将方法标记为 `@BeforeBatch` 进行设置，或标记为 `@AfterBatch` 进行拆卸。`#batch` 方法必须与游戏测试中提供的字符串匹配。
+
+批处理方法是 `Consumer` 引用，意味着它们接受一个 `ServerLevel` 并且不返回任何内容：
+
+```java
+public class ExampleGameTests {
+ @BeforeBatch(batch = "firstBatch")
+ public static void beforeTest(ServerLevel level) {
+ // 执行设置
+ }
+
+ @GameTest(batch = "firstBatch")
+ public static void exampleTest2(GameTestHelper helper) {
+ // Do stuff
+ }
+}
+```
+
+注册游戏测试
+----------
+
+游戏测试必须注册才能在游戏中运行。有两种方法可以实现：通过 `@GameTestHolder` 注解或 `RegisterGameTestsEvent`。这两种注册方法仍然要求测试方法被注解为 `@GameTest`、`@GameTestGenerator`、`@BeforeBatch` 或 `@AfterBatch` 中的一种。
+
+### GameTestHolder
+
+`@GameTestHolder` 注解注册类型（类、接口、枚举或记录）中的任何测试方法。`@GameTestHolder` 包含一个方法，具有多种用途。在此示例中，提供的 `#value` 必须是 mod 的 id；否则，测试将不会在默认配置下运行。
+
+```java
+@GameTestHolder(MODID)
+public class ExampleGameTests {
+ // ...
+}
+```
+
+### RegisterGameTestsEvent
+
+`RegisterGameTestsEvent` 也可以通过 `#register` 注册类或方法。事件监听器必须 [添加][event] 到 mod 事件总线上。以这种方式注册的测试方法必须在每个标注了 `@GameTest` 的方法中提供它们的 mod id 给 `GameTest#templateNamespace`。
+
+```java
+// 在某个类中
+public void registerTests(RegisterGameTestsEvent event) {
+ event.register(ExampleGameTests.class);
+}
+
+// 在 ExampleGameTests 中
+@GameTest(templateNamespace = MODID)
+public static void exampleTest3(GameTestHelper helper) {
+ // 执行设置
+}
+```
+
+:::note
+提供给 `GameTestHolder#value` 和 `GameTest#templateNamespace` 的值可以与当前 mod id 不同。在 [buildscript][namespaces] 中的配置需要更改。
+:::
+
+结构模板
+-----------
+
+游戏测试在由结构或模板加载的场景中执行。所有模板都定义了场景的尺寸以及将要加载的初始数据（方块和实体）。模板必须以 `.nbt` 文件的形式存储在 `data//structures` 目录中。
+
+:::tip
+可以使用结构方块创建并保存结构模板。
+:::
+
+模板的位置由以下几个因素确定：
+
+- 如果指定了模板的命名空间。
+- 如果类应该作为模板名称的前缀。
+- 如果指定了模板的名称。
+
+模板的命名空间由 `GameTest#templateNamespace` 确定，如果未指定，则由 `GameTestHolder#value` 确定，如果两者都未指定，则由 `minecraft` 确定。
+
+如果将 `@PrefixGameTestTemplate` 应用于带有测试注解的类或方法，并且设置为 `false`，则不会将简单类名添加到模板名称的前面。否则，简单类名将被转换为小写并添加到模板名称的前后，中间用点分隔。
+
+模板的名称由 `GameTest#template` 确定。如果未指定，则使用方法的小写名称。
+
+```java
+// 所有结构的 modid 将为 MODID
+@GameTestHolder(MODID)
+public class ExampleGameTests {
+
+ // 类名作为前缀，未指定模板名称
+ // 模板位置为 'modid:examplegametests.exampletest'
+ @GameTest
+ public static void exampleTest(GameTestHelper helper) { /*...*/ }
+
+ // 类名不作为前缀，未指定模板名称
+ // 模板位置为 'modid:exampletest2'
+ @PrefixGameTestTemplate(false)
+ @GameTest
+ public static void exampleTest2(GameTestHelper helper) { /*...*/ }
+
+ // 类名作为前缀，指定了模板名称
+ // 模板位置为 'modid:examplegametests.test_template'
+ @GameTest(template = "test_template")
+ public static void exampleTest3(GameTestHelper helper) { /*...*/ }
+
+ // 类名不作为前缀，指定了模板名称
+ // 模板位置为 'modid:test_template2'
+ @PrefixGameTestTemplate(false)
+ @GameTest(template = "test_template2")
+ public static void exampleTest4(GameTestHelper helper) { /*...*/ }
+}
+```
+
+运行游戏测试
+------------------
+
+可以使用 `/test` 命令运行游戏测试。`test` 命令是高度可配置的；然而，只有几个对于运行测试至关重要：
+
+子命令 | 描述
+:---: | :---
+`run` | 运行指定的测试：`run `。
+`runall` | 运行所有可用的测试。
+`runthis` | 在玩家附近 15 格内运行最近的测试。
+`runthese` | 运行玩家 200 格内的测试。
+`runfailed` | 运行上次运行失败的所有测试。
+
+:::note
+子命令遵循测试命令：`/test `。
+:::
+
+构建脚本配置
+------------------
+
+游戏测试提供了在构建脚本（`build.gradle` 文件）中运行和集成到不同设置中的额外配置设置。
+
+### 启用其他命名空间
+
+如果构建脚本已按照[推荐方式设置][buildscript]，那么只有当前 mod id 下的游戏测试将被启用。要启用其他命名空间加载游戏测试，运行配置必须将属性 `forge.enabledGameTestNamespaces` 设置为一个字符串，其中指定每个命名空间，用逗号分隔。如果属性为空或未设置，则将加载所有命名空间。
+
+```gradle
+// 在运行配置中
+property 'forge.enabledGameTestNamespaces', 'modid1,modid2,modid3'
+```
+
+:::caution
+命名空间之间不能有空格；否则，命名空间将无法正确加载。
+:::
+
+### 游戏测试服务器运行配置
+
+游戏测试服务器是一个特殊配置，运行一个构建服务器。构建服务器返回需要的失败游戏测试数的退出代码。所有失败的测试，无论是必需的还是可选的，都将被记录。可以使用 `gradlew runGameTestServer` 来运行此服务器。
+
+
+ FG5 的重要信息
+
+:::caution
+由于 Gradle 的工作方式的一个怪异之处，如果一个任务强制系统退出，默认情况下 Gradle 守护进程将被终止，导致 Gradle 运行器报告构建失败。ForgeGradle 默认设置了对运行任务的强制退出，以便任何子项目都不会按顺序执行。然而，这样一来，游戏测试服务器将总是失败。
+
+可以通过在运行配置中禁用强制退出来解决此问题，使用 `#setForceExit` 方法：
+
+```gradle
+// 游戏测试服务器运行配置
+gameTestServer {
+ // ...
+ setForceExit false
+}
+```
+:::
+
+
+### 在其他运行配置中启用游戏测试
+
+默认情况下，只有 `client`、`server` 和 `gameTestServer` 运行配置中启用了游戏测试。如果另一个运行配置应该运行游戏测试，那么必须将 `forge.enableGameTest` 属性设置为 `true`。
+
+```gradle
+// 在运行配置中
+property
+
+ 'forge.enableGameTest', 'true'
+```
+
+[test]: #running-game-tests
+[namespaces]: #enabling-other-namespaces
+[event]: ../concepts/events.md#registering-an-event-handler
+[buildscript]: ../gettingstarted/index.md#simple-buildgradle-customizations
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/keymappings.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/keymappings.md
new file mode 100644
index 000000000..20d66d57f
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/keymappings.md
@@ -0,0 +1,159 @@
+# Key Mappings
+
+一个按键映射或键绑定定义了应与输入相关联的特定操作：鼠标单击、按键等。每当客户端可以接受输入时，都可以检查键映射定义的每个操作。 此外，每个按键映射都可以通过[控制选项菜单][控制]分配给任何输入。
+
+## 注册一个`KeyMapping`
+
+可以通过仅在物理客户端上监听 [**mod 事件总线**][modbus] 上的 `RegisterKeyMappingsEvent` 并调用 `#register` 来注册 `KeyMapping`。
+
+```java
+// 在某个仅限物理客户端的类中
+
+// KeyMapping 是惰性初始化的，因此在注册之前它不存在
+public static final Lazy EXAMPLE_MAPPING = Lazy.of(() -> /*...*/);
+
+// 事件仅在物理客户端上的 mod 事件总线上
+@SubscribeEvent
+public void registerBindings(RegisterKeyMappingsEvent event) {
+ event.register(EXAMPLE_MAPPING.get());
+}
+```
+
+## 创建 `KeyMapping`
+
+可以使用其构造函数创建 `KeyMapping`。`KeyMapping` 接受一个[翻译键][tk]，用于定义映射的名称，映射的默认输入以及在[控制选项菜单][controls]中将映射放置在其中的类别的[翻译键][tk]。
+
+:::tip
+可以通过提供未由原版提供的自定义类别 [翻译键][tk] 来将 `KeyMapping` 添加到自定义类别中。自定义类别翻译键应包含 mod id（例如 `key.categories.examplemod.examplecategory`）。
+:::
+
+### 默认输入
+
+每个键映射都与一个默认输入关联。这是通过 `InputConstants$Key` 提供的。每个输入由一个 `InputConstants$Type` 组成，用于定义提供输入的设备，以及一个整数，用于定义设备上关联的标识符。
+
+原版提供了三种输入类型：`KEYSYM`，它使用提供的 `GLFW` 键令定义键盘，`SCANCODE`，它使用平台特定的扫描码定义键盘，以及 `MOUSE`，它定义了鼠标。
+
+:::note
+强烈建议使用 `KEYSYM` 而不是 `SCANCODE` 用于键盘，因为 `GLFW` 键令与任何特定的系统无关。您可以在 [GLFW 文档][keyinput] 上阅读更多信息。
+:::
+
+整数取决于所提供的类型。所有输入代码都在 `GLFW` 中定义：`KEYSYM` 令牌以 `GLFW_KEY_*` 为前缀，而 `MOUSE` 代码以 `GLFW_MOUSE_*` 为前缀。
+
+```java
+new KeyMapping(
+ "key.examplemod.example1", // 将使用此翻译键进行本地化
+ InputConstants.Type.KEYSYM, // 默认映射在键盘上
+ GLFW.GLFW_KEY_P, // 默认键为 P
+ "key.categories.misc" // 映射将位于杂项类别中
+)
+```
+
+:::note
+如果键映射不应映射到默认键，则应将输入设置为 `InputConstants#UNKNOWN`。原版构造函数将要求您通过 `InputConstants$Key#getValue` 提取输入代码，而 Forge 构造函数可以提供原始输入字段。
+:::
+
+### `IKeyConflictContext`
+
+并非所有映射都在每个上下文中使用。某些映射仅在 GUI 中使用，而其他映射则仅在游戏中使用。为了避免在不同上下文中使用相同键的映射相互冲突，可以分配一个 `IKeyConflictContext`。
+
+每个冲突上下文都包含两种方法：`#isActive`，定义映射是否可以在当前游戏状态下使用，以及 `#conflicts`，定义映射是否与同一冲突上下文中的键或不同冲突上下文中的键冲突。
+
+目前，Forge 通过 `KeyConflictContext` 定义了三个基本上下文：`UNIVERSAL`，默认为意味着键可以在每个上下文中使用，`GUI`，意味着映射只能在打开 `Screen` 时使用，以及 `IN_GAME`，意味着映射只能在未打开 `Screen` 时使用。可以通过实现 `IKeyConflictContext` 来创建新的冲突上下文。
+
+```java
+new KeyMapping(
+ "key.examplemod.example2",
+ KeyConflictContext.GUI, // 只能在打开屏幕时使用映射
+ InputConstants.Type.MOUSE, // 默认映射在鼠标上
+ GLFW.GLFW_MOUSE_BUTTON_LEFT, // 默认鼠标输入为左键
+ "key.categories.examplemod.examplecategory" // 映射将位于新示例类别中
+)
+```
+
+### `KeyModifier`
+
+模组可能不希望映射在按下修饰键时具有相同的行为（例如 `G` vs `CTRL + G`）。为解决这个问题，Forge 在构造函数中添加了一个额外的参数，以接受一个 `KeyModifier`，该修饰符可以应用控制（`KeyModifier#CONTROL`）、shift（`KeyModifier#SHIFT`）或 alt（`KeyModifier#ALT`）到任何输入。`KeyModifier#NONE` 是默认值，不会应用任何修饰符。
+
+可以通过按住修饰键和相关输入来将修饰符添加到[控制选项菜单][controls]中。
+
+```java
+new KeyMapping(
+ "key.examplemod.example3",
+ KeyConflictContext.UNIVERSAL,
+ KeyModifier.SHIFT, // 默认映射需要按住 shift
+ InputConstants.Type.KEYSYM, // 默认映射在键盘上
+ GLFW.GLFW_KEY_G, // 默认键为 G
+ "key.categories.misc"
+)
+```
+
+## 检查 `KeyMapping`
+
+可以检查 `KeyMapping` 来查看是否已单击它。根据何时，映射可以在条件中用于应用相关逻辑。
+
+### 在游戏中
+
+在游戏中，应通过监听[**Forge 事件总线**][forgebus]上的 `ClientTickEvent` 并在 while 循环中检查 `KeyMapping#consumeClick` 来检查映射是否已被单击。`#consumeClick` 仅在执行输入的次数且尚未处理之前返回 `true`，因此不会
+
+无限制地阻止游戏。
+
+```java
+// 事件仅在 Forge 事件总线上的物理客户端上
+public void onClientTick(ClientTickEvent event) {
+ if (event.phase == TickEvent.Phase.END) { // 由于每个刻度事件都调用两次，因此只调用一次代码
+ while (EXAMPLE_MAPPING.get().consumeClick()) {
+ // 在此处执行单击时要执行的逻辑
+ }
+ }
+}
+```
+
+:::caution
+不要将 `InputEvent` 用作 `ClientTickEvent` 的替代方案。键盘和鼠标输入各有单独的事件，因此它们不会处理任何额外的输入。
+:::
+
+### 在 GUI 内
+
+在 GUI 中，可以在 `GuiEventListener` 方法之一中使用 `IForgeKeyMapping#isActiveAndMatches` 检查映射。可以检查的最常见方法是 `#keyPressed` 和 `#mouseClicked`。
+
+`#keyPressed` 接受 `GLFW` 键令、平台特定的扫描码以及按下的修饰键的位字段。可以通过使用 `InputConstants#getKey` 创建输入来将键与映射进行检查。修饰符已经在映射方法本身中进行了检查。
+
+```java
+// 在某个 Screen 子类中
+@Override
+public boolean keyPressed(int key, int scancode, int mods) {
+ if (EXAMPLE_MAPPING.get().isActiveAndMatches(InputConstants.getKey(key, scancode))) {
+ // 在此处执行按键按下时要执行的逻辑
+ return true;
+ }
+ return super.keyPressed(x, y, button);
+}
+```
+
+:::note
+如果您不拥有要检查 **键** 的屏幕，则可以监听[**Forge 事件总线**][forgebus]上的 `ScreenEvent$KeyPressed` 的 `Pre` 或 `Post` 事件。
+:::
+
+`#mouseClicked` 接受鼠标的 x 位置、y 位置和单击的按钮。鼠标按钮可以使用 `InputConstants$Type#getOrCreate` 与 `MOUSE` 输入创建输入进行与映射的检查。
+
+```java
+// 在某个 Screen 子类中
+@Override
+public boolean mouseClicked(double x, double y, int button) {
+ if (EXAMPLE_MAPPING.get().isActiveAndMatches(InputConstants.TYPE.MOUSE.getOrCreate(button))) {
+ // 在此处执行鼠标单击时要执行的逻辑
+ return true;
+ }
+ return super.mouseClicked(x, y, button);
+}
+```
+
+:::note
+如果您不拥有要检查 **鼠标** 的屏幕，则可以监听[**Forge 事件总线**][forgebus]上的 `ScreenEvent$MouseButtonPressed` 的 `Pre` 或 `Post` 事件。
+:::
+
+[modbus]: ../concepts/events.md#event-buses
+[controls]: https://minecraft.fandom.com/wiki/Controls
+[tk]: ../resources/client/i18n.md#components
+[keyinput]: https://www.glfw.org/docs/3.3/input_guide.html#input_key
+[forgebus]: ../concepts/events.md#registering-an-event-handler
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/resourcelocation.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/resourcelocation.md
new file mode 100644
index 000000000..ee7682cd0
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/resourcelocation.md
@@ -0,0 +1,48 @@
+# 资源位置
+
+`ResourceLocation` 是 Minecraft 中最重要的内容之一。它们用作[注册表][registries]中的键，作为数据或资源文件的标识符，作为代码中模型的引用，以及许多其他地方。`ResourceLocation` 由两部分组成：命名空间和路径，由 `:` 分隔。
+
+命名空间表示资源位置所指的 mod、资源包或数据包。例如，具有模组 ID `examplemod` 的模组将使用 `examplemod` 命名空间。Minecraft 使用 `minecraft` 命名空间。可以根据需要定义额外的命名空间，只需创建相应的数据文件夹，这通常是由数据包执行的，以将其逻辑与 Vanilla 分开。
+
+路径是指你的命名空间内的任何对象的引用。例如，`minecraft:cow` 是指 `minecraft` 命名空间中名为 `cow` 的对象 - 通常此位置将用于从实体注册表中获取 cow 实体。另一个示例是 `examplemod:example_item`，它可能用于从项注册表中获取模组的 `example_item`。
+
+`ResourceLocation` 只能包含小写字母、数字、下划线、点和连字符。路径可能还包含斜杠。请注意，由于 Java 模块的限制，模组 ID 不得包含连字符，这意味着模组命名空间也不得包含连字符（路径仍然允许包含）。
+
+:::info
+`ResourceLocation` 本身并不表示我们要使用它的对象的类型。例如，名为 `minecraft:dirt` 的对象存在于多个位置。由接收 `ResourceLocation` 的对象决定将对象与其关联。
+:::
+
+可以通过调用 `new ResourceLocation("examplemod", "example_item")` 或 `new ResourceLocation("examplemod:example_item")` 来创建新的 `ResourceLocation` 实例。如果使用后者，并且字符串不包含 `:`，则整个字符串将用作路径，而 `minecraft` 将用作命名空间。因此，例如 `new ResourceLocation("example_item")` 将导致 `minecraft:example_item`。
+
+可以使用 `ResourceLocation#getNamespace()` 和 `#getPath()` 分别检索 `ResourceLocation` 的命名空间和路径，并通过 `ResourceLocation#toString()` 检索组合形式。
+
+`ResourceLocation` 是不可变的。`ResourceLocation` 上的所有实用方法，例如 `withPrefix` 或 `withSuffix`，都返回一个新的 `ResourceLocation`。
+
+## 解析 `ResourceLocation`
+
+某些位置，例如注册表，直接使用 `ResourceLocation`。然而，其他一些位置将根据需要解析 `ResourceLocation`。例如：
+
+- `ResourceLocation` 用作 GUI 背景的标识符。例如，熔炉 GUI 使用资源位置 `minecraft:textures/gui/container/furnace.png`。这映射到磁盘上的文件 `assets/minecraft/textures/gui/container/furnace.png`。请注意，在此资源位置中需要 `.png` 后缀。
+- `ResourceLocation` 用作方块模型的标识符。例如，泥土的方块模型使用资源位置 `minecraft:block/dirt`。这映射到磁盘上的文件 `assets/minecraft/models/block/dirt.json`。请注意，在此资源位置中不需要 `.json` 后缀。还请注意，此资源位置自动映射到 `models` 子文件夹。
+- `ResourceLocation` 用作配方的标识符。例如，铁块的合成配方使用资源位置 `minecraft:iron_block`。这映射到磁盘上的文件 `data/minecraft/recipes/iron_block.json`。请注意，在此资源位置中不需要 `.json` 后缀。还请注意，此资源位置自动映射到 `recipes` 子文件夹。
+
+`ResourceLocation` 是否需要文件后缀，以及资源位置解析为什么内容，取决于使用情况。
+
+## `ModelResourceLocation`
+
+`ModelResourceLocation` 是一种特殊类型的资源位置，包含第三部分，称为变体。Minecraft 主要用于区分模型的不同变体，在不同的显示上下文中使用不同的变体（例如三叉戟，在第一人称、第三人称和库存中有不同的模型）。对于项，变体始终为 `inventory`，对于块状态，变体是由属性-值对的逗号分隔字符串组成的（例如 `facing=north,waterlogged=false`），对于没有块状态属性的块为空。
+
+变体附加到常规资源位置，以及 `#`。例如，钻石剑的项模型的完整名称是 `minecraft:diamond_sword#inventory`。然而，在大多数情况下，`inventory` 变体可以省略。
+
+`ModelResourceLocation` 是一个[仅客户端][sides]的类。这意味着引用该类的服务器将因为 `NoClassDefFoundError` 而崩溃。
+
+## `ResourceKey`
+
+`ResourceKey` 将注册表 ID 与注册表名称结合在一起。一个示例是具有注册表 ID `minecraft:item` 和注册表名称 `minecraft:diamond_sword` 的注册表键。与 `ResourceLocation` 不同，`ResourceKey` 实际上指代一个唯一的元素，因此能够清楚地识别一个元素。它们通常用于许多不同的注册表相互接触的情况。一个常见的用例是数据包，特别是世界生成。
+
+可以通过静态方法 `ResourceKey#create(ResourceKey>, ResourceLocation)` 创建新的 `ResourceKey`。这里的第二个参数是注册表名称，而第一个参数是所谓的注册表键。注册表键是一种特殊的 `ResourceKey`，其注册表是根注册表（即所有其他注册表的注册表）。可以通过 `ResourceKey#createRegistryKey(ResourceLocation)` 创建所需注册表的注册表键。
+
+`ResourceKey` 在创建时进行了内部化。这意味着可以并且鼓励通过引用相等性（`==`）进行比较，但它们的创建相对较昂贵。
+
+[registries]: ../concepts/registries.md
+[sides]: ../concepts/sides.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/updatechecker.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/updatechecker.md
new file mode 100644
index 000000000..3f6194d43
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/misc/updatechecker.md
@@ -0,0 +1,63 @@
+Forge更新检查器
+====================
+
+Forge提供了一个非常轻量级的、可选择的更新检查框架。如果任何mod有可用的更新，它将在主菜单的“Mods”按钮和mod列表上显示一个闪烁的图标，以及相应的更新日志。它*不会*自动下载更新。
+
+入门指南
+---------------
+
+首先，您需要在您的 `mods.toml` 文件中指定 `updateJSONURL` 参数。该参数的值应该是一个指向更新JSON文件的有效URL。此文件可以托管在您自己的Web服务器、GitHub或任何您想要的地方，只要所有使用您的mod的用户都可以可靠地访问它。
+
+更新JSON格式
+------------------
+
+JSON本身具有相对简单的格式，如下所示：
+
+```js
+{
+ "homepage": "<您的mod的主页/下载页面>",
+ "": {
+ "": "<此版本的更新日志>",
+ // 列出给定Minecraft版本的所有版本的您的mod，以及它们的更新日志
+ // ...
+ },
+ "promos": {
+ "-latest": "",
+ // 声明给定Minecraft版本的最新的“最新”版本的您的mod
+ "-recommended": "",
+ // 声明给定Minecraft版本的最新的“稳定”版本的您的mod
+ // ...
+ }
+}
+```
+
+这相当容易理解，但一些注意事项：
+
+* `homepage` 下的链接是当mod过期时将向用户显示的链接。
+* Forge使用内部算法来确定您的mod的一个版本字符串是否比另一个版本字符串“更新”。大多数版本方案都应该是兼容的，但如果您担心您的方案是否受支持，请参阅 `ComparableVersion` 类。强烈建议遵循[Maven版本规范][mvnver]。
+* 更新日志字符串可以使用 `\n` 分隔成行。一些人喜欢包含一个简短的更新日志，然后链接到一个提供完整更改列表的外部网站。
+* 手动输入数据可能会很烦琐。您可以将您的 `build.gradle` 配置为在构建发布时自动更新此文件，因为 Groovy 具有原生的JSON解析支持。将此操作留给读者作为练习。
+
+- 这里有一些示例，[nocubes][], [Corail Tombstone][corail] 和 [Chisels & Bits 2][chisel]。
+
+检索更新检查结果
+-------------------------------
+
+您可以使用 `VersionChecker#getResult(IModInfo)` 检索 Forge 更新检查器的结果。您可以通过 `ModContainer#getModInfo` 获取您的 `IModInfo`。您可以在构造函数中使用 `ModLoadingContext.get().getActiveContainer()`，`ModList.get().getModContainerById()` 或 `ModList.get().getModContainerByObject()` 获取您的 `ModContainer`。您可以使用 `ModList.get().getModContainerById()` 获取任何其他 mod 的 `ModContainer`。返回的对象具有一个 `#status` 方法，该方法指示版本检查的状态。
+
+| 状态 | 描述 |
+|----------------:|:------------|
+| `FAILED` | 版本检查器无法连接到提供的URL。 |
+| `UP_TO_DATE` | 当前版本等于推荐版本。 |
+| `AHEAD` | 如果没有最新版本，当前版本比推荐版本新。 |
+| `OUTDATED` | 有新的推荐或最新版本。 |
+| `BETA_OUTDATED` | 有新的最新版本。 |
+| `BETA` | 当前版本等于或比最新版本更新。 |
+| `PENDING` | 请求的结果尚未完成，因此您应该稍后重试。 |
+
+返回的对象还将具有目标版本和任何在 `update.json` 中指定的更新日志行。
+
+[mvnver]: ../gettingstarted/versioning.md
+[nocubes]: https://cadiboo.github.io/projects/nocubes/update.json
+[corail]: https://github.com/Corail31/tombstone_lite/blob/master/update.json
+[chisel]: https://github.com/Aeltumn/Chisels-and-Bits-2/blob/master/update.json
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/configuration-tasks.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/configuration-tasks.md
new file mode 100644
index 000000000..e8f40c032
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/configuration-tasks.md
@@ -0,0 +1,122 @@
+# 使用配置任务
+
+客户端和服务器的网络协议有一个特定的阶段，服务器可以在玩家实际加入游戏之前配置客户端。
+这个阶段称为配置阶段，例如，原版服务器用它来向客户端发送资源包信息。
+
+这个阶段也可以被 mod 用来在玩家加入游戏之前配置客户端。
+
+## 注册配置任务
+使用配置阶段的第一步是注册一个配置任务。
+这可以通过在 `OnGameConfigurationEvent` 事件中注册新的配置任务来完成。
+```java
+@SubscribeEvent
+public static void register(final OnGameConfigurationEvent event) {
+ event.register(new MyConfigurationTask());
+}
+```
+`OnGameConfigurationEvent` 事件在 mod 总线上触发，并暴露了服务器用来配置相关客户端的当前监听器。
+Modder 可以使用暴露的监听器来判断客户端是否运行了 mod，并在是这样的情况下注册一个配置任务。
+
+## 实现配置任务
+配置任务是一个简单的接口：`ICustomConfigurationTask`。
+这个接口有两个方法：`void run(Consumer sender);`，和 `ConfigurationTask.Type type();` 返回配置任务的类型。
+类型用于标识配置任务。
+下面是一个配置任务的示例：
+```java
+public record MyConfigurationTask implements ICustomConfigurationTask {
+ public static final ConfigurationTask.Type TYPE = new ConfigurationTask.Type(new ResourceLocation("mymod:my_task"));
+
+ @Override
+ public void run(final Consumer sender) {
+ final MyData payload = new MyData();
+ sender.accept(payload);
+ }
+
+ @Override
+ public ConfigurationTask.Type type() {
+ return TYPE;
+ }
+}
+```
+
+## 确认配置任务
+您的配置在服务器上执行，服务器需要知道何时可以执行下一个配置任务。
+这可以通过确认所述配置任务的执行来完成。
+
+有两种主要方式可以实现这一点：
+
+### 捕获监听器
+当客户端不需要确认配置任务时，可以捕获监听器，并可以直接在服务器端确认配置任务。
+```java
+public record MyConfigurationTask(ServerConfigurationListener listener) implements ICustomConfigurationTask {
+ public static final ConfigurationTask.Type TYPE = new ConfigurationTask.Type(new ResourceLocation("mymod:my_task"));
+
+ @Override
+ public void run(final Consumer sender) {
+ final MyData payload = new MyData();
+ sender.accept(payload);
+ listener.finishCurrentTask(type());
+ }
+
+ @Override
+ public ConfigurationTask.Type type() {
+ return TYPE;
+ }
+}
+```
+要使用这样的配置任务，需要在 `OnGameConfigurationEvent` 事件中捕获监听器。
+```java
+@SubscribeEvent
+public static void register(final OnGameConfigurationEvent event) {
+ event.register(new MyConfigurationTask(event.listener()));
+}
+```
+然后，在当前配置任务完成后，下一个配置任务将立即执行，客户端不需要确认配置任务。
+此外，服务器将不会等待客户端正确处理发送的载荷。
+
+### 确认配置任务
+当客户端需要确认配置任务时，您将需要向客户端发送自己的载荷：
+```java
+public record AckPayload() implements CustomPacketPayload {
+ public static final ResourceLocation ID = new ResourceLocation("mymod:ack");
+
+ @Override
+ public void write(final FriendlyByteBuf buffer) {
+ // 无需写入数据
+ }
+
+ @Override
+ public ResourceLocation id() {
+ return ID;
+ }
+}
+```
+当服务器端配置任务发送的有效载荷被正确处理时，您可以向服务器发送此载荷以确认配置任务。
+```java
+public void onMyData(MyData data, ConfigurationPayloadContext context) {
+ context.submitAsync(() -> {
+ blah(data.name());
+ })
+ .exceptionally(e -> {
+ // 处理异常
+ context.packetHandler().disconnect(Component.translatable("my_mod.configuration.failed", e.getMessage()));
+ return null;
+ })
+ .thenAccept(v -> {
+ context.replyHandler().send(new AckPayload());
+ });
+}
+```
+其中 `onMyData` 是处理由服务器端配置任务发送的载荷的处理程序。
+
+当服务器接收到此载荷时，将确认配置任务，并将执行下一个配置任务：
+```java
+public void onAck(AckPayload payload, ConfigurationPayloadContext context) {
+ context.taskCompletedHandler().onTaskCompleted(MyConfigurationTask.TYPE);
+}
+```
+其中 `onAck` 是处理由客户端发送的载荷的处理程序。
+
+## 阻塞登录过程
+当配置未被确认时，服务器将永远等待，客户端将永远无法加入游戏。
+因此，始终确认配置任务非常重要，除非配置任务失败，然后您可以断开客户端的连接。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/entities.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/entities.md
new file mode 100644
index 000000000..07af05890
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/entities.md
@@ -0,0 +1,29 @@
+# 实体
+
+除了常规的网络消息外，还提供了各种其他系统来处理实体数据的同步。
+
+## 生成数据
+自 1.20.2 版本以来，Mojang 引入了 Bundle 数据包的概念，用于将实体生成数据包一起发送。
+这允许更多的数据与生成数据包一起发送，并且使得数据的发送更有效率。
+
+您可以通过实现以下接口向 Forge 发送的生成数据包添加额外数据。
+
+### IEntityWithComplexSpawn
+如果您的实体具有在客户端上需要但随时间不变的数据，则可以使用此接口将其添加到实体生成数据包中。`#writeSpawnData` 和 `#readSpawnData` 控制如何将数据编码到/从网络缓冲区中解码。
+或者，您可以重写 `sendPairingData(...)` 方法，该方法在实体与客户端配对时调用。此方法在服务器上调用，可用于在生成数据包的同一捆绑包中向客户端发送附加负载。
+
+## 动态数据
+### 数据参数
+
+这是将实体数据从服务器同步到客户端的主要原始系统。因此，有许多可用于参考的原始示例。
+
+首先，您需要为要保持同步的数据获取一个 `EntityDataAccessor`。这应该作为您的实体类中的 `static final` 字段存储，通过调用 `SynchedEntityData#defineId` 并传递实体类和该类型数据的序列化程序来获得。可用的序列化程序实现可以在 `EntityDataSerializers` 类的静态常量中找到。
+
+:::caution
+您应该 __仅__ 为您自己的实体创建数据参数，在该实体类内部。
+为您无法控制的实体添加参数可能会导致用于通过网络发送该数据的 ID 不同步，导致难以调试的崩溃。
+:::
+
+然后，重写 `Entity#defineSynchedData` 并为每个数据参数调用 `this.entityData.define(...)`，传递参数和要使用的初始值。记得始终先调用 `super` 方法！
+
+然后，您可以通过实体的 `entityData` 实例获取和设置这些值。所做的更改将自动同步到客户端。
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/index.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/index.md
new file mode 100644
index 000000000..6a0cb4b8c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/index.md
@@ -0,0 +1,18 @@
+# 网络通信
+
+服务器和客户端之间的通信是成功实现模组的基础。
+
+网络通信有两个主要目标：
+
+1. 确保客户端视图与服务器视图“同步”
+ - 在坐标 (X, Y, Z) 处的花刚刚生长了
+2. 让客户端告诉服务器有关玩家状态变化的信息
+ - 玩家按下了一个键
+
+实现这些目标最常见的方式是在客户端和服务器之间传递消息。这些消息通常会被结构化，按特定的排列方式包含数据，以便于发送和接收。
+
+NeoForge 提供了一种技术来促进通信，主要建立在 [netty][] 之上。
+通过监听 `RegisterPayloadHandlerEvent` 事件，可以注册特定类型的 [负载][payloads]、其读取器和处理函数到注册器中。
+
+[netty]: https://netty.io "Netty Website"
+[payloads]: ./payload.md "Registering custom Payloads"
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/payload.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/payload.md
new file mode 100644
index 000000000..b549ec2e4
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/networking/payload.md
@@ -0,0 +1,98 @@
+# 注册负载
+
+负载是在客户端和服务器之间发送任意数据的一种方法。它们使用从 `RegisterPayloadHandlerEvent` 事件中获取的 `IPayloadRegistrar` 进行注册，该事件可以为给定的命名空间检索到。
+```java
+@SubscribeEvent
+public static void register(final RegisterPayloadHandlerEvent event) {
+ final IPayloadRegistrar registrar = event.registrar("mymod");
+}
+```
+
+假设我们想要发送以下数据：
+```java
+public record MyData(String name, int age) {}
+```
+
+然后，我们可以实现 `CustomPacketPayload` 接口来创建一个可用于发送和接收此数据的负载。
+```java
+public record MyData(String name, int age) implements CustomPacketPayload {
+
+ public static final ResourceLocation ID = new ResourceLocation("mymod", "my_data");
+
+ public MyData(final FriendlyByteBuf buffer) {
+ this(buffer.readUtf(), buffer.readInt());
+ }
+
+ @Override
+ public void write(final FriendlyByteBuf buffer) {
+ buffer.writeUtf(name());
+ buffer.writeInt(age());
+ }
+
+ @Override
+ public ResourceLocation id() {
+ return ID;
+ }
+}
+```
+从上面的示例中可以看出，`CustomPacketPayload` 接口要求我们实现 `write` 和 `id` 方法。`write` 方法负责将数据写入缓冲区，而 `id` 方法负责返回此负载的唯一标识符。
+然后，我们还需要一个读取器来稍后进行注册，在这里我们可以使用自定义构造函数从缓冲区中读取数据。
+
+最后，我们可以使用注册器注册此负载：
+```java
+@SubscribeEvent
+public static void register(final RegisterPayloadHandlerEvent event) {
+ final IPayloadRegistrar registrar = event.registrar("mymod");
+ registrar.play(MyData.ID, MyData::new, handler -> handler
+ .client(ClientPayloadHandler.getInstance()::handleData)
+ .server(ServerPayloadHandler.getInstance()::handleData));
+}
+```
+分解上面的代码，我们可以注意到几件事情：
+- 注册器有一个 `play` 方法，可用于注册在游戏播放阶段发送的负载。
+ - 此代码中未显示的方法还有 `configuration` 和 `common`，但它们也可以用于为配置阶段注册负载。`common` 方法可用于同时为配置和游戏播放阶段注册负载。
+- `MyData` 的构造函数被用作方法引用，以创建负载的读取器。
+- 注册方法的第三个参数是一个回调，用于注册负载到达客户端或服务器端时的处理程序。
+ - `client` 方法用于在负载到达客户端时注册处理程序。
+ - `server` 方法用于在负载到达服务器端时注册处理程序。
+ - 在注册器本身上还有一个次要的注册方法 `play`，它接受客户端和服务器端的处理程序，可以用于同时为两端注册处理程序。
+
+现在我们已经注册了负载，我们需要实现一个处理程序。
+在此示例中，我们将特别关注客户端端处理程序，但服务器端处理程序非常相似。
+```java
+public class ClientPayloadHandler {
+
+ private static final ClientPayloadHandler INSTANCE = new ClientPayloadHandler();
+
+ public static ClientPayloadHandler getInstance() {
+ return INSTANCE;
+ }
+
+ public void handleData(final MyData data, final PlayPayloadContext context) {
+ // 处理数据，在网络线程上
+ blah(data.name());
+
+ // 在主游戏线程上处理数据
+ context.workHandler().submitAsync(() -> {
+ blah(data.age());
+ })
+ .exceptionally(e -> {
+ // 处理异常
+ context.packetHandler().disconnect(Component.translatable("my_mod.networking.failed", e.getMessage()));
+ return null;
+ });
+ }
+}
+```
+这里需要注意几件事情：
+- 此处处理方法获取负载和上下文对象。上下文对象对于播放和配置阶段是不同的，如果注册了一个通用负载，则需要接受两个上下文的超类型。
+- 负载方法的处理程序在网络线程上调用，因此重要的是在此处进行所有繁重的工作，而不是阻塞主游戏线程。
+- 如果要在主游戏线程上运行代码，可以使用上下文的 `workHandler` 提交任务到主线程。
+ - `workHandler` 将返回一个在主线程上完成的 `CompletableFuture`，可以用于提交任务到主线程。
+ - 注意：返回的是 `CompletableFuture`，这意味着您可以将多个任务链接在一起，并在单个位置处理异常。
+ - 如果不在 `CompletableFuture` 中处理异常，则它将被忽略，**您将不会收到任何通知**。
+
+现在您知道了如何为您的模组促进客户端和服务器之间的通信，您可以开始实现自己的负载。
+有了自己的负载，您就可以使用它们来配置客户端和服务器，使用[配置任务][]。
+
+[配置任务]: ./configuration-tasks.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/_category_.json b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/_category_.json
new file mode 100644
index 000000000..f785d798d
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/_category_.json
@@ -0,0 +1,3 @@
+{
+ "label": "Client"
+}
\ No newline at end of file
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/i18n.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/i18n.md
new file mode 100644
index 000000000..54bb13b3c
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/i18n.md
@@ -0,0 +1,181 @@
+# I18n 与 L10n
+
+I18n（国际化的简称）是一种设计程序以适应多种语言的方法。L10n（本地化的简称）是将文本翻译成用户语言的过程。Minecraft使用`Component`来实现这些功能。
+
+## `Component`组件
+
+`Component`是有元数据的文本片段，元数据包括如文本格式化等内容。它可以通过以下方式之一创建（以下都是`Component`接口中的静态方法）：
+
+| 方法 | 描述 |
+|-----------------|--------------------------------------------------------------------------------------------------|
+| `empty` | 创建一个空组件。 |
+| `literal` | 创建一个具有给定文本的组件，并直接显示该文本，而不进行翻译。 |
+| `nullToEmpty` | 对于给定的null创建一个空组件，否则创建一个文字组件。 |
+| `translatable` | 创建一个可翻译的组件。给定的字符串随后会被解析为翻译键（见下文）。 |
+| `keybind` | 创建一个包含给定按键绑定的（翻译后的）显示名称的组件。 |
+| `nbt` | 创建一个表示给定路径上的[NBT][nbt]的组件。 |
+| `score` | 创建一个包含记分板目标值的组件。 |
+| `selector` | 创建一个组件，包含给定[实体选择器][selector]的实体名称列表。 |
+
+`Component.translatable()`还有一个可变参数，接受字符串插值元素。这与Java的`String#format`类似，但总是使用`%s`代替`%i`、`%d`、`%f`和任何其他格式说明符，在需要时调用`#toString()`。
+
+每个`Component`都可以使用`#getString()`来解析。解析通常是惰性的，这意味着服务器可以指定一个`Component`，将其发送给客户端，然后客户端会各自解析`Component`（不同语言可能导致不同的文本）。Minecraft中的许多地方也会直接接受`Component`并为你解决解析问题。
+
+:::caution
+永远不要让服务器翻译`Component`。总是将`Component`发送到客户端并在那里解析它们。
+:::
+
+### 文本格式化
+
+`Component`可以使用`Style`进行格式化。`Style`是不可变的，修改时会创建一个新的`Style`对象，因此允许一次创建，然后根据需要重复使用。
+
+`Style.EMPTY`通常可以用作工作的基础。可以通过`Style#applyTo(Style other)`合并多个`Style`，该方法返回一个新的`Style`，它从被`applyTo()`方法调用的`Style`中取得设置，除非相应的设置不存在，在这种情况下，则使用作为参数传入的`Style`中的设置。然后可以这样将`Style`应用到组件上：
+
+```java
+Component text = Component.literal("Hello World!");
+
+// Create a new style.
+Style blue = Style.EMPTY.withColor(0x0000FF);
+// Styles use a builder-like pattern.
+Style blueItalic = Style.EMPTY.withColor(0x0000FF).withItalic(true);
+// Besides italic, we can also make styles bold, underlined, strikethrough, or obfuscated.
+Style bold = Style.EMPTY.withBold(true);
+Style underlined = Style.EMPTY.withUnderlined(true);
+Style strikethrough = Style.EMPTY.withStrikethrough(true);
+Style obfuscated = Style.EMPTY.withObfuscated(true);
+// Let's merge some styles together!
+Style merged = blueItalic.applyTo(bold).applyTo(strikethrough);
+
+// Set a style on a component.
+text.setStyle(merged);
+// Merge a new style into it.
+text.withStyle(Style.EMPTY.withColor(0xFF0000));
+```
+
+另一个更复杂的格式化选项是使用点击和悬停事件：
+
+```java
+// We have a total of 6 options for a click event, and a total of 3 options for a hover event.
+ClickEvent clickEvent;
+HoverEvent hoverEvent;
+
+// Opens the given URL in your default browser when clicked.
+clickEvent = new ClickEvent(ClickEvent.Action.OPEN_URL, "http://example.com/");
+// Opens the given file when clicked. For security reasons, this cannot be sent from a server.
+clickEvent = new ClickEvent(ClickEvent.Action.OPEN_FILE, "C:/example.txt");
+// Runs the given command when clicked.
+clickEvent = new ClickEvent(ClickEvent.Action.RUN_COMMAND, "/gamemode creative");
+// Suggests the given command in the chat when clicked.
+clickEvent = new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, "/gamemode creative");
+// Changes a book page when clicked. Irrelevant outside of a book screen context.
+clickEvent = new ClickEvent(ClickEvent.Action.CHANGE_PAGE, "1");
+// Copies the given text to the clipboard.
+clickEvent = new ClickEvent(ClickEvent.Action.COPY_TO_CLIPBOARD, "Hello World!");
+
+// Shows the given component when hovered. May be formatted as well.
+// Keep in mind that click or hover events won't work in a hover tooltip for obvious reasons.
+hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_TEXT, Component.literal("Hello World!"));
+// Shows a complete tooltip of the given item stack when hovered.
+// See the possible constructors of ItemStackInfo.
+hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_ITEM, new HoverEvent.ItemStackInfo(...));
+// Shows a complete tooltip of the given entity when hovered.
+// See the possible constructors of EntityTooltipInfo.
+hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_ENTITY, new HoverEvent.EntityTooltipInfo(...));
+
+// Apply the events to a style.
+Style clickable = Style.EMPTY.withClickEvent(clickEvent);
+Style hoverable = Style.EMPTY.withHoverEvent(hoverEvent);
+```
+
+## 语言文件
+
+语言文件是包含从翻译键（见下文）到实际名称的映射的JSON文件。它们位于`assets//lang/language_name.json`。例如，对于一个id为`examplemod`的mod，US English的翻译将位于`assets/examplemod/lang/en_us.json`。可以在[这里][mcwikilang]找到Minecraft支持的所有语言的完整列表。
+
+一个语言文件通常看起来是这样的：
+
+```json
+{
+ "translation.key.1": "Translation 1",
+ "translation.key.2": "Translation 2"
+}
+```
+
+### 翻译键
+
+翻译键是在翻译中使用的键。在许多情况下，它们遵循格式`registry.modid.name`。例如，一个id为`examplemod`的mod提供了一个名为`example_block`的方块，可能会希望为键`block.examplemod.example_block`提供翻译。然而，你基本上可以使用任何字符串作为翻译键。
+
+如果选定语言中没有与翻译键相关联的翻译，游戏将回退到US English（`en_us`），除非已经选择了US English。如果US English也没有翻译，翻译将静默失败，并代之以显示原始翻译键。
+
+Minecraft的一些地方为你提供了获取翻译键的辅助方法。例如，方块和物品都提供了`#getDescriptionId`方法。这些不仅可以被查询，而且在需要时也可以被覆盖。一个常见的用例是，根据它们的[NBT][nbt]值有不同名称的物品。这些通常会覆盖带有[`ItemStack`][itemstack]参数的`#getDescriptionId`变体，并根据堆栈的NBT返回不同的值。另一个常见的用例是`BlockItem`，它覆盖该方法以使用关联方块的翻译键。
+
+:::tip
+翻译键的唯一目的是用于本地化。不要用它们来处理游戏逻辑，游戏逻辑应该使用[注册名称][regname]。
+:::
+
+### 翻译Mod元数据
+
+从NeoForge 20.4.179版本开始，翻译文件可以使用以下键（其中`modid`需替换为实际的mod id）覆盖[mod信息][modstoml]的某些部分：
+
+| | 翻译键 | 覆盖内容 |
+|--------------|--------------------------------------------|-------------------------------------------------------------------------------|
+| 显示名称 | `fml.menu.mods.info.displayname.modid` | 可在`[[mods]]`部分中放置一个名为`displayName`的字段代替。 |
+| 描述 | `fml.menu.mods.info.description.modid` | 可在`[[mods]]`部分中放置一个名为`description`的字段代替。 |
+
+### 数据生成
+
+语言文件可以[通过数据生成][datagen]来创建。要这样做，请扩展`LanguageProvider`类并在`addTranslations()`方法中添加你的翻译：
+
+```java
+public class MyLanguageProvider extends LanguageProvider {
+ public MyLanguageProvider(PackOutput output) {
+ super(
+ // Provided by the GatherDataEvent.
+ output,
+ // Your mod id.
+ "examplemod",
+ // The locale to use. You may use multiple language providers for different locales.
+ "en_us"
+ );
+ }
+
+ @Override
+ protected void addTranslations() {
+ // Adds a translation with the given key and the given value.
+ add("translation.key.1", "Translation 1");
+
+ // Helpers are available for various common object types. Every helper has two variants: an add() variant
+ // for the object itself, and an addTypeHere() variant that accepts a supplier for the object.
+ // The different names for the supplier variants are required due to generic type erasure.
+ // All following examples assume the existence of the values as suppliers of the needed type.
+
+ // Adds a block translation.
+ add(MyBlocks.EXAMPLE_BLOCK.get(), "Example Block");
+ addBlock(MyBlocks.EXAMPLE_BLOCK, "Example Block");
+ // Adds an item translation.
+ add(MyItems.EXAMPLE_ITEM.get(), "Example Item");
+ addItem(MyItems.EXAMPLE_ITEM, "Example Item");
+ // Adds an item stack translation. This is mainly for items that have NBT-specific names.
+ add(MyItems.EXAMPLE_ITEM_STACK.get(), "Example Item");
+ addItemStack(MyItems.EXAMPLE_ITEM_STACK, "Example Item");
+ // Adds an entity type translation.
+ add(MyEntityTypes.EXAMPLE_ENTITY_TYPE.get(), "Example Entity");
+ addEntityType(MyEntityTypes.EXAMPLE_ENTITY_TYPE, "Example Entity");
+ // Adds an enchantment translation.
+ add(MyEnchantments.EXAMPLE_ENCHANTMENT.get(), "Example Enchantment");
+ addEnchantment(MyEnchantments.EXAMPLE_ENCHANTMENT, "Example Enchantment");
+ // Adds a mob effect translation.
+ add(MyMobEffects.EXAMPLE_MOB_EFFECT.get(), "Example Effect");
+ addEffect(MyMobEffects.EXAMPLE_MOB_EFFECT, "Example Effect");
+ }
+}
+```
+
+然后，在`GatherDataEvent`中像注册其他提供者一样注册这个提供者。
+
+[datagen]: ../index.md#data-generation
+[itemstack]: ../../items/index.md#itemstacks
+[mcwikilang]: https://minecraft.wiki/w/Language
+[modstoml]: ../../gettingstarted/modfiles.md#modstoml
+[nbt]: ../../datastorage/nbt.md
+[regname]: ../../concepts/registries.md
+[selector]: https://minecraft.wiki/w/Target_selectors
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/bakedmodel.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/bakedmodel.md
new file mode 100644
index 000000000..214e08d5f
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/bakedmodel.md
@@ -0,0 +1,138 @@
+# 烘焙模型
+
+`BakedModel` 是带有纹理的形状在代码中的表示形式。它们可以来自多个来源，例如通过 `UnbakedModel#bake`（默认模型加载器）或 `IUnbakedGeometry#bake`（[自定义模型加载器][modelloader]）的调用生成。一些[方块实体渲染器][ber]也使用烘焙模型。模型的复杂度没有限制。
+
+模型存储在 `ModelManager` 中，可以通过 `Minecraft.getInstance().modelManager` 访问。然后，您可以调用 `ModelManager#getModel` 通过其 [`ResourceLocation`][rl] 或 [`ModelResourceLocation`][mrl] 获取特定模型。模组基本上总是重用之前自动加载和烘焙的模型。
+
+## `BakedModel` 的方法
+
+### `getQuads`
+
+烘焙模型最重要的方法是 `getQuads`。此方法负责返回 `BakedQuad` 的列表，这些列表随后可以发送到 GPU。在建模程序中（以及大多数其他游戏中），四边形类似于三角形，然而由于 Minecraft 通常关注于方形，开发者选择使用四边形（4个顶点）而非三角形（3个顶点）进行渲染。`getQuads` 有五个参数可用：
+
+- `BlockState`：正在渲染的[方块状态][blockstate]。可能为空，表示正在渲染物品。
+- `Direction`：正在剔除的面的方向。可能为空，这意味着应该返回不可遮挡的四边形。
+- `RandomSource`：客户端绑定的随机源，您可以用于随机化。
+- `ModelData`：使用的额外模型数据。这可能包含方块实体渲染所需的额外数据。由 `BakedModel#getModelData` 提供。
+- `RenderType`：用于渲染方块的[渲染类型][rendertype]。可能为空，表示应返回此模型使用的所有渲染类型的四边形。否则，它是 `BakedModel#getRenderTypes` 返回的渲染类型之一（见下文）。
+
+模型应该大量缓存。这是因为即使区块只有在其中一个方块更改时才重建，但此方法中的计算仍需尽可能快速，并且理想情况下由于该方法将被每个区块部分调用多次（每个给定模型使用的渲染类型的次数 * 每个模型使用的渲染类型的数量 * 每个区块部分 4096 个方块），因此应该进行大量缓存。此外，[方块实体渲染器][ber]或实体渲染器实际上可能每帧调用此方法几次。
+
+### `applyTransform` 和 `getTransforms`
+
+`applyTransform` 允许在应用模型的透视变换时应用自定义逻辑，包括返回完全不同的模型。此方法由 NeoForge 添加，替代了 vanilla 的 `getTransforms()` 方法，后者只允许您自定义变换本身，而不能自定义应用方式。然而，`applyTransform` 的默认实现遵循 `getTransforms`，所以如果您只需要自定义变换，也可以重写 `getTransforms` 并完成它。`applyTransforms` 提供三个参数：
+
+- `ItemDisplayContext`：模型正在转换到的[透视][perspective]。
+- `PoseStack`：用于渲染的姿势堆栈。
+- `boolean`：是否使用修改后的值进行左手渲染，而不是默认的右手渲染；如果渲染的手是左手（副手，或在选项中启用
+
+左手模式的主手），则为 `true`。
+
+:::note
+`applyTransform` 和 `getTransforms` 仅适用于物品模型。
+:::
+
+### 其他
+
+您可能会重写和/或查询的其他 `BakedModel` 方法包括：
+
+| 签名 | 效果 |
+|---|---|
+| `TriState useAmbientOcclusion()` | 是否使用[环境光遮蔽][ao]。接受 `BlockState`、`RenderType` 和 `ModelData` 参数，并返回 `TriState`，这不仅允许强制禁用 AO，还允许强制启用 AO。有两个重载，每个都返回一个 `boolean` 参数，并只接受 `BlockState` 或无参数；这两个都已弃用，将被第一个变体取代。 |
+| `boolean isGui3d()` | 此模型在 GUI 插槽中是否渲染为 3D 或平面。 |
+| `boolean usesBlockLight()` | 在照亮模型时是否使用 3D 照明（`true`）或正面的平面照明（`false`）。 |
+| `boolean isCustomRenderer()` | 如果为真，跳过正常渲染并调用关联的 [`BlockEntityWithoutLevelRenderer`][bewlr] 的 `renderByItem` 方法。如果为假，则通过默认渲染器渲染。 |
+| `ItemOverrides getOverrides()` | 返回与此模型相关的 [`ItemOverrides`][itemoverrides]。这仅在物品模型中相关。 |
+| `ModelData getModelData(BlockAndTintGetter, BlockPos, BlockState, ModelData)` | 返回用于模型的模型数据。此方法传递一个现有的 `ModelData`，如果方块有关联的方块实体，则为 `BlockEntity#getModelData()` 的结果，如果不是这种情况，则为 `ModelData.EMPTY`。此方法可用于需要模型数据但没有方块实体的方块，例如具有连接纹理的方块。 |
+| `TextureAtlasSprite getParticleIcon(ModelData)` | 返回用于模型的粒子精灵。可以使用模型数据为不同的模型数据值使用不同的粒子精灵。NeoForge 添加，替换了没有参数的 vanilla `getParticleIcon()` 重载。 |
+| `ChunkRenderTypeSet getRenderTypes(BlockState, RandomSource, ModelData)` | 返回包含用于渲染方块模型的渲染类型的 `ChunkRenderTypeSet`。`ChunkRenderTypeSet` 是一个支持集合的有序 `Iterable`。默认回退到从模型 JSON [获取渲染类型][rendertype]。仅用于方块模型，物品模型使用下面的重载。 |
+| `List getRenderTypes(ItemStack, boolean)` | 返回包含用于渲染物品模型的渲染类型的 `List`。默认回退到正常的模型绑定渲染类型查找，这总是产生一个元素的列表。仅用于物品模型，方块模型使用上面的重载。 |
+
+## 透视
+
+Minecraft 的渲染引擎总共识别 8 种透视类型（如果包括代码中的回退，则为 9 种）用于物品渲染。这些在模型 JSON 的 `display` 块中使用，并在代码中通过 `ItemDisplayContext` 枚举表示。
+
+| 枚举值 | JSON 键 | 用途 |
+|---|---|---|
+| `THIRD_PERSON_RIGHT_HAND` | `"thirdperson_righthand"` | 第三人称右手（F5 视图，或其他玩家上） |
+| `THIRD_PERSON_LEFT_HAND` | `"thirdperson_lefthand"` | 第三人称左手（F5 视图，或其他玩家上） |
+| `FIRST_PERSON_RIGHT_HAND` | `"firstperson_righthand"` | 第一人称右手 |
+| `FIRST_PERSON_LEFT_HAND` | `"firstperson_lefthand"` | 第一人
+
+称左手 |
+| `HEAD` | `"head"` | 玩家头部装备槽中（通常只能通过命令实现） |
+| `GUI` | `"gui"` | 背包，玩家快捷栏 |
+| `GROUND` | `"ground"` | 掉落物；注意，掉落物的旋转是由掉落物渲染器处理的，而非模型 |
+| `FIXED` | `"fixed"` | 物品框 |
+| `NONE` | `"none"` | 代码中的回退用途，不应在 JSON 中使用 |
+
+## `ItemOverrides`
+
+`ItemOverrides` 是一个类，提供了一种方式让烘焙模型处理 [`ItemStack`][itemstack] 的状态并通过 `#resolve` 方法返回新的烘焙模型。`#resolve` 有五个参数：
+
+- `BakedModel`：原始模型。
+- `ItemStack`：正在渲染的物品堆栈。
+- `ClientLevel`：模型正在其中渲染的级别。这应该只用于查询级别，不得以任何方式修改。可能为空。
+- `LivingEntity`：模型渲染在其上的实体。可能为空，例如在[方块实体渲染器][ber]中渲染时。
+- `int`：用于随机化的种子。
+
+`ItemOverrides` 还持有模型的覆盖选项作为 `BakedOverride`。`BakedOverride` 的对象是模型的 [`overrides`][overrides] 块在代码中的表示形式。它可以由烘焙模型使用，根据其内容返回不同的模型。可以通过 `ItemOverrides#getOverrides()` 检索 `ItemOverrides` 实例的所有 `BakedOverride` 列表。
+
+## `BakedModelWrapper`
+
+`BakedModelWrapper` 可用于修改已存在的 `BakedModel`。`BakedModelWrapper` 是 `BakedModel` 的一个子类，它在构造函数中接受另一个 `BakedModel`（“原始”模型），并默认将所有方法重定向到原始模型。然后，您的实现可以选择只覆盖某些方法，如下所示：
+
+```java
+// 泛型参数可以是 BakedModel 的更具体的子类。
+// 如果是这样，构造参数必须匹配该类型。
+public class MyBakedModelWrapper extends BakedModelWrapper {
+ // 将原始模型传递给 super。
+ public MyBakedModelWrapper(BakedModel originalModel) {
+ super(originalModel);
+ }
+
+ // 在这里覆盖您想要的方法。如果需要，也可以访问 originalModel。
+}
+```
+
+编写您的模型包装类后，必须将包装器应用于它应影响的模型。在[客户端][sides]的[事件处理器][event]中为 `ModelEvent.ModifyBakingResult` 这样做：
+
+```java
+@SubscribeEvent
+public static void modifyBakingResult(ModelEvent.ModifyBakingResult event) {
+ // 对于方块模型
+ event.getModels().computeIfPresent(
+ // 要修改的模型的模型资源位置。从
+ // BlockModelShaper#stateToModelLocation 获取，参数为受影响的方块状态。
+ BlockModelShaper.stateToModelLocation(MyBlocksClass.EXAMPLE_BLOCK.defaultBlockState()),
+ // 一个带有位置和原始模型为参数的 BiFunction，返回新模型。
+ (location, model) -> new MyBakedModelWrapper(model);
+ );
+ // 对于物品模型
+ event.getModels().computeIfPresent(
+ // 要修改的模型的模型资源位置。
+ new ModelResourceLocation("examplemod", "example_item", "inventory"),
+ // 一个带有位置和原始模型为参数的 BiFunction，返回新模型。
+ (location, model) -> new MyBakedModelWrapper(model);
+ );
+}
+```
+
+:::warning
+通常建议在可能的情况下使用[自定义模型加载器][modelloader
+
+]而不是在 `ModelEvent.ModifyBakingResult` 中包装烘焙模型。如果需要，自定义模型加载器也可以使用 `BakedModelWrapper`。
+:::
+
+[ao]: https://zh.wikipedia.org/wiki/环境光遮蔽
+[ber]: ../../../blockentities/ber.md
+[bewlr]: ../../../items/bewlr.md
+[blockstate]: ../../../blocks/states.md
+[itemoverrides]: #itemoverrides
+[itemstack]: ../../../items/index.md#itemstacks
+[modelloader]: modelloaders.md
+[mrl]: ../../../misc/resourcelocation.md#modelresourcelocations
+[overrides]: index.md#overrides
+[perspective]: #perspectives
+[rendertype]: index.md#render-types
+[rl]: ../../../misc/resourcelocation.md
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/datagen.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/datagen.md
new file mode 100644
index 000000000..b84b30b07
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/datagen.md
@@ -0,0 +1,289 @@
+# 模型数据生成
+
+与大多数JSON数据一样，方块和物品模型可以通过[数据生成][datagen]创建。由于物品和方块模型之间有一些共同之处，因此部分数据生成代码也是相同的。
+
+## 模型数据生成类
+
+### `ModelBuilder`
+
+每个模型都以某种形式的`ModelBuilder`开始 - 通常是`BlockModelBuilder`或`ItemModelBuilder`，具体取决于您要生成的内容。它包含模型的所有属性：其父级、纹理、元素、变换、加载器等。每个属性都可以通过一个方法设置：
+
+| 方法 | 效果 |
+|----------------------------------------------------|----------------------------------------------------------------------------------------------------------|
+| `#texture(String key, ResourceLocation texture)` | 添加具有给定键和给定纹理位置的纹理变量。有一个重载，其中第二个参数是`String`。 |
+| `#renderType(ResourceLocation renderType)` | 设置渲染类型。有一个参数为`String`的重载。有效值的列表见`RenderType`类。 |
+| `#ao(boolean ao)` | 设置是否使用[环境光遮蔽][ao]。 |
+| `#guiLight(GuiLight light)` | 设置GUI光源。可以是`GuiLight.FRONT`或`GuiLight.SIDE`。 |
+| `#element()` | 添加一个新的`ElementBuilder`（相当于向模型添加一个新[element][elements]）。返回该`ElementBuilder`以便进一步修改。|
+| `#transforms()` | 返回构建器的`TransformVecBuilder`，用于设置模型的`display`。 |
+| `#customLoader(BiFunction customLoaderFactory)` | 使用给定的工厂使该模型使用[自定义加载器][custommodelloader]，因此使用自定义加载器构建器。这会改变构建器类型，因此可能会使用不同的方法，这取决于加载器的实现。NeoForge提供了一些开箱即用的自定义加载器，详见链接文章（包括数据生成）。|
+
+:::tip
+虽然可以通过数据生成创建复杂和详细的模型，但建议使用如[Blockbench][blockbench]之类的建模软件创建更复杂的模型，然后直接使用导出的模型或作为其他模型的父级。
+:::
+
+### `ModelProvider`
+
+方块和物品模型数据生成都利用了`ModelProvider`的子类，分别命名为`BlockModelProvider`和`ItemModelProvider`。虽然物品模型数据生成直接扩展`ItemModelProvider`，但方块模型数据生成使用`BlockStateProvider`基类，它内部有一个可以通过`BlockStateProvider#models()`访问的`BlockModelProvider`。此外，`BlockStateProvider`还有自己的内部`ItemModelProvider`，可通过`BlockStateProvider#itemModels()`访问。`ModelProvider`最重要的部分是`getBuilder(String path)`方法，它返回给定位置的`BlockModelBuilder`（或`ItemModelBuilder`）。
+
+然而，`ModelProvider`还包含各种辅助方法。可能最重要的辅助方法是`withExistingParent(String name, ResourceLocation parent)`，它返回一个新的构建器（通过`getBuilder(name)`）并将给定的`ResourceLocation`设置为模型父级。另外两个非常常见的辅助器是`mcLoc(String name)`，返回带有命名空间`minecraft`和给定路径的`ResourceLocation`，以及`modLoc(String name)`，做同样的事情但使用提供者的mod id（通常是您的mod id）而不是`minecraft`。此外，它还提供了各种辅助方法，这些方法是`#withExistingParent`的快捷方式，用于常见事物如板条、楼梯、栅栏、门等。
+
+### `ModelFile`
+
+最后一个重要的类是`ModelFile`。`ModelFile`是
+
+磁盘上模型JSON的代码表示形式。`ModelFile`是一个抽象类，有两个内部子类`ExistingModelFile`和`UncheckedModelFile`。使用`ExistingFileHelper`验证`ExistingModelFile`的存在，而`UncheckedModelFile`被假定为存在而无需进一步检查。此外，`ModelBuilder`也被视为`ModelFile`。
+
+## 方块模型数据生成
+
+现在，要实际生成方块状态和方块模型文件，请扩展`BlockStateProvider`并重写`registerStatesAndModels()`方法。请注意，方块模型总是放置在`models/block`子文件夹中，但引用相对于`models`（即它们必须总是以`block/`为前缀）。在大多数情况下，选择众多预定义辅助方法之一是有意义的：
+
+```java
+public class MyBlockStateProvider extends BlockStateProvider {
+ // 参数值由GatherDataEvent提供。
+ public MyBlockStateProvider(PackOutput output, ExistingFileHelper existingFileHelper) {
+ // 用您自己的mod id替换"examplemod"。
+ super(output, "examplemod", existingFileHelper);
+ }
+
+ @Override
+ protected void registerStatesAndModels() {
+ // 占位符，其用法应替换为实际值。请参阅上文了解如何使用模型构建器，
+ // 以及下文了解模型构建器提供的辅助方法。
+ ModelFile exampleModel = models().withExistingParent("minecraft:block/cobblestone");
+ Block block = MyBlocksClass.EXAMPLE_BLOCK.get();
+ ResourceLocation exampleTexture = modLoc("block/example_texture");
+ ResourceLocation bottomTexture = modLoc("block/example_texture_bottom");
+ ResourceLocation topTexture = modLoc("block/example_texture_top");
+ ResourceLocation sideTexture = modLoc("block/example_texture_front");
+ ResourceLocation frontTexture = modLoc("block/example_texture_front");
+
+ // 创建一个简单的方块模型，每个面都使用相同的纹理。
+ // 纹理必须位于assets//textures/block/.png，
+ // 其中和分别是方块的注册名的命名空间和路径。
+ // 用于大多数（完整）方块，如木板、圆石或砖块。
+ simpleBlock(block);
+ // 接受要使用的模型文件的重载。
+ simpleBlock(block, exampleModel);
+ // 接受一个或多个（变量参数）ConfiguredModel对象的重载。
+ // 有关ConfiguredModel的更多信息，请参见下文。
+ simpleBlock(block, ConfiguredModel.builder().build());
+ // 添加一个带有方块名称的物品模型文件，以给定的模型文件为父级，供方块物品使用。
+ simpleBlockItem(block, exampleModel);
+ // 调用#simpleBlock()（模型文件重载）和#simpleBlockItem的简写。
+ simpleBlockWithItem(block, exampleModel);
+
+ // 添加一个木材方块模型。需要两个纹理，位于assets//textures/block/.png和
+ // assets//textures/block/_top.png，分别引用侧面和顶部纹理。
+ // 请注意，这里的方块输入仅限于RotatedPillarBlock，这是原版木材使用的类。
+ logBlock(block);
+ // 类似于#logBlock，但纹理命名为_side.png和_end.png而不是
+ // .png和_top.png。由石英柱和类似方块使用。
+ // 有一个重载允许您指定不同的纹理基本名称，然后根据需要后缀为_side和_end，
+ // 一个重载允许您指定两个资源位置
+ // 为侧面和端部纹理，以及一个重载允许指定侧面和端部模型文件。
+ axisBlock(block);
+ // #logBlock和#axisBlock的变体，另外允许指定渲染类型。
+ // 有字符串和资源位置变体用于渲染类型，
+ // 与#logBlock和#axisBlock的所有变体结合使用。
+ logBlockWithRenderType(block, "minecraft:cutout");
+ axisBlockWithRenderType(block, mcLoc("cutout_mipped"));
+
+ // 指定一个具有侧面纹理、前面纹理和顶部纹理的水平可旋转方块模型。
+ // 底部将使用侧面纹理。如果不需要前面或顶部纹理，
+ // 只需传入侧面纹理两次。例如，用于熔炉和类似方块。
+ horizontalBlock(block, sideTexture, frontTexture, topTexture);
+ // 指定一个将根据需要旋转的模型文件的水平可旋转方块模型。
+ // 有一个重载，而不是模型文件接受一个Function，
+ // 允许不同的旋转使用不同的模型。例如，用于石切机。
+ horizontalBlock(block, exampleModel);
+ // 指定一个附着在面上的水平可旋转方块模型，例如按钮或拉杆。
+ // 考虑到在地面和天花板上放置方块，并相应旋转它们。
+ // 像#horizontalBlock一样，有一个重载接受一个Function。
+ horizontalFaceBlock(block, exampleModel);
+ // 类似于#horizontalBlock，但用于可向上和向下旋转的方块。
+ // 同样，有一个重载接受一个Function。
+ directionalBlock(block, exampleModel);
+ }
+}
+```
+
+另外，`BlockStateProvider`中存在以下常见方块模型的辅助方法：
+
+- 楼梯
+- 板条
+- 按钮
+- 压力板
+- 标志
+- 栅栏
+- 栅栏门
+- 墙
+- 窗格
+- 门
+- 活板门
+
+在某些情况下，方块状态不需要特殊处理，但模型需要。在这种情况下，可通过`BlockStateProvider#models()`访问的`BlockModelProvider`提供了一些额外的辅助方法，所有这些方法都接受第一个参数为名称，并且大多数与完整立方体有关。它们通常用作例如`simpleBlock`的模型文件参数。辅助方法包括支持`BlockStateProvider`中的方法，以及：
+
+- `withExistingParent`: 前面已经提到，此方法返回一个带有给定父级的新模型构建器。父级必须已经存在或在模型之前创建。
+- `getExistingFile`: 在模型提供者的`ExistingFileHelper`中执行查找，如果存在则返回相应的`ModelFile`，否则抛出`IllegalStateException`。
+- `singleTexture`: 接受一个父级和一个纹理位置，返回一个带有给定父级的模型，并将纹理变量`texture`设置为给定的纹理位置。
+- `sideBottomTop`: 接受一个父级和三个纹理位置，返回一个模型，其侧面、底部和顶部纹理设置为三个纹理位置。
+- `cube`: 接受六个纹理资源位置，分别用于六个面，返回一个完整立方体模型，其六个面设置为六个纹理。
+- `cubeAll`: 接受一个纹理位置，返回一个完整立方体模型，将给定纹理应用于所有六个面。如果愿意，可以将其视为`singleTexture`和`cube`的混合体。
+- `cubeTop`: 接受两个纹理位置，返回一个完整立方体模型，第一个纹理
+
+应用于侧面和底部，第二个纹理应用于顶部。
+- `cubeBottomTop`: 接受三个纹理位置，返回一个完整立方体模型，其侧面、底部和顶部纹理设置为三个纹理位置。如果愿意，可以将其视为`cube`和`sideBottomTop`的混合体。
+- `cubeColumn`和`cubeColumnHorizontal`: 接受两个纹理位置，返回一个“立立”或“横卧”的柱状立方体模型，其侧面和端部纹理设置为两个纹理位置。由`BlockStateProvider#logBlock`、`BlockStateProvider#axisBlock`及其变体使用。
+- `orientable`: 接受三个纹理位置，返回一个带有“前面”纹理的立方体。这三个纹理位置分别是侧面、前面和顶部纹理。
+- `orientableVertical`: `orientable`的变体，省略了顶部参数，改为使用侧面参数。
+- `orientableWithBottom`: `orientable`的变体，其具有一个在前面和顶部参数之间的底部纹理的第四参数。
+- `crop`: 接受一个纹理位置，返回一个带有给定纹理的类似作物的模型，如四种原版作物所使用的。
+- `cross`: 接受一个纹理位置，返回一个带有给定纹理的十字模型，如花、树苗和许多其他植被方块所使用的。
+- `torch`: 接受一个纹理位置，返回一个带有给定纹理的火把模型。
+- `wall_torch`: 接受一个纹理位置，返回一个带有给定纹理的壁挂火把模型（壁挂火把是与立火把不同的方块）。
+- `carpet`: 接受一个纹理位置，返回一个带有给定纹理的地毯模型。
+
+最后，别忘了在事件中注册您的方块状态提供者：
+
+```java
+@SubscribeEvent
+public static void gatherData(GatherDataEvent event) {
+ DataGenerator generator = event.getGenerator();
+ PackOutput output = generator.getPackOutput();
+ ExistingFileHelper existingFileHelper = event.getExistingFileHelper();
+
+ // 其他提供者在这里
+ generator.addProvider(
+ event.includeClient(),
+ new MyBlockStateProvider(output, existingFileHelper)
+ );
+}
+```
+
+### `ConfiguredModel.Builder`
+
+如果默认辅助工具不能满足您的需求，您也可以使用`ConfiguredModel.Builder`直接构建模型对象，然后在`VariantBlockStateBuilder`中使用它们构建`variants`块状态文件，或在`MultiPartBlockStateBuilder`中构建`multipart`块状态文件：
+
+```java
+// 创建一个ConfiguredModel.Builder。或者，您可以使用下面演示的方式之一
+// (VariantBlockStateBuilder.PartialBlockstate#modelForState或MultiPartBlockStateBuilder#part)在适用的情况下。
+ConfiguredModel.Builder builder = ConfiguredModel.builder()
+// 使用一个模型文件。如前所述，可以是ExistingModelFile、UncheckedModelFile，
+// 或某种类型的ModelBuilder。参见上文了解如何使用ModelBuilder。
+ .modelFile(models().withExistingParent("minecraft:block/cobblestone"))
+ // 设置绕x轴和y轴的旋转。
+ .rotationX(90)
+ .rotationY(180)
+ // 设置uv锁定。
+ .uvlock(true)
+ // 设置权重。
+ .weight(5);
+// 构建配置模型。返回类型是一个数组
+// 以考虑同一块状态中可能有多个模型。
+ConfiguredModel[] model = builder.build();
+
+// 获取一个变体块状态构建器。
+VariantBlockStateBuilder variantBuilder = getVariantBuilder(MyBlocksClass.EXAMPLE_BLOCK.get());
+// 创建一个部分状态并设置属性。
+VariantBlockStateBuilder.PartialBlockstate partialState = variantBuilder.partialState
+
+();
+// 为部分块状态添加一个或多个模型。模型是变量参数。
+variantBuilder.addModels(partialState,
+ // 至少指定一个ConfiguredModel.Builder，如上所见。通过#modelForState创建。
+ partialState.modelForState()
+ .modelFile(models().withExistingParent("minecraft:block/cobblestone"))
+ .uvlock(true)
+);
+// 或者，forAllStates(Function)为每个可能的状态创建一个模型。
+// 传递的函数将为每个可能的状态调用一次。
+variantBuilder.forAllStates(state -> {
+ // 根据状态的属性返回一个ConfiguredModel。
+ // 例如，以下代码将根据方块的水平旋转旋转模型。
+ return ConfiguredModel.builder()
+ .modelFile(models().withExistingParent("minecraft:block/cobblestone"))
+ .rotationY((int) state.getValue(BlockStateProperties.HORIZONTAL_FACING).toYRot())
+ .build();
+});
+
+// 获取一个多部分块状态构建器。
+MultiPartBlockStateBuilder multipartBuilder = getMultipartBuilder(MyBlocksClass.EXAMPLE_BLOCK.get());
+// 添加一个新部分。从.part()开始，以.end()结束。
+multipartBuilder.addPart(multipartBuilder.part()
+ // 步骤一：构建模型。multipartBuilder.part()返回一个ConfiguredModel.Builder，
+ // 意味着上面看到的所有方法都可以在这里使用。
+ .modelFile("minecraft:block/cobblestone")
+ // 调用.addModel()。现在模型已构建，我们可以进入步骤二：添加部分数据。
+ .addModel()
+ // 为部分添加条件。需要一个属性
+ // 和至少一个属性值；属性值是变量参数。
+ .condition(BlockStateProperties.FACING, Direction.NORTH, Direction.SOUTH)
+ // 将多部分条件设置为或运算而不是默认的与运算。
+ .useOr()
+ // 创建一个嵌套条件组。
+ .nestedGroup()
+ // 向嵌套组添加一个条件。
+ .condition(BlockStateProperties.FACING, Direction.NORTH)
+ // 仅将这个条件组设置为或运算而不是与运算。
+ .useOr()
+ // 创建另一个嵌套条件组。嵌套组的数量没有限制。
+ .nestedGroup()
+ // 结束嵌套条件组，返回到拥有的部分构建器或条件组级别。
+ // 这里调用两次，因为我们当前有两个嵌套组。
+ .endNestedGroup()
+ .endNestedGroup()
+ // 结束部分构建器并将生成的部分添加到多部分构建器中。
+ .end()
+);
+```
+
+## 物品模型数据生成
+
+生成物品模型相对简单得多，这主要是因为我们直接在`ItemModelProvider`上操作，而不是使用像`BlockStateProvider`这样的中间类，这当然是因为物品模型没有与方块状态文件等价的文件，而是直接使用。
+
+与上面类似，我们创建一个类并让它扩展基础提供者，在这种情况下是`ItemModelProvider`。由于我们直接在`ModelProvider`的子类中，所有的`models()`调用都变成了`this`（或被省略）。
+
+```java
+public class MyItemModelProvider extends ItemModelProvider {
+ public MyItemModelProvider(PackOutput output, ExistingFileHelper existingFileHelper) {
+ super(output, "examplemod", existingFileHelper);
+ }
+
+ @Override
+ protected void registerModels() {
+ // 方块物品通常使用其相应的方块模型作为父级。
+ withExistingParent(MyItemsClass.EXAMPLE_BLOCK_ITEM.get(), modLoc("block/example_block"));
+ // 物品通常使用一个简单的父级和一个纹理。最常见的父级是item/generated和item/handheld。
+ // 在这个例子中，物品纹理位于assets/examplemod/textures/item/example_item.png。
+ // 如果您想要一个更复杂的模型，您可以使用 getBuilder()，然后从中进行工作，就像使用块模型一样。
+ withExistingParent(MyItemsClass.EXAMPLE_ITEM.get(), mcLoc("item/ generated")).texture("layer0", "item/example_item");
+ // 上面的行很常见，因此有一个快捷方式。 请注意项目注册表名称和
+ // 相对于纹理/项目的纹理路径必须匹配。
+ basicItem(MyItemsClass.EXAMPLE_ITEM.get());
+ }
+}
+```
+
+与所有数据提供者一样，不要忘记将您的提供者注册到该事件：
+
+```java
+@SubscribeEvent
+public static void gatherData(GatherDataEvent event) {
+ DataGenerator generator = event.getGenerator();
+ PackOutput output = generator.getPackOutput();
+ ExistingFileHelper existingFileHelper = event.getExistingFileHelper();
+
+ // other providers here
+ generator.addProvider(
+ event.includeClient(),
+ new MyItemModelProvider(output, existingFileHelper)
+ );
+}
+```
+
+[ao]: https://en.wikipedia.org/wiki/Ambient_occlusion
+[blockbench]: https://www.blockbench.net
+[custommodelloader]: modelloaders.md#datagen
+[datagen]: ../../index.md#data-generation
+[elements]: index.md#elements
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/index.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/index.md
new file mode 100644
index 000000000..04f3b3324
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/index.md
@@ -0,0 +1,305 @@
+模型是JSON文件，确定方块或物品的视觉形状和纹理。模型由立方体元素组成，每个元素都有自己的大小，然后每个面都被分配一个纹理。
+
+每个物品通过其注册名称被分配一个物品模型。例如，注册名称为 `examplemod:example_item` 的物品将被分配到 `assets/examplemod/models/item/example_item.json` 中的模型。对于方块来说，情况稍微复杂一些，因为它们首先被分配一个方块状态文件。更多信息请参见[下文][bsfile]。
+
+## 规范
+
+_另请参阅：[Minecraft Wiki][mcwiki]上的[模型][mcwikimodel]_
+
+模型是一个具有以下可选属性的JSON文件：
+
+- `loader`：NeoForge添加的。设置自定义模型加载器。有关更多信息，请参阅[自定义模型加载器][custommodelloader]。
+- `parent`：设置父模型，格式为相对于 `models` 文件夹的[资源位置][rl]。所有父属性将首先应用，然后被声明模型中设置的属性覆盖。常见的父模型包括：
+ - `minecraft:block/block`：所有方块模型的通用父模型。
+ - `minecraft:block/cube`：所有使用1x1x1立方体模型的模型的父模型。
+ - `minecraft:block/cube_all`：使用相同纹理在所有六个面上的立方体模型变种，例如圆石或木板。
+ - `minecraft:block/cube_bottom_top`：使用相同纹理在所有四个水平面上，并在顶部和底部使用单独的纹理的立方体模型变种。常见示例包括砂岩或镶嵌石英。
+ - `minecraft:block/cube_column`：具有侧面纹理和底部和顶部纹理的立方体模型变种。示例包括木头原木，以及石英和紫珀柱。
+ - `minecraft:block/cross`：使用两个具有相同纹理的平面，一个顺时针旋转45°，另一个逆时针旋转45°，从上方看形成X形（因此得名）。示例包括大多数植物，例如草、树苗和花朵。
+ - `minecraft:item/generated`：经典的2D平面物品模型的父模型。大多数物品都使用此模型。由于其四边形是从纹理生成的，因此会忽略 `elements` 块。
+ - `minecraft:item/handheld`：用于看起来实际由玩家持有的2D平面物品模型的父模型。主要由工具使用。作为 `item/generated` 的子模型，因此它也会忽略 `elements` 块。
+ - `minecraft:builtin/entity`：指定除 `particle` 外没有其他纹理。如果这是父模型，则[`BakedModel#isCustomRenderer()`][iscustomrenderer]将返回 `true`，以允许使用 [`BlockEntityWithoutLevelRenderer`][bewlr]。
+ - 方块物品通常（但不总是）使用其对应的方块模型作为父模型。例如，圆石物品模型使用父模型 `minecraft:block/cobblestone`。
+- `ambientocclusion`：是否启用[环境光遮蔽][ao]。仅在方块模型上有效。默认为 `true`。如果您的自定义方块模型具有奇怪的阴影，请尝试将其设置为 `false`。
+- `render_type`：参见[渲染类型][rendertype]。
+- `gui_light`：可以是 `"front"` 或 `"side"`。如果是 `"front"`，光将来自前方，对于平面2D模型很有用。如果是 `"side"`，光将来自侧面，对于3D模型（尤其是方块模型）很有用。默认为 `"side"`。仅在物品模型上有效。
+- `textures`：一个子对象，将名称（称为纹理变量）映射到[纹理位置][textures]。然后可以在[elements]中使用纹理变量。它们也可以在元素中指定，但在子模型中保留未指定。
+ - 方块模型还应指定一个 `particle` 纹理。当坠落在、穿越或破坏方块时，将使用此纹理。
+ - 物品模型还可以使用层纹理，命名为 `layer0`、`layer1` 等，其中具有较高索引的层会呈现在具有较低索引的层上方（例如 `layer1` 将呈现在 `layer0` 上方）。仅在父模型为 `item/generated` 时有效，最多支持5层（`layer0` 到 `layer4`）。
+- `elements`：立方体[元素]的列表。
+- `overrides`：[覆盖模型][overrides]的列表。仅在物品模型上有效。
+- `display`：包含不同[视角]的不同显示选项的子对象，请参见链接的文章以获取可能的键。仅在物品模型上有效，但通常在方块模型中指定，以便物品模型可以继承显示选项。每个视角都是一个可选的子对象，可能包含以下选项，按顺序应用：
+ - `translation`：模型的平移，指定为 `[x, y, z]`。
+ - `rotation`：模型的旋转，指定为 `[x, y, z]`。
+ - `scale`：模型的
+
+缩放，指定为 `[x, y, z]`。
+ - `right_rotation`：NeoForge添加的。在缩放后应用的第二个旋转，指定为 `[x, y, z]`。
+- `transform`：参见[根变换][roottransforms]。
+
+:::tip
+如果您在确定如何精确指定某些内容方面遇到困难，请查看执行类似操作的原版模型。
+:::
+
+### 渲染类型
+
+使用可选的 NeoForge 添加的 `render_type` 字段，您可以为模型设置渲染类型。如果未设置（如所有原版模型），游戏将退回到 `ItemBlockRenderTypes` 中硬编码的渲染类型。如果 `ItemBlockRenderTypes` 中也不存在该方块的渲染类型，它将退回到 `minecraft:solid`。原版提供以下默认渲染类型：
+
+- `minecraft:solid`：用于完全实心的方块，例如石头。
+- `minecraft:cutout`：用于任何像素完全实心或完全透明的方块，即具有完全不透明或完全透明的像素，例如玻璃。
+- `minecraft:cutout_mipped`：`minecraft:cutout` 的变体，将在较大距离上缩小纹理以避免视觉伪影（[mipmapping]）。由于通常不希望物品上使用mipmapping并且可能会导致伪影，因此不会对物品渲染应用mipmapping。例如，用于树叶。
+- `minecraft:cutout_mipped_all`：`minecraft:cutout_mipped` 的变体，将mipmapping应用于物品模型。
+- `minecraft:translucent`：用于任何像素可能部分透明的方块，例如有色玻璃。
+- `minecraft:tripwire`：用于具有被渲染到天气目标的特殊要求的方块，即绊线。
+
+选择正确的渲染类型在某种程度上是一个性能问题。实心渲染比切割渲染快，切割渲染比半透明渲染快。因此，您应该为您的用例指定最严格的适用渲染类型，因为它也将是最快的。
+
+如果愿意，您也可以添加自己的渲染类型。要这样做，请订阅 [mod 总线][modbus] [事件] `RegisterNamedRenderTypesEvent` 并 `#register` 您的渲染类型。`#register` 具有三个或四个参数：
+
+- 渲染类型的名称。将以您的mod id作为前缀。例如，在此处使用 `"my_cutout"` 将为您提供 `examplemod:my_cutout` 作为新的可供您使用的渲染类型（前提是您的mod id为 `examplemod`）。
+- 分块渲染类型。可以使用 `RenderType.chunkBufferLayers()` 返回的列表中的任何类型。
+- 实体渲染类型。必须是具有 `DefaultVertexFormat.NEW_ENTITY` 顶点格式的渲染类型。
+- 可选项：神奇的渲染类型。必须是具有 `DefaultVertexFormat.NEW_ENTITY` 顶点格式的渲染类型。如果将图形模式设置为 _Fabulous!_，则将使用此渲染类型而不是常规实体渲染类型。如果省略，将回退到常规渲染类型。通常建议在渲染类型在某种程度上使用透明度时设置。
+
+### 元素
+
+元素是立方体对象的JSON表示。它具有以下属性：
+
+- `from`：立方体起始角的坐标，指定为 `[x, y, z]`。以1/16方块单位指定。例如，`[0, 0, 0]` 将是“左下”角，`[8, 8, 8]` 将是中心，`[16, 16, 16]` 将是“右上”角。
+- `to`：立方体结束角的坐标，指定为 `[x, y, z]`。与 `from` 一样，这是以1/16方块单位指定的。
+
+:::tip
+Minecraft中的值在范围 `[-16, 32]` 内。但是，强烈不建议超过 `[0, 16]`，因为这将导致光照和/或剔除问题。
+:::
+
+- `neoforge_data`：请参见[额外的面数据][extrafacedata]。
+- `faces`：包含最多6个面的数据的对象，分别命名为 `north`、`south`、`east`、`west`、`up` 和 `down`。每个面都具有以下数据：
+ - `uv`：面的uv，指定为 `[u1, v1, u2, v2]`，其中 `u1, v1` 是左上角uv坐标，`u2, v2` 是右下角uv坐标。
+ - `texture`：面使用的纹理。必须是以 `#` 为前缀的纹理变量。例如，如果您的模型有一个名为 `wood` 的纹理，则可以使用 `#wood` 引用该纹理。在技术上是可选的，如果缺少将使用缺失的纹理。
+ - `rotation`：可选。以顺时针90、180或270度旋转纹理。
+ - `cullface`：可选。告诉渲染引擎在指定方向上有一个完整方块触碰时跳过渲染面。方向可以是 `north`、`south`、`east`、`west`、`up` 或 `down`。
+ - `tint
+
+index`：可选。指定颜色处理程序可能使用的染色索引，有关更多信息，请参见[着色][tinting]。默认为-1，表示不染色。
+ - `neoforge_data`：请参见[额外的面数据][extrafacedata]。
+
+此外，它还可以指定以下可选属性：
+
+- `shade`：仅适用于方块模型。可选。此元素的面是否应该有方向相关的阴影。默认为 true。
+- `rotation`：对象的旋转，指定为包含以下数据的子对象：
+ - `angle`：旋转角度，以度为单位。可以是 -45 到 45，步长为22.5度。
+ - `axis`：围绕旋转的轴。目前无法围绕多个轴旋转对象。
+ - `origin`：可选。旋转的原点，指定为 `[x, y, z]`。请注意，这些是绝对值，即它们不是相对于立方体位置的。如果未指定，将使用 `[0, 0, 0]`。
+
+#### 额外的面数据
+
+额外的面数据（`neoforge_data`）可以应用于元素和元素的单个面。在所有可用的上下文中，它都是可选的。如果同时指定了元素级和面级额外面数据，则面级数据将覆盖元素级数据。额外的数据可以指定以下数据：
+
+- `color`：使用给定颜色对面进行染色。必须是ARGB值。可以指定为字符串或十进制整数（JSON不支持十六进制文字）。默认为 `0xFFFFFFFF`。如果颜色值是恒定的，可以用作对染色的替代。
+- `block_light`：覆盖用于此面的块光照值。默认为0。
+- `sky_light`：覆盖用于此面的天空光照值。默认为0。
+- `ambient_occlusion`：为此面禁用或启用环境光遮蔽。默认为模型中设置的值。
+
+使用自定义的 `neoforge:item_layers` 加载器，还可以指定要应用于 `item/generated` 模型中所有几何图形的额外面数据。在以下示例中，第1层将以红色染色并以完全亮度发光：
+
+```json5
+{
+ "loader": "neoforge:item_layers",
+ "parent": "minecraft:item/generated",
+ "textures": {
+ "layer0": "minecraft:item/stick",
+ "layer1": "minecraft:item/glowstone_dust"
+ },
+ "neoforge_data": {
+ "1": {
+ "color": "0xFFFF0000",
+ "block_light": 15,
+ "sky_light": 15,
+ "ambient_occlusion": false
+ }
+ }
+}
+```
+
+### 覆盖模型
+
+物品覆盖可以根据浮点值（称为覆盖值）为物品分配不同的模型。例如，弓和十字弓使用此功能根据它们已经拉开的时间来更改纹理。覆盖模型有模型和代码两个方面。
+
+模型可以指定一个或多个覆盖模型，当覆盖值等于或大于给定的阈值时应使用。例如，弓使用两个不同的属性 `pulling` 和 `pull`。 `pulling` 被视为布尔值，其中1被解释为正在拉动，0被解释为未拉动，而 `pull` 表示弓当前拉伸的程度。然后，它使用这些属性来指定在充能至低于65%时（`pulling` 1，没有 `pull` 值），65%时（`pulling` 1，`pull` 0.65）和90%时（`pulling` 1，`pull` 0.9）使用三种不同的替代模型。如果多个模型适用（因为值不断变大），则匹配列表的最后一个元素，因此请确保您的顺序是正确的。覆盖模型如下所示：
+```json5
+{
+ // other stuff here
+ "overrides": [
+ {
+ // pulling = 1
+ "predicate": {
+ "pulling": 1
+ },
+ "model": "item/bow_pulling_0"
+ },
+ {
+ // pulling = 1, pull >= 0.65
+ "predicate": {
+ "pulling": 1,
+ "pull": 0.65
+ },
+ "model": "item/bow_pulling_1"
+ },
+ // pulling = 1, pull >= 0.9
+ {
+ "predicate": {
+ "pulling": 1,
+ "pull": 0.9
+ },
+ "model": "item/bow_pulling_2"
+ }
+ ]
+}
+```
+
+事情的代码方面相当简单。假设我们想要向我们的物品添加一个名为 `examplemod:property` 的属性，我们会在[客户端][side]的[event handler][eventhandler]中使用以下代码：
+
+```java
+@SubscribeEvent
+public static void onClientSetup(FMLClientSetupEvent event) {
+ event.enqueueWork(() -> { // ItemProperties#register is not threadsafe, so we need to call it on the main thread
+ ItemProperties.register(
+ // The item to apply the property to.
+ ExampleItems.EXAMPLE_ITEM,
+ // The id of the property.
+ new ResourceLocation("examplemod", "property"),
+ // A reference to a method that calculates the override value.
+ // Parameters are the used item stack, the level context, the player using the item,
+ // and a random seed you can use.
+ (stack, level, player, seed) -> someMethodThatReturnsAFloat()
+ );
+ });
+}
+```
+
+:::info
+原版 Minecraft 仅允许 0 到 1 之间的浮点值。NeoForge 对此进行了补充，以允许任意的浮点值。
+:::
+
+### 根变换
+
+在模型的顶层添加 `transform` 属性会告诉加载器在应用 [blockstate 文件][bsfile]（用于方块模型）中的旋转或 `display` 块中的变换（用于物品模型）之前，应该对所有几何图形应用一个变换。这是由 NeoForge 添加的。
+
+根变换可以通过两种方式指定。第一种方式是作为一个名为 `matrix` 的单个属性，其中包含一个 3x4 的变换矩阵（行主序，最后一行被省略），以嵌套的 JSON 数组形式表示。矩阵是按照平移、左旋转、缩放、右旋转和变换原点的顺序组合而成。示例如下：
+
+```json5
+{
+ // ...
+ "transform": {
+ "matrix": [
+ [0, 0, 0, 0],
+ [0, 0, 0, 0],
+ [0, 0, 0, 0]
+ ]
+ }
+}
+```
+
+根据Minecraft译名标准化，以下是翻译后的文档：
+
+第二种方式是指定一个包含以下条目的JSON对象，按以下顺序应用：
+
+- `translation`：相对位移。指定为一个三维向量（`[x, y, z]`），如果缺失默认为`[0, 0, 0]`。
+- `rotation` 或 `left_rotation`：在缩放之前应用于平移原点的旋转。默认不旋转。可以用以下方式指定：
+ - 一个带有单一轴到旋转映射的JSON对象，例如 `{"x": 90}`
+ - 一个包含单一轴到旋转映射的JSON对象的数组，按照指定的顺序应用，例如 `[{"x": 90}, {"y": 45}, {"x": -22.5}]`
+ - 一个包含三个值的数组，每个值分别指定每个轴的旋转，例如 `[90, 45, -22.5]`
+ - 一个包含四个值的数组，直接指定一个四元数，例如 `[0.38268346, 0, 0, 0.9238795]`（= X轴45度旋转）
+- `scale`：相对于平移原点的缩放。指定为一个三维向量（`[x, y, z]`），如果缺失默认为`[1, 1, 1]`。
+- `post_rotation` 或 `right_rotation`：在缩放之后应用于平移原点的旋转。默认不旋转。指定方式与`rotation`相同。
+- `origin`：用于旋转和缩放的原点。转换也作为最后一步移到这里。指定为一个三维向量（`[x, y, z]`）或使用三个内置值之一 `"corner"`（=`[0, 0, 0]`），`"center"`（=`[0.5, 0.5, 0.5]`）或 `"opposing-corner"`（=`[1, 1, 1]`，默认值）。
+
+## 方块状态文件
+
+参见：[Minecraft Wiki][mcwiki]上的[方块状态文件][mcwikiblockstate]
+
+方块状态文件由游戏用于为不同的[方块状态]分配不同的模型。每个注册到游戏的方块必须有一个确切的方块状态文件。指定方块模型到方块状态有两种相互排斥的方式：通过变体或者多部件。
+
+在`variants`块内，每个方块状态都有一个元素。这是将方块状态与模型相关联的主要方式，被绝大多数方块使用。
+- 键是没有方块名的方块状态的字符串表示，例如对于非含水的台阶是`"type=top,waterlogged=false"`，或者对于没有属性的方块是`""`。值得注意的是，未使用的属性可以省略。例如，如果`waterlogged`属性对所选模型无影响，则两个对象`type=top,waterlogged=false`和`type=top,waterlogged=true`可以被合并为一个`type=top`对象。这也意味着对于每个方块，空字符串都是有效的。
+- 值要么是单一的模型对象，要么是模型对象的数组。如果使用了模型对象的数组，将从中随机选择一个模型。一个模型对象包含以下数据：
+ - `model`：模型文件位置的路径，相对于命名空间的`models`文件夹，例如`minecraft:block/cobblestone`。
+ - `x`和`y`：模型在x轴/y轴的旋转。限制为90度的步进。每个都是可选的，默认为0。
+ - `uvlock`：旋转模型时是否锁定UV。可选的，默认为false。
+ - `weight`：仅在模型对象数组中有用。给对象一个权重，用于选择随机模型对象。可选的，默认为1。
+
+相反，在`multipart`块内，元素根据方块状态的属性组合。这种方法主要被栅栏和围墙使用，它们根据布尔属性启用四个方向的部分。一个多部分元素由两个部分组成：`when`块和`apply`块。
+
+- `when`块指定了一个方块状态的字符串表示，或者一个必须满足元素应用的属性列表。这些列表可以被命名为`"OR"`或`"AND"`，对其内容执行相应的逻辑操作。单个方块状态和列表值都可以通过用`|`分隔它们来指定多个实际值（例如 `facing=east|facing=west`）。
+- `apply`块指定了要使用的模型对象或模型对象数组。这与`variants`块的工作方式完全相同。
+
+## 着色
+
+有些方块，如草或树叶，会根据它们的位置和/或属性改变它们的纹理。[模型元素][elements]可以在它们的面上指定一个染色指数，这将允许颜色处理器处理相应的面。代码方面通过两个事件来处理，一个是方块颜色处理器，另一个是物品颜色处理器。它们的工作方式非常相似，让我们先看一下方块处理器：
+
+```java
+@SubscribeEvent
+public static void registerBlockColorHandlers(RegisterColorHandlersEvent.Block event) {
+ // Parameters are the block's state, the level the block is in, the block's position, and the tint index.
+ // The level and position may be null.
+ event.register((state, level, pos, tintIndex) -> {
+ // Replace with your own calculation. See the BlockColors class for vanilla references.
+ // All vanilla uses assume alpha 255 (= 1f), but modded consumers may also account
+ // for alpha values specified here. Generally, if the tint index is -1,
+ // it means that no tinting should take place and a default value should be used instead.
+ return 0xFFFFFF;
+ });
+}
+```
+
+物品处理器的工作方式几乎相同，只是命名和lambda参数有所不同：
+
+```java
+@SubscribeEvent
+public static void registerItemColorHandlers(RegisterColorHandlersEvent.Item event) {
+ // Parameters are the item stack and the tint index.
+ event.register((stack, tintIndex) -> {
+ // Like above, replace with your own calculation. Vanilla values are in the ItemColors class.
+ // Also like above, tint index -1 means no tint and should use a default value instead.
+ return 0xFFFFFF;
+ });
+}
+```
+
+请注意，`item/generated`模型为其各个层指定了染色指数 - `layer0`有染色指数0，`layer1`有染色指数1，等等。另外，记住方块物品是物品，而不是方块，需要物品颜色处理器来着色。
+
+## 注册额外的模型
+
+一些并未与某个方块或物品有所关联，但在其他上下文（例如[方块实体渲染器][ber]）中仍然需要的模型，可以通过`ModelEvent.RegisterAdditional`来注册：
+
+```java
+// Client-side mod bus event handler
+@SubscribeEvent
+public static void registerAdditional(ModelEvent.RegisterAdditional event) {
+ event.register(new ResourceLocation("examplemod", "block/example_unused_model"));
+}
+```
+
+[ao]: https://en.wikipedia.org/wiki/Ambient_occlusion
+[ber]: ../../../blockentities/ber.md
+[bewlr]: ../../../items/bewlr.md
+[bsfile]: #blockstate-files
+[custommodelloader]: modelloaders.md
+[elements]: #elements
+[event]: ../../../concepts/events.md
+[eventhandler]: ../../../concepts/events.md#registering-an-event-handler
+[extrafacedata]: #extra-face-data
+[iscustomrenderer]: bakedmodel.md#others
+[mcwiki]: https://minecraft.wiki
+[mcwikiblockstate]: https://minecraft.wiki/w/Tutorials/Models#Block_states
+[mcwikimodel]: https://minecraft.wiki/w/Model
+[mipmapping]: https://en.wikipedia.org/wiki/Mipmap
+[modbus]: ../../../concepts/events.md#event-buses
+[overrides]: #overrides
+[perspectives]: bakedmodel.md#perspectives
+[rendertype]: #render-types
+[roottransforms]: #root-transforms
+[rl]: ../../../misc/resourcelocation.md
+[side]: ../../../concepts/sides.md
+[textures]: ../textures.md
+[tinting]: #tinting
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/modelloaders.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/modelloaders.md
new file mode 100644
index 000000000..3852f1fb8
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/models/modelloaders.md
@@ -0,0 +1,469 @@
+# 自定义模型加载器
+
+一个模型就是一个形状。它可以是一个立方体、一组立方体、一组三角形，或者任何其他的几何形状（或几何形状的组合）。在大多数上下文中，模型是如何定义的并不重要，因为最终一切都会在内存中变成`BakedModel`。因此，NeoForge增加了能够注册自定义模型加载器的功能，这些加载器可以将任何你想要的模型转换成游戏使用的`BakedModel`。
+
+一个方块模型的入口点仍然是模型JSON文件。然而，你可以在JSON的根部指定一个`loader`字段，它会将默认加载器替换为你自己的加载器。一个自定义模型加载器可能会忽略默认加载器所需的所有字段。
+
+## 内建模型加载器
+
+除了默认模型加载器，NeoForge还提供了几个内建的加载器，每个加载器都有不同的用途。
+
+### 组合模型
+
+组合模型可以用来在父模型中指定不同的模型部分，并且只在子模型中应用其中的一些。以下面的例子最能说明这一点。考虑以下位于`examplemod:example_composite_model`的父模型：
+
+```json5
+{
+ "loader": "neoforge:composite",
+ // Specify model parts.
+ "children": {
+ "part_1": {
+ "parent": "examplemod:some_model_1"
+ },
+ "part_2": {
+ "parent": "examplemod:some_model_2"
+ }
+ },
+ "visibility": {
+ // Disable part 2 by default.
+ "part_2": false
+ }
+}
+```
+
+然后，我们可以在`examplemod:example_composite_model`的子模型中禁用和启用单独的部分：
+
+```json5
+{
+ "parent": "examplemod:example_composite_model",
+ // Override visibility. If a part is missing, it will use the parent model's visibility value.
+ "visibility": {
+ "part_1": false,
+ "part_2": true
+ }
+}
+```
+
+要[datagen][modeldatagen]这个模型，使用自定义加载器类`CompositeModelBuilder`。
+
+### 动态流体容器模型
+
+动态流体容器模型，也称为动态桶模型，它最常见的使用场景是用于表示流体容器的物品（如桶或罐）并想在模型中显示流体。这只有在流体量是固定的（例如只有岩浆和细雪）的情况下才可行，如果流体是任意的，那么请使用[`BlockEntityWithoutLevelRenderer`][bewlr]。
+
+```json5
+{
+ "loader": "neoforge:fluid_container",
+ // Required. Must be a valid fluid id.
+ "fluid": "minecraft:water",
+ // The loader generally expects two textures: base and fluid.
+ "textures": {
+ // The base container texture, i.e. the equivalent of an empty bucket.
+ "base": "examplemod:item/custom_container",
+ // The fluid texture, i.e. the equivalent of water in a bucket.
+ "fluid": "examplemod:item/custom_container_fluid"
+ },
+ // Optional, defaults to false. Whether to flip the model upside down, for gaseous fluids.
+ "flip_gas": true,
+ // Optional, defaults to true. Whether to have the cover act as the mask.
+ "cover_is_mask": false,
+ // Optional, defaults to true. Whether to apply the fluid's luminosity to the item model.
+ "apply_fluid_luminosity": false,
+}
+```
+
+很多时候，动态流体容器模型会直接使用桶模型。这是通过指定`neoforge:item_bucket`父模型来实现的，如下所示：
+
+```json5
+{
+ "loader": "neoforge:fluid_container",
+ "parent": "neoforge:item/bucket",
+ // Replace with your own fluid.
+ "fluid": "minecraft:water"
+ // Optional properties here. Note that the textures are handled by the parent.
+}
+```
+
+要[datagen][modeldatagen]这个模型，使用自定义加载器类`DynamicFluidContainerModelBuilder`。请注意，出于对旧版本支持的考虑，这个类还提供了一个设置`apply_tint`属性的方法，这个属性现在已不再使用。
+
+### 元素模型
+
+一个元素模型由方块模型[elements][elements]和一个可选的[根变换][transform]组成。主要用于常规模型渲染之外的场景，例如在[BER][ber]中。
+
+```json5
+{
+ "loader": "neoforge:elements",
+ "elements": [...],
+ "transform": {...}
+}
+```
+
+### 空模型
+
+一个空模型什么都不渲染。
+
+```json5
+{
+ "loader": "neoforge:empty"
+}
+```
+
+### 物品层模型
+
+物品层模型是标准`item/generated`模型的一个变种，提供了以下额外的功能：
+
+- 无限数量的层（而不是默认的5层）
+- 每一层的[渲染类型][rendertype]
+
+```json5
+{
+ "loader": "neoforge:item_layers",
+ "textures": {
+ "layer0": "...",
+ "layer1": "...",
+ "layer2": "...",
+ "layer3": "...",
+ "layer4": "...",
+ "layer5": "...",
+ },
+ "render_types": {
+ // Map render types to layer numbers. For example, layers 0, 2 and 4 will use cutout.
+ "minecraft:cutout": [0, 2, 4],
+ "minecraft:cutout_mipped": [1, 3],
+ "minecraft:translucent": [5]
+ },
+ // other stuff the default loader allows here
+}
+```
+
+要[datagen][modeldatagen]这个模型，使用自定义加载器类`ItemLayerModelBuilder`。
+
+### OBJ模型
+
+OBJ模型加载器允许您在游戏中使用Wavefront `.obj` 3D模型，允许在模型中包含任意形状（包括三角形、圆形等）。`.obj`模型必须放在`models`文件夹（或其子文件夹）中，并且必须提供一个同名的`.mtl`文件（或手动设置），所以例如，位于`models/block/example.obj`的OBJ模型必须有一个对应的MTL文件位于`models/block/example.mtl`。
+
+```json5
+{
+ "loader": "neoforge:obj",
+ // Required. Reference to the model file. Note that this is relative to the namespace root, not the model folder.
+ "model": "examplemod:models/example.obj",
+ // Normally, .mtl files must be put into the same location as the .obj file, with only the file ending differing.
+ // This will cause the loader to automatically pick them up. However, you can also set the location
+ // of the .mtl file manually if needed.
+ "mtl_override": "examplemod:models/example_other_name.mtl",
+ // These textures can be referenced in the .mtl file as #texture0, #particle, etc.
+ // This usually requires manual editing of the .mtl file.
+ "textures": {
+ "texture0": "minecraft:block/cobblestone",
+ "particle": "minecraft:block/stone"
+ },
+ // Enable or disable automatic culling of the model. Optional, defaults to true.
+ "automatic_culling": false,
+ // Whether to shade the model or not. Optional, defaults to true.
+ "shade_quads": false,
+ // Some modeling programs will assume V=0 to be bottom instead of the top. This property flips the Vs upside-down.
+ // Optional, defaults to false.
+ "flip_v": true,
+ // Whether to enable emissivity or not. Optional, defaults to true.
+ "emissive_ambient": false
+}
+```
+
+要[datagen][modeldatagen]这个模型，使用自定义加载器类`ObjModelBuilder`。
+
+### 独立变换模型
+
+独立变换模型可用于根据视角切换不同的模型。视角与[normal model][model]中的`display`块相同。这通过指定一个基础模型（作为后备）然后为每个视角指定覆盖模型来实现。注意，如果您愿意，每个这样的模型都可以是完整的模型，但通常最简单的方法是使用那个模型的子模型来引用另一个模型，如下所示：
+
+```json5
+{
+ "loader": "neoforge:separate_transforms",
+ // Use the cobblestone model normally.
+ "base": {
+ "parent": "minecraft:block/cobblestone"
+ },
+ // Use the stone model only when dropped.
+ "perspectives": {
+ "ground": {
+ "parent": "minecraft:block/stone"
+ }
+ }
+}
+```
+
+要[datagen][modeldatagen]这个模型，使用自定义加载器类`SeparateTransformsModelBuilder`。
+
+## 创建自定义模型加载器
+
+要创建自己的模型加载器，您需要三个类加上一个事件处理程序：
+
+- 一个几何体加载器类
+- 一个几何体类
+- 一个动态的[baked model][bakedmodel]类
+- 一个用于`ModelEvent.RegisterGeometryLoaders`的[客户端][sides] [事件处理程序][event]，用于注册几何体加载器
+
+为了说明这些类是如何连接的，我们将跟随一个模型的加载过程：
+
+- 在模型加载期间，带有`loader`属性设置为您的加载器的模型JSON被传递给您的几何体加载器。然后，几何体加载器读取模型JSON并使用模型JSON的属性返回一个几何体对象。
+- 在模型烘焙期间，几何体被烘焙，返回一个动态烘焙模型。
+- 在模型渲染期间，动态烘焙模型用于渲染。
+
+让我们通过一个基本的类设置进一步说明。几何体加载器类命名为`MyGeometryLoader`，几何体类命名为`MyGeometry`，动态烘焙模型类命名为`MyDynamicModel`：
+
+```java
+public class MyGeometryLoader implements IGeometryLoader {
+ // It is highly recommended to use a singleton pattern for geometry loaders, as all models can be loaded through one loader.
+ public static final MyGeometryLoader INSTANCE = new MyGeometryLoader();
+ // The id we will use to register this loader. Also used in the loader datagen class.
+ public static final ResourceLocation ID = new ResourceLocation("examplemod", "my_custom_loader");
+
+ // In accordance with the singleton pattern, make the constructor private.
+ private MyGeometryLoader() {}
+
+ @Override
+ public MyGeometry read(JsonObject jsonObject, JsonDeserializationContext context) throws JsonParseException {
+ // Use the given JsonObject and, if needed, the JsonDeserializationContext to get properties from the model JSON.
+ // The MyGeometry constructor may have constructor parameters (see below).
+ return new MyGeometry();
+ }
+}
+
+public class MyGeometry implements IUnbakedGeometry {
+ // The constructor may have any parameters you need, and store them in fields for further usage below.
+ // If the constructor has parameters, the constructor call in MyGeometryLoader#read must match them.
+ public MyGeometry() {}
+
+ // Method responsible for model baking, returning our dynamic model. Parameters in this method are:
+ // - The geometry baking context. Contains many properties that we will pass into the model, e.g. light and ao values.
+ // - The model baker. Can be used for baking sub-models.
+ // - The sprite getter. Maps materials (= texture variables) to TextureAtlasSprites. Materials can be obtained from the context.
+ // For example, to get a model's particle texture, call spriteGetter.apply(context.getMaterial("particle"));
+ // - The model state. This holds the properties from the blockstate file, e.g. rotations and the uvlock boolean.
+ // - The item overrides. This is the code representation of an "overrides" block in an item model.
+ // - The resource location of the model.
+ @Override
+ public BakedModel bake(IGeometryBakingContext context, ModelBaker baker, Function spriteGetter, ModelState modelState, ItemOverrides overrides, ResourceLocation modelLocation) {
+ // See info on the parameters below.
+ return new MyDynamicModel(context.useAmbientOcclusion(), context.isGui3d(), context.useBlockLight(),
+ spriteGetter.apply(context.getMaterial("particle")), overrides);
+ }
+
+ // Method responsible for correctly resolving parent properties. Required if this model loads any nested models or reuses the vanilla loader on itself (see below).
+ @Override
+ public void resolveParents(Function modelGetter, IGeometryBakingContext context) {
+ base.resolveParents(modelGetter);
+ }
+}
+
+// BakedModelWrapper can be used as well to return default values for most methods, allowing you to only override what actually needs to be overridden.
+public class MyDynamicModel implements IDynamicBakedModel {
+ // Material of the missing texture. Its sprite can be used as a fallback when needed.
+ private static final Material MISSING_TEXTURE =
+ new Material(TextureAtlas.LOCATION_BLOCKS, MissingTextureAtlasSprite.getLocation());
+
+ // Attributes for use in the methods below. Optional, the methods may also use constant values if applicable.
+ private final boolean useAmbientOcclusion;
+ private final boolean isGui3d;
+ private final boolean usesBlockLight;
+ private final TextureAtlasSprite particle;
+ private final ItemOverrides overrides;
+
+ // The constructor does not require any parameters other than the ones for instantiating the final fields.
+ // It may specify any additional parameters to store in fields you deem necessary for your model to work.
+ public MyDynamicModel(boolean useAmbientOcclusion, boolean isGui3d, boolean usesBlockLight, TextureAtlasSprite particle, ItemOverrides overrides) {
+ this.useAmbientOcclusion = useAmbientOcclusion;
+ this.isGui3d = isGui3d;
+ this.usesBlockLight = usesBlockLight;
+ this.particle = particle;
+ this.overrides = overrides;
+ }
+
+ // Use our attributes. Refer to the article on baked models for more information on the method's effects.
+ @Override
+ public boolean useAmbientOcclusion() {
+ return useAmbientOcclusion;
+ }
+
+ @Override
+ public boolean isGui3d() {
+ return isGui3d;
+ }
+
+ @Override
+ public boolean usesBlockLight() {
+ return usesBlockLight;
+ }
+
+ @Override
+ public TextureAtlasSprite getParticleIcon() {
+ // Return MISSING_TEXTURE.sprite() if you don't need a particle, e.g. when in an item model context.
+ return particle;
+ }
+
+ @Override
+ public ItemOverrides getOverrides() {
+ // Return ItemOverrides.EMPTY when in a block model context.
+ return overrides;
+ }
+
+ // Override this to true if you want to use a custom block entity renderer instead of the default renderer.
+ @Override
+ public boolean isCustomRenderer() {
+ return false;
+ }
+
+ // This is where the magic happens. Return a list of the quads to render here. Parameters are:
+ // - The blockstate being rendered. May be null if rendering an item.
+ // - The side being culled against. May be null, which means quads that cannot be occluded should be returned.
+ // - A client-bound random source you can use for randomizing stuff.
+ // - The extra data to use. Originates from a block entity (if present), or from BakedModel#getModelData().
+ // - The render type for which quads are being requested.
+ // NOTE: This may be called many times in quick succession, up to several times per block.
+ // This should be as fast as possible and use caching wherever applicable.
+ @Override
+ public List getQuads(@Nullable BlockState state, @Nullable Direction side, RandomSource rand, ModelData extraData, @Nullable RenderType renderType) {
+ List quads = new ArrayList<>();
+ // add elements to the quads list as needed here
+ return quads;
+ }
+}
+```
+
+在所有操作完成后，不要忘记实际注册您的加载器，否则所有的工作都将白费：
+
+```java
+// Client-side mod bus event handler
+@SubscribeEvent
+public static void registerGeometryLoaders(ModelEvent.RegisterGeometryLoaders event) {
+ event.register(MyGeometryLoader.ID, MyGeometryLoader.INSTANCE);
+}
+```
+
+### 数据生成
+
+当然，我们也可以对我们的模型进行[数据生成]。为此，我们需要一个扩展`CustomLoaderBuilder`的类：
+
+```java
+// This assumes a block model. Use ItemModelBuilder as the generic parameter instead
+// if you're making a custom item model.
+public class MyLoaderBuilder extends CustomLoaderBuilder {
+ public MyLoaderBuilder(BlockModelBuilder parent, ExistingFileHelper existingFileHelper) {
+ super(
+ // Your model loader's id.
+ MyGeometryLoader.ID,
+ // The parent builder we use. This is always the first constructor parameter.
+ parent,
+ // The existing file helper we use. This is always the second constructor parameter.
+ existingFileHelper,
+ // Whether the loader allows inline vanilla elements as a fallback if the loader is absent.
+ false
+ );
+ }
+
+ // Add fields and setters for the fields here. The fields can then be used below.
+
+ // Serialize the model to JSON.
+ @Override
+ public JsonObject toJson(JsonObject json) {
+ // Add your fields to the given JsonObject.
+ // Then call super, which adds the loader property and some other things.
+ return super.toJson(json);
+ }
+}
+```
+
+要使用这个加载器构建器，在块（或物品）[模型数据生成][modeldatagen]期间执行以下操作：
+
+```java
+// This assumes a BlockStateProvider. Use getBuilder("my_cool_block") directly in an ItemModelProvider.
+// The parameter for customLoader() is a BiFunction. The parameters of the BiFunction
+// are the result of the getBuilder() call and the provider's ExistingFileHelper.
+MyLoaderBuilder loaderBuilder = models().getBuilder("my_cool_block").customLoader(MyLoaderBuilder::new);
+```
+
+然后，在`loaderBuilder`上调用你的字段设置器。
+
+#### 可见性
+
+`CustomLoaderBuilder`的默认实现有应用可见性的方法。你可以选择在你的模型加载器中使用或忽视`visibility`属性。目前，只有[复合模型加载器][composite]使用了这个属性。
+
+### 重用默认模型加载器
+
+在某些情况下，重用 Vanilla 模型加载器并在其基础上构建你的模型逻辑，而不是直接替换它，是有意义的。我们可以使用一个巧妙的技巧来实现这个目标：在模型加载器中，我们只需移除`loader`属性，然后将其发送回模型解析器，让其误以为现在是一个常规模型。然后我们将它传给几何体，在那里烘焙模型几何体（就像默认的几何体处理器那样），并将其传递给动态模型，在那里我们可以以我们想要的方式使用模型的quads：
+
+```java
+public class MyGeometryLoader implements IGeometryLoader {
+ public static final MyGeometryLoader INSTANCE = new MyGeometryLoader();
+ public static final ResourceLocation ID = new ResourceLocation(...);
+
+ private MyGeometryLoader() {}
+
+ @Override
+ public MyGeometry read(JsonObject jsonObject, JsonDeserializationContext context) throws JsonParseException {
+ // Trick the deserializer into thinking this is a normal model by removing the loader field and then passing it back into the deserializer.
+ jsonObject.remove("loader");
+ BlockModel base = context.deserialize(jsonObject, BlockModel.class);
+ // other stuff here if needed
+ return new MyGeometry(base);
+ }
+}
+
+public class MyGeometry implements IUnbakedGeometry {
+ private final BlockModel base;
+
+ // Store the block model for usage below.
+ public MyGeometry(BlockModel base) {
+ this.base = base;
+ }
+
+ @Override
+ public BakedModel bake(IGeometryBakingContext context, ModelBaker baker, Function spriteGetter, ModelState modelState, ItemOverrides overrides, ResourceLocation modelLocation) {
+ BakedModel bakedBase = new ElementsModel(base.getElements()).bake(context, baker, spriteGetter, modelState, overrides, modelLocation);
+ return new MyDynamicModel(bakedBase, /* other parameters here */);
+ }
+
+ @Override
+ public void resolveParents(Function modelGetter, IGeometryBakingContext context) {
+ base.resolveParents(modelGetter);
+ }
+}
+
+public class MyDynamicModel implements IDynamicBakedModel {
+ private final BakedModel base;
+ // other fields here
+
+ public MyDynamicModel(BakedModel base, /* other parameters here */) {
+ this.base = base;
+ // set other fields here
+ }
+
+ // other override methods here
+
+ @Override
+ public List getQuads(@Nullable BlockState state, @Nullable Direction side, RandomSource rand, ModelData extraData, @Nullable RenderType renderType) {
+ List quads = new ArrayList<>();
+ // Add the base model's quads. Can also do something different with the quads here, depending on what you need.
+ quads.add(base.getQuads(state, side, rand, extraData, renderType));
+ // add other elements to the quads list as needed here
+ return quads;
+ }
+
+ // Apply the base model's transforms to our model as well.
+ @Override
+ public BakedModel applyTransform(ItemDisplayContext transformType, PoseStack poseStack, boolean applyLeftHandTransform) {
+ return base.applyTransform(transformType, poseStack, applyLeftHandTransform);
+ }
+}
+```
+
+[bakedmodel]: bakedmodel.md
+[ber]: ../../../blockentities/ber.md
+[bewlr]: ../../../items/bewlr.md
+[composite]: #composite-model
+[datagen]: ../../index.md#data-generation
+[elements]: index.md#elements
+[event]: ../../../concepts/events.md#registering-an-event-handler
+[model]: index.md#specification
+[modeldatagen]: datagen.md
+[rendertype]: index.md#render-types
+[sides]: ../../../concepts/sides.md
+[transform]: index.md#root-transforms
diff --git a/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/particles.md b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/particles.md
new file mode 100644
index 000000000..e7f3e9bf6
--- /dev/null
+++ b/i18n/zh-Hans/docusaurus-plugin-content-docs/current/resources/client/particles.md
@@ -0,0 +1,260 @@
+# 粒子效果
+
+粒子效果是能够美化游戏并增加沉浸感的2D效果。它们可以在客户端和服务器端[side]产生，但由于它们主要是视觉效果，关键部分只存在于物理（和逻辑）客户端。
+
+## 注册粒子效果
+
+### `ParticleType`
+
+粒子效果是使用`ParticleType`注册的。这与`EntityType`或`BlockEntityType`类似，有一个`Particle`类 - 每个产生的粒子都是该类的一个实例 -，然后有`ParticleType`类，保存一些共有信息，用于注册。`ParticleType`是一个[注册表]，这意味着我们想要使用`DeferredRegister`来注册它们，就像所有其他注册的对象一样：
+
+```java
+public class MyParticleTypes {
+ // Assuming that your mod id is examplemod
+ public static final DeferredRegister> PARTICLE_TYPES =
+ DeferredRegister.create(BuiltInRegistries.PARTICLE_TYPE, "examplemod");
+
+ // The easiest way to add new particle types is reusing vanilla's SimpleParticleType.
+ // Implementing a custom ParticleType is also possible, see below.
+ public static final Supplier MY_PARTICLE = PARTICLE_TYPES.register(
+ // The name of the particle type.
+ "my_particle",
+ // The supplier. The boolean parameter denotes whether setting the Particles option in the
+ // video settings to Minimal will affect this particle type or not; this is false for
+ // most vanilla particles, but true for e.g. explosions, campfire smoke, or squid ink.
+ () -> new SimpleParticleType(false)
+ );
+}
+```
+
+:::info
+如果您需要在服务器端处理粒子效果，那么`ParticleType`是必需的。客户端也可以直接使用`Particle`。
+:::
+
+### `Particle`
+
+`Particle`是稍后被生成到世界中并显示给玩家的实体。虽然你可以扩展`Particle`并自己实现一些功能，但在许多情况下，扩展`TextureSheetParticle`可能会更好，因为这个类为你提供了如动画和缩放等功能的助手，而且还为你实现了实际的渲染（如果直接扩展`Particle`，你需要自己实现这些功能）。
+
+`Particle`的大多数属性是由如`gravity`，`lifetime`，`hasPhysics`，`friction`等字段控制的。唯一有意义的自我实现方法是`tick`和`move`，这两个方法都正如你所期望的那样进行操作。因此，自定义的粒子类通常很简短，例如，只包括一个构造函数，设置一些字段并让超类处理剩下的事情。一个基本的实现可能看起来像这样：
+
+```java
+public class MyParticle extends TextureSheetParticle {
+ private final SpriteSet spriteSet;
+
+ // First four parameters are self-explanatory. The SpriteSet parameter is provided by the
+ // ParticleProvider, see below. You may also add additional parameters as needed, e.g. xSpeed/ySpeed/zSpeed.
+ public MyParticle(ClientLevel level, double x, double y, double z, SpriteSet spriteSet) {
+ super(level, x, y, z);
+ this.spriteSet = spriteSet;
+ this.gravity = 0; // Our particle floats in midair now, because why not.
+ }
+
+ @Override
+ public void tick() {
+ // Set the sprite for the current particle age, i.e. advance the animation.
+ setSpriteFromAge(spriteSet);
+ // Let super handle further movement. You may replace this with your own movement if needed.
+ // You may also override move() if you only want to modify the built-in movement.
+ super.tick();
+ }
+}
+```
+
+### `ParticleProvider`
+
+接下来，粒子类型必须注册一个`ParticleProvider`。`ParticleProvider`是一个仅在客户端的类，负责通过`createParticle`方法实际创建我们的`Particle`。虽然这里可以包含更复杂的代码，但许多粒子提供器的实现可能非常简单，如下所示：
+
+```java
+// The generic type of ParticleProvider must match the type of the particle type this provider is for.
+public class MyParticleProvider implements ParticleProvider {
+ // A set of particle sprites.
+ private final SpriteSet spriteSet;
+
+ // The registration function passes a SpriteSet, so we accept that and store it for further use.
+ public MyParticleProvider(SpriteSet spriteSet) {
+ this.spriteSet = spriteSet;
+ }
+
+ // This is where the magic happens. We return a new particle each time this method is called!
+ // The type of the first parameter matches the generic type passed to the super interface.
+ @Override
+ public Particle createParticle(SimpleParticleType type, ClientLevel level,
+ double x, double y, double z, double xSpeed, double ySpeed, double zSpeed) {
+ // We don't use the type and speed, and pass in everything else. You may of course use them if needed.
+ return new MyParticle(level, x, y, z, spriteSet);
+ }
+}
+```
+
+然后，您的粒子提供器必须在[客户端][side] [mod bus][modbus] [event] `RegisterParticleProvidersEvent`中与粒子类型关联：
+
+```java
+@SubscribeEvent
+public static void registerParticleProviders(RegisterParticleProvidersEvent event) {
+ // There are multiple ways to register providers, all differing in the functional type they provide in the
+ // second parameter. For example, #registerSpriteSet represents a Function>:
+ event.registerSpriteSet(MyParticleTypes.MY_PARTICLE.get(), MyParticleProvider::new);
+ // Other methods include #registerSprite, which is essentially a Supplier,
+ // and #registerSpecial, which maps to a Supplier. See the source code of the event for further info.
+}
+```
+
+### 粒子定义
+
+最后，我们必须将我们的粒子类型与一个纹理关联起来。与物品被关联到一个物品模型相似，我们将我们的粒子类型与所谓的粒子定义（或粒子描述）关联起来。粒子定义是`assets//particles`目录中的一个JSON文件，它的名称与粒子类型相同（例如，对于上述示例是`my_particle.json`）。粒子定义JSON的格式如下：
+
+```json5
+{
+ // A list of textures that will be played in order. Will loop if necessary.
+ // Texture locations are relative to the textures/particle folder.
+ "textures": [
+ "examplemod:my_particle_0",
+ "examplemod:my_particle_1",
+ "examplemod:my_particle_2",
+ "examplemod:my_particle_3"
+ ]
+}
+```
+
+请注意，仅当使用精灵集粒子时才需要粒子定义文件。单精灵粒子直接映射到`assets//textures/particle/.png`的纹理文件，特殊粒子提供器可以做任何你想做的事情。
+
+:::danger
+不匹配的精灵集粒子工厂列表和粒子定义文件，即没有相应粒子工厂的粒子描述，或者反之亦然，将会抛出异常！
+:::
+
+### 数据生成
+
+粒子定义文件也可以通过扩展`ParticleDescriptionProvider`并覆写`#addDescriptions()`方法来进行[数据生成][datagen]：
+
+```java
+public class MyParticleDescriptionProvider extends ParticleDescriptionProvider {
+ // Get the parameters from GatherDataEvent.
+ public AMParticleDefinitionsProvider(PackOutput output, ExistingFileHelper existingFileHelper) {
+ super(output, existingFileHelper);
+ }
+
+ // Assumes that all the referenced particles actually exists. Replace "examplemod" with your mod id.
+ @Override
+ protected void addDescriptions() {
+ // Adds a single sprite particle definition with the file at
+ // assets/examplemod/textures/particle/my_single_particle.png.
+ sprite(MyParticleTypes.MY_SINGLE_PARTICLE.get(), new ResourceLocation("examplemod", "my_single_particle"));
+ // Adds a multi sprite particle definition, with a vararg parameter. Alternatively accepts a list.
+ spriteSet(MyParticleTypes.MY_MULTI_PARTICLE.get(),
+ new ResourceLocation("examplemod", "my_multi_particle_0"),
+ new ResourceLocation("examplemod", "my_multi_particle_1"),
+ new ResourceLocation("examplemod", "my_multi_particle_2")
+ );
+ // Alternative for the above, appends "_" to the base name given, for the given amount of textures.
+ spriteSet(MyParticleTypes.MY_ALT_MULTI_PARTICLE.get(),
+ // The base name.
+ new ResourceLocation("examplemod", "my_multi_particle"),
+ // The amount of textures.
+ 3,
+ // Whether to reverse the list, i.e. start at the last element instead of the first.
+ false
+ );
+ }
+}
+```
+
+不要忘了向 `GatherDataEvent` 添加提供器:
+
+```java
+@SubscribeEvent
+public static void gatherData(GatherDataEvent event) {
+ DataGenerator generator = event.getGenerator();
+ PackOutput output = generator.getPackOutput();
+ ExistingFileHelper existingFileHelper = event.getExistingFileHelper();
+
+ // other providers here
+ generator.addProvider(
+ event.includeClient(),
+ new MyParticleDescriptionProvider(output, existingFileHelper)
+ );
+}
+```
+
+### 自定义 `ParticleType`
+
+虽然在大多数情况下，`SimpleParticleType`就足够了，但有时需要在服务器端为粒子附加额外的数据。这就需要一个自定义的`ParticleType`和一个关联的自定义`ParticleOptions`。让我们从`ParticleOptions`开始，因为这是实际存储信息的地方：
+
+```java
+public class MyParticleOptions implements ParticleOptions {
+ // Does not need any parameters, but may define any fields necessary for the particle to work.
+ public MyParticleOptions() {}
+
+ @Override
+ public void writeToNetwork(FriendlyByteBuf buf) {
+ // Write your custom info to the given buffer.
+ }
+
+ @Override
+ public String writeToString() {
+ // Return a stringified version of your custom info, for use in commands.
+ // We don't have any info in this type, so we return the empty string.
+ return "";
+ }
+
+ // The deserializer object to use. We will discuss how to use this in a moment.
+ public static final ParticleOptions.Deserializer DESERIALIZER =
+ new ParticleOptions.Deserializer() {
+ public MyParticleOptions fromCommand(ParticleType type, StringReader reader)
+ throws CommandSyntaxException {
+ // You may deserialize things using the given StringReader and pass them to your
+ // particle options object if needed.
+ return new MyParticleOptions();
+ }
+
+ public MyParticleOptions fromNetwork(ParticleType type, FriendlyByteBuf buf) {
+ // Similar to above, deserialize any needed info from the given buffer.
+ return new MyParticleOptions();
+ }
+ };
+}
+```
+
+然后我们在我们的自定义`ParticleType`中使用这个`ParticleOptions`实现...
+
+```java
+public class MyParticleType extends ParticleType