eos (real)

Reviewed-on: Raphael/SCHALE.GameServer#5

Account_Data_into_SCHALE.md

@@ -0,0 +1,25 @@
+**How to Save and Load Your Official Account Data into SCHALE(EN)**
+By Raphael
+
+1. Use any Pcap program, turn it on, log into your official account, and capture the packets.  
+   The Pcap file should look something like this:  
+   [Example Pcap file](https://gist.github.com/raphaeIl/b85185098b6ef0d569c794f49c8f910c)
+
+2. Save the file as a JSON and place it in the `Resources\account_data` folder. If the folder does not exist, create it.  
+   Example file path: `Resources\account_data\accountdata_Raphael.json`
+
+3. Start the server, log into the game, and run:
+   ```
+   /loaddata list
+   ```
+   If the log displays your JSON file name, the file is in the correct folder.
+
+4. Run the following command to load the data:
+   ```
+   /loaddata <your_json_filename.json>
+   ```
+   This will load the data from your official server’s Pcap file into the PS. If successful, restart the client, and all your data should be loaded.  
+
+   **Tip:** If your custom Pcap file doesn’t work, please try using my example JSON file first.
+
+---

Account_Data_into_SCHALE_ZHCN.md

@@ -0,0 +1,24 @@
+**如何将官方账号数据保存并加载到 SCHALE (ZHCN)**
+
+- CN-By 北野桜奈
+
+1. 使用任何 Pcap 程序，打开它并登录到你的官方账号，抓取数据包。  
+   Pcap 文件应类似于以下示例：  
+   [示例 Pcap 文件](https://gist.github.com/raphaeIl/b85185098b6ef0d569c794f49c8f910c)  
+
+2. 将该文件保存为 JSON 格式，并放置到 `Resources\account_data` 文件夹中。如果文件夹不存在，请自行创建。  
+   示例文件路径：`Resources\account_data\accountdata_Raphael.json`
+
+3. 启动服务器，进入游戏并运行以下命令：
+   ```
+   /loaddata list
+   ```
+   如果日志显示了你的 JSON 文件名，说明该文件已正确放置。
+
+4. 运行以下命令加载数据：
+   ```
+   /loaddata <your_json_filename.json>
+   ```
+   这将从官方服务器的 Pcap 数据加载到 PS。如果加载成功，请重启客户端，所有数据应该已加载。  
+
+   **提示：** 如果你的自定义 Pcap 文件无法正常工作，请先尝试我的示例 JSON 文件。

Command.md

@@ -0,0 +1,480 @@
+# 💻 蔚蓝档案命令手册
+*📝 作者：阁主*
+
+---
+
+## 📑 目录
+- [📑 English version of Command](Command_EN.md)
+- [🏰 咖啡厅命令 (Cafe)](#咖啡厅-cafe-命令)
+- [👥 角色命令 (Character)](#角色-character-命令)
+- [💎 货币命令 (Currency)](#货币-currency-命令)
+- [❓ 帮助命令 (Help)](#帮助-help-命令)
+- [📦 库存命令 (Inventory)](#库存-inventory-命令)
+- [💾 加载数据命令 (LoadData)](#加载数据-loaddata-命令)
+- [⚙️ 设置账号命令 (SetAccount)](#设置账号-setaccount-命令)
+- [🔓 解锁全部命令 (UnlockAll)](#解锁全部-unlockall-命令)
+
+---
+
+# 🏰 咖啡厅 (Cafe) 命令
+> 打造您的理想咖啡厅，创造独特的休憩空间
+
+## ⌨️ 命令格式
+```
+/cafe <character|furniture> <add|addall|removeall> [id/amount]
+```
+## 🎯 功能说明
+此命令用于管理游戏中的咖啡厅系统，让您能够自由布置角色和家具。
+
+## 📋 可用子命令
+
+### 👥 角色管理 (character)
+
+#### 1. ➕ 添加单个角色
+```
+/cafe character add <角色ID>
+```
+- 💫 功能：向咖啡厅添加指定ID的角色
+- 📝 示例：`/cafe character add 123`
+- ℹ️ 说明：重复添加会收到提示
+
+#### 2. ✨ 批量添加角色
+```
+/cafe character addall [数量]
+```
+- 💫 功能：向咖啡厅批量添加可用角色
+- 📝 示例：
+  - `/cafe character addall` (添加50个角色)
+  - `/cafe character addall 100` (添加100个角色)
+- ℹ️ 说明：仅添加满足条件的角色：
+  - ✅ 可玩角色
+  - ✅ 非NPC角色
+  - ✅ 已正式发布的角色
+
+#### 3. 🗑️ 移除所有角色
+```
+/cafe character removeall
+```
+- 💫 功能：清空咖啡厅中的所有角色
+- ⚠️ 注意：此操作不可撤销
+
+## ⚡ 注意事项
+1. 🔄 所有命令执行后自动保存
+2. 📝 命令不区分大小写
+3. ℹ️ 添加重复角色会收到提示
+4. 🚧 家具功能尚在开发中
+
+---
+# 👥 角色 (Character) 命令
+> 管理您的角色系统，打造完美的战斗团队
+
+## ⌨️ 命令格式
+```
+/character <add|clear> [all|characterId]
+```
+
+## 🎯 功能说明
+此命令用于管理玩家的角色系统，支持添加和清除角色功能。
+
+## 📋 可用子命令
+
+### ✨ 添加角色 (add)
+
+#### 1. 🌟 添加所有角色
+```
+/character add all
+```
+- 💫 功能：添加所有可用角色
+- ✨ 特点：角色将以最强状态添加
+  - ✅ 最大等级
+  - ✅ 完全培养
+  - ✅ 技能满级
+
+#### 2. ➕ 添加指定角色
+```
+/character add <角色ID>
+```
+- 💫 功能：添加指定ID的角色
+- 📝 示例：`/character add 1`
+- ℹ️ 说明：角色将以最强状态添加
+
+### 🗑️ 清除角色 (clear)
+```
+/character clear
+```
+- 💫 功能：清空所有角色
+- ⚠️ 警告：此操作不可撤销
+
+## ⚡ 注意事项
+1. 🔄 操作自动保存
+2. 📝 命令不区分大小写
+3. ℹ️ 重复添加会提示
+4. ⚠️ 清除操作需谨慎
+
+---
+
+# 💎 货币 (Currency) 命令
+> 自由调整各类货币数量，畅享游戏体验
+
+## ⌨️ 命令格式
+```
+/currency <货币类型> <数量>
+```
+
+## 🎯 功能说明
+此命令用于修改账号中各类货币的数量。
+
+## 💰 可用货币类型
+
+### 💫 基础货币
+- `Gold` - 💰 金币
+- `Gem` - 💎 青辉石（总数）
+- `GemPaid` - 💳 付费青辉石
+- `GemBonus` - 🎁 奖励青辉石
+
+### 🎫 体力票券
+- `ActionPoint` - ⚡ 体力值
+- `AcademyTicket` - 📚 学院券
+- `ArenaTicket` - ⚔️ 竞技场券
+- `RaidTicket` - 🎯 总力战券
+
+### 🗺️ 每周副本券
+- `WeekDungeonChaserATicket` - 🏃‍♂️ 追击战A券
+- `WeekDungeonChaserBTicket` - 🏃‍♀️ 追击战B券
+- `WeekDungeonChaserCTicket` - 🏃 追击战C券
+- `WeekDungeonFindGiftTicket` - 🎁 寻宝战券
+- `WeekDungeonBloodTicket` - 🗡️ 血战券
+- `ChaserTotalTicket` - 🎯 追击战总券
+
+### 🏫 学院副本券
+- `SchoolDungeonATicket` - 📘 学院副本A券
+- `SchoolDungeonBTicket` - 📗 学院副本B券
+- `SchoolDungeonCTicket` - 📙 学院副本C券
+- `SchoolDungeonTotalTicket` - 📚 学院副本总券
+
+### 🌟 特殊副本券
+- `TimeAttackDungeonTicket` - ⏱️ 限时挑战券
+- `WorldRaidTicketA` - 🌍 世界副本A券
+- `WorldRaidTicketB` - 🌎 世界副本B券
+- `WorldRaidTicketC` - 🌏 世界副本C券
+
+### ⚔️ 清除战券
+- `EliminateTicketA` - 🗡️ 清除战A券
+- `EliminateTicketB` - ⚔️ 清除战B券
+- `EliminateTicketC` - 🛡️ 清除战C券
+- `EliminateTicketD` - 🔰 清除战D券
+
+### 🏆 其他
+- `MasterCoin` - 🎖️ 大师币
+
+## 📝 使用示例
+```
+/currency Gem 99999          # 设置青辉石为99999
+/currency ActionPoint 9999   # 设置体力值为9999
+/currency Gold 99999999     # 设置金币为99999999
+```
+
+## ⚡ 注意事项
+1. 📝 货币类型区分大小写
+2. 🔢 数量必须为整数
+3. 🔄 修改立即生效并保存
+4. ⚠️ 无效输入将提示错误
+5. 💡 请合理使用此功能
+
+---
+# ❓ 帮助 (Help) 命令
+> 获取详细的命令使用说明，助您轻松上手
+
+## ⌨️ 命令格式
+```
+/help [命令名称]
+```
+
+## 🎯 功能说明
+此命令用于查看所有可用命令的帮助信息，或获取特定命令的详细说明。
+
+## 📋 使用方法
+
+### 1. 📑 查看所有命令
+```
+/help
+```
+- 💫 功能：显示完整命令列表
+- 📝 显示格式：
+  - 命令名称
+  - 简要说明
+  - 基本用法
+
+### 2. 🔍 查看特定命令
+```
+/help <命令名称>
+```
+- 💫 功能：显示指定命令的详细信息
+- 📝 示例：`/help currency`
+- ℹ️ 显示内容：
+  - 📌 命令说明
+  - ⌨️ 使用方法
+  - 📑 参数详解
+
+## ⚡ 注意事项
+1. 📝 命令名称不区分大小写
+2. 🔤 仅支持英文命令名
+3. ⚠️ 无效命令将提示错误
+4. 💡 默认显示所有命令概览
+
+---
+
+# 📦 库存 (Inventory) 命令
+> 一键管理所有游戏物品，打造完美账号
+
+## ⌨️ 命令格式
+```
+/inventory <addall|addallmax|removeall>
+```
+
+## 🎯 功能说明
+此命令用于管理玩家的所有库存物品，包括角色、武器、装备等全部游戏内容。
+
+## 📋 可用子命令
+
+### 1. ✨ 添加所有物品（普通）
+```
+/inventory addall
+```
+- 💫 功能：添加所有游戏内容
+- 📦 添加内容：
+  - 👥 所有角色（基础状态）
+  - ⚔️ 所有武器（基础状态）
+  - 🛡️ 所有装备
+  - 🎁 所有道具
+  - 🔧 所有装置
+  - 🏰 所有记忆大厅
+  - 📚 所有剧情
+
+### 2. 🌟 添加所有物品（最大化）
+```
+/inventory addallmax
+```
+- 💫 功能：添加所有内容（最强状态）
+- 📦 添加内容：
+  - 👥 所有角色（满级满培养）
+  - ⚔️ 所有武器（满级满突破）
+  - 🛡️ 所有装备
+  - 🎁 所有道具
+  - 🔧 所有装置（满级）
+  - 🏰 所有记忆大厅
+  - 📚 所有剧情
+
+### 3. 🗑️ 移除所有物品
+```
+/inventory removeall
+```
+- 💫 功能：清空所有物品
+- ⚠️ 移除内容：
+  - 👥 所有角色
+  - ⚔️ 所有武器
+  - 🛡️ 所有装备
+  - 🎁 所有道具
+  - 🔧 所有装置
+  - 🏰 所有记忆大厅
+  - 📚 所有剧情
+
+## ⚡ 注意事项
+1. 🔄 操作自动保存
+2. 📝 命令不区分大小写
+3. ⚠️ 清空操作不可撤销
+4. ✨ 最大化会将可培养内容提升至最高等级
+
+---
+# 💾 加载数据 (LoadData) 命令
+> 轻松导入存档数据，快速恢复游戏进度
+
+## ⌨️ 命令格式
+```
+/loaddata <文件名|list>
+```
+
+## 🎯 功能说明
+此命令用于从保存的数据文件中加载账号数据，包括角色、武器、装备等全部游戏内容。
+
+## 📋 使用方法
+
+### 1. 📑 查看可用数据文件
+```
+/loaddata list
+```
+- 💫 功能：显示可用存档列表
+- 📂 位置：Resources/account_data/
+- 📝 显示：所有可加载的存档文件
+
+### 2. 📥 加载指定数据文件
+```
+/loaddata <文件名>
+```
+- 💫 功能：加载指定存档数据
+- 📝 示例：`/loaddata save1.json`
+- 📦 加载内容：
+  - 👤 账号信息（昵称、等级等）
+  - 👥 角色数据
+  - ⚔️ 武器数据
+  - 🎁 道具数据
+  - 🔧 装置数据
+  - 🛡️ 装备数据
+  - 🏰 记忆大厅数据
+  - ☕ 咖啡厅数据
+  - 👥 梯队编成数据
+
+## ⚡ 注意事项
+1. 📂 文件必须在指定目录
+2. 📄 需包含文件扩展名
+3. 🔄 会覆盖当前账号数据
+4. 🔗 自动处理ID映射
+5. ⚠️ 无效文件将提示错误
+6. ✅ 成功后显示确认消息
+
+---
+
+# ⚙️ 设置账号 (SetAccount) 命令
+> 自定义您的账号信息，打造个性化体验
+
+## ⌨️ 命令格式
+```
+/setaccount <属性名> <值>
+```
+
+## 🎯 功能说明
+此命令用于修改玩家账号的各项属性数据。
+
+## 📋 可用属性
+
+### 👤 基础信息
+- `Nickname` - 📝 昵称
+  - 类型：文本
+  - 示例：`/setaccount Nickname Sensei`
+
+- `Level` - 📊 等级
+  - 类型：整数
+  - 示例：`/setaccount Level 75`
+
+- `Exp` - ✨ 经验值
+  - 类型：整数
+  - 示例：`/setaccount Exp 999999`
+
+### 🎨 个人设置
+- `CallName` - 📢 称呼名称
+  - 类型：文本
+  - 示例：`/setaccount CallName Teacher`
+
+- `Comment` - 📝 个人简介
+  - 类型：文本
+  - 示例：`/setaccount Comment "Hello World"`
+
+- `LobbyMode` - 🏰 大厅模式
+  - 类型：整数
+  - 示例：`/setaccount LobbyMode 1`
+
+### 🎭 展示相关
+- `RepresentCharacterServerId` - 👥 代表角色ID
+  - 类型：整数
+  - 示例：`/setaccount RepresentCharacterServerId 10000`
+
+- `MemoryLobbyUniqueId` - 🏰 记忆大厅ID
+  - 类型：整数
+  - 示例：`/setaccount MemoryLobbyUniqueId 1`
+
+### 📊 账号状态
+- `State` - 🔰 账号状态
+  - 类型：AccountState枚举
+  - 示例：`/setaccount State Normal`
+
+- `VIPLevel` - 👑 VIP等级
+  - 类型：整数
+  - 示例：`/setaccount VIPLevel 5`
+
+### ⏰ 时间相关
+- `BirthDay` - 🎂 生日
+  - 类型：日期时间
+  - 示例：`/setaccount BirthDay 2024-01-01`
+
+- `LastConnectTime` - 🔄 最后连接时间
+  - 类型：日期时间
+  - 示例：`/setaccount LastConnectTime "2024-01-01 12:00:00"`
+
+## ⚡ 注意事项
+1. 📝 属性名区分大小写
+2. 🔢 值类型必须匹配
+3. 🔄 修改立即生效
+4. ⚠️ 无效输入将提示错误
+5. 📅 日期格式需正确
+6. 💡 谨慎修改重要属性
+
+---
+# 🔓 解锁全部 (UnlockAll) 命令
+> 一键解锁所有游戏内容，畅玩无限可能
+
+## ⌨️ 命令格式
+```
+/unlockall <内容类型>
+```
+
+## 🎯 功能说明
+此命令用于解锁游戏中的各类关卡内容，包括主线剧情、每周副本、学院副本等。
+
+## 📋 可用内容类型
+
+### 1. 📚 主线剧情 (campaign)
+```
+/unlockall campaign
+```
+- 💫 功能：解锁所有主线关卡
+- 📦 解锁内容：
+  - 🔰 普通难度关卡
+  - ⚔️ 困难难度关卡
+  - ✨ 额外关卡
+  - 🌟 超困难关卡
+- ✅ 完成状态：
+  - 🎯 已通关
+  - ⭐ 获得全部三星
+  - 🎁 已领取首次通关奖励
+  - 🏆 已领取星级奖励
+
+### 2. 🗺️ 每周副本 (weekdungeon)
+```
+/unlockall weekdungeon
+```
+- 💫 功能：解锁所有每周副本
+- ✅ 完成状态：
+  - 🎯 关卡已完成
+  - ⭐ 星级目标达成
+  - 📦 宝箱收集最大值
+
+### 3. 🏫 学院副本 (schooldungeon)
+```
+/unlockall schooldungeon
+```
+- 💫 功能：解锁所有学院副本
+- ✅ 完成状态：
+  - 🎯 关卡已完成
+  - ⭐ 星级目标达成
+
+## ⚡ 注意事项
+1. 📝 类型名不区分大小写
+2. 🔄 解锁立即生效并保存
+3. ⚠️ 无效类型将提示错误
+4. 💡 解锁后无法撤销
+
+---
+
+## 📝 文档更新记录
+
+### v1.0.0 (2025-01-20)
+- ✨ 首次发布完整命令文档
+- 📚 添加所有基础命令说明
+- 🎨 优化文档排版和样式
+- 🔍 补充详细使用示例
+- 🐛 修复文档格式问题
+- ✨ 添加更多使用示例
+- 📝 完善注意事项说明
+
+---
+*💡 如有任何问题或建议，欢迎随时反馈！*

Command_EN.md

@@ -0,0 +1,187 @@
+# 💻 Blue Archive Command Manual  
+*📝 Author: Ge Zhu*  
+*📝 Translate: Kitano Sakura*  
+---
+
+## 📑 Table of Contents  
+- [🏰 Cafe Commands (Cafe)](#cafe-commands-cafe)  
+- [👥 Character Commands (Character)](#character-commands-character)  
+- [💎 Currency Commands (Currency)](#currency-commands-currency)  
+- [❓ Help Commands (Help)](#help-commands-help)  
+- [📦 Inventory Commands (Inventory)](#inventory-commands-inventory)  
+- [💾 Load Data Commands (LoadData)](#load-data-commands-loaddata)  
+- [⚙️ Set Account Commands (SetAccount)](#set-account-commands-setaccount)  
+- [🔓 Unlock All Commands (UnlockAll)](#unlock-all-commands-unlockall)  
+
+---
+
+# 🏰 Cafe Commands (Cafe)  
+> Build your ideal cafe and create a unique relaxation space  
+
+## ⌨️ Command Format  
+```
+/cafe <character|furniture> <add|addall|removeall> [id/amount]
+```  
+
+## 🎯 Function Description  
+This command allows you to manage the in-game Cafe system, enabling you to freely arrange characters and furniture.  
+
+## 📋 Available Subcommands  
+
+### 👥 Character Management (character)  
+
+#### 1. ➕ Add a Single Character  
+```
+/cafe character add <CharacterID>
+```  
+- 💫 Function: Adds a specified character ID to the Cafe  
+- 📝 Example: `/cafe character add 123`  
+- ℹ️ Note: Adding a duplicate character will prompt a message  
+
+#### 2. ✨ Batch Add Characters  
+```
+/cafe character addall [amount]
+```  
+- 💫 Function: Adds multiple eligible characters to the Cafe  
+- 📝 Examples:  
+  - `/cafe character addall` (Adds 50 characters)  
+  - `/cafe character addall 100` (Adds 100 characters)  
+- ℹ️ Conditions for addition:  
+  - ✅ Playable characters only  
+  - ✅ Non-NPC characters  
+  - ✅ Officially released characters  
+
+#### 3. 🗑️ Remove All Characters  
+```
+/cafe character removeall
+```  
+- 💫 Function: Clears all characters from the Cafe  
+- ⚠️ Warning: This action is irreversible  
+
+## ⚡ Notes  
+1. 🔄 All commands automatically save changes  
+2. 📝 Commands are case-insensitive  
+3. ℹ️ Duplicate characters cannot be added  
+4. 🚧 Furniture functionality is under development  
+
+---  
+
+# 👥 Character Commands (Character)  
+> Manage your character system and build the perfect combat team  
+
+## ⌨️ Command Format  
+```
+/character <add|clear> [all|characterId]
+```  
+
+## 🎯 Function Description  
+This command manages the player’s character system, supporting the addition and clearing of characters.  
+
+## 📋 Available Subcommands  
+
+### ✨ Add Characters (add)  
+
+#### 1. 🌟 Add All Characters  
+```
+/character add all
+```  
+- 💫 Function: Adds all available characters  
+- ✨ Features: Characters are added in their strongest state:  
+  - ✅ Max level  
+  - ✅ Fully developed  
+  - ✅ Skills maxed out  
+
+#### 2. ➕ Add a Specific Character  
+```
+/character add <CharacterID>
+```  
+- 💫 Function: Adds a specific character by ID  
+- 📝 Example: `/character add 1`  
+- ℹ️ Note: Characters are added in their strongest state  
+
+### 🗑️ Clear All Characters (clear)  
+```
+/character clear
+```  
+- 💫 Function: Clears all characters  
+- ⚠️ Warning: This action is irreversible  
+
+## ⚡ Notes  
+1. 🔄 Operations save automatically  
+2. 📝 Commands are case-insensitive  
+3. ℹ️ Duplicate additions prompt a message  
+4. ⚠️ Use clear commands with caution  
+
+---
+
+# 💎 Currency Commands (Currency)  
+> Freely adjust the amount of various currencies for a better gaming experience  
+
+## ⌨️ Command Format  
+```
+/currency <currencyType> <amount>
+```  
+
+## 🎯 Function Description  
+This command modifies the amounts of various currencies in your account.  
+
+## 💰 Available Currency Types  
+
+### 💫 Basic Currencies  
+- `Gold` - 💰 Gold  
+- `Gem` - 💎 Pyroxene (total)  
+- `GemPaid` - 💳 Paid Pyroxene  
+- `GemBonus` - 🎁 Bonus Pyroxene  
+
+### 🎫 Stamina Tickets  
+- `ActionPoint` - ⚡ Stamina  
+- `AcademyTicket` - 📚 Academy Tickets  
+- `ArenaTicket` - ⚔️ Arena Tickets  
+- `RaidTicket` - 🎯 Raid Tickets  
+
+### 🗺️ Weekly Dungeon Tickets  
+- `WeekDungeonChaserATicket` - 🏃‍♂️ Chase Battle A Ticket  
+- `WeekDungeonChaserBTicket` - 🏃‍♀️ Chase Battle B Ticket  
+- `WeekDungeonChaserCTicket` - 🏃 Chase Battle C Ticket  
+- `WeekDungeonFindGiftTicket` - 🎁 Treasure Hunt Ticket  
+- `WeekDungeonBloodTicket` - 🗡️ Blood Battle Ticket  
+- `ChaserTotalTicket` - 🎯 Total Chase Battle Ticket  
+
+### 🏫 Academy Dungeon Tickets  
+- `SchoolDungeonATicket` - 📘 Academy Dungeon A Ticket  
+- `SchoolDungeonBTicket` - 📗 Academy Dungeon B Ticket  
+- `SchoolDungeonCTicket` - 📙 Academy Dungeon C Ticket  
+- `SchoolDungeonTotalTicket` - 📚 Total Academy Dungeon Ticket  
+
+### 🌟 Special Dungeon Tickets  
+- `TimeAttackDungeonTicket` - ⏱️ Time Attack Dungeon Ticket  
+- `WorldRaidTicketA` - 🌍 World Raid A Ticket  
+- `WorldRaidTicketB` - 🌎 World Raid B Ticket  
+- `WorldRaidTicketC` - 🌏 World Raid C Ticket  
+
+### ⚔️ Elimination Tickets  
+- `EliminateTicketA` - 🗡️ Elimination A Ticket  
+- `EliminateTicketB` - ⚔️ Elimination B Ticket  
+- `EliminateTicketC` - 🛡️ Elimination C Ticket  
+- `EliminateTicketD` - 🔰 Elimination D Ticket  
+
+### 🏆 Others  
+- `MasterCoin` - 🎖️ Master Coin  
+
+## 📝 Usage Examples  
+```
+/currency Gem 99999          # Set Pyroxene to 99999  
+/currency ActionPoint 9999   # Set Stamina to 9999  
+/currency Gold 99999999      # Set Gold to 99999999  
+```  
+
+## ⚡ Notes  
+1. 📝 Currency types are case-sensitive  
+2. 🔢 Amounts must be integers  
+3. 🔄 Changes are effective immediately  
+4. ⚠️ Invalid inputs will prompt an error  
+5. 💡 Use responsibly  
+
+---  
+
+(Translation continued upon request!)

Mitmproxy_Readme_EN.md

@@ -1,132 +1,128 @@
-## Mitmproxy Usage Guide  
+---
-(By 北野樱奈)  
 
-## Prerequisites  
+# 🌐 **Mitmproxy Usage Guide**  
- 1. [Download mitmproxy](https://mitmproxy.org/) and install it.  
+* (By Kitano Sakura)*  
- 2. Basic knowledge of WireGuard and Python scripting.  
- 3. A client device (e.g., Android emulator or smartphone) and a host machine running `mitmproxy`.  
 
-### Installation Steps  
+---
-- **Linux/Mac**  
-```markdown
-# Ubuntu/Debian  
 
-sudo apt update  
+## 🛠️ **Prerequisites**  
-sudo apt install mitmproxy  
+   - Download and install [**Mitmproxy**](https://mitmproxy.org/).  
+   - Basic knowledge of **WireGuard** and **Python scripting**.  
+   - Required devices:  
+   - A host machine to run **Mitmproxy**.  
+   - A client device (e.g., Android emulator or smartphone).  
 
-# macOS  
+---
-brew install mitmproxy  
+
+## 📥 **Step 1: Install Mitmproxy**  
+
+### 📂 Installation  
+
+#### Linux / macOS  
+```bash
+# Ubuntu/Debian
+sudo apt update
+sudo apt install mitmproxy
+
+# macOS
+brew install mitmproxy
 ```  
-- **Windows**: Download the `.exe` installer from [mitmproxy.org](https://mitmproxy.org/) and follow the instructions to complete the installation.  
 
-### Verify Installation  
+#### Windows  
-Run the following command to verify the installation:  
+Download the `.exe` installer from [**mitmproxy.org**](https://mitmproxy.org/) and follow the setup instructions.  
-```bash  
+
-mitmproxy --version  
+### ✅ Verify Installation  
+Run the following command to confirm successful installation:  
+```bash
+mitmproxy --version
 ```  
 
 ---
 
-## Step 2: Install CA Certificates on Client and Server  
+## 🔑 **Step 2: Install the CA Certificate**  
 
-To decrypt HTTPS traffic, the client needs to trust the `mitmproxy` CA certificate.  
+### 📜 Steps  
 
-### Steps  
+1. Start `mitmproxy` to generate the CA certificate:  
- 1. Start `mitmproxy` to generate the certificate:  
+   ```bash
-   ```bash  
+   mitmdump
-   mitmdump  
    ```  
- 2. On the PC, navigate to `C:\Users\YourUser\.mitmproxy` to locate the certificate file (mitmproxy-ca.p12).  
+2. Locate the generated certificate:  
- 3. In the `mitmproxy` directory, locate `mitmproxy-ca-cert.crt`.  
+   - Certificate path:  
- 4. Rename `mitmproxy-ca-cert.crt` to `c8750f0d.0`.  
+     - `C:\Users\<Username>\.mitmproxy\mitmproxy-ca-cert.crt` (Windows)  
- 5. Install the certificate as a system CA.  
+     - `~/.mitmproxy/` (Linux / macOS)  
-
+3. Rename `mitmproxy-ca-cert.crt` to `c8750f0d.0`.  
----  
+4. Move the certificate to the system CA directory and set permissions:  
-
+   ```bash
-### For Android Devices  
+   adb root
- 1. Move the certificate to the system CA directory:  
+   adb remount
-   ```bash  
+   adb shell mv /sdcard/c8750f0d.0 /system/etc/security/cacerts/
-   adb root  
+   adb shell chmod 644 /system/etc/security/cacerts/c8750f0d.0
-   adb remount  
+   adb reboot
-   adb shell mv /sdcard/c8750f0d.0 /system/etc/security/cacerts/  
-   ```  
- 2. Set the correct permissions:  
-   ```bash  
-   adb shell chmod 644 /system/etc/security/cacerts/c8750f0d.0  
-   ```  
- 3. Reboot the device:  
-   ```bash  
-   adb reboot  
    ```  
 
 ---
 
-## Step 3: Download the Redirect Script  
+## 🔧 **Step 3: Configure the Redirect Script**  
 
-Download the script from the repository.  
+Download `redirect_server.py` from the repository and modify the `SERVER_HOST` field:  
 
-### Note: **Make sure to modify the IP address in `redirect_server.py`.**  
+```python
-```python  
+import gzip
-import gzip  
+import json
-import json  
+from mitmproxy import http
-from mitmproxy import http  
 
-SERVER_HOST = 'Replace this with your IP'  
+SERVER_HOST = 'Update here'  # Replace with your server IP
-SERVER_PORT = 80  
+SERVER_PORT = 80
 
-REWRITE_HOST_LIST = [  
+REWRITE_HOST_LIST = [
-    'ba-jp-sdk.bluearchive.jp',  
+    'ba-jp-sdk.bluearchive.jp',
-    'prod-gateway.bluearchiveyostar.com',  
+    'prod-gateway.bluearchiveyostar.com',
-    'prod-game.bluearchiveyostar.com',  
+    'prod-game.bluearchiveyostar.com',
-    # 'prod-notice.bluearchiveyostar.com',  
+]
-    # 'prod-logcollector.bluearchiveyostar.com',  
-]  
 ```  
 
 ---
 
-## Step 4: Launch mitmproxy and Load the Script  
+## 🚀 **Step 4: Start Mitmproxy**  
 
-Run the following command to start `mitmproxy` with the redirect script:  
+Run the following command to launch Mitmproxy with the redirect script:  
-```bash  
+```bash
-mitmweb -m wireguard --no-http2 -s redirect_server.py --set termlog_verbosity=warn --ignore Your IP 
+mitmweb -m wireguard --no-http2 -s redirect_server.py --set termlog_verbosity=warn --ignore <your IP address>
 ```  
 
-### Parameter Explanation:  
+### 📝 Parameter Explanation:  
 - `-m wireguard`: Use WireGuard as the network layer.  
-- `--no-http2`: Disable HTTP/2 to improve compatibility.  
+- `--no-http2`: Disable HTTP/2 for better compatibility.  
 - `-s redirect_server.py`: Load the redirect script.  
-- `--set termlog_verbosity=warn`: Set log level to warnings only.  
+- `--set termlog_verbosity=warn`: Show warnings only in logs.  
 
-You can monitor traffic through the `mitmweb` interface at `http://localhost:8081`.  
+Access the Mitmproxy web interface at `http://localhost:8081` to monitor traffic.  
 
 ---
 
-## Step 5: Install and Configure WireGuard  
+## 🔄 **Step 5: Install WireGuard**  
 
-Use WireGuard to route client traffic to `mitmproxy`.  
+### 📥 Installation  
+- **Android**: Download from [**Google Play**](https://play.google.com/store/apps/details?id=com.wireguard.android).  
+- **Other Platforms**: Refer to the [**official WireGuard installation guide**](https://www.wireguard.com/install/).  
 
-### Installation Steps  
+### ⚙️ Configuration  
-- **Android**: [Download WireGuard](https://play.google.com/store/apps/details?id=com.wireguard.android).  
+1. Open the WireGuard client and scan the QR code provided by Mitmproxy.  
-- **Other Platforms**: Refer to the [official WireGuard installation guide](https://www.wireguard.com/install/).  
+2. Apply the configuration to route all traffic through Mitmproxy.  
-
-### Configuration Steps  
- 1. Open the WireGuard client, click the `+` button in the bottom left corner, and select **Scan QR Code**.  
- 2. The emulator will display a scanner window. Select **Real-time Screenshot**.  
- 3. Position the screenshot over the QR code in the Mitmproxy browser page (accessible via settings).  
- 4. Enable the configuration.  
 
 ---
 
-## Troubleshooting  
+## 🛠️ **Troubleshooting**  
 
-### Error: Client TLS handshake failed. The client does not trust the proxy's certificate for yostar-oversea-netsdk-logging.ap-southeast-1.log.aliyuncs.com (OpenSSL Error([('SSL routines', '', 'ssl/tls alert certificate unknown')]))  
+### ❌ Error: Client TLS handshake failed  
-- Ensure that both the PC and client have the same Mitmproxy certificate installed.  
+- Ensure the same CA certificate is installed on both the host and client devices.  
-- Verify that the Mitmproxy certificate is properly installed on both ends.  
+- Verify that the CA certificate is installed as a system certificate.  
 
-### Android Certificate Disappears After Installation  
+### ❌ Certificate disappears on Android  
-- Use the MT Manager to grant SU (superuser) permissions.  
+- Use MT Manager to grant SU permissions.  
-- Navigate to `/system/etc/security/cacerts/`.  
+- Manually navigate to `/system/etc/security/cacerts/` and reset permissions to `644`.  
-- Locate `c8750f0d.0` and set the permissions to 664. The user group should be set to root.  
 
 ---
+
+🎉 **Done!** 

Mitmproxy_Readme_ZH.md

@@ -1,129 +1,128 @@
-## Mitmproxy方案使用教程
+---
-（By 北野樱奈）
+
-
+# 🌐 **Mitmproxy 方案使用教程**  
-## 前置要求
+* (By 北野樱奈)*  
- 1. [下载 mitmproxy](https://mitmproxy.org/) 并安装。
+
- 2. 具备 WireGuard 和 Python 脚本的基本知识。
+---
- 3. 一台客户端设备（例如 Android 模拟器或手机）以及运行 `mitmproxy` 的主机。
+
-### 安装步骤
+## 🛠️ **前置要求**  
-- Linux/Mac
+   - 下载并安装 [**Mitmproxy**](https://mitmproxy.org/)。  
-```markdown
+   - 熟悉 **WireGuard** 和 **Python 脚本**的基本操作。  
-  # Ubuntu/Debian
+   - 准备以下设备：  
-
+   - 一台运行 **Mitmproxy** 的主机。  
-  sudo apt update
+   - 一台客户端设备（如 Android 模拟器或手机）。  
-  sudo apt install mitmproxy
+
-
+---
-  # macOS
+
-  brew install mitmproxy
+## 📥 **第一步：安装 Mitmproxy**  
-  ```
+
-- **Windows**: 从 [mitmproxy.org](https://mitmproxy.org/) 下载 `.exe` 安装程序，并按说明完成安装。
+### 📂 安装步骤  
-
+
-### 验证安装
+#### Linux / MacOS  
-运行以下命令验证安装是否成功：
+```bash
-```bash
+# Ubuntu/Debian
-mitmproxy --version
+sudo apt update
-```
+sudo apt install mitmproxy
-
+
----
+# macOS
-
+brew install mitmproxy
-## 第二步：在客户端以及服务端安装 CA 证书
+```  
-
+
-为了解密 HTTPS 流量，客户端需要信任 `mitmproxy` 的 CA 证书。
+#### Windows  
-
+从 [**mitmproxy.org**](https://mitmproxy.org/) 下载 `.exe` 安装程序并按说明完成安装。  
-### 操作步骤
+
- 1. 启动 `mitmproxy`生成证书：
+### ✅ 验证安装  
-   ```bash
+运行以下命令确保安装成功：  
-   mitmdump
+```bash
-   ```
+mitmproxy --version
- 2. 在电脑端的C:\Users\用户\ .mitmproxy安装电脑证书（mitmproxy-ca.p12）
+```  
- 3. mitmproxy的目录下会有mitmproxy-ca-cert.crt
+
- 4. 将 mitmproxy-ca-cert.crt 重命名为 c8750f0d.0
+---
- 5. 将证书安装为系统 CA
+
----
+## 🔑 **第二步：安装 CA 证书**  
- 1. 将证书移动到系统 CA 目录：
+
-   ```bash
+### 📜 操作步骤  
-   adb root
+
-   adb remount
+1. 启动 `mitmproxy` 并生成证书：  
-   adb shell mv /sdcard/c8750f0d.0 /system/etc/security/cacerts/
+   ```bash
-   ```
+   mitmdump
- 2. 设置正确的权限：
+   ```  
-   ```bash
+2. 找到生成的证书文件：  
-   adb shell chmod 644 /system/etc/security/cacerts/c8750f0d.0
+   - 证书位于：  
-   ```
+     `C:\Users\<用户名>\.mitmproxy\mitmproxy-ca-cert.crt`（Windows）  
- 3. 重启设备：
+     `~/.mitmproxy/`（Linux / MacOS）  
-   ```bash
+3. 将 `mitmproxy-ca-cert.crt` 重命名为 `c8750f0d.0`。  
-   adb reboot
+4. 使用以下命令将证书移动到系统 CA 目录并设置权限：  
-   ```
+   ```bash
-
+   adb root
----
+   adb remount
----
+   adb shell mv /sdcard/c8750f0d.0 /system/etc/security/cacerts/
-
+   adb shell chmod 644 /system/etc/security/cacerts/c8750f0d.0
-## 第三步：下载重定向脚本
+   adb reboot
-
+   ```  
-可以从仓库下载脚本
+
-
+---
-### 注意：`请一定要修改redirect_server.py内的IP地址`
+
-```python
+## 🔧 **第三步：配置重定向脚本**  
-import gzip
+
-import json
+从仓库下载 `redirect_server.py` 并修改其中的 `SERVER_HOST`：  
-from mitmproxy import http
+
-
+```python
-SERVER_HOST = '修改这里'
+import gzip
-SERVER_PORT = 80
+import json
-
+from mitmproxy import http
-REWRITE_HOST_LIST = [
+
-    'ba-jp-sdk.bluearchive.jp',
+SERVER_HOST = '修改这里'  # 替换为你的服务器 IP
-    'prod-gateway.bluearchiveyostar.com',
+SERVER_PORT = 80
-    'prod-game.bluearchiveyostar.com',
+
-    # 'prod-notice.bluearchiveyostar.com',
+REWRITE_HOST_LIST = [
-    # 'prod-logcollector.bluearchiveyostar.com',
+    'ba-jp-sdk.bluearchive.jp',
-]
+    'prod-gateway.bluearchiveyostar.com',
-```
+    'prod-game.bluearchiveyostar.com',
-
+]
----
+```  
-
+
-## 第四步：启动 mitmproxy 并加载脚本
+---
-
+
-运行以下命令以使用重定向脚本启动 `mitmproxy`：
+## 🚀 **第四步：启动 Mitmproxy**  
-```bash
+
-mitmweb -m wireguard --no-http2 -s redirect_server.py --set termlog_verbosity=warn --ignore 这里输入你的IP地址
+使用以下命令加载重定向脚本并启动代理：  
-```
+```bash
-
+mitmweb -m wireguard --no-http2 -s redirect_server.py --set termlog_verbosity=warn --ignore <你的IP地址>
-### 参数说明：
+```  
-- `-m wireguard`: 使用 WireGuard 作为网络层。
+
-- `--no-http2`: 禁用 HTTP/2 以提高兼容性。
+### 📝 参数说明：  
-- `-s redirect_server.py`: 加载重定向脚本。
+- `-m wireguard`: 使用 WireGuard 作为网络层协议。  
-- `--set termlog_verbosity=warn`: 设置日志级别为警告。
+- `--no-http2`: 禁用 HTTP/2 提高兼容性。  
-
+- `-s redirect_server.py`: 加载重定向脚本。  
-你可以通过 `http://localhost:8081` 访问 `mitmweb` 界面监控流量。
+- `--set termlog_verbosity=warn`: 仅显示警告级别日志。  
-
+
----
+访问 `http://localhost:8081` 查看 Mitmproxy 界面。  
-
+
-## 第五步：安装并配置 WireGuard
+---
-
+
-使用 WireGuard 将客户端流量路由到 `mitmproxy`。
+## 🔄 **第五步：安装 WireGuard**  
-
+
-### 安装步骤
+### 📥 安装步骤  
-- **Android**: [下载 WireGuard](https://play.google.com/store/apps/details?id=com.wireguard.android)。
+- **Android**: 从 [**Google Play**](https://play.google.com/store/apps/details?id=com.wireguard.android) 下载。  
-- **其他平台**: 参考 [WireGuard 官方安装指南](https://www.wireguard.com/install/)。
+- **其他平台**: 参考 [**WireGuard 官方安装指南**](https://www.wireguard.com/install/)。  
-
+
-### 配置步骤
+### ⚙️ 配置步骤  
- 1. 打开 WireGuard 客户端，点击左下角＋号，选择扫描二维码
+1. 打开 WireGuard 客户端并扫描 Mitmproxy 提供的二维码。  
- 2. 选择后模拟器会弹出扫一扫窗口，选择实时截屏
+2. 完成后启用该配置，将所有流量路由到 `Mitmproxy`。  
- 3. 选择截屏后，会有获取图像窗口，移动到Mitmproxy浏览器页面上的二维码（没有的话在设置里面）
+
- 4. 启用该配置。
+---
-
+
----
+## 🛠️ **故障排查**  
-
+
-## 故障排查
+### ❌ 错误：Client TLS handshake failed  
-
+- 检查电脑与客户端是否安装了相同的 CA 证书。  
-### Client TLS handshake failed. The client does not trust the proxy's certificate for yostar-oversea-netsdk-logging.ap-southeast-1.log.aliyuncs.com (OpenSSL Error([('SSL routines', '', 'ssl/tls alert certificate unknown')]))
+- 确保 CA 证书安装为系统证书。  
-- 确保电脑端以及客户端证书为内容一样的
+
-- 确保双端安装了Mitmproxy证书
+### ❌ 安卓端证书消失  
-
+- 使用 MT 管理器授予 SU 权限。  
-### 安卓端安装后证书消失？
+- 手动前往 `/system/etc/security/cacerts/`，重新设置权限为 `644`。  
-- 可以使用MT管理器授予SU权限
+
-- 然后前往/system/etc/security/cacerts/
+---
-- 找到 c8750f0d.0 给予 664 权限。用户组为 root
+
-
+🎉 **完成！** 
----

README.md

@@ -1,68 +1,47 @@
-# SCHALE.GameServer
+
-
+# This Project is now Outdated and Archived, for the Newest Maintained version, Please Use https://git.fufufu.moe/KaniPS/
-### [中文教程](README_zh.md) (by shunner114514)
+
-### [Mitmproxy Solution](Mitmproxy_Readme_EN.md) (by KitanoSakura)
+# 此项目已停止维护，最新版本请用 https://git.fufufu.moe/KaniPS/
-## Prerequisites
+
-
+# 🌌 **SCHALE.GameServer** 🌟  
-- Some computer knowledge
+
-- [.NET SDK 8.0](https://dotnet.microsoft.com/zh-cn/download/dotnet/8.0)
+
-- [SQL Express](https://www.microsoft.com/zh-tw/sql-server/sql-server-downloads)
+# 📚 Project Documentation Directory
-- [SQL Server Management Studio (SSMS)](https://learn.microsoft.com/zh-tw/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-ver16)
+
-- [LD Player 9](https://www.ldplayer.tw/)
+## 📌 Directory
-- [Python](https://www.python.org/)
+
-- [Frida](https://frida.re/)
+- [🔧 Environment Installation](#environment-installation)
-- [frida-server-16.2.5-android-x86_64](https://github.com/frida/frida/releases)
+- [🚀 Command List](Command.md)
-
+- [📦 Mitmproxy Solution](Mitmproxy_Readme_ZH.md)
-## Steps
+- [🎟  Import Official Server Data](Account_Data_into_SCHALE.md)
-
+- [📞 DISCORD](#DISCORD)
-1. Start SQL server
+
-2. Start private game server
+---
-3. Start LD Player
+
-4. Start Frida server
+## 🔧 Environment Installation
-5. Start ブルアカ
+
-6. Inject Frida script
+### 1. Install [SQL Server Express 2022](https://go.microsoft.com/fwlink/p/?linkid=2216019&clcid=0x804&culture=zh-cn&country=cn)
-7. Enjoy :smile:
+  * Open the downloaded installer
-
+  * Select "Basic"
-### SQL server
+  * Choose your preferred installation path
-
+  * Start the installation
-Use SSMS to connect with default settings except that you have to check "Trust server certificate".
+
-
+### 2. Install [SSMS (SQL Server Management Studio 20)](https://aka.ms/ssmsfullsetup)
-### Game server
+  * Keep the default installation path
-
+  * Install
-```bash
+
-# in this repo
+### 3. Install [Microsoft Visual Studio 2022](https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false)
-cd SCHALE.GameServer
+  * Install the Community version
-dotnet run
+  * Select all components related to C# and "Visual Studio Extensions Development" for the workload
-```
+  * Install with the default path
-
+
-### Frida server
+### 4. Install [LDPlayer 9](https://lddl01.ldmnq.com/downloader/ldplayerinst9.exe?n=ldplayer9_ld_999_ld.exe)
-
+  * Download game updates normally after installation is complete
-1. Extract `frida-server-16.2.5-android-x86_64.xz`
+
-to `LDPlayer/frida-server-16.2.5-android-x86_64`.
+### 5. Install [Python](https://www.python.org/ftp/python/3.12.3/python-3.12.3-amd64.exe)
-2. Turn on LD Player
+  * Choose custom installation, leave other settings as default
-3. Turn on root and adb in the settings of LD Player.
+  * Choose the installation path
-4.
+  * Install and wait for completion
-
+  
-```bash
+## 📞 DISCORD
-# in LDPlayer
+- [Discord](https://discord.gg/URaXJpS5gd)
-cd LDPlayer9
-./adb.exe push ../frida-server-16.2.5-android-x86_64 /data/local/tmp/frida-server
-./adb.exe shell
-su
-cd /data/local/tmp
-chmod 755 frida-server
-./frida-server
-```
-
-### Inject Frida script
-
-> [!NOTE]  
-> Edit line 5 of [ba.js](./ba.js) to your own server IP.
-
-> [!WARNING]  
-> Do this fast when you open ブルアカ and see the Yostar logo.
-
-```bash
-# in this repo
-frida -U "ブルアカ" -l ba.js --realm=emulated
-```

README_zh.md

@@ -1,92 +1,37 @@
-# SCHALE.GameServer
+# 🌌 **SCHALE.GameServer** 🌟  
-**本文基于[https://github.com/rafi1212122/SCHALE.GameServer](https://github.com/rafi1212122/SCHALE.GameServer)及个人操作经验编写，资源配置文件请到以上链接获取，若有任何疑问请到Discord社群询问**
+
-
+# 📚 项目文档目录
-### [Mitmproxy方案使用教程](Mitmproxy_Readme_ZH.md) (by 北野樱奈)
+
-
+## 📌 目录
-## 安装准备阶段
+
-### 1.安装[SQL Server Express 2022](https://go.microsoft.com/fwlink/p/?linkid=2216019&clcid=0x804&culture=zh-cn&country=cn)
+- [🔧 环境安装](#环境安装)
-  * 打开你下载的安装程序
+- [🚀 命令列表](Command.md)
-  * 选择“基础”
+- [📦 Mitmproxy方案](Mitmproxy_Readme_ZH.md)
-  * 选择你习惯的安装路径
+- [🎟 导入官服数据](Account_Data_into_SCHALE_ZHCN.md)
-  * 开始安装
+- [📞 DISCORD](#DISCORD)
-### 2.安装[SSMS(SQL Server Management Studio 20)](https://aka.ms/ssmsfullsetup)
+
-  * 路径默认即可
+---
-  * 安装
+
-### 3.安装[Microsoft Visual Studio 2022](https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false)
+## 🔧 环境安装
-  * 安装Community版
+
-  * 工作负荷选择所有带有C#的组件以及“Visual Studio扩展开发”
+### 1.安装[SQL Server Express 2022](https://go.microsoft.com/fwlink/p/?linkid=2216019&clcid=0x804&culture=zh-cn&country=cn)
-  * 直接默认路径安装
+  * 打开你下载的安装程序
-### 4.安装[雷电模拟器9](https://lddl01.ldmnq.com/downloader/ldplayerinst9.exe?n=ldplayer9_ld_999_ld.exe)
+  * 选择“基础”
-### 5.安装[Python](https://www.python.org/ftp/python/3.12.3/python-3.12.3-amd64.exe)
+  * 选择你习惯的安装路径
-  * 选择自定义安装，其余默认
+  * 开始安装
-  * 选择安装路径
+### 2.安装[SSMS(SQL Server Management Studio 20)](https://aka.ms/ssmsfullsetup)
-  * 安装，等待完成
+  * 路径默认即可
-### 6.安装Frida
+  * 安装
-  * win+R打开运行，键入cmd
+### 3.安装[Microsoft Visual Studio 2022](https://visualstudio.microsoft.com/zh-hans/thank-you-downloading-visual-studio/?sku=Community&channel=Release&version=VS2022&source=VSLandingPage&cid=2030&passive=false)
-  * 在cmd中输入`pip install frida`回车
+  * 安装Community版
-  * 等待下载安装完成
+  * 工作负荷选择所有带有C#的组件以及“Visual Studio扩展开发”
-  * 再输入`pip install frida-tools`回车
+  * 直接默认路径安装
-  * 等待下载安装完成（时间可能较长）
+### 4.安装[雷电模拟器9](https://lddl01.ldmnq.com/downloader/ldplayerinst9.exe?n=ldplayer9_ld_999_ld.exe)
-### 7.推送Frida-server至模拟器
+  * 安装完成后正常下载游戏更新
-  * 下载[frida-server-16.x.x-android-x86_64.xz](https://github.com/frida/frida/releases/download/16.3.1/frida-server-16.3.1-android-x86_64.xz)并解压
+### 5.安装[Python](https://www.python.org/ftp/python/3.12.3/python-3.12.3-amd64.exe)
-  * 把frida-server-16.x.x-android-x86_64放入`\leidian\LDPlayer9`路径下
+  * 选择自定义安装，其余默认
-  * 打开模拟器并在设置中打开ADB调试和ROOT权限
+  * 选择安装路径
-  * 在（你安装时的盘）:\leidian\LDPlayer9路径下的导航栏中输入cmd并回车
+  * 安装，等待完成
-  * 输入`adb push frida-server-16.x.x-android-x86_64 /data/local/tmp`
+  
-  * 等待传输完成
+## 📞 DISCORD
-## 资源配置阶段
+- [Discord](https://discord.gg/URaXJpS5gd)
-  * 打开并解压所下载的SCHALE.GameServer-master.zip  
-  * 使用Microsoft Visual Studio 2022打开包中的SCHALE.GameServer.sln  
-  * 选择顶部菜单栏“视图”下拉“终端”  
-  * 若在`...\SCHALE.GameServer-master>`下，请输入`cd SCHALE.GameServer`转到以下路径  
-  * 在`\SCHALE.GameServer-master\SCHALE.GameServer`路径下输入：  
-    `dotnet publish -a x64 --use-current-runtime --self-contained false -p:InvariantGlobalization=false`  
-  * ~~找到并在`\SCHALE.GameServer-master\SCHALE.GameServer\bin\Release\net8.0\win-x64`路径下创建Resources文件夹，再在其下创建excel文件夹，将Excel.zip解压至此文件夹~~（最新版该步骤已集成于`SCHALE.GameServer.exe`）
-  * 打开SSMS，默认连接（注意勾选信任服务器证书）  
-  * 运行`\SCHALE.GameServer-master\SCHALE.GameServer\bin\Release\net8.0\win-x64\SCHALE.GameServer.exe` （后台挂起）（首次运行请允许通过防火墙） 
-  * 找到ba.js文件使用记事本打开，修改第5行`REPLACE THIS WITH YOUR LOCAL IP`为你此时的IPV4地址（网络和Internet设置中可查看）  
-## 启动游戏阶段
-  *建议把ba.js放入\leidian\LDPlayer9路径下*
-    
-  **以下操作每次启动都要执行！**
-  * 打开雷电模拟器
-  * 启动frida
-      * 在（你安装时的盘）:\leidian\LDPlayer9路径下的导航栏中输入cmd并回车
-      * 在所打开的cmd中键入:
-        ```
-        adb shell
-        su    //超级管理员
-        cd /data/local/tmp    //转到此路径下
-        chmod 755 frida-server-16.x.x-android-x86_64
-        ./frida-server-16.x.x-android-x86_64    //启动frida
-        ```
-    **！！！注意此步骤完成后不要关闭该cmd！！！**  
-  
-  * （PC）重新打开一个路径相同的cmd
-  * （模拟器）启动游戏 ブルアカ
-  * 在出现Yostar徽标时键入并回车：  
-    `frida -U "ブルアカ" -l ba.js --realm=emulated`（后台挂起）
-  * 出现`Attatching...`并且SCHALE.GameServer.exe出现Ping时基本成功
-   
-  **###进入私服前需要先连接官服下载资源并通过新手教程###**  
-  
-  **###首次登录设置完名称和发音档时会抛出错误，此时重启`SCHALE.GameServer.exe`、关闭游戏，从“启动游戏ブルアカ”步骤再次开始即可正常进入###**
-  
-## 注意事项
-  * 此项目还处于初期阶段，存在大量不可使用选项，出现问题请尝试重新登录或重启
-  * 若出现`SCHALE.GameServer.exe`没有Ping的情况，请检查ba.js中的IPV4地址与你当前地址是否一致
-  * 若已成功安装SQL Server Express，请不要轻易自行尝试卸载或删除它，否则可能无法再次成功安装
-  * 如果很不幸，你的电脑上已经多次无法成功安装SQL Server Express且不愿意重装系统，以下提供一个平替方案：  
-    *需要较高性能的电脑和足够的硬盘存储*
-    * 安装[VMware Workstation Pro](https://blog.csdn.net/weixin_74195551/article/details/127288338)
-    * 网络搜索许可证密钥填入
-    * 前往Windows官网或其他正规渠道获取Windows 10/11镜像
-    * 创建并安装Windows虚拟机  
-      参阅[VMware中安装win10教程_vmware安装win10-CSDN博客](https://blog.csdn.net/lvlheike/article/details/120398259)
-    * 创建完虚拟机需设置：
-      * 你的电脑：设置-系统-屏幕-显示卡-默认图形设置，启用“硬件加速GPU计划”
-      * （虚拟机设置）处理器：勾选虚拟化Intel VT-x/EPT或AMD-V/RVI(V)
-      * （虚拟机设置）显示器：勾选“加速3D图形”，选择“指定监视器设置”，监视器数量为1个，图形内存改为所给**内存**的一半
-    * 启动虚拟机
-    * 使用[KMS](https://github.com/zbezj/HEU_KMS_Activator/releases/tag/42.0.4)激活Windows
-    * 完成后即可开始安装

SCHALE.Common/Database/dbs.cs

@@ -11,7 +11,6 @@ using SCHALE.Common.NetworkProtocol;
 
 namespace SCHALE.Common.Database
 {
-
     public abstract class HexaCommand
     {
         public long CommandId { get; set; }
@@ -19,22 +18,22 @@ namespace SCHALE.Common.Database
     }
 
     public enum HexaCommandType
-	{
+    {
-		None = 0,
+        None = 0,
-		UnitSpawn = 1,
+        UnitSpawn = 1,
-		PlayScenario = 2,
+        PlayScenario = 2,
-		StrategySpawn = 3,
+        StrategySpawn = 3,
-		TileSpawn = 4,
+        TileSpawn = 4,
-		TileHide = 5,
+        TileHide = 5,
-		EndBattle = 6,
+        EndBattle = 6,
-		WaitTurn = 7,
+        WaitTurn = 7,
-		StrategyHide = 8,
+        StrategyHide = 8,
-		UnitDie = 9,
+        UnitDie = 9,
-		UnitMove = 10,
+        UnitMove = 10,
-		CharacterEmoji = 11,
+        CharacterEmoji = 11,
-	}
+    }
 
-	public abstract class HexaCondition
+    public abstract class HexaCondition
     {
         public long ConditionId { get; set; }
         public abstract HexaConditionType Type { get; }
@@ -407,7 +406,7 @@ namespace SCHALE.Common.Database
 	public class CampaignMainStageSaveDB : ContentSaveDB
 	{
 		public override ContentType ContentType { get => ContentType.CampaignMainStage; }
-		public CampaignState CampaignState { get; set; }
+        public CampaignState CampaignState { get; set; }
 		public int CurrentTurn { get; set; }
 		public int EnemyClearCount { get; set; }
 		public int LastEnemyEntityId { get; set; }
@@ -1530,6 +1529,7 @@ namespace SCHALE.Common.Database
 
 	public class SingleRaidLobbyInfoDB : RaidLobbyInfoDB
 	{
+		public List<Difficulty> ClearDifficulty { get; set; }
 	}
 
 	public class EliminateRaidLobbyInfoDB : RaidLobbyInfoDB
@@ -4849,7 +4849,7 @@ namespace SCHALE.Common.Database
 		public int PassiveSkillLevel { get; set; }
 		public int ExtraPassiveSkillLevel { get; set; }
 		public int FavorRank { get; set; }
-		public StatSnapshotCollection StatSnapshotCollection { get; set; }
+		public List<StatSnapshot> StatSnapshotCollection { get; set; }
 		public long HPRateBefore { get; set; }
 		public long HPRateAfter { get; set; }
 		public int CrowdControlCount { get; set; }
@@ -4883,7 +4883,7 @@ namespace SCHALE.Common.Database
 	
 		[JsonIgnore]
 		public int ExSkillUseCount { get; }
-		public KillLogCollection KillLog { get; set; }
+		public Dictionary<long, int> KillLog { get; set; }
 	
 		[JsonIgnore]
 		public int KillCount { get; }
@@ -4901,7 +4901,7 @@ namespace SCHALE.Common.Database
 	public class SkillCostSummary
 	{
 		public float InitialCost { get; set; }
-		public CostRegenSnapshotCollection CostPerFrameSnapshots { get; set; }
+		public List<SkillCostRegenSnapshot> CostPerFrameSnapshots { get; set; }
 		public List<SkillCostAddSnapshot> CostAddSnapshots { get; set; }
 		public List<SkillCostUseSnapshot> CostUseSnapshots { get; set; }
 	}
@@ -5167,6 +5167,7 @@ namespace SCHALE.Common.Database
 		private int CurrentCount { get; set; }
 		public LogicEffect LogicEffectToDispel { get; }
 		public bool IsDispellable { get; }
+		public EntityId DotInvokerEntityId { get; set; }
 		public Func<bool> ExpirationCheck { get; set; }
 		public Entity ExpirationCheckOwner { get; set; }
 		public int StackSameEffectCount { get; }
@@ -5192,6 +5193,12 @@ namespace SCHALE.Common.Database
 	public abstract class SkillCard : IDisposable
 	{
 		private EventHandler<EventArgs> StateChanged;
+		private EventHandler<UpdateEvent> CardCopyUpdated;
+		public LogicEffectValue[] CopyApplyLogicEffectValues;
+		public SkillSpecification CopySkillSpecification;
+		public bool DeductRedrawGaugeWhenHandExist;
+		public int CopyUseMaxCount;
+		public int CopyUseCount;
 		private static int SkillUniqueIndex;
 		public int SkillCardUniqueId;
 		public int Cost;
@@ -5200,6 +5207,14 @@ namespace SCHALE.Common.Database
 		public int ExtraEnemyCost;
 		public int NPCCost;
 		public int ExtraNPCCost;
+		public BattleEntity CastOwnerEntity { get; }
+		public long CastCharacterId { get; }
+		public long CastOwnerCostumeId { get; }
+		public SkillDataPack CastSkillData { get; }
+		public string CastSkillGroupId { get; }
+		public CharacterSkillListKey CastSkillListKey { get; }
+		public TargetCandidateRule CastCandidateRule { get; }
+		public SkillSlot CastSkillSlot { get; }
 		public abstract BattleEntity OwnerEntity { get; }
 		public abstract long OwnerCostumeId { get; }
 		public SkillDataPack SkillData { get; }
@@ -5222,10 +5237,14 @@ namespace SCHALE.Common.Database
 		public bool IsAutoUse { get; set; }
 		public abstract EntityId OwnerEntityId { get; }
 		public abstract long CharacterId { get; }
-		public int OriginalCost { get; }
+		public string CopyLogicEffectGroupId { get; set; }
+		public SkillCard CopyCard { get; set; }
+		public List<SkillCard> CopiedCard { get; set; }
+		public int OriginalCost { get; set; }
 		public int CostUsed { get; set; }
 		public bool IsNPCCard { get; set; }
 		public int SkillRemainCount { get; set; }
+		public bool IsCopyCard { get; }
 		public void Dispose()
 		{
 		}
@@ -5420,6 +5439,7 @@ namespace SCHALE.Common.Database
 
 	public class Circle : Shape, IEquatable<Circle>
 	{
+		private Vector2 forward;
 		public static Circle Empty { get; }
 		public static Circle Default { get; }
 	
@@ -5430,6 +5450,8 @@ namespace SCHALE.Common.Database
 		public override ValueTuple<float, float> Size { get; }
 		public override Vector2 Center { get; set; }
 		public float Radius { get; set; }
+		public override Vector2 Right { get; set; }
+		public override Vector2 Forward { get; set; }
 		public bool Equals(Circle other)
 		{
 			return default;
@@ -5607,6 +5629,7 @@ namespace SCHALE.Common.Database
 		public TagConstraint TagConstraint { get; }
 		public HPRateConstraint HPRateConstraint { get; }
 		public TacticRoleConstraint TacticRoleConstraint { get; }
+		public bool IsPlayerSquadConstraint { get; }
 		public CoverState CoverState { get; }
 		public bool NeedSearchTarget { get; }
 		public bool Equals(TargetCandidateRule other)
@@ -6988,7 +7011,7 @@ namespace SCHALE.Common.Database
 
 	public class BattleNumericLog : IEquatable<BattleNumericLog>
 	{
-		public BattleEntityType EntityType { get; set; }
+        public string EntityType { get; set; } // original type: BattleEntityType, too lazy to write Enum to string converter
 		public BattleLogCategory Category { get; set; }
 		public BattleLogSourceType Source { get; set; }
 		public long CalculatedSum { get; set; }
@@ -7264,6 +7287,14 @@ namespace SCHALE.Common.Database
 		public bool IsDisabled { get; }
 	}
 
+	public enum UpdateEvent
+	{
+		New = 0,
+		Modify = 1,
+		Dispell = 2,
+		Remove = 3,
+	}
+
 	public class SkillDataPack
 	{
 		public NewSkillAction Action { get; }
@@ -8557,6 +8588,7 @@ namespace SCHALE.Common.Database
 		public bool Dispellable { get; }
 		public string UIPath { get; }
 		public List<AttackLogicEffectType> LogicEffectTypeReduceGauge { get; }
+		public GaugeTraceType GaugeTraceElement { get; }
 		public override bool IsDurationChangedByStat { get; }
 	}
 
@@ -8594,6 +8626,7 @@ namespace SCHALE.Common.Database
 		public CoverState CoverState;
 		public HPRateConstraint HPRateConstraint;
 		public TacticRoleConstraint TacticRoleConstraint;
+		public bool IsPlayerSquadConstraint;
 		public bool Equals(OptionalCandidateRule other)
 		{
 			return default;
@@ -8639,7 +8672,6 @@ namespace SCHALE.Common.Database
 	public abstract class ExpressionContainer
 	{
 		protected Expression expression;
-		public Stack<string> StackTrace { get; }
 	}
 
 	public abstract class BehaviorNode
@@ -8732,6 +8764,13 @@ namespace SCHALE.Common.Database
 		public bool Dispellable { get; }
 		public List<AttackLogicEffectType> LogicEffectTypeReduceGauge { get; }
 		public string UIPath { get; }
+		public GaugeTraceType GaugeTraceElement { get; }
+	}
+
+	public enum GaugeTraceType
+	{
+		None = 0,
+		HPRate = 1,
 	}
 
 	public enum DiffOperatorType
@@ -8753,14 +8792,12 @@ namespace SCHALE.Common.Database
 		private EvaluateFunctionHandler EvaluateFunction;
 		private EvaluateParameterHandler EvaluateParameter;
 		private Dictionary<string, object> _parameters;
-		private Stack<string> stackTrace;
 		public EvaluateOptions Options { get; set; }
 		protected string OriginalExpression { get; }
 		public static bool CacheEnabled { get; set; }
 		public string Error { get; set; }
 		public LogicalExpression ParsedExpression { get; set; }
 		public Dictionary<string, object> Parameters { get; set; }
-		public Stack<string> StackTrace { get; }
 	}
 
 	public sealed class EvaluateFunctionHandler

SCHALE.Common/FlatData/AccountLevelExcel.cs

@@ -23,30 +23,38 @@ public struct AccountLevelExcel : IFlatbufferObject
   public long Id { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public long Level { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public long Exp { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public long APAutoChargeMax { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public int NewbieExpRatio { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public bool NeedReportEvent { get { int o = __p.__offset(12); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public int CloseInterval { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public long APAutoChargeMax { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public bool NeedReportEvent { get { int o = __p.__offset(16); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
 
   public static Offset<SCHALE.Common.FlatData.AccountLevelExcel> CreateAccountLevelExcel(FlatBufferBuilder builder,
       long Id = 0,
       long Level = 0,
       long Exp = 0,
+      int NewbieExpRatio = 0,
+      int CloseInterval = 0,
       long APAutoChargeMax = 0,
       bool NeedReportEvent = false) {
-    builder.StartTable(5);
+    builder.StartTable(7);
     AccountLevelExcel.AddAPAutoChargeMax(builder, APAutoChargeMax);
     AccountLevelExcel.AddExp(builder, Exp);
     AccountLevelExcel.AddLevel(builder, Level);
     AccountLevelExcel.AddId(builder, Id);
+    AccountLevelExcel.AddCloseInterval(builder, CloseInterval);
+    AccountLevelExcel.AddNewbieExpRatio(builder, NewbieExpRatio);
     AccountLevelExcel.AddNeedReportEvent(builder, NeedReportEvent);
     return AccountLevelExcel.EndAccountLevelExcel(builder);
   }
 
-  public static void StartAccountLevelExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void StartAccountLevelExcel(FlatBufferBuilder builder) { builder.StartTable(7); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddLevel(FlatBufferBuilder builder, long level) { builder.AddLong(1, level, 0); }
   public static void AddExp(FlatBufferBuilder builder, long exp) { builder.AddLong(2, exp, 0); }
-  public static void AddAPAutoChargeMax(FlatBufferBuilder builder, long aPAutoChargeMax) { builder.AddLong(3, aPAutoChargeMax, 0); }
+  public static void AddNewbieExpRatio(FlatBufferBuilder builder, int newbieExpRatio) { builder.AddInt(3, newbieExpRatio, 0); }
-  public static void AddNeedReportEvent(FlatBufferBuilder builder, bool needReportEvent) { builder.AddBool(4, needReportEvent, false); }
+  public static void AddCloseInterval(FlatBufferBuilder builder, int closeInterval) { builder.AddInt(4, closeInterval, 0); }
+  public static void AddAPAutoChargeMax(FlatBufferBuilder builder, long aPAutoChargeMax) { builder.AddLong(5, aPAutoChargeMax, 0); }
+  public static void AddNeedReportEvent(FlatBufferBuilder builder, bool needReportEvent) { builder.AddBool(6, needReportEvent, false); }
   public static Offset<SCHALE.Common.FlatData.AccountLevelExcel> EndAccountLevelExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AccountLevelExcel>(o);
@@ -61,6 +69,8 @@ public struct AccountLevelExcel : IFlatbufferObject
     _o.Id = TableEncryptionService.Convert(this.Id, key);
     _o.Level = TableEncryptionService.Convert(this.Level, key);
     _o.Exp = TableEncryptionService.Convert(this.Exp, key);
+    _o.NewbieExpRatio = TableEncryptionService.Convert(this.NewbieExpRatio, key);
+    _o.CloseInterval = TableEncryptionService.Convert(this.CloseInterval, key);
     _o.APAutoChargeMax = TableEncryptionService.Convert(this.APAutoChargeMax, key);
     _o.NeedReportEvent = TableEncryptionService.Convert(this.NeedReportEvent, key);
   }
@@ -71,6 +81,8 @@ public struct AccountLevelExcel : IFlatbufferObject
       _o.Id,
       _o.Level,
       _o.Exp,
+      _o.NewbieExpRatio,
+      _o.CloseInterval,
       _o.APAutoChargeMax,
       _o.NeedReportEvent);
   }
@@ -81,6 +93,8 @@ public class AccountLevelExcelT
   public long Id { get; set; }
   public long Level { get; set; }
   public long Exp { get; set; }
+  public int NewbieExpRatio { get; set; }
+  public int CloseInterval { get; set; }
   public long APAutoChargeMax { get; set; }
   public bool NeedReportEvent { get; set; }
 
@@ -88,6 +102,8 @@ public class AccountLevelExcelT
     this.Id = 0;
     this.Level = 0;
     this.Exp = 0;
+    this.NewbieExpRatio = 0;
+    this.CloseInterval = 0;
     this.APAutoChargeMax = 0;
     this.NeedReportEvent = false;
   }
@@ -102,8 +118,10 @@ static public class AccountLevelExcelVerify
       && verifier.VerifyField(tablePos, 4 /*Id*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 6 /*Level*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 8 /*Exp*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 10 /*APAutoChargeMax*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*NewbieExpRatio*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 12 /*NeedReportEvent*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 12 /*CloseInterval*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*APAutoChargeMax*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 16 /*NeedReportEvent*/, 1 /*bool*/, 1, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/AttendanceExcel.cs

@@ -87,6 +87,13 @@ public struct AttendanceExcel : IFlatbufferObject
   public ArraySegment<byte>? GetDecorationImagePathBytes() { return __p.__vector_as_arraysegment(40); }
 #endif
   public byte[] GetDecorationImagePathArray() { return __p.__vector_as_array<byte>(40); }
+  public string DecorationGarlandImagePath { get { int o = __p.__offset(42); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetDecorationGarlandImagePathBytes() { return __p.__vector_as_span<byte>(42, 1); }
+#else
+  public ArraySegment<byte>? GetDecorationGarlandImagePathBytes() { return __p.__vector_as_arraysegment(42); }
+#endif
+  public byte[] GetDecorationGarlandImagePathArray() { return __p.__vector_as_array<byte>(42); }
 
   public static Offset<SCHALE.Common.FlatData.AttendanceExcel> CreateAttendanceExcel(FlatBufferBuilder builder,
       long Id = 0,
@@ -107,13 +114,15 @@ public struct AttendanceExcel : IFlatbufferObject
       SCHALE.Common.FlatData.MailType MailType = SCHALE.Common.FlatData.MailType.System,
       SCHALE.Common.FlatData.DialogCategory DialogCategory = SCHALE.Common.FlatData.DialogCategory.Cafe,
       StringOffset TitleImagePathOffset = default(StringOffset),
-      StringOffset DecorationImagePathOffset = default(StringOffset)) {
+      StringOffset DecorationImagePathOffset = default(StringOffset),
-    builder.StartTable(19);
+      StringOffset DecorationGarlandImagePathOffset = default(StringOffset)) {
+    builder.StartTable(20);
     AttendanceExcel.AddExpiryDate(builder, ExpiryDate);
     AttendanceExcel.AddBookSize(builder, BookSize);
     AttendanceExcel.AddAccountLevelLimit(builder, AccountLevelLimit);
     AttendanceExcel.AddDisplayOrder(builder, DisplayOrder);
     AttendanceExcel.AddId(builder, Id);
+    AttendanceExcel.AddDecorationGarlandImagePath(builder, DecorationGarlandImagePathOffset);
     AttendanceExcel.AddDecorationImagePath(builder, DecorationImagePathOffset);
     AttendanceExcel.AddTitleImagePath(builder, TitleImagePathOffset);
     AttendanceExcel.AddDialogCategory(builder, DialogCategory);
@@ -131,7 +140,7 @@ public struct AttendanceExcel : IFlatbufferObject
     return AttendanceExcel.EndAttendanceExcel(builder);
   }
 
-  public static void StartAttendanceExcel(FlatBufferBuilder builder) { builder.StartTable(19); }
+  public static void StartAttendanceExcel(FlatBufferBuilder builder) { builder.StartTable(20); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddType(FlatBufferBuilder builder, SCHALE.Common.FlatData.AttendanceType type) { builder.AddInt(1, (int)type, 0); }
   public static void AddCountdownPrefab(FlatBufferBuilder builder, StringOffset countdownPrefabOffset) { builder.AddOffset(2, countdownPrefabOffset.Value, 0); }
@@ -151,6 +160,7 @@ public struct AttendanceExcel : IFlatbufferObject
   public static void AddDialogCategory(FlatBufferBuilder builder, SCHALE.Common.FlatData.DialogCategory dialogCategory) { builder.AddInt(16, (int)dialogCategory, 0); }
   public static void AddTitleImagePath(FlatBufferBuilder builder, StringOffset titleImagePathOffset) { builder.AddOffset(17, titleImagePathOffset.Value, 0); }
   public static void AddDecorationImagePath(FlatBufferBuilder builder, StringOffset decorationImagePathOffset) { builder.AddOffset(18, decorationImagePathOffset.Value, 0); }
+  public static void AddDecorationGarlandImagePath(FlatBufferBuilder builder, StringOffset decorationGarlandImagePathOffset) { builder.AddOffset(19, decorationGarlandImagePathOffset.Value, 0); }
   public static Offset<SCHALE.Common.FlatData.AttendanceExcel> EndAttendanceExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.AttendanceExcel>(o);
@@ -181,6 +191,7 @@ public struct AttendanceExcel : IFlatbufferObject
     _o.DialogCategory = TableEncryptionService.Convert(this.DialogCategory, key);
     _o.TitleImagePath = TableEncryptionService.Convert(this.TitleImagePath, key);
     _o.DecorationImagePath = TableEncryptionService.Convert(this.DecorationImagePath, key);
+    _o.DecorationGarlandImagePath = TableEncryptionService.Convert(this.DecorationGarlandImagePath, key);
   }
   public static Offset<SCHALE.Common.FlatData.AttendanceExcel> Pack(FlatBufferBuilder builder, AttendanceExcelT _o) {
     if (_o == null) return default(Offset<SCHALE.Common.FlatData.AttendanceExcel>);
@@ -192,6 +203,7 @@ public struct AttendanceExcel : IFlatbufferObject
     var _EndDate = _o.EndDate == null ? default(StringOffset) : builder.CreateString(_o.EndDate);
     var _TitleImagePath = _o.TitleImagePath == null ? default(StringOffset) : builder.CreateString(_o.TitleImagePath);
     var _DecorationImagePath = _o.DecorationImagePath == null ? default(StringOffset) : builder.CreateString(_o.DecorationImagePath);
+    var _DecorationGarlandImagePath = _o.DecorationGarlandImagePath == null ? default(StringOffset) : builder.CreateString(_o.DecorationGarlandImagePath);
     return CreateAttendanceExcel(
       builder,
       _o.Id,
@@ -212,7 +224,8 @@ public struct AttendanceExcel : IFlatbufferObject
       _o.MailType,
       _o.DialogCategory,
       _TitleImagePath,
-      _DecorationImagePath);
+      _DecorationImagePath,
+      _DecorationGarlandImagePath);
   }
 }
 
@@ -237,6 +250,7 @@ public class AttendanceExcelT
   public SCHALE.Common.FlatData.DialogCategory DialogCategory { get; set; }
   public string TitleImagePath { get; set; }
   public string DecorationImagePath { get; set; }
+  public string DecorationGarlandImagePath { get; set; }
 
   public AttendanceExcelT() {
     this.Id = 0;
@@ -258,6 +272,7 @@ public class AttendanceExcelT
     this.DialogCategory = SCHALE.Common.FlatData.DialogCategory.Cafe;
     this.TitleImagePath = null;
     this.DecorationImagePath = null;
+    this.DecorationGarlandImagePath = null;
   }
 }
 
@@ -286,6 +301,7 @@ static public class AttendanceExcelVerify
       && verifier.VerifyField(tablePos, 36 /*DialogCategory*/, 4 /*SCHALE.Common.FlatData.DialogCategory*/, 4, false)
       && verifier.VerifyString(tablePos, 38 /*TitleImagePath*/, false)
       && verifier.VerifyString(tablePos, 40 /*DecorationImagePath*/, false)
+      && verifier.VerifyString(tablePos, 42 /*DecorationGarlandImagePath*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/CVUnlockScenarioType.cs

@@ -0,0 +1,16 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum CVUnlockScenarioType : int
+{
+  Main = 0,
+  Event = 1,
+  SpecialOperation = 2,
+};
+
+
+}

SCHALE.Common/FlatData/CharacterDialogEmojiExcel.cs

@@ -0,0 +1,150 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
+using global::Google.FlatBuffers;
+
+public struct CharacterDialogEmojiExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CharacterDialogEmojiExcel GetRootAsCharacterDialogEmojiExcel(ByteBuffer _bb) { return GetRootAsCharacterDialogEmojiExcel(_bb, new CharacterDialogEmojiExcel()); }
+  public static CharacterDialogEmojiExcel GetRootAsCharacterDialogEmojiExcel(ByteBuffer _bb, CharacterDialogEmojiExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CharacterDialogEmojiExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long GroupId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public int TargetIndex { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public string DialogType { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetDialogTypeBytes() { return __p.__vector_as_span<byte>(8, 1); }
+#else
+  public ArraySegment<byte>? GetDialogTypeBytes() { return __p.__vector_as_arraysegment(8); }
+#endif
+  public byte[] GetDialogTypeArray() { return __p.__vector_as_array<byte>(8); }
+  public long Duration { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public bool HideUI { get { int o = __p.__offset(12); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public string LocalizeKR { get { int o = __p.__offset(14); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetLocalizeKRBytes() { return __p.__vector_as_span<byte>(14, 1); }
+#else
+  public ArraySegment<byte>? GetLocalizeKRBytes() { return __p.__vector_as_arraysegment(14); }
+#endif
+  public byte[] GetLocalizeKRArray() { return __p.__vector_as_array<byte>(14); }
+  public string LocalizeJP { get { int o = __p.__offset(16); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetLocalizeJPBytes() { return __p.__vector_as_span<byte>(16, 1); }
+#else
+  public ArraySegment<byte>? GetLocalizeJPBytes() { return __p.__vector_as_arraysegment(16); }
+#endif
+  public byte[] GetLocalizeJPArray() { return __p.__vector_as_array<byte>(16); }
+
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel> CreateCharacterDialogEmojiExcel(FlatBufferBuilder builder,
+      long GroupId = 0,
+      int TargetIndex = 0,
+      StringOffset DialogTypeOffset = default(StringOffset),
+      long Duration = 0,
+      bool HideUI = false,
+      StringOffset LocalizeKROffset = default(StringOffset),
+      StringOffset LocalizeJPOffset = default(StringOffset)) {
+    builder.StartTable(7);
+    CharacterDialogEmojiExcel.AddDuration(builder, Duration);
+    CharacterDialogEmojiExcel.AddGroupId(builder, GroupId);
+    CharacterDialogEmojiExcel.AddLocalizeJP(builder, LocalizeJPOffset);
+    CharacterDialogEmojiExcel.AddLocalizeKR(builder, LocalizeKROffset);
+    CharacterDialogEmojiExcel.AddDialogType(builder, DialogTypeOffset);
+    CharacterDialogEmojiExcel.AddTargetIndex(builder, TargetIndex);
+    CharacterDialogEmojiExcel.AddHideUI(builder, HideUI);
+    return CharacterDialogEmojiExcel.EndCharacterDialogEmojiExcel(builder);
+  }
+
+  public static void StartCharacterDialogEmojiExcel(FlatBufferBuilder builder) { builder.StartTable(7); }
+  public static void AddGroupId(FlatBufferBuilder builder, long groupId) { builder.AddLong(0, groupId, 0); }
+  public static void AddTargetIndex(FlatBufferBuilder builder, int targetIndex) { builder.AddInt(1, targetIndex, 0); }
+  public static void AddDialogType(FlatBufferBuilder builder, StringOffset dialogTypeOffset) { builder.AddOffset(2, dialogTypeOffset.Value, 0); }
+  public static void AddDuration(FlatBufferBuilder builder, long duration) { builder.AddLong(3, duration, 0); }
+  public static void AddHideUI(FlatBufferBuilder builder, bool hideUI) { builder.AddBool(4, hideUI, false); }
+  public static void AddLocalizeKR(FlatBufferBuilder builder, StringOffset localizeKROffset) { builder.AddOffset(5, localizeKROffset.Value, 0); }
+  public static void AddLocalizeJP(FlatBufferBuilder builder, StringOffset localizeJPOffset) { builder.AddOffset(6, localizeJPOffset.Value, 0); }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel> EndCharacterDialogEmojiExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel>(o);
+  }
+  public CharacterDialogEmojiExcelT UnPack() {
+    var _o = new CharacterDialogEmojiExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterDialogEmojiExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterDialogEmoji");
+    _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
+    _o.TargetIndex = TableEncryptionService.Convert(this.TargetIndex, key);
+    _o.DialogType = TableEncryptionService.Convert(this.DialogType, key);
+    _o.Duration = TableEncryptionService.Convert(this.Duration, key);
+    _o.HideUI = TableEncryptionService.Convert(this.HideUI, key);
+    _o.LocalizeKR = TableEncryptionService.Convert(this.LocalizeKR, key);
+    _o.LocalizeJP = TableEncryptionService.Convert(this.LocalizeJP, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel> Pack(FlatBufferBuilder builder, CharacterDialogEmojiExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel>);
+    var _DialogType = _o.DialogType == null ? default(StringOffset) : builder.CreateString(_o.DialogType);
+    var _LocalizeKR = _o.LocalizeKR == null ? default(StringOffset) : builder.CreateString(_o.LocalizeKR);
+    var _LocalizeJP = _o.LocalizeJP == null ? default(StringOffset) : builder.CreateString(_o.LocalizeJP);
+    return CreateCharacterDialogEmojiExcel(
+      builder,
+      _o.GroupId,
+      _o.TargetIndex,
+      _DialogType,
+      _o.Duration,
+      _o.HideUI,
+      _LocalizeKR,
+      _LocalizeJP);
+  }
+}
+
+public class CharacterDialogEmojiExcelT
+{
+  public long GroupId { get; set; }
+  public int TargetIndex { get; set; }
+  public string DialogType { get; set; }
+  public long Duration { get; set; }
+  public bool HideUI { get; set; }
+  public string LocalizeKR { get; set; }
+  public string LocalizeJP { get; set; }
+
+  public CharacterDialogEmojiExcelT() {
+    this.GroupId = 0;
+    this.TargetIndex = 0;
+    this.DialogType = null;
+    this.Duration = 0;
+    this.HideUI = false;
+    this.LocalizeKR = null;
+    this.LocalizeJP = null;
+  }
+}
+
+
+static public class CharacterDialogEmojiExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*GroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*TargetIndex*/, 4 /*int*/, 4, false)
+      && verifier.VerifyString(tablePos, 8 /*DialogType*/, false)
+      && verifier.VerifyField(tablePos, 10 /*Duration*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 12 /*HideUI*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyString(tablePos, 14 /*LocalizeKR*/, false)
+      && verifier.VerifyString(tablePos, 16 /*LocalizeJP*/, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CharacterDialogEmojiExcelTable.cs

@@ -0,0 +1,88 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
+using global::Google.FlatBuffers;
+
+public struct CharacterDialogEmojiExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static CharacterDialogEmojiExcelTable GetRootAsCharacterDialogEmojiExcelTable(ByteBuffer _bb) { return GetRootAsCharacterDialogEmojiExcelTable(_bb, new CharacterDialogEmojiExcelTable()); }
+  public static CharacterDialogEmojiExcelTable GetRootAsCharacterDialogEmojiExcelTable(ByteBuffer _bb, CharacterDialogEmojiExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public CharacterDialogEmojiExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.CharacterDialogEmojiExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.CharacterDialogEmojiExcel?)(new SCHALE.Common.FlatData.CharacterDialogEmojiExcel()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int DataListLength { get { int o = __p.__offset(4); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcelTable> CreateCharacterDialogEmojiExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    CharacterDialogEmojiExcelTable.AddDataList(builder, DataListOffset);
+    return CharacterDialogEmojiExcelTable.EndCharacterDialogEmojiExcelTable(builder);
+  }
+
+  public static void StartCharacterDialogEmojiExcelTable(FlatBufferBuilder builder) { builder.StartTable(1); }
+  public static void AddDataList(FlatBufferBuilder builder, VectorOffset dataListOffset) { builder.AddOffset(0, dataListOffset.Value, 0); }
+  public static VectorOffset CreateDataListVector(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcelTable> EndCharacterDialogEmojiExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcelTable>(o);
+  }
+  public CharacterDialogEmojiExcelTableT UnPack() {
+    var _o = new CharacterDialogEmojiExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(CharacterDialogEmojiExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("CharacterDialogEmojiExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.CharacterDialogEmojiExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcelTable> Pack(FlatBufferBuilder builder, CharacterDialogEmojiExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.CharacterDialogEmojiExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.CharacterDialogEmojiExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateCharacterDialogEmojiExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class CharacterDialogEmojiExcelTableT
+{
+  public List<SCHALE.Common.FlatData.CharacterDialogEmojiExcelT> DataList { get; set; }
+
+  public CharacterDialogEmojiExcelTableT() {
+    this.DataList = null;
+  }
+}
+
+
+static public class CharacterDialogEmojiExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.CharacterDialogEmojiExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/CharacterDialogEventExcel.cs

@@ -70,15 +70,16 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
   public uint[] GetVoiceIdArray() { return __p.__vector_as_array<uint>(36); }
   public bool CollectionVisible { get { int o = __p.__offset(38); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
   public SCHALE.Common.FlatData.CVCollectionType CVCollectionType { get { int o = __p.__offset(40); return o != 0 ? (SCHALE.Common.FlatData.CVCollectionType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.CVCollectionType.CVNormal; } }
-  public long UnlockEventSeason { get { int o = __p.__offset(42); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.CVUnlockScenarioType CVUnlockScenarioType { get { int o = __p.__offset(42); return o != 0 ? (SCHALE.Common.FlatData.CVUnlockScenarioType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.CVUnlockScenarioType.Main; } }
-  public long ScenarioGroupId { get { int o = __p.__offset(44); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long UnlockEventSeason { get { int o = __p.__offset(44); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public string LocalizeCVGroup { get { int o = __p.__offset(46); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public long ScenarioGroupId { get { int o = __p.__offset(46); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string LocalizeCVGroup { get { int o = __p.__offset(48); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetLocalizeCVGroupBytes() { return __p.__vector_as_span<byte>(46, 1); }
+  public Span<byte> GetLocalizeCVGroupBytes() { return __p.__vector_as_span<byte>(48, 1); }
 #else
-  public ArraySegment<byte>? GetLocalizeCVGroupBytes() { return __p.__vector_as_arraysegment(46); }
+  public ArraySegment<byte>? GetLocalizeCVGroupBytes() { return __p.__vector_as_arraysegment(48); }
 #endif
-  public byte[] GetLocalizeCVGroupArray() { return __p.__vector_as_array<byte>(46); }
+  public byte[] GetLocalizeCVGroupArray() { return __p.__vector_as_array<byte>(48); }
 
   public static Offset<SCHALE.Common.FlatData.CharacterDialogEventExcel> CreateCharacterDialogEventExcel(FlatBufferBuilder builder,
       long CostumeUniqueId = 0,
@@ -100,10 +101,11 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
       VectorOffset VoiceIdOffset = default(VectorOffset),
       bool CollectionVisible = false,
       SCHALE.Common.FlatData.CVCollectionType CVCollectionType = SCHALE.Common.FlatData.CVCollectionType.CVNormal,
+      SCHALE.Common.FlatData.CVUnlockScenarioType CVUnlockScenarioType = SCHALE.Common.FlatData.CVUnlockScenarioType.Main,
       long UnlockEventSeason = 0,
       long ScenarioGroupId = 0,
       StringOffset LocalizeCVGroupOffset = default(StringOffset)) {
-    builder.StartTable(22);
+    builder.StartTable(23);
     CharacterDialogEventExcel.AddScenarioGroupId(builder, ScenarioGroupId);
     CharacterDialogEventExcel.AddUnlockEventSeason(builder, UnlockEventSeason);
     CharacterDialogEventExcel.AddDuration(builder, Duration);
@@ -114,6 +116,7 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
     CharacterDialogEventExcel.AddOriginalCharacterId(builder, OriginalCharacterId);
     CharacterDialogEventExcel.AddCostumeUniqueId(builder, CostumeUniqueId);
     CharacterDialogEventExcel.AddLocalizeCVGroup(builder, LocalizeCVGroupOffset);
+    CharacterDialogEventExcel.AddCVUnlockScenarioType(builder, CVUnlockScenarioType);
     CharacterDialogEventExcel.AddCVCollectionType(builder, CVCollectionType);
     CharacterDialogEventExcel.AddVoiceId(builder, VoiceIdOffset);
     CharacterDialogEventExcel.AddLocalizeJP(builder, LocalizeJPOffset);
@@ -129,7 +132,7 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
     return CharacterDialogEventExcel.EndCharacterDialogEventExcel(builder);
   }
 
-  public static void StartCharacterDialogEventExcel(FlatBufferBuilder builder) { builder.StartTable(22); }
+  public static void StartCharacterDialogEventExcel(FlatBufferBuilder builder) { builder.StartTable(23); }
   public static void AddCostumeUniqueId(FlatBufferBuilder builder, long costumeUniqueId) { builder.AddLong(0, costumeUniqueId, 0); }
   public static void AddOriginalCharacterId(FlatBufferBuilder builder, long originalCharacterId) { builder.AddLong(1, originalCharacterId, 0); }
   public static void AddDisplayOrder(FlatBufferBuilder builder, long displayOrder) { builder.AddLong(2, displayOrder, 0); }
@@ -154,9 +157,10 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
   public static void StartVoiceIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static void AddCollectionVisible(FlatBufferBuilder builder, bool collectionVisible) { builder.AddBool(17, collectionVisible, false); }
   public static void AddCVCollectionType(FlatBufferBuilder builder, SCHALE.Common.FlatData.CVCollectionType cVCollectionType) { builder.AddInt(18, (int)cVCollectionType, 0); }
-  public static void AddUnlockEventSeason(FlatBufferBuilder builder, long unlockEventSeason) { builder.AddLong(19, unlockEventSeason, 0); }
+  public static void AddCVUnlockScenarioType(FlatBufferBuilder builder, SCHALE.Common.FlatData.CVUnlockScenarioType cVUnlockScenarioType) { builder.AddInt(19, (int)cVUnlockScenarioType, 0); }
-  public static void AddScenarioGroupId(FlatBufferBuilder builder, long scenarioGroupId) { builder.AddLong(20, scenarioGroupId, 0); }
+  public static void AddUnlockEventSeason(FlatBufferBuilder builder, long unlockEventSeason) { builder.AddLong(20, unlockEventSeason, 0); }
-  public static void AddLocalizeCVGroup(FlatBufferBuilder builder, StringOffset localizeCVGroupOffset) { builder.AddOffset(21, localizeCVGroupOffset.Value, 0); }
+  public static void AddScenarioGroupId(FlatBufferBuilder builder, long scenarioGroupId) { builder.AddLong(21, scenarioGroupId, 0); }
+  public static void AddLocalizeCVGroup(FlatBufferBuilder builder, StringOffset localizeCVGroupOffset) { builder.AddOffset(22, localizeCVGroupOffset.Value, 0); }
   public static Offset<SCHALE.Common.FlatData.CharacterDialogEventExcel> EndCharacterDialogEventExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.CharacterDialogEventExcel>(o);
@@ -188,6 +192,7 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
     for (var _j = 0; _j < this.VoiceIdLength; ++_j) {_o.VoiceId.Add(TableEncryptionService.Convert(this.VoiceId(_j), key));}
     _o.CollectionVisible = TableEncryptionService.Convert(this.CollectionVisible, key);
     _o.CVCollectionType = TableEncryptionService.Convert(this.CVCollectionType, key);
+    _o.CVUnlockScenarioType = TableEncryptionService.Convert(this.CVUnlockScenarioType, key);
     _o.UnlockEventSeason = TableEncryptionService.Convert(this.UnlockEventSeason, key);
     _o.ScenarioGroupId = TableEncryptionService.Convert(this.ScenarioGroupId, key);
     _o.LocalizeCVGroup = TableEncryptionService.Convert(this.LocalizeCVGroup, key);
@@ -225,6 +230,7 @@ public struct CharacterDialogEventExcel : IFlatbufferObject
       _VoiceId,
       _o.CollectionVisible,
       _o.CVCollectionType,
+      _o.CVUnlockScenarioType,
       _o.UnlockEventSeason,
       _o.ScenarioGroupId,
       _LocalizeCVGroup);
@@ -252,6 +258,7 @@ public class CharacterDialogEventExcelT
   public List<uint> VoiceId { get; set; }
   public bool CollectionVisible { get; set; }
   public SCHALE.Common.FlatData.CVCollectionType CVCollectionType { get; set; }
+  public SCHALE.Common.FlatData.CVUnlockScenarioType CVUnlockScenarioType { get; set; }
   public long UnlockEventSeason { get; set; }
   public long ScenarioGroupId { get; set; }
   public string LocalizeCVGroup { get; set; }
@@ -276,6 +283,7 @@ public class CharacterDialogEventExcelT
     this.VoiceId = null;
     this.CollectionVisible = false;
     this.CVCollectionType = SCHALE.Common.FlatData.CVCollectionType.CVNormal;
+    this.CVUnlockScenarioType = SCHALE.Common.FlatData.CVUnlockScenarioType.Main;
     this.UnlockEventSeason = 0;
     this.ScenarioGroupId = 0;
     this.LocalizeCVGroup = null;
@@ -307,9 +315,10 @@ static public class CharacterDialogEventExcelVerify
       && verifier.VerifyVectorOfData(tablePos, 36 /*VoiceId*/, 4 /*uint*/, false)
       && verifier.VerifyField(tablePos, 38 /*CollectionVisible*/, 1 /*bool*/, 1, false)
       && verifier.VerifyField(tablePos, 40 /*CVCollectionType*/, 4 /*SCHALE.Common.FlatData.CVCollectionType*/, 4, false)
-      && verifier.VerifyField(tablePos, 42 /*UnlockEventSeason*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 42 /*CVUnlockScenarioType*/, 4 /*SCHALE.Common.FlatData.CVUnlockScenarioType*/, 4, false)
-      && verifier.VerifyField(tablePos, 44 /*ScenarioGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 44 /*UnlockEventSeason*/, 8 /*long*/, 8, false)
-      && verifier.VerifyString(tablePos, 46 /*LocalizeCVGroup*/, false)
+      && verifier.VerifyField(tablePos, 46 /*ScenarioGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 48 /*LocalizeCVGroup*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/ConstEventCommonExcel.cs

@@ -45,6 +45,7 @@ public struct ConstEventCommonExcel : IFlatbufferObject
   public int TreasureLoopVariationAmount { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
   public int TreasureLimitVariationLoopCount { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
   public int TreasureLimitVariationClearLoopCount { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int EventStoryReplayHideEventContentId { get { int o = __p.__offset(30); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
 
   public static Offset<SCHALE.Common.FlatData.ConstEventCommonExcel> CreateConstEventCommonExcel(FlatBufferBuilder builder,
       int EventContentHardStageCount = 0,
@@ -59,12 +60,14 @@ public struct ConstEventCommonExcel : IFlatbufferObject
       int TreasureNormalVariationAmount = 0,
       int TreasureLoopVariationAmount = 0,
       int TreasureLimitVariationLoopCount = 0,
-      int TreasureLimitVariationClearLoopCount = 0) {
+      int TreasureLimitVariationClearLoopCount = 0,
-    builder.StartTable(13);
+      int EventStoryReplayHideEventContentId = 0) {
+    builder.StartTable(14);
     ConstEventCommonExcel.AddSpecialOperactionCollectionGroupId(builder, SpecialOperactionCollectionGroupId);
     ConstEventCommonExcel.AddCardShopProbWeightCount(builder, CardShopProbWeightCount);
     ConstEventCommonExcel.AddSubEventChangeLimitSeconds(builder, SubEventChangeLimitSeconds);
     ConstEventCommonExcel.AddEventStrategyPlayTimeLimitInSeconds(builder, EventStrategyPlayTimeLimitInSeconds);
+    ConstEventCommonExcel.AddEventStoryReplayHideEventContentId(builder, EventStoryReplayHideEventContentId);
     ConstEventCommonExcel.AddTreasureLimitVariationClearLoopCount(builder, TreasureLimitVariationClearLoopCount);
     ConstEventCommonExcel.AddTreasureLimitVariationLoopCount(builder, TreasureLimitVariationLoopCount);
     ConstEventCommonExcel.AddTreasureLoopVariationAmount(builder, TreasureLoopVariationAmount);
@@ -77,7 +80,7 @@ public struct ConstEventCommonExcel : IFlatbufferObject
     return ConstEventCommonExcel.EndConstEventCommonExcel(builder);
   }
 
-  public static void StartConstEventCommonExcel(FlatBufferBuilder builder) { builder.StartTable(13); }
+  public static void StartConstEventCommonExcel(FlatBufferBuilder builder) { builder.StartTable(14); }
   public static void AddEventContentHardStageCount(FlatBufferBuilder builder, int eventContentHardStageCount) { builder.AddInt(0, eventContentHardStageCount, 0); }
   public static void AddEventStrategyPlayTimeLimitInSeconds(FlatBufferBuilder builder, long eventStrategyPlayTimeLimitInSeconds) { builder.AddLong(1, eventStrategyPlayTimeLimitInSeconds, 0); }
   public static void AddSubEventChangeLimitSeconds(FlatBufferBuilder builder, long subEventChangeLimitSeconds) { builder.AddLong(2, subEventChangeLimitSeconds, 0); }
@@ -91,6 +94,7 @@ public struct ConstEventCommonExcel : IFlatbufferObject
   public static void AddTreasureLoopVariationAmount(FlatBufferBuilder builder, int treasureLoopVariationAmount) { builder.AddInt(10, treasureLoopVariationAmount, 0); }
   public static void AddTreasureLimitVariationLoopCount(FlatBufferBuilder builder, int treasureLimitVariationLoopCount) { builder.AddInt(11, treasureLimitVariationLoopCount, 0); }
   public static void AddTreasureLimitVariationClearLoopCount(FlatBufferBuilder builder, int treasureLimitVariationClearLoopCount) { builder.AddInt(12, treasureLimitVariationClearLoopCount, 0); }
+  public static void AddEventStoryReplayHideEventContentId(FlatBufferBuilder builder, int eventStoryReplayHideEventContentId) { builder.AddInt(13, eventStoryReplayHideEventContentId, 0); }
   public static Offset<SCHALE.Common.FlatData.ConstEventCommonExcel> EndConstEventCommonExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ConstEventCommonExcel>(o);
@@ -115,6 +119,7 @@ public struct ConstEventCommonExcel : IFlatbufferObject
     _o.TreasureLoopVariationAmount = TableEncryptionService.Convert(this.TreasureLoopVariationAmount, key);
     _o.TreasureLimitVariationLoopCount = TableEncryptionService.Convert(this.TreasureLimitVariationLoopCount, key);
     _o.TreasureLimitVariationClearLoopCount = TableEncryptionService.Convert(this.TreasureLimitVariationClearLoopCount, key);
+    _o.EventStoryReplayHideEventContentId = TableEncryptionService.Convert(this.EventStoryReplayHideEventContentId, key);
   }
   public static Offset<SCHALE.Common.FlatData.ConstEventCommonExcel> Pack(FlatBufferBuilder builder, ConstEventCommonExcelT _o) {
     if (_o == null) return default(Offset<SCHALE.Common.FlatData.ConstEventCommonExcel>);
@@ -134,7 +139,8 @@ public struct ConstEventCommonExcel : IFlatbufferObject
       _o.TreasureNormalVariationAmount,
       _o.TreasureLoopVariationAmount,
       _o.TreasureLimitVariationLoopCount,
-      _o.TreasureLimitVariationClearLoopCount);
+      _o.TreasureLimitVariationClearLoopCount,
+      _o.EventStoryReplayHideEventContentId);
   }
 }
 
@@ -153,6 +159,7 @@ public class ConstEventCommonExcelT
   public int TreasureLoopVariationAmount { get; set; }
   public int TreasureLimitVariationLoopCount { get; set; }
   public int TreasureLimitVariationClearLoopCount { get; set; }
+  public int EventStoryReplayHideEventContentId { get; set; }
 
   public ConstEventCommonExcelT() {
     this.EventContentHardStageCount = 0;
@@ -168,6 +175,7 @@ public class ConstEventCommonExcelT
     this.TreasureLoopVariationAmount = 0;
     this.TreasureLimitVariationLoopCount = 0;
     this.TreasureLimitVariationClearLoopCount = 0;
+    this.EventStoryReplayHideEventContentId = 0;
   }
 }
 
@@ -190,6 +198,7 @@ static public class ConstEventCommonExcelVerify
       && verifier.VerifyField(tablePos, 24 /*TreasureLoopVariationAmount*/, 4 /*int*/, 4, false)
       && verifier.VerifyField(tablePos, 26 /*TreasureLimitVariationLoopCount*/, 4 /*int*/, 4, false)
       && verifier.VerifyField(tablePos, 28 /*TreasureLimitVariationClearLoopCount*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 30 /*EventStoryReplayHideEventContentId*/, 4 /*int*/, 4, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/ConstFieldExcel.cs

@@ -25,56 +25,14 @@ public struct ConstFieldExcel : IFlatbufferObject
   public int ThinkDialogDurationDefault { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
   public int IdleThinkDelayMin { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
   public int IdleThinkDelayMax { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int ExclaimDurationDefault { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int QuestionDurationDefault { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int UpsetDurationDefault { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int SurpriseDurationDefault { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int BulbDurationDefault { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int HeartDurationDefault { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int SweatDurationDefault { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int AngryDurationDefault { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int MusicDurationDefault { get { int o = __p.__offset(30); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int DotDurationDefault { get { int o = __p.__offset(32); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int MomotalkDurationDefault { get { int o = __p.__offset(34); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int PhoneDurationDefault { get { int o = __p.__offset(36); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int KeywordDurationDefault { get { int o = __p.__offset(38); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public int EvidenceDurationDefault { get { int o = __p.__offset(40); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
 
   public static Offset<SCHALE.Common.FlatData.ConstFieldExcel> CreateConstFieldExcel(FlatBufferBuilder builder,
       int DialogSmoothTime = 0,
       int TalkDialogDurationDefault = 0,
       int ThinkDialogDurationDefault = 0,
       int IdleThinkDelayMin = 0,
-      int IdleThinkDelayMax = 0,
+      int IdleThinkDelayMax = 0) {
-      int ExclaimDurationDefault = 0,
+    builder.StartTable(5);
-      int QuestionDurationDefault = 0,
-      int UpsetDurationDefault = 0,
-      int SurpriseDurationDefault = 0,
-      int BulbDurationDefault = 0,
-      int HeartDurationDefault = 0,
-      int SweatDurationDefault = 0,
-      int AngryDurationDefault = 0,
-      int MusicDurationDefault = 0,
-      int DotDurationDefault = 0,
-      int MomotalkDurationDefault = 0,
-      int PhoneDurationDefault = 0,
-      int KeywordDurationDefault = 0,
-      int EvidenceDurationDefault = 0) {
-    builder.StartTable(19);
-    ConstFieldExcel.AddEvidenceDurationDefault(builder, EvidenceDurationDefault);
-    ConstFieldExcel.AddKeywordDurationDefault(builder, KeywordDurationDefault);
-    ConstFieldExcel.AddPhoneDurationDefault(builder, PhoneDurationDefault);
-    ConstFieldExcel.AddMomotalkDurationDefault(builder, MomotalkDurationDefault);
-    ConstFieldExcel.AddDotDurationDefault(builder, DotDurationDefault);
-    ConstFieldExcel.AddMusicDurationDefault(builder, MusicDurationDefault);
-    ConstFieldExcel.AddAngryDurationDefault(builder, AngryDurationDefault);
-    ConstFieldExcel.AddSweatDurationDefault(builder, SweatDurationDefault);
-    ConstFieldExcel.AddHeartDurationDefault(builder, HeartDurationDefault);
-    ConstFieldExcel.AddBulbDurationDefault(builder, BulbDurationDefault);
-    ConstFieldExcel.AddSurpriseDurationDefault(builder, SurpriseDurationDefault);
-    ConstFieldExcel.AddUpsetDurationDefault(builder, UpsetDurationDefault);
-    ConstFieldExcel.AddQuestionDurationDefault(builder, QuestionDurationDefault);
-    ConstFieldExcel.AddExclaimDurationDefault(builder, ExclaimDurationDefault);
     ConstFieldExcel.AddIdleThinkDelayMax(builder, IdleThinkDelayMax);
     ConstFieldExcel.AddIdleThinkDelayMin(builder, IdleThinkDelayMin);
     ConstFieldExcel.AddThinkDialogDurationDefault(builder, ThinkDialogDurationDefault);
@@ -83,26 +41,12 @@ public struct ConstFieldExcel : IFlatbufferObject
     return ConstFieldExcel.EndConstFieldExcel(builder);
   }
 
-  public static void StartConstFieldExcel(FlatBufferBuilder builder) { builder.StartTable(19); }
+  public static void StartConstFieldExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddDialogSmoothTime(FlatBufferBuilder builder, int dialogSmoothTime) { builder.AddInt(0, dialogSmoothTime, 0); }
   public static void AddTalkDialogDurationDefault(FlatBufferBuilder builder, int talkDialogDurationDefault) { builder.AddInt(1, talkDialogDurationDefault, 0); }
   public static void AddThinkDialogDurationDefault(FlatBufferBuilder builder, int thinkDialogDurationDefault) { builder.AddInt(2, thinkDialogDurationDefault, 0); }
   public static void AddIdleThinkDelayMin(FlatBufferBuilder builder, int idleThinkDelayMin) { builder.AddInt(3, idleThinkDelayMin, 0); }
   public static void AddIdleThinkDelayMax(FlatBufferBuilder builder, int idleThinkDelayMax) { builder.AddInt(4, idleThinkDelayMax, 0); }
-  public static void AddExclaimDurationDefault(FlatBufferBuilder builder, int exclaimDurationDefault) { builder.AddInt(5, exclaimDurationDefault, 0); }
-  public static void AddQuestionDurationDefault(FlatBufferBuilder builder, int questionDurationDefault) { builder.AddInt(6, questionDurationDefault, 0); }
-  public static void AddUpsetDurationDefault(FlatBufferBuilder builder, int upsetDurationDefault) { builder.AddInt(7, upsetDurationDefault, 0); }
-  public static void AddSurpriseDurationDefault(FlatBufferBuilder builder, int surpriseDurationDefault) { builder.AddInt(8, surpriseDurationDefault, 0); }
-  public static void AddBulbDurationDefault(FlatBufferBuilder builder, int bulbDurationDefault) { builder.AddInt(9, bulbDurationDefault, 0); }
-  public static void AddHeartDurationDefault(FlatBufferBuilder builder, int heartDurationDefault) { builder.AddInt(10, heartDurationDefault, 0); }
-  public static void AddSweatDurationDefault(FlatBufferBuilder builder, int sweatDurationDefault) { builder.AddInt(11, sweatDurationDefault, 0); }
-  public static void AddAngryDurationDefault(FlatBufferBuilder builder, int angryDurationDefault) { builder.AddInt(12, angryDurationDefault, 0); }
-  public static void AddMusicDurationDefault(FlatBufferBuilder builder, int musicDurationDefault) { builder.AddInt(13, musicDurationDefault, 0); }
-  public static void AddDotDurationDefault(FlatBufferBuilder builder, int dotDurationDefault) { builder.AddInt(14, dotDurationDefault, 0); }
-  public static void AddMomotalkDurationDefault(FlatBufferBuilder builder, int momotalkDurationDefault) { builder.AddInt(15, momotalkDurationDefault, 0); }
-  public static void AddPhoneDurationDefault(FlatBufferBuilder builder, int phoneDurationDefault) { builder.AddInt(16, phoneDurationDefault, 0); }
-  public static void AddKeywordDurationDefault(FlatBufferBuilder builder, int keywordDurationDefault) { builder.AddInt(17, keywordDurationDefault, 0); }
-  public static void AddEvidenceDurationDefault(FlatBufferBuilder builder, int evidenceDurationDefault) { builder.AddInt(18, evidenceDurationDefault, 0); }
   public static Offset<SCHALE.Common.FlatData.ConstFieldExcel> EndConstFieldExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.ConstFieldExcel>(o);
@@ -119,20 +63,6 @@ public struct ConstFieldExcel : IFlatbufferObject
     _o.ThinkDialogDurationDefault = TableEncryptionService.Convert(this.ThinkDialogDurationDefault, key);
     _o.IdleThinkDelayMin = TableEncryptionService.Convert(this.IdleThinkDelayMin, key);
     _o.IdleThinkDelayMax = TableEncryptionService.Convert(this.IdleThinkDelayMax, key);
-    _o.ExclaimDurationDefault = TableEncryptionService.Convert(this.ExclaimDurationDefault, key);
-    _o.QuestionDurationDefault = TableEncryptionService.Convert(this.QuestionDurationDefault, key);
-    _o.UpsetDurationDefault = TableEncryptionService.Convert(this.UpsetDurationDefault, key);
-    _o.SurpriseDurationDefault = TableEncryptionService.Convert(this.SurpriseDurationDefault, key);
-    _o.BulbDurationDefault = TableEncryptionService.Convert(this.BulbDurationDefault, key);
-    _o.HeartDurationDefault = TableEncryptionService.Convert(this.HeartDurationDefault, key);
-    _o.SweatDurationDefault = TableEncryptionService.Convert(this.SweatDurationDefault, key);
-    _o.AngryDurationDefault = TableEncryptionService.Convert(this.AngryDurationDefault, key);
-    _o.MusicDurationDefault = TableEncryptionService.Convert(this.MusicDurationDefault, key);
-    _o.DotDurationDefault = TableEncryptionService.Convert(this.DotDurationDefault, key);
-    _o.MomotalkDurationDefault = TableEncryptionService.Convert(this.MomotalkDurationDefault, key);
-    _o.PhoneDurationDefault = TableEncryptionService.Convert(this.PhoneDurationDefault, key);
-    _o.KeywordDurationDefault = TableEncryptionService.Convert(this.KeywordDurationDefault, key);
-    _o.EvidenceDurationDefault = TableEncryptionService.Convert(this.EvidenceDurationDefault, key);
   }
   public static Offset<SCHALE.Common.FlatData.ConstFieldExcel> Pack(FlatBufferBuilder builder, ConstFieldExcelT _o) {
     if (_o == null) return default(Offset<SCHALE.Common.FlatData.ConstFieldExcel>);
@@ -142,21 +72,7 @@ public struct ConstFieldExcel : IFlatbufferObject
       _o.TalkDialogDurationDefault,
       _o.ThinkDialogDurationDefault,
       _o.IdleThinkDelayMin,
-      _o.IdleThinkDelayMax,
+      _o.IdleThinkDelayMax);
-      _o.ExclaimDurationDefault,
-      _o.QuestionDurationDefault,
-      _o.UpsetDurationDefault,
-      _o.SurpriseDurationDefault,
-      _o.BulbDurationDefault,
-      _o.HeartDurationDefault,
-      _o.SweatDurationDefault,
-      _o.AngryDurationDefault,
-      _o.MusicDurationDefault,
-      _o.DotDurationDefault,
-      _o.MomotalkDurationDefault,
-      _o.PhoneDurationDefault,
-      _o.KeywordDurationDefault,
-      _o.EvidenceDurationDefault);
   }
 }
 
@@ -167,20 +83,6 @@ public class ConstFieldExcelT
   public int ThinkDialogDurationDefault { get; set; }
   public int IdleThinkDelayMin { get; set; }
   public int IdleThinkDelayMax { get; set; }
-  public int ExclaimDurationDefault { get; set; }
-  public int QuestionDurationDefault { get; set; }
-  public int UpsetDurationDefault { get; set; }
-  public int SurpriseDurationDefault { get; set; }
-  public int BulbDurationDefault { get; set; }
-  public int HeartDurationDefault { get; set; }
-  public int SweatDurationDefault { get; set; }
-  public int AngryDurationDefault { get; set; }
-  public int MusicDurationDefault { get; set; }
-  public int DotDurationDefault { get; set; }
-  public int MomotalkDurationDefault { get; set; }
-  public int PhoneDurationDefault { get; set; }
-  public int KeywordDurationDefault { get; set; }
-  public int EvidenceDurationDefault { get; set; }
 
   public ConstFieldExcelT() {
     this.DialogSmoothTime = 0;
@@ -188,20 +90,6 @@ public class ConstFieldExcelT
     this.ThinkDialogDurationDefault = 0;
     this.IdleThinkDelayMin = 0;
     this.IdleThinkDelayMax = 0;
-    this.ExclaimDurationDefault = 0;
-    this.QuestionDurationDefault = 0;
-    this.UpsetDurationDefault = 0;
-    this.SurpriseDurationDefault = 0;
-    this.BulbDurationDefault = 0;
-    this.HeartDurationDefault = 0;
-    this.SweatDurationDefault = 0;
-    this.AngryDurationDefault = 0;
-    this.MusicDurationDefault = 0;
-    this.DotDurationDefault = 0;
-    this.MomotalkDurationDefault = 0;
-    this.PhoneDurationDefault = 0;
-    this.KeywordDurationDefault = 0;
-    this.EvidenceDurationDefault = 0;
   }
 }
 
@@ -216,20 +104,6 @@ static public class ConstFieldExcelVerify
       && verifier.VerifyField(tablePos, 8 /*ThinkDialogDurationDefault*/, 4 /*int*/, 4, false)
       && verifier.VerifyField(tablePos, 10 /*IdleThinkDelayMin*/, 4 /*int*/, 4, false)
       && verifier.VerifyField(tablePos, 12 /*IdleThinkDelayMax*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 14 /*ExclaimDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 16 /*QuestionDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 18 /*UpsetDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 20 /*SurpriseDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 22 /*BulbDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 24 /*HeartDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 26 /*SweatDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 28 /*AngryDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 30 /*MusicDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 32 /*DotDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 34 /*MomotalkDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 36 /*PhoneDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 38 /*KeywordDurationDefault*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 40 /*EvidenceDurationDefault*/, 4 /*int*/, 4, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/DialogCategory.cs

@@ -78,6 +78,7 @@ public enum DialogCategory : int
   UIMultiFloorRaid = 68,
   UIEventMiniGameDreamMaker = 69,
   UIAttendanceEvent17 = 70,
+  UIAttendanceEvent18 = 71,
 };
 
 

SCHALE.Common/FlatData/Difficulty.cs

@@ -14,6 +14,7 @@ public enum Difficulty : int
   Extreme = 4,
   Insane = 5,
   Torment = 6,
+  Lunatic = 7,
 };
 
 

SCHALE.Common/FlatData/EventContentMeetupInfoExcel.cs

@@ -0,0 +1,102 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
+using global::Google.FlatBuffers;
+
+public struct EventContentMeetupInfoExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static EventContentMeetupInfoExcel GetRootAsEventContentMeetupInfoExcel(ByteBuffer _bb) { return GetRootAsEventContentMeetupInfoExcel(_bb, new EventContentMeetupInfoExcel()); }
+  public static EventContentMeetupInfoExcel GetRootAsEventContentMeetupInfoExcel(ByteBuffer _bb, EventContentMeetupInfoExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public EventContentMeetupInfoExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long EventContentId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.ParcelType CostParcelType { get { int o = __p.__offset(6); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ParcelType.None; } }
+  public long CostId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public int CostAmount { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel> CreateEventContentMeetupInfoExcel(FlatBufferBuilder builder,
+      long EventContentId = 0,
+      SCHALE.Common.FlatData.ParcelType CostParcelType = SCHALE.Common.FlatData.ParcelType.None,
+      long CostId = 0,
+      int CostAmount = 0) {
+    builder.StartTable(4);
+    EventContentMeetupInfoExcel.AddCostId(builder, CostId);
+    EventContentMeetupInfoExcel.AddEventContentId(builder, EventContentId);
+    EventContentMeetupInfoExcel.AddCostAmount(builder, CostAmount);
+    EventContentMeetupInfoExcel.AddCostParcelType(builder, CostParcelType);
+    return EventContentMeetupInfoExcel.EndEventContentMeetupInfoExcel(builder);
+  }
+
+  public static void StartEventContentMeetupInfoExcel(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void AddEventContentId(FlatBufferBuilder builder, long eventContentId) { builder.AddLong(0, eventContentId, 0); }
+  public static void AddCostParcelType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType costParcelType) { builder.AddInt(1, (int)costParcelType, 0); }
+  public static void AddCostId(FlatBufferBuilder builder, long costId) { builder.AddLong(2, costId, 0); }
+  public static void AddCostAmount(FlatBufferBuilder builder, int costAmount) { builder.AddInt(3, costAmount, 0); }
+  public static Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel> EndEventContentMeetupInfoExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel>(o);
+  }
+  public EventContentMeetupInfoExcelT UnPack() {
+    var _o = new EventContentMeetupInfoExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(EventContentMeetupInfoExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("EventContentMeetupInfo");
+    _o.EventContentId = TableEncryptionService.Convert(this.EventContentId, key);
+    _o.CostParcelType = TableEncryptionService.Convert(this.CostParcelType, key);
+    _o.CostId = TableEncryptionService.Convert(this.CostId, key);
+    _o.CostAmount = TableEncryptionService.Convert(this.CostAmount, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel> Pack(FlatBufferBuilder builder, EventContentMeetupInfoExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel>);
+    return CreateEventContentMeetupInfoExcel(
+      builder,
+      _o.EventContentId,
+      _o.CostParcelType,
+      _o.CostId,
+      _o.CostAmount);
+  }
+}
+
+public class EventContentMeetupInfoExcelT
+{
+  public long EventContentId { get; set; }
+  public SCHALE.Common.FlatData.ParcelType CostParcelType { get; set; }
+  public long CostId { get; set; }
+  public int CostAmount { get; set; }
+
+  public EventContentMeetupInfoExcelT() {
+    this.EventContentId = 0;
+    this.CostParcelType = SCHALE.Common.FlatData.ParcelType.None;
+    this.CostId = 0;
+    this.CostAmount = 0;
+  }
+}
+
+
+static public class EventContentMeetupInfoExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*EventContentId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 6 /*CostParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, 4, false)
+      && verifier.VerifyField(tablePos, 8 /*CostId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 10 /*CostAmount*/, 4 /*int*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/EventContentMeetupInfoExcelTable.cs

@@ -0,0 +1,88 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
+using global::Google.FlatBuffers;
+
+public struct EventContentMeetupInfoExcelTable : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static EventContentMeetupInfoExcelTable GetRootAsEventContentMeetupInfoExcelTable(ByteBuffer _bb) { return GetRootAsEventContentMeetupInfoExcelTable(_bb, new EventContentMeetupInfoExcelTable()); }
+  public static EventContentMeetupInfoExcelTable GetRootAsEventContentMeetupInfoExcelTable(ByteBuffer _bb, EventContentMeetupInfoExcelTable obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public EventContentMeetupInfoExcelTable __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public SCHALE.Common.FlatData.EventContentMeetupInfoExcel? DataList(int j) { int o = __p.__offset(4); return o != 0 ? (SCHALE.Common.FlatData.EventContentMeetupInfoExcel?)(new SCHALE.Common.FlatData.EventContentMeetupInfoExcel()).__assign(__p.__indirect(__p.__vector(o) + j * 4), __p.bb) : null; }
+  public int DataListLength { get { int o = __p.__offset(4); return o != 0 ? __p.__vector_len(o) : 0; } }
+
+  public static Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcelTable> CreateEventContentMeetupInfoExcelTable(FlatBufferBuilder builder,
+      VectorOffset DataListOffset = default(VectorOffset)) {
+    builder.StartTable(1);
+    EventContentMeetupInfoExcelTable.AddDataList(builder, DataListOffset);
+    return EventContentMeetupInfoExcelTable.EndEventContentMeetupInfoExcelTable(builder);
+  }
+
+  public static void StartEventContentMeetupInfoExcelTable(FlatBufferBuilder builder) { builder.StartTable(1); }
+  public static void AddDataList(FlatBufferBuilder builder, VectorOffset dataListOffset) { builder.AddOffset(0, dataListOffset.Value, 0); }
+  public static VectorOffset CreateDataListVector(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel>[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel>[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, ArraySegment<Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel>> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateDataListVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel>>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartDataListVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcelTable> EndEventContentMeetupInfoExcelTable(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcelTable>(o);
+  }
+  public EventContentMeetupInfoExcelTableT UnPack() {
+    var _o = new EventContentMeetupInfoExcelTableT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(EventContentMeetupInfoExcelTableT _o) {
+		byte[] key = TableEncryptionService.CreateKey("EventContentMeetupInfoExcel");
+    _o.DataList = new List<SCHALE.Common.FlatData.EventContentMeetupInfoExcelT>();
+    for (var _j = 0; _j < this.DataListLength; ++_j) {_o.DataList.Add(this.DataList(_j).HasValue ? this.DataList(_j).Value.UnPack() : null);}
+  }
+  public static Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcelTable> Pack(FlatBufferBuilder builder, EventContentMeetupInfoExcelTableT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcelTable>);
+    var _DataList = default(VectorOffset);
+    if (_o.DataList != null) {
+      var __DataList = new Offset<SCHALE.Common.FlatData.EventContentMeetupInfoExcel>[_o.DataList.Count];
+      for (var _j = 0; _j < __DataList.Length; ++_j) { __DataList[_j] = SCHALE.Common.FlatData.EventContentMeetupInfoExcel.Pack(builder, _o.DataList[_j]); }
+      _DataList = CreateDataListVector(builder, __DataList);
+    }
+    return CreateEventContentMeetupInfoExcelTable(
+      builder,
+      _DataList);
+  }
+}
+
+public class EventContentMeetupInfoExcelTableT
+{
+  public List<SCHALE.Common.FlatData.EventContentMeetupInfoExcelT> DataList { get; set; }
+
+  public EventContentMeetupInfoExcelTableT() {
+    this.DataList = null;
+  }
+}
+
+
+static public class EventContentMeetupInfoExcelTableVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyVectorOfTables(tablePos, 4 /*DataList*/, SCHALE.Common.FlatData.EventContentMeetupInfoExcelVerify.Verify, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/FlatData/EventContentScenarioExcel.cs

@@ -49,33 +49,30 @@ public struct EventContentScenarioExcel : IFlatbufferObject
 #endif
   public byte[] GetRecollectionResourceArray() { return __p.__vector_as_array<byte>(32); }
   public bool IsRecollectionHorizon { get { int o = __p.__offset(34); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
-  public SCHALE.Common.FlatData.ParcelType CostParcelType { get { int o = __p.__offset(36); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ParcelType.None; } }
+  public SCHALE.Common.FlatData.ParcelType RewardParcelType(int j) { int o = __p.__offset(36); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
-  public long CostId { get { int o = __p.__offset(38); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public int RewardParcelTypeLength { get { int o = __p.__offset(36); return o != 0 ? __p.__vector_len(o) : 0; } }
-  public int CostAmount { get { int o = __p.__offset(40); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public SCHALE.Common.FlatData.ParcelType RewardParcelType(int j) { int o = __p.__offset(42); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
-  public int RewardParcelTypeLength { get { int o = __p.__offset(42); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<SCHALE.Common.FlatData.ParcelType> GetRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(42, 4); }
+  public Span<SCHALE.Common.FlatData.ParcelType> GetRewardParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(36, 4); }
 #else
-  public ArraySegment<byte>? GetRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(42); }
+  public ArraySegment<byte>? GetRewardParcelTypeBytes() { return __p.__vector_as_arraysegment(36); }
 #endif
-  public SCHALE.Common.FlatData.ParcelType[] GetRewardParcelTypeArray() { int o = __p.__offset(42); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public SCHALE.Common.FlatData.ParcelType[] GetRewardParcelTypeArray() { int o = __p.__offset(36); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
-  public long RewardId(int j) { int o = __p.__offset(44); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public long RewardId(int j) { int o = __p.__offset(38); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
-  public int RewardIdLength { get { int o = __p.__offset(44); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int RewardIdLength { get { int o = __p.__offset(38); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<long> GetRewardIdBytes() { return __p.__vector_as_span<long>(44, 8); }
+  public Span<long> GetRewardIdBytes() { return __p.__vector_as_span<long>(38, 8); }
 #else
-  public ArraySegment<byte>? GetRewardIdBytes() { return __p.__vector_as_arraysegment(44); }
+  public ArraySegment<byte>? GetRewardIdBytes() { return __p.__vector_as_arraysegment(38); }
 #endif
-  public long[] GetRewardIdArray() { return __p.__vector_as_array<long>(44); }
+  public long[] GetRewardIdArray() { return __p.__vector_as_array<long>(38); }
-  public int RewardAmount(int j) { int o = __p.__offset(46); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+  public int RewardAmount(int j) { int o = __p.__offset(40); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
-  public int RewardAmountLength { get { int o = __p.__offset(46); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int RewardAmountLength { get { int o = __p.__offset(40); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<int> GetRewardAmountBytes() { return __p.__vector_as_span<int>(46, 4); }
+  public Span<int> GetRewardAmountBytes() { return __p.__vector_as_span<int>(40, 4); }
 #else
-  public ArraySegment<byte>? GetRewardAmountBytes() { return __p.__vector_as_arraysegment(46); }
+  public ArraySegment<byte>? GetRewardAmountBytes() { return __p.__vector_as_arraysegment(40); }
 #endif
-  public int[] GetRewardAmountArray() { return __p.__vector_as_array<int>(46); }
+  public int[] GetRewardAmountArray() { return __p.__vector_as_array<int>(40); }
 
   public static Offset<SCHALE.Common.FlatData.EventContentScenarioExcel> CreateEventContentScenarioExcel(FlatBufferBuilder builder,
       long Id = 0,
@@ -94,14 +91,10 @@ public struct EventContentScenarioExcel : IFlatbufferObject
       uint RecollectionSummaryLocalizeScenarioId = 0,
       StringOffset RecollectionResourceOffset = default(StringOffset),
       bool IsRecollectionHorizon = false,
-      SCHALE.Common.FlatData.ParcelType CostParcelType = SCHALE.Common.FlatData.ParcelType.None,
-      long CostId = 0,
-      int CostAmount = 0,
       VectorOffset RewardParcelTypeOffset = default(VectorOffset),
       VectorOffset RewardIdOffset = default(VectorOffset),
       VectorOffset RewardAmountOffset = default(VectorOffset)) {
-    builder.StartTable(22);
+    builder.StartTable(19);
-    EventContentScenarioExcel.AddCostId(builder, CostId);
     EventContentScenarioExcel.AddClearedScenarioGroupId(builder, ClearedScenarioGroupId);
     EventContentScenarioExcel.AddConditionEventContentId(builder, ConditionEventContentId);
     EventContentScenarioExcel.AddConditionAmount(builder, ConditionAmount);
@@ -112,8 +105,6 @@ public struct EventContentScenarioExcel : IFlatbufferObject
     EventContentScenarioExcel.AddRewardAmount(builder, RewardAmountOffset);
     EventContentScenarioExcel.AddRewardId(builder, RewardIdOffset);
     EventContentScenarioExcel.AddRewardParcelType(builder, RewardParcelTypeOffset);
-    EventContentScenarioExcel.AddCostAmount(builder, CostAmount);
-    EventContentScenarioExcel.AddCostParcelType(builder, CostParcelType);
     EventContentScenarioExcel.AddRecollectionResource(builder, RecollectionResourceOffset);
     EventContentScenarioExcel.AddRecollectionSummaryLocalizeScenarioId(builder, RecollectionSummaryLocalizeScenarioId);
     EventContentScenarioExcel.AddScenarioConditionType(builder, ScenarioConditionType);
@@ -126,7 +117,7 @@ public struct EventContentScenarioExcel : IFlatbufferObject
     return EventContentScenarioExcel.EndEventContentScenarioExcel(builder);
   }
 
-  public static void StartEventContentScenarioExcel(FlatBufferBuilder builder) { builder.StartTable(22); }
+  public static void StartEventContentScenarioExcel(FlatBufferBuilder builder) { builder.StartTable(19); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddEventContentId(FlatBufferBuilder builder, long eventContentId) { builder.AddLong(1, eventContentId, 0); }
   public static void AddReplayDisplayGroup(FlatBufferBuilder builder, int replayDisplayGroup) { builder.AddInt(2, replayDisplayGroup, 0); }
@@ -148,22 +139,19 @@ public struct EventContentScenarioExcel : IFlatbufferObject
   public static void AddRecollectionSummaryLocalizeScenarioId(FlatBufferBuilder builder, uint recollectionSummaryLocalizeScenarioId) { builder.AddUint(13, recollectionSummaryLocalizeScenarioId, 0); }
   public static void AddRecollectionResource(FlatBufferBuilder builder, StringOffset recollectionResourceOffset) { builder.AddOffset(14, recollectionResourceOffset.Value, 0); }
   public static void AddIsRecollectionHorizon(FlatBufferBuilder builder, bool isRecollectionHorizon) { builder.AddBool(15, isRecollectionHorizon, false); }
-  public static void AddCostParcelType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType costParcelType) { builder.AddInt(16, (int)costParcelType, 0); }
+  public static void AddRewardParcelType(FlatBufferBuilder builder, VectorOffset rewardParcelTypeOffset) { builder.AddOffset(16, rewardParcelTypeOffset.Value, 0); }
-  public static void AddCostId(FlatBufferBuilder builder, long costId) { builder.AddLong(17, costId, 0); }
-  public static void AddCostAmount(FlatBufferBuilder builder, int costAmount) { builder.AddInt(18, costAmount, 0); }
-  public static void AddRewardParcelType(FlatBufferBuilder builder, VectorOffset rewardParcelTypeOffset) { builder.AddOffset(19, rewardParcelTypeOffset.Value, 0); }
   public static VectorOffset CreateRewardParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
   public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateRewardParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartRewardParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
-  public static void AddRewardId(FlatBufferBuilder builder, VectorOffset rewardIdOffset) { builder.AddOffset(20, rewardIdOffset.Value, 0); }
+  public static void AddRewardId(FlatBufferBuilder builder, VectorOffset rewardIdOffset) { builder.AddOffset(17, rewardIdOffset.Value, 0); }
   public static VectorOffset CreateRewardIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateRewardIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateRewardIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateRewardIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartRewardIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
-  public static void AddRewardAmount(FlatBufferBuilder builder, VectorOffset rewardAmountOffset) { builder.AddOffset(21, rewardAmountOffset.Value, 0); }
+  public static void AddRewardAmount(FlatBufferBuilder builder, VectorOffset rewardAmountOffset) { builder.AddOffset(18, rewardAmountOffset.Value, 0); }
   public static VectorOffset CreateRewardAmountVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateRewardAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
@@ -197,9 +185,6 @@ public struct EventContentScenarioExcel : IFlatbufferObject
     _o.RecollectionSummaryLocalizeScenarioId = TableEncryptionService.Convert(this.RecollectionSummaryLocalizeScenarioId, key);
     _o.RecollectionResource = TableEncryptionService.Convert(this.RecollectionResource, key);
     _o.IsRecollectionHorizon = TableEncryptionService.Convert(this.IsRecollectionHorizon, key);
-    _o.CostParcelType = TableEncryptionService.Convert(this.CostParcelType, key);
-    _o.CostId = TableEncryptionService.Convert(this.CostId, key);
-    _o.CostAmount = TableEncryptionService.Convert(this.CostAmount, key);
     _o.RewardParcelType = new List<SCHALE.Common.FlatData.ParcelType>();
     for (var _j = 0; _j < this.RewardParcelTypeLength; ++_j) {_o.RewardParcelType.Add(TableEncryptionService.Convert(this.RewardParcelType(_j), key));}
     _o.RewardId = new List<long>();
@@ -248,9 +233,6 @@ public struct EventContentScenarioExcel : IFlatbufferObject
       _o.RecollectionSummaryLocalizeScenarioId,
       _RecollectionResource,
       _o.IsRecollectionHorizon,
-      _o.CostParcelType,
-      _o.CostId,
-      _o.CostAmount,
       _RewardParcelType,
       _RewardId,
       _RewardAmount);
@@ -275,9 +257,6 @@ public class EventContentScenarioExcelT
   public uint RecollectionSummaryLocalizeScenarioId { get; set; }
   public string RecollectionResource { get; set; }
   public bool IsRecollectionHorizon { get; set; }
-  public SCHALE.Common.FlatData.ParcelType CostParcelType { get; set; }
-  public long CostId { get; set; }
-  public int CostAmount { get; set; }
   public List<SCHALE.Common.FlatData.ParcelType> RewardParcelType { get; set; }
   public List<long> RewardId { get; set; }
   public List<int> RewardAmount { get; set; }
@@ -299,9 +278,6 @@ public class EventContentScenarioExcelT
     this.RecollectionSummaryLocalizeScenarioId = 0;
     this.RecollectionResource = null;
     this.IsRecollectionHorizon = false;
-    this.CostParcelType = SCHALE.Common.FlatData.ParcelType.None;
-    this.CostId = 0;
-    this.CostAmount = 0;
     this.RewardParcelType = null;
     this.RewardId = null;
     this.RewardAmount = null;
@@ -330,12 +306,9 @@ static public class EventContentScenarioExcelVerify
       && verifier.VerifyField(tablePos, 30 /*RecollectionSummaryLocalizeScenarioId*/, 4 /*uint*/, 4, false)
       && verifier.VerifyString(tablePos, 32 /*RecollectionResource*/, false)
       && verifier.VerifyField(tablePos, 34 /*IsRecollectionHorizon*/, 1 /*bool*/, 1, false)
-      && verifier.VerifyField(tablePos, 36 /*CostParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 36 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
-      && verifier.VerifyField(tablePos, 38 /*CostId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 38 /*RewardId*/, 8 /*long*/, false)
-      && verifier.VerifyField(tablePos, 40 /*CostAmount*/, 4 /*int*/, 4, false)
+      && verifier.VerifyVectorOfData(tablePos, 40 /*RewardAmount*/, 4 /*int*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 42 /*RewardParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 44 /*RewardId*/, 8 /*long*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 46 /*RewardAmount*/, 4 /*int*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/EventContentType.cs

@@ -44,6 +44,8 @@ public enum EventContentType : int
   SpecialMiniEvent = 34,
   ScenarioCollection = 35,
   ScenarioShortcut = 36,
+  SeasonalEvent = 37,
+  MiniShop = 38,
 };
 
 

SCHALE.Common/FlatData/FieldContentStageExcel.cs

@@ -25,24 +25,42 @@ public struct FieldContentStageExcel : IFlatbufferObject
   public long AreaId { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public long GroupId { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public SCHALE.Common.FlatData.StageDifficulty StageDifficulty { get { int o = __p.__offset(12); return o != 0 ? (SCHALE.Common.FlatData.StageDifficulty)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.StageDifficulty.None; } }
-  public string Name { get { int o = __p.__offset(14); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public long PrevStageId { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string Name { get { int o = __p.__offset(16); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(14, 1); }
+  public Span<byte> GetNameBytes() { return __p.__vector_as_span<byte>(16, 1); }
 #else
-  public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(14); }
+  public ArraySegment<byte>? GetNameBytes() { return __p.__vector_as_arraysegment(16); }
 #endif
-  public byte[] GetNameArray() { return __p.__vector_as_array<byte>(14); }
+  public byte[] GetNameArray() { return __p.__vector_as_array<byte>(16); }
-  public long BattleDuration { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long BattleDuration { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public SCHALE.Common.FlatData.ParcelType StageEnterCostType { get { int o = __p.__offset(18); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ParcelType.None; } }
+  public SCHALE.Common.FlatData.ParcelType StageEnterCostType { get { int o = __p.__offset(20); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ParcelType.None; } }
-  public long StageEnterCostId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long StageEnterCostId { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public int StageEnterCostAmount { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int StageEnterCostAmount { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public SCHALE.Common.FlatData.StageTopography StageTopography { get { int o = __p.__offset(24); return o != 0 ? (SCHALE.Common.FlatData.StageTopography)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.StageTopography.Street; } }
+  public SCHALE.Common.FlatData.StageTopography StageTopography { get { int o = __p.__offset(26); return o != 0 ? (SCHALE.Common.FlatData.StageTopography)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.StageTopography.Street; } }
-  public int RecommandLevel { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public int RecommandLevel { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
-  public long GroundID { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long GroundID { get { int o = __p.__offset(30); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public long BGMId { get { int o = __p.__offset(30); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long BGMId { get { int o = __p.__offset(32); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public bool InstantClear { get { int o = __p.__offset(32); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public bool InstantClear { get { int o = __p.__offset(34); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
-  public long FixedEchelonId { get { int o = __p.__offset(34); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long FixedEchelonId { get { int o = __p.__offset(36); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public bool SkipFormationSettings { get { int o = __p.__offset(36); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public bool SkipFormationSettings { get { int o = __p.__offset(38); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public bool DailyLastPlay { get { int o = __p.__offset(40); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public SCHALE.Common.FlatData.StarGoalType StarGoal(int j) { int o = __p.__offset(42); return o != 0 ? (SCHALE.Common.FlatData.StarGoalType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.StarGoalType)0; }
+  public int StarGoalLength { get { int o = __p.__offset(42); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<SCHALE.Common.FlatData.StarGoalType> GetStarGoalBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.StarGoalType>(42, 4); }
+#else
+  public ArraySegment<byte>? GetStarGoalBytes() { return __p.__vector_as_arraysegment(42); }
+#endif
+  public SCHALE.Common.FlatData.StarGoalType[] GetStarGoalArray() { int o = __p.__offset(42); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.StarGoalType[] a = new SCHALE.Common.FlatData.StarGoalType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.StarGoalType)__p.bb.GetInt(p + i * 4); } return a; }
+  public int StarGoalAmount(int j) { int o = __p.__offset(44); return o != 0 ? __p.bb.GetInt(__p.__vector(o) + j * 4) : (int)0; }
+  public int StarGoalAmountLength { get { int o = __p.__offset(44); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<int> GetStarGoalAmountBytes() { return __p.__vector_as_span<int>(44, 4); }
+#else
+  public ArraySegment<byte>? GetStarGoalAmountBytes() { return __p.__vector_as_arraysegment(44); }
+#endif
+  public int[] GetStarGoalAmountArray() { return __p.__vector_as_array<int>(44); }
 
   public static Offset<SCHALE.Common.FlatData.FieldContentStageExcel> CreateFieldContentStageExcel(FlatBufferBuilder builder,
       long Id = 0,
@@ -50,6 +68,7 @@ public struct FieldContentStageExcel : IFlatbufferObject
       long AreaId = 0,
       long GroupId = 0,
       SCHALE.Common.FlatData.StageDifficulty StageDifficulty = SCHALE.Common.FlatData.StageDifficulty.None,
+      long PrevStageId = 0,
       StringOffset NameOffset = default(StringOffset),
       long BattleDuration = 0,
       SCHALE.Common.FlatData.ParcelType StageEnterCostType = SCHALE.Common.FlatData.ParcelType.None,
@@ -61,46 +80,67 @@ public struct FieldContentStageExcel : IFlatbufferObject
       long BGMId = 0,
       bool InstantClear = false,
       long FixedEchelonId = 0,
-      bool SkipFormationSettings = false) {
+      bool SkipFormationSettings = false,
-    builder.StartTable(17);
+      bool DailyLastPlay = false,
+      VectorOffset StarGoalOffset = default(VectorOffset),
+      VectorOffset StarGoalAmountOffset = default(VectorOffset)) {
+    builder.StartTable(21);
     FieldContentStageExcel.AddFixedEchelonId(builder, FixedEchelonId);
     FieldContentStageExcel.AddBGMId(builder, BGMId);
     FieldContentStageExcel.AddGroundID(builder, GroundID);
     FieldContentStageExcel.AddStageEnterCostId(builder, StageEnterCostId);
     FieldContentStageExcel.AddBattleDuration(builder, BattleDuration);
+    FieldContentStageExcel.AddPrevStageId(builder, PrevStageId);
     FieldContentStageExcel.AddGroupId(builder, GroupId);
     FieldContentStageExcel.AddAreaId(builder, AreaId);
     FieldContentStageExcel.AddSeasonId(builder, SeasonId);
     FieldContentStageExcel.AddId(builder, Id);
+    FieldContentStageExcel.AddStarGoalAmount(builder, StarGoalAmountOffset);
+    FieldContentStageExcel.AddStarGoal(builder, StarGoalOffset);
     FieldContentStageExcel.AddRecommandLevel(builder, RecommandLevel);
     FieldContentStageExcel.AddStageTopography(builder, StageTopography);
     FieldContentStageExcel.AddStageEnterCostAmount(builder, StageEnterCostAmount);
     FieldContentStageExcel.AddStageEnterCostType(builder, StageEnterCostType);
     FieldContentStageExcel.AddName(builder, NameOffset);
     FieldContentStageExcel.AddStageDifficulty(builder, StageDifficulty);
+    FieldContentStageExcel.AddDailyLastPlay(builder, DailyLastPlay);
     FieldContentStageExcel.AddSkipFormationSettings(builder, SkipFormationSettings);
     FieldContentStageExcel.AddInstantClear(builder, InstantClear);
     return FieldContentStageExcel.EndFieldContentStageExcel(builder);
   }
 
-  public static void StartFieldContentStageExcel(FlatBufferBuilder builder) { builder.StartTable(17); }
+  public static void StartFieldContentStageExcel(FlatBufferBuilder builder) { builder.StartTable(21); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddSeasonId(FlatBufferBuilder builder, long seasonId) { builder.AddLong(1, seasonId, 0); }
   public static void AddAreaId(FlatBufferBuilder builder, long areaId) { builder.AddLong(2, areaId, 0); }
   public static void AddGroupId(FlatBufferBuilder builder, long groupId) { builder.AddLong(3, groupId, 0); }
   public static void AddStageDifficulty(FlatBufferBuilder builder, SCHALE.Common.FlatData.StageDifficulty stageDifficulty) { builder.AddInt(4, (int)stageDifficulty, 0); }
-  public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(5, nameOffset.Value, 0); }
+  public static void AddPrevStageId(FlatBufferBuilder builder, long prevStageId) { builder.AddLong(5, prevStageId, 0); }
-  public static void AddBattleDuration(FlatBufferBuilder builder, long battleDuration) { builder.AddLong(6, battleDuration, 0); }
+  public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset) { builder.AddOffset(6, nameOffset.Value, 0); }
-  public static void AddStageEnterCostType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType stageEnterCostType) { builder.AddInt(7, (int)stageEnterCostType, 0); }
+  public static void AddBattleDuration(FlatBufferBuilder builder, long battleDuration) { builder.AddLong(7, battleDuration, 0); }
-  public static void AddStageEnterCostId(FlatBufferBuilder builder, long stageEnterCostId) { builder.AddLong(8, stageEnterCostId, 0); }
+  public static void AddStageEnterCostType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType stageEnterCostType) { builder.AddInt(8, (int)stageEnterCostType, 0); }
-  public static void AddStageEnterCostAmount(FlatBufferBuilder builder, int stageEnterCostAmount) { builder.AddInt(9, stageEnterCostAmount, 0); }
+  public static void AddStageEnterCostId(FlatBufferBuilder builder, long stageEnterCostId) { builder.AddLong(9, stageEnterCostId, 0); }
-  public static void AddStageTopography(FlatBufferBuilder builder, SCHALE.Common.FlatData.StageTopography stageTopography) { builder.AddInt(10, (int)stageTopography, 0); }
+  public static void AddStageEnterCostAmount(FlatBufferBuilder builder, int stageEnterCostAmount) { builder.AddInt(10, stageEnterCostAmount, 0); }
-  public static void AddRecommandLevel(FlatBufferBuilder builder, int recommandLevel) { builder.AddInt(11, recommandLevel, 0); }
+  public static void AddStageTopography(FlatBufferBuilder builder, SCHALE.Common.FlatData.StageTopography stageTopography) { builder.AddInt(11, (int)stageTopography, 0); }
-  public static void AddGroundID(FlatBufferBuilder builder, long groundID) { builder.AddLong(12, groundID, 0); }
+  public static void AddRecommandLevel(FlatBufferBuilder builder, int recommandLevel) { builder.AddInt(12, recommandLevel, 0); }
-  public static void AddBGMId(FlatBufferBuilder builder, long bGMId) { builder.AddLong(13, bGMId, 0); }
+  public static void AddGroundID(FlatBufferBuilder builder, long groundID) { builder.AddLong(13, groundID, 0); }
-  public static void AddInstantClear(FlatBufferBuilder builder, bool instantClear) { builder.AddBool(14, instantClear, false); }
+  public static void AddBGMId(FlatBufferBuilder builder, long bGMId) { builder.AddLong(14, bGMId, 0); }
-  public static void AddFixedEchelonId(FlatBufferBuilder builder, long fixedEchelonId) { builder.AddLong(15, fixedEchelonId, 0); }
+  public static void AddInstantClear(FlatBufferBuilder builder, bool instantClear) { builder.AddBool(15, instantClear, false); }
-  public static void AddSkipFormationSettings(FlatBufferBuilder builder, bool skipFormationSettings) { builder.AddBool(16, skipFormationSettings, false); }
+  public static void AddFixedEchelonId(FlatBufferBuilder builder, long fixedEchelonId) { builder.AddLong(16, fixedEchelonId, 0); }
+  public static void AddSkipFormationSettings(FlatBufferBuilder builder, bool skipFormationSettings) { builder.AddBool(17, skipFormationSettings, false); }
+  public static void AddDailyLastPlay(FlatBufferBuilder builder, bool dailyLastPlay) { builder.AddBool(18, dailyLastPlay, false); }
+  public static void AddStarGoal(FlatBufferBuilder builder, VectorOffset starGoalOffset) { builder.AddOffset(19, starGoalOffset.Value, 0); }
+  public static VectorOffset CreateStarGoalVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.StarGoalType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateStarGoalVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.StarGoalType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStarGoalVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.StarGoalType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStarGoalVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.StarGoalType>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartStarGoalVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
+  public static void AddStarGoalAmount(FlatBufferBuilder builder, VectorOffset starGoalAmountOffset) { builder.AddOffset(20, starGoalAmountOffset.Value, 0); }
+  public static VectorOffset CreateStarGoalAmountVector(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateStarGoalAmountVectorBlock(FlatBufferBuilder builder, int[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStarGoalAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<int> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateStarGoalAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<int>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartStarGoalAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
   public static Offset<SCHALE.Common.FlatData.FieldContentStageExcel> EndFieldContentStageExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.FieldContentStageExcel>(o);
@@ -117,6 +157,7 @@ public struct FieldContentStageExcel : IFlatbufferObject
     _o.AreaId = TableEncryptionService.Convert(this.AreaId, key);
     _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
     _o.StageDifficulty = TableEncryptionService.Convert(this.StageDifficulty, key);
+    _o.PrevStageId = TableEncryptionService.Convert(this.PrevStageId, key);
     _o.Name = TableEncryptionService.Convert(this.Name, key);
     _o.BattleDuration = TableEncryptionService.Convert(this.BattleDuration, key);
     _o.StageEnterCostType = TableEncryptionService.Convert(this.StageEnterCostType, key);
@@ -129,10 +170,25 @@ public struct FieldContentStageExcel : IFlatbufferObject
     _o.InstantClear = TableEncryptionService.Convert(this.InstantClear, key);
     _o.FixedEchelonId = TableEncryptionService.Convert(this.FixedEchelonId, key);
     _o.SkipFormationSettings = TableEncryptionService.Convert(this.SkipFormationSettings, key);
+    _o.DailyLastPlay = TableEncryptionService.Convert(this.DailyLastPlay, key);
+    _o.StarGoal = new List<SCHALE.Common.FlatData.StarGoalType>();
+    for (var _j = 0; _j < this.StarGoalLength; ++_j) {_o.StarGoal.Add(TableEncryptionService.Convert(this.StarGoal(_j), key));}
+    _o.StarGoalAmount = new List<int>();
+    for (var _j = 0; _j < this.StarGoalAmountLength; ++_j) {_o.StarGoalAmount.Add(TableEncryptionService.Convert(this.StarGoalAmount(_j), key));}
   }
   public static Offset<SCHALE.Common.FlatData.FieldContentStageExcel> Pack(FlatBufferBuilder builder, FieldContentStageExcelT _o) {
     if (_o == null) return default(Offset<SCHALE.Common.FlatData.FieldContentStageExcel>);
     var _Name = _o.Name == null ? default(StringOffset) : builder.CreateString(_o.Name);
+    var _StarGoal = default(VectorOffset);
+    if (_o.StarGoal != null) {
+      var __StarGoal = _o.StarGoal.ToArray();
+      _StarGoal = CreateStarGoalVector(builder, __StarGoal);
+    }
+    var _StarGoalAmount = default(VectorOffset);
+    if (_o.StarGoalAmount != null) {
+      var __StarGoalAmount = _o.StarGoalAmount.ToArray();
+      _StarGoalAmount = CreateStarGoalAmountVector(builder, __StarGoalAmount);
+    }
     return CreateFieldContentStageExcel(
       builder,
       _o.Id,
@@ -140,6 +196,7 @@ public struct FieldContentStageExcel : IFlatbufferObject
       _o.AreaId,
       _o.GroupId,
       _o.StageDifficulty,
+      _o.PrevStageId,
       _Name,
       _o.BattleDuration,
       _o.StageEnterCostType,
@@ -151,7 +208,10 @@ public struct FieldContentStageExcel : IFlatbufferObject
       _o.BGMId,
       _o.InstantClear,
       _o.FixedEchelonId,
-      _o.SkipFormationSettings);
+      _o.SkipFormationSettings,
+      _o.DailyLastPlay,
+      _StarGoal,
+      _StarGoalAmount);
   }
 }
 
@@ -162,6 +222,7 @@ public class FieldContentStageExcelT
   public long AreaId { get; set; }
   public long GroupId { get; set; }
   public SCHALE.Common.FlatData.StageDifficulty StageDifficulty { get; set; }
+  public long PrevStageId { get; set; }
   public string Name { get; set; }
   public long BattleDuration { get; set; }
   public SCHALE.Common.FlatData.ParcelType StageEnterCostType { get; set; }
@@ -174,6 +235,9 @@ public class FieldContentStageExcelT
   public bool InstantClear { get; set; }
   public long FixedEchelonId { get; set; }
   public bool SkipFormationSettings { get; set; }
+  public bool DailyLastPlay { get; set; }
+  public List<SCHALE.Common.FlatData.StarGoalType> StarGoal { get; set; }
+  public List<int> StarGoalAmount { get; set; }
 
   public FieldContentStageExcelT() {
     this.Id = 0;
@@ -181,6 +245,7 @@ public class FieldContentStageExcelT
     this.AreaId = 0;
     this.GroupId = 0;
     this.StageDifficulty = SCHALE.Common.FlatData.StageDifficulty.None;
+    this.PrevStageId = 0;
     this.Name = null;
     this.BattleDuration = 0;
     this.StageEnterCostType = SCHALE.Common.FlatData.ParcelType.None;
@@ -193,6 +258,9 @@ public class FieldContentStageExcelT
     this.InstantClear = false;
     this.FixedEchelonId = 0;
     this.SkipFormationSettings = false;
+    this.DailyLastPlay = false;
+    this.StarGoal = null;
+    this.StarGoalAmount = null;
   }
 }
 
@@ -207,18 +275,22 @@ static public class FieldContentStageExcelVerify
       && verifier.VerifyField(tablePos, 8 /*AreaId*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 10 /*GroupId*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 12 /*StageDifficulty*/, 4 /*SCHALE.Common.FlatData.StageDifficulty*/, 4, false)
-      && verifier.VerifyString(tablePos, 14 /*Name*/, false)
+      && verifier.VerifyField(tablePos, 14 /*PrevStageId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 16 /*BattleDuration*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 16 /*Name*/, false)
-      && verifier.VerifyField(tablePos, 18 /*StageEnterCostType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*BattleDuration*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 20 /*StageEnterCostId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 20 /*StageEnterCostType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, 4, false)
-      && verifier.VerifyField(tablePos, 22 /*StageEnterCostAmount*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*StageEnterCostId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 24 /*StageTopography*/, 4 /*SCHALE.Common.FlatData.StageTopography*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*StageEnterCostAmount*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 26 /*RecommandLevel*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 26 /*StageTopography*/, 4 /*SCHALE.Common.FlatData.StageTopography*/, 4, false)
-      && verifier.VerifyField(tablePos, 28 /*GroundID*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 28 /*RecommandLevel*/, 4 /*int*/, 4, false)
-      && verifier.VerifyField(tablePos, 30 /*BGMId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 30 /*GroundID*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 32 /*InstantClear*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 32 /*BGMId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 34 /*FixedEchelonId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 34 /*InstantClear*/, 1 /*bool*/, 1, false)
-      && verifier.VerifyField(tablePos, 36 /*SkipFormationSettings*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 36 /*FixedEchelonId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 38 /*SkipFormationSettings*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 40 /*DailyLastPlay*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyVectorOfData(tablePos, 42 /*StarGoal*/, 4 /*SCHALE.Common.FlatData.StarGoalType*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 44 /*StarGoalAmount*/, 4 /*int*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/FieldDateExcel.cs

@@ -35,15 +35,31 @@ public struct FieldDateExcel : IFlatbufferObject
   public long StartConditionId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public SCHALE.Common.FlatData.FieldConditionType EndConditionType { get { int o = __p.__offset(18); return o != 0 ? (SCHALE.Common.FlatData.FieldConditionType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.FieldConditionType.Invalid; } }
   public long EndConditionId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public long OpenConditionStage { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.FieldConditionType EndReadyConditionType { get { int o = __p.__offset(22); return o != 0 ? (SCHALE.Common.FlatData.FieldConditionType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.FieldConditionType.Invalid; } }
-  public string DateResultSpinePath { get { int o = __p.__offset(24); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public long EndReadyConditionId { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long OpenConditionStage { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string CharacterIconPath { get { int o = __p.__offset(28); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetDateResultSpinePathBytes() { return __p.__vector_as_span<byte>(24, 1); }
+  public Span<byte> GetCharacterIconPathBytes() { return __p.__vector_as_span<byte>(28, 1); }
 #else
-  public ArraySegment<byte>? GetDateResultSpinePathBytes() { return __p.__vector_as_arraysegment(24); }
+  public ArraySegment<byte>? GetCharacterIconPathBytes() { return __p.__vector_as_arraysegment(28); }
 #endif
-  public byte[] GetDateResultSpinePathArray() { return __p.__vector_as_array<byte>(24); }
+  public byte[] GetCharacterIconPathArray() { return __p.__vector_as_array<byte>(28); }
-  public float DateResultSpineOffsetX { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
+  public string DateResultBGPath { get { int o = __p.__offset(30); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetDateResultBGPathBytes() { return __p.__vector_as_span<byte>(30, 1); }
+#else
+  public ArraySegment<byte>? GetDateResultBGPathBytes() { return __p.__vector_as_arraysegment(30); }
+#endif
+  public byte[] GetDateResultBGPathArray() { return __p.__vector_as_array<byte>(30); }
+  public string DateResultSpinePath { get { int o = __p.__offset(32); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetDateResultSpinePathBytes() { return __p.__vector_as_span<byte>(32, 1); }
+#else
+  public ArraySegment<byte>? GetDateResultSpinePathBytes() { return __p.__vector_as_arraysegment(32); }
+#endif
+  public byte[] GetDateResultSpinePathArray() { return __p.__vector_as_array<byte>(32); }
+  public float DateResultSpineOffsetX { get { int o = __p.__offset(34); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
 
   public static Offset<SCHALE.Common.FlatData.FieldDateExcel> CreateFieldDateExcel(FlatBufferBuilder builder,
       long SeasonId = 0,
@@ -55,11 +71,16 @@ public struct FieldDateExcel : IFlatbufferObject
       long StartConditionId = 0,
       SCHALE.Common.FlatData.FieldConditionType EndConditionType = SCHALE.Common.FlatData.FieldConditionType.Invalid,
       long EndConditionId = 0,
+      SCHALE.Common.FlatData.FieldConditionType EndReadyConditionType = SCHALE.Common.FlatData.FieldConditionType.Invalid,
+      long EndReadyConditionId = 0,
       long OpenConditionStage = 0,
+      StringOffset CharacterIconPathOffset = default(StringOffset),
+      StringOffset DateResultBGPathOffset = default(StringOffset),
       StringOffset DateResultSpinePathOffset = default(StringOffset),
       float DateResultSpineOffsetX = 0.0f) {
-    builder.StartTable(12);
+    builder.StartTable(16);
     FieldDateExcel.AddOpenConditionStage(builder, OpenConditionStage);
+    FieldDateExcel.AddEndReadyConditionId(builder, EndReadyConditionId);
     FieldDateExcel.AddEndConditionId(builder, EndConditionId);
     FieldDateExcel.AddStartConditionId(builder, StartConditionId);
     FieldDateExcel.AddEntrySceneId(builder, EntrySceneId);
@@ -68,13 +89,16 @@ public struct FieldDateExcel : IFlatbufferObject
     FieldDateExcel.AddSeasonId(builder, SeasonId);
     FieldDateExcel.AddDateResultSpineOffsetX(builder, DateResultSpineOffsetX);
     FieldDateExcel.AddDateResultSpinePath(builder, DateResultSpinePathOffset);
+    FieldDateExcel.AddDateResultBGPath(builder, DateResultBGPathOffset);
+    FieldDateExcel.AddCharacterIconPath(builder, CharacterIconPathOffset);
+    FieldDateExcel.AddEndReadyConditionType(builder, EndReadyConditionType);
     FieldDateExcel.AddEndConditionType(builder, EndConditionType);
     FieldDateExcel.AddStartConditionType(builder, StartConditionType);
     FieldDateExcel.AddDateLocalizeKey(builder, DateLocalizeKeyOffset);
     return FieldDateExcel.EndFieldDateExcel(builder);
   }
 
-  public static void StartFieldDateExcel(FlatBufferBuilder builder) { builder.StartTable(12); }
+  public static void StartFieldDateExcel(FlatBufferBuilder builder) { builder.StartTable(16); }
   public static void AddSeasonId(FlatBufferBuilder builder, long seasonId) { builder.AddLong(0, seasonId, 0); }
   public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(1, uniqueId, 0); }
   public static void AddOpenDate(FlatBufferBuilder builder, long openDate) { builder.AddLong(2, openDate, 0); }
@@ -84,9 +108,13 @@ public struct FieldDateExcel : IFlatbufferObject
   public static void AddStartConditionId(FlatBufferBuilder builder, long startConditionId) { builder.AddLong(6, startConditionId, 0); }
   public static void AddEndConditionType(FlatBufferBuilder builder, SCHALE.Common.FlatData.FieldConditionType endConditionType) { builder.AddInt(7, (int)endConditionType, 0); }
   public static void AddEndConditionId(FlatBufferBuilder builder, long endConditionId) { builder.AddLong(8, endConditionId, 0); }
-  public static void AddOpenConditionStage(FlatBufferBuilder builder, long openConditionStage) { builder.AddLong(9, openConditionStage, 0); }
+  public static void AddEndReadyConditionType(FlatBufferBuilder builder, SCHALE.Common.FlatData.FieldConditionType endReadyConditionType) { builder.AddInt(9, (int)endReadyConditionType, 0); }
-  public static void AddDateResultSpinePath(FlatBufferBuilder builder, StringOffset dateResultSpinePathOffset) { builder.AddOffset(10, dateResultSpinePathOffset.Value, 0); }
+  public static void AddEndReadyConditionId(FlatBufferBuilder builder, long endReadyConditionId) { builder.AddLong(10, endReadyConditionId, 0); }
-  public static void AddDateResultSpineOffsetX(FlatBufferBuilder builder, float dateResultSpineOffsetX) { builder.AddFloat(11, dateResultSpineOffsetX, 0.0f); }
+  public static void AddOpenConditionStage(FlatBufferBuilder builder, long openConditionStage) { builder.AddLong(11, openConditionStage, 0); }
+  public static void AddCharacterIconPath(FlatBufferBuilder builder, StringOffset characterIconPathOffset) { builder.AddOffset(12, characterIconPathOffset.Value, 0); }
+  public static void AddDateResultBGPath(FlatBufferBuilder builder, StringOffset dateResultBGPathOffset) { builder.AddOffset(13, dateResultBGPathOffset.Value, 0); }
+  public static void AddDateResultSpinePath(FlatBufferBuilder builder, StringOffset dateResultSpinePathOffset) { builder.AddOffset(14, dateResultSpinePathOffset.Value, 0); }
+  public static void AddDateResultSpineOffsetX(FlatBufferBuilder builder, float dateResultSpineOffsetX) { builder.AddFloat(15, dateResultSpineOffsetX, 0.0f); }
   public static Offset<SCHALE.Common.FlatData.FieldDateExcel> EndFieldDateExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.FieldDateExcel>(o);
@@ -107,13 +135,19 @@ public struct FieldDateExcel : IFlatbufferObject
     _o.StartConditionId = TableEncryptionService.Convert(this.StartConditionId, key);
     _o.EndConditionType = TableEncryptionService.Convert(this.EndConditionType, key);
     _o.EndConditionId = TableEncryptionService.Convert(this.EndConditionId, key);
+    _o.EndReadyConditionType = TableEncryptionService.Convert(this.EndReadyConditionType, key);
+    _o.EndReadyConditionId = TableEncryptionService.Convert(this.EndReadyConditionId, key);
     _o.OpenConditionStage = TableEncryptionService.Convert(this.OpenConditionStage, key);
+    _o.CharacterIconPath = TableEncryptionService.Convert(this.CharacterIconPath, key);
+    _o.DateResultBGPath = TableEncryptionService.Convert(this.DateResultBGPath, key);
     _o.DateResultSpinePath = TableEncryptionService.Convert(this.DateResultSpinePath, key);
     _o.DateResultSpineOffsetX = TableEncryptionService.Convert(this.DateResultSpineOffsetX, key);
   }
   public static Offset<SCHALE.Common.FlatData.FieldDateExcel> Pack(FlatBufferBuilder builder, FieldDateExcelT _o) {
     if (_o == null) return default(Offset<SCHALE.Common.FlatData.FieldDateExcel>);
     var _DateLocalizeKey = _o.DateLocalizeKey == null ? default(StringOffset) : builder.CreateString(_o.DateLocalizeKey);
+    var _CharacterIconPath = _o.CharacterIconPath == null ? default(StringOffset) : builder.CreateString(_o.CharacterIconPath);
+    var _DateResultBGPath = _o.DateResultBGPath == null ? default(StringOffset) : builder.CreateString(_o.DateResultBGPath);
     var _DateResultSpinePath = _o.DateResultSpinePath == null ? default(StringOffset) : builder.CreateString(_o.DateResultSpinePath);
     return CreateFieldDateExcel(
       builder,
@@ -126,7 +160,11 @@ public struct FieldDateExcel : IFlatbufferObject
       _o.StartConditionId,
       _o.EndConditionType,
       _o.EndConditionId,
+      _o.EndReadyConditionType,
+      _o.EndReadyConditionId,
       _o.OpenConditionStage,
+      _CharacterIconPath,
+      _DateResultBGPath,
       _DateResultSpinePath,
       _o.DateResultSpineOffsetX);
   }
@@ -143,7 +181,11 @@ public class FieldDateExcelT
   public long StartConditionId { get; set; }
   public SCHALE.Common.FlatData.FieldConditionType EndConditionType { get; set; }
   public long EndConditionId { get; set; }
+  public SCHALE.Common.FlatData.FieldConditionType EndReadyConditionType { get; set; }
+  public long EndReadyConditionId { get; set; }
   public long OpenConditionStage { get; set; }
+  public string CharacterIconPath { get; set; }
+  public string DateResultBGPath { get; set; }
   public string DateResultSpinePath { get; set; }
   public float DateResultSpineOffsetX { get; set; }
 
@@ -157,7 +199,11 @@ public class FieldDateExcelT
     this.StartConditionId = 0;
     this.EndConditionType = SCHALE.Common.FlatData.FieldConditionType.Invalid;
     this.EndConditionId = 0;
+    this.EndReadyConditionType = SCHALE.Common.FlatData.FieldConditionType.Invalid;
+    this.EndReadyConditionId = 0;
     this.OpenConditionStage = 0;
+    this.CharacterIconPath = null;
+    this.DateResultBGPath = null;
     this.DateResultSpinePath = null;
     this.DateResultSpineOffsetX = 0.0f;
   }
@@ -178,9 +224,13 @@ static public class FieldDateExcelVerify
       && verifier.VerifyField(tablePos, 16 /*StartConditionId*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 18 /*EndConditionType*/, 4 /*SCHALE.Common.FlatData.FieldConditionType*/, 4, false)
       && verifier.VerifyField(tablePos, 20 /*EndConditionId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 22 /*OpenConditionStage*/, 8 /*long*/, 8, false)
+      && verifier.VerifyField(tablePos, 22 /*EndReadyConditionType*/, 4 /*SCHALE.Common.FlatData.FieldConditionType*/, 4, false)
-      && verifier.VerifyString(tablePos, 24 /*DateResultSpinePath*/, false)
+      && verifier.VerifyField(tablePos, 24 /*EndReadyConditionId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 26 /*DateResultSpineOffsetX*/, 4 /*float*/, 4, false)
+      && verifier.VerifyField(tablePos, 26 /*OpenConditionStage*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 28 /*CharacterIconPath*/, false)
+      && verifier.VerifyString(tablePos, 30 /*DateResultBGPath*/, false)
+      && verifier.VerifyString(tablePos, 32 /*DateResultSpinePath*/, false)
+      && verifier.VerifyField(tablePos, 34 /*DateResultSpineOffsetX*/, 4 /*float*/, 4, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/FieldDialogType.cs

@@ -24,6 +24,8 @@ public enum FieldDialogType : int
   Phone = 14,
   Keyword = 15,
   Evidence = 16,
+  Chat = 17,
+  Keyword_843 = 18,
 };
 
 

SCHALE.Common/FlatData/FieldEvidenceExcel.cs

@@ -21,42 +21,45 @@ public struct FieldEvidenceExcel : IFlatbufferObject
   public FieldEvidenceExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public string NameLocalizeKey { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public long SeasonId { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string NameLocalizeKey { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetNameLocalizeKeyBytes() { return __p.__vector_as_span<byte>(6, 1); }
+  public Span<byte> GetNameLocalizeKeyBytes() { return __p.__vector_as_span<byte>(8, 1); }
 #else
-  public ArraySegment<byte>? GetNameLocalizeKeyBytes() { return __p.__vector_as_arraysegment(6); }
+  public ArraySegment<byte>? GetNameLocalizeKeyBytes() { return __p.__vector_as_arraysegment(8); }
 #endif
-  public byte[] GetNameLocalizeKeyArray() { return __p.__vector_as_array<byte>(6); }
+  public byte[] GetNameLocalizeKeyArray() { return __p.__vector_as_array<byte>(8); }
-  public string DescriptionLocalizeKey { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public string DescriptionLocalizeKey { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_span<byte>(8, 1); }
+  public Span<byte> GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_span<byte>(10, 1); }
 #else
-  public ArraySegment<byte>? GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_arraysegment(8); }
+  public ArraySegment<byte>? GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_arraysegment(10); }
 #endif
-  public byte[] GetDescriptionLocalizeKeyArray() { return __p.__vector_as_array<byte>(8); }
+  public byte[] GetDescriptionLocalizeKeyArray() { return __p.__vector_as_array<byte>(10); }
-  public string DetailLocalizeKey { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public string DetailLocalizeKey { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetDetailLocalizeKeyBytes() { return __p.__vector_as_span<byte>(10, 1); }
+  public Span<byte> GetDetailLocalizeKeyBytes() { return __p.__vector_as_span<byte>(12, 1); }
 #else
-  public ArraySegment<byte>? GetDetailLocalizeKeyBytes() { return __p.__vector_as_arraysegment(10); }
+  public ArraySegment<byte>? GetDetailLocalizeKeyBytes() { return __p.__vector_as_arraysegment(12); }
 #endif
-  public byte[] GetDetailLocalizeKeyArray() { return __p.__vector_as_array<byte>(10); }
+  public byte[] GetDetailLocalizeKeyArray() { return __p.__vector_as_array<byte>(12); }
-  public string ImagePath { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public string ImagePath { get { int o = __p.__offset(14); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(12, 1); }
+  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(14, 1); }
 #else
-  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(12); }
+  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(14); }
 #endif
-  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(12); }
+  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(14); }
 
   public static Offset<SCHALE.Common.FlatData.FieldEvidenceExcel> CreateFieldEvidenceExcel(FlatBufferBuilder builder,
       long UniqueId = 0,
+      long SeasonId = 0,
       StringOffset NameLocalizeKeyOffset = default(StringOffset),
       StringOffset DescriptionLocalizeKeyOffset = default(StringOffset),
       StringOffset DetailLocalizeKeyOffset = default(StringOffset),
       StringOffset ImagePathOffset = default(StringOffset)) {
-    builder.StartTable(5);
+    builder.StartTable(6);
+    FieldEvidenceExcel.AddSeasonId(builder, SeasonId);
     FieldEvidenceExcel.AddUniqueId(builder, UniqueId);
     FieldEvidenceExcel.AddImagePath(builder, ImagePathOffset);
     FieldEvidenceExcel.AddDetailLocalizeKey(builder, DetailLocalizeKeyOffset);
@@ -65,12 +68,13 @@ public struct FieldEvidenceExcel : IFlatbufferObject
     return FieldEvidenceExcel.EndFieldEvidenceExcel(builder);
   }
 
-  public static void StartFieldEvidenceExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
+  public static void StartFieldEvidenceExcel(FlatBufferBuilder builder) { builder.StartTable(6); }
   public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
-  public static void AddNameLocalizeKey(FlatBufferBuilder builder, StringOffset nameLocalizeKeyOffset) { builder.AddOffset(1, nameLocalizeKeyOffset.Value, 0); }
+  public static void AddSeasonId(FlatBufferBuilder builder, long seasonId) { builder.AddLong(1, seasonId, 0); }
-  public static void AddDescriptionLocalizeKey(FlatBufferBuilder builder, StringOffset descriptionLocalizeKeyOffset) { builder.AddOffset(2, descriptionLocalizeKeyOffset.Value, 0); }
+  public static void AddNameLocalizeKey(FlatBufferBuilder builder, StringOffset nameLocalizeKeyOffset) { builder.AddOffset(2, nameLocalizeKeyOffset.Value, 0); }
-  public static void AddDetailLocalizeKey(FlatBufferBuilder builder, StringOffset detailLocalizeKeyOffset) { builder.AddOffset(3, detailLocalizeKeyOffset.Value, 0); }
+  public static void AddDescriptionLocalizeKey(FlatBufferBuilder builder, StringOffset descriptionLocalizeKeyOffset) { builder.AddOffset(3, descriptionLocalizeKeyOffset.Value, 0); }
-  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(4, imagePathOffset.Value, 0); }
+  public static void AddDetailLocalizeKey(FlatBufferBuilder builder, StringOffset detailLocalizeKeyOffset) { builder.AddOffset(4, detailLocalizeKeyOffset.Value, 0); }
+  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(5, imagePathOffset.Value, 0); }
   public static Offset<SCHALE.Common.FlatData.FieldEvidenceExcel> EndFieldEvidenceExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.FieldEvidenceExcel>(o);
@@ -83,6 +87,7 @@ public struct FieldEvidenceExcel : IFlatbufferObject
   public void UnPackTo(FieldEvidenceExcelT _o) {
 		byte[] key = TableEncryptionService.CreateKey("FieldEvidence");
     _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.SeasonId = TableEncryptionService.Convert(this.SeasonId, key);
     _o.NameLocalizeKey = TableEncryptionService.Convert(this.NameLocalizeKey, key);
     _o.DescriptionLocalizeKey = TableEncryptionService.Convert(this.DescriptionLocalizeKey, key);
     _o.DetailLocalizeKey = TableEncryptionService.Convert(this.DetailLocalizeKey, key);
@@ -97,6 +102,7 @@ public struct FieldEvidenceExcel : IFlatbufferObject
     return CreateFieldEvidenceExcel(
       builder,
       _o.UniqueId,
+      _o.SeasonId,
       _NameLocalizeKey,
       _DescriptionLocalizeKey,
       _DetailLocalizeKey,
@@ -107,6 +113,7 @@ public struct FieldEvidenceExcel : IFlatbufferObject
 public class FieldEvidenceExcelT
 {
   public long UniqueId { get; set; }
+  public long SeasonId { get; set; }
   public string NameLocalizeKey { get; set; }
   public string DescriptionLocalizeKey { get; set; }
   public string DetailLocalizeKey { get; set; }
@@ -114,6 +121,7 @@ public class FieldEvidenceExcelT
 
   public FieldEvidenceExcelT() {
     this.UniqueId = 0;
+    this.SeasonId = 0;
     this.NameLocalizeKey = null;
     this.DescriptionLocalizeKey = null;
     this.DetailLocalizeKey = null;
@@ -128,10 +136,11 @@ static public class FieldEvidenceExcelVerify
   {
     return verifier.VerifyTableStart(tablePos)
       && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyString(tablePos, 6 /*NameLocalizeKey*/, false)
+      && verifier.VerifyField(tablePos, 6 /*SeasonId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyString(tablePos, 8 /*DescriptionLocalizeKey*/, false)
+      && verifier.VerifyString(tablePos, 8 /*NameLocalizeKey*/, false)
-      && verifier.VerifyString(tablePos, 10 /*DetailLocalizeKey*/, false)
+      && verifier.VerifyString(tablePos, 10 /*DescriptionLocalizeKey*/, false)
-      && verifier.VerifyString(tablePos, 12 /*ImagePath*/, false)
+      && verifier.VerifyString(tablePos, 12 /*DetailLocalizeKey*/, false)
+      && verifier.VerifyString(tablePos, 14 /*ImagePath*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/FieldInteractionType.cs

@@ -18,6 +18,7 @@ public enum FieldInteractionType : int
   Timeline = 8,
   ActionTrigger = 9,
   Interplay = 10,
+  UnderCoverStage = 11,
 };
 
 

SCHALE.Common/FlatData/FieldKeywordExcel.cs

@@ -21,34 +21,37 @@ public struct FieldKeywordExcel : IFlatbufferObject
   public FieldKeywordExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public long UniqueId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public string NameLocalizeKey { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public long SeasonId { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string NameLocalizeKey { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetNameLocalizeKeyBytes() { return __p.__vector_as_span<byte>(6, 1); }
+  public Span<byte> GetNameLocalizeKeyBytes() { return __p.__vector_as_span<byte>(8, 1); }
 #else
-  public ArraySegment<byte>? GetNameLocalizeKeyBytes() { return __p.__vector_as_arraysegment(6); }
+  public ArraySegment<byte>? GetNameLocalizeKeyBytes() { return __p.__vector_as_arraysegment(8); }
 #endif
-  public byte[] GetNameLocalizeKeyArray() { return __p.__vector_as_array<byte>(6); }
+  public byte[] GetNameLocalizeKeyArray() { return __p.__vector_as_array<byte>(8); }
-  public string DescriptionLocalizeKey { get { int o = __p.__offset(8); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public string DescriptionLocalizeKey { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_span<byte>(8, 1); }
+  public Span<byte> GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_span<byte>(10, 1); }
 #else
-  public ArraySegment<byte>? GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_arraysegment(8); }
+  public ArraySegment<byte>? GetDescriptionLocalizeKeyBytes() { return __p.__vector_as_arraysegment(10); }
 #endif
-  public byte[] GetDescriptionLocalizeKeyArray() { return __p.__vector_as_array<byte>(8); }
+  public byte[] GetDescriptionLocalizeKeyArray() { return __p.__vector_as_array<byte>(10); }
-  public string ImagePath { get { int o = __p.__offset(10); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public string ImagePath { get { int o = __p.__offset(12); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(10, 1); }
+  public Span<byte> GetImagePathBytes() { return __p.__vector_as_span<byte>(12, 1); }
 #else
-  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(10); }
+  public ArraySegment<byte>? GetImagePathBytes() { return __p.__vector_as_arraysegment(12); }
 #endif
-  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(10); }
+  public byte[] GetImagePathArray() { return __p.__vector_as_array<byte>(12); }
 
   public static Offset<SCHALE.Common.FlatData.FieldKeywordExcel> CreateFieldKeywordExcel(FlatBufferBuilder builder,
       long UniqueId = 0,
+      long SeasonId = 0,
       StringOffset NameLocalizeKeyOffset = default(StringOffset),
       StringOffset DescriptionLocalizeKeyOffset = default(StringOffset),
       StringOffset ImagePathOffset = default(StringOffset)) {
-    builder.StartTable(4);
+    builder.StartTable(5);
+    FieldKeywordExcel.AddSeasonId(builder, SeasonId);
     FieldKeywordExcel.AddUniqueId(builder, UniqueId);
     FieldKeywordExcel.AddImagePath(builder, ImagePathOffset);
     FieldKeywordExcel.AddDescriptionLocalizeKey(builder, DescriptionLocalizeKeyOffset);
@@ -56,11 +59,12 @@ public struct FieldKeywordExcel : IFlatbufferObject
     return FieldKeywordExcel.EndFieldKeywordExcel(builder);
   }
 
-  public static void StartFieldKeywordExcel(FlatBufferBuilder builder) { builder.StartTable(4); }
+  public static void StartFieldKeywordExcel(FlatBufferBuilder builder) { builder.StartTable(5); }
   public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
-  public static void AddNameLocalizeKey(FlatBufferBuilder builder, StringOffset nameLocalizeKeyOffset) { builder.AddOffset(1, nameLocalizeKeyOffset.Value, 0); }
+  public static void AddSeasonId(FlatBufferBuilder builder, long seasonId) { builder.AddLong(1, seasonId, 0); }
-  public static void AddDescriptionLocalizeKey(FlatBufferBuilder builder, StringOffset descriptionLocalizeKeyOffset) { builder.AddOffset(2, descriptionLocalizeKeyOffset.Value, 0); }
+  public static void AddNameLocalizeKey(FlatBufferBuilder builder, StringOffset nameLocalizeKeyOffset) { builder.AddOffset(2, nameLocalizeKeyOffset.Value, 0); }
-  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(3, imagePathOffset.Value, 0); }
+  public static void AddDescriptionLocalizeKey(FlatBufferBuilder builder, StringOffset descriptionLocalizeKeyOffset) { builder.AddOffset(3, descriptionLocalizeKeyOffset.Value, 0); }
+  public static void AddImagePath(FlatBufferBuilder builder, StringOffset imagePathOffset) { builder.AddOffset(4, imagePathOffset.Value, 0); }
   public static Offset<SCHALE.Common.FlatData.FieldKeywordExcel> EndFieldKeywordExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.FieldKeywordExcel>(o);
@@ -73,6 +77,7 @@ public struct FieldKeywordExcel : IFlatbufferObject
   public void UnPackTo(FieldKeywordExcelT _o) {
 		byte[] key = TableEncryptionService.CreateKey("FieldKeyword");
     _o.UniqueId = TableEncryptionService.Convert(this.UniqueId, key);
+    _o.SeasonId = TableEncryptionService.Convert(this.SeasonId, key);
     _o.NameLocalizeKey = TableEncryptionService.Convert(this.NameLocalizeKey, key);
     _o.DescriptionLocalizeKey = TableEncryptionService.Convert(this.DescriptionLocalizeKey, key);
     _o.ImagePath = TableEncryptionService.Convert(this.ImagePath, key);
@@ -85,6 +90,7 @@ public struct FieldKeywordExcel : IFlatbufferObject
     return CreateFieldKeywordExcel(
       builder,
       _o.UniqueId,
+      _o.SeasonId,
       _NameLocalizeKey,
       _DescriptionLocalizeKey,
       _ImagePath);
@@ -94,12 +100,14 @@ public struct FieldKeywordExcel : IFlatbufferObject
 public class FieldKeywordExcelT
 {
   public long UniqueId { get; set; }
+  public long SeasonId { get; set; }
   public string NameLocalizeKey { get; set; }
   public string DescriptionLocalizeKey { get; set; }
   public string ImagePath { get; set; }
 
   public FieldKeywordExcelT() {
     this.UniqueId = 0;
+    this.SeasonId = 0;
     this.NameLocalizeKey = null;
     this.DescriptionLocalizeKey = null;
     this.ImagePath = null;
@@ -113,9 +121,10 @@ static public class FieldKeywordExcelVerify
   {
     return verifier.VerifyTableStart(tablePos)
       && verifier.VerifyField(tablePos, 4 /*UniqueId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyString(tablePos, 6 /*NameLocalizeKey*/, false)
+      && verifier.VerifyField(tablePos, 6 /*SeasonId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyString(tablePos, 8 /*DescriptionLocalizeKey*/, false)
+      && verifier.VerifyString(tablePos, 8 /*NameLocalizeKey*/, false)
-      && verifier.VerifyString(tablePos, 10 /*ImagePath*/, false)
+      && verifier.VerifyString(tablePos, 10 /*DescriptionLocalizeKey*/, false)
+      && verifier.VerifyString(tablePos, 12 /*ImagePath*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/FieldSceneExcel.cs

@@ -54,22 +54,38 @@ public struct FieldSceneExcel : IFlatbufferObject
   public ArraySegment<byte>? GetBeginConditionalBGMScenarioGroupIdBytes() { return __p.__vector_as_arraysegment(18); }
 #endif
   public long[] GetBeginConditionalBGMScenarioGroupIdArray() { return __p.__vector_as_array<long>(18); }
-  public long EndConditionalBGMScenarioGroupId(int j) { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public long BeginConditionalBGMInteractionId(int j) { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
-  public int EndConditionalBGMScenarioGroupIdLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int BeginConditionalBGMInteractionIdLength { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<long> GetEndConditionalBGMScenarioGroupIdBytes() { return __p.__vector_as_span<long>(20, 8); }
+  public Span<long> GetBeginConditionalBGMInteractionIdBytes() { return __p.__vector_as_span<long>(20, 8); }
 #else
-  public ArraySegment<byte>? GetEndConditionalBGMScenarioGroupIdBytes() { return __p.__vector_as_arraysegment(20); }
+  public ArraySegment<byte>? GetBeginConditionalBGMInteractionIdBytes() { return __p.__vector_as_arraysegment(20); }
 #endif
-  public long[] GetEndConditionalBGMScenarioGroupIdArray() { return __p.__vector_as_array<long>(20); }
+  public long[] GetBeginConditionalBGMInteractionIdArray() { return __p.__vector_as_array<long>(20); }
-  public long ConditionalBGMId(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public long EndConditionalBGMScenarioGroupId(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
-  public int ConditionalBGMIdLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int EndConditionalBGMScenarioGroupIdLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<long> GetConditionalBGMIdBytes() { return __p.__vector_as_span<long>(22, 8); }
+  public Span<long> GetEndConditionalBGMScenarioGroupIdBytes() { return __p.__vector_as_span<long>(22, 8); }
 #else
-  public ArraySegment<byte>? GetConditionalBGMIdBytes() { return __p.__vector_as_arraysegment(22); }
+  public ArraySegment<byte>? GetEndConditionalBGMScenarioGroupIdBytes() { return __p.__vector_as_arraysegment(22); }
 #endif
-  public long[] GetConditionalBGMIdArray() { return __p.__vector_as_array<long>(22); }
+  public long[] GetEndConditionalBGMScenarioGroupIdArray() { return __p.__vector_as_array<long>(22); }
+  public long EndConditionalBGMInteractionId(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int EndConditionalBGMInteractionIdLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetEndConditionalBGMInteractionIdBytes() { return __p.__vector_as_span<long>(24, 8); }
+#else
+  public ArraySegment<byte>? GetEndConditionalBGMInteractionIdBytes() { return __p.__vector_as_arraysegment(24); }
+#endif
+  public long[] GetEndConditionalBGMInteractionIdArray() { return __p.__vector_as_array<long>(24); }
+  public long ConditionalBGMId(int j) { int o = __p.__offset(26); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public int ConditionalBGMIdLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
+#if ENABLE_SPAN_T
+  public Span<long> GetConditionalBGMIdBytes() { return __p.__vector_as_span<long>(26, 8); }
+#else
+  public ArraySegment<byte>? GetConditionalBGMIdBytes() { return __p.__vector_as_arraysegment(26); }
+#endif
+  public long[] GetConditionalBGMIdArray() { return __p.__vector_as_array<long>(26); }
 
   public static Offset<SCHALE.Common.FlatData.FieldSceneExcel> CreateFieldSceneExcel(FlatBufferBuilder builder,
       long UniqueId = 0,
@@ -80,15 +96,19 @@ public struct FieldSceneExcel : IFlatbufferObject
       long BGMId = 0,
       VectorOffset ConditionalBGMQuestIdOffset = default(VectorOffset),
       VectorOffset BeginConditionalBGMScenarioGroupIdOffset = default(VectorOffset),
+      VectorOffset BeginConditionalBGMInteractionIdOffset = default(VectorOffset),
       VectorOffset EndConditionalBGMScenarioGroupIdOffset = default(VectorOffset),
+      VectorOffset EndConditionalBGMInteractionIdOffset = default(VectorOffset),
       VectorOffset ConditionalBGMIdOffset = default(VectorOffset)) {
-    builder.StartTable(10);
+    builder.StartTable(12);
     FieldSceneExcel.AddBGMId(builder, BGMId);
     FieldSceneExcel.AddGroupId(builder, GroupId);
     FieldSceneExcel.AddDateId(builder, DateId);
     FieldSceneExcel.AddUniqueId(builder, UniqueId);
     FieldSceneExcel.AddConditionalBGMId(builder, ConditionalBGMIdOffset);
+    FieldSceneExcel.AddEndConditionalBGMInteractionId(builder, EndConditionalBGMInteractionIdOffset);
     FieldSceneExcel.AddEndConditionalBGMScenarioGroupId(builder, EndConditionalBGMScenarioGroupIdOffset);
+    FieldSceneExcel.AddBeginConditionalBGMInteractionId(builder, BeginConditionalBGMInteractionIdOffset);
     FieldSceneExcel.AddBeginConditionalBGMScenarioGroupId(builder, BeginConditionalBGMScenarioGroupIdOffset);
     FieldSceneExcel.AddConditionalBGMQuestId(builder, ConditionalBGMQuestIdOffset);
     FieldSceneExcel.AddDesignLevelPath(builder, DesignLevelPathOffset);
@@ -96,7 +116,7 @@ public struct FieldSceneExcel : IFlatbufferObject
     return FieldSceneExcel.EndFieldSceneExcel(builder);
   }
 
-  public static void StartFieldSceneExcel(FlatBufferBuilder builder) { builder.StartTable(10); }
+  public static void StartFieldSceneExcel(FlatBufferBuilder builder) { builder.StartTable(12); }
   public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
   public static void AddDateId(FlatBufferBuilder builder, long dateId) { builder.AddLong(1, dateId, 0); }
   public static void AddGroupId(FlatBufferBuilder builder, long groupId) { builder.AddLong(2, groupId, 0); }
@@ -115,13 +135,25 @@ public struct FieldSceneExcel : IFlatbufferObject
   public static VectorOffset CreateBeginConditionalBGMScenarioGroupIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateBeginConditionalBGMScenarioGroupIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartBeginConditionalBGMScenarioGroupIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
-  public static void AddEndConditionalBGMScenarioGroupId(FlatBufferBuilder builder, VectorOffset endConditionalBGMScenarioGroupIdOffset) { builder.AddOffset(8, endConditionalBGMScenarioGroupIdOffset.Value, 0); }
+  public static void AddBeginConditionalBGMInteractionId(FlatBufferBuilder builder, VectorOffset beginConditionalBGMInteractionIdOffset) { builder.AddOffset(8, beginConditionalBGMInteractionIdOffset.Value, 0); }
+  public static VectorOffset CreateBeginConditionalBGMInteractionIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateBeginConditionalBGMInteractionIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBeginConditionalBGMInteractionIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateBeginConditionalBGMInteractionIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartBeginConditionalBGMInteractionIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddEndConditionalBGMScenarioGroupId(FlatBufferBuilder builder, VectorOffset endConditionalBGMScenarioGroupIdOffset) { builder.AddOffset(9, endConditionalBGMScenarioGroupIdOffset.Value, 0); }
   public static VectorOffset CreateEndConditionalBGMScenarioGroupIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateEndConditionalBGMScenarioGroupIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateEndConditionalBGMScenarioGroupIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateEndConditionalBGMScenarioGroupIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartEndConditionalBGMScenarioGroupIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
-  public static void AddConditionalBGMId(FlatBufferBuilder builder, VectorOffset conditionalBGMIdOffset) { builder.AddOffset(9, conditionalBGMIdOffset.Value, 0); }
+  public static void AddEndConditionalBGMInteractionId(FlatBufferBuilder builder, VectorOffset endConditionalBGMInteractionIdOffset) { builder.AddOffset(10, endConditionalBGMInteractionIdOffset.Value, 0); }
+  public static VectorOffset CreateEndConditionalBGMInteractionIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
+  public static VectorOffset CreateEndConditionalBGMInteractionIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEndConditionalBGMInteractionIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
+  public static VectorOffset CreateEndConditionalBGMInteractionIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
+  public static void StartEndConditionalBGMInteractionIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
+  public static void AddConditionalBGMId(FlatBufferBuilder builder, VectorOffset conditionalBGMIdOffset) { builder.AddOffset(11, conditionalBGMIdOffset.Value, 0); }
   public static VectorOffset CreateConditionalBGMIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateConditionalBGMIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateConditionalBGMIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
@@ -148,8 +180,12 @@ public struct FieldSceneExcel : IFlatbufferObject
     for (var _j = 0; _j < this.ConditionalBGMQuestIdLength; ++_j) {_o.ConditionalBGMQuestId.Add(TableEncryptionService.Convert(this.ConditionalBGMQuestId(_j), key));}
     _o.BeginConditionalBGMScenarioGroupId = new List<long>();
     for (var _j = 0; _j < this.BeginConditionalBGMScenarioGroupIdLength; ++_j) {_o.BeginConditionalBGMScenarioGroupId.Add(TableEncryptionService.Convert(this.BeginConditionalBGMScenarioGroupId(_j), key));}
+    _o.BeginConditionalBGMInteractionId = new List<long>();
+    for (var _j = 0; _j < this.BeginConditionalBGMInteractionIdLength; ++_j) {_o.BeginConditionalBGMInteractionId.Add(TableEncryptionService.Convert(this.BeginConditionalBGMInteractionId(_j), key));}
     _o.EndConditionalBGMScenarioGroupId = new List<long>();
     for (var _j = 0; _j < this.EndConditionalBGMScenarioGroupIdLength; ++_j) {_o.EndConditionalBGMScenarioGroupId.Add(TableEncryptionService.Convert(this.EndConditionalBGMScenarioGroupId(_j), key));}
+    _o.EndConditionalBGMInteractionId = new List<long>();
+    for (var _j = 0; _j < this.EndConditionalBGMInteractionIdLength; ++_j) {_o.EndConditionalBGMInteractionId.Add(TableEncryptionService.Convert(this.EndConditionalBGMInteractionId(_j), key));}
     _o.ConditionalBGMId = new List<long>();
     for (var _j = 0; _j < this.ConditionalBGMIdLength; ++_j) {_o.ConditionalBGMId.Add(TableEncryptionService.Convert(this.ConditionalBGMId(_j), key));}
   }
@@ -167,11 +203,21 @@ public struct FieldSceneExcel : IFlatbufferObject
       var __BeginConditionalBGMScenarioGroupId = _o.BeginConditionalBGMScenarioGroupId.ToArray();
       _BeginConditionalBGMScenarioGroupId = CreateBeginConditionalBGMScenarioGroupIdVector(builder, __BeginConditionalBGMScenarioGroupId);
     }
+    var _BeginConditionalBGMInteractionId = default(VectorOffset);
+    if (_o.BeginConditionalBGMInteractionId != null) {
+      var __BeginConditionalBGMInteractionId = _o.BeginConditionalBGMInteractionId.ToArray();
+      _BeginConditionalBGMInteractionId = CreateBeginConditionalBGMInteractionIdVector(builder, __BeginConditionalBGMInteractionId);
+    }
     var _EndConditionalBGMScenarioGroupId = default(VectorOffset);
     if (_o.EndConditionalBGMScenarioGroupId != null) {
       var __EndConditionalBGMScenarioGroupId = _o.EndConditionalBGMScenarioGroupId.ToArray();
       _EndConditionalBGMScenarioGroupId = CreateEndConditionalBGMScenarioGroupIdVector(builder, __EndConditionalBGMScenarioGroupId);
     }
+    var _EndConditionalBGMInteractionId = default(VectorOffset);
+    if (_o.EndConditionalBGMInteractionId != null) {
+      var __EndConditionalBGMInteractionId = _o.EndConditionalBGMInteractionId.ToArray();
+      _EndConditionalBGMInteractionId = CreateEndConditionalBGMInteractionIdVector(builder, __EndConditionalBGMInteractionId);
+    }
     var _ConditionalBGMId = default(VectorOffset);
     if (_o.ConditionalBGMId != null) {
       var __ConditionalBGMId = _o.ConditionalBGMId.ToArray();
@@ -187,7 +233,9 @@ public struct FieldSceneExcel : IFlatbufferObject
       _o.BGMId,
       _ConditionalBGMQuestId,
       _BeginConditionalBGMScenarioGroupId,
+      _BeginConditionalBGMInteractionId,
       _EndConditionalBGMScenarioGroupId,
+      _EndConditionalBGMInteractionId,
       _ConditionalBGMId);
   }
 }
@@ -202,7 +250,9 @@ public class FieldSceneExcelT
   public long BGMId { get; set; }
   public List<long> ConditionalBGMQuestId { get; set; }
   public List<long> BeginConditionalBGMScenarioGroupId { get; set; }
+  public List<long> BeginConditionalBGMInteractionId { get; set; }
   public List<long> EndConditionalBGMScenarioGroupId { get; set; }
+  public List<long> EndConditionalBGMInteractionId { get; set; }
   public List<long> ConditionalBGMId { get; set; }
 
   public FieldSceneExcelT() {
@@ -214,7 +264,9 @@ public class FieldSceneExcelT
     this.BGMId = 0;
     this.ConditionalBGMQuestId = null;
     this.BeginConditionalBGMScenarioGroupId = null;
+    this.BeginConditionalBGMInteractionId = null;
     this.EndConditionalBGMScenarioGroupId = null;
+    this.EndConditionalBGMInteractionId = null;
     this.ConditionalBGMId = null;
   }
 }
@@ -233,8 +285,10 @@ static public class FieldSceneExcelVerify
       && verifier.VerifyField(tablePos, 14 /*BGMId*/, 8 /*long*/, 8, false)
       && verifier.VerifyVectorOfData(tablePos, 16 /*ConditionalBGMQuestId*/, 8 /*long*/, false)
       && verifier.VerifyVectorOfData(tablePos, 18 /*BeginConditionalBGMScenarioGroupId*/, 8 /*long*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 20 /*EndConditionalBGMScenarioGroupId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 20 /*BeginConditionalBGMInteractionId*/, 8 /*long*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 22 /*ConditionalBGMId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*EndConditionalBGMScenarioGroupId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 24 /*EndConditionalBGMInteractionId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 26 /*ConditionalBGMId*/, 8 /*long*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/FieldSeasonExcel.cs

@@ -39,34 +39,29 @@ public struct FieldSeasonExcel : IFlatbufferObject
 #endif
   public byte[] GetEndDateArray() { return __p.__vector_as_array<byte>(14); }
   public long LobbyBGMChangeStageId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public string CharacterIconPath { get { int o = __p.__offset(18); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public long FieldPrefabControlID { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public SCHALE.Common.FlatData.FieldDialogType FieldGetKeywordCallDialogEnum { get { int o = __p.__offset(20); return o != 0 ? (SCHALE.Common.FlatData.FieldDialogType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.FieldDialogType.None; } }
+  public string MasteryImagePath { get { int o = __p.__offset(22); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetCharacterIconPathBytes() { return __p.__vector_as_span<byte>(18, 1); }
+  public Span<byte> GetMasteryImagePathBytes() { return __p.__vector_as_span<byte>(22, 1); }
 #else
-  public ArraySegment<byte>? GetCharacterIconPathBytes() { return __p.__vector_as_arraysegment(18); }
+  public ArraySegment<byte>? GetMasteryImagePathBytes() { return __p.__vector_as_arraysegment(22); }
 #endif
-  public byte[] GetCharacterIconPathArray() { return __p.__vector_as_array<byte>(18); }
+  public byte[] GetMasteryImagePathArray() { return __p.__vector_as_array<byte>(22); }
-  public string MasteryImagePath { get { int o = __p.__offset(20); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public string FieldLobbyTitleImagePath { get { int o = __p.__offset(24); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetMasteryImagePathBytes() { return __p.__vector_as_span<byte>(20, 1); }
+  public Span<byte> GetFieldLobbyTitleImagePathBytes() { return __p.__vector_as_span<byte>(24, 1); }
 #else
-  public ArraySegment<byte>? GetMasteryImagePathBytes() { return __p.__vector_as_arraysegment(20); }
+  public ArraySegment<byte>? GetFieldLobbyTitleImagePathBytes() { return __p.__vector_as_arraysegment(24); }
 #endif
-  public byte[] GetMasteryImagePathArray() { return __p.__vector_as_array<byte>(20); }
+  public byte[] GetFieldLobbyTitleImagePathArray() { return __p.__vector_as_array<byte>(24); }
-  public string FieldLobbyTitleImagePath { get { int o = __p.__offset(22); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+  public string KeywordLogoImagePath { get { int o = __p.__offset(26); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
 #if ENABLE_SPAN_T
-  public Span<byte> GetFieldLobbyTitleImagePathBytes() { return __p.__vector_as_span<byte>(22, 1); }
+  public Span<byte> GetKeywordLogoImagePathBytes() { return __p.__vector_as_span<byte>(26, 1); }
 #else
-  public ArraySegment<byte>? GetFieldLobbyTitleImagePathBytes() { return __p.__vector_as_arraysegment(22); }
+  public ArraySegment<byte>? GetKeywordLogoImagePathBytes() { return __p.__vector_as_arraysegment(26); }
 #endif
-  public byte[] GetFieldLobbyTitleImagePathArray() { return __p.__vector_as_array<byte>(22); }
+  public byte[] GetKeywordLogoImagePathArray() { return __p.__vector_as_array<byte>(26); }
-  public string KeywordLogoImagePath { get { int o = __p.__offset(24); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
-#if ENABLE_SPAN_T
-  public Span<byte> GetKeywordLogoImagePathBytes() { return __p.__vector_as_span<byte>(24, 1); }
-#else
-  public ArraySegment<byte>? GetKeywordLogoImagePathBytes() { return __p.__vector_as_arraysegment(24); }
-#endif
-  public byte[] GetKeywordLogoImagePathArray() { return __p.__vector_as_array<byte>(24); }
 
   public static Offset<SCHALE.Common.FlatData.FieldSeasonExcel> CreateFieldSeasonExcel(FlatBufferBuilder builder,
       long UniqueId = 0,
@@ -76,11 +71,13 @@ public struct FieldSeasonExcel : IFlatbufferObject
       StringOffset StartDateOffset = default(StringOffset),
       StringOffset EndDateOffset = default(StringOffset),
       long LobbyBGMChangeStageId = 0,
-      StringOffset CharacterIconPathOffset = default(StringOffset),
+      long FieldPrefabControlID = 0,
+      SCHALE.Common.FlatData.FieldDialogType FieldGetKeywordCallDialogEnum = SCHALE.Common.FlatData.FieldDialogType.None,
       StringOffset MasteryImagePathOffset = default(StringOffset),
       StringOffset FieldLobbyTitleImagePathOffset = default(StringOffset),
       StringOffset KeywordLogoImagePathOffset = default(StringOffset)) {
-    builder.StartTable(11);
+    builder.StartTable(12);
+    FieldSeasonExcel.AddFieldPrefabControlID(builder, FieldPrefabControlID);
     FieldSeasonExcel.AddLobbyBGMChangeStageId(builder, LobbyBGMChangeStageId);
     FieldSeasonExcel.AddInstantEntryDateId(builder, InstantEntryDateId);
     FieldSeasonExcel.AddEntryDateId(builder, EntryDateId);
@@ -89,13 +86,13 @@ public struct FieldSeasonExcel : IFlatbufferObject
     FieldSeasonExcel.AddKeywordLogoImagePath(builder, KeywordLogoImagePathOffset);
     FieldSeasonExcel.AddFieldLobbyTitleImagePath(builder, FieldLobbyTitleImagePathOffset);
     FieldSeasonExcel.AddMasteryImagePath(builder, MasteryImagePathOffset);
-    FieldSeasonExcel.AddCharacterIconPath(builder, CharacterIconPathOffset);
+    FieldSeasonExcel.AddFieldGetKeywordCallDialogEnum(builder, FieldGetKeywordCallDialogEnum);
     FieldSeasonExcel.AddEndDate(builder, EndDateOffset);
     FieldSeasonExcel.AddStartDate(builder, StartDateOffset);
     return FieldSeasonExcel.EndFieldSeasonExcel(builder);
   }
 
-  public static void StartFieldSeasonExcel(FlatBufferBuilder builder) { builder.StartTable(11); }
+  public static void StartFieldSeasonExcel(FlatBufferBuilder builder) { builder.StartTable(12); }
   public static void AddUniqueId(FlatBufferBuilder builder, long uniqueId) { builder.AddLong(0, uniqueId, 0); }
   public static void AddEventContentId(FlatBufferBuilder builder, long eventContentId) { builder.AddLong(1, eventContentId, 0); }
   public static void AddEntryDateId(FlatBufferBuilder builder, long entryDateId) { builder.AddLong(2, entryDateId, 0); }
@@ -103,10 +100,11 @@ public struct FieldSeasonExcel : IFlatbufferObject
   public static void AddStartDate(FlatBufferBuilder builder, StringOffset startDateOffset) { builder.AddOffset(4, startDateOffset.Value, 0); }
   public static void AddEndDate(FlatBufferBuilder builder, StringOffset endDateOffset) { builder.AddOffset(5, endDateOffset.Value, 0); }
   public static void AddLobbyBGMChangeStageId(FlatBufferBuilder builder, long lobbyBGMChangeStageId) { builder.AddLong(6, lobbyBGMChangeStageId, 0); }
-  public static void AddCharacterIconPath(FlatBufferBuilder builder, StringOffset characterIconPathOffset) { builder.AddOffset(7, characterIconPathOffset.Value, 0); }
+  public static void AddFieldPrefabControlID(FlatBufferBuilder builder, long fieldPrefabControlID) { builder.AddLong(7, fieldPrefabControlID, 0); }
-  public static void AddMasteryImagePath(FlatBufferBuilder builder, StringOffset masteryImagePathOffset) { builder.AddOffset(8, masteryImagePathOffset.Value, 0); }
+  public static void AddFieldGetKeywordCallDialogEnum(FlatBufferBuilder builder, SCHALE.Common.FlatData.FieldDialogType fieldGetKeywordCallDialogEnum) { builder.AddInt(8, (int)fieldGetKeywordCallDialogEnum, 0); }
-  public static void AddFieldLobbyTitleImagePath(FlatBufferBuilder builder, StringOffset fieldLobbyTitleImagePathOffset) { builder.AddOffset(9, fieldLobbyTitleImagePathOffset.Value, 0); }
+  public static void AddMasteryImagePath(FlatBufferBuilder builder, StringOffset masteryImagePathOffset) { builder.AddOffset(9, masteryImagePathOffset.Value, 0); }
-  public static void AddKeywordLogoImagePath(FlatBufferBuilder builder, StringOffset keywordLogoImagePathOffset) { builder.AddOffset(10, keywordLogoImagePathOffset.Value, 0); }
+  public static void AddFieldLobbyTitleImagePath(FlatBufferBuilder builder, StringOffset fieldLobbyTitleImagePathOffset) { builder.AddOffset(10, fieldLobbyTitleImagePathOffset.Value, 0); }
+  public static void AddKeywordLogoImagePath(FlatBufferBuilder builder, StringOffset keywordLogoImagePathOffset) { builder.AddOffset(11, keywordLogoImagePathOffset.Value, 0); }
   public static Offset<SCHALE.Common.FlatData.FieldSeasonExcel> EndFieldSeasonExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.FieldSeasonExcel>(o);
@@ -125,7 +123,8 @@ public struct FieldSeasonExcel : IFlatbufferObject
     _o.StartDate = TableEncryptionService.Convert(this.StartDate, key);
     _o.EndDate = TableEncryptionService.Convert(this.EndDate, key);
     _o.LobbyBGMChangeStageId = TableEncryptionService.Convert(this.LobbyBGMChangeStageId, key);
-    _o.CharacterIconPath = TableEncryptionService.Convert(this.CharacterIconPath, key);
+    _o.FieldPrefabControlID = TableEncryptionService.Convert(this.FieldPrefabControlID, key);
+    _o.FieldGetKeywordCallDialogEnum = TableEncryptionService.Convert(this.FieldGetKeywordCallDialogEnum, key);
     _o.MasteryImagePath = TableEncryptionService.Convert(this.MasteryImagePath, key);
     _o.FieldLobbyTitleImagePath = TableEncryptionService.Convert(this.FieldLobbyTitleImagePath, key);
     _o.KeywordLogoImagePath = TableEncryptionService.Convert(this.KeywordLogoImagePath, key);
@@ -134,7 +133,6 @@ public struct FieldSeasonExcel : IFlatbufferObject
     if (_o == null) return default(Offset<SCHALE.Common.FlatData.FieldSeasonExcel>);
     var _StartDate = _o.StartDate == null ? default(StringOffset) : builder.CreateString(_o.StartDate);
     var _EndDate = _o.EndDate == null ? default(StringOffset) : builder.CreateString(_o.EndDate);
-    var _CharacterIconPath = _o.CharacterIconPath == null ? default(StringOffset) : builder.CreateString(_o.CharacterIconPath);
     var _MasteryImagePath = _o.MasteryImagePath == null ? default(StringOffset) : builder.CreateString(_o.MasteryImagePath);
     var _FieldLobbyTitleImagePath = _o.FieldLobbyTitleImagePath == null ? default(StringOffset) : builder.CreateString(_o.FieldLobbyTitleImagePath);
     var _KeywordLogoImagePath = _o.KeywordLogoImagePath == null ? default(StringOffset) : builder.CreateString(_o.KeywordLogoImagePath);
@@ -147,7 +145,8 @@ public struct FieldSeasonExcel : IFlatbufferObject
       _StartDate,
       _EndDate,
       _o.LobbyBGMChangeStageId,
-      _CharacterIconPath,
+      _o.FieldPrefabControlID,
+      _o.FieldGetKeywordCallDialogEnum,
       _MasteryImagePath,
       _FieldLobbyTitleImagePath,
       _KeywordLogoImagePath);
@@ -163,7 +162,8 @@ public class FieldSeasonExcelT
   public string StartDate { get; set; }
   public string EndDate { get; set; }
   public long LobbyBGMChangeStageId { get; set; }
-  public string CharacterIconPath { get; set; }
+  public long FieldPrefabControlID { get; set; }
+  public SCHALE.Common.FlatData.FieldDialogType FieldGetKeywordCallDialogEnum { get; set; }
   public string MasteryImagePath { get; set; }
   public string FieldLobbyTitleImagePath { get; set; }
   public string KeywordLogoImagePath { get; set; }
@@ -176,7 +176,8 @@ public class FieldSeasonExcelT
     this.StartDate = null;
     this.EndDate = null;
     this.LobbyBGMChangeStageId = 0;
-    this.CharacterIconPath = null;
+    this.FieldPrefabControlID = 0;
+    this.FieldGetKeywordCallDialogEnum = SCHALE.Common.FlatData.FieldDialogType.None;
     this.MasteryImagePath = null;
     this.FieldLobbyTitleImagePath = null;
     this.KeywordLogoImagePath = null;
@@ -196,10 +197,11 @@ static public class FieldSeasonExcelVerify
       && verifier.VerifyString(tablePos, 12 /*StartDate*/, false)
       && verifier.VerifyString(tablePos, 14 /*EndDate*/, false)
       && verifier.VerifyField(tablePos, 16 /*LobbyBGMChangeStageId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyString(tablePos, 18 /*CharacterIconPath*/, false)
+      && verifier.VerifyField(tablePos, 18 /*FieldPrefabControlID*/, 8 /*long*/, 8, false)
-      && verifier.VerifyString(tablePos, 20 /*MasteryImagePath*/, false)
+      && verifier.VerifyField(tablePos, 20 /*FieldGetKeywordCallDialogEnum*/, 4 /*SCHALE.Common.FlatData.FieldDialogType*/, 4, false)
-      && verifier.VerifyString(tablePos, 22 /*FieldLobbyTitleImagePath*/, false)
+      && verifier.VerifyString(tablePos, 22 /*MasteryImagePath*/, false)
-      && verifier.VerifyString(tablePos, 24 /*KeywordLogoImagePath*/, false)
+      && verifier.VerifyString(tablePos, 24 /*FieldLobbyTitleImagePath*/, false)
+      && verifier.VerifyString(tablePos, 26 /*KeywordLogoImagePath*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/FieldWorldMapButtonType.cs

@@ -0,0 +1,18 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum FieldWorldMapButtonType : int
+{
+  DefaultMode = 0,
+  Normal = 1,
+  Combat = 2,
+  Combat_VeryHard = 3,
+  UnderCover = 4,
+};
+
+
+}

SCHALE.Common/FlatData/FieldWorldMapZoneExcel.cs

@@ -29,7 +29,9 @@ public struct FieldWorldMapZoneExcel : IFlatbufferObject
   public long CloseConditionId { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public long ResultFieldScene { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public long FieldStageInteractionId { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public uint LocalizeCode { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public SCHALE.Common.FlatData.FieldWorldMapButtonType WorldMapButtonType { get { int o = __p.__offset(22); return o != 0 ? (SCHALE.Common.FlatData.FieldWorldMapButtonType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.FieldWorldMapButtonType.DefaultMode; } }
+  public uint LocalizeCode { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public bool NewTagDisplay { get { int o = __p.__offset(26); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
 
   public static Offset<SCHALE.Common.FlatData.FieldWorldMapZoneExcel> CreateFieldWorldMapZoneExcel(FlatBufferBuilder builder,
       long Id = 0,
@@ -41,22 +43,26 @@ public struct FieldWorldMapZoneExcel : IFlatbufferObject
       long CloseConditionId = 0,
       long ResultFieldScene = 0,
       long FieldStageInteractionId = 0,
-      uint LocalizeCode = 0) {
+      SCHALE.Common.FlatData.FieldWorldMapButtonType WorldMapButtonType = SCHALE.Common.FlatData.FieldWorldMapButtonType.DefaultMode,
-    builder.StartTable(10);
+      uint LocalizeCode = 0,
+      bool NewTagDisplay = false) {
+    builder.StartTable(12);
     FieldWorldMapZoneExcel.AddFieldStageInteractionId(builder, FieldStageInteractionId);
     FieldWorldMapZoneExcel.AddResultFieldScene(builder, ResultFieldScene);
     FieldWorldMapZoneExcel.AddCloseConditionId(builder, CloseConditionId);
     FieldWorldMapZoneExcel.AddOpenConditionId(builder, OpenConditionId);
     FieldWorldMapZoneExcel.AddId(builder, Id);
     FieldWorldMapZoneExcel.AddLocalizeCode(builder, LocalizeCode);
+    FieldWorldMapZoneExcel.AddWorldMapButtonType(builder, WorldMapButtonType);
     FieldWorldMapZoneExcel.AddCloseConditionType(builder, CloseConditionType);
     FieldWorldMapZoneExcel.AddOpenConditionType(builder, OpenConditionType);
     FieldWorldMapZoneExcel.AddDate(builder, Date);
     FieldWorldMapZoneExcel.AddGroupId(builder, GroupId);
+    FieldWorldMapZoneExcel.AddNewTagDisplay(builder, NewTagDisplay);
     return FieldWorldMapZoneExcel.EndFieldWorldMapZoneExcel(builder);
   }
 
-  public static void StartFieldWorldMapZoneExcel(FlatBufferBuilder builder) { builder.StartTable(10); }
+  public static void StartFieldWorldMapZoneExcel(FlatBufferBuilder builder) { builder.StartTable(12); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddGroupId(FlatBufferBuilder builder, int groupId) { builder.AddInt(1, groupId, 0); }
   public static void AddDate(FlatBufferBuilder builder, int date) { builder.AddInt(2, date, 0); }
@@ -66,7 +72,9 @@ public struct FieldWorldMapZoneExcel : IFlatbufferObject
   public static void AddCloseConditionId(FlatBufferBuilder builder, long closeConditionId) { builder.AddLong(6, closeConditionId, 0); }
   public static void AddResultFieldScene(FlatBufferBuilder builder, long resultFieldScene) { builder.AddLong(7, resultFieldScene, 0); }
   public static void AddFieldStageInteractionId(FlatBufferBuilder builder, long fieldStageInteractionId) { builder.AddLong(8, fieldStageInteractionId, 0); }
-  public static void AddLocalizeCode(FlatBufferBuilder builder, uint localizeCode) { builder.AddUint(9, localizeCode, 0); }
+  public static void AddWorldMapButtonType(FlatBufferBuilder builder, SCHALE.Common.FlatData.FieldWorldMapButtonType worldMapButtonType) { builder.AddInt(9, (int)worldMapButtonType, 0); }
+  public static void AddLocalizeCode(FlatBufferBuilder builder, uint localizeCode) { builder.AddUint(10, localizeCode, 0); }
+  public static void AddNewTagDisplay(FlatBufferBuilder builder, bool newTagDisplay) { builder.AddBool(11, newTagDisplay, false); }
   public static Offset<SCHALE.Common.FlatData.FieldWorldMapZoneExcel> EndFieldWorldMapZoneExcel(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     return new Offset<SCHALE.Common.FlatData.FieldWorldMapZoneExcel>(o);
@@ -87,7 +95,9 @@ public struct FieldWorldMapZoneExcel : IFlatbufferObject
     _o.CloseConditionId = TableEncryptionService.Convert(this.CloseConditionId, key);
     _o.ResultFieldScene = TableEncryptionService.Convert(this.ResultFieldScene, key);
     _o.FieldStageInteractionId = TableEncryptionService.Convert(this.FieldStageInteractionId, key);
+    _o.WorldMapButtonType = TableEncryptionService.Convert(this.WorldMapButtonType, key);
     _o.LocalizeCode = TableEncryptionService.Convert(this.LocalizeCode, key);
+    _o.NewTagDisplay = TableEncryptionService.Convert(this.NewTagDisplay, key);
   }
   public static Offset<SCHALE.Common.FlatData.FieldWorldMapZoneExcel> Pack(FlatBufferBuilder builder, FieldWorldMapZoneExcelT _o) {
     if (_o == null) return default(Offset<SCHALE.Common.FlatData.FieldWorldMapZoneExcel>);
@@ -102,7 +112,9 @@ public struct FieldWorldMapZoneExcel : IFlatbufferObject
       _o.CloseConditionId,
       _o.ResultFieldScene,
       _o.FieldStageInteractionId,
-      _o.LocalizeCode);
+      _o.WorldMapButtonType,
+      _o.LocalizeCode,
+      _o.NewTagDisplay);
   }
 }
 
@@ -117,7 +129,9 @@ public class FieldWorldMapZoneExcelT
   public long CloseConditionId { get; set; }
   public long ResultFieldScene { get; set; }
   public long FieldStageInteractionId { get; set; }
+  public SCHALE.Common.FlatData.FieldWorldMapButtonType WorldMapButtonType { get; set; }
   public uint LocalizeCode { get; set; }
+  public bool NewTagDisplay { get; set; }
 
   public FieldWorldMapZoneExcelT() {
     this.Id = 0;
@@ -129,7 +143,9 @@ public class FieldWorldMapZoneExcelT
     this.CloseConditionId = 0;
     this.ResultFieldScene = 0;
     this.FieldStageInteractionId = 0;
+    this.WorldMapButtonType = SCHALE.Common.FlatData.FieldWorldMapButtonType.DefaultMode;
     this.LocalizeCode = 0;
+    this.NewTagDisplay = false;
   }
 }
 
@@ -148,7 +164,9 @@ static public class FieldWorldMapZoneExcelVerify
       && verifier.VerifyField(tablePos, 16 /*CloseConditionId*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 18 /*ResultFieldScene*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 20 /*FieldStageInteractionId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 22 /*LocalizeCode*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 22 /*WorldMapButtonType*/, 4 /*SCHALE.Common.FlatData.FieldWorldMapButtonType*/, 4, false)
+      && verifier.VerifyField(tablePos, 24 /*LocalizeCode*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 26 /*NewTagDisplay*/, 1 /*bool*/, 1, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/ProductMonthlyExcel.cs

@@ -40,55 +40,56 @@ public struct ProductMonthlyExcel : IFlatbufferObject
   public SCHALE.Common.FlatData.ProductTagType ProductTagType { get { int o = __p.__offset(14); return o != 0 ? (SCHALE.Common.FlatData.ProductTagType)__p.bb.GetInt(o + __p.bb_pos) : SCHALE.Common.FlatData.ProductTagType.Monthly; } }
   public long MonthlyDays { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
   public bool UseMonthlyProductCheck { get { int o = __p.__offset(18); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
-  public SCHALE.Common.FlatData.ParcelType ParcelType_(int j) { int o = __p.__offset(20); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public long PurchaseCountLimit { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public int ParcelType_Length { get { int o = __p.__offset(20); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public SCHALE.Common.FlatData.ParcelType ParcelType_(int j) { int o = __p.__offset(22); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public int ParcelType_Length { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<SCHALE.Common.FlatData.ParcelType> GetParcelType_Bytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(20, 4); }
+  public Span<SCHALE.Common.FlatData.ParcelType> GetParcelType_Bytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(22, 4); }
 #else
-  public ArraySegment<byte>? GetParcelType_Bytes() { return __p.__vector_as_arraysegment(20); }
+  public ArraySegment<byte>? GetParcelType_Bytes() { return __p.__vector_as_arraysegment(22); }
 #endif
-  public SCHALE.Common.FlatData.ParcelType[] GetParcelType_Array() { int o = __p.__offset(20); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public SCHALE.Common.FlatData.ParcelType[] GetParcelType_Array() { int o = __p.__offset(22); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
-  public long ParcelId(int j) { int o = __p.__offset(22); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public long ParcelId(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
-  public int ParcelIdLength { get { int o = __p.__offset(22); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int ParcelIdLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<long> GetParcelIdBytes() { return __p.__vector_as_span<long>(22, 8); }
+  public Span<long> GetParcelIdBytes() { return __p.__vector_as_span<long>(24, 8); }
 #else
-  public ArraySegment<byte>? GetParcelIdBytes() { return __p.__vector_as_arraysegment(22); }
+  public ArraySegment<byte>? GetParcelIdBytes() { return __p.__vector_as_arraysegment(24); }
 #endif
-  public long[] GetParcelIdArray() { return __p.__vector_as_array<long>(22); }
+  public long[] GetParcelIdArray() { return __p.__vector_as_array<long>(24); }
-  public long ParcelAmount(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public long ParcelAmount(int j) { int o = __p.__offset(26); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
-  public int ParcelAmountLength { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int ParcelAmountLength { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<long> GetParcelAmountBytes() { return __p.__vector_as_span<long>(24, 8); }
+  public Span<long> GetParcelAmountBytes() { return __p.__vector_as_span<long>(26, 8); }
 #else
-  public ArraySegment<byte>? GetParcelAmountBytes() { return __p.__vector_as_arraysegment(24); }
+  public ArraySegment<byte>? GetParcelAmountBytes() { return __p.__vector_as_arraysegment(26); }
 #endif
-  public long[] GetParcelAmountArray() { return __p.__vector_as_array<long>(24); }
+  public long[] GetParcelAmountArray() { return __p.__vector_as_array<long>(26); }
-  public long EnterCostReduceGroupId { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public long EnterCostReduceGroupId { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public SCHALE.Common.FlatData.ParcelType DailyParcelType(int j) { int o = __p.__offset(28); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
+  public SCHALE.Common.FlatData.ParcelType DailyParcelType(int j) { int o = __p.__offset(30); return o != 0 ? (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(__p.__vector(o) + j * 4) : (SCHALE.Common.FlatData.ParcelType)0; }
-  public int DailyParcelTypeLength { get { int o = __p.__offset(28); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int DailyParcelTypeLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<SCHALE.Common.FlatData.ParcelType> GetDailyParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(28, 4); }
+  public Span<SCHALE.Common.FlatData.ParcelType> GetDailyParcelTypeBytes() { return __p.__vector_as_span<SCHALE.Common.FlatData.ParcelType>(30, 4); }
 #else
-  public ArraySegment<byte>? GetDailyParcelTypeBytes() { return __p.__vector_as_arraysegment(28); }
+  public ArraySegment<byte>? GetDailyParcelTypeBytes() { return __p.__vector_as_arraysegment(30); }
 #endif
-  public SCHALE.Common.FlatData.ParcelType[] GetDailyParcelTypeArray() { int o = __p.__offset(28); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
+  public SCHALE.Common.FlatData.ParcelType[] GetDailyParcelTypeArray() { int o = __p.__offset(30); if (o == 0) return null; int p = __p.__vector(o); int l = __p.__vector_len(o); SCHALE.Common.FlatData.ParcelType[] a = new SCHALE.Common.FlatData.ParcelType[l]; for (int i = 0; i < l; i++) { a[i] = (SCHALE.Common.FlatData.ParcelType)__p.bb.GetInt(p + i * 4); } return a; }
-  public long DailyParcelId(int j) { int o = __p.__offset(30); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public long DailyParcelId(int j) { int o = __p.__offset(32); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
-  public int DailyParcelIdLength { get { int o = __p.__offset(30); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int DailyParcelIdLength { get { int o = __p.__offset(32); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<long> GetDailyParcelIdBytes() { return __p.__vector_as_span<long>(30, 8); }
+  public Span<long> GetDailyParcelIdBytes() { return __p.__vector_as_span<long>(32, 8); }
 #else
-  public ArraySegment<byte>? GetDailyParcelIdBytes() { return __p.__vector_as_arraysegment(30); }
+  public ArraySegment<byte>? GetDailyParcelIdBytes() { return __p.__vector_as_arraysegment(32); }
 #endif
-  public long[] GetDailyParcelIdArray() { return __p.__vector_as_array<long>(30); }
+  public long[] GetDailyParcelIdArray() { return __p.__vector_as_array<long>(32); }
-  public long DailyParcelAmount(int j) { int o = __p.__offset(32); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
+  public long DailyParcelAmount(int j) { int o = __p.__offset(34); return o != 0 ? __p.bb.GetLong(__p.__vector(o) + j * 8) : (long)0; }
-  public int DailyParcelAmountLength { get { int o = __p.__offset(32); return o != 0 ? __p.__vector_len(o) : 0; } }
+  public int DailyParcelAmountLength { get { int o = __p.__offset(34); return o != 0 ? __p.__vector_len(o) : 0; } }
 #if ENABLE_SPAN_T
-  public Span<long> GetDailyParcelAmountBytes() { return __p.__vector_as_span<long>(32, 8); }
+  public Span<long> GetDailyParcelAmountBytes() { return __p.__vector_as_span<long>(34, 8); }
 #else
-  public ArraySegment<byte>? GetDailyParcelAmountBytes() { return __p.__vector_as_arraysegment(32); }
+  public ArraySegment<byte>? GetDailyParcelAmountBytes() { return __p.__vector_as_arraysegment(34); }
 #endif
-  public long[] GetDailyParcelAmountArray() { return __p.__vector_as_array<long>(32); }
+  public long[] GetDailyParcelAmountArray() { return __p.__vector_as_array<long>(34); }
 
   public static Offset<SCHALE.Common.FlatData.ProductMonthlyExcel> CreateProductMonthlyExcel(FlatBufferBuilder builder,
       long Id = 0,
@@ -99,6 +100,7 @@ public struct ProductMonthlyExcel : IFlatbufferObject
       SCHALE.Common.FlatData.ProductTagType ProductTagType = SCHALE.Common.FlatData.ProductTagType.Monthly,
       long MonthlyDays = 0,
       bool UseMonthlyProductCheck = false,
+      long PurchaseCountLimit = 0,
       VectorOffset ParcelType_Offset = default(VectorOffset),
       VectorOffset ParcelIdOffset = default(VectorOffset),
       VectorOffset ParcelAmountOffset = default(VectorOffset),
@@ -106,8 +108,9 @@ public struct ProductMonthlyExcel : IFlatbufferObject
       VectorOffset DailyParcelTypeOffset = default(VectorOffset),
       VectorOffset DailyParcelIdOffset = default(VectorOffset),
       VectorOffset DailyParcelAmountOffset = default(VectorOffset)) {
-    builder.StartTable(15);
+    builder.StartTable(16);
     ProductMonthlyExcel.AddEnterCostReduceGroupId(builder, EnterCostReduceGroupId);
+    ProductMonthlyExcel.AddPurchaseCountLimit(builder, PurchaseCountLimit);
     ProductMonthlyExcel.AddMonthlyDays(builder, MonthlyDays);
     ProductMonthlyExcel.AddPrice(builder, Price);
     ProductMonthlyExcel.AddId(builder, Id);
@@ -125,7 +128,7 @@ public struct ProductMonthlyExcel : IFlatbufferObject
     return ProductMonthlyExcel.EndProductMonthlyExcel(builder);
   }
 
-  public static void StartProductMonthlyExcel(FlatBufferBuilder builder) { builder.StartTable(15); }
+  public static void StartProductMonthlyExcel(FlatBufferBuilder builder) { builder.StartTable(16); }
   public static void AddId(FlatBufferBuilder builder, long id) { builder.AddLong(0, id, 0); }
   public static void AddProductId(FlatBufferBuilder builder, StringOffset productIdOffset) { builder.AddOffset(1, productIdOffset.Value, 0); }
   public static void AddStoreType(FlatBufferBuilder builder, SCHALE.Common.FlatData.StoreType storeType) { builder.AddInt(2, (int)storeType, 0); }
@@ -134,38 +137,39 @@ public struct ProductMonthlyExcel : IFlatbufferObject
   public static void AddProductTagType(FlatBufferBuilder builder, SCHALE.Common.FlatData.ProductTagType productTagType) { builder.AddInt(5, (int)productTagType, 0); }
   public static void AddMonthlyDays(FlatBufferBuilder builder, long monthlyDays) { builder.AddLong(6, monthlyDays, 0); }
   public static void AddUseMonthlyProductCheck(FlatBufferBuilder builder, bool useMonthlyProductCheck) { builder.AddBool(7, useMonthlyProductCheck, false); }
-  public static void AddParcelType_(FlatBufferBuilder builder, VectorOffset parcelType_Offset) { builder.AddOffset(8, parcelType_Offset.Value, 0); }
+  public static void AddPurchaseCountLimit(FlatBufferBuilder builder, long purchaseCountLimit) { builder.AddLong(8, purchaseCountLimit, 0); }
+  public static void AddParcelType_(FlatBufferBuilder builder, VectorOffset parcelType_Offset) { builder.AddOffset(9, parcelType_Offset.Value, 0); }
   public static VectorOffset CreateParcelType_Vector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
   public static VectorOffset CreateParcelType_VectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateParcelType_VectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateParcelType_VectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartParcelType_Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
-  public static void AddParcelId(FlatBufferBuilder builder, VectorOffset parcelIdOffset) { builder.AddOffset(9, parcelIdOffset.Value, 0); }
+  public static void AddParcelId(FlatBufferBuilder builder, VectorOffset parcelIdOffset) { builder.AddOffset(10, parcelIdOffset.Value, 0); }
   public static VectorOffset CreateParcelIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateParcelIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateParcelIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateParcelIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartParcelIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
-  public static void AddParcelAmount(FlatBufferBuilder builder, VectorOffset parcelAmountOffset) { builder.AddOffset(10, parcelAmountOffset.Value, 0); }
+  public static void AddParcelAmount(FlatBufferBuilder builder, VectorOffset parcelAmountOffset) { builder.AddOffset(11, parcelAmountOffset.Value, 0); }
   public static VectorOffset CreateParcelAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateParcelAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateParcelAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateParcelAmountVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartParcelAmountVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
-  public static void AddEnterCostReduceGroupId(FlatBufferBuilder builder, long enterCostReduceGroupId) { builder.AddLong(11, enterCostReduceGroupId, 0); }
+  public static void AddEnterCostReduceGroupId(FlatBufferBuilder builder, long enterCostReduceGroupId) { builder.AddLong(12, enterCostReduceGroupId, 0); }
-  public static void AddDailyParcelType(FlatBufferBuilder builder, VectorOffset dailyParcelTypeOffset) { builder.AddOffset(12, dailyParcelTypeOffset.Value, 0); }
+  public static void AddDailyParcelType(FlatBufferBuilder builder, VectorOffset dailyParcelTypeOffset) { builder.AddOffset(13, dailyParcelTypeOffset.Value, 0); }
   public static VectorOffset CreateDailyParcelTypeVector(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddInt((int)data[i]); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelTypeVectorBlock(FlatBufferBuilder builder, SCHALE.Common.FlatData.ParcelType[] data) { builder.StartVector(4, data.Length, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelTypeVectorBlock(FlatBufferBuilder builder, ArraySegment<SCHALE.Common.FlatData.ParcelType> data) { builder.StartVector(4, data.Count, 4); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelTypeVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<SCHALE.Common.FlatData.ParcelType>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartDailyParcelTypeVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(4, numElems, 4); }
-  public static void AddDailyParcelId(FlatBufferBuilder builder, VectorOffset dailyParcelIdOffset) { builder.AddOffset(13, dailyParcelIdOffset.Value, 0); }
+  public static void AddDailyParcelId(FlatBufferBuilder builder, VectorOffset dailyParcelIdOffset) { builder.AddOffset(14, dailyParcelIdOffset.Value, 0); }
   public static VectorOffset CreateDailyParcelIdVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelIdVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelIdVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelIdVectorBlock(FlatBufferBuilder builder, IntPtr dataPtr, int sizeInBytes) { builder.StartVector(1, sizeInBytes, 1); builder.Add<long>(dataPtr, sizeInBytes); return builder.EndVector(); }
   public static void StartDailyParcelIdVector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); }
-  public static void AddDailyParcelAmount(FlatBufferBuilder builder, VectorOffset dailyParcelAmountOffset) { builder.AddOffset(14, dailyParcelAmountOffset.Value, 0); }
+  public static void AddDailyParcelAmount(FlatBufferBuilder builder, VectorOffset dailyParcelAmountOffset) { builder.AddOffset(15, dailyParcelAmountOffset.Value, 0); }
   public static VectorOffset CreateDailyParcelAmountVector(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddLong(data[i]); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelAmountVectorBlock(FlatBufferBuilder builder, long[] data) { builder.StartVector(8, data.Length, 8); builder.Add(data); return builder.EndVector(); }
   public static VectorOffset CreateDailyParcelAmountVectorBlock(FlatBufferBuilder builder, ArraySegment<long> data) { builder.StartVector(8, data.Count, 8); builder.Add(data); return builder.EndVector(); }
@@ -190,6 +194,7 @@ public struct ProductMonthlyExcel : IFlatbufferObject
     _o.ProductTagType = TableEncryptionService.Convert(this.ProductTagType, key);
     _o.MonthlyDays = TableEncryptionService.Convert(this.MonthlyDays, key);
     _o.UseMonthlyProductCheck = TableEncryptionService.Convert(this.UseMonthlyProductCheck, key);
+    _o.PurchaseCountLimit = TableEncryptionService.Convert(this.PurchaseCountLimit, key);
     _o.ParcelType_ = new List<SCHALE.Common.FlatData.ParcelType>();
     for (var _j = 0; _j < this.ParcelType_Length; ++_j) {_o.ParcelType_.Add(TableEncryptionService.Convert(this.ParcelType_(_j), key));}
     _o.ParcelId = new List<long>();
@@ -248,6 +253,7 @@ public struct ProductMonthlyExcel : IFlatbufferObject
       _o.ProductTagType,
       _o.MonthlyDays,
       _o.UseMonthlyProductCheck,
+      _o.PurchaseCountLimit,
       _ParcelType_,
       _ParcelId,
       _ParcelAmount,
@@ -268,6 +274,7 @@ public class ProductMonthlyExcelT
   public SCHALE.Common.FlatData.ProductTagType ProductTagType { get; set; }
   public long MonthlyDays { get; set; }
   public bool UseMonthlyProductCheck { get; set; }
+  public long PurchaseCountLimit { get; set; }
   public List<SCHALE.Common.FlatData.ParcelType> ParcelType_ { get; set; }
   public List<long> ParcelId { get; set; }
   public List<long> ParcelAmount { get; set; }
@@ -285,6 +292,7 @@ public class ProductMonthlyExcelT
     this.ProductTagType = SCHALE.Common.FlatData.ProductTagType.Monthly;
     this.MonthlyDays = 0;
     this.UseMonthlyProductCheck = false;
+    this.PurchaseCountLimit = 0;
     this.ParcelType_ = null;
     this.ParcelId = null;
     this.ParcelAmount = null;
@@ -309,13 +317,14 @@ static public class ProductMonthlyExcelVerify
       && verifier.VerifyField(tablePos, 14 /*ProductTagType*/, 4 /*SCHALE.Common.FlatData.ProductTagType*/, 4, false)
       && verifier.VerifyField(tablePos, 16 /*MonthlyDays*/, 8 /*long*/, 8, false)
       && verifier.VerifyField(tablePos, 18 /*UseMonthlyProductCheck*/, 1 /*bool*/, 1, false)
-      && verifier.VerifyVectorOfData(tablePos, 20 /*ParcelType_*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyField(tablePos, 20 /*PurchaseCountLimit*/, 8 /*long*/, 8, false)
-      && verifier.VerifyVectorOfData(tablePos, 22 /*ParcelId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 22 /*ParcelType_*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 24 /*ParcelAmount*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 24 /*ParcelId*/, 8 /*long*/, false)
-      && verifier.VerifyField(tablePos, 26 /*EnterCostReduceGroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyVectorOfData(tablePos, 26 /*ParcelAmount*/, 8 /*long*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 28 /*DailyParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
+      && verifier.VerifyField(tablePos, 28 /*EnterCostReduceGroupId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyVectorOfData(tablePos, 30 /*DailyParcelId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 30 /*DailyParcelType*/, 4 /*SCHALE.Common.FlatData.ParcelType*/, false)
-      && verifier.VerifyVectorOfData(tablePos, 32 /*DailyParcelAmount*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 32 /*DailyParcelId*/, 8 /*long*/, false)
+      && verifier.VerifyVectorOfData(tablePos, 34 /*DailyParcelAmount*/, 8 /*long*/, false)
       && verifier.VerifyTableEnd(tablePos);
   }
 }

SCHALE.Common/FlatData/StageFileRefreshSettingExcel.cs

@@ -1,84 +0,0 @@
-// <auto-generated>
-//  automatically generated by the FlatBuffers compiler, do not modify
-// </auto-generated>
-
-namespace SCHALE.Common.FlatData
-{
-
-using global::System;
-using global::System.Collections.Generic;
-using global::SCHALE.Common.Crypto;
-using global::Google.FlatBuffers;
-
-public struct StageFileRefreshSettingExcel : IFlatbufferObject
-{
-  private Table __p;
-  public ByteBuffer ByteBuffer { get { return __p.bb; } }
-  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
-  public static StageFileRefreshSettingExcel GetRootAsStageFileRefreshSettingExcel(ByteBuffer _bb) { return GetRootAsStageFileRefreshSettingExcel(_bb, new StageFileRefreshSettingExcel()); }
-  public static StageFileRefreshSettingExcel GetRootAsStageFileRefreshSettingExcel(ByteBuffer _bb, StageFileRefreshSettingExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
-  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
-  public StageFileRefreshSettingExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
-
-  public long GroundId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
-  public bool ForceSave { get { int o = __p.__offset(6); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
-
-  public static Offset<SCHALE.Common.FlatData.StageFileRefreshSettingExcel> CreateStageFileRefreshSettingExcel(FlatBufferBuilder builder,
-      long GroundId = 0,
-      bool ForceSave = false) {
-    builder.StartTable(2);
-    StageFileRefreshSettingExcel.AddGroundId(builder, GroundId);
-    StageFileRefreshSettingExcel.AddForceSave(builder, ForceSave);
-    return StageFileRefreshSettingExcel.EndStageFileRefreshSettingExcel(builder);
-  }
-
-  public static void StartStageFileRefreshSettingExcel(FlatBufferBuilder builder) { builder.StartTable(2); }
-  public static void AddGroundId(FlatBufferBuilder builder, long groundId) { builder.AddLong(0, groundId, 0); }
-  public static void AddForceSave(FlatBufferBuilder builder, bool forceSave) { builder.AddBool(1, forceSave, false); }
-  public static Offset<SCHALE.Common.FlatData.StageFileRefreshSettingExcel> EndStageFileRefreshSettingExcel(FlatBufferBuilder builder) {
-    int o = builder.EndTable();
-    return new Offset<SCHALE.Common.FlatData.StageFileRefreshSettingExcel>(o);
-  }
-  public StageFileRefreshSettingExcelT UnPack() {
-    var _o = new StageFileRefreshSettingExcelT();
-    this.UnPackTo(_o);
-    return _o;
-  }
-  public void UnPackTo(StageFileRefreshSettingExcelT _o) {
-		byte[] key = TableEncryptionService.CreateKey("StageFileRefreshSetting");
-    _o.GroundId = TableEncryptionService.Convert(this.GroundId, key);
-    _o.ForceSave = TableEncryptionService.Convert(this.ForceSave, key);
-  }
-  public static Offset<SCHALE.Common.FlatData.StageFileRefreshSettingExcel> Pack(FlatBufferBuilder builder, StageFileRefreshSettingExcelT _o) {
-    if (_o == null) return default(Offset<SCHALE.Common.FlatData.StageFileRefreshSettingExcel>);
-    return CreateStageFileRefreshSettingExcel(
-      builder,
-      _o.GroundId,
-      _o.ForceSave);
-  }
-}
-
-public class StageFileRefreshSettingExcelT
-{
-  public long GroundId { get; set; }
-  public bool ForceSave { get; set; }
-
-  public StageFileRefreshSettingExcelT() {
-    this.GroundId = 0;
-    this.ForceSave = false;
-  }
-}
-
-
-static public class StageFileRefreshSettingExcelVerify
-{
-  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
-  {
-    return verifier.VerifyTableStart(tablePos)
-      && verifier.VerifyField(tablePos, 4 /*GroundId*/, 8 /*long*/, 8, false)
-      && verifier.VerifyField(tablePos, 6 /*ForceSave*/, 1 /*bool*/, 1, false)
-      && verifier.VerifyTableEnd(tablePos);
-  }
-}
-
-}

SCHALE.Common/FlatData/UnderCoverItemCategory.cs

@@ -0,0 +1,17 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+public enum UnderCoverItemCategory : int
+{
+  Consumable = 0,
+  Interaction = 1,
+  Skill = 2,
+  Collection = 3,
+};
+
+
+}

SCHALE.Common/FlatData/UnderCoverStageExcel.cs

@@ -0,0 +1,145 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace SCHALE.Common.FlatData
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::SCHALE.Common.Crypto;
+using global::Google.FlatBuffers;
+
+public struct UnderCoverStageExcel : IFlatbufferObject
+{
+  private Table __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
+  public static UnderCoverStageExcel GetRootAsUnderCoverStageExcel(ByteBuffer _bb) { return GetRootAsUnderCoverStageExcel(_bb, new UnderCoverStageExcel()); }
+  public static UnderCoverStageExcel GetRootAsUnderCoverStageExcel(ByteBuffer _bb, UnderCoverStageExcel obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
+  public UnderCoverStageExcel __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long GroupId { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
+  public string StageNameFile { get { int o = __p.__offset(6); return o != 0 ? __p.__string(o + __p.bb_pos) : null; } }
+#if ENABLE_SPAN_T
+  public Span<byte> GetStageNameFileBytes() { return __p.__vector_as_span<byte>(6, 1); }
+#else
+  public ArraySegment<byte>? GetStageNameFileBytes() { return __p.__vector_as_arraysegment(6); }
+#endif
+  public byte[] GetStageNameFileArray() { return __p.__vector_as_array<byte>(6); }
+  public int StageTryCount { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public bool ApplySkip { get { int o = __p.__offset(10); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public int SkipCount { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
+  public bool ShowClearScene { get { int o = __p.__offset(14); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
+  public uint StageTips { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+  public uint StageName { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
+
+  public static Offset<SCHALE.Common.FlatData.UnderCoverStageExcel> CreateUnderCoverStageExcel(FlatBufferBuilder builder,
+      long GroupId = 0,
+      StringOffset StageNameFileOffset = default(StringOffset),
+      int StageTryCount = 0,
+      bool ApplySkip = false,
+      int SkipCount = 0,
+      bool ShowClearScene = false,
+      uint StageTips = 0,
+      uint StageName = 0) {
+    builder.StartTable(8);
+    UnderCoverStageExcel.AddGroupId(builder, GroupId);
+    UnderCoverStageExcel.AddStageName(builder, StageName);
+    UnderCoverStageExcel.AddStageTips(builder, StageTips);
+    UnderCoverStageExcel.AddSkipCount(builder, SkipCount);
+    UnderCoverStageExcel.AddStageTryCount(builder, StageTryCount);
+    UnderCoverStageExcel.AddStageNameFile(builder, StageNameFileOffset);
+    UnderCoverStageExcel.AddShowClearScene(builder, ShowClearScene);
+    UnderCoverStageExcel.AddApplySkip(builder, ApplySkip);
+    return UnderCoverStageExcel.EndUnderCoverStageExcel(builder);
+  }
+
+  public static void StartUnderCoverStageExcel(FlatBufferBuilder builder) { builder.StartTable(8); }
+  public static void AddGroupId(FlatBufferBuilder builder, long groupId) { builder.AddLong(0, groupId, 0); }
+  public static void AddStageNameFile(FlatBufferBuilder builder, StringOffset stageNameFileOffset) { builder.AddOffset(1, stageNameFileOffset.Value, 0); }
+  public static void AddStageTryCount(FlatBufferBuilder builder, int stageTryCount) { builder.AddInt(2, stageTryCount, 0); }
+  public static void AddApplySkip(FlatBufferBuilder builder, bool applySkip) { builder.AddBool(3, applySkip, false); }
+  public static void AddSkipCount(FlatBufferBuilder builder, int skipCount) { builder.AddInt(4, skipCount, 0); }
+  public static void AddShowClearScene(FlatBufferBuilder builder, bool showClearScene) { builder.AddBool(5, showClearScene, false); }
+  public static void AddStageTips(FlatBufferBuilder builder, uint stageTips) { builder.AddUint(6, stageTips, 0); }
+  public static void AddStageName(FlatBufferBuilder builder, uint stageName) { builder.AddUint(7, stageName, 0); }
+  public static Offset<SCHALE.Common.FlatData.UnderCoverStageExcel> EndUnderCoverStageExcel(FlatBufferBuilder builder) {
+    int o = builder.EndTable();
+    return new Offset<SCHALE.Common.FlatData.UnderCoverStageExcel>(o);
+  }
+  public UnderCoverStageExcelT UnPack() {
+    var _o = new UnderCoverStageExcelT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(UnderCoverStageExcelT _o) {
+		byte[] key = TableEncryptionService.CreateKey("UnderCoverStage");
+    _o.GroupId = TableEncryptionService.Convert(this.GroupId, key);
+    _o.StageNameFile = TableEncryptionService.Convert(this.StageNameFile, key);
+    _o.StageTryCount = TableEncryptionService.Convert(this.StageTryCount, key);
+    _o.ApplySkip = TableEncryptionService.Convert(this.ApplySkip, key);
+    _o.SkipCount = TableEncryptionService.Convert(this.SkipCount, key);
+    _o.ShowClearScene = TableEncryptionService.Convert(this.ShowClearScene, key);
+    _o.StageTips = TableEncryptionService.Convert(this.StageTips, key);
+    _o.StageName = TableEncryptionService.Convert(this.StageName, key);
+  }
+  public static Offset<SCHALE.Common.FlatData.UnderCoverStageExcel> Pack(FlatBufferBuilder builder, UnderCoverStageExcelT _o) {
+    if (_o == null) return default(Offset<SCHALE.Common.FlatData.UnderCoverStageExcel>);
+    var _StageNameFile = _o.StageNameFile == null ? default(StringOffset) : builder.CreateString(_o.StageNameFile);
+    return CreateUnderCoverStageExcel(
+      builder,
+      _o.GroupId,
+      _StageNameFile,
+      _o.StageTryCount,
+      _o.ApplySkip,
+      _o.SkipCount,
+      _o.ShowClearScene,
+      _o.StageTips,
+      _o.StageName);
+  }
+}
+
+public class UnderCoverStageExcelT
+{
+  public long GroupId { get; set; }
+  public string StageNameFile { get; set; }
+  public int StageTryCount { get; set; }
+  public bool ApplySkip { get; set; }
+  public int SkipCount { get; set; }
+  public bool ShowClearScene { get; set; }
+  public uint StageTips { get; set; }
+  public uint StageName { get; set; }
+
+  public UnderCoverStageExcelT() {
+    this.GroupId = 0;
+    this.StageNameFile = null;
+    this.StageTryCount = 0;
+    this.ApplySkip = false;
+    this.SkipCount = 0;
+    this.ShowClearScene = false;
+    this.StageTips = 0;
+    this.StageName = 0;
+  }
+}
+
+
+static public class UnderCoverStageExcelVerify
+{
+  static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
+  {
+    return verifier.VerifyTableStart(tablePos)
+      && verifier.VerifyField(tablePos, 4 /*GroupId*/, 8 /*long*/, 8, false)
+      && verifier.VerifyString(tablePos, 6 /*StageNameFile*/, false)
+      && verifier.VerifyField(tablePos, 8 /*StageTryCount*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 10 /*ApplySkip*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 12 /*SkipCount*/, 4 /*int*/, 4, false)
+      && verifier.VerifyField(tablePos, 14 /*ShowClearScene*/, 1 /*bool*/, 1, false)
+      && verifier.VerifyField(tablePos, 16 /*StageTips*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyField(tablePos, 18 /*StageName*/, 4 /*uint*/, 4, false)
+      && verifier.VerifyTableEnd(tablePos);
+  }
+}
+
+}

SCHALE.Common/NetworkProtocol/protos.cs

@@ -109,7 +109,7 @@ namespace SCHALE.Common.NetworkProtocol
 		public int DeviceSystemMemorySize { get; set; }
 	}
 
-    public class AccountAuthResponse : ResponsePacket
+	public class AccountAuthResponse : ResponsePacket
 	{
 		public override Protocol Protocol
 		{
@@ -141,7 +141,7 @@ namespace SCHALE.Common.NetworkProtocol
 		public IEnumerable<IssueAlertInfoDB> IssueAlertInfos { get; set; }
 	}
 
-    public class AccountAuth2Request : AccountAuthRequest
+	public class AccountAuth2Request : AccountAuthRequest
 	{
 		public override Protocol Protocol
 		{
@@ -2270,6 +2270,7 @@ namespace SCHALE.Common.NetworkProtocol
 		}
 
 		public Nullable<long> TargetAccountId { get; set; }
+		public Nullable<long> CurrentVisitingAccountId { get; set; }
 	}
 
 	public class CafeTravelResponse : ResponsePacket
@@ -3139,9 +3140,7 @@ namespace SCHALE.Common.NetworkProtocol
 
 		public long TargetCharacterDBId { get; set; }
 
-        [JsonConverter(typeof(JsonStringEnumConverter))]
         public SkillSlot SkillSlot { get; set; }
-
 		public int Level { get; set; }
 		public List<SelectTicketReplaceInfo> ReplaceInfos { get; set; }
 	}
@@ -5849,8 +5848,8 @@ namespace SCHALE.Common.NetworkProtocol
 	public class EquipmentItemEquipResponse : ResponsePacket
 	{
 		public CharacterDB CharacterDB { get; set; }
-		public List<EquipmentDB> EquipmentDBs { get; set; }
+        public List<EquipmentDB> EquipmentDBs { get; set; }
-		public override Protocol Protocol
+        public override Protocol Protocol
 		{
 			get
 			{
@@ -9514,7 +9513,7 @@ namespace SCHALE.Common.NetworkProtocol
 	public class ProofTokenRequestQuestionResponse : ResponsePacket
 	{
 		public long Hint { get; set; }
-		public string Question { get; set; }
+        public string Question { get; set; }
         public override Protocol Protocol
 		{
 			get
@@ -9892,7 +9891,7 @@ namespace SCHALE.Common.NetworkProtocol
 		public IEnumerable<RaidDamage> RaidBossDamages { get; }
 	
 		[JsonIgnore]
-		public RaidBossResultCollection RaidBossResults { get; }
+		public List<RaidBossResult> RaidBossResults { get; }
 		public BattleSummary Summary { get; set; }
 		public ClanAssistUseInfo AssistUseInfo { get; set; }
 	}
@@ -11934,6 +11933,8 @@ namespace SCHALE.Common.NetworkProtocol
 		CafeAlreadyOpened = 15019,
 		CafeNoPlaceToTravel = 15020,
 		CafeCannotTravelToOwnCafe = 15021,
+		CafeCannotTravel = 15022,
+		CafeCannotTravel_CafeLock = 15023,
 		ScenarioMode_Fail = 16000,
 		ScenarioMode_DuplicatedScenarioModeId = 16001,
 		ScenarioMode_LimitClearedScenario = 16002,

SCHALE.GameServer/Controllers/Api/ProtocolHandlers/Shop.cs

@@ -139,125 +139,139 @@ namespace SCHALE.GameServer.Controllers.Api.ProtocolHandlers
             //    });
             //}
 
+            List<long> rateUps = [10110, 10111, 10112, 20041];
+            Random random = new Random();
+
             for (int i = 0; i < 10; ++i)
             {
-                var randomNumber = Random.Shared.NextInt64(1000);
+                long gotId = rateUps[random.Next(rateUps.Count)];
-                if (randomNumber < 7)
+                gachaList.Add(new()
                 {
-                    // always 3 star
+                    CharacterId = gotId,
-                    shouldDoGuaranteedSR = false;
+                    Character = new()
-                    var isNew = accountChSet.Add(rateUpChId);
-                    gachaList.Add(new()
                     {
-                        CharacterId = rateUpChId,
+                        AccountServerId = account.ServerId,
-                        Character = !isNew ? null : new()
+                        UniqueId = gotId,
-                        {
+                        StarGrade = 3,
-                            AccountServerId = account.ServerId,
+                    },
-                            UniqueId = rateUpChId,
+                });
-                            StarGrade = 3,
+                //var randomNumber = Random.Shared.NextInt64(1000);
-                        },
+                //if (randomNumber < 7)
-                        Stone = isNew ? null : new()
+                //{
-                        {
+                //    // always 3 star
-                            UniqueId = chUniStoneID,
+                //    shouldDoGuaranteedSR = false;
-                            StackCount = 50,
+                //    var isNew = accountChSet.Add(rateUpChId);
-                        }
+                //    gachaList.Add(new()
-                    });
+                //    {
-                    if (!isNew)
+                //        CharacterId = rateUpChId,
-                    {
+                //        Character = !isNew ? null : new()
-                        itemDict[chUniStoneID] += 50;
+                //        {
-                        itemDict[rateUpChId] += 100;
+                //            AccountServerId = account.ServerId,
-                    }
+                //            UniqueId = rateUpChId,
-                }
+                //            StarGrade = 3,
-                else if (randomNumber < 30)
+                //        },
-                {
+                //        Stone = isNew ? null : new()
-                    shouldDoGuaranteedSR = false;
+                //        {
-                    var normalSSRList = _sharedData.CharaListSSRNormal;
+                //            UniqueId = chUniStoneID,
-                    var poolSize = normalSSRList.Count;
+                //            StackCount = 50,
-                    if (rateUpIsNormalStudent) poolSize--;
+                //        }
+                //    });
+                //    if (!isNew)
+                //    {
+                //        itemDict[chUniStoneID] += 50;
+                //        itemDict[rateUpChId] += 100;
+                //    }
+                //}
+                //else if (randomNumber < 30)
+                //{
+                //    shouldDoGuaranteedSR = false;
+                //    var normalSSRList = _sharedData.CharaListSSRNormal;
+                //    var poolSize = normalSSRList.Count;
+                //    if (rateUpIsNormalStudent) poolSize--;
 
-                    var randomPoolIdx = (int)Random.Shared.NextInt64(poolSize);
+                //    var randomPoolIdx = (int)Random.Shared.NextInt64(poolSize);
-                    if (normalSSRList[randomPoolIdx].Id == rateUpChId) randomPoolIdx++;
+                //    if (normalSSRList[randomPoolIdx].Id == rateUpChId) randomPoolIdx++;
 
-                    var chId = normalSSRList[randomPoolIdx].Id;
+                //    var chId = normalSSRList[randomPoolIdx].Id;
-                    var isNew = accountChSet.Add(chId);
+                //    var isNew = accountChSet.Add(chId);
-                    gachaList.Add(new()
+                //    gachaList.Add(new()
-                    {
+                //    {
-                        CharacterId = chId,
+                //        CharacterId = chId,
-                        Character = !isNew ? null : new()
+                //        Character = !isNew ? null : new()
-                        {
+                //        {
-                            AccountServerId = account.ServerId,
+                //            AccountServerId = account.ServerId,
-                            UniqueId = chId,
+                //            UniqueId = chId,
-                            StarGrade = 3,
+                //            StarGrade = 3,
-                        },
+                //        },
-                        Stone = isNew ? null : new()
+                //        Stone = isNew ? null : new()
-                        {
+                //        {
-                            UniqueId = chUniStoneID,
+                //            UniqueId = chUniStoneID,
-                            StackCount = 50,
+                //            StackCount = 50,
-                        }
+                //        }
-                    });
+                //    });
-                    if (!isNew)
+                //    if (!isNew)
-                    {
+                //    {
-                        itemDict[chUniStoneID] += 50;
+                //        itemDict[chUniStoneID] += 50;
-                        itemDict[chId] += 30;
+                //        itemDict[chId] += 30;
-                    }
+                //    }
-                }
+                //}
-                else if (randomNumber < 215 || (i == 9 && shouldDoGuaranteedSR))
+                //else if (randomNumber < 215 || (i == 9 && shouldDoGuaranteedSR))
-                {
+                //{
-                    shouldDoGuaranteedSR = false;
+                //    shouldDoGuaranteedSR = false;
-                    var normalSRList = _sharedData.CharaListSRNormal;
+                //    var normalSRList = _sharedData.CharaListSRNormal;
-                    var randomPoolIdx = (int)Random.Shared.NextInt64(normalSRList.Count);
+                //    var randomPoolIdx = (int)Random.Shared.NextInt64(normalSRList.Count);
-                    var chId = normalSRList[randomPoolIdx].Id;
+                //    var chId = normalSRList[randomPoolIdx].Id;
-                    var isNew = accountChSet.Add(chId);
+                //    var isNew = accountChSet.Add(chId);
 
-                    gachaList.Add(new()
+                //    gachaList.Add(new()
-                    {
+                //    {
-                        CharacterId = chId,
+                //        CharacterId = chId,
-                        Character = !isNew ? null : new()
+                //        Character = !isNew ? null : new()
-                        {
+                //        {
-                            AccountServerId = account.ServerId,
+                //            AccountServerId = account.ServerId,
-                            UniqueId = chId,
+                //            UniqueId = chId,
-                            StarGrade = 2,
+                //            StarGrade = 2,
-                        },
+                //        },
-                        Stone = isNew ? null : new()
+                //        Stone = isNew ? null : new()
-                        {
+                //        {
-                            UniqueId = chUniStoneID,
+                //            UniqueId = chUniStoneID,
-                            StackCount = 10,
+                //            StackCount = 10,
-                        }
+                //        }
-                    });
+                //    });
-                    if (!isNew)
+                //    if (!isNew)
-                    {
+                //    {
-                        itemDict[chUniStoneID] += 10;
+                //        itemDict[chUniStoneID] += 10;
-                        itemDict[chId] += 5;
+                //        itemDict[chId] += 5;
-                    }
+                //    }
-                }
+                //}
-                else
+                //else
-                {
+                //{
-                    var normalRList = _sharedData.CharaListRNormal;
+                //    var normalRList = _sharedData.CharaListRNormal;
-                    var randomPoolIdx = (int)Random.Shared.NextInt64(normalRList.Count);
+                //    var randomPoolIdx = (int)Random.Shared.NextInt64(normalRList.Count);
-                    var chId = normalRList[randomPoolIdx].Id;
+                //    var chId = normalRList[randomPoolIdx].Id;
-                    var isNew = accountChSet.Add(chId);
+                //    var isNew = accountChSet.Add(chId);
 
-                    gachaList.Add(new()
+                //    gachaList.Add(new()
-                    {
+                //    {
-                        CharacterId = chId,
+                //        CharacterId = chId,
-                        Character = !isNew ? null : new()
+                //        Character = !isNew ? null : new()
-                        {
+                //        {
-                            AccountServerId = account.ServerId,
+                //            AccountServerId = account.ServerId,
-                            UniqueId = chId,
+                //            UniqueId = chId,
-                            StarGrade = 1,
+                //            StarGrade = 1,
-                        },
+                //        },
-                        Stone = isNew ? null : new()
+                //        Stone = isNew ? null : new()
-                        {
+                //        {
-                            UniqueId = chUniStoneID,
+                //            UniqueId = chUniStoneID,
-                            StackCount = 1,
+                //            StackCount = 1,
-                        }
+                //        }
-                    });
+                //    });
-                    if (!isNew)
+                //    if (!isNew)
-                    {
+                //    {
-                        itemDict[chUniStoneID] += 1;
+                //        itemDict[chUniStoneID] += 1;
-                        itemDict[chId] += 1;
+                //        itemDict[chId] += 1;
-                    }
+                //    }
-                }
+                //}
             }
 
             account.AddCharacters(_context, [.. gachaList.Where(x => x.Character != null).Select(x => x.Character)]);

SCHALE.GameServer/GameServer.cs

@@ -2,10 +2,12 @@ using System.Collections;
 using System.Net.NetworkInformation;
 using System.Reflection;
 using System.Text;
+using Google.FlatBuffers;
 using Microsoft.AspNetCore.Server.Kestrel.Core;
 using Microsoft.EntityFrameworkCore;
 using SCHALE.Common.Crypto;
 using SCHALE.Common.Database;
+using SCHALE.Common.FlatData;
 using SCHALE.GameServer.Commands;
 using SCHALE.GameServer.Controllers;
 using SCHALE.GameServer.Controllers.Api.ProtocolHandlers;
@@ -21,6 +23,10 @@ namespace SCHALE.GameServer
     {
         public static async Task Main(string[] args)
         {
+            //TableService.DumpExcels("E:\\documents\\Decompiling\\Extracted\\BlueArchiveJP\\SCHALE.GameServer.Custom\\SCHALE.GameServer\\SCHALE.GameServer\\bin\\Debug\\net8.0\\Resources\\excel", "E:\\documents\\Decompiling\\Extracted\\BlueArchiveJP\\SCHALE.GameServer.Custom\\SCHALE.GameServer\\SCHALE.GameServer\\bin\\Debug\\net8.0\\Resources\\dump");
+            //TableService.DumpExcelDB("E:\\documents\\Decompiling\\Extracted\\BlueArchiveJP\\SCHALE.GameServer.Custom\\SCHALE.GameServer\\SCHALE.GameServer\\bin\\Debug\\net8.0\\Resources\\ExcelDB.db", "E:\\documents\\Decompiling\\Extracted\\BlueArchiveJP\\SCHALE.GameServer.Custom\\SCHALE.GameServer\\SCHALE.GameServer\\bin\\Debug\\net8.0\\Resources\\dump_db");
+            //return;
+
             var config = new ConfigurationBuilder()
                 .SetBasePath(Path.GetDirectoryName(AppContext.BaseDirectory)!)
                 .AddJsonFile("appsettings.json")

SCHALE.GameServer/Managers/RaidManager.cs

@@ -28,7 +28,7 @@ namespace SCHALE.GameServer.Managers
                     ReceiveRewardIds = targetSeasonData.SeasonRewardId,
                     PlayableHighestDifficulty = new()
                     {
-                        { targetSeasonData.OpenRaidBossGroup.FirstOrDefault(), Difficulty.Torment }
+                        { targetSeasonData.OpenRaidBossGroup.FirstOrDefault(), Difficulty.Lunatic }
                     }
                 };
             } 

SCHALE.GameServer/Utils/Config.cs

@@ -14,7 +14,7 @@ namespace SCHALE.GameServer.Utils
         public string IRCAddress { get; set; } = "127.0.0.1";
         public int IRCPort { get; set; } = 6667;
 
-        public string VersionId { get; set; } = "r75_49ajrpwcziy395uuk0jq_2";
+        public string VersionId { get; set; } = "r76_odfuvebzfonktr6yf71a";
 
         public static void Load()
         {

SCHALE.GameServer/Utils/InventoryUtils.cs

@@ -21,7 +21,7 @@ namespace SCHALE.Common.Utils
             var characterLevelExcel = connection.ExcelTableService.GetTable<CharacterLevelExcelTable>().UnPack().DataList;
             //var favorLevelExcel = connection.ExcelTableService.GetTable<FavorLevelExcelTable>().UnPack().DataList;
             // was moved to db, fix later hardcode now
-
+            
             var allCharacters = characterExcel.Where(x =>
                 x is
                 {